@therealtinhtute/baroiplayer 1.0.7 → 1.1.0

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

@@ -3,18 +3,16 @@
  * Based on deep research analysis of HLS.js optimization patterns
  */
 
-import Hls, { HlsConfig } from 'hls.js';
-import { MediaPlayerConfig } from '../../types';
+import Hls, { HlsConfig } from "hls.js"
+import { MediaPlayerConfig } from "../../types"
 
-export interface EnhancedHLSConfig {
+export interface EnhancedHLSConfig extends HlsConfig {
 	/** Enable machine learning-enhanced adaptive bitrate streaming */
-	enableAdvancedABR?: boolean;
+	enableAdvancedABR?: boolean
 	/** Optimize for low-latency streaming */
-	lowLatencyMode?: boolean;
+	lowLatencyMode?: boolean
 	/** Enhanced buffer management for smoother playback */
-	optimizedBuffering?: boolean;
-	// Include all standard HLS.js properties
-	[key: string]: any;
+	optimizedBuffering?: boolean
 }
 
 export const ENHANCED_HLS_DEFAULTS: EnhancedHLSConfig = {
@@ -51,48 +49,81 @@ export const ENHANCED_HLS_DEFAULTS: EnhancedHLSConfig = {
 				maxNumRetry: 5,
 				retryDelayMs: 3000,
 				maxRetryDelayMs: 30000,
-				backoff: 'linear',
+				backoff: "linear"
 			},
 			errorRetry: {
 				maxNumRetry: 5,
 				retryDelayMs: 3000,
 				maxRetryDelayMs: 30000,
-				backoff: 'linear',
+				backoff: "linear"
+			}
+		}
+	},
+
+	// Progressive segment loading for better performance
+	segmentLoadPolicy: {
+		default: {
+			maxTimeToFirstByteMs: 9000,
+			maxLoadTimeMs: 20000,
+			timeoutRetry: {
+				maxNumRetry: 3,
+				retryDelayMs: 2000,
+				maxRetryDelayMs: 20000,
+				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,
+	// Enhanced manifest parsing
+	manifestLoadPolicy: {
+		default: {
+			maxTimeToFirstByteMs: 9000,
+			maxLoadTimeMs: 20000,
+			timeoutRetry: {
+				maxNumRetry: 3,
+				retryDelayMs: 2000,
+				maxRetryDelayMs: 20000,
+				backoff: "linear"
+			},
+			errorRetry: {
+				maxNumRetry: 5,
+				retryDelayMs: 3000,
+				maxRetryDelayMs: 30000,
+				backoff: "linear"
+			}
+		}
+	},
 
 	// Level selection optimization
 	startLevel: -1, // Auto-select start level
+	initialBitrate: 0, // Auto-detect
+	preferManagedMediaSource: true,
 
 	// Debug and monitoring
 	debug: false,
 	enableWorker: true,
 	enableSoftwareAES: true,
-	workerPath: 'https://cdn.jsdelivr.net/npm/hls.js@latest/dist/hls.worker.js',
+	workerPath: "https://cdn.jsdelivr.net/npm/hls.js@latest/dist/hls.worker.js",
 
 	// Custom configuration flags
 	enableAdvancedABR: true,
-	optimizedBuffering: true,
-};
+	optimizedBuffering: true
+}
 
 export class EnhancedHLSProvider {
-	private hls: Hls | null = null;
-	private config: EnhancedHLSConfig;
-	private performanceMonitor: HLSPerformanceMonitor;
+	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();
+		this.config = { ...ENHANCED_HLS_DEFAULTS, ...config }
+		this.performanceMonitor = new HLSPerformanceMonitor()
 	}
 
 	/**
@@ -104,51 +135,48 @@ export class EnhancedHLSProvider {
 		options: MediaPlayerConfig = {}
 	): Hls {
 		// Clean up existing instance
-		this.destroy();
+		this.destroy()
 
 		// Create new HLS instance with enhanced config
-		this.hls = new Hls(this.config);
+		this.hls = new Hls(this.config)
 
 		// Setup performance monitoring
-		this.performanceMonitor.attach(this.hls);
+		this.performanceMonitor.attach(this.hls)
 
 		// Configure advanced event handling
-		this.setupEventHandlers(videoElement, options);
+		this.setupEventHandlers(videoElement, options)
 
 		// Load media
-		this.hls.loadSource(mediaUrl);
-		this.hls.attachMedia(videoElement);
+		this.hls.loadSource(mediaUrl)
+		this.hls.attachMedia(videoElement)
 
-		return this.hls;
+		return this.hls
 	}
 
 	/**
 	 * Setup enhanced event handlers for better error recovery and performance
 	 */
-	private setupEventHandlers(
-		videoElement: HTMLVideoElement,
-		options: MediaPlayerConfig
-	): void {
-		if (!this.hls) return;
+	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);
-		});
+			this.handleHLSError(event, data, videoElement, options)
+		})
 
 		// Performance monitoring events
 		this.hls.on(Hls.Events.FRAG_BUFFERED, (event, data) => {
-			this.performanceMonitor.onFragmentBuffered(data);
-		});
+			this.performanceMonitor.onFragmentBuffered(data)
+		})
 
 		this.hls.on(Hls.Events.LEVEL_SWITCHED, (event, data) => {
-			this.performanceMonitor.onLevelSwitched(data);
-		});
+			this.performanceMonitor.onLevelSwitched(data)
+		})
 
 		// Quality optimization events
-		(this.hls as any).on('hlsBitrateSwitch', (event: any, data: any) => {
-			this.performanceMonitor.onBitrateSwitch(data);
-		});
+		this.hls.on(Hls.Events.BITRATE_SWITCHING, (event, data) => {
+			this.performanceMonitor.onBitrateSwitch(data)
+		})
 	}
 
 	/**
@@ -160,51 +188,51 @@ export class EnhancedHLSProvider {
 		videoElement: HTMLVideoElement,
 		options: MediaPlayerConfig
 	): void {
-		console.warn('HLS Error:', data);
+		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;
+					const newLevel = Math.max(0, (this.hls.currentLevel || 0) - 1)
+					this.hls.currentLevel = newLevel
 				}
-				break;
+				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;
+					this.hls.config.fragLoadPolicy.default.timeoutRetry.maxNumRetry = 8
+					this.hls.config.fragLoadPolicy.default.timeoutRetry.retryDelayMs = 5000
 				}
-				break;
+				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);
+				if (options.hlsConfig?.fallbackUrl) {
+					this.hls?.loadSource(options.hlsConfig.fallbackUrl)
 				}
-				break;
+				break
 
 			case Hls.ErrorDetails.BUFFER_APPEND_ERROR:
 				// Buffer error - recover with buffer flush
 				if (this.hls && data.frag) {
-					this.hls.swapAudioCodec();
+					this.hls.swapAudioCodec()
 				}
-				break;
+				break
 
 			default:
 				// For other errors, try general recovery
 				if (this.hls && data.fatal) {
-					this.hls.recoverMediaError();
+					this.hls.recoverMediaError()
 				}
-				break;
+				break
 		}
 
 		// Custom error handler if provided
-		if ((options as any).onError) {
-			(options as any).onError(data);
+		if (options.onError) {
+			options.onError(data)
 		}
 	}
 
@@ -212,9 +240,9 @@ export class EnhancedHLSProvider {
 	 * Update configuration dynamically
 	 */
 	public updateConfig(newConfig: Partial<EnhancedHLSConfig>): void {
-		Object.assign(this.config, newConfig);
+		this.config = { ...this.config, ...newConfig }
 		if (this.hls) {
-			Object.assign(this.hls.config, this.config);
+			this.hls.config = this.config
 		}
 	}
 
@@ -222,7 +250,7 @@ export class EnhancedHLSProvider {
 	 * Get current performance metrics
 	 */
 	public getPerformanceMetrics(): any {
-		return this.performanceMonitor.getMetrics();
+		return this.performanceMonitor.getMetrics()
 	}
 
 	/**
@@ -230,9 +258,9 @@ export class EnhancedHLSProvider {
 	 */
 	public destroy(): void {
 		if (this.hls) {
-			this.performanceMonitor.detach();
-			this.hls.destroy();
-			this.hls = null;
+			this.performanceMonitor.detach()
+			this.hls.destroy()
+			this.hls = null
 		}
 	}
 
@@ -240,7 +268,7 @@ export class EnhancedHLSProvider {
 	 * Check if HLS is supported
 	 */
 	public static isSupported(): boolean {
-		return Hls.isSupported();
+		return Hls.isSupported()
 	}
 }
 
@@ -254,23 +282,23 @@ class HLSPerformanceMonitor {
 		bitrateChanges: 0,
 		averageBufferLength: 0,
 		droppedFrames: 0,
-		lastQualitySwitch: 0,
-	};
+		lastQualitySwitch: 0
+	}
 
-	private startTime: number = Date.now();
+	private startTime: number = Date.now()
 
 	public attach(hls: Hls): void {
 		// Monitor video element for dropped frames
-		const video = hls.media;
+		const video = hls.media
 		if (video) {
 			const checkDroppedFrames = () => {
-				if ((video as any).getVideoPlaybackQuality) {
-					const quality = (video as any).getVideoPlaybackQuality();
-					this.metrics.droppedFrames = quality.droppedVideoFrames;
+				if (video.getVideoPlaybackQuality) {
+					const quality = video.getVideoPlaybackQuality()
+					this.metrics.droppedFrames = quality.droppedVideoFrames
 				}
-			};
+			}
 
-			video.addEventListener('timeupdate', checkDroppedFrames);
+			video.addEventListener("timeupdate", checkDroppedFrames)
 		}
 	}
 
@@ -279,30 +307,30 @@ class HLSPerformanceMonitor {
 	}
 
 	public onFragmentBuffered(data: any): void {
-		this.metrics.bufferedFragments++;
-		this.updateAverageBufferLength();
+		this.metrics.bufferedFragments++
+		this.updateAverageBufferLength()
 	}
 
 	public onLevelSwitched(data: any): void {
-		this.metrics.levelSwitches++;
-		this.metrics.lastQualitySwitch = Date.now();
+		this.metrics.levelSwitches++
+		this.metrics.lastQualitySwitch = Date.now()
 	}
 
 	public onBitrateSwitch(data: any): void {
-		this.metrics.bitrateChanges++;
+		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;
+		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),
-		};
+			fragmentRate: this.metrics.bufferedFragments / ((Date.now() - this.startTime) / 1000)
+		}
 	}
-}
+}

package/src/core/providers/lazy-provider.tsx

@@ -0,0 +1,51 @@
+import { type ReactNode, Suspense, lazy } from 'react'
+
+export const EnhancedHLSProvider = lazy(() =>
+	import(
+		/* webpackChunkName: "hls-provider" */
+		'./enhanced-hls-provider'
+	).then((module) => ({ default: module.EnhancedHLSProvider }))
+)
+
+export const SubtitleParser = lazy(() =>
+	import(
+		/* webpackChunkName: "subtitle-parser" */
+		'../features/subtitles/subtitle-parser'
+	).then((module) => ({ default: module.SubtitleParser }))
+)
+
+export const SubtitleManager = lazy(() =>
+	import(
+		/* webpackChunkName: "subtitle-manager" */
+		'../features/subtitles/subtitle-manager'
+	).then((module) => ({ default: module.SubtitleManager }))
+)
+
+export const BasePlugin = lazy(() =>
+	import(
+		/* webpackChunkName: "base-plugin" */
+		'../plugins/base-plugin'
+	).then((module) => ({ default: module.BasePlugin }))
+)
+
+export const PluginRegistry = lazy(() =>
+	import(
+		/* webpackChunkName: "plugin-registry" */
+		'../plugins/registry'
+	).then((module) => ({ default: module.PluginRegistry }))
+)
+
+export const AnalyticsPlugin = lazy(() =>
+	import(
+		/* webpackChunkName: "analytics-plugin" */
+		'../plugins/examples/analytics-plugin'
+	).then((module) => ({ default: module.AnalyticsPlugin }))
+)
+
+export type LazyHLSProvider = Promise<{
+	default: new (config?: any) => { isSupported(): boolean; initialize(): any; destroy(): void }
+}>
+
+export function LazyLoader({ children, fallback }: { children: ReactNode; fallback?: ReactNode }) {
+	return <Suspense fallback={fallback ?? <div className="h-full w-full animate-pulse rounded bg-white/10" />}>{children}</Suspense>
+}