@therealtinhtute/baroiplayer 1.0.7 → 1.1.0

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

@@ -1,136 +0,0 @@
-import { 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 declare class SubtitleManager {
-    private tracks;
-    private activeTrackId;
-    private currentCues;
-    private isEnabled;
-    private style;
-    private eventListeners;
-    constructor(options?: SubtitleManagerOptions);
-    /**
-     * Add multiple subtitle tracks
-     */
-    addTracks(tracks: SubtitleTrack[]): void;
-    /**
-     * Add a single subtitle track
-     */
-    addTrack(track: SubtitleTrack): void;
-    /**
-     * Remove a subtitle track
-     */
-    removeTrack(trackId: string): void;
-    /**
-     * Get all available tracks
-     */
-    getTracks(): SubtitleTrack[];
-    /**
-     * Get a specific track by ID
-     */
-    getTrack(trackId: string): SubtitleTrack | undefined;
-    /**
-     * Set the active subtitle track
-     */
-    setActiveTrack(trackId: string | null): Promise<void>;
-    /**
-     * Get the currently active track
-     */
-    getActiveTrack(): SubtitleTrack | null;
-    /**
-     * Enable or disable subtitles
-     */
-    setEnabled(enabled: boolean): void;
-    /**
-     * Check if subtitles are enabled
-     */
-    isSubtitlesEnabled(): boolean;
-    /**
-     * Update subtitle styling
-     */
-    updateStyle(newStyle: Partial<SubtitleStyle>): void;
-    /**
-     * Get current subtitle style
-     */
-    getStyle(): SubtitleStyle;
-    /**
-     * Update current time and get active cues
-     */
-    updateTime(currentTime: number): SubtitleCue[];
-    /**
-     * Get current active cues
-     */
-    getCurrentCues(): SubtitleCue[];
-    /**
-     * Load a subtitle track
-     */
-    loadTrack(trackId: string): Promise<void>;
-    /**
-     * Preload all available tracks
-     */
-    preloadAllTracks(): Promise<void>;
-    /**
-     * Search for cues containing text
-     */
-    searchCues(query: string, trackId?: string): Array<{
-        trackId: string;
-        cue: SubtitleCue;
-    }>;
-    /**
-     * Export subtitles in a specific format
-     */
-    exportSubtitles(trackId: string, format: 'vtt' | 'srt'): string | null;
-    /**
-     * Event system methods
-     */
-    on(event: string, callback: Function): () => void;
-    private emit;
-    /**
-     * Detect subtitle format from URL extension
-     */
-    private detectFormat;
-    /**
-     * Export cues as WebVTT format
-     */
-    private exportAsVTT;
-    /**
-     * Export cues as SRT format
-     */
-    private exportAsSRT;
-    /**
-     * Format time for different subtitle formats
-     */
-    private formatTime;
-    /**
-     * Cleanup resources
-     */
-    destroy(): void;
-}
-//# sourceMappingURL=subtitle-manager.d.ts.map

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

@@ -1,441 +0,0 @@
-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

@@ -1,60 +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 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