@amazon/vinyl 4.0.0 → 4.0.1-next.20261016184530

package/dist/types/ts3.7/playback/PlaybackControllerImpl.d.ts

@@ -180,6 +180,18 @@ export declare class PlaybackControllerImpl extends EventHostImpl<PlaybackContro
      * @private
      */
     private doSeek;
+    /**
+     * Dispatches `waiting` when a seek while playing targets an unbuffered position and the media element did not.
+     * Safari 27 keeps its readyState while seeking, so it never fires `waiting` for the seek.
+     * @private
+     */
+    private initializeSeekWaitingEvent;
+    /**
+     * Dispatches `playing` when a seek while playing completes and the media element did not. A seek ends `playing`,
+     * but WebKit only fires `playing` again if its readyState dropped, which it doesn't for a buffered position.
+     * @private
+     */
+    private initializeSeekPlayingEvent;
     /**
      * Dispatches a readyStateChange event when {@link readyState} changes.
      * @private

package/dist/types/ts4.1/playback/PlaybackControllerImpl.d.ts

@@ -182,6 +182,18 @@ export declare class PlaybackControllerImpl extends EventHostImpl<PlaybackContro
      * @private
      */
     private doSeek;
+    /**
+     * Dispatches `waiting` when a seek while playing targets an unbuffered position and the media element did not.
+     * Safari 27 keeps its readyState while seeking, so it never fires `waiting` for the seek.
+     * @private
+     */
+    private initializeSeekWaitingEvent;
+    /**
+     * Dispatches `playing` when a seek while playing completes and the media element did not. A seek ends `playing`,
+     * but WebKit only fires `playing` again if its readyState dropped, which it doesn't for a buffered position.
+     * @private
+     */
+    private initializeSeekPlayingEvent;
     /**
      * Dispatches a readyStateChange event when {@link readyState} changes.
      * @private

package/dist/types/ts4.7/playback/PlaybackControllerImpl.d.ts

@@ -180,6 +180,18 @@ export declare class PlaybackControllerImpl extends EventHostImpl<PlaybackContro
      * @private
      */
     private doSeek;
+    /**
+     * Dispatches `waiting` when a seek while playing targets an unbuffered position and the media element did not.
+     * Safari 27 keeps its readyState while seeking, so it never fires `waiting` for the seek.
+     * @private
+     */
+    private initializeSeekWaitingEvent;
+    /**
+     * Dispatches `playing` when a seek while playing completes and the media element did not. A seek ends `playing`,
+     * but WebKit only fires `playing` again if its readyState dropped, which it doesn't for a buffered position.
+     * @private
+     */
+    private initializeSeekPlayingEvent;
     /**
      * Dispatches a readyStateChange event when {@link readyState} changes.
      * @private

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

@@ -1024,6 +1024,92 @@ describe('PlaybackController', () => {
                         expect(waitedSpy).not.toHaveBeenCalled();
                     });
                 });
+                describe('when a seek while playing targets an unbuffered position', () => {
+                    let waitingSpy;
+                    beforeEach(() => {
+                        waitingSpy = createSpy('waiting');
+                        controller.on('waiting', waitingSpy);
+                        media.buffered = new MockTimeRanges([[0, 20]]);
+                        media.currentTime = 22;
+                        media.seeking = true;
+                    });
+                    it('emits waiting if the media element does not', async () => {
+                        media.dispatchEvent(mockEvent('seeking'));
+                        expect(waitingSpy).not.toHaveBeenCalled();
+                        await clock.tick();
+                        expect(waitingSpy).toHaveBeenCalledTimes(1);
+                        expect(controller.waiting).toBeTrue();
+                        media.dispatchEvent(mockEvent('waiting'));
+                        expect(waitingSpy).toHaveBeenCalledTimes(1);
+                        media.seeking = false;
+                        media.dispatchEvent(mockEvent('playing'));
+                        expect(controller.waiting).toBeFalse();
+                    });
+                    it('emits waiting once if the media element does', async () => {
+                        media.dispatchEvent(mockEvent('seeking'));
+                        media.dispatchEvent(mockEvent('waiting'));
+                        await clock.tick();
+                        expect(waitingSpy).toHaveBeenCalledTimes(1);
+                    });
+                    it('does not emit waiting when paused', async () => {
+                        media.paused = true;
+                        media.dispatchEvent(mockEvent('seeking'));
+                        await clock.tick();
+                        expect(waitingSpy).not.toHaveBeenCalled();
+                    });
+                    it('does not emit waiting when the seek completes first', async () => {
+                        media.dispatchEvent(mockEvent('seeking'));
+                        media.seeking = false;
+                        media.dispatchEvent(mockEvent('seeked'));
+                        await clock.tick();
+                        expect(waitingSpy).not.toHaveBeenCalled();
+                    });
+                });
+                describe('when a seek while playing completes', () => {
+                    let playingSpy;
+                    beforeEach(() => {
+                        media.readyState = PlaybackReadyState.HAVE_ENOUGH_DATA;
+                        media.dispatchEvent(mockEvent('playing'));
+                        playingSpy = createSpy('playing');
+                        controller.on('playing', playingSpy);
+                        media.dispatchEvent(mockEvent('seeking'));
+                        expect(controller.playing).toBeFalse();
+                    });
+                    it('emits playing if the media element does not', () => {
+                        media.dispatchEvent(mockEvent('seeked'));
+                        expect(playingSpy).toHaveBeenCalledTimes(1);
+                        expect(controller.playing).toBeTrue();
+                        media.dispatchEvent(mockEvent('playing'));
+                        expect(playingSpy).toHaveBeenCalledTimes(1);
+                    });
+                    it('emits playing once if the media element does', () => {
+                        media.dispatchEvent(mockEvent('playing'));
+                        media.dispatchEvent(mockEvent('seeked'));
+                        expect(playingSpy).toHaveBeenCalledTimes(1);
+                    });
+                    it('does not emit playing when paused', () => {
+                        media.paused = true;
+                        media.dispatchEvent(mockEvent('seeked'));
+                        expect(playingSpy).not.toHaveBeenCalled();
+                    });
+                    it('does not emit playing without future data', () => {
+                        media.readyState = PlaybackReadyState.HAVE_CURRENT_DATA;
+                        media.dispatchEvent(mockEvent('seeked'));
+                        expect(playingSpy).not.toHaveBeenCalled();
+                    });
+                });
+                describe('when a seek while playing targets a buffered position', () => {
+                    it('does not emit waiting', async () => {
+                        const waitingSpy = createSpy('waiting');
+                        controller.on('waiting', waitingSpy);
+                        media.buffered = new MockTimeRanges([[0, 30]]);
+                        media.currentTime = 22;
+                        media.seeking = true;
+                        media.dispatchEvent(mockEvent('seeking'));
+                        await clock.tick();
+                        expect(waitingSpy).not.toHaveBeenCalled();
+                    });
+                });
             });
             describe('pause', () => {
                 it('invokes pause on the element', () => {

package/dist/unit/types/current/setup.js

@@ -2,24 +2,25 @@
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { getGlobalRegistry, setGlobalRefDebug } from '@amazon/vinyl-util';
+import { getGlobalRegistry, getSearchParams, setGlobalRefDebug, } from '@amazon/vinyl-util';
 import { addCustomMatchers, ConsoleReporter, flushPromises, } from '@amazon/vinyl-util/browserTestUtil';
 import { RestApiReporter } from '@amazon/vinyl-util/testUtil';
-import { initializeFrequencyAnalyzer } from '@amazon/vinyl/vinylTestUtil';
+import { initializeFrequencyAnalyzer, initializeMediaUnlock, } from '@amazon/vinyl/vinylTestUtil';
 addCustomMatchers();
 // Diagnostic: GlobalRefImpl records the stack
 setGlobalRefDebug(true);
 // Configured here instead of the jasmine.config.json to work with both ts-node and the html
-// test runner.
+// test runner. `?stopOnSpecFailure=false` runs every spec, as test:integ does.
 jasmine.getEnv().configure({
-    stopOnSpecFailure: true,
+    stopOnSpecFailure: getSearchParams().get('stopOnSpecFailure') !== 'false',
     stopSpecOnExpectationFailure: true,
     failSpecWithNoExpectations: true,
 });
 // Register the reporters
 jasmine.getEnv().addReporter(new ConsoleReporter());
 RestApiReporter.installFromSearchParam();
-// Prompts for user interaction and unlocks the AudioContext if checkAudio is present in the query params.
+// In a browser, prompts for a click to unlock media playback, then attaches the analyzer if checkAudio is set.
+initializeMediaUnlock();
 initializeFrequencyAnalyzer();
 afterEach(async () => {
     await flushPromises();

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

@@ -2,7 +2,7 @@
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { createEmptyMediaQualityMetadata, defaultSegmentControllerBaseOptions, PREFETCH_POLL_THROTTLE, prefetchPriorityQueuesRef, SegmentControllerImpl, } from '@amazon/vinyl';
+import { clearCodecDenylist, createEmptyMediaQualityMetadata, denylistCodecsFromMimeType, defaultSegmentControllerBaseOptions, PREFETCH_POLL_THROTTLE, prefetchPriorityQueuesRef, SegmentControllerImpl, } from '@amazon/vinyl';
 import { Abort, AbortError, Deferred, floorToNearest, mergeDeep, networkState, noop, sleep, } from '@amazon/vinyl-util';
 import { MockPlaybackController } from '@amazon/vinyl/vinylTestUtil';
 import { data } from '@amazon/vinyl-observable';
@@ -362,6 +362,49 @@ describe('SegmentControllerImpl', () => {
             // segmentController is for 'audio', but only 'video' qualities exist
             expect(await segmentController.getSegment(5)).toBeNull();
         });
+        describe('when a codec has been denylisted', () => {
+            const OPUS = 'audio/mp4; codecs="opus"';
+            const AAC = 'audio/mp4; codecs="mp4a.40.2"';
+            let selectQuality;
+            beforeEach(() => {
+                timelineData.value = Promise.resolve({
+                    periods: [
+                        {
+                            startTime: 0,
+                            endTime: 100,
+                            qualities: [OPUS, AAC].map((mimeType, i) => ({
+                                metadata: {
+                                    ...createEmptyMediaQualityMetadata(),
+                                    contentType: 'audio',
+                                    mimeType,
+                                    decoderId: String(i),
+                                },
+                                getSegment: (time) => segmentProvider.getSegment(time),
+                            })),
+                        },
+                    ],
+                    minBufferTime: 10,
+                    getAdBreaks: () => Promise.resolve([]),
+                    getDuration: () => Promise.resolve(100),
+                });
+                selectQuality = spyOn(mockDeps.qualitySelector, 'selectQuality').and.returnValue(0);
+            });
+            afterEach(() => clearCodecDenylist());
+            function selectedFrom() {
+                return selectQuality.calls.mostRecent().args[0].map((metadata) => metadata.mimeType);
+            }
+            it('selects only from qualities whose codecs are not denylisted', async () => {
+                denylistCodecsFromMimeType(OPUS);
+                await segmentController.getSegment(5);
+                expect(selectedFrom()).toEqual([AAC]);
+            });
+            it('selects from every quality if all of their codecs are denylisted', async () => {
+                denylistCodecsFromMimeType(OPUS);
+                denylistCodecsFromMimeType(AAC);
+                await segmentController.getSegment(5);
+                expect(selectedFrom()).toEqual([OPUS, AAC]);
+            });
+        });
         it('returns null when quality getSegment returns null within period', async () => {
             await fillPrefetch();
             segmentController.clear();

package/dist/unit/types/current/streaming/buffering/BufferingController.test.js

@@ -447,6 +447,20 @@ describe('BufferingControllerImpl', () => {
             await nextPollImmediate();
             expect(sourceBufferController.appendInit).toHaveBeenCalledOnceWith(any(ArrayBuffer), 'opus');
         });
+        it('continues after the buffered segment once the new initialization segment is appended', async () => {
+            await open();
+            sourceBufferController.setTimestampOffset.calls.reset();
+            segmentController.getSegment.and.callFake((time) => {
+                const mockSegment = createMockSegment(time);
+                if (mockSegment.startTime >= 10) {
+                    mockSegment.quality.decoderId = 'next period';
+                    mockSegment.timestampOffset = mockSegment.startTime - 4;
+                }
+                return Promise.resolve(mockSegment);
+            });
+            await setTime(9);
+            expect(sourceBufferController.setTimestampOffset).toHaveBeenCalledOnceWith(10);
+        });
     });
     describe('when segment controller returns null', () => {
         beforeEach(() => {

package/dist/unit/types/current/streaming/buffering/MediaSourceController.test.js

@@ -256,6 +256,11 @@ describe('MediaSourceControllerImpl', () => {
             expect(() => controller.createSourceBuffer('audio', 'invalid/type')).toThrowError(MediaSourceError, 'error creating source buffer');
         });
         describe('SourceBufferRef disposal', () => {
+            beforeEach(() => {
+                mockMediaSource.sourceBuffers = [
+                    mockSourceBuffer,
+                ];
+            });
             it('removes source buffer from media source', () => {
                 mockMediaSource.readyState = 'open';
                 const ref = controller.createSourceBuffer('audio', 'audio/mp4');
@@ -269,6 +274,14 @@ describe('MediaSourceControllerImpl', () => {
                 ref.dispose();
                 expect(mockMediaSource.removeSourceBuffer).not.toHaveBeenCalled();
             });
+            it('does not remove a source buffer the media source already removed', () => {
+                mockMediaSource.readyState = 'open';
+                const ref = controller.createSourceBuffer('audio', 'audio/mp4');
+                mockMediaSource.sourceBuffers =
+                    [];
+                ref.dispose();
+                expect(mockMediaSource.removeSourceBuffer).not.toHaveBeenCalled();
+            });
         });
     });
     describe('endOfStream', () => {

package/dist/unit/types/current/track/dash/createDashFactories.test.js

@@ -46,7 +46,8 @@ describe('createDashFactories', () => {
             type: 'dash',
             manifestProvider,
         });
-        const deps = createContainer(factories).dependencies;
+        const container = createContainer(factories);
+        const deps = container.dependencies;
         expect(deps).toEqual(objectContaining({
             baseUrlSelector: pickFirstBaseUrlSelector,
             segmentRequestInit: undefined,
@@ -59,6 +60,7 @@ describe('createDashFactories', () => {
             contentStreamFactory: any(Function),
             qualitySelector: any(QualitySelectorImpl),
         }));
+        container.dispose();
     });
     it('wires per-track option observables from the player options', () => {
         const factoryCreator = createDashFactories(null);
@@ -67,11 +69,13 @@ describe('createDashFactories', () => {
             type: 'dash',
             manifestProvider,
         });
-        const deps = createContainer(factories).dependencies;
+        const container = createContainer(factories);
+        const deps = container.dependencies;
         const options = dashFactoryDeps.options.value;
         expect(deps.audio.value).toBe(options.audio);
         expect(deps.allowedContentTypes.value).toBe(options.allowedContentTypes);
         expect(deps.abr.value).toBe(options.abr);
+        container.dispose();
     });
     it('provides streaming options to createContentStreamFactories', () => {
         const factoryCreator = createDashFactories({
@@ -86,8 +90,10 @@ describe('createDashFactories', () => {
             type: 'dash',
             manifestProvider,
         });
-        const deps = createContainer(factories).dependencies;
+        const container = createContainer(factories);
+        const deps = container.dependencies;
         expect(deps.contentStreamFactory('audio')).toEqual(any(Object));
+        container.dispose();
     });
     it('creates a sidecar text track controller and populates from manifest', async () => {
         const factoryCreator = createDashFactories(null);
@@ -114,12 +120,14 @@ describe('createDashFactories', () => {
             type: 'dash',
             manifestProvider: provider,
         });
-        const deps = createContainer(factories).dependencies;
+        const container = createContainer(factories);
+        const deps = container.dependencies;
         const ttc = deps.textTrackController;
         await deps.manifestTransformed.value;
         await new Promise((r) => setTimeout(r, 0));
         expect(ttc).toBeDefined();
         expect(ttc.textTracks.length).toBeGreaterThan(0);
+        container.dispose();
     });
     it('text track controller swallows manifest fetch errors', async () => {
         const factoryCreator = createDashFactories(null);
@@ -129,10 +137,12 @@ describe('createDashFactories', () => {
             type: 'dash',
             manifestProvider: provider,
         });
-        const deps = createContainer(factories).dependencies;
+        const container = createContainer(factories);
+        const deps = container.dependencies;
         const controller = deps.textTrackController;
         await deps.manifestTransformed.value.catch(() => undefined);
         await new Promise((r) => setTimeout(r, 0));
         expect(controller.textTracks).toEqual([]);
+        container.dispose();
     });
 });

package/dist/unit/types/current/track/hls/createHlsFactories.test.js

@@ -36,7 +36,8 @@ describe('createHlsFactories', () => {
             type: 'hls',
             manifestProvider,
         });
-        const deps = createContainer(factories).dependencies;
+        const container = createContainer(factories);
+        const deps = container.dependencies;
         expect(deps).toEqual(objectContaining({
             segmentRequestInit: undefined,
             manifestController: any(ManifestControllerImpl),
@@ -47,6 +48,7 @@ describe('createHlsFactories', () => {
             contentStreamFactory: any(Function),
             qualitySelector: any(QualitySelectorImpl),
         }));
+        container.dispose();
     });
     it('wires per-track option observables from the player options', () => {
         const factoryCreator = createHlsFactories(null);
@@ -55,11 +57,13 @@ describe('createHlsFactories', () => {
             type: 'hls',
             manifestProvider,
         });
-        const deps = createContainer(factories).dependencies;
+        const container = createContainer(factories);
+        const deps = container.dependencies;
         const options = hlsFactoryDeps.options.value;
         expect(deps.audio.value).toBe(options.audio);
         expect(deps.allowedContentTypes.value).toBe(options.allowedContentTypes);
         expect(deps.abr.value).toBe(options.abr);
+        container.dispose();
     });
     it('exposes the shared adController without owning it', () => {
         const factoryCreator = createHlsFactories(null);
@@ -93,8 +97,10 @@ describe('createHlsFactories', () => {
             type: 'hls',
             manifestProvider,
         });
-        const deps = createContainer(factories).dependencies;
+        const container = createContainer(factories);
+        const deps = container.dependencies;
         expect(deps.contentStreamFactory('audio')).toEqual(any(Object));
+        container.dispose();
     });
     it('uses createUrlHlsManifestProvider when no manifestProvider given', () => {
         const factoryCreator = createHlsFactories(null);
@@ -102,8 +108,10 @@ describe('createHlsFactories', () => {
             uri: 'https://example.com/main.m3u8',
             type: 'hls',
         });
-        const deps = createContainer(factories).dependencies;
+        const container = createContainer(factories);
+        const deps = container.dependencies;
         expect(deps.manifestController).toEqual(any(ManifestControllerImpl));
+        container.dispose();
     });
     it('creates a sidecar text track controller and populates from manifest', async () => {
         const factoryCreator = createHlsFactories(null);
@@ -128,7 +136,8 @@ describe('createHlsFactories', () => {
             type: 'hls',
             manifestProvider: provider,
         });
-        const deps = createContainer(factories).dependencies;
+        const container = createContainer(factories);
+        const deps = container.dependencies;
         // Resolve textTrackController first so it subscribes to
         // manifestTransformed before the manifest promise resolves.
         const controller = deps.textTrackController;
@@ -137,6 +146,7 @@ describe('createHlsFactories', () => {
         expect(controller).toBeDefined();
         expect(controller.textTracks.length).toBe(1);
         expect(controller.textTracks[0].language).toBe('en');
+        container.dispose();
     });
     it('text track controller swallows manifest fetch errors', async () => {
         const factoryCreator = createHlsFactories(null);
@@ -146,13 +156,15 @@ describe('createHlsFactories', () => {
             type: 'hls',
             manifestProvider: provider,
         });
-        const deps = createContainer(factories).dependencies;
+        const container = createContainer(factories);
+        const deps = container.dependencies;
         const controller = deps.textTrackController;
         // Trigger the transform; the promise will reject but the
         // textTrackController must not throw.
         await deps.manifestTransformed.value.catch(() => undefined);
         await new Promise((r) => setTimeout(r, 0));
         expect(controller.textTracks).toEqual([]);
+        container.dispose();
     });
     describe('ad interstitial discovery', () => {
         function interstitialManifest(overrides = {}) {
@@ -184,11 +196,13 @@ describe('createHlsFactories', () => {
                 type: 'hls',
                 manifestProvider: provider,
             });
-            const deps = createContainer(factories).dependencies;
+            const container = createContainer(factories);
+            const deps = container.dependencies;
             const timeline = await deps.mediaTimeline.value;
             const adBreaks = await timeline.getAdBreaks();
             expect(adBreaks.length).toBe(1);
             expect(adBreaks[0].id).toBe('ad1');
+            container.dispose();
         });
         it('merges stitched SCTE-35 breaks with interstitials by start time', async () => {
             const factoryCreator = createHlsFactories(null);
@@ -230,13 +244,15 @@ describe('createHlsFactories', () => {
                 type: 'hls',
                 manifestProvider: provider,
             });
-            const deps = createContainer(factories).dependencies;
+            const container = createContainer(factories);
+            const deps = container.dependencies;
             const timeline = await deps.mediaTimeline.value;
             const adBreaks = await timeline.getAdBreaks();
             expect(adBreaks.map((b) => [b.id, b.startTime, b.insertion])).toEqual([
                 ['splice-1', 2, 'stitched'],
                 ['ad1', 11, 'interstitial'],
             ]);
+            container.dispose();
         });
         it('omits ad breaks when the playlist has none', async () => {
             const factoryCreator = createHlsFactories(null);
@@ -245,9 +261,11 @@ describe('createHlsFactories', () => {
                 type: 'hls',
                 manifestProvider,
             });
-            const deps = createContainer(factories).dependencies;
+            const container = createContainer(factories);
+            const deps = container.dependencies;
             const timeline = await deps.mediaTimeline.value;
             expect(await timeline.getAdBreaks()).toEqual([]);
+            container.dispose();
         });
         it('discovers ads against a live (non-ended) playlist', async () => {
             const factoryCreator = createHlsFactories(null);
@@ -257,9 +275,11 @@ describe('createHlsFactories', () => {
                 type: 'hls',
                 manifestProvider: provider,
             });
-            const deps = createContainer(factories).dependencies;
+            const container = createContainer(factories);
+            const deps = container.dependencies;
             const timeline = await deps.mediaTimeline.value;
             expect((await timeline.getAdBreaks()).length).toBe(1);
+            container.dispose();
         });
         it('returns no ad breaks when there are no variants', async () => {
             const factoryCreator = createHlsFactories(null);
@@ -275,9 +295,11 @@ describe('createHlsFactories', () => {
                 type: 'hls',
                 manifestProvider: provider,
             });
-            const deps = createContainer(factories).dependencies;
+            const container = createContainer(factories);
+            const deps = container.dependencies;
             const timeline = await deps.mediaTimeline.value;
             expect(await timeline.getAdBreaks()).toEqual([]);
+            container.dispose();
         });
         it('surfaces media playlist fetch errors from getAdBreaks', async () => {
             const factoryCreator = createHlsFactories(null);
@@ -290,12 +312,14 @@ describe('createHlsFactories', () => {
                 type: 'hls',
                 manifestProvider: provider,
             });
-            const deps = createContainer(factories).dependencies;
+            const container = createContainer(factories);
+            const deps = container.dependencies;
             const timeline = await deps.mediaTimeline.value;
             // Discovery is now lazy: getAdBreaks() rejects on a failed media
             // playlist fetch, leaving error handling to the caller (e.g.
             // MseTrack swallows it via its errorHandler).
             await expectAsync(timeline.getAdBreaks()).toBeRejectedWithError('media down');
+            container.dispose();
         });
     });
 });