@amazon/vinyl 1.1.1 → 2.0.0

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,263 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createVinylPlayer, SidecarTextTrackController, } 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 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 makeTrackWithController() {
+        const track = new MockTrack();
+        const controller = new SidecarTextTrackController({ media: null });
+        track.textTrackController = controller;
+        return { track, controller };
+    }
+    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.setTextTracks([
+            {
+                id: 't1',
+                kind: 'subtitles',
+                language: 'en',
+                label: 'English',
+                default: false,
+                forced: false,
+                characteristics: [],
+                uri: 'https://x/sub.vtt',
+                mimeType: 'text/vtt',
+            },
+        ]);
+        deps.trackController.activeTrack = track;
+        deps.trackController.dispatch('trackActivated', { track: track });
+        expect(player.textTracks.length).toBe(1);
+    });
+    it('selects an active text track via setActiveTextTrack', () => {
+        const { track, controller } = makeTrackWithController();
+        controller.setTextTracks([
+            {
+                id: 't1',
+                kind: 'subtitles',
+                language: 'en',
+                label: 'English',
+                default: false,
+                forced: false,
+                characteristics: [],
+                uri: 'https://x/sub.vtt',
+                mimeType: 'text/vtt',
+            },
+        ]);
+        deps.trackController.activeTrack = track;
+        deps.trackController.dispatch('trackActivated', { track: track });
+        player.setActiveTextTrack('t1');
+        expect(player.activeTextTrack?.id).toBe('t1');
+        player.setActiveTextTrack(null);
+        expect(player.activeTextTrack).toBeNull();
+    });
+    it('ignores setActiveTextTrack when current track has no controller', () => {
+        const track = new MockTrack();
+        deps.trackController.activeTrack = track;
+        deps.trackController.dispatch('trackActivated', { track: track });
+        // No throw, and activeTextTrack stays null.
+        player.setActiveTextTrack('anything');
+        expect(player.activeTextTrack).toBeNull();
+    });
+    it('redispatches textTracksChange events from the active controller', () => {
+        const { track, controller } = makeTrackWithController();
+        deps.trackController.activeTrack = track;
+        deps.trackController.dispatch('trackActivated', { track: track });
+        const spy = createEventSpy(player, 'textTracksChange');
+        controller.setTextTracks([
+            {
+                id: 't1',
+                kind: 'subtitles',
+                language: null,
+                label: 'A',
+                default: false,
+                forced: false,
+                characteristics: [],
+                uri: 'a.vtt',
+                mimeType: 'text/vtt',
+            },
+        ]);
+        expect(spy).toHaveBeenCalled();
+    });
+    it('fires textTracksChange when switching to a track with different list', () => {
+        const a = makeTrackWithController();
+        const b = makeTrackWithController();
+        const trackInfoA = {
+            id: 't1',
+            kind: 'subtitles',
+            language: 'en',
+            label: 'A',
+            default: false,
+            forced: false,
+            characteristics: [],
+            uri: 'a.vtt',
+            mimeType: 'text/vtt',
+        };
+        const trackInfoB = {
+            id: 't2',
+            kind: 'subtitles',
+            language: 'fr',
+            label: 'B',
+            default: false,
+            forced: false,
+            characteristics: [],
+            uri: 'b.vtt',
+            mimeType: 'text/vtt',
+        };
+        a.controller.setTextTracks([trackInfoA]);
+        b.controller.setTextTracks([trackInfoB]);
+        deps.trackController.activeTrack = a.track;
+        deps.trackController.dispatch('trackActivated', { track: a.track });
+        const spy = createEventSpy(player, 'textTracksChange');
+        deps.trackController.activeTrack = b.track;
+        deps.trackController.dispatch('trackActivated', { track: b.track });
+        expect(spy).toHaveBeenCalled();
+    });
+    it("deactivates the previous track's captions on trackDeactivated", () => {
+        // Tracks are cached, not disposed, when unloaded. The previous
+        // controller retains its DOM TextTrack unless we deactivate it.
+        const a = makeTrackWithController();
+        a.controller.setTextTracks([
+            {
+                id: 't1',
+                kind: 'subtitles',
+                language: 'en',
+                label: 'A',
+                default: false,
+                forced: false,
+                characteristics: [],
+                uri: 'a.vtt',
+                mimeType: 'text/vtt',
+            },
+        ]);
+        deps.trackController.activeTrack = a.track;
+        deps.trackController.dispatch('trackActivated', { track: a.track });
+        a.controller.setActiveTextTrack('t1');
+        expect(a.controller.activeTextTrack?.id).toBe('t1');
+        // Unload: current → null.
+        deps.trackController.activeTrack = null;
+        deps.trackController.dispatch('trackDeactivated', { track: a.track });
+        expect(a.controller.activeTextTrack).toBeNull();
+    });
+    it('fires activeTextTrackChange when switching tracks', () => {
+        const a = makeTrackWithController();
+        const b = makeTrackWithController();
+        a.controller.setTextTracks([
+            {
+                id: 't1',
+                kind: 'subtitles',
+                language: 'en',
+                label: 'A',
+                default: false,
+                forced: false,
+                characteristics: [],
+                uri: 'a.vtt',
+                mimeType: 'text/vtt',
+            },
+        ]);
+        a.controller.setActiveTextTrack('t1');
+        deps.trackController.activeTrack = a.track;
+        deps.trackController.dispatch('trackActivated', { track: a.track });
+        const spy = createEventSpy(player, 'activeTextTrackChange');
+        deps.trackController.activeTrack = b.track;
+        deps.trackController.dispatch('trackActivated', { track: 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 by resume().
+        const content = makeTrackWithController();
+        content.controller.setTextTracks([
+            {
+                id: 'c-forced',
+                kind: 'subtitles',
+                language: 'en',
+                label: 'English (Forced)',
+                default: true,
+                forced: true,
+                characteristics: [],
+                uri: 'c.vtt',
+                mimeType: 'text/vtt',
+            },
+        ]);
+        // Forced caption auto-selects for content.
+        expect(content.controller.activeTextTrack?.id).toBe('c-forced');
+        const ad = makeTrackWithController();
+        ad.controller.setTextTracks([
+            {
+                id: 'ad-cc',
+                kind: 'subtitles',
+                language: 'en',
+                label: 'English',
+                default: false,
+                forced: false,
+                characteristics: [],
+                uri: 'ad.vtt',
+                mimeType: 'text/vtt',
+            },
+        ]);
+        // Content becomes current.
+        deps.trackController.activeTrack = content.track;
+        deps.trackController.dispatch('trackActivated', {
+            track: content.track,
+        });
+        // Enter the ad break: the swap preserves the content selection
+        // (suspend keeps _active) rather than clearing it.
+        deps.adController.currentAdBreak = { placement: 'midroll' };
+        content.controller.suspend();
+        deps.trackController.activeTrack = ad.track;
+        deps.trackController.dispatch('trackActivated', { track: ad.track });
+        // Viewer enables the ad's captions during the break.
+        player.setActiveTextTrack('ad-cc');
+        expect(player.activeTextTrack?.id).toBe('ad-cc');
+        // Ad ends, content resumes.
+        deps.adController.currentAdBreak = null;
+        const spy = createEventSpy(player, 'activeTextTrackChange');
+        deps.trackController.activeTrack = content.track;
+        content.controller.resume();
+        deps.trackController.dispatch('trackActivated', {
+            track: 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('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();
+        deps.trackController.activeTrack = a.track;
+        deps.trackController.dispatch('trackActivated', { track: a.track });
+        const spy = createEventSpy(player, 'activeTextTrackChange');
+        deps.trackController.activeTrack = b.track;
+        deps.trackController.dispatch('trackActivated', { track: b.track });
+        expect(spy).not.toHaveBeenCalled();
+    });
+});