@npo/player 1.22.5 → 1.23.0

package/README.md

@@ -11,7 +11,7 @@ Extensive and up-to-date documentation is available at https://docs.npoplayer.nl
 Code quality is analysed by SonarCloud. The project can be found at https://sonarcloud.io/project/overview?id=NPOstart_npo-player
 
 # Changelog
-Current version: v1.22.3
+Current version: v1.23.0
 
 The changelog is available at https://docs.npoplayer.nl/implementation/web/changelog/
 

package/lib/js/ads/ster.js

@@ -2,14 +2,14 @@ import { AdTagType, PlayerEvent } from 'bitmovin-player';
 import { NpoPlayerUIVariants } from '../../types/interfaces';
 export async function handlePreRolls(playerapi, streamObject, npoplayer) {
     return new Promise((resolve) => {
-        if (streamObject.metadata.hasPreroll == 'false' || streamObject.assets.preroll == null) {
+        if (streamObject.metadata.hasPreroll == 'false' || streamObject.assets.preroll == undefined) {
             resolve();
             return;
         }
-        let prerollUrl = streamObject.assets.preroll;
+        const prerollUrl = streamObject.assets.preroll;
         let adIndex = 0;
         let totalAds = 0;
-        let currentClickListener = null;
+        let currentClickListener;
         let adUiSet = false;
         async function handleReady() {
             playerapi.off(PlayerEvent.Ready, handleReady);
@@ -19,7 +19,7 @@ export async function handlePreRolls(playerapi, streamObject, npoplayer) {
                     type: AdTagType.VAST
                 },
                 id: 'Ad',
-                position: 'pre',
+                position: 'pre'
             };
             await playerapi.ads.schedule(advertConfig);
         }
@@ -30,15 +30,17 @@ export async function handlePreRolls(playerapi, streamObject, npoplayer) {
         }
         playerapi.on(PlayerEvent.Play, handlePlay);
         function setAdUi() {
-            let activeAdBreak = playerapi.ads.getActiveAdBreak();
+            const activeAdBreak = playerapi.ads.getActiveAdBreak();
             if (!activeAdBreak || !activeAdBreak.ads)
                 return false;
             npoplayer.uiManager?.release();
-            npoplayer.uiManager = null;
-            npoplayer.createUIManager(playerapi, NpoPlayerUIVariants.AD);
+            npoplayer.uiManager = undefined;
+            if (npoplayer.playerContext) {
+                npoplayer.createUIManager(playerapi, npoplayer.playerContext, NpoPlayerUIVariants.AD);
+            }
             adUiSet = true;
-            let adButton = npoplayer.uiComponents.adbutton;
-            let currentAd = activeAdBreak.ads[0];
+            const adButton = npoplayer.uiComponents.adbutton;
+            const currentAd = activeAdBreak.ads[0];
             adIndex = 1;
             totalAds = activeAdBreak.ads.length;
             adButton?.show();
@@ -58,7 +60,7 @@ export async function handlePreRolls(playerapi, streamObject, npoplayer) {
         }
         function handleAdStarted() {
             playerapi.off(PlayerEvent.AdStarted, handleAdStarted);
-            let activeAdBreak = playerapi.ads.getActiveAdBreak();
+            const activeAdBreak = playerapi.ads.getActiveAdBreak();
             if (!activeAdBreak || !activeAdBreak.ads) {
                 console.error('No active ad break data found');
                 return;
@@ -69,10 +71,9 @@ export async function handlePreRolls(playerapi, streamObject, npoplayer) {
         }
         playerapi.on(PlayerEvent.AdStarted, handleAdStarted);
         function adClickHandler(ad, button) {
-            let clickThroughCallback;
+            const clickThroughCallback = ad.clickThroughUrlOpened;
             if (currentClickListener)
                 button?.onClick.unsubscribe(currentClickListener);
-            clickThroughCallback = ad.clickThroughUrlOpened;
             currentClickListener = () => {
                 try {
                     window.open(ad.clickThroughUrl, '_blank');
@@ -84,11 +85,10 @@ export async function handlePreRolls(playerapi, streamObject, npoplayer) {
                     console.log(error);
                 }
             };
-            button.onClick.subscribe(currentClickListener);
         }
         function handleAdFinished() {
             playerapi.off(PlayerEvent.AdFinished, handleAdFinished);
-            let activeAdBreak = playerapi.ads.getActiveAdBreak();
+            const activeAdBreak = playerapi.ads.getActiveAdBreak();
             if (!activeAdBreak || !activeAdBreak.ads) {
                 console.error('No active ad break data found');
                 return;
@@ -97,8 +97,8 @@ export async function handlePreRolls(playerapi, streamObject, npoplayer) {
                 handleAdBreakFinished();
                 return;
             }
-            let adButton = npoplayer.uiComponents.adbutton;
-            let nextAd = activeAdBreak.ads[adIndex];
+            const adButton = npoplayer.uiComponents.adbutton;
+            const nextAd = activeAdBreak.ads[adIndex];
             adIndex += 1;
             adButton?.show();
             adClickHandler(nextAd, adButton);
@@ -112,8 +112,10 @@ export async function handlePreRolls(playerapi, streamObject, npoplayer) {
             npoplayer.uiComponents.adbutton?.hide();
             npoplayer.uiComponents.adlabel?.hide();
             npoplayer.uiManager?.release();
-            npoplayer.uiManager = null;
-            npoplayer.createUIManager(playerapi, NpoPlayerUIVariants.DEFAULT);
+            npoplayer.uiManager = undefined;
+            if (npoplayer.playerContext) {
+                npoplayer.createUIManager(playerapi, npoplayer.playerContext, NpoPlayerUIVariants.DEFAULT);
+            }
             adUiSet = false;
             resolve();
         }

package/lib/js/ads/ster.test.js

@@ -1,21 +1,21 @@
 import { handlePreRolls } from './ster';
-jest.mock("bitmovin-player");
-jest.mock("../../npoplayer");
-describe("handlePreRolls", () => {
+jest.mock('bitmovin-player');
+jest.mock('../../npoplayer');
+describe('handlePreRolls', () => {
     let mockPlayerAPI;
     let mockNpoPlayer;
     beforeEach(() => {
         mockPlayerAPI = {
             ads: {
-                schedule: jest.fn().mockResolvedValue(undefined),
-                getActiveAdBreak: jest.fn(),
+                schedule: jest.fn().mockResolvedValue(true),
+                getActiveAdBreak: jest.fn()
             },
             on: jest.fn(),
-            off: jest.fn(),
+            off: jest.fn()
         };
         mockNpoPlayer = {
             uiManager: {
-                release: jest.fn(),
+                release: jest.fn()
             },
             createUIManager: jest.fn(),
             uiComponents: {
@@ -24,33 +24,33 @@ describe("handlePreRolls", () => {
                     hide: jest.fn(),
                     onClick: {
                         subscribe: jest.fn(),
-                        unsubscribe: jest.fn(),
-                    },
+                        unsubscribe: jest.fn()
+                    }
                 },
                 adlabel: {
                     setText: jest.fn(),
-                    hide: jest.fn(),
-                },
+                    hide: jest.fn()
+                }
             },
-            adBreakActive: false,
+            adBreakActive: false
         };
     });
-    it("should not schedule ads when hasPreroll is false", async () => {
+    it('should not schedule ads when hasPreroll is false', async () => {
         const streamObject = {
             metadata: {
-                hasPreroll: "false"
+                hasPreroll: 'false'
             },
             assets: {
-                preroll: "sample_url"
+                preroll: 'sample_url'
             }
         };
         await handlePreRolls(mockPlayerAPI, streamObject, mockNpoPlayer);
         expect(mockPlayerAPI.ads.schedule).not.toHaveBeenCalled();
     });
-    it("should not schedule ads if preroll URL is missing", async () => {
+    it('should not schedule ads if preroll URL is missing', async () => {
         const streamObject = {
             metadata: {
-                hasPreroll: "true"
+                hasPreroll: 'true'
             },
             assets: {}
         };

package/lib/js/api/getstreamobject.js

@@ -1,4 +1,4 @@
-import { noTrailingSlash } from '../utilities/utilities';
+import { removeTrailingSlash } from '../utilities/utilities.url';
 export async function getStreamObject(npoplayer, payload) {
     try {
         const controller = new AbortController();
@@ -6,11 +6,11 @@ export async function getStreamObject(npoplayer, payload) {
         const timeout = setTimeout(() => {
             controller.abort();
         }, 5000);
-        const response = await fetch(noTrailingSlash(payload.baseURL) + '/stream-link', {
+        const response = await fetch(removeTrailingSlash(payload.baseURL) + '/stream-link', {
             method: 'post',
             headers: {
-                Accept: '*/*',
-                Authorization: payload.jwt,
+                'Accept': '*/*',
+                'Authorization': payload.jwt,
                 'Content-Type': 'application/json'
             },
             body: JSON.stringify(payload.data),
@@ -18,11 +18,11 @@ export async function getStreamObject(npoplayer, payload) {
         });
         clearTimeout(timeout);
         const streamApiResponse = await response.json();
-        if (!response.ok) {
-            npoplayer.doError(`Het is niet gelukt de stream op te halen: \n ${streamApiResponse.body}`, response.status);
+        if (response.ok) {
+            return streamApiResponse;
         }
         else {
-            return streamApiResponse;
+            npoplayer.doError(`Het is niet gelukt de stream op te halen: \n ${streamApiResponse.body}`, response.status);
         }
     }
     catch (error) {

package/lib/js/api/getstreamobject.test.js

@@ -2,14 +2,14 @@ import { getStreamObject } from './getstreamobject';
 import NpoPlayer from '../../npoplayer';
 import fetchMock from 'jest-fetch-mock';
 fetchMock.enableMocks();
-jest.mock('../ui/handlers/streamhandler', () => ({
-    processStream: jest.fn(),
+jest.mock('../../ui/handlers/streamhandler', () => ({
+    processStream: jest.fn()
 }));
 describe('getStreamObject', () => {
     let npoplayer;
     let apiPayload;
     const testPlayerConfig = {
-        key: 'dummy key',
+        key: 'dummy key'
     };
     const div = document.createElement('div');
     beforeEach(() => {

package/lib/js/markers/updateLiveMarkers.d.ts

@@ -1,4 +1,4 @@
-import { PlayerAPI } from "bitmovin-player";
-import { UIManager } from "bitmovin-player-ui";
-import { TimeLineMarker } from "types/interfaces";
+import { PlayerAPI } from 'bitmovin-player';
+import { UIManager } from 'bitmovin-player-ui';
+import { TimeLineMarker } from 'types/interfaces';
 export declare function updateLiveMarkers(timeLineMarkers: TimeLineMarker[], player: PlayerAPI, uiManager: UIManager, autoFillTimeLineMarkerDuration: boolean): void;

package/lib/js/markers/updateLiveMarkers.js

@@ -4,28 +4,27 @@ export function updateLiveMarkers(timeLineMarkers, player, uiManager, autoFillTi
         return;
     }
     removeAllMarkers(uiManager);
-    let currentTimeEpoch = Math.floor(Date.now() / 1000);
+    const currentTimeEpoch = Math.floor(Date.now() / 1000);
     timeLineMarkers.sort((a, b) => a.time - b.time);
-    let relativeTimeMarkers = timeLineMarkers.map((marker, index) => transformMarker(marker, index, timeLineMarkers, currentTimeEpoch, player, autoFillTimeLineMarkerDuration));
-    relativeTimeMarkers.forEach(marker => {
+    const relativeTimeMarkers = timeLineMarkers.map((marker, index) => transformMarker(marker, index, timeLineMarkers, currentTimeEpoch, player, autoFillTimeLineMarkerDuration));
+    for (const marker of relativeTimeMarkers) {
         uiManager?.addTimelineMarker(marker);
-    });
+    }
 }
 function transformMarker(marker, index, timeLineMarkers, currentTimeEpoch, player, autoFillTimeLineMarkerDuration) {
     const DVR_WINDOW_LENGTH = Math.abs(player.getMaxTimeShift());
-    let duration = marker.duration !== undefined ? marker.duration : 0;
+    let duration = marker.duration === undefined ? 0 : marker.duration;
     let startTimeRelativeToCurrent = marker.time - currentTimeEpoch;
     if (autoFillTimeLineMarkerDuration) {
-        if (index === timeLineMarkers.length - 1) {
-            duration = Math.min(currentTimeEpoch, marker.time + DVR_WINDOW_LENGTH) - marker.time;
-        }
-        else {
-            duration = timeLineMarkers[index + 1].time - marker.time;
-        }
+        duration =
+            index === timeLineMarkers.length - 1
+                ? Math.min(currentTimeEpoch, marker.time + DVR_WINDOW_LENGTH) - marker.time
+                : timeLineMarkers[index + 1].time - marker.time;
         if (startTimeRelativeToCurrent < -DVR_WINDOW_LENGTH) {
-            duration = index === timeLineMarkers.length - 1 ?
-                currentTimeEpoch - (currentTimeEpoch - DVR_WINDOW_LENGTH) :
-                timeLineMarkers[index + 1].time - (currentTimeEpoch - DVR_WINDOW_LENGTH);
+            duration =
+                index === timeLineMarkers.length - 1
+                    ? currentTimeEpoch - (currentTimeEpoch - DVR_WINDOW_LENGTH)
+                    : timeLineMarkers[index + 1].time - (currentTimeEpoch - DVR_WINDOW_LENGTH);
             startTimeRelativeToCurrent = -DVR_WINDOW_LENGTH;
         }
     }
@@ -33,7 +32,7 @@ function transformMarker(marker, index, timeLineMarkers, currentTimeEpoch, playe
         time: marker.time,
         duration: duration,
         title: marker.title,
-        cssClasses: ['npo-livestream-marker'],
+        cssClasses: ['npo-livestream-marker']
     };
 }
 function removeAllMarkers(uiManager) {

package/lib/js/markers/updateLiveMarkers.test.js

@@ -1,16 +1,16 @@
 import { updateLiveMarkers } from './updateLiveMarkers';
-import { UIManager } from "bitmovin-player-ui";
-jest.mock("bitmovin-player-ui", () => {
+import { UIManager } from 'bitmovin-player-ui';
+jest.mock('bitmovin-player-ui', () => {
     return {
         UIManager: jest.fn().mockImplementation(() => ({
             getTimelineMarkers: jest.fn().mockReturnValue([]),
             addTimelineMarker: jest.fn(),
-            removeTimelineMarker: jest.fn(),
-        })),
+            removeTimelineMarker: jest.fn()
+        }))
     };
 });
-jest.mock("bitmovin-player", () => ({
-    PlayerAPI: jest.fn(),
+jest.mock('bitmovin-player', () => ({
+    PlayerAPI: jest.fn()
 }));
 describe('updateLiveMarkers', () => {
     const player = {
@@ -25,7 +25,7 @@ describe('updateLiveMarkers', () => {
     test('should correctly update UI manager with sorted and transformed markers', () => {
         const timeLineMarkers = [
             { time: 3000, title: 'Marker 2' },
-            { time: 1000, title: 'Marker 1' },
+            { time: 1000, title: 'Marker 1' }
         ];
         updateLiveMarkers(timeLineMarkers, player, uiManager, true);
         expect(uiManager.getTimelineMarkers).toHaveBeenCalled();
@@ -34,19 +34,18 @@ describe('updateLiveMarkers', () => {
         expect(uiManager.addTimelineMarker).toHaveBeenCalledWith(expect.objectContaining({
             time: 1000,
             title: 'Marker 1',
-            cssClasses: ['npo-livestream-marker'],
+            cssClasses: ['npo-livestream-marker']
         }));
         expect(uiManager.addTimelineMarker).toHaveBeenCalledWith(expect.objectContaining({
             time: 3000,
             title: 'Marker 2',
-            cssClasses: ['npo-livestream-marker'],
+            cssClasses: ['npo-livestream-marker']
         }));
     });
     test('should remove existing markers before adding new ones', () => {
+        ;
         uiManager.getTimelineMarkers.mockReturnValue([{ time: 2000, title: 'Existing Marker' }]);
-        const timeLineMarkers = [
-            { time: 1000, title: 'New Marker' },
-        ];
+        const timeLineMarkers = [{ time: 1000, title: 'New Marker' }];
         updateLiveMarkers(timeLineMarkers, player, uiManager, true);
         expect(uiManager.removeTimelineMarker).toHaveBeenCalledTimes(1);
         expect(uiManager.addTimelineMarker).toHaveBeenCalledTimes(1);

package/lib/js/playeractions/customerrors.test.js

@@ -1,51 +1,51 @@
-import { customSpecificErrorMessageOverlayConfig } from "./handlers/customerrors";
-describe("Test custom error messages", () => {
-    it("should return a 1000 error message", () => {
-        expect(customSpecificErrorMessageOverlayConfig[1000]).toBe("Oeps, er gaat iets mis");
+import { customSpecificErrorMessageOverlayConfig } from './handlers/customerrors';
+describe('Test custom error messages', () => {
+    it('should return a 1000 error message', () => {
+        expect(customSpecificErrorMessageOverlayConfig[1000]).toBe('Oeps, er gaat iets mis');
     });
-    it("should return a 1001 error message", () => {
-        expect(customSpecificErrorMessageOverlayConfig[1001]).toBe("Oeps, er gaat iets mis");
+    it('should return a 1001 error message', () => {
+        expect(customSpecificErrorMessageOverlayConfig[1001]).toBe('Oeps, er gaat iets mis');
     });
-    it("should return a 1101 error message", () => {
-        expect(customSpecificErrorMessageOverlayConfig[1101]).toBe("De player is niet aangemaakt");
+    it('should return a 1101 error message', () => {
+        expect(customSpecificErrorMessageOverlayConfig[1101]).toBe('De player is niet aangemaakt');
     });
-    it("should return a 1102 error message", () => {
-        expect(customSpecificErrorMessageOverlayConfig[1102]).toBe("Er ging iets mis met de configuratie");
+    it('should return a 1102 error message', () => {
+        expect(customSpecificErrorMessageOverlayConfig[1102]).toBe('Er ging iets mis met de configuratie');
     });
-    it("should return a 1103 error message", () => {
-        expect(customSpecificErrorMessageOverlayConfig[1103]).toBe("Er is iets mis met de licentie (access key)");
+    it('should return a 1103 error message', () => {
+        expect(customSpecificErrorMessageOverlayConfig[1103]).toBe('Er is iets mis met de licentie (access key)');
     });
-    it("should return a 1104 error message", () => {
-        expect(customSpecificErrorMessageOverlayConfig[1104]).toBe("De video kan niet worden afgespeeld op dit domein");
+    it('should return a 1104 error message', () => {
+        expect(customSpecificErrorMessageOverlayConfig[1104]).toBe('De video kan niet worden afgespeeld op dit domein');
     });
-    it("should return a 1105 error message", () => {
-        expect(customSpecificErrorMessageOverlayConfig[1105]).toBe("De video kan niet op dit web-adres worden afgespeeld");
+    it('should return a 1105 error message', () => {
+        expect(customSpecificErrorMessageOverlayConfig[1105]).toBe('De video kan niet op dit web-adres worden afgespeeld');
     });
-    it("should return a 1113 error message", () => {
-        expect(customSpecificErrorMessageOverlayConfig[1113]).toBe("De video kan niet worden afgespeeld zonder web server");
+    it('should return a 1113 error message', () => {
+        expect(customSpecificErrorMessageOverlayConfig[1113]).toBe('De video kan niet worden afgespeeld zonder web server');
     });
-    it("should return a 1201 error message", () => {
-        expect(customSpecificErrorMessageOverlayConfig[1201]).toBe("Er is iets mis met de source configuratie");
+    it('should return a 1201 error message', () => {
+        expect(customSpecificErrorMessageOverlayConfig[1201]).toBe('Er is iets mis met de source configuratie');
     });
-    it("should return a 1202 error message", () => {
-        expect(customSpecificErrorMessageOverlayConfig[1202]({ code: 1202 })).toBe("The downloaded manifest is invalid");
+    it('should return a 1202 error message', () => {
+        expect(customSpecificErrorMessageOverlayConfig[1202]({ code: 1202 })).toBe('The downloaded manifest is invalid');
     });
-    it("should return a 1203 error message", () => {
-        expect(customSpecificErrorMessageOverlayConfig[1203]).toBe("Helaas, deze video is niet beschikbaar.");
+    it('should return a 1203 error message', () => {
+        expect(customSpecificErrorMessageOverlayConfig[1203]).toBe('Helaas, deze video is niet beschikbaar.');
     });
-    it("should return a 1208 error message", () => {
+    it('should return a 1208 error message', () => {
         const errorMessage = customSpecificErrorMessageOverlayConfig[1208]({
-            data: { statusCode: 1 },
+            data: { statusCode: 1 }
         });
-        expect(errorMessage).toBe("Manifest laden mislukt met HTTP fout 1");
+        expect(errorMessage).toBe('Manifest laden mislukt met HTTP fout 1');
     });
-    it("should return a 1400 error message", () => {
-        expect(customSpecificErrorMessageOverlayConfig[1400]).toBe("Er is iets mis met uw internet-verbinding");
+    it('should return a 1400 error message', () => {
+        expect(customSpecificErrorMessageOverlayConfig[1400]).toBe('Er is iets mis met uw internet-verbinding');
     });
-    it("should return a 2003 error message", () => {
-        expect(customSpecificErrorMessageOverlayConfig[2003]).toBe("Oeps, er is iets mis met het opvragen van de DRM");
+    it('should return a 2003 error message', () => {
+        expect(customSpecificErrorMessageOverlayConfig[2003]).toBe('Oeps, er is iets mis met het opvragen van de DRM');
     });
-    it("should return a 2006 error message", () => {
-        expect(customSpecificErrorMessageOverlayConfig[2006]).toBe("Oeps, er is iets mis met de DRM");
+    it('should return a 2006 error message', () => {
+        expect(customSpecificErrorMessageOverlayConfig[2006]).toBe('Oeps, er is iets mis met de DRM');
     });
 });

package/lib/js/playeractions/handlers/customerrors.js

@@ -1,56 +1,56 @@
-import { ErrorUtils } from "bitmovin-player-ui";
+import { ErrorUtils } from 'bitmovin-player-ui';
 export const customSpecificErrorMessageOverlayConfig = {
-    1000: "Oeps, er gaat iets mis",
-    1001: "Oeps, er gaat iets mis",
-    1101: "De player is niet aangemaakt",
-    1102: "Er ging iets mis met de configuratie",
-    1103: "Er is iets mis met de licentie (access key)",
-    1104: "De video kan niet worden afgespeeld op dit domein",
-    1105: "De video kan niet op dit web-adres worden afgespeeld",
-    1106: "",
-    1107: "",
-    1108: "",
-    1113: "De video kan niet worden afgespeeld zonder web server",
-    1201: "Er is iets mis met de source configuratie",
+    1000: 'Oeps, er gaat iets mis',
+    1001: 'Oeps, er gaat iets mis',
+    1101: 'De player is niet aangemaakt',
+    1102: 'Er ging iets mis met de configuratie',
+    1103: 'Er is iets mis met de licentie (access key)',
+    1104: 'De video kan niet worden afgespeeld op dit domein',
+    1105: 'De video kan niet op dit web-adres worden afgespeeld',
+    1106: '',
+    1107: '',
+    1108: '',
+    1113: 'De video kan niet worden afgespeeld zonder web server',
+    1201: 'Er is iets mis met de source configuratie',
     1202: (error) => {
         return ErrorUtils.defaultErrorMessages[error.code];
     },
-    1203: "Helaas, deze video is niet beschikbaar.",
-    1204: "",
-    1205: "",
-    1206: "",
-    1207: "",
+    1203: 'Helaas, deze video is niet beschikbaar.',
+    1204: '',
+    1205: '',
+    1206: '',
+    1207: '',
     1208: (error) => {
         const statusCode = error.data.statusCode;
-        return "Manifest laden mislukt met HTTP fout " + statusCode;
+        return 'Manifest laden mislukt met HTTP fout ' + statusCode;
     },
-    1209: "",
-    1210: "",
-    1211: "",
-    1301: "",
-    1304: "",
-    1400: "Er is iets mis met uw internet-verbinding",
-    1401: "",
-    1402: "",
-    1403: "",
-    1404: "",
-    2001: "",
-    2002: "",
-    2003: "Oeps, er is iets mis met het opvragen van de DRM",
-    2005: "",
-    2006: "Oeps, er is iets mis met de DRM",
-    2007: "",
-    2008: "",
-    2009: "",
-    2010: "",
-    2011: "",
-    2012: "",
-    2013: "",
-    2015: "",
-    2101: "",
-    3001: "",
-    3002: "",
-    3003: "",
-    3004: "",
-    4000: "",
+    1209: '',
+    1210: '',
+    1211: '',
+    1301: '',
+    1304: '',
+    1400: 'Er is iets mis met uw internet-verbinding',
+    1401: '',
+    1402: '',
+    1403: '',
+    1404: '',
+    2001: '',
+    2002: '',
+    2003: 'Oeps, er is iets mis met het opvragen van de DRM',
+    2005: '',
+    2006: 'Oeps, er is iets mis met de DRM',
+    2007: '',
+    2008: '',
+    2009: '',
+    2010: '',
+    2011: '',
+    2012: '',
+    2013: '',
+    2015: '',
+    2101: '',
+    3001: '',
+    3002: '',
+    3003: '',
+    3004: '',
+    4000: ''
 };

package/lib/js/playeractions/handlers/error.js

@@ -7,7 +7,7 @@ export function handlePlayerError(player, uiComponents, input) {
     player.unload();
     if (uiComponents.controlbar)
         uiComponents.controlbar.hide();
-    if (uiComponents.errorMessageOverlay == null)
+    if (uiComponents.errorMessageOverlay == undefined)
         return;
     uiComponents.errorMessageOverlay.show();
     uiComponents.errorMessageOverlay.errorLabel.setText(message ?? 'De video kan niet worden geladen');

package/lib/js/playeractions/handlers/error.test.js

@@ -1,43 +1,43 @@
-import { handlePlayerError } from "./error";
+import { handlePlayerError } from './error';
 const hide = jest.fn();
 const unload = jest.fn();
 const setText = jest.fn();
 const show = jest.fn();
-const input = "string";
+const input = 'string';
 const player = { unload };
 const uiComponents = {
     controlbar: { hide },
     errorMessageOverlay: {
         errorLabel: { setText },
-        show,
-    },
+        show
+    }
 };
-describe("Test DRM verification", () => {
+describe('Test DRM verification', () => {
     afterEach(() => {
         jest.resetAllMocks();
     });
-    it("should call player.unload", () => {
+    it('should call player.unload', () => {
         handlePlayerError(player, uiComponents, input);
         expect(unload).toHaveBeenCalled();
     });
-    it("should hide the controlbar", () => {
+    it('should hide the controlbar', () => {
         handlePlayerError(player, uiComponents, input);
         expect(hide).toHaveBeenCalled();
     });
-    it("should not hide the controlbar", () => {
+    it('should not hide the controlbar', () => {
         const components = {
             ...uiComponents,
-            controlbar: undefined,
+            controlbar: undefined
         };
         handlePlayerError(player, components, input);
         expect(hide).not.toHaveBeenCalled();
     });
-    it("should show the message overlay", () => {
+    it('should show the message overlay', () => {
         handlePlayerError(player, uiComponents, input);
         expect(show).toHaveBeenCalled();
         expect(setText).toHaveBeenCalled();
     });
-    it("should not show the message overlay", () => {
+    it('should not show the message overlay', () => {
         handlePlayerError(player, { ...uiComponents, errorMessageOverlay: undefined }, input);
         expect(show).not.toHaveBeenCalled();
     });

package/lib/js/playeractions/handlers/handleoffsets.d.ts

@@ -2,5 +2,5 @@ import { type PlayerAPI } from 'bitmovin-player';
 import type NpoPlayer from '../../../npoplayer';
 import { type StreamOptions } from 'types/interfaces';
 export declare function handleStartOffset(player: PlayerAPI, offset?: number): void;
-export declare function shiftToProgramStart(player: PlayerAPI | null, timestamp?: number): void;
-export declare function handleLiveOffsetLogic(npoplayer: NpoPlayer, player: PlayerAPI | null, options: StreamOptions): void;
+export declare function shiftToProgramStart(player: PlayerAPI | undefined, timestamp?: number): void;
+export declare function handleLiveOffsetLogic(npoplayer: NpoPlayer, player: PlayerAPI | undefined, options: StreamOptions): void;