@therealtinhtute/baroiplayer 1.0.8 → 1.1.0

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

@@ -1,280 +1,281 @@
 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'
-  }
+	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
-  }
+	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())
-          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() !== '') {
-        textLines.push(lines[i])
-        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])
-    const minutes = parseInt(match[2])
-    const seconds = parseInt(match[3])
-    const milliseconds = parseInt(match[4])
-    
-    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()
-  }
-}
+	/**
+	 * 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())
+					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() !== "") {
+				textLines.push(lines[i])
+				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])
+		const minutes = parseInt(match[2])
+		const seconds = parseInt(match[3])
+		const milliseconds = parseInt(match[4])
+
+		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()
+	}
+}