@therealtinhtute/baroiplayer 1.0.6 → 1.0.8

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

@@ -1,305 +0,0 @@
-/**
- * Enhanced Plugin System with Video.js-inspired hooks architecture
- * Provides middleware-based extensibility while maintaining backward compatibility
- */
-import { BasePlugin } from './base-plugin';
-// Enhanced plugin with hooks support
-export class EnhancedMediaPlugin extends BasePlugin {
-    hooks = {};
-    priority = 0;
-    middleware;
-    constructor(name, config = {}) {
-        super(name, config);
-        this.priority = config.priority || 0;
-        this.setupHooks();
-    }
-    /**
-     * Override to setup plugin-specific hooks
-     */
-    setupHooks() {
-        // Override in subclasses
-    }
-    /**
-     * Register a hook
-     */
-    registerHook(hookType, handler) {
-        this.hooks[hookType] = handler;
-    }
-    /**
-     * Execute a hook if it exists
-     */
-    executeHook(hookType, ...args) {
-        const hook = this.hooks[hookType];
-        if (hook) {
-            return hook(...args);
-        }
-    }
-    /**
-     * Get plugin priority
-     */
-    getPriority() {
-        return this.priority;
-    }
-    /**
-     * Set middleware for advanced plugin behavior
-     */
-    setMiddleware(middleware) {
-        this.middleware = middleware;
-    }
-}
-/**
- * Enhanced Plugin Registry with hooks and middleware support
- */
-export class EnhancedPluginRegistry {
-    plugins = new Map();
-    middlewares = [];
-    hooks = new Map();
-    /**
-     * Register a plugin with the system
-     */
-    register(plugin) {
-        this.plugins.set(plugin.getName(), plugin);
-        // Register plugin hooks
-        this.registerPluginHooks(plugin);
-        // Register plugin middleware if available
-        if (plugin.middleware) {
-            this.addMiddleware(plugin.middleware);
-        }
-    }
-    /**
-     * Unregister a plugin
-     */
-    unregister(pluginName) {
-        const plugin = this.plugins.get(pluginName);
-        if (plugin) {
-            this.unregisterPluginHooks(plugin);
-            this.plugins.delete(pluginName);
-        }
-    }
-    /**
-     * Get a registered plugin
-     */
-    getPlugin(name) {
-        return this.plugins.get(name);
-    }
-    /**
-     * Get all registered plugins
-     */
-    getPlugins() {
-        return Array.from(this.plugins.values());
-    }
-    /**
-     * Get plugins sorted by priority
-     */
-    getPluginsByPriority() {
-        return Array.from(this.plugins.values()).sort((a, b) => a.getPriority() - b.getPriority());
-    }
-    /**
-     * Execute a hook across all registered plugins
-     */
-    async executeHook(hookType, ...args) {
-        const hookHandlers = this.hooks.get(hookType) || [];
-        const results = [];
-        for (const { plugin, handler } of hookHandlers) {
-            try {
-                const result = await handler(...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
-     */
-    addMiddleware(middleware) {
-        this.middlewares.push(middleware);
-        // Sort by priority
-        this.middlewares.sort((a, b) => a.priority - b.priority);
-    }
-    /**
-     * Remove middleware
-     */
-    removeMiddleware(name) {
-        this.middlewares = this.middlewares.filter(m => m.name !== name);
-    }
-    /**
-     * Execute middleware chain
-     */
-    async executeMiddleware(context) {
-        let index = 0;
-        const next = () => {
-            if (index >= this.middlewares.length || context.stopped) {
-                return Promise.resolve(context);
-            }
-            const middleware = this.middlewares[index++];
-            return Promise.resolve(middleware.execute(context, next));
-        };
-        return next();
-    }
-    /**
-     * Register hooks from a plugin
-     */
-    registerPluginHooks(plugin) {
-        const hooks = plugin.hooks || {};
-        Object.entries(hooks).forEach(([hookType, handler]) => {
-            if (handler) {
-                if (!this.hooks.has(hookType)) {
-                    this.hooks.set(hookType, []);
-                }
-                this.hooks.get(hookType).push({
-                    plugin: plugin.getName(),
-                    handler,
-                });
-            }
-        });
-    }
-    /**
-     * Unregister hooks from a plugin
-     */
-    unregisterPluginHooks(plugin) {
-        const hooks = plugin.hooks || {};
-        Object.keys(hooks).forEach((hookType) => {
-            const handlers = this.hooks.get(hookType);
-            if (handlers) {
-                this.hooks.set(hookType, handlers.filter(h => h.plugin !== plugin.getName()));
-            }
-        });
-    }
-    /**
-     * Clear all plugins and middleware
-     */
-    clear() {
-        this.plugins.clear();
-        this.middlewares = [];
-        this.hooks.clear();
-    }
-}
-/**
- * Plugin Manager for enhanced plugin system integration
- */
-export class EnhancedPluginManager {
-    registry;
-    player;
-    constructor(player) {
-        this.player = player;
-        this.registry = new EnhancedPluginRegistry();
-    }
-    /**
-     * Setup plugin system for player
-     */
-    async setup(options = {}) {
-        // Execute beforeSetup hooks
-        const setupResults = await this.registry.executeHook('beforeSetup', this.player.getElement(), 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
-     */
-    register(plugin) {
-        this.registry.register(plugin);
-    }
-    /**
-     * Unregister a plugin
-     */
-    unregister(pluginName) {
-        this.registry.unregister(pluginName);
-    }
-    /**
-     * Execute hooks for specific events
-     */
-    async handleEvent(event, data) {
-        const context = {
-            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
-     */
-    async dispose() {
-        // Execute beforeDispose hooks
-        await this.registry.executeHook('beforeDispose', this.player);
-        // Clear registry
-        this.registry.clear();
-    }
-    /**
-     * Get plugin registry
-     */
-    getRegistry() {
-        return this.registry;
-    }
-}
-// Default middlewares
-export const createPerformanceMiddleware = () => ({
-    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 = () => ({
-    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 = () => ({
-    name: 'logging',
-    priority: 1000, // Run first
-    execute: async (context, next) => {
-        console.debug(`Plugin event: ${context.event}`, context.data);
-        return next();
-    },
-});
-export default EnhancedPluginManager;

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

@@ -1,191 +0,0 @@
-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);
-};

package/src/core/plugins/index.js

@@ -1,9 +0,0 @@
-export { PluginError, PluginDependencyError, PluginConflictError } from './types';
-export { PluginRegistry } from './registry';
-export { BasePlugin, createPlugin } from './base-plugin';
-// Example plugins
-export { AnalyticsPlugin, createAnalyticsPlugin } from './examples/analytics-plugin';
-// Plugin utilities
-export * from './utils';
-// Version
-export const PLUGIN_SYSTEM_VERSION = '1.0.0';