@amazon/vinyl 1.1.1 → 2.0.0

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

@@ -2,53 +2,163 @@
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { MediaSourceControllerImpl, MediaSourceError, } from '@amazon/vinyl';
-import { Deferred } from '@amazon/vinyl-util';
-import { flushPromises, MockMediaSource, MockSourceBuffer, } from '@amazon/vinyl-util/browserTestUtil';
+import { DURATION_PADDING, LIVE_DURATION, MediaSourceControllerImpl, MediaSourceError, } from '@amazon/vinyl';
+import { AbortError, Deferred, IllegalStateError, } from '@amazon/vinyl-util';
+import { flushPromises, implementEventFakes, mockEvent, MockMediaSource, MockSourceBuffer, } from '@amazon/vinyl-util/browserTestUtil';
 import { data } from '@amazon/vinyl-observable';
 var createSpy = jasmine.createSpy;
 var objectContaining = jasmine.objectContaining;
 import { createEventSpy } from '@amazon/vinyl-util/testUtil';
+const VOD_DURATION = 60;
+function createVodTimeline(duration = VOD_DURATION) {
+    return {
+        periods: [],
+        minBufferTime: 0,
+        getAdBreaks: () => Promise.resolve([]),
+        getDuration: () => Promise.resolve(duration),
+    };
+}
+const liveTimeline = {
+    periods: [],
+    minBufferTime: 0,
+    getAdBreaks: () => Promise.resolve([]),
+    getDuration: () => Promise.resolve(Infinity),
+};
 describe('MediaSourceControllerImpl', () => {
     let mediaSourceFactory;
     let contentTypesValue;
+    let mediaTimelineTransformed;
     let mockMediaSource;
     let deps;
     let controller;
+    let objectUrl;
+    function open() {
+        mockMediaSource.readyState = 'open';
+        mockMediaSource.dispatchEvent(mockEvent('sourceopen'));
+    }
     beforeEach(() => {
         mockMediaSource = new MockMediaSource();
+        implementEventFakes(mockMediaSource);
         mockMediaSource.addSourceBuffer.and.callFake(() => new MockSourceBuffer());
         mediaSourceFactory =
             createSpy('mediaSourceFactory').and.returnValue(mockMediaSource);
         contentTypesValue = data(Promise.resolve(new Set(['audio'])));
+        mediaTimelineTransformed = data(Promise.resolve(createVodTimeline()));
         deps = {
             mediaSourceFactory,
             contentTypesValue,
+            mediaTimelineTransformed,
         };
+        // activate() now owns media source creation and the object URL, so the
+        // real URL APIs (which reject non-Blob args under Node) are stubbed.
+        spyOn(URL, 'createObjectURL').and.returnValue('blob:test-url');
+        spyOn(URL, 'revokeObjectURL');
         controller = new MediaSourceControllerImpl(deps);
+        objectUrl = controller.activate();
     });
     afterEach(() => {
         controller.dispose();
     });
-    describe('constructor', () => {
+    describe('activate', () => {
         it('creates media source using factory', () => {
             expect(mediaSourceFactory).toHaveBeenCalledOnceWith();
         });
+        it('returns an object url for the media source', () => {
+            expect(URL.createObjectURL).toHaveBeenCalledWith(mockMediaSource);
+            expect(objectUrl).toBe('blob:test-url');
+        });
     });
     describe('readyState', () => {
         it('returns media source ready state', () => {
             mockMediaSource.readyState = 'open';
             expect(controller.readyState).toBe('open');
         });
+        it("returns 'closed' when there is no active media source", () => {
+            const freshController = new MediaSourceControllerImpl(deps);
+            expect(freshController.readyState).toBe('closed');
+        });
+    });
+    describe('deactivate', () => {
+        it('returns early and does not throw when never activated', () => {
+            const freshController = new MediaSourceControllerImpl(deps);
+            expect(() => freshController.deactivate()).not.toThrow();
+            expect(URL.revokeObjectURL).not.toHaveBeenCalled();
+        });
+        it('swallows errors thrown while revoking the object url', () => {
+            ;
+            URL.revokeObjectURL.and.throwError(new Error('revoke failed'));
+            expect(() => controller.deactivate()).not.toThrow();
+        });
     });
     describe('duration', () => {
-        it('gets duration from media source', () => {
-            mockMediaSource.duration = 123.45;
-            expect(controller.duration).toBe(123.45);
+        it('sets media source duration after sourceopen', async () => {
+            open();
+            await flushPromises();
+            expect(mockMediaSource.duration).toBe(VOD_DURATION + DURATION_PADDING);
+        });
+        it('uses LIVE_DURATION for live timelines', async () => {
+            mediaTimelineTransformed.value = Promise.resolve(liveTimeline);
+            open();
+            await flushPromises();
+            expect(mockMediaSource.duration).toBe(LIVE_DURATION);
+        });
+        it('does not set duration when media source is not open', async () => {
+            await flushPromises();
+            expect(mockMediaSource.duration).toBe(0);
+        });
+        it('refreshes duration when timeline changes', async () => {
+            open();
+            await flushPromises();
+            expect(mockMediaSource.duration).toBe(VOD_DURATION + DURATION_PADDING);
+            mediaTimelineTransformed.value = Promise.resolve(createVodTimeline(120));
+            await flushPromises();
+            expect(mockMediaSource.duration).toBe(120 + DURATION_PADDING);
+        });
+        it('emits an error if getDuration rejects', async () => {
+            const errorSpy = createEventSpy(controller, 'error');
+            const error = new Error('expected');
+            mediaTimelineTransformed.value = Promise.resolve({
+                periods: [],
+                minBufferTime: 0,
+                getAdBreaks: () => Promise.resolve([]),
+                getDuration: () => Promise.reject(error),
+            });
+            open();
+            await flushPromises();
+            expect(errorSpy).toHaveBeenCalledWith({
+                target: controller,
+                error,
+            });
         });
-        it('sets duration on media source', () => {
-            controller.duration = 67.89;
-            expect(mockMediaSource.duration).toBe(67.89);
+        it('does not emit silent (abort) errors', async () => {
+            const errorSpy = createEventSpy(controller, 'error');
+            mediaTimelineTransformed.value = Promise.resolve({
+                periods: [],
+                minBufferTime: 0,
+                getAdBreaks: () => Promise.resolve([]),
+                getDuration: () => Promise.reject(new AbortError()),
+            });
+            open();
+            await flushPromises();
+            expect(errorSpy).not.toHaveBeenCalled();
+        });
+        it('discards a duration result if the source closed before it resolved', async () => {
+            const deferred = new Deferred();
+            mediaTimelineTransformed.value = Promise.resolve({
+                periods: [],
+                minBufferTime: 0,
+                getAdBreaks: () => Promise.resolve([]),
+                getDuration: () => deferred,
+            });
+            open();
+            await flushPromises();
+            // Close before the duration resolves; the late result should be ignored.
+            mockMediaSource.readyState = 'closed';
+            mockMediaSource.dispatchEvent(mockEvent('sourceclose'));
+            deferred.resolve(123);
+            await flushPromises();
+            expect(mockMediaSource.duration).toBe(0);
+            expect(controller.readyToAppend).toBeFalse();
         });
     });
     describe('createSourceBuffer', () => {
@@ -58,18 +168,15 @@ describe('MediaSourceControllerImpl', () => {
             mockMediaSource.addSourceBuffer.and.returnValue(mockSourceBuffer);
         });
         it('creates source buffer with correct mime type', () => {
-            const controller = new MediaSourceControllerImpl(deps);
             const ref = controller.createSourceBuffer('audio', 'audio/mp4');
             expect(mockMediaSource.addSourceBuffer).toHaveBeenCalledWith('audio/mp4');
             expect(ref.value).toBe(mockSourceBuffer);
         });
         it('sets source buffer mode to sequence', () => {
-            const controller = new MediaSourceControllerImpl(deps);
             controller.createSourceBuffer('audio', 'audio/mp4');
             expect(mockSourceBuffer.mode).toBe('sequence');
         });
         it('emits error events when contentTypesValue rejects', async () => {
-            const controller = new MediaSourceControllerImpl(deps);
             const errorSpy = createEventSpy(controller, 'error');
             const error = new Error('expected error');
             contentTypesValue.value = Promise.reject(error);
@@ -80,13 +187,20 @@ describe('MediaSourceControllerImpl', () => {
             });
         });
         describe('readyToAppend', () => {
-            it('is true when all streams have been created', async () => {
-                const controller = new MediaSourceControllerImpl(deps);
+            it('is true only after duration is set and all source buffers are created', async () => {
+                // Each createSourceBuffer must return a distinct SourceBuffer because
+                // the controller dedupes buffers by identity.
+                mockMediaSource.addSourceBuffer.and.callFake(() => new MockSourceBuffer());
                 const readyToAppendSpy = createEventSpy(controller, 'readyToAppend');
                 expect(controller.readyToAppend).toBeFalse();
                 await flushPromises();
                 expect(readyToAppendSpy).not.toHaveBeenCalled();
+                // Source buffer alone is not enough — duration must be set.
                 controller.createSourceBuffer('audio', 'audio/mp4');
+                expect(controller.readyToAppend).toBeFalse();
+                expect(readyToAppendSpy).not.toHaveBeenCalled();
+                open();
+                await flushPromises();
                 expect(controller.readyToAppend).toBeTrue();
                 expect(readyToAppendSpy).toHaveBeenCalledTimes(1);
                 readyToAppendSpy.calls.reset();
@@ -103,22 +217,23 @@ describe('MediaSourceControllerImpl', () => {
                 expect(readyToAppendSpy).toHaveBeenCalledTimes(1);
             });
         });
+        it('throws IllegalStateError when not active', () => {
+            const freshController = new MediaSourceControllerImpl(deps);
+            expect(() => freshController.createSourceBuffer('audio', 'audio/mp4')).toThrowError(IllegalStateError, 'cannot create a source buffer when not active');
+        });
         it('throws MediaSourceError when addSourceBuffer fails', () => {
-            const controller = new MediaSourceControllerImpl(deps);
             const error = new Error('test error');
             mockMediaSource.addSourceBuffer.and.throwError(error);
             expect(() => controller.createSourceBuffer('audio', 'invalid/type')).toThrowError(MediaSourceError, 'error creating source buffer');
         });
         describe('SourceBufferRef disposal', () => {
             it('removes source buffer from media source', () => {
-                const controller = new MediaSourceControllerImpl(deps);
                 mockMediaSource.readyState = 'open';
                 const ref = controller.createSourceBuffer('audio', 'audio/mp4');
                 ref.dispose();
                 expect(mockMediaSource.removeSourceBuffer).toHaveBeenCalledWith(mockSourceBuffer);
             });
             it('does not remove source buffer when media source is closed', () => {
-                const controller = new MediaSourceControllerImpl(deps);
                 mockMediaSource.readyState = 'open';
                 const ref = controller.createSourceBuffer('audio', 'audio/mp4');
                 mockMediaSource.readyState = 'closed';
@@ -137,14 +252,6 @@ describe('MediaSourceControllerImpl', () => {
             expect(mockMediaSource.endOfStream).toHaveBeenCalledWith('decode');
         });
     });
-    describe('createUrl', () => {
-        it('creates object URL for media source', () => {
-            spyOn(URL, 'createObjectURL').and.returnValue('blob:test-url');
-            const url = controller.createUrl();
-            expect(URL.createObjectURL).toHaveBeenCalledWith(mockMediaSource);
-            expect(url).toBe('blob:test-url');
-        });
-    });
 });
 describe('MediaSourceError', () => {
     it('creates error with message and reason', () => {

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

@@ -96,6 +96,10 @@ describe('SourceBufferControllerImpl', () => {
         await flushPromises();
         expect(controller.isBusy()).withContext('isBusy').toBeFalse();
     });
+    it('tags with the content type, not undefined', () => {
+        expect(controller[Symbol.toStringTag]).toBe('SourceBuffer_audio');
+        expect(controller.logPrefix).toMatch(/^SourceBuffer_audio\//);
+    });
     describe('enqueue', () => {
         it('enqueues a task to execute when the source buffer is next idle', async () => {
             expect(await controller.enqueue(() => Promise.resolve(3))).toBe(3);

package/dist/unit/types/current/streaming/buffering/codecDenylist.test.d.ts

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

package/dist/unit/types/current/streaming/buffering/codecDenylist.test.d.ts.map

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

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

@@ -0,0 +1,56 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { clearCodecDenylist, denylistCodecsFromMimeType, getDenylistedCodecs, isMimeTypeDenylisted, } from '@amazon/vinyl';
+describe('codecDenylist', () => {
+    afterEach(() => {
+        clearCodecDenylist();
+    });
+    describe('denylistCodecsFromMimeType', () => {
+        it('adds codecs and returns true on first denylist', () => {
+            expect(denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"')).toBeTrue();
+            expect(getDenylistedCodecs()).toContain('hvc1.1');
+        });
+        it('returns false when all codecs are already denylisted', () => {
+            denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"');
+            expect(denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"')).toBeFalse();
+        });
+        it('returns true when at least one codec is newly added', () => {
+            denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"');
+            expect(denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1,ec-3"')).toBeTrue();
+        });
+        it('returns false for a mimeType with no codecs', () => {
+            expect(denylistCodecsFromMimeType('video/mp4')).toBeFalse();
+        });
+        it('stores codecs lowercased', () => {
+            denylistCodecsFromMimeType('video/mp4; codecs="HVC1.1"');
+            expect(getDenylistedCodecs()).toContain('hvc1.1');
+        });
+    });
+    describe('isMimeTypeDenylisted', () => {
+        it('returns true when a codec is denylisted', () => {
+            denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"');
+            expect(isMimeTypeDenylisted('video/mp4; codecs="hvc1.1"')).toBeTrue();
+        });
+        it('is case-insensitive', () => {
+            denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"');
+            expect(isMimeTypeDenylisted('video/mp4; codecs="HVC1.1"')).toBeTrue();
+        });
+        it('returns false when no codec is denylisted', () => {
+            denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"');
+            expect(isMimeTypeDenylisted('video/mp4; codecs="avc1.64001f"')).toBeFalse();
+        });
+        it('returns false for a mimeType with no codecs', () => {
+            denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"');
+            expect(isMimeTypeDenylisted('video/mp4')).toBeFalse();
+        });
+    });
+    describe('clearCodecDenylist', () => {
+        it('empties the denylist', () => {
+            denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"');
+            clearCodecDenylist();
+            expect(getDenylistedCodecs()).toEqual([]);
+        });
+    });
+});

package/dist/unit/types/current/streaming/createAllowedContentTypesValue.test.d.ts

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

package/dist/unit/types/current/streaming/createAllowedContentTypesValue.test.d.ts.map

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

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

@@ -0,0 +1,77 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createAllowedContentTypesValue, } from '@amazon/vinyl';
+import { data } from '@amazon/vinyl-observable';
+describe('createAllowedContentTypesValue', () => {
+    let baseContentTypesValue;
+    let options;
+    beforeEach(() => {
+        baseContentTypesValue = data(Promise.resolve(new Set(['audio', 'video', 'text'])));
+        options = data({ allowedContentTypes: null });
+    });
+    it('passes all content types through when the allow list is null', async () => {
+        const result = await createAllowedContentTypesValue({
+            baseContentTypesValue,
+            options,
+        }).value;
+        expect(result).toEqual(new Set(['audio', 'video', 'text']));
+    });
+    it('keeps only the allowed media content types', async () => {
+        options.value = { allowedContentTypes: ['audio'] };
+        const result = await createAllowedContentTypesValue({
+            baseContentTypesValue,
+            options,
+        }).value;
+        // Text always passes through; video is dropped.
+        expect(result).toEqual(new Set(['audio', 'text']));
+    });
+    it('always keeps text even when only video is allowed', async () => {
+        options.value = { allowedContentTypes: ['video'] };
+        const result = await createAllowedContentTypesValue({
+            baseContentTypesValue,
+            options,
+        }).value;
+        expect(result).toEqual(new Set(['video', 'text']));
+    });
+    it('keeps text even when the allow list is empty', async () => {
+        options.value = { allowedContentTypes: [] };
+        const result = await createAllowedContentTypesValue({
+            baseContentTypesValue,
+            options,
+        }).value;
+        expect(result).toEqual(new Set(['text']));
+    });
+    it('ignores allowed types not present in the manifest', async () => {
+        baseContentTypesValue.value = Promise.resolve(new Set(['audio']));
+        options.value = { allowedContentTypes: ['audio', 'video'] };
+        const result = await createAllowedContentTypesValue({
+            baseContentTypesValue,
+            options,
+        }).value;
+        expect(result).toEqual(new Set(['audio']));
+    });
+    it('re-emits a newly filtered set when the allow list changes', async () => {
+        const value = createAllowedContentTypesValue({
+            baseContentTypesValue,
+            options,
+        });
+        const emissions = [];
+        const unsub = value.onData((promise) => {
+            void promise.then((set) => emissions.push(set));
+        });
+        // Changing the allow list should produce a new, filtered emission,
+        // which is what drives the track to reload with only these types.
+        options.value = { allowedContentTypes: ['audio'] };
+        expect(await value.value).toEqual(new Set(['audio', 'text']));
+        unsub();
+        // Wait for all pending promise callbacks to resolve.
+        await Promise.resolve();
+        await Promise.resolve();
+        expect(emissions).toEqual([
+            new Set(['audio', 'video', 'text']),
+            new Set(['audio', 'text']),
+        ]);
+    });
+});

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

@@ -24,12 +24,16 @@ describe('createDefaultMediaTimelineTransformer', () => {
             persistentState: false,
         });
     });
-    function createDeps(timeline, preferredAudioLanguage = null) {
+    function createDeps(timeline, preferredAudioLanguage = null, codecOverrides = {}, preferDescriptiveAudio = false) {
         return {
             capabilities,
             drmController,
             mediaTimeline: data(Promise.resolve(timeline)),
-            options: data({ preferredAudioLanguage }),
+            options: data({
+                preferredAudioLanguage,
+                codecOverrides,
+                preferDescriptiveAudio,
+            }),
         };
     }
     it('passes through playable qualities', async () => {
@@ -48,11 +52,91 @@ describe('createDefaultMediaTimelineTransformer', () => {
                 },
             ],
             minBufferTime: 2,
+            getAdBreaks: () => Promise.resolve([]),
+            getDuration: () => Promise.resolve(Infinity),
         };
         const result = await createDefaultMediaTimelineTransformer(createDeps(timeline)).value;
         expect(result.periods[0].qualities.length).toBe(1);
         expect(result.periods[0].qualities[0].metadata.qualityId).toBe('q1');
     });
+    it('selects main vs audio-description audio per preferDescriptiveAudio', async () => {
+        const makeTimeline = () => ({
+            periods: [
+                {
+                    startTime: 0,
+                    endTime: 100,
+                    qualities: [
+                        createQuality({
+                            contentType: 'audio',
+                            mimeType: 'audio/mp4',
+                            qualityId: 'main',
+                            lang: 'en',
+                        }),
+                        createQuality({
+                            contentType: 'audio',
+                            mimeType: 'audio/mp4',
+                            qualityId: 'dvs',
+                            lang: 'en',
+                            characteristics: [
+                                'public.accessibility.describes-video',
+                            ],
+                        }),
+                    ],
+                },
+            ],
+            minBufferTime: 2,
+            getAdBreaks: () => Promise.resolve([]),
+            getDuration: () => Promise.resolve(Infinity),
+        });
+        const audioIds = (t) => t.periods[0].qualities.map((q) => q.metadata.qualityId);
+        const byDefault = await createDefaultMediaTimelineTransformer(createDeps(makeTimeline())).value;
+        expect(audioIds(byDefault)).toEqual(['main']);
+        const optedIn = await createDefaultMediaTimelineTransformer(createDeps(makeTimeline(), null, {}, true)).value;
+        expect(audioIds(optedIn)).toEqual(['dvs']);
+    });
+    it('does not let a described rendition with a closer language tag evict the main audio', async () => {
+        // The main audio is region-tagged ('en-US') while the described
+        // rendition carries the generic 'en'. Against a preference of 'en',
+        // 'en' scores an exact match and 'en-US' only a related one, so if the
+        // language filter ran before the audio-description gate it would drop
+        // the main audio and strand the (not-opted-in) listener on described
+        // audio. The description gate must run first so the main audio wins.
+        const makeTimeline = () => ({
+            periods: [
+                {
+                    startTime: 0,
+                    endTime: 100,
+                    qualities: [
+                        createQuality({
+                            contentType: 'audio',
+                            mimeType: 'audio/mp4',
+                            qualityId: 'main',
+                            lang: 'en-US',
+                        }),
+                        createQuality({
+                            contentType: 'audio',
+                            mimeType: 'audio/mp4',
+                            qualityId: 'dvs',
+                            lang: 'en',
+                            characteristics: [
+                                'public.accessibility.describes-video',
+                            ],
+                        }),
+                    ],
+                },
+            ],
+            minBufferTime: 2,
+            getAdBreaks: () => Promise.resolve([]),
+            getDuration: () => Promise.resolve(Infinity),
+        });
+        const audioIds = (t) => t.periods[0].qualities.map((q) => q.metadata.qualityId);
+        const byDefault = await createDefaultMediaTimelineTransformer(createDeps(makeTimeline(), 'en')).value;
+        expect(audioIds(byDefault)).toEqual(['main']);
+        // Opting in still yields the described rendition (the eligibility gate
+        // keeps only it, then language selection picks among what remains).
+        const optedIn = await createDefaultMediaTimelineTransformer(createDeps(makeTimeline(), 'en', {}, true)).value;
+        expect(audioIds(optedIn)).toEqual(['dvs']);
+    });
     it('filters out unsupported mime types', async () => {
         capabilities.canPlayTypeMse.and.callFake((type) => type.includes('mp4a'));
         const timeline = {
@@ -75,11 +159,67 @@ describe('createDefaultMediaTimelineTransformer', () => {
                 },
             ],
             minBufferTime: 2,
+            getAdBreaks: () => Promise.resolve([]),
+            getDuration: () => Promise.resolve(Infinity),
         };
         const result = await createDefaultMediaTimelineTransformer(createDeps(timeline)).value;
         expect(result.periods[0].qualities.length).toBe(1);
         expect(result.periods[0].qualities[0].metadata.qualityId).toBe('aac');
     });
+    it('denies a codec via codecOverrides even when the browser supports it', async () => {
+        capabilities.canPlayTypeMse.and.returnValue(true);
+        const timeline = {
+            periods: [
+                {
+                    startTime: 0,
+                    endTime: 100,
+                    qualities: [
+                        createQuality({
+                            contentType: 'video',
+                            mimeType: 'video/mp4; codecs="hvc1.1"',
+                            qualityId: 'hevc',
+                        }),
+                        createQuality({
+                            contentType: 'video',
+                            mimeType: 'video/mp4; codecs="avc1.64001f"',
+                            qualityId: 'avc',
+                        }),
+                    ],
+                },
+            ],
+            minBufferTime: 2,
+            getAdBreaks: () => Promise.resolve([]),
+            getDuration: () => Promise.resolve(Infinity),
+        };
+        const result = await createDefaultMediaTimelineTransformer(createDeps(timeline, null, { hvc1: 'deny' })).value;
+        expect(result.periods[0].qualities.map((q) => q.metadata.qualityId)).toEqual(['avc']);
+    });
+    it('allows a codec via codecOverrides even when the browser reports it unsupported', async () => {
+        // Browser rejects everything; the override forces the codec through.
+        capabilities.canPlayTypeMse.and.returnValue(false);
+        const timeline = {
+            periods: [
+                {
+                    startTime: 0,
+                    endTime: 100,
+                    qualities: [
+                        createQuality({
+                            contentType: 'video',
+                            mimeType: 'video/mp4; codecs="hvc1.1"',
+                            qualityId: 'hevc',
+                        }),
+                    ],
+                },
+            ],
+            minBufferTime: 2,
+            getAdBreaks: () => Promise.resolve([]),
+            getDuration: () => Promise.resolve(Infinity),
+        };
+        const result = await createDefaultMediaTimelineTransformer(createDeps(timeline, null, { hvc1: 'allow' })).value;
+        expect(result.periods[0].qualities.map((q) => q.metadata.qualityId)).toEqual(['hevc']);
+        // The override supersedes the browser check, which is not consulted.
+        expect(capabilities.canPlayTypeMse).not.toHaveBeenCalled();
+    });
     it('filters out unsupported key systems', async () => {
         drmController.isSupported.and.callFake((metadata) => Promise.resolve(metadata.contentProtections.length === 0
             ? { supported: true, persistentState: false }
@@ -107,6 +247,8 @@ describe('createDefaultMediaTimelineTransformer', () => {
                 },
             ],
             minBufferTime: 2,
+            getAdBreaks: () => Promise.resolve([]),
+            getDuration: () => Promise.resolve(Infinity),
         };
         const result = await createDefaultMediaTimelineTransformer(createDeps(timeline)).value;
         expect(result.periods[0].qualities.length).toBe(1);
@@ -135,6 +277,8 @@ describe('createDefaultMediaTimelineTransformer', () => {
                 },
             ],
             minBufferTime: 2,
+            getAdBreaks: () => Promise.resolve([]),
+            getDuration: () => Promise.resolve(Infinity),
         };
         const result = await createDefaultMediaTimelineTransformer(createDeps(timeline, 'en')).value;
         expect(result.periods[0].qualities.length).toBe(1);
@@ -163,6 +307,8 @@ describe('createDefaultMediaTimelineTransformer', () => {
                 },
             ],
             minBufferTime: 2,
+            getAdBreaks: () => Promise.resolve([]),
+            getDuration: () => Promise.resolve(Infinity),
         };
         const options = data({
             preferredAudioLanguage: 'en',
@@ -197,6 +343,8 @@ describe('createDefaultMediaTimelineTransformer', () => {
                 },
             ],
             minBufferTime: 5,
+            getAdBreaks: () => Promise.resolve([]),
+            getDuration: () => Promise.resolve(Infinity),
         };
         const result = await createDefaultMediaTimelineTransformer(createDeps(timeline)).value;
         expect(result.minBufferTime).toBe(5);

package/dist/unit/types/current/streaming/mediaTimelineAccessibilityFilter.test.d.ts

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

package/dist/unit/types/current/streaming/mediaTimelineAccessibilityFilter.test.d.ts.map

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