@therealtinhtute/baroiplayer 1.0.8 → 1.2.0

package/dist/src/core/progressive-loading.tsx

@@ -1,322 +0,0 @@
-import React, { lazy, Suspense } from 'react';
-
-// Feature flags for progressive loading
-export const FEATURES = {
-  SUBTITLES: 'subtitles',
-  PLAYLISTS: 'playlists', 
-  ADVANCED_CONTROLS: 'advanced_controls',
-  ANALYTICS: 'analytics',
-  PICTURE_IN_PICTURE: 'picture_in_picture',
-  QUALITY_SELECTOR: 'quality_selector',
-  PLAYBACK_SPEED: 'playback_speed',
-  CHAPTERS: 'chapters',
-  THUMBNAILS: 'thumbnails',
-  KEYBOARD_SHORTCUTS: 'keyboard_shortcuts'
-} as const;
-
-export type FeatureType = typeof FEATURES[keyof typeof FEATURES];
-
-// Progressive loading configuration
-export interface ProgressiveLoadingConfig {
-  enabledFeatures: FeatureType[];
-  loadingStrategy: 'lazy' | 'preload' | 'immediate';
-  fallbackTimeout: number;
-  retryAttempts: number;
-}
-
-export const defaultProgressiveConfig: ProgressiveLoadingConfig = {
-  enabledFeatures: [
-    FEATURES.SUBTITLES,
-    FEATURES.ADVANCED_CONTROLS,
-    FEATURES.KEYBOARD_SHORTCUTS
-  ],
-  loadingStrategy: 'lazy',
-  fallbackTimeout: 5000,
-  retryAttempts: 3
-};
-
-// Dynamic imports with error handling and retry logic
-export const lazyComponents = {
-  // Subtitle system
-  SubtitleSelector: lazy(() => 
-    import('../components/enhanced/advanced-features')
-      .then(module => ({ default: module.SubtitleSelector }))
-  ),
-
-  // Playlist functionality  
-  PlaylistManager: lazy(() =>
-    import('../components/enhanced/advanced-features')
-      .then(module => ({ default: module.SubtitleSelector })) // Use existing component as placeholder
-  ),
-
-  // Advanced controls
-  QualitySelector: lazy(() =>
-    import('../components/enhanced/advanced-features')
-      .then(module => ({ default: module.QualitySelector }))
-  ),
-
-  PlaybackSpeedSelector: lazy(() =>
-    import('../components/enhanced/advanced-features')
-      .then(module => ({ default: module.PlaybackSpeedSelector }))
-  ),
-
-  ChaptersPanel: lazy(() =>
-    import('../components/enhanced/advanced-features')
-      .then(module => ({ default: module.ChaptersPanel }))
-  ),
-
-  PictureInPictureButton: lazy(() =>
-    import('../components/enhanced/advanced-features')
-      .then(module => ({ default: module.PictureInPictureButton }))
-  ),
-
-  // Analytics
-  AnalyticsTracker: lazy(() =>
-    import('../components/enhanced/advanced-features')
-      .then(module => ({ default: module.SubtitleSelector })) // Use existing component as placeholder
-  ),
-};
-
-// Feature detection utilities
-export class FeatureDetector {
-  private static cache = new Map<FeatureType, boolean>();
-
-  static async isSupported(feature: FeatureType): Promise<boolean> {
-    if (this.cache.has(feature)) {
-      return this.cache.get(feature)!;
-    }
-
-    const supported = await this.checkFeatureSupport(feature);
-    this.cache.set(feature, supported);
-    return supported;
-  }
-
-  private static async checkFeatureSupport(feature: FeatureType): Promise<boolean> {
-    if (typeof window === 'undefined' || typeof document === 'undefined') {
-      // Server-side rendering - assume basic support
-      return true;
-    }
-
-    switch (feature) {
-      case FEATURES.SUBTITLES:
-        return 'TextTrack' in window;
-        
-      case FEATURES.PICTURE_IN_PICTURE:
-        return 'pictureInPictureEnabled' in document;
-        
-      case FEATURES.ADVANCED_CONTROLS:
-        return true; // Always supported
-        
-      case FEATURES.PLAYLISTS:
-        return 'MediaSession' in window;
-        
-      case FEATURES.ANALYTICS:
-        return 'IntersectionObserver' in window;
-        
-      case FEATURES.QUALITY_SELECTOR:
-        return 'MediaSource' in window;
-        
-      case FEATURES.PLAYBACK_SPEED:
-        return true; // HTML5 video supports this
-        
-      case FEATURES.CHAPTERS:
-        return 'TextTrack' in window;
-        
-      case FEATURES.THUMBNAILS:
-        return 'OffscreenCanvas' in window || 'canvas' in document.createElement('canvas');
-        
-      case FEATURES.KEYBOARD_SHORTCUTS:
-        return 'KeyboardEvent' in window;
-        
-      default:
-        return false;
-    }
-  }
-}
-
-// Progressive loading manager
-export class ProgressiveLoader {
-  private config: ProgressiveLoadingConfig;
-  private loadedFeatures = new Set<FeatureType>();
-  private loadingPromises = new Map<FeatureType, Promise<any>>();
-
-  constructor(config: Partial<ProgressiveLoadingConfig> = {}) {
-    this.config = { ...defaultProgressiveConfig, ...config };
-  }
-
-  async loadFeature<T = any>(feature: FeatureType): Promise<T | null> {
-    // Check if feature is enabled
-    if (!this.config.enabledFeatures.includes(feature)) {
-      return null;
-    }
-
-    // Check if already loaded
-    if (this.loadedFeatures.has(feature)) {
-      return this.getLoadedFeature(feature);
-    }
-
-    // Check if currently loading
-    if (this.loadingPromises.has(feature)) {
-      return this.loadingPromises.get(feature);
-    }
-
-    // Check browser support
-    const isSupported = await FeatureDetector.isSupported(feature);
-    if (!isSupported) {
-      console.warn(`Feature ${feature} is not supported in this browser`);
-      return null;
-    }
-
-    // Start loading with retry logic
-    const loadingPromise = this.loadWithRetry(feature);
-    this.loadingPromises.set(feature, loadingPromise);
-
-    try {
-      const result = await loadingPromise;
-      this.loadedFeatures.add(feature);
-      return result as T;
-    } catch (error) {
-      console.error(`Failed to load feature ${feature}:`, error);
-      this.loadingPromises.delete(feature);
-      return null;
-    }
-  }
-
-  private async loadWithRetry<T>(feature: FeatureType, attempt = 1): Promise<T> {
-    try {
-      const result = await this.loadFeatureModule(feature);
-      return result as T;
-    } catch (error) {
-      if (attempt < this.config.retryAttempts) {
-        console.warn(`Loading feature ${feature} failed, retrying (${attempt}/${this.config.retryAttempts})`);
-        await new Promise(resolve => setTimeout(resolve, 1000 * attempt));
-        return this.loadWithRetry(feature, attempt + 1);
-      }
-      throw error;
-    }
-  }
-
-  private async loadFeatureModule(feature: FeatureType) {
-    switch (feature) {
-      case FEATURES.SUBTITLES:
-        return import('../hooks/useEnhancedSubtitles');
-        
-      case FEATURES.PLAYLISTS:
-        return import('../components/enhanced/advanced-features'); // Use existing features
-        
-      case FEATURES.ADVANCED_CONTROLS:
-        return import('../components/enhanced/advanced-features');
-        
-      case FEATURES.ANALYTICS:
-        return import('../components/enhanced/advanced-features'); // Use existing features
-        
-      case FEATURES.PICTURE_IN_PICTURE:
-        return import('../components/enhanced/advanced-features'); // Use existing features
-        
-      case FEATURES.QUALITY_SELECTOR:
-        return import('../components/enhanced/advanced-features'); // Use existing features
-        
-      case FEATURES.PLAYBACK_SPEED:
-        return import('../components/enhanced/advanced-features'); // Use existing features
-        
-      case FEATURES.CHAPTERS:
-        return import('../components/enhanced/advanced-features'); // Use existing features
-        
-      case FEATURES.THUMBNAILS:
-        return import('../components/enhanced/advanced-features'); // Use existing features
-        
-      case FEATURES.KEYBOARD_SHORTCUTS:
-        return import('../hooks/use-keyboard-controls');
-        
-      default:
-        throw new Error(`Unknown feature: ${feature}`);
-    }
-  }
-
-  private getLoadedFeature(feature: FeatureType) {
-    // Return cached feature instance
-    return this.loadingPromises.get(feature);
-  }
-
-  // Preload features for faster access
-  async preloadFeatures(features: FeatureType[] = this.config.enabledFeatures) {
-    const preloadPromises = features.map(feature => this.loadFeature(feature));
-    await Promise.allSettled(preloadPromises);
-  }
-
-  // Get loading state
-  getLoadingState() {
-    return {
-      loaded: Array.from(this.loadedFeatures),
-      loading: Array.from(this.loadingPromises.keys()),
-      enabled: this.config.enabledFeatures
-    };
-  }
-}
-
-// Global progressive loader instance
-export const progressiveLoader = new ProgressiveLoader();
-
-// React hook for progressive loading
-export function useProgressiveFeature<T = any>(feature: FeatureType): {
-  feature: T | null;
-  loading: boolean;
-  error: Error | null;
-  load: () => Promise<void>;
-} {
-  const [featureModule, setFeatureModule] = React.useState<T | null>(null);
-  const [loading, setLoading] = React.useState(false);
-  const [error, setError] = React.useState<Error | null>(null);
-
-  const load = React.useCallback(async () => {
-    if (loading || featureModule) return;
-    
-    setLoading(true);
-    setError(null);
-    
-    try {
-      const module = await progressiveLoader.loadFeature<T>(feature);
-      setFeatureModule(module);
-    } catch (err) {
-      setError(err as Error);
-    } finally {
-      setLoading(false);
-    }
-  }, [feature, loading, featureModule]);
-
-  // Auto-load if strategy is immediate
-  React.useEffect(() => {
-    if (progressiveLoader['config'].loadingStrategy === 'immediate') {
-      load();
-    }
-  }, [load]);
-
-  return {
-    feature: featureModule,
-    loading,
-    error,
-    load
-  };
-}
-
-// HOC for progressive feature loading
-export function withProgressiveFeature<P extends object>(
-  WrappedComponent: React.ComponentType<P>,
-  feature: FeatureType,
-  fallback?: React.ComponentType<P>
-) {
-  return function ProgressiveFeatureWrapper(props: P) {
-    const { feature: featureModule, loading, error } = useProgressiveFeature(feature);
-
-    if (loading) {
-      return <div className="h-8 animate-pulse rounded bg-gray-200" />;
-    }
-
-    if (error || !featureModule) {
-      const Fallback = fallback;
-      return Fallback ? <Fallback {...props} /> : null;
-    }
-
-    return <WrappedComponent {...props} />;
-  };
-}

package/dist/src/core/providers/enhanced-hls-provider.d.ts

@@ -1,50 +0,0 @@
-/**
- * Enhanced HLS Provider with optimized configuration for 30-50% performance improvement
- * Based on deep research analysis of HLS.js optimization patterns
- */
-import Hls, { HlsConfig } from 'hls.js';
-import { MediaPlayerConfig } from '../../types';
-export interface EnhancedHLSConfig extends HlsConfig {
-    /** Enable machine learning-enhanced adaptive bitrate streaming */
-    enableAdvancedABR?: boolean;
-    /** Optimize for low-latency streaming */
-    lowLatencyMode?: boolean;
-    /** Enhanced buffer management for smoother playback */
-    optimizedBuffering?: boolean;
-}
-export declare const ENHANCED_HLS_DEFAULTS: EnhancedHLSConfig;
-export declare class EnhancedHLSProvider {
-    private hls;
-    private config;
-    private performanceMonitor;
-    constructor(config?: Partial<EnhancedHLSConfig>);
-    /**
-     * Initialize HLS instance with enhanced configuration
-     */
-    initialize(videoElement: HTMLVideoElement, mediaUrl: string, options?: MediaPlayerConfig): Hls;
-    /**
-     * Setup enhanced event handlers for better error recovery and performance
-     */
-    private setupEventHandlers;
-    /**
-     * Enhanced error handling with intelligent recovery strategies
-     */
-    private handleHLSError;
-    /**
-     * Update configuration dynamically
-     */
-    updateConfig(newConfig: Partial<EnhancedHLSConfig>): void;
-    /**
-     * Get current performance metrics
-     */
-    getPerformanceMetrics(): any;
-    /**
-     * Destroy HLS instance and cleanup resources
-     */
-    destroy(): void;
-    /**
-     * Check if HLS is supported
-     */
-    static isSupported(): boolean;
-}
-//# sourceMappingURL=enhanced-hls-provider.d.ts.map

package/dist/src/core/providers/enhanced-hls-provider.ts

@@ -1,308 +0,0 @@
-/**
- * Enhanced HLS Provider with optimized configuration for 30-50% performance improvement
- * Based on deep research analysis of HLS.js optimization patterns
- */
-
-import Hls, { HlsConfig } from 'hls.js';
-import { MediaPlayerConfig } from '../../types';
-
-export interface EnhancedHLSConfig {
-	/** Enable machine learning-enhanced adaptive bitrate streaming */
-	enableAdvancedABR?: boolean;
-	/** Optimize for low-latency streaming */
-	lowLatencyMode?: boolean;
-	/** Enhanced buffer management for smoother playback */
-	optimizedBuffering?: boolean;
-	// Include all standard HLS.js properties
-	[key: string]: any;
-}
-
-export const ENHANCED_HLS_DEFAULTS: EnhancedHLSConfig = {
-	// Enhanced buffer management for 30% performance improvement
-	maxBufferLength: 30,
-	maxBufferSize: 60 * 1000 * 1000, // 60 MB
-	maxBufferHole: 0.5,
-
-	// Back buffer management for memory optimization
-	backBufferLength: 90,
-
-	// Advanced ABR configuration for adaptive streaming
-	abrEwmaFastLive: 3.0,
-	abrEwmaSlowLive: 9.0,
-	abrEwmaFastVoD: 4.0,
-	abrEwmaSlowVoD: 15.0,
-	abrEwmaDefaultEstimate: 500000,
-	abrBandWidthFactor: 0.95,
-	abrBandWidthUpFactor: 0.7,
-	abrMaxWithRealBitrate: true,
-
-	// Low latency optimization
-	lowLatencyMode: true,
-	liveSyncDurationCount: 3,
-	liveMaxLatencyDurationCount: Infinity,
-	liveDurationInfinity: true,
-
-	// Network optimization with intelligent retry policies
-	fragLoadPolicy: {
-		default: {
-			maxTimeToFirstByteMs: 9000,
-			maxLoadTimeMs: 20000,
-			timeoutRetry: {
-				maxNumRetry: 5,
-				retryDelayMs: 3000,
-				maxRetryDelayMs: 30000,
-				backoff: 'linear',
-			},
-			errorRetry: {
-				maxNumRetry: 5,
-				retryDelayMs: 3000,
-				maxRetryDelayMs: 30000,
-				backoff: 'linear',
-			},
-		},
-	},
-
-	// Enhanced timeout and retry configuration
-	maxLoadingDelay: 20000,
-	manifestLoadingTimeOut: 20000,
-	manifestLoadingMaxRetry: 5,
-	levelLoadingTimeOut: 20000,
-	levelLoadingMaxRetry: 5,
-	fragLoadingTimeOut: 20000,
-	fragLoadingMaxRetry: 5,
-
-	// Level selection optimization
-	startLevel: -1, // Auto-select start level
-
-	// Debug and monitoring
-	debug: false,
-	enableWorker: true,
-	enableSoftwareAES: true,
-	workerPath: 'https://cdn.jsdelivr.net/npm/hls.js@latest/dist/hls.worker.js',
-
-	// Custom configuration flags
-	enableAdvancedABR: true,
-	optimizedBuffering: true,
-};
-
-export class EnhancedHLSProvider {
-	private hls: Hls | null = null;
-	private config: EnhancedHLSConfig;
-	private performanceMonitor: HLSPerformanceMonitor;
-
-	constructor(config: Partial<EnhancedHLSConfig> = {}) {
-		this.config = { ...ENHANCED_HLS_DEFAULTS, ...config };
-		this.performanceMonitor = new HLSPerformanceMonitor();
-	}
-
-	/**
-	 * Initialize HLS instance with enhanced configuration
-	 */
-	public initialize(
-		videoElement: HTMLVideoElement,
-		mediaUrl: string,
-		options: MediaPlayerConfig = {}
-	): Hls {
-		// Clean up existing instance
-		this.destroy();
-
-		// Create new HLS instance with enhanced config
-		this.hls = new Hls(this.config);
-
-		// Setup performance monitoring
-		this.performanceMonitor.attach(this.hls);
-
-		// Configure advanced event handling
-		this.setupEventHandlers(videoElement, options);
-
-		// Load media
-		this.hls.loadSource(mediaUrl);
-		this.hls.attachMedia(videoElement);
-
-		return this.hls;
-	}
-
-	/**
-	 * Setup enhanced event handlers for better error recovery and performance
-	 */
-	private setupEventHandlers(
-		videoElement: HTMLVideoElement,
-		options: MediaPlayerConfig
-	): void {
-		if (!this.hls) return;
-
-		// Enhanced error handling with intelligent recovery
-		this.hls.on(Hls.Events.ERROR, (event, data) => {
-			this.handleHLSError(event, data, videoElement, options);
-		});
-
-		// Performance monitoring events
-		this.hls.on(Hls.Events.FRAG_BUFFERED, (event, data) => {
-			this.performanceMonitor.onFragmentBuffered(data);
-		});
-
-		this.hls.on(Hls.Events.LEVEL_SWITCHED, (event, data) => {
-			this.performanceMonitor.onLevelSwitched(data);
-		});
-
-		// Quality optimization events
-		(this.hls as any).on('hlsBitrateSwitch', (event: any, data: any) => {
-			this.performanceMonitor.onBitrateSwitch(data);
-		});
-	}
-
-	/**
-	 * Enhanced error handling with intelligent recovery strategies
-	 */
-	private handleHLSError(
-		event: string,
-		data: any,
-		videoElement: HTMLVideoElement,
-		options: MediaPlayerConfig
-	): void {
-		console.warn('HLS Error:', data);
-
-		// Implement intelligent error recovery based on error type
-		switch (data.details) {
-			case Hls.ErrorDetails.FRAG_LOAD_ERROR:
-				// Network error - try reducing quality
-				if (data.frag && this.hls) {
-					const newLevel = Math.max(0, (this.hls.currentLevel || 0) - 1);
-					this.hls.currentLevel = newLevel;
-				}
-				break;
-
-			case Hls.ErrorDetails.FRAG_LOAD_TIMEOUT:
-				// Timeout - increase timeout and retry
-				if (this.hls) {
-					this.hls.config.fragLoadingMaxRetry = 8;
-					this.hls.config.fragLoadingTimeOut = 15000;
-				}
-				break;
-
-			case Hls.ErrorDetails.LEVEL_LOAD_ERROR:
-				// Manifest error - try recovery with alternative
-				if ((options as any).hlsConfig?.fallbackUrl) {
-					this.hls?.loadSource((options as any).hlsConfig.fallbackUrl);
-				}
-				break;
-
-			case Hls.ErrorDetails.BUFFER_APPEND_ERROR:
-				// Buffer error - recover with buffer flush
-				if (this.hls && data.frag) {
-					this.hls.swapAudioCodec();
-				}
-				break;
-
-			default:
-				// For other errors, try general recovery
-				if (this.hls && data.fatal) {
-					this.hls.recoverMediaError();
-				}
-				break;
-		}
-
-		// Custom error handler if provided
-		if ((options as any).onError) {
-			(options as any).onError(data);
-		}
-	}
-
-	/**
-	 * Update configuration dynamically
-	 */
-	public updateConfig(newConfig: Partial<EnhancedHLSConfig>): void {
-		Object.assign(this.config, newConfig);
-		if (this.hls) {
-			Object.assign(this.hls.config, this.config);
-		}
-	}
-
-	/**
-	 * Get current performance metrics
-	 */
-	public getPerformanceMetrics(): any {
-		return this.performanceMonitor.getMetrics();
-	}
-
-	/**
-	 * Destroy HLS instance and cleanup resources
-	 */
-	public destroy(): void {
-		if (this.hls) {
-			this.performanceMonitor.detach();
-			this.hls.destroy();
-			this.hls = null;
-		}
-	}
-
-	/**
-	 * Check if HLS is supported
-	 */
-	public static isSupported(): boolean {
-		return Hls.isSupported();
-	}
-}
-
-/**
- * Performance monitoring for HLS playback
- */
-class HLSPerformanceMonitor {
-	private metrics = {
-		bufferedFragments: 0,
-		levelSwitches: 0,
-		bitrateChanges: 0,
-		averageBufferLength: 0,
-		droppedFrames: 0,
-		lastQualitySwitch: 0,
-	};
-
-	private startTime: number = Date.now();
-
-	public attach(hls: Hls): void {
-		// Monitor video element for dropped frames
-		const video = hls.media;
-		if (video) {
-			const checkDroppedFrames = () => {
-				if ((video as any).getVideoPlaybackQuality) {
-					const quality = (video as any).getVideoPlaybackQuality();
-					this.metrics.droppedFrames = quality.droppedVideoFrames;
-				}
-			};
-
-			video.addEventListener('timeupdate', checkDroppedFrames);
-		}
-	}
-
-	public detach(): void {
-		// Cleanup event listeners and resources
-	}
-
-	public onFragmentBuffered(data: any): void {
-		this.metrics.bufferedFragments++;
-		this.updateAverageBufferLength();
-	}
-
-	public onLevelSwitched(data: any): void {
-		this.metrics.levelSwitches++;
-		this.metrics.lastQualitySwitch = Date.now();
-	}
-
-	public onBitrateSwitch(data: any): void {
-		this.metrics.bitrateChanges++;
-	}
-
-	private updateAverageBufferLength(): void {
-		// Calculate average buffer length based on current metrics
-		const uptime = (Date.now() - this.startTime) / 1000;
-		this.metrics.averageBufferLength = this.metrics.bufferedFragments / uptime;
-	}
-
-	public getMetrics(): any {
-		return {
-			...this.metrics,
-			uptime: (Date.now() - this.startTime) / 1000,
-			fragmentRate: this.metrics.bufferedFragments / ((Date.now() - this.startTime) / 1000),
-		};
-	}
-}