@therealtinhtute/baroiplayer 1.0.8 → 1.2.0

package/src/context/media-store.ts

@@ -1,7 +1,7 @@
 "use client"
 
 import React from "react"
-import type { MediaState, MediaAction, MediaActionType } from "./media-context"
+import type { MediaAction, MediaActionType, MediaState } from "./media-context"
 import { MediaActionTypes, initialMediaState } from "./media-context"
 
 // Enhanced action types for React 19 features
@@ -34,7 +34,7 @@ export interface EnhancedMediaStore {
 	getState: () => MediaState
 	setState: (updates: Partial<MediaState>) => void
 	dispatch: (action: MediaAction) => void
-	
+
 	// React 19 enhancements
 	getOptimisticState: () => MediaState
 	dispatchOptimistic: (action: OptimisticMediaAction) => Promise<void>
@@ -71,7 +71,7 @@ export function createEnhancedMediaStore(
 	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)
@@ -89,20 +89,26 @@ export function createEnhancedMediaStore(
 
 	// 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>)
+		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()
-			}))
+			localStorage.setItem(
+				config.key,
+				JSON.stringify({
+					...persistedData,
+					timestamp: Date.now()
+				})
+			)
 		} catch (error) {
-			console.warn('Failed to persist media state:', error)
+			console.warn("Failed to persist media state:", error)
 		}
 	}
 
@@ -114,7 +120,7 @@ export function createEnhancedMediaStore(
 	}
 
 	const rehydrateFromStorage = async () => {
-		if (!config.enabled || typeof window === 'undefined') return
+		if (!config.enabled || typeof window === "undefined") return
 
 		try {
 			const stored = localStorage.getItem(config.key)
@@ -138,16 +144,16 @@ export function createEnhancedMediaStore(
 				notifyListeners()
 			}
 		} catch (error) {
-			console.warn('Failed to rehydrate media state:', error)
+			console.warn("Failed to rehydrate media state:", error)
 		}
 	}
 
 	const clearPersistedState = () => {
-		if (typeof window === 'undefined') return
+		if (typeof window === "undefined") return
 		try {
 			localStorage.removeItem(config.key)
 		} catch (error) {
-			console.warn('Failed to clear persisted state:', error)
+			console.warn("Failed to clear persisted state:", error)
 		}
 	}
 
@@ -160,7 +166,7 @@ export function createEnhancedMediaStore(
 		if (JSON.stringify(newState) !== JSON.stringify(state)) {
 			state = newState
 			optimisticState = { ...newState }
-			
+
 			// Persist relevant changes
 			debouncedPersist()
 			notifyListeners()
@@ -169,14 +175,14 @@ export function createEnhancedMediaStore(
 
 	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
 	}
@@ -186,86 +192,89 @@ export function createEnhancedMediaStore(
 
 		// 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> => {
+	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 {}
@@ -285,26 +294,26 @@ export function createEnhancedMediaStore(
 			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))
-			
+			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,
@@ -312,26 +321,25 @@ export function createEnhancedMediaStore(
 				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'
+
+			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(() => {
@@ -342,7 +350,7 @@ export function createEnhancedMediaStore(
 				}, Math.pow(2, actionState.retryCount) * 1000) // Exponential backoff
 			}
 		}
-		
+
 		notifyListeners()
 	}
 
@@ -376,4 +384,4 @@ export function createEnhancedMediaStore(
 		rehydrateFromStorage,
 		clearPersistedState
 	}
-}
+}

package/src/context/persistence.ts

@@ -47,14 +47,14 @@ export interface PersistenceConfig {
 	userPreferences: boolean
 	sessionState: boolean
 	playbackHistory: boolean
-	
+
 	// Limits
 	maxHistoryItems: number
 	maxCacheAge: number // milliseconds
-	
+
 	// Debouncing
 	debounceMs: number
-	
+
 	// Custom storage adapter
 	storage?: StorageAdapter
 }
@@ -70,42 +70,42 @@ export interface StorageAdapter {
 // Default localStorage adapter
 class LocalStorageAdapter implements StorageAdapter {
 	async getItem(key: string): Promise<string | null> {
-		if (typeof window === 'undefined') return null
+		if (typeof window === "undefined") return null
 		try {
 			return localStorage.getItem(key)
 		} catch (error) {
-			console.warn('Failed to read from localStorage:', error)
+			console.warn("Failed to read from localStorage:", error)
 			return null
 		}
 	}
 
 	async setItem(key: string, value: string): Promise<void> {
-		if (typeof window === 'undefined') return
+		if (typeof window === "undefined") return
 		try {
 			localStorage.setItem(key, value)
 		} catch (error) {
-			console.warn('Failed to write to localStorage:', error)
+			console.warn("Failed to write to localStorage:", error)
 		}
 	}
 
 	async removeItem(key: string): Promise<void> {
-		if (typeof window === 'undefined') return
+		if (typeof window === "undefined") return
 		try {
 			localStorage.removeItem(key)
 		} catch (error) {
-			console.warn('Failed to remove from localStorage:', error)
+			console.warn("Failed to remove from localStorage:", error)
 		}
 	}
 
 	async clear(): Promise<void> {
-		if (typeof window === 'undefined') return
+		if (typeof window === "undefined") return
 		try {
 			// Only clear baroi-player keys
-			Object.values(STORAGE_KEYS).forEach(key => {
+			Object.values(STORAGE_KEYS).forEach((key) => {
 				localStorage.removeItem(key)
 			})
 		} catch (error) {
-			console.warn('Failed to clear localStorage:', error)
+			console.warn("Failed to clear localStorage:", error)
 		}
 	}
 }
@@ -141,7 +141,7 @@ export class MediaPersistenceManager {
 			if (!data) return null
 
 			const parsed = JSON.parse(data) as { preferences: UserPreferences; timestamp: number }
-			
+
 			// Validate cache age
 			if (this.isCacheExpired(parsed.timestamp)) {
 				await this.clearUserPreferences()
@@ -150,7 +150,7 @@ export class MediaPersistenceManager {
 
 			return parsed.preferences
 		} catch (error) {
-			console.warn('Failed to get user preferences:', error)
+			console.warn("Failed to get user preferences:", error)
 			return null
 		}
 	}
@@ -160,15 +160,18 @@ export class MediaPersistenceManager {
 
 		this.debounce(STORAGE_KEYS.USER_PREFERENCES, async () => {
 			try {
-				const existing = await this.getUserPreferences() || {}
+				const existing = (await this.getUserPreferences()) || {}
 				const updated = { ...existing, ...preferences }
-				
-				await this.storage.setItem(STORAGE_KEYS.USER_PREFERENCES, JSON.stringify({
-					preferences: updated,
-					timestamp: Date.now()
-				}))
+
+				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)
+				console.warn("Failed to save user preferences:", error)
 			}
 		})
 	}
@@ -177,7 +180,7 @@ export class MediaPersistenceManager {
 		try {
 			await this.storage.removeItem(STORAGE_KEYS.USER_PREFERENCES)
 		} catch (error) {
-			console.warn('Failed to clear user preferences:', error)
+			console.warn("Failed to clear user preferences:", error)
 		}
 	}
 
@@ -192,7 +195,7 @@ export class MediaPersistenceManager {
 			const parsed = JSON.parse(data) as { state: SessionState; timestamp: number }
 			return parsed.state
 		} catch (error) {
-			console.warn('Failed to get session state:', error)
+			console.warn("Failed to get session state:", error)
 			return null
 		}
 	}
@@ -202,18 +205,21 @@ export class MediaPersistenceManager {
 
 		this.debounce(STORAGE_KEYS.SESSION_STATE, async () => {
 			try {
-				const existing = await this.getSessionState() || {
+				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()
-				}))
+				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)
+				console.warn("Failed to save session state:", error)
 			}
 		})
 	}
@@ -222,7 +228,7 @@ export class MediaPersistenceManager {
 		try {
 			await this.storage.removeItem(STORAGE_KEYS.SESSION_STATE)
 		} catch (error) {
-			console.warn('Failed to clear session state:', error)
+			console.warn("Failed to clear session state:", error)
 		}
 	}
 
@@ -235,7 +241,7 @@ export class MediaPersistenceManager {
 			if (!data) return []
 
 			const parsed = JSON.parse(data) as { history: PlaybackHistoryItem[]; timestamp: number }
-			
+
 			// Validate cache age
 			if (this.isCacheExpired(parsed.timestamp)) {
 				await this.clearPlaybackHistory()
@@ -244,12 +250,12 @@ export class MediaPersistenceManager {
 
 			return parsed.history || []
 		} catch (error) {
-			console.warn('Failed to get playback history:', error)
+			console.warn("Failed to get playback history:", error)
 			return []
 		}
 	}
 
-	async addToPlaybackHistory(item: Omit<PlaybackHistoryItem, 'timestamp'>): Promise<void> {
+	async addToPlaybackHistory(item: Omit<PlaybackHistoryItem, "timestamp">): Promise<void> {
 		if (!this.config.playbackHistory) return
 
 		try {
@@ -260,18 +266,20 @@ export class MediaPersistenceManager {
 			}
 
 			// Remove existing entry for the same media
-			const filteredHistory = history.filter(h => h.mediaId !== item.mediaId)
-			
+			const filteredHistory = history.filter((h) => h.mediaId !== item.mediaId)
+
 			// Add new item at the beginning
-			const updatedHistory = [newItem, ...filteredHistory]
-				.slice(0, this.config.maxHistoryItems)
+			const updatedHistory = [newItem, ...filteredHistory].slice(0, this.config.maxHistoryItems)
 
-			await this.storage.setItem(STORAGE_KEYS.PLAYBACK_HISTORY, JSON.stringify({
-				history: updatedHistory,
-				timestamp: Date.now()
-			}))
+			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)
+			console.warn("Failed to add to playback history:", error)
 		}
 	}
 
@@ -279,7 +287,7 @@ export class MediaPersistenceManager {
 		try {
 			await this.storage.removeItem(STORAGE_KEYS.PLAYBACK_HISTORY)
 		} catch (error) {
-			console.warn('Failed to clear playback history:', error)
+			console.warn("Failed to clear playback history:", error)
 		}
 	}
 
@@ -287,7 +295,7 @@ export class MediaPersistenceManager {
 	async savePlaybackPosition(mediaId: string, position: number): Promise<void> {
 		const session = await this.getSessionState()
 		const playbackPosition = session?.playbackPosition || {}
-		
+
 		await this.saveSessionState({
 			playbackPosition: {
 				...playbackPosition,
@@ -354,14 +362,14 @@ export class MediaPersistenceManager {
 // Hook for using persistence in components
 export function useMediaPersistence(config?: Partial<PersistenceConfig>) {
 	const [manager] = React.useState(() => new MediaPersistenceManager(config))
-	
+
 	React.useEffect(() => {
 		return () => {
 			// Clear any pending debounced operations
 			manager.clearAll()
 		}
 	}, [manager])
-	
+
 	return manager
 }
 
@@ -373,20 +381,20 @@ export function useAutoMediaPersistence(
 ) {
 	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: Partial<MediaState> = {
 					...(preferences && {
@@ -395,51 +403,52 @@ export function useAutoMediaPersistence(
 						playbackRate: preferences.playbackRate,
 						subtitlesShowing: preferences.subtitlesShowing
 					}),
-					...(session && mediaId === session.mediaId && {
-						currentTime: session.currentTime
-					})
+					...(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)
+					console.log("Rehydrated state:", rehydratedState)
 				}
-				
+
 				setIsRehydrated(true)
 			} catch (error) {
-				console.warn('Failed to rehydrate state:', 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
@@ -450,4 +459,4 @@ export function useAutoMediaPersistence(
 export const defaultStorageAdapter = new LocalStorageAdapter()
 
 // Import React for hooks
-import React from "react"
+import React from "react"