@therealtinhtute/baroiplayer 1.0.7 → 1.1.0

package/dist/src/context/persistence.ts

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

package/dist/src/core/events/event-system.d.ts

@@ -1,170 +0,0 @@
-export interface MediaPlayerEvent {
-    type: string;
-    timestamp: number;
-    target?: string;
-    detail?: any;
-    bubbles?: boolean;
-    cancelable?: boolean;
-    defaultPrevented?: boolean;
-}
-export type EventHandler<T = any> = (event: MediaPlayerEvent & {
-    detail: T;
-}) => void;
-export type EventUnsubscriber = () => void;
-export interface EventOptions {
-    once?: boolean;
-    passive?: boolean;
-    priority?: 'high' | 'normal' | 'low';
-    filter?: (event: MediaPlayerEvent) => boolean;
-}
-export type EventCategory = 'media' | 'user' | 'system' | 'plugin' | 'error' | 'performance';
-export interface MediaEvents {
-    'media:loadstart': {
-        src: string;
-    };
-    'media:loadeddata': {
-        duration: number;
-    };
-    'media:canplay': {};
-    'media:canplaythrough': {};
-    'media:play': {
-        currentTime: number;
-    };
-    'media:pause': {
-        currentTime: number;
-    };
-    'media:ended': {
-        duration: number;
-    };
-    'media:seeking': {
-        currentTime: number;
-        targetTime: number;
-    };
-    'media:seeked': {
-        currentTime: number;
-        previousTime: number;
-    };
-    'media:timeupdate': {
-        currentTime: number;
-        duration: number;
-    };
-    'media:durationchange': {
-        duration: number;
-    };
-    'media:volumechange': {
-        volume: number;
-        muted: boolean;
-    };
-    'media:ratechange': {
-        playbackRate: number;
-    };
-    'media:loadedmetadata': {
-        src: string;
-    };
-    'media:progress': {
-        buffered: TimeRanges;
-    };
-    'media:suspend': {};
-    'media:abort': {};
-    'media:error': {
-        error: Error;
-    };
-    'media:stalled': {};
-    'media:waiting': {};
-    'user:click': {
-        x: number;
-        y: number;
-        element: string;
-    };
-    'user:hover': {
-        element: string;
-    };
-    'user:focus': {
-        element: string;
-    };
-    'user:keyboard': {
-        key: string;
-        code: string;
-        altKey: boolean;
-        ctrlKey: boolean;
-        shiftKey: boolean;
-    };
-    'user:gesture': {
-        type: string;
-        data: any;
-    };
-    'system:ready': {};
-    'system:resize': {
-        width: number;
-        height: number;
-    };
-    'system:fullscreen': {
-        isFullscreen: boolean;
-    };
-    'system:pip': {
-        isPictureInPicture: boolean;
-    };
-    'system:visibility': {
-        isVisible: boolean;
-    };
-    'plugin:loaded': {
-        name: string;
-    };
-    'plugin:enabled': {
-        name: string;
-    };
-    'plugin:disabled': {
-        name: string;
-    };
-    'plugin:error': {
-        name: string;
-        error: Error;
-    };
-    'performance:fps': {
-        fps: number;
-    };
-    'performance:memory': {
-        used: number;
-        total: number;
-    };
-    'performance:load': {
-        loadTime: number;
-    };
-}
-export declare class EventBus {
-    private listeners;
-    private eventQueue;
-    private isProcessing;
-    private middlewares;
-    private eventHistory;
-    private maxHistorySize;
-    on<K extends keyof MediaEvents>(type: K, handler: EventHandler<MediaEvents[K]>, options?: EventOptions): EventUnsubscriber;
-    once<K extends keyof MediaEvents>(type: K, handler: EventHandler<MediaEvents[K]>, options?: EventOptions): EventUnsubscriber;
-    addEventListener(type: string, handler: EventHandler, options?: EventOptions): EventUnsubscriber;
-    removeEventListener(type: string, handler?: EventHandler): void;
-    emit<K extends keyof MediaEvents>(type: K, detail?: MediaEvents[K], options?: Partial<MediaPlayerEvent>): boolean;
-    dispatchEvent(event: MediaPlayerEvent): boolean;
-    private processEventQueue;
-    private processEvent;
-    use(middleware: (event: MediaPlayerEvent) => MediaPlayerEvent | null): () => void;
-    private addToHistory;
-    getHistory(filter?: (event: MediaPlayerEvent) => boolean): MediaPlayerEvent[];
-    clearHistory(): void;
-    private matchPattern;
-    private generateId;
-    getListenerCount(type?: string): number;
-    getEventTypes(): string[];
-    removeAllListeners(type?: string): void;
-    destroy(): void;
-}
-export declare const defaultEventBus: EventBus;
-export declare class EventDelegator {
-    private eventBus;
-    private element;
-    private delegatedEvents;
-    constructor(eventBus: EventBus, element: HTMLElement);
-    delegate(domEvent: string, mediaEvent?: string): void;
-    setupCommonDelegations(): void;
-    destroy(): void;
-}
-//# sourceMappingURL=event-system.d.ts.map