@therealtinhtute/baroiplayer 1.0.8 → 1.1.0

package/src/core/events/middleware.ts

@@ -1,244 +1,263 @@
-import type { MediaPlayerEvent } from './event-system'
+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
-  }
+	// 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)
-  }
+	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
@@ -246,24 +265,22 @@ 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()
-}
+	// 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 +1,22 @@
 // Core architecture exports
 
 // Plugin system
-export * from './plugins'
+export * from "./plugins"
 
-// Event system  
-export * from './events'
+// Event system
+export * from "./events"
 
 // Service providers
-export * from './providers/service-provider'
+export * from "./providers/service-provider"
 
 // Version
-export const CORE_ARCHITECTURE_VERSION = '1.0.0'
+export const CORE_ARCHITECTURE_VERSION = "1.0.0"
 
 // Architecture utilities
-export { createArchitecture } from './utils'
+export { createArchitecture } from "./utils"
 
 // Progressive loading system
-export * from './progressive-loading'
+export * from "./progressive-loading"
 
 // Performance monitoring and testing
-export * from './performance'
+export * from "./performance"