@therealtinhtute/baroiplayer 1.0.8 → 1.1.0

package/src/hooks/useEnhancedSubtitles.ts

@@ -1,258 +1,258 @@
-import { useState, useCallback, useMemo, useEffect } from "react"
+import { useCallback, useEffect, useMemo, useState } from "react"
 
 interface SubtitleCue {
-  start: number
-  end: number
-  text: string
+	start: number
+	end: number
+	text: string
 }
 
 export interface SubtitleTrack {
-  id: string
-  label: string
-  language?: string
-  src?: string
+	id: string
+	label: string
+	language?: string
+	src?: string
 }
 
 export interface UseEnhancedSubtitlesOptions {
-  subtitleSrc?: string
-  subtitleTracks?: SubtitleTrack[]
-  defaultFontSize?: "small" | "medium" | "large"
-  onLoadError?: (error: Error) => void
+	subtitleSrc?: string
+	subtitleTracks?: SubtitleTrack[]
+	defaultFontSize?: "small" | "medium" | "large"
+	onLoadError?: (error: Error) => void
 }
 
 export function useEnhancedSubtitles({
-  subtitleSrc,
-  subtitleTracks = [],
-  defaultFontSize = "medium",
-  onLoadError
+	subtitleSrc,
+	subtitleTracks = [],
+	defaultFontSize = "medium",
+	onLoadError
 }: UseEnhancedSubtitlesOptions = {}) {
-  const [subtitlesEnabled, setSubtitlesEnabled] = useState(false)
-  const [subtitleCues, setSubtitleCues] = useState<SubtitleCue[]>([])
-  const [currentSubtitle, setCurrentSubtitle] = useState("")
-  const [currentTrackId, setCurrentTrackId] = useState<string | null>(null)
-  const [fontSize, setFontSize] = useState<"small" | "medium" | "large">(defaultFontSize)
-  const [loadError, setLoadError] = useState<Error | null>(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: string): number => {
-      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: string): number => {
-      // 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: string) => {
-      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: SubtitleCue[] = []
-        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: number) => {
-        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: string | null) => {
-      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: "small" | "medium" | "large") => {
-      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
-  }
+	const [subtitlesEnabled, setSubtitlesEnabled] = useState(false)
+	const [subtitleCues, setSubtitleCues] = useState<SubtitleCue[]>([])
+	const [currentSubtitle, setCurrentSubtitle] = useState("")
+	const [currentTrackId, setCurrentTrackId] = useState<string | null>(null)
+	const [fontSize, setFontSize] = useState<"small" | "medium" | "large">(defaultFontSize)
+	const [loadError, setLoadError] = useState<Error | null>(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: string): number => {
+		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: string): number => {
+		// 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: string) => {
+		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: SubtitleCue[] = []
+			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: number) => {
+		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: string | null) => {
+		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: "small" | "medium" | "large") => {
+		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.ts

@@ -1,4 +1,4 @@
-import { useEffect, useCallback } from "react"
+import { useCallback, useEffect } from "react"
 import type { VideoControls } from "./useVideoPlayer"
 
 interface UseKeyboardShortcutsProps {
@@ -15,60 +15,60 @@ export function useKeyboardShortcuts({
 	duration
 }: UseKeyboardShortcutsProps) {
 	const handleKeyDown = (e: KeyboardEvent) => {
-    		const video = document.querySelector('video')
-    		if (!video) return
+		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
-    		}
-    	}
+		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])
-}
+}