@amazon/vinyl 1.0.0

package/dist/unit/types/current/streaming/util/segment.test.js

@@ -0,0 +1,92 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { getSegmentAtTime, getSegmentInsertionIndexAtTime, } from '@amazon/vinyl';
+var objectContaining = jasmine.objectContaining;
+describe('segment utils', () => {
+    const segments = [
+        {
+            timestampOffset: 0,
+            startTime: 0,
+            endTime: 10,
+        },
+        {
+            timestampOffset: 10,
+            startTime: 10,
+            endTime: 20,
+        },
+        {
+            timestampOffset: 20,
+            startTime: 20,
+            endTime: 30,
+        },
+        {
+            timestampOffset: 30,
+            startTime: 30,
+            endTime: 40,
+        },
+    ];
+    describe('getSegmentAtTime', () => {
+        it('returns the segment at the given time', () => {
+            expect(getSegmentAtTime(0, segments)).toEqual(objectContaining({ startTime: 0 }));
+            expect(getSegmentAtTime(10, segments)).toEqual(objectContaining({ startTime: 10 }));
+            expect(getSegmentAtTime(19.99, segments)).toEqual(objectContaining({ startTime: 10 }));
+            expect(getSegmentAtTime(20, segments)).toEqual(objectContaining({ startTime: 20 }));
+            expect(getSegmentAtTime(25, segments)).toEqual(objectContaining({ startTime: 20 }));
+            expect(getSegmentAtTime(30, segments)).toEqual(objectContaining({ startTime: 30 }));
+            expect(getSegmentAtTime(39.999, segments)).toEqual(objectContaining({ startTime: 30 }));
+        });
+        describe('when no segments span the provided time', () => {
+            it('returns null', () => {
+                expect(getSegmentAtTime(0, [])).toBeNull();
+                expect(getSegmentAtTime(10, [])).toBeNull();
+                expect(getSegmentAtTime(100, segments)).toBeNull();
+                expect(getSegmentAtTime(-1, segments)).toBeNull();
+                expect(getSegmentAtTime(40, segments)).toBeNull();
+            });
+        });
+        describe('with a forward-snap affordance', () => {
+            it('snaps forward to the next segment when time is within affordance of its start', () => {
+                expect(getSegmentAtTime(9.9, segments, 0.2)).toEqual(objectContaining({ startTime: 10 }));
+                expect(getSegmentAtTime(19.85, segments, 0.2)).toEqual(objectContaining({ startTime: 20 }));
+            });
+            it('does not snap forward when the gap exceeds affordance', () => {
+                expect(getSegmentAtTime(9.5, segments, 0.2)).toEqual(objectContaining({ startTime: 0 }));
+            });
+            it('returns the next segment even when the previous one still covers time', () => {
+                // Documented trade-off: time=9.9 is covered by [0,10) but
+                // affordance forward-snaps to [10,20).
+                expect(getSegmentAtTime(9.9, segments, 0.2)).toEqual(objectContaining({ startTime: 10 }));
+            });
+            it('snaps forward into the first segment when time is just before 0', () => {
+                expect(getSegmentAtTime(-0.1, segments, 0.2)).toEqual(objectContaining({ startTime: 0 }));
+            });
+            it('returns null when the snapped lookup lands past the last segment', () => {
+                expect(getSegmentAtTime(40, segments, 0.2)).toBeNull();
+                expect(getSegmentAtTime(39.9, segments, 0.2)).toEqual(objectContaining({ startTime: 30 }));
+            });
+            it('still gates on the original time against endTime', () => {
+                // time + affordance lands in [0,10), but endTime is exclusive
+                // and time itself is at endTime — must return null.
+                expect(getSegmentAtTime(10, segments, 0)).toEqual(objectContaining({ startTime: 10 }));
+                // With one-segment list and affordance, time at endTime returns null.
+                const oneSegment = [segments[0]];
+                expect(getSegmentAtTime(10, oneSegment, 0.2)).toBeNull();
+            });
+        });
+    });
+    describe('getSegmentInsertionIndexAtTime', () => {
+        it('returns the segment insertion index at the given time', () => {
+            expect(getSegmentInsertionIndexAtTime(0, [])).toBe(0);
+            expect(getSegmentInsertionIndexAtTime(-10, segments)).toBe(0);
+            expect(getSegmentInsertionIndexAtTime(0, segments)).toBe(1);
+            expect(getSegmentInsertionIndexAtTime(10, segments)).toBe(2);
+            expect(getSegmentInsertionIndexAtTime(19.99, segments)).toBe(2);
+            expect(getSegmentInsertionIndexAtTime(20, segments)).toBe(3);
+            expect(getSegmentInsertionIndexAtTime(30, segments)).toBe(4);
+            expect(getSegmentInsertionIndexAtTime(40, segments)).toBe(4);
+            expect(getSegmentInsertionIndexAtTime(50, segments)).toBe(4);
+        });
+    });
+});

package/dist/unit/types/current/track/AutoResetController.test.d.ts

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

package/dist/unit/types/current/track/AutoResetController.test.d.ts.map

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

package/dist/unit/types/current/track/AutoResetController.test.js

@@ -0,0 +1,266 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AutoResetControllerImpl, } from '@amazon/vinyl';
+import { ErrorOrigin, ReportableError, networkState, DisposedError, } from '@amazon/vinyl-util';
+import { MockPlaybackController } from '@amazon/vinyl/vinylTestUtil';
+import { createEventSpy, MockNetworkState, overrideGlobalInit, } from '@amazon/vinyl-util/testUtil';
+import { mockEvent, useMockTime } from '@amazon/vinyl-util/browserTestUtil';
+describe('AutoResetControllerImpl', () => {
+    let deps;
+    let controller;
+    let playbackController;
+    const mockNetworkStateRef = overrideGlobalInit(networkState, () => new MockNetworkState());
+    let mockNetworkState;
+    const clock = useMockTime();
+    beforeEach(() => {
+        playbackController = new MockPlaybackController();
+        deps = {
+            playbackController: playbackController,
+        };
+        mockNetworkState = mockNetworkStateRef.value;
+        mockNetworkState.onLine = true;
+    });
+    afterEach(() => {
+        if (!controller.disposed)
+            controller.dispose();
+    });
+    describe('constructor', () => {
+        it('creates instance with default options', () => {
+            controller = new AutoResetControllerImpl(deps);
+            expect(controller).toBeDefined();
+            expect(controller[Symbol.toStringTag]).toBe('AutoResetControllerImpl');
+        });
+        it('merges provided options with defaults', () => {
+            const options = {
+                enabled: false,
+                maxRetries: 10,
+            };
+            controller = new AutoResetControllerImpl(deps, options);
+            expect(controller).toBeDefined();
+        });
+        it('subscribes to playback controller events', () => {
+            controller = new AutoResetControllerImpl(deps);
+            expect(playbackController.on).toHaveBeenCalledWith('play', jasmine.any(Function));
+            expect(playbackController.on).toHaveBeenCalledWith('pause', jasmine.any(Function));
+            expect(playbackController.on).toHaveBeenCalledWith('seeking', jasmine.any(Function));
+            expect(playbackController.on).toHaveBeenCalledWith('playing', jasmine.any(Function));
+        });
+    });
+    describe('setError', () => {
+        beforeEach(() => {
+            controller = new AutoResetControllerImpl(deps);
+        });
+        it('ignores non-ReportableError', () => {
+            const error = new Error('test error');
+            controller.setError(error);
+            expect(mockNetworkState.on).not.toHaveBeenCalled();
+        });
+        it('ignores ReportableError with non-SERVICE_INTERNAL origin', () => {
+            const error = new ReportableError('test', ErrorOrigin.SERVICE_EXTERNAL);
+            controller.setError(error);
+            expect(mockNetworkState.on).not.toHaveBeenCalled();
+        });
+        it('sets error and starts watching for SERVICE_INTERNAL ReportableError', () => {
+            const error = new ReportableError('test', ErrorOrigin.SERVICE_INTERNAL);
+            controller.setError(error);
+            expect(mockNetworkState.on).toHaveBeenCalledWith('online', jasmine.any(Function));
+        });
+        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);
+            mockNetworkState.on.calls.reset();
+            controller.setError(error2);
+            expect(mockNetworkState.on).not.toHaveBeenCalled();
+        });
+    });
+    describe('reset behavior', () => {
+        let resetSpy;
+        let error;
+        beforeEach(() => {
+            controller = new AutoResetControllerImpl(deps);
+            resetSpy = createEventSpy(controller, 'reset');
+            error = new ReportableError('test', ErrorOrigin.SERVICE_INTERNAL);
+        });
+        it('emits reset event when network comes online', () => {
+            controller.setError(error);
+            const onlineCallback = mockNetworkState.on.calls.argsFor(0)[1];
+            onlineCallback(mockEvent('online'));
+            expect(resetSpy).toHaveBeenCalledWith({});
+        });
+        it('does not emit reset when no error is set', () => {
+            // Trigger online event without setting error first
+            mockNetworkState.dispatch('online', mockEvent('online'));
+            expect(resetSpy).not.toHaveBeenCalled();
+        });
+        it('emits reset on playback controller events when in error state', () => {
+            controller.setError(error);
+            playbackController.dispatch('play', {});
+            expect(resetSpy).toHaveBeenCalledWith({});
+            resetSpy.calls.reset();
+            controller.setError(error);
+            playbackController.dispatch('pause', {});
+            expect(resetSpy).toHaveBeenCalledWith({});
+            resetSpy.calls.reset();
+            controller.setError(error);
+            playbackController.dispatch('seeking', {});
+            expect(resetSpy).toHaveBeenCalledWith({});
+            resetSpy.calls.reset();
+            controller.setError(error);
+            playbackController.dispatch('playing', {});
+            expect(resetSpy).toHaveBeenCalledWith({});
+        });
+        it('does not emit reset on playback events when no error is set', () => {
+            playbackController.dispatch('play', {});
+            expect(resetSpy).not.toHaveBeenCalled();
+        });
+        it('resets on playback events play, pause, seeking, playing', async () => {
+            controller = new AutoResetControllerImpl(deps, {
+                retryInterval: 1,
+                maxRetries: 3,
+            });
+            resetSpy = createEventSpy(controller, 'reset');
+            controller.setError(error);
+            // Expect 'play' to trigger a reset immediately
+            playbackController.dispatch('play', {});
+            expect(resetSpy).toHaveBeenCalledTimes(1);
+            // Exhaust retries
+            for (let i = 0; i < 3; i++) {
+                controller.setError(error);
+                await clock.tick(1);
+            }
+            resetSpy.calls.reset();
+            for (let i = 0; i < 3; i++) {
+                // Should not be resetting after max retries has been exhausted
+                controller.setError(error);
+                await clock.tick(1);
+                expect(resetSpy).toHaveBeenCalledTimes(0);
+            }
+            // Expect 'pause' to trigger a reset immediately, even if retries are exhausted
+            playbackController.dispatch('pause', {});
+            expect(resetSpy).toHaveBeenCalledTimes(1);
+            resetSpy.calls.reset();
+            // Expect retry count to have been reset
+            for (let i = 1; i <= 3; i++) {
+                controller.setError(error);
+                await clock.tick(1);
+                expect(resetSpy).toHaveBeenCalledTimes(i);
+            }
+            // Expect max retries to be respected after reset
+            for (let i = 1; i <= 3; i++) {
+                controller.setError(error);
+                await clock.tick(1);
+                expect(resetSpy).toHaveBeenCalledTimes(3);
+            }
+        });
+    });
+    describe('retry interval behavior', () => {
+        let resetSpy;
+        let error;
+        beforeEach(() => {
+            error = new ReportableError('test', ErrorOrigin.SERVICE_INTERNAL);
+        });
+        it('retries at specified interval when online', async () => {
+            controller = new AutoResetControllerImpl(deps, { retryInterval: 5 });
+            resetSpy = createEventSpy(controller, 'reset');
+            controller.setError(error);
+            await clock.tick(4.999);
+            expect(resetSpy).toHaveBeenCalledTimes(0);
+            await clock.tick(0.001);
+            expect(resetSpy).toHaveBeenCalledTimes(1);
+        });
+        it('does not retry when offline', async () => {
+            mockNetworkState.onLine = false;
+            controller = new AutoResetControllerImpl(deps, { retryInterval: 1 });
+            resetSpy = createEventSpy(controller, 'reset');
+            controller.setError(error);
+            await clock.tick(1);
+            expect(resetSpy).not.toHaveBeenCalled();
+        });
+        it('continues retrying up to maxRetries', async () => {
+            controller = new AutoResetControllerImpl(deps, {
+                retryInterval: 1,
+                maxRetries: 3,
+            });
+            resetSpy = createEventSpy(controller, 'reset');
+            for (let i = 1; i <= 3; i++) {
+                controller.setError(error);
+                await clock.tick(1);
+                expect(resetSpy).toHaveBeenCalledTimes(i);
+            }
+            // Should stop after maxRetries
+            for (let i = 1; i <= 3; i++) {
+                controller.setError(error);
+                await clock.tick(1);
+                expect(resetSpy).toHaveBeenCalledTimes(3);
+            }
+        });
+    });
+    describe('clear', () => {
+        let error;
+        beforeEach(() => {
+            controller = new AutoResetControllerImpl(deps);
+            error = new ReportableError('test', ErrorOrigin.SERVICE_INTERNAL);
+        });
+        it('clears error state and stops watching', () => {
+            controller.setError(error);
+            expect(mockNetworkState.on).toHaveBeenCalled();
+            controller.clear();
+            // Should not emit reset after clearing
+            const resetSpy = createEventSpy(controller, 'reset');
+            playbackController.dispatch('play', {});
+            expect(resetSpy).not.toHaveBeenCalled();
+        });
+        it('does nothing when no error is set', () => {
+            controller.clear();
+            expect(mockNetworkState.on).not.toHaveBeenCalled();
+        });
+        it('stops timeout when clearing', async () => {
+            controller = new AutoResetControllerImpl(deps, { retryInterval: 1 });
+            const resetSpy = createEventSpy(controller, 'reset');
+            controller.setError(error);
+            controller.clear();
+            await clock.tick(1);
+            expect(resetSpy).not.toHaveBeenCalled();
+        });
+    });
+    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.dispose();
+            // Should not emit reset after disposing
+            const resetSpy = createEventSpy(controller, 'reset');
+            playbackController.dispatch('play', {});
+            expect(resetSpy).not.toHaveBeenCalled();
+            expect(playbackController.hasAnyListeners()).toBeFalse();
+            expect(mockNetworkState.hasAnyListeners()).toBeFalse();
+        });
+        it('throws if already disposed', () => {
+            controller = new AutoResetControllerImpl(deps);
+            controller.dispose();
+            expect(() => {
+                controller.dispose();
+            }).toThrowError(DisposedError);
+        });
+    });
+    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);
+            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);
+            playbackController.dispatch('play', {});
+            expect(resetSpy).not.toHaveBeenCalled();
+        });
+    });
+});

package/dist/unit/types/current/track/TrackBase.test.d.ts

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

package/dist/unit/types/current/track/TrackBase.test.d.ts.map

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

package/dist/unit/types/current/track/TrackBase.test.js

@@ -0,0 +1,205 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TrackBase, trackBaseOptionsValidator, } from '@amazon/vinyl';
+import { Abort, createShortUid, DisposedError, } from '@amazon/vinyl-util';
+import { MockDrmController, MockPlaybackController, } from '@amazon/vinyl/vinylTestUtil';
+import { createEventSpy } from '@amazon/vinyl-util/testUtil';
+var createSpy = jasmine.createSpy;
+var objectContaining = jasmine.objectContaining;
+var any = jasmine.any;
+describe('TrackBase', () => {
+    class TestTrackBase extends TrackBase {
+        constructor(id, deps) {
+            super(id, 'test', deps);
+        }
+        contentTypes = new Set();
+        qualities = null;
+        qualitiesUnfiltered = null;
+        getStreamingQuality = createSpy('getStreamingQuality').and.returnValue(null);
+        getBufferingQuality = createSpy('getBufferingQuality').and.returnValue(null);
+        getPlaybackQuality = createSpy('getPlaybackQuality').and.returnValue(null);
+        clearPrefetch = createSpy();
+        onActivated = createSpy();
+        onDeactivated = createSpy();
+        getDrmSessionAbort() {
+            return this.drmSessionAbort.value;
+        }
+        simulateError(error) {
+            this.errorHandler(error);
+        }
+    }
+    let track;
+    let playbackController;
+    let drmController;
+    function createTrack(id) {
+        return new TestTrackBase(id ?? createShortUid(), {
+            playbackController,
+            drmController,
+        });
+    }
+    beforeEach(() => {
+        drmController = new MockDrmController();
+        playbackController = new MockPlaybackController();
+        playbackController.seekTo.and.resolveTo(void 0);
+        track = createTrack();
+    });
+    describe('id', () => {
+        it('returns the id', () => {
+            track = createTrack('example');
+            expect(track.uri).toBe('example');
+        });
+    });
+    describe('fetchedRanges', () => {
+        it('is empty ranges', () => {
+            expect(track.fetchedRanges).toEqual(objectContaining({ ranges: [] }));
+        });
+    });
+    describe('activate', () => {
+        describe('when track is not active', () => {
+            it('seeks to track.startTime', () => {
+                track.activate({ startTime: 44 });
+                expect(playbackController.seekTo).toHaveBeenCalledOnceWith(44);
+                playbackController.seekTo.calls.reset();
+                track.deactivate();
+                track.activate({ startTime: 55 });
+                expect(playbackController.seekTo).toHaveBeenCalledOnceWith(55);
+            });
+            it('calls onActivated', () => {
+                track.activate({ startTime: 23 });
+                expect(track.onActivated).toHaveBeenCalledOnceWith({
+                    startTime: 23,
+                });
+            });
+            it('changes isActive state', () => {
+                expect(track.active).toBeFalse();
+                track.activate({});
+                expect(track.active).toBeTrue();
+            });
+        });
+        describe('when track is already active', () => {
+            beforeEach(() => {
+                track.activate({});
+                track.onActivated.calls.reset();
+            });
+            it('does nothing', () => {
+                track.activate({});
+                expect(track.onActivated.calls.count()).toEqual(0);
+            });
+        });
+    });
+    describe('deactivate', () => {
+        describe('when track is active', () => {
+            beforeEach(() => {
+                track.activate({});
+            });
+            it('calls onDeactivated', () => {
+                track.deactivate();
+                expect(track.onDeactivated).toHaveBeenCalledOnceWith();
+            });
+            it('aborts open drm sessions', () => {
+                const sessionAbort = track.getDrmSessionAbort();
+                track.deactivate();
+                expect(sessionAbort.aborted()).toBeTrue();
+                expect(track.getDrmSessionAbort()).toEqual(any(Abort));
+                expect(track.getDrmSessionAbort()).not.toBe(sessionAbort);
+            });
+        });
+        describe('when track is not active', () => {
+            it('does nothing', () => {
+                track.deactivate();
+                expect(track.onDeactivated).not.toHaveBeenCalled();
+            });
+        });
+    });
+    describe('extra', () => {
+        it('returns the load options extra when active', () => {
+            track.preload({ prefetchPriority: 2 }, { extra: 42 });
+            expect(track.extra).toBeNull();
+            track.activate({ extra: 42 });
+            expect(track.extra).toBe(42);
+            track.deactivate();
+            expect(track.extra).toBeNull();
+        });
+    });
+    describe('toString', () => {
+        it('contains the id', () => {
+            expect(track.toString()).toContain(track.uri);
+            expect(track.toString()).toContain('TrackBase');
+        });
+    });
+    describe('disposed', () => {
+        it('is true when the track is disposed', () => {
+            expect(track.disposed).toBeFalse();
+            track.dispose();
+            expect(track.disposed).toBeTrue();
+        });
+    });
+    describe('dispose', () => {
+        describe('when already disposed', () => {
+            it('throws a DisposedError', () => {
+                track.dispose();
+                expect(() => track.dispose()).toThrowMatching((e) => e instanceof DisposedError);
+            });
+        });
+        describe('when active', () => {
+            it('deactivates', () => {
+                track.activate({});
+                track.dispose();
+                expect(track.active).toBeFalse();
+            });
+        });
+    });
+    describe('trackBaseOptionsValidator', () => {
+        it('validates the track layout options config shape', () => {
+            expect(trackBaseOptionsValidator.isValid({
+                startTime: 44,
+                extra: {},
+            })).toBeTrue();
+            expect(trackBaseOptionsValidator.isValid({
+                startTime: '44',
+                extra: {},
+            })).toBeFalse();
+        });
+    });
+    describe('error', () => {
+        it('returns the last handled error', () => {
+            expect(track.error).toBeNull();
+            const error = new Error('expected');
+            track.simulateError(error);
+            expect(track.error).toBe(error);
+            track.simulateError(new Error('ignored'));
+            expect(track.error).toBe(error);
+        });
+    });
+    describe('errorHandler', () => {
+        it('sets error and emits an error event when not in an error state', () => {
+            const error = new Error('expected');
+            const errorSpy = createEventSpy(track, 'error');
+            track.simulateError(error);
+            expect(errorSpy).toHaveBeenCalledOnceWith({
+                error,
+                target: track,
+            });
+        });
+    });
+    describe('reset', () => {
+        let resetSpy;
+        beforeEach(() => {
+            resetSpy = createEventSpy(track, 'reset');
+        });
+        it('does nothing if not in an error state', () => {
+            track.reset();
+            expect(resetSpy).not.toHaveBeenCalled();
+        });
+        it('resets error state and emits a reset event', () => {
+            const error = new Error('expected');
+            track.simulateError(error);
+            expect(track.error).toBe(error);
+            track.reset();
+            expect(track.error).toBeNull();
+            expect(resetSpy).toHaveBeenCalledOnceWith({});
+        });
+    });
+});

package/dist/unit/types/current/track/TrackController.test.d.ts

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

package/dist/unit/types/current/track/TrackController.test.d.ts.map

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