@therealtinhtute/baroiplayer 1.0.8 → 1.2.0

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

@@ -1,417 +0,0 @@
-/**
- * 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

@@ -1,30 +0,0 @@
-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.ts

@@ -1,242 +0,0 @@
-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/dist/src/core/plugins/index.d.ts

@@ -1,8 +0,0 @@
-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';
-export { AnalyticsPlugin, createAnalyticsPlugin } from './examples/analytics-plugin';
-export * from './utils';
-export declare const PLUGIN_SYSTEM_VERSION = "1.0.0";
-//# sourceMappingURL=index.d.ts.map