@therealtinhtute/baroiplayer 1.0.0 → 1.0.1

package/dist/src/core/plugins/base-plugin.ts

@@ -0,0 +1,224 @@
+import type {
+  Plugin,
+  PluginMetadata,
+  PluginContext,
+  PluginConfig,
+  PluginCategory,
+  PluginPriority
+} from './types'
+
+// Abstract base plugin class
+export abstract class BasePlugin implements Plugin {
+  public readonly metadata: PluginMetadata
+
+  protected context?: PluginContext
+  protected config: PluginConfig = {}
+  protected initialized = false
+  protected active = false
+
+  constructor(metadata: Omit<PluginMetadata, 'version'> & { version?: string }) {
+    this.metadata = {
+      version: '1.0.0',
+      ...metadata
+    }
+  }
+
+  // Plugin lifecycle methods - can be overridden by subclasses
+  async initialize(context: PluginContext, config: PluginConfig = {}): Promise<void> {
+    if (this.initialized) {
+      context.logger.warn('Plugin already initialized')
+      return
+    }
+
+    this.context = context
+    this.config = { ...this.config, ...config }
+    
+    try {
+      await this.onInitialize()
+      this.initialized = true
+      context.logger.info(`Plugin initialized`)
+    } catch (error) {
+      context.logger.error('Failed to initialize plugin', error)
+      throw error
+    }
+  }
+
+  async activate(context: PluginContext): Promise<void> {
+    if (!this.initialized) {
+      throw new Error('Plugin must be initialized before activation')
+    }
+
+    if (this.active) {
+      context.logger.warn('Plugin already active')
+      return
+    }
+
+    try {
+      await this.onActivate()
+      this.active = true
+      context.logger.info(`Plugin activated`)
+    } catch (error) {
+      context.logger.error('Failed to activate plugin', error)
+      throw error
+    }
+  }
+
+  async deactivate(context: PluginContext): Promise<void> {
+    if (!this.active) {
+      context.logger.warn('Plugin already inactive')
+      return
+    }
+
+    try {
+      await this.onDeactivate()
+      this.active = false
+      context.logger.info(`Plugin deactivated`)
+    } catch (error) {
+      context.logger.error('Failed to deactivate plugin', error)
+      throw error
+    }
+  }
+
+  async destroy(context: PluginContext): Promise<void> {
+    if (this.active) {
+      await this.deactivate(context)
+    }
+
+    try {
+      await this.onDestroy()
+      this.initialized = false
+      context.logger.info(`Plugin destroyed`)
+    } catch (error) {
+      context.logger.error('Failed to destroy plugin', error)
+      throw error
+    }
+  }
+
+  async configure(config: PluginConfig): Promise<void> {
+    const oldConfig = { ...this.config }
+    this.config = { ...this.config, ...config }
+    
+    try {
+      await this.onConfigure(config, oldConfig)
+      this.context?.logger.info('Plugin configured')
+    } catch (error) {
+      // Rollback configuration on error
+      this.config = oldConfig
+      this.context?.logger.error('Failed to configure plugin', error)
+      throw error
+    }
+  }
+
+  healthCheck(): boolean {
+    return this.initialized && this.onHealthCheck()
+  }
+
+  // Template methods for subclasses to override
+  protected abstract onInitialize(): Promise<void> | void
+  protected abstract onActivate(): Promise<void> | void
+  protected abstract onDeactivate(): Promise<void> | void
+  
+  protected onDestroy(): Promise<void> | void {
+    // Default implementation - subclasses can override
+  }
+
+  protected onConfigure(newConfig: PluginConfig, oldConfig: PluginConfig): Promise<void> | void {
+    // Default implementation - subclasses can override
+  }
+
+  protected onHealthCheck(): boolean {
+    // Default implementation - subclasses can override
+    return true
+  }
+
+  // Utility methods for plugins
+  protected get state() {
+    return this.context?.state
+  }
+
+  protected get controls() {
+    return this.context?.controls
+  }
+
+  protected get element() {
+    return this.context?.element
+  }
+
+  protected get logger() {
+    return this.context?.logger
+  }
+
+  protected emit(event: string, data?: any): void {
+    this.context?.emit(event, data)
+  }
+
+  protected on(event: string, handler: (data: any) => void): () => void {
+    return this.context?.on(event, handler) || (() => {})
+  }
+
+  // Helper methods for common plugin patterns
+  protected addEventListeners(element: HTMLElement, events: Record<string, (e: Event) => void>): () => void {
+    Object.entries(events).forEach(([event, handler]) => {
+      element.addEventListener(event, handler)
+    })
+
+    // Return cleanup function
+    return () => {
+      Object.entries(events).forEach(([event, handler]) => {
+        element.removeEventListener(event, handler)
+      })
+    }
+  }
+
+  protected createConfig<T extends PluginConfig>(defaults: T): T {
+    return { ...defaults, ...this.config } as T
+  }
+
+  // Plugin status
+  get isInitialized(): boolean {
+    return this.initialized
+  }
+
+  get isActive(): boolean {
+    return this.active
+  }
+}
+
+// Simple plugin factory helper
+export function createPlugin<T extends BasePlugin>(
+  PluginClass: new (config?: PluginConfig) => T
+) {
+  return (config?: PluginConfig) => new PluginClass(config)
+}
+
+// Plugin decorator for metadata - TODO: Fix implementation
+// export function plugin(metadata: Omit<PluginMetadata, 'version'> & { version?: string }) {
+//   return function<T extends { new (...args: any[]): BasePlugin }>(constructor: T) {
+//     return class extends constructor {
+//       constructor(...args: any[]) {
+//         super(metadata, ...args)
+//       }
+//     }
+//   }
+// }
+
+// Common plugin configurations
+export interface UIPluginConfig extends PluginConfig {
+  position?: 'top' | 'bottom' | 'left' | 'right' | 'center'
+  zIndex?: number
+  className?: string
+  style?: Record<string, string>
+}
+
+export interface AnalyticsPluginConfig extends PluginConfig {
+  trackingId?: string
+  events?: string[]
+  samplingRate?: number
+  debug?: boolean
+}
+
+export interface PerformancePluginConfig extends PluginConfig {
+  enableMetrics?: boolean
+  reportInterval?: number
+  thresholds?: Record<string, number>
+}

package/dist/src/core/plugins/enhanced-plugin-system.d.ts

@@ -0,0 +1,160 @@
+/**
+ * Enhanced Plugin System with Video.js-inspired hooks architecture
+ * Provides middleware-based extensibility while maintaining backward compatibility
+ */
+import { BasePlugin } from './base-plugin';
+import { MediaPlayerInstance, MediaPlayerConfig } from '../../types';
+export interface MediaPluginHooks {
+    /** Called before player setup, can modify configuration */
+    beforeSetup?: (element: HTMLElement, options: MediaPlayerConfig) => MediaPlayerConfig;
+    /** Called during player setup */
+    setup?: (player: MediaPlayerInstance) => MediaPlayerInstance | void;
+    /** Called when player is ready */
+    ready?: (player: MediaPlayerInstance) => void;
+    /** Called when media source is loaded */
+    sourceLoaded?: (player: MediaPlayerInstance, source: string) => void;
+    /** Called on playback state changes */
+    playbackChange?: (player: MediaPlayerInstance, isPlaying: boolean) => void;
+    /** Called on error events */
+    error?: (player: MediaPlayerInstance, error: MediaError) => MediaError | void;
+    /** Called before player disposal */
+    beforeDispose?: (player: MediaPlayerInstance) => void;
+    /** Called during quality changes */
+    qualityChange?: (player: MediaPlayerInstance, quality: number) => void;
+    /** Called during volume changes */
+    volumeChange?: (player: MediaPlayerInstance, volume: number) => void;
+    /** Called during fullscreen changes */
+    fullscreenChange?: (player: MediaPlayerInstance, isFullscreen: boolean) => void;
+}
+export declare abstract class EnhancedMediaPlugin extends BasePlugin {
+    protected hooks: Partial<MediaPluginHooks>;
+    protected priority: number;
+    protected middleware?: PluginMiddleware;
+    constructor(name: string, config?: any);
+    /**
+     * Override to setup plugin-specific hooks
+     */
+    protected setupHooks(): void;
+    /**
+     * Register a hook
+     */
+    registerHook<K extends keyof MediaPluginHooks>(hookType: K, handler: MediaPluginHooks[K]): void;
+    /**
+     * Execute a hook if it exists
+     */
+    executeHook<K extends keyof MediaPluginHooks>(hookType: K, ...args: Parameters<NonNullable<MediaPluginHooks[K]>>): ReturnType<NonNullable<MediaPluginHooks[K]>> | void;
+    /**
+     * Get plugin priority
+     */
+    getPriority(): number;
+    /**
+     * Set middleware for advanced plugin behavior
+     */
+    setMiddleware(middleware: PluginMiddleware): void;
+}
+export interface PluginMiddleware {
+    name: string;
+    priority: number;
+    execute: (context: PluginContext, next: () => PluginContext | Promise<PluginContext>) => PluginContext | Promise<PluginContext>;
+}
+export interface PluginContext {
+    player: MediaPlayerInstance;
+    event: string;
+    data: any;
+    originalData: any;
+    modified: boolean;
+    stopped: boolean;
+}
+/**
+ * Enhanced Plugin Registry with hooks and middleware support
+ */
+export declare class EnhancedPluginRegistry {
+    private plugins;
+    private middlewares;
+    private hooks;
+    /**
+     * Register a plugin with the system
+     */
+    register(plugin: EnhancedMediaPlugin): void;
+    /**
+     * Unregister a plugin
+     */
+    unregister(pluginName: string): void;
+    /**
+     * Get a registered plugin
+     */
+    getPlugin(name: string): EnhancedMediaPlugin | undefined;
+    /**
+     * Get all registered plugins
+     */
+    getPlugins(): EnhancedMediaPlugin[];
+    /**
+     * Get plugins sorted by priority
+     */
+    getPluginsByPriority(): EnhancedMediaPlugin[];
+    /**
+     * Execute a hook across all registered plugins
+     */
+    executeHook<K extends keyof MediaPluginHooks>(hookType: K, ...args: Parameters<NonNullable<MediaPluginHooks[K]>>): Promise<any[]>;
+    /**
+     * Add middleware to the execution chain
+     */
+    addMiddleware(middleware: PluginMiddleware): void;
+    /**
+     * Remove middleware
+     */
+    removeMiddleware(name: string): void;
+    /**
+     * Execute middleware chain
+     */
+    executeMiddleware(context: PluginContext): Promise<PluginContext>;
+    /**
+     * Register hooks from a plugin
+     */
+    private registerPluginHooks;
+    /**
+     * Unregister hooks from a plugin
+     */
+    private unregisterPluginHooks;
+    /**
+     * Clear all plugins and middleware
+     */
+    clear(): void;
+}
+/**
+ * Plugin Manager for enhanced plugin system integration
+ */
+export declare class EnhancedPluginManager {
+    private registry;
+    private player;
+    constructor(player: MediaPlayerInstance);
+    /**
+     * Setup plugin system for player
+     */
+    setup(options?: MediaPlayerConfig): Promise<void>;
+    /**
+     * Register a plugin
+     */
+    register(plugin: EnhancedMediaPlugin): void;
+    /**
+     * Unregister a plugin
+     */
+    unregister(pluginName: string): void;
+    /**
+     * Execute hooks for specific events
+     */
+    handleEvent(event: string, data: any): Promise<void>;
+    /**
+     * Dispose plugin manager
+     */
+    dispose(): Promise<void>;
+    /**
+     * Get plugin registry
+     */
+    getRegistry(): EnhancedPluginRegistry;
+}
+export declare const createPerformanceMiddleware: () => PluginMiddleware;
+export declare const createErrorHandlingMiddleware: () => PluginMiddleware;
+export declare const createLoggingMiddleware: () => PluginMiddleware;
+export default EnhancedPluginManager;
+//# sourceMappingURL=enhanced-plugin-system.d.ts.map

package/dist/src/core/plugins/enhanced-plugin-system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enhanced-plugin-system.d.ts","sourceRoot":"","sources":["enhanced-plugin-system.ts"],"names":[],"mappings":"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"}

package/dist/src/core/plugins/enhanced-plugin-system.js

@@ -0,0 +1,305 @@
+/**
+ * Enhanced Plugin System with Video.js-inspired hooks architecture
+ * Provides middleware-based extensibility while maintaining backward compatibility
+ */
+import { BasePlugin } from './base-plugin';
+// Enhanced plugin with hooks support
+export class EnhancedMediaPlugin extends BasePlugin {
+    hooks = {};
+    priority = 0;
+    middleware;
+    constructor(name, config = {}) {
+        super(name, config);
+        this.priority = config.priority || 0;
+        this.setupHooks();
+    }
+    /**
+     * Override to setup plugin-specific hooks
+     */
+    setupHooks() {
+        // Override in subclasses
+    }
+    /**
+     * Register a hook
+     */
+    registerHook(hookType, handler) {
+        this.hooks[hookType] = handler;
+    }
+    /**
+     * Execute a hook if it exists
+     */
+    executeHook(hookType, ...args) {
+        const hook = this.hooks[hookType];
+        if (hook) {
+            return hook(...args);
+        }
+    }
+    /**
+     * Get plugin priority
+     */
+    getPriority() {
+        return this.priority;
+    }
+    /**
+     * Set middleware for advanced plugin behavior
+     */
+    setMiddleware(middleware) {
+        this.middleware = middleware;
+    }
+}
+/**
+ * Enhanced Plugin Registry with hooks and middleware support
+ */
+export class EnhancedPluginRegistry {
+    plugins = new Map();
+    middlewares = [];
+    hooks = new Map();
+    /**
+     * Register a plugin with the system
+     */
+    register(plugin) {
+        this.plugins.set(plugin.getName(), plugin);
+        // Register plugin hooks
+        this.registerPluginHooks(plugin);
+        // Register plugin middleware if available
+        if (plugin.middleware) {
+            this.addMiddleware(plugin.middleware);
+        }
+    }
+    /**
+     * Unregister a plugin
+     */
+    unregister(pluginName) {
+        const plugin = this.plugins.get(pluginName);
+        if (plugin) {
+            this.unregisterPluginHooks(plugin);
+            this.plugins.delete(pluginName);
+        }
+    }
+    /**
+     * Get a registered plugin
+     */
+    getPlugin(name) {
+        return this.plugins.get(name);
+    }
+    /**
+     * Get all registered plugins
+     */
+    getPlugins() {
+        return Array.from(this.plugins.values());
+    }
+    /**
+     * Get plugins sorted by priority
+     */
+    getPluginsByPriority() {
+        return Array.from(this.plugins.values()).sort((a, b) => a.getPriority() - b.getPriority());
+    }
+    /**
+     * Execute a hook across all registered plugins
+     */
+    async executeHook(hookType, ...args) {
+        const hookHandlers = this.hooks.get(hookType) || [];
+        const results = [];
+        for (const { plugin, handler } of hookHandlers) {
+            try {
+                const result = await handler(...args);
+                results.push({ plugin, result });
+            }
+            catch (error) {
+                console.error(`Error executing hook ${hookType} in plugin ${plugin}:`, error);
+            }
+        }
+        return results;
+    }
+    /**
+     * Add middleware to the execution chain
+     */
+    addMiddleware(middleware) {
+        this.middlewares.push(middleware);
+        // Sort by priority
+        this.middlewares.sort((a, b) => a.priority - b.priority);
+    }
+    /**
+     * Remove middleware
+     */
+    removeMiddleware(name) {
+        this.middlewares = this.middlewares.filter(m => m.name !== name);
+    }
+    /**
+     * Execute middleware chain
+     */
+    async executeMiddleware(context) {
+        let index = 0;
+        const next = () => {
+            if (index >= this.middlewares.length || context.stopped) {
+                return Promise.resolve(context);
+            }
+            const middleware = this.middlewares[index++];
+            return Promise.resolve(middleware.execute(context, next));
+        };
+        return next();
+    }
+    /**
+     * Register hooks from a plugin
+     */
+    registerPluginHooks(plugin) {
+        const hooks = plugin.hooks || {};
+        Object.entries(hooks).forEach(([hookType, handler]) => {
+            if (handler) {
+                if (!this.hooks.has(hookType)) {
+                    this.hooks.set(hookType, []);
+                }
+                this.hooks.get(hookType).push({
+                    plugin: plugin.getName(),
+                    handler,
+                });
+            }
+        });
+    }
+    /**
+     * Unregister hooks from a plugin
+     */
+    unregisterPluginHooks(plugin) {
+        const hooks = plugin.hooks || {};
+        Object.keys(hooks).forEach((hookType) => {
+            const handlers = this.hooks.get(hookType);
+            if (handlers) {
+                this.hooks.set(hookType, handlers.filter(h => h.plugin !== plugin.getName()));
+            }
+        });
+    }
+    /**
+     * Clear all plugins and middleware
+     */
+    clear() {
+        this.plugins.clear();
+        this.middlewares = [];
+        this.hooks.clear();
+    }
+}
+/**
+ * Plugin Manager for enhanced plugin system integration
+ */
+export class EnhancedPluginManager {
+    registry;
+    player;
+    constructor(player) {
+        this.player = player;
+        this.registry = new EnhancedPluginRegistry();
+    }
+    /**
+     * Setup plugin system for player
+     */
+    async setup(options = {}) {
+        // Execute beforeSetup hooks
+        const setupResults = await this.registry.executeHook('beforeSetup', this.player.getElement(), options);
+        // Apply configuration modifications from hooks
+        const modifiedOptions = setupResults.reduce((acc, { result }) => {
+            return result || acc;
+        }, options);
+        // Execute setup hooks
+        await this.registry.executeHook('setup', this.player);
+        // Execute ready hooks
+        await this.registry.executeHook('ready', this.player);
+    }
+    /**
+     * Register a plugin
+     */
+    register(plugin) {
+        this.registry.register(plugin);
+    }
+    /**
+     * Unregister a plugin
+     */
+    unregister(pluginName) {
+        this.registry.unregister(pluginName);
+    }
+    /**
+     * Execute hooks for specific events
+     */
+    async handleEvent(event, data) {
+        const context = {
+            player: this.player,
+            event,
+            data,
+            originalData: data,
+            modified: false,
+            stopped: false,
+        };
+        // Execute middleware chain
+        const processedContext = await this.registry.executeMiddleware(context);
+        // Execute relevant hooks based on event
+        switch (event) {
+            case 'sourceLoaded':
+                await this.registry.executeHook('sourceLoaded', this.player, data.source);
+                break;
+            case 'playbackChange':
+                await this.registry.executeHook('playbackChange', this.player, data.isPlaying);
+                break;
+            case 'error':
+                await this.registry.executeHook('error', this.player, data.error);
+                break;
+            case 'qualityChange':
+                await this.registry.executeHook('qualityChange', this.player, data.quality);
+                break;
+            case 'volumeChange':
+                await this.registry.executeHook('volumeChange', this.player, data.volume);
+                break;
+            case 'fullscreenChange':
+                await this.registry.executeHook('fullscreenChange', this.player, data.isFullscreen);
+                break;
+        }
+    }
+    /**
+     * Dispose plugin manager
+     */
+    async dispose() {
+        // Execute beforeDispose hooks
+        await this.registry.executeHook('beforeDispose', this.player);
+        // Clear registry
+        this.registry.clear();
+    }
+    /**
+     * Get plugin registry
+     */
+    getRegistry() {
+        return this.registry;
+    }
+}
+// Default middlewares
+export const createPerformanceMiddleware = () => ({
+    name: 'performance',
+    priority: 0,
+    execute: async (context, next) => {
+        const start = performance.now();
+        const result = await next();
+        const duration = performance.now() - start;
+        if (duration > 16) { // Log slow operations
+            console.warn(`Slow plugin operation: ${context.event} took ${duration.toFixed(2)}ms`);
+        }
+        return result;
+    },
+});
+export const createErrorHandlingMiddleware = () => ({
+    name: 'errorHandling',
+    priority: -1000, // Run last
+    execute: async (context, next) => {
+        try {
+            return await next();
+        }
+        catch (error) {
+            console.error(`Plugin error in ${context.event}:`, error);
+            context.stopped = true;
+            return context;
+        }
+    },
+});
+export const createLoggingMiddleware = () => ({
+    name: 'logging',
+    priority: 1000, // Run first
+    execute: async (context, next) => {
+        console.debug(`Plugin event: ${context.event}`, context.data);
+        return next();
+    },
+});
+export default EnhancedPluginManager;