@therealtinhtute/baroiplayer 1.0.0

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

@@ -0,0 +1,411 @@
+/**
+ * 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';
+
+// Plugin hooks interface inspired by Video.js architecture
+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;
+}
+
+// Enhanced plugin with hooks support
+export abstract class EnhancedMediaPlugin extends BasePlugin {
+	protected hooks: Partial<MediaPluginHooks> = {};
+	protected priority: number = 0;
+	protected middleware?: PluginMiddleware;
+
+	constructor(name: string, config: any = {}) {
+		super(name, config);
+		this.priority = config.priority || 0;
+		this.setupHooks();
+	}
+
+	/**
+	 * Override to setup plugin-specific hooks
+	 */
+	protected setupHooks(): void {
+		// Override in subclasses
+	}
+
+	/**
+	 * Register a hook
+	 */
+	public registerHook<K extends keyof MediaPluginHooks>(
+		hookType: K,
+		handler: MediaPluginHooks[K]
+	): void {
+		this.hooks[hookType] = handler;
+	}
+
+	/**
+	 * Execute a hook if it exists
+	 */
+	public executeHook<K extends keyof MediaPluginHooks>(
+		hookType: K,
+		...args: Parameters<NonNullable<MediaPluginHooks[K]>>
+	): ReturnType<NonNullable<MediaPluginHooks[K]>> | void {
+		const hook = this.hooks[hookType];
+		if (hook) {
+			return (hook as any)(...args);
+		}
+	}
+
+	/**
+	 * Get plugin priority
+	 */
+	public getPriority(): number {
+		return this.priority;
+	}
+
+	/**
+	 * Set middleware for advanced plugin behavior
+	 */
+	public setMiddleware(middleware: PluginMiddleware): void {
+		this.middleware = middleware;
+	}
+}
+
+// Middleware interface for plugin system
+export interface PluginMiddleware {
+	name: string;
+	priority: number;
+	execute: (
+		context: PluginContext,
+		next: () => PluginContext | Promise<PluginContext>
+	) => PluginContext | Promise<PluginContext>;
+}
+
+// Plugin execution context
+export interface PluginContext {
+	player: MediaPlayerInstance;
+	event: string;
+	data: any;
+	originalData: any;
+	modified: boolean;
+	stopped: boolean;
+}
+
+/**
+ * Enhanced Plugin Registry with hooks and middleware support
+ */
+export class EnhancedPluginRegistry {
+	private plugins: Map<string, EnhancedMediaPlugin> = new Map();
+	private middlewares: PluginMiddleware[] = [];
+	private hooks: Map<keyof MediaPluginHooks, Array<{ plugin: string; handler: Function }>> = new Map();
+
+	/**
+	 * Register a plugin with the system
+	 */
+	public register(plugin: EnhancedMediaPlugin): void {
+		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
+	 */
+	public unregister(pluginName: string): void {
+		const plugin = this.plugins.get(pluginName);
+		if (plugin) {
+			this.unregisterPluginHooks(plugin);
+			this.plugins.delete(pluginName);
+		}
+	}
+
+	/**
+	 * Get a registered plugin
+	 */
+	public getPlugin(name: string): EnhancedMediaPlugin | undefined {
+		return this.plugins.get(name);
+	}
+
+	/**
+	 * Get all registered plugins
+	 */
+	public getPlugins(): EnhancedMediaPlugin[] {
+		return Array.from(this.plugins.values());
+	}
+
+	/**
+	 * Get plugins sorted by priority
+	 */
+	public getPluginsByPriority(): EnhancedMediaPlugin[] {
+		return Array.from(this.plugins.values()).sort((a, b) => a.getPriority() - b.getPriority());
+	}
+
+	/**
+	 * Execute a hook across all registered plugins
+	 */
+	public async executeHook<K extends keyof MediaPluginHooks>(
+		hookType: K,
+		...args: Parameters<NonNullable<MediaPluginHooks[K]>>
+	): Promise<any[]> {
+		const hookHandlers = this.hooks.get(hookType) || [];
+		const results: any[] = [];
+
+		for (const { plugin, handler } of hookHandlers) {
+			try {
+				const result = await (handler as any)(...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
+	 */
+	public addMiddleware(middleware: PluginMiddleware): void {
+		this.middlewares.push(middleware);
+		// Sort by priority
+		this.middlewares.sort((a, b) => a.priority - b.priority);
+	}
+
+	/**
+	 * Remove middleware
+	 */
+	public removeMiddleware(name: string): void {
+		this.middlewares = this.middlewares.filter(m => m.name !== name);
+	}
+
+	/**
+	 * Execute middleware chain
+	 */
+	public async executeMiddleware(context: PluginContext): Promise<PluginContext> {
+		let index = 0;
+
+		const next = (): Promise<PluginContext> => {
+			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
+	 */
+	private registerPluginHooks(plugin: EnhancedMediaPlugin): void {
+		const hooks = (plugin as any).hooks || {};
+
+		Object.entries(hooks).forEach(([hookType, handler]) => {
+			if (handler) {
+				if (!this.hooks.has(hookType as keyof MediaPluginHooks)) {
+					this.hooks.set(hookType as keyof MediaPluginHooks, []);
+				}
+
+				this.hooks.get(hookType as keyof MediaPluginHooks)!.push({
+					plugin: plugin.getName(),
+					handler,
+				});
+			}
+		});
+	}
+
+	/**
+	 * Unregister hooks from a plugin
+	 */
+	private unregisterPluginHooks(plugin: EnhancedMediaPlugin): void {
+		const hooks = (plugin as any).hooks || {};
+
+		Object.keys(hooks).forEach((hookType) => {
+			const handlers = this.hooks.get(hookType as keyof MediaPluginHooks);
+			if (handlers) {
+				this.hooks.set(
+					hookType as keyof MediaPluginHooks,
+					handlers.filter(h => h.plugin !== plugin.getName())
+				);
+			}
+		});
+	}
+
+	/**
+	 * Clear all plugins and middleware
+	 */
+	public clear(): void {
+		this.plugins.clear();
+		this.middlewares = [];
+		this.hooks.clear();
+	}
+}
+
+/**
+ * Plugin Manager for enhanced plugin system integration
+ */
+export class EnhancedPluginManager {
+	private registry: EnhancedPluginRegistry;
+	private player: MediaPlayerInstance;
+
+	constructor(player: MediaPlayerInstance) {
+		this.player = player;
+		this.registry = new EnhancedPluginRegistry();
+	}
+
+	/**
+	 * Setup plugin system for player
+	 */
+	public async setup(options: MediaPlayerConfig = {}): Promise<void> {
+		// 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
+	 */
+	public register(plugin: EnhancedMediaPlugin): void {
+		this.registry.register(plugin);
+	}
+
+	/**
+	 * Unregister a plugin
+	 */
+	public unregister(pluginName: string): void {
+		this.registry.unregister(pluginName);
+	}
+
+	/**
+	 * Execute hooks for specific events
+	 */
+	public async handleEvent(event: string, data: any): Promise<void> {
+		const context: PluginContext = {
+			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
+	 */
+	public async dispose(): Promise<void> {
+		// Execute beforeDispose hooks
+		await this.registry.executeHook('beforeDispose', this.player);
+
+		// Clear registry
+		this.registry.clear();
+	}
+
+	/**
+	 * Get plugin registry
+	 */
+	public getRegistry(): EnhancedPluginRegistry {
+		return this.registry;
+	}
+}
+
+// Default middlewares
+export const createPerformanceMiddleware = (): PluginMiddleware => ({
+	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 = (): PluginMiddleware => ({
+	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 = (): PluginMiddleware => ({
+	name: 'logging',
+	priority: 1000, // Run first
+	execute: async (context, next) => {
+		console.debug(`Plugin event: ${context.event}`, context.data);
+		return next();
+	},
+});
+
+export default EnhancedPluginManager;

package/src/core/plugins/examples/analytics-plugin.ts

@@ -0,0 +1,242 @@
+import { BasePlugin, type AnalyticsPluginConfig } from '../base-plugin'
+
+interface AnalyticsEvent {
+  event: string
+  timestamp: number
+  data?: any
+}
+
+interface AnalyticsConfig extends AnalyticsPluginConfig {
+  trackingId: string
+  events: string[]
+  samplingRate: number
+  debug: boolean
+  endpoint?: string
+}
+
+export class AnalyticsPlugin extends BasePlugin {
+  private events: AnalyticsEvent[] = []
+  private analyticsConfig!: AnalyticsConfig
+  private cleanupFunctions: Array<() => void> = []
+  private reportTimer?: NodeJS.Timeout
+
+  constructor(config?: AnalyticsPluginConfig) {
+    super({
+      name: 'analytics',
+      description: 'Media player analytics and tracking',
+      category: 'analytics',
+      priority: 'low',
+      author: 'BaroiPlayer Team'
+    })
+  }
+
+  protected onInitialize(): void {
+    this.analyticsConfig = this.createConfig<AnalyticsConfig>({
+      trackingId: '',
+      events: ['play', 'pause', 'seek', 'ended', 'error'],
+      samplingRate: 1.0,
+      debug: false,
+      endpoint: '/api/analytics'
+    })
+
+    if (!this.analyticsConfig.trackingId) {
+      throw new Error('Analytics plugin requires a tracking ID')
+    }
+
+    this.logger?.info('Analytics plugin initialized', { 
+      trackingId: this.analyticsConfig.trackingId,
+      events: this.analyticsConfig.events 
+    })
+  }
+
+  protected onActivate(): void {
+    // Set up event listeners for media events
+    const mediaEventCleanup = this.setupMediaEventListeners()
+    this.cleanupFunctions.push(mediaEventCleanup)
+
+    // Set up periodic reporting
+    if (this.analyticsConfig.endpoint) {
+      this.reportTimer = setInterval(() => {
+        this.reportEvents()
+      }, 30000) // Report every 30 seconds
+
+      this.cleanupFunctions.push(() => {
+        if (this.reportTimer) {
+          clearInterval(this.reportTimer)
+        }
+      })
+    }
+
+    this.trackEvent('plugin_activated', { plugin: 'analytics' })
+    this.logger?.info('Analytics tracking started')
+  }
+
+  protected onDeactivate(): void {
+    // Clean up all event listeners and timers
+    this.cleanupFunctions.forEach(cleanup => cleanup())
+    this.cleanupFunctions = []
+
+    // Report any remaining events
+    if (this.events.length > 0) {
+      this.reportEvents()
+    }
+
+    this.trackEvent('plugin_deactivated', { plugin: 'analytics' })
+    this.logger?.info('Analytics tracking stopped')
+  }
+
+  protected onConfigure(newConfig: AnalyticsConfig): void {
+    // Update tracking configuration  
+    this.analyticsConfig = { ...this.analyticsConfig, ...newConfig }
+    if (newConfig.events) {
+      // Re-setup event listeners if events changed
+      this.cleanupFunctions.forEach(cleanup => cleanup())
+      this.cleanupFunctions = []
+      
+      const mediaEventCleanup = this.setupMediaEventListeners()
+      this.cleanupFunctions.push(mediaEventCleanup)
+    }
+  }
+
+  private setupMediaEventListeners(): () => void {
+    const cleanupFunctions: Array<() => void> = []
+
+    // Listen for media state changes
+    if (this.analyticsConfig.events.includes('play')) {
+      const unsubscribe = this.on('media:play', (data) => {
+        this.trackEvent('play', data)
+      })
+      cleanupFunctions.push(unsubscribe)
+    }
+
+    if (this.analyticsConfig.events.includes('pause')) {
+      const unsubscribe = this.on('media:pause', (data) => {
+        this.trackEvent('pause', data)
+      })
+      cleanupFunctions.push(unsubscribe)
+    }
+
+    if (this.analyticsConfig.events.includes('seek')) {
+      const unsubscribe = this.on('media:seek', (data) => {
+        this.trackEvent('seek', data)
+      })
+      cleanupFunctions.push(unsubscribe)
+    }
+
+    if (this.analyticsConfig.events.includes('ended')) {
+      const unsubscribe = this.on('media:ended', (data) => {
+        this.trackEvent('ended', data)
+      })
+      cleanupFunctions.push(unsubscribe)
+    }
+
+    if (this.analyticsConfig.events.includes('error')) {
+      const unsubscribe = this.on('media:error', (data) => {
+        this.trackEvent('error', data)
+      })
+      cleanupFunctions.push(unsubscribe)
+    }
+
+    // Return cleanup function
+    return () => {
+      cleanupFunctions.forEach(cleanup => cleanup())
+    }
+  }
+
+  private trackEvent(event: string, data?: any): void {
+    // Apply sampling rate
+    if (Math.random() > this.analyticsConfig.samplingRate) {
+      return
+    }
+
+    const analyticsEvent: AnalyticsEvent = {
+      event,
+      timestamp: Date.now(),
+      data: {
+        ...data,
+        trackingId: this.analyticsConfig.trackingId,
+        sessionId: this.generateSessionId(),
+        mediaState: {
+          currentTime: this.state?.currentTime,
+          duration: this.state?.duration,
+          volume: this.state?.volume,
+          isPlaying: this.state?.isPlaying
+        }
+      }
+    }
+
+    this.events.push(analyticsEvent)
+
+    if (this.analyticsConfig.debug) {
+      this.logger?.info('Analytics event tracked', analyticsEvent)
+    }
+
+    // Emit event for other plugins or applications to use
+    this.emit('analytics:event', analyticsEvent)
+  }
+
+  private async reportEvents(): Promise<void> {
+    if (this.events.length === 0 || !this.analyticsConfig.endpoint) {
+      return
+    }
+
+    const eventsToReport = [...this.events]
+    this.events = []
+
+    try {
+      const response = await fetch(this.analyticsConfig.endpoint, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+          trackingId: this.analyticsConfig.trackingId,
+          events: eventsToReport
+        })
+      })
+
+      if (!response.ok) {
+        throw new Error(`Analytics report failed: ${response.status}`)
+      }
+
+      if (this.analyticsConfig.debug) {
+        this.logger?.info(`Reported ${eventsToReport.length} analytics events`)
+      }
+
+    } catch (error) {
+      // Put events back in queue on failure
+      this.events.unshift(...eventsToReport)
+      this.logger?.error('Failed to report analytics events', error)
+    }
+  }
+
+  private generateSessionId(): string {
+    // Simple session ID generation - could be more sophisticated
+    return `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
+  }
+
+  // Public API for manual event tracking
+  public track(event: string, data?: any): void {
+    this.trackEvent(event, data)
+  }
+
+  // Get pending events count
+  public getPendingEventsCount(): number {
+    return this.events.length
+  }
+
+  // Flush all pending events
+  public async flush(): Promise<void> {
+    await this.reportEvents()
+  }
+
+  protected onHealthCheck(): boolean {
+    // Check if we're not accumulating too many events
+    return this.events.length < 1000
+  }
+}
+
+// Plugin factory
+export const createAnalyticsPlugin = (config?: AnalyticsPluginConfig) => {
+  return new AnalyticsPlugin(config)
+}

package/src/core/plugins/index.ts

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