@irrelon/emitter 5.0.6 → 6.0.0

package/.eslintignore

@@ -1 +1,2 @@
-node_modules
+node_modules
+readme.md

package/.prettierignore

@@ -2,8 +2,9 @@ artifacts
 cache
 node_modules
 .next
-yarn.lock
 package-lock.json
 public
 .yarn
 .yarnrc
+.md
+readme.md

package/.prettierrc.yml

@@ -1,9 +1,26 @@
 trailingComma: "none"
 tabWidth: 4
-printWidth: 140
+printWidth: 120
 semi: true
 singleQuote: false
 arrowParens: always
 bracketSpacing: true
 bracketSameLine: false
 jsxSingleQuote: false
+plugins: ['@trivago/prettier-plugin-sort-imports']
+importOrder: [
+    "^react$",
+    "chakra-ui",
+    "<THIRD_PARTY_MODULES>",
+    "interface",
+    "context/",
+    "config",
+    "components/",
+    "utils/",
+    "services/",
+    "enums/",
+    "types/",
+    ".svg",
+    "^../(.*)$",
+    "(?=./styles.module.scss)",
+]

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

@@ -1,31 +1,31 @@
-export declare type AnyFunction<ReturnType = any> = (...args: any[]) => ReturnType;
-export declare type AnyConstructor = new (...args: any[]) => any;
-export declare enum EventReturnFlag {
-    none = 0,
-    cancel = 1
+export type AnyFunction<ReturnType = any> = (...args: any[]) => ReturnType;
+export type AnyConstructor = new (...args: any[]) => any;
+export declare enum ListenerReturnFlag {
+    none = "!+_NONE",
+    cancel = "!+_CANCEL"
 }
-export declare type EventListenerCallback<EventCallbackFunctionSignature extends AnyFunction = AnyFunction> = (...args: Parameters<EventCallbackFunctionSignature>) => ReturnType<EventCallbackFunctionSignature>;
+export type EventListenerCallback<EventCallbackFunctionSignature extends AnyFunction = AnyFunction> = (...args: Parameters<EventCallbackFunctionSignature>) => ReturnType<EventCallbackFunctionSignature>;
 export interface EventStaticEmitterObject<EventCallbackFunctionSignature extends AnyFunction = AnyFunction> {
     id: string;
     args: Parameters<EventCallbackFunctionSignature>;
 }
-export interface EmitterEventsInterface {
+export interface EmitterAnyEventsInterface {
     [key: string]: AnyFunction;
 }
-export declare type ConvertInterfaceToDict<T> = {
+export type EmitterEventsInterface<T> = {
     [K in keyof T]: T[K];
 };
 /**
  * Creates a new class with the capability to emit events.
  */
-export declare class Emitter<EventsInterface extends EmitterEventsInterface = EmitterEventsInterface> {
+export declare class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterface> = EmitterAnyEventsInterface> {
     _eventsEmitting: boolean;
     _eventRemovalQueue: any[];
     _eventListeners?: {
-        [EventName in (keyof EventsInterface)]?: Record<string, EventListenerCallback<EventsInterface[EventName]>[]>;
+        [EventName in keyof EventsInterface]?: Record<string, EventListenerCallback<EventsInterface[EventName]>[]>;
     };
     _eventStaticEmitters: {
-        [EventName in (keyof EventsInterface)]?: EventStaticEmitterObject<EventsInterface[EventName]>[];
+        [EventName in keyof EventsInterface]?: EventStaticEmitterObject<EventsInterface[EventName]>[];
     };
     _eventsAllowDefer: boolean;
     _eventsDeferTimeouts: Record<any, number>;
@@ -101,6 +101,7 @@ export declare class Emitter<EventsInterface extends EmitterEventsInterface = Em
     off<EventName extends keyof EventsInterface>(eventName: EventName, id: string, listener?: EventListenerCallback<EventsInterface[EventName]>): this;
     off<EventName extends keyof EventsInterface>(eventName: EventName, listener?: EventListenerCallback<EventsInterface[EventName]>): this;
     off<EventName extends keyof EventsInterface>(eventName: EventName): this;
+    _emitToArrayOfListeners<EventName extends keyof EventsInterface>(arr: EventListenerCallback<EventsInterface[EventName]>[], data: Parameters<EventsInterface[EventName]>): (ReturnType<EventsInterface[EventName]> | ListenerReturnFlag)[];
     /**
      * Emit an event by name.
      * @param eventName The name of the event to emit.
@@ -130,8 +131,8 @@ export declare class Emitter<EventsInterface extends EmitterEventsInterface = Em
      *     // The console output is:
      *     //    data1, data2
      */
-    emit<EventName extends keyof EventsInterface>(eventName: EventName, ...data: Parameters<EventsInterface[EventName]>): Promise<EventReturnFlag>;
-    emitId<EventName extends keyof EventsInterface>(eventName: EventName, id: string, ...data: Parameters<EventsInterface[EventName]>): EventReturnFlag;
+    emit<EventName extends keyof EventsInterface>(eventName: EventName, ...data: Parameters<EventsInterface[EventName]>): (ReturnType<EventsInterface[EventName]> | ListenerReturnFlag)[];
+    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
@@ -186,13 +187,19 @@ export declare class Emitter<EventsInterface extends EmitterEventsInterface = Em
      * @returns The emitter instance.
      */
     deferEmit<EventName extends keyof EventsInterface>(eventName: EventName, ...data: Parameters<EventsInterface[EventName]>): this;
+    /**
+     * Returns true if the result from an emit() call passed as the first
+     * argument contains a cancellation flag.
+     * @param resultArr
+     */
+    didCancel(resultArr: (unknown | ListenerReturnFlag)[]): boolean;
     /**
      * 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.
+     * errors that might occur by potentially mutating the event listener array
+     * while the emitter is running through them. This method is called after
+     * the event emitter is finished processing.
      * @private
      */
     _processRemovalQueue(): void;

package/dist/cjs/src/Emitter.js

@@ -1,20 +1,11 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeEmitter = exports.Emitter = exports.EventReturnFlag = void 0;
-var EventReturnFlag;
-(function (EventReturnFlag) {
-    EventReturnFlag[EventReturnFlag["none"] = 0] = "none";
-    EventReturnFlag[EventReturnFlag["cancel"] = 1] = "cancel";
-})(EventReturnFlag = exports.EventReturnFlag || (exports.EventReturnFlag = {}));
+exports.makeEmitter = exports.Emitter = exports.ListenerReturnFlag = void 0;
+var ListenerReturnFlag;
+(function (ListenerReturnFlag) {
+    ListenerReturnFlag["none"] = "!+_NONE";
+    ListenerReturnFlag["cancel"] = "!+_CANCEL";
+})(ListenerReturnFlag || (exports.ListenerReturnFlag = ListenerReturnFlag = {}));
 /**
  * Creates a new class with the capability to emit events.
  */
@@ -42,11 +33,13 @@ class Emitter {
             }, 1);
         };
         this._eventListeners = this._eventListeners || {};
-        const nonNullableEventListeners = this._eventListeners[eventName] = this._eventListeners[eventName] || {};
+        const nonNullableEventListeners = (this._eventListeners[eventName] = this._eventListeners[eventName] || {});
         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++) {
@@ -159,6 +152,24 @@ class Emitter {
         // Both id and listener were provided, remove for the specific id
         return this._off(eventName, rest[0], rest[1]);
     }
+    _emitToArrayOfListeners(arr, data) {
+        const arrCount = arr.length;
+        const resultArr = [];
+        for (let arrIndex = 0; arrIndex < arrCount; arrIndex++) {
+            // Check we have a function to execute
+            const tmpFunc = arr[arrIndex];
+            if (typeof tmpFunc !== "function") {
+                continue;
+            }
+            const eventListenerResponse = tmpFunc(...data);
+            resultArr.push(eventListenerResponse);
+            if (eventListenerResponse === ListenerReturnFlag.cancel) {
+                // Cancel further event processing
+                break;
+            }
+        }
+        return resultArr;
+    }
     /**
      * Emit an event by name.
      * @param eventName The name of the event to emit.
@@ -189,69 +200,27 @@ class Emitter {
      *     //    data1, data2
      */
     emit(eventName, ...data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this._eventListeners) {
-                return EventReturnFlag.none;
-            }
-            const id = "*";
-            let returnFlag = EventReturnFlag.none;
-            this._eventsEmitting = true;
-            if (this._eventListeners[eventName] && this._eventListeners[eventName][id]) {
-                // Handle global emit
-                const arr = this._eventListeners[eventName][id];
-                const promiseArr = arr.map((tmpFunc) => {
-                    if (typeof tmpFunc !== "function")
-                        return;
-                    return tmpFunc(...data);
-                });
-                const result = (yield Promise.all(promiseArr)).find((tmpResult) => tmpResult !== EventReturnFlag.none);
-                if (result) {
-                    returnFlag = EventReturnFlag.cancel;
-                }
-            }
-            this._eventsEmitting = false;
-            this._processRemovalQueue();
-            return returnFlag;
-        });
+        return this.emitId(eventName, "*", ...data);
     }
     emitId(eventName, id, ...data) {
-        if (!this._eventListeners) {
-            return EventReturnFlag.none;
+        if (!this._eventListeners || !this._eventListeners[eventName]) {
+            return [];
         }
-        this._eventListeners = this._eventListeners || {};
+        let emitterResult = [];
         this._eventsEmitting = true;
-        if (!this._eventListeners[eventName]) {
-            this._eventsEmitting = false;
-            this._processRemovalQueue();
-            return EventReturnFlag.none;
-        }
         // Handle id emit
         if (this._eventListeners[eventName][id]) {
             const arr = this._eventListeners[eventName][id];
-            const arrCount = arr.length;
-            for (let arrIndex = 0; arrIndex < arrCount; arrIndex++) {
-                // Check we have a function to execute
-                const tmpFunc = arr[arrIndex];
-                if (typeof tmpFunc === "function") {
-                    tmpFunc.call(this, ...data);
-                }
-            }
+            emitterResult = emitterResult.concat(this._emitToArrayOfListeners(arr, data));
         }
-        // Handle global emit
-        if (this._eventListeners[eventName]["*"]) {
+        // Handle global emit if the id passed wasn't already a global (*) id
+        if (id !== "*" && this._eventListeners[eventName]["*"]) {
             const arr = this._eventListeners[eventName]["*"];
-            const arrCount = arr.length;
-            for (let arrIndex = 0; arrIndex < arrCount; arrIndex++) {
-                // Check we have a function to execute
-                const tmpFunc = arr[arrIndex];
-                if (typeof tmpFunc === "function") {
-                    tmpFunc.call(this, ...data);
-                }
-            }
+            emitterResult = emitterResult.concat(this._emitToArrayOfListeners(arr, data));
         }
         this._eventsEmitting = false;
         this._processRemovalQueue();
-        return EventReturnFlag.none;
+        return emitterResult;
     }
     /**
      * Creates a persistent emitter record that will fire a listener if
@@ -282,8 +251,8 @@ class Emitter {
         this._eventStaticEmitters = this._eventStaticEmitters || {};
         this._eventStaticEmitters[eventName] = this._eventStaticEmitters[eventName] || [];
         this._eventStaticEmitters[eventName].push({
-            "id": "*",
-            "args": data
+            id: "*",
+            args: data
         });
         this._processRemovalQueue();
         return this;
@@ -334,7 +303,7 @@ class Emitter {
         this._eventStaticEmitters[eventName] = this._eventStaticEmitters[eventName] || [];
         this._eventStaticEmitters[eventName].push({
             id,
-            "args": data
+            args: data
         });
         this._processRemovalQueue();
         return this;
@@ -436,13 +405,21 @@ class Emitter {
         }
         return this;
     }
+    /**
+     * Returns true if the result from an emit() call passed as the first
+     * argument contains a cancellation flag.
+     * @param resultArr
+     */
+    didCancel(resultArr) {
+        return resultArr.findIndex((result) => result === ListenerReturnFlag.cancel) > -1;
+    }
     /**
      * 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.
+     * errors that might occur by potentially mutating the event listener array
+     * while the emitter is running through them. This method is called after
+     * the event emitter is finished processing.
      * @private
      */
     _processRemovalQueue() {

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

@@ -39,11 +39,12 @@ describe("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) || !myClass._eventListeners.moo["*"] || myClass._eventListeners.moo["*"].length, true, "Listeners all removed from event");
+            assert_1.default.strictEqual(!((_b = myClass._eventListeners) === null || _b === void 0 ? void 0 : _b.moo) ||
+                !myClass._eventListeners.moo["*"] ||
+                myClass._eventListeners.moo["*"].length, true, "Listeners all removed from event");
         });
         it("Supports extending Emitter as a base class", () => {
             var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
@@ -93,45 +94,54 @@ describe("Emitter", () => {
             myClass.emitId("moo", "testId", "foo");
             assert_1.default.strictEqual(emitCount, 1, "Event fired correctly");
             myClass.off("moo", "testId");
-            assert_1.default.strictEqual(!((_b = myClass._eventListeners) === null || _b === void 0 ? void 0 : _b.moo) || !((_c = myClass._eventListeners) === null || _c === void 0 ? void 0 : _c.moo["testId"]) || ((_d = myClass._eventListeners) === null || _d === void 0 ? void 0 : _d.moo["testId"].length) === 0, true, "Listeners all removed from event");
-            assert_1.default.strictEqual(((_e = myClass._eventListeners) === null || _e === void 0 ? void 0 : _e.moo) && ((_f = myClass._eventListeners) === null || _f === void 0 ? void 0 : _f.moo["^^noId"]) && ((_g = myClass._eventListeners) === null || _g === void 0 ? void 0 : _g.moo["^^noId"].length) === 1, true, "Global listener still there");
-            assert_1.default.strictEqual(!((_h = myClass._eventListeners) === null || _h === void 0 ? void 0 : _h.moo) || !((_j = myClass._eventListeners) === null || _j === void 0 ? void 0 : _j.moo["*"]) || ((_k = myClass._eventListeners) === null || _k === void 0 ? void 0 : _k.moo["*"].length) === 0, true, "Global listener still there");
+            assert_1.default.strictEqual(!((_b = myClass._eventListeners) === null || _b === void 0 ? void 0 : _b.moo) ||
+                !((_c = myClass._eventListeners) === null || _c === void 0 ? void 0 : _c.moo["testId"]) ||
+                ((_d = myClass._eventListeners) === null || _d === void 0 ? void 0 : _d.moo["testId"].length) === 0, true, "Listeners all removed from event");
+            assert_1.default.strictEqual(((_e = myClass._eventListeners) === null || _e === void 0 ? void 0 : _e.moo) &&
+                ((_f = myClass._eventListeners) === null || _f === void 0 ? void 0 : _f.moo["^^noId"]) &&
+                ((_g = myClass._eventListeners) === null || _g === void 0 ? void 0 : _g.moo["^^noId"].length) === 1, true, "Global listener still there");
+            assert_1.default.strictEqual(!((_h = myClass._eventListeners) === null || _h === void 0 ? void 0 : _h.moo) ||
+                !((_j = myClass._eventListeners) === null || _j === void 0 ? void 0 : _j.moo["*"]) ||
+                ((_k = myClass._eventListeners) === null || _k === void 0 ? void 0 : _k.moo["*"].length) === 0, true, "Global listener still there");
             myClass.off("moo");
-            assert_1.default.strictEqual(!((_l = myClass._eventListeners) === null || _l === void 0 ? void 0 : _l.moo) || !((_m = myClass._eventListeners) === null || _m === void 0 ? void 0 : _m.moo["*"]) || ((_o = myClass._eventListeners) === null || _o === void 0 ? void 0 : _o.moo["*"].length) === 0, true, "Listeners all removed from event");
+            assert_1.default.strictEqual(!((_l = myClass._eventListeners) === null || _l === void 0 ? void 0 : _l.moo) ||
+                !((_m = myClass._eventListeners) === null || _m === void 0 ? void 0 : _m.moo["*"]) ||
+                ((_o = myClass._eventListeners) === null || _o === void 0 ? void 0 : _o.moo["*"].length) === 0, true, "Listeners all removed from event");
         });
     });
     describe("emit()", () => {
         it("Supports type safe usage", () => __awaiter(void 0, void 0, void 0, function* () {
             const emitter = new Emitter_1.Emitter();
             let listenerFiredCount = 0;
-            emitter.on("person", (name, age, enabled) => __awaiter(void 0, void 0, void 0, function* () {
+            emitter.on("person", (name) => {
                 return new Promise((resolve) => {
                     setTimeout(() => {
                         listenerFiredCount++;
-                        resolve();
+                        resolve(name);
                     }, 1000);
                 });
-            }));
-            emitter.on("post", () => __awaiter(void 0, void 0, void 0, function* () {
+            });
+            emitter.on("post", () => {
                 return new Promise((resolve) => {
                     setTimeout(() => {
                         listenerFiredCount++;
                         resolve();
                     }, 1000);
                 });
-            }));
-            emitter.on("post", () => __awaiter(void 0, void 0, void 0, function* () {
+            });
+            emitter.on("post", () => {
                 return new Promise((resolve) => {
                     setTimeout(() => {
                         listenerFiredCount++;
                         resolve();
                     }, 1000);
                 });
-            }));
+            });
             const time = new Date().getTime();
-            yield emitter.emit("post");
+            yield Promise.all(emitter.emit("post"));
             const delta = new Date().getTime() - time;
             assert_1.default.ok(delta > 900, `Delta was not correct, await may not have paused? Delta was: ${delta}`);
+            assert_1.default.ok(listenerFiredCount === 2, `listenerFiredCount was not correct, await may not have paused? listenerFiredCount was: ${listenerFiredCount}`);
         }));
         it("Supports awaiting async listeners", () => __awaiter(void 0, void 0, void 0, function* () {
             const emitter = new Emitter_1.Emitter();
@@ -153,44 +163,86 @@ describe("Emitter", () => {
                 });
             }));
             const time = new Date().getTime();
-            yield emitter.emit("foo");
+            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?");
         }));
+        it("Supports awaiting async and non-async listener return data", () => __awaiter(void 0, void 0, void 0, function* () {
+            const emitter = new Emitter_1.Emitter();
+            let listenerFiredCount = 0;
+            emitter.on("foo", () => {
+                return new Promise((resolve) => {
+                    setTimeout(() => {
+                        listenerFiredCount++;
+                        resolve("Foo1 Return Value");
+                    }, 1000);
+                });
+            });
+            emitter.on("foo", () => {
+                return "Foo2 Return Value";
+            });
+            const time = new Date().getTime();
+            const results = 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.ok(listenerFiredCount === 1, "listenerFiredCount was not correct, await may not have been used?");
+            assert_1.default.strictEqual(results[0], "Foo1 Return Value", "Return data for foo1 was not correct");
+            assert_1.default.strictEqual(results[1], "Foo2 Return Value", "Return data for foo2 was not correct");
+        }));
+        it("Supports responding with a cancellation signal", () => __awaiter(void 0, void 0, void 0, function* () {
+            const emitter = new Emitter_1.Emitter();
+            let listenerFiredCount = 0;
+            emitter.on("foo", () => {
+                listenerFiredCount++;
+                return "Foo1 Return Value";
+            });
+            emitter.on("foo", () => {
+                listenerFiredCount++;
+                // This listener will respond with a cancellation, this should terminate further listener calls
+                return Emitter_1.ListenerReturnFlag.cancel;
+            });
+            emitter.on("foo", () => {
+                listenerFiredCount++;
+                return "Foo3 Return Value";
+            });
+            emitter.on("foo", () => {
+                listenerFiredCount++;
+                return "Foo4 Return Value";
+            });
+            const results = emitter.emit("foo");
+            assert_1.default.ok(listenerFiredCount === 2, "listenerFiredCount was not correct, await may not have been used?");
+            assert_1.default.strictEqual(results[0], "Foo1 Return Value", "Return data should be a cancel flag");
+            assert_1.default.strictEqual(results[1], Emitter_1.ListenerReturnFlag.cancel, "Return data should be a cancel flag");
+            assert_1.default.ok(emitter.didCancel(results), "didCancel should detect a cancel flag");
+        }));
     });
     describe("off()", () => {
         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");
             myClass.on("moo", "testId", listener2);
             assert_1.default.strictEqual((_d = myClass._eventListeners) === null || _d === void 0 ? void 0 : _d.moo["testId"].length, 2, "Listeners registered on event");
             myClass.off("moo");
-            assert_1.default.strictEqual(!((_e = myClass._eventListeners) === null || _e === void 0 ? void 0 : _e.moo) || (((_f = myClass._eventListeners) === null || _f === void 0 ? void 0 : _f.moo["*"].length) === 0 && ((_g = myClass._eventListeners) === null || _g === void 0 ? void 0 : _g.moo["testId"].length) === 0), true, "Listeners all removed from event");
+            assert_1.default.strictEqual(!((_e = myClass._eventListeners) === null || _e === void 0 ? void 0 : _e.moo) ||
+                (((_f = myClass._eventListeners) === null || _f === void 0 ? void 0 : _f.moo["*"].length) === 0 &&
+                    ((_g = myClass._eventListeners) === null || _g === void 0 ? void 0 : _g.moo["testId"].length) === 0), true, "Listeners all removed from event");
         });
         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");
@@ -203,15 +255,11 @@ 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");
@@ -224,15 +272,11 @@ 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");
@@ -348,10 +392,16 @@ describe("Emitter", () => {
             myClass.emitId("moo", "testId", "foo");
             assert_1.default.strictEqual(emitCount, 2, "Event fired correctly");
             myClass.off("moo", "testId");
-            assert_1.default.strictEqual(!((_b = myClass._eventListeners) === null || _b === void 0 ? void 0 : _b.moo) || !((_c = myClass._eventListeners) === null || _c === void 0 ? void 0 : _c.moo["testId"]) || ((_d = myClass._eventListeners) === null || _d === void 0 ? void 0 : _d.moo["testId"].length), true, "Listeners all removed from event");
-            assert_1.default.strictEqual(((_e = myClass._eventListeners) === null || _e === void 0 ? void 0 : _e.moo) && ((_f = myClass._eventListeners) === null || _f === void 0 ? void 0 : _f.moo["*"]) && ((_g = myClass._eventListeners) === null || _g === void 0 ? void 0 : _g.moo["*"].length) === 1, true, "Global listener still there");
+            assert_1.default.strictEqual(!((_b = myClass._eventListeners) === null || _b === void 0 ? void 0 : _b.moo) ||
+                !((_c = myClass._eventListeners) === null || _c === void 0 ? void 0 : _c.moo["testId"]) ||
+                ((_d = myClass._eventListeners) === null || _d === void 0 ? void 0 : _d.moo["testId"].length), true, "Listeners all removed from event");
+            assert_1.default.strictEqual(((_e = myClass._eventListeners) === null || _e === void 0 ? void 0 : _e.moo) &&
+                ((_f = myClass._eventListeners) === null || _f === void 0 ? void 0 : _f.moo["*"]) &&
+                ((_g = myClass._eventListeners) === null || _g === void 0 ? void 0 : _g.moo["*"].length) === 1, true, "Global listener still there");
             myClass.off("moo");
-            assert_1.default.strictEqual(!((_h = myClass._eventListeners) === null || _h === void 0 ? void 0 : _h.moo) || !((_j = myClass._eventListeners) === null || _j === void 0 ? void 0 : _j.moo["*"]) || ((_k = myClass._eventListeners) === null || _k === void 0 ? void 0 : _k.moo["*"].length) === 0, true, "Listeners all removed from event");
+            assert_1.default.strictEqual(!((_h = myClass._eventListeners) === null || _h === void 0 ? void 0 : _h.moo) ||
+                !((_j = myClass._eventListeners) === null || _j === void 0 ? void 0 : _j.moo["*"]) ||
+                ((_k = myClass._eventListeners) === null || _k === void 0 ? void 0 : _k.moo["*"].length) === 0, true, "Listeners all removed from event");
         });
     });
 });