@npo/player 1.24.7 → 1.26.0

package/lib/js/tracking/handlers/playertrackerinit.js

@@ -1,15 +1,17 @@
 import { newATInternetPlugin, newGovoltePlugin, newPageTracker, newTag } from '@npotag/tag';
 const npoTagPlugins = [newGovoltePlugin({ maxRetryCount: 5, delayBetweenRetriesInMs: 3000 }), newATInternetPlugin()];
-export function initPlayerTracker(npoplayer, _npotag, _npotaginstance) {
-    if (npoplayer.npoTag == undefined) {
-        npoplayer.npoTag = {
+export function initPlayerTracker(npoPlayer, _npoTag, _npoTagInstance, _npoTagPageTracker) {
+    if (!npoPlayer.npoTag) {
+        npoPlayer.npoTag = {
             npoTagInstance: undefined,
             pageTracker: undefined,
             heartbeatInterval: undefined
         };
     }
-    npoplayer.npoTag.npoTagInstance = _npotag == undefined ? _npotaginstance : newTag(_npotag, npoTagPlugins);
-    if (npoplayer.npoTag.npoTagInstance != undefined) {
-        npoplayer.npoTag.pageTracker = newPageTracker(npoplayer.npoTag.npoTagInstance);
+    if (!npoPlayer.npoTag?.npoTagInstance) {
+        npoPlayer.npoTag.npoTagInstance = _npoTagInstance ?? (_npoTag ? newTag(_npoTag, npoTagPlugins) : undefined);
+    }
+    if (!npoPlayer.npoTag?.pageTracker && npoPlayer.npoTag?.npoTagInstance) {
+        npoPlayer.npoTag.pageTracker = _npoTagPageTracker ?? newPageTracker(npoPlayer.npoTag.npoTagInstance);
     }
 }

package/lib/js/tracking/handlers/playertrackerinit.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/js/tracking/handlers/playertrackerinit.test.js

@@ -0,0 +1,74 @@
+import { newPageTracker, newTag } from '@npotag/tag';
+import { initPlayerTracker } from './playertrackerinit';
+jest.mock('@npotag/tag', () => ({
+    newATInternetPlugin: jest.fn(),
+    newGovoltePlugin: jest.fn(),
+    newPageTracker: jest.fn(),
+    newTag: jest.fn()
+}));
+describe('initPlayerTracker', () => {
+    let mockNpoPlayer;
+    beforeEach(() => {
+        mockNpoPlayer = {
+            npoTag: undefined
+        };
+        jest.clearAllMocks();
+    });
+    it('should initialize npoTag if it is undefined', () => {
+        initPlayerTracker(mockNpoPlayer);
+        expect(mockNpoPlayer.npoTag).toBeDefined();
+        expect(mockNpoPlayer.npoTag?.npoTagInstance).toBeUndefined();
+        expect(mockNpoPlayer.npoTag?.pageTracker).toBeUndefined();
+    });
+    it('should initialize npoTagInstance if _npoTagInstance is provided', () => {
+        const mockNpoTagInstance = {};
+        initPlayerTracker(mockNpoPlayer, undefined, mockNpoTagInstance);
+        expect(mockNpoPlayer.npoTag?.npoTagInstance).toBe(mockNpoTagInstance);
+        expect(mockNpoPlayer.npoTag?.pageTracker).toBeUndefined();
+    });
+    it('should create a new npoTagInstance if _npoTag is provided and _npoTagInstance is undefined', () => {
+        const mockNpoTag = {};
+        const mockNewTagInstance = {};
+        newTag.mockReturnValue(mockNewTagInstance);
+        initPlayerTracker(mockNpoPlayer, mockNpoTag);
+        expect(newTag).toHaveBeenCalledWith(mockNpoTag, expect.any(Array));
+        expect(mockNpoPlayer.npoTag?.npoTagInstance).toBe(mockNewTagInstance);
+        expect(mockNpoPlayer.npoTag?.pageTracker).toBeUndefined();
+    });
+    it('should initialize pageTracker if _npoTagPageTracker is provided', () => {
+        const mockPageTracker = {};
+        const mockNpoTagInstance = {};
+        mockNpoPlayer.npoTag = {
+            npoTagInstance: mockNpoTagInstance,
+            pageTracker: undefined,
+            heartbeatInterval: undefined
+        };
+        initPlayerTracker(mockNpoPlayer, undefined, mockNpoTagInstance, mockPageTracker);
+        expect(mockNpoPlayer.npoTag?.pageTracker).toBe(mockPageTracker);
+    });
+    it('should create a new pageTracker if _npoTagPageTracker is undefined', () => {
+        const mockNpoTagInstance = {};
+        const mockNewPageTracker = {};
+        newPageTracker.mockReturnValue(mockNewPageTracker);
+        mockNpoPlayer.npoTag = {
+            npoTagInstance: mockNpoTagInstance,
+            pageTracker: undefined,
+            heartbeatInterval: undefined
+        };
+        initPlayerTracker(mockNpoPlayer);
+        expect(newPageTracker).toHaveBeenCalledWith(mockNpoTagInstance);
+        expect(mockNpoPlayer.npoTag?.pageTracker).toBe(mockNewPageTracker);
+    });
+    it('should not overwrite existing pageTracker', () => {
+        const mockPageTracker = {};
+        const mockNpoTagInstance = {};
+        mockNpoPlayer.npoTag = {
+            npoTagInstance: mockNpoTagInstance,
+            pageTracker: mockPageTracker,
+            heartbeatInterval: undefined
+        };
+        initPlayerTracker(mockNpoPlayer);
+        expect(mockNpoPlayer.npoTag?.pageTracker).toBe(mockPageTracker);
+        expect(newPageTracker).not.toHaveBeenCalled();
+    });
+});

package/lib/js/tracking/handlers/playertrackerstart.js

@@ -12,7 +12,7 @@ export function startPlayerTracker(playerInstance, duration, version, source) {
             stream_length: duration,
             stream_id: validatePrid(source),
             player_id: 'npoplayer-web',
-            av_type: playerInstance.npoplayerServices.getAVType(playerInstance.streamObject.stream.avType),
+            av_type: playerInstance.npoPlayerServices.getAVType(playerInstance.streamObject.stream.avType),
             player_version: version,
             sko_player_version: '1.0.0'
         };

package/lib/js/utilities/utilities.element.d.ts

@@ -4,7 +4,13 @@ interface ElementByQuery {
 }
 interface RemoveClassFromElementByQuery extends ElementByQuery {
     className: string;
+    condition: boolean;
+}
+export interface UpdateClassFromElementByQuery extends ElementByQuery {
+    className: string;
+    condition: boolean;
 }
 export declare function getElementByQuery({ container, query }: ElementByQuery): Element | null;
 export declare function removeClassFromElementByQuery(params: RemoveClassFromElementByQuery): void;
+export declare function updateClassFromElementByQuery(params: UpdateClassFromElementByQuery): void;
 export {};

package/lib/js/utilities/utilities.element.js

@@ -6,3 +6,13 @@ export function removeClassFromElementByQuery(params) {
     const element = getElementByQuery({ container, query });
     element?.classList.remove(className);
 }
+export function updateClassFromElementByQuery(params) {
+    const { className, container, query, condition } = params;
+    const element = getElementByQuery({ container, query });
+    if (condition && element) {
+        element.classList.add(className);
+    }
+    else if (element) {
+        element.classList.remove(className);
+    }
+}

package/lib/js/utilities/utilities.element.test.js

@@ -1,5 +1,6 @@
-import { getElementByQuery, removeClassFromElementByQuery } from './utilities.element';
+import { getElementByQuery, updateClassFromElementByQuery } from './utilities.element';
 const CLASS = 'element-class';
+const NEW_CLASS = 'new-class';
 const ID = 'element-id';
 const PARENT_ELEMENT = document.createElement('div');
 const CHILD_ELEMENT_WITH_ID = document.createElement('div');
@@ -13,13 +14,25 @@ describe('getElementByQuery', () => {
         expect(getElementByQuery({ container: PARENT_ELEMENT, query: `#${ID}` })).toEqual(CHILD_ELEMENT_WITH_ID);
     });
 });
-describe('removeClassFromElementByQuery', () => {
-    it('should remove the specified class from from the queried element', () => {
-        removeClassFromElementByQuery({
+describe('updateClassFromElementByQuery', () => {
+    it('should remove the specified class from the queried element', () => {
+        updateClassFromElementByQuery({
             container: PARENT_ELEMENT,
             query: `.${CLASS}`,
-            className: CLASS
+            className: CLASS,
+            condition: false
         });
         expect(PARENT_ELEMENT.querySelector(`.${CLASS}`)).toBeNull();
     });
+    it('should add the specified class to the queried element', () => {
+        const ELEMENT_WITHOUT_CLASS = document.createElement('div');
+        PARENT_ELEMENT.appendChild(ELEMENT_WITHOUT_CLASS);
+        updateClassFromElementByQuery({
+            container: PARENT_ELEMENT,
+            query: 'div:not([class])',
+            className: NEW_CLASS,
+            condition: true
+        });
+        expect(PARENT_ELEMENT.querySelector(`.${NEW_CLASS}`)).not.toBeNull();
+    });
 });

package/lib/lang/nl.json

@@ -52,7 +52,7 @@
     "googleCast": "Google Cast",
     "vr": "VR",
     "off": "Uit",
-    "auto": "automatisch",
+    "auto": "Automatisch",
     "back": "Terug",
     "reset": "Herstellen",
     "replay": "Replay",

package/lib/lang/subtitleLabels/nl.json

@@ -0,0 +1,14 @@
+{
+    "ar": "Arabisch",
+    "bg": "Bulgaars",
+    "de": "Duits",
+    "en": "Engels",
+    "es": "Spaans",
+    "fr": "Frans",
+    "it": "Italiaans",
+    "nl": "Nederlands",
+    "ma": "Marokkaans",
+    "pl": "Pools",
+    "ua": "Oekraïens",
+    "tr": "Turks"
+}

package/lib/npoplayer.d.ts

@@ -1,18 +1,21 @@
 import { NpoPlayerServices } from './services/services';
-import { type StreamTracker, type NPOTag } from '@npotag/tag';
+import { type StreamTracker, type NPOTag, type PageTracker } from '@npotag/tag';
 import { type InitialisationProps } from '@npotag/tag/dist/types/src/npoTag';
 import { type PlayerAPI, type PlayerConfig, type SourceConfig } from 'bitmovin-player';
 import { UIManager } from 'bitmovin-player-ui';
 import { LogEmitter } from './types/classes';
-import { type DRMProfile, type ApiPayload, type NPOTagObject, type StreamObject, type StreamOptions, type UIComponents, type TimeLineMarker, type LocalStorageData, type PlayerContext, type EventListeners, NpoPlayerUIVariants } from './types/interfaces';
+import { type DRMProfile, type ApiPayload, type NPOTagObject, type StreamObject, type StreamOptions, type UIComponents, type TimeLineMarker, type PlayerContext, type EventListeners, NpoPlayerUIVariants } from './types/interfaces';
 export { type PlayerConfig, type InitialisationProps, type NPOTagObject, type StreamOptions, NpoPlayerUIVariants };
 export default class NpoPlayer {
-    playerConfig: PlayerConfig;
+    playerConfig: PlayerConfig | undefined;
     sourceConfig: SourceConfig;
     streamObject: StreamObject;
     player: PlayerAPI | undefined;
     uiManager: UIManager | undefined;
     npoTag: NPOTagObject | undefined;
+    npoTagInitialisation: InitialisationProps | undefined;
+    npoTagInstance: NPOTag | undefined;
+    npoTagPageTracker: PageTracker | undefined;
     streamTracker: StreamTracker | undefined;
     logEmitter: LogEmitter;
     uiComponents: UIComponents;
@@ -27,11 +30,17 @@ export default class NpoPlayer {
     isShowingPlayNextScreen: boolean;
     canceledPlayNextScreen: boolean;
     playerContext: PlayerContext | undefined;
-    npoplayerServices: NpoPlayerServices;
+    npoPlayerServices: NpoPlayerServices;
     eventListeners: EventListeners | undefined;
     mockNpoPlayer: any;
-    userPreferences: LocalStorageData;
-    constructor(_container: HTMLElement, _playerConfig: PlayerConfig, _npotag?: InitialisationProps | undefined, _npotaginstance?: NPOTag | undefined, _variant?: NpoPlayerUIVariants);
+    constructor(container: HTMLElement | {
+        container: HTMLElement;
+        playerConfig: PlayerConfig;
+        npoTag?: InitialisationProps | undefined;
+        npoTagInstance?: NPOTag | undefined;
+        variant?: NpoPlayerUIVariants;
+        npoTagPageTracker?: PageTracker | undefined;
+    }, playerConfig?: PlayerConfig | undefined, npoTag?: InitialisationProps | undefined, npoTagInstance?: NPOTag | undefined, variant?: NpoPlayerUIVariants, npoTagPageTracker?: PageTracker | undefined);
     initPlayer(_container: HTMLElement, playerConfig: PlayerConfig): void;
     loadStream(source: string, options?: StreamOptions): Promise<void>;
     doError(input: any, status?: number): void;

package/lib/npoplayer.js

@@ -11,19 +11,16 @@ import { isMediaUrl, isUrl } from './js/utilities/utilities.url';
 import { logVersion } from './js/utilities/utilities.version';
 import { getStreamDurationInSeconds } from './js/utilities/utilities.stream';
 import { LogEmitter } from './types/classes';
-import { handlePreRolls } from './services/advertHandlers/handlePreRolls';
 import pkg from '../package.json';
-import { NpoPlayerUIVariants, LocalStorageValues } from './types/interfaces';
+import { NpoPlayerUIVariants } from './types/interfaces';
 import { nativeMobileUiFactory } from './ui/nativemobileuifactory';
 import { setupMediaSessionActionHandlers } from './js/playeractions/handlers/mediasessionactions';
 import { removeReplayClass } from './js/playeractions/handlers/removereplayclass';
-import { showNicamAfterUiDelay } from './ui/handlers/nicamhandler';
 import { updateLiveMarkers } from './js/markers/updateLiveMarkers';
 import { NpoPlayerAPI } from './services/npoPlayerAPI/npoPlayerAPI';
-import { discardAdBreak } from './services/advertHandlers/discardAdBreak';
 export { NpoPlayerUIVariants };
 export default class NpoPlayer {
-    constructor(_container, _playerConfig, _npotag, _npotaginstance, _variant) {
+    constructor(container, playerConfig, npoTag, npoTagInstance, variant, npoTagPageTracker) {
         this.sourceConfig = {};
         this.streamObject = {
             stream: { drmType: '', streamProfile: '', streamURL: '', avType: '', sourceProfile: '' },
@@ -33,6 +30,9 @@ export default class NpoPlayer {
         };
         this.player = undefined;
         this.uiManager = undefined;
+        this.npoTagInitialisation = undefined;
+        this.npoTagInstance = undefined;
+        this.npoTagPageTracker = undefined;
         this.streamTracker = undefined;
         this.logEmitter = new LogEmitter();
         this.uiComponents = {};
@@ -45,48 +45,59 @@ export default class NpoPlayer {
         this.isShowingPlayNextScreen = false;
         this.canceledPlayNextScreen = false;
         this.playerContext = undefined;
-        this.npoplayerServices = new NpoPlayerServices();
+        this.npoPlayerServices = new NpoPlayerServices();
         this.eventListeners = undefined;
-        this.userPreferences = {};
-        this.playerConfig = _playerConfig;
-        this.container = _container;
-        this.variant = _variant || NpoPlayerUIVariants.DEFAULT;
-        initPlayerTracker(this, _npotag, _npotaginstance);
-        this.initPlayer(this.container, _playerConfig);
+        if (typeof container === 'object' && !(container instanceof HTMLElement)) {
+            const params = container;
+            this.container = params.container;
+            this.playerConfig = params.playerConfig;
+            this.npoTagInitialisation = params.npoTag || undefined;
+            this.npoTagInstance = params.npoTagInstance;
+            this.variant = params.variant || NpoPlayerUIVariants.DEFAULT;
+            this.npoTagPageTracker = params.npoTagPageTracker || undefined;
+        }
+        else {
+            this.container = container;
+            this.playerConfig = playerConfig || undefined;
+            this.npoTagInitialisation = npoTag || undefined;
+            this.npoTagInstance = npoTagInstance;
+            this.variant = variant || NpoPlayerUIVariants.DEFAULT;
+            this.npoTagPageTracker = npoTagPageTracker || undefined;
+            console.warn('As of NPO Player version 1.25, parameter-based initialization has been deprecated in favor of object-based initialization. This feature will be removed in version 2.0. Please update your implementation to ensure compatibility. For more details, refer to the documentation at: https://docs.npoplayer.nl/implementation/web/player.');
+        }
+        if (!this.playerConfig) {
+            console.error('Player configuration is missing. Ensure that playerConfig is properly initialized before using the player.');
+            return;
+        }
+        if (this.npoTagInstance) {
+            initPlayerTracker(this, this.npoTagInitialisation, this.npoTagInstance, this.npoTagPageTracker);
+        }
+        this.initPlayer(this.container, this.playerConfig);
     }
     initPlayer(_container, playerConfig) {
         const processedPlayerConfig = playerAction.processPlayerConfig(this, playerConfig);
         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());
-                this.npoplayerServices.setStoredUserPrefs(LocalStorageValues.VOLUME, npoPlayerAPI.getVolume());
-                this.npoplayerServices.setStoredUserPrefs(LocalStorageValues.IS_MUTED, npoPlayerAPI.isMuted().toString());
-            }
-        });
+        this.playerContext = { player: npoPlayerAPI, npoPlayer: this };
+        this.npoPlayerServices.handleUserPrefs(this.playerContext);
+        this.npoPlayerServices.setAccessibilityAttributes(this.playerContext);
+        this.npoPlayerServices.handlePreferences(this.playerContext);
         this.container.addEventListener('keydown', (e) => {
             if (!this.playerContext)
                 return;
-            this.npoplayerServices.keyboardHandler(this.playerContext, e);
+            this.npoPlayerServices.keyboardHandler(this.playerContext, e);
         }, true);
     }
     async loadStream(source, options = {}) {
         if (!this.playerContext)
             return;
         this.streamOptions = options;
-        if (this.player == undefined) {
+        if (!this.player) {
             console.error('Er is nog geen player geladen.');
             return;
         }
-        if (this.playerContext) {
-            discardAdBreak(this.playerContext);
-        }
+        this.npoPlayerServices.discardAdBreak(this.playerContext);
         let _streamObject;
         const sourceIsUrl = isUrl(source);
         const sourceIsMedia = await isMediaUrl(source);
@@ -105,16 +116,17 @@ export default class NpoPlayer {
                 analytics: {
                     customData2: 'other',
                     customData3: 'unknown',
-                    customData4: this.npoTag?.npoTagInstance?.getParty(),
+                    customData4: this.npoTagInstance?.getParty(),
                     customData5: this.version
                 }
             };
+            await this.playerContext.player.createUIManager(this.playerContext, this.variant);
             await this.playerContext.player?.load(this.sourceConfig);
             getDurationAndStartPlayerTracker();
         }
         else if (sourceIsJWTToken) {
             this.jwt = source;
-            const profile = await this.npoplayerServices.decideProfile(this.playerContext, options?.preferredDRM ?? '');
+            const profile = await this.npoPlayerServices.decideProfile(this.playerContext, options?.preferredDRM ?? '');
             const defaultEndpoint = 'https://prod.npoplayer.nl/';
             const endpoint = options?.endpoint ?? defaultEndpoint;
             const payload = {
@@ -131,12 +143,10 @@ export default class NpoPlayer {
                     }
                 }
             };
+            await this.playerContext.player.createUIManager(this.playerContext, this.variant);
             try {
                 _streamObject = await getStreamObject(this, payload);
                 this.streamObject = _streamObject;
-                if (_streamObject) {
-                    await this.playerContext.player.createUIManager(this.playerContext, this.variant);
-                }
             }
             catch (error) {
                 this.doError('Het is niet gelukt de stream op te halen. \n' + error);
@@ -146,8 +156,8 @@ export default class NpoPlayer {
             if (this.streamObject?.stream == undefined)
                 return;
             const drmType = this.streamObject.stream.drmType ?? undefined;
-            this.sourceConfig = await playerAction.processSourceConfig(this.npoplayerServices, options.sourceConfig ?? {}, this.streamObject, drmType && drmType.length > 0 ? profile.drm : undefined, this.streamOptions, this.version, this.npoTag?.npoTagInstance?.getParty(), this.npoplayerServices);
-            await this.npoplayerServices.verifyDRM(this.playerContext, payload);
+            this.sourceConfig = await playerAction.processSourceConfig(this.npoPlayerServices, source, options.sourceConfig ?? {}, this.streamObject, drmType && drmType.length > 0 ? profile.drm : undefined, this.streamOptions, this.version, this.npoTag?.npoTagInstance);
+            await this.npoPlayerServices.verifyDRM(this.playerContext, payload);
             setupMediaSessionActionHandlers(this.player, this.sourceConfig, _streamObject);
             logEvent(this, 'load');
             let streamDuration = _streamObject.metadata.duration;
@@ -170,7 +180,7 @@ export default class NpoPlayer {
                 this.streamObject.assets.preroll) {
                 this.player.on(PlayerEvent.AdBreakFinished, initAndStartTracker);
                 this.player.on(PlayerEvent.AdError, initAndStartTracker);
-                await handlePreRolls(this.playerContext);
+                await this.npoPlayerServices.schedulePreRolls(this.playerContext);
             }
             else {
                 initAndStartTracker();
@@ -179,12 +189,12 @@ export default class NpoPlayer {
         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);
-            this.sourceConfig.metadata.npoTagSession = String(this.npoTag?.npoTagInstance?.getSerializedSessionInfo());
-        }
+        this.npoPlayerServices.handleStreamOptions(this.playerContext);
+        this.npoPlayerServices.setupNicamKijkwijzerIcons(this.playerContext);
+        this.player.on(PlayerEvent.Ready, () => {
+            this.npoPlayerServices.showNicamAfterUiDelay(this.playerContext);
+        });
+        this.npoPlayerServices.handleVerticalVideoControls(this.playerContext, this.variant);
         this.player.on(PlayerEvent.Seek, () => {
             removeReplayClass(this.player);
         });
@@ -196,9 +206,6 @@ export default class NpoPlayer {
                 this.hidePlayNextScreen();
             });
         }
-        this.player.on(PlayerEvent.Play, () => {
-            showNicamAfterUiDelay(this.player, this.uiManager);
-        });
         const setLiveOffsetListener = function () {
             if (this.playerContext === undefined)
                 return;
@@ -208,7 +215,7 @@ export default class NpoPlayer {
         this.player.on(PlayerEvent.Ready, setLiveOffsetListener);
     }
     doError(input, status) {
-        if (this.player == undefined)
+        if (!this.player)
             return;
         if (status) {
             this.logEmitter.emit('logError', status);
@@ -307,9 +314,12 @@ export default class NpoPlayer {
         const destroyLogic = async () => {
             try {
                 if (this.npoTag != undefined) {
-                    clearInterval(this.npoTag.heartbeatInterval);
+                    clearInterval(this.npoTag?.heartbeatInterval);
                 }
                 logEvent(this, 'stop');
+                if (this.playerContext) {
+                    this.npoPlayerServices.removeUivisiblityHandlers(this.playerContext);
+                }
                 this.uiManager?.release();
                 this.uiManager = undefined;
                 await this.player?.destroy();
@@ -332,9 +342,6 @@ export default class NpoPlayer {
                 if (this.npoTag != undefined) {
                     clearInterval(this.npoTag.heartbeatInterval);
                 }
-                if (this.playerContext) {
-                    discardAdBreak(this.playerContext);
-                }
                 this.hidePlayNextScreen();
                 await this.player?.unload();
                 return true;

package/lib/npoplayer.test.js

@@ -3,12 +3,20 @@ const div = document.createElement('div');
 const testPlayerConfig = {
     key: 'dummy-key'
 };
-jest.mock('./ui/handlers/streamhandler', () => ({
-    processStream: jest.fn()
+jest.mock('./services/streamoptionsHandlers/streamOptionsHandler', () => ({
+    handleStreamOptions: jest.fn()
 }));
 let player;
-test('player init', async () => {
+test('player init with parameters', async () => {
     player = new NpoPlayer(div, testPlayerConfig);
     expect(player).toBeInstanceOf(NpoPlayer);
-    expect(player.playerConfig.key).toBe(testPlayerConfig.key);
+    expect(player.playerConfig?.key).toBe(testPlayerConfig.key);
+});
+test('player init with parameters', async () => {
+    player = new NpoPlayer({
+        container: div,
+        playerConfig: testPlayerConfig
+    });
+    expect(player).toBeInstanceOf(NpoPlayer);
+    expect(player.playerConfig?.key).toBe(testPlayerConfig.key);
 });

package/lib/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@npo/player",
-  "version": "1.24.7",
+  "version": "1.26.0",
   "description": "NPO Player",
   "author": "Publieke Omroep <player@npo.nl>",
   "contributors": [
@@ -89,8 +89,8 @@
     "webpack-dev-server": "^4.11.1"
   },
   "dependencies": {
-    "@npotag/tag": "3.2.1",
-    "bitmovin-player": "8.173.0",
+    "@npotag/tag": "3.2.4",
+    "bitmovin-player": "^8.166.0",
     "bitmovin-player-ui": "3.67.0"
   },
   "browserslist": [

package/lib/services/a11y/setup.js

@@ -1,16 +1,13 @@
 import { NpoPlayerEvent } from '../../types/events';
 import { addAccessibilityAttributes } from '../../ui/handlers/accessibilityhandler';
 export function setupAccessibilityAttributes(playerContext) {
-    const { player, npoplayer } = playerContext;
+    const { player, npoPlayer } = playerContext;
     const events = [NpoPlayerEvent.SourceLoaded, NpoPlayerEvent.AdBreakFinished, NpoPlayerEvent.AdError];
     const triggerAddAccessibilityAttributes = () => {
         for (const event of events) {
             player?.off(event, triggerAddAccessibilityAttributes);
         }
-        if (npoplayer.streamOptions.enableSubtitles === true || npoplayer.userPreferences.subtitles_enabled === 'true') {
-            player?.enableSubtitles();
-        }
-        addAccessibilityAttributes(npoplayer.container, npoplayer.streamObject.metadata);
+        addAccessibilityAttributes(npoPlayer.container, npoPlayer.streamObject.metadata);
     };
     for (const event of events) {
         player?.on(event, triggerAddAccessibilityAttributes);

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

@@ -31,14 +31,11 @@ describe('setupAccessibilityAttributes', () => {
         };
         playerContext = {
             player: mockPlayerAPI,
-            npoplayer: {
+            npoPlayer: {
                 ...mockNpoPlayer,
                 streamOptions: {
                     enableSubtitles: false
                 },
-                userPreferences: {
-                    subtitles_enabled: 'false'
-                },
                 container: document.createElement('div'),
                 streamObject: {},
                 playerConfig: {},
@@ -69,20 +66,6 @@ describe('setupAccessibilityAttributes', () => {
     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);
@@ -103,6 +86,6 @@ describe('setupAccessibilityAttributes', () => {
         setupAccessibilityAttributes(playerContext);
         const triggerFunction = mockAddEventListener.mock.calls[0][1];
         triggerFunction();
-        expect(addAccessibilityAttributes).toHaveBeenCalledWith(playerContext.npoplayer.container, playerContext.npoplayer.streamObject.metadata);
+        expect(addAccessibilityAttributes).toHaveBeenCalledWith(playerContext.npoPlayer.container, playerContext.npoPlayer.streamObject.metadata);
     });
 });

package/lib/services/advertHandlers/discardAdBreak.js

@@ -1,11 +1,11 @@
 export function discardAdBreak(playerContext) {
-    const { npoplayer, player } = playerContext;
-    const { adBreakActive } = npoplayer;
+    const { npoPlayer, player } = playerContext;
+    const { adBreakActive } = npoPlayer;
     if (!player || adBreakActive === false)
         return;
     const activeAdBreak = player.getActiveAdBreak();
     if (activeAdBreak?.id) {
-        player.discardAdBreak(activeAdBreak.id);
+        player.playerAPI.ads.discardAdBreak(activeAdBreak.id);
     }
-    npoplayer.adBreakActive = false;
+    npoPlayer.adBreakActive = false;
 }