@therealtinhtute/baroiplayer 1.0.0 → 1.0.1

package/dist/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/dist/src/features/subtitles/subtitle-parser.d.ts

@@ -0,0 +1,60 @@
+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 declare class SubtitleParser {
+    /**
+     * Parse subtitle content based on format
+     */
+    static parse(content: string, format: 'vtt' | 'srt'): ParsedSubtitles;
+    /**
+     * Auto-detect subtitle format from content
+     */
+    static detectFormat(content: string): 'vtt' | 'srt' | 'unknown';
+    /**
+     * Parse WebVTT format
+     */
+    private static parseVTT;
+    /**
+     * Parse SRT format
+     */
+    private static parseSRT;
+    /**
+     * Parse VTT timing line with settings
+     */
+    private static parseVTTTiming;
+    /**
+     * Parse SRT timing line
+     */
+    private static parseSRTTiming;
+    /**
+     * Parse time string to seconds
+     */
+    private static parseTimeString;
+    /**
+     * Find active cues at a given time
+     */
+    static getActiveCues(cues: SubtitleCue[], currentTime: number): SubtitleCue[];
+    /**
+     * Clean subtitle text (remove HTML tags, etc.)
+     */
+    static cleanText(text: string): string;
+}
+//# sourceMappingURL=subtitle-parser.d.ts.map

package/dist/src/features/subtitles/subtitle-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subtitle-parser.d.ts","sourceRoot":"","sources":["subtitle-parser.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,WAAW;IAC1B,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,CAAC,EAAE;QACT,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;QACtB,QAAQ,CAAC,EAAE,MAAM,CAAA;QACjB,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,KAAK,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,KAAK,CAAA;QAClC,QAAQ,CAAC,EAAE,IAAI,GAAG,IAAI,CAAA;KACvB,CAAA;CACF;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,WAAW,EAAE,CAAA;IACnB,QAAQ,CAAC,EAAE;QACT,KAAK,CAAC,EAAE,MAAM,CAAA;QACd,QAAQ,CAAC,EAAE,MAAM,CAAA;QACjB,WAAW,CAAC,EAAE,MAAM,CAAA;KACrB,CAAA;CACF;AAED,qBAAa,cAAc;IACzB;;OAEG;IACH,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,GAAG,KAAK,GAAG,eAAe;IAWrE;;OAEG;IACH,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,GAAG,KAAK,GAAG,SAAS;IAgB/D;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ;IA2EvB;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ;IA0BvB;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,cAAc;IAyD7B;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,cAAc;IAe7B;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,eAAe;IAY9B;;OAEG;IACH,MAAM,CAAC,aAAa,CAAC,IAAI,EAAE,WAAW,EAAE,EAAE,WAAW,EAAE,MAAM,GAAG,WAAW,EAAE;IAM7E;;OAEG;IACH,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;CAUvC"}