@npo/player 1.22.4 → 1.23.0

package/lib/services/a11y/setup.test.js

@@ -0,0 +1,109 @@
+import { PlayerEvent } from 'bitmovin-player';
+import { addAccessibilityAttributes } from '../../ui/handlers/accessibilityhandler';
+import { setupAccessibilityAttributes } from './setup';
+import { mockNpoPlayer } from '../../../tests/mocks/mockNpoplayer';
+jest.mock('bitmovin-player', () => ({
+    PlayerEvent: {
+        SourceLoaded: 'sourceLoaded',
+        AdBreakFinished: 'adBreakFinished',
+        AdError: 'adError'
+    }
+}));
+jest.mock('../../ui/handlers/accessibilityhandler');
+describe('setupAccessibilityAttributes', () => {
+    let playerContext;
+    let mockEnableSubtitles;
+    let mockAddEventListener;
+    let mockRemoveEventListener;
+    let mockPlayerAPI;
+    beforeEach(() => {
+        mockEnableSubtitles = jest.fn();
+        mockAddEventListener = jest.fn();
+        mockRemoveEventListener = jest.fn();
+        mockPlayerAPI = {
+            on: mockAddEventListener,
+            off: mockRemoveEventListener,
+            enableSubtitles: mockEnableSubtitles,
+            subtitles: {
+                list: jest.fn().mockReturnValue([{ id: 1, enabled: false }]),
+                enable: jest.fn()
+            }
+        };
+        playerContext = {
+            player: mockPlayerAPI,
+            npoplayer: {
+                ...mockNpoPlayer,
+                streamOptions: {
+                    enableSubtitles: false
+                },
+                userPreferences: {
+                    subtitles_enabled: 'false'
+                },
+                container: document.createElement('div'),
+                streamObject: {},
+                playerConfig: {},
+                initPlayer: () => { },
+                loadStream: () => Promise.resolve(),
+                createUIManager: async () => { },
+                doError: () => { },
+                play: async () => { },
+                pause: () => { },
+                setVolume: () => { },
+                increaseVolume: () => { },
+                decreaseVolume: () => { },
+                goForward: () => { },
+                goBackwards: () => { },
+                watchFromStart: () => { },
+                showPlayNextScreen: () => { },
+                updateMarkers: () => { },
+                cancelPlayNextScreen: () => { },
+                hidePlayNextScreen: () => { },
+                doPlayNext: () => { },
+                destroy: () => false,
+                unload: () => {
+                    return true;
+                },
+                printVersion: () => { }
+            }
+        };
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should enable subtitles if playerContext.npoplayer.userPreferences.subtitles_enabled is "true"', () => {
+        playerContext.npoplayer.userPreferences.subtitles_enabled = 'true';
+        setupAccessibilityAttributes(playerContext);
+        const triggerFunction = mockAddEventListener.mock.calls[0][1];
+        triggerFunction();
+        expect(mockEnableSubtitles).toHaveBeenCalled();
+    });
+    it('should enable subtitles if streamOptions.enableSubtitles is true', () => {
+        playerContext.npoplayer.streamOptions.enableSubtitles = true;
+        setupAccessibilityAttributes(playerContext);
+        const triggerFunction = mockAddEventListener.mock.calls[0][1];
+        triggerFunction();
+        expect(mockEnableSubtitles).toHaveBeenCalled();
+    });
+    it('should set up event listeners for specified events', () => {
+        setupAccessibilityAttributes(playerContext);
+        expect(mockAddEventListener).toHaveBeenCalledTimes(3);
+        expect(mockAddEventListener).toHaveBeenCalledWith(PlayerEvent.SourceLoaded, expect.any(Function));
+        expect(mockAddEventListener).toHaveBeenCalledWith(PlayerEvent.AdBreakFinished, expect.any(Function));
+        expect(mockAddEventListener).toHaveBeenCalledWith(PlayerEvent.AdError, expect.any(Function));
+    });
+    it('should remove event listeners after they are triggered', () => {
+        setupAccessibilityAttributes(playerContext);
+        const triggerFunction = mockAddEventListener.mock.calls[0][1];
+        triggerFunction();
+        expect(mockRemoveEventListener).toHaveBeenCalledTimes(3);
+        expect(mockRemoveEventListener).toHaveBeenCalledWith(PlayerEvent.SourceLoaded, triggerFunction);
+        expect(mockRemoveEventListener).toHaveBeenCalledWith(PlayerEvent.AdBreakFinished, triggerFunction);
+        expect(mockRemoveEventListener).toHaveBeenCalledWith(PlayerEvent.AdError, triggerFunction);
+    });
+    it('should call addAccessibilityAttributes with the correct parameters', () => {
+        setupAccessibilityAttributes(playerContext);
+        const triggerFunction = mockAddEventListener.mock.calls[0][1];
+        triggerFunction();
+        expect(addAccessibilityAttributes).toHaveBeenCalledWith(playerContext.npoplayer.container, playerContext.npoplayer.streamObject.metadata);
+    });
+});

package/lib/services/avTypeHandlers/getAVType.d.ts

@@ -0,0 +1,2 @@
+import { AVType } from '@npotag/tag/dist/types/src/streamTracker';
+export declare function getAVType(avType: string): AVType;

package/lib/services/avTypeHandlers/getAVType.js

@@ -0,0 +1,9 @@
+const avTypeMapping = {
+    video: 'video',
+    vod: 'video',
+    audio: 'audio',
+    aod: 'audio'
+};
+export function getAVType(avType) {
+    return avTypeMapping[avType];
+}

package/lib/services/avTypeHandlers/getAVType.test.js

@@ -0,0 +1,18 @@
+import { getAVType } from './getAVType';
+describe('getAVType', () => {
+    it('should return "video" for "video"', () => {
+        expect(getAVType('video')).toBe('video');
+    });
+    it('should return "audio" for "audio"', () => {
+        expect(getAVType('audio')).toBe('audio');
+    });
+    it('should return "video" for "vod"', () => {
+        expect(getAVType('vod')).toBe('video');
+    });
+    it('should return "audio" for "aod"', () => {
+        expect(getAVType('aod')).toBe('audio');
+    });
+    it('should return "undefined" for an unknown type', () => {
+        expect(getAVType('dummy')).toBe(undefined);
+    });
+});

package/lib/services/drmHandlers/constants.d.ts

@@ -0,0 +1,15 @@
+export declare const appleDRM: string[];
+export declare const openDRM: string[];
+export declare enum DRM_TYPES {
+    FAIRPLAY = "fairplay",
+    WIDEVINE = "widevine",
+    PLAYREADY = "playready"
+}
+export declare enum STREAM_TYPES {
+    DASH = "dash",
+    HLS = "hls"
+}
+export type DRMInfo = {
+    supportedDRM: string[];
+    preferredDRM: string;
+};

package/lib/services/drmHandlers/constants.js

@@ -0,0 +1,13 @@
+export const appleDRM = ['com.apple.fps.1_0', 'com.apple.fps.2_0'];
+export const openDRM = ['com.widevine.alpha', 'com.microsoft.playready'];
+export var DRM_TYPES;
+(function (DRM_TYPES) {
+    DRM_TYPES["FAIRPLAY"] = "fairplay";
+    DRM_TYPES["WIDEVINE"] = "widevine";
+    DRM_TYPES["PLAYREADY"] = "playready";
+})(DRM_TYPES || (DRM_TYPES = {}));
+export var STREAM_TYPES;
+(function (STREAM_TYPES) {
+    STREAM_TYPES["DASH"] = "dash";
+    STREAM_TYPES["HLS"] = "hls";
+})(STREAM_TYPES || (STREAM_TYPES = {}));

package/lib/services/drmHandlers/decideprofile.d.ts

@@ -0,0 +1,2 @@
+import { type Profile, PlayerContext } from '../../types/interfaces';
+export declare function decideProfile(playerContext: PlayerContext, preferredDRM?: string): Promise<Profile>;

package/lib/services/drmHandlers/decideprofile.js

@@ -0,0 +1,51 @@
+import { DRM_TYPES, STREAM_TYPES } from './constants';
+import { getBestDRMForDash, getBestDRMForHls } from './utils';
+export async function decideProfile(playerContext, preferredDRM = '') {
+    if (!playerContext.player) {
+        console.error('No player detected');
+        return { profileName: '', drm: '' };
+    }
+    const player = playerContext.player;
+    const supportedTech = player.getSupportedTech();
+    const supportedDRM = await player.getSupportedDRM();
+    const isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+    if ((isSafari && supportedTech.some((tech) => tech.streaming === 'hls') && supportedDRM.includes(DRM_TYPES.FAIRPLAY)) ||
+        preferredDRM === DRM_TYPES.FAIRPLAY) {
+        return { profileName: STREAM_TYPES.HLS, drm: DRM_TYPES.FAIRPLAY };
+    }
+    const { bestWithDRM, bestDRM } = determineBestWithDRM(supportedTech, { supportedDRM, preferredDRM });
+    const bestWithoutDRM = determineBestWithoutDRM(supportedTech);
+    return bestWithDRM ? { profileName: bestWithDRM, drm: bestDRM } : { profileName: bestWithoutDRM, drm: bestDRM };
+}
+function determineBestWithDRM(supportedTech, drmInfo) {
+    let bestWithDRM = '';
+    let bestDRM = '';
+    const techMap = {
+        dash: { drm: DRM_TYPES.WIDEVINE, stream: STREAM_TYPES.DASH },
+        hls: { drm: DRM_TYPES.FAIRPLAY, stream: STREAM_TYPES.HLS },
+        whep: {
+            drm: drmInfo.preferredDRM === DRM_TYPES.FAIRPLAY ? DRM_TYPES.FAIRPLAY : '',
+            stream: drmInfo.preferredDRM === DRM_TYPES.FAIRPLAY ? STREAM_TYPES.HLS : STREAM_TYPES.DASH
+        }
+    };
+    for (const tech of supportedTech) {
+        if (bestWithDRM)
+            continue;
+        if (techMap[tech.streaming]) {
+            const { drm, stream } = techMap[tech.streaming];
+            if (drmInfo.preferredDRM !== drm) {
+                bestDRM =
+                    tech.streaming === STREAM_TYPES.DASH ? getBestDRMForDash(drmInfo) : getBestDRMForHls(drmInfo);
+                if (bestDRM)
+                    bestWithDRM = stream;
+            }
+        }
+    }
+    return { bestWithDRM, bestDRM };
+}
+function determineBestWithoutDRM(supportedTech) {
+    for (const tech of supportedTech) {
+        return tech.streaming;
+    }
+    return '';
+}

package/lib/services/drmHandlers/decideprofile.test.js

@@ -0,0 +1,34 @@
+import { decideProfile } from './decideprofile';
+import { mockNpoPlayer } from '../../../tests/mocks/mockNpoplayer';
+import { STREAM_TYPES, DRM_TYPES } from './constants';
+describe('decideProfile', () => {
+    let mockPlayer;
+    const mockNpoplayer = mockNpoPlayer;
+    let mockPlayerContext;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockPlayer = {
+            getSupportedTech: jest.fn().mockReturnValue([{ streaming: STREAM_TYPES.DASH }, { streaming: STREAM_TYPES.HLS }]),
+            getSupportedDRM: jest
+                .fn()
+                .mockResolvedValue(['com.widevine.alpha', 'com.microsoft.playready', 'com.apple.fps.1_0'])
+        };
+        mockPlayerContext = { player: mockPlayer, npoplayer: mockNpoplayer };
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should return profile with dash streaming and widevine DRM', async () => {
+        const result = await decideProfile(mockPlayerContext);
+        expect(result).toEqual({ profileName: STREAM_TYPES.DASH, drm: DRM_TYPES.WIDEVINE });
+    });
+    it('should return profile with hls streaming and fairplay DRM on Safari', async () => {
+        Object.defineProperty(window.navigator, 'userAgent', { value: 'Safari', configurable: true });
+        const result = await decideProfile(mockPlayerContext, DRM_TYPES.FAIRPLAY);
+        expect(result).toEqual({ profileName: STREAM_TYPES.HLS, drm: DRM_TYPES.FAIRPLAY });
+    });
+    it('should return profile with hls streaming and fairplay DRM when preferred DRM is Fairplay', async () => {
+        const result = await decideProfile(mockPlayerContext, DRM_TYPES.FAIRPLAY);
+        expect(result).toEqual({ profileName: STREAM_TYPES.HLS, drm: DRM_TYPES.FAIRPLAY });
+    });
+});

package/lib/services/drmHandlers/drmhandlers.d.ts

@@ -0,0 +1,2 @@
+export { decideProfile } from './decideprofile';
+export { verifyDRM } from './verifydrm';

package/lib/services/drmHandlers/drmhandlers.js

@@ -0,0 +1,2 @@
+export { decideProfile } from './decideprofile';
+export { verifyDRM } from './verifydrm';

package/lib/services/drmHandlers/utils.d.ts

@@ -0,0 +1,5 @@
+import { type DRMInfo } from './constants';
+export declare function isSupportedAppleDRM(drm: string): boolean;
+export declare function isSupportedOpenDRM(drm: string): boolean;
+export declare function getBestDRMForDash(drmInfo: DRMInfo): string;
+export declare function getBestDRMForHls(drmInfo: DRMInfo): string;

package/lib/services/drmHandlers/utils.js

@@ -0,0 +1,26 @@
+import { appleDRM, openDRM, DRM_TYPES } from './constants';
+export function isSupportedAppleDRM(drm) {
+    return appleDRM.includes(drm);
+}
+export function isSupportedOpenDRM(drm) {
+    return openDRM.includes(drm);
+}
+export function getBestDRMForDash(drmInfo) {
+    for (const drm of drmInfo.supportedDRM) {
+        if (isSupportedOpenDRM(drm) && !drmInfo.preferredDRM) {
+            return 'widevine';
+        }
+        if (isSupportedAppleDRM(drm) && drmInfo.preferredDRM === DRM_TYPES.FAIRPLAY) {
+            return DRM_TYPES.FAIRPLAY;
+        }
+    }
+    return '';
+}
+export function getBestDRMForHls(drmInfo) {
+    for (const drm of drmInfo.supportedDRM) {
+        if (isSupportedAppleDRM(drm) && (drmInfo.preferredDRM === DRM_TYPES.FAIRPLAY || !drmInfo.preferredDRM)) {
+            return DRM_TYPES.FAIRPLAY;
+        }
+    }
+    return '';
+}

package/lib/services/drmHandlers/utils.test.js

@@ -0,0 +1,74 @@
+import { isSupportedAppleDRM, isSupportedOpenDRM, getBestDRMForDash, getBestDRMForHls } from './utils';
+import { DRM_TYPES } from './constants';
+const appleFps1 = 'com.apple.fps.1_0';
+const appleFps2 = 'com.apple.fps.2_0';
+const widevine = 'com.widevine.alpha';
+const playready = 'com.microsoft.playready';
+describe('DRM Functions', () => {
+    describe('isSupportedAppleDRM', () => {
+        it('should return true for supported Apple DRM', () => {
+            expect(isSupportedAppleDRM(appleFps1)).toBe(true);
+            expect(isSupportedAppleDRM(appleFps2)).toBe(true);
+        });
+        it('should return false for unsupported Apple DRM', () => {
+            expect(isSupportedAppleDRM(widevine)).toBe(false);
+            expect(isSupportedAppleDRM(playready)).toBe(false);
+        });
+    });
+    describe('isSupportedOpenDRM', () => {
+        it('should return true for supported Open DRM', () => {
+            expect(isSupportedOpenDRM(widevine)).toBe(true);
+            expect(isSupportedOpenDRM(playready)).toBe(true);
+        });
+        it('should return false for unsupported Open DRM', () => {
+            expect(isSupportedOpenDRM(appleFps1)).toBe(false);
+            expect(isSupportedOpenDRM(appleFps2)).toBe(false);
+        });
+    });
+    describe('getBestDRMForDash', () => {
+        it('should return widevine for supported open DRM and no preferred DRM', () => {
+            const drmInfo = {
+                supportedDRM: [widevine],
+                preferredDRM: ''
+            };
+            expect(getBestDRMForDash(drmInfo)).toBe('widevine');
+        });
+        it('should return fairplay for supported Apple DRM and preferred DRM is fairplay', () => {
+            const drmInfo = {
+                supportedDRM: [appleFps1],
+                preferredDRM: DRM_TYPES.FAIRPLAY
+            };
+            expect(getBestDRMForDash(drmInfo)).toBe(DRM_TYPES.FAIRPLAY);
+        });
+        it('should return empty string for no matching DRM', () => {
+            const drmInfo = {
+                supportedDRM: ['com.other.drm'],
+                preferredDRM: ''
+            };
+            expect(getBestDRMForDash(drmInfo)).toBe('');
+        });
+    });
+    describe('getBestDRMForHls', () => {
+        it('should return fairplay for supported Apple DRM and preferred DRM is fairplay', () => {
+            const drmInfo = {
+                supportedDRM: [appleFps1],
+                preferredDRM: DRM_TYPES.FAIRPLAY
+            };
+            expect(getBestDRMForHls(drmInfo)).toBe(DRM_TYPES.FAIRPLAY);
+        });
+        it('should return fairplay for supported Apple DRM and no preferred DRM', () => {
+            const drmInfo = {
+                supportedDRM: [appleFps2],
+                preferredDRM: ''
+            };
+            expect(getBestDRMForHls(drmInfo)).toBe(DRM_TYPES.FAIRPLAY);
+        });
+        it('should return empty string for no matching DRM', () => {
+            const drmInfo = {
+                supportedDRM: ['com.other.drm'],
+                preferredDRM: ''
+            };
+            expect(getBestDRMForHls(drmInfo)).toBe('');
+        });
+    });
+});

package/lib/services/drmHandlers/verifydrm.d.ts

@@ -0,0 +1,2 @@
+import { PlayerContext, type ApiPayload } from '../../types/interfaces';
+export declare function verifyDRM(playerContext: PlayerContext, payload: ApiPayload): Promise<void>;

package/lib/services/drmHandlers/verifydrm.js

@@ -0,0 +1,40 @@
+import { convertJwtToBase64, convertBase64ToObject } from '../../js/utilities/utilities.jwt';
+import { getStreamObject } from '../../js/api/getstreamobject';
+export async function verifyDRM(playerContext, payload) {
+    try {
+        const { player, npoplayer: { streamObject, sourceConfig } } = playerContext;
+        const { stream } = streamObject;
+        if (stream.drmToken) {
+            const drmJsonTimestamp = getDRMTokenTimestamp(stream.drmToken);
+            const currentTime = Math.trunc(Date.now() / 1000);
+            if (drmJsonTimestamp >= currentTime) {
+                await player.load(sourceConfig);
+                return;
+            }
+            console.warn('DRM token window verstreken; item wordt herladen met een nieuwe token.');
+            await refreshDRMToken(playerContext, payload);
+            return;
+        }
+        await loadPlayer(playerContext, sourceConfig);
+    }
+    catch (error) {
+        console.error(`Error verifying DRM in verifyDRM function: ${error}`);
+    }
+}
+async function loadPlayer(playerContext, sourceConfig) {
+    await playerContext.player.load(sourceConfig);
+}
+function getDRMTokenTimestamp(drmToken) {
+    const drmBase64 = convertJwtToBase64(drmToken);
+    return convertBase64ToObject(drmBase64).iat;
+}
+async function refreshDRMToken(playerContext, payload) {
+    const backupStreamObject = await getStreamObject(playerContext.npoplayer, payload);
+    const newDrmToken = backupStreamObject.stream.drmToken;
+    const clonedStreamObject = {
+        ...playerContext.npoplayer.streamObject,
+        stream: { ...playerContext.npoplayer.streamObject.stream, drmToken: newDrmToken }
+    };
+    playerContext.npoplayer.streamObject = clonedStreamObject;
+    await loadPlayer(playerContext, playerContext.npoplayer.sourceConfig);
+}

package/lib/services/drmHandlers/verifydrm.test.js

@@ -0,0 +1,89 @@
+import { verifyDRM } from './verifydrm';
+import { mockNpoPlayer } from '../../../tests/mocks/mockNpoplayer';
+import { convertBase64ToObject, convertJwtToBase64 } from '../../js/utilities/utilities.jwt';
+import { getStreamObject } from '../../js/api/getstreamobject';
+jest.mock('../../js/utilities/utilities.jwt', () => ({
+    convertBase64ToObject: jest.fn(),
+    convertJwtToBase64: jest.fn()
+}));
+jest.mock('../../js/api/getstreamobject', () => ({
+    getStreamObject: jest.fn()
+}));
+let mockPlayer;
+const mockNpoplayer = mockNpoPlayer;
+let mockPlayerContext;
+beforeEach(() => {
+    jest.clearAllMocks();
+    mockPlayer = {
+        streamObject: { stream: { drmToken: undefined } },
+        load: jest.fn()
+    };
+    mockPlayerContext = { player: mockPlayer, npoplayer: mockNpoplayer };
+});
+afterEach(() => {
+    jest.clearAllMocks();
+});
+const payload = {
+    baseURL: 'url',
+    jwt: 'jwt',
+    data: { data: 'data' }
+};
+describe('Test DRM verification', () => {
+    it('should call player.load when the drmToken is not null and drmJsonTimestamp is greater than currentTime', async () => {
+        const currentTime = Math.trunc(Date.now() / 1000);
+        const drmToken = 'token';
+        const drmJsonTimestamp = currentTime + 10;
+        const sourceConfig = {};
+        mockNpoPlayer.streamObject.stream = {
+            avType: '',
+            drmType: '',
+            streamProfile: '',
+            sourceProfile: '',
+            streamURL: '',
+            drmToken: drmToken
+        };
+        mockPlayerContext.npoplayer.sourceConfig = sourceConfig;
+        jest.spyOn(global.Date, 'now').mockImplementation(() => currentTime * 1000);
+        convertJwtToBase64.mockReturnValue(JSON.stringify({ iat: drmJsonTimestamp }));
+        convertBase64ToObject.mockReturnValue({ iat: drmJsonTimestamp });
+        await verifyDRM(mockPlayerContext, payload);
+        expect(mockPlayerContext.player.load).toHaveBeenCalledWith(sourceConfig);
+    });
+    it('should call refreshDRMToken when the drmToken is not null and drmJsonTimestamp is less than currentTime', async () => {
+        const currentTime = Math.trunc(Date.now() / 1000);
+        const drmToken = 'token';
+        const drmJsonTimestamp = currentTime - 10;
+        const sourceConfig = {};
+        mockNpoPlayer.streamObject.stream = {
+            avType: '',
+            drmType: '',
+            streamProfile: '',
+            sourceProfile: '',
+            streamURL: '',
+            drmToken: drmToken
+        };
+        mockPlayerContext.npoplayer.sourceConfig = sourceConfig;
+        jest.spyOn(global.Date, 'now').mockImplementation(() => currentTime * 1000);
+        convertJwtToBase64.mockReturnValue(JSON.stringify({ iat: drmJsonTimestamp }));
+        convertBase64ToObject.mockReturnValue({ iat: drmJsonTimestamp });
+        getStreamObject.mockResolvedValue({ stream: { drmToken: 'newToken' } });
+        jest.spyOn(mockPlayerContext.player, 'load').mockResolvedValue(undefined);
+        await verifyDRM(mockPlayerContext, payload);
+        expect(getStreamObject).toHaveBeenCalledWith(mockPlayerContext.npoplayer, payload);
+        expect(mockPlayerContext.player.load).toHaveBeenCalledWith(sourceConfig);
+    });
+    it('should call loadPlayer when the drmToken is null', async () => {
+        const sourceConfig = {};
+        mockNpoPlayer.streamObject.stream = {
+            avType: '',
+            drmType: '',
+            streamProfile: '',
+            sourceProfile: '',
+            streamURL: '',
+            drmToken: undefined
+        };
+        mockPlayerContext.npoplayer.sourceConfig = sourceConfig;
+        await verifyDRM(mockPlayerContext, payload);
+        expect(mockPlayerContext.player.load).toHaveBeenCalledWith(sourceConfig);
+    });
+});

package/lib/services/eventListenerHandlers/removeEventListeners.d.ts

@@ -0,0 +1,2 @@
+import { PlayerContext } from 'types/interfaces';
+export declare const removeEventListeners: (playerContext: PlayerContext) => void;

package/lib/services/eventListenerHandlers/removeEventListeners.js

@@ -0,0 +1,18 @@
+import { PlayerEvent } from 'bitmovin-player';
+export const removeEventListeners = (playerContext) => {
+    const { eventListeners } = playerContext.npoplayer;
+    if (eventListeners) {
+        const { segmentHandleTimeChangedCallback, segmentSeekFunctionCallback, liveStreamHandleTimeChangedCallback } = eventListeners;
+        const eventMapping = [
+            { event: PlayerEvent.TimeChanged, callback: liveStreamHandleTimeChangedCallback },
+            { event: PlayerEvent.TimeChanged, callback: segmentHandleTimeChangedCallback },
+            { event: PlayerEvent.Seek, callback: segmentSeekFunctionCallback }
+        ];
+        for (const { event, callback } of eventMapping) {
+            if (callback) {
+                playerContext.player.off(event, callback);
+            }
+        }
+        playerContext.npoplayer.eventListeners = undefined;
+    }
+};

package/lib/services/eventListenerHandlers/removeEventListeners.test.js

@@ -0,0 +1,27 @@
+import { PlayerEvent } from 'bitmovin-player';
+import { mockPlayerContext } from '../../../tests/mocks/mockPlayerContext';
+import { removeEventListeners } from './removeEventListeners';
+describe('removeEventListeners', () => {
+    let context;
+    beforeEach(() => {
+        context = { ...mockPlayerContext };
+        jest.clearAllMocks();
+    });
+    it('should remove TimeChanged event listener if exists', () => {
+        removeEventListeners(context);
+        if (context.npoplayer.eventListeners) {
+            expect(context.player.off).toHaveBeenCalledWith(PlayerEvent.TimeChanged, context.npoplayer.eventListeners.segmentHandleTimeChangedCallback);
+            expect(context.player.off).toHaveBeenCalledWith(PlayerEvent.TimeChanged, context.npoplayer.eventListeners.liveStreamHandleTimeChangedCallback);
+        }
+    });
+    it('should remove Seek event listener if exists', () => {
+        removeEventListeners(context);
+        if (context.npoplayer.eventListeners) {
+            expect(context.player.off).toHaveBeenCalledWith(PlayerEvent.Seek, context.npoplayer.eventListeners.segmentSeekFunctionCallback);
+        }
+    });
+    it('should reset EventListeners in playerContext', () => {
+        removeEventListeners(context);
+        expect(context.npoplayer.eventListeners).toBeUndefined();
+    });
+});

package/lib/services/keyboardHandlers/resolvekeypress.d.ts

@@ -0,0 +1,2 @@
+import { PlayerContext } from '../../types/interfaces';
+export declare function resolveKeyPress(playerContext: PlayerContext, e: KeyboardEvent): void;

package/lib/services/keyboardHandlers/resolvekeypress.js

@@ -0,0 +1,49 @@
+import { ViewMode } from '../../types/interfaces';
+export function resolveKeyPress(playerContext, e) {
+    const isMuted = playerContext.player.isMuted() ?? false;
+    const isPaused = playerContext.player.isPaused() ?? false;
+    const viewMode = playerContext.player.getViewMode();
+    if (['Space', 'ArrowUp', 'ArrowDown'].includes(e.code))
+        e.preventDefault();
+    const actions = {
+        KeyM: () => (isMuted ? playerContext.player.unmute() : playerContext.player.mute()),
+        KeyF: () => viewMode === ViewMode.Fullscreen
+            ? playerContext.player.setViewMode(ViewMode.Inline)
+            : playerContext.player.setViewMode(ViewMode.Fullscreen),
+        Space: () => {
+            if (isPaused) {
+                playerContext.player.play().catch((error) => {
+                    console.error('Failed to play:', error);
+                });
+            }
+            else {
+                playerContext.player.pause();
+            }
+        },
+        ArrowUp: () => {
+            if (isMuted)
+                playerContext.player.unmute();
+            playerContext.npoplayer.increaseVolume();
+        },
+        ArrowDown: () => {
+            if (isMuted)
+                playerContext.player.unmute();
+            playerContext.npoplayer.decreaseVolume();
+        },
+        ArrowLeft: () => playerContext.npoplayer.goBackwards(10),
+        ArrowRight: () => playerContext.npoplayer.goForward(10),
+        Escape: () => {
+            const { settingsPanels } = playerContext.npoplayer.uiComponents;
+            if (settingsPanels && settingsPanels.length > 0) {
+                for (const panel of settingsPanels) {
+                    if (panel.isShown()) {
+                        panel.hide();
+                    }
+                }
+            }
+        }
+    };
+    const action = actions[e.code];
+    if (action)
+        action();
+}