@therealtinhtute/baroiplayer 1.2.0 → 2.0.0-beta.1

package/src/core/plugins/registry.ts

@@ -1,546 +0,0 @@
-import { EventBus } from "../events/event-system"
-import { ConsolePluginLogger } from "./utils"
-import type {
-	PluginRegistry as IPluginRegistry,
-	Plugin,
-	PluginCategory,
-	PluginConfig,
-	PluginContext,
-	PluginEvents,
-	PluginFactory,
-	PluginLogger,
-	PluginPriority
-} from "./types"
-import { PluginConflictError, PluginDependencyError, PluginError } from "./types"
-
-export class PluginRegistry implements IPluginRegistry {
-	private plugins = new Map<string, Plugin>()
-	private pluginConfigs = new Map<string, PluginConfig>()
-	private pluginContexts = new Map<string, PluginContext>()
-	private enabledPlugins = new Set<string>()
-	private eventBus = new EventBus()
-	private logger: PluginLogger
-
-	constructor(logger?: PluginLogger) {
-		this.logger = logger || new ConsolePluginLogger("[PluginRegistry]")
-	}
-
-	register(name: string, plugin: Plugin, config?: PluginConfig): void
-	register(factory: PluginFactory, config?: PluginConfig): void
-	register(
-		nameOrFactory: string | PluginFactory,
-		pluginOrConfig?: Plugin | PluginConfig,
-		config: PluginConfig = {}
-	): void {
-		let name: string | undefined
-		let plugin: Plugin | undefined
-		let pluginConfig: PluginConfig = {}
-
-		try {
-			if (typeof nameOrFactory === "string") {
-				name = nameOrFactory
-				plugin = pluginOrConfig as Plugin
-				pluginConfig = config
-			} else {
-				const factory = nameOrFactory
-				pluginConfig = (pluginOrConfig as PluginConfig) || {}
-				plugin = factory(pluginConfig)
-				name = plugin?.metadata?.name
-			}
-
-			if (!name || !plugin) {
-				throw new PluginError("unknown", "initialize", "Invalid plugin registration payload")
-			}
-
-			if (this.plugins.has(name)) {
-				throw new PluginError(name, "initialize", "Plugin already registered")
-			}
-
-			this.plugins.set(name, plugin)
-			this.pluginConfigs.set(name, pluginConfig)
-
-			this.logger.info(`Plugin '${name}' registered successfully`)
-			;(this.eventBus as any).emit("plugin:registered", { name, plugin })
-		} catch (error) {
-			const pluginName = name || plugin?.metadata?.name || "unknown"
-			this.logger.error(`Failed to register plugin '${pluginName}'`, error)
-			;(this.eventBus as any).emit("plugin:error", { name: pluginName, error: error as Error })
-			throw error
-		}
-	}
-
-	async unregister(name: string, context?: PluginContext): Promise<void> {
-		const plugin = this.plugins.get(name)
-		if (!plugin) {
-			throw new PluginError(name, "destroy", "Plugin not found")
-		}
-
-		try {
-			const pluginContext = context || this.pluginContexts.get(name) || this.createPluginContext(name)
-
-			if (this.enabledPlugins.has(name)) {
-				await this.deactivate(name, pluginContext)
-			}
-
-			if (plugin.isInitialized) {
-				await plugin.destroy(pluginContext)
-			}
-
-			this.plugins.delete(name)
-			this.pluginConfigs.delete(name)
-			this.pluginContexts.delete(name)
-			this.enabledPlugins.delete(name)
-
-			this.logger.info(`Plugin '${name}' unregistered successfully`)
-		} catch (error) {
-			this.logger.error(`Failed to unregister plugin '${name}'`, error)
-			throw error
-		}
-	}
-
-	get(name: string): Plugin | undefined {
-		return this.plugins.get(name)
-	}
-
-	has(name: string): boolean {
-		return this.plugins.has(name)
-	}
-
-	getAll(): Plugin[] {
-		return Array.from(this.plugins.values()).sort(this.sortByPriority)
-	}
-
-	getByCategory(category: PluginCategory): Plugin[] {
-		return this.getAll().filter((plugin) => plugin.metadata.category === category)
-	}
-
-	getActive(): Plugin[] {
-		return Array.from(this.enabledPlugins)
-			.map((name) => this.plugins.get(name))
-			.filter((plugin): plugin is Plugin => Boolean(plugin))
-			.sort(this.sortByPriority)
-	}
-
-	isEnabled(name: string): boolean {
-		return this.enabledPlugins.has(name)
-	}
-
-	async initialize(name: string, context: PluginContext, config: PluginConfig = {}): Promise<void> {
-		const plugin = this.plugins.get(name)
-		if (!plugin) {
-			throw new PluginError(name, "initialize", "Plugin not found")
-		}
-
-		this.ensureDependenciesExist(name)
-
-		const mergedConfig = { ...(this.pluginConfigs.get(name) || {}), ...config }
-		this.pluginConfigs.set(name, mergedConfig)
-		this.pluginContexts.set(name, context)
-
-		try {
-			await plugin.initialize(context, mergedConfig)
-		} catch (error) {
-			this.logger.error(`Failed to initialize plugin '${name}'`, error)
-			;(this.eventBus as any).emit("plugin:error", { name, error: error as Error })
-			throw error
-		}
-	}
-
-	async activate(name: string, context: PluginContext): Promise<void> {
-		const plugin = this.plugins.get(name)
-		if (!plugin) {
-			throw new PluginError(name, "activate", "Plugin not found")
-		}
-
-		this.ensureDependenciesActive(name)
-		this.ensureNoActiveConflicts(name)
-		this.pluginContexts.set(name, context)
-
-		try {
-			await plugin.activate(context)
-			this.enabledPlugins.add(name)
-			;(this.eventBus as any).emit("plugin:enabled", { name, plugin })
-		} catch (error) {
-			this.logger.error(`Failed to activate plugin '${name}'`, error)
-			;(this.eventBus as any).emit("plugin:error", { name, error: error as Error })
-			throw error
-		}
-	}
-
-	async deactivate(name: string, context: PluginContext): Promise<void> {
-		const plugin = this.plugins.get(name)
-		if (!plugin) {
-			throw new PluginError(name, "deactivate", "Plugin not found")
-		}
-
-		this.pluginContexts.set(name, context)
-
-		try {
-			await plugin.deactivate(context)
-			this.enabledPlugins.delete(name)
-			;(this.eventBus as any).emit("plugin:disabled", { name, plugin })
-		} catch (error) {
-			this.logger.error(`Failed to deactivate plugin '${name}'`, error)
-			;(this.eventBus as any).emit("plugin:error", { name, error: error as Error })
-			throw error
-		}
-	}
-
-	async initializeAll(context: PluginContext): Promise<void> {
-		this.validateDependencies()
-		const orderedNames = this.getAll().map((plugin) => this.findPluginKey(plugin)).filter(Boolean) as string[]
-
-		for (const name of orderedNames) {
-			await this.initialize(name, context)
-		}
-	}
-
-	async activateAll(context: PluginContext): Promise<void> {
-		const orderedNames = this.getAll().map((plugin) => this.findPluginKey(plugin)).filter(Boolean) as string[]
-
-		for (const name of orderedNames) {
-			const plugin = this.plugins.get(name)
-			if (!plugin) continue
-			if (!plugin.isInitialized) {
-				await this.initialize(name, context)
-			}
-			await this.activate(name, context)
-		}
-	}
-
-	async deactivateAll(context: PluginContext): Promise<void> {
-		const orderedNames = this.getAll()
-			.map((plugin) => this.findPluginKey(plugin))
-			.filter(Boolean)
-			.reverse() as string[]
-
-		for (const name of orderedNames) {
-			if (this.enabledPlugins.has(name)) {
-				await this.deactivate(name, context)
-			}
-		}
-	}
-
-	async destroyAll(context: PluginContext): Promise<void> {
-		await this.deactivateAll(context)
-
-		const names = Array.from(this.plugins.keys())
-		for (const name of names) {
-			const plugin = this.plugins.get(name)
-			if (!plugin) continue
-			if (plugin.isInitialized) {
-				await plugin.destroy(context)
-			}
-		}
-
-		this.plugins.clear()
-		this.pluginConfigs.clear()
-		this.pluginContexts.clear()
-		this.enabledPlugins.clear()
-	}
-
-	validateDependencies(): void {
-		for (const [name, plugin] of this.plugins.entries()) {
-			const missingDependencies = (plugin.metadata.dependencies || []).filter(
-				(dep) => !this.plugins.has(dep)
-			)
-			if (missingDependencies.length > 0) {
-				throw new PluginDependencyError(name, missingDependencies)
-			}
-		}
-
-		const visited = new Set<string>()
-		const visiting = new Set<string>()
-
-		const visit = (name: string) => {
-			if (visited.has(name)) return
-			if (visiting.has(name)) {
-				throw new PluginError(name, "initialize", "Circular dependency detected")
-			}
-
-			visiting.add(name)
-			const plugin = this.plugins.get(name)
-			if (!plugin) return
-
-			for (const dep of plugin.metadata.dependencies || []) {
-				visit(dep)
-			}
-
-			visiting.delete(name)
-			visited.add(name)
-		}
-
-		for (const name of this.plugins.keys()) {
-			visit(name)
-		}
-	}
-
-	validateConflicts(): void {
-		for (const [name, plugin] of this.plugins.entries()) {
-			const activeConflicts = (plugin.metadata.conflicts || []).filter((conflict) =>
-				this.plugins.has(conflict)
-			)
-			if (activeConflicts.length > 0) {
-				throw new PluginConflictError(name, activeConflicts)
-			}
-		}
-	}
-
-	healthCheck(name: string): boolean
-	healthCheck(): Promise<{ name: string; healthy: boolean; error?: Error }[]>
-	healthCheck(name?: string): boolean | Promise<{ name: string; healthy: boolean; error?: Error }[]> {
-		if (typeof name === "string") {
-			const plugin = this.plugins.get(name)
-			if (!plugin) return false
-			try {
-				const testInitFlag = (plugin as { onInitializeCalled?: boolean }).onInitializeCalled
-				if (typeof testInitFlag === "boolean") {
-					return testInitFlag
-				}
-				if (plugin.healthCheck) {
-					return Boolean(plugin.healthCheck())
-				}
-				if (typeof plugin.isInitialized === "boolean") {
-					return plugin.isInitialized
-				}
-				return false
-			} catch {
-				return false
-			}
-		}
-
-		return this.healthCheckEnabledPlugins()
-	}
-
-	healthCheckAll(): Record<string, boolean> {
-		const status: Record<string, boolean> = {}
-		for (const pluginName of this.plugins.keys()) {
-			status[pluginName] = this.healthCheck(pluginName)
-		}
-		return status
-	}
-
-	async enable(name: string): Promise<void> {
-		const plugin = this.plugins.get(name)
-		if (!plugin) {
-			throw new PluginError(name, "activate", "Plugin not found")
-		}
-
-		if (this.enabledPlugins.has(name)) {
-			this.logger.warn(`Plugin '${name}' is already enabled`)
-			return
-		}
-
-		const context = this.pluginContexts.get(name) || this.createPluginContext(name)
-		if (!plugin.isInitialized) {
-			await this.initialize(name, context)
-		}
-		await this.activate(name, context)
-	}
-
-	async disable(name: string): Promise<void> {
-		const plugin = this.plugins.get(name)
-		if (!plugin) {
-			throw new PluginError(name, "deactivate", "Plugin not found")
-		}
-
-		if (!this.enabledPlugins.has(name)) {
-			this.logger.warn(`Plugin '${name}' is already disabled`)
-			return
-		}
-
-		const context = this.pluginContexts.get(name) || this.createPluginContext(name)
-		await this.deactivate(name, context)
-		await plugin.destroy(context)
-	}
-
-	async configure(name: string, config: PluginConfig): Promise<void> {
-		const plugin = this.plugins.get(name)
-		if (!plugin) {
-			throw new PluginError(name, "initialize", "Plugin not found")
-		}
-
-		try {
-			this.pluginConfigs.set(name, { ...this.pluginConfigs.get(name), ...config })
-			if (plugin.configure) {
-				await plugin.configure(config)
-			}
-			this.logger.info(`Plugin '${name}' configured successfully`)
-			;(this.eventBus as any).emit("plugin:configured", { name, config })
-		} catch (error) {
-			this.logger.error(`Failed to configure plugin '${name}'`, error)
-			;(this.eventBus as any).emit("plugin:error", { name, error: error as Error })
-			throw error
-		}
-	}
-
-	async enablePlugins(names: string[]): Promise<void> {
-		const resolved = this.resolveDependencies(names)
-
-		for (const name of resolved) {
-			if (!this.enabledPlugins.has(name)) {
-				await this.enable(name)
-			}
-		}
-	}
-
-	async disablePlugins(names: string[]): Promise<void> {
-		const reversed = [...names].reverse()
-
-		for (const name of reversed) {
-			if (this.enabledPlugins.has(name)) {
-				await this.disable(name)
-			}
-		}
-	}
-
-	getEnabledPlugins(): Plugin[] {
-		return this.getActive()
-	}
-
-	on<K extends keyof PluginEvents>(
-		event: K,
-		listener: (data: PluginEvents[K]) => void
-	): () => void {
-		;(this.eventBus as any).on(event, listener)
-		return () => (this.eventBus as any).off(event, listener)
-	}
-
-	private async healthCheckEnabledPlugins(): Promise<
-		{ name: string; healthy: boolean; error?: Error }[]
-	> {
-		const results = []
-
-		for (const name of this.enabledPlugins) {
-			const plugin = this.plugins.get(name)
-			if (!plugin) continue
-
-			try {
-				const healthResult = plugin.healthCheck ? plugin.healthCheck() : true
-				const healthy =
-					healthResult instanceof Promise ? await healthResult : Boolean(healthResult)
-				results.push({ name, healthy })
-			} catch (error) {
-				results.push({ name, healthy: false, error: error as Error })
-			}
-		}
-
-		return results
-	}
-
-	private findPluginKey(target: Plugin): string | undefined {
-		for (const [name, plugin] of this.plugins.entries()) {
-			if (plugin === target) return name
-		}
-		return undefined
-	}
-
-	private ensureDependenciesExist(name: string): void {
-		const plugin = this.plugins.get(name)
-		if (!plugin) return
-
-		const missingDependencies = (plugin.metadata.dependencies || []).filter(
-			(dep) => !this.plugins.has(dep)
-		)
-
-		if (missingDependencies.length > 0) {
-			throw new PluginDependencyError(name, missingDependencies)
-		}
-	}
-
-	private ensureDependenciesActive(name: string): void {
-		const plugin = this.plugins.get(name)
-		if (!plugin) return
-
-		const inactiveDependencies = (plugin.metadata.dependencies || []).filter(
-			(dep) => !this.enabledPlugins.has(dep)
-		)
-
-		if (inactiveDependencies.length > 0) {
-			throw new PluginDependencyError(name, inactiveDependencies)
-		}
-	}
-
-	private ensureNoActiveConflicts(name: string): void {
-		const plugin = this.plugins.get(name)
-		if (!plugin) return
-
-		const activeConflicts = (plugin.metadata.conflicts || []).filter((conflict) =>
-			this.enabledPlugins.has(conflict)
-		)
-
-		if (activeConflicts.length > 0) {
-			throw new PluginConflictError(name, activeConflicts)
-		}
-	}
-
-	private createPluginContext(pluginName: string): PluginContext {
-		return {
-			state: {} as any,
-			controls: {} as any,
-			plugins: this,
-			emit: (event: string, data?: any) => (this.eventBus as any).emit(event, data),
-			on: (event: string, handler: (data: any) => void) => {
-				;(this.eventBus as any).on(event, handler)
-				return () => (this.eventBus as any).off(event, handler)
-			},
-			element: null,
-			logger: this.createPluginLogger(pluginName)
-		}
-	}
-
-	private createPluginLogger(pluginName: string): PluginLogger {
-		return {
-			info: (message: string, data?: any) => this.logger.info(`[${pluginName}] ${message}`, data),
-			warn: (message: string, data?: any) => this.logger.warn(`[${pluginName}] ${message}`, data),
-			error: (message: string, data?: any) => this.logger.error(`[${pluginName}] ${message}`, data),
-			debug: (message: string, data?: any) => this.logger.debug(`[${pluginName}] ${message}`, data)
-		}
-	}
-
-	private resolveDependencies(names: string[]): string[] {
-		const resolved: string[] = []
-		const visiting = new Set<string>()
-
-		const visit = (name: string) => {
-			if (resolved.includes(name)) return
-			if (visiting.has(name)) {
-				throw new PluginError(name, "initialize", "Circular dependency detected")
-			}
-
-			visiting.add(name)
-
-			const plugin = this.plugins.get(name)
-			if (!plugin) {
-				throw new PluginError(name, "initialize", "Plugin not found")
-			}
-
-			for (const dep of plugin.metadata.dependencies || []) {
-				visit(dep)
-			}
-
-			visiting.delete(name)
-			resolved.push(name)
-		}
-
-		for (const name of names) {
-			visit(name)
-		}
-
-		return resolved
-	}
-
-	private sortByPriority(a: Plugin, b: Plugin): number {
-		const priorityOrder: Record<PluginPriority, number> = {
-			high: 3,
-			medium: 2,
-			normal: 2,
-			low: 1
-		}
-
-		const aPriority = priorityOrder[a.metadata.priority] || 1
-		const bPriority = priorityOrder[b.metadata.priority] || 1
-
-		return bPriority - aPriority
-	}
-}

package/src/core/plugins/types.ts

@@ -1,169 +0,0 @@
-// TODO: Import proper types when integrated
-export interface MediaState {
-	isPlaying: boolean
-	currentTime: number
-	duration: number
-	volume: number
-	isMuted: boolean
-}
-
-export interface MediaPlayerControls {
-	play(): void
-	pause(): void
-	seek(time: number): void
-	setVolume(volume: number): void
-}
-
-// Plugin lifecycle phases
-export type PluginPhase = "initialize" | "activate" | "deactivate" | "destroy"
-
-// Plugin categories for organization
-export type PluginCategory =
-	| "controls"
-	| "analytics"
-	| "streaming"
-	| "subtitle"
-	| "quality"
-	| "ui"
-	| "accessibility"
-	| "performance"
-
-// Plugin priority for execution order
-export type PluginPriority = "high" | "medium" | "normal" | "low"
-
-// Plugin configuration interface
-export interface PluginConfig {
-	[key: string]: any
-}
-
-// Plugin context provided to each plugin
-export interface PluginContext {
-	// Core media player state and controls
-	state: MediaState
-	controls: MediaPlayerControls
-
-	// Plugin management
-	plugins: PluginRegistry
-
-	// Event system
-	emit: (event: string, data?: any) => void
-	on: (event: string, handler: (data: any) => void) => () => void
-
-	// Utilities
-	element: HTMLElement | null
-	logger: PluginLogger
-}
-
-// Plugin metadata
-export interface PluginMetadata {
-	name: string
-	version: string
-	description: string
-	author?: string
-	category: PluginCategory
-	priority: PluginPriority
-	dependencies?: string[]
-	conflicts?: string[]
-}
-
-// Plugin interface that all plugins must implement
-export interface Plugin {
-	metadata: PluginMetadata
-	isInitialized?: boolean
-	isActive?: boolean
-
-	// Plugin lifecycle methods
-	initialize(context: PluginContext, config?: PluginConfig): Promise<void> | void
-	activate(context: PluginContext): Promise<void> | void
-	deactivate(context: PluginContext): Promise<void> | void
-	destroy(context: PluginContext): Promise<void> | void
-
-	// Configuration handling
-	configure?(config: PluginConfig): Promise<void> | void
-
-	// Health check for plugin status
-	healthCheck?(): Promise<boolean> | boolean
-}
-
-// Plugin factory function type
-export type PluginFactory<T extends Plugin = Plugin> = (config?: PluginConfig) => T
-
-// Plugin registry interface
-export interface PluginRegistry {
-	register(name: string, plugin: Plugin, config?: PluginConfig): void
-	register(factory: PluginFactory, config?: PluginConfig): void
-	unregister(name: string, context?: PluginContext): Promise<void>
-	get(name: string): Plugin | undefined
-	has(name: string): boolean
-	getAll(): Plugin[]
-	getByCategory(category: PluginCategory): Plugin[]
-	getActive(): Plugin[]
-	isEnabled(name: string): boolean
-	initialize(name: string, context: PluginContext, config?: PluginConfig): Promise<void>
-	activate(name: string, context: PluginContext): Promise<void>
-	deactivate(name: string, context: PluginContext): Promise<void>
-	initializeAll(context: PluginContext): Promise<void>
-	activateAll(context: PluginContext): Promise<void>
-	deactivateAll(context: PluginContext): Promise<void>
-	destroyAll(context: PluginContext): Promise<void>
-	validateDependencies(): void
-	validateConflicts(): void
-	healthCheck(name: string): boolean
-	healthCheck(): Promise<{ name: string; healthy: boolean; error?: Error }[]>
-	healthCheckAll(): Record<string, boolean>
-	enable(name: string): Promise<void>
-	disable(name: string): Promise<void>
-	configure(name: string, config: PluginConfig): Promise<void>
-}
-
-// Plugin logger interface
-export interface PluginLogger {
-	info(message: string, data?: any): void
-	warn(message: string, data?: any): void
-	error(message: string, data?: any): void
-	debug(message: string, data?: any): void
-}
-
-// Plugin event types
-export interface PluginEvents {
-	"plugin:registered": { name: string; plugin: Plugin }
-	"plugin:enabled": { name: string; plugin: Plugin }
-	"plugin:disabled": { name: string; plugin: Plugin }
-	"plugin:error": { name: string; error: Error }
-	"plugin:configured": { name: string; config: PluginConfig }
-}
-
-// Plugin error types
-export class PluginError extends Error {
-	constructor(
-		public pluginName: string,
-		public phase: PluginPhase,
-		message: string,
-		public originalError?: Error
-	) {
-		super(`Plugin '${pluginName}' failed during ${phase}: ${message}`)
-		this.name = "PluginError"
-	}
-}
-
-// Plugin dependency error
-export class PluginDependencyError extends PluginError {
-	constructor(
-		pluginName: string,
-		public missingDependencies: string[]
-	) {
-		super(pluginName, "initialize", `Missing dependencies: ${missingDependencies.join(", ")}`)
-		this.name = "PluginDependencyError"
-	}
-}
-
-// Plugin conflict error
-export class PluginConflictError extends PluginError {
-	constructor(
-		pluginName: string,
-		public conflictingPlugins: string[]
-	) {
-		super(pluginName, "activate", `Conflicts with active plugins: ${conflictingPlugins.join(", ")}`)
-		this.name = "PluginConflictError"
-	}
-}