@amazon/vinyl 1.2.0 → 2.0.0

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

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

@@ -0,0 +1,212 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { parseWebVtt } from '@amazon/vinyl';
+import { ValidationError } from '@amazon/vinyl-util';
+describe('parseWebVtt', () => {
+    it('parses a minimal cue', () => {
+        const text = `WEBVTT
+
+00:00:01.000 --> 00:00:02.500
+Hello world`;
+        const doc = parseWebVtt(text);
+        expect(doc.cues).toEqual([
+            {
+                id: null,
+                startTime: 1,
+                endTime: 2.5,
+                text: 'Hello world',
+            },
+        ]);
+    });
+    it('parses a cue identifier', () => {
+        const text = `WEBVTT
+
+cue-1
+00:00:01.000 --> 00:00:02.000
+text payload`;
+        expect(parseWebVtt(text).cues).toEqual([
+            {
+                id: 'cue-1',
+                startTime: 1,
+                endTime: 2,
+                text: 'text payload',
+            },
+        ]);
+    });
+    it('parses multiple cues with multi-line text', () => {
+        const text = `WEBVTT
+
+00:00:00.500 --> 00:00:01.000
+line one
+line two
+
+00:00:01.000 --> 00:00:02.000
+second cue`;
+        expect(parseWebVtt(text).cues).toEqual([
+            {
+                id: null,
+                startTime: 0.5,
+                endTime: 1,
+                text: 'line one\nline two',
+            },
+            {
+                id: null,
+                startTime: 1,
+                endTime: 2,
+                text: 'second cue',
+            },
+        ]);
+    });
+    it('parses MM:SS.mmm timestamps without an hours field', () => {
+        const text = `WEBVTT
+
+10:30.500 --> 11:45.250
+brief`;
+        const cue = parseWebVtt(text).cues[0];
+        expect(cue.startTime).toBeCloseTo(630.5, 6);
+        expect(cue.endTime).toBeCloseTo(705.25, 6);
+    });
+    it('parses HH:MM:SS.mmm timestamps', () => {
+        const text = `WEBVTT
+
+01:02:03.400 --> 01:02:04.500
+deep`;
+        const cue = parseWebVtt(text).cues[0];
+        expect(cue.startTime).toBeCloseTo(3723.4, 6);
+        expect(cue.endTime).toBeCloseTo(3724.5, 6);
+    });
+    it('strips a UTF-8 BOM', () => {
+        const text = 'WEBVTT\n\n00:00:01.000 --> 00:00:02.000\nx';
+        expect(parseWebVtt(text).cues.length).toBe(1);
+    });
+    it('accepts CRLF line endings', () => {
+        const text = `WEBVTT\r\n\r\n00:00:01.000 --> 00:00:02.000\r\ncrlf`;
+        expect(parseWebVtt(text).cues[0].text).toBe('crlf');
+    });
+    it('skips NOTE blocks', () => {
+        const text = `WEBVTT
+
+NOTE this is a comment
+that spans multiple lines
+
+00:00:01.000 --> 00:00:02.000
+hello`;
+        const doc = parseWebVtt(text);
+        expect(doc.cues.length).toBe(1);
+        expect(doc.cues[0].text).toBe('hello');
+    });
+    it('skips standalone NOTE block', () => {
+        const text = `WEBVTT
+
+NOTE
+single line note
+
+00:00:01.000 --> 00:00:02.000
+ok`;
+        const doc = parseWebVtt(text);
+        expect(doc.cues.length).toBe(1);
+    });
+    it('skips STYLE blocks', () => {
+        const text = `WEBVTT
+
+STYLE
+::cue { color: red; }
+
+00:00:01.000 --> 00:00:02.000
+styled`;
+        expect(parseWebVtt(text).cues.length).toBe(1);
+    });
+    it('skips REGION blocks', () => {
+        const text = `WEBVTT
+
+REGION
+id:fred
+width:40%
+
+00:00:01.000 --> 00:00:02.000
+regional`;
+        expect(parseWebVtt(text).cues.length).toBe(1);
+    });
+    it('tolerates 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');
+    });
+    it('skips a malformed cue and continues', () => {
+        const text = `WEBVTT
+
+00:00:01.000 --> NOT-A-TIME
+broken cue
+should be 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('returns empty cues on header-only input', () => {
+        expect(parseWebVtt('WEBVTT\n').cues).toEqual([]);
+    });
+    it('throws on missing header', () => {
+        expect(() => parseWebVtt('not a vtt file')).toThrowMatching((e) => {
+            return e instanceof ValidationError;
+        });
+    });
+    it('throws on non-string input', () => {
+        expect(() => parseWebVtt(undefined)).toThrowMatching((e) => e instanceof ValidationError);
+    });
+    it('accepts header followed by extra description', () => {
+        const text = `WEBVTT - English subtitles
+
+00:00:01.000 --> 00:00:02.000
+hi`;
+        expect(parseWebVtt(text).cues.length).toBe(1);
+    });
+    it('accepts header followed by tab', () => {
+        const text = `WEBVTT\t\n\n00:00:01.000 --> 00:00:02.000\nhi`;
+        expect(parseWebVtt(text).cues.length).toBe(1);
+    });
+    it('skips an HLS X-TIMESTAMP-MAP header line', () => {
+        // HLS captions place `X-TIMESTAMP-MAP=...` in the WebVTT header (per
+        // RFC 8216 §3.5). Without recognizing this as part of the header, the
+        // first cue in every segment gets consumed as a malformed identifier.
+        const text = `WEBVTT
+X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
+
+00:00:00.250 --> 00:00:00.879
+Welcome,
+
+00:00:01.000 --> 00:00:02.000
+hi`;
+        const cues = parseWebVtt(text).cues;
+        expect(cues.length).toBe(2);
+        expect(cues[0].text).toBe('Welcome,');
+        expect(cues[1].text).toBe('hi');
+    });
+    it('skips WebVTT metadata header lines', () => {
+        // Metadata headers of the form `Name: value` between the signature
+        // and the first blank line are part of the file header.
+        const text = `WEBVTT
+Kind: captions
+Language: en
+
+00:00:01.000 --> 00:00:02.000
+hi`;
+        const cues = parseWebVtt(text).cues;
+        expect(cues.length).toBe(1);
+        expect(cues[0].text).toBe('hi');
+    });
+    it('handles trailing identifier without timing line', () => {
+        // Identifier with no following timing line - cue is dropped, parser
+        // breaks out cleanly without throwing.
+        const text = `WEBVTT
+
+trailing-id`;
+        expect(parseWebVtt(text).cues).toEqual([]);
+    });
+});

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

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

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

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

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

@@ -0,0 +1,67 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { pickPreferredTextTrack } from '@amazon/vinyl';
+let nextId = 0;
+function track(overrides = {}) {
+    return {
+        id: `t${nextId++}`,
+        kind: 'subtitles',
+        language: 'en',
+        label: '',
+        default: false,
+        forced: false,
+        characteristics: [],
+        uri: 'x.vtt',
+        mimeType: null,
+        ...overrides,
+    };
+}
+describe('pickPreferredTextTrack', () => {
+    it('returns null when the preference is null (captions off)', () => {
+        expect(pickPreferredTextTrack([track()], null)).toBeNull();
+    });
+    it('returns null when there are no tracks', () => {
+        expect(pickPreferredTextTrack([], 'en')).toBeNull();
+    });
+    it('selects the track matching the preferred language', () => {
+        const en = track({ id: 'en', language: 'en' });
+        const es = track({ id: 'es', language: 'es' });
+        expect(pickPreferredTextTrack([es, en], 'en')).toBe(en);
+    });
+    it('returns null when no track relates to the preference', () => {
+        expect(pickPreferredTextTrack([track({ language: 'es' })], 'ja')).toBeNull();
+    });
+    it('ignores tracks without a language tag', () => {
+        expect(pickPreferredTextTrack([track({ language: null })], 'en')).toBeNull();
+    });
+    it('prefers a full track over a forced-only track of the same language', () => {
+        const forced = track({ id: 'forced', language: 'en', forced: true });
+        const full = track({ id: 'full', language: 'en', forced: false });
+        expect(pickPreferredTextTrack([forced, full], 'en')).toBe(full);
+    });
+    it('breaks a remaining tie by the manifest-default flag', () => {
+        const a = track({ id: 'a', language: 'en', default: false });
+        const b = track({ id: 'b', language: 'en', default: true });
+        expect(pickPreferredTextTrack([a, b], 'en')).toBe(b);
+    });
+    it('honors preference order, earlier entries winning', () => {
+        const en = track({ id: 'en', language: 'en' });
+        const fr = track({ id: 'fr', language: 'fr' });
+        expect(pickPreferredTextTrack([en, fr], ['fr', 'en'])).toBe(fr);
+        expect(pickPreferredTextTrack([en, fr], ['en', 'fr'])).toBe(en);
+    });
+    it('matches a related language when no exact match exists', () => {
+        const enUs = track({ id: 'en-US', language: 'en-US' });
+        const es = track({ id: 'es', language: 'es' });
+        // 'en' is the parent of 'en-US' — related, so it should be chosen.
+        expect(pickPreferredTextTrack([es, enUs], 'en')).toBe(enUs);
+    });
+    it('prefers a closer language match over a more distant one', () => {
+        const enUs = track({ id: 'en-US', language: 'en-US' });
+        const enGb = track({ id: 'en-GB', language: 'en-GB' });
+        // Exact 'en-US' (relatedness 4) beats sibling 'en-GB' (relatedness 2).
+        expect(pickPreferredTextTrack([enGb, enUs], 'en-US')).toBe(enUs);
+    });
+});

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

@@ -2,7 +2,7 @@
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { TrackBase, trackBaseOptionsValidator, } from '@amazon/vinyl';
+import { TrackBase, trackConfigOptionsValidator, } from '@amazon/vinyl';
 import { Abort, createShortUid, DisposedError, } from '@amazon/vinyl-util';
 import { MockDrmController, MockPlaybackController, } from '@amazon/vinyl/vinylTestUtil';
 import { createEventSpy } from '@amazon/vinyl-util/testUtil';
@@ -29,6 +29,9 @@ describe('TrackBase', () => {
         simulateError(error) {
             this.errorHandler(error);
         }
+        simulateSetSeekRange(value) {
+            this.setSeekRange(value);
+        }
     }
     let track;
     let playbackController;
@@ -151,13 +154,13 @@ describe('TrackBase', () => {
             });
         });
     });
-    describe('trackBaseOptionsValidator', () => {
-        it('validates the track layout options config shape', () => {
-            expect(trackBaseOptionsValidator.isValid({
+    describe('trackConfigOptionsValidator', () => {
+        it('validates the track config options shape', () => {
+            expect(trackConfigOptionsValidator.isValid({
                 startTime: 44,
                 extra: {},
             })).toBeTrue();
-            expect(trackBaseOptionsValidator.isValid({
+            expect(trackConfigOptionsValidator.isValid({
                 startTime: '44',
                 extra: {},
             })).toBeFalse();
@@ -184,6 +187,14 @@ describe('TrackBase', () => {
             });
         });
     });
+    describe('setSeekRange', () => {
+        it('does not re-emit seekRangeChange when the range is unchanged', () => {
+            track.simulateSetSeekRange({ start: 0, end: 60 });
+            const seekRangeSpy = createEventSpy(track, 'seekRangeChange');
+            track.simulateSetSeekRange({ start: 0, end: 60 });
+            expect(seekRangeSpy).not.toHaveBeenCalled();
+        });
+    });
     describe('reset', () => {
         let resetSpy;
         beforeEach(() => {
@@ -201,5 +212,39 @@ describe('TrackBase', () => {
             expect(track.error).toBeNull();
             expect(resetSpy).toHaveBeenCalledOnceWith({});
         });
+        describe('hard reset of an active track', () => {
+            beforeEach(() => {
+                playbackController.play.and.resolveTo(void 0);
+                track.activate({ startTime: 5 });
+                // Clear calls captured during activate so assertions only
+                // observe the reset behavior.
+                track.onActivated.calls.reset();
+                track.onDeactivated.calls.reset();
+                track.clearPrefetch.calls.reset();
+                playbackController.seekTo.calls.reset();
+            });
+            it('deactivates, activates, and restores the playback time', () => {
+                playbackController.currentTime = 42;
+                track.reset(true);
+                expect(track.onDeactivated).toHaveBeenCalledOnceWith();
+                expect(track.clearPrefetch).toHaveBeenCalledOnceWith();
+                expect(track.onActivated).toHaveBeenCalledOnceWith({
+                    startTime: 5,
+                });
+                expect(playbackController.seekTo).toHaveBeenCalledOnceWith(42);
+                expect(resetSpy).toHaveBeenCalledOnceWith({});
+            });
+            it('resumes playback when it was not paused', () => {
+                playbackController.paused = false;
+                playbackController.ended = false;
+                track.reset(true);
+                expect(playbackController.play).toHaveBeenCalledOnceWith();
+            });
+            it('does not resume playback when it was paused', () => {
+                playbackController.paused = true;
+                track.reset(true);
+                expect(playbackController.play).not.toHaveBeenCalled();
+            });
+        });
     });
 });