@amazon/vinyl 1.0.0

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

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

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

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

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

@@ -0,0 +1,85 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createTrackFactory, } from '@amazon/vinyl';
+import { MockTrack } from '@amazon/vinyl/vinylTestUtil';
+import { expectNothing, expectTypeStrictlyEquals, } from '@amazon/vinyl-util/browserTestUtil';
+describe('createTrackFactory', () => {
+    class MockTrack1 extends MockTrack {
+    }
+    class MockTrack2 extends MockTrack {
+    }
+    class MockTrack3 extends MockTrack {
+    }
+    let trackFactory;
+    beforeEach(() => {
+        trackFactory = createTrackFactory({
+            key1: {
+                validate() { },
+                createTrack(options) {
+                    const track = new MockTrack1();
+                    track.uri = options.uri;
+                    return track;
+                },
+            },
+            key2: {
+                validate() { },
+                createTrack(options) {
+                    const track = new MockTrack2();
+                    track.uri = options.uri;
+                    return track;
+                },
+            },
+            key3: {
+                validate() { },
+                createTrack(options) {
+                    const track = new MockTrack3();
+                    track.uri = options.uri;
+                    return track;
+                },
+            },
+        });
+    });
+    it('maps track type keys to their respective factories', () => {
+        const track1 = trackFactory.createTrack({ type: 'key1', uri: 'uri1' });
+        expect(track1).toBeInstanceOf(MockTrack1);
+        expect(track1.uri).toBe('uri1');
+        const track2 = trackFactory.createTrack({ type: 'key2', uri: 'uri2' });
+        expect(track2).toBeInstanceOf(MockTrack2);
+        expect(track2.uri).toBe('uri2');
+        const track3 = trackFactory.createTrack({ type: 'key3', uri: 'uri3' });
+        expect(track3).toBeInstanceOf(MockTrack3);
+        expect(track3.uri).toBe('uri3');
+    });
+    it('validates type', () => {
+        trackFactory.validate({ type: 'key3', uri: 'abc' });
+        expect(() => trackFactory.validate({ type: 'non-existent', uri: 'abc' })).toThrowError('Expected: one of: key1 | key2 | key3, but was: "non-existent". At: ');
+    });
+    it('enforces that track factory keys can be assigned to the track type id', () => {
+        createTrackFactory({
+            key1: {
+                validate() { },
+                // valid, key1 is assignable to key1
+                createTrack(_options) {
+                    return new MockTrack1();
+                },
+            },
+        });
+        createTrackFactory({
+            // @ts-expect-error 'key1' is not assignable to 'key2'
+            key1: {
+                validate() { },
+                createTrack(_options) {
+                    return new MockTrack1();
+                },
+            },
+        });
+        expectNothing(); // compile-time only check
+    });
+});
+describe('InferLoadOptionsFromFactory', () => {
+    it('provides the type of load options for the given factory type', () => {
+        expectTypeStrictlyEquals(true);
+    });
+});

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

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

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

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

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

@@ -0,0 +1,273 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createSegmentDataProvider, } from '@amazon/vinyl';
+import { Abort, networkMetricsController, requesterWithRetryRef, } from '@amazon/vinyl-util';
+import { MockNetworkMetricsController, MockRequester, overrideGlobalInit, } from '@amazon/vinyl-util/testUtil';
+import { useMockTime } from '@amazon/vinyl-util/browserTestUtil';
+var createSpy = jasmine.createSpy;
+var any = jasmine.any;
+var objectContaining = jasmine.objectContaining;
+describe('createSegmentDataProvider', () => {
+    let mockRequester;
+    let deps;
+    const mockRequesterRef = overrideGlobalInit(requesterWithRetryRef, () => new MockRequester());
+    const networkMetricsControllerRef = overrideGlobalInit(networkMetricsController, () => new MockNetworkMetricsController());
+    const clock = useMockTime();
+    beforeEach(() => {
+        mockRequester = mockRequesterRef.value;
+        mockRequester.request.and.resolveTo(new Response(new ArrayBuffer(100)));
+        deps = {
+            requestInterceptor: createSpy('requestInterceptor'),
+            segmentRequestInit: undefined,
+        };
+    });
+    it('returns a function', () => {
+        const provider = createSegmentDataProvider(deps, {
+            url: 'https://example.com/seg0.mp4',
+            reportDownlinkMetrics: false,
+        });
+        expect(provider).toEqual(any(Function));
+    });
+    it('fetches the segment URL and returns an ArrayBuffer', async () => {
+        const provider = createSegmentDataProvider(deps, {
+            url: 'https://example.com/seg0.mp4',
+            reportDownlinkMetrics: false,
+        });
+        const result = await provider();
+        expect(result).toEqual(any(ArrayBuffer));
+        expect(mockRequester.request).toHaveBeenCalledTimes(1);
+    });
+    describe('when mediaRange is provided', () => {
+        it('adds Range header', async () => {
+            const provider = createSegmentDataProvider(deps, {
+                url: 'https://example.com/seg0.mp4',
+                mediaRange: [100, 299],
+                reportDownlinkMetrics: false,
+            });
+            await provider();
+            const interceptorCall = deps.requestInterceptor;
+            const params = interceptorCall.calls.argsFor(0)[0];
+            expect(params.init.headers).toEqual(objectContaining({ Range: 'bytes=100-299' }));
+        });
+    });
+    describe('when mediaRange is not provided', () => {
+        it('does not add Range header', async () => {
+            const provider = createSegmentDataProvider(deps, {
+                url: 'https://example.com/seg0.mp4',
+                reportDownlinkMetrics: false,
+            });
+            await provider();
+            const interceptorCall = deps.requestInterceptor;
+            const params = interceptorCall.calls.argsFor(0)[0];
+            expect(params.init.headers).toBeUndefined();
+        });
+    });
+    it('calls the request interceptor', async () => {
+        const provider = createSegmentDataProvider(deps, {
+            url: 'https://example.com/seg0.mp4',
+            reportDownlinkMetrics: false,
+        });
+        await provider();
+        expect(deps.requestInterceptor).toHaveBeenCalledTimes(1);
+    });
+    describe('segmentRequestInit', () => {
+        it('applies segmentRequestInit properties to the request', async () => {
+            const depsWithInit = {
+                ...deps,
+                segmentRequestInit: { headers: { 'X-Custom': 'value' } },
+            };
+            const provider = createSegmentDataProvider(depsWithInit, {
+                url: 'https://example.com/seg0.mp4',
+                reportDownlinkMetrics: false,
+            });
+            await provider();
+            const interceptorCall = deps.requestInterceptor;
+            const params = interceptorCall.calls.argsFor(0)[0];
+            expect(params.init.headers).toEqual(objectContaining({ 'X-Custom': 'value' }));
+        });
+        it('merges segmentRequestInit headers with Range header', async () => {
+            const depsWithInit = {
+                ...deps,
+                segmentRequestInit: { headers: { 'X-Custom': 'value' } },
+            };
+            const provider = createSegmentDataProvider(depsWithInit, {
+                url: 'https://example.com/seg0.mp4',
+                mediaRange: [0, 99],
+                reportDownlinkMetrics: false,
+            });
+            await provider();
+            const interceptorCall = deps.requestInterceptor;
+            const params = interceptorCall.calls.argsFor(0)[0];
+            expect(params.init.headers).toEqual({
+                'X-Custom': 'value',
+                Range: 'bytes=0-99',
+            });
+        });
+        it('does not allow segmentRequestInit to override Range header', async () => {
+            const depsWithInit = {
+                ...deps,
+                segmentRequestInit: {
+                    headers: { Range: 'bytes=999-9999' },
+                },
+            };
+            const provider = createSegmentDataProvider(depsWithInit, {
+                url: 'https://example.com/seg0.mp4',
+                mediaRange: [0, 99],
+                reportDownlinkMetrics: false,
+            });
+            await provider();
+            const interceptorCall = deps.requestInterceptor;
+            const params = interceptorCall.calls.argsFor(0)[0];
+            expect(params.init.headers).toEqual(objectContaining({ Range: 'bytes=0-99' }));
+        });
+        it('normalizes Headers object before merging with Range', async () => {
+            const depsWithInit = {
+                ...deps,
+                segmentRequestInit: {
+                    headers: new Headers({ 'X-Custom': 'value' }),
+                },
+            };
+            const provider = createSegmentDataProvider(depsWithInit, {
+                url: 'https://example.com/seg0.mp4',
+                mediaRange: [0, 99],
+                reportDownlinkMetrics: false,
+            });
+            await provider();
+            const interceptorCall = deps.requestInterceptor;
+            const params = interceptorCall.calls.argsFor(0)[0];
+            expect(params.init.headers).toEqual(objectContaining({
+                'x-custom': 'value',
+                Range: 'bytes=0-99',
+            }));
+        });
+        it('normalizes array headers before merging with Range', async () => {
+            const depsWithInit = {
+                ...deps,
+                segmentRequestInit: {
+                    headers: [['X-Custom', 'value']],
+                },
+            };
+            const provider = createSegmentDataProvider(depsWithInit, {
+                url: 'https://example.com/seg0.mp4',
+                mediaRange: [0, 99],
+                reportDownlinkMetrics: false,
+            });
+            await provider();
+            const interceptorCall = deps.requestInterceptor;
+            const params = interceptorCall.calls.argsFor(0)[0];
+            expect(params.init.headers).toEqual(objectContaining({
+                'X-Custom': 'value',
+                Range: 'bytes=0-99',
+            }));
+        });
+    });
+    it('passes abort to the request', async () => {
+        const provider = createSegmentDataProvider(deps, {
+            url: 'https://example.com/seg0.mp4',
+            reportDownlinkMetrics: false,
+        });
+        const abort = new Abort();
+        await provider(abort);
+        expect(mockRequester.request.calls.argsFor(0)[2]).toEqual(objectContaining({ abort }));
+    });
+    describe('serviceId', () => {
+        it('uses serviceId when provided', async () => {
+            const provider = createSegmentDataProvider(deps, {
+                url: 'https://example.com/seg0.mp4',
+                serviceId: 'my-service',
+                reportDownlinkMetrics: false,
+            });
+            await provider();
+            expect(mockRequester.request.calls.argsFor(0)[2]).toEqual(objectContaining({ serviceId: 'my-service' }));
+        });
+        it('falls back to hostname when serviceId is not provided', async () => {
+            const provider = createSegmentDataProvider(deps, {
+                url: 'https://example.com/seg0.mp4',
+                reportDownlinkMetrics: false,
+            });
+            await provider();
+            expect(mockRequester.request.calls.argsFor(0)[2]).toEqual(objectContaining({ serviceId: 'example.com' }));
+        });
+    });
+    describe('when reportDownlinkMetrics is true', () => {
+        it('reports transfer entry to network metrics controller', async () => {
+            const mockBuffer = new ArrayBuffer(1234);
+            const response = new Response(mockBuffer);
+            mockRequester.request.and.resolveTo(response);
+            const provider = createSegmentDataProvider(deps, {
+                url: 'https://example.com/seg0.mp4',
+                reportDownlinkMetrics: true,
+            });
+            const promise = provider();
+            await clock.tick(2);
+            await promise;
+            expect(networkMetricsControllerRef.value.addDownlinkTransferEntry).toHaveBeenCalledOnceWith(objectContaining({
+                bytes: 1234,
+                serviceId: 'example.com',
+            }));
+        });
+    });
+    describe('when reportDownlinkMetrics is false', () => {
+        it('does not report transfer entry', async () => {
+            const provider = createSegmentDataProvider(deps, {
+                url: 'https://example.com/seg0.mp4',
+                reportDownlinkMetrics: false,
+            });
+            await provider();
+            expect(networkMetricsControllerRef.value.addDownlinkTransferEntry).not.toHaveBeenCalled();
+        });
+    });
+    describe('responseStart from resource timing', () => {
+        it('uses performance resource timing responseStart when available', async () => {
+            const mockBuffer = new ArrayBuffer(500);
+            const response = new Response(mockBuffer);
+            mockRequester.request.and.resolveTo(response);
+            // Mock performance.getEntriesByName
+            const mockEntry = { responseStart: 100 };
+            spyOn(performance, 'getEntriesByName').and.returnValue([
+                mockEntry,
+            ]);
+            const provider = createSegmentDataProvider(deps, {
+                url: 'https://example.com/seg0.mp4',
+                reportDownlinkMetrics: true,
+            });
+            await provider();
+            expect(networkMetricsControllerRef.value.addDownlinkTransferEntry).toHaveBeenCalledOnceWith(objectContaining({
+                responseStart: performance.timeOrigin + 100,
+            }));
+        });
+        it('sets responseStart to null when resource timing responseStart is 0', async () => {
+            const mockBuffer = new ArrayBuffer(500);
+            const response = new Response(mockBuffer);
+            mockRequester.request.and.resolveTo(response);
+            const mockEntry = { responseStart: 0 };
+            spyOn(performance, 'getEntriesByName').and.returnValue([
+                mockEntry,
+            ]);
+            const provider = createSegmentDataProvider(deps, {
+                url: 'https://example.com/seg0.mp4',
+                reportDownlinkMetrics: true,
+            });
+            await provider();
+            expect(networkMetricsControllerRef.value.addDownlinkTransferEntry).toHaveBeenCalledOnceWith(objectContaining({
+                responseStart: null,
+            }));
+        });
+        it('sets responseStart to null when no resource timing entries exist', async () => {
+            const mockBuffer = new ArrayBuffer(500);
+            const response = new Response(mockBuffer);
+            mockRequester.request.and.resolveTo(response);
+            spyOn(performance, 'getEntriesByName').and.returnValue([]);
+            const provider = createSegmentDataProvider(deps, {
+                url: 'https://example.com/seg0.mp4',
+                reportDownlinkMetrics: true,
+            });
+            await provider();
+            expect(networkMetricsControllerRef.value.addDownlinkTransferEntry).toHaveBeenCalledOnceWith(objectContaining({
+                responseStart: null,
+            }));
+        });
+    });
+});

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

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

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

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

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

@@ -0,0 +1,17 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createVinylTrackFactories } from '@amazon/vinyl';
+import { createMockVinylDependencies } from '@amazon/vinyl/vinylTestUtil';
+var objectContaining = jasmine.objectContaining;
+var any = jasmine.any;
+describe('createVinylTrackFactories', () => {
+    it('returns track factories for Vinyl', () => {
+        const trackFactories = createVinylTrackFactories(createMockVinylDependencies());
+        expect(trackFactories).toEqual(objectContaining({
+            src: any(Object),
+            srcObject: any(Object),
+        }));
+    });
+});

package/dist/unit/types/current/track/dash/DashManifestController.test.d.ts

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

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

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

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

@@ -0,0 +1,186 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Deferred } from '@amazon/vinyl-util';
+import { DashManifestControllerImpl, } from '@amazon/vinyl';
+import { mockDashManifest } from '@amazon/vinyl/vinylTestUtil';
+import { expectNothing, flushPromises, } from '@amazon/vinyl-util/browserTestUtil';
+var createSpy = jasmine.createSpy;
+describe('DashManifestController', () => {
+    let manifestProvider;
+    beforeEach(() => {
+        manifestProvider = createSpy('manifestProvider');
+        manifestProvider.and.resolveTo({
+            manifest: mockDashManifest,
+            baseUrl: 'https://example.com',
+        });
+    });
+    function createManifestController() {
+        return new DashManifestControllerImpl({
+            manifestProvider,
+        });
+    }
+    it('has a toStringTag', () => {
+        const manifestController = createManifestController();
+        expect(String(manifestController)).toContain('DashManifestControllerImpl');
+    });
+    it('has a logPrefix', () => {
+        const manifestController = createManifestController();
+        expect(manifestController.logPrefix).toBe('DashManifestControllerImpl');
+    });
+    describe('refresh', () => {
+        it('reloads the manifest', () => {
+            const manifestController = createManifestController();
+            manifestController.refresh();
+            expect(manifestProvider).toHaveBeenCalledTimes(2);
+        });
+        it('notifies observers', () => {
+            const manifestController = createManifestController();
+            const observer = createSpy('observer');
+            manifestController.onData(observer);
+            observer.calls.reset();
+            manifestController.refresh();
+            expect(observer).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('value', () => {
+        it('resolves to the manifest and path', async () => {
+            const manifestController = createManifestController();
+            const result = await manifestController.value;
+            expect(result).toEqual({
+                manifest: mockDashManifest,
+                baseUrl: 'https://example.com',
+            });
+        });
+    });
+    describe('getValue', () => {
+        it('returns the same as value', () => {
+            const manifestController = createManifestController();
+            expect(manifestController.getValue()).toBe(manifestController.value);
+        });
+    });
+    describe('changeId', () => {
+        it('increments when manifest is refreshed', () => {
+            const manifestController = createManifestController();
+            const initial = manifestController.changeId;
+            manifestController.refresh();
+            expect(manifestController.changeId).toBe(initial + 1);
+        });
+    });
+    describe('pick', () => {
+        it('returns a sub-observable', () => {
+            const manifestController = createManifestController();
+            const thenPick = manifestController.pick('then');
+            expect(thenPick.value).toEqual(jasmine.any(Function));
+        });
+    });
+    describe('disposed', () => {
+        it('returns false before dispose', () => {
+            const manifestController = createManifestController();
+            expect(manifestController.disposed).toBe(false);
+        });
+        it('returns true after dispose', () => {
+            const manifestController = createManifestController();
+            manifestController.dispose();
+            expect(manifestController.disposed).toBe(true);
+        });
+    });
+    describe('value - pending', () => {
+        it('resolves pending manifest', async () => {
+            const deferredManifestAndPath = new Deferred();
+            manifestProvider.and.returnValue(deferredManifestAndPath);
+            const manifestController = createManifestController();
+            const valuePromise = manifestController.value;
+            deferredManifestAndPath.resolve({
+                manifest: mockDashManifest,
+                baseUrl: 'https://example.com',
+            });
+            expect(await valuePromise).toEqual({
+                manifest: mockDashManifest,
+                baseUrl: 'https://example.com',
+            });
+        });
+    });
+    describe('when manifest provider rejects', () => {
+        it('does not cause an unhandled rejection', async () => {
+            manifestProvider.and.rejectWith(new Error('expected'));
+            createManifestController();
+            await flushPromises();
+            expectNothing();
+        });
+        it('rejects the value', async () => {
+            manifestProvider.and.rejectWith(new Error('expected'));
+            const controller = createManifestController();
+            await expectAsync(controller.value).toBeRejectedWithError('expected');
+        });
+    });
+    describe('error', () => {
+        it('is null when manifest loads successfully', () => {
+            const manifestController = createManifestController();
+            expect(manifestController.error).toBeNull();
+        });
+        it('is set when manifest provider rejects', async () => {
+            manifestProvider.and.rejectWith(new Error('test error'));
+            const manifestController = createManifestController();
+            await expectAsync(manifestController.value).toBeRejected();
+            expect(manifestController.error).toEqual(jasmine.objectContaining({ message: 'test error' }));
+        });
+        it('is cleared after refresh', async () => {
+            manifestProvider.and.rejectWith(new Error('test error'));
+            const manifestController = createManifestController();
+            await expectAsync(manifestController.value).toBeRejected();
+            expect(manifestController.error).not.toBeNull();
+            manifestProvider.and.resolveTo({
+                manifest: mockDashManifest,
+                baseUrl: 'https://example.com',
+            });
+            manifestController.refresh();
+            expect(manifestController.error).toBeNull();
+        });
+    });
+    describe('reset', () => {
+        it('refreshes manifest when there was an error', async () => {
+            manifestProvider.and.rejectWith(new Error('test error'));
+            const manifestController = createManifestController();
+            await expectAsync(manifestController.value).toBeRejected();
+            manifestProvider.and.resolveTo({
+                manifest: mockDashManifest,
+                baseUrl: 'https://example.com',
+            });
+            manifestController.reset();
+            expect(manifestProvider.calls.count()).toBe(2);
+        });
+        it('does nothing when no error occurred', () => {
+            const manifestController = createManifestController();
+            const initialCallCount = manifestProvider.calls.count();
+            manifestController.reset();
+            expect(manifestProvider.calls.count()).toBe(initialCallCount);
+        });
+    });
+    describe('map', () => {
+        it('transforms the manifest data', () => {
+            const manifestController = createManifestController();
+            const mapped = manifestController.map((promise) => promise.then((data) => data.manifest));
+            expect(mapped).toBeDefined();
+        });
+    });
+    describe('pick', () => {
+        it('picks a property from the manifest data', () => {
+            const manifestController = createManifestController();
+            // Pick a property that exists on Promise<DashManifestData>
+            const picked = manifestController.pick('then');
+            expect(picked).toBeDefined();
+        });
+    });
+    describe('dispose', () => {
+        it('aborts current request', () => {
+            const deferred = new Deferred();
+            manifestProvider.and.returnValue(deferred);
+            const manifestController = createManifestController();
+            const abort = manifestProvider.calls.first().args[0];
+            manifestController.dispose();
+            expect(abort.aborted()).toBeTrue();
+        });
+    });
+});

package/dist/unit/types/current/track/dash/DashMediaQualityMetadataResolver.test.d.ts

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

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

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