@therealtinhtute/baroiplayer 1.0.6 → 1.0.8

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

@@ -1,289 +0,0 @@
-"use client";
-import * as React from "react";
-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'],
-    tapThreshold: 200,
-    doubleTapThreshold: 300,
-    longPressThreshold: 500,
-    swipeThreshold: 50,
-    swipeVelocityThreshold: 0.5,
-    pinchThreshold: 0.1,
-    rotationThreshold: 15,
-    enableHapticFeedback: true
-};
-// Touch gesture hook
-export function useTouchGestures(ref, onGesture, config = {}) {
-    const mergedConfig = { ...defaultConfig, ...config };
-    const { isTouchDevice } = useDeviceInfo();
-    const { triggerHaptic } = useHapticFeedback();
-    const gestureState = React.useRef({
-        isTracking: false,
-        touches: [],
-        startTouches: []
-    });
-    // Helper functions
-    const getTouchPoint = (touch) => ({
-        id: touch.identifier,
-        x: touch.clientX,
-        y: touch.clientY,
-        timestamp: Date.now()
-    });
-    const getDistance = (p1, p2) => Math.sqrt(Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2));
-    const getVelocity = (start, end) => {
-        const timeDiff = Math.max(end.timestamp - start.timestamp, 1);
-        return {
-            x: (end.x - start.x) / timeDiff,
-            y: (end.y - start.y) / timeDiff
-        };
-    };
-    const createGestureEvent = (type, startPoint, currentPoint, additionalData = {}) => ({
-        type,
-        startPoint: { x: startPoint.x, y: startPoint.y },
-        currentPoint: { x: currentPoint.x, y: currentPoint.y },
-        duration: currentPoint.timestamp - startPoint.timestamp,
-        target: ref.current,
-        preventDefault: () => { },
-        ...additionalData
-    });
-    // Handle touch start
-    const handleTouchStart = React.useCallback((e) => {
-        if (!mergedConfig.enabledGestures.length)
-            return;
-        const touches = Array.from(e.touches).map(getTouchPoint);
-        const state = gestureState.current;
-        state.isTracking = true;
-        state.touches = touches;
-        state.startTouches = [...touches];
-        // Clear any existing long press timer
-        if (state.longPressTimer) {
-            clearTimeout(state.longPressTimer);
-        }
-        // Set up long press detection for single touch
-        if (touches.length === 1 && mergedConfig.enabledGestures.includes('long-press')) {
-            state.longPressTimer = setTimeout(() => {
-                if (state.touches.length === 1 && touches[0]) {
-                    const gestureEvent = createGestureEvent('long-press', touches[0], touches[0]);
-                    onGesture(gestureEvent);
-                    if (mergedConfig.enableHapticFeedback) {
-                        triggerHaptic('heavy');
-                    }
-                }
-            }, mergedConfig.longPressThreshold);
-        }
-        // Handle multi-touch gestures
-        if (touches.length === 2 && touches[0] && touches[1]) {
-            state.initialDistance = getDistance(touches[0], touches[1]);
-            state.initialScale = 1;
-            state.lastScale = 1;
-        }
-    }, [mergedConfig, onGesture, triggerHaptic]);
-    // Handle touch move
-    const handleTouchMove = React.useCallback((e) => {
-        const state = gestureState.current;
-        if (!state.isTracking)
-            return;
-        const touches = Array.from(e.touches).map(getTouchPoint);
-        state.touches = touches;
-        // Handle pinch gesture
-        if (touches.length === 2 && state.initialDistance && touches[0] && touches[1]) {
-            const currentDistance = getDistance(touches[0], touches[1]);
-            const scale = currentDistance / state.initialDistance;
-            const scaleDiff = Math.abs(scale - (state.lastScale || 1));
-            if (scaleDiff > mergedConfig.pinchThreshold) {
-                const gestureType = scale > (state.lastScale || 1) ? 'pinch-out' : 'pinch-in';
-                if (mergedConfig.enabledGestures.includes(gestureType)) {
-                    const centerPoint = {
-                        x: (touches[0].x + touches[1].x) / 2,
-                        y: (touches[0].y + touches[1].y) / 2,
-                        id: -1,
-                        timestamp: Date.now()
-                    };
-                    const startCenterPoint = {
-                        x: ((state.startTouches[0]?.x ?? 0) + (state.startTouches[1]?.x ?? 0)) / 2,
-                        y: ((state.startTouches[0]?.y ?? 0) + (state.startTouches[1]?.y ?? 0)) / 2,
-                        id: -1,
-                        timestamp: state.startTouches[0]?.timestamp ?? Date.now()
-                    };
-                    const gestureEvent = createGestureEvent(gestureType, startCenterPoint, centerPoint, {
-                        scale,
-                        distance: currentDistance
-                    });
-                    onGesture(gestureEvent);
-                    state.lastScale = scale;
-                }
-            }
-        }
-        // Clear long press timer on move
-        if (state.longPressTimer && touches.length === 1 && state.startTouches[0] && touches[0]) {
-            const startTouch = state.startTouches[0];
-            const currentTouch = touches[0];
-            const distance = getDistance(startTouch, currentTouch);
-            if (distance > mergedConfig.swipeThreshold) {
-                clearTimeout(state.longPressTimer);
-                state.longPressTimer = undefined;
-            }
-        }
-    }, [mergedConfig, onGesture]);
-    // Handle touch end
-    const handleTouchEnd = React.useCallback((e) => {
-        const state = gestureState.current;
-        if (!state.isTracking)
-            return;
-        const endTouches = Array.from(e.changedTouches).map(getTouchPoint);
-        const currentTime = Date.now();
-        // Clear long press timer
-        if (state.longPressTimer) {
-            clearTimeout(state.longPressTimer);
-            state.longPressTimer = undefined;
-        }
-        // Handle single touch gestures
-        if (state.startTouches.length === 1 && endTouches.length === 1 && state.startTouches[0] && endTouches[0]) {
-            const startTouch = state.startTouches[0];
-            const endTouch = endTouches[0];
-            const distance = getDistance(startTouch, endTouch);
-            const duration = endTouch.timestamp - startTouch.timestamp;
-            // Check for swipe gestures
-            if (distance > mergedConfig.swipeThreshold) {
-                const velocity = getVelocity(startTouch, endTouch);
-                const absVelX = Math.abs(velocity.x);
-                const absVelY = Math.abs(velocity.y);
-                if (absVelX > mergedConfig.swipeVelocityThreshold || absVelY > mergedConfig.swipeVelocityThreshold) {
-                    let gestureType;
-                    if (absVelX > absVelY) {
-                        gestureType = velocity.x > 0 ? 'swipe-right' : 'swipe-left';
-                    }
-                    else {
-                        gestureType = velocity.y > 0 ? 'swipe-down' : 'swipe-up';
-                    }
-                    if (mergedConfig.enabledGestures.includes(gestureType)) {
-                        const gestureEvent = createGestureEvent(gestureType, startTouch, endTouch, {
-                            velocity,
-                            distance
-                        });
-                        onGesture(gestureEvent);
-                        if (mergedConfig.enableHapticFeedback) {
-                            triggerHaptic('light');
-                        }
-                    }
-                }
-            }
-            // Check for tap gestures
-            else if (duration < mergedConfig.tapThreshold && distance < mergedConfig.swipeThreshold) {
-                // Check for double tap
-                if (state.lastTap &&
-                    currentTime - state.lastTap.timestamp < mergedConfig.doubleTapThreshold &&
-                    getDistance({ ...state.lastTap.point, id: -1, timestamp: state.lastTap.timestamp }, endTouch) < mergedConfig.swipeThreshold) {
-                    if (mergedConfig.enabledGestures.includes('double-tap')) {
-                        const gestureEvent = createGestureEvent('double-tap', startTouch, endTouch);
-                        onGesture(gestureEvent);
-                        if (mergedConfig.enableHapticFeedback) {
-                            triggerHaptic('medium');
-                        }
-                    }
-                    state.lastTap = undefined;
-                }
-                else {
-                    // Single tap
-                    if (mergedConfig.enabledGestures.includes('tap')) {
-                        const gestureEvent = createGestureEvent('tap', startTouch, endTouch);
-                        onGesture(gestureEvent);
-                        if (mergedConfig.enableHapticFeedback) {
-                            triggerHaptic('light');
-                        }
-                    }
-                    state.lastTap = {
-                        timestamp: currentTime,
-                        point: { x: endTouch.x, y: endTouch.y }
-                    };
-                }
-            }
-        }
-        // Reset gesture state
-        if (e.touches.length === 0) {
-            state.isTracking = false;
-            state.touches = [];
-            state.startTouches = [];
-            state.initialDistance = undefined;
-            state.initialScale = undefined;
-            state.lastScale = undefined;
-        }
-    }, [mergedConfig, onGesture, triggerHaptic]);
-    // Attach event listeners
-    React.useEffect(() => {
-        const element = ref.current;
-        if (!element || !isTouchDevice)
-            return;
-        element.addEventListener('touchstart', handleTouchStart, { passive: false });
-        element.addEventListener('touchmove', handleTouchMove, { passive: false });
-        element.addEventListener('touchend', handleTouchEnd, { passive: false });
-        element.addEventListener('touchcancel', handleTouchEnd, { passive: false });
-        return () => {
-            element.removeEventListener('touchstart', handleTouchStart);
-            element.removeEventListener('touchmove', handleTouchMove);
-            element.removeEventListener('touchend', handleTouchEnd);
-            element.removeEventListener('touchcancel', handleTouchEnd);
-        };
-    }, [handleTouchStart, handleTouchMove, handleTouchEnd, isTouchDevice]);
-    return {
-        isGestureEnabled: isTouchDevice && mergedConfig.enabledGestures.length > 0
-    };
-}
-// Media player specific gesture hook with predefined actions
-export function useMediaGestures(ref, actions) {
-    const handleGesture = React.useCallback((event) => {
-        const { type, velocity, distance, scale } = event;
-        switch (type) {
-            case 'double-tap':
-                // Double tap to play/pause
-                actions.onPlayPause?.();
-                break;
-            case 'swipe-left':
-                // Swipe left to seek backward
-                const backwardAmount = Math.min((distance || 0) / 10, 30); // Max 30 seconds
-                actions.onSeek?.('backward', backwardAmount);
-                break;
-            case 'swipe-right':
-                // Swipe right to seek forward
-                const forwardAmount = Math.min((distance || 0) / 10, 30); // Max 30 seconds
-                actions.onSeek?.('forward', forwardAmount);
-                break;
-            case 'swipe-up':
-                // Swipe up on right side for volume up
-                if (event.startPoint.x > (ref.current?.clientWidth || 0) / 2) {
-                    const volumeAmount = Math.min((distance || 0) / 100, 0.2); // Max 20%
-                    actions.onVolumeChange?.('up', volumeAmount);
-                }
-                break;
-            case 'swipe-down':
-                // Swipe down on right side for volume down
-                if (event.startPoint.x > (ref.current?.clientWidth || 0) / 2) {
-                    const volumeAmount = Math.min((distance || 0) / 100, 0.2); // Max 20%
-                    actions.onVolumeChange?.('down', volumeAmount);
-                }
-                break;
-            case 'pinch-out':
-                // Pinch out to zoom in (for video zoom functionality)
-                actions.onZoom?.(scale || 1);
-                break;
-            case 'pinch-in':
-                // Pinch in to zoom out
-                actions.onZoom?.(scale || 1);
-                break;
-            case 'long-press':
-                // Long press for fullscreen toggle
-                actions.onToggleFullscreen?.();
-                break;
-            default:
-                break;
-        }
-    }, [actions, ref]);
-    const gestureConfig = {
-        enabledGestures: ['tap', 'double-tap', 'long-press', 'swipe-left', 'swipe-right', 'swipe-up', 'swipe-down', 'pinch-in', 'pinch-out'],
-        enableHapticFeedback: true,
-        swipeThreshold: 30,
-        swipeVelocityThreshold: 0.3
-    };
-    return useTouchGestures(ref, handleGesture, gestureConfig);
-}

package/src/hooks/useEnhancedSubtitles.js

@@ -1,205 +0,0 @@
-import { useState, useEffect } from "react";
-export function useEnhancedSubtitles({ subtitleSrc, subtitleTracks = [], defaultFontSize = "medium", onLoadError } = {}) {
-    const [subtitlesEnabled, setSubtitlesEnabled] = useState(false);
-    const [subtitleCues, setSubtitleCues] = useState([]);
-    const [currentSubtitle, setCurrentSubtitle] = useState("");
-    const [currentTrackId, setCurrentTrackId] = useState(null);
-    const [fontSize, setFontSize] = useState(defaultFontSize);
-    const [loadError, setLoadError] = useState(null);
-    const [isLoading, setIsLoading] = useState(false);
-    // Size mapping for subtitle font sizes
-    const sizeMap = {
-        small: "text-sm",
-        medium: "text-base",
-        large: "text-lg"
-    };
-    // Determine if subtitles are available
-    const hasSubtitles = !!(subtitleSrc || (subtitleTracks && subtitleTracks.length > 0));
-    // Parse VTT/WebVTT timestamp
-    const parseVTTTime = (timeStr) => {
-        const parts = timeStr.split(":");
-        const seconds = parts[2] ? parseFloat(parts[2]) : 0;
-        const minutes = parts[1] ? parseInt(parts[1], 10) * 60 : 0;
-        const hours = parts[0] ? parseInt(parts[0], 10) * 3600 : 0;
-        return hours + minutes + seconds;
-    };
-    // Parse SRT timestamp
-    const parseSRTTime = (timeStr) => {
-        // SRT format: 00:00:00,000 (hours:minutes:seconds,milliseconds)
-        const [time, ms] = timeStr.split(",");
-        const parts = (time || "").split(":");
-        const milliseconds = ms ? parseInt(ms, 10) / 1000 : 0;
-        const seconds = parts[2] ? parseInt(parts[2], 10) : 0;
-        const minutes = parts[1] ? parseInt(parts[1], 10) * 60 : 0;
-        const hours = parts[0] ? parseInt(parts[0], 10) * 3600 : 0;
-        return hours + minutes + seconds + milliseconds;
-    };
-    // Load and parse subtitle file
-    const loadSubtitles = async (url) => {
-        setIsLoading(true);
-        setLoadError(null);
-        try {
-            const response = await fetch(url);
-            if (!response.ok) {
-                throw new Error(`Failed to load subtitles: ${response.status} ${response.statusText}`);
-            }
-            const text = await response.text();
-            const cues = [];
-            const lines = text.split("\n");
-            let i = 0;
-            // Detect format (VTT or SRT)
-            const isVTT = text.includes("WEBVTT") || url.endsWith(".vtt");
-            const isSRT = url.endsWith(".srt") || /^\d+$/.test(lines[0]?.trim() || "");
-            if (isVTT) {
-                // Parse VTT format
-                while (i < lines.length) {
-                    if (lines[i]?.includes("-->")) {
-                        const [startStr, endStr] = (lines[i] || "").split("-->").map((s) => s.trim());
-                        const start = parseVTTTime(startStr || "");
-                        const end = parseVTTTime(endStr || "");
-                        i++;
-                        let subtitleText = "";
-                        while (i < lines.length && lines[i]?.trim() !== "") {
-                            subtitleText += (subtitleText ? " " : "") + lines[i]?.trim();
-                            i++;
-                        }
-                        if (subtitleText) {
-                            cues.push({ start, end, text: subtitleText });
-                        }
-                    }
-                    i++;
-                }
-            }
-            else if (isSRT) {
-                // Parse SRT format
-                while (i < lines.length) {
-                    // Skip the sequence number
-                    if (/^\d+$/.test(lines[i]?.trim() || "")) {
-                        i++;
-                        // Parse timestamp line
-                        if (lines[i]?.includes("-->")) {
-                            const [startStr, endStr] = (lines[i] || "").split("-->").map((s) => s.trim());
-                            const start = parseSRTTime(startStr || "");
-                            const end = parseSRTTime(endStr || "");
-                            i++;
-                            let subtitleText = "";
-                            while (i < lines.length && lines[i]?.trim() !== "") {
-                                subtitleText += (subtitleText ? " " : "") + lines[i]?.trim();
-                                i++;
-                            }
-                            if (subtitleText) {
-                                cues.push({ start, end, text: subtitleText });
-                            }
-                        }
-                    }
-                    i++;
-                }
-            }
-            else {
-                throw new Error("Unsupported subtitle format. Only VTT and SRT are supported.");
-            }
-            if (cues.length === 0) {
-                throw new Error("No subtitle cues found in file");
-            }
-            setSubtitleCues(cues);
-            setIsLoading(false);
-        }
-        catch (error) {
-            const err = error instanceof Error ? error : new Error("Failed to load subtitles");
-            console.error("Failed to load subtitles:", err);
-            setLoadError(err);
-            setIsLoading(false);
-            setSubtitleCues([]);
-            onLoadError?.(err);
-        }
-    };
-    // Get current subtitle text based on time
-    const getCurrentSubtitle = (currentTime) => {
-        if (!subtitlesEnabled || subtitleCues.length === 0)
-            return "";
-        const currentCue = subtitleCues.find((cue) => currentTime >= cue.start && currentTime <= cue.end);
-        return currentCue?.text || "";
-    };
-    // Toggle subtitles on/off
-    const toggleSubtitles = () => {
-        setSubtitlesEnabled(prev => {
-            const newEnabled = !prev;
-            if (newEnabled && !loadError) {
-                // Try to load subtitles if not already loaded
-                if (subtitleCues.length === 0 && !isLoading) {
-                    // Load default subtitle source or first track
-                    const srcToLoad = subtitleSrc || subtitleTracks[0]?.src;
-                    if (srcToLoad) {
-                        loadSubtitles(srcToLoad);
-                        if (subtitleTracks[0]) {
-                            setCurrentTrackId(subtitleTracks[0].id);
-                        }
-                    }
-                }
-            }
-            else if (!newEnabled) {
-                setCurrentSubtitle("");
-            }
-            return newEnabled;
-        });
-    };
-    // Select a specific subtitle track
-    const selectSubtitleTrack = (trackId) => {
-        if (!trackId) {
-            // Turn off subtitles
-            setSubtitlesEnabled(false);
-            setCurrentTrackId(null);
-            setCurrentSubtitle("");
-            return;
-        }
-        const track = subtitleTracks.find(t => t.id === trackId);
-        if (track?.src) {
-            setCurrentTrackId(trackId);
-            loadSubtitles(track.src);
-            setSubtitlesEnabled(true);
-        }
-    };
-    // Change subtitle font size
-    const changeSubtitleFontSize = (size) => {
-        setFontSize(size);
-    };
-    // Get CSS classes for subtitle display
-    const getSubtitleStyles = {
-        fontSize: sizeMap[fontSize],
-        className: `${sizeMap[fontSize]} font-medium`
-    };
-    // Clear subtitle on disable
-    useEffect(() => {
-        if (!subtitlesEnabled) {
-            setCurrentSubtitle("");
-        }
-    }, [subtitlesEnabled]);
-    // Auto-load default subtitles on mount if available
-    useEffect(() => {
-        if (subtitleSrc && !subtitleCues.length && !loadError && !isLoading) {
-            // Don't auto-load, wait for user to enable
-            // This prevents errors on initial load
-        }
-    }, []);
-    return {
-        // State
-        subtitlesEnabled,
-        currentSubtitle,
-        subtitleCues,
-        currentTrackId,
-        fontSize,
-        loadError,
-        isLoading,
-        hasSubtitles,
-        // Actions
-        toggleSubtitles,
-        selectSubtitleTrack,
-        changeSubtitleFontSize,
-        setCurrentSubtitle,
-        // Utilities
-        getCurrentSubtitle,
-        getSubtitleStyles,
-        // Track info
-        availableTracks: subtitleTracks
-    };
-}

package/src/hooks/useKeyboardShortcuts.js

@@ -1,59 +0,0 @@
-import { useEffect } from "react";
-export function useKeyboardShortcuts({ videoControls, toggleSubtitles, takeScreenshot, duration }) {
-    const handleKeyDown = (e) => {
-        const video = document.querySelector('video');
-        if (!video)
-            return;
-        switch (e.key.toLowerCase()) {
-            case " ":
-            case "k":
-                e.preventDefault();
-                videoControls.togglePlay();
-                break;
-            case "j":
-                e.preventDefault();
-                videoControls.seekBackward();
-                break;
-            case "l":
-                e.preventDefault();
-                videoControls.seekForward();
-                break;
-            case "arrowleft":
-                e.preventDefault();
-                video.currentTime = Math.max(0, video.currentTime - 5);
-                break;
-            case "arrowright":
-                e.preventDefault();
-                video.currentTime = Math.min(duration, video.currentTime + 5);
-                break;
-            case "arrowup":
-                e.preventDefault();
-                video.volume = Math.min(1, video.volume + 0.1);
-                break;
-            case "arrowdown":
-                e.preventDefault();
-                video.volume = Math.max(0, video.volume - 0.1);
-                break;
-            case "m":
-                e.preventDefault();
-                videoControls.toggleMute();
-                break;
-            case "f":
-                e.preventDefault();
-                videoControls.toggleFullscreen();
-                break;
-            case "c":
-                e.preventDefault();
-                toggleSubtitles();
-                break;
-            case "s":
-                e.preventDefault();
-                takeScreenshot(e.ctrlKey || e.metaKey);
-                break;
-        }
-    };
-    useEffect(() => {
-        document.addEventListener("keydown", handleKeyDown);
-        return () => document.removeEventListener("keydown", handleKeyDown);
-    }, [handleKeyDown]);
-}

package/src/hooks/useMediaControls.js

@@ -1,44 +0,0 @@
-import { useState, useRef, useEffect } from "react";
-export function useMediaControls(isPlaying, showSettings) {
-    const [controlsVisible, setControlsVisible] = useState(true);
-    const [showVolumeSlider, setShowVolumeSlider] = useState(false);
-    const hideTimeoutRef = useRef(null);
-    const showControls = () => {
-        setControlsVisible(true);
-        if (hideTimeoutRef.current) {
-            clearTimeout(hideTimeoutRef.current);
-        }
-        if (isPlaying && !showSettings) {
-            hideTimeoutRef.current = setTimeout(() => {
-                setControlsVisible(false);
-            }, 3000);
-        }
-    };
-    const handleMouseMove = () => {
-        showControls();
-    };
-    const handleMouseEnter = () => {
-        setControlsVisible(true);
-    };
-    const handleMouseLeave = () => {
-        if (isPlaying) {
-            setControlsVisible(false);
-        }
-    };
-    useEffect(() => {
-        showControls();
-        return () => {
-            if (hideTimeoutRef.current) {
-                clearTimeout(hideTimeoutRef.current);
-            }
-        };
-    }, [showControls]);
-    return {
-        controlsVisible,
-        showVolumeSlider,
-        setShowVolumeSlider,
-        handleMouseMove,
-        handleMouseEnter,
-        handleMouseLeave
-    };
-}

package/src/hooks/useScreenshot.js

@@ -1,56 +0,0 @@
-export function useScreenshot(videoRef) {
-    const takeScreenshot = (ctrlKey = false) => {
-        if (!videoRef.current)
-            return;
-        const video = videoRef.current;
-        const canvas = document.createElement("canvas");
-        canvas.width = video.videoWidth;
-        canvas.height = video.videoHeight;
-        const ctx = canvas.getContext("2d");
-        if (!ctx)
-            return;
-        try {
-            // Draw the video frame to canvas
-            ctx.drawImage(video, 0, 0);
-            // Try to export the canvas
-            canvas.toBlob((blob) => {
-                if (!blob) {
-                    console.error("Failed to create blob from canvas");
-                    return;
-                }
-                if (ctrlKey) {
-                    // Copy to clipboard
-                    if (navigator.clipboard && window.ClipboardItem) {
-                        const item = new ClipboardItem({ "image/png": blob });
-                        navigator.clipboard.write([item]).catch(err => {
-                            console.error("Failed to copy to clipboard:", err);
-                        });
-                    }
-                    else {
-                        console.warn("Clipboard API not supported");
-                    }
-                }
-                else {
-                    // Download
-                    const url = URL.createObjectURL(blob);
-                    const a = document.createElement("a");
-                    a.href = url;
-                    a.download = `screenshot-${Date.now()}.png`;
-                    a.click();
-                    URL.revokeObjectURL(url);
-                }
-            }, "image/png");
-        }
-        catch (error) {
-            if (error instanceof Error && error.message.includes("tainted")) {
-                console.error("Canvas is tainted - video source may not have proper CORS headers. Try setting crossOrigin='anonymous' on the video element.");
-                alert("Screenshot failed: The video source doesn't allow screenshots due to CORS policy. Please ensure the video server includes proper CORS headers or set crossOrigin='anonymous' on the video player.");
-            }
-            else {
-                console.error("Screenshot failed:", error);
-                alert("Screenshot failed: " + (error instanceof Error ? error.message : "Unknown error"));
-            }
-        }
-    };
-    return { takeScreenshot };
-}