@amazon/vinyl 1.0.0

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

@@ -0,0 +1,139 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createDefaultHlsMediaQualityMetadataResolver, } from '@amazon/vinyl';
+describe('HlsMediaQualityMetadataResolver', () => {
+    let resolver;
+    beforeEach(() => {
+        resolver = createDefaultHlsMediaQualityMetadataResolver();
+    });
+    const baseVariant = {
+        bandwidth: 500000,
+        uri: 'variant.m3u8',
+        codecs: 'avc1.640015,mp4a.40.2',
+        width: 480,
+        height: 270,
+        frameRate: 30,
+    };
+    /** Creates a variant, omitting keys whose value is explicitly set to undefined. */
+    function variant(overrides = {}) {
+        const result = {};
+        const allKeys = new Set([
+            ...Object.keys(baseVariant),
+            ...Object.keys(overrides),
+        ]);
+        for (const key of allKeys) {
+            const value = key in overrides
+                ? overrides[key]
+                : baseVariant[key];
+            if (value !== undefined)
+                result[key] = value;
+        }
+        return result;
+    }
+    function audioRendition(overrides = {}) {
+        return {
+            type: 'AUDIO',
+            groupId: 'aud1',
+            name: 'English',
+            language: 'en',
+            ...overrides,
+        };
+    }
+    it('sets bandwidth to null and bandwidthTotal from variant', () => {
+        const quality = resolver(variant({ bandwidth: 128000 }), []);
+        expect(quality.bandwidth).toBeNull();
+        expect(quality.bandwidthTotal).toBe(128000);
+    });
+    it('sets codecs from variant', () => {
+        const quality = resolver(variant({ codecs: 'mp4a.40.2' }), []);
+        expect(quality.codecs).toBe('mp4a.40.2');
+    });
+    it('sets contentType from first codec', () => {
+        const quality = resolver(variant({ codecs: 'avc1.640015,mp4a.40.2' }), []);
+        expect(quality.contentType).toBe('video');
+    });
+    it('sets contentType to audio for audio-only', () => {
+        const quality = resolver(variant({ codecs: 'mp4a.40.2' }), []);
+        expect(quality.contentType).toBe('audio');
+    });
+    it('sets contentType to null when codecs is undefined', () => {
+        const quality = resolver(variant({ codecs: undefined }), []);
+        expect(quality.contentType).toBeNull();
+    });
+    it('sets mimeType with codecs', () => {
+        const quality = resolver(variant({ codecs: 'avc1.640015,mp4a.40.2' }), []);
+        expect(quality.mimeType).toBe('video/mp4; codecs="avc1.640015,mp4a.40.2"');
+    });
+    it('sets mimeType to null when codecs is undefined', () => {
+        const quality = resolver(variant({ codecs: undefined }), []);
+        expect(quality.mimeType).toBeNull();
+    });
+    it('sets width and height from variant', () => {
+        const quality = resolver(variant({ width: 1920, height: 1080 }), []);
+        expect(quality.width).toBe(1920);
+        expect(quality.height).toBe(1080);
+    });
+    it('sets width and height to null when undefined', () => {
+        const quality = resolver(variant({ width: undefined, height: undefined }), []);
+        expect(quality.width).toBeNull();
+        expect(quality.height).toBeNull();
+    });
+    it('sets frameRate as tuple', () => {
+        const quality = resolver(variant({ frameRate: 30 }), []);
+        expect(quality.frameRate).toEqual([30, 1]);
+    });
+    it('sets frameRate to null when undefined', () => {
+        const quality = resolver(variant({ frameRate: undefined }), []);
+        expect(quality.frameRate).toBeNull();
+    });
+    it('sets lang from matching audio rendition', () => {
+        const quality = resolver(variant({ audioGroup: 'aud1' }), [
+            audioRendition({ groupId: 'aud1', language: 'fr' }),
+        ]);
+        expect(quality.lang).toBe('fr');
+    });
+    it('sets lang to null when no matching rendition', () => {
+        const quality = resolver(variant({ audioGroup: 'aud1' }), [
+            audioRendition({ groupId: 'aud2', language: 'fr' }),
+        ]);
+        expect(quality.lang).toBeNull();
+    });
+    it('sets lang to null when no audioGroup', () => {
+        const quality = resolver(variant({ audioGroup: undefined }), [
+            audioRendition(),
+        ]);
+        expect(quality.lang).toBeNull();
+    });
+    it('sets qualityId from bandwidth and codecs', () => {
+        const quality = resolver(variant({ bandwidth: 500000, codecs: 'mp4a.40.2' }), []);
+        expect(quality.qualityId).toBe('500000-mp4a.40.2');
+    });
+    it('sets decoderId from variant uri', () => {
+        const quality = resolver(variant({ uri: 'foo.m3u8' }), []);
+        expect(quality.decoderId).toBe('foo.m3u8');
+    });
+    it('sets DRM fields to empty/null', () => {
+        const quality = resolver(variant(), []);
+        expect(quality.contentProtections).toEqual([]);
+        expect(quality.encryptionScheme).toBeNull();
+        expect(quality.initDataType).toBeNull();
+    });
+    it('sets audioSamplingRate to null', () => {
+        const quality = resolver(variant(), []);
+        expect(quality.audioSamplingRate).toBeNull();
+    });
+    it('sets supplementalProperties to empty object', () => {
+        const quality = resolver(variant(), []);
+        expect(quality.supplementalProperties).toEqual({});
+    });
+    it('sets groupId to default', () => {
+        const quality = resolver(variant(), []);
+        expect(quality.groupId).toBe('0');
+    });
+    it('sets switchingGroupIds to null to allow unrestricted switching', () => {
+        const quality = resolver(variant(), []);
+        expect(quality.switchingGroupIds).toBeNull();
+    });
+});

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

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

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

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

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

@@ -0,0 +1,51 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createHlsTrackFactory, MseTrack, } from '@amazon/vinyl';
+import { ValidationError } from '@amazon/vinyl-util';
+import { createMockHlsDependencies, } from '@amazon/vinyl/vinylTestUtil';
+import { externalDependencies } from '@amazon/vinyl-di';
+const trackLoadOptions = {
+    type: 'hls',
+    uri: 'https://example.com/main.m3u8',
+};
+describe('createHlsTrackFactory', () => {
+    let trackFactory;
+    let track = null;
+    let deps;
+    beforeEach(() => {
+        track = null;
+        trackFactory = createHlsTrackFactory({
+            createHlsFactories: () => {
+                deps = createMockHlsDependencies();
+                return externalDependencies(deps);
+            },
+        });
+    });
+    afterEach(() => {
+        if (track && !track.disposed)
+            track.dispose();
+    });
+    it('creates a track factory for HlsTrack', () => {
+        track = trackFactory.createTrack(trackLoadOptions);
+        expect(track).toBeInstanceOf(MseTrack);
+    });
+    it('validates the track options', () => {
+        trackFactory.validate({
+            type: 'hls',
+            uri: 'https://example.com/test.m3u8',
+        });
+        expect(() => trackFactory.validate(
+        // @ts-expect-error Expected validation error
+        {
+            type: 'hls',
+        })).toThrowError(ValidationError);
+        expect(() => trackFactory.validate({
+            type: 'hls',
+            uri: 'https://example.com/test.m3u8',
+            // @ts-expect-error Expected validation error
+            requestInit: 3,
+        })).toThrowError(ValidationError);
+    });
+});

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

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

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

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

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

@@ -0,0 +1,297 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { buildHlsMediaTimeline, createEmptyMediaQualityMetadata, } from '@amazon/vinyl';
+import { noop } from '@amazon/vinyl-util';
+describe('buildHlsMediaTimeline', () => {
+    function createVariant(uri, bandwidth) {
+        return {
+            bandwidth,
+            uri,
+            codecs: 'mp4a.40.2',
+        };
+    }
+    function createMediaPlaylist(durations) {
+        return {
+            targetDuration: Math.max(...durations),
+            segments: durations.map((d, i) => ({
+                duration: d,
+                uri: `seg${i}.m4s`,
+                map: { uri: 'init.mp4' },
+            })),
+        };
+    }
+    function createManifestData(variants, playlist) {
+        return {
+            mainPlaylist: {
+                variants,
+                alternativeRenditions: [],
+            },
+            baseUrl: 'https://example.com/',
+            getMediaPlaylist: () => Promise.resolve(playlist),
+        };
+    }
+    const deps = {
+        mediaQualityMetadataResolver: () => ({
+            ...createEmptyMediaQualityMetadata(),
+            contentType: 'audio',
+        }),
+        requestInterceptor: noop,
+        segmentRequestInit: undefined,
+    };
+    it('builds a single-period timeline from HLS manifest', () => {
+        const variant = createVariant('v1.m3u8', 128000);
+        const playlist = createMediaPlaylist([4, 4, 4]);
+        const data = createManifestData([variant], playlist);
+        const timeline = buildHlsMediaTimeline(deps, data);
+        expect(timeline.periods.length).toBe(1);
+        expect(timeline.periods[0].startTime).toBe(0);
+        expect(timeline.periods[0].endTime).toBe(Infinity);
+        expect(timeline.minBufferTime).toBe(10);
+    });
+    it('computes duration lazily from media playlist', async () => {
+        const variant = createVariant('v1.m3u8', 128000);
+        const playlist = createMediaPlaylist([4, 4, 4]);
+        const data = createManifestData([variant], playlist);
+        const timeline = buildHlsMediaTimeline(deps, data);
+        expect(await timeline.getDuration()).toBe(12);
+    });
+    it('creates one quality per variant', () => {
+        const v1 = createVariant('v1.m3u8', 128000);
+        const v2 = createVariant('v2.m3u8', 256000);
+        const playlist = createMediaPlaylist([4, 4]);
+        const data = createManifestData([v1, v2], playlist);
+        const timeline = buildHlsMediaTimeline(deps, data);
+        expect(timeline.periods[0].qualities.length).toBe(2);
+    });
+    it('quality getSegment returns a segment reference', async () => {
+        const variant = createVariant('v1.m3u8', 128000);
+        const playlist = createMediaPlaylist([10, 10]);
+        const data = createManifestData([variant], playlist);
+        const timeline = buildHlsMediaTimeline(deps, data);
+        const quality = timeline.periods[0].qualities[0];
+        const segment = await quality.getSegment(5);
+        expect(segment).not.toBeNull();
+        expect(segment.startTime).toBe(0);
+        expect(segment.endTime).toBe(10);
+    });
+    it('quality getSegment returns null for out-of-range time', async () => {
+        const variant = createVariant('v1.m3u8', 128000);
+        const playlist = createMediaPlaylist([10]);
+        const data = createManifestData([variant], playlist);
+        const timeline = buildHlsMediaTimeline(deps, data);
+        const quality = timeline.periods[0].qualities[0];
+        const segment = await quality.getSegment(100);
+        expect(segment).toBeNull();
+    });
+    it('handles empty variants', () => {
+        const data = createManifestData([], createMediaPlaylist([]));
+        const timeline = buildHlsMediaTimeline(deps, data);
+        expect(timeline.periods[0].qualities.length).toBe(0);
+        expect(timeline.periods[0].endTime).toBe(Infinity);
+    });
+    it('uses variant URI for audio when variant is audio-only with audioGroup', async () => {
+        const variant = {
+            ...createVariant('flac.m3u8', 2_000_000),
+            codecs: 'flac',
+            audioGroup: 'audio-group',
+        };
+        const playlist = createMediaPlaylist([5, 5]);
+        const requestedUris = [];
+        const manifestData = {
+            mainPlaylist: {
+                variants: [variant],
+                alternativeRenditions: [
+                    {
+                        type: 'AUDIO',
+                        groupId: 'audio-group',
+                        uri: 'aac.m3u8',
+                        language: 'en',
+                    },
+                ],
+            },
+            baseUrl: 'https://example.com/',
+            getMediaPlaylist: (uri) => {
+                requestedUris.push(uri);
+                return Promise.resolve(playlist);
+            },
+        };
+        const timeline = buildHlsMediaTimeline(deps, manifestData);
+        const segment = await timeline.periods[0].qualities[0].getSegment(2);
+        expect(segment).not.toBeNull();
+        expect(requestedUris).toContain('flac.m3u8');
+        expect(requestedUris).not.toContain('aac.m3u8');
+    });
+    it('uses rendition URI for audio when variant carries both video and audio', async () => {
+        const variant = {
+            bandwidth: 5_000_000,
+            uri: 'video.m3u8',
+            codecs: 'avc1.640015,mp4a.40.2',
+            audioGroup: 'audio-group',
+        };
+        const playlist = createMediaPlaylist([5, 5]);
+        const requestedUris = [];
+        const manifestData = {
+            mainPlaylist: {
+                variants: [variant],
+                alternativeRenditions: [
+                    {
+                        type: 'AUDIO',
+                        groupId: 'audio-group',
+                        uri: 'audio.m3u8',
+                        language: 'en',
+                    },
+                ],
+            },
+            baseUrl: 'https://example.com/',
+            getMediaPlaylist: (uri) => {
+                requestedUris.push(uri);
+                return Promise.resolve(playlist);
+            },
+        };
+        const timeline = buildHlsMediaTimeline(deps, manifestData);
+        const audioQuality = timeline.periods[0].qualities.find((q) => q.metadata.contentType === 'audio');
+        const videoQuality = timeline.periods[0].qualities.find((q) => q.metadata.contentType === 'video');
+        await videoQuality.getSegment(2);
+        expect(requestedUris).toEqual(['video.m3u8']);
+        requestedUris.length = 0;
+        await audioQuality.getSegment(2);
+        expect(requestedUris).toEqual(['audio.m3u8']);
+    });
+    it('uses transmux path when no EXT-X-MAP is present', async () => {
+        const variant = createVariant('v1.m3u8', 128000);
+        const playlist = {
+            targetDuration: 10,
+            segments: [{ duration: 10, uri: 'seg0.ts' }],
+        };
+        const manifestData = createManifestData([variant], playlist);
+        // Build a minimal ADTS frame for the transmuxer
+        function adtsFrame(payloadSize) {
+            const frameLength = 7 + payloadSize;
+            const frame = new Uint8Array(frameLength);
+            frame[0] = 0xff;
+            frame[1] = 0xf1;
+            frame[2] = (1 << 6) | (4 << 2) | 0;
+            frame[3] = (2 << 6) | ((frameLength >> 11) & 0x03);
+            frame[4] = (frameLength >> 3) & 0xff;
+            frame[5] = ((frameLength & 0x07) << 5) | 0x1f;
+            frame[6] = 0xfc;
+            for (let i = 7; i < frameLength; i++)
+                frame[i] = 0xab;
+            return frame;
+        }
+        const adtsData = adtsFrame(100);
+        const fetchSpy = spyOn(globalThis, 'fetch').and.callFake(() => Promise.resolve(new Response(adtsData.buffer.slice(0))));
+        const timeline = buildHlsMediaTimeline(deps, manifestData);
+        const quality = timeline.periods[0].qualities[0];
+        const segment = await quality.getSegment(5);
+        expect(segment).not.toBeNull();
+        // Call data and initData to cover the transmux function bodies
+        const data = await segment.data();
+        expect(data).toEqual(jasmine.any(ArrayBuffer));
+        const initData = await segment.initData();
+        expect(initData).toEqual(jasmine.any(ArrayBuffer));
+        fetchSpy.and.callThrough();
+    });
+    it('handles variant without codecs in narrowing', async () => {
+        const variant = {
+            bandwidth: 128000,
+            uri: 'v1.m3u8',
+            // no codecs property
+        };
+        const playlist = createMediaPlaylist([10]);
+        const manifestData = createManifestData([variant], playlist);
+        const timeline = buildHlsMediaTimeline(deps, manifestData);
+        const quality = timeline.periods[0].qualities[0];
+        const segment = await quality.getSegment(5);
+        expect(segment).not.toBeNull();
+        // codecs should fall back to metadata.codecs
+        expect(segment.quality.codecs).toBeNull();
+    });
+    it('getDuration returns null when getMediaPlaylist fails', async () => {
+        const variant = createVariant('v1.m3u8', 128000);
+        const manifestData = {
+            mainPlaylist: {
+                variants: [variant],
+                alternativeRenditions: [],
+            },
+            baseUrl: 'https://example.com/',
+            getMediaPlaylist: () => Promise.reject(new Error('disposed')),
+        };
+        const timeline = buildHlsMediaTimeline(deps, manifestData);
+        expect(await timeline.getDuration()).toBeNull();
+    });
+    it('getDuration caches the result', async () => {
+        const variant = createVariant('v1.m3u8', 128000);
+        const playlist = createMediaPlaylist([5, 5]);
+        let calls = 0;
+        const manifestData = {
+            mainPlaylist: {
+                variants: [variant],
+                alternativeRenditions: [],
+            },
+            baseUrl: 'https://example.com/',
+            getMediaPlaylist: () => {
+                calls++;
+                return Promise.resolve(playlist);
+            },
+        };
+        const timeline = buildHlsMediaTimeline(deps, manifestData);
+        expect(await timeline.getDuration()).toBe(10);
+        expect(await timeline.getDuration()).toBe(10);
+        expect(calls).toBe(1);
+    });
+    it('getDuration returns null for empty segments', async () => {
+        const variant = createVariant('v1.m3u8', 128000);
+        const playlist = createMediaPlaylist([]);
+        const manifestData = createManifestData([variant], playlist);
+        const timeline = buildHlsMediaTimeline(deps, manifestData);
+        expect(await timeline.getDuration()).toBeNull();
+    });
+    it('passes byteRange from map to createSegmentDataProvider as mediaRange', async () => {
+        const variant = createVariant('v1.m3u8', 128000);
+        const playlist = {
+            targetDuration: 10,
+            segments: [
+                {
+                    duration: 10,
+                    uri: 'seg0.m4s',
+                    map: {
+                        uri: 'init.mp4',
+                        byteRange: { offset: 0, length: 500 },
+                    },
+                },
+            ],
+        };
+        const manifestData = createManifestData([variant], playlist);
+        const fetchSpy = spyOn(globalThis, 'fetch').and.callFake((input) => {
+            const url = typeof input === 'string'
+                ? input
+                : input instanceof URL
+                    ? input.href
+                    : input.url;
+            if (url.includes('init.mp4')) {
+                return Promise.resolve(new Response(new ArrayBuffer(500)));
+            }
+            return Promise.resolve(new Response(new ArrayBuffer(100)));
+        });
+        const timeline = buildHlsMediaTimeline(deps, manifestData);
+        const quality = timeline.periods[0].qualities[0];
+        const segment = await quality.getSegment(5);
+        expect(segment).not.toBeNull();
+        await segment.initData();
+        // Verify the Range header was set for the init segment
+        const initCall = fetchSpy.calls
+            .allArgs()
+            .find((args) => typeof args[0] === 'string' && args[0].includes('init.mp4'));
+        expect(initCall).toBeDefined();
+        expect(initCall[1]?.headers).toEqual(jasmine.objectContaining({ Range: 'bytes=0-499' }));
+        fetchSpy.and.callThrough();
+    });
+    it('getDuration returns null when no variants', async () => {
+        const manifestData = createManifestData([], createMediaPlaylist([]));
+        const timeline = buildHlsMediaTimeline(deps, manifestData);
+        expect(await timeline.getDuration()).toBeNull();
+    });
+});

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

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

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

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

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

@@ -0,0 +1,69 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createDefaultHlsManifestTransformer } from '@amazon/vinyl';
+import { data } from '@amazon/vinyl-observable';
+function variant(bandwidth) {
+    return { bandwidth, uri: `${bandwidth}.m3u8` };
+}
+function manifestData(variants) {
+    return {
+        mainPlaylist: {
+            variants,
+            alternativeRenditions: [],
+        },
+        baseUrl: 'https://example.com/',
+        getMediaPlaylist: () => Promise.resolve(null),
+    };
+}
+describe('createDefaultHlsManifestTransformer', () => {
+    it('sorts variants by bandwidth descending', async () => {
+        const input = manifestData([
+            variant(500000),
+            variant(2000000),
+            variant(1000000),
+        ]);
+        const controller = data(Promise.resolve(input));
+        const transformer = createDefaultHlsManifestTransformer({
+            manifestController: controller,
+        });
+        const result = await transformer.value;
+        const bandwidths = result.mainPlaylist.variants.map((v) => v.bandwidth);
+        expect(bandwidths).toEqual([2000000, 1000000, 500000]);
+    });
+    it('preserves other manifest data', async () => {
+        const input = manifestData([variant(100)]);
+        const controller = data(Promise.resolve(input));
+        const transformer = createDefaultHlsManifestTransformer({
+            manifestController: controller,
+        });
+        const result = await transformer.value;
+        expect(result.baseUrl).toBe('https://example.com/');
+        expect(result.mainPlaylist.alternativeRenditions).toEqual([]);
+    });
+    it('handles single variant', async () => {
+        const input = manifestData([variant(128000)]);
+        const controller = data(Promise.resolve(input));
+        const transformer = createDefaultHlsManifestTransformer({
+            manifestController: controller,
+        });
+        const result = await transformer.value;
+        expect(result.mainPlaylist.variants.length).toBe(1);
+        expect(result.mainPlaylist.variants[0].bandwidth).toBe(128000);
+    });
+    it('handles already sorted variants', async () => {
+        const input = manifestData([
+            variant(3000000),
+            variant(2000000),
+            variant(1000000),
+        ]);
+        const controller = data(Promise.resolve(input));
+        const transformer = createDefaultHlsManifestTransformer({
+            manifestController: controller,
+        });
+        const result = await transformer.value;
+        const bandwidths = result.mainPlaylist.variants.map((v) => v.bandwidth);
+        expect(bandwidths).toEqual([3000000, 2000000, 1000000]);
+    });
+});

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

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

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

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

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

@@ -0,0 +1,57 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ContentStreamImpl, createHlsContentStreamFactories, } from '@amazon/vinyl';
+import { MockMediaSourceController, MockPlaybackController, MockQualitySelector, } from '@amazon/vinyl/vinylTestUtil';
+import { createContainer } from '@amazon/vinyl-di';
+import { data } from '@amazon/vinyl-observable';
+var any = jasmine.any;
+describe('createHlsContentStreamFactories', () => {
+    let deps;
+    const emptyTimeline = { periods: [], minBufferTime: 0 };
+    beforeEach(() => {
+        deps = {
+            mediaSourceController: new MockMediaSourceController(),
+            playbackController: new MockPlaybackController(),
+            mediaTimelineTransformed: data(Promise.resolve(emptyTimeline)),
+            qualitySelector: new MockQualitySelector(),
+        };
+    });
+    it('creates a memoized factory function', () => {
+        const createFactories = createHlsContentStreamFactories(null)(deps);
+        expect(createFactories).toEqual(any(Function));
+    });
+    it('returns the same factories for the same content type', () => {
+        const createFactories = createHlsContentStreamFactories(null)(deps);
+        const first = createFactories('audio');
+        const second = createFactories('audio');
+        expect(first).toBe(second);
+    });
+    it('returns different factories for different content types', () => {
+        const createFactories = createHlsContentStreamFactories(null)(deps);
+        const audio = createFactories('audio');
+        const video = createFactories('video');
+        expect(audio).not.toBe(video);
+    });
+    it('factories can create a ContentStreamImpl', () => {
+        const createFactories = createHlsContentStreamFactories(null)(deps);
+        const factories = createFactories('audio');
+        const stream = new ContentStreamImpl(factories, 'audio');
+        stream.preload({ prefetchPriority: 1, startTime: 0 });
+        stream.activate({ startTime: 0 });
+        expect(stream).toBeDefined();
+        stream.dispose();
+    });
+    it('provides options to sub-controllers', () => {
+        const createFactories = createHlsContentStreamFactories({
+            buffering: { minBuffer: 3.1 },
+            segmentController: { prefetchActive: 5.2 },
+        })(deps);
+        const container = createContainer(createFactories('audio'));
+        const streamDeps = container.dependencies;
+        expect(streamDeps.bufferingController.options.minBuffer).toBe(3.1);
+        expect(streamDeps.segmentController.options.prefetchActive).toBe(5.2);
+        container.dispose();
+    });
+});

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

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

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

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