@therealtinhtute/baroiplayer 1.0.6 → 1.0.7

package/src/core/plugins/registry.js

@@ -1,261 +0,0 @@
-import { EventBus } from '../events/event-system';
-import { PluginError, PluginDependencyError, PluginConflictError } from './types';
-// Plugin registry implementation
-export class PluginRegistry {
-    plugins = new Map();
-    pluginConfigs = new Map();
-    enabledPlugins = new Set();
-    eventBus = new EventBus();
-    logger;
-    constructor(logger) {
-        this.logger = logger;
-    }
-    // Register a plugin factory
-    async register(factory, config = {}) {
-        try {
-            const plugin = factory(config);
-            const { name, dependencies = [], conflicts = [] } = plugin.metadata;
-            // Check if plugin already exists
-            if (this.plugins.has(name)) {
-                throw new PluginError(name, 'initialize', 'Plugin already registered');
-            }
-            // Validate dependencies
-            const missingDependencies = dependencies.filter(dep => !this.plugins.has(dep));
-            if (missingDependencies.length > 0) {
-                throw new PluginDependencyError(name, missingDependencies);
-            }
-            // Check for conflicts with enabled plugins
-            const activeConflicts = conflicts.filter(conflict => this.enabledPlugins.has(conflict));
-            if (activeConflicts.length > 0) {
-                throw new PluginConflictError(name, activeConflicts);
-            }
-            // Store plugin and configuration
-            this.plugins.set(name, plugin);
-            this.pluginConfigs.set(name, config);
-            this.logger.info(`Plugin '${name}' registered successfully`);
-            this.eventBus.emit('plugin:registered', { name, plugin });
-        }
-        catch (error) {
-            const pluginName = factory({}).metadata.name;
-            this.logger.error(`Failed to register plugin '${pluginName}'`, error);
-            this.eventBus.emit('plugin:error', { name: pluginName, error: error });
-            throw error;
-        }
-    }
-    // Unregister a plugin
-    async unregister(name) {
-        const plugin = this.plugins.get(name);
-        if (!plugin) {
-            throw new PluginError(name, 'destroy', 'Plugin not found');
-        }
-        try {
-            // Disable plugin if enabled
-            if (this.enabledPlugins.has(name)) {
-                await this.disable(name);
-            }
-            // Remove from registry
-            this.plugins.delete(name);
-            this.pluginConfigs.delete(name);
-            this.logger.info(`Plugin '${name}' unregistered successfully`);
-        }
-        catch (error) {
-            this.logger.error(`Failed to unregister plugin '${name}'`, error);
-            throw error;
-        }
-    }
-    // Get a plugin by name
-    get(name) {
-        return this.plugins.get(name);
-    }
-    // Get all plugins sorted by priority
-    getAll() {
-        return Array.from(this.plugins.values()).sort(this.sortByPriority);
-    }
-    // Check if plugin is enabled
-    isEnabled(name) {
-        return this.enabledPlugins.has(name);
-    }
-    // Enable a plugin
-    async enable(name) {
-        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;
-        }
-        try {
-            const context = this.createPluginContext(name);
-            const config = this.pluginConfigs.get(name);
-            // Initialize plugin
-            await plugin.initialize(context, config);
-            // Activate plugin
-            await plugin.activate(context);
-            this.enabledPlugins.add(name);
-            this.logger.info(`Plugin '${name}' enabled successfully`);
-            this.eventBus.emit('plugin:enabled', { name, plugin });
-        }
-        catch (error) {
-            this.logger.error(`Failed to enable plugin '${name}'`, error);
-            this.eventBus.emit('plugin:error', { name, error: error });
-            throw error;
-        }
-    }
-    // Disable a plugin
-    async disable(name) {
-        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;
-        }
-        try {
-            const context = this.createPluginContext(name);
-            // Deactivate plugin
-            await plugin.deactivate(context);
-            // Destroy plugin resources
-            await plugin.destroy(context);
-            this.enabledPlugins.delete(name);
-            this.logger.info(`Plugin '${name}' disabled successfully`);
-            this.eventBus.emit('plugin:disabled', { name, plugin });
-        }
-        catch (error) {
-            this.logger.error(`Failed to disable plugin '${name}'`, error);
-            this.eventBus.emit('plugin:error', { name, error: error });
-            throw error;
-        }
-    }
-    // Configure a plugin
-    async configure(name, config) {
-        const plugin = this.plugins.get(name);
-        if (!plugin) {
-            throw new PluginError(name, 'initialize', 'Plugin not found');
-        }
-        try {
-            // Update stored configuration
-            this.pluginConfigs.set(name, { ...this.pluginConfigs.get(name), ...config });
-            // If plugin has configure method, call it
-            if (plugin.configure) {
-                await plugin.configure(config);
-            }
-            this.logger.info(`Plugin '${name}' configured successfully`);
-            this.eventBus.emit('plugin:configured', { name, config });
-        }
-        catch (error) {
-            this.logger.error(`Failed to configure plugin '${name}'`, error);
-            this.eventBus.emit('plugin:error', { name, error: error });
-            throw error;
-        }
-    }
-    // Enable multiple plugins with dependency resolution
-    async enablePlugins(names) {
-        const resolved = this.resolveDependencies(names);
-        for (const name of resolved) {
-            if (!this.enabledPlugins.has(name)) {
-                await this.enable(name);
-            }
-        }
-    }
-    // Disable multiple plugins
-    async disablePlugins(names) {
-        // Disable in reverse order to handle dependencies
-        const reversed = [...names].reverse();
-        for (const name of reversed) {
-            if (this.enabledPlugins.has(name)) {
-                await this.disable(name);
-            }
-        }
-    }
-    // Get enabled plugins
-    getEnabledPlugins() {
-        return Array.from(this.enabledPlugins)
-            .map(name => this.plugins.get(name))
-            .filter(Boolean)
-            .sort(this.sortByPriority);
-    }
-    // Health check for all enabled plugins
-    async healthCheck() {
-        const results = [];
-        for (const name of this.enabledPlugins) {
-            const plugin = this.plugins.get(name);
-            try {
-                const healthy = plugin.healthCheck ? await plugin.healthCheck() : true;
-                results.push({ name, healthy });
-            }
-            catch (error) {
-                results.push({ name, healthy: false, error: error });
-            }
-        }
-        return results;
-    }
-    // Event handling
-    on(event, listener) {
-        this.eventBus.on(event, listener);
-        return () => this.eventBus.off(event, listener);
-    }
-    // Create plugin context (will be implemented when we have the full context)
-    createPluginContext(pluginName) {
-        // This will be implemented when we integrate with the media player
-        // For now, return a minimal context
-        return {
-            state: {},
-            controls: {},
-            plugins: this,
-            emit: (event, data) => this.eventBus.emit(event, data),
-            on: (event, handler) => {
-                this.eventBus.on(event, handler);
-                return () => this.eventBus.off(event, handler);
-            },
-            element: null,
-            logger: this.createPluginLogger(pluginName)
-        };
-    }
-    // Create plugin-specific logger
-    createPluginLogger(pluginName) {
-        return {
-            info: (message, data) => this.logger.info(`[${pluginName}] ${message}`, data),
-            warn: (message, data) => this.logger.warn(`[${pluginName}] ${message}`, data),
-            error: (message, data) => this.logger.error(`[${pluginName}] ${message}`, data),
-            debug: (message, data) => this.logger.debug(`[${pluginName}] ${message}`, data)
-        };
-    }
-    // Resolve plugin dependencies
-    resolveDependencies(names) {
-        const resolved = [];
-        const visiting = new Set();
-        const visit = (name) => {
-            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');
-            }
-            // Visit dependencies first
-            for (const dep of plugin.metadata.dependencies || []) {
-                visit(dep);
-            }
-            visiting.delete(name);
-            resolved.push(name);
-        };
-        for (const name of names) {
-            visit(name);
-        }
-        return resolved;
-    }
-    // Sort plugins by priority
-    sortByPriority(a, b) {
-        const priorityOrder = {
-            high: 3,
-            medium: 2,
-            low: 1
-        };
-        return priorityOrder[b.metadata.priority] - priorityOrder[a.metadata.priority];
-    }
-}

package/src/core/plugins/types.js

@@ -1,31 +0,0 @@
-// Plugin error types
-export class PluginError extends Error {
-    pluginName;
-    phase;
-    originalError;
-    constructor(pluginName, phase, message, originalError) {
-        super(`Plugin '${pluginName}' failed during ${phase}: ${message}`);
-        this.pluginName = pluginName;
-        this.phase = phase;
-        this.originalError = originalError;
-        this.name = 'PluginError';
-    }
-}
-// Plugin dependency error
-export class PluginDependencyError extends PluginError {
-    missingDependencies;
-    constructor(pluginName, missingDependencies) {
-        super(pluginName, 'initialize', `Missing dependencies: ${missingDependencies.join(', ')}`);
-        this.missingDependencies = missingDependencies;
-        this.name = 'PluginDependencyError';
-    }
-}
-// Plugin conflict error
-export class PluginConflictError extends PluginError {
-    conflictingPlugins;
-    constructor(pluginName, conflictingPlugins) {
-        super(pluginName, 'activate', `Conflicts with active plugins: ${conflictingPlugins.join(', ')}`);
-        this.conflictingPlugins = conflictingPlugins;
-        this.name = 'PluginConflictError';
-    }
-}

package/src/core/plugins/utils.js

@@ -1,274 +0,0 @@
-// Simple console logger implementation
-export class ConsolePluginLogger {
-    prefix;
-    constructor(prefix = '[Plugin]') {
-        this.prefix = prefix;
-    }
-    info(message, data) {
-        if (data) {
-            console.info(`${this.prefix} ${message}`, data);
-        }
-        else {
-            console.info(`${this.prefix} ${message}`);
-        }
-    }
-    warn(message, data) {
-        if (data) {
-            console.warn(`${this.prefix} ${message}`, data);
-        }
-        else {
-            console.warn(`${this.prefix} ${message}`);
-        }
-    }
-    error(message, data) {
-        if (data) {
-            console.error(`${this.prefix} ${message}`, data);
-        }
-        else {
-            console.error(`${this.prefix} ${message}`);
-        }
-    }
-    debug(message, data) {
-        if (process.env.NODE_ENV === 'development') {
-            if (data) {
-                console.debug(`${this.prefix} ${message}`, data);
-            }
-            else {
-                console.debug(`${this.prefix} ${message}`);
-            }
-        }
-    }
-}
-// Plugin validation utilities
-export class PluginValidator {
-    static validateMetadata(plugin) {
-        const { metadata } = plugin;
-        if (!metadata.name || typeof metadata.name !== 'string') {
-            throw new Error('Plugin metadata must include a valid name');
-        }
-        if (!metadata.version || typeof metadata.version !== 'string') {
-            throw new Error('Plugin metadata must include a valid version');
-        }
-        if (!metadata.description || typeof metadata.description !== 'string') {
-            throw new Error('Plugin metadata must include a valid description');
-        }
-        if (!metadata.category) {
-            throw new Error('Plugin metadata must include a valid category');
-        }
-        if (!metadata.priority) {
-            throw new Error('Plugin metadata must include a valid priority');
-        }
-        return true;
-    }
-    static validateConfig(config, schema) {
-        if (!schema)
-            return true;
-        // Simple schema validation - could be enhanced with a proper schema validator
-        for (const [key, rules] of Object.entries(schema)) {
-            const value = config[key];
-            if (rules.required && (value === undefined || value === null)) {
-                throw new Error(`Configuration property '${key}' is required`);
-            }
-            if (value !== undefined && rules.type && typeof value !== rules.type) {
-                throw new Error(`Configuration property '${key}' must be of type '${rules.type}'`);
-            }
-            if (rules.enum && !rules.enum.includes(value)) {
-                throw new Error(`Configuration property '${key}' must be one of: ${rules.enum.join(', ')}`);
-            }
-            if (rules.min !== undefined && typeof value === 'number' && value < rules.min) {
-                throw new Error(`Configuration property '${key}' must be at least ${rules.min}`);
-            }
-            if (rules.max !== undefined && typeof value === 'number' && value > rules.max) {
-                throw new Error(`Configuration property '${key}' must be at most ${rules.max}`);
-            }
-        }
-        return true;
-    }
-}
-// Plugin performance monitoring
-export class PluginPerformanceMonitor {
-    metrics = new Map();
-    measure(pluginName, operation, fn) {
-        const key = `${pluginName}.${operation}`;
-        const startTime = performance.now();
-        const updateMetrics = () => {
-            const endTime = performance.now();
-            const duration = endTime - startTime;
-            const existing = this.metrics.get(key) || {
-                calls: 0,
-                totalTime: 0,
-                averageTime: 0,
-                lastCall: 0
-            };
-            existing.calls++;
-            existing.totalTime += duration;
-            existing.averageTime = existing.totalTime / existing.calls;
-            existing.lastCall = endTime;
-            this.metrics.set(key, existing);
-        };
-        const result = fn();
-        if (result instanceof Promise) {
-            return result.then((value) => {
-                updateMetrics();
-                return value;
-            }, (error) => {
-                updateMetrics();
-                throw error;
-            });
-        }
-        else {
-            updateMetrics();
-            return result;
-        }
-    }
-    getMetrics(pluginName) {
-        if (pluginName) {
-            const pluginMetrics = {};
-            for (const [key, value] of this.metrics.entries()) {
-                if (key.startsWith(`${pluginName}.`)) {
-                    const operation = key.substring(pluginName.length + 1);
-                    pluginMetrics[operation] = value;
-                }
-            }
-            return pluginMetrics;
-        }
-        return Object.fromEntries(this.metrics.entries());
-    }
-    reset(pluginName) {
-        if (pluginName) {
-            for (const key of this.metrics.keys()) {
-                if (key.startsWith(`${pluginName}.`)) {
-                    this.metrics.delete(key);
-                }
-            }
-        }
-        else {
-            this.metrics.clear();
-        }
-    }
-}
-// Plugin development helpers
-export const PluginDevelopmentHelpers = {
-    // Create a mock plugin context for testing
-    createMockContext() {
-        return {
-            state: {
-                isPlaying: false,
-                currentTime: 0,
-                duration: 0,
-                volume: 1,
-                isMuted: false,
-                isLoading: false,
-                error: null
-            },
-            controls: {
-                play: () => Promise.resolve(),
-                pause: () => Promise.resolve(),
-                seek: (time) => Promise.resolve(),
-                setVolume: (volume) => Promise.resolve(),
-                mute: () => Promise.resolve(),
-                unmute: () => Promise.resolve(),
-                toggleMute: () => Promise.resolve()
-            },
-            plugins: {
-                get: () => undefined,
-                getAll: () => [],
-                isEnabled: () => false
-            },
-            emit: () => { },
-            on: () => () => { },
-            element: null,
-            logger: new ConsolePluginLogger('[MockPlugin]')
-        };
-    },
-    // Create a test plugin for development
-    createTestPlugin(name, hooks = {}) {
-        return {
-            metadata: {
-                name,
-                version: '1.0.0',
-                description: `Test plugin: ${name}`,
-                category: 'ui',
-                priority: 'medium'
-            },
-            initialize: async () => { },
-            activate: async () => { },
-            deactivate: async () => { },
-            destroy: async () => { },
-            healthCheck: () => true,
-            ...hooks
-        };
-    },
-    // Plugin timing utilities
-    time: {
-        async: async (label, fn) => {
-            console.time(label);
-            try {
-                const result = await fn();
-                console.timeEnd(label);
-                return result;
-            }
-            catch (error) {
-                console.timeEnd(label);
-                throw error;
-            }
-        },
-        sync: (label, fn) => {
-            console.time(label);
-            try {
-                const result = fn();
-                console.timeEnd(label);
-                return result;
-            }
-            catch (error) {
-                console.timeEnd(label);
-                throw error;
-            }
-        }
-    }
-};
-// Plugin storage utilities for persistent data
-export class PluginStorage {
-    prefix;
-    constructor(pluginName) {
-        this.prefix = `baroi-plugin-${pluginName}`;
-    }
-    get(key, defaultValue) {
-        try {
-            const item = localStorage.getItem(`${this.prefix}-${key}`);
-            return item ? JSON.parse(item) : defaultValue;
-        }
-        catch {
-            return defaultValue;
-        }
-    }
-    set(key, value) {
-        try {
-            localStorage.setItem(`${this.prefix}-${key}`, JSON.stringify(value));
-        }
-        catch (error) {
-            console.warn(`Failed to store plugin data for key: ${key}`, error);
-        }
-    }
-    remove(key) {
-        try {
-            localStorage.removeItem(`${this.prefix}-${key}`);
-        }
-        catch (error) {
-            console.warn(`Failed to remove plugin data for key: ${key}`, error);
-        }
-    }
-    clear() {
-        try {
-            const keys = Object.keys(localStorage).filter(key => key.startsWith(`${this.prefix}-`));
-            keys.forEach(key => localStorage.removeItem(key));
-        }
-        catch (error) {
-            console.warn('Failed to clear plugin data', error);
-        }
-    }
-}
-// Export default logger instance
-export const defaultPluginLogger = new ConsolePluginLogger();
-// Export default performance monitor instance
-export const defaultPerformanceMonitor = new PluginPerformanceMonitor();