@amazon/vinyl 1.2.0 → 1.2.2

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

@@ -207,6 +207,21 @@ describe('MseTrack', () => {
             expect(deps.playbackSource.load).toHaveBeenCalledOnceWith();
             expect(deps.playbackController.pause).toHaveBeenCalledOnceWith();
         });
+        it('aborts the drm session abort so key sessions close', async () => {
+            // Regression: MSE key sessions must be tied to the per-activation
+            // drmSessionAbort (fired by closeDrmSessions on deactivate), not a
+            // separate abort that never fires — otherwise sessions leak.
+            track = createTrack();
+            await awaitContentTypes();
+            getAudioStream().streamingQuality =
+                createEmptyMediaQualityMetadata();
+            track.activate({});
+            const abort = deps.drmController.initializeForPlayback.calls.mostRecent()
+                .args[1];
+            expect(abort.aborted()).toBeFalse();
+            track.deactivate();
+            expect(abort.aborted()).toBeTrue();
+        });
     });
     describe('error', () => {
         it('returns the first emitted error', async () => {

package/dist/unit/types/current/streaming/buffering/codecDenylist.test.d.ts

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

package/dist/unit/types/current/streaming/buffering/codecDenylist.test.d.ts.map

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

package/dist/unit/types/current/streaming/buffering/codecDenylist.test.js

@@ -0,0 +1,56 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { clearCodecDenylist, denylistCodecsFromMimeType, getDenylistedCodecs, isMimeTypeDenylisted, } from '@amazon/vinyl';
+describe('codecDenylist', () => {
+    afterEach(() => {
+        clearCodecDenylist();
+    });
+    describe('denylistCodecsFromMimeType', () => {
+        it('adds codecs and returns true on first denylist', () => {
+            expect(denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"')).toBeTrue();
+            expect(getDenylistedCodecs()).toContain('hvc1.1');
+        });
+        it('returns false when all codecs are already denylisted', () => {
+            denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"');
+            expect(denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"')).toBeFalse();
+        });
+        it('returns true when at least one codec is newly added', () => {
+            denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"');
+            expect(denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1,ec-3"')).toBeTrue();
+        });
+        it('returns false for a mimeType with no codecs', () => {
+            expect(denylistCodecsFromMimeType('video/mp4')).toBeFalse();
+        });
+        it('stores codecs lowercased', () => {
+            denylistCodecsFromMimeType('video/mp4; codecs="HVC1.1"');
+            expect(getDenylistedCodecs()).toContain('hvc1.1');
+        });
+    });
+    describe('isMimeTypeDenylisted', () => {
+        it('returns true when a codec is denylisted', () => {
+            denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"');
+            expect(isMimeTypeDenylisted('video/mp4; codecs="hvc1.1"')).toBeTrue();
+        });
+        it('is case-insensitive', () => {
+            denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"');
+            expect(isMimeTypeDenylisted('video/mp4; codecs="HVC1.1"')).toBeTrue();
+        });
+        it('returns false when no codec is denylisted', () => {
+            denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"');
+            expect(isMimeTypeDenylisted('video/mp4; codecs="avc1.64001f"')).toBeFalse();
+        });
+        it('returns false for a mimeType with no codecs', () => {
+            denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"');
+            expect(isMimeTypeDenylisted('video/mp4')).toBeFalse();
+        });
+    });
+    describe('clearCodecDenylist', () => {
+        it('empties the denylist', () => {
+            denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"');
+            clearCodecDenylist();
+            expect(getDenylistedCodecs()).toEqual([]);
+        });
+    });
+});

package/dist/unit/types/current/streaming/createAllowedContentTypesValue.test.d.ts

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

package/dist/unit/types/current/streaming/createAllowedContentTypesValue.test.d.ts.map

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

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

@@ -0,0 +1,77 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createAllowedContentTypesValue, } from '@amazon/vinyl';
+import { data } from '@amazon/vinyl-observable';
+describe('createAllowedContentTypesValue', () => {
+    let baseContentTypesValue;
+    let options;
+    beforeEach(() => {
+        baseContentTypesValue = data(Promise.resolve(new Set(['audio', 'video', 'text'])));
+        options = data({ allowedContentTypes: null });
+    });
+    it('passes all content types through when the allow list is null', async () => {
+        const result = await createAllowedContentTypesValue({
+            baseContentTypesValue,
+            options,
+        }).value;
+        expect(result).toEqual(new Set(['audio', 'video', 'text']));
+    });
+    it('keeps only the allowed media content types', async () => {
+        options.value = { allowedContentTypes: ['audio'] };
+        const result = await createAllowedContentTypesValue({
+            baseContentTypesValue,
+            options,
+        }).value;
+        // Text always passes through; video is dropped.
+        expect(result).toEqual(new Set(['audio', 'text']));
+    });
+    it('always keeps text even when only video is allowed', async () => {
+        options.value = { allowedContentTypes: ['video'] };
+        const result = await createAllowedContentTypesValue({
+            baseContentTypesValue,
+            options,
+        }).value;
+        expect(result).toEqual(new Set(['video', 'text']));
+    });
+    it('keeps text even when the allow list is empty', async () => {
+        options.value = { allowedContentTypes: [] };
+        const result = await createAllowedContentTypesValue({
+            baseContentTypesValue,
+            options,
+        }).value;
+        expect(result).toEqual(new Set(['text']));
+    });
+    it('ignores allowed types not present in the manifest', async () => {
+        baseContentTypesValue.value = Promise.resolve(new Set(['audio']));
+        options.value = { allowedContentTypes: ['audio', 'video'] };
+        const result = await createAllowedContentTypesValue({
+            baseContentTypesValue,
+            options,
+        }).value;
+        expect(result).toEqual(new Set(['audio']));
+    });
+    it('re-emits a newly filtered set when the allow list changes', async () => {
+        const value = createAllowedContentTypesValue({
+            baseContentTypesValue,
+            options,
+        });
+        const emissions = [];
+        const unsub = value.onData((promise) => {
+            void promise.then((set) => emissions.push(set));
+        });
+        // Changing the allow list should produce a new, filtered emission,
+        // which is what drives the track to reload with only these types.
+        options.value = { allowedContentTypes: ['audio'] };
+        expect(await value.value).toEqual(new Set(['audio', 'text']));
+        unsub();
+        // Wait for all pending promise callbacks to resolve.
+        await Promise.resolve();
+        await Promise.resolve();
+        expect(emissions).toEqual([
+            new Set(['audio', 'video', 'text']),
+            new Set(['audio', 'text']),
+        ]);
+    });
+});

package/dist/unit/types/current/streaming/createTimelineContentTypesValue.test.d.ts

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

package/dist/unit/types/current/streaming/createTimelineContentTypesValue.test.d.ts.map

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

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

@@ -0,0 +1,57 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createEmptyMediaQualityMetadata, createTimelineContentTypesValue, } from '@amazon/vinyl';
+import { data } from '@amazon/vinyl-observable';
+function createQuality(contentType) {
+    return {
+        metadata: {
+            ...createEmptyMediaQualityMetadata(),
+            contentType,
+        },
+        getSegment: () => Promise.resolve(null),
+    };
+}
+function timelineOf(...contentTypes) {
+    return {
+        periods: contentTypes.map((types, index) => ({
+            startTime: index * 10,
+            endTime: index * 10 + 10,
+            qualities: types.map(createQuality),
+        })),
+        minBufferTime: 2,
+        getAdBreaks: () => Promise.resolve([]),
+        getDuration: () => Promise.resolve(Infinity),
+    };
+}
+describe('createTimelineContentTypesValue', () => {
+    function contentTypesOf(timeline) {
+        return createTimelineContentTypesValue({
+            mediaTimelineTransformed: data(Promise.resolve(timeline)),
+        }).value;
+    }
+    it('reports every media content type present in the filtered timeline', async () => {
+        const result = await contentTypesOf(timelineOf(['audio', 'audio', 'video']));
+        expect(result).toEqual(new Set(['audio', 'video']));
+    });
+    it('omits a content type whose renditions were all filtered out', async () => {
+        // Every audio rendition dropped (e.g. by the sample-rate filter): video
+        // must still be reported so the load is not stranded waiting for an
+        // audio source buffer that will never be created.
+        const result = await contentTypesOf(timelineOf(['video']));
+        expect(result).toEqual(new Set(['video']));
+    });
+    it('reports only audio when every video rendition was filtered out', async () => {
+        const result = await contentTypesOf(timelineOf(['audio']));
+        expect(result).toEqual(new Set(['audio']));
+    });
+    it('excludes text — captions are a sidecar pipeline, not an MSE source buffer', async () => {
+        const result = await contentTypesOf(timelineOf(['audio', 'video', 'text']));
+        expect(result).toEqual(new Set(['audio', 'video']));
+    });
+    it('unions content types across periods', async () => {
+        const result = await contentTypesOf(timelineOf(['video'], ['audio', 'video']));
+        expect(result).toEqual(new Set(['audio', 'video']));
+    });
+});

package/dist/unit/types/current/streaming/mediaTimelineAccessibilityFilter.test.d.ts

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

package/dist/unit/types/current/streaming/mediaTimelineAccessibilityFilter.test.d.ts.map

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

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/text/HtmlTextTrackRenderer.test.d.ts

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

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

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

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

@@ -0,0 +1,231 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { computeCueLayout, renderCueText, HtmlTextTrackRenderer, } from '@amazon/vinyl';
+describe('computeCueLayout', () => {
+    it('flows a cue with no line/position (defaults: center, full width)', () => {
+        expect(computeCueLayout({})).toEqual({
+            textAlign: 'center',
+            maxWidth: '100%',
+        });
+    });
+    it('maps align and size', () => {
+        const layout = computeCueLayout({ align: 'start', size: 80 });
+        expect(layout.textAlign).toBe('start');
+        expect(layout.maxWidth).toBe('80%');
+    });
+    it('maps vertical writing modes', () => {
+        expect(computeCueLayout({ vertical: 'rl' }).writingMode).toBe('vertical-rl');
+        expect(computeCueLayout({ vertical: 'lr' }).writingMode).toBe('vertical-lr');
+    });
+    it('centers horizontally and bottom-anchors when only a line is set', () => {
+        // line 40% (snapToLines false), default lineAlign → top:40%.
+        const layout = computeCueLayout({ line: 40, snapToLines: false });
+        expect(layout.position).toBe('absolute');
+        expect(layout.left).toBe('50%');
+        expect(layout.top).toBe('40%');
+        expect(layout.transform).toBe('translateX(-50%)');
+    });
+    it('percentage line honors lineAlign end and center', () => {
+        expect(computeCueLayout({ line: 20, snapToLines: false, lineAlign: 'end' })
+            .bottom).toBe('80%');
+        const center = computeCueLayout({
+            line: 30,
+            snapToLines: false,
+            lineAlign: 'center',
+        });
+        expect(center.top).toBe('30%');
+        expect(center.transform).toContain('translateY(-50%)');
+    });
+    it('snap-to-lines integer line: negative counts up from the bottom', () => {
+        expect(computeCueLayout({ line: -3, snapToLines: true }).bottom).toBe('3em');
+        expect(computeCueLayout({ line: 2, snapToLines: true }).top).toBe('3em');
+    });
+    it('positions horizontally by positionAlign', () => {
+        expect(computeCueLayout({ position: 20, positionAlign: 'line-left' }).left).toBe('20%');
+        expect(computeCueLayout({ position: 20, positionAlign: 'line-right' })
+            .right).toBe('80%');
+        const center = computeCueLayout({
+            position: 30,
+            positionAlign: 'center',
+        });
+        expect(center.left).toBe('30%');
+        expect(center.transform).toBe('translateX(-50%)');
+    });
+    it('a position without a line bottom-anchors', () => {
+        expect(computeCueLayout({ position: 10 }).bottom).toBe('0');
+    });
+});
+describe('renderCueText', () => {
+    it('escapes plain text and turns newlines into <br>', () => {
+        expect(renderCueText('a & b\nc')).toBe('a &amp; b<br>c');
+    });
+    it('escapes a stray < that is not a tag', () => {
+        expect(renderCueText('a < b')).toBe('a &lt; b');
+    });
+    it('converts <c.class> to a styled span', () => {
+        expect(renderCueText('<c.styledotitalic>hi</c>')).toBe('<span class="styledotitalic">hi</span>');
+    });
+    it('joins multiple cue classes', () => {
+        expect(renderCueText('<c.a.b>x</c>')).toBe('<span class="a b">x</span>');
+    });
+    it('passes through i/b/u tags', () => {
+        expect(renderCueText('<i>x</i><b>y</b><u>z</u>')).toBe('<i>x</i><b>y</b><u>z</u>');
+    });
+    it('maps voice and lang tags to spans with attributes', () => {
+        expect(renderCueText('<v Bob>hi</v>')).toBe('<span title="Bob">hi</span>');
+        expect(renderCueText('<lang en>x</lang>')).toBe('<span lang="en">x</span>');
+    });
+    it('renders voice/lang without an annotation as a bare span', () => {
+        expect(renderCueText('<v>hi</v>')).toBe('<span>hi</span>');
+        expect(renderCueText('<lang>x</lang>')).toBe('<span>x</span>');
+    });
+    it('escapes annotation values', () => {
+        expect(renderCueText('<v a"b>x</v>')).toBe('<span title="a&quot;b">x</span>');
+    });
+    it('drops timestamp tags and unknown tags', () => {
+        expect(renderCueText('<00:00:01.000>a')).toBe('a');
+        expect(renderCueText('<xyz>a</xyz>')).toBe('a');
+    });
+});
+describe('HtmlTextTrackRenderer', () => {
+    function fakeElement() {
+        return {
+            style: {},
+            className: '',
+            innerHTML: '',
+            textContent: '',
+            children: [],
+            appendChild(node) {
+                this.children.push(node);
+            },
+            replaceChildren(...nodes) {
+                this.children = nodes;
+            },
+        };
+    }
+    // Reads children as an array so it works with both the Node fake (a plain
+    // array) and a real browser (a live HTMLCollection).
+    function domChildren() {
+        return Array.from(container.children);
+    }
+    /** The rendered cue boxes (excluding the internal <style> element). */
+    function cueBoxes() {
+        return domChildren().filter((c) => c.className === 'vinyl-text-cue');
+    }
+    /** The internal <style> element (always the first child). */
+    function styleElement() {
+        return domChildren()[0];
+    }
+    class FakeTextTrack {
+        activeCues = [];
+        listeners = new Map();
+        addEventListener = jasmine
+            .createSpy('addEventListener')
+            .and.callFake((type, fn) => this.listeners.set(type, fn));
+        removeEventListener = jasmine
+            .createSpy('removeEventListener')
+            .and.callFake((type) => this.listeners.delete(type));
+        fireCueChange() {
+            this.listeners.get('cuechange')?.();
+        }
+    }
+    function cue(text, geometry = {}) {
+        return { text, ...geometry };
+    }
+    let view;
+    let container;
+    // In Node there is no DOM, so stub `document`; in a real browser (the integ
+    // bundle) `document` is a read-only global — use it as-is and only fake when
+    // absent.
+    let stubbedDocument = false;
+    beforeEach(() => {
+        if (typeof document === 'undefined') {
+            ;
+            globalThis.document = {
+                createElement: () => fakeElement(),
+            };
+            stubbedDocument = true;
+        }
+        view = new HtmlTextTrackRenderer();
+        container = view.element;
+    });
+    afterEach(() => {
+        view.dispose();
+        if (stubbedDocument) {
+            delete globalThis.document;
+            stubbedDocument = false;
+        }
+    });
+    it('creates a positioned overlay container', () => {
+        expect(container.className).toBe('vinyl-text-container');
+        expect(container.style.justifyContent).toBe('flex-end');
+        expect(container.style.pointerEvents).toBe('none');
+    });
+    it('renders the active cues, escaping text and applying layout', () => {
+        const track = new FakeTextTrack();
+        track.activeCues = [cue('hi\nthere', { align: 'start' })];
+        view.setTextTrack(track);
+        expect(track.addEventListener).toHaveBeenCalledWith('cuechange', jasmine.any(Function));
+        const boxes = cueBoxes();
+        expect(boxes.length).toBe(1);
+        expect(boxes[0].innerHTML).toBe('hi<br>there');
+        expect(boxes[0].style.textAlign).toBe('start');
+    });
+    it('re-renders on cuechange', () => {
+        const track = new FakeTextTrack();
+        track.activeCues = [];
+        view.setTextTrack(track);
+        expect(cueBoxes().length).toBe(0);
+        track.activeCues = [cue('now showing')];
+        track.fireCueChange();
+        expect(cueBoxes().length).toBe(1);
+    });
+    it('renders an empty box for a cue with no text', () => {
+        const track = new FakeTextTrack();
+        track.activeCues = [{ align: 'center' }]; // no `text`
+        view.setTextTrack(track);
+        expect(cueBoxes()[0].innerHTML).toBe('');
+    });
+    it('handles a track with null activeCues', () => {
+        const track = new FakeTextTrack();
+        track.activeCues = null;
+        view.setTextTrack(track);
+        expect(cueBoxes().length).toBe(0);
+    });
+    it('is a no-op when set to the same track', () => {
+        const track = new FakeTextTrack();
+        view.setTextTrack(track);
+        view.setTextTrack(track);
+        expect(track.addEventListener).toHaveBeenCalledTimes(1);
+    });
+    it('detaches and clears when set to null', () => {
+        const track = new FakeTextTrack();
+        track.activeCues = [cue('bye')];
+        view.setTextTrack(track);
+        view.setTextTrack(null);
+        expect(track.removeEventListener).toHaveBeenCalledWith('cuechange', jasmine.any(Function));
+        expect(cueBoxes().length).toBe(0);
+    });
+    it('injects authored STYLE rules with ::cue selectors rewritten', () => {
+        view.setStyles([
+            '::cue(.loud) { font-weight: bold }\n::cue { color: red }',
+        ]);
+        const style = styleElement();
+        expect(style.textContent).toBe('.vinyl-text-cue .loud { font-weight: bold }\n.vinyl-text-cue { color: red }');
+    });
+    it('clears authored styles when the track changes', () => {
+        view.setStyles(['::cue { color: red }']);
+        const style = styleElement();
+        expect(style.textContent).not.toBe('');
+        view.setTextTrack(new FakeTextTrack());
+        expect(style.textContent).toBe('');
+    });
+    it('dispose detaches the current track', () => {
+        const track = new FakeTextTrack();
+        view.setTextTrack(track);
+        view.dispose();
+        expect(track.removeEventListener).toHaveBeenCalled();
+    });
+});

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":""}