import { validateIntegerRange } from "./util.ts";import { assert } from "../_util/assert.ts";
export interface WrappedFunction extends Function { listener: Function;}
export default class EventEmitter { public static defaultMaxListeners = 10; public static errorMonitor = Symbol("events.errorMonitor"); private maxListeners: number | undefined; private _events: Map<string | symbol, Array<Function | WrappedFunction>>;
public constructor() { this._events = new Map(); }
private _addListener( eventName: string | symbol, listener: Function | WrappedFunction, prepend: boolean, ): this { this.emit("newListener", eventName, listener); if (this._events.has(eventName)) { const listeners = this._events.get(eventName) as Array< Function | WrappedFunction >; if (prepend) { listeners.unshift(listener); } else { listeners.push(listener); } } else { this._events.set(eventName, [listener]); } const max = this.getMaxListeners(); if (max > 0 && this.listenerCount(eventName) > max) { const warning = new Error( `Possible EventEmitter memory leak detected. ${this.listenerCount(eventName)} ${eventName.toString()} listeners. Use emitter.setMaxListeners() to increase limit`, ); warning.name = "MaxListenersExceededWarning"; console.warn(warning); }
return this; }
public addListener( eventName: string | symbol, listener: Function | WrappedFunction, ): this { return this._addListener(eventName, listener, false); }
public emit(eventName: string | symbol, ...args: any[]): boolean { if (this._events.has(eventName)) { if ( eventName === "error" && this._events.get(EventEmitter.errorMonitor) ) { this.emit(EventEmitter.errorMonitor, ...args); } const listeners = (this._events.get(eventName) as Function[]).slice(); for (const listener of listeners) { try { listener.apply(this, args); } catch (err) { this.emit("error", err); } } return true; } else if (eventName === "error") { if (this._events.get(EventEmitter.errorMonitor)) { this.emit(EventEmitter.errorMonitor, ...args); } const errMsg = args.length > 0 ? args[0] : Error("Unhandled error."); throw errMsg; } return false; }
public eventNames(): [string | symbol] { return Array.from(this._events.keys()) as [string | symbol]; }
public getMaxListeners(): number { return this.maxListeners || EventEmitter.defaultMaxListeners; }
public listenerCount(eventName: string | symbol): number { if (this._events.has(eventName)) { return (this._events.get(eventName) as Function[]).length; } else { return 0; } }
private _listeners( target: EventEmitter, eventName: string | symbol, unwrap: boolean, ): Function[] { if (!target._events.has(eventName)) { return []; } const eventListeners: Function[] = target._events.get( eventName, ) as Function[];
return unwrap ? this.unwrapListeners(eventListeners) : eventListeners.slice(0); }
private unwrapListeners(arr: Function[]): Function[] { const unwrappedListeners: Function[] = new Array(arr.length) as Function[]; for (let i = 0; i < arr.length; i++) { unwrappedListeners[i] = (arr[i] as any)["listener"] || arr[i]; } return unwrappedListeners; }
public listeners(eventName: string | symbol): Function[] { return this._listeners(this, eventName, true); }
public rawListeners( eventName: string | symbol, ): Array<Function | WrappedFunction> { return this._listeners(this, eventName, false); }
public off(eventName: string | symbol, listener: Function): this { return this.removeListener(eventName, listener); }
public on( eventName: string | symbol, listener: Function | WrappedFunction, ): this { return this.addListener(eventName, listener); }
public once(eventName: string | symbol, listener: Function): this { const wrapped: WrappedFunction = this.onceWrap(eventName, listener); this.on(eventName, wrapped); return this; }
private onceWrap( eventName: string | symbol, listener: Function, ): WrappedFunction { const wrapper = function ( this: { eventName: string | symbol; listener: Function; rawListener: Function; context: EventEmitter; }, ...args: any[] ): void { this.context.removeListener(this.eventName, this.rawListener); this.listener.apply(this.context, args); }; const wrapperContext = { eventName: eventName, listener: listener, rawListener: (wrapper as unknown) as WrappedFunction, context: this, }; const wrapped = (wrapper.bind( wrapperContext, ) as unknown) as WrappedFunction; wrapperContext.rawListener = wrapped; wrapped.listener = listener; return wrapped as WrappedFunction; }
public prependListener( eventName: string | symbol, listener: Function | WrappedFunction, ): this { return this._addListener(eventName, listener, true); }
public prependOnceListener( eventName: string | symbol, listener: Function, ): this { const wrapped: WrappedFunction = this.onceWrap(eventName, listener); this.prependListener(eventName, wrapped); return this; }
public removeAllListeners(eventName?: string | symbol): this { if (this._events === undefined) { return this; }
if (eventName) { if (this._events.has(eventName)) { const listeners = (this._events.get(eventName) as Array< Function | WrappedFunction >).slice(); this._events.delete(eventName); for (const listener of listeners) { this.emit("removeListener", eventName, listener); } } } else { const eventList: [string | symbol] = this.eventNames(); eventList.map((value: string | symbol) => { this.removeAllListeners(value); }); }
return this; }
public removeListener(eventName: string | symbol, listener: Function): this { if (this._events.has(eventName)) { const arr: | Array<Function | WrappedFunction> | undefined = this._events.get(eventName);
assert(arr);
let listenerIndex = -1; for (let i = arr.length - 1; i >= 0; i--) { if ( arr[i] == listener || (arr[i] && (arr[i] as WrappedFunction)["listener"] == listener) ) { listenerIndex = i; break; } }
if (listenerIndex >= 0) { arr.splice(listenerIndex, 1); this.emit("removeListener", eventName, listener); if (arr.length === 0) { this._events.delete(eventName); } } } return this; }
public setMaxListeners(n: number): this { validateIntegerRange(n, "maxListeners", 0); this.maxListeners = n; return this; }}
export { EventEmitter };
export function once( emitter: EventEmitter | EventTarget, name: string, ): Promise<any[]> { return new Promise((resolve, reject) => { if (emitter instanceof EventTarget) { emitter.addEventListener( name, (...args) => { resolve(args); }, { once: true, passive: false, capture: false }, ); return; } else if (emitter instanceof EventEmitter) { const eventListener = (...args: any[]): void => { if (errorListener !== undefined) { emitter.removeListener("error", errorListener); } resolve(args); }; let errorListener: Function;
if (name !== "error") { errorListener = (err: any): void => { emitter.removeListener(name, eventListener); reject(err); };
emitter.once("error", errorListener); }
emitter.once(name, eventListener); return; } });}
function createIterResult(value: any, done: boolean): IteratorResult<any> { return { value, done };}
interface AsyncInterable { next(): Promise<IteratorResult<any, any>>; return(): Promise<IteratorResult<any, any>>; throw(err: Error): void; [Symbol.asyncIterator](): any;}
export function on( emitter: EventEmitter, event: string | symbol,): AsyncInterable { const unconsumedEventValues: any[] = []; const unconsumedPromises: any[] = []; let error: Error | null = null; let finished = false;
const iterator = { next(): Promise<IteratorResult<any>> { const value: any = unconsumedEventValues.shift(); if (value) { return Promise.resolve(createIterResult(value, false)); }
if (error) { const p: Promise<never> = Promise.reject(error); error = null; return p; }
if (finished) { return Promise.resolve(createIterResult(undefined, true)); }
return new Promise(function (resolve, reject) { unconsumedPromises.push({ resolve, reject }); }); },
return(): Promise<IteratorResult<any>> { emitter.removeListener(event, eventHandler); emitter.removeListener("error", errorHandler); finished = true;
for (const promise of unconsumedPromises) { promise.resolve(createIterResult(undefined, true)); }
return Promise.resolve(createIterResult(undefined, true)); },
throw(err: Error): void { error = err; emitter.removeListener(event, eventHandler); emitter.removeListener("error", errorHandler); },
[Symbol.asyncIterator](): any { return this; }, };
emitter.on(event, eventHandler); emitter.on("error", errorHandler);
return iterator;
function eventHandler(...args: any[]): void { const promise = unconsumedPromises.shift(); if (promise) { promise.resolve(createIterResult(args, false)); } else { unconsumedEventValues.push(args); } }
function errorHandler(err: any): void { finished = true;
const toError = unconsumedPromises.shift(); if (toError) { toError.reject(err); } else { error = err; }
iterator.return(); }}export const captureRejectionSymbol = Symbol.for("nodejs.rejection");