Refactor evaluations (#285)

* Replace evaluations with proxies and messages

* Return proxies synchronously

Otherwise events can be lost.

* Ensure events cannot be missed

* Refactor remaining fills

* Use more up-to-date version of util

For callbackify.

* Wait for dispose to come back before removing

This prevents issues with the "done" event not always being the last
event fired. For example a socket might close and then end, but only
if the caller called end.

* Remove old node-pty tests

* Fix emitting events twice on duplex streams

* Preserve environment when spawning processes

* Throw a better error if the proxy doesn't exist

* Remove rimraf dependency from ide

* Update net.Server.listening

* Use exit event instead of killed

Doesn't look like killed is even a thing.

* Add response timeout to server

* Fix trash

* Require node-pty & spdlog after they get unpackaged

This fixes an error when running in the binary.

* Fix errors in down emitter preventing reconnecting

* Fix disposing proxies when nothing listens to "error" event

* Refactor event tests to use jest.fn()

* Reject proxy call when disconnected

Otherwise it'll wait for the timeout which is a waste of time since we
already know the connection is dead.

* Use nbin for binary packaging

* Remove additional module requires

* Attempt to remove require for local bootstrap-fork

* Externalize fsevents

packages/events/src/events.ts

@@ -1,28 +1,51 @@
 import { IDisposable } from "@coder/disposable";
 
 export interface Event<T> {
-	(listener: (e: T) => void): IDisposable;
+	(listener: (value: T) => void): IDisposable;
+	(id: number | string, listener: (value: T) => void): IDisposable;
 }
 
 /**
- * Emitter typecasts for a single event type.
+ * Emitter typecasts for a single event type. You can optionally use IDs, but
+ * using undefined with IDs will not work. If you emit without an ID, *all*
+ * listeners regardless of their ID (or lack thereof) will receive the event.
+ * Similarly, if you listen without an ID you will get *all* events for any or
+ * no ID.
  */
 export class Emitter<T> {
-	private listeners = <Array<(e: T) => void>>[];
+	private listeners = <Array<(value: T) => void>>[];
+	private readonly idListeners = new Map<number | string, Array<(value: T) => void>>();
 
 	public get event(): Event<T> {
-		return (cb: (e: T) => void): IDisposable => {
-			if (this.listeners) {
-				this.listeners.push(cb);
+		return (id: number | string | ((value: T) => void), cb?: (value: T) => void): IDisposable => {
+			if (typeof id !== "function") {
+				if (this.idListeners.has(id)) {
+					this.idListeners.get(id)!.push(cb!);
+				} else {
+					this.idListeners.set(id, [cb!]);
+				}
+
+				return {
+					dispose: (): void => {
+						if (this.idListeners.has(id)) {
+							const cbs = this.idListeners.get(id)!;
+							const i = cbs.indexOf(cb!);
+							if (i !== -1) {
+								cbs.splice(i, 1);
+							}
+						}
+					},
+				};
 			}
 
+			cb = id;
+			this.listeners.push(cb);
+
 			return {
 				dispose: (): void => {
-					if (this.listeners) {
-						const i = this.listeners.indexOf(cb);
-						if (i !== -1) {
-							this.listeners.splice(i, 1);
-						}
+					const i = this.listeners.indexOf(cb!);
+					if (i !== -1) {
+						this.listeners.splice(i, 1);
 					}
 				},
 			};
@@ -32,16 +55,45 @@ export class Emitter<T> {
 	/**
 	 * Emit an event with a value.
 	 */
-	public emit(value: T): void {
-		if (this.listeners) {
-			this.listeners.forEach((t) => t(value));
+	public emit(value: T): void;
+	public emit(id: number | string, value: T): void;
+	public emit(id: number | string | T, value?: T): void {
+		if ((typeof id === "number" || typeof id === "string") && typeof value !== "undefined") {
+			if (this.idListeners.has(id)) {
+				this.idListeners.get(id)!.forEach((cb) => cb(value!));
+			}
+			this.listeners.forEach((cb) => cb(value!));
+		} else {
+			this.idListeners.forEach((cbs) => cbs.forEach((cb) => cb((id as T)!)));
+			this.listeners.forEach((cb) => cb((id as T)!));
 		}
 	}
 
 	/**
 	 * Dispose the current events.
 	 */
-	public dispose(): void {
-		this.listeners = [];
+	public dispose(): void;
+	public dispose(id: number | string): void;
+	public dispose(id?: number | string): void {
+		if (typeof id !== "undefined") {
+			this.idListeners.delete(id);
+		} else {
+			this.listeners = [];
+			this.idListeners.clear();
+		}
+	}
+
+	public get counts(): { [key: string]: number } {
+		const counts = <{ [key: string]: number }>{};
+		if (this.listeners.length > 0) {
+			counts["n/a"] = this.listeners.length;
+		}
+		this.idListeners.forEach((cbs, id) => {
+			if (cbs.length > 0) {
+				counts[`${id}`] = cbs.length;
+			}
+		});
+
+		return counts;
 	}
 }

packages/events/test/events.test.ts

@@ -0,0 +1,122 @@
+import { Emitter } from "../src/events";
+
+describe("Event", () => {
+	const emitter = new Emitter<number>();
+
+	it("should listen to global event", () => {
+		const fn = jest.fn();
+		const d = emitter.event(fn);
+		emitter.emit(10);
+		expect(fn).toHaveBeenCalledWith(10);
+		d.dispose();
+	});
+
+	it("should listen to id event", () => {
+		const fn = jest.fn();
+		const d = emitter.event(0, fn);
+		emitter.emit(0, 5);
+		expect(fn).toHaveBeenCalledWith(5);
+		d.dispose();
+	});
+
+	it("should listen to string id event", () => {
+		const fn = jest.fn();
+		const d = emitter.event("string", fn);
+		emitter.emit("string", 55);
+		expect(fn).toHaveBeenCalledWith(55);
+		d.dispose();
+	});
+
+	it("should not listen wrong id event", () => {
+		const fn = jest.fn();
+		const d = emitter.event(1, fn);
+		emitter.emit(0, 5);
+		emitter.emit(1, 6);
+		expect(fn).toHaveBeenCalledWith(6);
+		expect(fn).toHaveBeenCalledTimes(1);
+		d.dispose();
+	});
+
+	it("should listen to id event globally", () => {
+		const fn = jest.fn();
+		const d = emitter.event(fn);
+		emitter.emit(1, 11);
+		expect(fn).toHaveBeenCalledWith(11);
+		d.dispose();
+	});
+
+	it("should listen to global event", () => {
+		const fn = jest.fn();
+		const d = emitter.event(3, fn);
+		emitter.emit(14);
+		expect(fn).toHaveBeenCalledWith(14);
+		d.dispose();
+	});
+
+	it("should listen to id event multiple times", () => {
+		const fn = jest.fn();
+		const disposers = [
+			emitter.event(934, fn),
+			emitter.event(934, fn),
+			emitter.event(934, fn),
+			emitter.event(934, fn),
+		];
+		emitter.emit(934, 324);
+		expect(fn).toHaveBeenCalledTimes(4);
+		expect(fn).toHaveBeenCalledWith(324);
+		disposers.forEach((d) => d.dispose());
+	});
+
+	it("should dispose individually", () => {
+		const fn = jest.fn();
+		const d = emitter.event(fn);
+
+		const fn2 = jest.fn();
+		const d2 = emitter.event(1, fn2);
+
+		d.dispose();
+
+		emitter.emit(12);
+		emitter.emit(1, 12);
+
+		expect(fn).not.toBeCalled();
+		expect(fn2).toBeCalledTimes(2);
+
+		d2.dispose();
+
+		emitter.emit(12);
+		emitter.emit(1, 12);
+
+		expect(fn).not.toBeCalled();
+		expect(fn2).toBeCalledTimes(2);
+	});
+
+	it("should dispose by id", () => {
+		const fn = jest.fn();
+		emitter.event(fn);
+
+		const fn2 = jest.fn();
+		emitter.event(1, fn2);
+
+		emitter.dispose(1);
+
+		emitter.emit(12);
+		emitter.emit(1, 12);
+
+		expect(fn).toBeCalledTimes(2);
+		expect(fn2).not.toBeCalled();
+	});
+
+	it("should dispose all", () => {
+		const fn = jest.fn();
+		emitter.event(fn);
+		emitter.event(1, fn);
+
+		emitter.dispose();
+
+		emitter.emit(12);
+		emitter.emit(1, 12);
+
+		expect(fn).not.toBeCalled();
+	});
+});