@therealtinhtute/baroiplayer 1.0.6 → 1.0.7

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

@@ -1,251 +0,0 @@
-"use client";
-import { useEffect, useRef } from "react";
-import { useMediaState } from "./use-media-state";
-export function useMediaPlayer(options) {
-    const mediaRef = useRef(null);
-    const containerRef = useRef(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) => {
-        const media = mediaRef.current;
-        if (!media)
-            return;
-        media.currentTime = Math.max(0, Math.min(time, media.duration || 0));
-    };
-    const setVolumeControl = (volume) => {
-        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 = {
-        play,
-        pause,
-        toggle,
-        seek,
-        setVolume: setVolumeControl,
-        mute,
-        unmute,
-        toggleMute,
-        enterFullscreen,
-        exitFullscreen,
-        toggleFullscreen
-    };
-    return {
-        state,
-        controls,
-        mediaRef,
-        containerRef
-    };
-}

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

@@ -1 +0,0 @@
-{"version":3,"file":"use-media-state.d.ts","sourceRoot":"","sources":["use-media-state.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAOtD,wBAAgB,aAAa;;2BAaE,OAAO,CAAC,gBAAgB,CAAC;4BAIxB,OAAO;kCAID,MAAM;4BAIZ,MAAM;wBAIV,MAAM;wBAIN,OAAO;4BAIH,OAAO;kCAID,OAAO;sBAInB,MAAM,GAAG,IAAI;4BAIP,UAAU,GAAG,IAAI;EAiBhD;AAGD,wBAAgB,qBAAqB,QAkGpC;AAGD,wBAAgB,qBAAqB,QASpC"}

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

@@ -1,162 +0,0 @@
-"use client";
-import { useState } from "react";
-import { useMediaStore } from "../context/media-context";
-import { useMediaOptimistic } from "./use-media-optimistic";
-import { useMediaActions } from "./use-media-actions";
-// Legacy hook for backward compatibility
-export function useMediaState() {
-    const [state, setState] = useState({
-        isPlaying: false,
-        currentTime: 0,
-        duration: 0,
-        volume: 1,
-        isMuted: false,
-        isLoading: false,
-        isFullscreen: false,
-        error: null,
-        buffered: null
-    });
-    const updateState = (updates) => {
-        setState((prev) => ({ ...prev, ...updates }));
-    };
-    const setPlaying = (isPlaying) => {
-        updateState({ isPlaying });
-    };
-    const setCurrentTime = (currentTime) => {
-        updateState({ currentTime });
-    };
-    const setDuration = (duration) => {
-        updateState({ duration });
-    };
-    const setVolume = (volume) => {
-        updateState({ volume: Math.max(0, Math.min(1, volume)) });
-    };
-    const setMuted = (isMuted) => {
-        updateState({ isMuted });
-    };
-    const setLoading = (isLoading) => {
-        updateState({ isLoading });
-    };
-    const setFullscreen = (isFullscreen) => {
-        updateState({ isFullscreen });
-    };
-    const setError = (error) => {
-        updateState({ error });
-    };
-    const setBuffered = (buffered) => {
-        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();
-    }
-    // Cast to enhanced store type
-    const enhancedStore = store;
-    // 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) => {
-            // 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) => {
-            isPlaying ? actions.play(true) : actions.pause(true); // Use optimistic updates
-        },
-        setCurrentTime: (time) => actions.setCurrentTime(time),
-        setDuration: (duration) => actions.setDuration(duration),
-        setVolume: (volume) => actions.setVolume(volume, true),
-        setMuted: (muted) => {
-            muted ? actions.mute(true) : actions.unmute(true);
-        },
-        setLoading: (loading) => actions.setLoading(loading),
-        setFullscreen: (fullscreen) => {
-            fullscreen ? actions.enterFullscreen(true) : actions.exitFullscreen(true);
-        },
-        setError: (error) => actions.setError(error),
-        setBuffered: (buffered) => 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.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-memory-optimization.d.ts","sourceRoot":"","sources":["use-memory-optimization.ts"],"names":[],"mappings":"AAEA,OAAO,KAAkD,MAAM,OAAO,CAAA;AAGtE,wBAAgB,qBAAqB,CAAC,OAAO,GAAE;IAC9C,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,aAAa,CAAC,EAAE,OAAO,CAAA;CAClB;;;;;;;;;;;;;;gCAwGK,OAAO,SACT,MAAM,WACJ,aAAa,YACZ,uBAAuB;4BA0BS,MAAM,IAAI,SAAS,MAAM;2BAW1B,MAAM,IAAI,SAAS,MAAM;sCAWd,oBAAoB;4BAW9B,gBAAgB;yBAgCrC,MAAM;EAQ5B;AAGD,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC,gBAAgB,GAAG,gBAAgB,CAAC;;wCAmC7F,MAAM,WACJ,aAAa,YACZ,uBAAuB;EAiBlC;AAGD,wBAAgB,wBAAwB;;;;;;;EAiFvC"}

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

@@ -1,288 +0,0 @@
-"use client";
-import React, { useEffect, useRef, useCallback } from "react";
-// Memory optimization hook for media players
-export function useMemoryOptimization(options = {}) {
-    const { maxMemoryUsage = 100, // 100MB default
-    cleanupInterval = 30000, // 30 seconds default
-    enableGC = true, monitorMemory = true } = options;
-    const cleanupTimeoutRef = useRef();
-    const observersRef = useRef(new Set());
-    const eventListenersRef = useRef(new Map());
-    const intervalRefs = useRef(new Set());
-    const animationFrameRefs = useRef(new Set());
-    // Get current memory usage
-    const getMemoryUsage = useCallback(() => {
-        if (typeof window === 'undefined' || !('memory' in performance)) {
-            return { used: 0, total: 0, limit: 0 };
-        }
-        const memory = performance.memory;
-        return {
-            used: memory.usedJSHeapSize,
-            total: memory.totalJSHeapSize,
-            limit: memory.jsHeapSizeLimit
-        };
-    }, []);
-    // Memory monitoring state
-    const [memoryStats, setMemoryStats] = React.useState({
-        used: 0,
-        total: 0,
-        limit: 0,
-        usage: 0,
-        isHighUsage: false
-    });
-    // Memory monitoring
-    useEffect(() => {
-        if (!monitorMemory)
-            return;
-        const checkMemory = () => {
-            const memory = getMemoryUsage();
-            const usage = (memory.used / 1024 / 1024); // Convert to MB
-            const isHighUsage = usage > maxMemoryUsage;
-            setMemoryStats({
-                ...memory,
-                usage,
-                isHighUsage
-            });
-            // Trigger cleanup if memory usage is high
-            if (isHighUsage && enableGC) {
-                performCleanup();
-            }
-        };
-        checkMemory();
-        const interval = setInterval(checkMemory, cleanupInterval);
-        intervalRefs.current.add(interval);
-        return () => {
-            clearInterval(interval);
-            intervalRefs.current.delete(interval);
-        };
-    }, [monitorMemory, getMemoryUsage, maxMemoryUsage, enableGC, cleanupInterval]);
-    // Cleanup function
-    const performCleanup = useCallback(() => {
-        // Clear all timeouts
-        intervalRefs.current.forEach(timeout => {
-            clearTimeout(timeout);
-        });
-        intervalRefs.current.clear();
-        // Cancel all animation frames
-        animationFrameRefs.current.forEach(frameId => {
-            cancelAnimationFrame(frameId);
-        });
-        animationFrameRefs.current.clear();
-        // Disconnect all observers
-        observersRef.current.forEach(observer => {
-            observer.disconnect();
-        });
-        observersRef.current.clear();
-        // Remove all event listeners
-        eventListenersRef.current.forEach((listeners, element) => {
-            listeners.forEach(({ event, handler }) => {
-                element.removeEventListener(event, handler);
-            });
-        });
-        eventListenersRef.current.clear();
-        // Trigger garbage collection if available
-        if (enableGC && 'gc' in window) {
-            window.gc();
-        }
-    }, [enableGC]);
-    // Safe event listener management
-    const addEventListener = useCallback((element, event, handler, options) => {
-        element.addEventListener(event, handler, options);
-        if (!eventListenersRef.current.has(element)) {
-            eventListenersRef.current.set(element, []);
-        }
-        eventListenersRef.current.get(element).push({ event, handler });
-        // Return cleanup function
-        return () => {
-            element.removeEventListener(event, handler);
-            const listeners = eventListenersRef.current.get(element);
-            if (listeners) {
-                const index = listeners.findIndex(l => l.event === event && l.handler === handler);
-                if (index > -1) {
-                    listeners.splice(index, 1);
-                }
-                if (listeners.length === 0) {
-                    eventListenersRef.current.delete(element);
-                }
-            }
-        };
-    }, []);
-    // Safe interval management
-    const setInterval = useCallback((callback, delay) => {
-        const timeoutId = setInterval(callback, delay);
-        intervalRefs.current.add(timeoutId);
-        return () => {
-            clearInterval(timeoutId);
-            intervalRefs.current.delete(timeoutId);
-        };
-    }, []);
-    // Safe timeout management
-    const setTimeout = useCallback((callback, delay) => {
-        const timeoutId = setTimeout(callback, delay);
-        intervalRefs.current.add(timeoutId);
-        return () => {
-            clearTimeout(timeoutId);
-            intervalRefs.current.delete(timeoutId);
-        };
-    }, []);
-    // Safe animation frame management
-    const requestAnimationFrame = useCallback((callback) => {
-        const frameId = requestAnimationFrame(callback);
-        animationFrameRefs.current.add(frameId);
-        return () => {
-            cancelAnimationFrame(frameId);
-            animationFrameRefs.current.delete(frameId);
-        };
-    }, []);
-    // Safe observer management
-    const addObserver = useCallback((observer) => {
-        observersRef.current.add(observer);
-        return () => {
-            observer.disconnect();
-            observersRef.current.delete(observer);
-        };
-    }, []);
-    // Cleanup on unmount
-    useEffect(() => {
-        return () => {
-            performCleanup();
-        };
-    }, [performCleanup]);
-    return {
-        // Memory stats
-        memoryStats,
-        getMemoryUsage,
-        // Cleanup functions
-        performCleanup,
-        // Safe API functions
-        addEventListener,
-        setInterval,
-        setTimeout,
-        requestAnimationFrame,
-        addObserver,
-        // Utilities
-        formatBytes: (bytes) => {
-            if (bytes === 0)
-                return '0 Bytes';
-            const k = 1024;
-            const sizes = ['Bytes', 'KB', 'MB', 'GB'];
-            const i = Math.floor(Math.log(bytes) / Math.log(k));
-            return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
-        }
-    };
-}
-// Resource cleanup hook for media elements
-export function useMediaResourceCleanup(mediaRef) {
-    const { addEventListener, performCleanup } = useMemoryOptimization();
-    // Track resource cleanup
-    const cleanupResources = useCallback(() => {
-        const media = mediaRef.current;
-        if (!media)
-            return;
-        // Stop media playback
-        if (!media.paused) {
-            _media.pause();
-        }
-        // Clear source
-        if (media.src) {
-            media.src = '';
-            media.load();
-        }
-        // Remove source elements
-        while (media.firstChild) {
-            media.removeChild(media.firstChild);
-        }
-        // Clear any pending seeks
-        media.currentTime = 0;
-        // Clear buffered data
-        if ('clearBuffered' in media) {
-            media.clearBuffered();
-        }
-    }, [mediaRef]);
-    // Enhanced event listener registration
-    const registerMediaEventListener = useCallback((event, handler, options) => {
-        const media = mediaRef.current;
-        if (!media)
-            return () => { };
-        return addEventListener(media, event, handler, options);
-    }, [mediaRef, addEventListener]);
-    // Cleanup on unmount
-    useEffect(() => {
-        return cleanupResources;
-    }, [cleanupResources]);
-    return {
-        cleanupResources,
-        registerMediaEventListener
-    };
-}
-// Performance monitoring hook
-export function usePerformanceMonitoring() {
-    const [metrics, setMetrics] = React.useState({
-        fps: 0,
-        frameDrops: 0,
-        longTasks: 0,
-        totalLongTaskDuration: 0
-    });
-    const frameCountRef = useRef(0);
-    const lastFrameTimeRef = useRef(performance.now());
-    const longTaskObserverRef = useRef();
-    // FPS monitoring
-    useEffect(() => {
-        let rafId;
-        const measureFrame = () => {
-            frameCountRef.current++;
-            const now = performance.now();
-            // Calculate FPS every second
-            if (now - lastFrameTimeRef.current >= 1000) {
-                const fps = Math.round((frameCountRef.current * 1000) / (now - lastFrameTimeRef.current));
-                const expectedFrames = Math.round((now - lastFrameTimeRef.current) / 16.67); // 60fps
-                const frameDrops = Math.max(0, expectedFrames - frameCountRef.current);
-                setMetrics(prev => ({
-                    ...prev,
-                    fps,
-                    frameDrops: prev.frameDrops + frameDrops
-                }));
-                frameCountRef.current = 0;
-                lastFrameTimeRef.current = now;
-            }
-            rafId = requestAnimationFrame(measureFrame);
-        };
-        rafId = requestAnimationFrame(measureFrame);
-        return () => {
-            cancelAnimationFrame(rafId);
-        };
-    }, []);
-    // Long task monitoring
-    useEffect(() => {
-        if (!('PerformanceObserver' in window))
-            return;
-        try {
-            const observer = new PerformanceObserver((list) => {
-                for (const entry of list.getEntries()) {
-                    if (entry.duration > 50) { // Long task threshold
-                        setMetrics(prev => ({
-                            ...prev,
-                            longTasks: prev.longTasks + 1,
-                            totalLongTaskDuration: prev.totalLongTaskDuration + entry.duration
-                        }));
-                    }
-                }
-            });
-            observer.observe({ entryTypes: ['longtask'] });
-            longTaskObserverRef.current = observer;
-            return () => {
-                observer.disconnect();
-            };
-        }
-        catch (error) {
-            console.warn('Long task monitoring not supported:', error);
-        }
-    }, []);
-    return {
-        ...metrics,
-        averageLongTaskDuration: metrics.longTasks > 0
-            ? metrics.totalLongTaskDuration / metrics.longTasks
-            : 0,
-        isPerformanceGood: metrics.fps >= 50 && metrics.frameDrops < 5
-    };
-}