@therealtinhtute/baroiplayer 1.2.0 → 2.0.0-beta.1

package/src/features/subtitles/subtitle-manager.ts

@@ -1,435 +0,0 @@
-import { type ParsedSubtitles, type SubtitleCue, SubtitleParser } from "./subtitle-parser"
-
-export interface SubtitleTrack {
-	id: string
-	url: string
-	label: string
-	language: string
-	isDefault?: boolean
-	format?: "vtt" | "srt"
-	parsedSubtitles?: ParsedSubtitles
-	loadingState?: "idle" | "loading" | "loaded" | "error"
-	error?: string
-}
-
-export interface SubtitleStyle {
-	fontSize?: number
-	fontFamily?: string
-	color?: string
-	backgroundColor?: string
-	borderColor?: string
-	borderWidth?: number
-	opacity?: number
-	position?: "top" | "center" | "bottom"
-	alignment?: "left" | "center" | "right"
-	shadow?: boolean
-}
-
-export interface SubtitleManagerOptions {
-	tracks?: SubtitleTrack[]
-	defaultStyle?: SubtitleStyle
-	enabledByDefault?: boolean
-	preloadTracks?: boolean
-}
-
-export class SubtitleManager {
-	private tracks: Map<string, SubtitleTrack> = new Map()
-	private activeTrackId: string | null = null
-	private currentCues: SubtitleCue[] = []
-	private isEnabled: boolean = false
-	private style: SubtitleStyle
-	private eventListeners: Map<string, Set<Function>> = new Map()
-
-	constructor(options: SubtitleManagerOptions = {}) {
-		this.style = {
-			fontSize: 16,
-			fontFamily: "Arial, sans-serif",
-			color: "#ffffff",
-			backgroundColor: "rgba(0, 0, 0, 0.7)",
-			borderColor: "#000000",
-			borderWidth: 1,
-			opacity: 1,
-			position: "bottom",
-			alignment: "center",
-			shadow: true,
-			...options.defaultStyle
-		}
-
-		this.isEnabled = options.enabledByDefault ?? false
-
-		if (options.tracks) {
-			this.addTracks(options.tracks)
-
-			if (options.preloadTracks) {
-				this.preloadAllTracks()
-			}
-		}
-	}
-
-	/**
-	 * Add multiple subtitle tracks
-	 */
-	addTracks(tracks: SubtitleTrack[]): void {
-		tracks.forEach((track) => this.addTrack(track))
-	}
-
-	/**
-	 * Add a single subtitle track
-	 */
-	addTrack(track: SubtitleTrack): void {
-		const trackWithDefaults: SubtitleTrack = {
-			...track,
-			loadingState: "idle",
-			format: track.format || this.detectFormat(track.url)
-		}
-
-		this.tracks.set(track.id, trackWithDefaults)
-		this.emit("trackAdded", trackWithDefaults)
-
-		// Set as active if it's the default track and no track is currently active
-		if (track.isDefault && !this.activeTrackId) {
-			this.setActiveTrack(track.id)
-		}
-	}
-
-	/**
-	 * Remove a subtitle track
-	 */
-	removeTrack(trackId: string): void {
-		const track = this.tracks.get(trackId)
-		if (track) {
-			this.tracks.delete(trackId)
-
-			if (this.activeTrackId === trackId) {
-				this.activeTrackId = null
-				this.currentCues = []
-				this.emit("cuesChanged", [])
-			}
-
-			this.emit("trackRemoved", track)
-		}
-	}
-
-	/**
-	 * Get all available tracks
-	 */
-	getTracks(): SubtitleTrack[] {
-		return Array.from(this.tracks.values())
-	}
-
-	/**
-	 * Get a specific track by ID
-	 */
-	getTrack(trackId: string): SubtitleTrack | undefined {
-		return this.tracks.get(trackId)
-	}
-
-	/**
-	 * Set the active subtitle track
-	 */
-	async setActiveTrack(trackId: string | null): Promise<void> {
-		this.activeTrackId = trackId
-		this.currentCues = []
-
-		if (trackId) {
-			const track = this.tracks.get(trackId)
-			if (track && !track.parsedSubtitles && track.loadingState === "idle") {
-				await this.loadTrack(trackId)
-			}
-		}
-
-		this.emit("activeTrackChanged", trackId)
-		this.emit("cuesChanged", [])
-	}
-
-	/**
-	 * Get the currently active track
-	 */
-	getActiveTrack(): SubtitleTrack | null {
-		return this.activeTrackId ? this.tracks.get(this.activeTrackId) || null : null
-	}
-
-	/**
-	 * Enable or disable subtitles
-	 */
-	setEnabled(enabled: boolean): void {
-		this.isEnabled = enabled
-
-		if (!enabled) {
-			this.currentCues = []
-			this.emit("cuesChanged", [])
-		}
-
-		this.emit("enabledChanged", enabled)
-	}
-
-	/**
-	 * Check if subtitles are enabled
-	 */
-	isSubtitlesEnabled(): boolean {
-		return this.isEnabled
-	}
-
-	/**
-	 * Update subtitle styling
-	 */
-	updateStyle(newStyle: Partial<SubtitleStyle>): void {
-		this.style = { ...this.style, ...newStyle }
-		this.emit("styleChanged", this.style)
-	}
-
-	/**
-	 * Get current subtitle style
-	 */
-	getStyle(): SubtitleStyle {
-		return { ...this.style }
-	}
-
-	/**
-	 * Update current time and get active cues
-	 */
-	updateTime(currentTime: number): SubtitleCue[] {
-		if (!this.isEnabled || !this.activeTrackId) {
-			if (this.currentCues.length > 0) {
-				this.currentCues = []
-				this.emit("cuesChanged", [])
-			}
-			return []
-		}
-
-		const activeTrack = this.tracks.get(this.activeTrackId)
-		if (!activeTrack?.parsedSubtitles) {
-			if (this.currentCues.length > 0) {
-				this.currentCues = []
-				this.emit("cuesChanged", [])
-			}
-			return []
-		}
-
-		const activeCues = SubtitleParser.getActiveCues(activeTrack.parsedSubtitles.cues, currentTime)
-
-		// Check if cues have changed
-		const cuesChanged =
-			activeCues.length !== this.currentCues.length ||
-			activeCues.some(
-				(cue, index) => !this.currentCues[index] || cue.id !== this.currentCues[index].id
-			)
-
-		if (cuesChanged) {
-			this.currentCues = activeCues
-			this.emit("cuesChanged", activeCues)
-		}
-
-		return activeCues
-	}
-
-	/**
-	 * Get current active cues
-	 */
-	getCurrentCues(): SubtitleCue[] {
-		return [...this.currentCues]
-	}
-
-	/**
-	 * Load a subtitle track
-	 */
-	async loadTrack(trackId: string): Promise<void> {
-		const track = this.tracks.get(trackId)
-		if (!track || track.loadingState === "loading" || track.loadingState === "loaded") {
-			return
-		}
-
-		// Update loading state
-		track.loadingState = "loading"
-		this.emit("trackLoadingStateChanged", { trackId, state: "loading" })
-
-		try {
-			const response = await fetch(track.url)
-			if (!response.ok) {
-				throw new Error(`Failed to fetch subtitles: ${response.status} ${response.statusText}`)
-			}
-
-			const content = await response.text()
-			const format = track.format || SubtitleParser.detectFormat(content)
-
-			if (format === "unknown") {
-				throw new Error("Unsupported subtitle format")
-			}
-
-			const parsedSubtitles = SubtitleParser.parse(content, format)
-			track.parsedSubtitles = parsedSubtitles
-			track.loadingState = "loaded"
-			track.format = format
-
-			this.emit("trackLoadingStateChanged", { trackId, state: "loaded" })
-			this.emit("trackLoaded", track)
-		} catch (error) {
-			track.loadingState = "error"
-			track.error = error instanceof Error ? error.message : "Unknown error"
-
-			this.emit("trackLoadingStateChanged", { trackId, state: "error", error: track.error })
-			this.emit("trackError", { trackId, error: track.error })
-		}
-	}
-
-	/**
-	 * Preload all available tracks
-	 */
-	async preloadAllTracks(): Promise<void> {
-		const loadPromises = Array.from(this.tracks.keys()).map((trackId) => this.loadTrack(trackId))
-
-		await Promise.allSettled(loadPromises)
-	}
-
-	/**
-	 * Search for cues containing text
-	 */
-	searchCues(query: string, trackId?: string): Array<{ trackId: string; cue: SubtitleCue }> {
-		const results: Array<{ trackId: string; cue: SubtitleCue }> = []
-		const searchTracks = trackId ? [trackId] : Array.from(this.tracks.keys())
-
-		for (const id of searchTracks) {
-			const track = this.tracks.get(id)
-			if (!track?.parsedSubtitles) continue
-
-			for (const cue of track.parsedSubtitles.cues) {
-				const cleanText = SubtitleParser.cleanText(cue.text).toLowerCase()
-				if (cleanText.includes(query.toLowerCase())) {
-					results.push({ trackId: id, cue })
-				}
-			}
-		}
-
-		return results
-	}
-
-	/**
-	 * Export subtitles in a specific format
-	 */
-	exportSubtitles(trackId: string, format: "vtt" | "srt"): string | null {
-		const track = this.tracks.get(trackId)
-		if (!track?.parsedSubtitles) return null
-
-		const { cues, metadata } = track.parsedSubtitles
-
-		if (format === "vtt") {
-			return this.exportAsVTT(cues, metadata)
-		} else {
-			return this.exportAsSRT(cues)
-		}
-	}
-
-	/**
-	 * Event system methods
-	 */
-	on(event: string, callback: Function): () => void {
-		if (!this.eventListeners.has(event)) {
-			this.eventListeners.set(event, new Set())
-		}
-
-		this.eventListeners.get(event)!.add(callback)
-
-		return () => {
-			const listeners = this.eventListeners.get(event)
-			if (listeners) {
-				listeners.delete(callback)
-			}
-		}
-	}
-
-	private emit(event: string, data?: any): void {
-		const listeners = this.eventListeners.get(event)
-		if (listeners) {
-			listeners.forEach((callback) => callback(data))
-		}
-	}
-
-	/**
-	 * Detect subtitle format from URL extension
-	 */
-	private detectFormat(url: string): "vtt" | "srt" {
-		const extension = url.split(".").pop()?.toLowerCase()
-		return extension === "srt" ? "srt" : "vtt"
-	}
-
-	/**
-	 * Export cues as WebVTT format
-	 */
-	private exportAsVTT(cues: SubtitleCue[], metadata?: any): string {
-		let output = "WEBVTT\n\n"
-
-		if (metadata) {
-			Object.entries(metadata).forEach(([key, value]) => {
-				output += `${key}: ${value}\n`
-			})
-			output += "\n"
-		}
-
-		cues.forEach((cue, index) => {
-			if (cue.id) {
-				output += `${cue.id}\n`
-			}
-
-			const startTime = this.formatTime(cue.startTime, "vtt")
-			const endTime = this.formatTime(cue.endTime, "vtt")
-
-			output += `${startTime} --> ${endTime}`
-
-			if (cue.settings) {
-				const settings: string[] = []
-				Object.entries(cue.settings).forEach(([key, value]) => {
-					settings.push(`${key}:${value}`)
-				})
-				if (settings.length > 0) {
-					output += ` ${settings.join(" ")}`
-				}
-			}
-
-			output += `\n${cue.text}\n\n`
-		})
-
-		return output
-	}
-
-	/**
-	 * Export cues as SRT format
-	 */
-	private exportAsSRT(cues: SubtitleCue[]): string {
-		let output = ""
-
-		cues.forEach((cue, index) => {
-			const startTime = this.formatTime(cue.startTime, "srt")
-			const endTime = this.formatTime(cue.endTime, "srt")
-
-			output += `${index + 1}\n`
-			output += `${startTime} --> ${endTime}\n`
-			output += `${cue.text}\n\n`
-		})
-
-		return output
-	}
-
-	/**
-	 * Format time for different subtitle formats
-	 */
-	private formatTime(seconds: number, format: "vtt" | "srt"): string {
-		const hours = Math.floor(seconds / 3600)
-		const minutes = Math.floor((seconds % 3600) / 60)
-		const secs = Math.floor(seconds % 60)
-		const milliseconds = Math.floor((seconds % 1) * 1000)
-
-		const separator = format === "srt" ? "," : "."
-
-		return `${hours.toString().padStart(2, "0")}:${minutes.toString().padStart(2, "0")}:${secs.toString().padStart(2, "0")}${separator}${milliseconds.toString().padStart(3, "0")}`
-	}
-
-	/**
-	 * Cleanup resources
-	 */
-	destroy(): void {
-		this.tracks.clear()
-		this.eventListeners.clear()
-		this.activeTrackId = null
-		this.currentCues = []
-	}
-}

package/src/features/subtitles/subtitle-parser.ts

@@ -1,284 +0,0 @@
-export interface SubtitleCue {
-	id?: string
-	startTime: number
-	endTime: number
-	text: string
-	settings?: {
-		line?: number | "auto"
-		position?: number
-		size?: number
-		align?: "start" | "center" | "end"
-		vertical?: "rl" | "lr"
-	}
-}
-
-export interface ParsedSubtitles {
-	cues: SubtitleCue[]
-	metadata?: {
-		title?: string
-		language?: string
-		description?: string
-	}
-}
-
-export class SubtitleParser {
-	/**
-	 * Parse subtitle content based on format
-	 */
-	static parse(content: string, format: "vtt" | "srt"): ParsedSubtitles {
-		switch (format) {
-			case "vtt":
-				return this.parseVTT(content)
-			case "srt":
-				return this.parseSRT(content)
-			default:
-				throw new Error(`Unsupported subtitle format: ${format}`)
-		}
-	}
-
-	/**
-	 * Auto-detect subtitle format from content
-	 */
-	static detectFormat(content: string): "vtt" | "srt" | "unknown" {
-		const trimmedContent = content.trim()
-
-		if (trimmedContent.startsWith("WEBVTT")) {
-			return "vtt"
-		}
-
-		// Check for SRT pattern (number, timestamp, text)
-		const srtPattern = /^\d+\s*\n\d{2}:\d{2}:\d{2},\d{3}\s*-->\s*\d{2}:\d{2}:\d{2},\d{3}/m
-		if (srtPattern.test(trimmedContent)) {
-			return "srt"
-		}
-
-		return "unknown"
-	}
-
-	/**
-	 * Parse WebVTT format
-	 */
-	private static parseVTT(content: string): ParsedSubtitles {
-		const lines = content.split("\n")
-		const cues: SubtitleCue[] = []
-		const metadata: any = {}
-
-		let i = 0
-
-		// Skip WEBVTT header and metadata
-		if (lines[0]?.startsWith("WEBVTT")) {
-			i = 1
-			// Parse metadata in header
-			while (i < lines.length && lines[i]?.trim() !== "") {
-				const line = lines[i]?.trim() || ""
-				if (line.includes(":")) {
-					const [key, value] = line.split(":").map((s) => s.trim())
-					if (key && value) {
-						metadata[key.toLowerCase()] = value
-					}
-				}
-				i++
-			}
-		}
-
-		// Parse cues
-		while (i < lines.length) {
-			// Skip empty lines
-			if (!lines[i]?.trim()) {
-				i++
-				continue
-			}
-
-			let cueId: string | undefined
-			let timingLine: string
-
-			// Check if this line is a timing line or cue identifier
-			const isTimingLine = lines[i]?.includes("-->")
-			if (isTimingLine) {
-				timingLine = lines[i] || ""
-				i++
-			} else {
-				// This is a cue identifier
-				cueId = lines[i]?.trim()
-				i++
-				timingLine = lines[i] || ""
-				i++
-			}
-
-			// Parse timing line
-			const timing = this.parseVTTTiming(timingLine)
-			if (!timing) {
-				i++
-				continue
-			}
-
-			// Collect cue text
-			const textLines: string[] = []
-			while (i < lines.length && lines[i]?.trim() !== "") {
-				const line = lines[i]
-				if (line) textLines.push(line)
-				i++
-			}
-
-			if (textLines.length > 0) {
-				cues.push({
-					id: cueId,
-					startTime: timing.start,
-					endTime: timing.end,
-					text: textLines.join("\n"),
-					settings: timing.settings
-				})
-			}
-
-			i++
-		}
-
-		return { cues, metadata }
-	}
-
-	/**
-	 * Parse SRT format
-	 */
-	private static parseSRT(content: string): ParsedSubtitles {
-		const cues: SubtitleCue[] = []
-		const blocks = content.split(/\n\s*\n/).filter((block) => block.trim())
-
-		for (const block of blocks) {
-			const lines = block
-				.split("\n")
-				.map((line) => line.trim())
-				.filter((line) => line)
-			if (lines.length < 3) continue
-
-			const id = lines[0]
-			const timingLine = lines[1] || ""
-			const textLines = lines.slice(2)
-
-			const timing = this.parseSRTTiming(timingLine)
-			if (!timing) continue
-
-			cues.push({
-				id,
-				startTime: timing.start,
-				endTime: timing.end,
-				text: textLines.join("\n")
-			})
-		}
-
-		return { cues }
-	}
-
-	/**
-	 * Parse VTT timing line with settings
-	 */
-	private static parseVTTTiming(timingLine: string): {
-		start: number
-		end: number
-		settings?: SubtitleCue["settings"]
-	} | null {
-		const parts = timingLine.split(/\s+/)
-		const arrowIndex = parts.findIndex((part) => part === "-->")
-
-		if (arrowIndex === -1 || arrowIndex === 0 || arrowIndex === parts.length - 1) {
-			return null
-		}
-
-		const startTime = this.parseTimeString(parts[arrowIndex - 1] || "")
-		const endTime = this.parseTimeString(parts[arrowIndex + 1] || "")
-
-		if (startTime === null || endTime === null) {
-			return null
-		}
-
-		// Parse cue settings
-		const settings: SubtitleCue["settings"] = {}
-		const settingsParts = parts.slice(arrowIndex + 2)
-
-		for (const setting of settingsParts) {
-			const [key, value] = setting.split(":")
-			if (!key || !value) continue
-
-			switch (key) {
-				case "line":
-					settings.line = value === "auto" ? "auto" : parseInt(value)
-					break
-				case "position":
-					settings.position = parseInt(value)
-					break
-				case "size":
-					settings.size = parseInt(value)
-					break
-				case "align":
-					if (["start", "center", "end"].includes(value)) {
-						settings.align = value as "start" | "center" | "end"
-					}
-					break
-				case "vertical":
-					if (["rl", "lr"].includes(value)) {
-						settings.vertical = value as "rl" | "lr"
-					}
-					break
-			}
-		}
-
-		return {
-			start: startTime,
-			end: endTime,
-			settings: Object.keys(settings).length > 0 ? settings : undefined
-		}
-	}
-
-	/**
-	 * Parse SRT timing line
-	 */
-	private static parseSRTTiming(timingLine: string): {
-		start: number
-		end: number
-	} | null {
-		const match = timingLine.match(/(\d{2}:\d{2}:\d{2},\d{3})\s*-->\s*(\d{2}:\d{2}:\d{2},\d{3})/)
-		if (!match) return null
-
-		const startTime = this.parseTimeString(match[1]?.replace(",", ".") || "")
-		const endTime = this.parseTimeString(match[2]?.replace(",", ".") || "")
-
-		if (startTime === null || endTime === null) return null
-
-		return { start: startTime, end: endTime }
-	}
-
-	/**
-	 * Parse time string to seconds
-	 */
-	private static parseTimeString(timeStr: string): number | null {
-		const match = timeStr.match(/(\d{2}):(\d{2}):(\d{2})\.(\d{3})/)
-		if (!match) return null
-
-		const hours = parseInt(match[1] || "0", 10)
-		const minutes = parseInt(match[2] || "0", 10)
-		const seconds = parseInt(match[3] || "0", 10)
-		const milliseconds = parseInt(match[4] || "0", 10)
-
-		return hours * 3600 + minutes * 60 + seconds + milliseconds / 1000
-	}
-
-	/**
-	 * Find active cues at a given time
-	 */
-	static getActiveCues(cues: SubtitleCue[], currentTime: number): SubtitleCue[] {
-		return cues.filter((cue) => currentTime >= cue.startTime && currentTime <= cue.endTime)
-	}
-
-	/**
-	 * Clean subtitle text (remove HTML tags, etc.)
-	 */
-	static cleanText(text: string): string {
-		return text
-			.replace(/<[^>]*>/g, "") // Remove HTML tags
-			.replace(/&lt;/g, "<")
-			.replace(/&gt;/g, ">")
-			.replace(/&amp;/g, "&")
-			.replace(/&quot;/g, '"')
-			.replace(/&#39;/g, "'")
-			.trim()
-	}
-}