@npo/player 1.25.0 → 1.26.0

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/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

@@ -1,6 +1,5 @@
-import { UIManager } from 'bitmovin-player-ui';
 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, uiManager: UIManager | undefined): void;
+export declare function showNicamAfterUiDelay(playerContext: PlayerContext): void;
 export declare function setupNicamKijkwijzerIcons(playerContext: PlayerContext): void;

package/lib/services/nicamHandlers/nicamhandler.js

@@ -1,7 +1,7 @@
 import { NpoPlayerEvent } from '../../types/events';
 export function processNicam(playerContext, nicamElement) {
-    const streamOptions = playerContext.npoplayer.streamOptions;
-    const metadata = playerContext?.npoplayer?.streamObject?.metadata ?? {};
+    const streamOptions = playerContext.npoPlayer.streamOptions;
+    const metadata = playerContext?.npoPlayer?.streamObject?.metadata ?? {};
     const effectiveMetadata = { ...metadata, ...streamOptions };
     if (nicamElement) {
         nicamElement.innerHTML = '';
@@ -45,27 +45,28 @@ export function addNicamIcon(character, nicamElement) {
     span.classList.add('nicam-icon', iconClass);
     nicamElement.appendChild(span);
 }
-export function showNicamAfterUiDelay(playerContext, uiManager) {
-    const player = playerContext.player;
-    player.off(NpoPlayerEvent.Play, () => {
-        showNicamAfterUiDelay(playerContext, 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 { container } = playerContext.npoPlayer;
     const nicamElement = container.querySelector('.bmpui-nicam');
     processNicam(playerContext, nicamElement);
 }

package/lib/services/nicamHandlers/nicamhandler.test.js

@@ -1,6 +1,7 @@
-import { processNicam } from './nicamhandler';
+import { processNicam, showNicamAfterUiDelay } from './nicamhandler';
 import '@testing-library/jest-dom';
 import { createMockNpoPlayer, createPlayerContextMock } from '../../../tests/mocks/playerContextMock';
+import { NpoPlayerEvent } from '../../types/events';
 describe('NICAM Processing', () => {
     let mockElement;
     beforeEach(() => {
@@ -9,7 +10,7 @@ describe('NICAM Processing', () => {
     });
     it('processes NICAM from the streamObject', () => {
         const mockElement = document.createElement('div');
-        const npoplayerMock = createMockNpoPlayer({
+        const npoPlayerMock = createMockNpoPlayer({
             streamObject: {
                 metadata: {
                     ageRating: '12',
@@ -18,14 +19,14 @@ describe('NICAM Processing', () => {
             }
         });
         const playerContextMock = createPlayerContextMock({
-            npoplayer: npoplayerMock
+            npoPlayer: npoPlayerMock
         });
         processNicam(playerContextMock, mockElement);
         expect(mockElement.children).toHaveLength(5);
     });
     it('processes NICAM and age rating with streamOptions taking priority', () => {
         const mockElement = document.createElement('div');
-        const npoplayerMock = createMockNpoPlayer({
+        const npoPlayerMock = createMockNpoPlayer({
             streamObject: {
                 metadata: {
                     ageRating: '12',
@@ -38,14 +39,14 @@ describe('NICAM Processing', () => {
             }
         });
         const playerContextMock = createPlayerContextMock({
-            npoplayer: npoplayerMock
+            npoPlayer: npoPlayerMock
         });
         processNicam(playerContextMock, mockElement);
         expect(mockElement.children).toHaveLength(2);
     });
     it('does nothing if no NICAM element found', () => {
         document.querySelector = jest.fn().mockReturnValue(undefined);
-        const npoplayerMock = createMockNpoPlayer({
+        const npoPlayerMock = createMockNpoPlayer({
             streamObject: {
                 metadata: {
                     ageRating: '12',
@@ -54,16 +55,78 @@ describe('NICAM Processing', () => {
             }
         });
         const playerContextMock = createPlayerContextMock({
-            npoplayer: npoplayerMock
+            npoPlayer: npoPlayerMock
         });
         processNicam(playerContextMock, mockElement);
     });
     it('does nothing if no metadata and no streamOptions', () => {
-        const npoplayerMock = createMockNpoPlayer({});
+        const npoPlayerMock = createMockNpoPlayer({});
         const playerContextMock = createPlayerContextMock({
-            npoplayer: npoplayerMock
+            npoPlayer: npoPlayerMock
         });
         processNicam(playerContextMock, mockElement);
         expect(mockElement.appendChild).not.toHaveBeenCalled();
     });
 });
+describe('NICAM Visibility Management', () => {
+    let mockPlayerContext;
+    let mockContainer;
+    let mockPlayer;
+    let mockUiManager;
+    beforeEach(() => {
+        mockContainer = document.createElement('div');
+        mockPlayer = {
+            getNpoPlayerElement: jest.fn().mockReturnValue(mockContainer),
+            off: jest.fn()
+        };
+        mockUiManager = {
+            activeUi: {
+                onControlsHide: {
+                    subscribe: jest.fn(),
+                    unsubscribe: jest.fn()
+                },
+                onControlsShow: {
+                    subscribe: jest.fn(),
+                    unsubscribe: jest.fn()
+                }
+            }
+        };
+        mockPlayerContext = createPlayerContextMock({
+            player: mockPlayer,
+            npoPlayer: {
+                uiManager: mockUiManager,
+                container: mockContainer
+            }
+        });
+    });
+    describe('showNicamAfterUiDelay', () => {
+        it('should add showNicam class when controls are hidden', () => {
+            jest.useFakeTimers();
+            const showNicamClass = 'bmpui-show-nicam';
+            showNicamAfterUiDelay(mockPlayerContext);
+            mockUiManager.activeUi.onControlsHide.subscribe.mock.calls[0][0]();
+            expect(mockContainer).toHaveClass(showNicamClass);
+            jest.advanceTimersByTime(3000);
+            expect(mockContainer).not.toHaveClass(showNicamClass);
+            jest.useRealTimers();
+        });
+        it('should remove showNicam class when controls are shown', () => {
+            showNicamAfterUiDelay(mockPlayerContext);
+            const showNicamClass = 'bmpui-show-nicam';
+            mockUiManager.activeUi.onControlsHide.subscribe.mock.calls[0][0]();
+            expect(mockContainer).toHaveClass(showNicamClass);
+            mockUiManager.activeUi.onControlsShow.subscribe.mock.calls[0][0]();
+            expect(mockContainer).not.toHaveClass(showNicamClass);
+        });
+        it('should not execute if player container or uiManager is undefined', () => {
+            mockPlayerContext.npoPlayer.uiManager = undefined;
+            showNicamAfterUiDelay(mockPlayerContext);
+            expect(mockUiManager.activeUi.onControlsHide.subscribe).not.toHaveBeenCalled();
+            expect(mockUiManager.activeUi.onControlsShow.subscribe).not.toHaveBeenCalled();
+        });
+        it('should clean up event listeners when the player is ready', () => {
+            showNicamAfterUiDelay(mockPlayerContext);
+            expect(mockPlayer.off).toHaveBeenCalledWith(NpoPlayerEvent.Ready, expect.any(Function));
+        });
+    });
+});

package/lib/services/npoPlayerAPI/npoPlayerAPI.d.ts

@@ -17,7 +17,8 @@ export declare class NpoPlayerAPI {
     setViewMode(viewMode: ViewMode): void;
     getViewMode(): ViewMode;
     areSubtitlesEnabled(): boolean;
-    enableSubtitles(): void;
+    getCurrentSubtitle(): string | undefined;
+    enableSubtitles(selectedLang?: string): void;
     isPaused(): boolean;
     isMuted(): boolean;
     isLive(): boolean;
@@ -38,7 +39,6 @@ export declare class NpoPlayerAPI {
     getTimeShift(): number;
     scheduleAds(adConfig: AdConfig): Promise<AdBreak[]>;
     getActiveAdBreak(): AdBreak | null;
-    discardAdBreak(adBreakId: string): void;
     getConfig(mergedConfig?: boolean): PlayerConfig;
     createUIManager(playerContext: PlayerContext, variant: NpoPlayerUIVariants): Promise<void | UIManager>;
 }