@npo/player 1.24.7 → 1.26.0

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

@@ -2,59 +2,71 @@ import createPlayerContextMock, { createMockNpoPlayer, createMockNpoPlayerAPI }
 import { discardAdBreak } from './discardAdBreak';
 describe('discardAdBreak', () => {
     let mockNpoPlayerAPI;
-    let npoplayerMock;
+    let npoPlayerMock;
     const activeAdBreakMock = { id: 'ad-break-id' };
     afterEach(() => {
         jest.resetAllMocks();
     });
+    it('should not discard ad break if player is undefined', () => {
+        npoPlayerMock = createMockNpoPlayer({
+            adBreakActive: true
+        });
+        const playerContextMock = createPlayerContextMock({
+            player: undefined,
+            npoPlayer: npoPlayerMock
+        });
+        discardAdBreak(playerContextMock);
+        expect(npoPlayerMock.adBreakActive).toBe(true);
+    });
     it('should not discard ad break if adBreakActive is false', () => {
         mockNpoPlayerAPI = createMockNpoPlayerAPI({
-            getActiveAdBreak: jest.fn().mockReturnValue(undefined),
+            getActiveAdBreak: jest.fn().mockReturnValue(activeAdBreakMock),
             discardAdBreak: jest.fn()
         });
-        npoplayerMock = createMockNpoPlayer({
+        npoPlayerMock = createMockNpoPlayer({
             adBreakActive: false
         });
         const playerContextMock = createPlayerContextMock({
             player: mockNpoPlayerAPI,
-            npoplayer: npoplayerMock
+            npoPlayer: npoPlayerMock
         });
         discardAdBreak(playerContextMock);
         expect(mockNpoPlayerAPI.getActiveAdBreak).not.toHaveBeenCalled();
-        expect(mockNpoPlayerAPI.discardAdBreak).not.toHaveBeenCalled();
+        expect(mockNpoPlayerAPI.playerAPI.ads.discardAdBreak).not.toHaveBeenCalled();
+        expect(npoPlayerMock.adBreakActive).toBe(false);
     });
     it('should discard active ad break if adBreakActive is true and ad break exists', () => {
         mockNpoPlayerAPI = createMockNpoPlayerAPI({
             getActiveAdBreak: jest.fn().mockReturnValue(activeAdBreakMock),
             discardAdBreak: jest.fn()
         });
-        npoplayerMock = createMockNpoPlayer({
+        npoPlayerMock = createMockNpoPlayer({
             adBreakActive: true
         });
         const playerContextMock = createPlayerContextMock({
             player: mockNpoPlayerAPI,
-            npoplayer: npoplayerMock
+            npoPlayer: npoPlayerMock
         });
         discardAdBreak(playerContextMock);
         expect(mockNpoPlayerAPI.getActiveAdBreak).toHaveBeenCalled();
-        expect(mockNpoPlayerAPI.discardAdBreak).toHaveBeenCalledWith(activeAdBreakMock.id);
-        expect(npoplayerMock.adBreakActive).toBe(false);
+        expect(mockNpoPlayerAPI.playerAPI.ads.discardAdBreak).toHaveBeenCalledWith(activeAdBreakMock.id);
+        expect(npoPlayerMock.adBreakActive).toBe(false);
     });
     it('should not discard ad break if active ad break does not exist', () => {
         mockNpoPlayerAPI = createMockNpoPlayerAPI({
             getActiveAdBreak: jest.fn().mockReturnValue(undefined),
             discardAdBreak: jest.fn()
         });
-        npoplayerMock = createMockNpoPlayer({
+        npoPlayerMock = createMockNpoPlayer({
             adBreakActive: true
         });
         const playerContextMock = createPlayerContextMock({
             player: mockNpoPlayerAPI,
-            npoplayer: npoplayerMock
+            npoPlayer: npoPlayerMock
         });
         discardAdBreak(playerContextMock);
         expect(mockNpoPlayerAPI.getActiveAdBreak).toHaveBeenCalled();
-        expect(mockNpoPlayerAPI.discardAdBreak).not.toHaveBeenCalled();
-        expect(npoplayerMock.adBreakActive).toBe(false);
+        expect(mockNpoPlayerAPI.playerAPI.ads.discardAdBreak).not.toHaveBeenCalled();
+        expect(npoPlayerMock.adBreakActive).toBe(false);
     });
 });

package/lib/services/advertHandlers/handlePreRolls.js

@@ -3,12 +3,12 @@ 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) {
+        if (playerContext.npoPlayer.streamObject.metadata.hasPreroll == 'false' ||
+            playerContext.npoPlayer.streamObject.assets.preroll == undefined) {
             resolve();
             return;
         }
-        const prerollUrl = playerContext.npoplayer.streamObject.assets.preroll;
+        const prerollUrl = playerContext.npoPlayer.streamObject.assets.preroll;
         let adIndex = 0;
         let totalAds = 0;
         let currentClickListener;
@@ -35,13 +35,13 @@ export async function handlePreRolls(playerContext) {
             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);
+            playerContext.npoPlayer.uiManager?.release();
+            playerContext.npoPlayer.uiManager = undefined;
+            if (playerContext.npoPlayer.playerContext) {
+                void playerContext.player.createUIManager(playerContext, NpoPlayerUIVariants.AD);
             }
             adUiSet = true;
-            const adButton = playerContext.npoplayer.uiComponents.adbutton;
+            const adButton = playerContext.npoPlayer.uiComponents.adbutton;
             const currentAd = activeAdBreak.ads[0];
             adIndex = 1;
             totalAds = activeAdBreak.ads.length;
@@ -49,7 +49,7 @@ export async function handlePreRolls(playerContext) {
                 adButton.show();
                 adClickHandler(currentAd, adButton);
             }
-            playerContext.npoplayer.uiComponents.adlabel?.setText(`Advertentie 1 van ${activeAdBreak.ads.length}`);
+            playerContext.npoPlayer.uiComponents.adlabel?.setText(`Advertentie 1 van ${activeAdBreak.ads.length}`);
             return true;
         }
         function attemptSetAdUi(attemptsLeft = 10) {
@@ -71,7 +71,7 @@ export async function handlePreRolls(playerContext) {
             }
             if (!adUiSet)
                 attemptSetAdUi();
-            playerContext.npoplayer.adBreakActive = true;
+            playerContext.npoPlayer.adBreakActive = true;
         }
         playerContext.player.on(NpoPlayerEvent.AdStarted, handleAdStarted);
         function adClickHandler(ad, button) {
@@ -102,26 +102,26 @@ export async function handlePreRolls(playerContext) {
                 handleAdBreakFinished();
                 return;
             }
-            const adButton = playerContext.npoplayer.uiComponents.adbutton;
+            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.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);
+            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) {
+                void playerContext.player.createUIManager(playerContext, NpoPlayerUIVariants.DEFAULT);
             }
             adUiSet = false;
             resolve();

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

@@ -15,7 +15,7 @@ describe('handlePreRolls', () => {
         };
     });
     it('should not schedule ads when hasPreroll is false', async () => {
-        const npoplayerMock = createMockNpoPlayer({
+        const npoPlayerMock = createMockNpoPlayer({
             streamObject: {
                 metadata: {
                     hasPreroll: 'false'
@@ -26,13 +26,13 @@ describe('handlePreRolls', () => {
             }
         });
         const playerContextMock = createPlayerContextMock({
-            npoplayer: npoplayerMock
+            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({
+        const npoPlayerMock = createMockNpoPlayer({
             streamObject: {
                 metadata: {
                     hasPreroll: 'true'
@@ -41,7 +41,7 @@ describe('handlePreRolls', () => {
             }
         });
         const playerContextMock = createPlayerContextMock({
-            npoplayer: npoplayerMock
+            npoPlayer: npoPlayerMock
         });
         await handlePreRolls(playerContextMock);
         expect(mockPlayerAPI.ads.schedule).not.toHaveBeenCalled();

package/lib/services/cdnProviders/cdnProviders.js

@@ -2,9 +2,11 @@ export function createImmutableMap(entries) {
     const map = new Map(entries);
     return Object.freeze(map);
 }
+const nepFastlyProvider = 'NEP-FASTLY';
 export const npoCdnProvidersData = [
-    ['nep.global.ssl.fastly.net', 'NEP-FASTLY'],
-    ['npo-fsly.cdn.streamgate.io', 'NEP-FASTLY'],
+    ['nep.global.ssl.fastly.net', nepFastlyProvider],
+    ['npo-fsly.cdn.streamgate.io', nepFastlyProvider],
+    ['npo-fsly-2.cdn.streamgate.io', nepFastlyProvider],
     ['cdn.streamgate.nl', 'NEP'],
     ['pr.lswcdn.net', 'NEP-LSW'],
     ['cdn.eurovisioncdn.net', 'EUROVISION'],

package/lib/services/drmHandlers/decideprofile.js

@@ -5,7 +5,7 @@ export async function decideProfile(playerContext, preferredDRM = '') {
         console.error('No player detected');
         return { profileName: '', drm: '' };
     }
-    const player = playerContext.player;
+    const { player } = playerContext;
     const supportedTech = player.getSupportedTech();
     const supportedDRM = await player.getSupportedDRM();
     const isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);

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

@@ -13,7 +13,7 @@ describe('decideProfile', () => {
                 .fn()
                 .mockResolvedValue(['com.widevine.alpha', 'com.microsoft.playready', 'com.apple.fps.1_0'])
         };
-        mockPlayerContext = { player: mockPlayer, npoplayer: mockNpoplayer };
+        mockPlayerContext = { player: mockPlayer, npoPlayer: mockNpoplayer };
     });
     afterEach(() => {
         jest.clearAllMocks();

package/lib/services/drmHandlers/verifydrm.js

@@ -2,7 +2,7 @@ import { convertJwtToBase64, convertBase64ToObject } from '../../js/utilities/ut
 import { getStreamObject } from '../../js/api/getstreamobject';
 export async function verifyDRM(playerContext, payload) {
     try {
-        const { player, npoplayer: { streamObject, sourceConfig } } = playerContext;
+        const { player, npoPlayer: { streamObject, sourceConfig } } = playerContext;
         const { stream } = streamObject;
         if (stream.drmToken) {
             const drmJsonTimestamp = getDRMTokenTimestamp(stream.drmToken);
@@ -29,12 +29,12 @@ function getDRMTokenTimestamp(drmToken) {
     return convertBase64ToObject(drmBase64).iat;
 }
 async function refreshDRMToken(playerContext, payload) {
-    const backupStreamObject = await getStreamObject(playerContext.npoplayer, 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,
+        stream: { ...playerContext.npoPlayer.streamObject.stream, drmToken: newDrmToken }
     };
-    playerContext.npoplayer.streamObject = clonedStreamObject;
-    await loadPlayer(playerContext, playerContext.npoplayer.sourceConfig);
+    playerContext.npoPlayer.streamObject = clonedStreamObject;
+    await loadPlayer(playerContext, playerContext.npoPlayer.sourceConfig);
 }

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

@@ -18,7 +18,7 @@ beforeEach(() => {
         streamObject: { stream: { drmToken: undefined } },
         load: jest.fn()
     };
-    mockPlayerContext = { player: mockPlayer, npoplayer: mockNpoplayer };
+    mockPlayerContext = { player: mockPlayer, npoPlayer: mockNpoplayer };
 });
 afterEach(() => {
     jest.clearAllMocks();
@@ -42,7 +42,7 @@ describe('Test DRM verification', () => {
             streamURL: '',
             drmToken: drmToken
         };
-        mockPlayerContext.npoplayer.sourceConfig = sourceConfig;
+        mockPlayerContext.npoPlayer.sourceConfig = sourceConfig;
         jest.spyOn(global.Date, 'now').mockImplementation(() => currentTime * 1000);
         convertJwtToBase64.mockReturnValue(JSON.stringify({ iat: drmJsonTimestamp }));
         convertBase64ToObject.mockReturnValue({ iat: drmJsonTimestamp });
@@ -62,14 +62,14 @@ describe('Test DRM verification', () => {
             streamURL: '',
             drmToken: drmToken
         };
-        mockPlayerContext.npoplayer.sourceConfig = sourceConfig;
+        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(getStreamObject).toHaveBeenCalledWith(mockPlayerContext.npoPlayer, payload);
         expect(mockPlayerContext.player.load).toHaveBeenCalledWith(sourceConfig);
     });
     it('should call loadPlayer when the drmToken is null', async () => {
@@ -82,7 +82,7 @@ describe('Test DRM verification', () => {
             streamURL: '',
             drmToken: undefined
         };
-        mockPlayerContext.npoplayer.sourceConfig = sourceConfig;
+        mockPlayerContext.npoPlayer.sourceConfig = sourceConfig;
         await verifyDRM(mockPlayerContext, payload);
         expect(mockPlayerContext.player.load).toHaveBeenCalledWith(sourceConfig);
     });

package/lib/services/eventListenerHandlers/removeEventListeners.js

@@ -1,6 +1,6 @@
 import { NpoPlayerEvent } from '../../types/events';
 export const removeEventListeners = (playerContext) => {
-    const { eventListeners } = playerContext.npoplayer;
+    const { eventListeners } = playerContext.npoPlayer;
     if (eventListeners) {
         const { segmentHandleTimeChangedCallback, segmentSeekFunctionCallback, liveStreamHandleTimeChangedCallback } = eventListeners;
         const eventMapping = [
@@ -13,6 +13,6 @@ export const removeEventListeners = (playerContext) => {
                 playerContext.player.off(event, callback);
             }
         }
-        playerContext.npoplayer.eventListeners = undefined;
+        playerContext.npoPlayer.eventListeners = undefined;
     }
 };

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

@@ -8,35 +8,35 @@ describe('removeEventListeners', () => {
         mockPlayerContext = createPlayerContextMock();
     });
     it('should remove TimeChanged event listener if exists', () => {
-        mockPlayerContext.npoplayer.eventListeners = {
+        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);
+        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', () => {
-        mockPlayerContext.npoplayer.eventListeners = {
+        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);
+        if (mockPlayerContext.npoPlayer.eventListeners) {
+            expect(mockPlayerContext.player.off).toHaveBeenCalledWith(NpoPlayerEvent.Seek, mockPlayerContext.npoPlayer.eventListeners.segmentSeekFunctionCallback);
         }
     });
     it('should reset EventListeners in playerContext', () => {
-        mockPlayerContext.npoplayer.eventListeners = {
+        mockPlayerContext.npoPlayer.eventListeners = {
             segmentHandleTimeChangedCallback: jest.fn(),
             liveStreamHandleTimeChangedCallback: jest.fn(),
             segmentSeekFunctionCallback: jest.fn()
         };
         removeEventListeners(mockPlayerContext);
-        expect(mockPlayerContext.npoplayer.eventListeners).toBeUndefined();
+        expect(mockPlayerContext.npoPlayer.eventListeners).toBeUndefined();
     });
 });

package/lib/services/keyboardHandlers/resolvekeypress.js

@@ -23,17 +23,17 @@ export function resolveKeyPress(playerContext, e) {
         ArrowUp: () => {
             if (isMuted)
                 playerContext.player.unmute();
-            playerContext.npoplayer.increaseVolume();
+            playerContext.npoPlayer.increaseVolume();
         },
         ArrowDown: () => {
             if (isMuted)
                 playerContext.player.unmute();
-            playerContext.npoplayer.decreaseVolume();
+            playerContext.npoPlayer.decreaseVolume();
         },
-        ArrowLeft: () => playerContext.npoplayer.goBackwards(10),
-        ArrowRight: () => playerContext.npoplayer.goForward(10),
+        ArrowLeft: () => playerContext.npoPlayer.goBackwards(10),
+        ArrowRight: () => playerContext.npoPlayer.goForward(10),
         Escape: () => {
-            const { settingsPanels } = playerContext.npoplayer.uiComponents;
+            const { settingsPanels } = playerContext.npoPlayer.uiComponents;
             if (settingsPanels && settingsPanels.length > 0) {
                 for (const panel of settingsPanels) {
                     if (panel.isShown()) {

package/lib/services/keyboardHandlers/resolvekeypress.test.js

@@ -32,7 +32,7 @@ describe('resolveKeyPress', () => {
             })
         };
         e = new KeyboardEvent('keydown');
-        mockPlayerContext = { player: mockPlayer, npoplayer: mockNpoplayer };
+        mockPlayerContext = { player: mockPlayer, npoPlayer: mockNpoplayer };
     });
     it('should mute/unmute the player when "KeyM" is pressed', () => {
         mockPlayer.isMuted.mockReturnValue(true);

package/lib/services/liveStreamHandlers/handleLiveStreamControls.js

@@ -1,9 +1,9 @@
 import { NpoPlayerEvent } from '../../types/events';
 export const handleLiveStreamControls = (playerContext) => {
     const liveStreamHandleTimeChangedCallback = () => updateForwardButtonState(playerContext.player);
-    const { player, npoplayer } = playerContext;
+    const { player, npoPlayer } = playerContext;
     player.on(NpoPlayerEvent.TimeChanged, liveStreamHandleTimeChangedCallback);
-    npoplayer.eventListeners = {
+    npoPlayer.eventListeners = {
         liveStreamHandleTimeChangedCallback
     };
 };

package/lib/services/liveStreamHandlers/handleLiveStreamControls.test.js

@@ -11,8 +11,8 @@ describe('handleLiveStreamControls', () => {
     });
     it('should add TimeChanged event listener and store it in eventListeners', () => {
         handleLiveStreamControls(mockPlayerContext);
-        expect(mockPlayerContext.player.on).toHaveBeenCalledWith(NpoPlayerEvent.TimeChanged, mockPlayerContext.npoplayer.eventListeners?.liveStreamHandleTimeChangedCallback);
-        expect(mockPlayerContext.npoplayer.eventListeners?.liveStreamHandleTimeChangedCallback).toBeDefined();
+        expect(mockPlayerContext.player.on).toHaveBeenCalledWith(NpoPlayerEvent.TimeChanged, mockPlayerContext.npoPlayer.eventListeners?.liveStreamHandleTimeChangedCallback);
+        expect(mockPlayerContext.npoPlayer.eventListeners?.liveStreamHandleTimeChangedCallback).toBeDefined();
     });
 });
 describe('updateForwardButtonState', () => {

package/lib/services/localStorageHandlers/localStorageHandlers.js

@@ -18,7 +18,7 @@ export function getLocalStorage() {
 }
 export function setValuesBasedOnLocalStorage(playerContext) {
     const localStorageData = getLocalStorage();
-    const player = playerContext.player;
+    const { player } = playerContext;
     if (!player) {
         console.error('Player is undefined in playerContext');
         return;
@@ -28,6 +28,6 @@ export function setValuesBasedOnLocalStorage(playerContext) {
         player.mute();
     }
     if (localStorageData.subtitles_enabled === 'true') {
-        playerContext.npoplayer.streamOptions.enableSubtitles = true;
+        playerContext.npoPlayer.streamOptions.enableSubtitles = true;
     }
 }

package/lib/services/localStorageHandlers/localStorageHandlers.test.js

@@ -54,14 +54,11 @@ describe('localStorageHandler', () => {
             };
             playerContext = {
                 player: mockPlayerAPI,
-                npoplayer: {
+                npoPlayer: {
                     ...mockNpoPlayer,
                     streamOptions: {
                         enableSubtitles: false
                     },
-                    userPreferences: {
-                        subtitles_enabled: 'false'
-                    },
                     container: document.createElement('div'),
                     streamObject: {},
                     playerConfig: {},
@@ -102,7 +99,7 @@ describe('localStorageHandler', () => {
         it('should enable subtitles if localStorage subtitles_enabled is true', () => {
             localStorage.setItem('npoplayer-subtitles_enabled', JSON.stringify('true'));
             setValuesBasedOnLocalStorage(playerContext);
-            expect(playerContext.npoplayer.streamOptions.enableSubtitles).toBe(true);
+            expect(playerContext.npoPlayer.streamOptions.enableSubtitles).toBe(true);
         });
     });
 });

package/lib/services/nicamHandlers/nicamhandler.d.ts

@@ -0,0 +1,5 @@
+import { PlayerContext } from '../../types/interfaces';
+export declare function processNicam(playerContext: PlayerContext, nicamElement: HTMLElement | undefined): void;
+export declare function addNicamIcon(character: string, nicamElement: Element): void;
+export declare function showNicamAfterUiDelay(playerContext: PlayerContext): void;
+export declare function setupNicamKijkwijzerIcons(playerContext: PlayerContext): void;

package/lib/{ui/handlers → services/nicamHandlers}/nicamhandler.js

@@ -1,6 +1,8 @@
-import { PlayerEvent } from 'bitmovin-player';
-export function processNicam(streamObject, nicamElement, streamOptions) {
-    const effectiveMetadata = streamOptions ? { ...streamObject.metadata, ...streamOptions } : streamObject.metadata;
+import { NpoPlayerEvent } from '../../types/events';
+export function processNicam(playerContext, nicamElement) {
+    const streamOptions = playerContext.npoPlayer.streamOptions;
+    const metadata = playerContext?.npoPlayer?.streamObject?.metadata ?? {};
+    const effectiveMetadata = { ...metadata, ...streamOptions };
     if (nicamElement) {
         nicamElement.innerHTML = '';
         if (effectiveMetadata.ageRating !== undefined && isNicamIconValid(effectiveMetadata.ageRating.toLowerCase())) {
@@ -43,21 +45,28 @@ export function addNicamIcon(character, nicamElement) {
     span.classList.add('nicam-icon', iconClass);
     nicamElement.appendChild(span);
 }
-export function showNicamAfterUiDelay(player, uiManager) {
-    player.off(PlayerEvent.Play, () => {
-        showNicamAfterUiDelay(player, uiManager);
+export function showNicamAfterUiDelay(playerContext) {
+    const { player, npoPlayer } = playerContext;
+    const { uiManager } = npoPlayer;
+    const showNicamClassName = 'bmpui-show-nicam';
+    const playerContainer = player.getNpoPlayerElement();
+    player.off(NpoPlayerEvent.Ready, () => {
+        npoPlayer.npoPlayerServices.showNicamAfterUiDelay(playerContext);
     });
-    if (uiManager === null)
+    if (!playerContainer || !uiManager)
         return;
-    const playerContainer = player.getContainer().querySelector('.bmpui-npo-player.bmpui-layout-max-width-400') ||
-        player.getContainer().querySelector('.bmpui-npo-player.bmpui-layout-max-width-600');
-    if (!playerContainer)
-        return;
-    uiManager?.activeUi.onControlsHide.subscribeOnce(() => {
-        const className = 'bmpui-show-nicam';
-        playerContainer.classList.add(className);
+    uiManager.activeUi.onControlsHide.subscribe(() => {
+        playerContainer.classList.add(showNicamClassName);
         setTimeout(() => {
-            playerContainer.classList.remove(className);
+            playerContainer.classList.remove(showNicamClassName);
         }, 3000);
     });
+    uiManager?.activeUi.onControlsShow.subscribe(() => {
+        playerContainer.classList.remove(showNicamClassName);
+    });
+}
+export function setupNicamKijkwijzerIcons(playerContext) {
+    const { container } = playerContext.npoPlayer;
+    const nicamElement = container.querySelector('.bmpui-nicam');
+    processNicam(playerContext, nicamElement);
 }