@therealtinhtute/baroiplayer 1.0.0 → 1.0.1

package/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();
+    }
+}

package/src/core/events/hooks.d.ts

@@ -0,0 +1,33 @@
+import React from 'react';
+import { EventBus, type EventHandler, type EventUnsubscriber, type EventOptions, type MediaEvents } from './event-system';
+export declare function useEventBus(eventBus?: EventBus): EventBus;
+export declare function useEventListener<K extends keyof MediaEvents>(eventBus: EventBus, type: K, handler: EventHandler<MediaEvents[K]>, options?: EventOptions, deps?: React.DependencyList): void;
+export declare function useEventEmitter(eventBus: EventBus): <K extends keyof MediaEvents>(type: K, detail?: MediaEvents[K], options?: Partial<MediaEvents[K]>) => boolean;
+export declare function useEventOnce<K extends keyof MediaEvents>(eventBus: EventBus, type: K, handler: EventHandler<MediaEvents[K]>, deps?: React.DependencyList): void;
+export declare function useEventHandlers(eventBus: EventBus): {
+    on: <K extends keyof MediaEvents>(type: K, handler: EventHandler<MediaEvents[K]>, options?: EventOptions) => EventUnsubscriber;
+    removeAll: () => void;
+};
+export declare function useEventHistory(eventBus: EventBus, filter?: (event: any) => boolean, maxSize?: number): {
+    history: any[];
+    clearHistory: () => void;
+};
+export declare function useEventMetrics(eventBus: EventBus): {
+    getMetrics: () => {
+        [k: string]: {
+            count: number;
+            lastTimestamp: number;
+            frequency: number;
+        };
+    };
+    resetMetrics: () => void;
+};
+export declare function useEventDebugger(eventBus: EventBus, options?: {
+    logEvents?: boolean;
+    logMetrics?: boolean;
+    filterEventTypes?: string[];
+}): void;
+export declare function useConditionalEventListener<K extends keyof MediaEvents>(eventBus: EventBus, type: K, handler: EventHandler<MediaEvents[K]>, condition: boolean | (() => boolean), options?: EventOptions, deps?: React.DependencyList): void;
+export declare function useEventState<T>(eventBus: EventBus, initialValue: T, eventMapping: Record<string, (detail: any, currentValue: T) => T>): T;
+export declare function useEventEffect<K extends keyof MediaEvents>(eventBus: EventBus, type: K, effect: (detail: MediaEvents[K]) => void | (() => void), deps?: React.DependencyList): void;
+//# sourceMappingURL=hooks.d.ts.map

package/src/core/events/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAA4D,MAAM,OAAO,CAAA;AAChF,OAAO,EAAE,QAAQ,EAAE,KAAK,YAAY,EAAE,KAAK,iBAAiB,EAAE,KAAK,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAGzH,wBAAgB,WAAW,CAAC,QAAQ,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAiBzD;AAGD,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,MAAM,WAAW,EAC1D,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,CAAC,EACP,OAAO,EAAE,YAAY,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,EACrC,OAAO,CAAC,EAAE,YAAY,EACtB,IAAI,CAAC,EAAE,KAAK,CAAC,cAAc,GAC1B,IAAI,CAcN;AAGD,wBAAgB,eAAe,CAAC,QAAQ,EAAE,QAAQ,IAC5B,CAAC,SAAS,MAAM,WAAW,QACvC,CAAC,WACE,WAAW,CAAC,CAAC,CAAC,YACb,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,aAIpC;AAGD,wBAAgB,YAAY,CAAC,CAAC,SAAS,MAAM,WAAW,EACtD,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,CAAC,EACP,OAAO,EAAE,YAAY,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,EACrC,IAAI,CAAC,EAAE,KAAK,CAAC,cAAc,GAC1B,IAAI,CAEN;AAGD,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,QAAQ;SAGjB,CAAC,SAAS,MAAM,WAAW,QACnD,CAAC,WACE,YAAY,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,YAC3B,YAAY;;EAoBzB;AAGD,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,QAAQ,EAClB,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,OAAO,EAChC,OAAO,SAAM;;;EA2Bd;AAGD,wBAAgB,eAAe,CAAC,QAAQ,EAAE,QAAQ;;;mBAEvC,MAAM;2BACE,MAAM;uBACV,MAAM;;;;EAsCpB;AAGD,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE;IACP,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;CACvB,QAuCP;AAGD,wBAAgB,2BAA2B,CAAC,CAAC,SAAS,MAAM,WAAW,EACrE,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,CAAC,EACP,OAAO,EAAE,YAAY,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,EACrC,SAAS,EAAE,OAAO,GAAG,CAAC,MAAM,OAAO,CAAC,EACpC,OAAO,CAAC,EAAE,YAAY,EACtB,IAAI,CAAC,EAAE,KAAK,CAAC,cAAc,GAC1B,IAAI,CAWN;AAGD,wBAAgB,aAAa,CAAC,CAAC,EAC7B,QAAQ,EAAE,QAAQ,EAClB,YAAY,EAAE,CAAC,EACf,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE,YAAY,EAAE,CAAC,KAAK,CAAC,CAAC,KAoBlE;AAGD,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,WAAW,EACxD,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,CAAC,EACP,MAAM,EAAE,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,EACvD,IAAI,CAAC,EAAE,KAAK,CAAC,cAAc,GAC1B,IAAI,CA0BN"}

package/src/core/events/hooks.js

@@ -0,0 +1,198 @@
+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.d.ts

@@ -0,0 +1,6 @@
+export { EventBus, EventDelegator, defaultEventBus } from './event-system';
+export type { MediaPlayerEvent, EventHandler, EventUnsubscriber, EventOptions, EventCategory, MediaEvents } from './event-system';
+export * from './middleware';
+export * from './hooks';
+export declare const EVENT_SYSTEM_VERSION = "1.0.0";
+//# sourceMappingURL=index.d.ts.map

package/src/core/events/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EACR,cAAc,EACd,eAAe,EAChB,MAAM,gBAAgB,CAAA;AAEvB,YAAY,EACV,gBAAgB,EAChB,YAAY,EACZ,iBAAiB,EACjB,YAAY,EACZ,aAAa,EACb,WAAW,EACZ,MAAM,gBAAgB,CAAA;AAGvB,cAAc,cAAc,CAAA;AAC5B,cAAc,SAAS,CAAA;AAGvB,eAAO,MAAM,oBAAoB,UAAU,CAAA"}

package/src/core/events/index.js

@@ -0,0 +1,7 @@
+// 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';

package/src/core/events/middleware.d.ts

@@ -0,0 +1,39 @@
+import type { MediaPlayerEvent } from './event-system';
+export type EventMiddleware = (event: MediaPlayerEvent) => MediaPlayerEvent | null;
+export declare const eventMiddlewares: {
+    logger: (prefix?: string) => EventMiddleware;
+    throttle: (eventTypes: string[], delay?: number) => EventMiddleware;
+    debounce: (eventTypes: string[], delay?: number) => EventMiddleware;
+    filter: (predicate: (event: MediaPlayerEvent) => boolean) => EventMiddleware;
+    transform: (transformer: (event: MediaPlayerEvent) => MediaPlayerEvent) => EventMiddleware;
+    performance: () => EventMiddleware;
+    errorHandler: (onError?: (error: Error, event: MediaPlayerEvent) => void) => EventMiddleware;
+    security: (options?: {
+        blockedEventTypes?: string[];
+        sanitizeDetail?: boolean;
+        maxDetailSize?: number;
+    }) => EventMiddleware;
+    when: (condition: (event: MediaPlayerEvent) => boolean, middleware: EventMiddleware) => EventMiddleware;
+    chain: (...middlewares: EventMiddleware[]) => EventMiddleware;
+};
+export declare class MiddlewareBuilder {
+    private middlewares;
+    use(middleware: EventMiddleware): this;
+    log(prefix?: string): this;
+    throttle(eventTypes: string[], delay?: number): this;
+    debounce(eventTypes: string[], delay?: number): this;
+    filter(predicate: (event: MediaPlayerEvent) => boolean): this;
+    transform(transformer: (event: MediaPlayerEvent) => MediaPlayerEvent): this;
+    performance(): this;
+    errorHandler(onError?: (error: Error, event: MediaPlayerEvent) => void): this;
+    security(options?: Parameters<typeof eventMiddlewares.security>[0]): this;
+    when(condition: (event: MediaPlayerEvent) => boolean, middleware: EventMiddleware): this;
+    build(): EventMiddleware;
+}
+export declare const createMiddleware: () => MiddlewareBuilder;
+export declare const commonMiddlewares: {
+    development: () => EventMiddleware;
+    production: () => EventMiddleware;
+    testing: () => EventMiddleware;
+};
+//# sourceMappingURL=middleware.d.ts.map

package/src/core/events/middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["middleware.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAGtD,MAAM,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE,gBAAgB,KAAK,gBAAgB,GAAG,IAAI,CAAA;AAGlF,eAAO,MAAM,gBAAgB;iCAEG,eAAe;2BAQtB,MAAM,EAAE,qBAAgB,eAAe;2BAoBvC,MAAM,EAAE,qBAAgB,eAAe;wBAqC1C,CAAC,KAAK,EAAE,gBAAgB,KAAK,OAAO,KAAG,eAAe;6BAKjD,CAAC,KAAK,EAAE,gBAAgB,KAAK,gBAAgB,KAAG,eAAe;uBAUvE,eAAe;6BAuBP,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,gBAAgB,KAAK,IAAI,KAAG,eAAe;yBAuBtE;QAClB,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAA;QAC5B,cAAc,CAAC,EAAE,OAAO,CAAA;QACxB,aAAa,CAAC,EAAE,MAAM,CAAA;KACvB,KAAQ,eAAe;sBA2BN,CAAC,KAAK,EAAE,gBAAgB,KAAK,OAAO,cAAc,eAAe,KAAG,eAAe;4BAK7E,eAAe,EAAE,KAAG,eAAe;CAU5D,CAAA;AAGD,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,WAAW,CAAwB;IAG3C,GAAG,CAAC,UAAU,EAAE,eAAe,GAAG,IAAI;IAMtC,GAAG,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;IAK1B,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;IAKpD,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;IAKpD,MAAM,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,OAAO,GAAG,IAAI;IAK7D,SAAS,CAAC,WAAW,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,gBAAgB,GAAG,IAAI;IAK3E,WAAW,IAAI,IAAI;IAKnB,YAAY,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,gBAAgB,KAAK,IAAI,GAAG,IAAI;IAK7E,QAAQ,CAAC,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAKzE,IAAI,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,OAAO,EAAE,UAAU,EAAE,eAAe,GAAG,IAAI;IAKxF,KAAK,IAAI,eAAe;CAGzB;AAGD,eAAO,MAAM,gBAAgB,yBAAgC,CAAA;AAG7D,eAAO,MAAM,iBAAiB;;;;CAqB7B,CAAA"}