153 lines
3.8 KiB
TypeScript
153 lines
3.8 KiB
TypeScript
// TODO: You'll probably want to use WeakRef's here.
|
|
|
|
export type EventMap = Record<string, unknown>;
|
|
|
|
type Listener<T> = (detail: T) => void;
|
|
|
|
interface ListenerEntry<T> {
|
|
listener: Listener<T>;
|
|
wrappedListener: Listener<T>;
|
|
debounceTime?: number;
|
|
once?: boolean;
|
|
}
|
|
|
|
export type OffCallback = () => void;
|
|
|
|
export class EventEmitter<T extends EventMap> {
|
|
private listeners: Map<keyof T, Set<ListenerEntry<T[keyof T]>>> = new Map();
|
|
|
|
on<K extends keyof T>(
|
|
type: K,
|
|
listener: Listener<T[K]>,
|
|
debounceMilliseconds?: number,
|
|
): OffCallback {
|
|
const wrappedListener =
|
|
debounceMilliseconds && debounceMilliseconds > 0
|
|
? this.debounce(listener, debounceMilliseconds)
|
|
: listener;
|
|
|
|
if (!this.listeners.has(type)) {
|
|
this.listeners.set(type, new Set());
|
|
}
|
|
|
|
const listenerEntry: ListenerEntry<T[K]> = {
|
|
listener,
|
|
wrappedListener,
|
|
debounceTime: debounceMilliseconds,
|
|
};
|
|
|
|
this.listeners.get(type)?.add(listenerEntry as ListenerEntry<T[keyof T]>);
|
|
|
|
// Return an "off" callback that can be called to stop listening for events.
|
|
return () => this.off(type, listener);
|
|
}
|
|
|
|
once<K extends keyof T>(
|
|
type: K,
|
|
listener: Listener<T[K]>,
|
|
debounceMilliseconds?: number,
|
|
): OffCallback {
|
|
const wrappedListener: Listener<T[K]> = (detail: T[K]) => {
|
|
this.off(type, listener);
|
|
listener(detail);
|
|
};
|
|
|
|
const debouncedListener =
|
|
debounceMilliseconds && debounceMilliseconds > 0
|
|
? this.debounce(wrappedListener, debounceMilliseconds)
|
|
: wrappedListener;
|
|
|
|
if (!this.listeners.has(type)) {
|
|
this.listeners.set(type, new Set());
|
|
}
|
|
|
|
const listenerEntry: ListenerEntry<T[K]> = {
|
|
listener,
|
|
wrappedListener: debouncedListener,
|
|
debounceTime: debounceMilliseconds,
|
|
once: true,
|
|
};
|
|
|
|
this.listeners.get(type)?.add(listenerEntry as ListenerEntry<T[keyof T]>);
|
|
|
|
// Return an "off" callback that can be called to stop listening for events.
|
|
return () => this.off(type, listener);
|
|
}
|
|
|
|
off<K extends keyof T>(type: K, listener: Listener<T[K]>): void {
|
|
const listeners = this.listeners.get(type);
|
|
if (!listeners) return;
|
|
|
|
const listenerEntry = Array.from(listeners).find(
|
|
(entry) =>
|
|
entry.listener === listener || entry.wrappedListener === listener,
|
|
);
|
|
|
|
if (listenerEntry) {
|
|
listeners.delete(listenerEntry);
|
|
}
|
|
}
|
|
|
|
emit<K extends keyof T>(type: K, payload: T[K]): boolean {
|
|
const listeners = this.listeners.get(type);
|
|
if (!listeners) return false;
|
|
|
|
listeners.forEach((entry) => {
|
|
entry.wrappedListener(payload);
|
|
});
|
|
|
|
return listeners.size > 0;
|
|
}
|
|
|
|
removeAllListeners(): void {
|
|
this.listeners.clear();
|
|
}
|
|
|
|
async waitFor<K extends keyof T>(
|
|
type: K,
|
|
predicate: (payload: T[K]) => boolean,
|
|
timeoutMs?: number,
|
|
): Promise<T[K]> {
|
|
return new Promise((resolve, reject) => {
|
|
let timeoutId: ReturnType<typeof setTimeout> | undefined;
|
|
|
|
const listener = (payload: T[K]) => {
|
|
if (predicate(payload)) {
|
|
// Clean up
|
|
this.off(type, listener);
|
|
if (timeoutId !== undefined) {
|
|
clearTimeout(timeoutId);
|
|
}
|
|
resolve(payload);
|
|
}
|
|
};
|
|
|
|
// Set up timeout if specified
|
|
if (timeoutMs !== undefined) {
|
|
timeoutId = setTimeout(() => {
|
|
this.off(type, listener);
|
|
reject(new Error(`Timeout waiting for event "${String(type)}"`));
|
|
}, timeoutMs);
|
|
}
|
|
|
|
this.on(type, listener);
|
|
});
|
|
}
|
|
|
|
private debounce<K extends keyof T>(
|
|
func: Listener<T[K]>,
|
|
wait: number,
|
|
): Listener<T[K]> {
|
|
let timeout: ReturnType<typeof setTimeout>;
|
|
|
|
return (detail: T[K]) => {
|
|
if (timeout !== null) {
|
|
clearTimeout(timeout);
|
|
}
|
|
timeout = setTimeout(() => {
|
|
func(detail);
|
|
}, wait);
|
|
};
|
|
}
|
|
}
|