@amazon/vinyl 3.2.2 → 3.2.3-next.20261001224604

package/dist/unit/types/current/text/discoverDashTextTracks.test.js

@@ -42,6 +42,19 @@ describe('discoverDashTextTracks', () => {
         expect(result.length).toBe(1);
         expect(result[0].language).toBe('es');
     });
+    it('discovers a text AdaptationSet by its Representation mimeType', () => {
+        // DASH allows @mimeType on the Representation instead of the set.
+        const m = manifest(`
+            <AdaptationSet lang="fr">
+              <Representation id="fr-sub" mimeType="text/vtt" bandwidth="100">
+                <BaseURL>fr.vtt</BaseURL>
+              </Representation>
+            </AdaptationSet>`);
+        const result = discoverDashTextTracks(m, baseUrl);
+        expect(result.length).toBe(1);
+        expect(result[0].language).toBe('fr');
+        expect(result[0].uri).toBe('https://example.com/dash/fr.vtt');
+    });
     it('classifies kind=captions when role=caption is set', () => {
         const m = manifest(`
             <AdaptationSet contentType="text" lang="en" mimeType="text/vtt">
@@ -96,6 +109,10 @@ describe('discoverDashTextTracks', () => {
             </AdaptationSet>`);
         expect(discoverDashTextTracks(m, baseUrl)).toEqual([]);
     });
+    it('skips a non-text AdaptationSet with no Representation', () => {
+        const m = manifest(`<AdaptationSet contentType="audio"/>`);
+        expect(discoverDashTextTracks(m, baseUrl)).toEqual([]);
+    });
     it('skips text AdaptationSets carrying segmented codecs (stpp/wvtt)', () => {
         const m = manifest(`
             <AdaptationSet contentType="text" mimeType="application/mp4" codecs="stpp">

package/dist/unit/types/current/text/parseWebVtt.test.js

@@ -382,6 +382,32 @@ hi`;
         expect(cues.length).toBe(1);
         expect(cues[0].text).toBe('hi');
     });
+    it('parses a cue that follows the signature with no blank line', () => {
+        // The header block ends at a timing line as well as at a blank line
+        // (WebVTT file parsing breaks out of the header loop on `-->`), so a
+        // document omitting the blank line still yields its cues.
+        const text = `WEBVTT
+00:00:01.000 --> 00:00:02.000
+hi
+
+00:00:03.000 --> 00:00:04.000
+there`;
+        const cues = parseWebVtt(text).cues;
+        expect(cues.length).toBe(2);
+        expect(cues[0].startTime).toBe(1);
+        expect(cues[0].text).toBe('hi');
+        expect(cues[1].text).toBe('there');
+    });
+    it('keeps header lines as header when a cue follows with no blank line', () => {
+        const text = `WEBVTT
+Kind: captions
+00:00:01.000 --> 00:00:02.000
+hi`;
+        const cues = parseWebVtt(text).cues;
+        expect(cues.length).toBe(1);
+        expect(cues[0].id).toBeNull();
+        expect(cues[0].text).toBe('hi');
+    });
     it('handles trailing identifier without timing line', () => {
         // Identifier with no following timing line - cue is dropped, parser
         // breaks out cleanly without throwing.

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

@@ -597,49 +597,6 @@ describe('TrackControllerImpl', () => {
                 expect(track.clearPrefetch).toHaveBeenCalledTimes(1);
             }
         });
-        it('also clears prefetch on preloaded ad tracks', async () => {
-            pending('REVIEW: the refactor no longer proactively preloads ad tracks ' +
-                'discovered on the current track (ad tracks are created on ' +
-                'adEntered only). Decide: intended removal (delete this spec) ' +
-                'or regression (restore discovery-time ad preloading).');
-            const [main] = createLoadOptionsList(1);
-            trackController.load(main);
-            const track = trackController.activeTrack;
-            const ads = {
-                trackUri: main.uri,
-                adBreaks: [
-                    {
-                        id: 'b1',
-                        startTime: 5,
-                        duration: 10,
-                        placement: 'midroll',
-                        restrict: {},
-                        once: false,
-                        resumeOffset: null,
-                        playoutLimit: null,
-                        resolutionTimeOffset: null,
-                        skipControl: () => null,
-                        ads: () => Promise.resolve([
-                            {
-                                id: 'a1',
-                                startTime: 5,
-                                duration: 10,
-                                uri: 'https://ads/a.m3u8',
-                            },
-                        ]),
-                    },
-                ],
-            };
-            track.ads = ads;
-            track.dispatch('adsChange', { previous: null, current: ads });
-            // Ad resolution runs on microtasks.
-            await Promise.resolve();
-            await Promise.resolve();
-            await Promise.resolve();
-            const adTrack = trackController.getCachedTrack('https://ads/a.m3u8');
-            trackController.clearPrefetch();
-            expect(adTrack.clearPrefetch).toHaveBeenCalled();
-        });
     });
     describe('clearQueue', () => {
         it('clears the queue without unloading the current track', async () => {
@@ -1124,6 +1081,21 @@ describe('TrackControllerImpl', () => {
             expect(adTrack).withContext('midroll ad track warmed').toBeDefined();
             expect(adTrack.preload).toHaveBeenCalled();
         });
+        it('clears prefetch on a preloaded ad track', async () => {
+            const [main] = createLoadOptionsList(1);
+            factoryGivingBreak(main.uri, []); // records created tracks; no preroll
+            trackController.load(main);
+            await flushAds();
+            deps.adController.dispatch('adPreload', {
+                adBreak: midrollBreak('https://ads/mid.m3u8'),
+            });
+            await flushAds();
+            const adTrack = created.get('https://ads/mid.m3u8');
+            // Ad tracks are not in the content cache, so this only holds if
+            // clearPrefetch reaches the per-parent ad track store too.
+            trackController.clearPrefetch();
+            expect(adTrack.clearPrefetch).toHaveBeenCalledTimes(1);
+        });
         it('ignores adPreload when there is no parent track', () => {
             expect(() => deps.adController.dispatch('adPreload', {
                 adBreak: midrollBreak('https://ads/mid.m3u8'),
@@ -1307,23 +1279,6 @@ describe('TrackControllerImpl', () => {
             const track = trackController.activeTrack;
             expect(track.activate).toHaveBeenCalledWith(objectContaining({ startTime: 3 }));
         });
-        it('skips the deferred resume if interrupted before the frame', async () => {
-            pending('REVIEW: content resume on adBreakCompleted is now synchronous ' +
-                '(no deferred/interruptible frame), so this interruption ' +
-                'guard no longer applies. Decide: intended or restore deferral.');
-            const [main] = createLoadOptionsList(1);
-            trackController.load(main);
-            const changeSpy = createEventSpy(trackController, 'trackActivated');
-            deps.adController.dispatch('adBreakCompleted', {
-                adBreak: adBreak('midroll'),
-                resumePosition: 5,
-            });
-            // Interrupt: a new ad becomes current before the deferred resume runs.
-            deps.adController.currentAd = { ...ad, id: 'other' };
-            await clock.tick();
-            // The deferred setQueue was skipped; no track change occurred.
-            expect(changeSpy).not.toHaveBeenCalled();
-        });
         it('advances to the next track after a postroll ad when one exists', async () => {
             const list = createLoadOptionsList(2);
             trackController.load(...list);

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

@@ -542,6 +542,28 @@ describe('buildHlsMediaTimeline', () => {
         expect(initCall[1]?.headers).toEqual(jasmine.objectContaining({ Range: 'bytes=0-499' }));
         fetchSpy.and.callThrough();
     });
+    it('resolves segment and map URIs against the media playlist baseUrl', async () => {
+        const variant = createVariant('v1.m3u8', 128000);
+        const playlist = {
+            ...createMediaPlaylist([10]),
+            // The media playlist was redirected away from the main playlist's
+            // directory.
+            baseUrl: 'https://redirect.example.net/hls/v1.m3u8',
+        };
+        const manifestData = createManifestData([variant], playlist);
+        const fetchSpy = spyOn(globalThis, 'fetch').and.callFake(() => 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);
+        await segment.initData();
+        await segment.data();
+        const urls = fetchSpy.calls.allArgs().map(([input]) => String(input));
+        expect(urls).toEqual([
+            'https://redirect.example.net/hls/init.mp4',
+            'https://redirect.example.net/hls/seg0.m4s',
+        ]);
+        fetchSpy.and.callThrough();
+    });
     it('getDuration throws when no variants', async () => {
         const manifestData = createManifestData([], createMediaPlaylist([]));
         const timeline = buildHlsMediaTimeline(deps, manifestData);

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

@@ -113,6 +113,29 @@ describe('fetchMediaPlaylist', () => {
         expect(playlist.segments.length).toBe(1);
         expect(String(mockRequester.request.calls.argsFor(0)[0])).toBe('https://example.com/path/audio.m3u8');
     });
+    it('sets the baseUrl from the response URL', async () => {
+        mockRequester.request.and.callFake(() => {
+            const resp = new Response(mediaM3u8);
+            Object.defineProperty(resp, 'url', {
+                value: 'https://redirected.com/hls/audio.m3u8',
+            });
+            return Promise.resolve(resp);
+        });
+        const playlist = await fetchMediaPlaylist({
+            uri: 'audio.m3u8',
+            baseUrl: 'https://example.com/path/main.m3u8',
+            defines: undefined,
+        });
+        expect(playlist.baseUrl).toBe('https://redirected.com/hls/audio.m3u8');
+    });
+    it('falls back to the requested URL when the response has no URL', async () => {
+        const playlist = await fetchMediaPlaylist({
+            uri: 'audio.m3u8',
+            baseUrl: 'https://example.com/path/main.m3u8',
+            defines: undefined,
+        });
+        expect(playlist.baseUrl).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',