@therealtinhtute/baroiplayer 1.0.0 → 1.0.1

package/dist/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/dist/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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"}

package/dist/src/context/persistence.js

@@ -0,0 +1,356 @@
+"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";