@irrelon/emitter 6.0.1 → 6.2.0

package/tests/Emitter.test.ts

@@ -1,23 +1,30 @@
+import { jest } from "@jest/globals";
 import assert from "assert";
-import { Emitter, EmitterEventsInterface, EventListenerCallback, ListenerReturnFlag } from "../src/Emitter";
+import {
+	Emitter,
+	EmitterEventsInterface,
+	EmitterEventsWithStar,
+	EventListenerCallback,
+	ListenerReturnFlag
+} from "../src/Emitter";
 
 let expectedAssertions = 0;
 let actualAssertions = 0;
 
-function expect(val: number) {
+function expectAssertionCount (val: number) {
 	expectedAssertions = val;
 }
 
-function reset() {
+function resetAssertionCount () {
 	expectedAssertions = 0;
 	actualAssertions = 0;
 }
 
-function countAssertion() {
+function countAssertion () {
 	actualAssertions++;
 }
 
-function check() {
+function checkAssertionCount () {
 	if (expectedAssertions === undefined || expectedAssertions === actualAssertions) {
 		return;
 	}
@@ -25,15 +32,16 @@ function check() {
 	throw new Error("expected " + expectedAssertions + " assertions, got " + actualAssertions);
 }
 
-beforeEach(reset);
-afterEach(check);
+beforeEach(resetAssertionCount);
+afterEach(checkAssertionCount);
 
 describe("Emitter", () => {
 	describe("new Emitter()", () => {
 		it("Creates emitter instance by instantiation", () => {
 			const myClass = new Emitter();
 
-			myClass.on("moo", () => {});
+			myClass.on("moo", () => {
+			});
 
 			assert.strictEqual(myClass._eventListeners?.moo!["*"].length, 1, "Listener registered on event");
 
@@ -41,25 +49,19 @@ describe("Emitter", () => {
 
 			assert.strictEqual(
 				!myClass._eventListeners?.moo ||
-					!myClass._eventListeners.moo["*"] ||
-					myClass._eventListeners.moo["*"].length,
+				!myClass._eventListeners.moo["*"] ||
+				myClass._eventListeners.moo["*"].length,
 				true,
 				"Listeners all removed from event"
 			);
 		});
 
 		it("Supports extending Emitter as a base class", () => {
-			let testFuncCount = 0;
-
 			// Test extending Emitter and modifying base functionality
 			class MyClass extends Emitter {
-				testFunc() {
-					testFuncCount++;
-				}
-
-				on(eventName: string, id: string, listener: EventListenerCallback): this;
-				on(eventName: string, listener: EventListenerCallback): this;
-				on(eventName: string, ...rest: any[]): this {
+				on (eventName: string, id: string, listener: EventListenerCallback): this;
+				on (eventName: string, listener: EventListenerCallback): this;
+				on (eventName: string, ...rest: any[]): this {
 					const restTypes = rest.map((arg) => typeof arg);
 
 					if (restTypes[0] === "function") {
@@ -73,14 +75,14 @@ describe("Emitter", () => {
 				}
 
 				// @ts-ignore
-				emit(eventName: string, ...rest: any[]) {
+				emit (eventName: string, ...rest: any[]) {
 					return super.emitId(eventName, "^^noId", ...rest);
 				}
 
-				off(eventName: string, id: string, listener?: EventListenerCallback): this;
-				off(eventName: string, listener?: EventListenerCallback): this;
-				off(eventName: string): this;
-				off(eventName: string, ...rest: any[]) {
+				off (eventName: string, id: string, listener?: EventListenerCallback): this;
+				off (eventName: string, listener?: EventListenerCallback): this;
+				off (eventName: string): this;
+				off (eventName: string, ...rest: any[]) {
 					let id = rest[0];
 					let func = rest[1];
 
@@ -118,22 +120,22 @@ describe("Emitter", () => {
 
 			assert.strictEqual(
 				!myClass._eventListeners?.moo ||
-					!myClass._eventListeners?.moo["testId"] ||
-					(myClass._eventListeners?.moo["testId"].length as number) === 0,
+				!myClass._eventListeners?.moo["testId"] ||
+				(myClass._eventListeners?.moo["testId"].length as number) === 0,
 				true,
 				"Listeners all removed from event"
 			);
 			assert.strictEqual(
 				myClass._eventListeners?.moo &&
-					myClass._eventListeners?.moo["^^noId"] &&
-					myClass._eventListeners?.moo["^^noId"].length === 1,
+				myClass._eventListeners?.moo["^^noId"] &&
+				myClass._eventListeners?.moo["^^noId"].length === 1,
 				true,
 				"Global listener still there"
 			);
 			assert.strictEqual(
 				!myClass._eventListeners?.moo ||
-					!myClass._eventListeners?.moo["*"] ||
-					myClass._eventListeners?.moo["*"].length === 0,
+				!myClass._eventListeners?.moo["*"] ||
+				myClass._eventListeners?.moo["*"].length === 0,
 				true,
 				"Global listener still there"
 			);
@@ -142,8 +144,8 @@ describe("Emitter", () => {
 
 			assert.strictEqual(
 				!myClass._eventListeners?.moo ||
-					!myClass._eventListeners?.moo["*"] ||
-					myClass._eventListeners?.moo["*"].length === 0,
+				!myClass._eventListeners?.moo["*"] ||
+				myClass._eventListeners?.moo["*"].length === 0,
 				true,
 				"Listeners all removed from event"
 			);
@@ -230,6 +232,7 @@ describe("Emitter", () => {
 			const delta = new Date().getTime() - time;
 
 			assert.ok(delta > 900, "Delta was not correct, await may not have paused?");
+			assert.strictEqual(listenerFiredCount, 2, "Listener fire count was incorect");
 		});
 
 		it("Supports awaiting async and non-async listener return data", async () => {
@@ -338,12 +341,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", () => {});
+			myClass.on("moo", () => {
+			});
 			assert.strictEqual(myClass._eventListeners?.moo!["*"].length, 1, "Listeners registered on event");
-			myClass.on("moo", "testId", () => {});
+			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");
@@ -354,8 +361,8 @@ describe("Emitter", () => {
 
 			assert.strictEqual(
 				!myClass._eventListeners?.moo ||
-					(myClass._eventListeners?.moo["*"].length === 0 &&
-						myClass._eventListeners?.moo["testId"].length === 0),
+				(myClass._eventListeners?.moo["*"].length === 0 &&
+					myClass._eventListeners?.moo["testId"].length === 0),
 				true,
 				"Listeners all removed from event"
 			);
@@ -363,12 +370,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", () => {});
+			myClass.on("moo", () => {
+			});
 			assert.strictEqual(myClass._eventListeners?.moo!["*"].length, 1, "Listeners registered on event");
-			myClass.on("moo", "testId", () => {});
+			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");
@@ -391,12 +402,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", () => {});
+			myClass.on("moo", () => {
+			});
 			assert.strictEqual(myClass._eventListeners?.moo!["*"].length, 1, "Listeners registered on event");
-			myClass.on("moo", "testId", () => {});
+			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");
@@ -419,12 +434,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", () => {});
+			myClass.on("moo", () => {
+			});
 			assert.strictEqual(myClass._eventListeners?.moo!["*"].length, 1, "Listeners registered on event");
-			myClass.on("moo", "testId", () => {});
+			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");
@@ -448,9 +467,10 @@ 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);
+			expectAssertionCount(1);
 
 			const myClass = new MyClass();
 			myClass.emitStatic("moo");
@@ -464,9 +484,10 @@ describe("Emitter", () => {
 
 	describe("cancelStatic()", () => {
 		it("Removes static emitter", (resolve) => {
-			class MyClass extends Emitter {}
+			class MyClass extends Emitter {
+			}
 
-			expect(1);
+			expectAssertionCount(1);
 
 			const myClass = new MyClass();
 			myClass.emitStatic("moo");
@@ -489,9 +510,10 @@ 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);
+			expectAssertionCount(1);
 
 			const myClass = new MyClass();
 			myClass.on("moo", () => {
@@ -514,9 +536,10 @@ describe("Emitter", () => {
 		});
 
 		it("Only fires the last listener added (with id), cancelling all other listeners before it", (resolve) => {
-			class MyClass extends Emitter {}
+			class MyClass extends Emitter {
+			}
 
-			expect(2);
+			expectAssertionCount(2);
 
 			const myClass = new MyClass();
 
@@ -575,15 +598,15 @@ describe("Emitter", () => {
 
 			assert.strictEqual(
 				!myClass._eventListeners?.moo ||
-					!myClass._eventListeners?.moo["testId"] ||
-					myClass._eventListeners?.moo["testId"].length,
+				!myClass._eventListeners?.moo["testId"] ||
+				myClass._eventListeners?.moo["testId"].length,
 				true,
 				"Listeners all removed from event"
 			);
 			assert.strictEqual(
 				myClass._eventListeners?.moo &&
-					myClass._eventListeners?.moo["*"] &&
-					myClass._eventListeners?.moo["*"].length === 1,
+				myClass._eventListeners?.moo["*"] &&
+				myClass._eventListeners?.moo["*"].length === 1,
 				true,
 				"Global listener still there"
 			);
@@ -592,11 +615,67 @@ describe("Emitter", () => {
 
 			assert.strictEqual(
 				!myClass._eventListeners?.moo ||
-					!myClass._eventListeners?.moo["*"] ||
-					myClass._eventListeners?.moo["*"].length === 0,
+				!myClass._eventListeners?.moo["*"] ||
+				myClass._eventListeners?.moo["*"].length === 0,
 				true,
 				"Listeners all removed from event"
 			);
 		});
 	});
+
+	describe("Global listener functionality", () => {
+		interface MyEvents {
+			someEvent: (arg1: string, arg2: boolean, arg3: boolean) => void;
+		}
+
+		it("Listens for any event emitted and fires the listener with the onAny() function", () => {
+			const emitter = new Emitter<MyEvents>();
+
+			const spy = jest.fn();
+
+			emitter.onAny(spy);
+
+			emitter.emit("someEvent", "someArg1", true, false);
+
+			expect(spy).toHaveBeenCalledWith("someEvent", "someArg1", true, false);
+		});
+
+		it(`Listens for any event emitted and fires the listener with the on("*") function`, () => {
+			const emitter = new Emitter<EmitterEventsWithStar<MyEvents>>();
+
+			const spy = jest.fn();
+
+			emitter.on("*", spy);
+
+			emitter.emit("someEvent", "someArg1", true, false);
+
+			expect(spy).toHaveBeenCalledWith("someEvent", "someArg1", true, false);
+		});
+
+		it(`Cancels an event listener for any event emitted with the offAny() function`, () => {
+			const emitter = new Emitter<EmitterEventsWithStar<MyEvents>>();
+
+			const spy = jest.fn();
+
+			emitter.on("*", spy);
+			emitter.offAny(spy);
+
+			emitter.emit("someEvent", "someArg1", true, false);
+
+			expect(spy).toHaveBeenCalledTimes(0);
+		});
+
+		it(`Cancels an event listener for any event emitted with the off("*") function`, () => {
+			const emitter = new Emitter<EmitterEventsWithStar<MyEvents>>();
+
+			const spy = jest.fn();
+
+			emitter.on("*", spy);
+			emitter.off("*", spy);
+
+			emitter.emit("someEvent", "someArg1", true, false);
+
+			expect(spy).toHaveBeenCalledTimes(0);
+		});
+	});
 });

package/tsconfig.json

@@ -4,7 +4,8 @@
 		"baseUrl": ".",
 		"target": "es6",
 		"lib": [
-			"esnext"
+			"ESNext",
+			"DOM"
 		],
 		"allowJs": false,
 		"skipLibCheck": false,
@@ -12,6 +13,8 @@
 		"pretty": true,
 		"allowSyntheticDefaultImports": true,
 		"forceConsistentCasingInFileNames": true,
+		"experimentalDecorators": true,
+		"emitDecoratorMetadata": true,
 		"noEmit": false,
 		"incremental": true,
 		"esModuleInterop": true,
@@ -21,7 +24,10 @@
 		"isolatedModules": true,
 		"declaration": true,
 		"inlineSourceMap": false,
-		"types": ["node", "jest"]
+		"types": [
+			"node",
+			"jest"
+		]
 	},
 	"include": [
 		"src/**/*.ts",