@therealtinhtute/baroiplayer 1.0.3 → 1.0.5

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

@@ -57,7 +57,13 @@ export const useIntelligentPreloading = (
 		lastInteraction: Date.now(),
 	});
 
-	const networkInfoRef = useRef<NetworkInformation | null>(null);
+	// Network Information API (if available)
+	const networkInfoRef = useRef<{
+		effectiveType?: string;
+		downlink?: number;
+		rtt?: number;
+		saveData?: boolean;
+	} | null>(null);
 	const preloadedItemsRef = useRef<Set<string>>(new Set());
 	const preloadQueueRef = useRef<Array<{ source: MediaSource; priority: number }>>([]);
 
@@ -89,7 +95,7 @@ export const useIntelligentPreloading = (
 
 		const network = networkInfoRef.current;
 		return {
-			type: network.type,
+			type: network.effectiveType || '4g', // Use effectiveType as the primary type indicator
 			downlink: network.downlink || 10,
 			effectiveType: network.effectiveType || '4g',
 			saveData: network.saveData || false,
@@ -156,8 +162,9 @@ export const useIntelligentPreloading = (
 
 		// Additional heuristics
 		if (shouldPreload) {
-			// Prioritize HLS and adaptive streaming
-			if (source.type === 'hls' || source.type === 'm3u8') {
+			// Prioritize HLS and adaptive streaming (check URL extension)
+			const sourceUrl = source.src.toLowerCase();
+			if (sourceUrl.includes('.m3u8') || sourceUrl.includes('hls')) {
 				priority = priority === 'low' ? 'medium' : 'high';
 			}
 
@@ -168,7 +175,8 @@ export const useIntelligentPreloading = (
 			}
 
 			// Consider content type (video gets higher priority than audio)
-			if (source.type === 'mp4' || source.type === 'webm') {
+			if (source.type?.includes('mp4') || source.type?.includes('webm') ||
+				sourceUrl.includes('.mp4') || sourceUrl.includes('.webm')) {
 				priority = priority === 'low' ? 'medium' : priority;
 			}
 		}
@@ -184,23 +192,20 @@ export const useIntelligentPreloading = (
 			link.rel = 'preload';
 			link.href = source.src;
 
-			// Determine the correct 'as' attribute
-			switch (source.type) {
-				case 'hls':
-				case 'm3u8':
-					link.as = 'fetch';
-					break;
-				case 'mp4':
-				case 'webm':
-					link.as = 'video';
-					break;
-				case 'mp3':
-				case 'wav':
-				case 'ogg':
-					link.as = 'audio';
-					break;
-				default:
-					link.as = 'fetch';
+			// Determine the correct 'as' attribute based on URL or MIME type
+			const sourceUrl = source.src.toLowerCase();
+			const mimeType = source.type?.toLowerCase() || '';
+
+			if (sourceUrl.includes('.m3u8') || sourceUrl.includes('hls')) {
+				link.as = 'fetch';
+			} else if (mimeType.includes('mp4') || mimeType.includes('webm') ||
+				sourceUrl.includes('.mp4') || sourceUrl.includes('.webm')) {
+				link.as = 'video';
+			} else if (mimeType.includes('mp3') || mimeType.includes('wav') || mimeType.includes('ogg') ||
+				sourceUrl.includes('.mp3') || sourceUrl.includes('.wav') || sourceUrl.includes('.ogg')) {
+				link.as = 'audio';
+			} else {
+				link.as = 'fetch';
 			}
 
 			link.crossOrigin = 'anonymous';

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

@@ -295,8 +295,6 @@ export function useMediaPlayer(options: UseMediaPlayerOptions) {
 		toggle,
 		seek,
 		setVolume: setVolumeControl,
-		mute,
-		unmute,
 		toggleMute,
 		enterFullscreen,
 		exitFullscreen,

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

@@ -16,10 +16,10 @@ export function useMemoryOptimization(options: {
 		monitorMemory = true
 	} = options
 
-	const cleanupTimeoutRef = useRef<NodeJS.Timeout>()
+	const cleanupTimeoutRef = useRef<NodeJS.Timeout | 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()) // Use proper timer type
 	const animationFrameRefs = useRef<Set<number>>(new Set())
 
 	// Get current memory usage
@@ -67,20 +67,20 @@ export function useMemoryOptimization(options: {
 		}
 
 		checkMemory()
-		const interval = setInterval(checkMemory, cleanupInterval)
-		intervalRefs.current.add(interval)
+		const intervalId: ReturnType<typeof setInterval> = setInterval(checkMemory, cleanupInterval)
+		intervalRefs.current.add(intervalId)
 
 		return () => {
-			clearInterval(interval)
-			intervalRefs.current.delete(interval)
+			clearInterval(intervalId as any)
+			intervalRefs.current.delete(intervalId)
 		}
 	}, [monitorMemory, getMemoryUsage, maxMemoryUsage, enableGC, cleanupInterval])
 
 	// Cleanup function
 	const performCleanup = useCallback(() => {
-		// Clear all timeouts
-		intervalRefs.current.forEach(timeout => {
-			clearTimeout(timeout)
+		// Clear all intervals
+		intervalRefs.current.forEach(intervalId => {
+			clearInterval(intervalId as any)
 		})
 		intervalRefs.current.clear()
 
@@ -141,29 +141,29 @@ export function useMemoryOptimization(options: {
 	}, [])
 
 	// Safe interval management
-	const setInterval = useCallback((callback: () => void, delay: number) => {
+	const safeSetInterval = useCallback((callback: () => void, delay: number) => {
 		const timeoutId = setInterval(callback, delay)
 		intervalRefs.current.add(timeoutId)
 
 		return () => {
-			clearInterval(timeoutId)
+			clearInterval(timeoutId as any)
 			intervalRefs.current.delete(timeoutId)
 		}
 	}, [])
 
 	// Safe timeout management
-	const setTimeout = useCallback((callback: () => void, delay: number) => {
+	const safeSetTimeout = useCallback((callback: () => void, delay: number) => {
 		const timeoutId = setTimeout(callback, delay)
 		intervalRefs.current.add(timeoutId)
 
 		return () => {
-			clearTimeout(timeoutId)
+			clearTimeout(timeoutId as any)
 			intervalRefs.current.delete(timeoutId)
 		}
 	}, [])
 
 	// Safe animation frame management
-	const requestAnimationFrame = useCallback((callback: FrameRequestCallback) => {
+	const safeRequestAnimationFrame = useCallback((callback: FrameRequestCallback) => {
 		const frameId = requestAnimationFrame(callback)
 		animationFrameRefs.current.add(frameId)
 
@@ -200,9 +200,9 @@ export function useMemoryOptimization(options: {
 
 		// Safe API functions
 		addEventListener,
-		setInterval,
-		setTimeout,
-		requestAnimationFrame,
+		setInterval: safeSetInterval,
+		setTimeout: safeSetTimeout,
+		requestAnimationFrame: safeRequestAnimationFrame,
 		addObserver,
 
 		// Utilities
@@ -227,7 +227,7 @@ export function useMediaResourceCleanup(mediaRef: React.RefObject<HTMLVideoEleme
 
 		// Stop media playback
 		if (!media.paused) {
-		_media.pause()
+			media.pause()
 		}
 
 		// Clear source
@@ -284,7 +284,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/dist/src/hooks/use-mobile.ts

@@ -0,0 +1,125 @@
+import { useState, useEffect } from 'react';
+
+interface DeviceInfo {
+  isMobile: boolean;
+  isTablet: boolean;
+  isDesktop: boolean;
+  userAgent: string;
+  screenWidth: number;
+  screenHeight: number;
+}
+
+export function useDeviceInfo(): DeviceInfo {
+  const [deviceInfo, setDeviceInfo] = useState<DeviceInfo>(() => {
+    if (typeof window === 'undefined') {
+      return {
+        isMobile: false,
+        isTablet: false,
+        isDesktop: true,
+        userAgent: '',
+        screenWidth: 1920,
+        screenHeight: 1080
+      };
+    }
+
+    const userAgent = navigator.userAgent;
+    const screenWidth = window.innerWidth;
+    const screenHeight = window.innerHeight;
+
+    const isMobile = /Android|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(userAgent) && screenWidth < 768;
+    const isTablet = /iPad|Android/i.test(userAgent) && screenWidth >= 768 && screenWidth < 1024;
+    const isDesktop = !isMobile && !isTablet;
+
+    return {
+      isMobile,
+      isTablet,
+      isDesktop,
+      userAgent,
+      screenWidth,
+      screenHeight
+    };
+  });
+
+  useEffect(() => {
+    if (typeof window === 'undefined') return;
+
+    const handleResize = () => {
+      const userAgent = navigator.userAgent;
+      const screenWidth = window.innerWidth;
+      const screenHeight = window.innerHeight;
+
+      const isMobile = /Android|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(userAgent) && screenWidth < 768;
+      const isTablet = /iPad|Android/i.test(userAgent) && screenWidth >= 768 && screenWidth < 1024;
+      const isDesktop = !isMobile && !isTablet;
+
+      setDeviceInfo({
+        isMobile,
+        isTablet,
+        isDesktop,
+        userAgent,
+        screenWidth,
+        screenHeight
+      });
+    };
+
+    window.addEventListener('resize', handleResize);
+    return () => window.removeEventListener('resize', handleResize);
+  }, []);
+
+  return deviceInfo;
+}
+
+export function useContainerQuery(): boolean {
+  const [isSmall, setIsSmall] = useState(false);
+
+  useEffect(() => {
+    if (typeof window === 'undefined') return;
+
+    const checkSize = () => {
+      setIsSmall(window.innerWidth < 640);
+    };
+
+    checkSize();
+    window.addEventListener('resize', checkSize);
+    return () => window.removeEventListener('resize', checkSize);
+  }, []);
+
+  return isSmall;
+}
+
+export function useMobileOptimizations() {
+  const deviceInfo = useDeviceInfo();
+  const [isTouch, setIsTouch] = useState(false);
+
+  useEffect(() => {
+    setIsTouch('ontouchstart' in window || navigator.maxTouchPoints > 0);
+  }, []);
+
+  return {
+    ...deviceInfo,
+    isTouch,
+    preferReducedMotion: window.matchMedia('(prefers-reduced-motion: reduce)').matches,
+    prefersDarkScheme: window.matchMedia('(prefers-color-scheme: dark)').matches
+  };
+}
+
+export function useHapticFeedback() {
+  const deviceInfo = useDeviceInfo();
+
+  const triggerHaptic = (type: 'light' | 'medium' | 'heavy' = 'light') => {
+    if (!deviceInfo.isMobile || !('vibrate' in navigator)) return;
+
+    const patterns = {
+      light: [10],
+      medium: [20],
+      heavy: [50]
+    };
+
+    navigator.vibrate(patterns[type]);
+  };
+
+  return {
+    triggerHaptic,
+    supported: deviceInfo.isMobile && 'vibrate' in navigator
+  };
+}

package/dist/src/hooks/use-touch-gestures.js

@@ -1,6 +1,6 @@
 "use client";
 import * as React from "react";
-import { useDeviceInfo, useHapticFeedback } from "@rp/ui/hooks/use-mobile";
+import { useDeviceInfo, useHapticFeedback } from "./use-mobile";
 // Default configuration
 const defaultConfig = {
     enabledGestures: ['tap', 'double-tap', 'long-press', 'swipe-left', 'swipe-right', 'swipe-up', 'swipe-down', 'pinch-in', 'pinch-out'],

package/dist/src/index-legacy.ts

@@ -133,10 +133,11 @@ export { useEnhancedMediaPlayer } from "./hooks/use-enhanced-media-player"
 // Performance Monitoring
 export {
 	PerformanceMonitor,
-	PerformanceMetrics,
 	usePerformanceMonitor as usePerformanceMonitoring
 } from "./core/performance"
 
+export type { PerformanceMetrics } from "./core/performance"
+
 // Media Resource Preloader
 export { MediaResourcePreloader } from "./components/ui/media-resource-preloader"