/** * Copyright (c) Meta Platforms, Inc. and affiliates. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. * * @flow strict * @format */ export interface EventSubscription { remove(): void; } export interface IEventEmitter { addListener>( eventType: TEvent, listener: (...args: TEventToArgsMap[TEvent]) => mixed, context?: mixed, ): EventSubscription; emit>( eventType: TEvent, ...args: TEventToArgsMap[TEvent] ): void; removeAllListeners>(eventType?: ?TEvent): void; listenerCount>(eventType: TEvent): number; } interface Registration { +context: mixed; +listener: (...args: TArgs) => mixed; +remove: () => void; } type Registry = { [K in keyof TEventToArgsMap]: Set>, }; /** * EventEmitter manages listeners and publishes events to them. * * EventEmitter accepts a single type parameter that defines the valid events * and associated listener argument(s). * * @example * * const emitter = new EventEmitter<{ * success: [number, string], * error: [Error], * }>(); * * emitter.on('success', (statusCode, responseText) => {...}); * emitter.emit('success', 200, '...'); * * emitter.on('error', error => {...}); * emitter.emit('error', new Error('Resource not found')); * */ export default class EventEmitter implements IEventEmitter { // $FlowFixMe[incompatible-type] #registry: Registry = {}; /** * Registers a listener that is called when the supplied event is emitted. * Returns a subscription that has a `remove` method to undo registration. */ addListener>( eventType: TEvent, listener: (...args: TEventToArgsMap[TEvent]) => mixed, context: mixed, ): EventSubscription { if (typeof listener !== 'function') { throw new TypeError( 'EventEmitter.addListener(...): 2nd argument must be a function.', ); } const registrations = allocate< TEventToArgsMap, TEvent, TEventToArgsMap[TEvent], >(this.#registry, eventType); const registration: Registration = { context, listener, remove(): void { registrations.delete(registration); }, }; registrations.add(registration); return registration; } /** * Emits the supplied event. Additional arguments supplied to `emit` will be * passed through to each of the registered listeners. * * If a listener modifies the listeners registered for the same event, those * changes will not be reflected in the current invocation of `emit`. */ emit>( eventType: TEvent, ...args: TEventToArgsMap[TEvent] ): void { const registrations: ?Set> = this.#registry[eventType]; if (registrations != null) { // Copy `registrations` to take a snapshot when we invoke `emit`, in case // registrations are added or removed when listeners are invoked. for (const registration of Array.from(registrations)) { // $FlowFixMe[incompatible-call] registration.listener.apply(registration.context, args); } } } /** * Removes all registered listeners. */ removeAllListeners>( eventType?: ?TEvent, ): void { if (eventType == null) { // $FlowFixMe[incompatible-type] this.#registry = {}; } else { delete this.#registry[eventType]; } } /** * Returns the number of registered listeners for the supplied event. */ listenerCount>(eventType: TEvent): number { const registrations: ?Set> = this.#registry[eventType]; return registrations == null ? 0 : registrations.size; } } function allocate< TEventToArgsMap: {...}, TEvent: $Keys, TEventArgs: TEventToArgsMap[TEvent], >( registry: Registry, eventType: TEvent, ): Set> { let registrations: ?Set> = registry[eventType]; if (registrations == null) { registrations = new Set(); registry[eventType] = registrations; } return registrations; }