@therealtinhtute/baroiplayer 1.0.0 → 1.0.1

package/dist/src/core/plugins/examples/analytics-plugin.ts

@@ -0,0 +1,242 @@
+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

@@ -0,0 +1,8 @@
+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

package/dist/src/core/plugins/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AACA,YAAY,EACV,MAAM,EACN,aAAa,EACb,YAAY,EACZ,cAAc,IAAI,eAAe,EACjC,aAAa,EACb,YAAY,EACZ,cAAc,EACd,cAAc,EACd,cAAc,EACd,WAAW,EACX,YAAY,EACb,MAAM,SAAS,CAAA;AAEhB,OAAO,EACL,WAAW,EACX,qBAAqB,EACrB,mBAAmB,EACpB,MAAM,SAAS,CAAA;AAEhB,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAE3C,OAAO,EACL,UAAU,EACV,YAAY,EACZ,KAAK,cAAc,EACnB,KAAK,qBAAqB,EAC1B,KAAK,uBAAuB,EAC7B,MAAM,eAAe,CAAA;AAGtB,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAA;AAGpF,cAAc,SAAS,CAAA;AAGvB,eAAO,MAAM,qBAAqB,UAAU,CAAA"}

package/dist/src/core/plugins/index.js

@@ -0,0 +1,9 @@
+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';

package/dist/src/core/plugins/index.ts

@@ -0,0 +1,39 @@
+// Plugin system core exports
+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'
+
+// Example plugins
+export { AnalyticsPlugin, createAnalyticsPlugin } from './examples/analytics-plugin'
+
+// Plugin utilities
+export * from './utils'
+
+// Version
+export const PLUGIN_SYSTEM_VERSION = '1.0.0'

package/dist/src/core/plugins/registry.d.ts

@@ -0,0 +1,31 @@
+import type { Plugin, PluginFactory, PluginConfig, PluginRegistry as IPluginRegistry, PluginLogger, PluginEvents } from './types';
+export declare class PluginRegistry implements IPluginRegistry {
+    private plugins;
+    private pluginConfigs;
+    private enabledPlugins;
+    private eventBus;
+    private logger;
+    constructor(logger: PluginLogger);
+    register(factory: PluginFactory, config?: PluginConfig): Promise<void>;
+    unregister(name: string): Promise<void>;
+    get(name: string): Plugin | undefined;
+    getAll(): Plugin[];
+    isEnabled(name: string): boolean;
+    enable(name: string): Promise<void>;
+    disable(name: string): Promise<void>;
+    configure(name: string, config: PluginConfig): Promise<void>;
+    enablePlugins(names: string[]): Promise<void>;
+    disablePlugins(names: string[]): Promise<void>;
+    getEnabledPlugins(): Plugin[];
+    healthCheck(): Promise<{
+        name: string;
+        healthy: boolean;
+        error?: Error;
+    }[]>;
+    on<K extends keyof PluginEvents>(event: K, listener: (data: PluginEvents[K]) => void): () => void;
+    private createPluginContext;
+    private createPluginLogger;
+    private resolveDependencies;
+    private sortByPriority;
+}
+//# sourceMappingURL=registry.d.ts.map

package/dist/src/core/plugins/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["registry.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,MAAM,EACN,aAAa,EACb,YAAY,EACZ,cAAc,IAAI,eAAe,EAEjC,YAAY,EACZ,YAAY,EAEb,MAAM,SAAS,CAAA;AAQhB,qBAAa,cAAe,YAAW,eAAe;IACpD,OAAO,CAAC,OAAO,CAA4B;IAC3C,OAAO,CAAC,aAAa,CAAkC;IACvD,OAAO,CAAC,cAAc,CAAoB;IAC1C,OAAO,CAAC,QAAQ,CAAiB;IACjC,OAAO,CAAC,MAAM,CAAc;gBAEhB,MAAM,EAAE,YAAY;IAK1B,QAAQ,CAAC,OAAO,EAAE,aAAa,EAAE,MAAM,GAAE,YAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;IAsC1E,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAwB7C,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAKrC,MAAM,IAAI,MAAM,EAAE;IAKlB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAK1B,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiCnC,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAgCpC,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IA0B5D,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAW7C,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAYpD,iBAAiB,IAAI,MAAM,EAAE;IAQvB,WAAW,IAAI,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,KAAK,CAAA;KAAE,EAAE,CAAC;IAiBjF,EAAE,CAAC,CAAC,SAAS,MAAM,YAAY,EAC7B,KAAK,EAAE,CAAC,EACR,QAAQ,EAAE,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,KAAK,IAAI,GACxC,MAAM,IAAI;IAMb,OAAO,CAAC,mBAAmB;IAkB3B,OAAO,CAAC,kBAAkB;IAU1B,OAAO,CAAC,mBAAmB;IAkC3B,OAAO,CAAC,cAAc;CASvB"}

package/dist/src/core/plugins/registry.js

@@ -0,0 +1,261 @@
+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];
+    }
+}