@amazon/vinyl 1.0.0

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

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

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

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

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

@@ -0,0 +1,75 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { SegmentDataSlot, SegmentStatus, } from '@amazon/vinyl';
+import { AbortError, Deferred, withAbort } from '@amazon/vinyl-util';
+var createSpy = jasmine.createSpy;
+var any = jasmine.any;
+describe('SegmentDataSlot', () => {
+    let mockRequestSegment;
+    let slot;
+    beforeEach(() => {
+        mockRequestSegment = createSpy('requestSegment');
+        slot = new SegmentDataSlot(mockRequestSegment);
+    });
+    it('initializes with an INACTIVE status', () => {
+        expect(slot.status).toEqual(SegmentStatus.INACTIVE);
+    });
+    it('calls onStatusChange when status changes', async () => {
+        const segmentPromise = new Deferred();
+        mockRequestSegment.and.returnValue(segmentPromise);
+        const statusChangeSpy = createSpy('statusChange');
+        slot.onStatusChange = statusChangeSpy;
+        const requestPromise = slot.request();
+        expect(statusChangeSpy).toHaveBeenCalledOnceWith();
+        statusChangeSpy.calls.reset();
+        segmentPromise.resolve(new ArrayBuffer(0));
+        await requestPromise;
+        expect(statusChangeSpy).toHaveBeenCalledOnceWith();
+    });
+    describe('request', () => {
+        it('sets status to PENDING when request is made and RESOLVED on success', async () => {
+            mockRequestSegment.and.resolveTo(new ArrayBuffer(0));
+            const promise = slot.request();
+            expect(slot.status).toEqual(SegmentStatus.PENDING);
+            await promise;
+            expect(slot.status).toEqual(SegmentStatus.RESOLVED);
+        });
+        it('sets status to ERRED on failed request', async () => {
+            mockRequestSegment.and.rejectWith(new Error('Failed to load'));
+            await expectAsync(slot.request()).toBeRejectedWithError('Failed to load');
+            expect(slot.status).toEqual(SegmentStatus.ERRED);
+        });
+        it('resets to inactive on silent error', async () => {
+            mockRequestSegment.and.rejectWith(new AbortError());
+            await expectAsync(slot.request()).toBeRejectedWith(new AbortError());
+            expect(slot.status).toEqual(SegmentStatus.INACTIVE);
+            mockRequestSegment.and.resolveTo(new ArrayBuffer(0));
+            await expectAsync(slot.request()).toBeResolvedTo(any(ArrayBuffer));
+        });
+    });
+    describe('clear', () => {
+        it('aborts the request and resets the status to INACTIVE when cleared', async () => {
+            mockRequestSegment.and.callFake((abort) => {
+                return withAbort(new Deferred(), abort);
+            });
+            const promise = slot.request();
+            slot.clear();
+            expect(slot.status).toEqual(SegmentStatus.INACTIVE);
+            await expectAsync(promise).toBeRejectedWith(any(AbortError));
+        });
+        it('does nothing if already INACTIVE', () => {
+            slot.clear();
+            expect(slot.status).toEqual(SegmentStatus.INACTIVE);
+        });
+    });
+    describe('dispose', () => {
+        it('clears the segment and remove the status change handler', () => {
+            slot.onStatusChange = createSpy('statusChange');
+            slot.dispose();
+            expect(slot.onStatusChange).toBeNull();
+            expect(slot.status).toEqual(SegmentStatus.INACTIVE);
+        });
+    });
+});

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

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

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

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

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

@@ -0,0 +1,145 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { enqueueSegmentPrefetch, prefetchPriorityQueuesRef, } from '@amazon/vinyl';
+import { clone, Deferred, noop } from '@amazon/vinyl-util';
+import { flushPromises, marbleTest } from '@amazon/vinyl-util/browserTestUtil';
+describe('SegmentPrefetch', () => {
+    describe('enqueueSegmentPrefetch', () => {
+        it('appends a task to the prefetch task queue for the specified content type', async () => {
+            const deferred = new Deferred();
+            const task = () => deferred;
+            const promise = enqueueSegmentPrefetch(task, 'audio', {
+                trackPriority: 0,
+                prefetchStartTime: 0,
+                segmentStartTime: 0,
+            });
+            await expectAsync(promise).toBePending();
+            expect(prefetchPriorityQueuesRef.value.audio.running).toBe(1);
+            expect(prefetchPriorityQueuesRef.value.video.running).toBe(0);
+            deferred.resolve();
+            await promise;
+        });
+        it('uses separate queues for different content types', async () => {
+            const audioDeferred = new Deferred();
+            const videoDeferred = new Deferred();
+            const audioTask = () => audioDeferred;
+            const videoTask = () => videoDeferred;
+            const audioPromise = enqueueSegmentPrefetch(audioTask, 'audio', {
+                trackPriority: 0,
+                prefetchStartTime: 0,
+                segmentStartTime: 0,
+            });
+            const videoPromise = enqueueSegmentPrefetch(videoTask, 'video', {
+                trackPriority: 0,
+                prefetchStartTime: 0,
+                segmentStartTime: 0,
+            });
+            await expectAsync(audioPromise).toBePending();
+            await expectAsync(videoPromise).toBePending();
+            expect(prefetchPriorityQueuesRef.value.audio.running).toBe(1);
+            expect(prefetchPriorityQueuesRef.value.video.running).toBe(1);
+            audioDeferred.resolve();
+            videoDeferred.resolve();
+            await Promise.all([audioPromise, videoPromise]);
+        });
+        /**
+         * Provides a way to visualize segment prefetch priorities.
+         */
+        function createPriorityMarbleTest() {
+            return marbleTest(() => {
+                const promise = new Deferred();
+                const priority = {
+                    trackPriority: 0,
+                    prefetchStartTime: -1,
+                    segmentStartTime: 0,
+                };
+                // First requested segment will always be first regardless of priority, ignore from tests:
+                enqueueSegmentPrefetch(() => promise, 'audio', priority).catch(noop);
+                return {
+                    priority,
+                    currentIndex: 0,
+                    promise,
+                    actualOrder: [[]], // [trackPriority][startTime]
+                };
+            }, {
+                '-': (state) => {
+                    // dash represents no segment request at current time
+                    state.actualOrder[state.priority.trackPriority][state.priority.segmentStartTime] = '-';
+                    state.priority.segmentStartTime++;
+                },
+                '\n': (state) => {
+                    // newline represents a new track
+                    state.priority.trackPriority++;
+                    state.priority.prefetchStartTime = -1;
+                    state.priority.segmentStartTime = 0;
+                    state.actualOrder.push([]);
+                },
+                x: (state) => {
+                    // x represents a segment request for this time slot
+                    // First x is considered the first needed segment for playback
+                    if (state.priority.prefetchStartTime === -1) {
+                        state.priority.prefetchStartTime =
+                            state.priority.segmentStartTime;
+                    }
+                    const priority = clone(state.priority);
+                    enqueueSegmentPrefetch(() => {
+                        state.actualOrder[priority.trackPriority][priority.segmentStartTime] = (state.currentIndex++).toString(36);
+                        return state.promise;
+                    }, 'audio', priority).catch(noop);
+                    state.priority.segmentStartTime++;
+                },
+            }, async (o) => {
+                o.promise.resolve();
+                await o.promise;
+                await flushPromises();
+                return o.actualOrder.map((t) => t.join('')).join('\n');
+            });
+        }
+        async function testPriorityOrder(input, expected) {
+            expect(await createPriorityMarbleTest()(input.trim().replace(/[\t ]+/g, ''))).toEqual(expected.trim().replace(/[\t ]+/g, ''));
+        }
+        it('prioritizes by whether it is first segment, then by track priority', async () => {
+            // Tracks enqueue one segment at a time, and not out of order; segment start time does not need to
+            // affect sorting.
+            // Last row represents highest track priority, first row is lowest.
+            // Simulate each track enqueuing two segments, with start time of 0:
+            await testPriorityOrder(`
+                xx
+                xx
+                xx
+                xx
+                `, `
+                37
+                26
+                15
+                04
+                `);
+            // Simulate each track enqueuing three segments, with varying start times:
+            await testPriorityOrder(`
+                xxx
+                --xxx
+                ---xxx
+                -xxx
+                `, `
+                3ab
+                --289
+                ---167
+                -045
+                `);
+            // Chaotic input, first segments should be higher priority than later segments, then by track priority
+            await testPriorityOrder(`
+                ----x
+                -x--x
+                x--xx
+                -----x
+                `, `
+                ----3
+                -2--6
+                1--45
+                -----0
+                `);
+        });
+    });
+});

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

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

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

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

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

@@ -0,0 +1,10 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { expectTypeStrictlyEquals } from '@amazon/vinyl-util/browserTestUtil';
+describe('ALL_TRACK_EVENTS', () => {
+    it('provides a comprehensive list of all track events', () => {
+        expectTypeStrictlyEquals(true);
+    });
+});

package/dist/unit/types/current/streaming/abr/QualitySelectorImpl.test.d.ts

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

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

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