EventEmitter realisation

lib/events.js

@@ -1,84 +1,129 @@
 'use strict';
 
 class EventEmitter {
-  constructor(options = {}) {
+  constructor() {
     this.events = new Map();
-    this.maxListeners = options.maxListeners || 10;
+    this.wrappers = new Map();
+    this.maxListenersCount = 10;
   }
 
-  emit(name, ...args) {
-    const listeners = this.events.get(name);
-    if (!listeners) return null;
-    const promises = listeners.map((fn) => fn(...args));
-    return Promise.all(promises);
+  listenerCount(eventName) {
+    if (!eventName) {
+      const listeners = [...this.events.values()];
+      return listeners.reduce((total, cur) => total + cur.size, 0);
+    }
+    const listeners = this.events.get(eventName);
+    return listeners ? listeners.size : 0;
   }
 
-  on(name, fn) {
-    const listeners = this.events.get(name);
-    if (!listeners) return void this.events.set(name, [fn]);
-    if (listeners.includes(fn)) {
-      console.warn(`Duplicate listeners detected: ${fn.name}`);
-    }
-    listeners.push(fn);
-    const tooManyListeners = listeners.size > this.maxListeners;
-    if (tooManyListeners) {
-      const name = 'MaxListenersExceededWarning';
-      const warn = 'Possible EventEmitter memory leak detected';
-      const max = `Current maxListenersCount is ${this.maxListeners}`;
-      const hint = 'Hint: avoid adding listeners in loops';
-      console.warn(`${name}: ${warn}. ${max}. ${hint}`);
-    }
+  on(eventName, listener) {
+    const { events, maxListenersCount } = this;
+    if (!events.has(eventName)) events.set(eventName, new Set());
+    const listeners = this.events.get(eventName);
+    listeners.add(listener);
+    if (listeners.size <= maxListenersCount) return;
+    const title = 'MaxListenersExceededWarning';
+    const warn = 'Possible EventEmitter memory leak detected';
+    const max = `Current maxListenersCount is ${maxListenersCount}`;
+    const hint = 'Hint: avoid adding listeners in loops';
+    console.warn(`${title}: ${warn}. ${max}. ${hint}`);
   }
 
-  once(name, fn) {
-    const dispose = (...args) => {
-      this.off(name, dispose);
-      return void fn(...args);
+  once(eventName, listener) {
+    const wrapper = (...args) => {
+      this.off(eventName, wrapper);
+      return listener(...args);
     };
-    this.on(name, dispose);
+    wrapper.origin = listener;
+    this.on(eventName, wrapper);
+    this.wrappers.set(listener, wrapper);
   }
 
-  off(name, fn) {
-    const listeners = this.events.get(name);
-    if (!listeners) return;
-    const index = listeners.indexOf(fn);
-    listeners.splice(index, 1);
-    if (listeners.length === 0) {
-      this.events.delete(name);
-    }
+  emit(eventName, ...args) {
+    const listeners = this.events.get(eventName);
+    if (!listeners) return Promise.resolve();
+    const promises = [...listeners].map((listener) => listener(...args));
+    return Promise.all(promises).then(() => {});
   }
 
-  toPromise(name) {
-    return new Promise((resolve) => {
-      this.once(name, resolve);
-    });
+  off(eventName, listener) {
+    if (!listener) return void this.clear(eventName);
+    const listeners = this.events.get(eventName);
+    if (!listeners) return;
+    listeners.delete(listener);
+    const wrapped = this.wrappers.get(listener);
+    if (wrapped) {
+      listeners.delete(wrapped);
+      this.wrappers.delete(listener);
+    }
+    if (listeners.size === 0) this.events.delete(eventName);
   }
 
-  toIterator(name) {
-    const stub = () => {};
-    this.events.on(name, stub);
-    return {
-      async next() {},
-    };
+  clear(eventName) {
+    const { events, wrappers } = this;
+    if (!eventName) {
+      events.clear();
+      return void wrappers.clear();
+    }
+    const listeners = events.get(eventName);
+    if (!listeners) return;
+    for (const listener of listeners) {
+      wrappers.delete(listener);
+    }
+    events.delete(eventName);
   }
 
-  clear(name) {
-    if (!name) return void this.events.clear();
-    this.events.delete(name);
+  toPromise(eventName, options = {}) {
+    const { signal = null } = options;
+    return new Promise((resolve, reject) => {
+      if (!signal) {
+        return void this.once(eventName, (...args) => void resolve(args));
+      }
+      let onAbort = null;
+      const onSuccess = (...args) => {
+        signal.removeEventListener('abort', onAbort);
+        resolve(args);
+      };
+      onAbort = () => {
+        this.off(eventName, onSuccess);
+        const message = 'The operatopn was aborted';
+        reject(new Error(message, { cause: signal.reason }));
+      };
+      this.once(eventName, onSuccess);
+      signal.addEventListener('abort', onAbort);
+    });
   }
 
-  listeners(name) {
-    return this.events.get(name) || [];
+  toIterator(eventName, options = {}) {
+    const { signal = null } = options;
+    const next = () => {
+      const promise = this.toPromise(eventName, { signal });
+      return promise.then((value) => ({ done: false, value }));
+    };
+    return { [Symbol.asyncIterator]: () => ({ next }) };
   }
 
-  listenerCount(name) {
-    const listeners = this.events.get(name);
-    if (listeners) return listeners.length;
-    return 0;
+  eventNames() {
+    return [...this.events.keys()];
   }
 
-  eventNames() {
-    return Array.from(this.events.keys());
+  listeners(eventName) {
+    const result = [];
+    if (!eventName) {
+      const eventNames = this.events.keys();
+      for (const name of eventNames) {
+        const fns = this.listeners(name);
+        result.push(...fns);
+      }
+      return result;
+    }
+    const listeners = this.events.get(eventName);
+    if (!listeners) return result;
+    for (const listener of listeners) {
+      const origin = listener.origin ?? listener;
+      result.push(origin);
+    }
+    return result;
   }
 }
 

metautil.d.ts

@@ -278,16 +278,22 @@ type Listener = (...args: unknown[]) => void;
 type EventName = string | symbol;
 
 export class EventEmitter {
-  maxListeners: number;
   constructor();
-  emit(eventName: EventName, ...args: unknown[]): Promise<void>;
+  getMaxListeners(): number;
+  listenerCount(eventName?: EventName): number;
   on(eventName: EventName, listener: Listener): void;
   once(eventName: EventName, listener: Listener): void;
+  emit(eventName: EventName, ...args: unknown[]): Promise<void>;
   off(eventName: EventName, listener?: Listener): void;
-  toPromise(eventName: EventName): Promise<unknown>;
-  toIterator(eventName: EventName): Iterator<unknown>;
   clear(eventName?: EventName): void;
-  listeners(eventName?: EventName): Listener[];
-  listenerCount(eventName?: EventName): number;
+  toPromise(
+    eventName: EventName,
+    options?: { signal: AbortSignal },
+  ): Promise<unknown>;
+  toIterator(
+    eventName: EventName,
+    options?: { singal: AbortSignal },
+  ): Iterator<unknown>;
   eventNames(): EventName[];
+  listeners(eventName?: EventName): Listener[];
 }