@amazon/vinyl 1.2.0 → 2.0.4

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

@@ -2,9 +2,9 @@
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { createHlsFactories, HlsManifestControllerImpl, MediaSourceControllerImpl, QualitySelectorImpl, } from '@amazon/vinyl';
+import { createHlsFactories, ManifestControllerImpl, MediaSourceControllerImpl, QualitySelectorImpl, } from '@amazon/vinyl';
 import { createMockVinylDependencies } from '@amazon/vinyl/vinylTestUtil';
-import { mockHlsManifestData } from '@amazon/vinyl/vinylTestUtil';
+import { mockHlsManifestData, mockMediaPlaylist, } from '@amazon/vinyl/vinylTestUtil';
 import { createContainer } from '@amazon/vinyl-di';
 import { MockMediaSource, MockMediaSourceGlobal, } from '@amazon/vinyl-util/browserTestUtil';
 var objectContaining = jasmine.objectContaining;
@@ -39,7 +39,7 @@ describe('createHlsFactories', () => {
         const deps = createContainer(factories).dependencies;
         expect(deps).toEqual(objectContaining({
             segmentRequestInit: undefined,
-            manifestController: any(HlsManifestControllerImpl),
+            manifestController: any(ManifestControllerImpl),
             mediaSourceFactory: any(Function),
             mediaQualityMetadataResolver: any(Function),
             mediaSourceController: any(MediaSourceControllerImpl),
@@ -48,6 +48,39 @@ describe('createHlsFactories', () => {
             qualitySelector: any(QualitySelectorImpl),
         }));
     });
+    it('wires per-track option observables from the player options', () => {
+        const factoryCreator = createHlsFactories(null);
+        const factories = factoryCreator(hlsFactoryDeps)({
+            uri: 'https://example.com/main.m3u8',
+            type: 'hls',
+            manifestProvider,
+        });
+        const deps = createContainer(factories).dependencies;
+        const options = hlsFactoryDeps.options.value;
+        expect(deps.preferredAudioLanguage.value).toBe(options.preferredAudioLanguage);
+        expect(deps.allowedContentTypes.value).toBe(options.allowedContentTypes);
+        expect(deps.preferDescriptiveAudio.value).toBe(options.preferDescriptiveAudio);
+        expect(deps.abr.value).toBe(options.abr);
+    });
+    it('exposes the shared adController without owning it', () => {
+        const factoryCreator = createHlsFactories(null);
+        // Make the shared controller Disposable: if the track container owned
+        // it, container.dispose() would tear it down. Marking it external must
+        // prevent that. Otherwise a codec-recovery reloadCurrentTrack would
+        // dispose the player-level ad controller.
+        const disposeSpy = createSpy('dispose');
+        hlsFactoryDeps.adController.dispose = disposeSpy;
+        const factories = factoryCreator(hlsFactoryDeps)({
+            uri: 'https://example.com/main.m3u8',
+            type: 'hls',
+            manifestProvider,
+        });
+        const container = createContainer(factories);
+        // The track resolves the same shared player-level controller.
+        expect(container.dependencies.adController).toBe(hlsFactoryDeps.adController);
+        container.dispose();
+        expect(disposeSpy).not.toHaveBeenCalled();
+    });
     it('provides streaming options to createContentStreamFactories', () => {
         const factoryCreator = createHlsFactories({
             streaming: {
@@ -71,6 +104,151 @@ describe('createHlsFactories', () => {
             type: 'hls',
         });
         const deps = createContainer(factories).dependencies;
-        expect(deps.manifestController).toEqual(any(HlsManifestControllerImpl));
+        expect(deps.manifestController).toEqual(any(ManifestControllerImpl));
+    });
+    it('creates a sidecar text track controller and populates from manifest', async () => {
+        const factoryCreator = createHlsFactories(null);
+        const subtitleManifest = {
+            ...mockHlsManifestData,
+            mainPlaylist: {
+                ...mockHlsManifestData.mainPlaylist,
+                alternativeRenditions: [
+                    {
+                        type: 'SUBTITLES',
+                        groupId: 'subs',
+                        name: 'English',
+                        language: 'en',
+                        uri: 'subs/en.vtt',
+                    },
+                ],
+            },
+        };
+        const provider = createSpy('subtitleProvider').and.resolveTo(subtitleManifest);
+        const factories = factoryCreator(hlsFactoryDeps)({
+            uri: 'https://example.com/main.m3u8',
+            type: 'hls',
+            manifestProvider: provider,
+        });
+        const deps = createContainer(factories).dependencies;
+        // Resolve textTrackController first so it subscribes to
+        // manifestTransformed before the manifest promise resolves.
+        const controller = deps.textTrackController;
+        await deps.manifestTransformed.value;
+        await new Promise((r) => setTimeout(r, 0));
+        expect(controller).toBeDefined();
+        expect(controller.textTracks.length).toBe(1);
+        expect(controller.textTracks[0].language).toBe('en');
+    });
+    it('text track controller swallows manifest fetch errors', async () => {
+        const factoryCreator = createHlsFactories(null);
+        const provider = createSpy('failing').and.rejectWith(new Error('manifest down'));
+        const factories = factoryCreator(hlsFactoryDeps)({
+            uri: 'https://example.com/main.m3u8',
+            type: 'hls',
+            manifestProvider: provider,
+        });
+        const deps = createContainer(factories).dependencies;
+        const controller = deps.textTrackController;
+        // Trigger the transform; the promise will reject but the
+        // textTrackController must not throw.
+        await deps.manifestTransformed.value.catch(() => undefined);
+        await new Promise((r) => setTimeout(r, 0));
+        expect(controller.textTracks).toEqual([]);
+    });
+    describe('ad interstitial discovery', () => {
+        function interstitialManifest(overrides = {}) {
+            const media = {
+                ...mockMediaPlaylist,
+                dateRanges: [
+                    {
+                        id: 'ad1',
+                        classId: 'com.apple.hls.interstitial',
+                        startDate: '2024-01-01T00:00:00.000Z',
+                        duration: 5,
+                        clientAttributes: {
+                            'X-ASSET-URI': 'https://ads.example.com/ad.m3u8',
+                        },
+                    },
+                ],
+                ...overrides,
+            };
+            return {
+                ...mockHlsManifestData,
+                getMediaPlaylist: () => Promise.resolve(media),
+            };
+        }
+        it('attaches discovered ad breaks to the media timeline', async () => {
+            const factoryCreator = createHlsFactories(null);
+            const provider = createSpy('adProvider').and.resolveTo(interstitialManifest());
+            const factories = factoryCreator(hlsFactoryDeps)({
+                uri: 'https://example.com/main.m3u8',
+                type: 'hls',
+                manifestProvider: provider,
+            });
+            const deps = createContainer(factories).dependencies;
+            const timeline = await deps.mediaTimeline.value;
+            const adBreaks = await timeline.getAdBreaks();
+            expect(adBreaks.length).toBe(1);
+            expect(adBreaks[0].id).toBe('ad1');
+        });
+        it('omits ad breaks when the playlist has none', async () => {
+            const factoryCreator = createHlsFactories(null);
+            const factories = factoryCreator(hlsFactoryDeps)({
+                uri: 'https://example.com/main.m3u8',
+                type: 'hls',
+                manifestProvider,
+            });
+            const deps = createContainer(factories).dependencies;
+            const timeline = await deps.mediaTimeline.value;
+            expect(await timeline.getAdBreaks()).toEqual([]);
+        });
+        it('discovers ads against a live (non-ended) playlist', async () => {
+            const factoryCreator = createHlsFactories(null);
+            const provider = createSpy('liveProvider').and.resolveTo(interstitialManifest({ ended: false }));
+            const factories = factoryCreator(hlsFactoryDeps)({
+                uri: 'https://example.com/main.m3u8',
+                type: 'hls',
+                manifestProvider: provider,
+            });
+            const deps = createContainer(factories).dependencies;
+            const timeline = await deps.mediaTimeline.value;
+            expect((await timeline.getAdBreaks()).length).toBe(1);
+        });
+        it('returns no ad breaks when there are no variants', async () => {
+            const factoryCreator = createHlsFactories(null);
+            const provider = createSpy('noVariants').and.resolveTo({
+                ...mockHlsManifestData,
+                mainPlaylist: {
+                    ...mockHlsManifestData.mainPlaylist,
+                    variants: [],
+                },
+            });
+            const factories = factoryCreator(hlsFactoryDeps)({
+                uri: 'https://example.com/main.m3u8',
+                type: 'hls',
+                manifestProvider: provider,
+            });
+            const deps = createContainer(factories).dependencies;
+            const timeline = await deps.mediaTimeline.value;
+            expect(await timeline.getAdBreaks()).toEqual([]);
+        });
+        it('surfaces media playlist fetch errors from getAdBreaks', async () => {
+            const factoryCreator = createHlsFactories(null);
+            const provider = createSpy('throwingMedia').and.resolveTo({
+                ...mockHlsManifestData,
+                getMediaPlaylist: () => Promise.reject(new Error('media down')),
+            });
+            const factories = factoryCreator(hlsFactoryDeps)({
+                uri: 'https://example.com/main.m3u8',
+                type: 'hls',
+                manifestProvider: provider,
+            });
+            const deps = createContainer(factories).dependencies;
+            const timeline = await deps.mediaTimeline.value;
+            // Discovery is now lazy: getAdBreaks() rejects on a failed media
+            // playlist fetch, leaving error handling to the caller (e.g.
+            // MseTrack swallows it via its errorHandler).
+            await expectAsync(timeline.getAdBreaks()).toBeRejectedWithError('media down');
+        });
     });
 });

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

@@ -113,4 +113,23 @@ describe('fetchMediaPlaylist', () => {
         expect(playlist.segments.length).toBe(1);
         expect(String(mockRequester.request.calls.argsFor(0)[0])).toBe('https://example.com/path/audio.m3u8');
     });
+    it('resolves EXT-X-DEFINE:QUERYPARAM from the playlist URL query string', async () => {
+        mockRequester.request.and.callFake(() => Promise.resolve(new Response([
+            '#EXTM3U',
+            '#EXT-X-TARGETDURATION:6',
+            '#EXT-X-PLAYLIST-TYPE:VOD',
+            '#EXT-X-DEFINE:QUERYPARAM="tok"',
+            '#EXTINF:6.0,',
+            'segment0.aac?t={$tok}',
+            '#EXT-X-ENDLIST',
+        ].join('\n'))));
+        const playlist = await fetchMediaPlaylist({
+            uri: 'audio.m3u8?tok=xyz',
+            baseUrl: 'https://example.com/path/main.m3u8',
+            defines: undefined,
+        });
+        // The QUERYPARAM token from the playlist URL is substituted into the
+        // segment URI (relative resolution happens later, in the timeline).
+        expect(playlist.segments[0].uri).toBe('segment0.aac?t=xyz');
+    });
 });

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

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

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

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

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

@@ -0,0 +1,165 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createTrackLoadOptionsFromUrl, inferTrackTypeFromUrl, inferTrackTypeFromUrlPath, } from '@amazon/vinyl';
+import { requesterWithRetryRef } from '@amazon/vinyl-util';
+import { MockRequester, overrideGlobalInit } from '@amazon/vinyl-util/testUtil';
+describe('inferTrackTypeFromUrlPath', () => {
+    it('returns hls for .m3u8 extension', () => {
+        expect(inferTrackTypeFromUrlPath('https://example.com/stream.m3u8')).toBe('hls');
+    });
+    it('returns hls for .m3u8 with query params', () => {
+        expect(inferTrackTypeFromUrlPath('https://example.com/stream.m3u8?token=abc')).toBe('hls');
+    });
+    it('returns dash for .mpd extension', () => {
+        expect(inferTrackTypeFromUrlPath('https://example.com/manifest.mpd')).toBe('dash');
+    });
+    it('returns dash for .mpd with query params', () => {
+        expect(inferTrackTypeFromUrlPath('https://example.com/manifest.mpd?v=1')).toBe('dash');
+    });
+    it('returns src for common media extensions', () => {
+        expect(inferTrackTypeFromUrlPath('https://example.com/audio.mp3')).toBe('src');
+        expect(inferTrackTypeFromUrlPath('https://example.com/video.mp4')).toBe('src');
+        expect(inferTrackTypeFromUrlPath('https://example.com/audio.aac')).toBe('src');
+        expect(inferTrackTypeFromUrlPath('https://example.com/video.webm')).toBe('src');
+        expect(inferTrackTypeFromUrlPath('https://example.com/audio.ogg')).toBe('src');
+        expect(inferTrackTypeFromUrlPath('https://example.com/audio.wav')).toBe('src');
+        expect(inferTrackTypeFromUrlPath('https://example.com/audio.m4a')).toBe('src');
+        expect(inferTrackTypeFromUrlPath('https://example.com/video.m4v')).toBe('src');
+        expect(inferTrackTypeFromUrlPath('https://example.com/audio.opus')).toBe('src');
+    });
+    it('returns src for media extensions with query params', () => {
+        expect(inferTrackTypeFromUrlPath('https://example.com/video.mp4?quality=high')).toBe('src');
+    });
+    it('returns null for unrecognized URIs', () => {
+        expect(inferTrackTypeFromUrlPath('https://example.com/api/stream')).toBeNull();
+        expect(inferTrackTypeFromUrlPath('https://example.com/data.json')).toBeNull();
+    });
+});
+/**
+ * Builds a minimal `fetch` Response stand-in that satisfies `requestWithRetry`
+ * (which reads `ok`/`status`/`headers` and rejects on non-ok responses).
+ */
+function contentTypeResponse(contentType) {
+    return {
+        ok: true,
+        status: 200,
+        headers: {
+            get: (header) => header === 'content-type' ? contentType : null,
+        },
+    };
+}
+function notFoundResponse() {
+    return {
+        ok: false,
+        status: 404,
+        headers: { get: () => null },
+    };
+}
+describe('inferTrackTypeFromUrl', () => {
+    it('resolves from the extension without a network request', async () => {
+        const origFetch = globalThis.fetch;
+        const fetchSpy = jasmine.createSpy('fetch');
+        globalThis.fetch = fetchSpy;
+        try {
+            expect(await inferTrackTypeFromUrl('https://example.com/a.m3u8')).toBe('hls');
+            expect(fetchSpy).not.toHaveBeenCalled();
+        }
+        finally {
+            globalThis.fetch = origFetch;
+        }
+    });
+    it('falls through to a HEAD probe for extension-less URLs', async () => {
+        const origFetch = globalThis.fetch;
+        const fetchSpy = jasmine
+            .createSpy('fetch')
+            .and.resolveTo(contentTypeResponse('video/mp4'));
+        globalThis.fetch = fetchSpy;
+        try {
+            expect(await inferTrackTypeFromUrl('https://example.com/probe-fallthru')).toBe('src');
+            expect(fetchSpy).toHaveBeenCalledTimes(1);
+            expect(fetchSpy.calls.argsFor(0)[1]).toEqual(jasmine.objectContaining({ method: 'HEAD' }));
+        }
+        finally {
+            globalThis.fetch = origFetch;
+        }
+    });
+});
+describe('probeType (via inferTrackTypeFromUrl)', () => {
+    // Each spec uses a DISTINCT URL because probeType is memoized by URL, so a
+    // shared URL would leak a cached result into later specs.
+    async function probe(url, response) {
+        const origFetch = globalThis.fetch;
+        globalThis.fetch = jasmine.createSpy('fetch').and.resolveTo(response);
+        try {
+            return await inferTrackTypeFromUrl(url);
+        }
+        finally {
+            globalThis.fetch = origFetch;
+        }
+    }
+    it('maps application/dash+xml to dash', async () => {
+        expect(await probe('https://example.com/probe-dash', contentTypeResponse('application/dash+xml'))).toBe('dash');
+    });
+    it('maps an mpegurl content-type to hls', async () => {
+        expect(await probe('https://example.com/probe-hls', contentTypeResponse('application/vnd.apple.mpegurl'))).toBe('hls');
+    });
+    it('maps video/* content-types to src', async () => {
+        expect(await probe('https://example.com/probe-video', contentTypeResponse('video/mp4'))).toBe('src');
+    });
+    it('maps audio/* content-types to src', async () => {
+        expect(await probe('https://example.com/probe-audio', contentTypeResponse('audio/mpeg'))).toBe('src');
+    });
+    it('returns null for an unrecognized content-type', async () => {
+        expect(await probe('https://example.com/probe-unknown', contentTypeResponse('application/json'))).toBeNull();
+    });
+    it('returns null when the content-type header is missing', async () => {
+        expect(await probe('https://example.com/probe-no-content-type', contentTypeResponse(null))).toBeNull();
+    });
+    it('returns null for a non-ok response', async () => {
+        expect(await probe('https://example.com/probe-not-found', notFoundResponse())).toBeNull();
+    });
+    it('returns null when the request throws', async () => {
+        const origFetch = globalThis.fetch;
+        globalThis.fetch = jasmine
+            .createSpy('fetch')
+            .and.rejectWith(new Error('network down'));
+        try {
+            expect(await inferTrackTypeFromUrl('https://example.com/probe-throws')).toBeNull();
+        }
+        finally {
+            globalThis.fetch = origFetch;
+        }
+    });
+});
+describe('probeType (non-ok resolved response)', () => {
+    // The real requester rejects non-ok responses, so it can never resolve one
+    // to probeType. Override it with a mock that resolves a non-ok Response to
+    // exercise probeType's `!res.ok` guard.
+    const mockRequesterRef = overrideGlobalInit(requesterWithRetryRef, () => new MockRequester());
+    it('returns null when the request resolves a non-ok response', async () => {
+        mockRequesterRef.value.request.and.resolveTo(new Response(null, { status: 404 }));
+        expect(await inferTrackTypeFromUrl('https://example.com/probe-resolved-not-ok')).toBeNull();
+    });
+});
+describe('createTrackLoadOptionsFromUrl', () => {
+    it('returns uri and type for a typeable URL', async () => {
+        expect(await createTrackLoadOptionsFromUrl('https://example.com/create.m3u8')).toEqual({ uri: 'https://example.com/create.m3u8', type: 'hls' });
+    });
+    it('returns null for an empty string', async () => {
+        expect(await createTrackLoadOptionsFromUrl('')).toBeNull();
+    });
+    it('returns null for an untypeable URL', async () => {
+        const origFetch = globalThis.fetch;
+        globalThis.fetch = jasmine
+            .createSpy('fetch')
+            .and.resolveTo(contentTypeResponse('application/json'));
+        try {
+            expect(await createTrackLoadOptionsFromUrl('https://example.com/create-untypeable')).toBeNull();
+        }
+        finally {
+            globalThis.fetch = origFetch;
+        }
+    });
+});

package/dist/unit/types/current/track/source/SourceTrack.test.js

@@ -57,6 +57,11 @@ describe('SourceTrack', () => {
             });
         });
     });
+    describe('seekRange', () => {
+        it('returns null by default', () => {
+            expect(track.seekRange).toBeNull();
+        });
+    });
     describe('toString', () => {
         it('contains the uri', () => {
             expect(track.toString()).toContain(track.uri);

package/dist/unit/types/current/track/source/SourceTrackBase.test.js

@@ -40,6 +40,12 @@ describe('SourceTrackBase', () => {
     it('is an instance of BaseTrack', () => {
         expectPrototype(() => createSourceTrack(), SourceTrackBase, TrackBase);
     });
+    it('exposes a null textTrackController by default', () => {
+        expect(track.textTrackController).toBeNull();
+    });
+    it('exposes empty ad breaks by default', async () => {
+        expect(await track.getAds()).toEqual({ trackUri: 'uri', adBreaks: [] });
+    });
     describe('when src promise rejects', () => {
         it('emits an error event', async () => {
             const errorSpy = createEventSpy(track, 'error');
@@ -216,11 +222,14 @@ describe('SourceTrackBase', () => {
             expect(drmController.initializeForPlayback).not.toHaveBeenCalled();
             expect(drmController.setBufferingDrmInfo).not.toHaveBeenCalled();
             track.activate({});
-            expect(drmController.initializeForPlayback).toHaveBeenCalledOnceWith(metadata, any(Abort));
-            expect(drmController.setBufferingDrmInfo).toHaveBeenCalledOnceWith(metadata, any(Abort));
+            expect(drmController.initializeForPlayback).toHaveBeenCalledOnceWith(metadata, {
+                trackUri: 'uri',
+                abort: any(Abort),
+            });
+            expect(drmController.setBufferingDrmInfo).toHaveBeenCalledOnceWith(metadata, { trackUri: 'uri', abort: any(Abort) });
             drmController.setBufferingDrmInfo.calls.reset();
             track.deactivate();
-            expect(drmController.setBufferingDrmInfo).toHaveBeenCalledOnceWith(null, any(Abort));
+            expect(drmController.setBufferingDrmInfo).toHaveBeenCalledOnceWith(null, { trackUri: 'uri', abort: any(Abort) });
         });
     });
     describe('clearPrefetch', () => {
@@ -235,6 +244,18 @@ describe('SourceTrackBase', () => {
             expectNothing();
         });
     });
+    describe('when active and duration changes', () => {
+        it('updates the seek range to span the new duration', () => {
+            track.activate({});
+            const seekRangeChangeSpy = createEventSpy(track, 'seekRangeChange');
+            playbackController.dispatch('durationChange', {
+                previous: 0,
+                current: 120,
+            });
+            expect(track.seekRange).toEqual({ start: 0, end: 120 });
+            expect(seekRangeChangeSpy).toHaveBeenCalledOnceWith(objectContaining({ current: { start: 0, end: 120 } }));
+        });
+    });
     it('returns null for qualities', () => {
         track = createSourceTrack();
         expect(track.qualities).toBeNull();