@therealtinhtute/baroiplayer 1.2.0 → 2.0.0-beta.1

package/src/context/persistence.ts

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