@therealtinhtute/baroiplayer 1.0.0 → 1.0.1

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

@@ -0,0 +1,302 @@
+import React, { useEffect, useRef, useCallback, useMemo, useState } from 'react'
+import { EventBus, type EventHandler, type EventUnsubscriber, type EventOptions, type MediaEvents } from './event-system'
+
+// Hook to use event bus with React
+export function useEventBus(eventBus?: EventBus): EventBus {
+  const eventBusRef = useRef<EventBus | null>(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<K extends keyof MediaEvents>(
+  eventBus: EventBus,
+  type: K,
+  handler: EventHandler<MediaEvents[K]>,
+  options?: EventOptions,
+  deps?: React.DependencyList
+): void {
+  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: EventBus) {
+  return useCallback(<K extends keyof MediaEvents>(
+    type: K,
+    detail?: MediaEvents[K],
+    options?: Partial<MediaEvents[K]>
+  ) => {
+    return eventBus.emit(type, detail, options)
+  }, [eventBus])
+}
+
+// Hook for one-time event listeners
+export function useEventOnce<K extends keyof MediaEvents>(
+  eventBus: EventBus,
+  type: K,
+  handler: EventHandler<MediaEvents[K]>,
+  deps?: React.DependencyList
+): void {
+  useEventListener(eventBus, type, handler, { once: true }, deps)
+}
+
+// Hook to create event handlers with automatic cleanup
+export function useEventHandlers(eventBus: EventBus) {
+  const handlersRef = useRef<EventUnsubscriber[]>([])
+  
+  const addHandler = useCallback(<K extends keyof MediaEvents>(
+    type: K,
+    handler: EventHandler<MediaEvents[K]>,
+    options?: EventOptions
+  ) => {
+    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: EventBus,
+  filter?: (event: any) => boolean,
+  maxSize = 100
+) {
+  const historyRef = useRef<any[]>([])
+  
+  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: EventBus) {
+  const metricsRef = useRef<Map<string, {
+    count: number
+    lastTimestamp: number
+    frequency: number // events per second
+  }>>(new Map())
+  
+  useEffect(() => {
+    const updateMetrics = (event: any) => {
+      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: EventBus, 
+  options: {
+    logEvents?: boolean
+    logMetrics?: boolean
+    filterEventTypes?: string[]
+  } = {}
+) {
+  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<K extends keyof MediaEvents>(
+  eventBus: EventBus,
+  type: K,
+  handler: EventHandler<MediaEvents[K]>,
+  condition: boolean | (() => boolean),
+  options?: EventOptions,
+  deps?: React.DependencyList
+): void {
+  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<T>(
+  eventBus: EventBus,
+  initialValue: T,
+  eventMapping: Record<string, (detail: any, currentValue: T) => T>
+) {
+  const [state, setState] = useState<T>(initialValue)
+  
+  useEffect(() => {
+    const unsubscribers: EventUnsubscriber[] = []
+    
+    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<K extends keyof MediaEvents>(
+  eventBus: EventBus,
+  type: K,
+  effect: (detail: MediaEvents[K]) => void | (() => void),
+  deps?: React.DependencyList
+): void {
+  const cleanupRef = useRef<(() => void) | void>(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/dist/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/dist/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/dist/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/dist/src/core/events/index.ts

@@ -0,0 +1,22 @@
+// Event system exports
+export {
+  EventBus,
+  EventDelegator,
+  defaultEventBus
+} from './event-system'
+
+export type {
+  MediaPlayerEvent,
+  EventHandler,
+  EventUnsubscriber,
+  EventOptions,
+  EventCategory,
+  MediaEvents
+} from './event-system'
+
+// Event utilities
+export * from './middleware'
+export * from './hooks'
+
+// Version
+export const EVENT_SYSTEM_VERSION = '1.0.0'

package/dist/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/dist/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"}

package/dist/src/core/events/middleware.js

@@ -0,0 +1,219 @@
+// Common middleware implementations
+export const eventMiddlewares = {
+    // Logging middleware
+    logger: (prefix = '[Event]') => (event) => {
+        if (process.env.NODE_ENV === 'development') {
+            console.log(`${prefix} ${event.type}`, event.detail);
+        }
+        return event;
+    },
+    // Throttling middleware
+    throttle: (eventTypes, delay = 100) => {
+        const lastTimes = new Map();
+        return (event) => {
+            if (eventTypes.includes(event.type)) {
+                const lastTime = lastTimes.get(event.type) || 0;
+                const now = event.timestamp;
+                if (now - lastTime < delay) {
+                    return null; // Throttle this event
+                }
+                lastTimes.set(event.type, now);
+            }
+            return event;
+        };
+    },
+    // Debouncing middleware
+    debounce: (eventTypes, delay = 100) => {
+        const timeouts = new Map();
+        const eventQueue = new Map();
+        return (event) => {
+            if (eventTypes.includes(event.type)) {
+                // Clear existing timeout
+                const existingTimeout = timeouts.get(event.type);
+                if (existingTimeout) {
+                    clearTimeout(existingTimeout);
+                }
+                // Store the latest event
+                eventQueue.set(event.type, event);
+                // Set new timeout
+                const timeout = setTimeout(() => {
+                    const queuedEvent = eventQueue.get(event.type);
+                    if (queuedEvent) {
+                        // Process the debounced event
+                        // Note: This is a simplified approach - in a real implementation,
+                        // you'd need to re-inject the event into the processing pipeline
+                        eventQueue.delete(event.type);
+                        timeouts.delete(event.type);
+                    }
+                }, delay);
+                timeouts.set(event.type, timeout);
+                return null; // Don't process immediately
+            }
+            return event;
+        };
+    },
+    // Filtering middleware
+    filter: (predicate) => (event) => {
+        return predicate(event) ? event : null;
+    },
+    // Event transformation middleware
+    transform: (transformer) => (event) => {
+        try {
+            return transformer(event);
+        }
+        catch (error) {
+            console.error('Error in event transformer:', error);
+            return event;
+        }
+    },
+    // Performance monitoring middleware
+    performance: () => {
+        const metrics = new Map();
+        return (event) => {
+            const startTime = performance.now();
+            // Update metrics
+            const existing = metrics.get(event.type) || { count: 0, totalTime: 0 };
+            existing.count++;
+            existing.totalTime += performance.now() - startTime;
+            metrics.set(event.type, existing);
+            // Log metrics periodically (every 100 events)
+            if (existing.count % 100 === 0) {
+                const avgTime = existing.totalTime / existing.count;
+                console.log(`Event ${event.type}: ${existing.count} calls, avg ${avgTime.toFixed(2)}ms`);
+            }
+            return event;
+        };
+    },
+    // Error handling middleware
+    errorHandler: (onError) => (event) => {
+        try {
+            // Validate event structure
+            if (!event.type || typeof event.type !== 'string') {
+                throw new Error('Invalid event: missing or invalid type');
+            }
+            if (!event.timestamp || typeof event.timestamp !== 'number') {
+                throw new Error('Invalid event: missing or invalid timestamp');
+            }
+            return event;
+        }
+        catch (error) {
+            if (onError) {
+                onError(error, event);
+            }
+            else {
+                console.error('Event validation error:', error);
+            }
+            return null;
+        }
+    },
+    // Security middleware (prevent certain events or sanitize data)
+    security: (options = {}) => (event) => {
+        const { blockedEventTypes = [], sanitizeDetail = true, maxDetailSize = 10000 } = options;
+        // Block certain event types
+        if (blockedEventTypes.includes(event.type)) {
+            console.warn(`Blocked event type: ${event.type}`);
+            return null;
+        }
+        // Sanitize detail if needed
+        if (sanitizeDetail && event.detail) {
+            try {
+                const detailStr = JSON.stringify(event.detail);
+                if (detailStr.length > maxDetailSize) {
+                    console.warn(`Event detail too large, truncating: ${event.type}`);
+                    event.detail = { ...event.detail, _truncated: true };
+                }
+            }
+            catch (error) {
+                console.warn(`Failed to serialize event detail: ${event.type}`);
+                event.detail = { _serializationError: true };
+            }
+        }
+        return event;
+    },
+    // Conditional middleware
+    when: (condition, middleware) => (event) => {
+        return condition(event) ? middleware(event) : event;
+    },
+    // Chain multiple middleware
+    chain: (...middlewares) => (event) => {
+        let currentEvent = event;
+        for (const middleware of middlewares) {
+            if (currentEvent === null)
+                break;
+            currentEvent = middleware(currentEvent);
+        }
+        return currentEvent;
+    }
+};
+// Middleware builder class
+export class MiddlewareBuilder {
+    middlewares = [];
+    // Add middleware
+    use(middleware) {
+        this.middlewares.push(middleware);
+        return this;
+    }
+    // Add logging
+    log(prefix) {
+        return this.use(eventMiddlewares.logger(prefix));
+    }
+    // Add throttling
+    throttle(eventTypes, delay) {
+        return this.use(eventMiddlewares.throttle(eventTypes, delay));
+    }
+    // Add debouncing
+    debounce(eventTypes, delay) {
+        return this.use(eventMiddlewares.debounce(eventTypes, delay));
+    }
+    // Add filtering
+    filter(predicate) {
+        return this.use(eventMiddlewares.filter(predicate));
+    }
+    // Add transformation
+    transform(transformer) {
+        return this.use(eventMiddlewares.transform(transformer));
+    }
+    // Add performance monitoring
+    performance() {
+        return this.use(eventMiddlewares.performance());
+    }
+    // Add error handling
+    errorHandler(onError) {
+        return this.use(eventMiddlewares.errorHandler(onError));
+    }
+    // Add security
+    security(options) {
+        return this.use(eventMiddlewares.security(options));
+    }
+    // Add conditional middleware
+    when(condition, middleware) {
+        return this.use(eventMiddlewares.when(condition, middleware));
+    }
+    // Build the final middleware
+    build() {
+        return eventMiddlewares.chain(...this.middlewares);
+    }
+}
+// Helper to create middleware builder
+export const createMiddleware = () => new MiddlewareBuilder();
+// Export commonly used middleware combinations
+export const commonMiddlewares = {
+    // Development middleware stack
+    development: () => createMiddleware()
+        .log('[Dev Event]')
+        .performance()
+        .errorHandler()
+        .build(),
+    // Production middleware stack
+    production: () => createMiddleware()
+        .security()
+        .errorHandler()
+        .throttle(['media:timeupdate', 'user:mousemove'], 16) // ~60fps
+        .build(),
+    // Testing middleware stack
+    testing: () => createMiddleware()
+        .errorHandler((error, event) => {
+        throw new Error(`Event error in test: ${error.message} for event ${event.type}`);
+    })
+        .build()
+};