core/event-emitter

index.d.ts

@@ -171,6 +171,7 @@ type JSONLikeValue =
 type CanPromise<T> = T | Promise<T>;
 type CanPromiseLike<T> = T | PromiseLike<T>;
 type CanArray<T> = T | T[];
+type CanIterable<T> = T | Iterable<T>;
 
 type CanUndef<T> = T | undefined;
 type Nullable<T> = T | null | undefined;

src/core/event-emitter/const.ts

@@ -0,0 +1,8 @@
+import type { EmitterOptions } from 'core/event-emitter/interface';
+
+import defaultEngine from 'core/event-emitter/engines/default';
+
+export const defaultOptions: Required<EmitterOptions> = {
+	engine: defaultEngine,
+	engineOptions: {}
+};

src/core/event-emitter/engines/default.ts

@@ -0,0 +1,48 @@
+import { EventEmitter2 } from 'eventemitter2';
+
+import type { ConstructorOptions } from 'eventemitter2';
+
+import type { EmitterEngine, EmitterEvent } from 'core/event-emitter/interface';
+
+/**
+ *
+ */
+class Engine extends EventEmitter2 implements EmitterEngine {
+	/**
+	 *
+	 */
+	offAll(event?: CanArray<EmitterEvent>): void {
+		this.removeAllListeners(event);
+	}
+
+	/**
+	 *
+	 */
+	getEvents(): EmitterEvent[] {
+		return this.eventNames().flatMap((event) => {
+			if (Array.isArray(event)) {
+				return event.map(String);
+			}
+
+			return String(event);
+		});
+	}
+
+	prepend(event: EmitterEvent, handler: AnyFunction): void {
+		this.prependListener(event, handler);
+	}
+
+	/**
+	 *
+	 */
+	override hasListeners(event: string): boolean {
+		return <boolean>super.hasListeners(event);
+	}
+}
+
+/**
+ *
+ */
+export default function factory(options?: ConstructorOptions): Engine {
+	return new Engine(options);
+}

src/core/event-emitter/helpers.ts

@@ -0,0 +1,8 @@
+import type { EmitterEvent } from 'core/event-emitter/interface';
+
+/**
+ *
+ */
+export function isEmitterEvent(event: unknown): event is EmitterEvent {
+	return Object.isString(event);
+}

src/core/event-emitter/index.ts

@@ -0,0 +1,207 @@
+import { EventEmitter2 } from 'eventemitter2';
+
+import { isEmitterEvent } from 'core/event-emitter/helpers';
+
+import { defaultOptions } from 'core/event-emitter/const';
+
+import Stream from 'core/event-emitter/modules/stream';
+
+import type {
+
+	EmitterEngine,
+	EmitterEngineFactory,
+
+	EmitterOptions,
+	EmitterEvent,
+
+	EventHandler,
+	HandlerValues
+
+} from 'core/event-emitter/interface';
+
+export * from 'core/event-emitter/interface';
+
+/**
+ *
+ */
+export default class EventEmitter<T extends EmitterEngineFactory = typeof defaultOptions.engine> {
+	/**
+	 *
+	 */
+	protected readonly options: Required<EmitterOptions>;
+
+	/**
+	 *
+	 */
+	protected readonly engine: EmitterEngine;
+
+	/**
+	 *
+	 */
+	protected readonly localEmitter: EventEmitter2 = new EventEmitter2();
+
+	constructor(options: EmitterOptions<T> = {}) {
+		this.options = Object.mixin(true, {}, defaultOptions, options);
+		this.engine = this.options.engine(this.options.engineOptions);
+	}
+
+	/**
+	 *
+	 */
+	on(events: CanIterable<EmitterEvent>, handler: EventHandler): void;
+
+	/**
+	 *
+	 */
+	on(events: CanIterable<EmitterEvent>): AsyncIterableIterator<HandlerValues>;
+
+	on(events: CanIterable<EmitterEvent>, handler?: EventHandler): CanVoid<AsyncIterableIterator<HandlerValues>> {
+		const
+			eventsArr = this.normalizeEvents(events);
+
+		if (handler == null) {
+			return this.stream(eventsArr);
+		}
+
+		eventsArr.forEach((event) => this.engine.on(event, handler));
+	}
+
+	/**
+	 *
+	 */
+	 prepend(events: CanIterable<EmitterEvent>, handler: EventHandler): void {
+		 this.normalizeEvents(events).forEach((event) => {
+			 this.engine.prepend(event, handler);
+		 });
+	 }
+
+	/**
+	 *
+	 */
+	once(events: CanIterable<EmitterEvent>, handler: EventHandler): void;
+
+	/**
+	 *
+	 */
+	once(events: CanIterable<EmitterEvent>): AsyncIterableIterator<HandlerValues>;
+
+	/**
+	 *
+	 */
+	once(events: CanIterable<EmitterEvent>, handler?: EventHandler): CanVoid<AsyncIterableIterator<HandlerValues>> {
+		const
+			eventsArr = this.normalizeEvents(events);
+
+		eventsArr.forEach((event) => {
+			const wrapper: EventHandler = (...params) => {
+				if (handler == null) {
+					this.localEmitter.emit(`off.${event}`, {forbid: true});
+				} else {
+					handler(...params);
+				}
+
+				this.off(event, wrapper);
+			};
+
+			this.on(event, wrapper);
+		});
+
+		if (handler == null) {
+			return this.stream(eventsArr);
+		}
+	}
+
+	/**
+	 *
+	 */
+	any(events: Iterable<EmitterEvent>, handler: EventHandler): void;
+
+	/**
+	 *
+	 */
+	any(events: Iterable<EmitterEvent>): AsyncIterableIterator<HandlerValues>;
+
+	/**
+	 *
+	 */
+	any(events: Iterable<EmitterEvent>, handler?: EventHandler): CanVoid<AsyncIterableIterator<HandlerValues>> {
+		const
+			eventsArr = this.normalizeEvents(events),
+			handlers = new Map<string, EventHandler>();
+
+		eventsArr.forEach((event) => {
+			const wrapper: EventHandler = (...params) => {
+				handler?.(...params);
+
+				handlers.forEach((localHandler, event) => {
+					this.off(event, localHandler);
+
+					if (handler == null) {
+						this.localEmitter.emit(`off.${event}`);
+					}
+				});
+			};
+
+			this.on(event, wrapper);
+			handlers.set(event, wrapper);
+		});
+
+		if (handler == null) {
+			return this.stream(eventsArr);
+		}
+	}
+
+	/**
+	 *
+	 */
+	off(events?: CanIterable<EmitterEvent>, handler?: EventHandler): void {
+		const emitOff = (e: string) => {
+			this.localEmitter.emit(`off.${e}`);
+		};
+
+		if (events == null) {
+			this.engine.getEvents().forEach(emitOff);
+
+			this.engine.offAll();
+
+			return;
+		}
+
+		this.normalizeEvents(events).forEach((event) => {
+			if (handler == null) {
+				emitOff(event);
+
+				this.engine.offAll(event);
+			} else {
+				this.engine.off(event, handler);
+
+				if (!this.engine.hasListeners(event)) {
+					emitOff(event);
+				}
+			}
+		});
+	}
+
+	/**
+	 *
+	 */
+	emit(events: CanIterable<EmitterEvent>, ...values: HandlerValues): void {
+		this.normalizeEvents(events).forEach((event) => {
+			this.engine.emit(event, ...values);
+		});
+	}
+
+	/**
+	 *
+	 */
+	protected normalizeEvents(event: CanIterable<EmitterEvent>): EmitterEvent[] {
+		return isEmitterEvent(event) ? [event] : [...new Set(event)];
+	}
+
+	/**
+	 *
+	 */
+	protected stream(eventsArr: EmitterEvent[]): Stream {
+		return new Stream(this, this.localEmitter, eventsArr);
+	}
+}

src/core/event-emitter/interface.ts

@@ -0,0 +1,81 @@
+import type defaultEngine from 'core/event-emitter/engines/default';
+
+/**
+ *
+ */
+export interface EmitterOptions<T extends EmitterEngineFactory = typeof defaultEngine> {
+	/**
+	 *
+	 */
+	engine?: T;
+
+	/**
+	 *
+	 */
+	engineOptions?: InferFactoryParameters<T>;
+}
+
+/**
+ *
+ */
+export type EmitterEngineFactory = (params?: Dictionary) => EmitterEngine;
+
+/**
+ *
+ */
+export interface EmitterEngine {
+	/**
+	 *
+	 */
+	on(event: EmitterEvent, handler: AnyFunction): void;
+
+	/**
+	 *
+	 */
+	prepend(event: EmitterEvent, handler: AnyFunction): void;
+
+	/**
+	 *
+	 */
+	off(event: EmitterEvent, handler: AnyFunction): void;
+
+	/**
+	 *
+	 */
+	emit(event: EmitterEvent, ...values: unknown[]): void;
+
+	/**
+	 *
+	 */
+	offAll(event?: EmitterEvent): void;
+
+	/**
+	 *
+	 */
+	getEvents(): EmitterEvent[];
+
+	/**
+	 *
+	 */
+	hasListeners(event: EmitterEvent): boolean;
+}
+
+/**
+ *
+ */
+export type EmitterEvent = string;
+
+/**
+ *
+ */
+export type EventHandler = (...values: HandlerValues) => void;
+
+/**
+ *
+ */
+export type HandlerValues = unknown[];
+
+/**
+ *
+ */
+type InferFactoryParameters<T extends EmitterEngineFactory> = Parameters<T>[0];