@therealtinhtute/baroiplayer 1.0.6 → 1.0.8

package/dist/src/hooks/use-keyboard-controls.js

@@ -1,83 +0,0 @@
-"use client";
-import { useEffect } from "react";
-export function useKeyboardControls({ enabled = true, state, controls, seekStep = 10, volumeStep = 0.1 }) {
-    const handleKeyDown = (event) => {
-        if (!enabled)
-            return;
-        // Don't handle keyboard events if user is typing in an input
-        const target = event.target;
-        if (target.tagName === "INPUT" ||
-            target.tagName === "TEXTAREA" ||
-            target.contentEditable === "true") {
-            return;
-        }
-        switch (event.code) {
-            case "Space":
-            case "KeyK":
-                event.preventDefault();
-                controls.toggle();
-                break;
-            case "KeyM":
-                event.preventDefault();
-                controls.toggleMute();
-                break;
-            case "KeyF":
-                event.preventDefault();
-                controls.toggleFullscreen();
-                break;
-            case "ArrowLeft":
-                event.preventDefault();
-                controls.seek(Math.max(0, state.currentTime - seekStep));
-                break;
-            case "ArrowRight":
-                event.preventDefault();
-                controls.seek(Math.min(state.duration, state.currentTime + seekStep));
-                break;
-            case "ArrowUp":
-                event.preventDefault();
-                controls.setVolume(Math.min(1, state.volume + volumeStep));
-                break;
-            case "ArrowDown":
-                event.preventDefault();
-                controls.setVolume(Math.max(0, state.volume - volumeStep));
-                break;
-            case "Digit0":
-            case "Digit1":
-            case "Digit2":
-            case "Digit3":
-            case "Digit4":
-            case "Digit5":
-            case "Digit6":
-            case "Digit7":
-            case "Digit8":
-            case "Digit9":
-                event.preventDefault();
-                const digit = parseInt(event.code.replace("Digit", ""), 10);
-                const percentage = digit / 10;
-                controls.seek(state.duration * percentage);
-                break;
-            case "Home":
-                event.preventDefault();
-                controls.seek(0);
-                break;
-            case "End":
-                event.preventDefault();
-                controls.seek(state.duration);
-                break;
-            default:
-                // Don't prevent default for unhandled keys
-                break;
-        }
-    };
-    useEffect(() => {
-        if (!enabled)
-            return;
-        document.addEventListener("keydown", handleKeyDown);
-        return () => {
-            document.removeEventListener("keydown", handleKeyDown);
-        };
-    }, [enabled, handleKeyDown]);
-    return {
-        handleKeyDown
-    };
-}

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

@@ -1 +0,0 @@
-{"version":3,"file":"use-media-actions.d.ts","sourceRoot":"","sources":["use-media-actions.ts"],"names":[],"mappings":"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"}

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

@@ -1,121 +0,0 @@
-"use client";
-import React from "react";
-import { MediaActionTypes } from "../context/media-context";
-// Action creator factory
-function createOptimisticAction(type, store) {
-    return ((payload, optimistic = false) => {
-        const action = {
-            type,
-            detail: payload,
-            optimistic,
-            timestamp: Date.now()
-        };
-        if (optimistic) {
-            return store.dispatchOptimistic(action);
-        }
-        else {
-            store.dispatch(action);
-            return Promise.resolve();
-        }
-    });
-}
-// React 19 useActionState integration
-export function useMediaActionState(store) {
-    const [actionState, setActionState] = React.useState(store.getActionState());
-    // Subscribe to action state changes
-    React.useEffect(() => {
-        const unsubscribe = store.subscribe(() => {
-            const newActionState = store.getActionState();
-            setActionState(current => JSON.stringify(current) !== JSON.stringify(newActionState)
-                ? newActionState
-                : current);
-        });
-        return unsubscribe;
-    }, [store]);
-    return actionState;
-}
-// Media actions hook with React 19 optimistic updates
-export function useMediaActions(store) {
-    // Create action creators with optimistic support
-    const actions = React.useMemo(() => ({
-        // Playback actions
-        play: createOptimisticAction(MediaActionTypes.PLAY, store),
-        pause: createOptimisticAction(MediaActionTypes.PAUSE, store),
-        seek: createOptimisticAction(MediaActionTypes.SEEK, store),
-        // Volume actions  
-        setVolume: createOptimisticAction(MediaActionTypes.SET_VOLUME, store),
-        mute: createOptimisticAction(MediaActionTypes.MUTE, store),
-        unmute: createOptimisticAction(MediaActionTypes.UNMUTE, store),
-        toggleMute: createOptimisticAction(MediaActionTypes.TOGGLE_MUTE, store),
-        // Media state actions
-        setDuration: createOptimisticAction(MediaActionTypes.SET_DURATION, store),
-        setCurrentTime: createOptimisticAction(MediaActionTypes.SET_CURRENT_TIME, store),
-        setBuffered: createOptimisticAction(MediaActionTypes.SET_BUFFERED, store),
-        setLoading: createOptimisticAction(MediaActionTypes.SET_LOADING, store),
-        setError: createOptimisticAction(MediaActionTypes.SET_ERROR, store),
-        // Display actions
-        enterFullscreen: createOptimisticAction(MediaActionTypes.ENTER_FULLSCREEN, store),
-        exitFullscreen: createOptimisticAction(MediaActionTypes.EXIT_FULLSCREEN, store),
-        enterPiP: createOptimisticAction(MediaActionTypes.ENTER_PIP, store),
-        exitPiP: createOptimisticAction(MediaActionTypes.EXIT_PIP, store),
-        // Advanced actions
-        setPlaybackRate: createOptimisticAction(MediaActionTypes.SET_PLAYBACK_RATE, store),
-        setSubtitleTrack: createOptimisticAction(MediaActionTypes.SET_SUBTITLE_TRACK, store),
-        setRendition: createOptimisticAction(MediaActionTypes.SET_RENDITION, store),
-        toggleSubtitles: createOptimisticAction(MediaActionTypes.TOGGLE_SUBTITLES, store),
-        // Preview actions
-        previewTime: createOptimisticAction(MediaActionTypes.PREVIEW_TIME, store),
-        clearPreview: createOptimisticAction(MediaActionTypes.CLEAR_PREVIEW, store)
-    }), [store]);
-    // Get action state for loading/error handling
-    const actionState = useMediaActionState(store);
-    // Convenience methods that commonly use optimistic updates
-    const optimisticActions = React.useMemo(() => ({
-        // These actions benefit from immediate UI feedback
-        togglePlayPause: async (isPlaying) => {
-            if (isPlaying) {
-                await actions.pause(true); // optimistic
-            }
-            else {
-                await actions.play(true); // optimistic
-            }
-        },
-        seekWithPreview: async (time) => {
-            // Immediate preview update, then actual seek
-            await actions.previewTime(time, true);
-            await actions.seek(time, true);
-        },
-        adjustVolume: async (delta, currentVolume) => {
-            const newVolume = Math.max(0, Math.min(1, currentVolume + delta));
-            await actions.setVolume(newVolume, true);
-        },
-        toggleFullscreenOptimistic: async (isFullscreen) => {
-            if (isFullscreen) {
-                await actions.exitFullscreen(true);
-            }
-            else {
-                await actions.enterFullscreen(true);
-            }
-        }
-    }), [actions]);
-    // Retry failed action
-    const retryLastAction = React.useCallback(async () => {
-        const { lastAction } = actionState;
-        if (lastAction && actionState.error) {
-            await store.dispatchOptimistic({
-                ...lastAction,
-                retryCount: (lastAction.retryCount || 0) + 1
-            });
-        }
-    }, [store, actionState]);
-    return {
-        ...actions,
-        ...optimisticActions,
-        actionState,
-        retryLastAction,
-        isLoading: actionState.pending,
-        hasError: !!actionState.error,
-        errorMessage: actionState.error,
-        retryCount: actionState.retryCount
-    };
-}

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

@@ -1 +0,0 @@
-{"version":3,"file":"use-media-metadata.d.ts","sourceRoot":"","sources":["use-media-metadata.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,aAAa;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AA6DD,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa,CAG3D;AAGD,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAYlD"}

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

@@ -1,74 +0,0 @@
-import { use, cache } from 'react';
-// Cache metadata fetches to prevent duplicate requests
-const fetchMetadata = cache(async (src) => {
-    try {
-        // Create a video element to get metadata
-        const video = document.createElement('video');
-        video.crossOrigin = 'anonymous';
-        video.preload = 'metadata';
-        return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                video.removeEventListener('loadedmetadata', onMetadata);
-                video.removeEventListener('error', onError);
-                reject(new Error('Metadata loading timeout'));
-            }, 10000); // 10 second timeout
-            const onMetadata = () => {
-                clearTimeout(timeout);
-                video.removeEventListener('loadedmetadata', onMetadata);
-                video.removeEventListener('error', onError);
-                const metadata = {
-                    duration: video.duration || 0,
-                    format: getFormatFromSrc(src),
-                    width: video.videoWidth || undefined,
-                    height: video.videoHeight || undefined,
-                };
-                resolve(metadata);
-            };
-            const onError = (error) => {
-                clearTimeout(timeout);
-                video.removeEventListener('loadedmetadata', onMetadata);
-                video.removeEventListener('error', onError);
-                reject(new Error('Failed to load media metadata'));
-            };
-            video.addEventListener('loadedmetadata', onMetadata);
-            video.addEventListener('error', onError);
-            video.src = src;
-        });
-    }
-    catch (error) {
-        throw new Error(`Failed to fetch metadata: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-});
-function getFormatFromSrc(src) {
-    const url = new URL(src, window.location.href);
-    const pathname = url.pathname.toLowerCase();
-    if (pathname.endsWith('.mp4'))
-        return 'MP4';
-    if (pathname.endsWith('.webm'))
-        return 'WebM';
-    if (pathname.endsWith('.ogg'))
-        return 'OGG';
-    if (pathname.endsWith('.m3u8'))
-        return 'HLS';
-    if (pathname.endsWith('.mpd'))
-        return 'DASH';
-    return 'Unknown';
-}
-export function useMediaMetadata(src) {
-    // Use the React 19 use() hook for async data
-    return use(fetchMetadata(src));
-}
-// Utility function to format time
-export function formatTime(seconds) {
-    if (!isFinite(seconds) || isNaN(seconds))
-        return '0:00';
-    const hours = Math.floor(seconds / 3600);
-    const minutes = Math.floor((seconds % 3600) / 60);
-    const secs = Math.floor(seconds % 60);
-    if (hours > 0) {
-        return `${hours}:${minutes.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
-    }
-    else {
-        return `${minutes}:${secs.toString().padStart(2, '0')}`;
-    }
-}

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

@@ -1 +0,0 @@
-{"version":3,"file":"use-media-optimistic.d.ts","sourceRoot":"","sources":["use-media-optimistic.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAC1D,OAAO,KAAK,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AA6DvF,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,kBAAkB;iCAaC,qBAAqB;;kCAuB5C,MAAM;2BAWb,MAAM;;;sCA+BK,MAAM;;;;;;;;;;;;;;;;;;EAqD/C;AAkBD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,kBAAkB,WAgB7D;AAGD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,kBAAkB;;;;;EAoChE"}

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

@@ -1,205 +0,0 @@
-"use client";
-import React, { useOptimistic } from "react";
-// Optimistic update reducer function
-function optimisticMediaReducer(state, action) {
-    if (!action.optimistic)
-        return state;
-    // Apply immediate optimistic updates for better UX
-    switch (action.type) {
-        case "PLAY":
-            return { ...state, isPlaying: true, error: null };
-        case "PAUSE":
-            return { ...state, isPlaying: false };
-        case "SEEK":
-            return { ...state, currentTime: action.detail };
-        case "SET_VOLUME":
-            return { ...state, volume: Math.max(0, Math.min(1, action.detail)) };
-        case "MUTE":
-            return { ...state, isMuted: true };
-        case "UNMUTE":
-            return { ...state, isMuted: false };
-        case "TOGGLE_MUTE":
-            return { ...state, isMuted: !state.isMuted };
-        case "ENTER_FULLSCREEN":
-            return { ...state, isFullscreen: true };
-        case "EXIT_FULLSCREEN":
-            return { ...state, isFullscreen: false };
-        case "SET_PLAYBACK_RATE":
-            return { ...state, playbackRate: action.detail };
-        case "TOGGLE_SUBTITLES":
-            return { ...state, subtitlesShowing: !state.subtitlesShowing };
-        case "PREVIEW_TIME":
-            return { ...state, previewTime: action.detail };
-        case "CLEAR_PREVIEW":
-            return {
-                ...state,
-                previewTime: null,
-                previewImage: null,
-                previewCoords: null
-            };
-        default:
-            return state;
-    }
-}
-// Media optimistic state hook using React 19's useOptimistic
-export function useMediaOptimistic(store) {
-    const actualState = React.useSyncExternalStore(store.subscribe, store.getState, store.getState);
-    const [optimisticState, addOptimistic] = useOptimistic(actualState, optimisticMediaReducer);
-    // Enhanced dispatch that uses optimistic updates
-    const dispatchOptimistic = React.useCallback(async (action) => {
-        // Add optimistic update immediately
-        if (action.optimistic) {
-            addOptimistic(action);
-        }
-        // Dispatch the actual action
-        await store.dispatchOptimistic(action);
-    }, [store, addOptimistic]);
-    // Quick actions with optimistic updates
-    const optimisticActions = React.useMemo(() => ({
-        // Play/Pause with immediate feedback
-        togglePlayPause: async () => {
-            const action = {
-                type: optimisticState.isPlaying ? "PAUSE" : "PLAY",
-                optimistic: true,
-                timestamp: Date.now()
-            };
-            await dispatchOptimistic(action);
-        },
-        // Volume control with immediate slider feedback
-        setVolumeOptimistic: async (volume) => {
-            const action = {
-                type: "SET_VOLUME",
-                detail: Math.max(0, Math.min(1, volume)),
-                optimistic: true,
-                timestamp: Date.now()
-            };
-            await dispatchOptimistic(action);
-        },
-        // Seek with immediate scrub feedback
-        seekOptimistic: async (time) => {
-            const action = {
-                type: "SEEK",
-                detail: time,
-                optimistic: true,
-                timestamp: Date.now()
-            };
-            await dispatchOptimistic(action);
-        },
-        // Mute toggle with immediate icon change
-        toggleMuteOptimistic: async () => {
-            const action = {
-                type: "TOGGLE_MUTE",
-                optimistic: true,
-                timestamp: Date.now()
-            };
-            await dispatchOptimistic(action);
-        },
-        // Fullscreen toggle with immediate layout change
-        toggleFullscreenOptimistic: async () => {
-            const action = {
-                type: optimisticState.isFullscreen ? "EXIT_FULLSCREEN" : "ENTER_FULLSCREEN",
-                optimistic: true,
-                timestamp: Date.now()
-            };
-            await dispatchOptimistic(action);
-        },
-        // Playback rate with immediate feedback
-        setPlaybackRateOptimistic: async (rate) => {
-            const action = {
-                type: "SET_PLAYBACK_RATE",
-                detail: rate,
-                optimistic: true,
-                timestamp: Date.now()
-            };
-            await dispatchOptimistic(action);
-        },
-        // Subtitle toggle with immediate visibility change
-        toggleSubtitlesOptimistic: async () => {
-            const action = {
-                type: "TOGGLE_SUBTITLES",
-                optimistic: true,
-                timestamp: Date.now()
-            };
-            await dispatchOptimistic(action);
-        }
-    }), [optimisticState, dispatchOptimistic]);
-    // State selectors that return optimistic values
-    const selectors = React.useMemo(() => ({
-        isPlaying: optimisticState.isPlaying,
-        currentTime: optimisticState.currentTime,
-        volume: optimisticState.volume,
-        isMuted: optimisticState.isMuted,
-        isFullscreen: optimisticState.isFullscreen,
-        playbackRate: optimisticState.playbackRate,
-        subtitlesShowing: optimisticState.subtitlesShowing,
-        previewTime: optimisticState.previewTime,
-        // Computed values
-        progress: optimisticState.duration > 0
-            ? optimisticState.currentTime / optimisticState.duration
-            : 0,
-        formattedTime: formatTime(optimisticState.currentTime),
-        formattedDuration: formatTime(optimisticState.duration),
-        // State checks
-        canPlay: !optimisticState.isLoading && !optimisticState.error,
-        hasError: !!optimisticState.error,
-        isBuffering: optimisticState.isLoading
-    }), [optimisticState]);
-    return {
-        state: optimisticState,
-        actualState,
-        ...selectors,
-        ...optimisticActions,
-        dispatchOptimistic
-    };
-}
-// Time formatting utility
-function formatTime(seconds) {
-    if (!seconds || !isFinite(seconds))
-        return "0:00";
-    const mins = Math.floor(seconds / 60);
-    const secs = Math.floor(seconds % 60);
-    const hours = Math.floor(mins / 60);
-    if (hours > 0) {
-        return `${hours}:${String(mins % 60).padStart(2, '0')}:${String(secs).padStart(2, '0')}`;
-    }
-    return `${mins}:${String(secs).padStart(2, '0')}`;
-}
-// Hook for components that need to detect optimistic updates
-export function useOptimisticUpdates(store) {
-    const [hasOptimisticUpdates, setHasOptimisticUpdates] = React.useState(false);
-    React.useEffect(() => {
-        const unsubscribe = store.subscribe(() => {
-            const actualState = store.getState();
-            const optimisticState = store.getOptimisticState();
-            const hasUpdates = JSON.stringify(actualState) !== JSON.stringify(optimisticState);
-            setHasOptimisticUpdates(hasUpdates);
-        });
-        return unsubscribe;
-    }, [store]);
-    return hasOptimisticUpdates;
-}
-// Hook to get both actual and optimistic state for debugging
-export function useMediaStateComparison(store) {
-    const actualState = React.useSyncExternalStore(store.subscribe, store.getState, store.getState);
-    const optimisticState = React.useSyncExternalStore(store.subscribe, store.getOptimisticState, store.getOptimisticState);
-    const differences = React.useMemo(() => {
-        const diffs = [];
-        const stateKeys = Object.keys(actualState);
-        stateKeys.forEach(key => {
-            if (JSON.stringify(actualState[key]) !== JSON.stringify(optimisticState[key])) {
-                diffs.push({
-                    key: key,
-                    actual: actualState[key],
-                    optimistic: optimisticState[key]
-                });
-            }
-        });
-        return diffs;
-    }, [actualState, optimisticState]);
-    return {
-        actualState,
-        optimisticState,
-        differences,
-        hasOptimisticUpdates: differences.length > 0
-    };
-}

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

@@ -1 +0,0 @@
-{"version":3,"file":"use-media-player.d.ts","sourceRoot":"","sources":["use-media-player.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAA;AAGzD,UAAU,qBAAqB;IAC9B,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;IACtB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,CAAA;IACtC,WAAW,CAAC,EAAE,WAAW,GAAG,iBAAiB,CAAA;IAC7C,aAAa,CAAC,EAAE,MAAM,EAAE,CAAA;IACxB,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,MAAM,CAAC,EAAE,MAAM,IAAI,CAAA;IACnB,OAAO,CAAC,EAAE,MAAM,IAAI,CAAA;IACpB,YAAY,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,IAAI,CAAA;IAC5C,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;IAC7C,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IACzC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IACjC,WAAW,CAAC,EAAE,MAAM,IAAI,CAAA;IACxB,YAAY,CAAC,EAAE,MAAM,IAAI,CAAA;IACzB,OAAO,CAAC,EAAE,MAAM,IAAI,CAAA;CACpB;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,qBAAqB;;;;;EA0R5D"}