@helios-project/player 0.48.3

package/dist/features/text-tracks.d.ts

@@ -0,0 +1,40 @@
+export type TextTrackMode = 'disabled' | 'hidden' | 'showing';
+export interface TrackHost {
+    handleTrackModeChange(track: HeliosTextTrack): void;
+}
+export declare class HeliosCue {
+    startTime: number;
+    endTime: number;
+    text: string;
+    constructor(startTime: number, endTime: number, text: string);
+}
+export declare const CueClass: any;
+export declare class HeliosTextTrack extends EventTarget {
+    private _mode;
+    private _cues;
+    private _kind;
+    private _label;
+    private _language;
+    private _id;
+    private _host;
+    constructor(kind: string, label: string, language: string, host: TrackHost);
+    get kind(): string;
+    get label(): string;
+    get language(): string;
+    get id(): string;
+    get cues(): any[];
+    get mode(): TextTrackMode;
+    set mode(value: TextTrackMode);
+    addCue(cue: any): void;
+    removeCue(cue: any): void;
+}
+export declare class HeliosTextTrackList extends EventTarget implements Iterable<HeliosTextTrack> {
+    private tracks;
+    get length(): number;
+    [index: number]: HeliosTextTrack;
+    [Symbol.iterator](): Iterator<HeliosTextTrack>;
+    addTrack(track: HeliosTextTrack): void;
+    getTrackById(id: string): HeliosTextTrack | null;
+    removeTrack(track: HeliosTextTrack): void;
+    set onaddtrack(handler: ((event: any) => void) | null);
+}

package/dist/features/text-tracks.js

@@ -0,0 +1,99 @@
+// Shim for VTTCue if not present (e.g. JSDOM, older browsers)
+const GlobalVTTCue = (typeof window !== 'undefined' && window.VTTCue) || null;
+export class HeliosCue {
+    startTime;
+    endTime;
+    text;
+    constructor(startTime, endTime, text) {
+        this.startTime = startTime;
+        this.endTime = endTime;
+        this.text = text;
+    }
+}
+export const CueClass = GlobalVTTCue || HeliosCue;
+export class HeliosTextTrack extends EventTarget {
+    _mode = 'disabled';
+    _cues = [];
+    _kind;
+    _label;
+    _language;
+    _id;
+    _host;
+    constructor(kind, label, language, host) {
+        super();
+        this._kind = kind;
+        this._label = label;
+        this._language = language;
+        this._id = Math.random().toString(36).substring(2) + Date.now().toString(36);
+        this._host = host;
+    }
+    get kind() { return this._kind; }
+    get label() { return this._label; }
+    get language() { return this._language; }
+    get id() { return this._id; }
+    get cues() { return this._cues; }
+    get mode() {
+        return this._mode;
+    }
+    set mode(value) {
+        if (this._mode !== value) {
+            this._mode = value;
+            this._host.handleTrackModeChange(this);
+        }
+    }
+    addCue(cue) {
+        this._cues.push(cue);
+        this._cues.sort((a, b) => a.startTime - b.startTime);
+        // If we are showing, we need to update the host (controller) immediately with new cues
+        if (this._mode === 'showing') {
+            this._host.handleTrackModeChange(this);
+        }
+    }
+    removeCue(cue) {
+        const idx = this._cues.indexOf(cue);
+        if (idx !== -1) {
+            this._cues.splice(idx, 1);
+            if (this._mode === 'showing') {
+                this._host.handleTrackModeChange(this);
+            }
+        }
+    }
+}
+export class HeliosTextTrackList extends EventTarget {
+    tracks = [];
+    get length() { return this.tracks.length; }
+    [Symbol.iterator]() {
+        return this.tracks[Symbol.iterator]();
+    }
+    addTrack(track) {
+        this.tracks.push(track);
+        // Enable array-like access
+        this[this.tracks.length - 1] = track;
+        const event = new Event('addtrack');
+        event.track = track;
+        this.dispatchEvent(event);
+    }
+    getTrackById(id) {
+        return this.tracks.find(t => t.id === id) || null;
+    }
+    removeTrack(track) {
+        const index = this.tracks.indexOf(track);
+        if (index !== -1) {
+            this.tracks.splice(index, 1);
+            // Re-index properties
+            for (let i = index; i < this.tracks.length; i++) {
+                this[i] = this.tracks[i];
+            }
+            delete this[this.tracks.length];
+            const event = new Event('removetrack');
+            event.track = track;
+            this.dispatchEvent(event);
+        }
+    }
+    // Stub for standard event handler property
+    set onaddtrack(handler) {
+        if (handler) {
+            this.addEventListener('addtrack', handler);
+        }
+    }
+}