@therealtinhtute/baroiplayer 1.0.0

package/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/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/src/core/events/middleware.ts

@@ -0,0 +1,269 @@
+import type { MediaPlayerEvent } from './event-system'
+
+// Middleware function type
+export type EventMiddleware = (event: MediaPlayerEvent) => MediaPlayerEvent | null
+
+// Common middleware implementations
+export const eventMiddlewares = {
+  // Logging middleware
+  logger: (prefix = '[Event]'): EventMiddleware => (event) => {
+    if (process.env.NODE_ENV === 'development') {
+      console.log(`${prefix} ${event.type}`, event.detail)
+    }
+    return event
+  },
+
+  // Throttling middleware
+  throttle: (eventTypes: string[], delay = 100): EventMiddleware => {
+    const lastTimes = new Map<string, number>()
+    
+    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: string[], delay = 100): EventMiddleware => {
+    const timeouts = new Map<string, NodeJS.Timeout>()
+    const eventQueue = new Map<string, MediaPlayerEvent>()
+    
+    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: MediaPlayerEvent) => boolean): EventMiddleware => (event) => {
+    return predicate(event) ? event : null
+  },
+
+  // Event transformation middleware
+  transform: (transformer: (event: MediaPlayerEvent) => MediaPlayerEvent): EventMiddleware => (event) => {
+    try {
+      return transformer(event)
+    } catch (error) {
+      console.error('Error in event transformer:', error)
+      return event
+    }
+  },
+
+  // Performance monitoring middleware
+  performance: (): EventMiddleware => {
+    const metrics = new Map<string, { count: number; totalTime: number }>()
+    
+    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?: (error: Error, event: MediaPlayerEvent) => void): EventMiddleware => (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 as Error, event)
+      } else {
+        console.error('Event validation error:', error)
+      }
+      return null
+    }
+  },
+
+  // Security middleware (prevent certain events or sanitize data)
+  security: (options: {
+    blockedEventTypes?: string[]
+    sanitizeDetail?: boolean
+    maxDetailSize?: number
+  } = {}): EventMiddleware => (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: (event: MediaPlayerEvent) => boolean, middleware: EventMiddleware): EventMiddleware => (event) => {
+    return condition(event) ? middleware(event) : event
+  },
+
+  // Chain multiple middleware
+  chain: (...middlewares: EventMiddleware[]): EventMiddleware => (event) => {
+    let currentEvent: MediaPlayerEvent | null = event
+    
+    for (const middleware of middlewares) {
+      if (currentEvent === null) break
+      currentEvent = middleware(currentEvent)
+    }
+    
+    return currentEvent
+  }
+}
+
+// Middleware builder class
+export class MiddlewareBuilder {
+  private middlewares: EventMiddleware[] = []
+
+  // Add middleware
+  use(middleware: EventMiddleware): this {
+    this.middlewares.push(middleware)
+    return this
+  }
+
+  // Add logging
+  log(prefix?: string): this {
+    return this.use(eventMiddlewares.logger(prefix))
+  }
+
+  // Add throttling
+  throttle(eventTypes: string[], delay?: number): this {
+    return this.use(eventMiddlewares.throttle(eventTypes, delay))
+  }
+
+  // Add debouncing
+  debounce(eventTypes: string[], delay?: number): this {
+    return this.use(eventMiddlewares.debounce(eventTypes, delay))
+  }
+
+  // Add filtering
+  filter(predicate: (event: MediaPlayerEvent) => boolean): this {
+    return this.use(eventMiddlewares.filter(predicate))
+  }
+
+  // Add transformation
+  transform(transformer: (event: MediaPlayerEvent) => MediaPlayerEvent): this {
+    return this.use(eventMiddlewares.transform(transformer))
+  }
+
+  // Add performance monitoring
+  performance(): this {
+    return this.use(eventMiddlewares.performance())
+  }
+
+  // Add error handling
+  errorHandler(onError?: (error: Error, event: MediaPlayerEvent) => void): this {
+    return this.use(eventMiddlewares.errorHandler(onError))
+  }
+
+  // Add security
+  security(options?: Parameters<typeof eventMiddlewares.security>[0]): this {
+    return this.use(eventMiddlewares.security(options))
+  }
+
+  // Add conditional middleware
+  when(condition: (event: MediaPlayerEvent) => boolean, middleware: EventMiddleware): this {
+    return this.use(eventMiddlewares.when(condition, middleware))
+  }
+
+  // Build the final middleware
+  build(): EventMiddleware {
+    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()
+}

package/src/core/index.ts

@@ -0,0 +1,22 @@
+// Core architecture exports
+
+// Plugin system
+export * from './plugins'
+
+// Event system  
+export * from './events'
+
+// Service providers
+export * from './providers/service-provider'
+
+// Version
+export const CORE_ARCHITECTURE_VERSION = '1.0.0'
+
+// Architecture utilities
+export { createArchitecture } from './utils'
+
+// Progressive loading system
+export * from './progressive-loading'
+
+// Performance monitoring and testing
+export * from './performance'