@therealtinhtute/baroiplayer 1.0.0

package/src/core/plugins/registry.ts

@@ -0,0 +1,327 @@
+import { EventBus } from '../events/event-system'
+import type {
+  Plugin,
+  PluginFactory,
+  PluginConfig,
+  PluginRegistry as IPluginRegistry,
+  PluginContext,
+  PluginLogger,
+  PluginEvents,
+  PluginPriority
+} from './types'
+import {
+  PluginError,
+  PluginDependencyError,
+  PluginConflictError
+} from './types'
+
+// Plugin registry implementation
+export class PluginRegistry implements IPluginRegistry {
+  private plugins = new Map<string, Plugin>()
+  private pluginConfigs = new Map<string, PluginConfig>()
+  private enabledPlugins = new Set<string>()
+  private eventBus = new EventBus()
+  private logger: PluginLogger
+
+  constructor(logger: PluginLogger) {
+    this.logger = logger
+  }
+
+  // Register a plugin factory
+  async register(factory: PluginFactory, config: PluginConfig = {}): Promise<void> {
+    try {
+      const plugin = factory(config)
+      const { name, dependencies = [], conflicts = [] } = plugin.metadata
+
+      // Check if plugin already exists
+      if (this.plugins.has(name)) {
+        throw new PluginError(name, 'initialize', 'Plugin already registered')
+      }
+
+      // Validate dependencies
+      const missingDependencies = dependencies.filter(dep => !this.plugins.has(dep))
+      if (missingDependencies.length > 0) {
+        throw new PluginDependencyError(name, missingDependencies)
+      }
+
+      // Check for conflicts with enabled plugins
+      const activeConflicts = conflicts.filter(conflict => this.enabledPlugins.has(conflict))
+      if (activeConflicts.length > 0) {
+        throw new PluginConflictError(name, activeConflicts)
+      }
+
+      // Store plugin and configuration
+      this.plugins.set(name, plugin)
+      this.pluginConfigs.set(name, config)
+
+      this.logger.info(`Plugin '${name}' registered successfully`)
+      ;(this.eventBus as any).emit('plugin:registered', { name, plugin })
+
+    } catch (error) {
+      const pluginName = factory({}).metadata.name
+      this.logger.error(`Failed to register plugin '${pluginName}'`, error)
+      ;(this.eventBus as any).emit('plugin:error', { name: pluginName, error: error as Error })
+      throw error
+    }
+  }
+
+  // Unregister a plugin
+  async unregister(name: string): Promise<void> {
+    const plugin = this.plugins.get(name)
+    if (!plugin) {
+      throw new PluginError(name, 'destroy', 'Plugin not found')
+    }
+
+    try {
+      // Disable plugin if enabled
+      if (this.enabledPlugins.has(name)) {
+        await this.disable(name)
+      }
+
+      // Remove from registry
+      this.plugins.delete(name)
+      this.pluginConfigs.delete(name)
+
+      this.logger.info(`Plugin '${name}' unregistered successfully`)
+    } catch (error) {
+      this.logger.error(`Failed to unregister plugin '${name}'`, error)
+      throw error
+    }
+  }
+
+  // Get a plugin by name
+  get(name: string): Plugin | undefined {
+    return this.plugins.get(name)
+  }
+
+  // Get all plugins sorted by priority
+  getAll(): Plugin[] {
+    return Array.from(this.plugins.values()).sort(this.sortByPriority)
+  }
+
+  // Check if plugin is enabled
+  isEnabled(name: string): boolean {
+    return this.enabledPlugins.has(name)
+  }
+
+  // Enable a plugin
+  async enable(name: string): Promise<void> {
+    const plugin = this.plugins.get(name)
+    if (!plugin) {
+      throw new PluginError(name, 'activate', 'Plugin not found')
+    }
+
+    if (this.enabledPlugins.has(name)) {
+      this.logger.warn(`Plugin '${name}' is already enabled`)
+      return
+    }
+
+    try {
+      const context = this.createPluginContext(name)
+      const config = this.pluginConfigs.get(name)
+
+      // Initialize plugin
+      await plugin.initialize(context, config)
+      
+      // Activate plugin
+      await plugin.activate(context)
+      
+      this.enabledPlugins.add(name)
+      this.logger.info(`Plugin '${name}' enabled successfully`)
+      ;(this.eventBus as any).emit('plugin:enabled', { name, plugin })
+
+    } catch (error) {
+      this.logger.error(`Failed to enable plugin '${name}'`, error)
+      ;(this.eventBus as any).emit('plugin:error', { name, error: error as Error })
+      throw error
+    }
+  }
+
+  // Disable a plugin
+  async disable(name: string): Promise<void> {
+    const plugin = this.plugins.get(name)
+    if (!plugin) {
+      throw new PluginError(name, 'deactivate', 'Plugin not found')
+    }
+
+    if (!this.enabledPlugins.has(name)) {
+      this.logger.warn(`Plugin '${name}' is already disabled`)
+      return
+    }
+
+    try {
+      const context = this.createPluginContext(name)
+
+      // Deactivate plugin
+      await plugin.deactivate(context)
+      
+      // Destroy plugin resources
+      await plugin.destroy(context)
+      
+      this.enabledPlugins.delete(name)
+      this.logger.info(`Plugin '${name}' disabled successfully`)
+      ;(this.eventBus as any).emit('plugin:disabled', { name, plugin })
+
+    } catch (error) {
+      this.logger.error(`Failed to disable plugin '${name}'`, error)
+      ;(this.eventBus as any).emit('plugin:error', { name, error: error as Error })
+      throw error
+    }
+  }
+
+  // Configure a plugin
+  async configure(name: string, config: PluginConfig): Promise<void> {
+    const plugin = this.plugins.get(name)
+    if (!plugin) {
+      throw new PluginError(name, 'initialize', 'Plugin not found')
+    }
+
+    try {
+      // Update stored configuration
+      this.pluginConfigs.set(name, { ...this.pluginConfigs.get(name), ...config })
+
+      // If plugin has configure method, call it
+      if (plugin.configure) {
+        await plugin.configure(config)
+      }
+
+      this.logger.info(`Plugin '${name}' configured successfully`)
+      ;(this.eventBus as any).emit('plugin:configured', { name, config })
+
+    } catch (error) {
+      this.logger.error(`Failed to configure plugin '${name}'`, error)
+      ;(this.eventBus as any).emit('plugin:error', { name, error: error as Error })
+      throw error
+    }
+  }
+
+  // Enable multiple plugins with dependency resolution
+  async enablePlugins(names: string[]): Promise<void> {
+    const resolved = this.resolveDependencies(names)
+    
+    for (const name of resolved) {
+      if (!this.enabledPlugins.has(name)) {
+        await this.enable(name)
+      }
+    }
+  }
+
+  // Disable multiple plugins
+  async disablePlugins(names: string[]): Promise<void> {
+    // Disable in reverse order to handle dependencies
+    const reversed = [...names].reverse()
+    
+    for (const name of reversed) {
+      if (this.enabledPlugins.has(name)) {
+        await this.disable(name)
+      }
+    }
+  }
+
+  // Get enabled plugins
+  getEnabledPlugins(): Plugin[] {
+    return Array.from(this.enabledPlugins)
+      .map(name => this.plugins.get(name)!)
+      .filter(Boolean)
+      .sort(this.sortByPriority)
+  }
+
+  // Health check for all enabled plugins
+  async healthCheck(): Promise<{ name: string; healthy: boolean; error?: Error }[]> {
+    const results = []
+    
+    for (const name of this.enabledPlugins) {
+      const plugin = this.plugins.get(name)!
+      try {
+        const healthy = plugin.healthCheck ? await plugin.healthCheck() : true
+        results.push({ name, healthy })
+      } catch (error) {
+        results.push({ name, healthy: false, error: error as Error })
+      }
+    }
+    
+    return results
+  }
+
+  // Event handling
+  on<K extends keyof PluginEvents>(
+    event: K,
+    listener: (data: PluginEvents[K]) => void
+  ): () => void {
+    (this.eventBus as any).on(event, listener)
+    return () => (this.eventBus as any).off(event, listener)
+  }
+
+  // Create plugin context (will be implemented when we have the full context)
+  private createPluginContext(pluginName: string): PluginContext {
+    // This will be implemented when we integrate with the media player
+    // For now, return a minimal context
+    return {
+      state: {} as any,
+      controls: {} as any,
+      plugins: this,
+      emit: (event: string, data?: any) => (this.eventBus as any).emit(event, data),
+      on: (event: string, handler: (data: any) => void) => {
+        (this.eventBus as any).on(event, handler)
+        return () => (this.eventBus as any).off(event, handler)
+      },
+      element: null,
+      logger: this.createPluginLogger(pluginName)
+    }
+  }
+
+  // Create plugin-specific logger
+  private createPluginLogger(pluginName: string): PluginLogger {
+    return {
+      info: (message: string, data?: any) => this.logger.info(`[${pluginName}] ${message}`, data),
+      warn: (message: string, data?: any) => this.logger.warn(`[${pluginName}] ${message}`, data),
+      error: (message: string, data?: any) => this.logger.error(`[${pluginName}] ${message}`, data),
+      debug: (message: string, data?: any) => this.logger.debug(`[${pluginName}] ${message}`, data)
+    }
+  }
+
+  // Resolve plugin dependencies
+  private resolveDependencies(names: string[]): string[] {
+    const resolved: string[] = []
+    const visiting = new Set<string>()
+
+    const visit = (name: string) => {
+      if (resolved.includes(name)) return
+      if (visiting.has(name)) {
+        throw new PluginError(name, 'initialize', 'Circular dependency detected')
+      }
+
+      visiting.add(name)
+      
+      const plugin = this.plugins.get(name)
+      if (!plugin) {
+        throw new PluginError(name, 'initialize', 'Plugin not found')
+      }
+
+      // Visit dependencies first
+      for (const dep of plugin.metadata.dependencies || []) {
+        visit(dep)
+      }
+
+      visiting.delete(name)
+      resolved.push(name)
+    }
+
+    for (const name of names) {
+      visit(name)
+    }
+
+    return resolved
+  }
+
+  // Sort plugins by priority
+  private sortByPriority(a: Plugin, b: Plugin): number {
+    const priorityOrder: Record<PluginPriority, number> = {
+      high: 3,
+      medium: 2,
+      low: 1
+    }
+    
+    return priorityOrder[b.metadata.priority] - priorityOrder[a.metadata.priority]
+  }
+}

package/src/core/plugins/types.ts

@@ -0,0 +1,159 @@
+// TODO: Import proper types when integrated
+export interface MediaState {
+  isPlaying: boolean
+  currentTime: number
+  duration: number
+  volume: number
+  isMuted: boolean
+}
+
+export interface MediaPlayerControls {
+  play(): void
+  pause(): void
+  seek(time: number): void
+  setVolume(volume: number): void
+}
+
+// Plugin lifecycle phases
+export type PluginPhase = 'initialize' | 'activate' | 'deactivate' | 'destroy'
+
+// Plugin categories for organization
+export type PluginCategory = 
+  | 'controls' 
+  | 'analytics' 
+  | 'streaming' 
+  | 'subtitle' 
+  | 'quality' 
+  | 'ui' 
+  | 'accessibility'
+  | 'performance'
+
+// Plugin priority for execution order
+export type PluginPriority = 'high' | 'medium' | 'low'
+
+// Plugin configuration interface
+export interface PluginConfig {
+  [key: string]: any
+}
+
+// Plugin context provided to each plugin
+export interface PluginContext {
+  // Core media player state and controls
+  state: MediaState
+  controls: MediaPlayerControls
+  
+  // Plugin management
+  plugins: PluginRegistry
+  
+  // Event system
+  emit: (event: string, data?: any) => void
+  on: (event: string, handler: (data: any) => void) => () => void
+  
+  // Utilities
+  element: HTMLElement | null
+  logger: PluginLogger
+}
+
+// Plugin metadata
+export interface PluginMetadata {
+  name: string
+  version: string
+  description: string
+  author?: string
+  category: PluginCategory
+  priority: PluginPriority
+  dependencies?: string[]
+  conflicts?: string[]
+}
+
+// Plugin interface that all plugins must implement
+export interface Plugin {
+  metadata: PluginMetadata
+  
+  // Plugin lifecycle methods
+  initialize(context: PluginContext, config?: PluginConfig): Promise<void> | void
+  activate(context: PluginContext): Promise<void> | void
+  deactivate(context: PluginContext): Promise<void> | void
+  destroy(context: PluginContext): Promise<void> | void
+  
+  // Configuration handling
+  configure?(config: PluginConfig): Promise<void> | void
+  
+  // Health check for plugin status
+  healthCheck?(): Promise<boolean> | boolean
+}
+
+// Plugin factory function type
+export type PluginFactory<T extends Plugin = Plugin> = (config?: PluginConfig) => T
+
+// Plugin registry interface
+export interface PluginRegistry {
+  register(factory: PluginFactory, config?: PluginConfig): Promise<void>
+  unregister(name: string): Promise<void>
+  get(name: string): Plugin | undefined
+  getAll(): Plugin[]
+  isEnabled(name: string): boolean
+  enable(name: string): Promise<void>
+  disable(name: string): Promise<void>
+  configure(name: string, config: PluginConfig): Promise<void>
+}
+
+// Plugin logger interface
+export interface PluginLogger {
+  info(message: string, data?: any): void
+  warn(message: string, data?: any): void
+  error(message: string, data?: any): void
+  debug(message: string, data?: any): void
+}
+
+// Plugin event types
+export interface PluginEvents {
+  'plugin:registered': { name: string; plugin: Plugin }
+  'plugin:enabled': { name: string; plugin: Plugin }
+  'plugin:disabled': { name: string; plugin: Plugin }
+  'plugin:error': { name: string; error: Error }
+  'plugin:configured': { name: string; config: PluginConfig }
+}
+
+// Plugin error types
+export class PluginError extends Error {
+  constructor(
+    public pluginName: string,
+    public phase: PluginPhase,
+    message: string,
+    public originalError?: Error
+  ) {
+    super(`Plugin '${pluginName}' failed during ${phase}: ${message}`)
+    this.name = 'PluginError'
+  }
+}
+
+// Plugin dependency error
+export class PluginDependencyError extends PluginError {
+  constructor(
+    pluginName: string,
+    public missingDependencies: string[]
+  ) {
+    super(
+      pluginName,
+      'initialize',
+      `Missing dependencies: ${missingDependencies.join(', ')}`
+    )
+    this.name = 'PluginDependencyError'
+  }
+}
+
+// Plugin conflict error
+export class PluginConflictError extends PluginError {
+  constructor(
+    pluginName: string,
+    public conflictingPlugins: string[]
+  ) {
+    super(
+      pluginName,
+      'activate',
+      `Conflicts with active plugins: ${conflictingPlugins.join(', ')}`
+    )
+    this.name = 'PluginConflictError'
+  }
+}