@therealtinhtute/baroiplayer 1.1.0 → 1.2.0

package/src/hooks/core/index.ts

@@ -44,4 +44,4 @@ export type { VideoState, VideoControls } from "../useVideoPlayer"
 
 // Specialized hooks
 export { useMediaMetadata } from "../use-media-metadata"
-export { useOptimisticControls } from "../use-optimistic-controls"
+export { useOptimisticMediaState } from "../use-optimistic-controls"

package/src/hooks/use-buffer-health.ts

@@ -120,7 +120,7 @@ export function useBufferHealth(
 		}
 
 		if ("audioTracks" in video) {
-			const tracks = (video as HTMLVideoElement).audioTracks
+			const tracks = (video as any).audioTracks
 			if (tracks && tracks.length > 0) {
 				audioLevel = tracks[0]?.volume || null
 			}

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

@@ -34,6 +34,32 @@ interface UseEnhancedMediaPlayerOptions {
 	timeUpdateThrottleMs?: number
 	enableSeekPreview?: boolean
 	preloadStrategy?: "eager" | "lazy" | "progressive"
+	// Event handlers
+	onPlay?: () => void
+	onPause?: () => void
+}
+
+/**
+ * Safely sets currentTime on a media element, ensuring the value is finite
+ */
+function safeSetCurrentTime(media: HTMLVideoElement | HTMLAudioElement, time: number): boolean {
+	if (!Number.isFinite(time)) {
+		console.warn(`Attempted to set non-finite currentTime: ${time}`)
+		return false
+	}
+
+	if (time < 0) {
+		console.warn(`Attempted to set negative currentTime: ${time}`)
+		return false
+	}
+
+	try {
+		media.currentTime = time
+		return true
+	} catch (error) {
+		console.error(`Failed to set currentTime to ${time}:`, error)
+		return false
+	}
 }
 
 // Performance-optimized media player hook with React 19 features
@@ -51,7 +77,7 @@ export function useEnhancedMediaPlayer(options: UseEnhancedMediaPlayerOptions) {
 	const lastFrameTime = React.useRef<number>(0)
 
 	// Throttled time update
-	const timeUpdateTimeoutRef = useRef<NodeJS.Timeout>()
+	const timeUpdateTimeoutRef = useRef<ReturnType<typeof setTimeout> | undefined>(undefined)
 	const lastTimeUpdate = useRef<number>(0)
 
 	// Store integration
@@ -331,14 +357,25 @@ export function useEnhancedMediaPlayer(options: UseEnhancedMediaPlayerOptions) {
 			const media = mediaRef.current
 			if (!media) return
 
-			const clampedTime = Math.max(0, Math.min(time, duration || 0))
+			const validDuration = Number.isFinite(duration) && duration > 0 ? duration : Number.isFinite(media.duration) ? media.duration : 0
+			if (validDuration === 0) {
+				console.warn("Cannot seek: duration is not available")
+				return
+			}
+
+			const clampedTime = Math.max(0, Math.min(time, validDuration))
+
+			if (!Number.isFinite(clampedTime)) {
+				console.warn(`Computed non-finite seek time: ${clampedTime}`)
+				return
+			}
 
 			if (isEnhanced && actions) {
 				startSeekTransition(() => {
 					actions.seek(clampedTime, true) // Optimistic
 				})
 			} else {
-				media.currentTime = clampedTime
+				safeSetCurrentTime(media, clampedTime)
 			}
 		}
 
@@ -396,18 +433,79 @@ export function useEnhancedMediaPlayer(options: UseEnhancedMediaPlayerOptions) {
 			}
 		}
 
+		const mute = () => {
+			const media = mediaRef.current
+			if (!media) return
+
+			if (isEnhanced && actions) {
+				actions.mute(true)
+			} else {
+				media.muted = true
+			}
+		}
+
+		const unmute = () => {
+			const media = mediaRef.current
+			if (!media) return
+
+			if (isEnhanced && actions) {
+				actions.unmute(true)
+			} else {
+				media.muted = false
+			}
+		}
+
+		const toggleFullscreen = async () => {
+			if (isFullscreen) {
+				await exitFullscreen()
+			} else {
+				await enterFullscreen()
+			}
+		}
+
+		const setCurrentTime = (time: number) => {
+			const media = mediaRef.current
+			if (!media) return
+
+			const validDuration =
+				Number.isFinite(duration) && duration > 0
+					? duration
+					: Number.isFinite(media.duration)
+						? media.duration
+						: 0
+
+			if (validDuration === 0) {
+				console.warn("Cannot set currentTime: duration is not available")
+				return
+			}
+
+			const clampedTime = Math.max(0, Math.min(time, validDuration))
+
+			if (!Number.isFinite(clampedTime)) {
+				console.warn(`Computed non-finite currentTime: ${clampedTime}`)
+				return
+			}
+
+			safeSetCurrentTime(media, clampedTime)
+		}
+
 		return {
 			play,
 			pause,
 			toggle,
 			seek,
+			setCurrentTime,
 			setVolume,
+			mute,
+			unmute,
 			toggleMute,
 			enterFullscreen,
-			exitFullscreen
+			exitFullscreen,
+			toggleFullscreen
 		}
 	}, [
 		isPlaying,
+		isFullscreen,
 		duration,
 		isEnhanced,
 		actions,
@@ -421,13 +519,13 @@ export function useEnhancedMediaPlayer(options: UseEnhancedMediaPlayerOptions) {
 		() => ({
 			isPlaying: optimisticState?.isPlaying ?? isPlaying,
 			currentTime: optimisticState?.currentTime ?? currentTime,
-			duration: optimisticState?.duration ?? duration,
+			duration: optimisticState?.actualState?.duration ?? duration,
 			volume: optimisticState?.volume ?? optimisticVolume,
 			isMuted: optimisticState?.isMuted ?? isMuted,
 			isLoading: optimisticState?.isBuffering ?? isLoading,
 			isBuffering: optimisticState?.isBuffering ?? isBuffering,
-			error: optimisticState?.error ?? error,
-			buffered: optimisticState?.buffered ?? buffered,
+			error: optimisticState?.actualState?.error ?? error,
+			buffered: optimisticState?.actualState?.buffered ?? buffered,
 			isFullscreen: optimisticState?.isFullscreen ?? isFullscreen,
 			progress: duration > 0 ? currentTime / duration : 0,
 			isTransitioning: isPending || isSeeking,
@@ -467,8 +565,8 @@ export function useEnhancedMediaPlayer(options: UseEnhancedMediaPlayerOptions) {
 		isTransitioning: isPending || isSeeking,
 
 		// Enhanced features
-		actions: optimisticState?.actions,
-		actionState: optimisticState?.actionState,
+		actions: optimisticState,
+		actionState: optimisticState,
 
 		// Optimistic features
 		optimisticState,

package/src/hooks/use-focus-trap.tsx

@@ -98,14 +98,14 @@ export function useFocusTrap(
 		const focusableElements = getFocusableElements()
 		const firstElement = focusableElements[0]
 		firstElement?.focus()
-		lastFocusedElementRef.current = firstElement
+		lastFocusedElementRef.current = firstElement || null
 	}, [getFocusableElements])
 
 	const focusLastElement = useCallback(() => {
 		const focusableElements = getFocusableElements()
 		const lastElement = focusableElements[focusableElements.length - 1]
 		lastElement?.focus()
-		lastFocusedElementRef.current = lastElement
+		lastFocusedElementRef.current = lastElement || null
 	}, [getFocusableElements])
 
 	return {

package/src/hooks/use-intelligent-preloading.ts

@@ -6,6 +6,16 @@
 import { useCallback, useEffect, useMemo, useRef } from "react"
 import { MediaSource } from "../types"
 
+interface NetworkInformation {
+	type?: string
+	downlink?: number
+	effectiveType?: "slow-2g" | "2g" | "3g" | "4g"
+	saveData?: boolean
+	rtt?: number
+	addEventListener?: (type: string, listener: EventListener) => void
+	removeEventListener?: (type: string, listener: EventListener) => void
+}
+
 interface IntelligentPreloadingOptions {
 	/** Enable user behavior tracking */
 	trackUserBehavior?: boolean
@@ -158,8 +168,10 @@ export const useIntelligentPreloading = (
 
 			// Additional heuristics
 			if (shouldPreload) {
+				const sourceType = source.type as string
+
 				// Prioritize HLS and adaptive streaming
-				if (source.type === "hls" || source.type === "m3u8") {
+				if (sourceType === "hls" || sourceType === "m3u8" || sourceType === "application/x-mpegURL") {
 					priority = priority === "low" ? "medium" : "high"
 				}
 
@@ -171,7 +183,7 @@ export const useIntelligentPreloading = (
 				}
 
 				// Consider content type (video gets higher priority than audio)
-				if (source.type === "mp4" || source.type === "webm") {
+				if (sourceType === "mp4" || sourceType === "webm" || sourceType === "video/mp4" || sourceType === "video/webm") {
 					priority = priority === "low" ? "medium" : priority
 				}
 			}
@@ -189,19 +201,27 @@ export const useIntelligentPreloading = (
 			link.rel = "preload"
 			link.href = source.src
 
+			const sourceType = source.type as string
+
 			// Determine the correct 'as' attribute
-			switch (source.type) {
+			switch (sourceType) {
 				case "hls":
 				case "m3u8":
+				case "application/x-mpegURL":
 					link.as = "fetch"
 					break
 				case "mp4":
 				case "webm":
+				case "video/mp4":
+				case "video/webm":
 					link.as = "video"
 					break
 				case "mp3":
 				case "wav":
 				case "ogg":
+				case "audio/mpeg":
+				case "audio/wav":
+				case "audio/ogg":
 					link.as = "audio"
 					break
 				default:

package/src/hooks/use-keyboard-shortcuts.ts

@@ -63,10 +63,10 @@ export function useKeyboardShortcuts(
 	useEffect(() => {
 		const target = opts.capture ? window.document.body : window
 
-		target.addEventListener("keydown", handleKeyDown)
+		target.addEventListener("keydown", handleKeyDown as EventListener)
 
 		return () => {
-			target.removeEventListener("keydown", handleKeyDown)
+			target.removeEventListener("keydown", handleKeyDown as EventListener)
 		}
 	}, [handleKeyDown, opts.capture])
 

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

@@ -27,6 +27,29 @@ interface UseMediaPlayerOptions {
 	onEnded?: () => void
 }
 
+/**
+ * Safely sets currentTime on a media element, ensuring the value is finite
+ */
+function safeSetCurrentTime(media: HTMLVideoElement | HTMLAudioElement, time: number): boolean {
+	if (!Number.isFinite(time)) {
+		console.warn(`Attempted to set non-finite currentTime: ${time}`)
+		return false
+	}
+
+	if (time < 0) {
+		console.warn(`Attempted to set negative currentTime: ${time}`)
+		return false
+	}
+
+	try {
+		media.currentTime = time
+		return true
+	} catch (error) {
+		console.error(`Failed to set currentTime to ${time}:`, error)
+		return false
+	}
+}
+
 export function useMediaPlayer(options: UseMediaPlayerOptions) {
 	const mediaRef = useRef<HTMLVideoElement | HTMLAudioElement>(null)
 	const containerRef = useRef<HTMLDivElement>(null)
@@ -73,53 +96,53 @@ export function useMediaPlayer(options: UseMediaPlayerOptions) {
 	}, [options, setVolume, setMuted])
 
 	// Event handlers
-	const handlePlay = () => {
+	const handlePlay = useCallback(() => {
 		setPlaying(true)
 		options.onPlay?.()
-	}
+	}, [setPlaying, options])
 
-	const handlePause = () => {
+	const handlePause = useCallback(() => {
 		setPlaying(false)
 		options.onPause?.()
-	}
+	}, [setPlaying, options])
 
-	const handleTimeUpdate = () => {
+	const handleTimeUpdate = useCallback(() => {
 		const media = mediaRef.current
 		if (!media) return
 
 		setCurrentTime(media.currentTime)
 		options.onTimeUpdate?.(media.currentTime)
-	}
+	}, [setCurrentTime, options])
 
-	const handleDurationChange = () => {
+	const handleDurationChange = useCallback(() => {
 		const media = mediaRef.current
 		if (!media) return
 
 		setDuration(media.duration)
 		options.onDurationChange?.(media.duration)
-	}
+	}, [setDuration, options])
 
-	const handleVolumeChange = () => {
+	const handleVolumeChange = useCallback(() => {
 		const media = mediaRef.current
 		if (!media) return
 
 		setVolume(media.volume)
 		setMuted(media.muted)
 		options.onVolumeChange?.(media.volume)
-	}
+	}, [setVolume, setMuted, options])
 
-	const handleLoadStart = () => {
+	const handleLoadStart = useCallback(() => {
 		setLoading(true)
 		setError(null)
 		options.onLoadStart?.()
-	}
+	}, [setLoading, setError, options])
 
-	const handleLoadedData = () => {
+	const handleLoadedData = useCallback(() => {
 		setLoading(false)
 		options.onLoadedData?.()
-	}
+	}, [setLoading, options])
 
-	const handleError = () => {
+	const handleError = useCallback(() => {
 		const media = mediaRef.current
 		if (!media) return
 
@@ -127,19 +150,19 @@ export function useMediaPlayer(options: UseMediaPlayerOptions) {
 		setError(errorMessage)
 		setLoading(false)
 		options.onError?.(errorMessage)
-	}
+	}, [setError, setLoading, options])
 
-	const handleEnded = () => {
+	const handleEnded = useCallback(() => {
 		setPlaying(false)
 		options.onEnded?.()
-	}
+	}, [setPlaying, options])
 
-	const handleProgress = () => {
+	const handleProgress = useCallback(() => {
 		const media = mediaRef.current
 		if (!media) return
 
 		setBuffered(media.buffered)
-	}
+	}, [setBuffered])
 
 	// Attach event listeners
 	useEffect(() => {
@@ -183,7 +206,7 @@ export function useMediaPlayer(options: UseMediaPlayerOptions) {
 	])
 
 	// Control functions
-	const play = async () => {
+	const play = useCallback(async () => {
 		const media = mediaRef.current
 		if (!media) return
 
@@ -193,60 +216,67 @@ export function useMediaPlayer(options: UseMediaPlayerOptions) {
 			console.error("Failed to play media:", error)
 			setError("Failed to play media")
 		}
-	}
+	}, [setError])
 
-	const pause = () => {
+	const pause = useCallback(() => {
 		const media = mediaRef.current
 		if (!media) return
 
 		media.pause()
-	}
+	}, [])
 
-	const toggle = () => {
+	const toggle = useCallback(() => {
 		if (state.isPlaying) {
 			pause()
 		} else {
 			play()
 		}
-	}
+	}, [state.isPlaying, pause, play])
 
-	const seek = (time: number) => {
+	const seek = useCallback((time: number) => {
 		const media = mediaRef.current
 		if (!media) return
 
-		media.currentTime = Math.max(0, Math.min(time, media.duration || 0))
-	}
+		const duration = Number.isFinite(media.duration) ? media.duration : 0
+		if (duration === 0) {
+			console.warn("Cannot seek: duration is not available")
+			return
+		}
 
-	const setVolumeControl = (volume: number) => {
+		const clampedTime = Math.max(0, Math.min(time, duration))
+		safeSetCurrentTime(media, clampedTime)
+	}, [])
+
+	const setVolumeControl = useCallback((volume: number) => {
 		const media = mediaRef.current
 		if (!media) return
 
 		const clampedVolume = Math.max(0, Math.min(1, volume))
 		media.volume = clampedVolume
-	}
+	}, [])
 
-	const mute = () => {
+	const mute = useCallback(() => {
 		const media = mediaRef.current
 		if (!media) return
 
 		media.muted = true
-	}
+	}, [])
 
-	const unmute = () => {
+	const unmute = useCallback(() => {
 		const media = mediaRef.current
 		if (!media) return
 
 		media.muted = false
-	}
+	}, [])
 
-	const toggleMute = () => {
+	const toggleMute = useCallback(() => {
 		const media = mediaRef.current
 		if (!media) return
 
 		media.muted = !media.muted
-	}
+	}, [])
 
-	const enterFullscreen = async () => {
+	const enterFullscreen = useCallback(async () => {
 		const container = containerRef.current
 		if (!container || !document.fullscreenEnabled) return
 
@@ -256,9 +286,9 @@ export function useMediaPlayer(options: UseMediaPlayerOptions) {
 		} catch (error) {
 			console.error("Failed to enter fullscreen:", error)
 		}
-	}
+	}, [setFullscreen])
 
-	const exitFullscreen = async () => {
+	const exitFullscreen = useCallback(async () => {
 		if (!document.fullscreenElement) return
 
 		try {
@@ -267,15 +297,15 @@ export function useMediaPlayer(options: UseMediaPlayerOptions) {
 		} catch (error) {
 			console.error("Failed to exit fullscreen:", error)
 		}
-	}
+	}, [setFullscreen])
 
-	const toggleFullscreen = () => {
+	const toggleFullscreen = useCallback(() => {
 		if (document.fullscreenElement) {
 			exitFullscreen()
 		} else {
 			enterFullscreen()
 		}
-	}
+	}, [exitFullscreen, enterFullscreen])
 
 	// Listen for fullscreen changes
 	useEffect(() => {
@@ -294,6 +324,7 @@ export function useMediaPlayer(options: UseMediaPlayerOptions) {
 		pause,
 		toggle,
 		seek,
+		setCurrentTime: seek,
 		setVolume: setVolumeControl,
 		mute,
 		unmute,

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

@@ -18,12 +18,12 @@ export function useMemoryOptimization(
 		monitorMemory = true
 	} = options
 
-	const cleanupTimeoutRef = useRef<NodeJS.Timeout>()
+	const cleanupTimeoutRef = useRef<ReturnType<typeof setTimeout> | undefined>(undefined)
 	const observersRef = useRef<Set<MutationObserver>>(new Set())
 	const eventListenersRef = useRef<Map<Element, Array<{ event: string; handler: EventListener }>>>(
 		new Map()
 	)
-	const intervalRefs = useRef<Set<NodeJS.Timeout>>(new Set())
+	const intervalRefs = useRef<Set<ReturnType<typeof setInterval>>>(new Set())
 	const animationFrameRefs = useRef<Set<number>>(new Set())
 
 	// Get current memory usage
@@ -85,11 +85,11 @@ export function useMemoryOptimization(
 
 	// Safe interval management (must be declared before use)
 	const useInterval = useCallback((callback: () => void, delay: number) => {
-		const timeoutId = setInterval(callback, delay)
+		const timeoutId = globalThis.setInterval(callback, delay)
 		intervalRefs.current.add(timeoutId)
 
 		return () => {
-			clearInterval(timeoutId)
+			globalThis.clearInterval(timeoutId)
 			intervalRefs.current.delete(timeoutId)
 		}
 	}, [])
@@ -153,23 +153,23 @@ export function useMemoryOptimization(
 	)
 
 	// Safe timeout management
-	const setTimeout = useCallback((callback: () => void, delay: number) => {
-		const timeoutId = setTimeout(callback, delay)
+	const useSafeTimeout = useCallback((callback: () => void, delay: number) => {
+		const timeoutId = globalThis.setTimeout(callback, delay)
 		intervalRefs.current.add(timeoutId)
 
 		return () => {
-			clearTimeout(timeoutId)
+			globalThis.clearTimeout(timeoutId)
 			intervalRefs.current.delete(timeoutId)
 		}
 	}, [])
 
 	// Safe animation frame management
-	const requestAnimationFrame = useCallback((callback: FrameRequestCallback) => {
-		const frameId = requestAnimationFrame(callback)
+	const useSafeAnimationFrame = useCallback((callback: FrameRequestCallback) => {
+		const frameId = globalThis.requestAnimationFrame(callback)
 		animationFrameRefs.current.add(frameId)
 
 		return () => {
-			cancelAnimationFrame(frameId)
+			globalThis.cancelAnimationFrame(frameId)
 			animationFrameRefs.current.delete(frameId)
 		}
 	}, [])
@@ -201,9 +201,9 @@ export function useMemoryOptimization(
 
 		// Safe API functions
 		addEventListener,
-		setInterval,
-		setTimeout,
-		requestAnimationFrame,
+		setInterval: useInterval,
+		setTimeout: useSafeTimeout,
+		requestAnimationFrame: useSafeAnimationFrame,
 		addObserver,
 
 		// Utilities
@@ -230,7 +230,7 @@ export function useMediaResourceCleanup(
 
 		// Stop media playback
 		if (!media.paused) {
-			_media.pause()
+			media.pause()
 		}
 
 		// Clear source
@@ -286,7 +286,7 @@ export function usePerformanceMonitoring() {
 
 	const frameCountRef = useRef(0)
 	const lastFrameTimeRef = useRef(performance.now())
-	const longTaskObserverRef = useRef<PerformanceObserver>()
+	const longTaskObserverRef = useRef<PerformanceObserver | undefined>(undefined)
 
 	// FPS monitoring
 	useEffect(() => {

package/src/hooks/use-smart-preload.ts

@@ -56,8 +56,7 @@ export function useSmartPreload(options: UseSmartPreloadOptions = {}): UseSmartP
 			const preloadPromise = (async () => {
 				try {
 					const response = await fetch(src, {
-						method: "HEAD",
-						cache: "preload"
+						method: "HEAD"
 					})
 
 					if (!response.ok) {