@irrelon/emitter 5.0.2 → 5.0.4

package/tests/Emitter.test.ts

@@ -1,5 +1,5 @@
 import assert from "assert";
-import {Emitter, EventListenerCallback, EventReturnFlag} from "../src/Emitter";
+import {ConvertInterfaceToDict, Emitter, EventListenerCallback, EventReturnFlag} from "../src/Emitter";
 
 let expectedAssertions = 0;
 let actualAssertions = 0;
@@ -21,9 +21,8 @@ function check () {
 	if (expectedAssertions === undefined || expectedAssertions === actualAssertions) {
 		return;
 	}
-	const err = new Error("expected " + expectedAssertions + " assertions, got " + actualAssertions);
-	// @ts-ignore
-	this.currentTest.emit("error", err);
+
+	throw new Error("expected " + expectedAssertions + " assertions, got " + actualAssertions);
 }
 
 beforeEach(reset);
@@ -37,7 +36,7 @@ describe("Emitter", () => {
 			myClass.on("moo", () => {
 			});
 
-			assert.strictEqual(myClass._eventListeners?.moo["*"].length, 1, "Listener registered on event");
+			assert.strictEqual(myClass._eventListeners?.moo!["*"].length, 1, "Listener registered on event");
 
 			myClass.off("moo");
 
@@ -104,7 +103,7 @@ describe("Emitter", () => {
 				emitCount++;
 			});
 
-			assert.strictEqual(myClass._eventListeners?.moo["testId"].length, 1, "Listener registered on event");
+			assert.strictEqual(myClass._eventListeners?.moo!["testId"].length, 1, "Listener registered on event");
 
 			myClass.emitId("moo", "testId", "foo");
 
@@ -123,6 +122,50 @@ describe("Emitter", () => {
 	});
 
 	describe("emit()", () => {
+		it("Supports type safe usage", async () => {
+			interface MyEventsResponses {
+				post: () => void;
+				person: (name: string, age: number, enabled: boolean) => void;
+				house: (no: number, street: string, postcode: string, enabled: boolean) => void;
+			}
+
+			const emitter = new Emitter<ConvertInterfaceToDict<MyEventsResponses>>();
+			let listenerFiredCount = 0;
+
+			emitter.on("person", async (name, age, enabled) => {
+				return new Promise<void>((resolve) => {
+					setTimeout(() => {
+						listenerFiredCount++;
+						resolve();
+					}, 1000);
+				});
+			});
+
+			emitter.on("post", async () => {
+				return new Promise<void>((resolve) => {
+					setTimeout(() => {
+						listenerFiredCount++;
+						resolve();
+					}, 1000);
+				});
+			});
+
+			emitter.on("post", async () => {
+				return new Promise<void>((resolve) => {
+					setTimeout(() => {
+						listenerFiredCount++;
+						resolve();
+					}, 1000);
+				});
+			});
+
+			const time = new Date().getTime();
+			await emitter.emit("post");
+			const delta = new Date().getTime() - time;
+
+			assert.ok(delta > 900, `Delta was not correct, await may not have paused? Delta was: ${delta}`);
+		});
+
 		it("Supports awaiting async listeners", async () => {
 			const emitter = new Emitter();
 			let listenerFiredCount = 0;
@@ -132,7 +175,7 @@ describe("Emitter", () => {
 					setTimeout(() => {
 						listenerFiredCount++;
 						resolve();
-					},1000);
+					}, 1000);
 				});
 			});
 
@@ -141,7 +184,7 @@ describe("Emitter", () => {
 					setTimeout(() => {
 						listenerFiredCount++;
 						resolve();
-					},1000);
+					}, 1000);
 				});
 			});
 
@@ -156,12 +199,16 @@ describe("Emitter", () => {
 	describe("off()", () => {
 		it("Cancels all listeners (event)", () => {
 			const myClass = new Emitter();
-			const listener1 = () => {};
-			const listener2 = () => {};
+			const listener1 = () => {
+			};
+			const listener2 = () => {
+			};
 
-			myClass.on("moo", () => {});
-			assert.strictEqual(myClass._eventListeners?.moo["*"].length, 1, "Listeners registered on event");
-			myClass.on("moo", "testId", () => {});
+			myClass.on("moo", () => {
+			});
+			assert.strictEqual(myClass._eventListeners?.moo!["*"].length, 1, "Listeners registered on event");
+			myClass.on("moo", "testId", () => {
+			});
 			assert.strictEqual(myClass._eventListeners?.moo["testId"].length, 1, "Listeners registered on event");
 			myClass.on("moo", listener1);
 			assert.strictEqual(myClass._eventListeners?.moo["*"].length, 2, "Listeners registered on event");
@@ -175,12 +222,16 @@ describe("Emitter", () => {
 
 		it("Cancels id-based listeners (event, id)", () => {
 			const myClass = new Emitter();
-			const listener1 = () => {};
-			const listener2 = () => {};
+			const listener1 = () => {
+			};
+			const listener2 = () => {
+			};
 
-			myClass.on("moo", () => {});
-			assert.strictEqual(myClass._eventListeners?.moo["*"].length, 1, "Listeners registered on event");
-			myClass.on("moo", "testId", () => {});
+			myClass.on("moo", () => {
+			});
+			assert.strictEqual(myClass._eventListeners?.moo!["*"].length, 1, "Listeners registered on event");
+			myClass.on("moo", "testId", () => {
+			});
 			assert.strictEqual(myClass._eventListeners?.moo["testId"].length, 1, "Listeners registered on event");
 			myClass.on("moo", listener1);
 			assert.strictEqual(myClass._eventListeners?.moo["*"].length, 2, "Listeners registered on event");
@@ -195,12 +246,16 @@ describe("Emitter", () => {
 
 		it("Cancels listener-based listeners (event, listener)", () => {
 			const myClass = new Emitter();
-			const listener1 = () => {};
-			const listener2 = () => {};
+			const listener1 = () => {
+			};
+			const listener2 = () => {
+			};
 
-			myClass.on("moo", () => {});
-			assert.strictEqual(myClass._eventListeners?.moo["*"].length, 1, "Listeners registered on event");
-			myClass.on("moo", "testId", () => {});
+			myClass.on("moo", () => {
+			});
+			assert.strictEqual(myClass._eventListeners?.moo!["*"].length, 1, "Listeners registered on event");
+			myClass.on("moo", "testId", () => {
+			});
 			assert.strictEqual(myClass._eventListeners?.moo["testId"].length, 1, "Listeners registered on event");
 			myClass.on("moo", listener1);
 			assert.strictEqual(myClass._eventListeners?.moo["*"].length, 2, "Listeners registered on event");
@@ -215,12 +270,16 @@ describe("Emitter", () => {
 
 		it("Cancels id-based + listener-based listeners (event, id, listener)", () => {
 			const myClass = new Emitter();
-			const listener1 = () => {};
-			const listener2 = () => {};
+			const listener1 = () => {
+			};
+			const listener2 = () => {
+			};
 
-			myClass.on("moo", () => {});
-			assert.strictEqual(myClass._eventListeners?.moo["*"].length, 1, "Listeners registered on event");
-			myClass.on("moo", "testId", () => {});
+			myClass.on("moo", () => {
+			});
+			assert.strictEqual(myClass._eventListeners?.moo!["*"].length, 1, "Listeners registered on event");
+			myClass.on("moo", "testId", () => {
+			});
 			assert.strictEqual(myClass._eventListeners?.moo["testId"].length, 1, "Listeners registered on event");
 			myClass.on("moo", listener1);
 			assert.strictEqual(myClass._eventListeners?.moo["*"].length, 2, "Listeners registered on event");
@@ -236,7 +295,8 @@ describe("Emitter", () => {
 
 	describe("emitStatic()", () => {
 		it("Static emitter will emit when a new listener is added", (resolve) => {
-			class MyClass extends Emitter {}
+			class MyClass extends Emitter {
+			}
 
 			expect(1);
 
@@ -252,7 +312,8 @@ describe("Emitter", () => {
 
 	describe("cancelStatic()", () => {
 		it("Removes static emitter", (resolve) => {
-			class MyClass extends Emitter {}
+			class MyClass extends Emitter {
+			}
 
 			expect(1);
 
@@ -277,7 +338,9 @@ describe("Emitter", () => {
 
 	describe("overwrite()", () => {
 		it("Only fires the last listener added, cancelling all other listeners before it", (resolve) => {
-			class MyClass extends Emitter {}
+			class MyClass extends Emitter {
+			}
+
 			expect(1);
 
 			const myClass = new MyClass();
@@ -299,6 +362,43 @@ describe("Emitter", () => {
 				resolve();
 			}, 10);
 		});
+
+		it("Only fires the last listener added (with id), cancelling all other listeners before it", (resolve) => {
+			class MyClass extends Emitter {
+			}
+
+			expect(2);
+
+			const myClass = new MyClass();
+
+			// Define a listener without an id, this should not be overwritten
+			myClass.on("moo", () => {
+				countAssertion();
+				assert.ok(true, "Correct callback was fired");
+			});
+
+			// Define some listeners WITH ids, these should be overwritten
+			myClass.on("moo", "1234", () => {
+				countAssertion();
+				assert.ok(false, "Correct callback was fired");
+			});
+			myClass.on("moo", "1234", () => {
+				countAssertion();
+				assert.ok(false, "Correct callback was fired");
+			});
+
+			// Overwrite the id listeners
+			myClass.overwrite("moo", "1234", () => {
+				countAssertion();
+				assert.ok(true, "Correct callback was fired");
+			});
+
+			myClass.emitId("moo", "1234");
+
+			setTimeout(() => {
+				resolve();
+			}, 50);
+		});
 	});
 
 	describe("emitId()", () => {
@@ -316,7 +416,7 @@ describe("Emitter", () => {
 				emitCount++;
 			});
 
-			assert.strictEqual(myClass._eventListeners?.moo["testId"].length, 1, "Listener registered on event");
+			assert.strictEqual(myClass._eventListeners?.moo!["testId"].length, 1, "Listener registered on event");
 
 			myClass.emitId("moo", "testId", "foo");
 

package/tsconfig-base.json

@@ -0,0 +1,36 @@
+{
+	"compilerOptions": {
+		"downlevelIteration": true,
+		"baseUrl": ".",
+		"target": "es6",
+		"lib": [
+			"esnext"
+		],
+		"allowJs": false,
+		"skipLibCheck": false,
+		"strict": true,
+		"pretty": true,
+		"allowSyntheticDefaultImports": true,
+		"forceConsistentCasingInFileNames": true,
+		"noEmit": false,
+		"incremental": true,
+		"esModuleInterop": true,
+		"module": "es2022",
+		"moduleResolution": "node",
+		"resolveJsonModule": true,
+		"isolatedModules": true,
+		"declaration": true,
+		"inlineSourceMap": false,
+		"types": ["node", "jest"]
+	},
+	"include": [
+		"src/**/*.ts",
+		"tests/*.ts",
+		"tests/**/*.ts",
+		"src/**/*.tsx"
+	],
+	"exclude": [
+		"node_modules",
+		"dist"
+	]
+}

package/tsconfig-cjs.json

@@ -0,0 +1,8 @@
+{
+	"extends": "./tsconfig-base.json",
+	"compilerOptions": {
+		"module": "commonjs",
+		"outDir": "dist/cjs",
+		"target": "es2015"
+	}
+}

package/tsconfig.json

@@ -1,50 +1,8 @@
 {
+	"extends": "./tsconfig-base.json",
 	"compilerOptions": {
-		"downlevelIteration": true,
-		"baseUrl": ".",
-		"paths": {
-			"@/components/*": [
-				"components/*"
-			],
-			"@/services/*": [
-				"services/*"
-			],
-			"@/types/*": [
-				"types/*"
-			],
-			"@/styles/*": [
-				"styles/*"
-			],
-			"@/config/*": [
-				"config/*"
-			]
-		},
-		"target": "es6",
-		"lib": [
-			"dom",
-			"dom.iterable",
-			"esnext"
-		],
-		"allowJs": false,
-		"skipLibCheck": false,
-		"strict": true,
-		"forceConsistentCasingInFileNames": true,
-		"noEmit": false,
-		"incremental": true,
-		"esModuleInterop": true,
-		"module": "es2022",
-		"moduleResolution": "node",
-		"resolveJsonModule": true,
-		"isolatedModules": true,
-		"declaration": true
-	},
-	"include": [
-		"src/**/*.ts",
-		"tests/*.ts",
-		"tests/**/*.ts",
-		"src/**/*.tsx"
-	],
-	"exclude": [
-		"node_modules"
-	]
+		"module": "esnext",
+		"outDir": "dist/mjs",
+		"target": "esnext"
+	}
 }

package/src/Emitter.d.ts

@@ -1,190 +0,0 @@
-export declare enum EventReturnFlag {
-    none = 0,
-    cancel = 1
-}
-export declare type EventListenerCallback = (...args: any[]) => any | Promise<any>;
-export interface EventStaticEmitterObject {
-    id: string;
-    args: any[];
-}
-/**
- * Creates a new class with the capability to emit events.
- */
-export declare class Emitter {
-    _eventsEmitting: boolean;
-    _eventRemovalQueue: any[];
-    _eventListeners?: Record<string, Record<string, EventListenerCallback[]>>;
-    _eventStaticEmitters: Record<string, EventStaticEmitterObject[]>;
-    _eventsAllowDefer: boolean;
-    _eventsDeferTimeouts: Record<any, number>;
-    /**
-     * Attach an event listener to the passed event only if the passed
-     * id matches the id for the event being fired.
-     * @param {string} eventName The name of the event to listen for.
-     * @param {string} id The id to match against.
-     * @param {function} listener The method to call when the event is fired.
-     * @returns {Emitter} The emitter instance.
-     */
-    _on(eventName: string, id: string, listener: EventListenerCallback): this;
-    /**
-     * Attach an event listener to the passed event only if the passed
-     * id matches the document id for the event being fired.
-     * @param {String} eventName The name of the event to listen for.
-     * @param {*} id The id to match against.
-     * @param {Function} listener The method to call when the event is fired.
-     * @returns {Emitter} The emitter instance.
-     */
-    _once(eventName: string, id: string, listener: EventListenerCallback): this;
-    /**
-     * Cancels an event listener based on an event name, id and listener function.
-     * @param {String} eventName The event to cancel listener for.
-     * @param {String} id The ID of the event to cancel listening for.
-     * @param {Function} listener The event listener function used in the on()
-     * or once() call to cancel.
-     * @returns {Emitter} The emitter instance.
-     */
-    _off(eventName: string, id: string, listener?: EventListenerCallback): this;
-    /**
-     * Attach an event listener to the passed event only if the passed
-     * id matches the document id for the event being fired.
-     * @param {String} eventName The name of the event to listen for.
-     * @param {*} id The id to match against.
-     * @param {Function} listener The method to call when the event is fired.
-     * @returns {Emitter} The emitter instance.
-     */
-    on(eventName: string, id: string, listener: EventListenerCallback): this;
-    on(eventName: string, listener: EventListenerCallback): this;
-    /**
-     * Attach an event listener to the passed event only if the passed
-     * id matches the document id for the event being fired.
-     * @param {String} eventName The name of the event to listen for.
-     * @param id The id to match against.
-     * @param listener
-     * @returns {Emitter} The emitter instance.
-     */
-    once(eventName: string, id: string, listener: EventListenerCallback): this;
-    once(eventName: string, listener: EventListenerCallback): this;
-    /**
-     * Overwrites any previous event listeners so that if the event fires, only
-     * the listener you pass will be called. If you pass an id along with the
-     * listener, only listeners for the id will be overwritten. This is similar
-     * to calling `.off(eventName)` then `on(eventName, listener)` since
-     * `off(eventName)` will cancel any previous event listeners for the passed
-     * event name.
-     * @param {String} eventName The name of the event to listen for.
-     * @param {*} id The id to match against.
-     * @param {Function} listener The method to call when the event is fired.
-     * @returns {Emitter} The emitter instance.
-     */
-    overwrite(eventName: string, id: string, listener: EventListenerCallback): this;
-    overwrite(eventName: string, listener: EventListenerCallback): this;
-    /**
-     * Cancels an event listener based on an event name, id and listener function.
-     * @param {String} eventName The event to cancel listener for.
-     * @param {String} id The ID of the event to cancel listening for.
-     * @param {Function} listener The event listener function used in the on()
-     * or once() call to cancel.
-     * @returns {Emitter} The emitter instance.
-     */
-    off(eventName: string, id: string, listener?: EventListenerCallback): this;
-    off(eventName: string, listener?: EventListenerCallback): this;
-    off(eventName: string): this;
-    /**
-     * Emit an event by name.
-     * @param {Object} eventName The name of the event to emit.
-     * @param {...any} data The arguments to send to any listening methods.
-     * If you are sending multiple arguments, separate them with a comma so
-     * that they are received by the function as separate arguments.
-     * @return {number}
-     * @example #Emit an Event
-     *     // Emit the event named "hello"
-     *     myEntity.emit('hello');
-     * @example #Emit an Event With Data Object
-     *     // Emit the event named "hello"
-     *     myEntity.emit('hello', {moo: true});
-     * @example #Emit an Event With Multiple Data Values
-     *     // Emit the event named "hello"
-     *     myEntity.emit('hello', {moo: true}, 'someString');
-     * @example #Listen for Event Data
-     *     // Set a listener to listen for the data (multiple values emitted
-     *     // from an event are passed as function arguments)
-     *     myEntity.on('hello', function (arg1, arg2) {
-     *         console.log(arg1, arg2);
-     *     }
-     *
-     *     // Emit the event named "hello"
-     *     myEntity.emit('hello', 'data1', 'data2');
-     *
-     *     // The console output is:
-     *     //    data1, data2
-     */
-    emit(eventName: string, ...data: any[]): Promise<EventReturnFlag>;
-    emitId(eventName: string, id: string, ...data: any[]): EventReturnFlag;
-    /**
-     * Creates a persistent emitter record that will fire a listener if
-     * one is added for this event after the emitStatic() call has been
-     * made.
-     * @param {String} eventName The name of the event to emit.
-     * @param {...any} data Optional arguments to emit with the event.
-     * @returns {Emitter} The emitter instance.
-     * @private
-     */
-    emitStatic(eventName: string, ...data: any[]): this;
-    /**
-     * Creates a persistent emitter record that will fire a listener if
-     * one is added for this event after the emitStatic() call has been
-     * made.
-     * @param {String} eventName The name of the event to emit.
-     * @param {String} id The id of the event to emit.
-     * @param {...any} data Optional arguments to emit with the event.
-     * @returns {Emitter} The emitter instance.
-     * @private
-     */
-    emitStaticId(eventName: string, id: string, ...data: any[]): this;
-    /**
-     * Handles removing emitters, is an internal method not called directly.
-     * @param {String} eventName The event to remove static emitter for.
-     * @returns {Emitter} The emitter instance.
-     * @private
-     */
-    cancelStatic(eventName: string): this;
-    /**
-     * Checks if an event has any event listeners or not.
-     * @param {String} eventName The name of the event to check for.
-     * @returns {boolean} True if one or more event listeners are registered for
-     * the event. False if none are found.
-     */
-    willEmit(eventName: string): boolean;
-    /**
-     * Checks if an event has any event listeners or not based on the passed id.
-     * @param {String} eventName The name of the event to check for.
-     * @param {String} id The event ID to check for.
-     * @returns {boolean} True if one or more event listeners are registered for
-     * the event. False if none are found.
-     */
-    willEmitId(eventName: string, id: string): boolean;
-    /**
-     * Queues an event to be fired. This has automatic de-bouncing so that any
-     * events of the same type that occur within 100 milliseconds of a previous
-     * one will all be wrapped into a single emit rather than emitting tons of
-     * events for lots of chained inserts etc. Only the data from the last
-     * de-bounced event will be emitted.
-     * @param {String} eventName The name of the event to emit.
-     * @param {...any} data Optional arguments to emit with the event.
-     * @returns {Emitter} The emitter instance.
-     */
-    deferEmit(eventName: string, ...data: any[]): this;
-    /**
-     * If events are cleared with the off() method while the event emitter is
-     * actively processing any events then the off() calls get added to a
-     * queue to be executed after the event emitter is finished. This stops
-     * errors that might occur by potentially modifying the event queue while
-     * the emitter is running through them. This method is called after the
-     * event emitter is finished processing.
-     * @private
-     */
-    _processRemovalQueue(): void;
-}
-export declare function makeEmitter(obj: new (...args: any[]) => any, prototypeMode: boolean): Emitter;
-export declare function makeEmitter(obj: boolean): Emitter;
-export declare function makeEmitter(obj: Record<string, unknown>, prototypeMode: boolean): Emitter;