@amazon/vinyl 1.2.0 → 1.2.2

package/dist/unit/types/current/util/media/codecOverrides.test.d.ts

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

package/dist/unit/types/current/util/media/codecOverrides.test.d.ts.map

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

package/dist/unit/types/current/util/media/codecOverrides.test.js

@@ -0,0 +1,42 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { resolveCodecOverride } from '@amazon/vinyl';
+describe('codecOverrides', () => {
+    describe('resolveCodecOverride', () => {
+        it('returns undefined when overrides are undefined', () => {
+            expect(resolveCodecOverride('video/mp4; codecs="hvc1.1"', undefined)).toBeUndefined();
+        });
+        it('returns undefined when overrides are empty', () => {
+            expect(resolveCodecOverride('video/mp4; codecs="hvc1.1"', {})).toBeUndefined();
+        });
+        it('returns undefined when no key matches', () => {
+            expect(resolveCodecOverride('video/mp4; codecs="avc1.64001f"', {
+                hvc1: 'deny',
+            })).toBeUndefined();
+        });
+        it('matches a codec by prefix', () => {
+            expect(resolveCodecOverride('video/mp4; codecs="hvc1.2.20000000.L123.B0"', { hvc1: 'deny' })).toBe('deny');
+        });
+        it('resolves an allow', () => {
+            expect(resolveCodecOverride('video/mp4; codecs="av01.0.05M.08"', {
+                av01: 'allow',
+            })).toBe('allow');
+        });
+        it('is case-insensitive on the key', () => {
+            expect(resolveCodecOverride('video/mp4; codecs="HVC1.1"', {
+                hvc1: 'deny',
+            })).toBe('deny');
+        });
+        it('deny wins over allow across multiple codecs', () => {
+            expect(resolveCodecOverride('video/mp4; codecs="hvc1.1,mp4a.40.2"', {
+                mp4a: 'allow',
+                hvc1: 'deny',
+            })).toBe('deny');
+        });
+        it('returns undefined when the mimeType has no codecs', () => {
+            expect(resolveCodecOverride('video/mp4', { hvc1: 'deny' })).toBeUndefined();
+        });
+    });
+});

package/dist/unit/types/current/util/media/codecSupport.test.d.ts

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

package/dist/unit/types/current/util/media/codecSupport.test.d.ts.map

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

package/dist/unit/types/current/util/media/codecSupport.test.js

@@ -0,0 +1,26 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { extractCodecs } from '@amazon/vinyl';
+describe('codecSupport', () => {
+    describe('extractCodecs', () => {
+        it('extracts a single codec from a mimeType', () => {
+            expect(extractCodecs('video/mp4; codecs="avc1.64001f"')).toEqual([
+                'avc1.64001f',
+            ]);
+        });
+        it('extracts multiple comma-separated codecs', () => {
+            expect(extractCodecs('video/mp4; codecs="avc1.64001f,mp4a.40.2"')).toEqual(['avc1.64001f', 'mp4a.40.2']);
+        });
+        it('handles unquoted codecs', () => {
+            expect(extractCodecs('audio/mp4; codecs=ac-3')).toEqual(['ac-3']);
+        });
+        it('returns empty when no codecs parameter is present', () => {
+            expect(extractCodecs('video/mp4')).toEqual([]);
+        });
+        it('trims whitespace around codecs', () => {
+            expect(extractCodecs('video/mp4; codecs="hvc1.1 , mp4a.40.2"')).toEqual(['hvc1.1', 'mp4a.40.2']);
+        });
+    });
+});

package/dist/unit/types/current/util/media/mimeType.test.d.ts

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

package/dist/unit/types/current/util/media/mimeType.test.d.ts.map

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

package/dist/unit/types/current/util/media/mimeType.test.js

@@ -0,0 +1,22 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { mimeSubtype } from '@amazon/vinyl';
+describe('mimeSubtype', () => {
+    it('returns the subtype after the slash', () => {
+        expect(mimeSubtype('audio/mp4')).toBe('mp4');
+        expect(mimeSubtype('video/webm')).toBe('webm');
+    });
+    it('ignores codec and other parameters', () => {
+        expect(mimeSubtype('video/webm; codecs="vp9"')).toBe('webm');
+        expect(mimeSubtype('audio/mp4;codecs="mp4a.40.2"')).toBe('mp4');
+    });
+    it('lowercases and trims', () => {
+        expect(mimeSubtype('  VIDEO/MP4 ; codecs="avc1"')).toBe('mp4');
+    });
+    it('returns an empty string when there is no subtype', () => {
+        expect(mimeSubtype('video')).toBe('');
+        expect(mimeSubtype('')).toBe('');
+    });
+});

package/dist/unit/types/current/vinyl/VinylPlayerAdBreaks.test.d.ts

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

package/dist/unit/types/current/vinyl/VinylPlayerAdBreaks.test.d.ts.map

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

package/dist/unit/types/current/vinyl/VinylPlayerAdBreaks.test.js

@@ -0,0 +1,142 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AdControllerImpl, createVinylPlayer, } from '@amazon/vinyl';
+import { externalDependencies } from '@amazon/vinyl-di';
+import { createMockVinylDependencies, MockTrack, } from '@amazon/vinyl/vinylTestUtil';
+import { MockHTMLAudioElement } from '@amazon/vinyl-util/browserTestUtil';
+import { createEventSpy } from '@amazon/vinyl-util/testUtil';
+describe('VinylPlayer ad break API', () => {
+    let adController;
+    let base;
+    let depFactories;
+    let player;
+    beforeEach(() => {
+        base = createMockVinylDependencies();
+        // Use a real ad controller so setTrackAds drives state and events that the
+        // player getters and redispatch reflect.
+        adController = new AdControllerImpl({
+            playbackController: base.playbackController,
+        });
+        depFactories = externalDependencies({ ...base, adController });
+        player = createVinylPlayer({ media: new MockHTMLAudioElement() }, depFactories);
+    });
+    afterEach(() => {
+        player.dispose();
+    });
+    function makeBreak(overrides = {}) {
+        return {
+            id: 'b1',
+            startTime: 10,
+            duration: 5,
+            placement: 'midroll',
+            restrict: {},
+            once: false,
+            resumeOffset: null,
+            playoutLimit: null,
+            resolutionTimeOffset: null,
+            skipControl: () => null,
+            ads: () => Promise.resolve([
+                {
+                    id: 'a1',
+                    startTime: 10,
+                    duration: 5,
+                    uri: 'ad.m3u8',
+                },
+            ]),
+            ...overrides,
+        };
+    }
+    function trackAds(...adBreaks) {
+        return { trackUri: 't1', adBreaks };
+    }
+    function simulateTimeUpdate(time) {
+        base.playbackController.currentTime = time;
+        base.playbackController.dispatch('timeUpdate', {
+            previous: 0,
+            current: time,
+        });
+    }
+    /** Waits for pending microtasks (ad resolution) to settle. */
+    async function flush() {
+        await Promise.resolve();
+        await Promise.resolve();
+    }
+    /**
+     * Activates a content parent track whose getAds() resolves the given ads
+     * and marks playback playing — the state the ad controller requires before
+     * it scans for midroll ingress. Awaits the async ad resolution.
+     */
+    async function setContent(ads) {
+        const track = new MockTrack();
+        track.uri = ads.trackUri;
+        track.active = true;
+        track.ads = ads;
+        base.playbackController.playing = true;
+        adController.setAdsProvider(track);
+        await flush();
+    }
+    it('returns empty defaults when no ad breaks are set', () => {
+        expect(player.currentTrackAds).toBeNull();
+        expect(player.currentAdBreak).toBeNull();
+    });
+    it('returns ad breaks from the player-level ad controller', async () => {
+        await setContent(trackAds(makeBreak()));
+        expect(player.currentTrackAds?.adBreaks.map((b) => b.id)).toEqual([
+            'b1',
+        ]);
+    });
+    it('redispatches currentTrackAdsChange from the ad controller', async () => {
+        const spy = createEventSpy(player, 'currentTrackAdsChange');
+        await setContent(trackAds(makeBreak()));
+        expect(spy).toHaveBeenCalled();
+    });
+    it('redispatches adBreakEntered and adBreakCompleted from the ad controller', async () => {
+        await setContent(trackAds(makeBreak({ startTime: 10, duration: 5 })));
+        const entered = createEventSpy(player, 'adBreakEntered');
+        const completed = createEventSpy(player, 'adBreakCompleted');
+        simulateTimeUpdate(11);
+        await flush();
+        expect(entered).toHaveBeenCalledTimes(1);
+        expect(entered.calls.mostRecent().args[0].adBreak.id).toBe('b1');
+        // Exit via skipAd (updateTime is blocked while an ad is active)
+        player.skipAd();
+        expect(completed).toHaveBeenCalledTimes(1);
+        expect(completed.calls.mostRecent().args[0].adBreak.id).toBe('b1');
+    });
+    it('reflects the current ad break through the player getter', async () => {
+        await setContent(trackAds(makeBreak({ startTime: 0, duration: 10 })));
+        simulateTimeUpdate(5);
+        await flush();
+        expect(player.currentAdBreak?.id).toBe('b1');
+    });
+    it('reflects the current ad through the player getter', async () => {
+        await setContent(trackAds(makeBreak({ startTime: 0, duration: 10 })));
+        expect(player.currentAd).toBeNull();
+        simulateTimeUpdate(5);
+        await flush();
+        expect(player.currentAd?.id).toBe('a1');
+    });
+    it('skipAd delegates to the ad controller', async () => {
+        await setContent(trackAds(makeBreak({ startTime: 0, duration: 10 })));
+        simulateTimeUpdate(5);
+        await flush();
+        expect(player.currentAdBreak).not.toBeNull();
+        player.skipAd();
+        expect(player.currentAdBreak).toBeNull();
+    });
+    it('skipAdBreak delegates to the ad controller', async () => {
+        await setContent(trackAds(makeBreak({ startTime: 0, duration: 10 })));
+        simulateTimeUpdate(5);
+        await flush();
+        player.skipAdBreak();
+        expect(player.currentAdBreak).toBeNull();
+    });
+    it('skipAd is a no-op without an active break', () => {
+        expect(() => player.skipAd()).not.toThrow();
+    });
+    it('skipAdBreak is a no-op without an active break', () => {
+        expect(() => player.skipAdBreak()).not.toThrow();
+    });
+});

package/dist/unit/types/current/vinyl/VinylPlayerTextTracks.test.d.ts

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

package/dist/unit/types/current/vinyl/VinylPlayerTextTracks.test.d.ts.map

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

package/dist/unit/types/current/vinyl/VinylPlayerTextTracks.test.js

@@ -0,0 +1,188 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createVinylPlayer, } from '@amazon/vinyl';
+import { externalDependencies } from '@amazon/vinyl-di';
+import { createMockVinylDependencies, MockTextTrackController, MockTrack, } from '@amazon/vinyl/vinylTestUtil';
+import { MockHTMLAudioElement } from '@amazon/vinyl-util/browserTestUtil';
+import { createEventSpy } from '@amazon/vinyl-util/testUtil';
+/**
+ * These tests cover the player's read-through getters and event redispatch
+ * across track changes. Selection itself is declarative (driven by
+ * `VinylOptions.text`), so the tests drive a {@link MockTextTrackController}'s
+ * state and events directly rather than calling any imperative select API.
+ */
+describe('VinylPlayer text track API', () => {
+    let deps;
+    let depFactories;
+    let player;
+    beforeEach(() => {
+        deps = createMockVinylDependencies();
+        depFactories = externalDependencies(deps);
+        player = createVinylPlayer({ media: new MockHTMLAudioElement() }, depFactories);
+    });
+    afterEach(() => {
+        player.dispose();
+    });
+    function info(overrides = {}) {
+        return {
+            id: 't1',
+            kind: 'subtitles',
+            language: 'en',
+            label: 'A',
+            default: false,
+            forced: false,
+            characteristics: [],
+            uri: 'a.vtt',
+            mimeType: 'text/vtt',
+            ...overrides,
+        };
+    }
+    function makeTrackWithController() {
+        const track = new MockTrack();
+        const controller = new MockTextTrackController();
+        track.textTrackController = controller;
+        return { track, controller };
+    }
+    /** Sets the controller's track list and emits the change (as the real one does). */
+    function setTracks(controller, tracks) {
+        const previous = controller.textTracks;
+        controller.textTracks = tracks;
+        controller.dispatch('textTracksChange', { previous, current: tracks });
+    }
+    /** Sets the controller's active selection and emits the change. */
+    function setActive(controller, current) {
+        const previous = controller.activeTextTrack;
+        controller.activeTextTrack = current;
+        controller.dispatch('activeTextTrackChange', { previous, current });
+    }
+    function activate(track) {
+        deps.trackController.activeTrack = track;
+        deps.trackController.dispatch('trackActivated', { track });
+    }
+    it('returns empty defaults when no current track', () => {
+        expect(player.textTracks).toEqual([]);
+        expect(player.activeTextTrack).toBeNull();
+    });
+    it('returns text tracks from the current track', () => {
+        const { track, controller } = makeTrackWithController();
+        controller.textTracks = [info()];
+        activate(track);
+        expect(player.textTracks.length).toBe(1);
+    });
+    it('reflects the current track controller active selection', () => {
+        const { track, controller } = makeTrackWithController();
+        controller.textTracks = [info()];
+        activate(track);
+        setActive(controller, info());
+        expect(player.activeTextTrack?.id).toBe('t1');
+        setActive(controller, null);
+        expect(player.activeTextTrack).toBeNull();
+    });
+    it('reports null active when the current track has no controller', () => {
+        const track = new MockTrack();
+        activate(track);
+        expect(player.activeTextTrack).toBeNull();
+    });
+    it('redispatches textTracksChange events from the active controller', () => {
+        const { track, controller } = makeTrackWithController();
+        activate(track);
+        const spy = createEventSpy(player, 'textTracksChange');
+        setTracks(controller, [info({ language: null })]);
+        expect(spy).toHaveBeenCalled();
+    });
+    it('fires textTracksChange when switching to a track with a different list', () => {
+        const a = makeTrackWithController();
+        const b = makeTrackWithController();
+        setTracks(a.controller, [info({ id: 't1', language: 'en' })]);
+        setTracks(b.controller, [
+            info({ id: 't2', language: 'fr', label: 'B' }),
+        ]);
+        activate(a.track);
+        const spy = createEventSpy(player, 'textTracksChange');
+        activate(b.track);
+        expect(spy).toHaveBeenCalled();
+    });
+    it('fires activeTextTrackChange when switching tracks', () => {
+        const a = makeTrackWithController();
+        const b = makeTrackWithController();
+        setTracks(a.controller, [info({ id: 't1' })]);
+        setActive(a.controller, info({ id: 't1' }));
+        activate(a.track);
+        const spy = createEventSpy(player, 'activeTextTrackChange');
+        activate(b.track);
+        expect(spy).toHaveBeenCalled();
+    });
+    it('re-announces the content caption after an ad break so it does not read as off', () => {
+        // Regression: enabling captions during an ad and then letting content
+        // resume left consumers that track state via activeTextTrackChange
+        // believing captions were off, because the outgoing ad controller emits
+        // a clearing activeTextTrackChange(null) while the content's preserved
+        // (here forced) selection is restored silently on activate().
+        const content = makeTrackWithController();
+        const contentForced = info({
+            id: 'c-forced',
+            label: 'English (Forced)',
+            default: true,
+            forced: true,
+            uri: 'c.vtt',
+        });
+        setTracks(content.controller, [contentForced]);
+        setActive(content.controller, contentForced);
+        const ad = makeTrackWithController();
+        const adCc = info({ id: 'ad-cc', label: 'English', uri: 'ad.vtt' });
+        setTracks(ad.controller, [adCc]);
+        // Content becomes current.
+        activate(content.track);
+        // Enter the ad break: the content selection is preserved (deactivate
+        // keeps the selection) rather than cleared.
+        deps.adController.currentAdBreak = { placement: 'midroll' };
+        content.controller.deactivate();
+        activate(ad.track);
+        // Viewer enables the ad's captions during the break.
+        setActive(ad.controller, adCc);
+        expect(player.activeTextTrack?.id).toBe('ad-cc');
+        // Ad ends, content resumes.
+        deps.adController.currentAdBreak = null;
+        const spy = createEventSpy(player, 'activeTextTrackChange');
+        content.controller.activate();
+        activate(content.track);
+        // The player reports the content's forced caption as active again and,
+        // crucially, the last active-change event announces it — not the ad's
+        // clearing null.
+        expect(player.activeTextTrack?.id).toBe('c-forced');
+        expect(spy).toHaveBeenCalled();
+        const lastCurrent = spy.calls.mostRecent().args[0].current;
+        expect(lastCurrent?.id).toBe('c-forced');
+    });
+    it('announces empty tracks and null active when the track is torn down', () => {
+        // Real teardown (unload) transitions to null: the player must emit the
+        // cleared list/selection so consumers see captions go away.
+        const a = makeTrackWithController();
+        const t = info({ id: 't1' });
+        setTracks(a.controller, [t]);
+        setActive(a.controller, t);
+        activate(a.track);
+        const tracksSpy = createEventSpy(player, 'textTracksChange');
+        const activeSpy = createEventSpy(player, 'activeTextTrackChange');
+        // trackDeactivated with no ad break tears the current track down to null.
+        deps.trackController.activeTrack = null;
+        deps.trackController.dispatch('trackDeactivated', { track: a.track });
+        expect(tracksSpy).toHaveBeenCalled();
+        expect(tracksSpy.calls.mostRecent().args[0].current).toEqual([]);
+        expect(activeSpy).toHaveBeenCalled();
+        expect(activeSpy.calls.mostRecent().args[0].current).toBeNull();
+        expect(player.activeTextTrack).toBeNull();
+    });
+    it('does not emit activeTextTrackChange when neither track has an active selection', () => {
+        // Both tracks are text-capable but nothing is active — the current
+        // track change should not manufacture a spurious active-change event.
+        const a = makeTrackWithController();
+        const b = makeTrackWithController();
+        activate(a.track);
+        const spy = createEventSpy(player, 'activeTextTrackChange');
+        activate(b.track);
+        expect(spy).not.toHaveBeenCalled();
+    });
+});

package/dist/vinylTestUtil/types/current/mock/ad/MockAdController.d.ts

@@ -0,0 +1,15 @@
+import type { AdBreakInfo, AdController, AdInfo, TrackAds } from '../../../../src';
+import { MockEventHost } from '@amazon/vinyl-util/testUtil';
+export declare class MockAdController extends MockEventHost implements AdController {
+    currentTrackAds: TrackAds | null;
+    currentAd: AdInfo | null;
+    currentAdBreak: AdBreakInfo | null;
+    setAdsProvider: import("@amazon/vinyl-util/browserTestUtil").Spy2<(provider: import("../../../../src").AdsProvider | null) => void>;
+    failAd: import("@amazon/vinyl-util/browserTestUtil").Spy2<(error: Error) => void>;
+    skipAd: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+    skipAdBreak: import("@amazon/vinyl-util/browserTestUtil").Spy2<() => void>;
+    enterPreroll: import("@amazon/vinyl-util/browserTestUtil").Spy2<(() => Promise<AdBreakInfo | null>) & (() => any)>;
+    enterPostroll: import("@amazon/vinyl-util/browserTestUtil").Spy2<(() => Promise<AdBreakInfo | null>) & (() => any)>;
+    constructor();
+}
+//# sourceMappingURL=MockAdController.d.ts.map

package/dist/vinylTestUtil/types/current/mock/ad/MockAdController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockAdController.d.ts","sourceRoot":"","sources":["../../../../../../test/vinylTestUtil/mock/ad/MockAdController.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACR,WAAW,EACX,YAAY,EACZ,MAAM,EACN,QAAQ,EACX,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAA;AAI3D,qBAAa,gBAAiB,SAAQ,aAAc,YAAW,YAAY;IACvE,eAAe,EAAE,QAAQ,GAAG,IAAI,CAAO;IACvC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAO;IAC/B,cAAc,EAAE,WAAW,GAAG,IAAI,CAAO;IAEzC,cAAc,sHAA+B;IAC7C,MAAM,4EAAuB;IAC7B,MAAM,gEAAuB;IAC7B,WAAW,gEAA4B;IACvC,YAAY,uGAA6B;IACzC,aAAa,uGAA8B;;CAU9C"}

package/dist/vinylTestUtil/types/current/mock/ad/MockAdController.js

@@ -0,0 +1,26 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { MockEventHost } from '@amazon/vinyl-util/testUtil';
+import { createSpyFactory } from '@amazon/vinyl-util/browserTestUtil';
+const spyFactory = createSpyFactory();
+export class MockAdController extends MockEventHost {
+    currentTrackAds = null;
+    currentAd = null;
+    currentAdBreak = null;
+    setAdsProvider = spyFactory('setAdsProvider');
+    failAd = spyFactory('failAd');
+    skipAd = spyFactory('skipAd');
+    skipAdBreak = spyFactory('skipAdBreak');
+    enterPreroll = spyFactory('enterPreroll');
+    enterPostroll = spyFactory('enterPostroll');
+    constructor() {
+        super();
+        // enterPreroll/enterPostroll are awaited by the TrackController, so
+        // default them to resolve with "no roll" (null); tests override with
+        // resolveTo() as needed.
+        this.enterPreroll.and.resolveTo(null);
+        this.enterPostroll.and.resolveTo(null);
+    }
+}