@amazon/vinyl 1.1.1 → 2.0.0

package/dist/unit/types/current/streaming/mediaTimelineAccessibilityFilter.test.js

@@ -0,0 +1,99 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createAudioDescriptionFilter, createEmptyMediaQualityMetadata, filterTimelineQualities, isAudioDescription, throwNoPlayableAudio, } from '@amazon/vinyl';
+function audioQuality(id, characteristics) {
+    return {
+        metadata: {
+            ...createEmptyMediaQualityMetadata(),
+            qualityId: id,
+            contentType: 'audio',
+            lang: 'en',
+            characteristics,
+        },
+        getSegment: () => Promise.resolve(null),
+    };
+}
+function videoQuality() {
+    return {
+        metadata: {
+            ...createEmptyMediaQualityMetadata(),
+            qualityId: 'video',
+            contentType: 'video',
+        },
+        getSegment: () => Promise.resolve(null),
+    };
+}
+function timelineOf(qualities) {
+    return {
+        periods: [{ startTime: 0, endTime: 10, qualities: [...qualities] }],
+        minBufferTime: 2,
+        getAdBreaks: () => Promise.resolve([]),
+        getDuration: () => Promise.resolve(Infinity),
+    };
+}
+/** The audio qualityIds kept after applying the filter. */
+function keptAudio(qualities, preferDescription) {
+    const filtered = filterTimelineQualities(createAudioDescriptionFilter(preferDescription), throwNoPlayableAudio, timelineOf(qualities));
+    return filtered.periods[0].qualities
+        .filter((q) => q.metadata.contentType === 'audio')
+        .map((q) => q.metadata.qualityId);
+}
+const DVS = 'public.accessibility.describes-video';
+describe('throwNoPlayableAudio', () => {
+    it('throws (defensive guard — the filter never strands audio)', () => {
+        expect(() => throwNoPlayableAudio()).toThrowError(/No playable audio rendition/);
+    });
+});
+describe('isAudioDescription', () => {
+    it('detects the HLS describes-video characteristic', () => {
+        expect(isAudioDescription({
+            ...createEmptyMediaQualityMetadata(),
+            characteristics: [DVS],
+        })).toBeTrue();
+    });
+    it('detects the DASH description role', () => {
+        expect(isAudioDescription({
+            ...createEmptyMediaQualityMetadata(),
+            characteristics: ['description'],
+        })).toBeTrue();
+    });
+    it('is false for a plain rendition', () => {
+        expect(isAudioDescription(createEmptyMediaQualityMetadata())).toBeFalse();
+    });
+});
+describe('createAudioDescriptionFilter', () => {
+    it('drops the description track when a main alternative exists (default)', () => {
+        const kept = keptAudio([
+            audioQuality('dvs', [DVS]),
+            audioQuality('main', []),
+            videoQuality(),
+        ], false);
+        expect(kept).toEqual(['main']);
+    });
+    it('keeps the description track when it is the only audio (never strands)', () => {
+        const kept = keptAudio([audioQuality('dvs', [DVS]), videoQuality()], false);
+        expect(kept).toEqual(['dvs']);
+    });
+    it('keeps only the description track when opted in', () => {
+        const kept = keptAudio([
+            audioQuality('dvs', [DVS]),
+            audioQuality('main', []),
+            videoQuality(),
+        ], true);
+        expect(kept).toEqual(['dvs']);
+    });
+    it('keeps all audio when opted in but no description exists', () => {
+        const kept = keptAudio([audioQuality('a', []), audioQuality('b', []), videoQuality()], true);
+        expect(kept).toEqual(['a', 'b']);
+    });
+    it('leaves non-audio qualities untouched', () => {
+        const filtered = filterTimelineQualities(createAudioDescriptionFilter(false), throwNoPlayableAudio, timelineOf([
+            audioQuality('dvs', [DVS]),
+            audioQuality('main', []),
+            videoQuality(),
+        ]));
+        expect(filtered.periods[0].qualities.some((q) => q.metadata.contentType === 'video')).toBeTrue();
+    });
+});

package/dist/unit/types/current/streaming/mediaTimelineFilter.test.js

@@ -27,7 +27,16 @@ describe('filterTimelineQualities', () => {
             },
         ],
         minBufferTime: 2,
+        getAdBreaks: () => Promise.resolve([]),
+        getDuration: () => Promise.resolve(Infinity),
     };
+    it('returns the timeline unchanged when the filter is null', () => {
+        // A null predicate (e.g. no language preference) is a no-op.
+        const result = filterTimelineQualities(null, () => {
+            throw new Error('empty');
+        }, timeline);
+        expect(result).toBe(timeline);
+    });
     it('filters qualities by predicate', () => {
         const result = filterTimelineQualities((q) => q.contentType === 'audio', () => {
             throw new Error('empty');
@@ -60,6 +69,8 @@ describe('filterTimelineQualitiesAsync', () => {
             },
         ],
         minBufferTime: 2,
+        getAdBreaks: () => Promise.resolve([]),
+        getDuration: () => Promise.resolve(Infinity),
     };
     it('filters qualities by async predicate', async () => {
         const result = await filterTimelineQualitiesAsync((q) => Promise.resolve(q.contentType === 'audio'), () => {

package/dist/unit/types/current/streaming/mediaTimelineLanguageFilter.test.js

@@ -2,7 +2,7 @@
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { createEmptyMediaQualityMetadata, createLanguageFilter, filterTimelineQualities, } from '@amazon/vinyl';
+import { createEmptyMediaQualityMetadata, createLanguageFilter, filterTimelineQualities, resolvePreferredLanguages, } from '@amazon/vinyl';
 import { throwLanguagesUnsupported } from '@amazon/vinyl';
 function createQuality(contentType, lang) {
     return {
@@ -14,15 +14,56 @@ function createQuality(contentType, lang) {
         getSegment: () => Promise.resolve(null),
     };
 }
+/** A single-period timeline of audio qualities (one per lang) plus a video. */
+function audioTimeline(langs) {
+    return {
+        periods: [
+            {
+                startTime: 0,
+                endTime: 10,
+                qualities: [
+                    ...langs.map((l) => createQuality('audio', l)),
+                    createQuality('video', null),
+                ],
+            },
+        ],
+        minBufferTime: 2,
+        getAdBreaks: () => Promise.resolve([]),
+        getDuration: () => Promise.resolve(Infinity),
+    };
+}
+/** The audio languages kept after filtering `timeline` with `preferred`. */
+function keptAudioLangs(timeline, preferred) {
+    return applyLanguageFilter(timeline, preferred, 'audio')
+        .periods[0].qualities.filter((q) => q.metadata.contentType === 'audio')
+        .map((q) => q.metadata.lang);
+}
 function applyLanguageFilter(timeline, preferredLanguage, contentType) {
     const filter = createLanguageFilter(preferredLanguage, contentType);
     if (!filter)
         return timeline;
     return filterTimelineQualities(filter, throwLanguagesUnsupported, timeline);
 }
+/** Temporarily overrides globalThis.navigator for the duration of `fn`. */
+function withNavigator(nav, fn) {
+    const original = Object.getOwnPropertyDescriptor(globalThis, 'navigator');
+    Object.defineProperty(globalThis, 'navigator', {
+        value: nav,
+        configurable: true,
+    });
+    try {
+        fn();
+    }
+    finally {
+        if (original)
+            Object.defineProperty(globalThis, 'navigator', original);
+        else
+            delete globalThis.navigator;
+    }
+}
 describe('createLanguageFilter', () => {
-    it('returns null when preferredLanguage is null', () => {
-        expect(createLanguageFilter(null, 'audio')).toBeNull();
+    it('returns null for an empty preference list', () => {
+        expect(createLanguageFilter([], 'audio')).toBeNull();
     });
     it('returns a filter predicate when preferredLanguage is set', () => {
         expect(createLanguageFilter('en', 'audio')).toEqual(jasmine.any(Function));
@@ -41,6 +82,8 @@ describe('createLanguageFilter', () => {
                 },
             ],
             minBufferTime: 2,
+            getAdBreaks: () => Promise.resolve([]),
+            getDuration: () => Promise.resolve(Infinity),
         };
         const result = applyLanguageFilter(timeline, 'en', 'audio');
         expect(result.periods[0].qualities.length).toBe(2); // en audio + video
@@ -59,6 +102,8 @@ describe('createLanguageFilter', () => {
                 },
             ],
             minBufferTime: 2,
+            getAdBreaks: () => Promise.resolve([]),
+            getDuration: () => Promise.resolve(Infinity),
         };
         const result = applyLanguageFilter(timeline, 'en', 'audio');
         expect(result.periods[0].qualities.length).toBe(2); // en + null
@@ -73,6 +118,8 @@ describe('createLanguageFilter', () => {
                 },
             ],
             minBufferTime: 5,
+            getAdBreaks: () => Promise.resolve([]),
+            getDuration: () => Promise.resolve(Infinity),
         };
         const result = applyLanguageFilter(timeline, 'en', 'audio');
         expect(result.minBufferTime).toBe(5);
@@ -91,6 +138,8 @@ describe('createLanguageFilter', () => {
                 },
             ],
             minBufferTime: 2,
+            getAdBreaks: () => Promise.resolve([]),
+            getDuration: () => Promise.resolve(Infinity),
         };
         const result = applyLanguageFilter(timeline, 'en', 'audio');
         expect(result.periods[0].qualities.some((q) => q.metadata.contentType === 'video')).toBeTrue();
@@ -105,6 +154,8 @@ describe('createLanguageFilter', () => {
                 },
             ],
             minBufferTime: 2,
+            getAdBreaks: () => Promise.resolve([]),
+            getDuration: () => Promise.resolve(Infinity),
         };
         // 'xx' doesn't match 'ja', so all kept
         const result = applyLanguageFilter(timeline, 'xx', 'audio');
@@ -131,6 +182,8 @@ describe('createLanguageFilter', () => {
                 },
             ],
             minBufferTime: 2,
+            getAdBreaks: () => Promise.resolve([]),
+            getDuration: () => Promise.resolve(Infinity),
         };
         // 'en' matches period 1 but not period 2
         // Period 1: filtered to 'en' only
@@ -161,6 +214,8 @@ describe('createLanguageFilter', () => {
                 },
             ],
             minBufferTime: 2,
+            getAdBreaks: () => Promise.resolve([]),
+            getDuration: () => Promise.resolve(Infinity),
         };
         const result = applyLanguageFilter(timeline, 'en', 'audio');
         // Period 1: filtered to 'en'
@@ -168,4 +223,45 @@ describe('createLanguageFilter', () => {
         // Period 2: no audio qualities have lang, all kept
         expect(result.periods[1].qualities.length).toBe(2);
     });
+    it('prefers the first matching language in an ordered list', () => {
+        const timeline = audioTimeline(['en', 'ja', 'fr']);
+        expect(keptAudioLangs(timeline, ['ja', 'en'])).toEqual(['ja']);
+        expect(keptAudioLangs(timeline, ['en', 'ja'])).toEqual(['en']);
+    });
+    it('falls through to a later preference when earlier ones are absent', () => {
+        const timeline = audioTimeline(['en', 'ja']);
+        expect(keptAudioLangs(timeline, ['ko', 'ja', 'en'])).toEqual(['ja']);
+    });
+    it('orders by navigator.languages when the preference is null', () => {
+        withNavigator({ languages: ['ja-JP', 'en-US'] }, () => {
+            const timeline = audioTimeline(['en', 'ja']);
+            expect(keptAudioLangs(timeline, null)).toEqual(['ja']);
+        });
+    });
+    it('returns null when null and navigator is unavailable', () => {
+        withNavigator(undefined, () => {
+            expect(createLanguageFilter(null, 'audio')).toBeNull();
+        });
+    });
+});
+describe('resolvePreferredLanguages', () => {
+    it('wraps a single string in a one-element list', () => {
+        expect(resolvePreferredLanguages('en')).toEqual(['en']);
+    });
+    it('returns an array preference as-is (already ordered)', () => {
+        expect(resolvePreferredLanguages(['ja', 'en'])).toEqual(['ja', 'en']);
+    });
+    it('falls back to navigator.languages when null', () => {
+        withNavigator({ languages: ['ja-JP', 'en-US'] }, () => {
+            expect(resolvePreferredLanguages(null)).toEqual(['ja-JP', 'en-US']);
+        });
+    });
+    it('returns an empty list when null and navigator is unavailable', () => {
+        withNavigator(undefined, () => {
+            expect(resolvePreferredLanguages(null)).toEqual([]);
+        });
+    });
+    it('returns an empty list for an empty array', () => {
+        expect(resolvePreferredLanguages([])).toEqual([]);
+    });
 });

package/dist/unit/types/current/text/SidecarTextTrackController.test.d.ts

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

package/dist/unit/types/current/text/SidecarTextTrackController.test.d.ts.map

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