@therealtinhtute/baroiplayer 1.2.1 → 2.0.0-beta.1

package/src/core/events/hooks.ts

@@ -1,325 +0,0 @@
-import React, { useEffect, useRef, useCallback, useMemo, useState } from "react"
-import {
-	EventBus,
-	type EventHandler,
-	type EventOptions,
-	type EventUnsubscriber,
-	type MediaEvents
-} from "./event-system"
-
-// Hook to use event bus with React
-export function useEventBus(eventBus?: EventBus): EventBus {
-	const [eventBusInstance, setEventBusInstance] = useState(() => eventBus || new EventBus())
-
-	useEffect(() => {
-		// If an external eventBus is provided, we don't manage its lifecycle
-		if (eventBus) {
-			setEventBusInstance(eventBus)
-			return () => {
-				// Don't destroy externally provided event bus
-			}
-		}
-
-		return () => {
-			// Cleanup internally created event bus on unmount
-			eventBusInstance.destroy()
-		}
-	}, [eventBus, eventBusInstance])
-
-	return eventBusInstance
-}
-
-// 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])
-}
-
-// 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 [history, setHistory] = useState<any[]>([])
-
-	useEffect(() => {
-		const unsubscribe = eventBus.addEventListener("*", (event) => {
-			if (!filter || filter(event)) {
-				setHistory((prevHistory) => {
-					const newHistory = [...prevHistory, event]
-
-					// Limit history size
-					if (newHistory.length > maxSize) {
-						return newHistory.slice(-maxSize)
-					}
-
-					return newHistory
-				})
-			}
-		})
-
-		return unsubscribe
-	}, [eventBus, filter, maxSize])
-
-	const clearHistory = useCallback(() => {
-		setHistory([])
-	}, [])
-
-	return {
-		history,
-		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])
-
-	useEffect(() => {
-		if (!shouldListen) return
-
-		const unsubscribe = eventBus.on(type, handler, options)
-		return unsubscribe
-	}, [eventBus, type, shouldListen])
-}
-
-// 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)
-		}, []),
-		undefined,
-		deps
-	)
-
-	useEffect(() => {
-		return () => {
-			if (typeof cleanupRef.current === "function") {
-				cleanupRef.current()
-			}
-		}
-	}, [])
-}

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

@@ -1,286 +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/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"