@therealtinhtute/baroiplayer 1.2.1 → 2.0.0-beta.1

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

@@ -1,225 +0,0 @@
-import type {
-	Plugin,
-	PluginCategory,
-	PluginConfig,
-	PluginContext,
-	PluginMetadata,
-	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/src/core/plugins/enhanced-plugin-system.ts

@@ -1,435 +0,0 @@
-/**
- * Enhanced Plugin System with Video.js-inspired hooks architecture
- * Provides middleware-based extensibility while maintaining backward compatibility
- */
-
-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
-	/** 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(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
-	}
-
-	/**
-	 * 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
-	}
-
-	/**
-	 * 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
-	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
-		const middleware = plugin.getMiddleware()
-		if (middleware) {
-			this.addMiddleware(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++]
-			if (middleware) {
-				return Promise.resolve(middleware.execute(context, next))
-			}
-			return Promise.resolve(context)
-		}
-
-		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: handler as any
-				})
-			}
-		})
-	}
-
-	/**
-	 * 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.element as HTMLElement,
-			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