@therealtinhtute/baroiplayer 1.0.0 → 1.0.1

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

@@ -0,0 +1,274 @@
+// 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();

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

@@ -0,0 +1,316 @@
+import type { Plugin, PluginLogger, PluginConfig } from './types'
+
+// Simple console logger implementation
+export class ConsolePluginLogger implements PluginLogger {
+  private prefix: string
+
+  constructor(prefix = '[Plugin]') {
+    this.prefix = prefix
+  }
+
+  info(message: string, data?: any): void {
+    if (data) {
+      console.info(`${this.prefix} ${message}`, data)
+    } else {
+      console.info(`${this.prefix} ${message}`)
+    }
+  }
+
+  warn(message: string, data?: any): void {
+    if (data) {
+      console.warn(`${this.prefix} ${message}`, data)
+    } else {
+      console.warn(`${this.prefix} ${message}`)
+    }
+  }
+
+  error(message: string, data?: any): void {
+    if (data) {
+      console.error(`${this.prefix} ${message}`, data)
+    } else {
+      console.error(`${this.prefix} ${message}`)
+    }
+  }
+
+  debug(message: string, data?: any): void {
+    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: Plugin): boolean {
+    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: PluginConfig, schema?: Record<string, any>): boolean {
+    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 {
+  private metrics = new Map<string, {
+    calls: number
+    totalTime: number
+    averageTime: number
+    lastCall: number
+  }>()
+
+  measure<T>(pluginName: string, operation: string, fn: () => T | Promise<T>): T | Promise<T> {
+    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?: string) {
+    if (pluginName) {
+      const pluginMetrics: Record<string, any> = {}
+      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?: string): void {
+    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(): any {
+    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: number) => Promise.resolve(),
+        setVolume: (volume: number) => 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: string, hooks: Partial<Plugin> = {}): Plugin {
+    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 <T>(label: string, fn: () => Promise<T>): Promise<T> => {
+      console.time(label)
+      try {
+        const result = await fn()
+        console.timeEnd(label)
+        return result
+      } catch (error) {
+        console.timeEnd(label)
+        throw error
+      }
+    },
+
+    sync: <T>(label: string, fn: () => T): T => {
+      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 {
+  private prefix: string
+
+  constructor(pluginName: string) {
+    this.prefix = `baroi-plugin-${pluginName}`
+  }
+
+  get<T>(key: string, defaultValue?: T): T | undefined {
+    try {
+      const item = localStorage.getItem(`${this.prefix}-${key}`)
+      return item ? JSON.parse(item) as T : defaultValue
+    } catch {
+      return defaultValue
+    }
+  }
+
+  set<T>(key: string, value: T): void {
+    try {
+      localStorage.setItem(`${this.prefix}-${key}`, JSON.stringify(value))
+    } catch (error) {
+      console.warn(`Failed to store plugin data for key: ${key}`, error)
+    }
+  }
+
+  remove(key: string): void {
+    try {
+      localStorage.removeItem(`${this.prefix}-${key}`)
+    } catch (error) {
+      console.warn(`Failed to remove plugin data for key: ${key}`, error)
+    }
+  }
+
+  clear(): void {
+    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()

package/dist/src/core/progressive-loading.d.ts

@@ -0,0 +1,88 @@
+import React from 'react';
+export declare const FEATURES: {
+    readonly SUBTITLES: "subtitles";
+    readonly PLAYLISTS: "playlists";
+    readonly ADVANCED_CONTROLS: "advanced_controls";
+    readonly ANALYTICS: "analytics";
+    readonly PICTURE_IN_PICTURE: "picture_in_picture";
+    readonly QUALITY_SELECTOR: "quality_selector";
+    readonly PLAYBACK_SPEED: "playback_speed";
+    readonly CHAPTERS: "chapters";
+    readonly THUMBNAILS: "thumbnails";
+    readonly KEYBOARD_SHORTCUTS: "keyboard_shortcuts";
+};
+export type FeatureType = typeof FEATURES[keyof typeof FEATURES];
+export interface ProgressiveLoadingConfig {
+    enabledFeatures: FeatureType[];
+    loadingStrategy: 'lazy' | 'preload' | 'immediate';
+    fallbackTimeout: number;
+    retryAttempts: number;
+}
+export declare const defaultProgressiveConfig: ProgressiveLoadingConfig;
+export declare const lazyComponents: {
+    SubtitleSelector: React.LazyExoticComponent<({ subtitles, currentSubtitle, onSubtitleChange, className }: {
+        subtitles: import("../components/enhanced/advanced-features").Subtitle[];
+        currentSubtitle: string | null;
+        onSubtitleChange: (subtitleId: string | null) => void;
+        className?: string;
+    }) => import("react/jsx-runtime").JSX.Element>;
+    PlaylistManager: React.LazyExoticComponent<({ subtitles, currentSubtitle, onSubtitleChange, className }: {
+        subtitles: import("../components/enhanced/advanced-features").Subtitle[];
+        currentSubtitle: string | null;
+        onSubtitleChange: (subtitleId: string | null) => void;
+        className?: string;
+    }) => import("react/jsx-runtime").JSX.Element>;
+    QualitySelector: React.LazyExoticComponent<({ qualities, currentQuality, onQualityChange, className }: {
+        qualities: import("../components/enhanced/advanced-features").QualityLevel[];
+        currentQuality: string;
+        onQualityChange: (qualityId: string) => void;
+        className?: string;
+    }) => import("react/jsx-runtime").JSX.Element>;
+    PlaybackSpeedSelector: React.LazyExoticComponent<({ className }: {
+        className?: string;
+    }) => import("react/jsx-runtime").JSX.Element>;
+    ChaptersPanel: React.LazyExoticComponent<({ chapters, onChapterSelect, className }: {
+        chapters: import("../components/enhanced/advanced-features").Chapter[];
+        onChapterSelect: (chapter: import("../components/enhanced/advanced-features").Chapter) => void;
+        className?: string;
+    }) => import("react/jsx-runtime").JSX.Element>;
+    PictureInPictureButton: React.LazyExoticComponent<({ className }: {
+        className?: string;
+    }) => import("react/jsx-runtime").JSX.Element>;
+    AnalyticsTracker: React.LazyExoticComponent<({ subtitles, currentSubtitle, onSubtitleChange, className }: {
+        subtitles: import("../components/enhanced/advanced-features").Subtitle[];
+        currentSubtitle: string | null;
+        onSubtitleChange: (subtitleId: string | null) => void;
+        className?: string;
+    }) => import("react/jsx-runtime").JSX.Element>;
+};
+export declare class FeatureDetector {
+    private static cache;
+    static isSupported(feature: FeatureType): Promise<boolean>;
+    private static checkFeatureSupport;
+}
+export declare class ProgressiveLoader {
+    private config;
+    private loadedFeatures;
+    private loadingPromises;
+    constructor(config?: Partial<ProgressiveLoadingConfig>);
+    loadFeature<T = any>(feature: FeatureType): Promise<T | null>;
+    private loadWithRetry;
+    private loadFeatureModule;
+    private getLoadedFeature;
+    preloadFeatures(features?: FeatureType[]): Promise<void>;
+    getLoadingState(): {
+        loaded: FeatureType[];
+        loading: FeatureType[];
+        enabled: FeatureType[];
+    };
+}
+export declare const progressiveLoader: ProgressiveLoader;
+export declare function useProgressiveFeature<T = any>(feature: FeatureType): {
+    feature: T | null;
+    loading: boolean;
+    error: Error | null;
+    load: () => Promise<void>;
+};
+export declare function withProgressiveFeature<P extends object>(WrappedComponent: React.ComponentType<P>, feature: FeatureType, fallback?: React.ComponentType<P>): (props: P) => import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=progressive-loading.d.ts.map

package/dist/src/core/progressive-loading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"progressive-loading.d.ts","sourceRoot":"","sources":["progressive-loading.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAyB,MAAM,OAAO,CAAC;AAG9C,eAAO,MAAM,QAAQ;;;;;;;;;;;CAWX,CAAC;AAEX,MAAM,MAAM,WAAW,GAAG,OAAO,QAAQ,CAAC,MAAM,OAAO,QAAQ,CAAC,CAAC;AAGjE,MAAM,WAAW,wBAAwB;IACvC,eAAe,EAAE,WAAW,EAAE,CAAC;IAC/B,eAAe,EAAE,MAAM,GAAG,SAAS,GAAG,WAAW,CAAC;IAClD,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,eAAO,MAAM,wBAAwB,EAAE,wBAStC,CAAC;AAGF,eAAO,MAAM,cAAc;;;;;iBAwDd,CAAC;;;;;;iBAAD,CAAC;;;;;;iBAlER,CAAC;;;iBAyIM,CAAC;;;;;iBAyDN,CAAR;;;iBA6C4C,CAAC;;;;;;iBA7KhC,CAAC;;CAjBb,CAAC;AAGF,qBAAa,eAAe;IAC1B,OAAO,CAAC,MAAM,CAAC,KAAK,CAAmC;WAE1C,WAAW,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;mBAU3C,mBAAmB;CAyCzC;AAGD,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,MAAM,CAA2B;IACzC,OAAO,CAAC,cAAc,CAA0B;IAChD,OAAO,CAAC,eAAe,CAAwC;gBAEnD,MAAM,GAAE,OAAO,CAAC,wBAAwB,CAAM;IAIpD,WAAW,CAAC,CAAC,GAAG,GAAG,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;YAsCrD,aAAa;YAcb,iBAAiB;IAqC/B,OAAO,CAAC,gBAAgB;IAMlB,eAAe,CAAC,QAAQ,GAAE,WAAW,EAAgC;IAM3E,eAAe;;;;;CAOhB;AAGD,eAAO,MAAM,iBAAiB,mBAA0B,CAAC;AAGzD,wBAAgB,qBAAqB,CAAC,CAAC,GAAG,GAAG,EAAE,OAAO,EAAE,WAAW,GAAG;IACpE,OAAO,EAAE,CAAC,GAAG,IAAI,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B,CAkCA;AAGD,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,MAAM,EACrD,gBAAgB,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,EACxC,OAAO,EAAE,WAAW,EACpB,QAAQ,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,IAES,OAAO,CAAC,oDAcnD"}