@therealtinhtute/baroiplayer 1.0.6 → 1.0.7

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

@@ -1,288 +0,0 @@
-// 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();
-    }
-}

package/src/core/events/hooks.js

@@ -1,198 +0,0 @@
-import { useEffect, useRef, useCallback, useMemo, useState } from 'react';
-import { EventBus } from './event-system';
-// Hook to use event bus with React
-export function useEventBus(eventBus) {
-    const eventBusRef = useRef(null);
-    if (!eventBusRef.current) {
-        eventBusRef.current = eventBus || new EventBus();
-    }
-    useEffect(() => {
-        const currentEventBus = eventBusRef.current;
-        return () => {
-            // Cleanup on unmount
-            currentEventBus.destroy();
-        };
-    }, []);
-    return eventBusRef.current;
-}
-// Hook to listen to events
-export function useEventListener(eventBus, type, handler, options, deps) {
-    const handlerRef = useRef(handler);
-    const optionsRef = useRef(options);
-    // Update refs when dependencies change
-    useEffect(() => {
-        handlerRef.current = handler;
-        optionsRef.current = options;
-    });
-    useEffect(() => {
-        const unsubscribe = eventBus.on(type, handlerRef.current, optionsRef.current);
-        return unsubscribe;
-    }, [eventBus, type, ...(deps || [])]);
-}
-// Hook to emit events
-export function useEventEmitter(eventBus) {
-    return useCallback((type, detail, options) => {
-        return eventBus.emit(type, detail, options);
-    }, [eventBus]);
-}
-// Hook for one-time event listeners
-export function useEventOnce(eventBus, type, handler, deps) {
-    useEventListener(eventBus, type, handler, { once: true }, deps);
-}
-// Hook to create event handlers with automatic cleanup
-export function useEventHandlers(eventBus) {
-    const handlersRef = useRef([]);
-    const addHandler = useCallback((type, handler, options) => {
-        const unsubscribe = eventBus.on(type, handler, options);
-        handlersRef.current.push(unsubscribe);
-        return unsubscribe;
-    }, [eventBus]);
-    const removeAllHandlers = useCallback(() => {
-        handlersRef.current.forEach(unsubscribe => unsubscribe());
-        handlersRef.current = [];
-    }, []);
-    useEffect(() => {
-        return removeAllHandlers;
-    }, [removeAllHandlers]);
-    return {
-        on: addHandler,
-        removeAll: removeAllHandlers
-    };
-}
-// Hook for event history
-export function useEventHistory(eventBus, filter, maxSize = 100) {
-    const historyRef = useRef([]);
-    useEffect(() => {
-        const unsubscribe = eventBus.addEventListener('*', (event) => {
-            if (!filter || filter(event)) {
-                historyRef.current.push(event);
-                // Limit history size
-                if (historyRef.current.length > maxSize) {
-                    historyRef.current.shift();
-                }
-            }
-        });
-        return unsubscribe;
-    }, [eventBus, filter, maxSize]);
-    const clearHistory = useCallback(() => {
-        historyRef.current = [];
-    }, []);
-    return {
-        history: historyRef.current,
-        clearHistory
-    };
-}
-// Hook for event metrics/analytics
-export function useEventMetrics(eventBus) {
-    const metricsRef = useRef(new Map());
-    useEffect(() => {
-        const updateMetrics = (event) => {
-            const existing = metricsRef.current.get(event.type) || {
-                count: 0,
-                lastTimestamp: 0,
-                frequency: 0
-            };
-            existing.count++;
-            if (existing.lastTimestamp > 0) {
-                const timeDiff = (event.timestamp - existing.lastTimestamp) / 1000; // seconds
-                existing.frequency = timeDiff > 0 ? 1 / timeDiff : 0;
-            }
-            existing.lastTimestamp = event.timestamp;
-            metricsRef.current.set(event.type, existing);
-        };
-        const unsubscribe = eventBus.addEventListener('*', updateMetrics);
-        return unsubscribe;
-    }, [eventBus]);
-    const getMetrics = useCallback(() => {
-        return Object.fromEntries(metricsRef.current.entries());
-    }, []);
-    const resetMetrics = useCallback(() => {
-        metricsRef.current.clear();
-    }, []);
-    return {
-        getMetrics,
-        resetMetrics
-    };
-}
-// Hook for event debugging
-export function useEventDebugger(eventBus, options = {}) {
-    const { logEvents = true, logMetrics = false, filterEventTypes } = options;
-    useEffect(() => {
-        if (!logEvents)
-            return;
-        const unsubscribe = eventBus.addEventListener('*', (event) => {
-            if (filterEventTypes && !filterEventTypes.includes(event.type)) {
-                return;
-            }
-            console.group(`🎯 Event: ${event.type}`);
-            console.log('Timestamp:', new Date(event.timestamp).toISOString());
-            console.log('Detail:', event.detail);
-            console.log('Bubbles:', event.bubbles);
-            console.log('Cancelable:', event.cancelable);
-            console.groupEnd();
-        });
-        return unsubscribe;
-    }, [eventBus, logEvents, filterEventTypes]);
-    useEffect(() => {
-        if (!logMetrics)
-            return;
-        const interval = setInterval(() => {
-            const listenerCount = eventBus.getListenerCount();
-            const eventTypes = eventBus.getEventTypes();
-            console.group('📊 Event Metrics');
-            console.log('Total Listeners:', listenerCount);
-            console.log('Event Types:', eventTypes.length);
-            console.log('Active Types:', eventTypes);
-            console.groupEnd();
-        }, 5000);
-        return () => clearInterval(interval);
-    }, [eventBus, logMetrics]);
-}
-// Hook for conditional event handling
-export function useConditionalEventListener(eventBus, type, handler, condition, options, deps) {
-    const shouldListen = useMemo(() => {
-        return typeof condition === 'function' ? condition() : condition;
-    }, [condition, ...(deps || [])]);
-    useEffect(() => {
-        if (!shouldListen)
-            return;
-        const unsubscribe = eventBus.on(type, handler, options);
-        return unsubscribe;
-    }, [eventBus, type, shouldListen, ...(deps || [])]);
-}
-// Hook for event state synchronization
-export function useEventState(eventBus, initialValue, eventMapping) {
-    const [state, setState] = useState(initialValue);
-    useEffect(() => {
-        const unsubscribers = [];
-        Object.entries(eventMapping).forEach(([eventType, updater]) => {
-            const unsubscribe = eventBus.addEventListener(eventType, (event) => {
-                setState(current => updater(event.detail, current));
-            });
-            unsubscribers.push(unsubscribe);
-        });
-        return () => {
-            unsubscribers.forEach(unsubscribe => unsubscribe());
-        };
-    }, [eventBus, eventMapping]);
-    return state;
-}
-// Hook for creating event-driven effects
-export function useEventEffect(eventBus, type, effect, deps) {
-    const cleanupRef = useRef(undefined);
-    useEventListener(eventBus, type, useCallback((event) => {
-        // Clean up previous effect
-        if (typeof cleanupRef.current === 'function') {
-            cleanupRef.current();
-        }
-        // Run new effect
-        cleanupRef.current = effect(event.detail);
-    }, deps || []), undefined, deps);
-    useEffect(() => {
-        return () => {
-            if (typeof cleanupRef.current === 'function') {
-                cleanupRef.current();
-            }
-        };
-    }, []);
-}

package/src/core/events/index.js

@@ -1,7 +0,0 @@
-// Event system exports
-export { EventBus, EventDelegator, defaultEventBus } from './event-system';
-// Event utilities
-export * from './middleware';
-export * from './hooks';
-// Version
-export const EVENT_SYSTEM_VERSION = '1.0.0';