@irrelon/emitter 6.0.1 → 6.2.0

package/.editorconfig

@@ -1,11 +1,8 @@
-# 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
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = false

package/dist/cjs/src/Emitter.d.ts

@@ -15,10 +15,14 @@ export interface EmitterAnyEventsInterface {
 export type EmitterEventsInterface<T> = {
     [K in keyof T]: T[K];
 };
+export interface WithStar {
+    "*"?: (eventName: string, ...args: any[]) => void;
+}
+export type EmitterEventsWithStar<T> = EmitterEventsInterface<T> & WithStar;
 /**
- * Creates a new class with the capability to emit events.
+ * Creates a new class with the ability to emit events.
  */
-export declare class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterface> = EmitterAnyEventsInterface> {
+export declare class Emitter<EventsInterface extends EmitterEventsWithStar<EventsInterface> = EmitterAnyEventsInterface> {
     _eventsEmitting: boolean;
     _eventRemovalQueue: any[];
     _eventListeners?: {
@@ -29,6 +33,10 @@ export declare class Emitter<EventsInterface extends EmitterEventsInterface<Even
     };
     _eventsAllowDefer: boolean;
     _eventsDeferTimeouts: Record<any, number>;
+    _dispatchWindowEventsEnabled: boolean;
+    _dispatchPrefix?: string;
+    constructor(dispatchPrefix?: string, shouldDispatchWindowEvents?: boolean);
+    dispatchWindowEventsEnabled(shouldDispatchWindowEvents: boolean): void;
     /**
      * Attach an event listener to the passed event only if the passed
      * id matches the id for the event being fired.
@@ -56,6 +64,11 @@ export declare class Emitter<EventsInterface extends EmitterEventsInterface<Even
      * @returns The emitter instance.
      */
     _off<EventName extends keyof EventsInterface>(eventName: EventName, id: string, listener?: EventListenerCallback<EventsInterface[EventName]>): this;
+    /**
+     * Creates an event listener that listens for any and all events
+     * emitted.
+     */
+    onAny(listener: EventListenerCallback): void;
     /**
      * Attach an event listener to the passed event only if the passed
      * id matches the document id for the event being fired.
@@ -90,6 +103,11 @@ export declare class Emitter<EventsInterface extends EmitterEventsInterface<Even
      */
     overwrite<EventName extends keyof EventsInterface>(eventName: EventName, id: string, listener: EventListenerCallback<EventsInterface[EventName]>): this;
     overwrite<EventName extends keyof EventsInterface>(eventName: EventName, listener: EventListenerCallback<EventsInterface[EventName]>): this;
+    /**
+     * Removes an event listener that listens for any and all events
+     * emitted.
+     */
+    offAny(listener: EventListenerCallback): void;
     /**
      * Cancels an event listener based on an event name, id and listener function.
      * @param eventName The event to cancel listener for.
@@ -103,6 +121,14 @@ export declare class Emitter<EventsInterface extends EmitterEventsInterface<Even
     off<EventName extends keyof EventsInterface>(eventName: EventName): this;
     _emitToSingleListener<EventName extends keyof EventsInterface>(listener: EventListenerCallback<EventsInterface[EventName]>, data: Parameters<EventsInterface[EventName]>): ReturnType<EventsInterface[EventName]> | ListenerReturnFlag;
     _emitToArrayOfListeners<EventName extends keyof EventsInterface>(arr: EventListenerCallback<EventsInterface[EventName]>[], data: Parameters<EventsInterface[EventName]>): (ReturnType<EventsInterface[EventName]> | ListenerReturnFlag)[];
+    /**
+     * Dispatches an event originating in our emitter to the browser's
+     * window object.
+     * @param eventName The name of the event to emit. This gets prefixed with the
+     * dispatch prefix if one is set.
+     * @param data
+     */
+    _emitToWindowDispatch<EventName extends keyof EventsInterface>(eventName: EventName, data: any): void;
     /**
      * Call an event listener by name. The `rpc()` function differs from `emit()` in
      * that it will only call and return data from the first event listener for the
@@ -133,10 +159,10 @@ export declare class Emitter<EventsInterface extends EmitterEventsInterface<Even
      *
      *     // Emit the event named "hello"
      *     const result = myEntity.emit('hello', 'data1', 'data2');
-     *	   console.log("Result:", result);
+     *       console.log("Result:", result);
      *
      *     // The console output is:
-     *     //   Arguments: data1 data2
+     *     //	Arguments: data1 data2
      *     //	Result: "foo"
      */
     rpc<EventName extends keyof EventsInterface>(eventName: EventName, ...data: Parameters<EventsInterface[EventName]>): ReturnType<EventsInterface[EventName]> | ListenerReturnFlag;
@@ -147,7 +173,7 @@ export declare class Emitter<EventsInterface extends EmitterEventsInterface<Even
      * @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}
+     * @return {any[]} An array of all return values from all the listeners for the event.
      * @example #Emit an Event
      *     // Emit the event named "hello"
      *     myEntity.emit('hello');
@@ -160,7 +186,7 @@ export declare class Emitter<EventsInterface extends EmitterEventsInterface<Even
      * @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) {
+     *	   myEntity.on('hello', function (arg1, arg2) {
      *         console.log("Arguments:", arg1, arg2);
      *         return "foo";
      *     }
@@ -169,18 +195,29 @@ export declare class Emitter<EventsInterface extends EmitterEventsInterface<Even
      *     // The result is returned as an array of all return values
      *     // from all the listeners for the event
      *     const result = myEntity.emit('hello', 'data1', 'data2');
-     * 	   console.log("Result:", result);
+     *       console.log("Result:", result);
      *
      *     // The console output is:
-     *     //   Arguments: data1 data2
+     *     //	Arguments: data1 data2
      *     //	Result: ["foo"]
      */
     emit<EventName extends keyof EventsInterface>(eventName: EventName, ...data: Parameters<EventsInterface[EventName]>): (ReturnType<EventsInterface[EventName]> | ListenerReturnFlag)[];
+    /**
+     * Emits an event by name and id.
+     * @param eventName The name of the event to emit.
+     * @param id The id 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 {any[]} An array of all return values from all the listeners for the event.
+     */
     emitId<EventName extends keyof EventsInterface>(eventName: EventName, id: string, ...data: Parameters<EventsInterface[EventName]>): (ReturnType<EventsInterface[EventName]> | ListenerReturnFlag)[];
     /**
-     * Creates a persistent emitter record that will fire a listener if
-     * one is added for this event after the emitStatic() call has been
-     * made.
+     * Creates a persistent event. Once emitStatic() has been called, a
+     * persistent event is registered. Any existing event listeners will
+     * be called just like when you call emit(), however, any new
+     * listeners that are registered for this event via on() will also be
+     * called as soon as they are added.
      * @param eventName The name of the event to emit.
      * @param {...any} data Optional arguments to emit with the event.
      * @returns The emitter instance.
@@ -248,6 +285,6 @@ export declare class Emitter<EventsInterface extends EmitterEventsInterface<Even
      */
     _processRemovalQueue(): void;
 }
-export declare function makeEmitter(obj: AnyConstructor, prototypeMode: boolean): Emitter;
-export declare function makeEmitter(obj: boolean): Emitter;
-export declare function makeEmitter(obj: Record<string, unknown>, prototypeMode: boolean): Emitter;
+export declare function makeEmitter<EventsInterface extends EmitterEventsWithStar<EventsInterface> = EmitterAnyEventsInterface>(obj: boolean): Emitter<EventsInterface>;
+export declare function makeEmitter<EventsInterface extends EmitterEventsWithStar<EventsInterface> = EmitterAnyEventsInterface>(obj: Record<string, unknown>, prototypeMode: boolean): Emitter<EventsInterface>;
+export declare function makeEmitter<EventsInterface extends EmitterEventsWithStar<EventsInterface> = EmitterAnyEventsInterface>(obj: AnyConstructor): Emitter<EventsInterface>;

package/dist/cjs/src/Emitter.js

@@ -1,22 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeEmitter = exports.Emitter = exports.ListenerReturnFlag = void 0;
+exports.Emitter = exports.ListenerReturnFlag = void 0;
+exports.makeEmitter = makeEmitter;
 var ListenerReturnFlag;
 (function (ListenerReturnFlag) {
     ListenerReturnFlag["none"] = "!+_NONE";
     ListenerReturnFlag["cancel"] = "!+_CANCEL";
 })(ListenerReturnFlag || (exports.ListenerReturnFlag = ListenerReturnFlag = {}));
 /**
- * Creates a new class with the capability to emit events.
+ * Creates a new class with the ability to emit events.
  */
 class Emitter {
-    constructor() {
+    constructor(dispatchPrefix, shouldDispatchWindowEvents = false) {
         this._eventsEmitting = false;
         this._eventRemovalQueue = [];
         this._eventListeners = {};
         this._eventStaticEmitters = {};
         this._eventsAllowDefer = false;
         this._eventsDeferTimeouts = {};
+        this._dispatchWindowEventsEnabled = false;
+        this._dispatchPrefix = dispatchPrefix;
+        this._dispatchWindowEventsEnabled = shouldDispatchWindowEvents;
+    }
+    dispatchWindowEventsEnabled(shouldDispatchWindowEvents) {
+        this._dispatchWindowEventsEnabled = shouldDispatchWindowEvents;
     }
     /**
      * Attach an event listener to the passed event only if the passed
@@ -37,9 +44,7 @@ class Emitter {
         nonNullableEventListeners[id] = nonNullableEventListeners[id] || [];
         nonNullableEventListeners[id].push(listener);
         // Check for any static emitters, and fire the event if any exist
-        if (!this._eventStaticEmitters ||
-            !this._eventStaticEmitters[eventName] ||
-            !this._eventStaticEmitters[eventName].length)
+        if (!this._eventStaticEmitters || !this._eventStaticEmitters[eventName] || !this._eventStaticEmitters[eventName].length)
             return this;
         // Emit events for each emitter
         for (let i = 0; i < this._eventStaticEmitters[eventName].length; i++) {
@@ -115,6 +120,13 @@ class Emitter {
         }
         return this;
     }
+    /**
+     * Creates an event listener that listens for any and all events
+     * emitted.
+     */
+    onAny(listener) {
+        this.on("*", listener);
+    }
     on(eventName, idOrListener, listener) {
         if (typeof idOrListener === "string") {
             return this._on(eventName, idOrListener, listener);
@@ -137,6 +149,13 @@ class Emitter {
         this.off(eventName, rest[0]);
         return this._on(eventName, rest[0], rest[1]);
     }
+    /**
+     * Removes an event listener that listens for any and all events
+     * emitted.
+     */
+    offAny(listener) {
+        this.off("*", listener);
+    }
     off(eventName, ...rest) {
         if (rest.length === 0) {
             // Only event was provided, use * as the id to mean "any without"
@@ -173,6 +192,22 @@ class Emitter {
         }
         return resultArr;
     }
+    /**
+     * Dispatches an event originating in our emitter to the browser's
+     * window object.
+     * @param eventName The name of the event to emit. This gets prefixed with the
+     * dispatch prefix if one is set.
+     * @param data
+     */
+    _emitToWindowDispatch(eventName, data) {
+        if (typeof window === "undefined")
+            return;
+        if (!this._dispatchWindowEventsEnabled) {
+            return;
+        }
+        const finalEventName = (this._dispatchPrefix ? `${this._dispatchPrefix}.${eventName}` : eventName);
+        window.dispatchEvent(new CustomEvent(finalEventName, { detail: data }));
+    }
     /**
      * Call an event listener by name. The `rpc()` function differs from `emit()` in
      * that it will only call and return data from the first event listener for the
@@ -203,10 +238,10 @@ class Emitter {
      *
      *     // Emit the event named "hello"
      *     const result = myEntity.emit('hello', 'data1', 'data2');
-     *	   console.log("Result:", result);
+     *       console.log("Result:", result);
      *
      *     // The console output is:
-     *     //   Arguments: data1 data2
+     *     //	Arguments: data1 data2
      *     //	Result: "foo"
      */
     rpc(eventName, ...data) {
@@ -224,7 +259,7 @@ class Emitter {
             emitterResult = this._emitToSingleListener(arr[0], data);
         }
         else if (id !== "*" && this._eventListeners[eventName]["*"]) {
-            // Handle global emit if the id passed wasn't already a global (*) id
+            // Handle wildcard emit if the id passed wasn't already a wildcard (*) id
             const arr = this._eventListeners[eventName]["*"];
             emitterResult = this._emitToSingleListener(arr[0], data);
         }
@@ -244,7 +279,7 @@ class Emitter {
      * @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}
+     * @return {any[]} An array of all return values from all the listeners for the event.
      * @example #Emit an Event
      *     // Emit the event named "hello"
      *     myEntity.emit('hello');
@@ -257,7 +292,7 @@ class Emitter {
      * @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) {
+     *	   myEntity.on('hello', function (arg1, arg2) {
      *         console.log("Arguments:", arg1, arg2);
      *         return "foo";
      *     }
@@ -266,39 +301,57 @@ class Emitter {
      *     // The result is returned as an array of all return values
      *     // from all the listeners for the event
      *     const result = myEntity.emit('hello', 'data1', 'data2');
-     * 	   console.log("Result:", result);
+     *       console.log("Result:", result);
      *
      *     // The console output is:
-     *     //   Arguments: data1 data2
+     *     //	Arguments: data1 data2
      *     //	Result: ["foo"]
      */
     emit(eventName, ...data) {
+        this._emitToWindowDispatch(eventName, data);
         return this.emitId(eventName, "*", ...data);
     }
+    /**
+     * Emits an event by name and id.
+     * @param eventName The name of the event to emit.
+     * @param id The id 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 {any[]} An array of all return values from all the listeners for the event.
+     */
     emitId(eventName, id, ...data) {
-        if (!this._eventListeners || !this._eventListeners[eventName]) {
+        if (!this._eventListeners || (!this._eventListeners[eventName] && !this._eventListeners["*"])) {
             return [];
         }
         let emitterResult = [];
         this._eventsEmitting = true;
-        // Handle id emit
-        if (this._eventListeners[eventName][id]) {
-            const arr = this._eventListeners[eventName][id];
-            emitterResult = emitterResult.concat(this._emitToArrayOfListeners(arr, data));
+        if (this._eventListeners[eventName]) {
+            // Handle id emit
+            if (this._eventListeners[eventName][id]) {
+                const arr = this._eventListeners[eventName][id];
+                emitterResult = emitterResult.concat(this._emitToArrayOfListeners(arr, data));
+            }
+            // Handle id wildcard emit if the id passed wasn't already a wildcard (*) id
+            if (id !== "*" && this._eventListeners[eventName]["*"]) {
+                const arr = this._eventListeners[eventName]["*"];
+                emitterResult = emitterResult.concat(this._emitToArrayOfListeners(arr, data));
+            }
         }
-        // Handle global emit if the id passed wasn't already a global (*) id
-        if (id !== "*" && this._eventListeners[eventName]["*"]) {
-            const arr = this._eventListeners[eventName]["*"];
-            emitterResult = emitterResult.concat(this._emitToArrayOfListeners(arr, data));
+        if (this._eventListeners["*"]) {
+            const arr = this._eventListeners["*"]["*"];
+            emitterResult = emitterResult.concat(this._emitToArrayOfListeners(arr, [eventName, ...data]));
         }
         this._eventsEmitting = false;
         this._processRemovalQueue();
         return emitterResult;
     }
     /**
-     * Creates a persistent emitter record that will fire a listener if
-     * one is added for this event after the emitStatic() call has been
-     * made.
+     * Creates a persistent event. Once emitStatic() has been called, a
+     * persistent event is registered. Any existing event listeners will
+     * be called just like when you call emit(), however, any new
+     * listeners that are registered for this event via on() will also be
+     * called as soon as they are added.
      * @param eventName The name of the event to emit.
      * @param {...any} data Optional arguments to emit with the event.
      * @returns The emitter instance.
@@ -309,7 +362,7 @@ class Emitter {
         this._eventListeners = this._eventListeners || {};
         this._eventsEmitting = true;
         if (this._eventListeners[eventName] && this._eventListeners[eventName][id]) {
-            // Handle global emit
+            // Handle id wildcard emit
             const arr = this._eventListeners[eventName][id];
             const arrCount = arr.length;
             for (let arrIndex = 0; arrIndex < arrCount; arrIndex++) {
@@ -358,7 +411,7 @@ class Emitter {
                     }
                 }
             }
-            // Handle global emit
+            // Handle wildcard emit
             if (this._eventListeners[eventName]["*"]) {
                 const arr = this._eventListeners[eventName]["*"];
                 const arrCount = arr.length;
@@ -437,7 +490,7 @@ class Emitter {
                 }
             }
         }
-        // Handle global emit
+        // Handle wildcard emit
         if (this._eventListeners[eventName]["*"]) {
             const arr = this._eventListeners[eventName]["*"];
             const arrCount = arr.length;
@@ -535,7 +588,9 @@ function makeEmitter(obj, prototypeMode) {
     }
     // Convert the object prototype to have eventing capability
     operateOnObject.on = Emitter.prototype.on;
+    operateOnObject.onAny = Emitter.prototype.onAny;
     operateOnObject.off = Emitter.prototype.off;
+    operateOnObject.offAny = Emitter.prototype.offAny;
     operateOnObject.once = Emitter.prototype.once;
     operateOnObject.emit = Emitter.prototype.emit;
     operateOnObject.emitId = Emitter.prototype.emitId;
@@ -548,4 +603,3 @@ function makeEmitter(obj, prototypeMode) {
     operateOnObject._processRemovalQueue = Emitter.prototype._processRemovalQueue;
     return obj;
 }
-exports.makeEmitter = makeEmitter;

package/dist/cjs/tests/Emitter.test.js

@@ -12,34 +12,36 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
 const assert_1 = __importDefault(require("assert"));
 const Emitter_1 = require("../src/Emitter");
 let expectedAssertions = 0;
 let actualAssertions = 0;
-function expect(val) {
+function expectAssertionCount(val) {
     expectedAssertions = val;
 }
-function reset() {
+function resetAssertionCount() {
     expectedAssertions = 0;
     actualAssertions = 0;
 }
 function countAssertion() {
     actualAssertions++;
 }
-function check() {
+function checkAssertionCount() {
     if (expectedAssertions === undefined || expectedAssertions === actualAssertions) {
         return;
     }
     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", () => {
             var _a, _b;
             const myClass = new Emitter_1.Emitter();
-            myClass.on("moo", () => { });
+            myClass.on("moo", () => {
+            });
             assert_1.default.strictEqual((_a = myClass._eventListeners) === null || _a === void 0 ? void 0 : _a.moo["*"].length, 1, "Listener registered on event");
             myClass.off("moo");
             assert_1.default.strictEqual(!((_b = myClass._eventListeners) === null || _b === void 0 ? void 0 : _b.moo) ||
@@ -48,12 +50,8 @@ describe("Emitter", () => {
         });
         it("Supports extending Emitter as a base class", () => {
             var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
-            let testFuncCount = 0;
             // Test extending Emitter and modifying base functionality
             class MyClass extends Emitter_1.Emitter {
-                testFunc() {
-                    testFuncCount++;
-                }
                 on(eventName, ...rest) {
                     const restTypes = rest.map((arg) => typeof arg);
                     if (restTypes[0] === "function") {
@@ -166,6 +164,7 @@ describe("Emitter", () => {
             yield Promise.all(emitter.emit("foo"));
             const delta = new Date().getTime() - time;
             assert_1.default.ok(delta > 900, "Delta was not correct, await may not have paused?");
+            assert_1.default.strictEqual(listenerFiredCount, 2, "Listener fire count was incorect");
         }));
         it("Supports awaiting async and non-async listener return data", () => __awaiter(void 0, void 0, void 0, function* () {
             const emitter = new Emitter_1.Emitter();
@@ -243,11 +242,15 @@ describe("Emitter", () => {
         it("Cancels all listeners (event)", () => {
             var _a, _b, _c, _d, _e, _f, _g;
             const myClass = new Emitter_1.Emitter();
-            const listener1 = () => { };
-            const listener2 = () => { };
-            myClass.on("moo", () => { });
+            const listener1 = () => {
+            };
+            const listener2 = () => {
+            };
+            myClass.on("moo", () => {
+            });
             assert_1.default.strictEqual((_a = myClass._eventListeners) === null || _a === void 0 ? void 0 : _a.moo["*"].length, 1, "Listeners registered on event");
-            myClass.on("moo", "testId", () => { });
+            myClass.on("moo", "testId", () => {
+            });
             assert_1.default.strictEqual((_b = myClass._eventListeners) === null || _b === void 0 ? void 0 : _b.moo["testId"].length, 1, "Listeners registered on event");
             myClass.on("moo", listener1);
             assert_1.default.strictEqual((_c = myClass._eventListeners) === null || _c === void 0 ? void 0 : _c.moo["*"].length, 2, "Listeners registered on event");
@@ -261,11 +264,15 @@ describe("Emitter", () => {
         it("Cancels id-based listeners (event, id)", () => {
             var _a, _b, _c, _d, _e, _f, _g;
             const myClass = new Emitter_1.Emitter();
-            const listener1 = () => { };
-            const listener2 = () => { };
-            myClass.on("moo", () => { });
+            const listener1 = () => {
+            };
+            const listener2 = () => {
+            };
+            myClass.on("moo", () => {
+            });
             assert_1.default.strictEqual((_a = myClass._eventListeners) === null || _a === void 0 ? void 0 : _a.moo["*"].length, 1, "Listeners registered on event");
-            myClass.on("moo", "testId", () => { });
+            myClass.on("moo", "testId", () => {
+            });
             assert_1.default.strictEqual((_b = myClass._eventListeners) === null || _b === void 0 ? void 0 : _b.moo["testId"].length, 1, "Listeners registered on event");
             myClass.on("moo", listener1);
             assert_1.default.strictEqual((_c = myClass._eventListeners) === null || _c === void 0 ? void 0 : _c.moo["*"].length, 2, "Listeners registered on event");
@@ -278,11 +285,15 @@ describe("Emitter", () => {
         it("Cancels listener-based listeners (event, listener)", () => {
             var _a, _b, _c, _d, _e, _f;
             const myClass = new Emitter_1.Emitter();
-            const listener1 = () => { };
-            const listener2 = () => { };
-            myClass.on("moo", () => { });
+            const listener1 = () => {
+            };
+            const listener2 = () => {
+            };
+            myClass.on("moo", () => {
+            });
             assert_1.default.strictEqual((_a = myClass._eventListeners) === null || _a === void 0 ? void 0 : _a.moo["*"].length, 1, "Listeners registered on event");
-            myClass.on("moo", "testId", () => { });
+            myClass.on("moo", "testId", () => {
+            });
             assert_1.default.strictEqual((_b = myClass._eventListeners) === null || _b === void 0 ? void 0 : _b.moo["testId"].length, 1, "Listeners registered on event");
             myClass.on("moo", listener1);
             assert_1.default.strictEqual((_c = myClass._eventListeners) === null || _c === void 0 ? void 0 : _c.moo["*"].length, 2, "Listeners registered on event");
@@ -295,11 +306,15 @@ describe("Emitter", () => {
         it("Cancels id-based + listener-based listeners (event, id, listener)", () => {
             var _a, _b, _c, _d, _e, _f;
             const myClass = new Emitter_1.Emitter();
-            const listener1 = () => { };
-            const listener2 = () => { };
-            myClass.on("moo", () => { });
+            const listener1 = () => {
+            };
+            const listener2 = () => {
+            };
+            myClass.on("moo", () => {
+            });
             assert_1.default.strictEqual((_a = myClass._eventListeners) === null || _a === void 0 ? void 0 : _a.moo["*"].length, 1, "Listeners registered on event");
-            myClass.on("moo", "testId", () => { });
+            myClass.on("moo", "testId", () => {
+            });
             assert_1.default.strictEqual((_b = myClass._eventListeners) === null || _b === void 0 ? void 0 : _b.moo["testId"].length, 1, "Listeners registered on event");
             myClass.on("moo", listener1);
             assert_1.default.strictEqual((_c = myClass._eventListeners) === null || _c === void 0 ? void 0 : _c.moo["*"].length, 2, "Listeners registered on event");
@@ -314,7 +329,7 @@ describe("Emitter", () => {
         it("Static emitter will emit when a new listener is added", (resolve) => {
             class MyClass extends Emitter_1.Emitter {
             }
-            expect(1);
+            expectAssertionCount(1);
             const myClass = new MyClass();
             myClass.emitStatic("moo");
             myClass.on("moo", () => {
@@ -328,7 +343,7 @@ describe("Emitter", () => {
         it("Removes static emitter", (resolve) => {
             class MyClass extends Emitter_1.Emitter {
             }
-            expect(1);
+            expectAssertionCount(1);
             const myClass = new MyClass();
             myClass.emitStatic("moo");
             myClass.on("moo", () => {
@@ -349,7 +364,7 @@ describe("Emitter", () => {
         it("Only fires the last listener added, cancelling all other listeners before it", (resolve) => {
             class MyClass extends Emitter_1.Emitter {
             }
-            expect(1);
+            expectAssertionCount(1);
             const myClass = new MyClass();
             myClass.on("moo", () => {
                 countAssertion();
@@ -371,7 +386,7 @@ describe("Emitter", () => {
         it("Only fires the last listener added (with id), cancelling all other listeners before it", (resolve) => {
             class MyClass extends Emitter_1.Emitter {
             }
-            expect(2);
+            expectAssertionCount(2);
             const myClass = new MyClass();
             // Define a listener without an id, this should not be overwritten
             myClass.on("moo", () => {
@@ -427,4 +442,36 @@ describe("Emitter", () => {
                 ((_k = myClass._eventListeners) === null || _k === void 0 ? void 0 : _k.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_1.Emitter();
+            const spy = globals_1.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_1.Emitter();
+            const spy = globals_1.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_1.Emitter();
+            const spy = globals_1.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_1.Emitter();
+            const spy = globals_1.jest.fn();
+            emitter.on("*", spy);
+            emitter.off("*", spy);
+            emitter.emit("someEvent", "someArg1", true, false);
+            expect(spy).toHaveBeenCalledTimes(0);
+        });
+    });
 });