@npo/player 1.23.1 → 1.24.0

package/lib/npoplayer.js

@@ -1,6 +1,5 @@
 import { NpoPlayerServices } from './services/services';
 import { Player, PlayerEvent } from 'bitmovin-player';
-import { UIManager } from 'bitmovin-player-ui';
 import AdsModuleBM from 'bitmovin-player/modules/bitmovinplayer-advertising-bitmovin';
 import { logEvent, initPlayerTracker, startPlayerTracker } from './js/tracking/playertracker';
 import { hidePlayNextScreen, showPlayNextScreenIfNeeded } from './ui/handlers/playnextscreen';
@@ -11,15 +10,12 @@ import { isJWTToken } from './js/utilities/utilities.jwt';
 import { isMediaUrl, isUrl } from './js/utilities/utilities.url';
 import { logVersion } from './js/utilities/utilities.version';
 import { getStreamDurationInSeconds } from './js/utilities/utilities.stream';
-import { customSpecificErrorMessageOverlayConfig } from './js/playeractions/handlers/customerrors';
-import { createUIContainer } from './ui/uicontainer';
 import { LogEmitter } from './types/classes';
-import { handlePreRolls } from './js/ads/ster';
+import { handlePreRolls } from './services/advertHandlers/handlePreRolls';
 import pkg from '../package.json';
 import { NpoPlayerUIVariants, LocalStorageValues } from './types/interfaces';
 import { nativeMobileUiFactory } from './ui/nativemobileuifactory';
 import { setupMediaSessionActionHandlers } from './js/playeractions/handlers/mediasessionactions';
-import { processStream } from './ui/handlers/streamhandler';
 import { removeReplayClass } from './js/playeractions/handlers/removereplayclass';
 import { showNicamAfterUiDelay } from './ui/handlers/nicamhandler';
 import { updateLiveMarkers } from './js/markers/updateLiveMarkers';
@@ -55,14 +51,17 @@ export default class NpoPlayer {
         this.container = _container;
         this.variant = _variant || NpoPlayerUIVariants.DEFAULT;
         initPlayerTracker(this, _npotag, _npotaginstance);
-        this.initPlayer(this.container, _playerConfig, this.variant);
+        this.initPlayer(this.container, _playerConfig);
     }
-    initPlayer(_container, playerConfig, variant) {
+    initPlayer(_container, playerConfig) {
         const processedPlayerConfig = playerAction.processPlayerConfig(this, playerConfig);
-        Player.addModule(getModuleExport(AdsModuleBM));
-        this.userPreferences = this.npoplayerServices.getStoredUserPrefs();
         this.player = new Player(_container, processedPlayerConfig);
+        Player.addModule(getModuleExport(AdsModuleBM));
         const npoPlayerAPI = new NpoPlayerAPI(this.player);
+        this.playerContext = { player: npoPlayerAPI, npoplayer: this };
+        this.userPreferences = this.npoplayerServices.getStoredUserPrefs();
+        this.npoplayerServices.handleUserPrefs(this.playerContext);
+        this.npoplayerServices.setAccessibilityAttributes(this.playerContext);
         window.addEventListener('beforeunload', () => {
             if (this.player) {
                 this.npoplayerServices.setStoredUserPrefs(LocalStorageValues.SUBTITLES_ENABLED, npoPlayerAPI.areSubtitlesEnabled().toString());
@@ -70,10 +69,6 @@ export default class NpoPlayer {
                 this.npoplayerServices.setStoredUserPrefs(LocalStorageValues.IS_MUTED, npoPlayerAPI.isMuted().toString());
             }
         });
-        this.playerContext = { player: npoPlayerAPI, npoplayer: this };
-        this.createUIManager(this.player, this.playerContext, variant);
-        this.npoplayerServices.handleUserPrefs(this.playerContext);
-        this.npoplayerServices.setAccessibilityAttributes(this.playerContext);
         this.container.addEventListener('keydown', (e) => {
             if (!this.playerContext)
                 return;
@@ -89,8 +84,8 @@ export default class NpoPlayer {
             return;
         }
         if (this.adBreakActive) {
-            console.error('Je kunt geen nieuwe content laden tijdens een reclameblok.');
-            return;
+            const currentAd = this.player.ads.getActiveAdBreak().id;
+            this.player.ads.discardAdBreak(currentAd);
         }
         let _streamObject;
         const sourceIsUrl = isUrl(source);
@@ -140,7 +135,7 @@ export default class NpoPlayer {
                 _streamObject = await getStreamObject(this, payload);
                 this.streamObject = _streamObject;
                 if (_streamObject) {
-                    await this.createUIManager(this.player, this.playerContext, this.variant);
+                    await this.playerContext.player.createUIManager(this.playerContext, this.variant);
                 }
             }
             catch (error) {
@@ -163,28 +158,28 @@ export default class NpoPlayer {
             const initAndStartTracker = () => {
                 if (this.player === null)
                     return;
-                this.player?.off(PlayerEvent.SourceLoaded, initAndStartTracker);
                 this.player?.off(PlayerEvent.AdBreakFinished, initAndStartTracker);
                 this.player?.off(PlayerEvent.AdError, initAndStartTracker);
                 streamDuration =
                     streamDuration == undefined
-                        ? this.player?.on(PlayerEvent.Ready, getDurationAndStartPlayerTracker)
+                        ? getDurationAndStartPlayerTracker()
                         : startPlayerTracker(this, getStreamDurationInSeconds({ duration: streamDuration, durationIsInMs: true }), this.version, streamPrid);
             };
-            if (this.variant !== NpoPlayerUIVariants.AUDIO &&
+            if (this.variant === NpoPlayerUIVariants.DEFAULT &&
                 this.streamObject.metadata.hasPreroll === 'true' &&
                 this.streamObject.assets.preroll) {
                 this.player.on(PlayerEvent.AdBreakFinished, initAndStartTracker);
                 this.player.on(PlayerEvent.AdError, initAndStartTracker);
-                await handlePreRolls(this.player, this.streamObject, this);
+                await handlePreRolls(this.playerContext);
             }
             else {
-                this.player.on(PlayerEvent.Ready, initAndStartTracker);
+                initAndStartTracker();
             }
         }
         else {
             this.doError(`Het is niet gelukt de stream op te halen: \n Input is geen valide token of media object.`, 500);
         }
+        this.npoplayerServices.handleVerticalVideoControls(this.playerContext, this.variant);
         if (this.sourceConfig?.metadata) {
             this.sourceConfig.metadata.jwt = source;
             this.sourceConfig.metadata.streamLinkAsJsonString = JSON.stringify(this.streamObject);
@@ -205,26 +200,12 @@ export default class NpoPlayer {
             showNicamAfterUiDelay(this.player, this.uiManager);
         });
         const setLiveOffsetListener = function () {
-            if (this.player === null)
+            if (this.playerContext === undefined)
                 return;
             this.player?.off(PlayerEvent.SourceLoaded, setLiveOffsetListener);
-            playerAction.handleLiveOffsetLogic(this, this.player, options);
+            playerAction.handleLiveOffsetLogic(this.playerContext, options);
         }.bind(this);
-        this.player.on(PlayerEvent.Ready, setLiveOffsetListener);
-    }
-    async createUIManager(player, playerContext, variant) {
-        if (this.uiManager === undefined || variant !== this.variant) {
-            const uiConfig = {
-                errorMessages: customSpecificErrorMessageOverlayConfig,
-                disableAutoHideWhenHovered: true,
-                seekbarSnappingEnabled: false
-            };
-            this.uiManager = new UIManager(player, createUIContainer(this, player, variant, this.container), uiConfig);
-            this.variant = variant;
-        }
-        else {
-            processStream(this.streamObject, this.container, this.streamOptions, player, this.uiManager, this.sourceConfig, playerContext);
-        }
+        this.player.on(PlayerEvent.SourceLoaded, setLiveOffsetListener);
     }
     doError(input, status) {
         if (this.player == undefined)
@@ -241,19 +222,19 @@ export default class NpoPlayer {
         this.playerContext?.player.pause();
     }
     setVolume(volume) {
-        if (this.player == undefined)
+        if (this.playerContext === undefined)
             return;
-        this.player.setVolume(volume);
+        this.playerContext.player.setVolume(volume);
     }
     increaseVolume() {
-        if (this.player == undefined)
+        if (this.playerContext === undefined)
             return;
-        this.setVolume(this.player.getVolume() + 10);
+        this.playerContext.player.increaseVolume();
     }
     decreaseVolume() {
-        if (this.player == undefined)
+        if (this.playerContext === undefined)
             return;
-        this.setVolume(this.player.getVolume() - 10);
+        this.playerContext.player.decreaseVolume();
     }
     goForward(seconds) {
         if (this.player == undefined)
@@ -276,9 +257,9 @@ export default class NpoPlayer {
         }
     }
     watchFromStart() {
-        if (this.player == undefined)
+        if (this.playerContext == undefined)
             return;
-        playerAction.shiftToProgramStart(this.player, this.streamOptions.liveProgramTime);
+        playerAction.shiftToProgramStart(this.playerContext, this.streamOptions.liveProgramTime);
     }
     showPlayNextScreen() {
         if (this.player == undefined || !this.streamOptions.playNext?.showPlayNext || this.adBreakActive)

package/lib/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@npo/player",
-  "version": "1.23.1",
+  "version": "1.24.0",
   "description": "NPO Player",
   "author": "Publieke Omroep <player@npo.nl>",
   "contributors": [
@@ -16,7 +16,7 @@
   "types": "./lib/npoplayer.d.ts",
   "scripts": {
     "build": "webpack --hot",
-    "build:scss": "npm run build:web-styles && npm run build:mobile-styles && mkdir -p dist && cp src/style/*.css dist && mkdir src/scss && cp src/style/*.css.map dist && cp src/style/*.css src/scss && cp src/style/*.css.map src/scss",
+    "build:scss": "npm run build:web-styles && npm run build:mobile-styles && mkdir -p dist && cp src/style/*.css dist && cp src/style/*.css.map dist && mkdir -p src/scss && cp src/style/*.css src/scss && cp src/style/*.css.map src/scss",
     "build:web-styles": "sass src/style/npoplayer.scss:src/style/npoplayer.css --style=compressed && postcss src/style/npoplayer.css --use autoprefixer postcss-import -o src/style/npoplayer.css",
     "build:mobile-styles": "sass src/style/npoplayer-mobile.scss:src/style/npoplayer-mobile.css --style=compressed && postcss src/style/npoplayer-mobile.css --use autoprefixer postcss-import -o src/style/npoplayer-mobile.css",
     "build:cdn": "npm run build && bash build-cdn.sh",
@@ -89,9 +89,9 @@
     "webpack-dev-server": "^4.11.1"
   },
   "dependencies": {
-    "@npotag/tag": "3.1.2",
-    "bitmovin-player": "8.166.0",
-    "bitmovin-player-ui": "3.64.0"
+    "@npotag/tag": "3.2.1",
+    "bitmovin-player": "8.173.0",
+    "bitmovin-player-ui": "3.67.0"
   },
   "browserslist": [
     "defaults",

package/lib/services/a11y/setup.js

@@ -1,8 +1,8 @@
-import { PlayerEvent } from 'bitmovin-player';
+import { NpoPlayerEvent } from '../../types/events';
 import { addAccessibilityAttributes } from '../../ui/handlers/accessibilityhandler';
 export function setupAccessibilityAttributes(playerContext) {
     const { player, npoplayer } = playerContext;
-    const events = [PlayerEvent.SourceLoaded, PlayerEvent.AdBreakFinished, PlayerEvent.AdError];
+    const events = [NpoPlayerEvent.SourceLoaded, NpoPlayerEvent.AdBreakFinished, NpoPlayerEvent.AdError];
     const triggerAddAccessibilityAttributes = () => {
         for (const event of events) {
             player?.off(event, triggerAddAccessibilityAttributes);

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

@@ -1,4 +1,4 @@
-import { PlayerEvent } from 'bitmovin-player';
+import { NpoPlayerEvent } from '../../types/events';
 import { addAccessibilityAttributes } from '../../ui/handlers/accessibilityhandler';
 import { setupAccessibilityAttributes } from './setup';
 import { mockNpoPlayer } from '../../../tests/mocks/mockNpoplayer';
@@ -44,7 +44,6 @@ describe('setupAccessibilityAttributes', () => {
                 playerConfig: {},
                 initPlayer: () => { },
                 loadStream: () => Promise.resolve(),
-                createUIManager: async () => { },
                 doError: () => { },
                 play: async () => { },
                 pause: () => { },
@@ -87,18 +86,18 @@ describe('setupAccessibilityAttributes', () => {
     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));
+        expect(mockAddEventListener).toHaveBeenCalledWith(NpoPlayerEvent.SourceLoaded, expect.any(Function));
+        expect(mockAddEventListener).toHaveBeenCalledWith(NpoPlayerEvent.AdBreakFinished, expect.any(Function));
+        expect(mockAddEventListener).toHaveBeenCalledWith(NpoPlayerEvent.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);
+        expect(mockRemoveEventListener).toHaveBeenCalledWith(NpoPlayerEvent.SourceLoaded, triggerFunction);
+        expect(mockRemoveEventListener).toHaveBeenCalledWith(NpoPlayerEvent.AdBreakFinished, triggerFunction);
+        expect(mockRemoveEventListener).toHaveBeenCalledWith(NpoPlayerEvent.AdError, triggerFunction);
     });
     it('should call addAccessibilityAttributes with the correct parameters', () => {
         setupAccessibilityAttributes(playerContext);

package/lib/services/advertHandlers/handlePreRolls.d.ts

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

package/lib/services/advertHandlers/handlePreRolls.js

@@ -0,0 +1,132 @@
+import { AdTagType } from 'bitmovin-player';
+import { NpoPlayerUIVariants } from '../../types/interfaces';
+import { NpoPlayerEvent } from '../../types/events';
+export async function handlePreRolls(playerContext) {
+    return new Promise((resolve) => {
+        if (playerContext.npoplayer.streamObject.metadata.hasPreroll == 'false' ||
+            playerContext.npoplayer.streamObject.assets.preroll == undefined) {
+            resolve();
+            return;
+        }
+        const prerollUrl = playerContext.npoplayer.streamObject.assets.preroll;
+        let adIndex = 0;
+        let totalAds = 0;
+        let currentClickListener;
+        let adUiSet = false;
+        async function handleReady() {
+            playerContext.player.off(NpoPlayerEvent.Ready, handleReady);
+            const advertConfig = {
+                tag: {
+                    url: String(prerollUrl),
+                    type: AdTagType.VAST
+                },
+                id: 'Ad',
+                position: 'pre'
+            };
+            await playerContext.player.scheduleAds(advertConfig);
+        }
+        playerContext.player.on(NpoPlayerEvent.Ready, handleReady);
+        async function handlePlay() {
+            playerContext.player.off(NpoPlayerEvent.Play, handlePlay);
+            attemptSetAdUi();
+        }
+        playerContext.player.on(NpoPlayerEvent.Play, handlePlay);
+        function setAdUi() {
+            const activeAdBreak = playerContext.player.getActiveAdBreak();
+            if (!activeAdBreak || !activeAdBreak.ads)
+                return false;
+            playerContext.npoplayer.uiManager?.release();
+            playerContext.npoplayer.uiManager = undefined;
+            if (playerContext.npoplayer.playerContext) {
+                playerContext.player.createUIManager(playerContext, NpoPlayerUIVariants.AD);
+            }
+            adUiSet = true;
+            const adButton = playerContext.npoplayer.uiComponents.adbutton;
+            const currentAd = activeAdBreak.ads[0];
+            adIndex = 1;
+            totalAds = activeAdBreak.ads.length;
+            if (adButton) {
+                adButton.show();
+                adClickHandler(currentAd, adButton);
+            }
+            playerContext.npoplayer.uiComponents.adlabel?.setText(`Advertentie 1 van ${activeAdBreak.ads.length}`);
+            return true;
+        }
+        function attemptSetAdUi(attemptsLeft = 10) {
+            if (attemptsLeft <= 0)
+                return;
+            if (!adUiSet) {
+                setAdUi();
+                setTimeout(() => {
+                    attemptSetAdUi(attemptsLeft - 1);
+                }, 200);
+            }
+        }
+        function handleAdStarted() {
+            playerContext.player.off(NpoPlayerEvent.AdStarted, handleAdStarted);
+            const activeAdBreak = playerContext.player.getActiveAdBreak();
+            if (!activeAdBreak || !activeAdBreak.ads) {
+                console.error('No active ad break data found');
+                return;
+            }
+            if (!adUiSet)
+                attemptSetAdUi();
+            playerContext.npoplayer.adBreakActive = true;
+        }
+        playerContext.player.on(NpoPlayerEvent.AdStarted, handleAdStarted);
+        function adClickHandler(ad, button) {
+            const clickThroughCallback = ad.clickThroughUrlOpened;
+            if (currentClickListener)
+                button.onClick.unsubscribe(currentClickListener);
+            currentClickListener = () => {
+                try {
+                    window.open(ad.clickThroughUrl, '_blank');
+                    playerContext.player.pause();
+                    if (clickThroughCallback)
+                        clickThroughCallback();
+                }
+                catch (error) {
+                    console.log(error);
+                }
+            };
+            button.onClick.subscribe(currentClickListener);
+        }
+        function handleAdFinished() {
+            playerContext.player.off(NpoPlayerEvent.AdFinished, handleAdFinished);
+            const activeAdBreak = playerContext.player.getActiveAdBreak();
+            if (!activeAdBreak || !activeAdBreak.ads) {
+                console.error('No active ad break data found');
+                return;
+            }
+            if (adIndex >= totalAds) {
+                handleAdBreakFinished();
+                return;
+            }
+            const adButton = playerContext.npoplayer.uiComponents.adbutton;
+            const nextAd = activeAdBreak.ads[adIndex];
+            adIndex += 1;
+            if (adButton) {
+                adButton.show();
+                adClickHandler(nextAd, adButton);
+            }
+            playerContext.npoplayer.uiComponents.adlabel?.setText(`Advertentie ${adIndex} van ${activeAdBreak.ads.length}`);
+        }
+        playerContext.player.on(NpoPlayerEvent.AdFinished, handleAdFinished);
+        function handleAdBreakFinished() {
+            playerContext.player.off(NpoPlayerEvent.AdBreakFinished, handleAdBreakFinished);
+            playerContext.player.off(NpoPlayerEvent.AdError, handleAdBreakFinished);
+            playerContext.npoplayer.adBreakActive = false;
+            playerContext.npoplayer.uiComponents.adbutton?.hide();
+            playerContext.npoplayer.uiComponents.adlabel?.hide();
+            playerContext.npoplayer.uiManager?.release();
+            playerContext.npoplayer.uiManager = undefined;
+            if (playerContext.npoplayer.playerContext) {
+                playerContext.player.createUIManager(playerContext, NpoPlayerUIVariants.DEFAULT);
+            }
+            adUiSet = false;
+            resolve();
+        }
+        playerContext.player.on(NpoPlayerEvent.AdBreakFinished, handleAdBreakFinished);
+        playerContext.player.on(NpoPlayerEvent.AdError, handleAdBreakFinished);
+    });
+}

package/lib/services/advertHandlers/handlePrerolls.test.js

@@ -0,0 +1,52 @@
+import { handlePreRolls } from './handlePreRolls';
+import { createMockNpoPlayer, createPlayerContextMock } from '../../../tests/mocks/playerContextMock';
+jest.mock('bitmovin-player');
+jest.mock('../../npoplayer');
+describe('handlePreRolls', () => {
+    let mockPlayerAPI;
+    beforeEach(() => {
+        mockPlayerAPI = {
+            ads: {
+                schedule: jest.fn().mockResolvedValue(true),
+                getActiveAdBreak: jest.fn()
+            },
+            on: jest.fn(),
+            off: jest.fn()
+        };
+    });
+    it('should not schedule ads when hasPreroll is false', async () => {
+        const npoplayerMock = createMockNpoPlayer({
+            streamObject: {
+                metadata: {
+                    hasPreroll: 'false'
+                },
+                assets: {
+                    preroll: 'sample_url'
+                }
+            }
+        });
+        const playerContextMock = createPlayerContextMock({
+            npoplayer: npoplayerMock
+        });
+        await handlePreRolls(playerContextMock);
+        expect(mockPlayerAPI.ads.schedule).not.toHaveBeenCalled();
+    });
+    it('should not schedule ads if preroll URL is missing', async () => {
+        const npoplayerMock = createMockNpoPlayer({
+            streamObject: {
+                metadata: {
+                    hasPreroll: 'true'
+                },
+                assets: {}
+            }
+        });
+        const playerContextMock = createPlayerContextMock({
+            npoplayer: npoplayerMock
+        });
+        await handlePreRolls(playerContextMock);
+        expect(mockPlayerAPI.ads.schedule).not.toHaveBeenCalled();
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+});

package/lib/services/cdnProviders/cdnProviders.d.ts

@@ -0,0 +1,4 @@
+export type CdnProvider = 'NEP-FASTLY' | 'NEP' | 'NEP-LSW' | 'EUROVISION' | 'KPN' | 'AKEMAI' | 'OMROEP-ICECAST' | 'OMROEP-CONTENT' | 'OMROEP-PODCAST' | 'OMROEP-VIDEO' | 'OMROEP-DOWNLOAD' | 'NOS' | 'NPOAUDIO';
+export declare function createImmutableMap(entries: [string, CdnProvider][]): ReadonlyMap<string, CdnProvider>;
+export declare const npoCdnProvidersData: [string, CdnProvider][];
+export declare const npoCdnProviders: ReadonlyMap<string, CdnProvider>;

package/lib/services/cdnProviders/cdnProviders.js

@@ -0,0 +1,22 @@
+export function createImmutableMap(entries) {
+    const map = new Map(entries);
+    return Object.freeze(map);
+}
+export const npoCdnProvidersData = [
+    ['nep.global.ssl.fastly.net', 'NEP-FASTLY'],
+    ['npo-fsly.cdn.streamgate.io', 'NEP-FASTLY'],
+    ['cdn.streamgate.nl', 'NEP'],
+    ['pr.lswcdn.net', 'NEP-LSW'],
+    ['cdn.eurovisioncdn.net', 'EUROVISION'],
+    ['npo.prd.cdn.bcms.kpn.com', 'KPN'],
+    ['cdn.bcms.kpn.com', 'KPN'],
+    ['Akamai', 'AKEMAI'],
+    ['icecast.omroep.nl', 'OMROEP-ICECAST'],
+    ['content.omroep.nl', 'OMROEP-CONTENT'],
+    ['podcast.npo.nl', 'OMROEP-PODCAST'],
+    ['video.omroep.nl', 'OMROEP-VIDEO'],
+    ['download.omroep.nl', 'OMROEP-DOWNLOAD'],
+    ['download.nos.nl', 'NOS'],
+    ['entry.cdn.npoaudio.nl', 'NPOAUDIO']
+];
+export const npoCdnProviders = createImmutableMap(npoCdnProvidersData);

package/lib/services/cdnProviders/cndProviders.test.js

@@ -0,0 +1,22 @@
+import { createImmutableMap, npoCdnProviders, npoCdnProvidersData } from './cdnProviders';
+describe('createImmutableMap function', () => {
+    it('should create an immutable map with correct entries', () => {
+        const testEntries = [
+            ['test1.com', 'AKEMAI'],
+            ['test2.com', 'EUROVISION'],
+            ['test3.com', 'KPN']
+        ];
+        const immutableMap = createImmutableMap(testEntries);
+        for (const [key, value] of testEntries) {
+            expect(immutableMap.get(key)).toBe(value);
+        }
+    });
+});
+describe('npoCdnProviders map', () => {
+    it('should match the expected contents', () => {
+        expect(npoCdnProviders.size).toBe(npoCdnProvidersData.length);
+        for (const [key, value] of npoCdnProvidersData) {
+            expect(npoCdnProviders.get(key)).toBe(value);
+        }
+    });
+});

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

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

package/lib/services/eventListenerHandlers/removeEventListeners.js

@@ -1,12 +1,12 @@
-import { PlayerEvent } from 'bitmovin-player';
+import { NpoPlayerEvent } from '../../types/events';
 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 }
+            { event: NpoPlayerEvent.TimeChanged, callback: liveStreamHandleTimeChangedCallback },
+            { event: NpoPlayerEvent.TimeChanged, callback: segmentHandleTimeChangedCallback },
+            { event: NpoPlayerEvent.Seek, callback: segmentSeekFunctionCallback }
         ];
         for (const { event, callback } of eventMapping) {
             if (callback) {

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

@@ -1,27 +1,42 @@
-import { PlayerEvent } from 'bitmovin-player';
-import { mockPlayerContext } from '../../../tests/mocks/mockPlayerContext';
+import { NpoPlayerEvent } from '../../types/events';
 import { removeEventListeners } from './removeEventListeners';
+import createPlayerContextMock from '../../../tests/mocks/playerContextMock';
 describe('removeEventListeners', () => {
-    let context;
+    let mockPlayerContext;
     beforeEach(() => {
-        context = { ...mockPlayerContext };
         jest.clearAllMocks();
+        mockPlayerContext = createPlayerContextMock();
     });
     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);
+        mockPlayerContext.npoplayer.eventListeners = {
+            segmentHandleTimeChangedCallback: jest.fn(),
+            liveStreamHandleTimeChangedCallback: jest.fn(),
+            segmentSeekFunctionCallback: jest.fn()
+        };
+        removeEventListeners(mockPlayerContext);
+        if (mockPlayerContext.npoplayer.eventListeners) {
+            expect(mockPlayerContext.player.off).toHaveBeenCalledWith(NpoPlayerEvent.TimeChanged, mockPlayerContext.npoplayer.eventListeners.segmentHandleTimeChangedCallback);
+            expect(mockPlayerContext.player.off).toHaveBeenCalledWith(NpoPlayerEvent.TimeChanged, mockPlayerContext.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);
+        mockPlayerContext.npoplayer.eventListeners = {
+            segmentHandleTimeChangedCallback: jest.fn(),
+            liveStreamHandleTimeChangedCallback: jest.fn(),
+            segmentSeekFunctionCallback: jest.fn()
+        };
+        removeEventListeners(mockPlayerContext);
+        if (mockPlayerContext.npoplayer.eventListeners) {
+            expect(mockPlayerContext.player.off).toHaveBeenCalledWith(NpoPlayerEvent.Seek, mockPlayerContext.npoplayer.eventListeners.segmentSeekFunctionCallback);
         }
     });
     it('should reset EventListeners in playerContext', () => {
-        removeEventListeners(context);
-        expect(context.npoplayer.eventListeners).toBeUndefined();
+        mockPlayerContext.npoplayer.eventListeners = {
+            segmentHandleTimeChangedCallback: jest.fn(),
+            liveStreamHandleTimeChangedCallback: jest.fn(),
+            segmentSeekFunctionCallback: jest.fn()
+        };
+        removeEventListeners(mockPlayerContext);
+        expect(mockPlayerContext.npoplayer.eventListeners).toBeUndefined();
     });
 });

package/lib/services/liveStreamHandlers/handleLiveStreamControls.d.ts

@@ -1,4 +1,4 @@
-import { PlayerContext } from 'types/interfaces';
+import { PlayerContext } from '../../types/interfaces';
 export declare const handleLiveStreamControls: (playerContext: PlayerContext) => void;
 export declare function updateForwardButtonState(player: any): void;
 export declare function toggleForwardButtons(forwardButtons: NodeListOf<Element>, timeShift: number): void;

package/lib/services/liveStreamHandlers/handleLiveStreamControls.js

@@ -1,8 +1,8 @@
-import { PlayerEvent } from 'bitmovin-player';
+import { NpoPlayerEvent } from '../../types/events';
 export const handleLiveStreamControls = (playerContext) => {
     const liveStreamHandleTimeChangedCallback = () => updateForwardButtonState(playerContext.player);
     const { player, npoplayer } = playerContext;
-    player.on(PlayerEvent.TimeChanged, liveStreamHandleTimeChangedCallback);
+    player.on(NpoPlayerEvent.TimeChanged, liveStreamHandleTimeChangedCallback);
     npoplayer.eventListeners = {
         liveStreamHandleTimeChangedCallback
     };
@@ -10,7 +10,7 @@ export const handleLiveStreamControls = (playerContext) => {
 export function updateForwardButtonState(player) {
     const timeShift = player?.getTimeShift();
     const forwardButtons = player?.getContainer().querySelectorAll('.bmpui-ui-forwardbutton');
-    player.off(PlayerEvent.TimeChanged, () => {
+    player.off(NpoPlayerEvent.TimeChanged, () => {
         updateForwardButtonState(player);
     });
     if (forwardButtons && timeShift !== undefined) {

package/lib/services/liveStreamHandlers/handleLiveStreamControls.test.d.ts

@@ -0,0 +1,2 @@
+import '@testing-library/jest-dom';
+export declare const TIME_SHIFT_THRESHOLD = -10;