@therealtinhtute/baroiplayer 1.0.0

package/src/context/persistence.ts

@@ -0,0 +1,453 @@
+"use client"
+
+import type { MediaState } from "./media-context"
+
+// 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"
+} as const
+
+// User preferences that should be persisted long-term
+export interface UserPreferences {
+	volume: number
+	isMuted: boolean
+	playbackRate: number
+	subtitlesShowing: boolean
+	selectedSubtitleTrack: string | null
+	preferredRendition: string | null
+	autoplay: boolean
+	keyboardShortcuts: boolean
+}
+
+// Session state that should be persisted for the session
+export interface SessionState {
+	currentTime: number
+	mediaId?: string
+	src?: string
+	playbackPosition: Record<string, number> // mediaId -> position
+}
+
+// Playback history item
+export interface PlaybackHistoryItem {
+	mediaId: string
+	src: string
+	title?: string
+	currentTime: number
+	duration: number
+	timestamp: number
+	completed: boolean
+}
+
+// Persistence configuration
+export interface PersistenceConfig {
+	// Storage options
+	userPreferences: boolean
+	sessionState: boolean
+	playbackHistory: boolean
+	
+	// Limits
+	maxHistoryItems: number
+	maxCacheAge: number // milliseconds
+	
+	// Debouncing
+	debounceMs: number
+	
+	// Custom storage adapter
+	storage?: StorageAdapter
+}
+
+// Storage adapter interface for custom storage implementations
+export interface StorageAdapter {
+	getItem(key: string): Promise<string | null>
+	setItem(key: string, value: string): Promise<void>
+	removeItem(key: string): Promise<void>
+	clear(): Promise<void>
+}
+
+// Default localStorage adapter
+class LocalStorageAdapter implements StorageAdapter {
+	async getItem(key: string): Promise<string | null> {
+		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: string, value: string): Promise<void> {
+		if (typeof window === 'undefined') return
+		try {
+			localStorage.setItem(key, value)
+		} catch (error) {
+			console.warn('Failed to write to localStorage:', error)
+		}
+	}
+
+	async removeItem(key: string): Promise<void> {
+		if (typeof window === 'undefined') return
+		try {
+			localStorage.removeItem(key)
+		} catch (error) {
+			console.warn('Failed to remove from localStorage:', error)
+		}
+	}
+
+	async clear(): Promise<void> {
+		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: PersistenceConfig = {
+	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 {
+	private config: PersistenceConfig
+	private storage: StorageAdapter
+	private debounceTimeouts: Map<string, NodeJS.Timeout> = new Map()
+
+	constructor(config: Partial<PersistenceConfig> = {}) {
+		this.config = { ...DEFAULT_CONFIG, ...config }
+		this.storage = this.config.storage!
+	}
+
+	// User preferences methods
+	async getUserPreferences(): Promise<UserPreferences | null> {
+		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) as { preferences: UserPreferences; timestamp: number }
+			
+			// 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: Partial<UserPreferences>): Promise<void> {
+		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(): Promise<void> {
+		try {
+			await this.storage.removeItem(STORAGE_KEYS.USER_PREFERENCES)
+		} catch (error) {
+			console.warn('Failed to clear user preferences:', error)
+		}
+	}
+
+	// Session state methods
+	async getSessionState(): Promise<SessionState | null> {
+		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) as { state: SessionState; timestamp: number }
+			return parsed.state
+		} catch (error) {
+			console.warn('Failed to get session state:', error)
+			return null
+		}
+	}
+
+	async saveSessionState(state: Partial<SessionState>): Promise<void> {
+		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(): Promise<void> {
+		try {
+			await this.storage.removeItem(STORAGE_KEYS.SESSION_STATE)
+		} catch (error) {
+			console.warn('Failed to clear session state:', error)
+		}
+	}
+
+	// Playback history methods
+	async getPlaybackHistory(): Promise<PlaybackHistoryItem[]> {
+		if (!this.config.playbackHistory) return []
+
+		try {
+			const data = await this.storage.getItem(STORAGE_KEYS.PLAYBACK_HISTORY)
+			if (!data) return []
+
+			const parsed = JSON.parse(data) as { history: PlaybackHistoryItem[]; timestamp: number }
+			
+			// 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: Omit<PlaybackHistoryItem, 'timestamp'>): Promise<void> {
+		if (!this.config.playbackHistory) return
+
+		try {
+			const history = await this.getPlaybackHistory()
+			const newItem: PlaybackHistoryItem = {
+				...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(): Promise<void> {
+		try {
+			await this.storage.removeItem(STORAGE_KEYS.PLAYBACK_HISTORY)
+		} catch (error) {
+			console.warn('Failed to clear playback history:', error)
+		}
+	}
+
+	// Utility methods
+	async savePlaybackPosition(mediaId: string, position: number): Promise<void> {
+		const session = await this.getSessionState()
+		const playbackPosition = session?.playbackPosition || {}
+		
+		await this.saveSessionState({
+			playbackPosition: {
+				...playbackPosition,
+				[mediaId]: position
+			}
+		})
+	}
+
+	async getPlaybackPosition(mediaId: string): Promise<number> {
+		const session = await this.getSessionState()
+		return session?.playbackPosition?.[mediaId] || 0
+	}
+
+	// Extract preferences from MediaState
+	extractUserPreferences(state: MediaState): UserPreferences {
+		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: MediaState, mediaId?: string): SessionState {
+		return {
+			currentTime: state.currentTime,
+			mediaId,
+			playbackPosition: {}
+		}
+	}
+
+	// Clear all persisted data
+	async clearAll(): Promise<void> {
+		await this.storage.clear()
+		this.debounceTimeouts.clear()
+	}
+
+	// Private helper methods
+	private isCacheExpired(timestamp?: number): boolean {
+		if (!timestamp) return true
+		return Date.now() - timestamp > this.config.maxCacheAge
+	}
+
+	private debounce(key: string, fn: () => Promise<void>): void {
+		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?: Partial<PersistenceConfig>) {
+	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: MediaState,
+	mediaId?: string,
+	config?: Partial<PersistenceConfig>
+) {
+	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 && {
+						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"