@therealtinhtute/baroiplayer 1.0.8 → 1.2.0

package/dist/src/hooks/use-media-player.ts

@@ -1,310 +0,0 @@
-"use client"
-
-import { useCallback, useEffect, useRef } from "react"
-import type { MediaPlayerControls } from "../types/index"
-import { useMediaState } from "./use-media-state"
-
-interface UseMediaPlayerOptions {
-	src: string | string[]
-	autoPlay?: boolean
-	loop?: boolean
-	muted?: boolean
-	volume?: number
-	preload?: "none" | "metadata" | "auto"
-	crossOrigin?: "anonymous" | "use-credentials"
-	playbackRates?: number[]
-	keyboardControls?: boolean
-	showControls?: boolean
-	customControls?: boolean
-	onPlay?: () => void
-	onPause?: () => void
-	onTimeUpdate?: (currentTime: number) => void
-	onDurationChange?: (duration: number) => void
-	onVolumeChange?: (volume: number) => void
-	onError?: (error: string) => void
-	onLoadStart?: () => void
-	onLoadedData?: () => void
-	onEnded?: () => void
-}
-
-export function useMediaPlayer(options: UseMediaPlayerOptions) {
-	const mediaRef = useRef<HTMLVideoElement | HTMLAudioElement>(null)
-	const containerRef = useRef<HTMLDivElement>(null)
-
-	const {
-		state,
-		setPlaying,
-		setCurrentTime,
-		setDuration,
-		setVolume,
-		setMuted,
-		setLoading,
-		setFullscreen,
-		setError,
-		setBuffered
-	} = useMediaState()
-
-	// Initialize media element with options
-	useEffect(() => {
-		const media = mediaRef.current
-		if (!media) return
-
-		// Set initial properties
-		if (options.volume !== undefined) {
-			media.volume = options.volume
-			setVolume(options.volume)
-		}
-		if (options.muted !== undefined) {
-			media.muted = options.muted
-			setMuted(options.muted)
-		}
-		if (options.autoPlay !== undefined) {
-			media.autoplay = options.autoPlay
-		}
-		if (options.loop !== undefined) {
-			media.loop = options.loop
-		}
-		if (options.preload !== undefined) {
-			media.preload = options.preload
-		}
-		if (options.crossOrigin !== undefined) {
-			media.crossOrigin = options.crossOrigin
-		}
-	}, [options, setVolume, setMuted])
-
-	// Event handlers
-	const handlePlay = () => {
-    		setPlaying(true)
-    		options.onPlay?.()
-    	}
-
-	const handlePause = () => {
-    		setPlaying(false)
-    		options.onPause?.()
-    	}
-
-	const handleTimeUpdate = () => {
-    		const media = mediaRef.current
-    		if (!media) return
-
-    		setCurrentTime(media.currentTime)
-    		options.onTimeUpdate?.(media.currentTime)
-    	}
-
-	const handleDurationChange = () => {
-    		const media = mediaRef.current
-    		if (!media) return
-
-    		setDuration(media.duration)
-    		options.onDurationChange?.(media.duration)
-    	}
-
-	const handleVolumeChange = () => {
-    		const media = mediaRef.current
-    		if (!media) return
-
-    		setVolume(media.volume)
-    		setMuted(media.muted)
-    		options.onVolumeChange?.(media.volume)
-    	}
-
-	const handleLoadStart = () => {
-    		setLoading(true)
-    		setError(null)
-    		options.onLoadStart?.()
-    	}
-
-	const handleLoadedData = () => {
-    		setLoading(false)
-    		options.onLoadedData?.()
-    	}
-
-	const handleError = () => {
-    		const media = mediaRef.current
-    		if (!media) return
-
-    		const errorMessage = media.error?.message || "An error occurred while loading the media"
-    		setError(errorMessage)
-    		setLoading(false)
-    		options.onError?.(errorMessage)
-    	}
-
-	const handleEnded = () => {
-    		setPlaying(false)
-    		options.onEnded?.()
-    	}
-
-	const handleProgress = () => {
-    		const media = mediaRef.current
-    		if (!media) return
-
-    		setBuffered(media.buffered)
-    	}
-
-	// Attach event listeners
-	useEffect(() => {
-		const media = mediaRef.current
-		if (!media) return
-
-		media.addEventListener("play", handlePlay)
-		media.addEventListener("pause", handlePause)
-		media.addEventListener("timeupdate", handleTimeUpdate)
-		media.addEventListener("durationchange", handleDurationChange)
-		media.addEventListener("volumechange", handleVolumeChange)
-		media.addEventListener("loadstart", handleLoadStart)
-		media.addEventListener("loadeddata", handleLoadedData)
-		media.addEventListener("error", handleError)
-		media.addEventListener("ended", handleEnded)
-		media.addEventListener("progress", handleProgress)
-
-		return () => {
-			media.removeEventListener("play", handlePlay)
-			media.removeEventListener("pause", handlePause)
-			media.removeEventListener("timeupdate", handleTimeUpdate)
-			media.removeEventListener("durationchange", handleDurationChange)
-			media.removeEventListener("volumechange", handleVolumeChange)
-			media.removeEventListener("loadstart", handleLoadStart)
-			media.removeEventListener("loadeddata", handleLoadedData)
-			media.removeEventListener("error", handleError)
-			media.removeEventListener("ended", handleEnded)
-			media.removeEventListener("progress", handleProgress)
-		}
-	}, [
-		handlePlay,
-		handlePause,
-		handleTimeUpdate,
-		handleDurationChange,
-		handleVolumeChange,
-		handleLoadStart,
-		handleLoadedData,
-		handleError,
-		handleEnded,
-		handleProgress
-	])
-
-	// Control functions
-	const play = async () => {
-    		const media = mediaRef.current
-    		if (!media) return
-
-    		try {
-    			await media.play()
-    		} catch (error) {
-    			console.error("Failed to play media:", error)
-    			setError("Failed to play media")
-    		}
-    	}
-
-	const pause = () => {
-    		const media = mediaRef.current
-    		if (!media) return
-
-    		media.pause()
-    	}
-
-	const toggle = () => {
-    		if (state.isPlaying) {
-    			pause()
-    		} else {
-    			play()
-    		}
-    	}
-
-	const seek = (time: number) => {
-    		const media = mediaRef.current
-    		if (!media) return
-
-    		media.currentTime = Math.max(0, Math.min(time, media.duration || 0))
-    	}
-
-	const setVolumeControl = (volume: number) => {
-    		const media = mediaRef.current
-    		if (!media) return
-
-    		const clampedVolume = Math.max(0, Math.min(1, volume))
-    		media.volume = clampedVolume
-    	}
-
-	const mute = () => {
-    		const media = mediaRef.current
-    		if (!media) return
-
-    		media.muted = true
-    	}
-
-	const unmute = () => {
-    		const media = mediaRef.current
-    		if (!media) return
-
-    		media.muted = false
-    	}
-
-	const toggleMute = () => {
-    		const media = mediaRef.current
-    		if (!media) return
-
-    		media.muted = !media.muted
-    	}
-
-	const enterFullscreen = async () => {
-    		const container = containerRef.current
-    		if (!container || !document.fullscreenEnabled) return
-
-    		try {
-    			await container.requestFullscreen()
-    			setFullscreen(true)
-    		} catch (error) {
-    			console.error("Failed to enter fullscreen:", error)
-    		}
-    	}
-
-	const exitFullscreen = async () => {
-    		if (!document.fullscreenElement) return
-
-    		try {
-    			await document.exitFullscreen()
-    			setFullscreen(false)
-    		} catch (error) {
-    			console.error("Failed to exit fullscreen:", error)
-    		}
-    	}
-
-	const toggleFullscreen = () => {
-    		if (document.fullscreenElement) {
-    			exitFullscreen()
-    		} else {
-    			enterFullscreen()
-    		}
-    	}
-
-	// Listen for fullscreen changes
-	useEffect(() => {
-		const handleFullscreenChange = () => {
-			setFullscreen(!!document.fullscreenElement)
-		}
-
-		document.addEventListener("fullscreenchange", handleFullscreenChange)
-		return () => {
-			document.removeEventListener("fullscreenchange", handleFullscreenChange)
-		}
-	}, [setFullscreen])
-
-	const controls: MediaPlayerControls = {
-		play,
-		pause,
-		toggle,
-		seek,
-		setVolume: setVolumeControl,
-		toggleMute,
-		enterFullscreen,
-		exitFullscreen,
-		toggleFullscreen
-	}
-
-	return {
-		state,
-		controls,
-		mediaRef,
-		containerRef
-	}
-}

package/dist/src/hooks/use-media-state.d.ts

@@ -1,17 +0,0 @@
-import type { MediaPlayerState } from "../types/index";
-export declare function useMediaState(): {
-    state: MediaPlayerState;
-    updateState: (updates: Partial<MediaPlayerState>) => void;
-    setPlaying: (isPlaying: boolean) => void;
-    setCurrentTime: (currentTime: number) => void;
-    setDuration: (duration: number) => void;
-    setVolume: (volume: number) => void;
-    setMuted: (isMuted: boolean) => void;
-    setLoading: (isLoading: boolean) => void;
-    setFullscreen: (isFullscreen: boolean) => void;
-    setError: (error: string | null) => void;
-    setBuffered: (buffered: TimeRanges | null) => void;
-};
-export declare function useEnhancedMediaState(): any;
-export declare function useAdaptiveMediaState(): any;
-//# sourceMappingURL=use-media-state.d.ts.map

package/dist/src/hooks/use-media-state.ts

@@ -1,190 +0,0 @@
-"use client"
-
-import { useCallback, useState, useActionState, useOptimistic } from "react"
-import type { MediaPlayerState } from "../types/index"
-import { useMediaStore, useMediaSelector } from "../context/media-context"
-import { useMediaOptimistic } from "./use-media-optimistic"
-import { useMediaActions } from "./use-media-actions"
-import type { EnhancedMediaStore } from "../context/media-store"
-
-// Legacy hook for backward compatibility
-export function useMediaState() {
-	const [state, setState] = useState<MediaPlayerState>({
-		isPlaying: false,
-		currentTime: 0,
-		duration: 0,
-		volume: 1,
-		isMuted: false,
-		isLoading: false,
-		isFullscreen: false,
-		error: null,
-		buffered: null
-	})
-
-	const updateState = (updates: Partial<MediaPlayerState>) => {
-    		setState((prev: MediaPlayerState) => ({ ...prev, ...updates }))
-    	}
-
-	const setPlaying = (isPlaying: boolean) => {
-    			updateState({ isPlaying })
-    		}
-
-	const setCurrentTime = (currentTime: number) => {
-    			updateState({ currentTime })
-    		}
-
-	const setDuration = (duration: number) => {
-    			updateState({ duration })
-    		}
-
-	const setVolume = (volume: number) => {
-    			updateState({ volume: Math.max(0, Math.min(1, volume)) })
-    		}
-
-	const setMuted = (isMuted: boolean) => {
-    			updateState({ isMuted })
-    		}
-
-	const setLoading = (isLoading: boolean) => {
-    			updateState({ isLoading })
-    		}
-
-	const setFullscreen = (isFullscreen: boolean) => {
-    			updateState({ isFullscreen })
-    		}
-
-	const setError = (error: string | null) => {
-    			updateState({ error })
-    		}
-
-	const setBuffered = (buffered: TimeRanges | null) => {
-    			updateState({ buffered })
-    		}
-
-	return {
-		state,
-		updateState,
-		setPlaying,
-		setCurrentTime,
-		setDuration,
-		setVolume,
-		setMuted,
-		setLoading,
-		setFullscreen,
-		setError,
-		setBuffered
-	}
-}
-
-// React 19 enhanced media state hook
-export function useEnhancedMediaState() {
-	const store = useMediaStore()
-	
-	// Check if this is an enhanced store
-	const isEnhanced = 'getOptimisticState' in store
-	
-	if (!isEnhanced) {
-		// Fall back to regular media state if not enhanced
-		return useMediaState() as any
-	}
-	
-	// Cast to enhanced store type
-	const enhancedStore = store as unknown as EnhancedMediaStore
-	
-	// Use React 19 optimistic updates
-	const optimisticState = useMediaOptimistic(enhancedStore)
-	
-	// Get action handlers with React 19 features
-	const actions = useMediaActions(enhancedStore)
-	
-	return {
-		// State (optimistic values for immediate UI feedback)
-		state: optimisticState.state,
-		actualState: optimisticState.actualState,
-		
-		// Individual state selectors
-		isPlaying: optimisticState.isPlaying,
-		currentTime: optimisticState.currentTime,
-		duration: optimisticState.state.duration,
-		volume: optimisticState.volume,
-		isMuted: optimisticState.isMuted,
-		isLoading: optimisticState.isBuffering,
-		isFullscreen: optimisticState.isFullscreen,
-		error: optimisticState.state.error,
-		buffered: optimisticState.state.buffered,
-		
-		// Computed values
-		progress: optimisticState.progress,
-		formattedTime: optimisticState.formattedTime,
-		formattedDuration: optimisticState.formattedDuration,
-		
-		// Actions with optimistic updates
-		actions,
-		
-		// Action state for loading/error handling
-		isActionLoading: actions.isLoading,
-		actionError: actions.errorMessage,
-		retryLastAction: actions.retryLastAction,
-		
-		// Legacy compatibility methods
-		updateState: (updates: Partial<MediaPlayerState>) => {
-			// Map legacy updates to new actions
-			if ('isPlaying' in updates) {
-				updates.isPlaying ? actions.play() : actions.pause()
-			}
-			if ('currentTime' in updates) {
-				actions.setCurrentTime(updates.currentTime!)
-			}
-			if ('duration' in updates) {
-				actions.setDuration(updates.duration!)
-			}
-			if ('volume' in updates) {
-				actions.setVolume(updates.volume!)
-			}
-			if ('isMuted' in updates) {
-				updates.isMuted ? actions.mute() : actions.unmute()
-			}
-			if ('isLoading' in updates) {
-				actions.setLoading(updates.isLoading!)
-			}
-			if ('isFullscreen' in updates) {
-				updates.isFullscreen ? actions.enterFullscreen() : actions.exitFullscreen()
-			}
-			if ('error' in updates) {
-				actions.setError(updates.error ?? null)
-			}
-			if ('buffered' in updates) {
-				actions.setBuffered(updates.buffered ?? null)
-			}
-		},
-		
-		// Individual action methods for legacy compatibility
-		setPlaying: (isPlaying: boolean) => {
-			isPlaying ? actions.play(true) : actions.pause(true) // Use optimistic updates
-		},
-		setCurrentTime: (time: number) => actions.setCurrentTime(time),
-		setDuration: (duration: number) => actions.setDuration(duration),
-		setVolume: (volume: number) => actions.setVolume(volume, true),
-		setMuted: (muted: boolean) => {
-			muted ? actions.mute(true) : actions.unmute(true)
-		},
-		setLoading: (loading: boolean) => actions.setLoading(loading),
-		setFullscreen: (fullscreen: boolean) => {
-			fullscreen ? actions.enterFullscreen(true) : actions.exitFullscreen(true)
-		},
-		setError: (error: string | null) => actions.setError(error),
-		setBuffered: (buffered: TimeRanges | null) => actions.setBuffered(buffered)
-	}
-}
-
-// Hook that automatically chooses between legacy and enhanced based on context availability
-export function useAdaptiveMediaState() {
-	try {
-		// Try to use the enhanced version if MediaStore context is available
-		return useEnhancedMediaState()
-	} catch (error) {
-		// Fall back to legacy version if not in MediaProvider context
-		console.warn('MediaStore context not available, using legacy state management')
-		return useMediaState()
-	}
-}

package/dist/src/hooks/use-memory-optimization.d.ts

@@ -1,40 +0,0 @@
-import React from "react";
-export declare function useMemoryOptimization(options?: {
-    maxMemoryUsage?: number;
-    cleanupInterval?: number;
-    enableGC?: boolean;
-    monitorMemory?: boolean;
-}): {
-    memoryStats: {
-        used: number;
-        total: number;
-        limit: number;
-        usage: number;
-        isHighUsage: boolean;
-    };
-    getMemoryUsage: () => {
-        used: any;
-        total: any;
-        limit: any;
-    };
-    performCleanup: () => void;
-    addEventListener: (element: Element, event: string, handler: EventListener, options?: AddEventListenerOptions) => () => void;
-    setInterval: (callback: () => void, delay: number) => () => void;
-    setTimeout: (callback: () => void, delay: number) => () => void;
-    requestAnimationFrame: (callback: FrameRequestCallback) => () => void;
-    addObserver: (observer: MutationObserver) => () => void;
-    formatBytes: (bytes: number) => string;
-};
-export declare function useMediaResourceCleanup(mediaRef: React.RefObject<HTMLVideoElement | HTMLAudioElement>): {
-    cleanupResources: () => void;
-    registerMediaEventListener: (event: string, handler: EventListener, options?: AddEventListenerOptions) => () => void;
-};
-export declare function usePerformanceMonitoring(): {
-    averageLongTaskDuration: number;
-    isPerformanceGood: boolean;
-    fps: number;
-    frameDrops: number;
-    longTasks: number;
-    totalLongTaskDuration: number;
-};
-//# sourceMappingURL=use-memory-optimization.d.ts.map