@amazon/vinyl 2.0.4 → 3.0.1

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

@@ -74,6 +74,35 @@ seg.vtt
         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

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.js

@@ -108,15 +108,30 @@ ok`;
         const doc = parseWebVtt(text);
         expect(doc.cues.length).toBe(1);
     });
-    it('skips STYLE blocks', () => {
+    it('captures STYLE block CSS while still parsing cues', () => {
         const text = `WEBVTT
 
 STYLE
-::cue { color: red; }
+::cue(.loud) { font-weight: bold }
+
+STYLE
+::cue { color: red }
 
 00:00:01.000 --> 00:00:02.000
 styled`;
-        expect(parseWebVtt(text).cues.length).toBe(1);
+        const doc = parseWebVtt(text);
+        expect(doc.cues.length).toBe(1);
+        expect(doc.styles).toEqual([
+            '::cue(.loud) { font-weight: bold }',
+            '::cue { color: red }',
+        ]);
+    });
+    it('reports no styles when there are no STYLE blocks', () => {
+        const text = `WEBVTT
+
+00:00:01.000 --> 00:00:02.000
+x`;
+        expect(parseWebVtt(text).styles).toEqual([]);
     });
     it('skips REGION blocks', () => {
         const text = `WEBVTT
@@ -127,14 +142,98 @@ width:40%
 
 00:00:01.000 --> 00:00:02.000
 regional`;
-        expect(parseWebVtt(text).cues.length).toBe(1);
+        const doc = parseWebVtt(text);
+        expect(doc.cues.length).toBe(1);
+        expect(doc.styles).toEqual([]);
     });
-    it('tolerates cue settings on the timing line', () => {
+    it('parses cue settings on the timing line', () => {
         const text = `WEBVTT
 
 00:00:01.000 --> 00:00:02.000 line:50% align:start
 positioned`;
-        expect(parseWebVtt(text).cues[0].text).toBe('positioned');
+        const cue = parseWebVtt(text).cues[0];
+        expect(cue.text).toBe('positioned');
+        expect(cue.settings).toEqual({
+            line: 50,
+            snapToLines: false,
+            align: 'start',
+        });
+    });
+    it('parses integer/negative lines as snap-to-lines, with lineAlign', () => {
+        const text = `WEBVTT
+
+00:00:01.000 --> 00:00:02.000 line:-3,end
+a
+
+00:00:03.000 --> 00:00:04.000 line:5
+b`;
+        const [a, b] = parseWebVtt(text).cues;
+        expect(a.settings).toEqual({
+            line: -3,
+            snapToLines: true,
+            lineAlign: 'end',
+        });
+        expect(b.settings).toEqual({ line: 5, snapToLines: true });
+    });
+    it("maps the legacy 'middle' keyword to 'center'", () => {
+        const text = `WEBVTT
+
+00:00:01.000 --> 00:00:02.000 align:middle line:85%,middle position:50%,middle
+a`;
+        expect(parseWebVtt(text).cues[0].settings).toEqual({
+            align: 'center',
+            line: 85,
+            snapToLines: false,
+            lineAlign: 'center',
+            position: 50,
+            positionAlign: 'center',
+        });
+    });
+    it('parses position (with align), size and vertical', () => {
+        const text = `WEBVTT
+
+00:00:01.000 --> 00:00:02.000 position:20%,line-left size:80% vertical:rl
+a`;
+        expect(parseWebVtt(text).cues[0].settings).toEqual({
+            position: 20,
+            positionAlign: 'line-left',
+            size: 80,
+            vertical: 'rl',
+        });
+    });
+    it('omits settings and skips malformed/unknown tokens', () => {
+        const text = `WEBVTT
+
+00:00:01.000 --> 00:00:02.000
+plain
+
+00:00:03.000 --> 00:00:04.000 align:bogus size:oops region:foo bareword
+b`;
+        const [plain, b] = parseWebVtt(text).cues;
+        expect(plain.settings).toBeUndefined();
+        // align invalid, size not a %, unknown key, and a colon-less token.
+        expect(b.settings).toBeUndefined();
+    });
+    it('skips malformed line/position/percent values and invalid aligns', () => {
+        const text = `WEBVTT
+
+00:00:01.000 --> 00:00:02.000 line:x% size:y%
+a
+
+00:00:03.000 --> 00:00:04.000 line:1.5 position:bad
+b
+
+00:00:05.000 --> 00:00:06.000 line:5,bogus position:20%,nope
+c`;
+        const [a, b, c] = parseWebVtt(text).cues;
+        expect(a.settings).toBeUndefined(); // non-numeric percentages → dropped
+        expect(b.settings).toBeUndefined(); // non-integer line, non-% position
+        // Valid values kept; invalid *Align keywords dropped.
+        expect(c.settings).toEqual({
+            line: 5,
+            snapToLines: true,
+            position: 20,
+        });
     });
     it('skips a malformed cue and continues', () => {
         const text = `WEBVTT
@@ -149,6 +248,88 @@ good`;
         expect(cues.length).toBe(1);
         expect(cues[0].text).toBe('good');
     });
+    it('skips a line with --> but an invalid start timestamp', () => {
+        const text = `WEBVTT
+
+BForced --> 00:00:02.000
+skipped
+
+00:00:02.000 --> 00:00:03.000
+good`;
+        const cues = parseWebVtt(text).cues;
+        expect(cues.length).toBe(1);
+        expect(cues[0].text).toBe('good');
+    });
+    it('ignores unparseable text glued after the end timestamp', () => {
+        // Per the spec, timestamp collection stops after the milliseconds; any
+        // trailing text is parsed as (here, invalid, ignored) cue settings.
+        const cue = parseWebVtt('WEBVTT\n\n00:00:01.000 --> 00:00:02.000x\ntext').cues[0];
+        expect(cue.endTime).toBe(2);
+        expect(cue.settings).toBeUndefined();
+        expect(cue.text).toBe('text');
+    });
+    it('parses multi-digit hours (spec allows two or more)', () => {
+        const cues = parseWebVtt('WEBVTT\n\n100:00:01.000 --> 100:00:02.500\nhi').cues;
+        expect(cues.length).toBe(1);
+        expect(cues[0].startTime).toBe(360001);
+        expect(cues[0].endTime).toBe(360002.5);
+    });
+    it('treats consecutive blank lines between cues as separators', () => {
+        const text = 'WEBVTT\n\n00:00:01.000 --> 00:00:02.000\none\n\n\n' +
+            '00:00:03.000 --> 00:00:04.000\ntwo';
+        expect(parseWebVtt(text).cues.map((c) => c.text)).toEqual([
+            'one',
+            'two',
+        ]);
+    });
+    // Each line exercises a distinct timestamp-parser rejection branch; all are
+    // treated as a (dropped) identifier so only the trailing valid cue survives.
+    for (const timing of [
+        '12 --> 00:00:02.000', // two digits then no ':'
+        '7 --> 00:00:02.000', // one digit then no second digit
+        '00:00:01.000 00:00:02.000', // no --> ⇒ treated as an identifier
+        '5:30.000 --> 00:00:02.000', // MM:SS minutes not two digits
+        '75:30.000 --> 00:00:02.000', // MM:SS minutes > 59
+        '12:34 --> 00:00:02.000', // seconds not terminated by '.'
+        '00:99:00.000 --> 00:00:02.000', // HH:MM:SS minutes > 59
+        '00:00:99.000 --> 00:00:02.000', // HH:MM:SS seconds > 59
+        '00:00:0.400 --> 00:00:02.000', // HH:MM:SS seconds not two digits
+        '12:3:45.000 --> 00:00:02.000', // minutes not two digits before ':'
+        '00:00:00 --> 00:00:02.000', // HH:MM:SS missing .mmm
+        '00:00:00.00 --> 00:00:02.000', // milliseconds only two digits
+        '00:00.0 --> 00:00:02.000', // milliseconds only one digit
+        '00:00. --> 00:00:02.000', // milliseconds missing
+        '12:ab --> 00:00:02.000', // non-digit minute/second
+        '00:00:01.0', // truncated timestamp at end of input
+    ]) {
+        it(`skips a line with an invalid timestamp: "${timing}"`, () => {
+            const text = `WEBVTT\n\n${timing}\nfiller\n\n00:00:05.000 --> 00:00:06.000\nok`;
+            expect(parseWebVtt(text).cues.map((c) => c.text)).toEqual(['ok']);
+        });
+    }
+    // Keyword prefixes (NOTES/REGIONAL/STYLES) are ordinary cue identifiers, not
+    // NOTE/REGION/STYLE blocks — this also exercises each keyword's fall-through.
+    for (const identifier of ['NOTES', 'REGIONAL', 'STYLES']) {
+        it(`treats keyword prefix "${identifier}" as an identifier`, () => {
+            const cues = parseWebVtt(`WEBVTT\n\n${identifier}\n00:00:01.000 --> 00:00:02.000\nhi`).cues;
+            expect(cues.length).toBe(1);
+            expect(cues[0].id).toBe(identifier);
+        });
+    }
+    it('normalizes CRLF line endings and splits CRLF-separated cues', () => {
+        const text = 'WEBVTT\r\n\r\n00:00:01.000 --> 00:00:02.000\r\nline one\r\nline two' +
+            '\r\n\r\n00:00:03.000 --> 00:00:04.000\r\nsecond';
+        expect(parseWebVtt(text).cues.map((c) => c.text)).toEqual([
+            'line one\nline two',
+            'second',
+        ]);
+    });
+    it('accepts a NOTE block at end of input', () => {
+        expect(parseWebVtt('WEBVTT\n\nNOTE').cues).toEqual([]);
+    });
+    it('handles input that ends mid-timestamp', () => {
+        expect(parseWebVtt('WEBVTT\n\n00:00:00.000 --> 00:00:0').cues).toEqual([]);
+    });
     it('returns empty cues on header-only input', () => {
         expect(parseWebVtt('WEBVTT\n').cues).toEqual([]);
     });

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

@@ -3,6 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { pickPreferredTextTrack } from '@amazon/vinyl';
+import { setMockNavigator, spyOnPropertySafe, } from '@amazon/vinyl-util/testUtil';
 let nextId = 0;
 function track(overrides = {}) {
     return {
@@ -19,7 +20,17 @@ function track(overrides = {}) {
     };
 }
 describe('pickPreferredTextTrack', () => {
-    it('returns null when the preference is null (captions off)', () => {
+    it('falls back to navigator.languages when the preference is null', () => {
+        setMockNavigator().languages = ['en'];
+        const en = track({ id: 'en', language: 'en' });
+        expect(pickPreferredTextTrack([en], null)).toBe(en);
+    });
+    it('returns null when no track relates to navigator.languages', () => {
+        setMockNavigator().languages = ['en'];
+        expect(pickPreferredTextTrack([track({ language: 'ja' })], null)).toBeNull();
+    });
+    it('returns null for a null preference when navigator is unavailable', () => {
+        spyOnPropertySafe(global, 'navigator').and.returnValue(undefined);
         expect(pickPreferredTextTrack([track()], null)).toBeNull();
     });
     it('returns null when there are no tracks', () => {

package/dist/unit/types/current/track/TrackController.test.js

@@ -1308,6 +1308,42 @@ describe('TrackControllerImpl', () => {
             expect(trackActivated).toHaveBeenCalledWith(objectContaining({ track: objectContaining({ uri: main.uri }) }));
             expect(trackActivated).toHaveBeenCalledBefore(queueEnded);
         });
+        it('ends the track after an empty postroll where no ad ever began', async () => {
+            // An empty postroll (a break that resolves to no ads) completes
+            // without any adEntered, so the content track is never deactivated
+            // and stays active. onEnded has already deferred the trackEnded to
+            // adBreakCompleted, so this must still end the track and the queue
+            // rather than hang.
+            const [main] = createLoadOptionsList(1);
+            trackController.load(main);
+            await clock.tick(); // content activates (stays active — no ad plays)
+            expect(trackController.activeTrack.active).toBeTrue();
+            const trackEnded = createEventSpy(trackController, 'trackEnded');
+            const queueEnded = createEventSpy(trackController, 'queueEnded');
+            deps.adController.dispatch('adBreakCompleted', {
+                adBreak: adBreak('postroll'),
+                resumePosition: 0,
+            });
+            await clock.tick();
+            expect(trackEnded).toHaveBeenCalledWith(objectContaining({
+                track: objectContaining({ uri: main.uri }),
+            }));
+            expect(queueEnded).toHaveBeenCalled();
+        });
+        it('advances to the next track after an empty postroll where no ad ever began', async () => {
+            const list = createLoadOptionsList(2);
+            trackController.load(...list);
+            await clock.tick(); // content activates and stays active
+            expect(trackController.activeTrack.active).toBeTrue();
+            const trackEnded = createEventSpy(trackController, 'trackEnded');
+            deps.adController.dispatch('adBreakCompleted', {
+                adBreak: adBreak('postroll'),
+                resumePosition: 0,
+            });
+            await clock.tick();
+            expect(trackEnded).toHaveBeenCalledWith(objectContaining({ track: any(Object) }));
+            expect(trackController.activeTrack?.uri).toBe(list[1].uri);
+        });
         it('does not treat a completed midroll ad as the track ending', async () => {
             trackController.load(...createLoadOptionsList(1));
             const trackEnded = createEventSpy(trackController, 'trackEnded');

package/dist/unit/types/current/track/dash/createDashFactories.test.js

@@ -69,9 +69,8 @@ describe('createDashFactories', () => {
         });
         const deps = createContainer(factories).dependencies;
         const options = dashFactoryDeps.options.value;
-        expect(deps.preferredAudioLanguage.value).toBe(options.preferredAudioLanguage);
+        expect(deps.audio.value).toBe(options.audio);
         expect(deps.allowedContentTypes.value).toBe(options.allowedContentTypes);
-        expect(deps.preferDescriptiveAudio.value).toBe(options.preferDescriptiveAudio);
         expect(deps.abr.value).toBe(options.abr);
     });
     it('provides streaming options to createContentStreamFactories', () => {

package/dist/unit/types/current/track/hls/buildHlsMediaTimeline.test.js

@@ -403,9 +403,8 @@ describe('buildHlsMediaTimeline', () => {
             drmController,
             mediaTimeline: data(Promise.resolve(timeline)),
             options: data({
-                preferredAudioLanguage: null,
+                audio: { selection: { language: null, descriptive: false } },
                 codecOverrides: {},
-                preferDescriptiveAudio: false,
             }),
         }).value;
         const audio = result.periods[0].qualities.filter((q) => q.metadata.contentType === 'audio');

package/dist/unit/types/current/track/hls/createHlsFactories.test.js

@@ -57,9 +57,8 @@ describe('createHlsFactories', () => {
         });
         const deps = createContainer(factories).dependencies;
         const options = hlsFactoryDeps.options.value;
-        expect(deps.preferredAudioLanguage.value).toBe(options.preferredAudioLanguage);
+        expect(deps.audio.value).toBe(options.audio);
         expect(deps.allowedContentTypes.value).toBe(options.allowedContentTypes);
-        expect(deps.preferDescriptiveAudio.value).toBe(options.preferDescriptiveAudio);
         expect(deps.abr.value).toBe(options.abr);
     });
     it('exposes the shared adController without owning it', () => {