@amazon/vinyl 1.1.1 → 1.2.1

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

@@ -2,28 +2,49 @@
  * 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 } 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,
+        getDuration: () => Promise.resolve(duration),
+    };
+}
+const liveTimeline = {
+    periods: [],
+    minBufferTime: 0,
+    getDuration: () => Promise.resolve(Infinity),
+};
 describe('MediaSourceControllerImpl', () => {
     let mediaSourceFactory;
     let contentTypesValue;
+    let mediaTimelineTransformed;
     let mockMediaSource;
     let deps;
     let controller;
+    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,
         };
         controller = new MediaSourceControllerImpl(deps);
     });
@@ -42,13 +63,71 @@ describe('MediaSourceControllerImpl', () => {
         });
     });
     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,
+                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,
+                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,
+                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 +137,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 +156,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();
@@ -104,21 +187,18 @@ describe('MediaSourceControllerImpl', () => {
             });
         });
         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';

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

@@ -48,6 +48,7 @@ describe('createDefaultMediaTimelineTransformer', () => {
                 },
             ],
             minBufferTime: 2,
+            getDuration: () => Promise.resolve(Infinity),
         };
         const result = await createDefaultMediaTimelineTransformer(createDeps(timeline)).value;
         expect(result.periods[0].qualities.length).toBe(1);
@@ -75,6 +76,7 @@ describe('createDefaultMediaTimelineTransformer', () => {
                 },
             ],
             minBufferTime: 2,
+            getDuration: () => Promise.resolve(Infinity),
         };
         const result = await createDefaultMediaTimelineTransformer(createDeps(timeline)).value;
         expect(result.periods[0].qualities.length).toBe(1);
@@ -107,6 +109,7 @@ describe('createDefaultMediaTimelineTransformer', () => {
                 },
             ],
             minBufferTime: 2,
+            getDuration: () => Promise.resolve(Infinity),
         };
         const result = await createDefaultMediaTimelineTransformer(createDeps(timeline)).value;
         expect(result.periods[0].qualities.length).toBe(1);
@@ -135,6 +138,7 @@ describe('createDefaultMediaTimelineTransformer', () => {
                 },
             ],
             minBufferTime: 2,
+            getDuration: () => Promise.resolve(Infinity),
         };
         const result = await createDefaultMediaTimelineTransformer(createDeps(timeline, 'en')).value;
         expect(result.periods[0].qualities.length).toBe(1);
@@ -163,6 +167,7 @@ describe('createDefaultMediaTimelineTransformer', () => {
                 },
             ],
             minBufferTime: 2,
+            getDuration: () => Promise.resolve(Infinity),
         };
         const options = data({
             preferredAudioLanguage: 'en',
@@ -197,6 +202,7 @@ describe('createDefaultMediaTimelineTransformer', () => {
                 },
             ],
             minBufferTime: 5,
+            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":""}

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

@@ -0,0 +1,99 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createAudioDescriptionFilter, createEmptyMediaQualityMetadata, filterTimelineQualities, isAudioDescription, throwNoPlayableAudio, } from '@amazon/vinyl';
+function audioQuality(id, characteristics) {
+    return {
+        metadata: {
+            ...createEmptyMediaQualityMetadata(),
+            qualityId: id,
+            contentType: 'audio',
+            lang: 'en',
+            characteristics,
+        },
+        getSegment: () => Promise.resolve(null),
+    };
+}
+function videoQuality() {
+    return {
+        metadata: {
+            ...createEmptyMediaQualityMetadata(),
+            qualityId: 'video',
+            contentType: 'video',
+        },
+        getSegment: () => Promise.resolve(null),
+    };
+}
+function timelineOf(qualities) {
+    return {
+        periods: [{ startTime: 0, endTime: 10, qualities: [...qualities] }],
+        minBufferTime: 2,
+        getAdBreaks: () => Promise.resolve([]),
+        getDuration: () => Promise.resolve(Infinity),
+    };
+}
+/** The audio qualityIds kept after applying the filter. */
+function keptAudio(qualities, preferDescription) {
+    const filtered = filterTimelineQualities(createAudioDescriptionFilter(preferDescription), throwNoPlayableAudio, timelineOf(qualities));
+    return filtered.periods[0].qualities
+        .filter((q) => q.metadata.contentType === 'audio')
+        .map((q) => q.metadata.qualityId);
+}
+const DVS = 'public.accessibility.describes-video';
+describe('throwNoPlayableAudio', () => {
+    it('throws (defensive guard — the filter never strands audio)', () => {
+        expect(() => throwNoPlayableAudio()).toThrowError(/No playable audio rendition/);
+    });
+});
+describe('isAudioDescription', () => {
+    it('detects the HLS describes-video characteristic', () => {
+        expect(isAudioDescription({
+            ...createEmptyMediaQualityMetadata(),
+            characteristics: [DVS],
+        })).toBeTrue();
+    });
+    it('detects the DASH description role', () => {
+        expect(isAudioDescription({
+            ...createEmptyMediaQualityMetadata(),
+            characteristics: ['description'],
+        })).toBeTrue();
+    });
+    it('is false for a plain rendition', () => {
+        expect(isAudioDescription(createEmptyMediaQualityMetadata())).toBeFalse();
+    });
+});
+describe('createAudioDescriptionFilter', () => {
+    it('drops the description track when a main alternative exists (default)', () => {
+        const kept = keptAudio([
+            audioQuality('dvs', [DVS]),
+            audioQuality('main', []),
+            videoQuality(),
+        ], false);
+        expect(kept).toEqual(['main']);
+    });
+    it('keeps the description track when it is the only audio (never strands)', () => {
+        const kept = keptAudio([audioQuality('dvs', [DVS]), videoQuality()], false);
+        expect(kept).toEqual(['dvs']);
+    });
+    it('keeps only the description track when opted in', () => {
+        const kept = keptAudio([
+            audioQuality('dvs', [DVS]),
+            audioQuality('main', []),
+            videoQuality(),
+        ], true);
+        expect(kept).toEqual(['dvs']);
+    });
+    it('keeps all audio when opted in but no description exists', () => {
+        const kept = keptAudio([audioQuality('a', []), audioQuality('b', []), videoQuality()], true);
+        expect(kept).toEqual(['a', 'b']);
+    });
+    it('leaves non-audio qualities untouched', () => {
+        const filtered = filterTimelineQualities(createAudioDescriptionFilter(false), throwNoPlayableAudio, timelineOf([
+            audioQuality('dvs', [DVS]),
+            audioQuality('main', []),
+            videoQuality(),
+        ]));
+        expect(filtered.periods[0].qualities.some((q) => q.metadata.contentType === 'video')).toBeTrue();
+    });
+});

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

@@ -27,6 +27,7 @@ describe('filterTimelineQualities', () => {
             },
         ],
         minBufferTime: 2,
+        getDuration: () => Promise.resolve(Infinity),
     };
     it('filters qualities by predicate', () => {
         const result = filterTimelineQualities((q) => q.contentType === 'audio', () => {
@@ -60,6 +61,7 @@ describe('filterTimelineQualitiesAsync', () => {
             },
         ],
         minBufferTime: 2,
+        getDuration: () => Promise.resolve(Infinity),
     };
     it('filters qualities by async predicate', async () => {
         const result = await filterTimelineQualitiesAsync((q) => Promise.resolve(q.contentType === 'audio'), () => {

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

@@ -41,6 +41,7 @@ describe('createLanguageFilter', () => {
                 },
             ],
             minBufferTime: 2,
+            getDuration: () => Promise.resolve(Infinity),
         };
         const result = applyLanguageFilter(timeline, 'en', 'audio');
         expect(result.periods[0].qualities.length).toBe(2); // en audio + video
@@ -59,6 +60,7 @@ describe('createLanguageFilter', () => {
                 },
             ],
             minBufferTime: 2,
+            getDuration: () => Promise.resolve(Infinity),
         };
         const result = applyLanguageFilter(timeline, 'en', 'audio');
         expect(result.periods[0].qualities.length).toBe(2); // en + null
@@ -73,6 +75,7 @@ describe('createLanguageFilter', () => {
                 },
             ],
             minBufferTime: 5,
+            getDuration: () => Promise.resolve(Infinity),
         };
         const result = applyLanguageFilter(timeline, 'en', 'audio');
         expect(result.minBufferTime).toBe(5);
@@ -91,6 +94,7 @@ describe('createLanguageFilter', () => {
                 },
             ],
             minBufferTime: 2,
+            getDuration: () => Promise.resolve(Infinity),
         };
         const result = applyLanguageFilter(timeline, 'en', 'audio');
         expect(result.periods[0].qualities.some((q) => q.metadata.contentType === 'video')).toBeTrue();
@@ -105,6 +109,7 @@ describe('createLanguageFilter', () => {
                 },
             ],
             minBufferTime: 2,
+            getDuration: () => Promise.resolve(Infinity),
         };
         // 'xx' doesn't match 'ja', so all kept
         const result = applyLanguageFilter(timeline, 'xx', 'audio');
@@ -131,6 +136,7 @@ describe('createLanguageFilter', () => {
                 },
             ],
             minBufferTime: 2,
+            getDuration: () => Promise.resolve(Infinity),
         };
         // 'en' matches period 1 but not period 2
         // Period 1: filtered to 'en' only
@@ -161,6 +167,7 @@ describe('createLanguageFilter', () => {
                 },
             ],
             minBufferTime: 2,
+            getDuration: () => Promise.resolve(Infinity),
         };
         const result = applyLanguageFilter(timeline, 'en', 'audio');
         // Period 1: filtered to 'en'

package/dist/unit/types/current/text/HtmlTextTrackRenderer.test.d.ts

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

package/dist/unit/types/current/text/HtmlTextTrackRenderer.test.d.ts.map

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