@therealtinhtute/baroiplayer 1.0.8 → 1.2.0

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

@@ -1,379 +0,0 @@
-"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
-	}
-}

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

@@ -1,83 +0,0 @@
-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