@therealtinhtute/baroiplayer 1.0.8 → 1.2.0

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

@@ -1,302 +0,0 @@
-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

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

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

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

@@ -1,269 +0,0 @@
-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/dist/src/core/index.d.ts

@@ -1,8 +0,0 @@
-export * from './plugins';
-export * from './events';
-export * from './providers/service-provider';
-export declare const CORE_ARCHITECTURE_VERSION = "1.0.0";
-export { createArchitecture } from './utils';
-export * from './progressive-loading';
-export * from './performance';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/core/index.ts

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