@therealtinhtute/baroiplayer 1.0.8 → 1.2.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 Partial<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,62 @@ 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"
+			}
+		}
 	},
 
-	// 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 (not in HlsConfig)
+	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 +116,43 @@ 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);
-		});
-
-		// Quality optimization events
-		(this.hls as any).on('hlsBitrateSwitch', (event: any, data: any) => {
-			this.performanceMonitor.onBitrateSwitch(data);
-		});
+			this.performanceMonitor.onLevelSwitched(data)
+		})
 	}
 
 	/**
@@ -160,51 +164,46 @@ 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;
+				if (this.hls && this.hls.config.fragLoadPolicy?.default?.timeoutRetry) {
+					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);
+				// Manifest error - try recovery
+				if (this.hls && data.fatal) {
+					this.hls.recoverMediaError()
 				}
-				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;
-		}
-
-		// Custom error handler if provided
-		if ((options as any).onError) {
-			(options as any).onError(data);
+				break
 		}
 	}
 
@@ -212,9 +211,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);
+			Object.assign(this.hls.config, this.config)
 		}
 	}
 
@@ -222,7 +221,7 @@ export class EnhancedHLSProvider {
 	 * Get current performance metrics
 	 */
 	public getPerformanceMetrics(): any {
-		return this.performanceMonitor.getMetrics();
+		return this.performanceMonitor.getMetrics()
 	}
 
 	/**
@@ -230,9 +229,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 +239,7 @@ export class EnhancedHLSProvider {
 	 * Check if HLS is supported
 	 */
 	public static isSupported(): boolean {
-		return Hls.isSupported();
+		return Hls.isSupported()
 	}
 }
 
@@ -254,23 +253,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;
-		if (video) {
+		const video = hls.media as HTMLVideoElement | undefined
+		if (video && 'getVideoPlaybackQuality' in video) {
 			const checkDroppedFrames = () => {
-				if ((video as any).getVideoPlaybackQuality) {
-					const quality = (video as any).getVideoPlaybackQuality();
-					this.metrics.droppedFrames = quality.droppedVideoFrames;
+				if (video && 'getVideoPlaybackQuality' in video) {
+					const quality = (video as any).getVideoPlaybackQuality()
+					this.metrics.droppedFrames = quality.droppedVideoFrames
 				}
-			};
+			}
 
-			video.addEventListener('timeupdate', checkDroppedFrames);
+			video.addEventListener("timeupdate", checkDroppedFrames)
 		}
 	}
 
@@ -279,30 +278,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,14 @@
+import { type ReactNode, Suspense } from 'react'
+
+export async function loadEnhancedHLSProvider() {
+	const module = await import('./enhanced-hls-provider')
+	return module.EnhancedHLSProvider
+}
+
+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>
+}

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

@@ -1,97 +1,97 @@
-import React, { createContext, useContext, useMemo } from 'react'
-import { EventBus } from '../events'
-import { PluginRegistry, ConsolePluginLogger } from '../plugins'
+import React, { createContext, useContext, useMemo } from "react"
+import { EventBus } from "../events"
+import { ConsolePluginLogger, PluginRegistry } from "../plugins"
 
 // Service interfaces
 export interface MediaService {
-  loadMedia(src: string): Promise<void>
-  play(): Promise<void>
-  pause(): Promise<void>
-  seek(time: number): Promise<void>
-  setVolume(volume: number): Promise<void>
+	loadMedia(src: string): Promise<void>
+	play(): Promise<void>
+	pause(): Promise<void>
+	seek(time: number): Promise<void>
+	setVolume(volume: number): Promise<void>
 }
 
 export interface StorageService {
-  get<T>(key: string): T | null
-  set<T>(key: string, value: T): void
-  remove(key: string): void
-  clear(): void
+	get<T>(key: string): T | null
+	set<T>(key: string, value: T): void
+	remove(key: string): void
+	clear(): void
 }
 
 export interface AnalyticsService {
-  track(event: string, data?: any): void
-  identify(userId: string, traits?: any): void
-  page(name: string, properties?: any): void
+	track(event: string, data?: any): void
+	identify(userId: string, traits?: any): void
+	page(name: string, properties?: any): void
 }
 
 export interface LoggerService {
-  info(message: string, data?: any): void
-  warn(message: string, data?: any): void
-  error(message: string, data?: any): void
-  debug(message: string, data?: any): void
+	info(message: string, data?: any): void
+	warn(message: string, data?: any): void
+	error(message: string, data?: any): void
+	debug(message: string, data?: any): void
 }
 
 // Service implementations
 class LocalStorageService implements StorageService {
-  get<T>(key: string): T | null {
-    try {
-      const item = localStorage.getItem(`baroi-player-${key}`)
-      return item ? JSON.parse(item) as T : null
-    } catch {
-      return null
-    }
-  }
-
-  set<T>(key: string, value: T): void {
-    try {
-      localStorage.setItem(`baroi-player-${key}`, JSON.stringify(value))
-    } catch (error) {
-      console.warn('Failed to store data:', error)
-    }
-  }
-
-  remove(key: string): void {
-    try {
-      localStorage.removeItem(`baroi-player-${key}`)
-    } catch (error) {
-      console.warn('Failed to remove data:', error)
-    }
-  }
-
-  clear(): void {
-    try {
-      Object.keys(localStorage).forEach(key => {
-        if (key.startsWith('baroi-player-')) {
-          localStorage.removeItem(key)
-        }
-      })
-    } catch (error) {
-      console.warn('Failed to clear data:', error)
-    }
-  }
+	get<T>(key: string): T | null {
+		try {
+			const item = localStorage.getItem(`baroi-player-${key}`)
+			return item ? (JSON.parse(item) as T) : null
+		} catch {
+			return null
+		}
+	}
+
+	set<T>(key: string, value: T): void {
+		try {
+			localStorage.setItem(`baroi-player-${key}`, JSON.stringify(value))
+		} catch (error) {
+			console.warn("Failed to store data:", error)
+		}
+	}
+
+	remove(key: string): void {
+		try {
+			localStorage.removeItem(`baroi-player-${key}`)
+		} catch (error) {
+			console.warn("Failed to remove data:", error)
+		}
+	}
+
+	clear(): void {
+		try {
+			Object.keys(localStorage).forEach((key) => {
+				if (key.startsWith("baroi-player-")) {
+					localStorage.removeItem(key)
+				}
+			})
+		} catch (error) {
+			console.warn("Failed to clear data:", error)
+		}
+	}
 }
 
 class NoOpAnalyticsService implements AnalyticsService {
-  track(event: string, data?: any): void {
-    console.log('Analytics:', event, data)
-  }
+	track(event: string, data?: any): void {
+		console.log("Analytics:", event, data)
+	}
 
-  identify(userId: string, traits?: any): void {
-    console.log('Analytics identify:', userId, traits)
-  }
+	identify(userId: string, traits?: any): void {
+		console.log("Analytics identify:", userId, traits)
+	}
 
-  page(name: string, properties?: any): void {
-    console.log('Analytics page:', name, properties)
-  }
+	page(name: string, properties?: any): void {
+		console.log("Analytics page:", name, properties)
+	}
 }
 
 // Service container
 export interface ServiceContainer {
-  eventBus: EventBus
-  pluginRegistry: PluginRegistry
-  storage: StorageService
-  analytics: AnalyticsService
-  logger: LoggerService
+	eventBus: EventBus
+	pluginRegistry: PluginRegistry
+	storage: StorageService
+	analytics: AnalyticsService
+	logger: LoggerService
 }
 
 // Service provider context
@@ -99,70 +99,66 @@ const ServiceContext = createContext<ServiceContainer | null>(null)
 
 // Service provider props
 export interface ServiceProviderProps {
-  children: React.ReactNode
-  services?: Partial<ServiceContainer>
+	children: React.ReactNode
+	services?: Partial<ServiceContainer>
 }
 
 // Service provider component
 export function ServiceProvider({ children, services = {} }: ServiceProviderProps) {
-  const container = useMemo<ServiceContainer>(() => {
-    const logger = services.logger || new ConsolePluginLogger('[BaroiPlayer]')
-    const eventBus = services.eventBus || new EventBus()
-    const pluginRegistry = services.pluginRegistry || new PluginRegistry(logger)
-    const storage = services.storage || new LocalStorageService()
-    const analytics = services.analytics || new NoOpAnalyticsService()
-
-    return {
-      eventBus,
-      pluginRegistry,
-      storage,
-      analytics,
-      logger
-    }
-  }, [services])
-
-  return (
-    <ServiceContext.Provider value={container}>
-      {children}
-    </ServiceContext.Provider>
-  )
+	const container = useMemo<ServiceContainer>(() => {
+		const logger = services.logger || new ConsolePluginLogger("[BaroiPlayer]")
+		const eventBus = services.eventBus || new EventBus()
+		const pluginRegistry = services.pluginRegistry || new PluginRegistry(logger)
+		const storage = services.storage || new LocalStorageService()
+		const analytics = services.analytics || new NoOpAnalyticsService()
+
+		return {
+			eventBus,
+			pluginRegistry,
+			storage,
+			analytics,
+			logger
+		}
+	}, [services])
+
+	return <ServiceContext.Provider value={container}>{children}</ServiceContext.Provider>
 }
 
 // Service hooks
 export function useServices(): ServiceContainer {
-  const context = useContext(ServiceContext)
-  if (!context) {
-    throw new Error('useServices must be used within ServiceProvider')
-  }
-  return context
+	const context = useContext(ServiceContext)
+	if (!context) {
+		throw new Error("useServices must be used within ServiceProvider")
+	}
+	return context
 }
 
 export function useServiceEventBus(): EventBus {
-  return useServices().eventBus
+	return useServices().eventBus
 }
 
 export function usePluginRegistry(): PluginRegistry {
-  return useServices().pluginRegistry
+	return useServices().pluginRegistry
 }
 
 export function useStorage(): StorageService {
-  return useServices().storage
+	return useServices().storage
 }
 
 export function useAnalytics(): AnalyticsService {
-  return useServices().analytics
+	return useServices().analytics
 }
 
 export function useLogger(): LoggerService {
-  return useServices().logger
+	return useServices().logger
 }
 
 // Service decorators for dependency injection
 export function withServices<P extends object>(
-  Component: React.ComponentType<P & { services: ServiceContainer }>
+	Component: React.ComponentType<P & { services: ServiceContainer }>
 ): React.ComponentType<P> {
-  return function WithServicesComponent(props: P) {
-    const services = useServices()
-    return <Component {...props} services={services} />
-  }
-}
+	return function WithServicesComponent(props: P) {
+		const services = useServices()
+		return <Component {...props} services={services} />
+	}
+}