@therealtinhtute/baroiplayer 1.0.6 → 1.0.7

package/src/context/media-store.js

@@ -1,273 +0,0 @@
-"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.js

@@ -1,356 +0,0 @@
-"use client";
-// Storage keys
-export const STORAGE_KEYS = {
-    USER_PREFERENCES: "baroi-player-preferences",
-    SESSION_STATE: "baroi-player-session",
-    PLAYBACK_HISTORY: "baroi-player-history",
-    CACHE_TIMESTAMP: "baroi-player-cache-ts"
-};
-// Default localStorage adapter
-class LocalStorageAdapter {
-    async getItem(key) {
-        if (typeof window === 'undefined')
-            return null;
-        try {
-            return localStorage.getItem(key);
-        }
-        catch (error) {
-            console.warn('Failed to read from localStorage:', error);
-            return null;
-        }
-    }
-    async setItem(key, value) {
-        if (typeof window === 'undefined')
-            return;
-        try {
-            localStorage.setItem(key, value);
-        }
-        catch (error) {
-            console.warn('Failed to write to localStorage:', error);
-        }
-    }
-    async removeItem(key) {
-        if (typeof window === 'undefined')
-            return;
-        try {
-            localStorage.removeItem(key);
-        }
-        catch (error) {
-            console.warn('Failed to remove from localStorage:', error);
-        }
-    }
-    async clear() {
-        if (typeof window === 'undefined')
-            return;
-        try {
-            // Only clear baroi-player keys
-            Object.values(STORAGE_KEYS).forEach(key => {
-                localStorage.removeItem(key);
-            });
-        }
-        catch (error) {
-            console.warn('Failed to clear localStorage:', error);
-        }
-    }
-}
-// Default persistence configuration
-const DEFAULT_CONFIG = {
-    userPreferences: true,
-    sessionState: true,
-    playbackHistory: true,
-    maxHistoryItems: 50,
-    maxCacheAge: 7 * 24 * 60 * 60 * 1000, // 7 days
-    debounceMs: 1000,
-    storage: new LocalStorageAdapter()
-};
-// Persistence manager class
-export class MediaPersistenceManager {
-    config;
-    storage;
-    debounceTimeouts = new Map();
-    constructor(config = {}) {
-        this.config = { ...DEFAULT_CONFIG, ...config };
-        this.storage = this.config.storage;
-    }
-    // User preferences methods
-    async getUserPreferences() {
-        if (!this.config.userPreferences)
-            return null;
-        try {
-            const data = await this.storage.getItem(STORAGE_KEYS.USER_PREFERENCES);
-            if (!data)
-                return null;
-            const parsed = JSON.parse(data);
-            // Validate cache age
-            if (this.isCacheExpired(parsed.timestamp)) {
-                await this.clearUserPreferences();
-                return null;
-            }
-            return parsed.preferences;
-        }
-        catch (error) {
-            console.warn('Failed to get user preferences:', error);
-            return null;
-        }
-    }
-    async saveUserPreferences(preferences) {
-        if (!this.config.userPreferences)
-            return;
-        this.debounce(STORAGE_KEYS.USER_PREFERENCES, async () => {
-            try {
-                const existing = await this.getUserPreferences() || {};
-                const updated = { ...existing, ...preferences };
-                await this.storage.setItem(STORAGE_KEYS.USER_PREFERENCES, JSON.stringify({
-                    preferences: updated,
-                    timestamp: Date.now()
-                }));
-            }
-            catch (error) {
-                console.warn('Failed to save user preferences:', error);
-            }
-        });
-    }
-    async clearUserPreferences() {
-        try {
-            await this.storage.removeItem(STORAGE_KEYS.USER_PREFERENCES);
-        }
-        catch (error) {
-            console.warn('Failed to clear user preferences:', error);
-        }
-    }
-    // Session state methods
-    async getSessionState() {
-        if (!this.config.sessionState)
-            return null;
-        try {
-            const data = await this.storage.getItem(STORAGE_KEYS.SESSION_STATE);
-            if (!data)
-                return null;
-            const parsed = JSON.parse(data);
-            return parsed.state;
-        }
-        catch (error) {
-            console.warn('Failed to get session state:', error);
-            return null;
-        }
-    }
-    async saveSessionState(state) {
-        if (!this.config.sessionState)
-            return;
-        this.debounce(STORAGE_KEYS.SESSION_STATE, async () => {
-            try {
-                const existing = await this.getSessionState() || {
-                    currentTime: 0,
-                    playbackPosition: {}
-                };
-                const updated = { ...existing, ...state };
-                await this.storage.setItem(STORAGE_KEYS.SESSION_STATE, JSON.stringify({
-                    state: updated,
-                    timestamp: Date.now()
-                }));
-            }
-            catch (error) {
-                console.warn('Failed to save session state:', error);
-            }
-        });
-    }
-    async clearSessionState() {
-        try {
-            await this.storage.removeItem(STORAGE_KEYS.SESSION_STATE);
-        }
-        catch (error) {
-            console.warn('Failed to clear session state:', error);
-        }
-    }
-    // Playback history methods
-    async getPlaybackHistory() {
-        if (!this.config.playbackHistory)
-            return [];
-        try {
-            const data = await this.storage.getItem(STORAGE_KEYS.PLAYBACK_HISTORY);
-            if (!data)
-                return [];
-            const parsed = JSON.parse(data);
-            // Validate cache age
-            if (this.isCacheExpired(parsed.timestamp)) {
-                await this.clearPlaybackHistory();
-                return [];
-            }
-            return parsed.history || [];
-        }
-        catch (error) {
-            console.warn('Failed to get playback history:', error);
-            return [];
-        }
-    }
-    async addToPlaybackHistory(item) {
-        if (!this.config.playbackHistory)
-            return;
-        try {
-            const history = await this.getPlaybackHistory();
-            const newItem = {
-                ...item,
-                timestamp: Date.now()
-            };
-            // Remove existing entry for the same media
-            const filteredHistory = history.filter(h => h.mediaId !== item.mediaId);
-            // Add new item at the beginning
-            const updatedHistory = [newItem, ...filteredHistory]
-                .slice(0, this.config.maxHistoryItems);
-            await this.storage.setItem(STORAGE_KEYS.PLAYBACK_HISTORY, JSON.stringify({
-                history: updatedHistory,
-                timestamp: Date.now()
-            }));
-        }
-        catch (error) {
-            console.warn('Failed to add to playback history:', error);
-        }
-    }
-    async clearPlaybackHistory() {
-        try {
-            await this.storage.removeItem(STORAGE_KEYS.PLAYBACK_HISTORY);
-        }
-        catch (error) {
-            console.warn('Failed to clear playback history:', error);
-        }
-    }
-    // Utility methods
-    async savePlaybackPosition(mediaId, position) {
-        const session = await this.getSessionState();
-        const playbackPosition = session?.playbackPosition || {};
-        await this.saveSessionState({
-            playbackPosition: {
-                ...playbackPosition,
-                [mediaId]: position
-            }
-        });
-    }
-    async getPlaybackPosition(mediaId) {
-        const session = await this.getSessionState();
-        return session?.playbackPosition?.[mediaId] || 0;
-    }
-    // Extract preferences from MediaState
-    extractUserPreferences(state) {
-        return {
-            volume: state.volume,
-            isMuted: state.isMuted,
-            playbackRate: state.playbackRate,
-            subtitlesShowing: state.subtitlesShowing,
-            selectedSubtitleTrack: state.selectedSubtitleTrack?.id || null,
-            preferredRendition: state.selectedRendition,
-            autoplay: false, // This would come from config
-            keyboardShortcuts: true // This would come from config
-        };
-    }
-    // Extract session state from MediaState
-    extractSessionState(state, mediaId) {
-        return {
-            currentTime: state.currentTime,
-            mediaId,
-            playbackPosition: {}
-        };
-    }
-    // Clear all persisted data
-    async clearAll() {
-        await this.storage.clear();
-        this.debounceTimeouts.clear();
-    }
-    // Private helper methods
-    isCacheExpired(timestamp) {
-        if (!timestamp)
-            return true;
-        return Date.now() - timestamp > this.config.maxCacheAge;
-    }
-    debounce(key, fn) {
-        const existingTimeout = this.debounceTimeouts.get(key);
-        if (existingTimeout) {
-            clearTimeout(existingTimeout);
-        }
-        const timeout = setTimeout(async () => {
-            await fn();
-            this.debounceTimeouts.delete(key);
-        }, this.config.debounceMs);
-        this.debounceTimeouts.set(key, timeout);
-    }
-}
-// Hook for using persistence in components
-export function useMediaPersistence(config) {
-    const [manager] = React.useState(() => new MediaPersistenceManager(config));
-    React.useEffect(() => {
-        return () => {
-            // Clear any pending debounced operations
-            manager.clearAll();
-        };
-    }, [manager]);
-    return manager;
-}
-// React 19 integration for automatic persistence
-export function useAutoMediaPersistence(state, mediaId, config) {
-    const manager = useMediaPersistence(config);
-    const [isRehydrated, setIsRehydrated] = React.useState(false);
-    // Rehydrate on mount
-    React.useEffect(() => {
-        let isMounted = true;
-        const rehydrate = async () => {
-            try {
-                const [preferences, session] = await Promise.all([
-                    manager.getUserPreferences(),
-                    manager.getSessionState()
-                ]);
-                if (!isMounted)
-                    return;
-                // Return the rehydrated state for the store to apply
-                const rehydratedState = {
-                    ...(preferences && {
-                        volume: preferences.volume,
-                        isMuted: preferences.isMuted,
-                        playbackRate: preferences.playbackRate,
-                        subtitlesShowing: preferences.subtitlesShowing
-                    }),
-                    ...(session && mediaId === session.mediaId && {
-                        currentTime: session.currentTime
-                    })
-                };
-                // Apply rehydrated state via callback if provided
-                if (Object.keys(rehydratedState).length > 0) {
-                    // This would be handled by the store
-                    console.log('Rehydrated state:', rehydratedState);
-                }
-                setIsRehydrated(true);
-            }
-            catch (error) {
-                console.warn('Failed to rehydrate state:', error);
-                setIsRehydrated(true);
-            }
-        };
-        rehydrate();
-        return () => {
-            isMounted = false;
-        };
-    }, [manager, mediaId]);
-    // Auto-persist changes
-    React.useEffect(() => {
-        if (!isRehydrated)
-            return;
-        // Save user preferences
-        const preferences = manager.extractUserPreferences(state);
-        manager.saveUserPreferences(preferences);
-        // Save session state
-        if (mediaId) {
-            const session = manager.extractSessionState(state, mediaId);
-            manager.saveSessionState(session);
-            // Save playback position
-            if (state.currentTime > 0 && state.duration > 0) {
-                manager.savePlaybackPosition(mediaId, state.currentTime);
-            }
-        }
-    }, [manager, state, mediaId, isRehydrated]);
-    return {
-        manager,
-        isRehydrated
-    };
-}
-// Export default storage adapter
-export const defaultStorageAdapter = new LocalStorageAdapter();
-// Import React for hooks
-import React from "react";