@therealtinhtute/baroiplayer 1.0.0 → 1.0.2

package/dist/src/core/events/event-system.js

@@ -0,0 +1,288 @@
+// Event bus implementation
+export class EventBus {
+    listeners = new Map();
+    eventQueue = [];
+    isProcessing = false;
+    middlewares = [];
+    eventHistory = [];
+    maxHistorySize = 1000;
+    // Subscribe to events
+    on(type, handler, options = {}) {
+        return this.addEventListener(type, handler, options);
+    }
+    // Subscribe to events (one-time)
+    once(type, handler, options = {}) {
+        return this.addEventListener(type, handler, { ...options, once: true });
+    }
+    // Subscribe to events with wildcard support
+    addEventListener(type, handler, options = {}) {
+        const id = this.generateId();
+        const listener = { handler, options, id };
+        if (!this.listeners.has(type)) {
+            this.listeners.set(type, []);
+        }
+        const listeners = this.listeners.get(type);
+        // Insert based on priority
+        const priority = options.priority || 'normal';
+        const priorityValue = { high: 2, normal: 1, low: 0 }[priority];
+        let insertIndex = listeners.length;
+        for (let i = 0; i < listeners.length; i++) {
+            const listener = listeners[i];
+            if (!listener)
+                continue;
+            const listenerPriority = listener.options.priority || 'normal';
+            if (priorityValue > { high: 2, normal: 1, low: 0 }[listenerPriority]) {
+                insertIndex = i;
+                break;
+            }
+        }
+        listeners.splice(insertIndex, 0, listener);
+        // Return unsubscriber
+        return () => {
+            const index = listeners.findIndex(l => l.id === id);
+            if (index !== -1) {
+                listeners.splice(index, 1);
+            }
+            if (listeners.length === 0) {
+                this.listeners.delete(type);
+            }
+        };
+    }
+    // Remove event listener
+    removeEventListener(type, handler) {
+        const listeners = this.listeners.get(type);
+        if (!listeners)
+            return;
+        if (handler) {
+            const index = listeners.findIndex(l => l.handler === handler);
+            if (index !== -1) {
+                listeners.splice(index, 1);
+            }
+        }
+        else {
+            this.listeners.delete(type);
+        }
+        if (listeners && listeners.length === 0) {
+            this.listeners.delete(type);
+        }
+    }
+    // Emit events
+    emit(type, detail, options) {
+        const event = {
+            type,
+            timestamp: Date.now(),
+            detail,
+            bubbles: true,
+            cancelable: true,
+            defaultPrevented: false,
+            ...options
+        };
+        return this.dispatchEvent(event);
+    }
+    // Dispatch event
+    dispatchEvent(event) {
+        // Apply middlewares
+        let processedEvent = event;
+        for (const middleware of this.middlewares) {
+            processedEvent = middleware(processedEvent);
+            if (!processedEvent) {
+                return false; // Event was cancelled by middleware
+            }
+        }
+        // Add to history
+        this.addToHistory(processedEvent);
+        // Queue event for processing
+        this.eventQueue.push(processedEvent);
+        if (!this.isProcessing) {
+            this.processEventQueue();
+        }
+        return !processedEvent.defaultPrevented;
+    }
+    // Process event queue with React 19 concurrent scheduling
+    processEventQueue() {
+        if (this.isProcessing)
+            return;
+        this.isProcessing = true;
+        // Use scheduler for non-blocking event processing
+        const schedule = (typeof window !== 'undefined' && 'scheduler' in window)
+            ? window.scheduler.postTask
+            : (cb) => setTimeout(cb, 0);
+        const processNext = () => {
+            if (this.eventQueue.length === 0) {
+                this.isProcessing = false;
+                return;
+            }
+            const batchSize = Math.min(this.eventQueue.length, 5); // Process max 5 events per frame
+            const events = this.eventQueue.splice(0, batchSize);
+            // Process events in parallel using Promise.all
+            Promise.all(events.map(event => this.processEvent(event).catch(console.error)))
+                .then(() => {
+                // Schedule next batch in next frame
+                schedule(processNext);
+            })
+                .catch(() => {
+                this.isProcessing = false;
+            });
+        };
+        schedule(processNext);
+    }
+    // Process individual event
+    async processEvent(event) {
+        const { type } = event;
+        // Get exact matches
+        const exactListeners = this.listeners.get(type) || [];
+        // Get wildcard matches
+        const wildcardListeners = [];
+        for (const [pattern, listeners] of this.listeners.entries()) {
+            if (pattern.includes('*') && this.matchPattern(type, pattern)) {
+                wildcardListeners.push(...listeners);
+            }
+        }
+        // Combine and sort by priority
+        const allListeners = [...exactListeners, ...wildcardListeners]
+            .sort((a, b) => {
+            const priorityA = { high: 2, normal: 1, low: 0 }[a.options.priority || 'normal'];
+            const priorityB = { high: 2, normal: 1, low: 0 }[b.options.priority || 'normal'];
+            return priorityB - priorityA;
+        });
+        // Execute listeners
+        const listenersToRemove = [];
+        for (const listener of allListeners) {
+            // Apply filter if present
+            if (listener.options.filter && !listener.options.filter(event)) {
+                continue;
+            }
+            try {
+                // Execute handler
+                await Promise.resolve(listener.handler(event));
+                // Mark for removal if once
+                if (listener.options.once) {
+                    listenersToRemove.push(listener.id);
+                }
+                // Stop propagation if event was cancelled
+                if (event.defaultPrevented && !event.bubbles) {
+                    break;
+                }
+            }
+            catch (error) {
+                console.error(`Error in event handler for ${type}:`, error);
+                // Log error instead
+                console.error(`Event handler error for ${type}:`, error);
+            }
+        }
+        // Remove one-time listeners
+        for (const id of listenersToRemove) {
+            for (const [eventType, listeners] of this.listeners.entries()) {
+                const index = listeners.findIndex(l => l.id === id);
+                if (index !== -1) {
+                    listeners.splice(index, 1);
+                    if (listeners.length === 0) {
+                        this.listeners.delete(eventType);
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    // Add middleware
+    use(middleware) {
+        this.middlewares.push(middleware);
+        return () => {
+            const index = this.middlewares.indexOf(middleware);
+            if (index !== -1) {
+                this.middlewares.splice(index, 1);
+            }
+        };
+    }
+    // Event history management
+    addToHistory(event) {
+        this.eventHistory.push(event);
+        if (this.eventHistory.length > this.maxHistorySize) {
+            this.eventHistory.shift();
+        }
+    }
+    // Get event history
+    getHistory(filter) {
+        return filter ? this.eventHistory.filter(filter) : [...this.eventHistory];
+    }
+    // Clear event history
+    clearHistory() {
+        this.eventHistory = [];
+    }
+    // Pattern matching for wildcards
+    matchPattern(eventType, pattern) {
+        const regex = new RegExp('^' + pattern.replace(/\*/g, '.*').replace(/\?/g, '.') + '$');
+        return regex.test(eventType);
+    }
+    // Generate unique ID
+    generateId() {
+        return `event_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    // Get listener count
+    getListenerCount(type) {
+        if (type) {
+            return this.listeners.get(type)?.length || 0;
+        }
+        return Array.from(this.listeners.values()).reduce((sum, listeners) => sum + listeners.length, 0);
+    }
+    // Get all event types
+    getEventTypes() {
+        return Array.from(this.listeners.keys());
+    }
+    // Clear all listeners
+    removeAllListeners(type) {
+        if (type) {
+            this.listeners.delete(type);
+        }
+        else {
+            this.listeners.clear();
+        }
+    }
+    // Destroy event bus
+    destroy() {
+        this.listeners.clear();
+        this.eventQueue = [];
+        this.middlewares = [];
+        this.eventHistory = [];
+        this.isProcessing = false;
+    }
+}
+// Default event bus instance
+export const defaultEventBus = new EventBus();
+// Event delegation helper
+export class EventDelegator {
+    eventBus;
+    element;
+    delegatedEvents = new Set();
+    constructor(eventBus, element) {
+        this.eventBus = eventBus;
+        this.element = element;
+    }
+    // Delegate DOM events to event bus
+    delegate(domEvent, mediaEvent) {
+        if (this.delegatedEvents.has(domEvent))
+            return;
+        const handler = (e) => {
+            this.eventBus.emit(mediaEvent || `dom:${domEvent}`, {
+                originalEvent: e,
+                target: e.target?.tagName.toLowerCase(),
+                currentTarget: e.currentTarget?.tagName.toLowerCase()
+            });
+        };
+        this.element.addEventListener(domEvent, handler, { passive: true });
+        this.delegatedEvents.add(domEvent);
+    }
+    // Setup common delegations
+    setupCommonDelegations() {
+        this.delegate('click', 'user:click');
+        this.delegate('mouseenter', 'user:hover');
+        this.delegate('mouseleave', 'user:hover');
+        this.delegate('focus', 'user:focus');
+        this.delegate('blur', 'user:focus');
+        this.delegate('keydown', 'user:keyboard');
+        this.delegate('keyup', 'user:keyboard');
+    }
+    destroy() {
+        this.delegatedEvents.clear();
+    }
+}