@amazon/vinyl 1.2.0 → 1.2.2

package/dist/unit/types/current/text/discoverDashTextTracks.test.js

@@ -0,0 +1,216 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { discoverDashTextTracks } from '@amazon/vinyl';
+import { parseDashManifest } from '@amazon/vinyl-mpd-parser';
+describe('discoverDashTextTracks', () => {
+    const baseUrl = 'https://example.com/dash/';
+    function manifest(adaptationSets) {
+        const xml = `<?xml version="1.0" encoding="UTF-8"?>
+<MPD xmlns="urn:mpeg:dash:schema:mpd:2011" type="static" profiles="urn:mpeg:dash:profile:isoff-on-demand:2011" mediaPresentationDuration="PT60S" minBufferTime="PT2S">
+  <Period>
+    ${adaptationSets}
+  </Period>
+</MPD>`;
+        return parseDashManifest(xml);
+    }
+    it('discovers a text AdaptationSet by contentType', () => {
+        const m = manifest(`
+            <AdaptationSet contentType="text" lang="en" mimeType="text/vtt">
+              <Representation id="en-sub" bandwidth="100">
+                <BaseURL>subs/en.vtt</BaseURL>
+              </Representation>
+            </AdaptationSet>`);
+        const result = discoverDashTextTracks(m, baseUrl);
+        expect(result.length).toBe(1);
+        expect(result[0]).toEqual(jasmine.objectContaining({
+            kind: 'subtitles',
+            language: 'en',
+            uri: 'https://example.com/dash/subs/en.vtt',
+            mimeType: 'text/vtt',
+        }));
+    });
+    it('discovers a text AdaptationSet by mimeType when contentType is absent', () => {
+        const m = manifest(`
+            <AdaptationSet mimeType="text/vtt" lang="es">
+              <Representation id="es-sub" bandwidth="100">
+                <BaseURL>es.vtt</BaseURL>
+              </Representation>
+            </AdaptationSet>`);
+        const result = discoverDashTextTracks(m, baseUrl);
+        expect(result.length).toBe(1);
+        expect(result[0].language).toBe('es');
+    });
+    it('discovers a text AdaptationSet by its Representation mimeType', () => {
+        // DASH allows @mimeType on the Representation instead of the set.
+        const m = manifest(`
+            <AdaptationSet lang="fr">
+              <Representation id="fr-sub" mimeType="text/vtt" bandwidth="100">
+                <BaseURL>fr.vtt</BaseURL>
+              </Representation>
+            </AdaptationSet>`);
+        const result = discoverDashTextTracks(m, baseUrl);
+        expect(result.length).toBe(1);
+        expect(result[0].language).toBe('fr');
+        expect(result[0].uri).toBe('https://example.com/dash/fr.vtt');
+    });
+    it('classifies kind=captions when role=caption is set', () => {
+        const m = manifest(`
+            <AdaptationSet contentType="text" lang="en" mimeType="text/vtt">
+              <Role schemeIdUri="urn:mpeg:dash:role:2011" value="caption"/>
+              <Representation id="en-cap" bandwidth="100">
+                <BaseURL>cc.vtt</BaseURL>
+              </Representation>
+            </AdaptationSet>`);
+        const result = discoverDashTextTracks(m, baseUrl);
+        expect(result[0].kind).toBe('captions');
+    });
+    it('marks default when role=main is set', () => {
+        const m = manifest(`
+            <AdaptationSet contentType="text" lang="en" mimeType="text/vtt">
+              <Role schemeIdUri="urn:mpeg:dash:role:2011" value="main"/>
+              <Representation id="r" bandwidth="100">
+                <BaseURL>main.vtt</BaseURL>
+              </Representation>
+            </AdaptationSet>`);
+        const result = discoverDashTextTracks(m, baseUrl);
+        expect(result[0].default).toBeTrue();
+    });
+    it('marks forced when role=forced_subtitle is set', () => {
+        const m = manifest(`
+            <AdaptationSet contentType="text" lang="en" mimeType="text/vtt">
+              <Role schemeIdUri="urn:mpeg:dash:role:2011" value="forced_subtitle"/>
+              <Representation id="r" bandwidth="100">
+                <BaseURL>f.vtt</BaseURL>
+              </Representation>
+            </AdaptationSet>`);
+        const result = discoverDashTextTracks(m, baseUrl);
+        expect(result[0].forced).toBeTrue();
+        expect(result[0].characteristics).toEqual(['forced_subtitle']);
+    });
+    it('surfaces role and accessibility values as characteristics', () => {
+        const m = manifest(`
+            <AdaptationSet contentType="text" lang="en" mimeType="text/vtt">
+              <Role schemeIdUri="urn:mpeg:dash:role:2011" value="caption"/>
+              <Accessibility schemeIdUri="urn:tva:metadata:cs:AudioPurposeCS:2007" value="2"/>
+              <Representation id="r" bandwidth="100">
+                <BaseURL>c.vtt</BaseURL>
+              </Representation>
+            </AdaptationSet>`);
+        const result = discoverDashTextTracks(m, baseUrl);
+        expect(result[0].forced).toBeFalse();
+        expect(result[0].characteristics).toEqual(['caption', '2']);
+    });
+    it('skips AdaptationSets that are not text', () => {
+        const m = manifest(`
+            <AdaptationSet contentType="audio" mimeType="audio/mp4">
+              <Representation id="a" bandwidth="48000"/>
+            </AdaptationSet>`);
+        expect(discoverDashTextTracks(m, baseUrl)).toEqual([]);
+    });
+    it('skips a non-text AdaptationSet with no Representation', () => {
+        const m = manifest(`<AdaptationSet contentType="audio"/>`);
+        expect(discoverDashTextTracks(m, baseUrl)).toEqual([]);
+    });
+    it('skips text AdaptationSets carrying segmented codecs (stpp/wvtt)', () => {
+        const m = manifest(`
+            <AdaptationSet contentType="text" mimeType="application/mp4" codecs="stpp">
+              <Representation id="r" bandwidth="100">
+                <BaseURL>stpp.mp4</BaseURL>
+              </Representation>
+            </AdaptationSet>`);
+        expect(discoverDashTextTracks(m, baseUrl)).toEqual([]);
+    });
+    it('falls back to representation id when no BaseURL is set on representation', () => {
+        const m = manifest(`
+            <AdaptationSet contentType="text" mimeType="text/vtt" lang="fr">
+              <BaseURL>subs/</BaseURL>
+              <Representation id="fr-sub" bandwidth="100"/>
+            </AdaptationSet>`);
+        const result = discoverDashTextTracks(m, baseUrl);
+        expect(result.length).toBe(1);
+        expect(result[0].uri).toBe('https://example.com/dash/subs/fr-sub.vtt');
+    });
+    it('uses manifest path when AdaptationSet has no BaseURL', () => {
+        const noTrailingSlashBase = 'https://example.com/manifest.mpd';
+        const m = manifest(`
+            <AdaptationSet contentType="text" mimeType="text/vtt" lang="fr">
+              <Representation id="r" bandwidth="100"/>
+            </AdaptationSet>`);
+        // Without any BaseURL, the manifest URL is used as the base; since it
+        // doesn't end with a slash, the discoverer falls back to that path
+        // verbatim, which is rarely useful but should not throw.
+        expect(discoverDashTextTracks(m, noTrailingSlashBase)[0].uri).toBe(noTrailingSlashBase);
+    });
+    it('respects nested BaseURL chain', () => {
+        const xml = `<?xml version="1.0" encoding="UTF-8"?>
+<MPD xmlns="urn:mpeg:dash:schema:mpd:2011" type="static" profiles="urn:mpeg:dash:profile:isoff-on-demand:2011" mediaPresentationDuration="PT60S" minBufferTime="PT2S">
+  <BaseURL>https://cdn.example.com/v1/</BaseURL>
+  <Period>
+    <BaseURL>p0/</BaseURL>
+    <AdaptationSet contentType="text" mimeType="text/vtt" lang="ja">
+      <BaseURL>texts/</BaseURL>
+      <Representation id="ja" bandwidth="100">
+        <BaseURL>ja.vtt</BaseURL>
+      </Representation>
+    </AdaptationSet>
+  </Period>
+</MPD>`;
+        const result = discoverDashTextTracks(parseDashManifest(xml), baseUrl);
+        expect(result[0].uri).toBe('https://cdn.example.com/v1/p0/texts/ja.vtt');
+    });
+    it('returns multiple tracks across periods', () => {
+        const xml = `<?xml version="1.0" encoding="UTF-8"?>
+<MPD xmlns="urn:mpeg:dash:schema:mpd:2011" type="static" profiles="urn:mpeg:dash:profile:isoff-on-demand:2011" mediaPresentationDuration="PT120S" minBufferTime="PT2S">
+  <Period>
+    <AdaptationSet contentType="text" mimeType="text/vtt" lang="en">
+      <Representation id="en" bandwidth="100">
+        <BaseURL>en.vtt</BaseURL>
+      </Representation>
+    </AdaptationSet>
+  </Period>
+  <Period start="PT60S">
+    <AdaptationSet contentType="text" mimeType="text/vtt" lang="de">
+      <Representation id="de" bandwidth="100">
+        <BaseURL>de.vtt</BaseURL>
+      </Representation>
+    </AdaptationSet>
+  </Period>
+</MPD>`;
+        const result = discoverDashTextTracks(parseDashManifest(xml), baseUrl);
+        expect(result.length).toBe(2);
+    });
+    it('falls back to representation id as label when language is absent', () => {
+        const m = manifest(`
+            <AdaptationSet contentType="text" mimeType="text/vtt">
+              <Representation id="my-id" bandwidth="100">
+                <BaseURL>x.vtt</BaseURL>
+              </Representation>
+            </AdaptationSet>`);
+        const result = discoverDashTextTracks(m, baseUrl);
+        expect(result[0].language).toBeNull();
+        expect(result[0].label).toBe('my-id');
+    });
+    it('handles a Period with no AdaptationSet', () => {
+        const xml = `<?xml version="1.0" encoding="UTF-8"?>
+<MPD xmlns="urn:mpeg:dash:schema:mpd:2011" type="static" profiles="urn:mpeg:dash:profile:isoff-on-demand:2011" mediaPresentationDuration="PT60S" minBufferTime="PT2S">
+  <Period/>
+</MPD>`;
+        expect(discoverDashTextTracks(parseDashManifest(xml), baseUrl)).toEqual([]);
+    });
+    it('handles a text AdaptationSet with no Representation', () => {
+        const m = manifest(`
+            <AdaptationSet contentType="text" mimeType="text/vtt"/>`);
+        expect(discoverDashTextTracks(m, baseUrl)).toEqual([]);
+    });
+    it('treats missing mimeType as sidecar-eligible', () => {
+        const m = manifest(`
+            <AdaptationSet contentType="text" lang="en">
+              <Representation id="r" bandwidth="100">
+                <BaseURL>r.vtt</BaseURL>
+              </Representation>
+            </AdaptationSet>`);
+        expect(discoverDashTextTracks(m, baseUrl).length).toBe(1);
+    });
+});

package/dist/unit/types/current/text/discoverHlsTextTracks.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=discoverHlsTextTracks.test.d.ts.map

package/dist/unit/types/current/text/discoverHlsTextTracks.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discoverHlsTextTracks.test.d.ts","sourceRoot":"","sources":["../../../../../test/unit/text/discoverHlsTextTracks.test.ts"],"names":[],"mappings":""}

package/dist/unit/types/current/text/discoverHlsTextTracks.test.js

@@ -0,0 +1,177 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { discoverHlsTextTracks } from '@amazon/vinyl';
+describe('discoverHlsTextTracks', () => {
+    function makePlaylist(overrides = {}) {
+        return {
+            variants: [],
+            alternativeRenditions: [],
+            sessionData: [],
+            ...overrides,
+        };
+    }
+    it('returns empty when no renditions exist', () => {
+        expect(discoverHlsTextTracks(makePlaylist(), 'https://x/main.m3u8')).toEqual([]);
+    });
+    it('discovers a SUBTITLES rendition with a uri', () => {
+        const playlist = makePlaylist({
+            alternativeRenditions: [
+                {
+                    type: 'SUBTITLES',
+                    groupId: 'subs',
+                    name: 'English',
+                    language: 'en',
+                    uri: 'subs/en.vtt',
+                    default: true,
+                },
+            ],
+        });
+        const result = discoverHlsTextTracks(playlist, 'https://example.com/path/main.m3u8');
+        expect(result.length).toBe(1);
+        expect(result[0]).toEqual(jasmine.objectContaining({
+            kind: 'subtitles',
+            language: 'en',
+            label: 'English',
+            default: true,
+            uri: 'https://example.com/path/subs/en.vtt',
+            mimeType: 'text/vtt',
+        }));
+    });
+    it('surfaces forced and characteristics from the rendition', () => {
+        const playlist = makePlaylist({
+            alternativeRenditions: [
+                {
+                    type: 'SUBTITLES',
+                    groupId: 'subs',
+                    name: 'English (Forced)',
+                    language: 'en',
+                    uri: 'subs/en-forced.vtt',
+                    forced: true,
+                    characteristics: [
+                        'public.accessibility.transcribes-spoken-dialog',
+                    ],
+                },
+            ],
+        });
+        const result = discoverHlsTextTracks(playlist, 'https://x/main.m3u8');
+        expect(result[0].forced).toBeTrue();
+        expect(result[0].characteristics).toEqual([
+            'public.accessibility.transcribes-spoken-dialog',
+        ]);
+    });
+    it('defaults forced to false and characteristics to empty when absent', () => {
+        const playlist = makePlaylist({
+            alternativeRenditions: [
+                {
+                    type: 'SUBTITLES',
+                    groupId: 'subs',
+                    name: 'English',
+                    language: 'en',
+                    uri: 'subs/en.vtt',
+                },
+            ],
+        });
+        const result = discoverHlsTextTracks(playlist, 'https://x/main.m3u8');
+        expect(result[0].forced).toBeFalse();
+        expect(result[0].characteristics).toEqual([]);
+    });
+    it('skips SUBTITLES renditions without a uri', () => {
+        const playlist = makePlaylist({
+            alternativeRenditions: [
+                {
+                    type: 'SUBTITLES',
+                    groupId: 'subs',
+                    name: 'English',
+                },
+            ],
+        });
+        expect(discoverHlsTextTracks(playlist, 'https://x/main.m3u8')).toEqual([]);
+    });
+    it('ignores non-SUBTITLES renditions', () => {
+        const playlist = makePlaylist({
+            alternativeRenditions: [
+                {
+                    type: 'AUDIO',
+                    groupId: 'aud',
+                    name: 'English',
+                    uri: 'aud/en.m3u8',
+                },
+                {
+                    type: 'CLOSED-CAPTIONS',
+                    groupId: 'cc',
+                    name: 'English',
+                },
+            ],
+        });
+        expect(discoverHlsTextTracks(playlist, 'https://x/main.m3u8')).toEqual([]);
+    });
+    it('defaults language to null and default to false when absent', () => {
+        const playlist = makePlaylist({
+            alternativeRenditions: [
+                {
+                    type: 'SUBTITLES',
+                    groupId: 'subs',
+                    name: 'Track',
+                    uri: 'subs.vtt',
+                },
+            ],
+        });
+        const result = discoverHlsTextTracks(playlist, 'https://x/main.m3u8');
+        expect(result[0].language).toBeNull();
+        expect(result[0].default).toBeFalse();
+    });
+    it('emits stable, unique ids for multiple subtitle tracks', () => {
+        const playlist = makePlaylist({
+            alternativeRenditions: [
+                {
+                    type: 'SUBTITLES',
+                    groupId: 'subs',
+                    name: 'English',
+                    uri: 'en.vtt',
+                },
+                {
+                    type: 'SUBTITLES',
+                    groupId: 'subs',
+                    name: 'Spanish',
+                    uri: 'es.vtt',
+                },
+            ],
+        });
+        const ids = discoverHlsTextTracks(playlist, 'https://x/main.m3u8').map((t) => t.id);
+        expect(new Set(ids).size).toBe(ids.length);
+    });
+    it('attaches parent EXT-X-DEFINE variables when present', () => {
+        const playlist = makePlaylist({
+            alternativeRenditions: [
+                {
+                    type: 'SUBTITLES',
+                    groupId: 'subs',
+                    name: 'English',
+                    uri: 'subs/en.m3u8',
+                },
+            ],
+            defines: { prefix: 'https://cdn.example.com/' },
+        });
+        const result = discoverHlsTextTracks(playlist, 'https://x/main.m3u8');
+        expect(result[0].variables).toEqual({
+            prefix: 'https://cdn.example.com/',
+        });
+    });
+    it('omits variables when the parent has an empty defines map', () => {
+        const playlist = makePlaylist({
+            alternativeRenditions: [
+                {
+                    type: 'SUBTITLES',
+                    groupId: 'subs',
+                    name: 'English',
+                    uri: 'subs/en.m3u8',
+                },
+            ],
+            defines: {},
+        });
+        const result = discoverHlsTextTracks(playlist, 'https://x/main.m3u8');
+        expect(result[0].variables).toBeUndefined();
+    });
+});

package/dist/unit/types/current/text/mediaTextTrackProvider.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mediaTextTrackProvider.test.d.ts.map

package/dist/unit/types/current/text/mediaTextTrackProvider.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mediaTextTrackProvider.test.d.ts","sourceRoot":"","sources":["../../../../../test/unit/text/mediaTextTrackProvider.test.ts"],"names":[],"mappings":""}

package/dist/unit/types/current/text/mediaTextTrackProvider.test.js

@@ -0,0 +1,86 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createMediaTextTrackProvider } from '@amazon/vinyl';
+/** Minimal media element: a live `textTracks` list and a spied `addTextTrack`. */
+class FakeMediaElement {
+    tracks = [];
+    addTextTrack = jasmine
+        .createSpy('addTextTrack')
+        .and.callFake((kind, label, language) => {
+        const track = {
+            kind,
+            label,
+            language,
+            mode: 'disabled',
+            cues: [],
+            addCue(cue) {
+                this.cues.push(cue);
+            },
+            removeCue(cue) {
+                const i = this.cues.indexOf(cue);
+                if (i >= 0)
+                    this.cues.splice(i, 1);
+            },
+        };
+        this.tracks.push(track);
+        return track;
+    });
+    // ArrayLike view over the live tracks (what `isAttached` scans).
+    get textTracks() {
+        return this.tracks;
+    }
+    asMedia() {
+        return this;
+    }
+    cue() {
+        return { id: '' };
+    }
+}
+describe('createMediaTextTrackProvider', () => {
+    let media;
+    let provider;
+    beforeEach(() => {
+        media = new FakeMediaElement();
+        provider = createMediaTextTrackProvider({ media: media.asMedia() });
+    });
+    it('creates a track from the given kind/label/language', () => {
+        const ref = provider.getOrCreate('subtitles', 'English', 'en');
+        expect(media.addTextTrack).toHaveBeenCalledOnceWith('subtitles', 'English', 'en');
+        expect(media.tracks).toContain(ref.track);
+    });
+    it('memoizes by (kind,label,language) — same key returns the same track', () => {
+        const a = provider.getOrCreate('subtitles', 'English', 'en');
+        const b = provider.getOrCreate('subtitles', 'English', 'en');
+        expect(b).toBe(a);
+        expect(media.addTextTrack).toHaveBeenCalledTimes(1);
+    });
+    it('creates a distinct track per key', () => {
+        provider.getOrCreate('subtitles', 'English', 'en');
+        provider.getOrCreate('subtitles', 'Espanol', 'es');
+        expect(media.addTextTrack).toHaveBeenCalledTimes(2);
+    });
+    it('recreates a track that was detached from the media element', () => {
+        const first = provider.getOrCreate('subtitles', 'English', 'en');
+        // Simulate a media-source reset dropping added tracks.
+        media.tracks.length = 0;
+        const second = provider.getOrCreate('subtitles', 'English', 'en');
+        expect(second).not.toBe(first);
+        expect(media.addTextTrack).toHaveBeenCalledTimes(2);
+        expect(media.tracks).toContain(second.track);
+    });
+    it('clear() removes all cues from the track', () => {
+        const ref = provider.getOrCreate('subtitles', 'English', 'en');
+        ref.track.addCue(media.cue());
+        ref.track.addCue(media.cue());
+        expect(ref.track.cues?.length).toBe(2);
+        ref.clear();
+        expect(ref.track.cues?.length).toBe(0);
+    });
+    it('clear() is a no-op when the track has no cues (cues null)', () => {
+        const ref = provider.getOrCreate('subtitles', 'English', 'en');
+        ref.track.cues = null;
+        expect(() => ref.clear()).not.toThrow();
+    });
+});

package/dist/unit/types/current/text/parseWebVtt.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=parseWebVtt.test.d.ts.map

package/dist/unit/types/current/text/parseWebVtt.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseWebVtt.test.d.ts","sourceRoot":"","sources":["../../../../../test/unit/text/parseWebVtt.test.ts"],"names":[],"mappings":""}