@amazon/vinyl 1.1.1 → 1.2.0

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

@@ -3,10 +3,25 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { AutoResetControllerImpl, } from '@amazon/vinyl';
-import { ErrorOrigin, ReportableError, networkState, DisposedError, } from '@amazon/vinyl-util';
+import { networkState, DisposedError, RequestError } from '@amazon/vinyl-util';
 import { MockPlaybackController } from '@amazon/vinyl/vinylTestUtil';
-import { createEventSpy, MockNetworkState, overrideGlobalInit, } from '@amazon/vinyl-util/testUtil';
+import { createEventSpy, emptyInternalError, emptyResponseError, MockNetworkState, overrideGlobalInit, } from '@amazon/vinyl-util/testUtil';
 import { mockEvent, useMockTime } from '@amazon/vinyl-util/browserTestUtil';
+/**
+ * Creates a RequestError representing a transient network failure (no response received).
+ * These are the only errors that AutoResetController watches for retry opportunities.
+ */
+function createNetworkRequestError() {
+    return new RequestError(null, emptyInternalError);
+}
+/**
+ * Creates a RequestError that received an HTTP response. These should be ignored by
+ * the AutoResetController, since a service that responded is unlikely to recover
+ * on its own.
+ */
+function createResponseRequestError() {
+    return new RequestError(new Response(null, { status: 500 }), emptyResponseError);
+}
 describe('AutoResetControllerImpl', () => {
     let deps;
     let controller;
@@ -47,32 +62,35 @@ describe('AutoResetControllerImpl', () => {
             expect(playbackController.on).toHaveBeenCalledWith('seeking', jasmine.any(Function));
             expect(playbackController.on).toHaveBeenCalledWith('playing', jasmine.any(Function));
         });
+        it('starts with resetPending false', () => {
+            controller = new AutoResetControllerImpl(deps);
+            expect(controller.resetPending).toBeFalse();
+        });
     });
     describe('setError', () => {
         beforeEach(() => {
             controller = new AutoResetControllerImpl(deps);
         });
-        it('ignores non-ReportableError', () => {
+        it('ignores non-RequestError', () => {
             const error = new Error('test error');
             controller.setError(error);
             expect(mockNetworkState.on).not.toHaveBeenCalled();
+            expect(controller.resetPending).toBeFalse();
         });
-        it('ignores ReportableError with non-SERVICE_INTERNAL origin', () => {
-            const error = new ReportableError('test', ErrorOrigin.SERVICE_EXTERNAL);
-            controller.setError(error);
+        it('ignores RequestError with a response (HTTP failure)', () => {
+            controller.setError(createResponseRequestError());
             expect(mockNetworkState.on).not.toHaveBeenCalled();
+            expect(controller.resetPending).toBeFalse();
         });
-        it('sets error and starts watching for SERVICE_INTERNAL ReportableError', () => {
-            const error = new ReportableError('test', ErrorOrigin.SERVICE_INTERNAL);
-            controller.setError(error);
+        it('sets error and starts watching for transient network RequestError', () => {
+            controller.setError(createNetworkRequestError());
             expect(mockNetworkState.on).toHaveBeenCalledWith('online', jasmine.any(Function));
+            expect(controller.resetPending).toBeTrue();
         });
         it('ignores subsequent errors when already in error state', () => {
-            const error1 = new ReportableError('test1', ErrorOrigin.SERVICE_INTERNAL);
-            const error2 = new ReportableError('test2', ErrorOrigin.SERVICE_INTERNAL);
-            controller.setError(error1);
+            controller.setError(createNetworkRequestError());
             mockNetworkState.on.calls.reset();
-            controller.setError(error2);
+            controller.setError(createNetworkRequestError());
             expect(mockNetworkState.on).not.toHaveBeenCalled();
         });
     });
@@ -82,7 +100,7 @@ describe('AutoResetControllerImpl', () => {
         beforeEach(() => {
             controller = new AutoResetControllerImpl(deps);
             resetSpy = createEventSpy(controller, 'reset');
-            error = new ReportableError('test', ErrorOrigin.SERVICE_INTERNAL);
+            error = createNetworkRequestError();
         });
         it('emits reset event when network comes online', () => {
             controller.setError(error);
@@ -160,7 +178,7 @@ describe('AutoResetControllerImpl', () => {
         let resetSpy;
         let error;
         beforeEach(() => {
-            error = new ReportableError('test', ErrorOrigin.SERVICE_INTERNAL);
+            error = createNetworkRequestError();
         });
         it('retries at specified interval when online', async () => {
             controller = new AutoResetControllerImpl(deps, { retryInterval: 5 });
@@ -197,12 +215,109 @@ describe('AutoResetControllerImpl', () => {
                 expect(resetSpy).toHaveBeenCalledTimes(3);
             }
         });
+        it('clears resetPending when max retries are exhausted', async () => {
+            controller = new AutoResetControllerImpl(deps, {
+                retryInterval: 1,
+                maxRetries: 1,
+            });
+            controller.setError(error);
+            expect(controller.resetPending).toBeTrue();
+            // First retry succeeds (resets) and re-arms on next setError
+            await clock.tick(1);
+            controller.setError(error);
+            expect(controller.resetPending).toBeTrue();
+            // Second retry exhausts the budget — interval fires but no reset emitted,
+            // and resetPending should transition to false.
+            await clock.tick(1);
+            expect(controller.resetPending).toBeFalse();
+        });
+    });
+    describe('resetPending', () => {
+        let error;
+        beforeEach(() => {
+            controller = new AutoResetControllerImpl(deps);
+            error = createNetworkRequestError();
+        });
+        it('is false initially', () => {
+            expect(controller.resetPending).toBeFalse();
+        });
+        it('becomes true when an eligible error is set', () => {
+            controller.setError(error);
+            expect(controller.resetPending).toBeTrue();
+        });
+        it('remains false when a non-eligible error is set', () => {
+            controller.setError(new Error('not eligible'));
+            expect(controller.resetPending).toBeFalse();
+        });
+        it('becomes false after a reset is emitted', () => {
+            controller.setError(error);
+            playbackController.dispatch('play', {});
+            expect(controller.resetPending).toBeFalse();
+        });
+        it('becomes false when cleared', () => {
+            controller.setError(error);
+            controller.clear();
+            expect(controller.resetPending).toBeFalse();
+        });
+        it('is false when the controller is disabled', () => {
+            controller = new AutoResetControllerImpl(deps, { enabled: false });
+            controller.setError(error);
+            expect(controller.resetPending).toBeFalse();
+        });
+    });
+    describe('resetPendingChange event', () => {
+        let resetPendingChangeSpy;
+        let error;
+        beforeEach(() => {
+            controller = new AutoResetControllerImpl(deps);
+            resetPendingChangeSpy = createEventSpy(controller, 'resetPendingChange');
+            error = createNetworkRequestError();
+        });
+        it('dispatches when resetPending becomes true', () => {
+            controller.setError(error);
+            expect(resetPendingChangeSpy).toHaveBeenCalledOnceWith({
+                previous: false,
+                current: true,
+            });
+        });
+        it('dispatches when resetPending becomes false via reset', () => {
+            controller.setError(error);
+            resetPendingChangeSpy.calls.reset();
+            playbackController.dispatch('play', {});
+            expect(resetPendingChangeSpy).toHaveBeenCalledOnceWith({
+                previous: true,
+                current: false,
+            });
+        });
+        it('dispatches when resetPending becomes false via clear', () => {
+            controller.setError(error);
+            resetPendingChangeSpy.calls.reset();
+            controller.clear();
+            expect(resetPendingChangeSpy).toHaveBeenCalledOnceWith({
+                previous: true,
+                current: false,
+            });
+        });
+        it('does not dispatch when setError is called with an in-progress error', () => {
+            controller.setError(error);
+            resetPendingChangeSpy.calls.reset();
+            controller.setError(error);
+            expect(resetPendingChangeSpy).not.toHaveBeenCalled();
+        });
+        it('does not dispatch when clear is called with no error', () => {
+            controller.clear();
+            expect(resetPendingChangeSpy).not.toHaveBeenCalled();
+        });
+        it('does not dispatch when an ineligible error is set', () => {
+            controller.setError(new Error('not eligible'));
+            expect(resetPendingChangeSpy).not.toHaveBeenCalled();
+        });
     });
     describe('clear', () => {
         let error;
         beforeEach(() => {
             controller = new AutoResetControllerImpl(deps);
-            error = new ReportableError('test', ErrorOrigin.SERVICE_INTERNAL);
+            error = createNetworkRequestError();
         });
         it('clears error state and stops watching', () => {
             controller.setError(error);
@@ -229,8 +344,7 @@ describe('AutoResetControllerImpl', () => {
     describe('dispose', () => {
         it('clears error state and disposes resources', () => {
             controller = new AutoResetControllerImpl(deps);
-            const error = new ReportableError('test', ErrorOrigin.SERVICE_INTERNAL);
-            controller.setError(error);
+            controller.setError(createNetworkRequestError());
             controller.dispose();
             // Should not emit reset after disposing
             const resetSpy = createEventSpy(controller, 'reset');
@@ -250,15 +364,13 @@ describe('AutoResetControllerImpl', () => {
     describe('disabled behavior', () => {
         it('does not watch for errors when disabled', () => {
             controller = new AutoResetControllerImpl(deps, { enabled: false });
-            const error = new ReportableError('test', ErrorOrigin.SERVICE_INTERNAL);
-            controller.setError(error);
+            controller.setError(createNetworkRequestError());
             expect(mockNetworkState.on).not.toHaveBeenCalled();
         });
         it('does not emit reset events when disabled', () => {
             controller = new AutoResetControllerImpl(deps, { enabled: false });
             const resetSpy = createEventSpy(controller, 'reset');
-            const error = new ReportableError('test', ErrorOrigin.SERVICE_INTERNAL);
-            controller.setError(error);
+            controller.setError(createNetworkRequestError());
             playbackController.dispatch('play', {});
             expect(resetSpy).not.toHaveBeenCalled();
         });

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

@@ -12,7 +12,11 @@ describe('createDashContentStreamFactories', () => {
     let mediaSourceController;
     let playbackController;
     let qualitySelector;
-    const emptyTimeline = { periods: [], minBufferTime: 0 };
+    const emptyTimeline = {
+        periods: [],
+        minBufferTime: 0,
+        getDuration: () => Promise.resolve(Infinity),
+    };
     beforeEach(() => {
         mediaSourceController = new MockMediaSourceController();
         playbackController = new MockPlaybackController();

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

@@ -9,7 +9,11 @@ var objectContaining = jasmine.objectContaining;
 describe('createSegmentControllerFactory', () => {
     it('creates SegmentControllerImpl with merged dependencies', () => {
         const playbackController = new MockPlaybackController();
-        const emptyTimeline = { periods: [], minBufferTime: 0 };
+        const emptyTimeline = {
+            periods: [],
+            minBufferTime: 0,
+            getDuration: () => Promise.resolve(Infinity),
+        };
         const factory = createSegmentControllerFactory({ playbackController }, 'audio', { prefetchActive: 100 });
         const controller = factory({
             mediaTimelineTransformed: data(Promise.resolve(emptyTimeline)),

package/dist/unit/types/current/track/dash/util/mpd.test.js

@@ -308,5 +308,34 @@ describe('mpd utils', () => {
                 expect(calculateDuration(manifest)).toBe(50);
             });
         });
+        describe('when MPD type is dynamic', () => {
+            it('returns Infinity for live presentations', () => {
+                // language=XML
+                const manifest = parseDashManifest(`<?xml version="1.0" ?>
+<MPD type="dynamic" minBufferTime="PT0.0S" profiles="urn:mpeg:dash:profile:isoff-live:2011" xmlns="urn:mpeg:dash:schema:mpd:2011">
+  <Period/>
+</MPD>`);
+                expect(calculateDuration(manifest)).toBe(Infinity);
+            });
+        });
+        describe('when there are no periods', () => {
+            it('throws', () => {
+                const manifest = clone(mockDashManifest);
+                delete manifest.MPD
+                    .mediaPresentationDuration;
+                manifest.MPD.Period = [];
+                expect(() => calculateDuration(manifest)).toThrowError(/no periods/i);
+            });
+        });
+        describe('when the last period has no determinable end', () => {
+            it('throws', () => {
+                // language=XML
+                const manifest = parseDashManifest(`<?xml version="1.0" ?>
+<MPD minBufferTime="PT0.0S" profiles="urn:mpeg:dash:profile:isoff-live:2011" xmlns="urn:mpeg:dash:schema:mpd:2011">
+  <Period/>
+</MPD>`);
+                expect(() => calculateDuration(manifest)).toThrowError(/Unable to determine/);
+            });
+        });
     });
 });