@amazon/vinyl 1.2.1 → 1.2.2

package/dist/unit/types/current/playback/createStallDetector.test.js

@@ -0,0 +1,163 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createStallDetector } from '@amazon/vinyl';
+import { implementEventFakes, MockHTMLAudioElement, mockEvent, MockTimeRanges, useMockTime, } from '@amazon/vinyl-util/browserTestUtil';
+describe('createStallDetector', () => {
+    const clock = useMockTime();
+    let media;
+    let fabricatePlaying;
+    let stop;
+    beforeEach(() => {
+        media = new MockHTMLAudioElement();
+        implementEventFakes(media);
+        media.play.and.returnValue(Promise.resolve());
+        media.paused = false;
+        media.ended = false;
+        media.readyState = media.HAVE_ENOUGH_DATA;
+        media.currentTime = 10;
+        media.buffered = new MockTimeRanges([[0, 100]]);
+        fabricatePlaying = jasmine.createSpy('fabricatePlaying');
+    });
+    afterEach(() => {
+        stop?.();
+    });
+    function detect(overrides = {}) {
+        stop = createStallDetector(media, { fabricatePlaying, ...overrides });
+    }
+    /** Advances the mock clock by `n` default poll intervals. */
+    async function poll(n) {
+        for (let i = 0; i < n; i++) {
+            await clock.tick(0.25);
+        }
+    }
+    describe('a stall inside ready buffered data', () => {
+        it('nudges the play head once frozen past the stall threshold', async () => {
+            detect();
+            // Threshold is 0.75s = three polls; the third nudges by stallSkip.
+            await poll(3);
+            expect(media.currentTime).toBeCloseTo(10.1);
+        });
+        it('does not recover before the stall threshold', async () => {
+            detect();
+            await poll(2);
+            expect(media.currentTime).toBe(10);
+            expect(media.play).not.toHaveBeenCalled();
+        });
+        it('nudges even when the ready state is low (iOS reports a stale readyState)', async () => {
+            media.readyState = media.HAVE_METADATA;
+            detect();
+            await poll(3);
+            expect(media.currentTime).toBeCloseTo(10.1);
+            expect(media.play).not.toHaveBeenCalled();
+        });
+        it('keeps nudging, then gives up after maxAttempts', async () => {
+            detect();
+            // Default maxAttempts is 3, so at most three nudges (one every 3 polls).
+            await poll(12);
+            expect(media.currentTime).toBeCloseTo(10.3);
+            // Further polls do nothing; the detector has stopped.
+            await poll(6);
+            expect(media.currentTime).toBeCloseTo(10.3);
+        });
+    });
+    describe('a stall with no data at the playhead', () => {
+        it('does not recover when the playhead is outside all buffered ranges', async () => {
+            media.buffered = new MockTimeRanges([[50, 100]]);
+            detect();
+            await poll(6);
+            expect(media.currentTime).toBe(10);
+            expect(fabricatePlaying).not.toHaveBeenCalled();
+        });
+        it('does not recover at the end of buffered data', async () => {
+            // Within the default end margin (0.5s) of the buffer end.
+            media.buffered = new MockTimeRanges([[0, 10.3]]);
+            detect();
+            await poll(6);
+            expect(media.currentTime).toBe(10);
+        });
+        it('nudges at the end of the media (stuck end-of-track on src)', async () => {
+            // Buffer ends at the media duration: no more data is coming, so a
+            // freeze here is a stuck end-of-track and a nudge drives it to end.
+            media.buffered = new MockTimeRanges([[0, 10.3]]);
+            media.duration = 10.3;
+            detect();
+            await poll(3);
+            expect(media.currentTime).toBeCloseTo(10.1);
+        });
+        it('nudges outside buffered ranges when nudgeUnbuffered is set', async () => {
+            // WebKit path: re-issue the seek even though buffered looks empty.
+            media.buffered = new MockTimeRanges([[50, 100]]);
+            detect({ nudgeUnbuffered: true });
+            await poll(3);
+            expect(media.currentTime).toBeCloseTo(10.1);
+        });
+        it('stops when the source is emptied', async () => {
+            detect();
+            media.dispatchEvent(mockEvent('emptied'));
+            // Stopped: a later freeze in buffered data is not nudged.
+            await poll(6);
+            expect(media.currentTime).toBe(10);
+        });
+    });
+    describe('fabricating a playing event', () => {
+        it('fabricates when the head progresses without a playing event', async () => {
+            detect();
+            media.currentTime = 20;
+            await poll(1);
+            expect(fabricatePlaying).toHaveBeenCalledTimes(1);
+            // Detector stopped; a later freeze is not recovered.
+            await poll(6);
+            expect(media.play).not.toHaveBeenCalled();
+        });
+        it('does not fabricate when a real playing event fired and it keeps progressing', async () => {
+            detect();
+            media.dispatchEvent(mockEvent('playing'));
+            media.currentTime = 20;
+            await poll(6);
+            expect(fabricatePlaying).not.toHaveBeenCalled();
+        });
+        it('fabricates after reviving a stall even if a playing event fired earlier', async () => {
+            // iOS pattern: a playing event fires, then playback stalls.
+            media.readyState = media.HAVE_METADATA;
+            detect();
+            media.dispatchEvent(mockEvent('playing'));
+            await poll(3);
+            expect(media.currentTime).toBeCloseTo(10.1); // nudged (recovered)
+            // The recovery revives playback.
+            media.currentTime = 11;
+            await poll(1);
+            expect(fabricatePlaying).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('when the element is not advancing by design', () => {
+        it('does not recover while paused', async () => {
+            media.paused = true;
+            detect();
+            await poll(6);
+            expect(media.play).not.toHaveBeenCalled();
+            expect(media.currentTime).toBe(10);
+        });
+        it('does not recover once ended', async () => {
+            media.ended = true;
+            detect();
+            await poll(6);
+            expect(media.play).not.toHaveBeenCalled();
+            expect(media.currentTime).toBe(10);
+        });
+    });
+    it('honors provided options', async () => {
+        detect({
+            pollInterval: 0.5,
+            stallThreshold: 1,
+            bufferEndMargin: 0.2,
+            stallSkip: 0.25,
+            maxAttempts: 1,
+        });
+        // Threshold 1s = two 0.5s polls; one nudge of 0.25, then it gives up.
+        for (let i = 0; i < 6; i++)
+            await clock.tick(0.5);
+        expect(media.currentTime).toBeCloseTo(10.25);
+    });
+});

package/dist/unit/types/current/playback/createStallMonitor.test.d.ts

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

package/dist/unit/types/current/playback/createStallMonitor.test.d.ts.map

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

package/dist/unit/types/current/playback/createStallMonitor.test.js

@@ -0,0 +1,163 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createStallMonitor, StallEndedReason, } from '@amazon/vinyl';
+import { EventHostImpl } from '@amazon/vinyl-util';
+import { useMockTime } from '@amazon/vinyl-util/browserTestUtil';
+describe('createStallMonitor', () => {
+    const clock = useMockTime();
+    let host;
+    let onStallEntered;
+    let onStallEnded;
+    let stop;
+    beforeEach(() => {
+        host = new EventHostImpl();
+        onStallEntered = jasmine.createSpy('onStallEntered');
+        onStallEnded = jasmine.createSpy('onStallEnded');
+    });
+    afterEach(() => stop?.());
+    function monitor(overrides = {}) {
+        stop = createStallMonitor(host, { onStallEntered, onStallEnded }, overrides);
+    }
+    /** Advances the mock clock by `n` default (0.25s) poll intervals. */
+    async function poll(n) {
+        for (let i = 0; i < n; i++)
+            await clock.tick(0.25);
+    }
+    it('does not report a stall before playback is observed', async () => {
+        monitor();
+        // No 'playing' has been observed (e.g. initial load / awaiting a seek).
+        await poll(8);
+        expect(onStallEntered).not.toHaveBeenCalled();
+    });
+    it('reports a stall once the play head is frozen past the threshold', async () => {
+        monitor();
+        host.dispatch('playing', {});
+        await poll(3); // 0.75s < 1s threshold
+        expect(onStallEntered).not.toHaveBeenCalled();
+        await poll(1); // 1s
+        expect(onStallEntered).toHaveBeenCalledTimes(1);
+    });
+    it('honors a configurable threshold', async () => {
+        monitor({ stallThreshold: 2 });
+        host.dispatch('playing', {});
+        await poll(4); // 1s < 2s
+        expect(onStallEntered).not.toHaveBeenCalled();
+        await poll(4); // 2s
+        expect(onStallEntered).toHaveBeenCalledTimes(1);
+    });
+    it('does not report a stall while timeUpdates keep arriving', async () => {
+        monitor();
+        host.dispatch('playing', {});
+        for (let i = 0; i < 10; i++) {
+            await poll(2); // 0.5s, under the threshold
+            host.dispatch('timeUpdate', { previous: i, current: i + 1 });
+        }
+        expect(onStallEntered).not.toHaveBeenCalled();
+    });
+    it('ends a stall with reason "playing" when the play head advances, measuring from the last timeUpdate', async () => {
+        monitor();
+        host.dispatch('playing', {});
+        host.dispatch('timeUpdate', { previous: 0, current: 1 });
+        await poll(4); // freeze 1s -> stallEntered
+        expect(onStallEntered).toHaveBeenCalledTimes(1);
+        await poll(4); // frozen another 1s (total 2s)
+        host.dispatch('timeUpdate', { previous: 1, current: 2 }); // resume
+        expect(onStallEnded).toHaveBeenCalledTimes(1);
+        const info = onStallEnded.calls.mostRecent().args[0];
+        expect(info.reason).toBe(StallEndedReason.PLAYING);
+        expect(info.duration).toBeCloseTo(2, 1);
+    });
+    for (const [event, reason] of [
+        ['pause', StallEndedReason.PAUSE],
+        ['seeking', StallEndedReason.SEEKING],
+        ['emptied', StallEndedReason.EMPTIED],
+    ]) {
+        it(`ends a stall with reason "${reason}" on ${event}`, async () => {
+            monitor();
+            host.dispatch('playing', {});
+            await poll(4); // stallEntered
+            expect(onStallEntered).toHaveBeenCalledTimes(1);
+            host.dispatch(event, {});
+            expect(onStallEnded).toHaveBeenCalledTimes(1);
+            expect(onStallEnded.calls.mostRecent().args[0].reason).toBe(reason);
+        });
+    }
+    it('ends a stall with reason "playing" when a playing event fires (resume without a timeUpdate)', async () => {
+        monitor();
+        host.dispatch('playing', {});
+        await poll(4); // stallEntered
+        expect(onStallEntered).toHaveBeenCalledTimes(1);
+        // A 'playing' event (rather than a timeUpdate) signals the resume.
+        host.dispatch('playing', {});
+        expect(onStallEnded).toHaveBeenCalledTimes(1);
+        expect(onStallEnded.calls.mostRecent().args[0].reason).toBe(StallEndedReason.PLAYING);
+    });
+    it('suspends detection after a seek until playback is observed again', async () => {
+        monitor();
+        host.dispatch('playing', {});
+        host.dispatch('seeking', {}); // suspends; observedPlaying = false
+        await poll(8);
+        expect(onStallEntered).not.toHaveBeenCalled();
+        // Once playback is observed again, detection resumes.
+        host.dispatch('playing', {});
+        await poll(4);
+        expect(onStallEntered).toHaveBeenCalledTimes(1);
+    });
+    it('reports each stall/recovery cycle', async () => {
+        monitor();
+        host.dispatch('playing', {});
+        await poll(4);
+        host.dispatch('timeUpdate', { previous: 0, current: 1 }); // resume 1
+        await poll(4);
+        host.dispatch('timeUpdate', { previous: 1, current: 2 }); // resume 2
+        expect(onStallEntered).toHaveBeenCalledTimes(2);
+        expect(onStallEnded).toHaveBeenCalledTimes(2);
+    });
+    it('does not end and re-detect a stall on a non-advancing timeUpdate', async () => {
+        // Browsers emit `timeUpdate` even while the play head is frozen, with an unchanged (or
+        // briefly backward) currentTime. These must not be treated as progress, or the stall is
+        // ended and immediately re-detected, doubling the reported events.
+        monitor();
+        host.dispatch('playing', {});
+        host.dispatch('timeUpdate', { previous: 4, current: 5 });
+        await poll(4); // freeze 1s -> stallEntered
+        expect(onStallEntered).toHaveBeenCalledTimes(1);
+        // Still frozen: currentTime hasn't advanced (unchanged, backward, or sub-epsilon jitter).
+        host.dispatch('timeUpdate', { previous: 5, current: 5 });
+        host.dispatch('timeUpdate', { previous: 5, current: 4.99 });
+        host.dispatch('timeUpdate', { previous: 5, current: 5 + 1e-9 });
+        await poll(4);
+        expect(onStallEnded).not.toHaveBeenCalled();
+        expect(onStallEntered).toHaveBeenCalledTimes(1);
+        // A real forward advance ends the stall exactly once.
+        host.dispatch('timeUpdate', { previous: 5, current: 6 });
+        expect(onStallEnded).toHaveBeenCalledTimes(1);
+        expect(onStallEntered).toHaveBeenCalledTimes(1);
+    });
+    it('does not re-detect a stall immediately after resuming via a playing event', async () => {
+        // Resuming via `playing` must restart the freeze clock. Otherwise the poll, still seeing
+        // the stale pre-freeze progress time, immediately re-enters a stall before the first
+        // post-resume timeUpdate arrives — an extra, spurious stall.
+        monitor();
+        host.dispatch('playing', {});
+        host.dispatch('timeUpdate', { previous: 0, current: 1 });
+        await poll(4); // freeze 1s -> stallEntered
+        expect(onStallEntered).toHaveBeenCalledTimes(1);
+        // Resume with a 'playing' event and no timeUpdate yet.
+        host.dispatch('playing', {});
+        expect(onStallEnded).toHaveBeenCalledTimes(1);
+        // The freeze clock reset on resume, so a sub-threshold gap is not a new stall.
+        await poll(3); // 0.75s < 1s threshold
+        expect(onStallEntered).toHaveBeenCalledTimes(1);
+    });
+    it('stops reporting after disposal', async () => {
+        monitor();
+        host.dispatch('playing', {});
+        stop();
+        stop = undefined; // disposal is single-shot; don't dispose again in afterEach
+        await poll(8);
+        expect(onStallEntered).not.toHaveBeenCalled();
+    });
+});

package/dist/unit/types/current/streaming/MseTrack.test.js

@@ -207,6 +207,21 @@ describe('MseTrack', () => {
             expect(deps.playbackSource.load).toHaveBeenCalledOnceWith();
             expect(deps.playbackController.pause).toHaveBeenCalledOnceWith();
         });
+        it('aborts the drm session abort so key sessions close', async () => {
+            // Regression: MSE key sessions must be tied to the per-activation
+            // drmSessionAbort (fired by closeDrmSessions on deactivate), not a
+            // separate abort that never fires — otherwise sessions leak.
+            track = createTrack();
+            await awaitContentTypes();
+            getAudioStream().streamingQuality =
+                createEmptyMediaQualityMetadata();
+            track.activate({});
+            const abort = deps.drmController.initializeForPlayback.calls.mostRecent()
+                .args[1];
+            expect(abort.aborted()).toBeFalse();
+            track.deactivate();
+            expect(abort.aborted()).toBeTrue();
+        });
     });
     describe('error', () => {
         it('returns the first emitted error', async () => {

package/dist/unit/types/current/streaming/createTimelineContentTypesValue.test.d.ts

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

package/dist/unit/types/current/streaming/createTimelineContentTypesValue.test.d.ts.map

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

package/dist/unit/types/current/streaming/createTimelineContentTypesValue.test.js

@@ -0,0 +1,57 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createEmptyMediaQualityMetadata, createTimelineContentTypesValue, } from '@amazon/vinyl';
+import { data } from '@amazon/vinyl-observable';
+function createQuality(contentType) {
+    return {
+        metadata: {
+            ...createEmptyMediaQualityMetadata(),
+            contentType,
+        },
+        getSegment: () => Promise.resolve(null),
+    };
+}
+function timelineOf(...contentTypes) {
+    return {
+        periods: contentTypes.map((types, index) => ({
+            startTime: index * 10,
+            endTime: index * 10 + 10,
+            qualities: types.map(createQuality),
+        })),
+        minBufferTime: 2,
+        getAdBreaks: () => Promise.resolve([]),
+        getDuration: () => Promise.resolve(Infinity),
+    };
+}
+describe('createTimelineContentTypesValue', () => {
+    function contentTypesOf(timeline) {
+        return createTimelineContentTypesValue({
+            mediaTimelineTransformed: data(Promise.resolve(timeline)),
+        }).value;
+    }
+    it('reports every media content type present in the filtered timeline', async () => {
+        const result = await contentTypesOf(timelineOf(['audio', 'audio', 'video']));
+        expect(result).toEqual(new Set(['audio', 'video']));
+    });
+    it('omits a content type whose renditions were all filtered out', async () => {
+        // Every audio rendition dropped (e.g. by the sample-rate filter): video
+        // must still be reported so the load is not stranded waiting for an
+        // audio source buffer that will never be created.
+        const result = await contentTypesOf(timelineOf(['video']));
+        expect(result).toEqual(new Set(['video']));
+    });
+    it('reports only audio when every video rendition was filtered out', async () => {
+        const result = await contentTypesOf(timelineOf(['audio']));
+        expect(result).toEqual(new Set(['audio']));
+    });
+    it('excludes text — captions are a sidecar pipeline, not an MSE source buffer', async () => {
+        const result = await contentTypesOf(timelineOf(['audio', 'video', 'text']));
+        expect(result).toEqual(new Set(['audio', 'video']));
+    });
+    it('unions content types across periods', async () => {
+        const result = await contentTypesOf(timelineOf(['video'], ['audio', 'video']));
+        expect(result).toEqual(new Set(['audio', 'video']));
+    });
+});

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

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

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

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

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

@@ -0,0 +1,12 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { expectTypeStrictlyEquals } from '@amazon/vinyl-util/browserTestUtil';
+describe('ALL_TEXT_TRACK_EVENTS', () => {
+    it('provides a comprehensive list of all text track events', () => {
+        // The player redispatches exactly these; an omission silently stops an
+        // event reaching consumers, and `satisfies` alone does not catch it.
+        expectTypeStrictlyEquals(true);
+    });
+});

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

@@ -42,6 +42,19 @@ describe('discoverDashTextTracks', () => {
         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">
@@ -96,6 +109,10 @@ describe('discoverDashTextTracks', () => {
             </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">

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

@@ -382,6 +382,32 @@ hi`;
         expect(cues.length).toBe(1);
         expect(cues[0].text).toBe('hi');
     });
+    it('parses a cue that follows the signature with no blank line', () => {
+        // The header block ends at a timing line as well as at a blank line
+        // (WebVTT file parsing breaks out of the header loop on `-->`), so a
+        // document omitting the blank line still yields its cues.
+        const text = `WEBVTT
+00:00:01.000 --> 00:00:02.000
+hi
+
+00:00:03.000 --> 00:00:04.000
+there`;
+        const cues = parseWebVtt(text).cues;
+        expect(cues.length).toBe(2);
+        expect(cues[0].startTime).toBe(1);
+        expect(cues[0].text).toBe('hi');
+        expect(cues[1].text).toBe('there');
+    });
+    it('keeps header lines as header when a cue follows with no blank line', () => {
+        const text = `WEBVTT
+Kind: captions
+00:00:01.000 --> 00:00:02.000
+hi`;
+        const cues = parseWebVtt(text).cues;
+        expect(cues.length).toBe(1);
+        expect(cues[0].id).toBeNull();
+        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.