@therealtinhtute/baroiplayer 1.0.0 → 1.0.1

package/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 = [];
+    }
+}

package/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/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"}

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

@@ -0,0 +1,217 @@
+export class SubtitleParser {
+    /**
+     * Parse subtitle content based on format
+     */
+    static parse(content, format) {
+        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) {
+        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
+     */
+    static parseVTT(content) {
+        const lines = content.split('\n');
+        const cues = [];
+        const metadata = {};
+        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;
+            let timingLine;
+            // 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 = [];
+            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
+     */
+    static parseSRT(content) {
+        const cues = [];
+        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
+     */
+    static parseVTTTiming(timingLine) {
+        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 = {};
+        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;
+                    }
+                    break;
+                case 'vertical':
+                    if (['rl', 'lr'].includes(value)) {
+                        settings.vertical = value;
+                    }
+                    break;
+            }
+        }
+        return {
+            start: startTime,
+            end: endTime,
+            settings: Object.keys(settings).length > 0 ? settings : undefined
+        };
+    }
+    /**
+     * Parse SRT timing line
+     */
+    static parseSRTTiming(timingLine) {
+        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
+     */
+    static parseTimeString(timeStr) {
+        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, currentTime) {
+        return cues.filter(cue => currentTime >= cue.startTime && currentTime <= cue.endTime);
+    }
+    /**
+     * Clean subtitle text (remove HTML tags, etc.)
+     */
+    static cleanText(text) {
+        return text
+            .replace(/<[^>]*>/g, '') // Remove HTML tags
+            .replace(/&lt;/g, '<')
+            .replace(/&gt;/g, '>')
+            .replace(/&amp;/g, '&')
+            .replace(/&quot;/g, '"')
+            .replace(/&#39;/g, "'")
+            .trim();
+    }
+}