@amazon/vinyl 1.0.0

package/dist/unit/types/current/playback/PlaybackSourceImpl.test.d.ts

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

package/dist/unit/types/current/playback/PlaybackSourceImpl.test.d.ts.map

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

package/dist/unit/types/current/playback/PlaybackSourceImpl.test.js

@@ -0,0 +1,43 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { PlaybackSourceImpl } from '@amazon/vinyl';
+import { MockHTMLAudioElement, MockMediaStream, } from '@amazon/vinyl-util/browserTestUtil';
+describe('PlaybackSource', () => {
+    it(`directly relies on the media element's functionality`, () => {
+        const media = new MockHTMLAudioElement();
+        const p = new PlaybackSourceImpl({ media });
+        p.crossOrigin = 'use-credentials';
+        expect(media.crossOrigin).toBe('use-credentials');
+        expect(p.crossOrigin).toBe('use-credentials');
+        p.load();
+        expect(media.load).toHaveBeenCalledOnceWith();
+        p.src = 'https://example.com/';
+        expect(media.src).toBe('https://example.com/');
+        expect(p.src).toBe(media.src);
+        expect(p.currentSrc).toBe(media.currentSrc);
+        expect(p.srcObject).toBe(media.srcObject);
+        const src = new MockMediaStream();
+        p.srcObject = src;
+        expect(media.srcObject).toBe(src);
+    });
+    it('deletes src attribute on the element when assigned null', () => {
+        const media = new MockHTMLAudioElement();
+        const p = new PlaybackSourceImpl({ media });
+        p.src = 'https://example.com/test.mp3';
+        expect(media.src).toBe('https://example.com/test.mp3');
+        p.src = null;
+        expect(media.removeAttribute).toHaveBeenCalledOnceWith('src');
+    });
+    describe('disableRemotePlayback', () => {
+        it('delegates to the media element', () => {
+            const media = new MockHTMLAudioElement();
+            const p = new PlaybackSourceImpl({ media });
+            media.disableRemotePlayback = true;
+            expect(p.disableRemotePlayback).toBeTrue();
+            p.disableRemotePlayback = false;
+            expect(p.disableRemotePlayback).toBeFalse();
+        });
+    });
+});

package/dist/unit/types/current/playback/ReadonlyPlaybackController.test.d.ts

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

package/dist/unit/types/current/playback/ReadonlyPlaybackController.test.d.ts.map

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

package/dist/unit/types/current/playback/ReadonlyPlaybackController.test.js

@@ -0,0 +1,10 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { expectTypeStrictlyEquals } from '@amazon/vinyl-util/browserTestUtil';
+describe('ALL_PLAYBACK_STATE_EVENTS', () => {
+    it('provides a comprehensive list of all playback state events', () => {
+        expectTypeStrictlyEquals(true);
+    });
+});

package/dist/unit/types/current/playback/error/InvalidSeekError.test.d.ts

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

package/dist/unit/types/current/playback/error/InvalidSeekError.test.d.ts.map

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

package/dist/unit/types/current/playback/error/InvalidSeekError.test.js

@@ -0,0 +1,38 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { expectPrototype } from '@amazon/vinyl-util/browserTestUtil';
+import { InvalidSeekError } from '@amazon/vinyl';
+import { emptyRanges, ErrorLevel, ErrorOrigin, ReportableError, } from '@amazon/vinyl-util';
+import { rangesOf } from '@amazon/vinyl-util';
+var any = jasmine.any;
+describe('InvalidSeekError', () => {
+    it('is an instance of Error and InvalidSeekError', () => {
+        expectPrototype(() => new InvalidSeekError(1, emptyRanges, 1), InvalidSeekError, ReportableError, Error);
+    });
+    describe('toJSON', () => {
+        it('adds time and seekable ranges', () => {
+            expect(new InvalidSeekError(3, rangesOf([
+                [1, 4],
+                [6, 8],
+            ]), 1).toJSON()).toEqual({
+                name: 'InvalidSeekError',
+                message: 'Could not seek to time: 3, outside of seekable ranges [[1, 4], [6, 8]] with tolerance 1',
+                time: 3,
+                level: ErrorLevel.WARN,
+                origin: ErrorOrigin.API,
+                seekable: [
+                    [1, 4],
+                    [6, 8],
+                ],
+                stack: any(String),
+            });
+        });
+    });
+    describe('toStringTag', () => {
+        it('returns the name', () => {
+            expect(new InvalidSeekError(1, emptyRanges, 1)[Symbol.toStringTag]).toBe('InvalidSeekError');
+        });
+    });
+});

package/dist/unit/types/current/playback/error/ReportableMediaError.test.d.ts

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

package/dist/unit/types/current/playback/error/ReportableMediaError.test.d.ts.map

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

package/dist/unit/types/current/playback/error/ReportableMediaError.test.js

@@ -0,0 +1,64 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ErrorLevel, ErrorOrigin } from '@amazon/vinyl-util';
+import { expectPrototype } from '@amazon/vinyl-util/browserTestUtil';
+import { ReportableMediaError } from '@amazon/vinyl';
+var any = jasmine.any;
+describe('ReportableMediaError', () => {
+    it('is an instance of Error and ReportableMediaError', () => {
+        expectPrototype(() => new ReportableMediaError(null), ReportableMediaError, Error);
+    });
+    describe('constructor', () => {
+        it('handles null MediaError with SILENT level', () => {
+            const error = new ReportableMediaError(null);
+            expect(error.level).toBe(ErrorLevel.SILENT);
+            expect(error.origin).toBe(ErrorOrigin.MEDIA);
+            expect(error.message).toBe('An unknown media error has occurred.');
+            expect(error.reason).toBe('UNKNOWN_MEDIA_ERROR');
+            expect(error.code).toBe(-1);
+        });
+        it('handles MEDIA_ERR_ABORTED with SILENT level', () => {
+            const mediaError = { code: 1, MEDIA_ERR_ABORTED: 1 };
+            const error = new ReportableMediaError(mediaError);
+            expect(error.level).toBe(ErrorLevel.SILENT);
+            expect(error.code).toBe(1);
+            expect(error.reason).toBe('MEDIA_ERR_ABORTED');
+        });
+        it('handles other media errors with FATAL level', () => {
+            const mediaError = { code: 2, MEDIA_ERR_NETWORK: 2 };
+            const error = new ReportableMediaError(mediaError);
+            expect(error.level).toBe(ErrorLevel.FATAL);
+            expect(error.code).toBe(2);
+            expect(error.reason).toBe('MEDIA_ERR_NETWORK');
+        });
+    });
+    describe('toJSON', () => {
+        it('returns a serializable error representation', () => {
+            const error = new ReportableMediaError(null);
+            expect(error.toJSON()).toEqual({
+                name: 'ReportableMediaError',
+                origin: ErrorOrigin.MEDIA,
+                level: ErrorLevel.SILENT,
+                message: 'An unknown media error has occurred.',
+                stack: any(String),
+                reason: 'UNKNOWN_MEDIA_ERROR',
+                code: -1,
+            });
+        });
+    });
+    describe('toStringTag', () => {
+        it('returns the name', () => {
+            expect(new ReportableMediaError(null)[Symbol.toStringTag]).toBe('ReportableMediaError');
+        });
+    });
+    describe('static constants', () => {
+        it('defines media error constants', () => {
+            expect(ReportableMediaError.MEDIA_ERR_ABORTED).toBe(1);
+            expect(ReportableMediaError.MEDIA_ERR_NETWORK).toBe(2);
+            expect(ReportableMediaError.MEDIA_ERR_DECODE).toBe(3);
+            expect(ReportableMediaError.MEDIA_ERR_SRC_NOT_SUPPORTED).toBe(4);
+        });
+    });
+});

package/dist/unit/types/current/playback/logging/mediaErrorToJson.test.d.ts

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

package/dist/unit/types/current/playback/logging/mediaErrorToJson.test.d.ts.map

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

package/dist/unit/types/current/playback/logging/mediaErrorToJson.test.js

@@ -0,0 +1,46 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { mediaErrorToJson } from '@amazon/vinyl';
+import { MockMediaError } from '@amazon/vinyl-util/browserTestUtil';
+describe('mediaErrorToJson', () => {
+    it('produces a serializable format of a MediaError', () => {
+        const error = new MockMediaError();
+        error.code = error.MEDIA_ERR_ABORTED;
+        expect(mediaErrorToJson(error)).toEqual({
+            message: "The requesting of the associated resource was aborted by the user's request.",
+            code: 1,
+            name: 'MEDIA_ERR_ABORTED',
+        });
+        error.code = error.MEDIA_ERR_NETWORK;
+        expect(mediaErrorToJson(error)).toEqual({
+            message: 'A network error occurred.',
+            code: 2,
+            name: 'MEDIA_ERR_NETWORK',
+        });
+        error.code = error.MEDIA_ERR_DECODE;
+        expect(mediaErrorToJson(error)).toEqual({
+            message: 'An error occurred while trying to decode the media resource.',
+            code: 3,
+            name: 'MEDIA_ERR_DECODE',
+        });
+        error.code = error.MEDIA_ERR_SRC_NOT_SUPPORTED;
+        expect(mediaErrorToJson(error)).toEqual({
+            message: 'The associated resource was not supported.',
+            code: 4,
+            name: 'MEDIA_ERR_SRC_NOT_SUPPORTED',
+        });
+        expect(mediaErrorToJson(null)).toEqual({
+            message: 'An unknown media error has occurred.',
+            code: -1,
+            name: 'UNKNOWN_MEDIA_ERROR',
+        });
+        error.code = 5;
+        expect(mediaErrorToJson(error)).toEqual({
+            message: 'An unknown media error has occurred.',
+            code: 5,
+            name: 'UNKNOWN_MEDIA_ERROR',
+        });
+    });
+});

package/dist/unit/types/current/playback/logging/playbackStateLoggingHandler.test.d.ts

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

package/dist/unit/types/current/playback/logging/playbackStateLoggingHandler.test.d.ts.map

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

package/dist/unit/types/current/playback/logging/playbackStateLoggingHandler.test.js

@@ -0,0 +1,83 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { playbackStateLoggingHandler, TIMEUPDATE_THROTTLE } from '@amazon/vinyl';
+import { useMockTime } from '@amazon/vinyl-util/browserTestUtil';
+import { MockPlaybackController } from '@amazon/vinyl/vinylTestUtil';
+import { useMockLogger } from '@amazon/vinyl-util/testUtil';
+var any = jasmine.any;
+describe('playbackStateLoggingHandler', () => {
+    let playback;
+    const clock = useMockTime();
+    async function playbackTick(timeDelta) {
+        playback.currentTime += timeDelta;
+        await clock.tick(timeDelta);
+        playback.dispatch('timeUpdate', {});
+    }
+    const loggerRef = useMockLogger();
+    beforeEach(() => {
+        playback = new MockPlaybackController();
+    });
+    describe('when initialized', () => {
+        let loggingHandler;
+        beforeEach(() => {
+            loggingHandler = playbackStateLoggingHandler(playback);
+        });
+        afterEach(() => {
+            loggingHandler.dispose();
+        });
+        it('records all playback events', () => {
+            const logger = loggerRef.value;
+            playback.dispatch('play', {});
+            expect(logger.debug).toHaveBeenCalledWith(any(Object), 'play', any(Object));
+            logger.debug.calls.reset();
+            playback.dispatch('loadedMetadata', {});
+            expect(logger.debug).toHaveBeenCalledWith(any(Object), 'loadedMetadata', any(Object));
+            logger.debug.calls.reset();
+            playback.dispatch('abort', {});
+            expect(logger.debug).toHaveBeenCalledWith(any(Object), 'abort', any(Object));
+        });
+        describe('when timeUpdate events are emitted', () => {
+            describe('and are uninterrupted and incremental', () => {
+                it('accumulates timeUpdate events up to a defined TIMEUPDATE_THROTTLE limit', async () => {
+                    const logger = loggerRef.value;
+                    logger.debug.calls.reset();
+                    await playbackTick(0);
+                    for (let i = 0; i < 4; i++) {
+                        await playbackTick(TIMEUPDATE_THROTTLE / 5);
+                    }
+                    expect(logger.debug).not.toHaveBeenCalled();
+                    await playbackTick(TIMEUPDATE_THROTTLE / 5);
+                    expect(logger.debug).toHaveBeenCalledWith(any(Object), `timeUpdate 0.0-${TIMEUPDATE_THROTTLE.toFixed(1)} x5`);
+                    logger.debug.calls.reset();
+                });
+            });
+            describe('and are interrupted by another event', () => {
+                it('logs the batch preceding the current timeUpdate', async () => {
+                    const logger = loggerRef.value;
+                    await playbackTick(2.234);
+                    await playbackTick(2.344);
+                    await playbackTick(1.95);
+                    playback.dispatch('seeked', {});
+                    expect(logger.debug).toHaveBeenCalledWith(any(Object), 'seeked', any(Object));
+                    expect(logger.debug).toHaveBeenCalledWith(any(Object), 'timeUpdate 2.2-6.5 x3');
+                });
+            });
+        });
+    });
+    describe('when disposed', () => {
+        it('detaches from events when no longer needed', async () => {
+            const loggingHandler = playbackStateLoggingHandler(playback);
+            const logger = loggerRef.value;
+            logger.debug.calls.reset();
+            loggingHandler.dispose();
+            await playbackTick(2.234); // startTime: 2.234
+            await playbackTick(2.344);
+            await playbackTick(1.95);
+            await clock.tick(100);
+            playback.dispatch('seeked', {});
+            expect(logger.debug).not.toHaveBeenCalled();
+        });
+    });
+});

package/dist/unit/types/current/playback/nextEventHasMetadata.test.d.ts

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

package/dist/unit/types/current/playback/nextEventHasMetadata.test.d.ts.map

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

package/dist/unit/types/current/playback/nextEventHasMetadata.test.js

@@ -0,0 +1,32 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { nextHasMetadata } from '@amazon/vinyl';
+import { MockPlaybackController } from '@amazon/vinyl/vinylTestUtil';
+import { Abort } from '@amazon/vinyl-util';
+describe('nextHasMetadata', () => {
+    let controller;
+    beforeEach(() => {
+        controller = new MockPlaybackController();
+    });
+    it('resolves when the next HAVE_METADATA event is emitted', async () => {
+        const promise = nextHasMetadata(controller);
+        await expectAsync(promise).toBePending();
+        controller.dispatch('loadedMetadata', {});
+        await expectAsync(promise).toBeResolved();
+    });
+    it('fulfills promise if hasMetadata is already set to true', async () => {
+        controller.hasMetadata = false;
+        await expectAsync(nextHasMetadata(controller)).toBePending();
+        controller.hasMetadata = true;
+        await expectAsync(nextHasMetadata(controller)).toBeResolved();
+    });
+    it('accepts optional NextEventAsPromiseOptions', async () => {
+        const abort = new Abort();
+        abort.abort(new Error('reason'));
+        await expectAsync(nextHasMetadata(controller, {
+            abort,
+        })).toBeRejectedWithError('reason');
+    });
+});

package/dist/unit/types/current/setup.d.ts

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

package/dist/unit/types/current/setup.d.ts.map

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

package/dist/unit/types/current/setup.js

@@ -0,0 +1,27 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { getGlobalRegistry, setGlobalRefDebug } from '@amazon/vinyl-util';
+import { addCustomMatchers, ConsoleReporter, flushPromises, } from '@amazon/vinyl-util/browserTestUtil';
+import { RestApiReporter } from '@amazon/vinyl-util/testUtil';
+import { initializeFrequencyAnalyzer } from '@amazon/vinyl/vinylTestUtil';
+addCustomMatchers();
+// Diagnostic: GlobalRefImpl records the stack
+setGlobalRefDebug(true);
+// Configured here instead of the jasmine.config.json to work with both ts-node and the html
+// test runner.
+jasmine.getEnv().configure({
+    stopOnSpecFailure: true,
+    stopSpecOnExpectationFailure: true,
+    failSpecWithNoExpectations: true,
+});
+// Register the reporters
+jasmine.getEnv().addReporter(new ConsoleReporter());
+RestApiReporter.installFromSearchParam();
+// Prompts for user interaction and unlocks the AudioContext if checkAudio is present in the query params.
+initializeFrequencyAnalyzer();
+afterEach(async () => {
+    await flushPromises();
+    getGlobalRegistry().reset();
+});

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

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

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

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

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

@@ -0,0 +1,213 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ContentStreamImpl, createContentStreamFactory, createEmptyMediaQualityMetadata, } from '@amazon/vinyl';
+import { createEventSpy } from '@amazon/vinyl-util/testUtil';
+import { emptyRanges } from '@amazon/vinyl-util';
+import { MockBufferingController, MockSegmentController, } from '@amazon/vinyl/vinylTestUtil';
+describe('ContentStreamImpl', () => {
+    let segmentController;
+    let bufferingController;
+    let contentStream;
+    let deps;
+    const mockQuality = createEmptyMediaQualityMetadata();
+    beforeEach(() => {
+        segmentController = new MockSegmentController();
+        bufferingController = new MockBufferingController();
+        deps = {
+            segmentController: () => segmentController,
+            bufferingController: () => bufferingController,
+        };
+        contentStream = new ContentStreamImpl(deps, 'audio');
+    });
+    afterEach(() => {
+        contentStream.dispose();
+    });
+    describe('constructor', () => {
+        it('creates instance and sets up event redispatching', () => {
+            expect(contentStream).toBeInstanceOf(ContentStreamImpl);
+        });
+        it('redispatches fetchedRangesChange from segmentController', () => {
+            const spy = createEventSpy(contentStream, 'fetchedRangesChange');
+            segmentController.dispatch('fetchedRangesChange', {});
+            expect(spy).toHaveBeenCalledWith({});
+        });
+        it('redispatches streamingQualityChange from segmentController', () => {
+            const spy = createEventSpy(contentStream, 'streamingQualityChange');
+            const event = { current: mockQuality, previous: null };
+            segmentController.dispatch('streamingQualityChange', event);
+            expect(spy).toHaveBeenCalledWith(event);
+        });
+        it('redispatches bufferingQualityChange from bufferingController', () => {
+            const spy = createEventSpy(contentStream, 'bufferingQualityChange');
+            const event = { current: mockQuality, previous: null };
+            bufferingController.dispatch('bufferingQualityChange', event);
+            expect(spy).toHaveBeenCalledWith(event);
+        });
+        it('redispatches playbackQualityChange from bufferingController', () => {
+            const spy = createEventSpy(contentStream, 'playbackQualityChange');
+            const event = { current: mockQuality, previous: null };
+            bufferingController.dispatch('playbackQualityChange', event);
+            expect(spy).toHaveBeenCalledWith(event);
+        });
+        it('redispatches error from bufferingController', () => {
+            const spy = createEventSpy(contentStream, 'error');
+            const error = new Error('test error');
+            const target = { logPrefix: 'test' };
+            bufferingController.dispatch('error', { error, target });
+            expect(spy).toHaveBeenCalledWith({ error, target });
+        });
+    });
+    describe('preload', () => {
+        it('configures segmentController with startTime and prefetchPriority', () => {
+            contentStream.preload({
+                prefetchPriority: 5,
+                startTime: 10,
+            });
+            expect(segmentController.configure).toHaveBeenCalledWith({
+                startTime: 10,
+                trackPrefetchPriority: 5,
+            });
+        });
+        it('uses default startTime of 0 when not provided', () => {
+            contentStream.preload({
+                prefetchPriority: 3,
+            });
+            expect(segmentController.configure).toHaveBeenCalledWith({
+                startTime: 0,
+                trackPrefetchPriority: 3,
+            });
+        });
+    });
+    describe('fetchedRanges', () => {
+        it('returns fetchedRanges from segmentController', () => {
+            const ranges = emptyRanges;
+            segmentController.fetchedRanges = ranges;
+            expect(contentStream.fetchedRanges).toBe(ranges);
+        });
+    });
+    describe('streamingQuality', () => {
+        it('returns streamingQuality from segmentController', () => {
+            segmentController.streamingQuality = mockQuality;
+            expect(contentStream.streamingQuality).toBe(mockQuality);
+        });
+        it('returns null when segmentController streamingQuality is null', () => {
+            segmentController.streamingQuality = null;
+            expect(contentStream.streamingQuality).toBeNull();
+        });
+    });
+    describe('bufferingQuality', () => {
+        it('returns bufferingQuality from bufferingController', () => {
+            bufferingController.bufferingQuality = mockQuality;
+            expect(contentStream.bufferingQuality).toBe(mockQuality);
+        });
+        it('returns null when bufferingController bufferingQuality is null', () => {
+            bufferingController.bufferingQuality = null;
+            expect(contentStream.bufferingQuality).toBeNull();
+        });
+    });
+    describe('playbackQuality', () => {
+        it('returns playbackQuality from bufferingController', () => {
+            bufferingController.playbackQuality = mockQuality;
+            expect(contentStream.playbackQuality).toBe(mockQuality);
+        });
+        it('returns null when bufferingController playbackQuality is null', () => {
+            bufferingController.playbackQuality = null;
+            expect(contentStream.playbackQuality).toBeNull();
+        });
+    });
+    describe('bufferingEnded', () => {
+        it('returns bufferingEnded from bufferingController', () => {
+            bufferingController.bufferingEnded = true;
+            expect(contentStream.bufferingEnded).toBe(true);
+            bufferingController.bufferingEnded = false;
+            expect(contentStream.bufferingEnded).toBe(false);
+        });
+    });
+    describe('error', () => {
+        it('returns error from bufferingController when present', () => {
+            const error = new Error('buffering error');
+            bufferingController.error = error;
+            segmentController.error = null;
+            expect(contentStream.error).toBe(error);
+        });
+        it('returns error from segmentController when bufferingController has no error', () => {
+            const error = new Error('segment error');
+            bufferingController.error = null;
+            segmentController.error = error;
+            expect(contentStream.error).toBe(error);
+        });
+        it('returns bufferingController error when both have errors', () => {
+            const bufferingError = new Error('buffering error');
+            const segmentError = new Error('segment error');
+            bufferingController.error = bufferingError;
+            segmentController.error = segmentError;
+            expect(contentStream.error).toBe(bufferingError);
+        });
+        it('returns null when neither controller has error', () => {
+            bufferingController.error = null;
+            segmentController.error = null;
+            expect(contentStream.error).toBeNull();
+        });
+    });
+    describe('clearPrefetch', () => {
+        it('calls clear on both controllers', () => {
+            contentStream.clearPrefetch();
+            expect(segmentController.clear).toHaveBeenCalled();
+            expect(bufferingController.clear).toHaveBeenCalled();
+        });
+    });
+    describe('reset', () => {
+        it('calls reset on both controllers', () => {
+            contentStream.reset();
+            expect(segmentController.reset).toHaveBeenCalled();
+            expect(bufferingController.reset).toHaveBeenCalled();
+        });
+    });
+    describe('activate', () => {
+        it('configures and activates segmentController, then activates bufferingController', () => {
+            const loadOptions = { startTime: 5 };
+            contentStream.activate(loadOptions);
+            expect(segmentController.configure).toHaveBeenCalledWith({
+                startTime: 5,
+            });
+            expect(segmentController.activate).toHaveBeenCalled();
+            expect(bufferingController.activate).toHaveBeenCalled();
+        });
+        it('uses default startTime of 0 when not provided', () => {
+            const loadOptions = {};
+            contentStream.activate(loadOptions);
+            expect(segmentController.configure).toHaveBeenCalledWith({
+                startTime: 0,
+            });
+        });
+    });
+    describe('deactivate', () => {
+        it('deactivates both controllers', () => {
+            contentStream.deactivate();
+            expect(segmentController.deactivate).toHaveBeenCalled();
+            expect(bufferingController.deactivate).toHaveBeenCalled();
+        });
+    });
+    describe('dispose', () => {
+        it('disposes resources', () => {
+            const testContentStream = new ContentStreamImpl(deps, 'audio');
+            testContentStream.on('reset', () => { });
+            testContentStream.dispose();
+            expect(testContentStream.hasAnyListeners()).toBeFalse();
+            expect(segmentController.dispose).toHaveBeenCalledOnceWith();
+            expect(bufferingController.dispose).toHaveBeenCalledOnceWith();
+        });
+    });
+    describe('createContentStreamFactory', () => {
+        it('creates a ContentStreamFactory', () => {
+            const factory = createContentStreamFactory({
+                createContentStreamFactories: () => deps,
+            });
+            const contentStream = factory('audio');
+            expect(contentStream.contentType).toBe('audio');
+            contentStream.dispose();
+        });
+    });
+});

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

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

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

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