@supercat1337/event-emitter 1.0.10 → 1.0.11

package/README.md

@@ -1,92 +1,221 @@
-# event-emitter
+# @supercat1337/event-emitter 🐈⚡
 
-## Environment agnostic event emitter
+A modern, feature-rich EventEmitter implementation for JavaScript and TypeScript with advanced capabilities and excellent type safety.
 
-This package allows you to create an event emitter that can be used in any environment.
-You can define types for the events that you want to emit and listen to.
+## Features
 
-### Installation
-```
-$ npm install @supercat1337/event-emitter
+-   ✅ **Full TypeScript support** with generics and complete type definitions
+-   🎯 **Promise-based event waiting** with timeout support
+-   📊 **Listener lifecycle tracking** - know when events gain/lose listeners
+-   🛡️ **Memory safe** - automatic cleanup and unsubscribe functions
+-   ⚡ **High performance** - optimized for frequent events
+-   🔒 **Immutable patterns** - listener arrays are copied during emission
+-   🚀 **Modern ES2022+** - private fields, arrow functions, and more
+
+## Installation
+
+```bash
+npm install @supercat1337/event-emitter
 ```
 
-### Methods
- - on(event, listener) - Add a callback function that's going to be executed when the event is triggered. Returns a function that can be used to unsubscribe from the event
- - emit(event) - Trigger an event. 
- - once(event, listener) - Add a callback function that's going to be executed only once when the event is triggered. Returns a function that can be used to unsubscribe from the event
- - removeListener(event, listener) - Remove an event listener.
- - waitForEvent(event, max_wait_ms = 0) - Wait for an event to be emitted. If max_wait_ms is set to 0, the function will wait indefinitely.
- - waitForAnyEvent(events, max_wait_ms = 0) - Wait for any of the specified events to be emitted. If max_wait_ms is set to 0, the function will wait indefinitely.
- - clear() - Remove all event listeners
- - clearEventListeners(event) - Remove all listeners for a specified event
- - onHasEventListeners(callback) - Subscribe to the "#has-listeners" event. This event is emitted when the number of listeners for any event (except "#has-listeners" and "#no-listeners") goes from 0 to 1.
- - onNoEventListeners(callback) - Subscribe to the "#no-listeners" event. This event is emitted when the number of listeners for any event (except "#has-listeners" and "#no-listeners") goes from 1 to 0.
-
-### Usage
-
-Basic example
-```js
-import { EventEmitter } from "@supercat1337/event-emitter";
+## Quick Start
+
+```javascript
+import { EventEmitter } from '@supercat1337/event-emitter';
 
-// Create an event emitter with a custom event type
-/** @type {EventEmitter<"foo">} */
-var ev = new EventEmitter();
+// Define your event types
+type AppEvents = 'user:created' | 'user:deleted' | 'notification:sent';
 
-ev.on("foo", () => {
-    console.log("Hello!");
+const emitter = new EventEmitter<AppEvents>();
+
+// Subscribe to events
+const unsubscribe = emitter.on('user:created', (userData) => {
+    console.log('User created:', userData);
 });
 
-// IDE will complain if we emit an event that doesn't exist
-ev.emit("bar"); // $ExpectError
-ev.emit("foo");
+// Emit events
+emitter.emit('user:created', { id: 1, name: 'John' });
+
+// Unsubscribe when done
+unsubscribe();
 ```
 
-Example of unsubscribing from an event
-```js
-import { EventEmitter } from "@supercat1337/event-emitter";
+## API Reference
+
+### Core Methods
 
-/** @type {EventEmitter<"foo">} */
-var ev = new EventEmitter;
-var foo = 0
-var action = () => {
-    foo++;
-};
+#### `on(event, listener)`
 
-var unsubscriber = ev.on("foo", action);
+Subscribe to an event. Returns an unsubscribe function.
 
-ev.emit("foo");
-unsubscriber();
+```javascript
+const unsubscribe = emitter.on("user:created", (data) => {
+    console.log(data);
+});
+
+// Later...
+unsubscribe();
+```
 
-ev.emit("foo");
+#### `off(event, listener)`
 
-if (foo == 1) {
-    console.log("Success!");
-} else {
-    console.log("Fail!");
+Remove a specific listener from an event.
+
+```javascript
+function listener(data) {
+    /* ... */
 }
+emitter.on("user:created", listener);
+emitter.off("user:created", listener);
 ```
 
-Example of using the Once method
-```js
-import { EventEmitter } from "@supercat1337/event-emitter";
+#### `emit(event, ...args)`
+
+Emit an event with optional arguments.
+
+```javascript
+emitter.emit("user:created", { id: 1, name: "Alice" });
+```
+
+#### `once(event, listener)`
 
-/** @type {EventEmitter<"foo">} */
-var ev = new EventEmitter;
+Add a one-time listener that auto-removes after execution.
 
-var foo = 0
+```javascript
+emitter.once("app:ready", () => {
+    console.log("App is ready!");
+});
+```
+
+### Advanced Methods
+
+#### `waitForEvent(event, [maxWaitMs])`
+
+Wait for an event using Promises.
+
+```javascript
+// Wait indefinitely
+const result = await emitter.waitForEvent("data:loaded");
+
+// Wait with timeout (returns false if timeout reached)
+const success = await emitter.waitForEvent("data:loaded", 5000);
+```
+
+#### `waitForAnyEvent(events, [maxWaitMs])`
 
-ev.once("foo", () => {
-    foo++;
+Wait for any of multiple events.
+
+```javascript
+const events = ['success', 'error', 'timeout'] as const;
+const result = await emitter.waitForAnyEvent(events, 3000);
+```
+
+#### `onHasEventListeners(callback)`
+
+Get notified when any event gains its first listener.
+
+```javascript
+emitter.onHasEventListeners((eventName) => {
+    console.log(`Event ${eventName} now has listeners!`);
 });
+```
 
-ev.emit("foo");
-ev.emit("foo");
-ev.emit("foo");
+#### `onNoEventListeners(callback)`
 
-if (foo == 1) {
-    console.log("Success!");
-} else {
-    console.log("Fail!");
-}
+Get notified when any event loses its last listener.
+
+```javascript
+emitter.onNoEventListeners((eventName) => {
+    console.log(`Event ${eventName} has no more listeners!`);
+});
 ```
 
+### Lifecycle Management
+
+#### `destroy()`
+
+Completely destroy the emitter and clean up all resources.
+
+```javascript
+emitter.destroy();
+console.log(emitter.isDestroyed); // true
+```
+
+#### `clear()`
+
+Remove all listeners while keeping the emitter functional.
+
+```javascript
+emitter.clear();
+```
+
+#### `clearEventListeners(event)`
+
+Remove all listeners for a specific event.
+
+```javascript
+emitter.clearEventListeners("user:created");
+```
+
+## TypeScript Usage
+
+```typescript
+import { EventEmitter } from "@supercat1337/event-emitter";
+
+// Define your event types
+type MyEvents =
+    | "user:created"
+    | "user:updated"
+    | { type: "user:deleted"; payload: { id: string; reason: string } };
+
+const emitter = new EventEmitter<MyEvents>();
+
+// Full type safety!
+emitter.emit("user:created", { id: 1, name: "John" }); // ✅ Correct
+emitter.emit("user:created", "invalid"); // ❌ Type error
+```
+
+## Error Handling
+
+All listener errors are caught and logged to console, preventing emitter crashes:
+
+```javascript
+emitter.on("data:received", () => {
+    throw new Error("Something went wrong!");
+});
+
+// Error is caught and logged, emitter continues working
+emitter.emit("data:received");
+```
+
+## Performance Notes
+
+-   🔄 Listener arrays are copied before iteration to allow safe modification during emission
+-   ⚡ Event existence checks are optimized with direct property access
+-   🗑️ Automatic cleanup prevents memory leaks
+-   📏 No external dependencies
+
+## Browser Support
+
+| Feature    | Support         |
+| ---------- | --------------- |
+| ES2022+    | Modern browsers |
+| TypeScript | 4.0+            |
+| Node.js    | 14+             |
+
+## License
+
+MIT License - feel free to use in commercial projects.
+
+## Contributing
+
+Contributions welcome! Please ensure:
+
+-   ✅ All tests pass
+-   ✅ TypeScript types are maintained
+-   ✅ New features include tests
+-   ✅ Code follows existing style
+
+---
+
+**Made with ❤️ by [supercat1337](https://github.com/supercat1337)**

package/package.json

@@ -1,32 +1,32 @@
 {
-  "name": "@supercat1337/event-emitter",
-  "version": "1.0.10",
-  "description": "Event Emitter",
-  "main": "index.js",
-  "scripts": {
-    "test": "c8 ava",
-    "build": "npm run remove_type_files && npm run build_esm && npm run build_esm_min && npm run create_types",
-    "build_esm": "rollup ./src/index.js --file ./dist/event-emitter.esm.js --format es",
-    "build_esm_min": "esbuild --minify --bundle --platform=neutral --legal-comments=none ./src/index.js --outfile=./dist/event-emitter.esm.min.js",
-    "create_types": "npx -p typescript tsc --project my.tsconfig.types.json",
-    "remove_type_files": "del /q *.d.ts *.d.ts.map && cd dist && del /s /q *.d.ts *.d.ts.map && cd ../src && del /s /q *.d.ts *.d.ts.map && cd .."
+    "name": "@supercat1337/event-emitter",
+    "version": "1.0.11",
+    "description": "Event Emitter",
+    "main": "index.js",
+    "scripts": {
+        "test": "c8 ava",
+        "build": "npm run remove_type_files && npm run build_esm && npm run build_esm_min && npm run create_types",
+        "build_esm": "rollup ./src/index.js --file ./dist/event-emitter.esm.js --format es",
+        "build_esm_min": "esbuild --minify --bundle --platform=neutral --legal-comments=none ./src/index.js --outfile=./dist/event-emitter.esm.min.js",
+        "create_types": "npx -p typescript tsc --project my.tsconfig.types.json",
+        "remove_type_files": "del /q *.d.ts *.d.ts.map && cd dist && del /s /q *.d.ts *.d.ts.map && cd ../src && del /s /q *.d.ts *.d.ts.map && cd .."
     },
-  "author": "Supercat",
-  "license": "MIT",
-  "devDependencies": {
-    "ava": "^6.1.2",
-    "c8": "^9.1.0",
-    "esbuild": "^0.20.2",
-    "@types/node": "^20.12.2"
-  },
-  "type": "module",
-  "moduleResolution": "nodenext",
-  "keywords": [
-    "typed event emitter",
-    "typed event bus"
-  ],
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org"
-  },
-  "homepage": "https://github.com/supercat1337/event-emitter"
+    "author": "Supercat",
+    "license": "MIT",
+    "devDependencies": {
+        "ava": "^6.1.2",
+        "c8": "^9.1.0",
+        "esbuild": "^0.20.2",
+        "@types/node": "^20.12.2"
+    },
+    "type": "module",
+    "moduleResolution": "nodenext",
+    "keywords": [
+        "typed event emitter",
+        "typed event bus"
+    ],
+    "publishConfig": {
+        "registry": "https://registry.npmjs.org"
+    },
+    "homepage": "https://github.com/supercat1337/event-emitter"
 }

package/src/index.js

@@ -8,15 +8,31 @@ class EventEmitter {
     /** @type {Object.<string, Function[]>} */
     events = {};
 
+    /** @type {Object.<"#has-listeners"|"#no-listeners", Function[]>} */
+    #internalEvents = { "#has-listeners": [], "#no-listeners": [] };
+
+    #isDestroyed = false;
+
+    /**
+     * Is the event emitter destroyed?
+     * @type {boolean}
+     */
+    get isDestroyed() {
+        return this.#isDestroyed;
+    }
+
     /**
      * on is used to add a callback function that's going to be executed when the event is triggered
-     * @param {T|"#has-listeners"|"#no-listeners"} event
+     * @param {T} event
      * @param {Function} listener
      * @returns {()=>void}
      */
     on(event, listener) {
+        if (this.#isDestroyed) {
+            throw new Error("EventEmitter is destroyed");
+        }
 
-        if (typeof this.events[event] !== 'object') {
+        if (typeof this.events[event] !== "object") {
             this.events[event] = [];
         }
 
@@ -28,61 +44,141 @@ class EventEmitter {
             that.removeListener(event, listener);
         };
 
-        if (!/^(#has-listeners|#no-listeners)$/.test(event) && this.events[event].length == 1) { 
-            this.emit("#has-listeners", event);
+        if (this.events[event].length == 1) {
+            this.#emitInternal("#has-listeners", event);
         }
 
         return unsubscriber;
     }
+
+    /**
+     * Internal method to add a listener to an internal event
+     * @param {"#has-listeners"|"#no-listeners"} event
+     * @param {Function} listener
+     * @returns {()=>void}
+     */
+    #onInternalEvent(event, listener) {
+        if (typeof this.#internalEvents[event] !== "object") {
+            return;
+        }
+        this.#internalEvents[event].push(listener);
+
+        let that = this;
+
+        let unsubscriber = function () {
+            that.#removeInternalListener(event, listener);
+        };
+        return unsubscriber;
+    }
+
+    /**
+     * Internal method to remove a listener from an internal event
+     * @param {"#has-listeners"|"#no-listeners"} event
+     * @param {Function} listener
+     */
+    #removeInternalListener(event, listener) {
+        var idx;
+
+        if (typeof this.#internalEvents[event] === "object") {
+            idx = this.#internalEvents[event].indexOf(listener);
+
+            if (idx > -1) {
+                this.#internalEvents[event].splice(idx, 1);
+            }
+        }
+    }
+
+    /**
+     * off is an alias for removeListener
+     * @param {T} event
+     * @param {Function} listener
+     */
+    off(event, listener) {
+        return this.removeListener(event, listener);
+    }
+
     /**
      * Remove an event listener from an event
-     * @param {T|"#has-listeners"|"#no-listeners"} event
+     * @param {T} event
      * @param {Function} listener
      */
     removeListener(event, listener) {
+        if (this.#isDestroyed) {
+            return;
+        }
         var idx;
 
-        if (typeof this.events[event] === 'object') {
-            idx = this.events[event].indexOf(listener);
+        if (!this.events[event]) return;
+        idx = this.events[event].indexOf(listener);
 
-            if (idx > -1) {
-                this.events[event].splice(idx, 1);
+        if (idx > -1) {
+            this.events[event].splice(idx, 1);
 
-                if (!/^(#has-listeners|#no-listeners)$/.test(event) && this.events[event].length == 0) {
-                    this.emit("#no-listeners", event);
-                }
+            if (this.events[event].length == 0) {
+                this.#emitInternal("#no-listeners", event);
             }
         }
-
     }
+
     /**
      * emit is used to trigger an event
-     * @param {T|"#has-listeners"|"#no-listeners"} event
+     * @param {T} event
      */
     emit(event) {
-        if (typeof this.events[event] !== 'object') return;
+        if (this.#isDestroyed) {
+            return;
+        }
+
+        if (typeof this.events[event] !== "object") return;
 
-        var i, listeners, length, args = [].slice.call(arguments, 1);
+        var i,
+            listeners,
+            length,
+            args = [].slice.call(arguments, 1);
 
         listeners = this.events[event].slice();
         length = listeners.length;
 
         for (i = 0; i < length; i++) {
-
             try {
                 listeners[i].apply(this, args);
-            }
-            catch (e) {
+            } catch (e) {
                 console.error(event, args);
                 console.error(e);
             }
+        }
+    }
+
+    /**
+     * Internal function to emit an event
+     * @param {"#has-listeners"|"#no-listeners"} event
+     * @param {...any} args
+     */
+    #emitInternal(event, ...args) {
+        if (this.#isDestroyed) {
+            return;
+        }
 
+        if (typeof this.#internalEvents[event] !== "object") return;
+
+        var i, listeners, length;
+
+        listeners = this.#internalEvents[event].slice();
+        length = listeners.length;
+
+        for (i = 0; i < length; i++) {
+            try {
+                listeners[i].apply(this, args);
+            } catch (e) {
+                console.error(event, args);
+                console.error(e);
+            }
         }
     }
 
     /**
      * Add a one-time listener
-     * @param {T|"#has-listeners"|"#no-listeners"} event
+     * @param {T} event
      * @param {Function} listener
      * @returns {()=>void}
      */
@@ -93,7 +189,6 @@ class EventEmitter {
         });
     }
 
-
     /**
      * Wait for an event to be emitted
      * @param {T} event
@@ -101,12 +196,14 @@ class EventEmitter {
      * @returns {Promise<boolean>} - Resolves with true if the event was emitted, false if the time ran out.
      */
     waitForEvent(event, max_wait_ms = 0) {
+        if (this.#isDestroyed) {
+            throw new Error("EventEmitter is destroyed");
+        }
 
         return new Promise((resolve) => {
             let timeout;
 
             let unsubscriber = this.on(event, () => {
-
                 if (max_wait_ms > 0) {
                     clearTimeout(timeout);
                 }
@@ -120,13 +217,10 @@ class EventEmitter {
                     unsubscriber();
                     resolve(false);
                 }, max_wait_ms);
-
             }
-
         });
     }
 
-
     /**
      * Wait for any of the specified events to be emitted
      * @param {T[]} events - Array of event names to wait for
@@ -134,6 +228,9 @@ class EventEmitter {
      * @returns {Promise<boolean>} - Resolves with true if any event was emitted, false if the time ran out.
      */
     waitForAnyEvent(events, max_wait_ms = 0) {
+        if (this.#isDestroyed) {
+            throw new Error("EventEmitter is destroyed");
+        }
 
         return new Promise((resolve) => {
             let timeout;
@@ -162,9 +259,7 @@ class EventEmitter {
                     main_unsubscriber();
                     resolve(false);
                 }, max_wait_ms);
-
             }
-
         });
     }
 
@@ -180,12 +275,18 @@ class EventEmitter {
      * @alias clear
      */
     destroy() {
-        this.clear();
+        if (this.#isDestroyed) {
+            return;
+        }
+
+        this.#isDestroyed = true;
+        this.#internalEvents = { "#has-listeners": [], "#no-listeners": [] };
+        this.events = {};
     }
 
     /**
      * Clears all listeners for a specified event.
-     * @param {T|"#has-listeners"|"#no-listeners"} event - The event for which to clear all listeners.
+     * @param {T} event - The event for which to clear all listeners.
      */
     clearEventListeners(event) {
         let listeners = this.events[event] || [];
@@ -193,7 +294,7 @@ class EventEmitter {
 
         if (listenersCount > 0) {
             this.events[event] = [];
-            this.emit("#no-listeners", event);
+            this.#emitInternal("#no-listeners", event);
         }
     }
 
@@ -203,7 +304,10 @@ class EventEmitter {
      * @returns {()=>void}
      */
     onHasEventListeners(callback) {
-        return this.on("#has-listeners", callback);
+        if (this.#isDestroyed) {
+            throw new Error("EventEmitter is destroyed");
+        }
+        return this.#onInternalEvent("#has-listeners", callback);
     }
 
     /**
@@ -212,7 +316,10 @@ class EventEmitter {
      * @returns {()=>void}
      */
     onNoEventListeners(callback) {
-        return this.on("#no-listeners", callback);
+        if (this.#isDestroyed) {
+            throw new Error("EventEmitter is destroyed");
+        }
+        return this.#onInternalEvent("#no-listeners", callback);
     }
 }
 

package/tests/test.js

@@ -4,23 +4,21 @@
 import { EventEmitter } from "./../src/index.js";
 import test from "./../node_modules/ava/entrypoints/main.mjs";
 
-
-test("on(), emit()", t => {
+test("on(), emit()", (t) => {
     /** @type {EventEmitter<"foo"|"bar">} */
-    let ev = new EventEmitter;
+    let ev = new EventEmitter();
     ev.on("foo", () => {
         t.pass();
     });
 
     ev.emit("bar");
     ev.emit("foo");
-
 });
 
-test("once(), emit()", t => {
+test("once(), emit()", (t) => {
     /** @type {EventEmitter<"foo">} */
-    let ev = new EventEmitter;
-    let foo = 0
+    let ev = new EventEmitter();
+    let foo = 0;
     ev.once("foo", () => {
         foo++;
     });
@@ -32,14 +30,14 @@ test("once(), emit()", t => {
     if (foo == 1) {
         t.pass();
     } else {
-        t.fail()
+        t.fail();
     }
 });
 
-test("removeListener()", t => {
+test("removeListener()", (t) => {
     /** @type {EventEmitter<"foo">} */
-    let ev = new EventEmitter;
-    let foo = 0
+    let ev = new EventEmitter();
+    let foo = 0;
     let action = () => {
         foo++;
     };
@@ -53,21 +51,20 @@ test("removeListener()", t => {
     if (foo == 0) {
         t.pass();
     } else {
-        t.fail()
+        t.fail();
     }
 });
 
-test("Call unsubscriber", t => {
+test("Call unsubscriber", (t) => {
     /** @type {EventEmitter<"foo">} */
-    let ev = new EventEmitter;
-    let foo = 0
+    let ev = new EventEmitter();
+    let foo = 0;
     let action = () => {
         foo++;
     };
 
     let unsubscriber = ev.on("foo", action);
 
-
     ev.emit("foo");
     unsubscriber();
 
@@ -76,23 +73,22 @@ test("Call unsubscriber", t => {
     if (foo == 1) {
         t.pass();
     } else {
-        t.fail()
+        t.fail();
     }
 });
 
-
-test("on(), emit() with error", t => {
+test("on(), emit() with error", (t) => {
     /** @type {EventEmitter<"foo">} */
-    let ev = new EventEmitter;
+    let ev = new EventEmitter();
     let foo = 0;
 
     /**
-     * 
-     * @param {number} bar 
+     *
+     * @param {number} bar
      */
     function func(bar) {
         if (bar % 2) {
-            throw new Error("Custom error")
+            throw new Error("Custom error");
         } else {
             foo++;
         }
@@ -109,15 +105,14 @@ test("on(), emit() with error", t => {
     if (foo == 1) {
         t.pass();
     } else {
-        t.fail()
+        t.fail();
     }
-
 });
 
-test("waitForEvent()", async t => {
+test("waitForEvent()", async (t) => {
     /** @type {EventEmitter<"foo">} */
-    let ev = new EventEmitter;
-    let foo = 0
+    let ev = new EventEmitter();
+    let foo = 0;
     let action = () => {
         foo++;
     };
@@ -132,14 +127,14 @@ test("waitForEvent()", async t => {
     if (foo == 1) {
         t.pass();
     } else {
-        t.fail()
+        t.fail();
     }
 });
 
-test("waitForEvent() with timeout  and no event", async t => {
+test("waitForEvent() with timeout  and no event", async (t) => {
     /** @type {EventEmitter<"foo">} */
-    let ev = new EventEmitter;
-    let foo = 0
+    let ev = new EventEmitter();
+    let foo = 0;
     let action = () => {
         foo++;
     };
@@ -154,15 +149,14 @@ test("waitForEvent() with timeout  and no event", async t => {
     if (foo == 0) {
         t.pass();
     } else {
-        t.fail()
+        t.fail();
     }
 });
 
-
-test("waitForEvent() with timeout", async t => {
+test("waitForEvent() with timeout", async (t) => {
     /** @type {EventEmitter<"foo">} */
-    let ev = new EventEmitter;
-    let foo = 0
+    let ev = new EventEmitter();
+    let foo = 0;
     let action = () => {
         foo++;
     };
@@ -177,14 +171,13 @@ test("waitForEvent() with timeout", async t => {
     if (foo == 1) {
         t.pass();
     } else {
-        t.fail()
+        t.fail();
     }
 });
 
-
-test("waitForAnyEvent()", async t => {
+test("waitForAnyEvent()", async (t) => {
     /** @type {EventEmitter<"foo"|"bar">} */
-    let ev = new EventEmitter;
+    let ev = new EventEmitter();
     let foo = 0;
     let bar = 0;
 
@@ -207,18 +200,17 @@ test("waitForAnyEvent()", async t => {
     }, 10);
 
     await ev.waitForAnyEvent(["foo", "bar"]);
-    
+
     if (foo == 1 && bar == 1) {
         t.pass();
     } else {
-        t.fail()
+        t.fail();
     }
 });
 
-
-test("waitForAnyEvent() with timeout and no event", async t => {
+test("waitForAnyEvent() with timeout and no event", async (t) => {
     /** @type {EventEmitter<"foo"|"bar">} */
-    let ev = new EventEmitter;
+    let ev = new EventEmitter();
     let foo = 0;
     let bar = 0;
 
@@ -243,13 +235,13 @@ test("waitForAnyEvent() with timeout and no event", async t => {
     if (foo == 1 && bar == 0) {
         t.pass();
     } else {
-        t.fail()
+        t.fail();
     }
 });
 
-test("waitForAnyEvent() with timeout", async t => {
+test("waitForAnyEvent() with timeout", async (t) => {
     /** @type {EventEmitter<"foo"|"bar">} */
-    let ev = new EventEmitter;
+    let ev = new EventEmitter();
     let foo = 0;
     let bar = 0;
 
@@ -266,17 +258,17 @@ test("waitForAnyEvent() with timeout", async t => {
     }, 200);
 
     await ev.waitForAnyEvent(["foo", "bar"], 50);
-    
+
     if (foo == 0 && bar == 0) {
         t.pass();
     } else {
-        t.fail()
+        t.fail();
     }
 });
 
-test("clearEventListeners()", t => {
+test("clearEventListeners()", (t) => {
     /** @type {EventEmitter<"foo"|"bar">} */
-    let ev = new EventEmitter;
+    let ev = new EventEmitter();
     let foo = 0;
 
     ev.on("foo", () => {
@@ -293,12 +285,11 @@ test("clearEventListeners()", t => {
     ev.emit("foo");
 
     t.is(foo, 1);
-}
-);
+});
 
-test("destroy()", t => {
+test("destroy()", (t) => {
     /** @type {EventEmitter<"foo">} */
-    let ev = new EventEmitter;
+    let ev = new EventEmitter();
     let foo = 0;
 
     ev.on("foo", () => {
@@ -315,8 +306,8 @@ test("destroy()", t => {
 
     ev.destroy();
 
-    ev.on("foo", () => {
-
+    t.throws(() => {
+        ev.on("foo", () => {});
     });
 
     ev.emit("foo");
@@ -325,4 +316,3 @@ test("destroy()", t => {
 
     t.is(foo, 0);
 });
-