@therealtinhtute/baroiplayer 1.0.0 → 1.0.2

package/src/context/media-provider.js

@@ -0,0 +1,164 @@
+"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 }) }));
+}

package/src/context/media-store.d.ts

@@ -0,0 +1,33 @@
+import type { MediaState, MediaAction } from "./media-context";
+export interface OptimisticMediaAction extends MediaAction {
+    optimistic?: boolean;
+    retryCount?: number;
+    timestamp?: number;
+}
+export interface MediaActionState {
+    pending: boolean;
+    error: string | null;
+    lastAction: OptimisticMediaAction | null;
+    retryCount: number;
+}
+export interface PersistenceConfig {
+    enabled: boolean;
+    key: string;
+    persist: Array<keyof MediaState>;
+    debounceMs: number;
+}
+export interface EnhancedMediaStore {
+    subscribe: (callback: () => void) => () => void;
+    getState: () => MediaState;
+    setState: (updates: Partial<MediaState>) => void;
+    dispatch: (action: MediaAction) => void;
+    getOptimisticState: () => MediaState;
+    dispatchOptimistic: (action: OptimisticMediaAction) => Promise<void>;
+    rollbackOptimistic: (actionId: string) => void;
+    getActionState: () => MediaActionState;
+    setPersistenceConfig: (config: Partial<PersistenceConfig>) => void;
+    rehydrateFromStorage: () => Promise<void>;
+    clearPersistedState: () => void;
+}
+export declare function createEnhancedMediaStore(initialState?: MediaState, persistenceConfig?: Partial<PersistenceConfig>): EnhancedMediaStore;
+//# sourceMappingURL=media-store.d.ts.map

package/src/context/media-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media-store.d.ts","sourceRoot":"","sources":["media-store.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAmB,MAAM,iBAAiB,CAAA;AAI/E,MAAM,WAAW,qBAAsB,SAAQ,WAAW;IACzD,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,SAAS,CAAC,EAAE,MAAM,CAAA;CAClB;AAGD,MAAM,WAAW,gBAAgB;IAChC,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,UAAU,EAAE,qBAAqB,GAAG,IAAI,CAAA;IACxC,UAAU,EAAE,MAAM,CAAA;CAClB;AAGD,MAAM,WAAW,iBAAiB;IACjC,OAAO,EAAE,OAAO,CAAA;IAChB,GAAG,EAAE,MAAM,CAAA;IACX,OAAO,EAAE,KAAK,CAAC,MAAM,UAAU,CAAC,CAAA;IAChC,UAAU,EAAE,MAAM,CAAA;CAClB;AAGD,MAAM,WAAW,kBAAkB;IAElC,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAA;IAC/C,QAAQ,EAAE,MAAM,UAAU,CAAA;IAC1B,QAAQ,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,CAAA;IAChD,QAAQ,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,CAAA;IAGvC,kBAAkB,EAAE,MAAM,UAAU,CAAA;IACpC,kBAAkB,EAAE,CAAC,MAAM,EAAE,qBAAqB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IACpE,kBAAkB,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;IAC9C,cAAc,EAAE,MAAM,gBAAgB,CAAA;IACtC,oBAAoB,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,iBAAiB,CAAC,KAAK,IAAI,CAAA;IAClE,oBAAoB,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IACzC,mBAAmB,EAAE,MAAM,IAAI,CAAA;CAC/B;AAWD,wBAAgB,wBAAwB,CACvC,YAAY,GAAE,UAA8B,EAC5C,iBAAiB,GAAE,OAAO,CAAC,iBAAiB,CAAM,GAChD,kBAAkB,CA+TpB"}

package/src/context/media-store.js

@@ -0,0 +1,273 @@
+"use client";
+import { MediaActionTypes, initialMediaState } from "./media-context";
+// Default persistence configuration
+const DEFAULT_PERSISTENCE_CONFIG = {
+    enabled: true,
+    key: "baroi-player-state",
+    persist: ["volume", "isMuted", "playbackRate", "subtitlesShowing"],
+    debounceMs: 500
+};
+// Create enhanced media store with React 19 features
+export function createEnhancedMediaStore(initialState = initialMediaState, persistenceConfig = {}) {
+    let state = { ...initialState };
+    let optimisticState = { ...initialState };
+    let actionState = {
+        pending: false,
+        error: null,
+        lastAction: null,
+        retryCount: 0
+    };
+    const config = { ...DEFAULT_PERSISTENCE_CONFIG, ...persistenceConfig };
+    const listeners = new Set();
+    const optimisticQueue = new Map();
+    let persistenceTimeout = null;
+    const subscribe = (callback) => {
+        listeners.add(callback);
+        return () => listeners.delete(callback);
+    };
+    const notifyListeners = () => {
+        listeners.forEach((callback) => callback());
+    };
+    const getState = () => state;
+    const getOptimisticState = () => optimisticState;
+    const getActionState = () => actionState;
+    // Persistence helpers
+    const persistState = async () => {
+        if (!config.enabled || typeof window === 'undefined')
+            return;
+        const persistedData = config.persist.reduce((acc, key) => {
+            acc[key] = state[key];
+            return acc;
+        }, {});
+        try {
+            localStorage.setItem(config.key, JSON.stringify({
+                ...persistedData,
+                timestamp: Date.now()
+            }));
+        }
+        catch (error) {
+            console.warn('Failed to persist media state:', error);
+        }
+    };
+    const debouncedPersist = () => {
+        if (persistenceTimeout) {
+            clearTimeout(persistenceTimeout);
+        }
+        persistenceTimeout = setTimeout(persistState, config.debounceMs);
+    };
+    const rehydrateFromStorage = async () => {
+        if (!config.enabled || typeof window === 'undefined')
+            return;
+        try {
+            const stored = localStorage.getItem(config.key);
+            if (!stored)
+                return;
+            const parsedData = JSON.parse(stored);
+            const { timestamp, ...persistedState } = parsedData;
+            // Only rehydrate if data is less than 7 days old
+            const maxAge = 7 * 24 * 60 * 60 * 1000; // 7 days
+            if (timestamp && Date.now() - timestamp > maxAge) {
+                clearPersistedState();
+                return;
+            }
+            // Merge persisted state with current state
+            const newState = { ...state, ...persistedState };
+            if (JSON.stringify(newState) !== JSON.stringify(state)) {
+                state = newState;
+                optimisticState = { ...newState };
+                notifyListeners();
+            }
+        }
+        catch (error) {
+            console.warn('Failed to rehydrate media state:', error);
+        }
+    };
+    const clearPersistedState = () => {
+        if (typeof window === 'undefined')
+            return;
+        try {
+            localStorage.removeItem(config.key);
+        }
+        catch (error) {
+            console.warn('Failed to clear persisted state:', error);
+        }
+    };
+    const setPersistenceConfig = (newConfig) => {
+        Object.assign(config, newConfig);
+    };
+    const setState = (updates) => {
+        const newState = { ...state, ...updates };
+        if (JSON.stringify(newState) !== JSON.stringify(state)) {
+            state = newState;
+            optimisticState = { ...newState };
+            // Persist relevant changes
+            debouncedPersist();
+            notifyListeners();
+        }
+    };
+    const applyOptimisticUpdate = (action) => {
+        const actionId = `${action.type}-${Date.now()}-${Math.random()}`;
+        // Store original action for rollback
+        optimisticQueue.set(actionId, { ...action, timestamp: Date.now() });
+        // Apply optimistic update to optimistic state
+        const optimisticUpdate = processMediaAction(optimisticState, action);
+        optimisticState = { ...optimisticState, ...optimisticUpdate };
+        notifyListeners();
+        return actionId;
+    };
+    const rollbackOptimistic = (actionId) => {
+        if (!optimisticQueue.has(actionId))
+            return;
+        // Remove from queue and recalculate optimistic state
+        optimisticQueue.delete(actionId);
+        // Rebuild optimistic state from actual state + remaining optimistic actions
+        optimisticState = { ...state };
+        for (const [, action] of optimisticQueue) {
+            const update = processMediaAction(optimisticState, action);
+            optimisticState = { ...optimisticState, ...update };
+        }
+        notifyListeners();
+    };
+    // Process media action and return state updates
+    const processMediaAction = (currentState, action) => {
+        switch (action.type) {
+            case MediaActionTypes.PLAY:
+                return { isPlaying: true, error: null };
+            case MediaActionTypes.PAUSE:
+                return { isPlaying: false };
+            case MediaActionTypes.SEEK:
+                return { currentTime: action.detail };
+            case MediaActionTypes.SET_VOLUME:
+                return { volume: Math.max(0, Math.min(1, action.detail)) };
+            case MediaActionTypes.MUTE:
+                return { isMuted: true };
+            case MediaActionTypes.UNMUTE:
+                return { isMuted: false };
+            case MediaActionTypes.TOGGLE_MUTE:
+                return { isMuted: !currentState.isMuted };
+            case MediaActionTypes.SET_DURATION:
+                return { duration: action.detail };
+            case MediaActionTypes.SET_CURRENT_TIME:
+                return { currentTime: action.detail };
+            case MediaActionTypes.SET_BUFFERED:
+                return { buffered: action.detail };
+            case MediaActionTypes.SET_LOADING:
+                return { isLoading: action.detail };
+            case MediaActionTypes.SET_ERROR:
+                return { error: action.detail, isLoading: false };
+            case MediaActionTypes.ENTER_FULLSCREEN:
+                return { isFullscreen: true };
+            case MediaActionTypes.EXIT_FULLSCREEN:
+                return { isFullscreen: false };
+            case MediaActionTypes.ENTER_PIP:
+                return { isPictureInPicture: true };
+            case MediaActionTypes.EXIT_PIP:
+                return { isPictureInPicture: false };
+            case MediaActionTypes.SET_PLAYBACK_RATE:
+                return { playbackRate: action.detail };
+            case MediaActionTypes.SET_SUBTITLE_TRACK:
+                return { selectedSubtitleTrack: action.detail };
+            case MediaActionTypes.SET_RENDITION:
+                return { selectedRendition: action.detail };
+            case MediaActionTypes.TOGGLE_SUBTITLES:
+                return { subtitlesShowing: !currentState.subtitlesShowing };
+            case MediaActionTypes.PREVIEW_TIME:
+                return { previewTime: action.detail };
+            case MediaActionTypes.CLEAR_PREVIEW:
+                return { previewTime: null, previewImage: null, previewCoords: null };
+            default:
+                console.warn(`Unknown media action type: ${action.type}`);
+                return {};
+        }
+    };
+    const dispatch = (action) => {
+        const updates = processMediaAction(state, action);
+        setState(updates);
+    };
+    const dispatchOptimistic = async (action) => {
+        // Set action state to pending
+        actionState = {
+            pending: true,
+            error: null,
+            lastAction: action,
+            retryCount: action.retryCount || 0
+        };
+        // Apply optimistic update immediately
+        const actionId = applyOptimisticUpdate(action);
+        try {
+            // Simulate async operation (e.g., network request, DOM manipulation)
+            await new Promise(resolve => setTimeout(resolve, 0));
+            // Apply the actual update to the real state
+            const updates = processMediaAction(state, action);
+            const newState = { ...state, ...updates };
+            if (JSON.stringify(newState) !== JSON.stringify(state)) {
+                state = newState;
+                debouncedPersist();
+            }
+            // Clean up optimistic action
+            optimisticQueue.delete(actionId);
+            // Update action state
+            actionState = {
+                pending: false,
+                error: null,
+                lastAction: action,
+                retryCount: 0
+            };
+            // Sync optimistic state with actual state
+            optimisticState = { ...state };
+            for (const [, queuedAction] of optimisticQueue) {
+                const update = processMediaAction(optimisticState, queuedAction);
+                optimisticState = { ...optimisticState, ...update };
+            }
+        }
+        catch (error) {
+            // Rollback optimistic update on error
+            rollbackOptimistic(actionId);
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            actionState = {
+                pending: false,
+                error: errorMessage,
+                lastAction: action,
+                retryCount: (action.retryCount || 0) + 1
+            };
+            // Auto-retry logic for certain actions
+            if (actionState.retryCount < 3 && shouldRetry(action.type)) {
+                setTimeout(() => {
+                    dispatchOptimistic({
+                        ...action,
+                        retryCount: actionState.retryCount
+                    });
+                }, Math.pow(2, actionState.retryCount) * 1000); // Exponential backoff
+            }
+        }
+        notifyListeners();
+    };
+    // Determine if an action should be retried
+    const shouldRetry = (actionType) => {
+        const retryableActions = [
+            MediaActionTypes.PLAY,
+            MediaActionTypes.PAUSE,
+            MediaActionTypes.SEEK,
+            MediaActionTypes.SET_VOLUME,
+            MediaActionTypes.MUTE,
+            MediaActionTypes.UNMUTE,
+            MediaActionTypes.TOGGLE_MUTE
+        ];
+        return retryableActions.includes(actionType);
+    };
+    // Initialize with rehydrated state
+    rehydrateFromStorage();
+    return {
+        subscribe,
+        getState,
+        setState,
+        dispatch,
+        getOptimisticState,
+        dispatchOptimistic,
+        rollbackOptimistic,
+        getActionState,
+        setPersistenceConfig,
+        rehydrateFromStorage,
+        clearPersistedState
+    };
+}

package/src/context/persistence.d.ts

@@ -0,0 +1,83 @@
+import type { MediaState } from "./media-context";
+export declare const STORAGE_KEYS: {
+    readonly USER_PREFERENCES: "baroi-player-preferences";
+    readonly SESSION_STATE: "baroi-player-session";
+    readonly PLAYBACK_HISTORY: "baroi-player-history";
+    readonly CACHE_TIMESTAMP: "baroi-player-cache-ts";
+};
+export interface UserPreferences {
+    volume: number;
+    isMuted: boolean;
+    playbackRate: number;
+    subtitlesShowing: boolean;
+    selectedSubtitleTrack: string | null;
+    preferredRendition: string | null;
+    autoplay: boolean;
+    keyboardShortcuts: boolean;
+}
+export interface SessionState {
+    currentTime: number;
+    mediaId?: string;
+    src?: string;
+    playbackPosition: Record<string, number>;
+}
+export interface PlaybackHistoryItem {
+    mediaId: string;
+    src: string;
+    title?: string;
+    currentTime: number;
+    duration: number;
+    timestamp: number;
+    completed: boolean;
+}
+export interface PersistenceConfig {
+    userPreferences: boolean;
+    sessionState: boolean;
+    playbackHistory: boolean;
+    maxHistoryItems: number;
+    maxCacheAge: number;
+    debounceMs: number;
+    storage?: StorageAdapter;
+}
+export interface StorageAdapter {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    clear(): Promise<void>;
+}
+declare class LocalStorageAdapter implements StorageAdapter {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    clear(): Promise<void>;
+}
+export declare class MediaPersistenceManager {
+    private config;
+    private storage;
+    private debounceTimeouts;
+    constructor(config?: Partial<PersistenceConfig>);
+    getUserPreferences(): Promise<UserPreferences | null>;
+    saveUserPreferences(preferences: Partial<UserPreferences>): Promise<void>;
+    clearUserPreferences(): Promise<void>;
+    getSessionState(): Promise<SessionState | null>;
+    saveSessionState(state: Partial<SessionState>): Promise<void>;
+    clearSessionState(): Promise<void>;
+    getPlaybackHistory(): Promise<PlaybackHistoryItem[]>;
+    addToPlaybackHistory(item: Omit<PlaybackHistoryItem, 'timestamp'>): Promise<void>;
+    clearPlaybackHistory(): Promise<void>;
+    savePlaybackPosition(mediaId: string, position: number): Promise<void>;
+    getPlaybackPosition(mediaId: string): Promise<number>;
+    extractUserPreferences(state: MediaState): UserPreferences;
+    extractSessionState(state: MediaState, mediaId?: string): SessionState;
+    clearAll(): Promise<void>;
+    private isCacheExpired;
+    private debounce;
+}
+export declare function useMediaPersistence(config?: Partial<PersistenceConfig>): MediaPersistenceManager;
+export declare function useAutoMediaPersistence(state: MediaState, mediaId?: string, config?: Partial<PersistenceConfig>): {
+    manager: MediaPersistenceManager;
+    isRehydrated: boolean;
+};
+export declare const defaultStorageAdapter: LocalStorageAdapter;
+export {};
+//# sourceMappingURL=persistence.d.ts.map

package/src/context/persistence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence.d.ts","sourceRoot":"","sources":["persistence.ts"],"names":[],"mappings":"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"}