@amazon/vinyl 2.0.0 → 3.0.0

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

@@ -2,11 +2,17 @@
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { createVinylPlayer, SidecarTextTrackController, } from '@amazon/vinyl';
+import { createVinylPlayer, } from '@amazon/vinyl';
 import { externalDependencies } from '@amazon/vinyl-di';
-import { createMockVinylDependencies, MockTrack, } from '@amazon/vinyl/vinylTestUtil';
+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;
@@ -19,167 +25,93 @@ describe('VinylPlayer text track API', () => {
     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 SidecarTextTrackController({ media: null });
+        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.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 });
+        controller.textTracks = [info()];
+        activate(track);
         expect(player.textTracks.length).toBe(1);
     });
-    it('selects an active text track via setActiveTextTrack', () => {
+    it('reflects the current track controller active selection', () => {
         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');
+        controller.textTracks = [info()];
+        activate(track);
+        setActive(controller, info());
         expect(player.activeTextTrack?.id).toBe('t1');
-        player.setActiveTextTrack(null);
+        setActive(controller, null);
         expect(player.activeTextTrack).toBeNull();
     });
-    it('ignores setActiveTextTrack when current track has no controller', () => {
+    it('reports null active when the 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');
+        activate(track);
         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 });
+        activate(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',
-            },
-        ]);
+        setTracks(controller, [info({ language: null })]);
         expect(spy).toHaveBeenCalled();
     });
-    it('fires textTracksChange when switching to a track with different list', () => {
+    it('fires textTracksChange when switching to a track with a 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 });
+        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');
-        deps.trackController.activeTrack = b.track;
-        deps.trackController.dispatch('trackActivated', { track: b.track });
+        activate(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 });
+        setTracks(a.controller, [info({ id: 't1' })]);
+        setActive(a.controller, info({ id: 't1' }));
+        activate(a.track);
         const spy = createEventSpy(player, 'activeTextTrackChange');
-        deps.trackController.activeTrack = b.track;
-        deps.trackController.dispatch('trackActivated', { track: b.track });
+        activate(b.track);
         expect(spy).toHaveBeenCalled();
     });
     it('re-announces the content caption after an ad break so it does not read as off', () => {
@@ -187,59 +119,35 @@ describe('VinylPlayer text track API', () => {
         // 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().
+        // (here forced) selection is restored silently on activate().
         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 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();
-        ad.controller.setTextTracks([
-            {
-                id: 'ad-cc',
-                kind: 'subtitles',
-                language: 'en',
-                label: 'English',
-                default: false,
-                forced: false,
-                characteristics: [],
-                uri: 'ad.vtt',
-                mimeType: 'text/vtt',
-            },
-        ]);
+        const adCc = info({ id: 'ad-cc', label: 'English', uri: 'ad.vtt' });
+        setTracks(ad.controller, [adCc]);
         // 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.
+        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.suspend();
-        deps.trackController.activeTrack = ad.track;
-        deps.trackController.dispatch('trackActivated', { track: ad.track });
+        content.controller.deactivate();
+        activate(ad.track);
         // Viewer enables the ad's captions during the break.
-        player.setActiveTextTrack('ad-cc');
+        setActive(ad.controller, adCc);
         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,
-        });
+        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.
@@ -248,16 +156,33 @@ describe('VinylPlayer text track API', () => {
         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();
-        deps.trackController.activeTrack = a.track;
-        deps.trackController.dispatch('trackActivated', { track: a.track });
+        activate(a.track);
         const spy = createEventSpy(player, 'activeTextTrackChange');
-        deps.trackController.activeTrack = b.track;
-        deps.trackController.dispatch('trackActivated', { track: b.track });
+        activate(b.track);
         expect(spy).not.toHaveBeenCalled();
     });
 });

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

@@ -81,6 +81,8 @@ describe('createVinylFactories', () => {
         expect(container.dependencies).toEqual(objectContaining({
             patchedMedia: any(Object),
             media: any(Object),
+            textTrackProvider: any(Object),
+            textTrackRenderer: null,
             playbackController: any(PlaybackControllerImpl),
             playbackSource: any(PlaybackSourceImpl),
             loudnessNormalizationController: any(LoudnessNormalizationControllerImpl),

package/dist/vinylTestUtil/index.js

@@ -2407,6 +2407,7 @@ var MockPlaybackSource = class {
 
 // test/vinylTestUtil/mock/player/MockVinylPlayerDependencies.ts
 import {
+  createMediaTextTrackProvider,
   defaultVinylOptions
 } from "@amazon/vinyl";
 
@@ -2491,9 +2492,9 @@ var MockTextTrackController = class extends MockEventHost9 {
     super(...arguments);
     __publicField(this, "textTracks", []);
     __publicField(this, "activeTextTrack", null);
-    __publicField(this, "setActiveTextTrack", spyFactory21("setActiveTextTrack"));
-    __publicField(this, "suspend", spyFactory21("suspend"));
-    __publicField(this, "resume", spyFactory21("resume"));
+    __publicField(this, "active", false);
+    __publicField(this, "deactivate", spyFactory21("deactivate"));
+    __publicField(this, "activate", spyFactory21("activate"));
   }
 };
 
@@ -2533,9 +2534,10 @@ function createMockDashDependencies() {
     mediaQualityMetadataResolver: createSpy().and.callFake(
       () => createEmptyMediaQualityMetadata()
     ),
-    preferredAudioLanguage: data3(null),
+    audio: data3({
+      selection: { language: null, descriptive: false }
+    }),
     allowedContentTypes: data3(null),
-    preferDescriptiveAudio: data3(false),
     abr: data3(defaultQualitySelectorImplOptions)
   };
 }
@@ -2560,6 +2562,7 @@ import { data as data4 } from "@amazon/vinyl-observable";
 var createSpy2 = jasmine.createSpy;
 function createMockVinylDependencies() {
   const playbackController = new MockPlaybackController();
+  const media = createMockMedia();
   return {
     options: data4(defaultVinylOptions),
     trackController: new MockTrackController(),
@@ -2567,7 +2570,9 @@ function createMockVinylDependencies() {
     playbackController,
     capabilities: new MockCapabilities(),
     drmController: new MockDrmController(),
-    media: createMockMedia(),
+    media,
+    textTrackProvider: createMediaTextTrackProvider({ media }),
+    textTrackRenderer: null,
     createDashFactories: (_loadOptions) => externalDependencies(createMockDashDependencies()),
     createHlsFactories: (_loadOptions) => externalDependencies(createMockDashDependencies()),
     autoResetController: new MockAutoResetController(),
@@ -2700,9 +2705,10 @@ function createMockHlsDependencies() {
     mediaQualityMetadataResolver: createSpy3().and.callFake(
       () => createEmptyMediaQualityMetadata2()
     ),
-    preferredAudioLanguage: data5(null),
+    audio: data5({
+      selection: { language: null, descriptive: false }
+    }),
     allowedContentTypes: data5(null),
-    preferDescriptiveAudio: data5(false),
     abr: data5(defaultQualitySelectorImplOptions2)
   };
 }