@therealtinhtute/baroiplayer 1.2.1 → 2.0.0-beta.1

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

@@ -1,307 +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 Partial<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 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 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",
-
-	// 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)
-		})
-	}
-
-	/**
-	 * 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.fragLoadPolicy?.default?.timeoutRetry) {
-					this.hls.config.fragLoadPolicy.default.timeoutRetry.maxNumRetry = 8
-					this.hls.config.fragLoadPolicy.default.timeoutRetry.retryDelayMs = 5000
-				}
-				break
-
-			case Hls.ErrorDetails.LEVEL_LOAD_ERROR:
-				// Manifest error - try recovery
-				if (this.hls && data.fatal) {
-					this.hls.recoverMediaError()
-				}
-				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
-		}
-	}
-
-	/**
-	 * Update configuration dynamically
-	 */
-	public updateConfig(newConfig: Partial<EnhancedHLSConfig>): void {
-		this.config = { ...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 as HTMLVideoElement | undefined
-		if (video && 'getVideoPlaybackQuality' in video) {
-			const checkDroppedFrames = () => {
-				if (video && 'getVideoPlaybackQuality' in video) {
-					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)
-		}
-	}
-}

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

@@ -1,14 +0,0 @@
-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,164 +0,0 @@
-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>
-}
-
-export interface StorageService {
-	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
-}
-
-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
-}
-
-// 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)
-		}
-	}
-}
-
-class NoOpAnalyticsService implements AnalyticsService {
-	track(event: string, data?: any): void {
-		console.log("Analytics:", event, data)
-	}
-
-	identify(userId: string, traits?: any): void {
-		console.log("Analytics identify:", userId, traits)
-	}
-
-	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
-}
-
-// Service provider context
-const ServiceContext = createContext<ServiceContainer | null>(null)
-
-// Service provider props
-export interface ServiceProviderProps {
-	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>
-}
-
-// Service hooks
-export function useServices(): ServiceContainer {
-	const context = useContext(ServiceContext)
-	if (!context) {
-		throw new Error("useServices must be used within ServiceProvider")
-	}
-	return context
-}
-
-export function useServiceEventBus(): EventBus {
-	return useServices().eventBus
-}
-
-export function usePluginRegistry(): PluginRegistry {
-	return useServices().pluginRegistry
-}
-
-export function useStorage(): StorageService {
-	return useServices().storage
-}
-
-export function useAnalytics(): AnalyticsService {
-	return useServices().analytics
-}
-
-export function useLogger(): LoggerService {
-	return useServices().logger
-}
-
-// Service decorators for dependency injection
-export function withServices<P extends object>(
-	Component: React.ComponentType<P & { services: ServiceContainer }>
-): React.ComponentType<P> {
-	return function WithServicesComponent(props: P) {
-		const services = useServices()
-		return <Component {...props} services={services} />
-	}
-}

package/src/core/utils.tsx

@@ -1,34 +0,0 @@
-import React from "react"
-import { EventBus } from "./events"
-import { PluginRegistry } from "./plugins"
-import { type ServiceContainer, ServiceProvider } from "./providers/service-provider"
-
-// Architecture configuration
-export interface ArchitectureConfig {
-	plugins?: string[]
-	services?: Partial<ServiceContainer>
-	eventMiddleware?: any[]
-	debug?: boolean
-}
-
-// Create architecture wrapper component
-export function createArchitecture(config: ArchitectureConfig = {}) {
-	return function ArchitectureProvider({ children }: { children: React.ReactNode }) {
-		return <ServiceProvider services={config.services}>{children}</ServiceProvider>
-	}
-}
-
-// Architecture health check
-export async function healthCheck(services: ServiceContainer) {
-	const results = {
-		eventBus: {
-			healthy: true,
-			listenerCount: services.eventBus.getListenerCount(),
-			eventTypes: services.eventBus.getEventTypes().length
-		},
-		plugins: await services.pluginRegistry.healthCheck(),
-		timestamp: Date.now()
-	}
-
-	return results
-}