@therealtinhtute/baroiplayer 1.0.0 → 1.0.1

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

@@ -0,0 +1,136 @@
+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.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subtitle-manager.d.ts","sourceRoot":"","sources":["subtitle-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,WAAW,EAAE,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAE1F,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAA;IACV,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,MAAM,CAAC,EAAE,KAAK,GAAG,KAAK,CAAA;IACtB,eAAe,CAAC,EAAE,eAAe,CAAA;IACjC,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,QAAQ,GAAG,OAAO,CAAA;IACtD,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,QAAQ,CAAA;IACtC,SAAS,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAA;IACvC,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB;AAED,MAAM,WAAW,sBAAsB;IACrC,MAAM,CAAC,EAAE,aAAa,EAAE,CAAA;IACxB,YAAY,CAAC,EAAE,aAAa,CAAA;IAC5B,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB;AAED,qBAAa,eAAe;IAC1B,OAAO,CAAC,MAAM,CAAwC;IACtD,OAAO,CAAC,aAAa,CAAsB;IAC3C,OAAO,CAAC,WAAW,CAAoB;IACvC,OAAO,CAAC,SAAS,CAAiB;IAClC,OAAO,CAAC,KAAK,CAAe;IAC5B,OAAO,CAAC,cAAc,CAAwC;gBAElD,OAAO,GAAE,sBAA2B;IA0BhD;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,IAAI;IAIxC;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI;IAgBpC;;OAEG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAelC;;OAEG;IACH,SAAS,IAAI,aAAa,EAAE;IAI5B;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAIpD;;OAEG;IACG,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAe3D;;OAEG;IACH,cAAc,IAAI,aAAa,GAAG,IAAI;IAItC;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAWlC;;OAEG;IACH,kBAAkB,IAAI,OAAO;IAI7B;;OAEG;IACH,WAAW,CAAC,QAAQ,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG,IAAI;IAKnD;;OAEG;IACH,QAAQ,IAAI,aAAa;IAIzB;;OAEG;IACH,UAAU,CAAC,WAAW,EAAE,MAAM,GAAG,WAAW,EAAE;IAsC9C;;OAEG;IACH,cAAc,IAAI,WAAW,EAAE;IAI/B;;OAEG;IACG,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAwC/C;;OAEG;IACG,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAQvC;;OAEG;IACH,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,WAAW,CAAA;KAAE,CAAC;IAmBzF;;OAEG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,IAAI;IAatE;;OAEG;IACH,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,MAAM,IAAI;IAejD,OAAO,CAAC,IAAI;IAOZ;;OAEG;IACH,OAAO,CAAC,YAAY;IAKpB;;OAEG;IACH,OAAO,CAAC,WAAW;IAoCnB;;OAEG;IACH,OAAO,CAAC,WAAW;IAenB;;OAEG;IACH,OAAO,CAAC,UAAU;IAWlB;;OAEG;IACH,OAAO,IAAI,IAAI;CAMhB"}

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

@@ -0,0 +1,335 @@
+import { SubtitleParser } from './subtitle-parser';
+export class SubtitleManager {
+    tracks = new Map();
+    activeTrackId = null;
+    currentCues = [];
+    isEnabled = false;
+    style;
+    eventListeners = new Map();
+    constructor(options = {}) {
+        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) {
+        tracks.forEach(track => this.addTrack(track));
+    }
+    /**
+     * Add a single subtitle track
+     */
+    addTrack(track) {
+        const trackWithDefaults = {
+            ...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) {
+        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() {
+        return Array.from(this.tracks.values());
+    }
+    /**
+     * Get a specific track by ID
+     */
+    getTrack(trackId) {
+        return this.tracks.get(trackId);
+    }
+    /**
+     * Set the active subtitle track
+     */
+    async setActiveTrack(trackId) {
+        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() {
+        return this.activeTrackId ? this.tracks.get(this.activeTrackId) || null : null;
+    }
+    /**
+     * Enable or disable subtitles
+     */
+    setEnabled(enabled) {
+        this.isEnabled = enabled;
+        if (!enabled) {
+            this.currentCues = [];
+            this.emit('cuesChanged', []);
+        }
+        this.emit('enabledChanged', enabled);
+    }
+    /**
+     * Check if subtitles are enabled
+     */
+    isSubtitlesEnabled() {
+        return this.isEnabled;
+    }
+    /**
+     * Update subtitle styling
+     */
+    updateStyle(newStyle) {
+        this.style = { ...this.style, ...newStyle };
+        this.emit('styleChanged', this.style);
+    }
+    /**
+     * Get current subtitle style
+     */
+    getStyle() {
+        return { ...this.style };
+    }
+    /**
+     * Update current time and get active cues
+     */
+    updateTime(currentTime) {
+        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() {
+        return [...this.currentCues];
+    }
+    /**
+     * Load a subtitle track
+     */
+    async loadTrack(trackId) {
+        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() {
+        const loadPromises = Array.from(this.tracks.keys()).map(trackId => this.loadTrack(trackId));
+        await Promise.allSettled(loadPromises);
+    }
+    /**
+     * Search for cues containing text
+     */
+    searchCues(query, trackId) {
+        const results = [];
+        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, format) {
+        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, callback) {
+        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);
+            }
+        };
+    }
+    emit(event, data) {
+        const listeners = this.eventListeners.get(event);
+        if (listeners) {
+            listeners.forEach(callback => callback(data));
+        }
+    }
+    /**
+     * Detect subtitle format from URL extension
+     */
+    detectFormat(url) {
+        const extension = url.split('.').pop()?.toLowerCase();
+        return extension === 'srt' ? 'srt' : 'vtt';
+    }
+    /**
+     * Export cues as WebVTT format
+     */
+    exportAsVTT(cues, metadata) {
+        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
+     */
+    exportAsSRT(cues) {
+        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
+     */
+    formatTime(seconds, format) {
+        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() {
+        this.tracks.clear();
+        this.eventListeners.clear();
+        this.activeTrackId = null;
+        this.currentCues = [];
+    }
+}