@therealtinhtute/baroiplayer 1.0.0 → 1.0.2

package/dist/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/dist/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/dist/src/context/media-store.ts

@@ -0,0 +1,379 @@
+"use client"
+
+import React from "react"
+import type { MediaState, MediaAction, MediaActionType } from "./media-context"
+import { MediaActionTypes, initialMediaState } from "./media-context"
+
+// Enhanced action types for React 19 features
+export interface OptimisticMediaAction extends MediaAction {
+	optimistic?: boolean
+	retryCount?: number
+	timestamp?: number
+}
+
+// Action state for useActionState
+export interface MediaActionState {
+	pending: boolean
+	error: string | null
+	lastAction: OptimisticMediaAction | null
+	retryCount: number
+}
+
+// State persistence configuration
+export interface PersistenceConfig {
+	enabled: boolean
+	key: string
+	persist: Array<keyof MediaState>
+	debounceMs: number
+}
+
+// Enhanced media store interface
+export interface EnhancedMediaStore {
+	// Original store interface
+	subscribe: (callback: () => void) => () => void
+	getState: () => MediaState
+	setState: (updates: Partial<MediaState>) => void
+	dispatch: (action: MediaAction) => void
+	
+	// React 19 enhancements
+	getOptimisticState: () => MediaState
+	dispatchOptimistic: (action: OptimisticMediaAction) => Promise<void>
+	rollbackOptimistic: (actionId: string) => void
+	getActionState: () => MediaActionState
+	setPersistenceConfig: (config: Partial<PersistenceConfig>) => void
+	rehydrateFromStorage: () => Promise<void>
+	clearPersistedState: () => void
+}
+
+// Default persistence configuration
+const DEFAULT_PERSISTENCE_CONFIG: PersistenceConfig = {
+	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: MediaState = initialMediaState,
+	persistenceConfig: Partial<PersistenceConfig> = {}
+): EnhancedMediaStore {
+	let state = { ...initialState }
+	let optimisticState = { ...initialState }
+	let actionState: MediaActionState = {
+		pending: false,
+		error: null,
+		lastAction: null,
+		retryCount: 0
+	}
+
+	const config = { ...DEFAULT_PERSISTENCE_CONFIG, ...persistenceConfig }
+	const listeners = new Set<() => void>()
+	const optimisticQueue = new Map<string, OptimisticMediaAction>()
+	let persistenceTimeout: NodeJS.Timeout | null = null
+	
+	const subscribe = (callback: () => void) => {
+		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 as any)[key] = state[key]
+			return acc
+		}, {} as Partial<MediaState>)
+
+		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) as any
+			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: Partial<PersistenceConfig>) => {
+		Object.assign(config, newConfig)
+	}
+
+	const setState = (updates: Partial<MediaState>) => {
+		const newState = { ...state, ...updates }
+		if (JSON.stringify(newState) !== JSON.stringify(state)) {
+			state = newState
+			optimisticState = { ...newState }
+			
+			// Persist relevant changes
+			debouncedPersist()
+			notifyListeners()
+		}
+	}
+
+	const applyOptimisticUpdate = (action: OptimisticMediaAction) => {
+		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: string) => {
+		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: MediaState, action: MediaAction): Partial<MediaState> => {
+		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: MediaAction) => {
+		const updates = processMediaAction(state, action)
+		setState(updates)
+	}
+
+	const dispatchOptimistic = async (action: OptimisticMediaAction): Promise<void> => {
+		// 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: MediaActionType): boolean => {
+		const retryableActions: MediaActionType[] = [
+			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
+	}
+}