@amazon/vinyl 1.2.0 → 1.2.1

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

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

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

@@ -0,0 +1,365 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { loadWebVttCues } from '@amazon/vinyl';
+import { Abort, requesterWithRetryRef } from '@amazon/vinyl-util';
+import { MockRequester } from '@amazon/vinyl-util/testUtil';
+describe('loadWebVttCues', () => {
+    let requester;
+    beforeEach(() => {
+        requester = new MockRequester();
+        requesterWithRetryRef.set(() => requester);
+    });
+    function respondText(body, contentType, url) {
+        const headers = contentType
+            ? new Headers({ 'content-type': contentType })
+            : new Headers();
+        const response = new Response(body, { headers });
+        if (url) {
+            Object.defineProperty(response, 'url', { value: url });
+        }
+        return Promise.resolve(response);
+    }
+    // Common options: a callback receiving cues, and a playhead that keeps
+    // moving forward so the buffer window advances past every segment.
+    function streamingOpts(overrides = {}) {
+        let now = 0;
+        const batches = [];
+        return {
+            batches,
+            options: {
+                onCues: (cs) => batches.push(cs.map((c) => ({ text: c.text }))),
+                getCurrentTime: () => now,
+                advanceTime: (t) => {
+                    now = t;
+                },
+                ...overrides,
+            },
+        };
+    }
+    it('parses a direct .vtt response with no content-type header', async () => {
+        const response = new Response(`WEBVTT\n\n00:00:01.000 --> 00:00:02.000\nplain`, { headers: new Headers() });
+        response.headers.delete('content-type');
+        requester.request.and.resolveTo(response);
+        const { batches, options } = streamingOpts();
+        await loadWebVttCues('https://x.test/sub.vtt', options);
+        expect(batches.flat().map((c) => c.text)).toEqual(['plain']);
+    });
+    it('parses a direct .vtt response', async () => {
+        const body = `WEBVTT\n\n00:00:01.000 --> 00:00:02.000\ndirect`;
+        requester.request.and.resolveTo(respondText(body, 'text/vtt'));
+        const { batches, options } = streamingOpts();
+        await loadWebVttCues('https://x.test/sub.vtt', options);
+        expect(batches.flat().map((c) => c.text)).toEqual(['direct']);
+    });
+    it('treats application/x-mpegurl content-type as a media playlist', async () => {
+        const playlistText = `#EXTM3U
+#EXT-X-VERSION:3
+#EXT-X-TARGETDURATION:10
+#EXTINF:10.0,
+seg.vtt
+#EXT-X-ENDLIST
+`;
+        const segmentText = `WEBVTT\n\n00:00:01.000 --> 00:00:02.000\nfrom-segment`;
+        let call = 0;
+        requester.request.and.callFake(() => {
+            call++;
+            if (call === 1) {
+                return respondText(playlistText, 'application/vnd.apple.mpegurl', 'https://x.test/sub.m3u8');
+            }
+            return respondText(segmentText, 'text/vtt');
+        });
+        const { batches, options } = streamingOpts();
+        await loadWebVttCues('https://x.test/sub.txt', options);
+        expect(batches.flat().map((c) => c.text)).toEqual(['from-segment']);
+    });
+    it('forwards STYLE blocks parsed from a segment via onStyles', async () => {
+        const playlistText = `#EXTM3U
+#EXT-X-TARGETDURATION:10
+#EXTINF:10.0,
+seg.vtt
+#EXT-X-ENDLIST
+`;
+        const segmentText = `WEBVTT
+
+STYLE
+::cue { color: red }
+
+00:00:01.000 --> 00:00:02.000
+from-segment`;
+        let call = 0;
+        requester.request.and.callFake(() => {
+            call++;
+            if (call === 1) {
+                return respondText(playlistText, 'application/vnd.apple.mpegurl', 'https://x.test/sub.m3u8');
+            }
+            return respondText(segmentText, 'text/vtt');
+        });
+        const styleBatches = [];
+        const { options } = streamingOpts({
+            onStyles: (styles) => styleBatches.push([...styles]),
+        });
+        await loadWebVttCues('https://x.test/sub.m3u8', options);
+        expect(styleBatches).toEqual([['::cue { color: red }']]);
+    });
+    it('falls back to the request URI when response.url is empty (body sniffed)', async () => {
+        const playlistText = `#EXTM3U
+#EXT-X-VERSION:3
+#EXT-X-TARGETDURATION:10
+#EXTINF:10.0,
+0.vtt
+#EXT-X-ENDLIST
+`;
+        const segText = `WEBVTT\n\n00:00:00.000 --> 00:00:01.000\nfb`;
+        let call = 0;
+        requester.request.and.callFake(() => {
+            call++;
+            if (call === 1)
+                return respondText(playlistText, 'application/vnd.apple.mpegurl');
+            return respondText(segText);
+        });
+        // No .m3u8 extension → sniffed via body. Response.url omitted so the
+        // fallback branch (response.url || uri) is exercised.
+        const { batches, options } = streamingOpts();
+        await loadWebVttCues('https://x.test/playlist', options);
+        expect(batches.flat().map((c) => c.text)).toEqual(['fb']);
+    });
+    it('uses response.url when set (m3u8 fetch redirect)', async () => {
+        const playlistText = `#EXTM3U
+#EXT-X-VERSION:3
+#EXT-X-TARGETDURATION:10
+#EXTINF:10.0,
+0.vtt
+#EXT-X-ENDLIST
+`;
+        const segText = `WEBVTT\n\n00:00:00.000 --> 00:00:01.000\nseg`;
+        let call = 0;
+        requester.request.and.callFake(() => {
+            call++;
+            if (call === 1) {
+                return respondText(playlistText, 'application/vnd.apple.mpegurl', 'https://cdn.example.com/redirected/sub.m3u8');
+            }
+            return respondText(segText);
+        });
+        const { options } = streamingOpts();
+        await loadWebVttCues('https://x.test/sub.m3u8', options);
+        const segUrl = requester.request.calls.argsFor(1)[0];
+        expect(String(segUrl)).toBe('https://cdn.example.com/redirected/0.vtt');
+    });
+    it('uses response.url when set (sniffed body)', async () => {
+        const playlistText = `#EXTM3U
+#EXT-X-VERSION:3
+#EXT-X-TARGETDURATION:10
+#EXTINF:10.0,
+0.vtt
+#EXT-X-ENDLIST
+`;
+        const segText = `WEBVTT\n\n00:00:00.000 --> 00:00:01.000\nseg`;
+        let call = 0;
+        requester.request.and.callFake(() => {
+            call++;
+            if (call === 1) {
+                return respondText(playlistText, undefined, 'https://cdn.example.com/redirected/sub');
+            }
+            return respondText(segText);
+        });
+        const { options } = streamingOpts();
+        await loadWebVttCues('https://x.test/sub', options);
+        const segUrl = requester.request.calls.argsFor(1)[0];
+        expect(String(segUrl)).toBe('https://cdn.example.com/redirected/0.vtt');
+    });
+    it('detects a media playlist by .m3u8 URL extension', async () => {
+        const playlistText = `#EXTM3U
+#EXT-X-VERSION:3
+#EXT-X-TARGETDURATION:10
+#EXTINF:10.0,
+0.vtt
+#EXT-X-ENDLIST
+`;
+        const segText = `WEBVTT\n\n00:00:01.000 --> 00:00:02.000\nseg`;
+        let call = 0;
+        requester.request.and.callFake(() => {
+            call++;
+            if (call === 1) {
+                return respondText(playlistText, 'application/vnd.apple.mpegurl');
+            }
+            return respondText(segText);
+        });
+        const { batches, options } = streamingOpts();
+        await loadWebVttCues('https://x.test/sub.m3u8', options);
+        expect(batches.flat().map((c) => c.text)).toEqual(['seg']);
+    });
+    it('fetches segments incrementally in playhead-first order', async () => {
+        // 4 segments × 5s each. Playhead at 12s selects segment c (10-15s)
+        // first because its midpoint is closest to the playhead.
+        const playlistBody = `#EXTM3U
+#EXT-X-TARGETDURATION:5
+#EXTINF:5.0,
+a.vtt
+#EXTINF:5.0,
+b.vtt
+#EXTINF:5.0,
+c.vtt
+#EXTINF:5.0,
+d.vtt
+#EXT-X-ENDLIST
+`;
+        const fetched = [];
+        let call = 0;
+        requester.request.and.callFake((url) => {
+            call++;
+            if (call === 1)
+                return respondText(playlistBody);
+            const path = String(url).split('/').pop();
+            fetched.push(path);
+            return respondText(`WEBVTT\n\n00:00:00.000 --> 00:00:01.000\n${path}`);
+        });
+        const abort = new Abort();
+        const batches = [];
+        const promise = loadWebVttCues('https://x.test/sub.m3u8', {
+            onCues: (cs) => batches.push(cs.map((c) => c.text)),
+            getCurrentTime: () => 12,
+            abort,
+        });
+        // Let the loader consume every segment in the window, then abort.
+        await new Promise((r) => setTimeout(r, 50));
+        abort.abort();
+        await promise;
+        expect(fetched[0]).toBe('c.vtt');
+        expect(batches[0]).toEqual(['c.vtt']);
+    });
+    it('substitutes EXT-X-DEFINE:IMPORT variables in segment URIs', async () => {
+        const playlistBody = `#EXTM3U
+#EXT-X-DEFINE:IMPORT="prefix"
+#EXT-X-TARGETDURATION:5
+#EXTINF:5.0,
+{$prefix}0.vtt
+#EXT-X-ENDLIST
+`;
+        const segText = `WEBVTT\n\n00:00:00.000 --> 00:00:05.000\nhello`;
+        let call = 0;
+        requester.request.and.callFake((url) => {
+            call++;
+            if (call === 1)
+                return respondText(playlistBody);
+            expect(String(url)).toBe('https://cdn.example.com/0.vtt');
+            return respondText(segText);
+        });
+        const { batches, options } = streamingOpts();
+        await loadWebVttCues('https://x.test/sub.m3u8', {
+            ...options,
+            variables: { prefix: 'https://cdn.example.com/' },
+        });
+        expect(batches.flat().map((c) => c.text)).toEqual(['hello']);
+    });
+    it('re-evaluates playhead between segment fetches for seek responsiveness', async () => {
+        const playlistBody = `#EXTM3U
+#EXT-X-TARGETDURATION:5
+#EXTINF:5.0,
+a.vtt
+#EXTINF:5.0,
+b.vtt
+#EXTINF:5.0,
+c.vtt
+#EXTINF:5.0,
+d.vtt
+#EXT-X-ENDLIST
+`;
+        const fetched = [];
+        let currentTime = 0;
+        let call = 0;
+        requester.request.and.callFake((url) => {
+            call++;
+            if (call === 1)
+                return respondText(playlistBody);
+            const path = String(url).split('/').pop();
+            fetched.push(path);
+            // Seek to the end after seg0; abort will fire after seg3.
+            if (fetched.length === 1)
+                currentTime = 17;
+            return respondText(`WEBVTT\n\n00:00:00.000 --> 00:00:01.000\n${path}`);
+        });
+        const abort = new Abort();
+        const promise = loadWebVttCues('https://x.test/sub.m3u8', {
+            onCues: () => { },
+            getCurrentTime: () => currentTime,
+            abort,
+        });
+        // Let the loader fetch until it idles (no segments in window).
+        await new Promise((r) => setTimeout(r, 50));
+        abort.abort();
+        await promise;
+        // First fetch was seg0 (nearest 0s). Then seek → 17s makes seg3
+        // (mid=17.5) the closest of the remaining {1, 2, 3}.
+        expect(fetched[0]).toBe('a.vtt');
+        expect(fetched[1]).toBe('d.vtt');
+    });
+    it('honors abort during idle polling when playhead is outside every window', async () => {
+        // 2 segments at 10s+ but playhead sits at 100s (well past). No
+        // segment intersects the [-2, +10] buffer window, so the loader
+        // idles. Aborting must resolve the load promptly.
+        const playlistBody = `#EXTM3U
+#EXT-X-TARGETDURATION:5
+#EXTINF:5.0,
+a.vtt
+#EXTINF:5.0,
+b.vtt
+#EXT-X-ENDLIST
+`;
+        let call = 0;
+        requester.request.and.callFake(() => {
+            call++;
+            if (call === 1)
+                return respondText(playlistBody);
+            fail('no segment fetch expected');
+            return respondText('');
+        });
+        const abort = new Abort();
+        const promise = loadWebVttCues('https://x.test/sub.m3u8', {
+            onCues: () => { },
+            getCurrentTime: () => 100,
+            abort,
+        });
+        // Give the polling loop a moment to enter its wait.
+        await new Promise((r) => setTimeout(r, 20));
+        abort.abort();
+        await promise; // should not hang
+        expect(call).toBe(1);
+    });
+    it('respects a custom lookAhead window', async () => {
+        // With lookAhead=1, only segment 0 (0..5s) overlaps [-2, 1].
+        // Segment 1 (5..10s) is outside the window and never fetched
+        // because the playhead never advances.
+        const playlistBody = `#EXTM3U
+#EXT-X-TARGETDURATION:5
+#EXTINF:5.0,
+a.vtt
+#EXTINF:5.0,
+b.vtt
+#EXT-X-ENDLIST
+`;
+        let call = 0;
+        const fetched = [];
+        requester.request.and.callFake((url) => {
+            call++;
+            if (call === 1)
+                return respondText(playlistBody);
+            fetched.push(String(url).split('/').pop());
+            return respondText(`WEBVTT\n\n00:00:00.000 --> 00:00:01.000\nx`);
+        });
+        const abort = new Abort();
+        const promise = loadWebVttCues('https://x.test/sub.m3u8', {
+            onCues: () => { },
+            getCurrentTime: () => 0,
+            lookAhead: 1,
+            abort,
+        });
+        // Let a.vtt fetch, then let the loader enter its idle poll before
+        // aborting so the remaining segment stays pending.
+        await new Promise((r) => setTimeout(r, 20));
+        abort.abort();
+        await promise;
+        expect(fetched).toEqual(['a.vtt']);
+    });
+});

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

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

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

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

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

@@ -0,0 +1,76 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { applyVttCueStyle, isVttCue } from '@amazon/vinyl';
+describe('VttCueStyle', () => {
+    describe('isVttCue', () => {
+        let original;
+        beforeEach(() => {
+            original = globalThis.VTTCue;
+        });
+        afterEach(() => {
+            ;
+            globalThis.VTTCue = original;
+        });
+        it('is true for a VTTCue instance', () => {
+            class FakeVttCue {
+            }
+            ;
+            globalThis.VTTCue = FakeVttCue;
+            expect(isVttCue(new FakeVttCue())).toBe(true);
+        });
+        it('is false for a non-VTTCue cue', () => {
+            class FakeVttCue {
+            }
+            ;
+            globalThis.VTTCue = FakeVttCue;
+            expect(isVttCue({})).toBe(false);
+        });
+        it('is false when VTTCue is unavailable', () => {
+            ;
+            globalThis.VTTCue = undefined;
+            expect(isVttCue({})).toBe(false);
+        });
+    });
+    describe('applyVttCueStyle', () => {
+        it('applies every provided property', () => {
+            const cue = {};
+            const style = {
+                align: 'start',
+                line: 5,
+                lineAlign: 'center',
+                position: 10,
+                positionAlign: 'center',
+                size: 90,
+                snapToLines: false,
+                vertical: 'rl',
+            };
+            applyVttCueStyle(cue, style);
+            expect(cue).toEqual({
+                align: 'start',
+                line: 5,
+                lineAlign: 'center',
+                position: 10,
+                positionAlign: 'center',
+                size: 90,
+                snapToLines: false,
+                vertical: 'rl',
+            });
+        });
+        it('accepts the `auto` keyword for line and position', () => {
+            const cue = {};
+            applyVttCueStyle(cue, {
+                line: 'auto',
+                position: 'auto',
+            });
+            expect(cue.line).toBe('auto');
+            expect(cue.position).toBe('auto');
+        });
+        it('leaves unset properties untouched', () => {
+            const cue = { size: 100 };
+            applyVttCueStyle(cue, {});
+            expect(cue).toEqual({ size: 100 });
+        });
+    });
+});

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

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

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

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

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

@@ -0,0 +1,199 @@
+/*
+ * 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('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 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":""}