@therealtinhtute/baroiplayer 1.0.8 → 1.2.0

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

@@ -3,49 +3,50 @@
  * Provides middleware-based extensibility while maintaining backward compatibility
  */
 
-import { BasePlugin } from './base-plugin';
-import { MediaPlayerInstance, MediaPlayerConfig } from '../../types';
+import type { MediaPlayerConfig, MediaPlayerInstance } from "../../types"
+import { BasePlugin } from "./base-plugin"
 
 // Plugin hooks interface inspired by Video.js architecture
 export interface MediaPluginHooks {
 	/** Called before player setup, can modify configuration */
-	beforeSetup?: (element: HTMLElement, options: MediaPlayerConfig) => MediaPlayerConfig;
+	beforeSetup?: (element: HTMLElement, options: MediaPlayerConfig) => MediaPlayerConfig
 	/** Called during player setup */
-	setup?: (player: MediaPlayerInstance) => MediaPlayerInstance | void;
+	setup?: (player: MediaPlayerInstance) => MediaPlayerInstance | void
 	/** Called when player is ready */
-	ready?: (player: MediaPlayerInstance) => void;
+	ready?: (player: MediaPlayerInstance) => void
 	/** Called when media source is loaded */
-	sourceLoaded?: (player: MediaPlayerInstance, source: string) => void;
+	sourceLoaded?: (player: MediaPlayerInstance, source: string) => void
 	/** Called on playback state changes */
-	playbackChange?: (player: MediaPlayerInstance, isPlaying: boolean) => void;
+	playbackChange?: (player: MediaPlayerInstance, isPlaying: boolean) => void
 	/** Called on error events */
-	error?: (player: MediaPlayerInstance, error: MediaError) => MediaError | void;
+	error?: (player: MediaPlayerInstance, error: MediaError) => MediaError | void
 	/** Called before player disposal */
-	beforeDispose?: (player: MediaPlayerInstance) => void;
+	beforeDispose?: (player: MediaPlayerInstance) => void
 	/** Called during quality changes */
-	qualityChange?: (player: MediaPlayerInstance, quality: number) => void;
+	qualityChange?: (player: MediaPlayerInstance, quality: number) => void
 	/** Called during volume changes */
-	volumeChange?: (player: MediaPlayerInstance, volume: number) => void;
+	volumeChange?: (player: MediaPlayerInstance, volume: number) => void
 	/** Called during fullscreen changes */
-	fullscreenChange?: (player: MediaPlayerInstance, isFullscreen: boolean) => void;
+	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();
+	protected hooks: Partial<MediaPluginHooks> = {}
+	protected priority: number = 0
+	protected middleware?: PluginMiddleware
+
+	constructor(metadata: Parameters<(...args: any) => any>[0], config: any = {}) {
+		super(metadata)
+		this.priority = config.priority || 0
+		this.setupHooks()
+	}
+
+	/**
+	 * Get plugin name from metadata
+	 */
+	public getName(): string {
+		return this.metadata.name
 	}
 
 	/**
@@ -62,7 +63,7 @@ export abstract class EnhancedMediaPlugin extends BasePlugin {
 		hookType: K,
 		handler: MediaPluginHooks[K]
 	): void {
-		this.hooks[hookType] = handler;
+		this.hooks[hookType] = handler
 	}
 
 	/**
@@ -72,9 +73,9 @@ export abstract class EnhancedMediaPlugin extends BasePlugin {
 		hookType: K,
 		...args: Parameters<NonNullable<MediaPluginHooks[K]>>
 	): ReturnType<NonNullable<MediaPluginHooks[K]>> | void {
-		const hook = this.hooks[hookType];
+		const hook = this.hooks[hookType]
 		if (hook) {
-			return (hook as any)(...args);
+			return (hook as any)(...args)
 		}
 	}
 
@@ -82,57 +83,66 @@ export abstract class EnhancedMediaPlugin extends BasePlugin {
 	 * Get plugin priority
 	 */
 	public getPriority(): number {
-		return this.priority;
+		return this.priority
 	}
 
 	/**
 	 * Set middleware for advanced plugin behavior
 	 */
 	public setMiddleware(middleware: PluginMiddleware): void {
-		this.middleware = middleware;
+		this.middleware = middleware
+	}
+
+	/**
+	 * Get middleware for advanced plugin behavior
+	 */
+	public getMiddleware(): PluginMiddleware | undefined {
+		return this.middleware
 	}
 }
 
 // Middleware interface for plugin system
 export interface PluginMiddleware {
-	name: string;
-	priority: number;
+	name: string
+	priority: number
 	execute: (
 		context: PluginContext,
 		next: () => PluginContext | Promise<PluginContext>
-	) => PluginContext | Promise<PluginContext>;
+	) => PluginContext | Promise<PluginContext>
 }
 
 // Plugin execution context
 export interface PluginContext {
-	player: MediaPlayerInstance;
-	event: string;
-	data: any;
-	originalData: any;
-	modified: boolean;
-	stopped: boolean;
+	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();
+	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);
+		this.plugins.set(plugin.getName(), plugin)
 
 		// Register plugin hooks
-		this.registerPluginHooks(plugin);
+		this.registerPluginHooks(plugin)
 
 		// Register plugin middleware if available
-		if (plugin.middleware) {
-			this.addMiddleware(plugin.middleware);
+		const middleware = plugin.getMiddleware()
+		if (middleware) {
+			this.addMiddleware(middleware)
 		}
 	}
 
@@ -140,10 +150,10 @@ export class EnhancedPluginRegistry {
 	 * Unregister a plugin
 	 */
 	public unregister(pluginName: string): void {
-		const plugin = this.plugins.get(pluginName);
+		const plugin = this.plugins.get(pluginName)
 		if (plugin) {
-			this.unregisterPluginHooks(plugin);
-			this.plugins.delete(pluginName);
+			this.unregisterPluginHooks(plugin)
+			this.plugins.delete(pluginName)
 		}
 	}
 
@@ -151,21 +161,21 @@ export class EnhancedPluginRegistry {
 	 * Get a registered plugin
 	 */
 	public getPlugin(name: string): EnhancedMediaPlugin | undefined {
-		return this.plugins.get(name);
+		return this.plugins.get(name)
 	}
 
 	/**
 	 * Get all registered plugins
 	 */
 	public getPlugins(): EnhancedMediaPlugin[] {
-		return Array.from(this.plugins.values());
+		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());
+		return Array.from(this.plugins.values()).sort((a, b) => a.getPriority() - b.getPriority())
 	}
 
 	/**
@@ -175,99 +185,102 @@ export class EnhancedPluginRegistry {
 		hookType: K,
 		...args: Parameters<NonNullable<MediaPluginHooks[K]>>
 	): Promise<any[]> {
-		const hookHandlers = this.hooks.get(hookType) || [];
-		const results: 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 });
+				const result = await (handler as any)(...args)
+				results.push({ plugin, result })
 			} catch (error) {
-				console.error(`Error executing hook ${hookType} in plugin ${plugin}:`, error);
+				console.error(`Error executing hook ${hookType} in plugin ${plugin}:`, error)
 			}
 		}
 
-		return results;
+		return results
 	}
 
 	/**
 	 * Add middleware to the execution chain
 	 */
 	public addMiddleware(middleware: PluginMiddleware): void {
-		this.middlewares.push(middleware);
+		this.middlewares.push(middleware)
 		// Sort by priority
-		this.middlewares.sort((a, b) => a.priority - b.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);
+		this.middlewares = this.middlewares.filter((m) => m.name !== name)
 	}
 
 	/**
 	 * Execute middleware chain
 	 */
 	public async executeMiddleware(context: PluginContext): Promise<PluginContext> {
-		let index = 0;
+		let index = 0
 
 		const next = (): Promise<PluginContext> => {
 			if (index >= this.middlewares.length || context.stopped) {
-				return Promise.resolve(context);
+				return Promise.resolve(context)
 			}
 
-			const middleware = this.middlewares[index++];
-			return middleware ? Promise.resolve(middleware.execute(context, next)) : next();
-		};
+			const middleware = this.middlewares[index++]
+			if (middleware) {
+				return Promise.resolve(middleware.execute(context, next))
+			}
+			return Promise.resolve(context)
+		}
 
-		return next();
+		return next()
 	}
 
 	/**
 	 * Register hooks from a plugin
 	 */
 	private registerPluginHooks(plugin: EnhancedMediaPlugin): void {
-		const hooks = (plugin as any).hooks || {};
+		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.set(hookType as keyof MediaPluginHooks, [])
 				}
 
 				this.hooks.get(hookType as keyof MediaPluginHooks)!.push({
-					plugin: plugin.metadata.name,
-					handler: handler as Function,
-				});
+					plugin: plugin.getName(),
+					handler: handler as any
+				})
 			}
-		});
+		})
 	}
 
 	/**
 	 * Unregister hooks from a plugin
 	 */
 	private unregisterPluginHooks(plugin: EnhancedMediaPlugin): void {
-		const hooks = (plugin as any).hooks || {};
+		const hooks = (plugin as any).hooks || {}
 
 		Object.keys(hooks).forEach((hookType) => {
-			const handlers = this.hooks.get(hookType as keyof MediaPluginHooks);
+			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)
-				);
+					handlers.filter((h) => h.plugin !== plugin.getName())
+				)
 			}
-		});
+		})
 	}
 
 	/**
 	 * Clear all plugins and middleware
 	 */
 	public clear(): void {
-		this.plugins.clear();
-		this.middlewares = [];
-		this.hooks.clear();
+		this.plugins.clear()
+		this.middlewares = []
+		this.hooks.clear()
 	}
 }
 
@@ -275,12 +288,12 @@ export class EnhancedPluginRegistry {
  * Plugin Manager for enhanced plugin system integration
  */
 export class EnhancedPluginManager {
-	private registry: EnhancedPluginRegistry;
-	private player: MediaPlayerInstance;
+	private registry: EnhancedPluginRegistry
+	private player: MediaPlayerInstance
 
 	constructor(player: MediaPlayerInstance) {
-		this.player = player;
-		this.registry = new EnhancedPluginRegistry();
+		this.player = player
+		this.registry = new EnhancedPluginRegistry()
 	}
 
 	/**
@@ -288,32 +301,36 @@ export class EnhancedPluginManager {
 	 */
 	public async setup(options: MediaPlayerConfig = {}): Promise<void> {
 		// Execute beforeSetup hooks
-		const setupResults = await this.registry.executeHook('beforeSetup', this.player.element, options);
+		const setupResults = await this.registry.executeHook(
+			"beforeSetup",
+			this.player.element as HTMLElement,
+			options
+		)
 
 		// Apply configuration modifications from hooks
 		const modifiedOptions = setupResults.reduce((acc, { result }) => {
-			return result || acc;
-		}, options);
+			return result || acc
+		}, options)
 
 		// Execute setup hooks
-		await this.registry.executeHook('setup', this.player);
+		await this.registry.executeHook("setup", this.player)
 
 		// Execute ready hooks
-		await this.registry.executeHook('ready', this.player);
+		await this.registry.executeHook("ready", this.player)
 	}
 
 	/**
 	 * Register a plugin
 	 */
 	public register(plugin: EnhancedMediaPlugin): void {
-		this.registry.register(plugin);
+		this.registry.register(plugin)
 	}
 
 	/**
 	 * Unregister a plugin
 	 */
 	public unregister(pluginName: string): void {
-		this.registry.unregister(pluginName);
+		this.registry.unregister(pluginName)
 	}
 
 	/**
@@ -326,32 +343,32 @@ export class EnhancedPluginManager {
 			data,
 			originalData: data,
 			modified: false,
-			stopped: false,
-		};
+			stopped: false
+		}
 
 		// Execute middleware chain
-		const processedContext = await this.registry.executeMiddleware(context);
+		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;
+			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
 		}
 	}
 
@@ -360,58 +377,59 @@ export class EnhancedPluginManager {
 	 */
 	public async dispose(): Promise<void> {
 		// Execute beforeDispose hooks
-		await this.registry.executeHook('beforeDispose', this.player);
+		await this.registry.executeHook("beforeDispose", this.player)
 
 		// Clear registry
-		this.registry.clear();
+		this.registry.clear()
 	}
 
 	/**
 	 * Get plugin registry
 	 */
 	public getRegistry(): EnhancedPluginRegistry {
-		return this.registry;
+		return this.registry
 	}
 }
 
 // Default middlewares
 export const createPerformanceMiddleware = (): PluginMiddleware => ({
-	name: 'performance',
+	name: "performance",
 	priority: 0,
 	execute: async (context, next) => {
-		const start = performance.now();
-		const result = await next();
-		const duration = performance.now() - start;
+		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`);
+		if (duration > 16) {
+			// Log slow operations
+			console.warn(`Slow plugin operation: ${context.event} took ${duration.toFixed(2)}ms`)
 		}
 
-		return result;
-	},
-});
+		return result
+	}
+})
 
 export const createErrorHandlingMiddleware = (): PluginMiddleware => ({
-	name: 'errorHandling',
+	name: "errorHandling",
 	priority: -1000, // Run last
 	execute: async (context, next) => {
 		try {
-			return await next();
+			return await next()
 		} catch (error) {
-			console.error(`Plugin error in ${context.event}:`, error);
-			context.stopped = true;
-			return context;
+			console.error(`Plugin error in ${context.event}:`, error)
+			context.stopped = true
+			return context
 		}
-	},
-});
+	}
+})
 
 export const createLoggingMiddleware = (): PluginMiddleware => ({
-	name: 'logging',
+	name: "logging",
 	priority: 1000, // Run first
 	execute: async (context, next) => {
-		console.debug(`Plugin event: ${context.event}`, context.data);
-		return next();
-	},
-});
+		console.debug(`Plugin event: ${context.event}`, context.data)
+		return next()
+	}
+})
 
-export default EnhancedPluginManager;
+export default EnhancedPluginManager