@therealtinhtute/baroiplayer 1.0.6 → 1.0.8

package/src/core/progressive-loading.js

@@ -1,239 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import React, { lazy } 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'
-};
-export const defaultProgressiveConfig = {
-    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 {
-    static cache = new Map();
-    static async isSupported(feature) {
-        if (this.cache.has(feature)) {
-            return this.cache.get(feature);
-        }
-        const supported = await this.checkFeatureSupport(feature);
-        this.cache.set(feature, supported);
-        return supported;
-    }
-    static async checkFeatureSupport(feature) {
-        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 {
-    config;
-    loadedFeatures = new Set();
-    loadingPromises = new Map();
-    constructor(config = {}) {
-        this.config = { ...defaultProgressiveConfig, ...config };
-    }
-    async loadFeature(feature) {
-        // 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;
-        }
-        catch (error) {
-            console.error(`Failed to load feature ${feature}:`, error);
-            this.loadingPromises.delete(feature);
-            return null;
-        }
-    }
-    async loadWithRetry(feature, attempt = 1) {
-        try {
-            const result = await this.loadFeatureModule(feature);
-            return result;
-        }
-        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;
-        }
-    }
-    async loadFeatureModule(feature) {
-        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}`);
-        }
-    }
-    getLoadedFeature(feature) {
-        // Return cached feature instance
-        return this.loadingPromises.get(feature);
-    }
-    // Preload features for faster access
-    async preloadFeatures(features = 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(feature) {
-    const [featureModule, setFeatureModule] = React.useState(null);
-    const [loading, setLoading] = React.useState(false);
-    const [error, setError] = React.useState(null);
-    const load = React.useCallback(async () => {
-        if (loading || featureModule)
-            return;
-        setLoading(true);
-        setError(null);
-        try {
-            const module = await progressiveLoader.loadFeature(feature);
-            setFeatureModule(module);
-        }
-        catch (err) {
-            setError(err);
-        }
-        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(WrappedComponent, feature, fallback) {
-    return function ProgressiveFeatureWrapper(props) {
-        const { feature: featureModule, loading, error } = useProgressiveFeature(feature);
-        if (loading) {
-            return _jsx("div", { className: "h-8 animate-pulse rounded bg-gray-200" });
-        }
-        if (error || !featureModule) {
-            const Fallback = fallback;
-            return Fallback ? _jsx(Fallback, { ...props }) : null;
-        }
-        return _jsx(WrappedComponent, { ...props });
-    };
-}

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

@@ -1,273 +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 from 'hls.js';
-export const ENHANCED_HLS_DEFAULTS = {
-    // 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',
-            },
-        },
-    },
-    // 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 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',
-    // Custom configuration flags
-    enableAdvancedABR: true,
-    optimizedBuffering: true,
-};
-export class EnhancedHLSProvider {
-    hls = null;
-    config;
-    performanceMonitor;
-    constructor(config = {}) {
-        this.config = { ...ENHANCED_HLS_DEFAULTS, ...config };
-        this.performanceMonitor = new HLSPerformanceMonitor();
-    }
-    /**
-     * Initialize HLS instance with enhanced configuration
-     */
-    initialize(videoElement, mediaUrl, options = {}) {
-        // 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
-     */
-    setupEventHandlers(videoElement, options) {
-        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.on(Hls.Events.BITRATE_SWITCHING, (event, data) => {
-            this.performanceMonitor.onBitrateSwitch(data);
-        });
-    }
-    /**
-     * Enhanced error handling with intelligent recovery strategies
-     */
-    handleHLSError(event, data, videoElement, options) {
-        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.maxNumRetry = 8;
-                    this.hls.config.fragLoadPolicy.default.timeoutRetry.retryDelayMs = 5000;
-                }
-                break;
-            case Hls.ErrorDetails.LEVEL_LOAD_ERROR:
-                // Manifest error - try recovery with alternative
-                if (options.hlsConfig?.fallbackUrl) {
-                    this.hls?.loadSource(options.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.onError) {
-            options.onError(data);
-        }
-    }
-    /**
-     * Update configuration dynamically
-     */
-    updateConfig(newConfig) {
-        this.config = { ...this.config, ...newConfig };
-        if (this.hls) {
-            this.hls.config = this.config;
-        }
-    }
-    /**
-     * Get current performance metrics
-     */
-    getPerformanceMetrics() {
-        return this.performanceMonitor.getMetrics();
-    }
-    /**
-     * Destroy HLS instance and cleanup resources
-     */
-    destroy() {
-        if (this.hls) {
-            this.performanceMonitor.detach();
-            this.hls.destroy();
-            this.hls = null;
-        }
-    }
-    /**
-     * Check if HLS is supported
-     */
-    static isSupported() {
-        return Hls.isSupported();
-    }
-}
-/**
- * Performance monitoring for HLS playback
- */
-class HLSPerformanceMonitor {
-    metrics = {
-        bufferedFragments: 0,
-        levelSwitches: 0,
-        bitrateChanges: 0,
-        averageBufferLength: 0,
-        droppedFrames: 0,
-        lastQualitySwitch: 0,
-    };
-    startTime = Date.now();
-    attach(hls) {
-        // Monitor video element for dropped frames
-        const video = hls.media;
-        if (video) {
-            const checkDroppedFrames = () => {
-                if (video.getVideoPlaybackQuality) {
-                    const quality = video.getVideoPlaybackQuality();
-                    this.metrics.droppedFrames = quality.droppedVideoFrames;
-                }
-            };
-            video.addEventListener('timeupdate', checkDroppedFrames);
-        }
-    }
-    detach() {
-        // Cleanup event listeners and resources
-    }
-    onFragmentBuffered(data) {
-        this.metrics.bufferedFragments++;
-        this.updateAverageBufferLength();
-    }
-    onLevelSwitched(data) {
-        this.metrics.levelSwitches++;
-        this.metrics.lastQualitySwitch = Date.now();
-    }
-    onBitrateSwitch(data) {
-        this.metrics.bitrateChanges++;
-    }
-    updateAverageBufferLength() {
-        // Calculate average buffer length based on current metrics
-        const uptime = (Date.now() - this.startTime) / 1000;
-        this.metrics.averageBufferLength = this.metrics.bufferedFragments / uptime;
-    }
-    getMetrics() {
-        return {
-            ...this.metrics,
-            uptime: (Date.now() - this.startTime) / 1000,
-            fragmentRate: this.metrics.bufferedFragments / ((Date.now() - this.startTime) / 1000),
-        };
-    }
-}

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

@@ -1,105 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useContext, useMemo } from 'react';
-import { EventBus } from '../events';
-import { PluginRegistry, ConsolePluginLogger } from '../plugins';
-// Service implementations
-class LocalStorageService {
-    get(key) {
-        try {
-            const item = localStorage.getItem(`baroi-player-${key}`);
-            return item ? JSON.parse(item) : null;
-        }
-        catch {
-            return null;
-        }
-    }
-    set(key, value) {
-        try {
-            localStorage.setItem(`baroi-player-${key}`, JSON.stringify(value));
-        }
-        catch (error) {
-            console.warn('Failed to store data:', error);
-        }
-    }
-    remove(key) {
-        try {
-            localStorage.removeItem(`baroi-player-${key}`);
-        }
-        catch (error) {
-            console.warn('Failed to remove data:', error);
-        }
-    }
-    clear() {
-        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 {
-    track(event, data) {
-        console.log('Analytics:', event, data);
-    }
-    identify(userId, traits) {
-        console.log('Analytics identify:', userId, traits);
-    }
-    page(name, properties) {
-        console.log('Analytics page:', name, properties);
-    }
-}
-// Service provider context
-const ServiceContext = createContext(null);
-// Service provider component
-export function ServiceProvider({ children, services = {} }) {
-    const container = useMemo(() => {
-        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 (_jsx(ServiceContext.Provider, { value: container, children: children }));
-}
-// Service hooks
-export function useServices() {
-    const context = useContext(ServiceContext);
-    if (!context) {
-        throw new Error('useServices must be used within ServiceProvider');
-    }
-    return context;
-}
-export function useServiceEventBus() {
-    return useServices().eventBus;
-}
-export function usePluginRegistry() {
-    return useServices().pluginRegistry;
-}
-export function useStorage() {
-    return useServices().storage;
-}
-export function useAnalytics() {
-    return useServices().analytics;
-}
-export function useLogger() {
-    return useServices().logger;
-}
-// Service decorators for dependency injection
-export function withServices(Component) {
-    return function WithServicesComponent(props) {
-        const services = useServices();
-        return _jsx(Component, { ...props, services: services });
-    };
-}

package/src/core/utils.js

@@ -1,21 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { ServiceProvider } from './providers/service-provider';
-// Create architecture wrapper component
-export function createArchitecture(config = {}) {
-    return function ArchitectureProvider({ children }) {
-        return (_jsx(ServiceProvider, { services: config.services, children: children }));
-    };
-}
-// Architecture health check
-export async function healthCheck(services) {
-    const results = {
-        eventBus: {
-            healthy: true,
-            listenerCount: services.eventBus.getListenerCount(),
-            eventTypes: services.eventBus.getEventTypes().length
-        },
-        plugins: await services.pluginRegistry.healthCheck(),
-        timestamp: Date.now()
-    };
-    return results;
-}