@supercat1337/event-emitter 2.0.0 → 2.0.1

package/package.json

@@ -1,31 +1,57 @@
 {
     "name": "@supercat1337/event-emitter",
-    "version": "2.0.0",
-    "description": "Event Emitter",
+    "version": "2.0.1",
+    "description": "Lightweight typed event emitter with Symbol support, one-time listeners, and zero dependencies. Works in Node.js and browsers.",
     "main": "index.js",
+    "type": "module",
+    "exports": {
+        ".": "./index.js",
+        "./package.json": "./package.json"
+    },
+    "types": "./index.d.ts",
+    "files": [
+        "index.js",
+        "index.d.ts",
+        "src/**/*.js",
+        "src/**/*.d.ts"
+    ],
     "scripts": {
         "test": "c8 ava",
-        "create_types": "npm run remove_type_files && npx -p typescript tsc --project my.tsconfig.types.json",
-        "remove_type_files": "del /q *.d.ts *.d.ts.map && cd src && del /s /q *.d.ts *.d.ts.map && cd ../src && del /s /q *.d.ts *.d.ts.map && cd .."
+        "clean": "shx rm -f *.d.ts *.d.ts.map && shx rm -rf src/**/*.d.ts src/**/*.d.ts.map",
+        "build:types": "npm run clean && tsc --project my.tsconfig.types.json"
     },
-    "author": "Supercat",
+    "keywords": [
+        "event",
+        "emitter",
+        "eventemitter",
+        "event-emitter",
+        "typed",
+        "typescript",
+        "symbols",
+        "lightweight",
+        "tiny",
+        "zero-dependencies",
+        "browser",
+        "node",
+        "events",
+        "pubsub",
+        "observer"
+    ],
+    "author": "Albert Bazaleev",
     "license": "MIT",
     "devDependencies": {
+        "@types/node": "^20.12.2",
         "ava": "^6.1.2",
         "c8": "^9.1.0",
-        "@types/node": "^20.12.2"
+        "shx": "^0.4.0",
+        "typescript": "^5.4.3"
     },
-    "type": "module",
-    "keywords": [
-        "typed event emitter",
-        "typed event bus"
-    ],
     "publishConfig": {
         "registry": "https://registry.npmjs.org"
     },
     "homepage": "https://github.com/supercat1337/event-emitter",
     "repository": {
         "type": "git",
-        "url": "https://github.com/supercat1337/event-emitter.git"
+        "url": "git+https://github.com/supercat1337/event-emitter.git"
     }
 }

package/src/event-emitter-lite.d.ts

@@ -1,10 +1,10 @@
 export const ORIGINAL: unique symbol;
 /**
- * @template {string | Record<string, any[]>} [Events=string]
+ * @template {string | symbol | Record<string|symbol, any[]>} [Events=string]
  */
-export class EventEmitterLite<Events extends string | Record<string, any[]> = string> {
+export class EventEmitterLite<Events extends string | symbol | Record<string | symbol, any[]> = string> {
     /**
-     * @type {Object.<Events extends string ? Events : keyof Events, Function[]>}
+     * @type {Object.<Events extends string | symbol ? Events : keyof Events, Function[]>}
      */
     events: any;
     /**
@@ -14,39 +14,39 @@ export class EventEmitterLite<Events extends string | Record<string, any[]> = st
     logErrors: boolean;
     /**
      * on is used to add a callback function that's going to be executed when the event is triggered
-     * @template {Events extends string ? Events : keyof Events} K
+     * @template {Events extends string | symbol ? Events : keyof Events} K
      * @param {K} event
      * @param {Function} listener
      * @returns {() => void}
      */
-    on<K extends Events extends string ? Events : keyof Events>(event: K, listener: Function): () => void;
+    on<K extends Events extends string | symbol ? Events : keyof Events>(event: K, listener: Function): () => void;
     /**
      * Add a one-time listener
-     * @template {Events extends string ? Events : keyof Events} K
+     * @template {Events extends string | symbol ? Events : keyof Events} K
      * @param {K} event
      * @param {Function} listener
      * @returns {()=>void}
      */
-    once<K extends Events extends string ? Events : keyof Events>(event: K, listener: Function): () => void;
+    once<K extends Events extends string | symbol ? Events : keyof Events>(event: K, listener: Function): () => void;
     /**
      * off is an alias for removeListener
-     * @template {Events extends string ? Events : keyof Events} K
+     * @template {Events extends string | symbol ? Events : keyof Events} K
      * @param {K} event
      * @param {Function} listener
      */
-    off<K extends Events extends string ? Events : keyof Events>(event: K, listener: Function): void;
+    off<K extends Events extends string | symbol ? Events : keyof Events>(event: K, listener: Function): void;
     /**
      * Remove an event listener from an event
-     * @template {Events extends string ? Events : keyof Events} K
+     * @template {Events extends string | symbol ? Events : keyof Events} K
      * @param {K} event
      * @param {Function} listener
      */
-    removeListener<K extends Events extends string ? Events : keyof Events>(event: K, listener: Function): void;
+    removeListener<K extends Events extends string | symbol ? Events : keyof Events>(event: K, listener: Function): void;
     /**
      * emit is used to trigger an event
-     * @template {Events extends string ? Events : keyof Events} K
+     * @template {Events extends string | symbol ? Events : keyof Events} K
      * @param {K} event
      * @param {...any} args
      */
-    emit<K extends Events extends string ? Events : keyof Events>(event: K, ...args: any[]): void;
+    emit<K extends Events extends string | symbol ? Events : keyof Events>(event: K, ...args: any[]): void;
 }

package/src/event-emitter-lite.js

@@ -3,11 +3,11 @@
 export const ORIGINAL = Symbol('original');
 
 /**
- * @template {string | Record<string, any[]>} [Events=string]
+ * @template {string | symbol | Record<string|symbol, any[]>} [Events=string]
  */
 export class EventEmitterLite {
     /**
-     * @type {Object.<Events extends string ? Events : keyof Events, Function[]>}
+     * @type {Object.<Events extends string | symbol ? Events : keyof Events, Function[]>}
      */
     events = Object.create(null);
 
@@ -19,7 +19,7 @@ export class EventEmitterLite {
 
     /**
      * on is used to add a callback function that's going to be executed when the event is triggered
-     * @template {Events extends string ? Events : keyof Events} K
+     * @template {Events extends string | symbol ? Events : keyof Events} K
      * @param {K} event
      * @param {Function} listener
      * @returns {() => void}
@@ -34,7 +34,7 @@ export class EventEmitterLite {
 
     /**
      * Add a one-time listener
-     * @template {Events extends string ? Events : keyof Events} K
+     * @template {Events extends string | symbol ? Events : keyof Events} K
      * @param {K} event
      * @param {Function} listener
      * @returns {()=>void}
@@ -50,7 +50,7 @@ export class EventEmitterLite {
 
     /**
      * off is an alias for removeListener
-     * @template {Events extends string ? Events : keyof Events} K
+     * @template {Events extends string | symbol ? Events : keyof Events} K
      * @param {K} event
      * @param {Function} listener
      */
@@ -60,7 +60,7 @@ export class EventEmitterLite {
 
     /**
      * Remove an event listener from an event
-     * @template {Events extends string ? Events : keyof Events} K
+     * @template {Events extends string | symbol ? Events : keyof Events} K
      * @param {K} event
      * @param {Function} listener
      */
@@ -80,7 +80,7 @@ export class EventEmitterLite {
 
     /**
      * emit is used to trigger an event
-     * @template {Events extends string ? Events : keyof Events} K
+     * @template {Events extends string | symbol ? Events : keyof Events} K
      * @param {K} event
      * @param {...any} args
      */

package/src/event-emitter.d.ts

@@ -1,8 +1,8 @@
 /**
- * @template {string | Record<string, any[]>} [Events=string]
+ * @template {string | symbol | Record<string|symbol, any[]>} [Events=string]
  * @extends {EventEmitterLite<Events>}
  */
-export class EventEmitter<Events extends string | Record<string, any[]> = string> extends EventEmitterLite<Events> {
+export class EventEmitter<Events extends string | symbol | Record<string | symbol, any[]> = string> extends EventEmitterLite<Events> {
     /**
      * Is the event emitter destroyed?
      * @type {boolean}
@@ -10,20 +10,20 @@ export class EventEmitter<Events extends string | Record<string, any[]> = string
     get isDestroyed(): boolean;
     /**
      * Wait for a specific event to be emitted.
-     * @template {Events extends string ? Events : keyof Events} K
+     * @template {Events extends string | symbol? Events : keyof Events} K
      * @param {K} event - The event to wait for.
      * @param {number} [max_wait_ms=0] - Maximum time to wait in ms. If 0, waits indefinitely.
      * @returns {Promise<boolean>} - Resolves with true if event emitted, false on timeout.
      */
-    waitForEvent<K extends Events extends string ? Events : keyof Events>(event: K, max_wait_ms?: number): Promise<boolean>;
+    waitForEvent<K extends Events extends string | symbol ? Events : keyof Events>(event: K, max_wait_ms?: number): Promise<boolean>;
     /**
      * Wait for any of the specified events to be emitted.
-     * @template {Events extends string ? Events : keyof Events} K
+     * @template {Events extends string  | symbol? Events : keyof Events} K
      * @param {K[]} events - Array of event names.
      * @param {number} [max_wait_ms=0] - Maximum time to wait in ms.
      * @returns {Promise<boolean>} - Resolves with true if any event emitted, false on timeout.
      */
-    waitForAnyEvent<K extends Events extends string ? Events : keyof Events>(events: K[], max_wait_ms?: number): Promise<boolean>;
+    waitForAnyEvent<K extends Events extends string | symbol ? Events : keyof Events>(events: K[], max_wait_ms?: number): Promise<boolean>;
     /**
      * Clear all events
      */
@@ -34,10 +34,10 @@ export class EventEmitter<Events extends string | Record<string, any[]> = string
     destroy(): void;
     /**
      * Clears all listeners for a specified event.
-     * @template {Events extends string ? Events : keyof Events} K
+     * @template {Events extends string  | symbol? Events : keyof Events} K
      * @param {K} event
      */
-    clearEventListeners<K extends Events extends string ? Events : keyof Events>(event: K): void;
+    clearEventListeners<K extends Events extends string | symbol ? Events : keyof Events>(event: K): void;
     /**
      * onHasEventListeners() is used to 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.
      * @param {Function} callback

package/src/event-emitter.js

@@ -2,7 +2,7 @@
 import { EventEmitterLite } from './event-emitter-lite.js';
 
 /**
- * @template {string | Record<string, any[]>} [Events=string]
+ * @template {string | symbol | Record<string|symbol, any[]>} [Events=string]
  * @extends {EventEmitterLite<Events>}
  */
 export class EventEmitter extends EventEmitterLite {
@@ -26,7 +26,7 @@ export class EventEmitter extends EventEmitterLite {
 
     /**
      * on is used to add a callback function that's going to be executed when the event is triggered
-     * @template {Events extends string ? Events : keyof Events} K
+     * @template {Events extends string | symbol ? Events : keyof Events} K
      * @param {K} event
      * @param {Function} listener
      */
@@ -47,7 +47,7 @@ export class EventEmitter extends EventEmitterLite {
 
     /**
      * Remove an event listener from an event
-     * @template {Events extends string ? Events : keyof Events} K
+     * @template {Events extends string | symbol ? Events : keyof Events} K
      * @param {K} event
      * @param {Function} listener
      */
@@ -96,7 +96,7 @@ export class EventEmitter extends EventEmitterLite {
 
     /**
      * emit is used to trigger an event
-     * @template {Events extends string ? Events : keyof Events} K
+     * @template {Events extends string | symbol ? Events : keyof Events} K
      * @param {K} event
      * @param {...any} args
      */
@@ -157,7 +157,7 @@ export class EventEmitter extends EventEmitterLite {
 
     /**
      * Wait for a specific event to be emitted.
-     * @template {Events extends string ? Events : keyof Events} K
+     * @template {Events extends string | symbol? Events : keyof Events} K
      * @param {K} event - The event to wait for.
      * @param {number} [max_wait_ms=0] - Maximum time to wait in ms. If 0, waits indefinitely.
      * @returns {Promise<boolean>} - Resolves with true if event emitted, false on timeout.
@@ -168,7 +168,7 @@ export class EventEmitter extends EventEmitterLite {
 
     /**
      * Wait for any of the specified events to be emitted.
-     * @template {Events extends string ? Events : keyof Events} K
+     * @template {Events extends string  | symbol? Events : keyof Events} K
      * @param {K[]} events - Array of event names.
      * @param {number} [max_wait_ms=0] - Maximum time to wait in ms.
      * @returns {Promise<boolean>} - Resolves with true if any event emitted, false on timeout.
@@ -212,7 +212,7 @@ export class EventEmitter extends EventEmitterLite {
     clear() {
         if (this.#isDestroyed) return;
 
-        /** @type {(Events extends string ? Events : keyof Events)[]} */
+        /** @type {(Events extends string  | symbol? Events : keyof Events)[]} */
         // @ts-ignore
         const eventNames = Object.keys(this.events);
 
@@ -238,7 +238,7 @@ export class EventEmitter extends EventEmitterLite {
 
     /**
      * Clears all listeners for a specified event.
-     * @template {Events extends string ? Events : keyof Events} K
+     * @template {Events extends string  | symbol? Events : keyof Events} K
      * @param {K} event
      */
     clearEventListeners(event) {

package/.prettierrc

@@ -1,10 +0,0 @@
-{
-  "semi": true,
-  "tabWidth": 4,
-  "printWidth": 100,
-  "singleQuote": true,
-  "trailingComma": "es5",
-  "bracketSpacing": true,
-  "arrowParens": "avoid",
-  "endOfLine": "auto"
-}

package/jsconfig.json

@@ -1,12 +0,0 @@
-{
-  "compilerOptions": {
-    "baseUrl": ".",
-    "target": "ESNext",
-    "module": "NodeNext",
-    "noEmit": true,
-    "lib": ["ES2020", "es5", "es6", "dom", "dom.iterable"],
-    "moduleResolution": "NodeNext"
-  },
-  "exclude": ["node_modules"],
-  "include": ["index.js", "modules/**/*.d.ts"]
-}

package/my.tsconfig.types.json

@@ -1,19 +0,0 @@
-{
-    "compilerOptions": {
-        "allowJs": true,
-        "target": "ESNext",
-        "module": "NodeNext",
-        "emitDeclarationOnly": true,
-        "declaration": true, 
-        "outDir": "./",
-        "rootDir": ".",
-        "declarationMap": false,
-        "lib": ["ESNext", "DOM", "ES2023"],
-        "moduleResolution": "NodeNext",
-        "stripInternal": true
-    },
-    "include": [
-        "./index.js"
-    ],
-    "exclude": []
-}

package/tests/event-emitter-lite.test.js

@@ -1,256 +0,0 @@
-// @ts-check
-
-import ava from 'ava';
-import { EventEmitterLite } from '../src/event-emitter-lite.js'; 
-
-/** @typedef {{ emitter: EventEmitterLite }} MyContext */
-/** @typedef {import('ava').TestFn<MyContext>} TestFn */
-
-const test = /** @type {TestFn} */ (ava);
-
-test.beforeEach(t => {
-    t.context.emitter = new EventEmitterLite();
-});
-
-test('on() should add listener and emit should call it', t => {
-    const { emitter } = t.context;
-    let called = false;
-    emitter.on('test', () => {
-        called = true;
-    });
-    emitter.emit('test');
-    t.true(called);
-});
-
-test('emit() should pass arguments to listener', t => {
-    const { emitter } = t.context;
-    emitter.on(
-        'test',
-        /**  @param {number} a @param {string} b */ (a, b) => {
-            t.is(a, 1);
-            t.is(b, 'two');
-        }
-    );
-    emitter.emit('test', 1, 'two');
-});
-
-test('once() should call listener only once', t => {
-    const { emitter } = t.context;
-    let count = 0;
-    emitter.once('test', () => count++);
-    emitter.emit('test');
-    emitter.emit('test');
-    t.is(count, 1);
-});
-
-test('once() should be removable via off() with original listener', t => {
-    const { emitter } = t.context;
-    let count = 0;
-    function listener() {
-        count++;
-    }
-    emitter.once('test', listener);
-    emitter.off('test', listener); // remove listener
-    emitter.emit('test');
-    t.is(count, 0);
-});
-
-test('off() alias for removeListener should remove listener', t => {
-    const { emitter } = t.context;
-    let called = false;
-    const fn = () => {
-        called = true;
-    };
-    emitter.on('test', fn);
-    emitter.off('test', fn);
-    emitter.emit('test');
-    t.false(called);
-});
-
-test('removeListener() should remove listener added via on()', t => {
-    const { emitter } = t.context;
-    let called = false;
-    const fn = () => {
-        called = true;
-    };
-    emitter.on('test', fn);
-    emitter.removeListener('test', fn);
-    emitter.emit('test');
-    t.false(called);
-});
-
-test('unsubscriber returned by on() should remove listener', t => {
-    const { emitter } = t.context;
-    let called = false;
-    const unsub = emitter.on('test', () => {
-        called = true;
-    });
-    unsub();
-    emitter.emit('test');
-    t.false(called);
-});
-
-test('removeListener() should do nothing if listener not found', t => {
-    const { emitter } = t.context;
-    t.notThrows(() => {
-        emitter.removeListener('test', () => {});
-    });
-});
-
-test('emit() with no listeners should do nothing', t => {
-    const { emitter } = t.context;
-    t.notThrows(() => {
-        emitter.emit('test');
-    });
-});
-
-test('multiple listeners should all be called', t => {
-    const { emitter } = t.context;
-    let count = 0;
-    const inc = () => count++;
-    emitter.on('test', inc);
-    emitter.on('test', inc);
-    emitter.emit('test');
-    t.is(count, 2);
-});
-
-test('listeners should be called in order of addition', t => {
-    const { emitter } = t.context;
-    /** @type {number[]} */
-    const order = [];
-    emitter.on('test', () => order.push(1));
-    emitter.on('test', () => order.push(2));
-    emitter.emit('test');
-    t.deepEqual(order, [1, 2]);
-});
-
-test('removing listener during emit does not affect current iteration', t => {
-    const { emitter } = t.context;
-    let called = 0;
-    const fn1 = () => {
-        called++;
-        emitter.removeListener('test', fn2); // remove fn2
-    };
-    const fn2 = () => {
-        called++;
-    };
-    emitter.on('test', fn1);
-    emitter.on('test', fn2);
-    emitter.emit('test');
-    t.is(called, 2); // fn2 called twice
-});
-
-test('adding listener during emit does not affect current iteration', t => {
-    const { emitter } = t.context;
-    let called = 0;
-    const fn1 = () => {
-        emitter.on('test', () => called++);
-    };
-    emitter.on('test', fn1);
-    emitter.emit('test');
-    t.is(called, 0); // fn1 not called
-});
-
-test('logErrors: true should log to console', t => {
-    const { emitter } = t.context;
-    const originalError = console.error;
-    let logged = false;
-    console.error = (...args) => {
-        logged = true;
-    };
-    t.teardown(() => {
-        console.error = originalError;
-    });
-
-    emitter.logErrors = true;
-    emitter.on('test', () => {
-        throw new Error('boom');
-    });
-    t.notThrows(() => emitter.emit('test'));
-    t.true(logged);
-});
-
-test('logErrors: false should not log', t => {
-    const { emitter } = t.context;
-    const originalError = console.error;
-    let logged = false;
-    console.error = (...args) => {
-        logged = true;
-    };
-    t.teardown(() => {
-        console.error = originalError;
-    });
-
-    emitter.logErrors = false;
-    emitter.on('test', () => {
-        throw new Error('boom');
-    });
-    t.notThrows(() => emitter.emit('test'));
-    t.false(logged);
-});
-
-test('error in one listener does not prevent others', t => {
-    const { emitter } = t.context;
-    let called = false;
-    emitter.on('test', () => {
-        throw new Error('err');
-    });
-    emitter.on('test', () => {
-        called = true;
-    });
-    t.notThrows(() => emitter.emit('test'));
-    t.true(called);
-});
-
-test('this context in listener should be the emitter', t => {
-    const { emitter } = t.context;
-    emitter.on('test', function () {
-        // @ts-ignore
-        t.is(this, emitter);
-    });
-    emitter.emit('test');
-});
-
-test('event key is removed from events object when last listener removed', t => {
-    const { emitter } = t.context;
-    const fn = () => {};
-    emitter.on('test', fn);
-    t.true('test' in emitter.events); // or Object.prototype.hasOwnProperty.call(emitter.events, 'test')
-    emitter.removeListener('test', fn);
-    t.false('test' in emitter.events);
-});
-
-test('off with non-function listener should not throw', t => {
-    const { emitter } = t.context;
-    t.notThrows(() => {
-        // @ts-expect-error
-        emitter.off('test', 'not a function');
-    });
-});
-
-test('same listener added twice should be called twice', t => {
-    const { emitter } = t.context;
-    let count = 0;
-    function fn() {
-        count++;
-    }
-    emitter.on('test', fn);
-    emitter.on('test', fn);
-    emitter.emit('test');
-    t.is(count, 2);
-    emitter.off('test', fn);
-    emitter.emit('test');
-    t.is(count, 3);
-});
-
-test('once listener should be removable via off with original', t => {
-    const { emitter } = t.context;
-    let called = false;
-    function listener() {
-        called = true;
-    }
-    emitter.once('test', listener);
-    emitter.off('test', listener);
-    emitter.emit('test');
-    t.false(called);
-});

package/tests/event-emitter.test.js

@@ -1,471 +0,0 @@
-// @ts-check
-import ava from 'ava';
-import { EventEmitter } from '../src/event-emitter.js';
-
-/** @typedef {{ emitter: EventEmitter<any> }} MyContext */
-/** @typedef {import('ava').TestFn<MyContext>} TestFn */
-
-const test = /** @type {TestFn} */ (ava);
-
-test.beforeEach(t => {
-    t.context = { emitter: new EventEmitter() };
-});
-
-// ----------------------------------------------------------------------
-// Basic inheritance (quick check that Lite works)
-// ----------------------------------------------------------------------
-test('should inherit from EventEmitterLite: on and emit work', t => {
-    const { emitter } = t.context;
-    let called = false;
-    emitter.on('test', () => {
-        called = true;
-    });
-    emitter.emit('test');
-    t.true(called);
-});
-
-test('once works as expected', t => {
-    const { emitter } = t.context;
-    let count = 0;
-    emitter.once('test', () => count++);
-    emitter.emit('test');
-    emitter.emit('test');
-    t.is(count, 1);
-});
-
-test('off removes listener', t => {
-    const { emitter } = t.context;
-    let called = false;
-    const fn = () => {
-        called = true;
-    };
-    emitter.on('test', fn);
-    emitter.off('test', fn);
-    emitter.emit('test');
-    t.false(called);
-});
-
-// ----------------------------------------------------------------------
-// Internal events (#has-listeners, #no-listeners, #listener-error)
-// ----------------------------------------------------------------------
-test('#has-listeners emitted when first listener added', t => {
-    const { emitter } = t.context;
-    /** @type {string[]} */
-    const events = [];
-
-    emitter.onHasEventListeners(
-        /** @param {string} event */ event => {
-            events.push(event);
-        }
-    );
-
-    emitter.on('foo', () => {});
-    emitter.on('foo', () => {}); // second should not trigger
-    emitter.on('bar', () => {}); // should trigger for bar
-
-    t.deepEqual(events, ['foo', 'bar']);
-});
-
-test('#no-listeners emitted when last listener removed', t => {
-    const { emitter } = t.context;
-    /** @type {string[]} */
-    const events = [];
-
-    emitter.onNoEventListeners(
-        /** @param {string} event */ event => {
-            events.push(event);
-        }
-    );
-
-    const fn1 = () => {};
-    const fn2 = () => {};
-    const fnBar = () => {}; // keep reference for bar
-
-    emitter.on('foo', fn1);
-    emitter.on('foo', fn2);
-    emitter.on('bar', fnBar);
-
-    emitter.off('foo', fn1); // not last for foo yet
-    emitter.off('foo', fn2); // last for foo -> #no-listeners('foo')
-    emitter.off('bar', fnBar); // last for bar -> #no-listeners('bar')
-
-    t.deepEqual(events, ['foo', 'bar']);
-});
-
-test('#listener-error emitted when a listener throws', t => {
-    const { emitter } = t.context;
-    /** @type {Array<{ error: Error; event: string; args: any[] }>} */
-    const errors = [];
-
-    emitter.onListenerError(
-        /** @type {(error: Error, event: string, ...args: any[]) => void} */ (
-            error,
-            event,
-            ...args
-        ) => {
-            errors.push({ error, event, args });
-        }
-    );
-
-    emitter.on('fail', () => {
-        throw new Error('boom 1');
-    });
-    emitter.on(
-        'fail',
-        /** @type {(x: number) => void} */ x => {
-            throw new Error(`boom ${x}`);
-        }
-    );
-    emitter.emit('fail', 42);
-
-    t.is(errors.length, 2);
-    t.is(errors[0].error.message, 'boom 1');
-    t.is(errors[0].event, 'fail');
-    t.deepEqual(errors[0].args, [42]);
-
-    t.is(errors[1].error.message, 'boom 42');
-    t.is(errors[1].event, 'fail');
-    t.deepEqual(errors[1].args, [42]);
-});
-
-test('internal events do not trigger #has-listeners/#no-listeners for themselves', t => {
-    const { emitter } = t.context;
-    let hasCount = 0;
-    let noCount = 0;
-
-    emitter.onHasEventListeners(() => hasCount++);
-    emitter.onNoEventListeners(() => noCount++);
-
-    // Subscribing to internal events should not increase counters for 'has-listeners' etc.
-    emitter.onHasEventListeners(() => {});
-    emitter.onNoEventListeners(() => {});
-    emitter.onListenerError(() => {});
-
-    t.is(hasCount, 0);
-    t.is(noCount, 0);
-
-    // Adding a regular event should trigger
-    emitter.on('test', () => {});
-    t.is(hasCount, 1);
-
-    // Removing the last one should trigger no
-    emitter.off('test', () => {}); // but need to remove the same listener that was added
-    // For test purity, better to keep a reference
-});
-
-// ----------------------------------------------------------------------
-// waitForEvent / waitForAnyEvent
-// ----------------------------------------------------------------------
-test('waitForEvent resolves true when event emitted', async t => {
-    const { emitter } = t.context;
-    const promise = emitter.waitForEvent('ready');
-    emitter.emit('ready');
-    const result = await promise;
-    t.true(result);
-});
-
-test('waitForEvent resolves false on timeout', async t => {
-    const { emitter } = t.context;
-    const promise = emitter.waitForEvent('ready', 10);
-    const result = await promise;
-    t.false(result);
-});
-
-test('waitForAnyEvent resolves true when any event emitted', async t => {
-    const { emitter } = t.context;
-    const promise = emitter.waitForAnyEvent(['start', 'stop'], 100);
-    emitter.emit('stop');
-    const result = await promise;
-    t.true(result);
-});
-
-test('waitForAnyEvent resolves false on timeout', async t => {
-    const { emitter } = t.context;
-    const promise = emitter.waitForAnyEvent(['start', 'stop'], 10);
-    const result = await promise;
-    t.false(result);
-});
-
-test('waitForAnyEvent unsubscribes after first event', async t => {
-    const { emitter } = t.context;
-    let count = 0;
-    emitter.on('event1', () => count++);
-    emitter.on('event2', () => count++);
-
-    await emitter.waitForAnyEvent(['event1', 'event2'], 100);
-    emitter.emit('event1');
-    emitter.emit('event2');
-
-    t.is(count, 2); // both events should fire after waiting
-});
-
-test('waitForEvent throws if emitter destroyed', t => {
-    const { emitter } = t.context;
-    emitter.destroy();
-    t.throws(() => emitter.waitForEvent('test'), { message: /destroyed/ });
-});
-
-test('waitForAnyEvent throws if emitter destroyed', t => {
-    const { emitter } = t.context;
-    emitter.destroy();
-    t.throws(() => emitter.waitForAnyEvent(['test']), { message: /destroyed/ });
-});
-
-// ----------------------------------------------------------------------
-// destroy
-// ----------------------------------------------------------------------
-test('destroy sets isDestroyed = true and clears events', t => {
-    const { emitter } = t.context;
-    emitter.on('test', () => {});
-    t.false(emitter.isDestroyed);
-    emitter.destroy();
-    t.true(emitter.isDestroyed);
-    t.is(Object.keys(emitter.events).length, 0);
-
-    // After destroy, trying to subscribe to internal events should throw
-    t.throws(() => emitter.onHasEventListeners(() => {}), { message: /destroyed/ });
-    t.throws(() => emitter.onNoEventListeners(() => {}), { message: /destroyed/ });
-    t.throws(() => emitter.onListenerError(() => {}), { message: /destroyed/ });
-});
-
-test('after destroy, on throws', t => {
-    const { emitter } = t.context;
-    emitter.destroy();
-    t.throws(() => emitter.on('test', () => {}), { message: /destroyed/ });
-});
-
-test('after destroy, emit does nothing (no throw)', t => {
-    const { emitter } = t.context;
-    emitter.destroy();
-    t.notThrows(() => emitter.emit('test'));
-});
-
-test('after destroy, removeListener does nothing', t => {
-    const { emitter } = t.context;
-    emitter.destroy();
-    t.notThrows(() => emitter.removeListener('test', () => {}));
-});
-
-test('destroy can be called multiple times without error', t => {
-    const { emitter } = t.context;
-    emitter.destroy();
-    t.notThrows(() => emitter.destroy());
-});
-
-// ----------------------------------------------------------------------
-// clear and clearEventListeners
-// ----------------------------------------------------------------------
-test('clear removes all listeners and emits #no-listeners for each', t => {
-    const { emitter } = t.context;
-    /** @type {string[]} */
-    const noEvents = [];
-
-    emitter.onNoEventListeners(/** @param {string} event */ event => noEvents.push(event));
-    emitter.on('a', () => {});
-    emitter.on('b', () => {});
-    emitter.on('c', () => {});
-
-    emitter.clear();
-
-    t.deepEqual(noEvents.sort(), ['a', 'b', 'c']);
-    t.is(Object.keys(emitter.events).length, 0);
-});
-
-test('clearEventListeners removes all listeners for one event', t => {
-    const { emitter } = t.context;
-    let noCalled = false;
-
-    emitter.onNoEventListeners(
-        /** @param {string} event */ event => {
-            if (event === 'test') noCalled = true;
-        }
-    );
-
-    emitter.on('test', () => {});
-    emitter.on('test', () => {});
-    emitter.on('other', () => {});
-
-    emitter.clearEventListeners('test');
-
-    t.true(noCalled);
-    t.false('test' in emitter.events); // key removed
-    t.true('other' in emitter.events); // other remains
-    t.is(emitter.events['other'].length, 1);
-});
-
-// ----------------------------------------------------------------------
-// logErrors and interaction with #listener-error
-// ----------------------------------------------------------------------
-test('when logErrors is true, errors are logged and #listener-error emitted', t => {
-    const { emitter } = t.context;
-    const originalError = console.error;
-    /** @type {any[][]} */
-    const logged = [];
-    console.error = (...args) => logged.push(args);
-    t.teardown(() => {
-        console.error = originalError;
-    });
-
-    let internalErrorCaught = false;
-    emitter.onListenerError(() => {
-        internalErrorCaught = true;
-    });
-
-    emitter.logErrors = true;
-    emitter.on('boom', () => {
-        throw new Error('kaboom');
-    });
-    emitter.emit('boom');
-
-    t.true(internalErrorCaught);
-    t.true(logged.length > 0);
-    t.regex(logged[0][0], /Error in listener for event "boom"/);
-});
-
-test('when logErrors is false, errors are not logged but #listener-error still emitted', t => {
-    const { emitter } = t.context;
-    const originalError = console.error;
-    let logged = false;
-    console.error = () => (logged = true);
-    t.teardown(() => {
-        console.error = originalError;
-    });
-
-    let internalErrorCaught = false;
-    emitter.onListenerError(() => {
-        internalErrorCaught = true;
-    });
-
-    emitter.logErrors = false;
-    emitter.on('boom', () => {
-        throw new Error('kaboom');
-    });
-    emitter.emit('boom');
-
-    t.true(internalErrorCaught);
-    t.false(logged);
-});
-
-// ----------------------------------------------------------------------
-// Event key removal when no listeners (inherited from Lite)
-// ----------------------------------------------------------------------
-test('event key removed when last listener removed (inherited)', t => {
-    const { emitter } = t.context;
-    const fn = () => {};
-    emitter.on('test', fn);
-    t.true('test' in emitter.events);
-    emitter.removeListener('test', fn);
-    t.false('test' in emitter.events);
-});
-
-// ----------------------------------------------------------------------
-// Getter isDestroyed
-// ----------------------------------------------------------------------
-test('isDestroyed reflects destroyed state', t => {
-    const { emitter } = t.context;
-    t.false(emitter.isDestroyed);
-    emitter.destroy();
-    t.true(emitter.isDestroyed);
-});
-
-// test/event-emitter-extra.test.js (or add to existing file)
-
-// ----------------------------------------------------------------------
-// Additional tests to cover uncovered lines
-// ----------------------------------------------------------------------
-
-test('emit with no listeners should not throw and not call internal events', t => {
-    const { emitter } = t.context;
-    let internalErrorCalled = false;
-    emitter.onListenerError(() => {
-        internalErrorCalled = true;
-    });
-    t.notThrows(() => emitter.emit('nonexistent'));
-    t.false(internalErrorCalled); // covers line where listeners existence is checked
-});
-
-test('error in #listener-error handler does not cause infinite loop', t => {
-    const { emitter } = t.context;
-    const originalConsoleError = console.error;
-    let consoleCalled = false;
-    console.error = () => {
-        consoleCalled = true;
-    };
-    t.teardown(() => {
-        console.error = originalConsoleError;
-    });
-
-    // Subscriber to #listener-error itself throws
-    emitter.onListenerError(() => {
-        throw new Error('error in error handler');
-    });
-
-    // Regular listener that triggers #listener-error
-    emitter.on('boom', () => {
-        throw new Error('original error');
-    });
-
-    t.notThrows(() => emitter.emit('boom'));
-    t.true(consoleCalled); // critical error should be logged
-});
-
-test('waitForEvent with zero timeout waits indefinitely', async t => {
-    const { emitter } = t.context;
-    let resolved = false;
-    const promise = emitter.waitForEvent('ready', 0).then(() => {
-        resolved = true;
-    });
-
-    await new Promise(r => setTimeout(r, 50));
-    t.false(resolved); // not resolved yet
-
-    emitter.emit('ready');
-    await promise;
-    t.true(resolved);
-});
-
-test('waitForEvent with negative timeout waits indefinitely until event', async t => {
-    const { emitter } = t.context;
-    const promise = emitter.waitForEvent('ready', -10);
-    setTimeout(() => emitter.emit('ready'), 20);
-    const result = await promise;
-    t.true(result);
-});
-
-test('clearEventListeners on non-existent event does nothing', t => {
-    const { emitter } = t.context;
-    t.notThrows(() => emitter.clearEventListeners('absent'));
-    t.false('absent' in emitter.events);
-});
-
-test('calling destroy multiple times does nothing', t => {
-    const { emitter } = t.context;
-    emitter.destroy();
-    t.notThrows(() => emitter.destroy());
-    t.true(emitter.isDestroyed);
-});
-
-test('after destroy, onHasEventListeners throws', t => {
-    const { emitter } = t.context;
-    emitter.destroy();
-    t.throws(() => emitter.onHasEventListeners(() => {}), { message: /destroyed/ });
-});
-
-test('error in #listener-error handler does not cause infinite loop and flag resets', t => {
-    const { emitter } = t.context;
-    let calls = 0;
-
-    // Subscribe to #listener-error and throw
-    emitter.onListenerError(() => {
-        calls++;
-        throw new Error('error in error handler');
-    });
-
-    // Regular listener that triggers the first error
-    emitter.on('boom', () => {
-        throw new Error('original error');
-    });
-
-    t.notThrows(() => emitter.emit('boom'));
-    t.is(calls, 1); // #listener-error handler called once
-});