@therealtinhtute/baroiplayer 1.0.0 → 1.0.2

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

@@ -0,0 +1,417 @@
+/**
+ * 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;
+	public middleware?: PluginMiddleware;
+
+	constructor(name: string, config: any = {}) {
+		super({
+			name,
+			version: config.version || '1.0.0',
+			description: config.description || '',
+			category: config.category || 'general',
+			priority: config.priority || 0
+		});
+		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.metadata.name, 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 middleware ? Promise.resolve(middleware.execute(context, next)) : 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.metadata.name,
+					handler: handler as Function,
+				});
+			}
+		});
+	}
+
+	/**
+	 * 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.metadata.name)
+				);
+			}
+		});
+	}
+
+	/**
+	 * 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.element, 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/dist/src/core/plugins/examples/analytics-plugin.d.ts

@@ -0,0 +1,30 @@
+import { BasePlugin, type AnalyticsPluginConfig } from '../base-plugin';
+interface AnalyticsConfig extends AnalyticsPluginConfig {
+    trackingId: string;
+    events: string[];
+    samplingRate: number;
+    debug: boolean;
+    endpoint?: string;
+}
+export declare class AnalyticsPlugin extends BasePlugin {
+    private events;
+    private analyticsConfig;
+    private cleanupFunctions;
+    private reportTimer?;
+    constructor(config?: AnalyticsPluginConfig);
+    protected onInitialize(): void;
+    protected onActivate(): void;
+    protected onDeactivate(): void;
+    protected onConfigure(newConfig: AnalyticsConfig): void;
+    private setupMediaEventListeners;
+    private trackEvent;
+    private reportEvents;
+    private generateSessionId;
+    track(event: string, data?: any): void;
+    getPendingEventsCount(): number;
+    flush(): Promise<void>;
+    protected onHealthCheck(): boolean;
+}
+export declare const createAnalyticsPlugin: (config?: AnalyticsPluginConfig) => AnalyticsPlugin;
+export {};
+//# sourceMappingURL=analytics-plugin.d.ts.map

package/dist/src/core/plugins/examples/analytics-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analytics-plugin.d.ts","sourceRoot":"","sources":["analytics-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,KAAK,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AAQvE,UAAU,eAAgB,SAAQ,qBAAqB;IACrD,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,YAAY,EAAE,MAAM,CAAA;IACpB,KAAK,EAAE,OAAO,CAAA;IACd,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,qBAAa,eAAgB,SAAQ,UAAU;IAC7C,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,gBAAgB,CAAwB;IAChD,OAAO,CAAC,WAAW,CAAC,CAAgB;gBAExB,MAAM,CAAC,EAAE,qBAAqB;IAU1C,SAAS,CAAC,YAAY,IAAI,IAAI;IAmB9B,SAAS,CAAC,UAAU,IAAI,IAAI;IAsB5B,SAAS,CAAC,YAAY,IAAI,IAAI;IAc9B,SAAS,CAAC,WAAW,CAAC,SAAS,EAAE,eAAe,GAAG,IAAI;IAavD,OAAO,CAAC,wBAAwB;IA6ChC,OAAO,CAAC,UAAU;YAgCJ,YAAY;IAmC1B,OAAO,CAAC,iBAAiB;IAMlB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI;IAKtC,qBAAqB,IAAI,MAAM;IAKzB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAInC,SAAS,CAAC,aAAa,IAAI,OAAO;CAInC;AAGD,eAAO,MAAM,qBAAqB,GAAI,SAAS,qBAAqB,oBAEnE,CAAA"}

package/dist/src/core/plugins/examples/analytics-plugin.js

@@ -0,0 +1,191 @@
+import { BasePlugin } from '../base-plugin';
+export class AnalyticsPlugin extends BasePlugin {
+    events = [];
+    analyticsConfig;
+    cleanupFunctions = [];
+    reportTimer;
+    constructor(config) {
+        super({
+            name: 'analytics',
+            description: 'Media player analytics and tracking',
+            category: 'analytics',
+            priority: 'low',
+            author: 'BaroiPlayer Team'
+        });
+    }
+    onInitialize() {
+        this.analyticsConfig = this.createConfig({
+            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
+        });
+    }
+    onActivate() {
+        // 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');
+    }
+    onDeactivate() {
+        // 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');
+    }
+    onConfigure(newConfig) {
+        // 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);
+        }
+    }
+    setupMediaEventListeners() {
+        const cleanupFunctions = [];
+        // 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());
+        };
+    }
+    trackEvent(event, data) {
+        // Apply sampling rate
+        if (Math.random() > this.analyticsConfig.samplingRate) {
+            return;
+        }
+        const 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);
+    }
+    async reportEvents() {
+        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);
+        }
+    }
+    generateSessionId() {
+        // 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
+    track(event, data) {
+        this.trackEvent(event, data);
+    }
+    // Get pending events count
+    getPendingEventsCount() {
+        return this.events.length;
+    }
+    // Flush all pending events
+    async flush() {
+        await this.reportEvents();
+    }
+    onHealthCheck() {
+        // Check if we're not accumulating too many events
+        return this.events.length < 1000;
+    }
+}
+// Plugin factory
+export const createAnalyticsPlugin = (config) => {
+    return new AnalyticsPlugin(config);
+};