ezfw-core 1.0.0

package/core/eventBus.ts

@@ -0,0 +1,284 @@
+export interface EventHandler {
+    fn: (data: unknown, event: string) => void | Promise<void>;
+    context: object | null;
+    once: boolean;
+}
+
+export interface EmitOptions {
+    async?: boolean;
+    stopOnError?: boolean;
+}
+
+interface HistoryEntry {
+    event: string;
+    data: unknown;
+    timestamp: number;
+}
+
+interface NamespacedEmitter {
+    on: (event: string, fn: EventHandler['fn'], context?: object | null) => () => boolean;
+    once: (event: string, fn: EventHandler['fn'], context?: object | null) => () => boolean;
+    off: (event: string, fn?: EventHandler['fn']) => boolean;
+    emit: (event: string, data?: unknown, options?: EmitOptions) => boolean;
+    emitAsync: (event: string, data?: unknown) => Promise<boolean>;
+}
+
+export class EzEventBus {
+    private _handlers: Map<string, EventHandler[]> = new Map();
+    private _wildcardHandlers: Map<string, EventHandler[]> = new Map();
+    private _debug: boolean = false;
+    private _history: HistoryEntry[] = [];
+    private _maxHistory: number = 100;
+
+    on(event: string, fn: EventHandler['fn'], context: object | null = null): () => boolean {
+        if (typeof fn !== 'function') {
+            throw new Error('[EzEventBus] Handler must be a function');
+        }
+
+        const handler: EventHandler = { fn, context, once: false };
+
+        if (event.includes('*')) {
+            const handlers = this._wildcardHandlers.get(event) || [];
+            handlers.push(handler);
+            this._wildcardHandlers.set(event, handlers);
+        } else {
+            const handlers = this._handlers.get(event) || [];
+            handlers.push(handler);
+            this._handlers.set(event, handlers);
+        }
+
+        this._log('subscribe', event);
+
+        return () => this.off(event, fn);
+    }
+
+    once(event: string, fn: EventHandler['fn'], context: object | null = null): () => boolean {
+        if (typeof fn !== 'function') {
+            throw new Error('[EzEventBus] Handler must be a function');
+        }
+
+        const handler: EventHandler = { fn, context, once: true };
+
+        const handlers = this._handlers.get(event) || [];
+        handlers.push(handler);
+        this._handlers.set(event, handlers);
+
+        this._log('subscribe:once', event);
+
+        return () => this.off(event, fn);
+    }
+
+    off(event: string, fn?: EventHandler['fn']): boolean {
+        let removed = false;
+
+        if (event.includes('*')) {
+            if (!fn) {
+                removed = this._wildcardHandlers.delete(event);
+            } else {
+                const handlers = this._wildcardHandlers.get(event);
+                if (handlers) {
+                    const filtered = handlers.filter(h => h.fn !== fn);
+                    removed = filtered.length !== handlers.length;
+                    if (filtered.length) {
+                        this._wildcardHandlers.set(event, filtered);
+                    } else {
+                        this._wildcardHandlers.delete(event);
+                    }
+                }
+            }
+        } else {
+            if (!fn) {
+                removed = this._handlers.delete(event);
+            } else {
+                const handlers = this._handlers.get(event);
+                if (handlers) {
+                    const filtered = handlers.filter(h => h.fn !== fn);
+                    removed = filtered.length !== handlers.length;
+                    if (filtered.length) {
+                        this._handlers.set(event, filtered);
+                    } else {
+                        this._handlers.delete(event);
+                    }
+                }
+            }
+        }
+
+        if (removed) {
+            this._log('unsubscribe', event);
+        }
+
+        return removed;
+    }
+
+    emit(event: string, data?: unknown, options: EmitOptions = {}): boolean {
+        const { async: isAsync = false, stopOnError = false } = options;
+
+        this._log('emit', event, data);
+        this._addToHistory(event, data);
+
+        const handlers = this._getHandlersForEvent(event);
+
+        if (!handlers.length) {
+            return false;
+        }
+
+        const toRemove: EventHandler[] = [];
+
+        for (const handler of handlers) {
+            try {
+                if (isAsync) {
+                    queueMicrotask(() => {
+                        handler.fn.call(handler.context, data, event);
+                    });
+                } else {
+                    handler.fn.call(handler.context, data, event);
+                }
+
+                if (handler.once) {
+                    toRemove.push(handler);
+                }
+            } catch (err) {
+                console.error(`[EzEventBus] Error in handler for "${event}":`, err);
+                if (stopOnError) break;
+            }
+        }
+
+        for (const handler of toRemove) {
+            this.off(event, handler.fn);
+        }
+
+        return true;
+    }
+
+    async emitAsync(event: string, data?: unknown): Promise<boolean> {
+        this._log('emitAsync', event, data);
+        this._addToHistory(event, data);
+
+        const handlers = this._getHandlersForEvent(event);
+
+        if (!handlers.length) {
+            return false;
+        }
+
+        const toRemove: EventHandler[] = [];
+
+        for (const handler of handlers) {
+            try {
+                await handler.fn.call(handler.context, data, event);
+
+                if (handler.once) {
+                    toRemove.push(handler);
+                }
+            } catch (err) {
+                console.error(`[EzEventBus] Error in async handler for "${event}":`, err);
+            }
+        }
+
+        for (const handler of toRemove) {
+            this.off(event, handler.fn);
+        }
+
+        return true;
+    }
+
+    private _getHandlersForEvent(event: string): EventHandler[] {
+        const result: EventHandler[] = [];
+
+        const direct = this._handlers.get(event);
+        if (direct) {
+            result.push(...direct);
+        }
+
+        for (const [pattern, handlers] of this._wildcardHandlers) {
+            if (this._matchesWildcard(event, pattern)) {
+                result.push(...handlers);
+            }
+        }
+
+        return result;
+    }
+
+    private _matchesWildcard(event: string, pattern: string): boolean {
+        const regexPattern = pattern
+            .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+            .replace(/\*/g, '.*');
+
+        const regex = new RegExp(`^${regexPattern}$`);
+        return regex.test(event);
+    }
+
+    has(event: string): boolean {
+        return this._getHandlersForEvent(event).length > 0;
+    }
+
+    listenerCount(event: string): number {
+        return this._getHandlersForEvent(event).length;
+    }
+
+    eventNames(): string[] {
+        return [...this._handlers.keys()];
+    }
+
+    clear(event: string): void {
+        this._handlers.delete(event);
+        this._wildcardHandlers.delete(event);
+        this._log('clear', event);
+    }
+
+    clearAll(): void {
+        this._handlers.clear();
+        this._wildcardHandlers.clear();
+        this._log('clearAll');
+    }
+
+    setDebug(enabled: boolean): void {
+        this._debug = enabled;
+    }
+
+    getHistory(event?: string): HistoryEntry[] {
+        if (event) {
+            return this._history.filter(h => h.event === event);
+        }
+        return [...this._history];
+    }
+
+    clearHistory(): void {
+        this._history = [];
+    }
+
+    private _addToHistory(event: string, data: unknown): void {
+        this._history.push({
+            event,
+            data,
+            timestamp: Date.now()
+        });
+
+        if (this._history.length > this._maxHistory) {
+            this._history = this._history.slice(-this._maxHistory);
+        }
+    }
+
+    private _log(action: string, event?: string, data?: unknown): void {
+        if (!this._debug) return;
+
+        const msg = event ? `[EzEventBus] ${action}: ${event}` : `[EzEventBus] ${action}`;
+
+        if (data !== undefined) {
+            console.log(msg, data);
+        } else {
+            console.log(msg);
+        }
+    }
+
+    namespace(namespace: string): NamespacedEmitter {
+        const prefix = namespace + ':';
+
+        return {
+            on: (event, fn, context) => this.on(prefix + event, fn, context),
+            once: (event, fn, context) => this.once(prefix + event, fn, context),
+            off: (event, fn) => this.off(prefix + event, fn),
+            emit: (event, data, options) => this.emit(prefix + event, data, options),
+            emitAsync: (event, data) => this.emitAsync(prefix + event, data)
+        };
+    }
+}