@therealtinhtute/baroiplayer 1.0.8 → 1.2.0

package/dist/src/core/plugins/index.ts

@@ -1,39 +0,0 @@
-// Plugin system core exports
-export type {
-  Plugin,
-  PluginFactory,
-  PluginConfig,
-  PluginRegistry as IPluginRegistry,
-  PluginContext,
-  PluginLogger,
-  PluginMetadata,
-  PluginCategory,
-  PluginPriority,
-  PluginPhase,
-  PluginEvents
-} from './types'
-
-export {
-  PluginError,
-  PluginDependencyError,
-  PluginConflictError
-} from './types'
-
-export { PluginRegistry } from './registry'
-
-export {
-  BasePlugin,
-  createPlugin,
-  type UIPluginConfig,
-  type AnalyticsPluginConfig,
-  type PerformancePluginConfig
-} from './base-plugin'
-
-// Example plugins
-export { AnalyticsPlugin, createAnalyticsPlugin } from './examples/analytics-plugin'
-
-// Plugin utilities
-export * from './utils'
-
-// Version
-export const PLUGIN_SYSTEM_VERSION = '1.0.0'

package/dist/src/core/plugins/registry.d.ts

@@ -1,31 +0,0 @@
-import type { Plugin, PluginFactory, PluginConfig, PluginRegistry as IPluginRegistry, PluginLogger, PluginEvents } from './types';
-export declare class PluginRegistry implements IPluginRegistry {
-    private plugins;
-    private pluginConfigs;
-    private enabledPlugins;
-    private eventBus;
-    private logger;
-    constructor(logger: PluginLogger);
-    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>;
-    enablePlugins(names: string[]): Promise<void>;
-    disablePlugins(names: string[]): Promise<void>;
-    getEnabledPlugins(): Plugin[];
-    healthCheck(): Promise<{
-        name: string;
-        healthy: boolean;
-        error?: Error;
-    }[]>;
-    on<K extends keyof PluginEvents>(event: K, listener: (data: PluginEvents[K]) => void): () => void;
-    private createPluginContext;
-    private createPluginLogger;
-    private resolveDependencies;
-    private sortByPriority;
-}
-//# sourceMappingURL=registry.d.ts.map

package/dist/src/core/plugins/registry.ts

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

@@ -1,101 +0,0 @@
-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;
-}
-export type PluginPhase = 'initialize' | 'activate' | 'deactivate' | 'destroy';
-export type PluginCategory = 'controls' | 'analytics' | 'streaming' | 'subtitle' | 'quality' | 'ui' | 'accessibility' | 'performance';
-export type PluginPriority = 'high' | 'medium' | 'low';
-export interface PluginConfig {
-    [key: string]: any;
-}
-export interface PluginContext {
-    state: MediaState;
-    controls: MediaPlayerControls;
-    plugins: PluginRegistry;
-    emit: (event: string, data?: any) => void;
-    on: (event: string, handler: (data: any) => void) => () => void;
-    element: HTMLElement | null;
-    logger: PluginLogger;
-}
-export interface PluginMetadata {
-    name: string;
-    version: string;
-    description: string;
-    author?: string;
-    category: PluginCategory;
-    priority: PluginPriority;
-    dependencies?: string[];
-    conflicts?: string[];
-}
-export interface Plugin {
-    metadata: PluginMetadata;
-    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;
-    configure?(config: PluginConfig): Promise<void> | void;
-    healthCheck?(): Promise<boolean> | boolean;
-}
-export type PluginFactory<T extends Plugin = Plugin> = (config?: PluginConfig) => T;
-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>;
-}
-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;
-}
-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;
-    };
-}
-export declare class PluginError extends Error {
-    pluginName: string;
-    phase: PluginPhase;
-    originalError?: Error | undefined;
-    constructor(pluginName: string, phase: PluginPhase, message: string, originalError?: Error | undefined);
-}
-export declare class PluginDependencyError extends PluginError {
-    missingDependencies: string[];
-    constructor(pluginName: string, missingDependencies: string[]);
-}
-export declare class PluginConflictError extends PluginError {
-    conflictingPlugins: string[];
-    constructor(pluginName: string, conflictingPlugins: string[]);
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/src/core/plugins/types.ts

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

package/dist/src/core/plugins/utils.d.ts

@@ -1,38 +0,0 @@
-import type { Plugin, PluginLogger, PluginConfig } from './types';
-export declare class ConsolePluginLogger implements PluginLogger {
-    private prefix;
-    constructor(prefix?: string);
-    info(message: string, data?: any): void;
-    warn(message: string, data?: any): void;
-    error(message: string, data?: any): void;
-    debug(message: string, data?: any): void;
-}
-export declare class PluginValidator {
-    static validateMetadata(plugin: Plugin): boolean;
-    static validateConfig(config: PluginConfig, schema?: Record<string, any>): boolean;
-}
-export declare class PluginPerformanceMonitor {
-    private metrics;
-    measure<T>(pluginName: string, operation: string, fn: () => T | Promise<T>): T | Promise<T>;
-    getMetrics(pluginName?: string): Record<string, any>;
-    reset(pluginName?: string): void;
-}
-export declare const PluginDevelopmentHelpers: {
-    createMockContext(): any;
-    createTestPlugin(name: string, hooks?: Partial<Plugin>): Plugin;
-    time: {
-        async: <T>(label: string, fn: () => Promise<T>) => Promise<T>;
-        sync: <T>(label: string, fn: () => T) => T;
-    };
-};
-export declare class PluginStorage {
-    private prefix;
-    constructor(pluginName: string);
-    get<T>(key: string, defaultValue?: T): T | undefined;
-    set<T>(key: string, value: T): void;
-    remove(key: string): void;
-    clear(): void;
-}
-export declare const defaultPluginLogger: ConsolePluginLogger;
-export declare const defaultPerformanceMonitor: PluginPerformanceMonitor;
-//# sourceMappingURL=utils.d.ts.map