@amazon/vinyl 1.0.0

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

@@ -0,0 +1,140 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { pickFirstBaseUrlSelector, resolveDashUri, segmentTemplateUrl, } from '@amazon/vinyl';
+import { clone, ValidationError } from '@amazon/vinyl-util';
+import { mockDashManifest } from '@amazon/vinyl/vinylTestUtil';
+describe('resolveDashUri', () => {
+    let manifest;
+    let period;
+    let adaptationSet;
+    let representation;
+    let deps;
+    const baseUrl = 'https://example.com/';
+    beforeEach(() => {
+        deps = {
+            baseUrlSelector: pickFirstBaseUrlSelector,
+        };
+        manifest = clone(mockDashManifest);
+        period = manifest.MPD.Period[0];
+        adaptationSet = period.AdaptationSet[0];
+        representation = adaptationSet.Representation[0];
+    });
+    function setBaseUrls(mpdUri, periodUri, adaptationSetUri, representationUri) {
+        manifest.MPD.BaseURL = mpdUri ? [{ _content: mpdUri }] : [];
+        period.BaseURL = periodUri ? [{ _content: periodUri }] : [];
+        adaptationSet.BaseURL = adaptationSetUri
+            ? [{ _content: adaptationSetUri }]
+            : [];
+        representation.BaseURL = representationUri
+            ? [{ _content: representationUri }]
+            : [];
+    }
+    describe('when baseURL is empty or missing and URI is missing', () => {
+        it('rejects with a validation error', () => {
+            {
+                expect(() => resolveDashUri(deps, {
+                    uri: null,
+                    representation,
+                    baseUrl,
+                })).toThrowError(ValidationError, 'media missing URI or BaseURL');
+            }
+            {
+                representation.BaseURL = [];
+                expect(() => resolveDashUri(deps, {
+                    uri: null,
+                    representation,
+                    baseUrl,
+                })).toThrowError(ValidationError, 'media missing URI or BaseURL');
+            }
+        });
+    });
+    describe('when there are BaseURL elements at each scope', () => {
+        it('concatenates relative paths', () => {
+            {
+                setBaseUrls('foo/', 'bar/', 'baz/', 'bup.m3s');
+                expect(resolveDashUri(deps, {
+                    uri: null,
+                    representation,
+                    baseUrl,
+                }).url).toEqual('https://example.com/foo/bar/baz/bup.m3s');
+            }
+            {
+                setBaseUrls('foo/', 'bar/', 'https://example.org', 'bup.m3s');
+                expect(resolveDashUri(deps, {
+                    uri: null,
+                    representation,
+                    baseUrl,
+                }).url).toEqual('https://example.org/bup.m3s');
+            }
+            {
+                setBaseUrls('foo/', 'bar/', 'https://example.org', null);
+                expect(resolveDashUri(deps, {
+                    uri: 'example.mp4',
+                    representation,
+                    baseUrl,
+                }).url).toEqual('https://example.org/example.mp4');
+            }
+            {
+                setBaseUrls('foo/', 'bar/', 'https://example.org', 'https://example.gov');
+                expect(resolveDashUri(deps, {
+                    uri: 'example.mp4',
+                    representation,
+                    baseUrl,
+                }).url).toEqual('https://example.gov/example.mp4');
+            }
+            {
+                setBaseUrls(null, null, null, null);
+                expect(resolveDashUri(deps, {
+                    uri: 'example.mp4',
+                    representation,
+                    baseUrl,
+                }).url).toEqual('https://example.com/example.mp4');
+            }
+        });
+        it('returns serviceLocation defined at deepest level', () => {
+            manifest.MPD.BaseURL = [
+                { _content: '', serviceLocation: 'mpdLevel' },
+            ];
+            period.BaseURL = [{ _content: '', serviceLocation: 'periodLevel' }];
+            representation.BaseURL = [
+                { _content: '', serviceLocation: 'representationLevel' },
+            ];
+            expect(resolveDashUri(deps, {
+                uri: 'example.mp4',
+                representation,
+                baseUrl,
+            }).serviceLocation).toEqual('representationLevel');
+        });
+    });
+    describe('segmentTemplateUrl', () => {
+        it('replaces template tokens with provided values', () => {
+            representation.id = 'RepId';
+            representation.bandwidth = 948;
+            expect(segmentTemplateUrl('$RepresentationID$_$Time%05d$_$Number%02d$_$Bandwidth$', {
+                representation,
+                segmentNumber: 23,
+                sampleTime: 2400,
+            })).toEqual('RepId_02400_23_948');
+            expect(segmentTemplateUrl('$RepresentationID$_$Time%05d$_$Number%02d$_$Bandwidth$', {
+                representation,
+            })).toEqual('RepId_00000_00_948');
+        });
+        describe('when provided an unsupported token', () => {
+            it('throws a ValidationError', () => {
+                expect(() => segmentTemplateUrl('$Unknown$', {
+                    representation,
+                })).toThrowError(ValidationError);
+            });
+        });
+        describe('when a non IllegalArgumentError is caught', () => {
+            it('throws original error', () => {
+                expect(() => segmentTemplateUrl('$RepresentationID$', {
+                    // @ts-expect-error Expected representation
+                    representation: null,
+                })).toThrowError(TypeError);
+            });
+        });
+    });
+});

package/dist/unit/types/current/track/filters/keySystemFilter.test.d.ts

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

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

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

package/dist/unit/types/current/track/filters/keySystemFilter.test.js

@@ -0,0 +1,48 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { MockDrmController } from '@amazon/vinyl/vinylTestUtil';
+import { canPlayKeySystem, createEmptyMediaQualityMetadata, DrmKeySystem, throwKeySystemsUnsupported, } from '@amazon/vinyl';
+describe('canPlayKeySystem', () => {
+    let drmController;
+    beforeEach(() => {
+        drmController = new MockDrmController();
+    });
+    it('returns true for unprotected content', async () => {
+        const metadata = createEmptyMediaQualityMetadata();
+        metadata.contentProtections = [];
+        expect(await canPlayKeySystem({ drmController }, metadata)).toBe(true);
+        expect(drmController.isSupported).not.toHaveBeenCalled();
+    });
+    it('returns true when DRM controller supports the content', async () => {
+        drmController.isSupported.and.returnValue(Promise.resolve({
+            supported: true,
+            persistentState: false,
+        }));
+        const metadata = createEmptyMediaQualityMetadata();
+        metadata.contentProtections = [{ keySystem: DrmKeySystem.WIDEVINE }];
+        expect(await canPlayKeySystem({ drmController }, metadata)).toBe(true);
+        expect(drmController.isSupported).toHaveBeenCalledWith(metadata);
+    });
+    it('returns false when DRM controller does not support the content', async () => {
+        drmController.isSupported.and.returnValue(Promise.resolve({
+            supported: false,
+            persistentState: false,
+        }));
+        const metadata = createEmptyMediaQualityMetadata();
+        metadata.contentProtections = [{ keySystem: DrmKeySystem.PLAY_READY }];
+        expect(await canPlayKeySystem({ drmController }, metadata)).toBe(false);
+        expect(drmController.isSupported).toHaveBeenCalledWith(metadata);
+    });
+    it('throws correct error', () => {
+        try {
+            throwKeySystemsUnsupported();
+            fail('Expected error to be thrown');
+        }
+        catch (error) {
+            expect(error).toEqual(jasmine.any(Error));
+            expect(error.message).toBe('No key system supported.');
+        }
+    });
+});

package/dist/unit/types/current/track/filters/languageFilter.test.d.ts

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

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

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

package/dist/unit/types/current/track/filters/languageFilter.test.js

@@ -0,0 +1,104 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { normalizeLanguage, languageRelatedness, findBestLanguageMatch, throwLanguagesUnsupported, } from '@amazon/vinyl';
+import { MediaUnsupportedError } from '@amazon/vinyl-util';
+describe('languageFilter', () => {
+    describe('normalizeLanguage', () => {
+        it('lowercases language code', () => {
+            expect(normalizeLanguage('EN')).toBe('en');
+        });
+        it('uppercases region code', () => {
+            expect(normalizeLanguage('en-us')).toBe('en-US');
+        });
+        it('converts ISO 639-2 to ISO 639-1', () => {
+            expect(normalizeLanguage('eng')).toBe('en');
+            expect(normalizeLanguage('fra')).toBe('fr');
+            expect(normalizeLanguage('deu')).toBe('de');
+            expect(normalizeLanguage('spa')).toBe('es');
+            expect(normalizeLanguage('jpn')).toBe('ja');
+            expect(normalizeLanguage('zho')).toBe('zh');
+        });
+        it('converts ISO 639-2/B bibliographic codes', () => {
+            expect(normalizeLanguage('fre')).toBe('fr');
+            expect(normalizeLanguage('ger')).toBe('de');
+            expect(normalizeLanguage('chi')).toBe('zh');
+        });
+        it('converts 3-letter code with region', () => {
+            expect(normalizeLanguage('eng-us')).toBe('en-US');
+            expect(normalizeLanguage('fra-CA')).toBe('fr-CA');
+        });
+        it('passes through unknown 2-letter codes', () => {
+            expect(normalizeLanguage('xx')).toBe('xx');
+        });
+        it('discards subtags beyond region', () => {
+            expect(normalizeLanguage('en-US-dialect')).toBe('en-US');
+        });
+        it('handles empty string', () => {
+            expect(normalizeLanguage('')).toBe('');
+        });
+    });
+    describe('languageRelatedness', () => {
+        it('returns 4 for exact match', () => {
+            expect(languageRelatedness('en-US', 'en-US')).toBe(4);
+        });
+        it('returns 4 for exact match after normalization', () => {
+            expect(languageRelatedness('eng-us', 'en-US')).toBe(4);
+            expect(languageRelatedness('EN', 'en')).toBe(4);
+        });
+        it('returns 3 when candidate is parent of target', () => {
+            expect(languageRelatedness('en-US', 'en')).toBe(3);
+        });
+        it('returns 2 when candidate is sibling of target', () => {
+            expect(languageRelatedness('en-US', 'en-CA')).toBe(2);
+        });
+        it('returns 1 when candidate is child of target', () => {
+            expect(languageRelatedness('en', 'en-US')).toBe(1);
+        });
+        it('returns 0 for unrelated languages', () => {
+            expect(languageRelatedness('en', 'fr')).toBe(0);
+            expect(languageRelatedness('en-US', 'fr-CA')).toBe(0);
+        });
+        it('returns 0 for edge cases with same base but unusual structure', () => {
+            // After extensive analysis, line 283 appears to be unreachable
+            // with the current normalization logic. All possible combinations
+            // of 1-2 parts are explicitly handled by the conditions above.
+            // This test documents the expected behavior for standard cases.
+            expect(languageRelatedness('en', 'fr')).toBe(0); // Different base languages
+        });
+        it('handles ISO 639-2 codes', () => {
+            expect(languageRelatedness('eng', 'en')).toBe(4);
+            expect(languageRelatedness('eng-US', 'en-US')).toBe(4);
+            expect(languageRelatedness('spa', 'es-MX')).toBe(1);
+        });
+    });
+    describe('findBestLanguageMatch', () => {
+        it('returns exact match when available', () => {
+            expect(findBestLanguageMatch('en-US', ['fr', 'en-US', 'en'])).toBe('en-US');
+        });
+        it('returns parent when exact not available', () => {
+            expect(findBestLanguageMatch('en-US', ['fr', 'en', 'de'])).toBe('en');
+        });
+        it('returns sibling when parent not available', () => {
+            expect(findBestLanguageMatch('en-US', ['fr', 'en-CA'])).toBe('en-CA');
+        });
+        it('returns child when nothing closer available', () => {
+            expect(findBestLanguageMatch('en', ['fr', 'en-US'])).toBe('en-US');
+        });
+        it('returns first language when nothing is related', () => {
+            expect(findBestLanguageMatch('en', ['fr', 'de', 'ja'])).toBe('fr');
+        });
+        it('handles ISO 639-2 codes in search space', () => {
+            expect(findBestLanguageMatch('en', ['eng', 'fra'])).toBe('eng');
+        });
+        it('returns undefined for empty search space', () => {
+            expect(findBestLanguageMatch('en', [])).toBeUndefined();
+        });
+    });
+    describe('throwLanguagesUnsupported', () => {
+        it('throws MediaUnsupportedError', () => {
+            expect(() => throwLanguagesUnsupported()).toThrowMatching((e) => e instanceof MediaUnsupportedError);
+        });
+    });
+});

package/dist/unit/types/current/track/filters/resourceTypeFilter.test.d.ts

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

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

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

package/dist/unit/types/current/track/filters/resourceTypeFilter.test.js

@@ -0,0 +1,42 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { MockCapabilities } from '@amazon/vinyl/vinylTestUtil';
+import { canPlayMimeType, createEmptyMediaQualityMetadata, throwMimeTypesUnsupported, } from '@amazon/vinyl';
+describe('canPlayMimeType', () => {
+    let capabilities;
+    beforeEach(() => {
+        capabilities = new MockCapabilities();
+    });
+    it('returns false for unsupported mime types', () => {
+        capabilities.canPlayTypeMse.and.returnValue(false);
+        const metadata = createEmptyMediaQualityMetadata();
+        metadata.mimeType = 'audio/mp4; codecs="flac"';
+        expect(canPlayMimeType({ capabilities }, metadata)).toBe(false);
+    });
+    it('returns true for supported mime types', () => {
+        capabilities.canPlayTypeMse.and.returnValue(true);
+        const metadata = createEmptyMediaQualityMetadata();
+        metadata.mimeType = 'audio/mp4; codecs="opus"';
+        expect(canPlayMimeType({ capabilities }, metadata)).toBe(true);
+        expect(capabilities.canPlayTypeMse).toHaveBeenCalledWith('audio/mp4; codecs="opus"');
+    });
+    it('returns false for null mime type', () => {
+        capabilities.canPlayTypeMse.and.returnValue(true);
+        const metadata = createEmptyMediaQualityMetadata();
+        metadata.mimeType = null;
+        expect(canPlayMimeType({ capabilities }, metadata)).toBe(false);
+        expect(capabilities.canPlayTypeMse).not.toHaveBeenCalled();
+    });
+    it('throws correct error', () => {
+        try {
+            throwMimeTypesUnsupported();
+            fail('Expected error to be thrown');
+        }
+        catch (error) {
+            expect(error).toEqual(jasmine.any(Error));
+            expect(error.message).toBe('No resource type supported (container/codec).');
+        }
+    });
+});

package/dist/unit/types/current/track/filters/sampleRateFilter.test.d.ts

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

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

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

package/dist/unit/types/current/track/filters/sampleRateFilter.test.js

@@ -0,0 +1,102 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { supportsAudioSamplingRate, createEmptyMediaQualityMetadata, throwSamplingRatesUnsupported, } from '@amazon/vinyl';
+import { MockCapabilities } from '@amazon/vinyl/vinylTestUtil';
+import { setUserAgent } from '@amazon/vinyl-util';
+describe('supportsAudioSamplingRate', () => {
+    let capabilities;
+    beforeEach(() => {
+        capabilities = new MockCapabilities();
+        capabilities.sampleRate = 48_000;
+    });
+    describe('when browser is Firefox', () => {
+        beforeEach(() => {
+            setUserAgent('Firefox');
+        });
+        it('returns false when sample rate is above supported', () => {
+            const metadata = createEmptyMediaQualityMetadata();
+            metadata.audioSamplingRate = [96_000];
+            expect(supportsAudioSamplingRate({ capabilities }, metadata, 0, [
+                metadata,
+            ])).toBe(false);
+        });
+        it('returns false when sample rate is above 48kHz even if capabilities allows it', () => {
+            capabilities.sampleRate = 96_000;
+            const metadata = createEmptyMediaQualityMetadata();
+            metadata.audioSamplingRate = [96_000];
+            expect(supportsAudioSamplingRate({ capabilities }, metadata, 0, [
+                metadata,
+            ])).toBe(false);
+        });
+        it('returns false even when all rates are above 48kHz (no fallback to lowest)', () => {
+            const low = createEmptyMediaQualityMetadata();
+            low.audioSamplingRate = [88_200];
+            const high = createEmptyMediaQualityMetadata();
+            high.audioSamplingRate = [96_000];
+            expect(supportsAudioSamplingRate({ capabilities }, low, 0, [low, high])).toBe(false);
+            expect(supportsAudioSamplingRate({ capabilities }, high, 1, [
+                low,
+                high,
+            ])).toBe(false);
+        });
+        it('returns true when sample rate is at or below supported', () => {
+            const metadata = createEmptyMediaQualityMetadata();
+            metadata.audioSamplingRate = [48_000];
+            expect(supportsAudioSamplingRate({ capabilities }, metadata, 0, [
+                metadata,
+            ])).toBe(true);
+        });
+        it('returns true when sample rate is not set', () => {
+            const metadata = createEmptyMediaQualityMetadata();
+            metadata.audioSamplingRate = null;
+            expect(supportsAudioSamplingRate({ capabilities }, metadata, 0, [
+                metadata,
+            ])).toBe(true);
+        });
+    });
+    describe('when browser is not Firefox', () => {
+        beforeEach(() => {
+            setUserAgent('Chrome');
+        });
+        it('returns true when sample rate is at or below supported', () => {
+            const metadata = createEmptyMediaQualityMetadata();
+            metadata.audioSamplingRate = [48_000];
+            expect(supportsAudioSamplingRate({ capabilities }, metadata, 0, [
+                metadata,
+            ])).toBe(true);
+        });
+        it('returns false when sample rate is above supported and others are below', () => {
+            const low = createEmptyMediaQualityMetadata();
+            low.audioSamplingRate = [44_100];
+            const high = createEmptyMediaQualityMetadata();
+            high.audioSamplingRate = [96_000];
+            expect(supportsAudioSamplingRate({ capabilities }, high, 1, [
+                low,
+                high,
+            ])).toBe(false);
+        });
+        it('keeps lowest sample rate when all are above supported', () => {
+            const low = createEmptyMediaQualityMetadata();
+            low.audioSamplingRate = [88_200];
+            const high = createEmptyMediaQualityMetadata();
+            high.audioSamplingRate = [96_000];
+            expect(supportsAudioSamplingRate({ capabilities }, low, 0, [low, high])).toBe(true);
+            expect(supportsAudioSamplingRate({ capabilities }, high, 1, [
+                low,
+                high,
+            ])).toBe(false);
+        });
+    });
+    it('throws correct error', () => {
+        try {
+            throwSamplingRatesUnsupported();
+            fail('Expected error to be thrown');
+        }
+        catch (error) {
+            expect(error).toEqual(jasmine.any(Error));
+            expect(error.message).toBe('No supported sample rate');
+        }
+    });
+});

package/dist/unit/types/current/track/hls/HlsManifestController.test.d.ts

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

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

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

package/dist/unit/types/current/track/hls/HlsManifestController.test.js

@@ -0,0 +1,165 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Deferred } from '@amazon/vinyl-util';
+import { HlsManifestControllerImpl } from '@amazon/vinyl';
+import { mockHlsManifestData } from '@amazon/vinyl/vinylTestUtil';
+import { expectNothing, flushPromises, } from '@amazon/vinyl-util/browserTestUtil';
+var createSpy = jasmine.createSpy;
+describe('HlsManifestController', () => {
+    let manifestProvider;
+    beforeEach(() => {
+        manifestProvider = createSpy('manifestProvider');
+        manifestProvider.and.resolveTo(mockHlsManifestData);
+    });
+    function createManifestController() {
+        return new HlsManifestControllerImpl(manifestProvider);
+    }
+    it('has a toStringTag', () => {
+        const controller = createManifestController();
+        expect(String(controller)).toContain('HlsManifestControllerImpl');
+    });
+    it('has a logPrefix', () => {
+        const controller = createManifestController();
+        expect(controller.logPrefix).toBe('HlsManifestControllerImpl');
+    });
+    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('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/track/hls/HlsMediaQualityMetadataResolver.test.d.ts

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

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

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