@therealtinhtute/baroiplayer 1.0.0

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

@@ -0,0 +1,441 @@
+import { SubtitleParser, type SubtitleCue, type ParsedSubtitles } 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 = []
+        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

@@ -0,0 +1,280 @@
+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())
+          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()
+  }
+}