@amazon/vinyl 1.0.0

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

@@ -0,0 +1,81 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { buildDashMediaTimeline } from '@amazon/vinyl';
+import { noop } from '@amazon/vinyl-util';
+import { dash_segmentList } from '@amazon/vinyl/vinylTestUtil';
+import { pickFirstBaseUrlSelector } from '@amazon/vinyl';
+import { parseDashManifest } from '@amazon/vinyl-mpd-parser';
+describe('buildDashMediaTimeline', () => {
+    const manifest = parseDashManifest(dash_segmentList);
+    const deps = {
+        mediaQualityMetadataResolver: jasmine
+            .createSpy('resolver')
+            .and.callFake((rep) => ({
+            contentType: 'audio',
+            qualityId: rep.id ?? 'q',
+            decoderId: 'd',
+            groupId: 'g',
+            switchingGroupIds: null,
+            mimeType: 'audio/mp4',
+            codecs: 'mp4a.40.2',
+            bandwidth: rep.bandwidth,
+            bandwidthTotal: rep.bandwidth,
+            audioSamplingRate: null,
+            frameRate: null,
+            height: null,
+            width: null,
+            lang: null,
+            contentProtections: [],
+            encryptionScheme: null,
+            initDataType: null,
+            supplementalProperties: {},
+        })),
+        requestInterceptor: noop,
+        segmentRequestInit: undefined,
+        baseUrlSelector: pickFirstBaseUrlSelector,
+    };
+    it('builds periods from manifest', () => {
+        const data = {
+            manifest,
+            baseUrl: 'https://example.com/',
+        };
+        const timeline = buildDashMediaTimeline(deps, data);
+        expect(timeline.periods.length).toBe(manifest.MPD.Period.length);
+        expect(timeline.minBufferTime).toBe(manifest.MPD.minBufferTime);
+        expect(timeline.periods[0].qualities.length).toBeGreaterThan(0);
+    });
+    it('creates qualities with getSegment function', () => {
+        const data = {
+            manifest,
+            baseUrl: 'https://example.com/',
+        };
+        const timeline = buildDashMediaTimeline(deps, data);
+        const quality = timeline.periods[0].qualities[0];
+        expect(quality.getSegment).toEqual(jasmine.any(Function));
+        expect(quality.metadata).toBeDefined();
+    });
+    it('quality getSegment returns a segment reference', async () => {
+        const data = {
+            manifest,
+            baseUrl: 'https://example.com/',
+        };
+        const timeline = buildDashMediaTimeline(deps, data);
+        const quality = timeline.periods[0].qualities[0];
+        const segment = await quality.getSegment(0);
+        expect(segment).not.toBeNull();
+        expect(segment.startTime).toBeDefined();
+        expect(segment.initData).toBeDefined();
+        expect(segment.data).toBeDefined();
+    });
+    it('getDuration returns the manifest duration', async () => {
+        const data = {
+            manifest,
+            baseUrl: 'https://example.com/',
+        };
+        const timeline = buildDashMediaTimeline(deps, data);
+        const duration = await timeline.getDuration();
+        expect(duration).toEqual(jasmine.any(Number));
+    });
+});

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

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

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

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

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

@@ -0,0 +1,68 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ContentStreamImpl, createDashContentStreamFactories, } from '@amazon/vinyl';
+import { MockMediaSourceController, MockPlaybackController, MockQualitySelector, } from '@amazon/vinyl/vinylTestUtil';
+import { data } from '@amazon/vinyl-observable';
+var any = jasmine.any;
+import { createContainer } from '@amazon/vinyl-di';
+describe('createDashContentStreamFactories', () => {
+    let deps;
+    let mediaSourceController;
+    let playbackController;
+    let qualitySelector;
+    const emptyTimeline = { periods: [], minBufferTime: 0 };
+    beforeEach(() => {
+        mediaSourceController = new MockMediaSourceController();
+        playbackController = new MockPlaybackController();
+        qualitySelector = new MockQualitySelector();
+        deps = {
+            mediaSourceController,
+            playbackController,
+            mediaTimelineTransformed: data(Promise.resolve(emptyTimeline)),
+            qualitySelector,
+        };
+    });
+    it('creates factories function that returns Factories<ContentStreamImplDeps>', () => {
+        const createFactories = createDashContentStreamFactories(null)(deps);
+        expect(createFactories).toEqual(any(Function));
+        const factories = createFactories('audio');
+        expect(factories).toBeDefined();
+        expect(typeof factories).toBe('object');
+    });
+    it('creates different factories for different content types', () => {
+        const createFactories = createDashContentStreamFactories(null)(deps);
+        const audioFactories = createFactories('audio');
+        const videoFactories = createFactories('video');
+        expect(audioFactories).not.toBe(videoFactories);
+        const audioFactories2 = createFactories('audio');
+        expect(audioFactories2).toBe(audioFactories);
+    });
+    it('factories can be used to create a new ContentStreamImpl', () => {
+        const createFactories = createDashContentStreamFactories(null)(deps);
+        const factories = createFactories('audio');
+        // Create ContentStream to trigger factory instantiation
+        const contentStream = new ContentStreamImpl(factories, 'audio');
+        // Exercise methods to ensure all factories are used
+        contentStream.preload({ prefetchPriority: 1, startTime: 0 });
+        contentStream.activate({ startTime: 0 });
+        expect(contentStream).toBeDefined();
+        contentStream.dispose();
+    });
+    it('provides options to sub-controllers', () => {
+        const createFactories = createDashContentStreamFactories({
+            buffering: {
+                minBuffer: 3.1,
+            },
+            segmentController: {
+                prefetchActive: 5.2,
+            },
+        })(deps);
+        const audioContentStreamDepsContainer = createContainer(createFactories('audio'));
+        const audioContentStreamDeps = audioContentStreamDepsContainer.dependencies;
+        expect(audioContentStreamDeps.bufferingController.options.minBuffer).toBe(3.1);
+        expect(audioContentStreamDeps.segmentController.options.prefetchActive).toBe(5.2);
+        audioContentStreamDepsContainer.dispose();
+    });
+});

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

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

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

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

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

@@ -0,0 +1,119 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createEmptyMediaQualityMetadata, createDashContentTypesValue, } from '@amazon/vinyl';
+import { parseDashManifest, } from '@amazon/vinyl-mpd-parser';
+import { data } from '@amazon/vinyl-observable';
+var createSpy = jasmine.createSpy;
+describe('createDashContentTypesValue', () => {
+    let manifestData;
+    let dashMediaQualityMetadataResolver;
+    let deps;
+    beforeEach(() => {
+        manifestData = data(Promise.resolve({
+            manifest: parseDashManifest(`<?xml version="1.0"?>
+                    <MPD xmlns="urn:mpeg:dash:schema:mpd:2011" minBufferTime="PT10S" profiles="">
+                        <Period/>
+                    </MPD>`),
+            baseUrl: 'https://example.com',
+        }));
+        dashMediaQualityMetadataResolver = createSpy('mediaQualityMetadataResolver').and.callFake((rep) => {
+            return {
+                ...createEmptyMediaQualityMetadata(),
+                contentType: rep.parent.contentType,
+            };
+        });
+        deps = {
+            manifestTransformed: manifestData,
+            mediaQualityMetadataResolver: dashMediaQualityMetadataResolver,
+        };
+    });
+    function setManifest(xml) {
+        const manifest = parseDashManifest(xml);
+        manifestData.value = Promise.resolve({
+            manifest,
+            baseUrl: 'https://example.com',
+        });
+    }
+    it('returns audio for audio-only content', async () => {
+        setManifest(`<?xml version="1.0"?>
+            <MPD xmlns="urn:mpeg:dash:schema:mpd:2011" minBufferTime="PT10S" profiles="">
+                <Period>
+                    <AdaptationSet contentType="audio">
+                        <Representation id="audio1" bandwidth="1"/>
+                    </AdaptationSet>
+                </Period>
+            </MPD>`);
+        const result = await createDashContentTypesValue(deps).value;
+        expect(result).toEqual(new Set(['audio']));
+    });
+    it('returns video for video-only content', async () => {
+        setManifest(`<?xml version="1.0"?>
+            <MPD xmlns="urn:mpeg:dash:schema:mpd:2011" minBufferTime="PT10S" profiles="">
+                <Period>
+                    <AdaptationSet contentType="video">
+                        <Representation id="video1" bandwidth="1"/>
+                    </AdaptationSet>
+                </Period>
+            </MPD>`);
+        const result = await createDashContentTypesValue(deps).value;
+        expect(result).toEqual(new Set(['video']));
+    });
+    it('returns audio and video for mixed content', async () => {
+        setManifest(`<?xml version="1.0"?>
+            <MPD xmlns="urn:mpeg:dash:schema:mpd:2011" minBufferTime="PT10S" profiles="">
+                <Period>
+                    <AdaptationSet contentType="audio">
+                        <Representation id="audio1" bandwidth="1"/>
+                    </AdaptationSet>
+                    <AdaptationSet contentType="video">
+                        <Representation id="video1" bandwidth="1"/>
+                    </AdaptationSet>
+                </Period>
+            </MPD>`);
+        const result = await createDashContentTypesValue(deps).value;
+        expect(result).toEqual(new Set(['audio', 'video']));
+    });
+    it('returns empty set for empty periods', async () => {
+        setManifest(`<?xml version="1.0"?>
+            <MPD xmlns="urn:mpeg:dash:schema:mpd:2011" minBufferTime="PT10S" profiles="">
+                <Period/>
+            </MPD>`);
+        const result = await createDashContentTypesValue(deps).value;
+        expect(result).toEqual(new Set());
+    });
+    it('counts unique content types across periods', async () => {
+        setManifest(`<?xml version="1.0"?>
+            <MPD xmlns="urn:mpeg:dash:schema:mpd:2011" minBufferTime="PT10S" profiles="">
+                <Period>
+                    <AdaptationSet contentType="audio">
+                        <Representation id="audio1" bandwidth="1"/>
+                    </AdaptationSet>
+                </Period>
+                <Period>
+                    <AdaptationSet contentType="video">
+                        <Representation id="video1" bandwidth="1"/>
+                    </AdaptationSet>
+                </Period>
+            </MPD>`);
+        const result = await createDashContentTypesValue(deps).value;
+        expect(result).toEqual(new Set(['audio', 'video']));
+    });
+    it('deduplicates content types', async () => {
+        setManifest(`<?xml version="1.0"?>
+            <MPD xmlns="urn:mpeg:dash:schema:mpd:2011" minBufferTime="PT10S" profiles="">
+                <Period>
+                    <AdaptationSet contentType="audio">
+                        <Representation id="audio1" bandwidth="1"/>
+                        <Representation id="audio2" bandwidth="1"/>
+                    </AdaptationSet>
+                    <AdaptationSet contentType="audio">
+                        <Representation id="audio3" bandwidth="1"/>
+                    </AdaptationSet>
+                </Period>
+            </MPD>`);
+        const result = await createDashContentTypesValue(deps).value;
+        expect(result).toEqual(new Set(['audio']));
+    });
+});

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

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

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

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

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

@@ -0,0 +1,78 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createDashFactories, DashManifestControllerImpl, MediaSourceControllerImpl, pickFirstBaseUrlSelector, QualitySelectorImpl, } from '@amazon/vinyl';
+import { createMockVinylDependencies, mockDashManifest, } from '@amazon/vinyl/vinylTestUtil';
+import { createContainer } from '@amazon/vinyl-di';
+import { MockMediaSource, MockMediaSourceGlobal, } from '@amazon/vinyl-util/browserTestUtil';
+import { clone } from '@amazon/vinyl-util';
+var objectContaining = jasmine.objectContaining;
+var any = jasmine.any;
+var createSpy = jasmine.createSpy;
+describe('createDashFactories', () => {
+    const originalMediaSource = global.MediaSource;
+    const originalManagedMediaSource = global.ManagedMediaSource;
+    let dashFactoryDeps;
+    let manifestProvider;
+    beforeEach(() => {
+        // createMediaSource produces a new MediaSource, set mock constructor:
+        global.ManagedMediaSource = undefined;
+        global.MediaSource = MockMediaSource;
+        // Set up dependencies that can be used when creating DashTrackDeps from
+        // the factories
+        const deps = createMockVinylDependencies();
+        deps.capabilities.canPlayTypeMse.and.returnValue(true);
+        const manifest = clone(mockDashManifest);
+        const adaptationSet = manifest.MPD.Period[0].AdaptationSet[0];
+        adaptationSet.mimeType = 'audio/mp4';
+        adaptationSet.codecs = 'flac';
+        dashFactoryDeps = deps;
+        manifestProvider = createSpy('manifestProvider').and.resolveTo({
+            manifest,
+            baseUrl: 'https://example.com',
+        });
+    });
+    afterEach(() => {
+        global.MediaSource = originalMediaSource;
+        global.ManagedMediaSource = originalManagedMediaSource;
+        MockMediaSourceGlobal.isTypeSupported.calls.reset();
+    });
+    it('creates factories with external dependencies', () => {
+        const factoryCreator = createDashFactories(null);
+        const factories = factoryCreator(dashFactoryDeps)({
+            uri: 'test://manifest.mpd',
+            type: 'dash',
+            manifestProvider,
+        });
+        const deps = createContainer(factories).dependencies;
+        expect(deps).toEqual(objectContaining({
+            baseUrlSelector: pickFirstBaseUrlSelector,
+            segmentRequestInit: undefined,
+            manifestProvider: any(Function),
+            manifestController: any(DashManifestControllerImpl),
+            mediaSourceFactory: any(Function),
+            mediaQualityMetadataResolver: any(Function),
+            mediaSourceController: any(MediaSourceControllerImpl),
+            createContentStreamFactories: any(Function),
+            contentStreamFactory: any(Function),
+            qualitySelector: any(QualitySelectorImpl),
+        }));
+    });
+    it('provides streaming options to createContentStreamFactories', () => {
+        const factoryCreator = createDashFactories({
+            streaming: {
+                buffering: {
+                    minBuffer: 3.1,
+                },
+            },
+        });
+        const factories = factoryCreator(dashFactoryDeps)({
+            uri: 'test://manifest.mpd',
+            type: 'dash',
+            manifestProvider,
+        });
+        const deps = createContainer(factories).dependencies;
+        expect(deps.contentStreamFactory('audio')).toEqual(any(Object));
+    });
+});

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

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

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

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

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

@@ -0,0 +1,31 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createDashManifestProvider } from '@amazon/vinyl';
+var createSpy = jasmine.createSpy;
+describe('createDashManifestProvider', () => {
+    it('returns provided manifestProvider when available', () => {
+        const mockManifestProvider = createSpy('manifestProvider');
+        const loadOptions = {
+            uri: 'test://manifest.mpd',
+            type: 'dash',
+            manifestProvider: mockManifestProvider,
+        };
+        const provider = createDashManifestProvider(loadOptions)({
+            requestInterceptor: {},
+        });
+        expect(provider).toBe(mockManifestProvider);
+    });
+    it('creates urlDashManifestProvider when manifestProvider not provided', () => {
+        const loadOptions = {
+            uri: 'test://manifest.mpd',
+            type: 'dash',
+            requestInit: { headers: { test: 'header' } },
+        };
+        const provider = createDashManifestProvider(loadOptions)({
+            requestInterceptor: {},
+        });
+        expect(provider).toEqual(jasmine.any(Function));
+    });
+});

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

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

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

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

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

@@ -0,0 +1,76 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createDefaultDashManifestTransformer, } from '@amazon/vinyl';
+import { parseDashManifest } from '@amazon/vinyl-mpd-parser';
+import { clone } from '@amazon/vinyl-util';
+import { data } from '@amazon/vinyl-observable';
+const mockManifest = parseDashManifest(
+// language=XML
+`<?xml version="1.0"?>
+    <MPD xmlns="urn:mpeg:dash:schema:mpd:2011" minBufferTime="PT10S" profiles="">
+        <Period>
+            <AdaptationSet contentType="audio" id="1" segmentAlignment="true" selectionPriority="1">
+                <Representation codecs="mp4a.40.2" bandwidth="48120" qualityRanking="1" id="p1a1r1"/>
+                <Representation codecs="mp4a.40.2" bandwidth="256000" qualityRanking="2" id="p1a1r2"/>
+                <Representation codecs="mp4a.40.2" bandwidth="320597" qualityRanking="3" id="p1a1r3"/>
+            </AdaptationSet>
+            <AdaptationSet contentType="audio" id="2" segmentAlignment="true" selectionPriority="3">
+                <Representation codecs="flac" bandwidth="48120" qualityRanking="1" id="p1a2r1"/>
+                <Representation codecs="flac" bandwidth="256000" qualityRanking="2" id="p1a2r2"/>
+                <Representation codecs="flac" bandwidth="320597" qualityRanking="3" id="p1a2r3"/>
+            </AdaptationSet>
+            <AdaptationSet contentType="audio" id="3" segmentAlignment="true" selectionPriority="2">
+                <Representation codecs="opus" bandwidth="48120" qualityRanking="1" id="p1a3r1"/>
+                <Representation codecs="opus" bandwidth="256000" qualityRanking="2" id="p1a3r2"/>
+                <Representation codecs="opus" bandwidth="320597" qualityRanking="3" id="p1a3r3"/>
+            </AdaptationSet>
+        </Period>
+    </MPD>`);
+describe('createDefaultDashManifestTransformer', () => {
+    async function transform(manifest) {
+        const manifestAndPath = {
+            manifest,
+            baseUrl: 'https://example.com',
+        };
+        const manifestController = data(Promise.resolve(manifestAndPath));
+        const transformed = createDefaultDashManifestTransformer({
+            manifestController,
+        });
+        return transformed.value;
+    }
+    it('sorts adaptation sets by descending selectionPriority', async () => {
+        const result = await transform(clone(mockManifest));
+        const selectionPriorities = result.manifest.MPD.Period.map((period) => (period.AdaptationSet ?? []).map((as) => as.selectionPriority));
+        expect(selectionPriorities).toEqual([[3, 2, 1]]);
+    });
+    it('sorts representations by ascending qualityRanking', async () => {
+        const result = await transform(clone(mockManifest));
+        const qualityRanks = result.manifest.MPD.Period.map((period) => (period.AdaptationSet ?? []).map((as) => (as.Representation ?? []).map((r) => r.qualityRanking)));
+        expect(qualityRanks).toEqual([
+            [
+                [1, 2, 3],
+                [1, 2, 3],
+                [1, 2, 3],
+            ],
+        ]);
+    });
+    it('orders by bandwidth descendingly when qualityRanking is not set', async () => {
+        const manifest = clone(parseDashManifest(
+        // language=XML
+        `<?xml version="1.0"?>
+    <MPD xmlns="urn:mpeg:dash:schema:mpd:2011" minBufferTime="PT10S" profiles="">
+        <Period>
+            <AdaptationSet contentType="audio" id="1" segmentAlignment="true">
+                <Representation codecs="mp4a.40.2" bandwidth="48120" id="p1a1r1"/>
+                <Representation codecs="mp4a.40.2" bandwidth="256000" id="p1a1r2"/>
+                <Representation codecs="mp4a.40.2" bandwidth="320597" id="p1a1r3"/>
+            </AdaptationSet>
+        </Period>
+    </MPD>`));
+        const result = await transform(manifest);
+        const bandwidths = result.manifest.MPD.Period[0].AdaptationSet[0].Representation.map((rep) => rep.bandwidth);
+        expect(bandwidths).toEqual([320597, 256000, 48120]);
+    });
+});

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

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

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

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

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

@@ -0,0 +1,21 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createSegmentControllerFactory, } from '@amazon/vinyl';
+import { MockPlaybackController } from '@amazon/vinyl/vinylTestUtil';
+import { data } from '@amazon/vinyl-observable';
+var objectContaining = jasmine.objectContaining;
+describe('createSegmentControllerFactory', () => {
+    it('creates SegmentControllerImpl with merged dependencies', () => {
+        const playbackController = new MockPlaybackController();
+        const emptyTimeline = { periods: [], minBufferTime: 0 };
+        const factory = createSegmentControllerFactory({ playbackController }, 'audio', { prefetchActive: 100 });
+        const controller = factory({
+            mediaTimelineTransformed: data(Promise.resolve(emptyTimeline)),
+            qualitySelector: { selectQuality: () => 0 },
+        });
+        expect(controller).toEqual(jasmine.any(Object));
+        expect(controller.options).toEqual(objectContaining({ prefetchActive: 100 }));
+    });
+});

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

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

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

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

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

@@ -0,0 +1,111 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { filterDashAdaptationSets, filterDashRepresentations, manifestIsPlayable, mapManifestTransform, sortDashAdaptationSets, sortDashRepresentations, } from '@amazon/vinyl';
+import { parseDashManifest } from '@amazon/vinyl-mpd-parser';
+import { MediaUnsupportedError } from '@amazon/vinyl-util';
+import { data } from '@amazon/vinyl-observable';
+const manifest = parseDashManifest(
+// language=XML
+`<?xml version="1.0" ?>
+    <MPD minBufferTime="PT0.0S" profiles="" xmlns="urn:mpeg:dash:schema:mpd:2011">
+        <Period>
+            <AdaptationSet id="1" contentType="audio">
+                <Representation id="10" bandwidth="100"/>
+                <Representation id="20" bandwidth="200"/>
+            </AdaptationSet>
+            <AdaptationSet id="2" contentType="video">
+                <Representation id="30" bandwidth="300"/>
+            </AdaptationSet>
+        </Period>
+    </MPD>`);
+describe('manifestTransformUtils', () => {
+    describe('manifestIsPlayable', () => {
+        it('returns true when representations exist', () => {
+            expect(manifestIsPlayable(manifest)).toBe(true);
+        });
+        it('returns false when no representations exist', () => {
+            const empty = parseDashManifest(`<?xml version="1.0" ?>
+                <MPD minBufferTime="PT0.0S" profiles="" xmlns="urn:mpeg:dash:schema:mpd:2011">
+                    <Period><AdaptationSet/></Period>
+                </MPD>`);
+            expect(manifestIsPlayable(empty)).toBe(false);
+        });
+    });
+    describe('filterDashRepresentations', () => {
+        it('filters representations by predicate', () => {
+            const result = filterDashRepresentations((rep) => rep.bandwidth > 100, () => {
+                throw new MediaUnsupportedError('', '');
+            }, manifest);
+            const ids = result.MPD.Period[0].AdaptationSet[0].Representation.map((r) => r.id);
+            expect(ids).toEqual(['20']);
+        });
+        it('throws when result is not playable', () => {
+            expect(() => filterDashRepresentations(() => false, () => {
+                throw new MediaUnsupportedError('none', 'none');
+            }, manifest)).toThrowMatching((e) => e instanceof MediaUnsupportedError);
+        });
+        it('does not mutate the original manifest', () => {
+            const originalCount = manifest.MPD.Period[0].AdaptationSet[0].Representation.length;
+            filterDashRepresentations((rep) => rep.bandwidth > 100, () => {
+                throw new MediaUnsupportedError('', '');
+            }, manifest);
+            expect(manifest.MPD.Period[0].AdaptationSet[0].Representation.length).toBe(originalCount);
+        });
+    });
+    describe('filterDashAdaptationSets', () => {
+        it('filters adaptation sets by predicate', () => {
+            const result = filterDashAdaptationSets((as) => as.id === 1, () => {
+                throw new MediaUnsupportedError('', '');
+            }, manifest);
+            expect(result.MPD.Period[0].AdaptationSet.length).toBe(1);
+            expect(result.MPD.Period[0].AdaptationSet[0].id).toBe(1);
+        });
+        it('throws when result is not playable', () => {
+            expect(() => filterDashAdaptationSets(() => false, () => {
+                throw new MediaUnsupportedError('none', 'none');
+            }, manifest)).toThrowMatching((e) => e instanceof MediaUnsupportedError);
+        });
+    });
+    describe('sortDashAdaptationSets', () => {
+        it('sorts adaptation sets without mutating original', () => {
+            const result = sortDashAdaptationSets((a, b) => (b.id ?? 0) - (a.id ?? 0), manifest);
+            expect(result.MPD.Period[0].AdaptationSet[0].id).toBe(2);
+            expect(result.MPD.Period[0].AdaptationSet[1].id).toBe(1);
+            expect(manifest.MPD.Period[0].AdaptationSet[0].id).toBe(1);
+        });
+    });
+    describe('sortDashRepresentations', () => {
+        it('sorts representations without mutating original', () => {
+            const result = sortDashRepresentations((a, b) => b.bandwidth - a.bandwidth, manifest);
+            const ids = result.MPD.Period[0].AdaptationSet[0].Representation.map((r) => r.id);
+            expect(ids).toEqual(['20', '10']);
+            expect(manifest.MPD.Period[0].AdaptationSet[0].Representation[0].id).toBe('10');
+        });
+    });
+    describe('mapManifestTransform', () => {
+        const baseUrl = 'https://example.com/manifest.mpd';
+        it('transforms manifest while preserving baseUrl', async () => {
+            const manifestController = data(Promise.resolve({ manifest, baseUrl }));
+            const result = mapManifestTransform(manifestController, (m) => filterDashRepresentations((rep) => rep.bandwidth > 100, () => {
+                throw new MediaUnsupportedError('', '');
+            }, m));
+            const { manifest: transformed, baseUrl: resultUrl } = await result.value;
+            expect(resultUrl).toBe(baseUrl);
+            expect(transformed.MPD.Period[0].AdaptationSet[0].Representation.map((r) => r.id)).toEqual(['20']);
+        });
+        it('propagates transformation errors', async () => {
+            const manifestController = data(Promise.resolve({ manifest, baseUrl }));
+            const result = mapManifestTransform(manifestController, () => {
+                throw new MediaUnsupportedError('none', 'none');
+            });
+            await expectAsync(result.value).toBeRejectedWithError();
+        });
+        it('propagates manifest controller errors', async () => {
+            const manifestController = data(Promise.reject(new Error('load failed')));
+            const result = mapManifestTransform(manifestController, (m) => m);
+            await expectAsync(result.value).toBeRejectedWithError('load failed');
+        });
+    });
+});

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

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