@amazon/vinyl 1.0.0

package/dist/unit/types/current/drm/DrmKeySystem.test.d.ts

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

package/dist/unit/types/current/drm/DrmKeySystem.test.d.ts.map

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

package/dist/unit/types/current/drm/DrmKeySystem.test.js

@@ -0,0 +1,23 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { DrmKeySystem, isFairPlay, isPlayReady } from '@amazon/vinyl';
+describe('isPlayReady', () => {
+    it('returns true if key system is one of PlayReady key systems', () => {
+        expect(isPlayReady(DrmKeySystem.PLAY_READY)).toBeTrue();
+        expect(isPlayReady(DrmKeySystem.PLAY_READY_CHROMECAST)).toBeTrue();
+        expect(isPlayReady(DrmKeySystem.PLAY_READY_RECOMMENDATION)).toBeTrue();
+        expect(isPlayReady(DrmKeySystem.PLAY_READY_3000)).toBeTrue();
+        expect(isPlayReady(DrmKeySystem.WIDEVINE)).toBeFalse();
+        expect(isPlayReady(DrmKeySystem.FAIR_PLAY_1_0)).toBeFalse();
+    });
+});
+describe('isFairPlay', () => {
+    it('returns true if key system is one of FairPlay key systems', () => {
+        expect(isFairPlay(DrmKeySystem.FAIR_PLAY)).toBeTrue();
+        expect(isFairPlay(DrmKeySystem.FAIR_PLAY_1_0)).toBeTrue();
+        expect(isFairPlay(DrmKeySystem.PLAY_READY_3000)).toBeFalse();
+        expect(isFairPlay(DrmKeySystem.WIDEVINE)).toBeFalse();
+    });
+});

package/dist/unit/types/current/drm/DrmKeySystemResolver.test.d.ts

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

package/dist/unit/types/current/drm/DrmKeySystemResolver.test.d.ts.map

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

package/dist/unit/types/current/drm/DrmKeySystemResolver.test.js

@@ -0,0 +1,13 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ContentProtectionScheme } from '@amazon/vinyl-mpd-parser';
+import { defaultDrmKeySystemResolver, DrmKeySystem } from '@amazon/vinyl';
+describe('defaultDrmKeySystemResolver', () => {
+    it('returns the matching DrmKeySystem from the ContentProtection schemeIdUri', () => {
+        expect(defaultDrmKeySystemResolver(ContentProtectionScheme.WIDEVINE)).toEqual([DrmKeySystem.WIDEVINE]);
+        expect(defaultDrmKeySystemResolver(ContentProtectionScheme.FAIR_PLAY)).toEqual([DrmKeySystem.FAIR_PLAY, DrmKeySystem.FAIR_PLAY_1_0]);
+        expect(defaultDrmKeySystemResolver(ContentProtectionScheme.CENC)).toEqual([]);
+    });
+});

package/dist/unit/types/current/drm/commonEme/CommonEme.test.d.ts

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

package/dist/unit/types/current/drm/commonEme/CommonEme.test.d.ts.map

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

package/dist/unit/types/current/drm/commonEme/CommonEme.test.js

@@ -0,0 +1,26 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CommonMediaKeySessionError, MediaKeySessionErrorType, } from '@amazon/vinyl';
+import { ErrorLevel, ErrorOrigin } from '@amazon/vinyl-util';
+var any = jasmine.any;
+describe('CommonEme', () => {
+    describe('CommonMediaKeySessionError', () => {
+        it('returns a serializable error representation', () => {
+            const code = 0;
+            const systemCode = 0;
+            expect(new CommonMediaKeySessionError(code, MediaKeySessionErrorType.CLIENT, systemCode, MediaKeySessionErrorType.CLIENT).toJSON()).toEqual({
+                name: 'CommonMediaKeySessionError',
+                origin: ErrorOrigin.DRM,
+                level: ErrorLevel.WARN,
+                message: MediaKeySessionErrorType.CLIENT,
+                stack: any(String),
+                code,
+                codeStr: MediaKeySessionErrorType.CLIENT,
+                systemCode,
+                systemCodeStr: MediaKeySessionErrorType.CLIENT,
+            });
+        });
+    });
+});

package/dist/unit/types/current/drm/commonEme/MsCommonEme.test.d.ts

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

package/dist/unit/types/current/drm/commonEme/MsCommonEme.test.d.ts.map

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

package/dist/unit/types/current/drm/commonEme/MsCommonEme.test.js

@@ -0,0 +1,249 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { DrmError, DrmKeySystem, MediaKeySessionErrorType, MsCommonEme, MsCommonMediaKeys, MsCommonMediaKeySession, MsCommonMediaKeySystemAccess, msErrorCodeToStr, } from '@amazon/vinyl';
+import { DisposedError, isNode, utf16ToUint16Array } from '@amazon/vinyl-util';
+import { expectTypeEquals, implementEventFakes, MockHTMLAudioElement, mockEvent, } from '@amazon/vinyl-util/browserTestUtil';
+import { MockMSMediaKeyError, MockMSMediaKeyMessageEvent, MockMSMediaKeys, MockMSMediaKeySession, } from '@amazon/vinyl/vinylTestUtil';
+import { createEventSpy } from '@amazon/vinyl-util/testUtil';
+var createSpy = jasmine.createSpy;
+describe('MsCommonEme', () => {
+    beforeEach(() => {
+        if (!isNode()) {
+            pending('Cannot mock MS outside Node');
+            return;
+        }
+        ;
+        global.MSMediaKeys = MockMSMediaKeys;
+        global.MSMediaKeySession = MockMSMediaKeySession;
+        global.MSMediaKeyError = MockMSMediaKeyError;
+    });
+    afterEach(() => {
+        delete global.MSMediaKeys;
+        delete global.MSMediaKeySession;
+        delete global.MSMediaKeyError;
+    });
+    describe('MsCommonEme', () => {
+        // intersection type is to get the global legacy interface extensions
+        let mockAudioElement;
+        let mockAudioElementEvents;
+        let msCommonEme;
+        beforeEach(() => {
+            mockAudioElement = new MockHTMLAudioElement();
+            mockAudioElement.msSetMediaKeys = createSpy('msSetMediaKeys');
+            mockAudioElementEvents = implementEventFakes(mockAudioElement);
+            msCommonEme = new MsCommonEme();
+        });
+        describe('requestMediaKeySystemAccess', () => {
+            describe('requests access', () => {
+                const keySystem = DrmKeySystem.WIDEVINE;
+                const supportedConfigurations = [
+                    {},
+                    {
+                        audioCapabilities: [
+                            {
+                                contentType: 'test',
+                            },
+                        ],
+                    },
+                ];
+                describe('with configs', () => {
+                    describe('when isTypeSupported returns true', () => {
+                        beforeEach(() => {
+                            MockMSMediaKeys.isTypeSupported.and.returnValue(true);
+                        });
+                        it('returns system access object', async () => {
+                            const access = await msCommonEme.requestMediaKeySystemAccess(keySystem, supportedConfigurations);
+                            expect(access).toBeInstanceOf(MsCommonMediaKeySystemAccess);
+                            expect(access.keySystem).toBe(keySystem);
+                        });
+                    });
+                    describe('when isTypeSupported() returns false', () => {
+                        beforeEach(() => {
+                            MockMSMediaKeys.isTypeSupported.and.returnValue(false);
+                        });
+                        it('throws MediaKeySystemAccessError', async () => {
+                            await expectAsync(msCommonEme.requestMediaKeySystemAccess(keySystem, supportedConfigurations)).toBeRejectedWithError(DrmError, `keySystem not supported: com.widevine.alpha`);
+                        });
+                    });
+                    describe('with videoCapabilities only', () => {
+                        const videoOnlyConfigurations = [
+                            {
+                                videoCapabilities: [
+                                    {
+                                        contentType: 'video/mp4',
+                                    },
+                                ],
+                            },
+                        ];
+                        it('returns system access object when supported', async () => {
+                            MockMSMediaKeys.isTypeSupported.and.returnValue(true);
+                            const access = await msCommonEme.requestMediaKeySystemAccess(keySystem, videoOnlyConfigurations);
+                            expect(access).toBeInstanceOf(MsCommonMediaKeySystemAccess);
+                        });
+                        it('throws DrmError when not supported', async () => {
+                            MockMSMediaKeys.isTypeSupported.and.returnValue(false);
+                            await expectAsync(msCommonEme.requestMediaKeySystemAccess(keySystem, videoOnlyConfigurations)).toBeRejectedWithError(DrmError);
+                        });
+                    });
+                });
+            });
+        });
+        describe('addEncryptedListener', () => {
+            it('adds a listener and returns an Unsubscribe handle', () => {
+                expect(mockAudioElementEvents.hasAnyListeners())
+                    .withContext('hasAnyListeners')
+                    .toBe(false);
+                const handler = createSpy('handler');
+                const encryptedSub = msCommonEme.addEncryptedListener(mockAudioElement, handler);
+                expect(handler).not.toHaveBeenCalled();
+                expectTypeEquals(true);
+                const encryptedEvent = mockEvent('msneedkey');
+                mockAudioElement.dispatchEvent(encryptedEvent);
+                expect(handler).toHaveBeenCalledOnceWith(encryptedEvent);
+                encryptedSub();
+                expect(mockAudioElementEvents.hasAnyListeners())
+                    .withContext('hasAnyListeners')
+                    .toBe(false);
+            });
+        });
+    });
+    describe('MsCommonMediaKeySystemAccess', () => {
+        const keySystem = DrmKeySystem.WIDEVINE;
+        let msCommonMediaKeySystemAccess;
+        beforeEach(() => {
+            msCommonMediaKeySystemAccess = new MsCommonMediaKeySystemAccess(keySystem);
+        });
+        it('creates media keys', async () => {
+            const mediaKeys = await msCommonMediaKeySystemAccess.createMediaKeys();
+            expect(mediaKeys)
+                .withContext('mediaKeys instanceof MsCommonMediaKeys')
+                .toBeInstanceOf(MsCommonMediaKeys);
+            expect(mediaKeys.keySystem).toBe(keySystem);
+        });
+    });
+    describe('MsCommonMediaKeys', () => {
+        let mockAudioElement;
+        let mockMsMediaKeys;
+        let msCommonMediaKeys;
+        beforeEach(() => {
+            mockAudioElement = new MockHTMLAudioElement();
+            mockAudioElement.msSetMediaKeys = createSpy('msSetMediaKeys');
+            mockMsMediaKeys = new MockMSMediaKeys(DrmKeySystem.WIDEVINE);
+            msCommonMediaKeys = new MsCommonMediaKeys(DrmKeySystem.WIDEVINE, mockMsMediaKeys);
+            mockMsMediaKeys.createSession.and.callFake(() => {
+                return new MockMSMediaKeySession();
+            });
+        });
+        describe('setOnElement', () => {
+            it('sets media keys on element', async () => {
+                await msCommonMediaKeys.setOnElement(mockAudioElement);
+                expect(mockAudioElement.msSetMediaKeys).toHaveBeenCalledOnceWith(mockMsMediaKeys);
+            });
+        });
+        describe('clearFromElement', () => {
+            it('clears media keys on element', async () => {
+                await msCommonMediaKeys.clearFromElement(mockAudioElement);
+                expect(mockAudioElement.msSetMediaKeys).toHaveBeenCalledOnceWith(null);
+            });
+        });
+        describe('setServerCertificate', () => {
+            it('resolves to false', async () => {
+                await expectAsync(msCommonMediaKeys.setServerCertificate(new Uint8Array([1, 2, 3]))).toBeResolvedTo(false);
+            });
+        });
+        describe('createSession', () => {
+            const uint16Array = utf16ToUint16Array('skd://example0');
+            const uint8Array = new Uint8Array(uint16Array.buffer);
+            it('creates a session', () => {
+                const session0 = msCommonMediaKeys.createSession('audio/mp4; codecs="mp4a.40.2"', 'cenc', uint8Array);
+                expect(mockMsMediaKeys.createSession).toHaveBeenCalledOnceWith(`audio/mp4; codecs="mp4a.40.2"`, uint8Array);
+                expect(session0).toBeInstanceOf(MsCommonMediaKeySession);
+            });
+        });
+    });
+    describe('MsCommonMediaKeySession', () => {
+        let mockMsMediaKeySession;
+        let mockMsMediaKeySessionEvents;
+        let msCommonMediaKeySession;
+        let mockMsMediaKeyError;
+        const mimeType = 'audio';
+        const initDataType = 'cenc';
+        const initData = new Uint8Array([1, 2, 3]);
+        beforeEach(() => {
+            mockMsMediaKeySession = new MockMSMediaKeySession();
+            mockMsMediaKeySessionEvents = implementEventFakes(mockMsMediaKeySession);
+            msCommonMediaKeySession = new MsCommonMediaKeySession(mockMsMediaKeySession, mimeType, initDataType, initData);
+            mockMsMediaKeyError = new MockMSMediaKeyError();
+        });
+        it('adds event listener on session for mskeymessage event', () => {
+            expect(mockMsMediaKeySession.addEventListener).toHaveBeenCalled();
+            const messageEventSpy = createEventSpy(msCommonMediaKeySession, 'message');
+            const messageEvent = new MockMSMediaKeyMessageEvent();
+            mockMsMediaKeySession.dispatchEvent(messageEvent);
+            expect(messageEventSpy).toHaveBeenCalledOnceWith({
+                message: messageEvent.message.buffer,
+            });
+        });
+        describe('when an event listener is added for webkitkeyerror event', () => {
+            describe('when session has error', () => {
+                beforeEach(() => {
+                    mockMsMediaKeySession.error = new MSMediaKeyError();
+                });
+                afterEach(() => {
+                    mockMsMediaKeySession.error = null;
+                });
+                it('emits event', () => {
+                    expect(mockMsMediaKeySession.addEventListener).toHaveBeenCalled();
+                    const messageEventSpy = createEventSpy(msCommonMediaKeySession, 'error');
+                    mockMsMediaKeySession.dispatchEvent(mockMsMediaKeyError);
+                    expect(messageEventSpy).toHaveBeenCalled();
+                });
+            });
+            describe('when session has no error', () => {
+                it("doesn't emit event", () => {
+                    const mockSession = new MockMSMediaKeySession();
+                    implementEventFakes(mockSession);
+                    const msCommonMediaKeySession = new MsCommonMediaKeySession(mockSession, mimeType, initDataType, initData);
+                    expect(mockSession.addEventListener).toHaveBeenCalled();
+                    const messageEventSpy = createEventSpy(msCommonMediaKeySession, 'error');
+                    mockSession.dispatchEvent(mockMsMediaKeyError);
+                    expect(messageEventSpy).not.toHaveBeenCalled();
+                });
+            });
+        });
+        describe('update', () => {
+            it('rejects update when disposed', async () => {
+                msCommonMediaKeySession.dispose();
+                await expectAsync(msCommonMediaKeySession.update(new ArrayBuffer(0))).toBeRejectedWith(new DisposedError());
+            });
+            it('updates media key session', async () => {
+                const arrayBufferEmpty = new ArrayBuffer(0);
+                await msCommonMediaKeySession.update(arrayBufferEmpty);
+                expect(mockMsMediaKeySession.update).toHaveBeenCalledOnceWith(new Uint8Array(arrayBufferEmpty));
+            });
+        });
+        describe('dispose', () => {
+            it('removes listeners and closes session', () => {
+                expect(msCommonMediaKeySession.disposed).toBeFalse();
+                msCommonMediaKeySession.dispose();
+                expect(msCommonMediaKeySession.disposed).toBeTrue();
+                expect(mockMsMediaKeySessionEvents.hasAnyListeners())
+                    .withContext('hasAnyListeners')
+                    .toBe(false);
+                expect(mockMsMediaKeySession.close).toHaveBeenCalledOnceWith();
+            });
+        });
+    });
+    describe('msErrorCodeToStr', () => {
+        it('translates value correctly', () => {
+            expect(msErrorCodeToStr(MSMediaKeyError.MS_MEDIA_KEYERR_CLIENT)).toBe(MediaKeySessionErrorType.CLIENT);
+            expect(msErrorCodeToStr(MSMediaKeyError.MS_MEDIA_KEYERR_DOMAIN)).toBe(MediaKeySessionErrorType.DOMAIN);
+            expect(msErrorCodeToStr(MSMediaKeyError.MS_MEDIA_KEYERR_HARDWARECHANGE)).toBe(MediaKeySessionErrorType.HARDWARECHANGE);
+            expect(msErrorCodeToStr(MSMediaKeyError.MS_MEDIA_KEYERR_OUTPUT)).toBe(MediaKeySessionErrorType.OUTPUT);
+            expect(msErrorCodeToStr(MSMediaKeyError.MS_MEDIA_KEYERR_SERVICE)).toBe(MediaKeySessionErrorType.SERVICE);
+            expect(msErrorCodeToStr(MSMediaKeyError.MS_MEDIA_KEYERR_UNKNOWN)).toBe(MediaKeySessionErrorType.UNKNOWN);
+        });
+    });
+});

package/dist/unit/types/current/drm/commonEme/StandardCommonEme.test.d.ts

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

package/dist/unit/types/current/drm/commonEme/StandardCommonEme.test.d.ts.map

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

package/dist/unit/types/current/drm/commonEme/StandardCommonEme.test.js

@@ -0,0 +1,227 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { DrmKeySystem, StandardCommonEme, StandardCommonMediaKeys, StandardCommonMediaKeySession, StandardCommonMediaKeySystemAccess, } from '@amazon/vinyl';
+import { Deferred, DisposedError, never, } from '@amazon/vinyl-util';
+import { expectTypeEquals, flushPromises, implementEventFakes, mockEvent, MockHTMLAudioElement, MockMediaKeyMessageEvent, MockMediaKeys, MockMediaKeySession, MockMediaKeySystemAccess, } from '@amazon/vinyl-util/browserTestUtil';
+import { createEventSpy, setMockNavigator } from '@amazon/vinyl-util/testUtil';
+var any = jasmine.any;
+describe('StandardCommonEme', () => {
+    let navigator;
+    let mediaKeySystemAccess;
+    beforeEach(() => {
+        navigator = setMockNavigator();
+        mediaKeySystemAccess = new MockMediaKeySystemAccess();
+        mediaKeySystemAccess.createMediaKeys.and.resolveTo(new MockMediaKeys());
+        navigator.requestMediaKeySystemAccess.and.resolveTo(mediaKeySystemAccess);
+    });
+    describe('StandardCommonEme', () => {
+        let audio;
+        let standardCommonEme;
+        let audioEventFakes;
+        beforeEach(() => {
+            audio = new MockHTMLAudioElement();
+            audioEventFakes = implementEventFakes(audio);
+            standardCommonEme = new StandardCommonEme();
+        });
+        describe('requestMediaKeySystemAccess', () => {
+            const supportedConfigurations = [
+                {},
+                {
+                    audioCapabilities: [
+                        {
+                            contentType: 'test',
+                        },
+                    ],
+                },
+            ];
+            describe('when navigator.requestMediaKeySystemAccess resolves', () => {
+                it('returns StandardCommonMediaKeySystemAccess', async () => {
+                    expect(navigator.requestMediaKeySystemAccess).not.toHaveBeenCalled();
+                    await expectAsync(standardCommonEme.requestMediaKeySystemAccess(DrmKeySystem.WIDEVINE, supportedConfigurations)).toBeResolvedTo(any(StandardCommonMediaKeySystemAccess));
+                });
+            });
+            describe('when navigator.requestMediaKeySystemAccess rejects', () => {
+                beforeEach(() => {
+                    navigator.requestMediaKeySystemAccess.and.rejectWith(new Error('expected'));
+                });
+                it('rejects with reason', async () => {
+                    await expectAsync(standardCommonEme.requestMediaKeySystemAccess(DrmKeySystem.WIDEVINE, supportedConfigurations)).toBeRejectedWithError(Error, 'expected');
+                });
+            });
+        });
+        describe('addEncryptedListener', () => {
+            it('adds a listener and returns an Unsubscribe handle', () => {
+                expect(audioEventFakes.hasAnyListeners())
+                    .withContext('hasAnyListeners')
+                    .toBe(false);
+                const handler = jasmine.createSpy('handler');
+                const encryptedSub = standardCommonEme.addEncryptedListener(audio, handler);
+                expect(handler).not.toHaveBeenCalled();
+                expectTypeEquals(true);
+                const encryptedEvent = mockEvent('encrypted');
+                audio.dispatchEvent(encryptedEvent);
+                expect(handler).toHaveBeenCalledOnceWith(encryptedEvent);
+                encryptedSub();
+                expect(audioEventFakes.hasAnyListeners())
+                    .withContext('hasAnyListeners')
+                    .toBe(false);
+            });
+        });
+    });
+    describe('StandardCommonMediaKeySystemAccess', () => {
+        let standardCommonMediaKeySystemAccess;
+        beforeEach(() => {
+            standardCommonMediaKeySystemAccess =
+                new StandardCommonMediaKeySystemAccess(DrmKeySystem.WIDEVINE, mediaKeySystemAccess);
+        });
+        describe('createMediaKeys', () => {
+            it('creates media keys', async () => {
+                expect(mediaKeySystemAccess.createMediaKeys).not.toHaveBeenCalled();
+                const mediaKeys = await standardCommonMediaKeySystemAccess.createMediaKeys();
+                expect(mediaKeySystemAccess.createMediaKeys).toHaveBeenCalledTimes(1);
+                expect(mediaKeys).toBeInstanceOf(StandardCommonMediaKeys);
+            });
+        });
+    });
+    describe('StandardCommonMediaKeys', () => {
+        let mockAudioElement;
+        let mediaKeys;
+        let standardCommonMediaKeys;
+        beforeEach(() => {
+            mockAudioElement = new MockHTMLAudioElement();
+            mediaKeys = new MockMediaKeys();
+            standardCommonMediaKeys = new StandardCommonMediaKeys(DrmKeySystem.WIDEVINE, mediaKeys);
+        });
+        describe('setOnElement', () => {
+            it('sets media keys on element', async () => {
+                expect(mockAudioElement.setMediaKeys).not.toHaveBeenCalled();
+                await standardCommonMediaKeys.setOnElement(mockAudioElement);
+                expect(mockAudioElement.setMediaKeys).toHaveBeenCalledOnceWith(mediaKeys);
+            });
+        });
+        describe('clearFromElement', () => {
+            it('clears media keys on element', async () => {
+                expect(mockAudioElement.setMediaKeys).not.toHaveBeenCalled();
+                await standardCommonMediaKeys.clearFromElement(mockAudioElement);
+                expect(mockAudioElement.setMediaKeys).toHaveBeenCalledOnceWith(null);
+            });
+        });
+        describe('setServerCertificate', () => {
+            it('delegates to mediaKeys.setServerCertificate and returns the result', async () => {
+                const cert = new Uint8Array([1, 2, 3]);
+                mediaKeys.setServerCertificate.and.resolveTo(true);
+                const result = await standardCommonMediaKeys.setServerCertificate(cert);
+                expect(result).toBeTrue();
+                expect(mediaKeys.setServerCertificate).toHaveBeenCalledOnceWith(cert);
+            });
+        });
+        describe('createSession', () => {
+            it('creates a session', () => {
+                expect(mediaKeys.createSession).not.toHaveBeenCalled();
+                const mediaKeySession = new MockMediaKeySession();
+                mediaKeySession.closed = never;
+                implementEventFakes(mediaKeySession);
+                mediaKeySession.generateRequest.and.resolveTo(void 0);
+                mediaKeys.createSession.and.returnValue(mediaKeySession);
+                const mimeType = 'audio';
+                const initData = new Uint8Array([1, 2, 3]);
+                const session = standardCommonMediaKeys.createSession(mimeType, 'cenc', initData);
+                expect(mediaKeys.createSession).toHaveBeenCalledOnceWith('temporary');
+                expect(session).toBeInstanceOf(StandardCommonMediaKeySession);
+                expect(session.initData).toBe(initData);
+                expect(session.mimeType).toBe(mimeType);
+                expect(session.initDataType).toBe('cenc');
+            });
+        });
+    });
+    describe('StandardCommonMediaKeySession', () => {
+        let mediaKeySession;
+        let mediaKeySessionEventFakes;
+        let standardCommonMediaKeySession;
+        const mimeType = 'audio';
+        const initData = new Uint8Array([1, 2, 3]);
+        let closed;
+        beforeEach(() => {
+            mediaKeySession = new MockMediaKeySession();
+            mediaKeySessionEventFakes = implementEventFakes(mediaKeySession);
+            mediaKeySession.close.and.returnValue(Promise.resolve());
+            mediaKeySession.generateRequest.and.resolveTo(void 0);
+            closed = new Deferred();
+            mediaKeySession.closed = closed;
+            standardCommonMediaKeySession = new StandardCommonMediaKeySession(mediaKeySession, mimeType, 'cenc', initData);
+        });
+        it('adds event listener on session for message event', () => {
+            expect(mediaKeySession.addEventListener).toHaveBeenCalled();
+            const messageEventSpy = createEventSpy(standardCommonMediaKeySession, 'message');
+            const event = new MockMediaKeyMessageEvent();
+            event.type = 'message';
+            mediaKeySession.dispatchEvent(event);
+            expect(messageEventSpy).toHaveBeenCalledOnceWith({
+                message: event.message,
+            });
+        });
+        describe('when created', () => {
+            it('calls session.generateRequest() with the initData buffer', () => {
+                expect(mediaKeySession.generateRequest).toHaveBeenCalledOnceWith('cenc', initData.buffer);
+                mediaKeySession.generateRequest.calls.reset();
+                const arrayBuffer = new ArrayBuffer(0);
+                standardCommonMediaKeySession =
+                    new StandardCommonMediaKeySession(mediaKeySession, mimeType, 'cenc', arrayBuffer);
+                expect(mediaKeySession.generateRequest).toHaveBeenCalledOnceWith('cenc', arrayBuffer);
+            });
+            describe('when session.generateRequest rejects', () => {
+                it('emits an error event', async () => {
+                    mediaKeySession.generateRequest.and.rejectWith(new Error('expected'));
+                    standardCommonMediaKeySession =
+                        new StandardCommonMediaKeySession(mediaKeySession, mimeType, 'cenc', initData);
+                    const errorSpy = createEventSpy(standardCommonMediaKeySession, 'error');
+                    await expectAsync(errorSpy.next()).toBeResolvedTo({
+                        target: standardCommonMediaKeySession,
+                        error: new Error('expected'),
+                    });
+                });
+            });
+        });
+        describe('update', () => {
+            it('throws when disposed', () => {
+                standardCommonMediaKeySession.dispose();
+                expect(() => standardCommonMediaKeySession.update(new ArrayBuffer(0))).toThrowError(DisposedError);
+            });
+            it('updates media key session', async () => {
+                const arrayBufferEmpty = new ArrayBuffer(0);
+                await standardCommonMediaKeySession.update(arrayBufferEmpty);
+                expect(mediaKeySession.update).toHaveBeenCalledOnceWith(arrayBufferEmpty);
+            });
+        });
+        describe('closed event', () => {
+            it('dispatches when the MediaKeySession closed resolves', async () => {
+                const closedSpy = createEventSpy(standardCommonMediaKeySession, 'closed');
+                closed.resolve('closed-by-application');
+                await flushPromises();
+                expect(closedSpy).toHaveBeenCalledOnceWith({
+                    reason: 'closed-by-application',
+                });
+            });
+        });
+        describe('when session.closed is nullish', () => {
+            it('does not fail to create a session', () => {
+                ;
+                mediaKeySession.closed = null;
+                expect(() => new StandardCommonMediaKeySession(mediaKeySession, mimeType, 'cenc', new ArrayBuffer(0))).not.toThrow();
+            });
+        });
+        describe('dispose', () => {
+            it('removes listeners and closes session', () => {
+                expect(standardCommonMediaKeySession.disposed).toBeFalse();
+                standardCommonMediaKeySession.dispose();
+                expect(standardCommonMediaKeySession.disposed).toBeTrue();
+                expect(mediaKeySessionEventFakes.hasAnyListeners())
+                    .withContext('hasAnyListeners')
+                    .toBe(false);
+                expect(mediaKeySession.close).toHaveBeenCalledOnceWith();
+            });
+        });
+    });
+});

package/dist/unit/types/current/drm/commonEme/WebKitCommonEme.test.d.ts

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

package/dist/unit/types/current/drm/commonEme/WebKitCommonEme.test.d.ts.map

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