@irrelon/emitter 6.0.0 → 6.1.0

package/tests/Emitter.test.ts

@@ -1,14 +1,15 @@
+import { jest } from "@jest/globals";
 import assert from "assert";
 import { Emitter, EmitterEventsInterface, 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;
 }
@@ -17,7 +18,7 @@ function countAssertion () {
 	actualAssertions++;
 }
 
-function check () {
+function checkAssertionCount () {
 	if (expectedAssertions === undefined || expectedAssertions === actualAssertions) {
 		return;
 	}
@@ -25,8 +26,8 @@ function check () {
 	throw new Error("expected " + expectedAssertions + " assertions, got " + actualAssertions);
 }
 
-beforeEach(reset);
-afterEach(check);
+beforeEach(resetAssertionCount);
+afterEach(checkAssertionCount);
 
 describe("Emitter", () => {
 	describe("new Emitter()", () => {
@@ -41,22 +42,16 @@ 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 {
@@ -118,22 +113,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 +137,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"
 			);
@@ -152,153 +147,187 @@ describe("Emitter", () => {
 
 	describe("emit()", () => {
 		it("Supports type safe usage", async () => {
-			interface MyEventsResponses {
-				post: () => Promise<void>;
-				person: (name: string, age: number, enabled: boolean) => Promise<string>;
-				house: (no: number, street: string, postcode: string, enabled: boolean) => void;
-			}
-
-			const emitter = new Emitter<MyEventsResponses>();
-			let listenerFiredCount = 0;
-
-			emitter.on("person", (name) => {
-				return new Promise<string>((resolve) => {
-					setTimeout(() => {
-						listenerFiredCount++;
-						resolve(name);
-					}, 1000);
-				});
-			});
-
-			emitter.on("post", () => {
-				return new Promise<void>((resolve) => {
-					setTimeout(() => {
-						listenerFiredCount++;
-						resolve();
-					}, 1000);
-				});
-			});
-
-			emitter.on("post", () => {
-				return new Promise<void>((resolve) => {
-					setTimeout(() => {
-						listenerFiredCount++;
-						resolve();
-					}, 1000);
-				});
-			});
-
-			const time = new Date().getTime();
-			await Promise.all(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}`);
-			assert.ok(
-				listenerFiredCount === 2,
-				`listenerFiredCount was not correct, await may not have paused? listenerFiredCount was: ${listenerFiredCount}`
-			);
+            interface MyEventsResponses {
+                post: () => Promise<void>;
+                person: (name: string, age: number, enabled: boolean) => Promise<string>;
+                house: (no: number, street: string, postcode: string, enabled: boolean) => void;
+            }
+
+            const emitter = new Emitter<MyEventsResponses>();
+            let listenerFiredCount = 0;
+
+            emitter.on("person", (name) => {
+            	return new Promise<string>((resolve) => {
+            		setTimeout(() => {
+            			listenerFiredCount++;
+            			resolve(name);
+            		}, 1000);
+            	});
+            });
+
+            emitter.on("post", () => {
+            	return new Promise<void>((resolve) => {
+            		setTimeout(() => {
+            			listenerFiredCount++;
+            			resolve();
+            		}, 1000);
+            	});
+            });
+
+            emitter.on("post", () => {
+            	return new Promise<void>((resolve) => {
+            		setTimeout(() => {
+            			listenerFiredCount++;
+            			resolve();
+            		}, 1000);
+            	});
+            });
+
+            const time = new Date().getTime();
+            await Promise.all(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}`);
+            assert.ok(
+            	listenerFiredCount === 2,
+            	`listenerFiredCount was not correct, await may not have paused? listenerFiredCount was: ${listenerFiredCount}`
+            );
 		});
 
 		it("Supports awaiting async listeners", async () => {
-			interface TestEvents {
-				foo: () => Promise<void>;
-			}
-
-			const emitter = new Emitter<EmitterEventsInterface<TestEvents>>();
-			let listenerFiredCount = 0;
-
-			emitter.on("foo", async () => {
-				return new Promise<void>((resolve) => {
-					setTimeout(() => {
-						listenerFiredCount++;
-						resolve();
-					}, 1000);
-				});
-			});
-
-			emitter.on("foo", async () => {
-				return new Promise<void>((resolve) => {
-					setTimeout(() => {
-						listenerFiredCount++;
-						resolve();
-					}, 1000);
-				});
-			});
-
-			const time = new Date().getTime();
-			await Promise.all(emitter.emit("foo"));
-			const delta = new Date().getTime() - time;
-
-			assert.ok(delta > 900, "Delta was not correct, await may not have paused?");
+            interface TestEvents {
+                foo: () => Promise<void>;
+            }
+
+            const emitter = new Emitter<EmitterEventsInterface<TestEvents>>();
+            let listenerFiredCount = 0;
+
+            emitter.on("foo", async () => {
+            	return new Promise<void>((resolve) => {
+            		setTimeout(() => {
+            			listenerFiredCount++;
+            			resolve();
+            		}, 1000);
+            	});
+            });
+
+            emitter.on("foo", async () => {
+            	return new Promise<void>((resolve) => {
+            		setTimeout(() => {
+            			listenerFiredCount++;
+            			resolve();
+            		}, 1000);
+            	});
+            });
+
+            const time = new Date().getTime();
+            await Promise.all(emitter.emit("foo"));
+            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 () => {
-			interface MyTestEvents {
-				foo: () => string | Promise<string>;
-			}
-
-			const emitter = new Emitter<EmitterEventsInterface<MyTestEvents>>();
-			let listenerFiredCount = 0;
-
-			emitter.on("foo", () => {
-				return new Promise<string>((resolve) => {
-					setTimeout(() => {
-						listenerFiredCount++;
-						resolve("Foo1 Return Value");
-					}, 1000);
-				});
-			});
-
-			emitter.on("foo", () => {
-				return "Foo2 Return Value";
-			});
-
-			const time = new Date().getTime();
-			const results: string[] = await Promise.all(emitter.emit("foo"));
-			const delta = new Date().getTime() - time;
+            interface MyTestEvents {
+                foo: () => string | Promise<string>;
+            }
+
+            const emitter = new Emitter<EmitterEventsInterface<MyTestEvents>>();
+            let listenerFiredCount = 0;
+
+            emitter.on("foo", () => {
+            	return new Promise<string>((resolve) => {
+            		setTimeout(() => {
+            			listenerFiredCount++;
+            			resolve("Foo1 Return Value");
+            		}, 1000);
+            	});
+            });
+
+            emitter.on("foo", () => {
+            	return "Foo2 Return Value";
+            });
+
+            const time = new Date().getTime();
+            const results: string[] = await Promise.all(emitter.emit("foo"));
+            const delta = new Date().getTime() - time;
+
+            assert.ok(delta > 900, "Delta was not correct, await may not have paused?");
+            assert.ok(listenerFiredCount === 1, "listenerFiredCount was not correct, await may not have been used?");
+            assert.strictEqual(results[0], "Foo1 Return Value", "Return data for foo1 was not correct");
+            assert.strictEqual(results[1], "Foo2 Return Value", "Return data for foo2 was not correct");
+		});
 
-			assert.ok(delta > 900, "Delta was not correct, await may not have paused?");
-			assert.ok(listenerFiredCount === 1, "listenerFiredCount was not correct, await may not have been used?");
-			assert.strictEqual(results[0], "Foo1 Return Value", "Return data for foo1 was not correct");
-			assert.strictEqual(results[1], "Foo2 Return Value", "Return data for foo2 was not correct");
+		it("Supports awaiting async and non-async rpc listener return data", async () => {
+            interface MyTestEvents {
+                foo1: () => string | Promise<string>;
+                foo2: () => string;
+            }
+
+            const emitter = new Emitter<EmitterEventsInterface<MyTestEvents>>();
+            let listenerFiredCount = 0;
+
+            emitter.on("foo1", () => {
+            	return new Promise<string>((resolve) => {
+            		setTimeout(() => {
+            			listenerFiredCount++;
+            			resolve("Foo1 Return Value");
+            		}, 1000);
+            	});
+            });
+
+            emitter.on("foo2", () => {
+            	return "Foo2 Return Value";
+            });
+
+            const time = new Date().getTime();
+            const result1 = await emitter.rpc("foo1");
+            const result2 = emitter.rpc("foo2");
+            const delta = new Date().getTime() - time;
+
+            assert.ok(delta > 900, "Delta was not correct, await may not have paused?");
+            assert.ok(listenerFiredCount === 1, "listenerFiredCount was not correct, await may not have been used?");
+            assert.strictEqual(result1, "Foo1 Return Value", "Return data for foo1 was not correct");
+            assert.strictEqual(result2, "Foo2 Return Value", "Return data for foo2 was not correct");
 		});
 
 		it("Supports responding with a cancellation signal", async () => {
-			interface MyTestEvents {
-				foo: () => string | ListenerReturnFlag;
-			}
+            interface MyTestEvents {
+                foo: () => string | ListenerReturnFlag;
+            }
 
-			const emitter = new Emitter<EmitterEventsInterface<MyTestEvents>>();
-			let listenerFiredCount = 0;
+            const emitter = new Emitter<EmitterEventsInterface<MyTestEvents>>();
+            let listenerFiredCount = 0;
 
-			emitter.on("foo", () => {
-				listenerFiredCount++;
-				return "Foo1 Return Value";
-			});
+            emitter.on("foo", () => {
+            	listenerFiredCount++;
+            	return "Foo1 Return Value";
+            });
 
-			emitter.on("foo", () => {
-				listenerFiredCount++;
+            emitter.on("foo", () => {
+            	listenerFiredCount++;
 
-				// This listener will respond with a cancellation, this should terminate further listener calls
-				return ListenerReturnFlag.cancel;
-			});
+            	// This listener will respond with a cancellation, this should terminate further listener calls
+            	return ListenerReturnFlag.cancel;
+            });
 
-			emitter.on("foo", () => {
-				listenerFiredCount++;
-				return "Foo3 Return Value";
-			});
+            emitter.on("foo", () => {
+            	listenerFiredCount++;
+            	return "Foo3 Return Value";
+            });
 
-			emitter.on("foo", () => {
-				listenerFiredCount++;
-				return "Foo4 Return Value";
-			});
+            emitter.on("foo", () => {
+            	listenerFiredCount++;
+            	return "Foo4 Return Value";
+            });
 
-			const results = emitter.emit("foo");
+            const results = emitter.emit("foo");
 
-			assert.ok(listenerFiredCount === 2, "listenerFiredCount was not correct, await may not have been used?");
-			assert.strictEqual(results[0], "Foo1 Return Value", "Return data should be a cancel flag");
-			assert.strictEqual(results[1], ListenerReturnFlag.cancel, "Return data should be a cancel flag");
-			assert.ok(emitter.didCancel(results), "didCancel should detect a cancel flag");
+            assert.ok(listenerFiredCount === 2, "listenerFiredCount was not correct, await may not have been used?");
+            assert.strictEqual(results[0], "Foo1 Return Value", "Return data should be a cancel flag");
+            assert.strictEqual(results[1], ListenerReturnFlag.cancel, "Return data should be a cancel flag");
+            assert.ok(emitter.didCancel(results), "didCancel should detect a cancel flag");
 		});
 	});
 
@@ -321,8 +350,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"
 			);
@@ -417,7 +446,7 @@ describe("Emitter", () => {
 		it("Static emitter will emit when a new listener is added", (resolve) => {
 			class MyClass extends Emitter {}
 
-			expect(1);
+			expectAssertionCount(1);
 
 			const myClass = new MyClass();
 			myClass.emitStatic("moo");
@@ -433,7 +462,7 @@ describe("Emitter", () => {
 		it("Removes static emitter", (resolve) => {
 			class MyClass extends Emitter {}
 
-			expect(1);
+			expectAssertionCount(1);
 
 			const myClass = new MyClass();
 			myClass.emitStatic("moo");
@@ -458,7 +487,7 @@ describe("Emitter", () => {
 		it("Only fires the last listener added, cancelling all other listeners before it", (resolve) => {
 			class MyClass extends Emitter {}
 
-			expect(1);
+			expectAssertionCount(1);
 
 			const myClass = new MyClass();
 			myClass.on("moo", () => {
@@ -483,7 +512,7 @@ describe("Emitter", () => {
 		it("Only fires the last listener added (with id), cancelling all other listeners before it", (resolve) => {
 			class MyClass extends Emitter {}
 
-			expect(2);
+			expectAssertionCount(2);
 
 			const myClass = new MyClass();
 
@@ -542,15 +571,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"
 			);
@@ -559,11 +588,63 @@ 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", () => {
+		it("Listens for any event emitted and fires the listener with the onAny() function", () => {
+			const emitter = new Emitter();
+
+			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();
+
+			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();
+
+			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();
+
+			const spy = jest.fn();
+
+			emitter.on("*", spy);
+			emitter.off("*", spy);
+
+			emitter.emit("someEvent", "someArg1", true, false);
+
+			expect(spy).toHaveBeenCalledTimes(0);
+		});
+	});
+});

package/.editorconfig

@@ -1,11 +0,0 @@
-# EditorConfig is awesome: http://EditorConfig.org
-
-# top-most EditorConfig file
-root = true
-
-# Unix-style newlines with a newline ending every file
-[*]
-end_of_line = lf
-insert_final_newline = false
-indent_style = tab
-indent_size = 4