@therealtinhtute/baroiplayer 1.0.6 → 1.0.7

package/src/context/error-handling.js

@@ -1,300 +0,0 @@
-"use client";
-import React from "react";
-// Error types specific to media operations
-export var MediaErrorType;
-(function (MediaErrorType) {
-    MediaErrorType["NETWORK_ERROR"] = "NETWORK_ERROR";
-    MediaErrorType["PLAYBACK_ERROR"] = "PLAYBACK_ERROR";
-    MediaErrorType["PERMISSION_ERROR"] = "PERMISSION_ERROR";
-    MediaErrorType["NOT_SUPPORTED_ERROR"] = "NOT_SUPPORTED_ERROR";
-    MediaErrorType["TIMEOUT_ERROR"] = "TIMEOUT_ERROR";
-    MediaErrorType["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
-})(MediaErrorType || (MediaErrorType = {}));
-// Default retry configuration
-const DEFAULT_RETRY_CONFIG = {
-    maxRetries: 3,
-    baseDelay: 1000,
-    maxDelay: 10000,
-    exponentialBackoff: true,
-    retryableErrors: [
-        MediaErrorType.NETWORK_ERROR,
-        MediaErrorType.TIMEOUT_ERROR
-    ],
-    retryableActions: [
-        "PLAY",
-        "PAUSE",
-        "SEEK",
-        "SET_VOLUME",
-        "ENTER_FULLSCREEN",
-        "EXIT_FULLSCREEN"
-    ]
-};
-// Network error recovery
-class NetworkErrorRecovery {
-    canRecover(error) {
-        return error.type === MediaErrorType.NETWORK_ERROR && error.retryCount < 3;
-    }
-    async recover(error) {
-        // Wait for network to become available
-        if (navigator.onLine === false) {
-            await new Promise(resolve => {
-                const handleOnline = () => {
-                    window.removeEventListener('online', handleOnline);
-                    resolve(void 0);
-                };
-                window.addEventListener('online', handleOnline);
-            });
-        }
-        // Additional delay for network stability
-        await new Promise(resolve => setTimeout(resolve, 2000));
-    }
-}
-// Playback error recovery
-class PlaybackErrorRecovery {
-    canRecover(error) {
-        return error.type === MediaErrorType.PLAYBACK_ERROR && error.retryCount < 2;
-    }
-    async recover(error) {
-        // Try to reload the media element
-        const mediaElement = document.querySelector('video, audio');
-        if (mediaElement) {
-            mediaElement.load();
-            await new Promise(resolve => {
-                const handleCanPlay = () => {
-                    mediaElement.removeEventListener('canplay', handleCanPlay);
-                    resolve(void 0);
-                };
-                mediaElement.addEventListener('canplay', handleCanPlay);
-            });
-        }
-    }
-}
-// Permission error recovery (for fullscreen, etc.)
-class PermissionErrorRecovery {
-    canRecover(error) {
-        return error.type === MediaErrorType.PERMISSION_ERROR &&
-            error.action?.type === 'ENTER_FULLSCREEN';
-    }
-    async recover(error) {
-        // Request user interaction for fullscreen
-        console.warn('Fullscreen requires user interaction');
-        // In a real implementation, you might show a message to the user
-    }
-}
-// Error handler class
-export class MediaErrorHandler {
-    config;
-    recoveryStrategies;
-    errorQueue = new Map();
-    listeners = new Set();
-    constructor(config = {}, recoveryStrategies = []) {
-        this.config = { ...DEFAULT_RETRY_CONFIG, ...config };
-        this.recoveryStrategies = [
-            new NetworkErrorRecovery(),
-            new PlaybackErrorRecovery(),
-            new PermissionErrorRecovery(),
-            ...recoveryStrategies
-        ];
-    }
-    // Create a media error from a generic error
-    createMediaError(error, action, retryCount = 0) {
-        const timestamp = Date.now();
-        if (error instanceof Error) {
-            const errorType = this.categorizeError(error, action);
-            return {
-                type: errorType,
-                message: error.message,
-                action,
-                timestamp,
-                retryable: this.isRetryable(errorType, action),
-                retryCount,
-                originalError: error
-            };
-        }
-        return {
-            type: MediaErrorType.UNKNOWN_ERROR,
-            message: typeof error === 'string' ? error : 'Unknown error occurred',
-            action,
-            timestamp,
-            retryable: this.isRetryable(MediaErrorType.UNKNOWN_ERROR, action),
-            retryCount
-        };
-    }
-    // Categorize errors based on error properties and action context
-    categorizeError(error, action) {
-        const message = error.message.toLowerCase();
-        // Network-related errors
-        if (message.includes('network') ||
-            message.includes('fetch') ||
-            message.includes('connection') ||
-            error.name === 'NetworkError') {
-            return MediaErrorType.NETWORK_ERROR;
-        }
-        // Permission errors
-        if (message.includes('permission') ||
-            message.includes('denied') ||
-            message.includes('fullscreen') ||
-            error.name === 'NotAllowedError') {
-            return MediaErrorType.PERMISSION_ERROR;
-        }
-        // Playback errors
-        if (message.includes('decode') ||
-            message.includes('format') ||
-            message.includes('codec') ||
-            action?.type === 'PLAY') {
-            return MediaErrorType.PLAYBACK_ERROR;
-        }
-        // Timeout errors
-        if (message.includes('timeout') ||
-            error.name === 'TimeoutError') {
-            return MediaErrorType.TIMEOUT_ERROR;
-        }
-        // Not supported errors
-        if (message.includes('not supported') ||
-            message.includes('unsupported') ||
-            error.name === 'NotSupportedError') {
-            return MediaErrorType.NOT_SUPPORTED_ERROR;
-        }
-        return MediaErrorType.UNKNOWN_ERROR;
-    }
-    // Check if an error/action combination is retryable
-    isRetryable(errorType, action) {
-        const errorRetryable = this.config.retryableErrors.includes(errorType);
-        const actionRetryable = !action || this.config.retryableActions.includes(action.type);
-        return errorRetryable && actionRetryable;
-    }
-    // Calculate retry delay with exponential backoff
-    calculateRetryDelay(retryCount) {
-        if (!this.config.exponentialBackoff) {
-            return this.config.baseDelay;
-        }
-        const delay = this.config.baseDelay * Math.pow(2, retryCount);
-        return Math.min(delay, this.config.maxDelay);
-    }
-    // Handle an error with automatic retry logic
-    async handleError(error, action, retryCallback) {
-        const mediaError = this.createMediaError(error, action, action?.retryCount || 0);
-        const errorId = `${action?.type}-${mediaError.timestamp}`;
-        // Store error for tracking
-        this.errorQueue.set(errorId, mediaError);
-        // Notify listeners
-        this.listeners.forEach(listener => listener(mediaError));
-        // Try recovery strategies
-        for (const strategy of this.recoveryStrategies) {
-            if (strategy.canRecover(mediaError)) {
-                try {
-                    await strategy.recover(mediaError);
-                    break;
-                }
-                catch (recoveryError) {
-                    console.warn('Recovery strategy failed:', recoveryError);
-                }
-            }
-        }
-        // Retry if possible
-        if (mediaError.retryable &&
-            mediaError.retryCount < this.config.maxRetries &&
-            retryCallback &&
-            action) {
-            const delay = this.calculateRetryDelay(mediaError.retryCount);
-            console.log(`Retrying action ${action.type} in ${delay}ms (attempt ${mediaError.retryCount + 1}/${this.config.maxRetries})`);
-            setTimeout(async () => {
-                try {
-                    await retryCallback({
-                        ...action,
-                        retryCount: mediaError.retryCount + 1
-                    });
-                    // Remove from error queue on successful retry
-                    this.errorQueue.delete(errorId);
-                }
-                catch (retryError) {
-                    // Handle retry failure
-                    await this.handleError(retryError, {
-                        ...action,
-                        retryCount: mediaError.retryCount + 1
-                    }, retryCallback);
-                }
-            }, delay);
-        }
-        return mediaError;
-    }
-    // Subscribe to error events
-    subscribe(listener) {
-        this.listeners.add(listener);
-        return () => this.listeners.delete(listener);
-    }
-    // Get current errors
-    getErrors() {
-        return Array.from(this.errorQueue.values());
-    }
-    // Clear specific error
-    clearError(errorId) {
-        this.errorQueue.delete(errorId);
-    }
-    // Clear all errors
-    clearAllErrors() {
-        this.errorQueue.clear();
-    }
-    // Get error statistics
-    getErrorStats() {
-        const errors = this.getErrors();
-        const now = Date.now();
-        const recentThreshold = 5 * 60 * 1000; // 5 minutes
-        const errorsByType = errors.reduce((acc, error) => {
-            acc[error.type] = (acc[error.type] || 0) + 1;
-            return acc;
-        }, {});
-        const retryableErrors = errors.filter(e => e.retryable).length;
-        const recentErrors = errors.filter(e => now - e.timestamp < recentThreshold);
-        return {
-            totalErrors: errors.length,
-            errorsByType,
-            retryableErrors,
-            recentErrors
-        };
-    }
-}
-// Hook for using error handling in components
-export function useMediaErrorHandler(config) {
-    const [handler] = React.useState(() => new MediaErrorHandler(config));
-    const [errors, setErrors] = React.useState([]);
-    React.useEffect(() => {
-        const unsubscribe = handler.subscribe((error) => {
-            setErrors(current => [...current, error]);
-        });
-        return unsubscribe;
-    }, [handler]);
-    const clearError = React.useCallback((errorId) => {
-        handler.clearError(errorId);
-        setErrors(current => current.filter(e => `${e.action?.type}-${e.timestamp}` !== errorId));
-    }, [handler]);
-    const clearAllErrors = React.useCallback(() => {
-        handler.clearAllErrors();
-        setErrors([]);
-    }, [handler]);
-    return {
-        handler,
-        errors,
-        clearError,
-        clearAllErrors,
-        errorStats: handler.getErrorStats()
-    };
-}
-// Hook for error boundaries
-export function useMediaErrorBoundary() {
-    const [error, setError] = React.useState(null);
-    const resetError = React.useCallback(() => {
-        setError(null);
-    }, []);
-    const captureError = React.useCallback((error, action) => {
-        const handler = new MediaErrorHandler();
-        const mediaError = handler.createMediaError(error, action);
-        setError(mediaError);
-    }, []);
-    return {
-        error,
-        hasError: !!error,
-        resetError,
-        captureError
-    };
-}

package/src/context/media-context.js

@@ -1,121 +0,0 @@
-"use client";
-import React from "react";
-// Media action types
-export const MediaActionTypes = {
-    PLAY: "PLAY",
-    PAUSE: "PAUSE",
-    SEEK: "SEEK",
-    SET_VOLUME: "SET_VOLUME",
-    MUTE: "MUTE",
-    UNMUTE: "UNMUTE",
-    TOGGLE_MUTE: "TOGGLE_MUTE",
-    SET_DURATION: "SET_DURATION",
-    SET_CURRENT_TIME: "SET_CURRENT_TIME",
-    SET_BUFFERED: "SET_BUFFERED",
-    SET_LOADING: "SET_LOADING",
-    SET_ERROR: "SET_ERROR",
-    ENTER_FULLSCREEN: "ENTER_FULLSCREEN",
-    EXIT_FULLSCREEN: "EXIT_FULLSCREEN",
-    ENTER_PIP: "ENTER_PIP",
-    EXIT_PIP: "EXIT_PIP",
-    SET_PLAYBACK_RATE: "SET_PLAYBACK_RATE",
-    SET_SUBTITLE_TRACK: "SET_SUBTITLE_TRACK",
-    SET_RENDITION: "SET_RENDITION",
-    TOGGLE_SUBTITLES: "TOGGLE_SUBTITLES",
-    PREVIEW_TIME: "PREVIEW_TIME",
-    CLEAR_PREVIEW: "CLEAR_PREVIEW",
-    // New actions for Video.js adapter
-    SET_BUFFERING: "SET_BUFFERING",
-    SET_QUALITY_LEVEL: "SET_QUALITY_LEVEL",
-    SET_BANDWIDTH_ESTIMATE: "SET_BANDWIDTH_ESTIMATE",
-    SET_ACTIVE_TEXT_TRACKS: "SET_ACTIVE_TEXT_TRACKS"
-};
-// Create the media context
-export const MediaContext = React.createContext(null);
-// Hook to use media context
-export function useMediaContext() {
-    const context = React.useContext(MediaContext);
-    if (!context) {
-        throw new Error("useMediaContext must be used within a MediaPlayer");
-    }
-    return context;
-}
-// Store context for state management
-export const MediaStoreContext = React.createContext(null);
-// Hook to use media store
-export function useMediaStore() {
-    const store = React.useContext(MediaStoreContext);
-    if (!store) {
-        throw new Error("useMediaStore must be used within a MediaPlayer");
-    }
-    return store;
-}
-// Hook to select specific state values - React 19 optimized
-export function useMediaSelector(selector) {
-    const store = useMediaStore();
-    // React 19 compiler will optimize this callback
-    const getSnapshot = () => selector(store.getState());
-    return React.useSyncExternalStore(store.subscribe, getSnapshot, getSnapshot);
-}
-// Hook to get dispatch function
-export function useMediaDispatch() {
-    const store = useMediaStore();
-    return store.dispatch;
-}
-// React 19 enhanced context selector with optimistic updates
-export function useOptimisticMediaSelector(selector) {
-    const store = useMediaStore();
-    // Check if enhanced store is available
-    const isEnhanced = 'getOptimisticState' in store;
-    const getSnapshot = () => {
-        if (isEnhanced) {
-            // Use optimistic state for immediate UI feedback
-            return selector(store.getOptimisticState());
-        }
-        else {
-            // Fall back to regular state
-            return selector(store.getState());
-        }
-    };
-    return React.useSyncExternalStore(store.subscribe, getSnapshot, getSnapshot);
-}
-// Hook for accessing React 19 enhanced features
-export function useMediaEnhancements() {
-    const store = useMediaStore();
-    const context = useMediaContext();
-    const isEnhanced = 'getOptimisticState' in store;
-    const errorHandler = 'errorHandler' in context ? context.errorHandler : null;
-    const isRehydrated = 'isRehydrated' in context ? context.isRehydrated : true;
-    return {
-        isEnhanced,
-        errorHandler,
-        isRehydrated,
-        actionsState: isEnhanced ? store.getActionState() : null
-    };
-}
-// Initial media state
-export const initialMediaState = {
-    isPlaying: false,
-    currentTime: 0,
-    duration: 0,
-    buffered: null,
-    isLoading: false,
-    isBuffering: false,
-    error: null,
-    volume: 1,
-    isMuted: false,
-    isFullscreen: false,
-    isPictureInPicture: false,
-    playbackRate: 1,
-    subtitlesShowing: false,
-    selectedSubtitleTrack: null,
-    selectedRendition: null,
-    qualityLevel: -1,
-    bandwidthEstimate: 0,
-    activeTextTracks: [],
-    previewTime: null,
-    previewImage: null,
-    previewCoords: null,
-    subtitlesList: [],
-    renditionList: []
-};

package/src/context/media-provider.js

@@ -1,164 +0,0 @@
-"use client";
-import { jsx as _jsx } from "react/jsx-runtime";
-import React from "react";
-import { MediaActionTypes, MediaContext, MediaStoreContext, initialMediaState } from "./media-context";
-import { createEnhancedMediaStore } from "./media-store";
-import { useAutoMediaPersistence } from "./persistence";
-import { MediaErrorHandler } from "./error-handling";
-// Legacy store for backward compatibility
-function createLegacyMediaStore(initialState = initialMediaState) {
-    let state = { ...initialState };
-    const listeners = new Set();
-    const subscribe = (callback) => {
-        listeners.add(callback);
-        return () => listeners.delete(callback);
-    };
-    const getState = () => state;
-    const setState = (updates) => {
-        const newState = { ...state, ...updates };
-        if (JSON.stringify(newState) !== JSON.stringify(state)) {
-            state = newState;
-            listeners.forEach((callback) => callback());
-        }
-    };
-    const dispatch = (action) => {
-        switch (action.type) {
-            case MediaActionTypes.PLAY:
-                setState({ isPlaying: true, error: null });
-                break;
-            case MediaActionTypes.PAUSE:
-                setState({ isPlaying: false });
-                break;
-            case MediaActionTypes.SEEK:
-                setState({ currentTime: action.detail });
-                break;
-            case MediaActionTypes.SET_VOLUME:
-                setState({ volume: Math.max(0, Math.min(1, action.detail)) });
-                break;
-            case MediaActionTypes.MUTE:
-                setState({ isMuted: true });
-                break;
-            case MediaActionTypes.UNMUTE:
-                setState({ isMuted: false });
-                break;
-            case MediaActionTypes.TOGGLE_MUTE:
-                setState({ isMuted: !state.isMuted });
-                break;
-            case MediaActionTypes.SET_DURATION:
-                setState({ duration: action.detail });
-                break;
-            case MediaActionTypes.SET_CURRENT_TIME:
-                setState({ currentTime: action.detail });
-                break;
-            case MediaActionTypes.SET_BUFFERED:
-                setState({ buffered: action.detail });
-                break;
-            case MediaActionTypes.SET_LOADING:
-                setState({ isLoading: action.detail });
-                break;
-            case MediaActionTypes.SET_ERROR:
-                setState({ error: action.detail, isLoading: false });
-                break;
-            case MediaActionTypes.ENTER_FULLSCREEN:
-                setState({ isFullscreen: true });
-                break;
-            case MediaActionTypes.EXIT_FULLSCREEN:
-                setState({ isFullscreen: false });
-                break;
-            case MediaActionTypes.ENTER_PIP:
-                setState({ isPictureInPicture: true });
-                break;
-            case MediaActionTypes.EXIT_PIP:
-                setState({ isPictureInPicture: false });
-                break;
-            case MediaActionTypes.SET_PLAYBACK_RATE:
-                setState({ playbackRate: action.detail });
-                break;
-            case MediaActionTypes.SET_SUBTITLE_TRACK:
-                setState({ selectedSubtitleTrack: action.detail });
-                break;
-            case MediaActionTypes.SET_RENDITION:
-                setState({ selectedRendition: action.detail });
-                break;
-            case MediaActionTypes.TOGGLE_SUBTITLES:
-                setState({ subtitlesShowing: !state.subtitlesShowing });
-                break;
-            case MediaActionTypes.PREVIEW_TIME:
-                setState({ previewTime: action.detail });
-                break;
-            case MediaActionTypes.CLEAR_PREVIEW:
-                setState({ previewTime: null, previewImage: null, previewCoords: null });
-                break;
-            default:
-                console.warn(`Unknown media action type: ${action.type}`);
-        }
-    };
-    return { subscribe, getState, setState, dispatch };
-}
-// Enhanced media provider component with React 19 features
-export function MediaProvider({ children, mediaId = "media-player", labelId = "media-player-label", descriptionId = "media-player-description", dir = "ltr", portalContainer, tooltipDelayDuration = 700, tooltipSideOffset = 4, disabled = false, isVideo = true, withoutTooltip = false, initialState = {}, 
-// React 19 enhancements
-useEnhancedStore = true, persistenceConfig, retryConfig, enableOptimisticUpdates = true, enableErrorRecovery = true, onStateRehydrated }) {
-    const rootRef = React.useRef(null);
-    const mediaRef = React.useRef(null);
-    // Create enhanced or legacy store based on configuration
-    const store = React.useMemo(() => {
-        const combinedInitialState = { ...initialMediaState, ...initialState };
-        if (useEnhancedStore) {
-            return createEnhancedMediaStore(combinedInitialState, persistenceConfig);
-        }
-        else {
-            return createLegacyMediaStore(combinedInitialState);
-        }
-    }, [useEnhancedStore, persistenceConfig]);
-    // Error handler for React 19 features
-    const errorHandler = React.useMemo(() => {
-        if (enableErrorRecovery && useEnhancedStore) {
-            return new MediaErrorHandler(retryConfig);
-        }
-        return null;
-    }, [enableErrorRecovery, useEnhancedStore, retryConfig]);
-    // Auto-persistence for React 19 enhanced store
-    const persistenceResult = useEnhancedStore ? useAutoMediaPersistence(store.getState(), mediaId, persistenceConfig) : null;
-    // Handle state rehydration callback
-    React.useEffect(() => {
-        if (persistenceResult?.isRehydrated && onStateRehydrated) {
-            const currentState = store.getState();
-            onStateRehydrated(currentState);
-        }
-    }, [persistenceResult?.isRehydrated, onStateRehydrated, store]);
-    // Enhanced context value with React 19 features
-    const contextValue = React.useMemo(() => ({
-        mediaId,
-        labelId,
-        descriptionId,
-        dir,
-        rootRef,
-        mediaRef,
-        portalContainer,
-        tooltipDelayDuration,
-        tooltipSideOffset,
-        disabled,
-        isVideo,
-        withoutTooltip,
-        // React 19 enhancements
-        errorHandler,
-        isEnhanced: useEnhancedStore,
-        isRehydrated: persistenceResult?.isRehydrated
-    }), [
-        mediaId,
-        labelId,
-        descriptionId,
-        dir,
-        portalContainer,
-        tooltipDelayDuration,
-        tooltipSideOffset,
-        disabled,
-        isVideo,
-        withoutTooltip,
-        errorHandler,
-        useEnhancedStore,
-        persistenceResult?.isRehydrated
-    ]);
-    return (_jsx(MediaContext.Provider, { value: contextValue, children: _jsx(MediaStoreContext.Provider, { value: store, children: children }) }));
-}