@therealtinhtute/baroiplayer 1.0.0

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

@@ -0,0 +1,442 @@
+// Event system types
+export interface MediaPlayerEvent {
+  type: string
+  timestamp: number
+  target?: string
+  detail?: any
+  bubbles?: boolean
+  cancelable?: boolean
+  defaultPrevented?: boolean
+}
+
+export type EventHandler<T = any> = (event: MediaPlayerEvent & { detail: T }) => void
+export type EventUnsubscriber = () => void
+
+export interface EventOptions {
+  once?: boolean
+  passive?: boolean
+  priority?: 'high' | 'normal' | 'low'
+  filter?: (event: MediaPlayerEvent) => boolean
+}
+
+// Event categories for organization
+export type EventCategory = 
+  | 'media'      // Media playback events
+  | 'user'       // User interaction events  
+  | 'system'     // System/internal events
+  | 'plugin'     // Plugin events
+  | 'error'      // Error events
+  | 'performance' // Performance events
+
+// Standard media events
+export interface MediaEvents {
+  // Playback events
+  'media:loadstart': { src: string }
+  'media:loadeddata': { duration: number }
+  'media:canplay': {}
+  'media:canplaythrough': {}
+  'media:play': { currentTime: number }
+  'media:pause': { currentTime: number }
+  'media:ended': { duration: number }
+  'media:seeking': { currentTime: number, targetTime: number }
+  'media:seeked': { currentTime: number, previousTime: number }
+  'media:timeupdate': { currentTime: number, duration: number }
+  'media:durationchange': { duration: number }
+  'media:volumechange': { volume: number, muted: boolean }
+  'media:ratechange': { playbackRate: number }
+  
+  // Loading events
+  'media:loadedmetadata': { src: string }
+  'media:progress': { buffered: TimeRanges }
+  'media:suspend': {}
+  'media:abort': {}
+  'media:error': { error: Error }
+  'media:stalled': {}
+  'media:waiting': {}
+  
+  // User interaction events  
+  'user:click': { x: number, y: number, element: string }
+  'user:hover': { element: string }
+  'user:focus': { element: string }
+  'user:keyboard': { key: string, code: string, altKey: boolean, ctrlKey: boolean, shiftKey: boolean }
+  'user:gesture': { type: string, data: any }
+  
+  // System events
+  'system:ready': {}
+  'system:resize': { width: number, height: number }
+  'system:fullscreen': { isFullscreen: boolean }
+  'system:pip': { isPictureInPicture: boolean }
+  'system:visibility': { isVisible: boolean }
+  
+  // Plugin events
+  'plugin:loaded': { name: string }
+  'plugin:enabled': { name: string }
+  'plugin:disabled': { name: string }
+  'plugin:error': { name: string, error: Error }
+  
+  // Performance events
+  'performance:fps': { fps: number }
+  'performance:memory': { used: number, total: number }
+  'performance:load': { loadTime: number }
+}
+
+// Event bus implementation
+export class EventBus {
+  private listeners = new Map<string, Array<{
+    handler: EventHandler
+    options: EventOptions
+    id: string
+  }>>()
+  
+  private eventQueue: MediaPlayerEvent[] = []
+  private isProcessing = false
+  private middlewares: Array<(event: MediaPlayerEvent) => MediaPlayerEvent | null> = []
+  private eventHistory: MediaPlayerEvent[] = []
+  private maxHistorySize = 1000
+
+  // Subscribe to events
+  on<K extends keyof MediaEvents>(
+    type: K,
+    handler: EventHandler<MediaEvents[K]>,
+    options: EventOptions = {}
+  ): EventUnsubscriber {
+    return this.addEventListener(type, handler as EventHandler, options)
+  }
+
+  // Subscribe to events (one-time)
+  once<K extends keyof MediaEvents>(
+    type: K,
+    handler: EventHandler<MediaEvents[K]>,
+    options: EventOptions = {}
+  ): EventUnsubscriber {
+    return this.addEventListener(type, handler as EventHandler, { ...options, once: true })
+  }
+
+  // Subscribe to events with wildcard support
+  addEventListener(
+    type: string,
+    handler: EventHandler,
+    options: EventOptions = {}
+  ): EventUnsubscriber {
+    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: string, handler?: EventHandler): void {
+    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<K extends keyof MediaEvents>(
+    type: K,
+    detail?: MediaEvents[K],
+    options?: Partial<MediaPlayerEvent>
+  ): boolean {
+    const event: MediaPlayerEvent = {
+      type,
+      timestamp: Date.now(),
+      detail,
+      bubbles: true,
+      cancelable: true,
+      defaultPrevented: false,
+      ...options
+    }
+
+    return this.dispatchEvent(event)
+  }
+
+  // Dispatch event
+  dispatchEvent(event: MediaPlayerEvent): boolean {
+    // Apply middlewares
+    let processedEvent: MediaPlayerEvent | null = 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
+  private processEventQueue(): void {
+    if (this.isProcessing) return
+
+    this.isProcessing = true
+
+    // Use scheduler for non-blocking event processing
+    const schedule = (typeof window !== 'undefined' && 'scheduler' in window)
+      ? (window as any).scheduler.postTask
+      : (cb: () => void) => 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
+  private async processEvent(event: MediaPlayerEvent): Promise<void> {
+    const { type } = event
+
+    // Get exact matches
+    const exactListeners = this.listeners.get(type) || []
+    
+    // Get wildcard matches
+    const wildcardListeners: typeof exactListeners = []
+    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: string[] = []
+
+    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 as any))
+
+        // 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: (event: MediaPlayerEvent) => MediaPlayerEvent | null): () => void {
+    this.middlewares.push(middleware)
+    return () => {
+      const index = this.middlewares.indexOf(middleware)
+      if (index !== -1) {
+        this.middlewares.splice(index, 1)
+      }
+    }
+  }
+
+  // Event history management
+  private addToHistory(event: MediaPlayerEvent): void {
+    this.eventHistory.push(event)
+    if (this.eventHistory.length > this.maxHistorySize) {
+      this.eventHistory.shift()
+    }
+  }
+
+  // Get event history
+  getHistory(filter?: (event: MediaPlayerEvent) => boolean): MediaPlayerEvent[] {
+    return filter ? this.eventHistory.filter(filter) : [...this.eventHistory]
+  }
+
+  // Clear event history
+  clearHistory(): void {
+    this.eventHistory = []
+  }
+
+  // Pattern matching for wildcards
+  private matchPattern(eventType: string, pattern: string): boolean {
+    const regex = new RegExp(
+      '^' + pattern.replace(/\*/g, '.*').replace(/\?/g, '.') + '$'
+    )
+    return regex.test(eventType)
+  }
+
+  // Generate unique ID
+  private generateId(): string {
+    return `event_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
+  }
+
+  // Get listener count
+  getListenerCount(type?: string): number {
+    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(): string[] {
+    return Array.from(this.listeners.keys())
+  }
+
+  // Clear all listeners
+  removeAllListeners(type?: string): void {
+    if (type) {
+      this.listeners.delete(type)
+    } else {
+      this.listeners.clear()
+    }
+  }
+
+  // Destroy event bus
+  destroy(): void {
+    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 {
+  private eventBus: EventBus
+  private element: HTMLElement
+  private delegatedEvents = new Set<string>()
+
+  constructor(eventBus: EventBus, element: HTMLElement) {
+    this.eventBus = eventBus
+    this.element = element
+  }
+
+  // Delegate DOM events to event bus
+  delegate(domEvent: string, mediaEvent?: string): void {
+    if (this.delegatedEvents.has(domEvent)) return
+
+    const handler = (e: Event) => {
+      this.eventBus.emit(mediaEvent || `dom:${domEvent}` as any, {
+        originalEvent: e,
+        target: (e.target as HTMLElement)?.tagName.toLowerCase(),
+        currentTarget: (e.currentTarget as HTMLElement)?.tagName.toLowerCase()
+      })
+    }
+
+    this.element.addEventListener(domEvent, handler, { passive: true })
+    this.delegatedEvents.add(domEvent)
+  }
+
+  // Setup common delegations
+  setupCommonDelegations(): void {
+    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(): void {
+    this.delegatedEvents.clear()
+  }
+}
+