@amazon/vinyl 1.2.0 → 2.0.0

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/mediaSource.test.js

@@ -57,6 +57,12 @@ describe('mediaSource', () => {
             expect(isTypeSupported('type2')).toBeTrue();
             expect(MockMediaSourceGlobal.isTypeSupported).toHaveBeenCalledOnceWith('type2');
         });
+        it('delegates to the native MediaSource.isTypeSupported', () => {
+            global.MediaSource = MockMediaSourceGlobal;
+            MockMediaSourceGlobal.isTypeSupported.and.returnValue(true);
+            expect(isTypeSupported('video/mp4; codecs="hvc1.2.20000000.L123.B0"')).toBeTrue();
+            expect(MockMediaSourceGlobal.isTypeSupported).toHaveBeenCalled();
+        });
     });
     describe('onMediaSourceOpen', () => {
         let mediaSource;

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

@@ -148,42 +148,154 @@ describe('VinylPlayer', () => {
         pC.dispatch('play', event);
         expect(spy).toHaveBeenCalledOnceWith(event);
     });
-    it('re-dispatches currentTrackChange from the track controller', () => {
-        const spy = createSpy('currentTrackChange');
-        player.on('currentTrackChange', spy);
+    it('re-dispatches trackActivated and trackDeactivated from the track controller', () => {
+        const activatedSpy = createSpy('trackActivated');
+        const deactivatedSpy = createSpy('trackDeactivated');
+        player.on('trackActivated', activatedSpy);
+        player.on('trackDeactivated', deactivatedSpy);
         const trackController = deps.trackController;
-        const mockTrackA = new MockTrack();
-        const mockTrackB = new MockTrack();
-        trackController.dispatch('currentTrackChange', {
-            previous: mockTrackA,
-            current: mockTrackB,
+        const mockTrack = new MockTrack();
+        trackController.dispatch('trackActivated', { track: mockTrack });
+        expect(activatedSpy).toHaveBeenCalledOnceWith({ track: mockTrack });
+        trackController.dispatch('trackDeactivated', { track: mockTrack });
+        expect(deactivatedSpy).toHaveBeenCalledOnceWith({ track: mockTrack });
+    });
+    it('ignores a repeat trackActivated for the already-active track', () => {
+        const trackController = deps.trackController;
+        const mockTrack = new MockTrack();
+        const seekRangeSpy = createSpy('seekRangeChange');
+        trackController.dispatch('trackActivated', { track: mockTrack });
+        player.on('seekRangeChange', seekRangeSpy);
+        // Re-activating the same track is a no-op transition (no re-wiring or
+        // state-change events).
+        trackController.dispatch('trackActivated', { track: mockTrack });
+        expect(seekRangeSpy).not.toHaveBeenCalled();
+    });
+    describe('load span metrics', () => {
+        it('republishes the current track loadSpanMeasured as an attributed loadSpan', () => {
+            const spy = createSpy('loadSpan');
+            player.on('loadSpan', spy);
+            const mockTrack = new MockTrack();
+            mockTrack.uri = 'track-a';
+            deps.trackController.dispatch('trackActivated', {
+                track: mockTrack,
+            });
+            mockTrack.dispatch('loadSpanMeasured', {
+                kind: 'initSegment',
+                startTime: 1,
+                endTime: 2,
+            });
+            expect(spy).toHaveBeenCalledOnceWith({
+                kind: 'initSegment',
+                startTime: 1,
+                endTime: 2,
+                trackUri: 'track-a',
+            });
         });
-        expect(spy).toHaveBeenCalledOnceWith({
-            previous: mockTrackA,
-            current: mockTrackB,
+        it('attributes a DRM license span to the track carried on the measurement', () => {
+            const spy = createSpy('loadSpan');
+            player.on('loadSpan', spy);
+            // The license span is stamped at the source with the initiating
+            // track. Even when a different track is current, the span must
+            // attribute to the track the measurement carries.
+            const currentTrack = new MockTrack();
+            currentTrack.uri = 'track-current';
+            deps.trackController.activeTrack = currentTrack;
+            deps.drmController.dispatch('loadSpanMeasured', {
+                kind: 'license',
+                startTime: 3,
+                endTime: 5,
+                trackUri: 'track-preloaded',
+            });
+            expect(spy).toHaveBeenCalledOnceWith({
+                kind: 'license',
+                startTime: 3,
+                endTime: 5,
+                trackUri: 'track-preloaded',
+            });
         });
-        spy.calls.reset();
-        trackController.dispatch('currentTrackChange', {
-            previous: mockTrackB,
-            current: null,
+        it('does not emit a license span the DRM controller could not attribute', () => {
+            const spy = createSpy('loadSpan');
+            player.on('loadSpan', spy);
+            const currentTrack = new MockTrack();
+            currentTrack.uri = 'track-current';
+            deps.trackController.activeTrack = currentTrack;
+            // A measurement with no trackUri (the initiating track was unknown)
+            // is dropped rather than misattributed to the current track.
+            deps.drmController.dispatch('loadSpanMeasured', {
+                kind: 'license',
+                startTime: 3,
+                endTime: 5,
+            });
+            expect(spy).not.toHaveBeenCalled();
+        });
+        it('stops republishing after the track is no longer current', () => {
+            const spy = createSpy('loadSpan');
+            player.on('loadSpan', spy);
+            const mockTrack = new MockTrack();
+            mockTrack.uri = 'track-a';
+            deps.trackController.dispatch('trackActivated', {
+                track: mockTrack,
+            });
+            deps.trackController.dispatch('trackDeactivated', {
+                track: mockTrack,
+            });
+            mockTrack.dispatch('loadSpanMeasured', {
+                kind: 'manifest',
+                startTime: 1,
+                endTime: 2,
+            });
+            expect(spy).not.toHaveBeenCalled();
         });
-        expect(spy).toHaveBeenCalledOnceWith({
-            previous: mockTrackB,
-            current: null,
+    });
+    it('reloads the current track on a codecUnsupported event', () => {
+        const trackController = deps.trackController;
+        const mockTrack = new MockTrack();
+        // Make the track the current one so its streaming events are
+        // redispatched onto the player.
+        trackController.dispatch('trackActivated', { track: mockTrack });
+        mockTrack.dispatch('codecUnsupported', {
+            mimeType: 'video/mp4; codecs="hvc1.1"',
+            contentType: 'video',
+        });
+        expect(trackController.reset).toHaveBeenCalledOnceWith(true);
+    });
+    it('does not reload the current track on codecUnsupported while an ad is playing', () => {
+        const trackController = deps.trackController;
+        // An ad break currently contains the playhead.
+        deps.adController.currentAdBreak = {
+            id: 'b1',
+            startTime: 0,
+            duration: 10,
+            placement: 'preroll',
+            ads: () => Promise.resolve([]),
+            restrict: {},
+            once: false,
+            resumeOffset: null,
+            playoutLimit: null,
+            resolutionTimeOffset: null,
+            skipControl: () => null,
+        };
+        const mockTrack = new MockTrack();
+        trackController.dispatch('trackActivated', { track: mockTrack });
+        mockTrack.dispatch('codecUnsupported', {
+            mimeType: 'video/mp4; codecs="hvc1.1"',
+            contentType: 'video',
         });
+        expect(trackController.reset).not.toHaveBeenCalled();
     });
     describe('currentTrack', () => {
         it('returns the currently active track', () => {
-            expect(player.currentTrack).toBeNull();
+            expect(player.activeTrack).toBeNull();
             const mockTrackA = new MockTrack();
             mockTrackA.uri = 'srcA';
             const mockTrackB = new MockTrack();
             mockTrackB.uri = 'srcB';
-            expect(player.currentTrack).toBeNull();
-            deps.trackController.currentTrack = mockTrackA;
-            expect(player.currentTrack).toBe(mockTrackA);
-            deps.trackController.currentTrack = mockTrackB;
-            expect(player.currentTrack).toBe(mockTrackB);
+            expect(player.activeTrack).toBeNull();
+            deps.trackController.activeTrack = mockTrackA;
+            expect(player.activeTrack).toBe(mockTrackA);
+            deps.trackController.activeTrack = mockTrackB;
+            expect(player.activeTrack).toBe(mockTrackB);
         });
     });
     describe('fetchedRanges', () => {
@@ -192,7 +304,7 @@ describe('VinylPlayer', () => {
             const mockTrackA = new MockTrack();
             const expectedRanges = new RangesImpl([[0, 10]]);
             mockTrackA.fetchedRanges = expectedRanges;
-            deps.trackController.currentTrack = mockTrackA;
+            deps.trackController.activeTrack = mockTrackA;
             expect(player.fetchedRanges).toEqual(expectedRanges);
         });
     });
@@ -204,7 +316,7 @@ describe('VinylPlayer', () => {
                 [0, 10],
                 [30, 60],
             ]);
-            deps.trackController.currentTrack = mockTrackA;
+            deps.trackController.activeTrack = mockTrackA;
             expect(player.fetchedTime).toEqual(10);
             deps.playbackController.currentTime = 6;
             expect(player.fetchedTime).toEqual(10);
@@ -219,7 +331,7 @@ describe('VinylPlayer', () => {
             expect(player.fetchedTimePercent).toBe(0);
             const mockTrackA = new MockTrack();
             mockTrackA.fetchedRanges = new RangesImpl([[0, 50]]);
-            deps.trackController.currentTrack = mockTrackA;
+            deps.trackController.activeTrack = mockTrackA;
             deps.playbackController.duration = 100;
             expect(player.fetchedTimePercent).toEqual(0.5);
             deps.playbackController.duration = Number.NaN;
@@ -233,18 +345,16 @@ describe('VinylPlayer', () => {
             const event = {};
             mockTrackA.dispatch('fetchedRangesChange', event);
             expect(fetchedRangesChangeSpy).not.toHaveBeenCalled();
-            deps.trackController.dispatch('currentTrackChange', {
-                previous: null,
-                current: mockTrackA,
+            deps.trackController.dispatch('trackActivated', {
+                track: mockTrackA,
             });
             expect(fetchedRangesChangeSpy).toHaveBeenCalledOnceWith(event); // Emitted on track change
             fetchedRangesChangeSpy.calls.reset();
             mockTrackA.dispatch('fetchedRangesChange', event);
             expect(fetchedRangesChangeSpy).toHaveBeenCalledOnceWith(event);
             fetchedRangesChangeSpy.calls.reset();
-            deps.trackController.dispatch('currentTrackChange', {
-                previous: mockTrackA,
-                current: null,
+            deps.trackController.dispatch('trackDeactivated', {
+                track: mockTrackA,
             });
             expect(fetchedRangesChangeSpy).toHaveBeenCalledOnceWith(event); // Emitted on track change
             fetchedRangesChangeSpy.calls.reset();
@@ -274,7 +384,7 @@ describe('VinylPlayer', () => {
             mockTrackA.getStreamingQuality.and.returnValue(streamingQuality);
             mockTrackA.getBufferingQuality.and.returnValue(bufferingQuality);
             mockTrackA.getPlaybackQuality.and.returnValue(playbackQuality);
-            deps.trackController.currentTrack = mockTrackA;
+            deps.trackController.activeTrack = mockTrackA;
             expect(player.getStreamingQuality('audio')).toEqual(streamingQuality);
             expect(player.getBufferingQuality('audio')).toEqual(bufferingQuality);
             expect(player.getPlaybackQuality('audio')).toEqual(playbackQuality);
@@ -283,7 +393,7 @@ describe('VinylPlayer', () => {
             expect(player.contentTypes).toEqual(new Set());
             const mockTrackA = new MockTrack();
             mockTrackA.contentTypes = new Set(['audio', 'video']);
-            deps.trackController.currentTrack = mockTrackA;
+            deps.trackController.activeTrack = mockTrackA;
             expect(player.contentTypes).toEqual(new Set(['audio', 'video']));
         });
         it('returns qualities from current track', () => {
@@ -291,7 +401,7 @@ describe('VinylPlayer', () => {
             const mockTrackA = new MockTrack();
             const q = [createEmptyMediaQualityMetadata()];
             mockTrackA.qualities = q;
-            deps.trackController.currentTrack = mockTrackA;
+            deps.trackController.activeTrack = mockTrackA;
             expect(player.qualities).toBe(q);
         });
         it('returns qualitiesUnfiltered from current track', () => {
@@ -299,7 +409,7 @@ describe('VinylPlayer', () => {
             const mockTrackA = new MockTrack();
             const q = [createEmptyMediaQualityMetadata()];
             mockTrackA.qualitiesUnfiltered = q;
-            deps.trackController.currentTrack = mockTrackA;
+            deps.trackController.activeTrack = mockTrackA;
             expect(player.qualitiesUnfiltered).toBe(q);
         });
         it('deprecated getters work for backward compatibility', () => {
@@ -312,7 +422,7 @@ describe('VinylPlayer', () => {
             mockTrackA.getStreamingQuality.and.callFake((contentType) => contentType === 'audio' ? audioQuality : null);
             mockTrackA.getBufferingQuality.and.callFake((contentType) => contentType === 'audio' ? audioQuality : null);
             mockTrackA.getPlaybackQuality.and.callFake((contentType) => contentType === 'audio' ? audioQuality : null);
-            deps.trackController.currentTrack = mockTrackA;
+            deps.trackController.activeTrack = mockTrackA;
             // Test deprecated getters
             // eslint-disable-next-line @typescript-eslint/no-deprecated
             expect(player.streamingQuality).toEqual(audioQuality);
@@ -338,9 +448,8 @@ describe('VinylPlayer', () => {
                 };
                 const mockTrackA = new MockTrack();
                 mockTrackA.getPlaybackQuality.and.callFake((contentType) => contentType === 'audio' ? qualityA : null);
-                deps.trackController.dispatch('currentTrackChange', {
-                    previous: null,
-                    current: mockTrackA,
+                deps.trackController.dispatch('trackActivated', {
+                    track: mockTrackA,
                 });
                 expect(playbackQualityChangeSpy).toHaveBeenCalledOnceWith({
                     previous: null,
@@ -357,9 +466,8 @@ describe('VinylPlayer', () => {
                     current: qualityB,
                 });
                 playbackQualityChangeSpy.calls.reset();
-                deps.trackController.dispatch('currentTrackChange', {
-                    previous: mockTrackA,
-                    current: null,
+                deps.trackController.dispatch('trackDeactivated', {
+                    track: mockTrackA,
                 });
                 expect(playbackQualityChangeSpy).toHaveBeenCalledOnceWith({
                     previous: qualityB,
@@ -372,9 +480,8 @@ describe('VinylPlayer', () => {
             const mockTrackA = new MockTrack();
             const q = [createEmptyMediaQualityMetadata()];
             mockTrackA.qualities = q;
-            deps.trackController.dispatch('currentTrackChange', {
-                previous: null,
-                current: mockTrackA,
+            deps.trackController.dispatch('trackActivated', {
+                track: mockTrackA,
             });
             expect(spy).toHaveBeenCalledOnceWith({
                 previous: [],
@@ -386,9 +493,8 @@ describe('VinylPlayer', () => {
             const mockTrackA = new MockTrack();
             const q = [createEmptyMediaQualityMetadata()];
             mockTrackA.qualitiesUnfiltered = q;
-            deps.trackController.dispatch('currentTrackChange', {
-                previous: null,
-                current: mockTrackA,
+            deps.trackController.dispatch('trackActivated', {
+                track: mockTrackA,
             });
             expect(spy).toHaveBeenCalledOnceWith({
                 previous: [],
@@ -449,23 +555,6 @@ describe('VinylPlayer', () => {
             expect(configSpy).not.toHaveBeenCalled();
         });
     });
-    describe('when preferredAudioLanguage changes', () => {
-        it('clears prefetch', () => {
-            expect(deps.trackController.clearPrefetch).not.toHaveBeenCalled();
-            player.configure({ preferredAudioLanguage: 'ja' });
-            expect(deps.trackController.clearPrefetch).toHaveBeenCalledWith();
-        });
-        it('does not clear prefetch when value is unchanged', () => {
-            player.configure({ preferredAudioLanguage: 'ja' });
-            deps.trackController.clearPrefetch.calls.reset();
-            player.configure({ preferredAudioLanguage: 'ja' });
-            expect(deps.trackController.clearPrefetch).not.toHaveBeenCalled();
-        });
-        it('does not clear prefetch on initial options', () => {
-            // clearPrefetch should not have been called from the initial options set
-            expect(deps.trackController.clearPrefetch).not.toHaveBeenCalled();
-        });
-    });
     describe('client', () => {
         it('returns an object with the injected capabilities and user agent info', () => {
             expect(player.client).toEqual({
@@ -512,7 +601,7 @@ describe('VinylPlayer', () => {
             player.reset();
             expect(deps.drmController.reset).toHaveBeenCalledOnceWith();
             expect(deps.playbackController.reset).toHaveBeenCalledOnceWith();
-            expect(deps.trackController.reset).toHaveBeenCalledOnceWith();
+            expect(deps.trackController.reset).toHaveBeenCalledOnceWith(false);
         });
         it('clears the error state', () => {
             const error = new DrmError('test error');
@@ -549,9 +638,8 @@ describe('VinylPlayer', () => {
             const resetSpy = createEventSpy(player, 'reset');
             const mockTrack = new MockTrack();
             // Set current track
-            deps.trackController.dispatch('currentTrackChange', {
-                previous: null,
-                current: mockTrack,
+            deps.trackController.dispatch('trackActivated', {
+                track: mockTrack,
             });
             // Simulate track emitting reset event
             mockTrack.dispatch('reset', {});
@@ -561,9 +649,8 @@ describe('VinylPlayer', () => {
             const resetSpy = createEventSpy(player, 'reset');
             const mockTrack = new MockTrack();
             // Set current track
-            deps.trackController.dispatch('currentTrackChange', {
-                previous: null,
-                current: mockTrack,
+            deps.trackController.dispatch('trackActivated', {
+                track: mockTrack,
             });
             // Track reset events should not bubble
             mockTrack.dispatch('reset', {});
@@ -592,7 +679,7 @@ describe('VinylPlayer', () => {
             expect(player.error).toBeNull();
             expect(deps.drmController.reset).toHaveBeenCalledOnceWith();
             expect(deps.playbackController.reset).toHaveBeenCalledOnceWith();
-            expect(deps.trackController.reset).toHaveBeenCalledOnceWith();
+            expect(deps.trackController.reset).toHaveBeenCalledOnceWith(false);
         });
         it('clears auto reset controller on reset', () => {
             const error = new DrmError('test error');
@@ -644,6 +731,21 @@ describe('VinylPlayer', () => {
             });
         });
     });
+    describe('seekRange', () => {
+        it('returns null when no track is loaded', () => {
+            const player = createVinylPlayer(mockOptions, depFactories);
+            expect(player.seekRange).toBeNull();
+            player.dispose();
+        });
+        it('delegates to the current track seekRange', () => {
+            const player = createVinylPlayer(mockOptions, depFactories);
+            const track = new MockTrack();
+            track.seekRange = { start: 0, end: 120 };
+            deps.trackController.activeTrack = track;
+            expect(player.seekRange).toEqual({ start: 0, end: 120 });
+            player.dispose();
+        });
+    });
     describe('disposed', () => {
         it('returns true if the player is disposed', () => {
             const player = createVinylPlayer(mockOptions, depFactories);

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