@therealtinhtute/baroiplayer 1.0.7 → 1.1.0

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

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

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