@amazon/vinyl 1.2.0 → 1.2.1

package/dist/unit/types/current/drm/DrmControllerImpl.test.js

@@ -4,7 +4,7 @@
  */
 import { createEmptyMediaQualityMetadata, DrmControllerImpl, DrmError, DrmKeySystem, DrmRobustness, LICENSE_TIMEOUT, ReportableMediaError, } from '@amazon/vinyl';
 import { createEventSpy, useMockLogger } from '@amazon/vinyl-util/testUtil';
-import { Abort, base64ToByteArray, bufferToBase64, Deferred, ErrorLevel, ErrorOrigin, never, nextEventAsPromise, ReportableError, utf16ToUint16Array, } from '@amazon/vinyl-util';
+import { Abort, base64ToByteArray, bufferToBase64, Deferred, ErrorLevel, ErrorOrigin, never, nextEventAsPromise, ReportableError, setUserAgent, utf16ToUint16Array, } from '@amazon/vinyl-util';
 import { flushPromises, implementEventFakes, MockHTMLAudioElement, MockMediaError, useMockTime, } from '@amazon/vinyl-util/browserTestUtil';
 import { MockCommonEme, MockCommonMediaKeys, MockCommonMediaKeySession, MockCommonMediaKeySystemAccess, } from '@amazon/vinyl/vinylTestUtil';
 var createSpy = jasmine.createSpy;
@@ -1275,6 +1275,71 @@ describe('DrmControllerImpl', () => {
             ]);
         });
     });
+    describe('ChromeOS verified media path', () => {
+        // ChromeOS only enables the verified media path (VMP) when a video
+        // capability is present, so audio-only content must advertise a dummy
+        // avc1 video capability alongside its audio capability.
+        const chromeOsUserAgent = 'Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36';
+        const chromeUserAgent = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36';
+        it('adds avc1 video capabilities for audio content on ChromeOS', async () => {
+            setUserAgent(chromeOsUserAgent);
+            drmController.setBufferingDrmInfo({
+                ...drmInfo,
+                contentType: 'audio',
+                mimeType: 'audio/mp4',
+            });
+            await emitEncrypted();
+            expect(commonEme.requestMediaKeySystemAccess).toHaveBeenCalledOnceWith(DrmKeySystem.WIDEVINE, [
+                {
+                    initDataTypes: ['cenc'],
+                    audioCapabilities: [
+                        {
+                            contentType: 'audio/mp4',
+                            encryptionScheme: 'cenc',
+                            robustness: DrmRobustness.SW_SECURE_CRYPTO,
+                        },
+                    ],
+                    videoCapabilities: [
+                        {
+                            contentType: 'video/mp4; codecs="avc1.4d401f"',
+                            robustness: DrmRobustness.SW_SECURE_DECODE,
+                        },
+                    ],
+                },
+            ]);
+        });
+        it('does not add video capabilities for audio content off ChromeOS', async () => {
+            setUserAgent(chromeUserAgent);
+            drmController.setBufferingDrmInfo({
+                ...drmInfo,
+                contentType: 'audio',
+                mimeType: 'audio/mp4',
+            });
+            await emitEncrypted();
+            const config = commonEme.requestMediaKeySystemAccess.calls.mostRecent()
+                .args[1][0];
+            expect(config.videoCapabilities).toBeUndefined();
+        });
+        it('does not alter video content capabilities on ChromeOS', async () => {
+            setUserAgent(chromeOsUserAgent);
+            drmController.setBufferingDrmInfo({
+                ...drmInfo,
+                contentType: 'video',
+                mimeType: 'video/mp4',
+            });
+            await emitEncrypted();
+            const config = commonEme.requestMediaKeySystemAccess.calls.mostRecent()
+                .args[1][0];
+            expect(config.videoCapabilities).toEqual([
+                {
+                    contentType: 'video/mp4',
+                    encryptionScheme: 'cenc',
+                    robustness: DrmRobustness.SW_SECURE_CRYPTO,
+                },
+            ]);
+            expect(config.audioCapabilities).toBeUndefined();
+        });
+    });
     describe('when a session has been created', () => {
         beforeEach(async () => {
             drmController.setBufferingDrmInfo(drmInfo);

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

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

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

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

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

@@ -0,0 +1,197 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Deferred } from '@amazon/vinyl-util';
+import { ManifestControllerImpl } from '@amazon/vinyl';
+import { mockHlsManifestData } from '@amazon/vinyl/vinylTestUtil';
+import { expectNothing, flushPromises, } from '@amazon/vinyl-util/browserTestUtil';
+var createSpy = jasmine.createSpy;
+describe('ManifestControllerImpl', () => {
+    let manifestProvider;
+    beforeEach(() => {
+        manifestProvider = createSpy('manifestProvider');
+        manifestProvider.and.resolveTo(mockHlsManifestData);
+    });
+    function createManifestController() {
+        return new ManifestControllerImpl({ manifestProvider });
+    }
+    it('has a toStringTag', () => {
+        const controller = createManifestController();
+        expect(String(controller)).toContain('ManifestControllerImpl');
+    });
+    it('has a logPrefix', () => {
+        const controller = createManifestController();
+        expect(controller.logPrefix).toBe('ManifestControllerImpl');
+    });
+    describe('refresh', () => {
+        it('reloads the manifest', () => {
+            const controller = createManifestController();
+            controller.refresh();
+            expect(manifestProvider).toHaveBeenCalledTimes(2);
+        });
+        it('notifies observers', () => {
+            const controller = createManifestController();
+            const observer = createSpy('observer');
+            controller.onData(observer);
+            observer.calls.reset();
+            controller.refresh();
+            expect(observer).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('value', () => {
+        it('resolves to the manifest data', async () => {
+            const controller = createManifestController();
+            const result = await controller.value;
+            expect(result.mainPlaylist).toBe(mockHlsManifestData.mainPlaylist);
+            expect(result.baseUrl).toBe(mockHlsManifestData.baseUrl);
+        });
+    });
+    describe('getValue', () => {
+        it('returns the same as value', () => {
+            const controller = createManifestController();
+            expect(controller.getValue()).toBe(controller.value);
+        });
+    });
+    describe('changeId', () => {
+        it('increments when manifest is refreshed', () => {
+            const controller = createManifestController();
+            const initial = controller.changeId;
+            controller.refresh();
+            expect(controller.changeId).toBe(initial + 1);
+        });
+    });
+    describe('pick', () => {
+        it('returns a sub-observable', () => {
+            const controller = createManifestController();
+            const thenPick = controller.pick('then');
+            expect(thenPick.value).toEqual(jasmine.any(Function));
+        });
+    });
+    describe('map', () => {
+        it('returns a mapped observable', async () => {
+            const controller = createManifestController();
+            const mapped = controller.map(async (promise) => {
+                const data = await promise;
+                return data.baseUrl;
+            });
+            expect(await mapped.value).toBe(mockHlsManifestData.baseUrl);
+        });
+    });
+    describe('disposed', () => {
+        it('returns false before dispose', () => {
+            const controller = createManifestController();
+            expect(controller.disposed).toBe(false);
+        });
+        it('returns true after dispose', () => {
+            const controller = createManifestController();
+            controller.dispose();
+            expect(controller.disposed).toBe(true);
+        });
+    });
+    describe('value - pending', () => {
+        it('resolves pending manifest', async () => {
+            const deferred = new Deferred();
+            manifestProvider.and.returnValue(deferred);
+            const controller = createManifestController();
+            const valuePromise = controller.value;
+            deferred.resolve(mockHlsManifestData);
+            const result = await valuePromise;
+            expect(result.mainPlaylist).toBe(mockHlsManifestData.mainPlaylist);
+        });
+    });
+    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', async () => {
+            const controller = createManifestController();
+            await controller.value;
+            expect(controller.error).toBeNull();
+        });
+        it('is set when manifest provider rejects', async () => {
+            manifestProvider.and.rejectWith(new Error('test error'));
+            const controller = createManifestController();
+            await expectAsync(controller.value).toBeRejected();
+            expect(controller.error).toEqual(jasmine.objectContaining({ message: 'test error' }));
+        });
+        it('is cleared after refresh', async () => {
+            manifestProvider.and.rejectWith(new Error('test error'));
+            const controller = createManifestController();
+            await expectAsync(controller.value).toBeRejected();
+            expect(controller.error).not.toBeNull();
+            manifestProvider.and.resolveTo(mockHlsManifestData);
+            controller.refresh();
+            expect(controller.error).toBeNull();
+        });
+    });
+    describe('reset', () => {
+        it('refreshes manifest when there was an error', async () => {
+            manifestProvider.and.rejectWith(new Error('test error'));
+            const controller = createManifestController();
+            await expectAsync(controller.value).toBeRejected();
+            manifestProvider.and.resolveTo(mockHlsManifestData);
+            controller.reset();
+            expect(manifestProvider.calls.count()).toBe(2);
+        });
+        it('does nothing when no error occurred', () => {
+            const controller = createManifestController();
+            const initialCallCount = manifestProvider.calls.count();
+            controller.reset();
+            expect(manifestProvider.calls.count()).toBe(initialCallCount);
+        });
+    });
+    describe('load span metrics', () => {
+        it('dispatches loadSpanMeasured on the initial manifest fetch', async () => {
+            const controller = createManifestController();
+            const spy = createSpy('loadSpanMeasured');
+            controller.on('loadSpanMeasured', spy);
+            await controller.value;
+            await flushPromises();
+            expect(spy).toHaveBeenCalledWith(jasmine.objectContaining({
+                kind: 'manifest',
+                startTime: jasmine.any(Number),
+                endTime: jasmine.any(Number),
+            }));
+        });
+        it('does not re-measure on refresh', async () => {
+            const controller = createManifestController();
+            await controller.value;
+            const spy = createSpy('loadSpanMeasured');
+            controller.on('loadSpanMeasured', spy);
+            controller.refresh();
+            await controller.value;
+            await flushPromises();
+            expect(spy).not.toHaveBeenCalled();
+        });
+        it('reports listeners', () => {
+            const controller = createManifestController();
+            expect(controller.hasAnyListeners()).toBeFalse();
+            expect(controller.hasListeners('loadSpanMeasured')).toBeFalse();
+            controller.on('loadSpanMeasured', createSpy('loadSpanMeasured'));
+            expect(controller.hasAnyListeners()).toBeTrue();
+            expect(controller.hasListeners('loadSpanMeasured')).toBeTrue();
+        });
+    });
+    describe('dispose', () => {
+        it('aborts current request', () => {
+            const deferred = new Deferred();
+            manifestProvider.and.returnValue(deferred);
+            const controller = createManifestController();
+            const abort = manifestProvider.calls.first()
+                .args[0];
+            controller.dispose();
+            expect(abort.aborted()).toBeTrue();
+        });
+    });
+});

package/dist/unit/types/current/streaming/buffering/codecDenylist.test.d.ts

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

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

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

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

@@ -0,0 +1,56 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { clearCodecDenylist, denylistCodecsFromMimeType, getDenylistedCodecs, isMimeTypeDenylisted, } from '@amazon/vinyl';
+describe('codecDenylist', () => {
+    afterEach(() => {
+        clearCodecDenylist();
+    });
+    describe('denylistCodecsFromMimeType', () => {
+        it('adds codecs and returns true on first denylist', () => {
+            expect(denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"')).toBeTrue();
+            expect(getDenylistedCodecs()).toContain('hvc1.1');
+        });
+        it('returns false when all codecs are already denylisted', () => {
+            denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"');
+            expect(denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"')).toBeFalse();
+        });
+        it('returns true when at least one codec is newly added', () => {
+            denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"');
+            expect(denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1,ec-3"')).toBeTrue();
+        });
+        it('returns false for a mimeType with no codecs', () => {
+            expect(denylistCodecsFromMimeType('video/mp4')).toBeFalse();
+        });
+        it('stores codecs lowercased', () => {
+            denylistCodecsFromMimeType('video/mp4; codecs="HVC1.1"');
+            expect(getDenylistedCodecs()).toContain('hvc1.1');
+        });
+    });
+    describe('isMimeTypeDenylisted', () => {
+        it('returns true when a codec is denylisted', () => {
+            denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"');
+            expect(isMimeTypeDenylisted('video/mp4; codecs="hvc1.1"')).toBeTrue();
+        });
+        it('is case-insensitive', () => {
+            denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"');
+            expect(isMimeTypeDenylisted('video/mp4; codecs="HVC1.1"')).toBeTrue();
+        });
+        it('returns false when no codec is denylisted', () => {
+            denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"');
+            expect(isMimeTypeDenylisted('video/mp4; codecs="avc1.64001f"')).toBeFalse();
+        });
+        it('returns false for a mimeType with no codecs', () => {
+            denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"');
+            expect(isMimeTypeDenylisted('video/mp4')).toBeFalse();
+        });
+    });
+    describe('clearCodecDenylist', () => {
+        it('empties the denylist', () => {
+            denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"');
+            clearCodecDenylist();
+            expect(getDenylistedCodecs()).toEqual([]);
+        });
+    });
+});

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

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

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

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

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

@@ -0,0 +1,77 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createAllowedContentTypesValue, } from '@amazon/vinyl';
+import { data } from '@amazon/vinyl-observable';
+describe('createAllowedContentTypesValue', () => {
+    let baseContentTypesValue;
+    let options;
+    beforeEach(() => {
+        baseContentTypesValue = data(Promise.resolve(new Set(['audio', 'video', 'text'])));
+        options = data({ allowedContentTypes: null });
+    });
+    it('passes all content types through when the allow list is null', async () => {
+        const result = await createAllowedContentTypesValue({
+            baseContentTypesValue,
+            options,
+        }).value;
+        expect(result).toEqual(new Set(['audio', 'video', 'text']));
+    });
+    it('keeps only the allowed media content types', async () => {
+        options.value = { allowedContentTypes: ['audio'] };
+        const result = await createAllowedContentTypesValue({
+            baseContentTypesValue,
+            options,
+        }).value;
+        // Text always passes through; video is dropped.
+        expect(result).toEqual(new Set(['audio', 'text']));
+    });
+    it('always keeps text even when only video is allowed', async () => {
+        options.value = { allowedContentTypes: ['video'] };
+        const result = await createAllowedContentTypesValue({
+            baseContentTypesValue,
+            options,
+        }).value;
+        expect(result).toEqual(new Set(['video', 'text']));
+    });
+    it('keeps text even when the allow list is empty', async () => {
+        options.value = { allowedContentTypes: [] };
+        const result = await createAllowedContentTypesValue({
+            baseContentTypesValue,
+            options,
+        }).value;
+        expect(result).toEqual(new Set(['text']));
+    });
+    it('ignores allowed types not present in the manifest', async () => {
+        baseContentTypesValue.value = Promise.resolve(new Set(['audio']));
+        options.value = { allowedContentTypes: ['audio', 'video'] };
+        const result = await createAllowedContentTypesValue({
+            baseContentTypesValue,
+            options,
+        }).value;
+        expect(result).toEqual(new Set(['audio']));
+    });
+    it('re-emits a newly filtered set when the allow list changes', async () => {
+        const value = createAllowedContentTypesValue({
+            baseContentTypesValue,
+            options,
+        });
+        const emissions = [];
+        const unsub = value.onData((promise) => {
+            void promise.then((set) => emissions.push(set));
+        });
+        // Changing the allow list should produce a new, filtered emission,
+        // which is what drives the track to reload with only these types.
+        options.value = { allowedContentTypes: ['audio'] };
+        expect(await value.value).toEqual(new Set(['audio', 'text']));
+        unsub();
+        // Wait for all pending promise callbacks to resolve.
+        await Promise.resolve();
+        await Promise.resolve();
+        expect(emissions).toEqual([
+            new Set(['audio', 'video', 'text']),
+            new Set(['audio', 'text']),
+        ]);
+    });
+});

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

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

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

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

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

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

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

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

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

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