@npo/player 1.25.0 → 1.26.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.25.0
+Current version: v1.26.0
 
 The changelog is available at https://docs.npoplayer.nl/implementation/web/changelog/
 

package/lib/js/api/getstreamobject.d.ts

@@ -1,3 +1,3 @@
 import { type ApiPayload } from '../../types/interfaces';
 import type NpoPlayer from '../../npoplayer';
-export declare function getStreamObject(npoplayer: NpoPlayer, payload: ApiPayload): Promise<any>;
+export declare function getStreamObject(npoPlayer: NpoPlayer, payload: ApiPayload): Promise<any>;

package/lib/js/api/getstreamobject.js

@@ -1,5 +1,5 @@
 import { removeTrailingSlash } from '../utilities/utilities.url';
-export async function getStreamObject(npoplayer, payload) {
+export async function getStreamObject(npoPlayer, payload) {
     try {
         const controller = new AbortController();
         const { signal } = controller;
@@ -22,16 +22,16 @@ export async function getStreamObject(npoplayer, payload) {
             return streamApiResponse;
         }
         else {
-            npoplayer.doError(`Het is niet gelukt de stream op te halen: \n ${streamApiResponse.body}`, response.status);
+            npoPlayer.doError('Het is niet gelukt de stream op te halen.', response.status);
         }
     }
     catch (error) {
         if (error instanceof Error) {
             if (error.message === 'AbortError') {
-                npoplayer.doError('Het is niet gelukt de stream op te halen: \n Request timed out', 408);
+                npoPlayer.doError('Het ophalen van de stream duurde te lang.', 408);
             }
             else {
-                npoplayer.doError(`Het is niet gelukt de stream op te halen: \n ${error.message}`, 500);
+                npoPlayer.doError(`Het is niet gelukt de stream op te halen: \n ${error.message}`, 500);
             }
         }
     }

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

@@ -2,18 +2,18 @@ import { getStreamObject } from './getstreamobject';
 import NpoPlayer from '../../npoplayer';
 import fetchMock from 'jest-fetch-mock';
 fetchMock.enableMocks();
-jest.mock('../../services/streamoptionsHandlers/steamOptionsHandler', () => ({
+jest.mock('../../services/streamoptionsHandlers/streamOptionsHandler', () => ({
     handleStreamOptions: jest.fn()
 }));
 describe('getStreamObject', () => {
-    let npoplayer;
+    let npoPlayer;
     let apiPayload;
     const testPlayerConfig = {
         key: 'dummy key'
     };
     const div = document.createElement('div');
     beforeEach(() => {
-        npoplayer = new NpoPlayer(div, testPlayerConfig);
+        npoPlayer = new NpoPlayer(div, testPlayerConfig);
         apiPayload = {
             baseURL: 'http://example.com',
             jwt: 'someToken',
@@ -24,25 +24,25 @@ describe('getStreamObject', () => {
     });
     it('should handle successful fetch', async () => {
         fetchMock.mockResponseOnce(JSON.stringify({ foo: 'bar' }));
-        const result = await getStreamObject(npoplayer, apiPayload);
+        const result = await getStreamObject(npoPlayer, apiPayload);
         expect(result).toEqual({ foo: 'bar' });
     });
     it('should handle fetch with bad response', async () => {
         fetchMock.mockResponseOnce(JSON.stringify({ body: 'Bad Request' }), { status: 400 });
-        const doErrorSpy = jest.spyOn(npoplayer, 'doError');
-        await getStreamObject(npoplayer, apiPayload);
-        expect(doErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Het is niet gelukt de stream op te halen'), 400);
+        const doErrorSpy = jest.spyOn(npoPlayer, 'doError');
+        await getStreamObject(npoPlayer, apiPayload);
+        expect(doErrorSpy).toHaveBeenCalledWith(expect.stringMatching('Het is niet gelukt de stream op te halen.'), 400);
     });
     it('should handle fetch timeout', async () => {
         fetchMock.mockRejectOnce(new Error('AbortError'));
-        const doErrorSpy = jest.spyOn(npoplayer, 'doError');
-        await getStreamObject(npoplayer, apiPayload);
-        expect(doErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Request timed out'), 408);
+        const doErrorSpy = jest.spyOn(npoPlayer, 'doError');
+        await getStreamObject(npoPlayer, apiPayload);
+        expect(doErrorSpy).toHaveBeenCalledWith(expect.stringMatching('Het ophalen van de stream duurde te lang.'), 408);
     });
     it('should handle fetch with other errors', async () => {
         fetchMock.mockRejectOnce(new Error('SomeError'));
-        const doErrorSpy = jest.spyOn(npoplayer, 'doError');
-        await getStreamObject(npoplayer, apiPayload);
+        const doErrorSpy = jest.spyOn(npoPlayer, 'doError');
+        await getStreamObject(npoPlayer, apiPayload);
         expect(doErrorSpy).toHaveBeenCalledWith(expect.stringContaining('SomeError'), 500);
     });
 });

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

@@ -8,11 +8,13 @@ export function handleStartOffset(playerContext, offset) {
         return;
     }
     const seek = () => {
+        player.off(NpoPlayerEvent.Ready, seek);
         player.off(NpoPlayerEvent.SourceLoaded, seek);
         player.off(NpoPlayerEvent.AdBreakFinished, seek);
         player.off(NpoPlayerEvent.AdError, seek);
         player.seek(offset);
     };
+    player.on(NpoPlayerEvent.Ready, seek);
     player.on(NpoPlayerEvent.SourceLoaded, seek);
     player.on(NpoPlayerEvent.AdBreakFinished, seek);
     player.on(NpoPlayerEvent.AdError, seek);
@@ -28,22 +30,22 @@ export function shiftToProgramStart(playerContext, timestamp) {
     player.timeShift(timestamp);
 }
 export function handleLiveOffsetLogic(playerContext, options) {
-    const { player, npoplayer } = playerContext;
-    if (npoplayer.uiComponents.watchFromStartButton == undefined)
+    const { player, npoPlayer } = playerContext;
+    if (npoPlayer.uiComponents.watchFromStartButton == undefined)
         return;
     if (options?.liveProgramTime == undefined) {
-        npoplayer.uiComponents.watchFromStartButton.hide();
+        npoPlayer.uiComponents.watchFromStartButton.hide();
         return;
     }
-    npoplayer.streamOptions.liveProgramTime = options.liveProgramTime;
+    npoPlayer.streamOptions.liveProgramTime = options.liveProgramTime;
     if (player.isLive() && options.liveProgramTime > 0) {
-        npoplayer.uiComponents.watchFromStartButton.show();
+        npoPlayer.uiComponents.watchFromStartButton.show();
     }
     else {
-        npoplayer.uiComponents.watchFromStartButton.hide();
+        npoPlayer.uiComponents.watchFromStartButton.hide();
     }
     if (options.liveOffset !== null && options.liveOffset !== false && options.liveProgramTime > 0) {
-        npoplayer.uiComponents.watchFromStartButton.hide();
+        npoPlayer.uiComponents.watchFromStartButton.hide();
         shiftToProgramStart(playerContext, options.liveProgramTime);
     }
 }

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

@@ -39,7 +39,7 @@ describe('Test offset handling', () => {
             seek: seekMock,
             off: jest.fn(),
             on: jest.fn((event, callback) => {
-                if (event === PlayerEvent.SourceLoaded) {
+                if (event === PlayerEvent.Ready) {
                     callback();
                 }
             })

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

@@ -1,3 +1,3 @@
 import { type PlayerConfig } from 'bitmovin-player';
 import NpoPlayer from 'npoplayer';
-export declare function processPlayerConfig(npoplayer: NpoPlayer, playerConfig: PlayerConfig): PlayerConfig;
+export declare function processPlayerConfig(npoPlayer: NpoPlayer, playerConfig: PlayerConfig): PlayerConfig;

package/lib/js/playeractions/handlers/processplayerconfig.js

@@ -1,6 +1,6 @@
 import { LogLevel } from 'bitmovin-player';
 import { isSafari } from '../../utilities/utilities.user-agent';
-export function processPlayerConfig(npoplayer, playerConfig) {
+export function processPlayerConfig(npoPlayer, playerConfig) {
     const processedConfig = playerConfig;
     if (isSafari()) {
         processedConfig.playback = {
@@ -17,9 +17,9 @@ export function processPlayerConfig(npoplayer, playerConfig) {
         receiverVersion: 'v3',
         messageNamespace: 'urn:x-cast:com.bitmovin.player.caf',
         customReceiverConfig: {
-            drm: npoplayer.drmProfile.drm,
-            profileName: npoplayer.drmProfile.profileName,
-            jwt: npoplayer.jwt
+            drm: npoPlayer.drmProfile.drm,
+            profileName: npoPlayer.drmProfile.profileName,
+            jwt: npoPlayer.jwt
         }
     };
     const userRemoteControlConfig = processedConfig.remotecontrol || defaultRemoteControlConfig;

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

@@ -2,4 +2,5 @@ import { StreamObject, StreamOptions } from 'types/interfaces';
 import { SourceConfig } from 'bitmovin-player';
 import { NpoPlayerServices } from '../../../services/services';
 import { NPOTag } from '@npotag/tag';
+export declare const getSubtitleLabels: (data: any) => string;
 export declare function processSourceConfig(npoPlayerServices: NpoPlayerServices, source: string, _sourceConfig: SourceConfig | undefined, _streamObject: StreamObject, drm: string | undefined, streamOptions: StreamOptions, version: string, npoTagInstance: NPOTag | undefined): Promise<SourceConfig>;

package/lib/js/playeractions/handlers/processsourceconfig.js

@@ -1,6 +1,7 @@
 import { HttpResponseType } from 'bitmovin-player';
 import { npoCdnProviders } from '../../../services/cdnProviders/cdnProviders';
 import { replaceSpecialCharacters } from '../../utilities/utilities.text';
+import subtitleLabelMap from '../../../lang/subtitleLabels/nl.json';
 async function setDrm(sourceConfig, drm, _streamObject, useWidevineServerCertificate) {
     const npoDrmGateway = 'https://npo-drm-gateway.samgcloud.nepworldwide.nl/authentication?custom_data=';
     switch (drm) {
@@ -66,11 +67,9 @@ async function getServerCertificate(url) {
     const response = await fetch(url);
     return response.arrayBuffer();
 }
-const getSubtitleLabels = function (data) {
-    if (data.label === 'nl') {
-        return 'Nederlands';
-    }
-    return data.label;
+export const getSubtitleLabels = function (data) {
+    const langKey = data.lang.toLowerCase();
+    return subtitleLabelMap[langKey] || data.label || langKey;
 };
 const getQualityLabels = function (data) {
     return data.height + 'p';

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

@@ -0,0 +1,25 @@
+import { getSubtitleLabels } from './processsourceconfig';
+describe('getSubtitleLabels', () => {
+    it('should return the correct language label for known lang codes', () => {
+        expect(getSubtitleLabels({ lang: 'ar' })).toBe('Arabisch');
+        expect(getSubtitleLabels({ lang: 'bg' })).toBe('Bulgaars');
+        expect(getSubtitleLabels({ lang: 'de' })).toBe('Duits');
+        expect(getSubtitleLabels({ lang: 'en' })).toBe('Engels');
+        expect(getSubtitleLabels({ lang: 'es' })).toBe('Spaans');
+        expect(getSubtitleLabels({ lang: 'fr' })).toBe('Frans');
+        expect(getSubtitleLabels({ lang: 'it' })).toBe('Italiaans');
+        expect(getSubtitleLabels({ lang: 'nl' })).toBe('Nederlands');
+        expect(getSubtitleLabels({ lang: 'ma' })).toBe('Marokkaans');
+        expect(getSubtitleLabels({ lang: 'pl' })).toBe('Pools');
+        expect(getSubtitleLabels({ lang: 'ua' })).toBe('Oekraïens');
+        expect(getSubtitleLabels({ lang: 'tr' })).toBe('Turks');
+    });
+    it('should return the original label if the lang code is unknown', () => {
+        expect(getSubtitleLabels({ lang: 'jp', label: 'Japanese' })).toBe('Japanese');
+        expect(getSubtitleLabels({ lang: 'jp' })).toBe('jp');
+    });
+    it('should handle mixed case lang codes', () => {
+        expect(getSubtitleLabels({ lang: 'EN' })).toBe('Engels');
+        expect(getSubtitleLabels({ lang: 'Fr' })).toBe('Frans');
+    });
+});

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

@@ -4,7 +4,7 @@ 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 | undefined;
@@ -30,10 +30,9 @@ 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 | {
         container: HTMLElement;
         playerConfig: PlayerConfig;

package/lib/npoplayer.js

@@ -12,7 +12,7 @@ import { logVersion } from './js/utilities/utilities.version';
 import { getStreamDurationInSeconds } from './js/utilities/utilities.stream';
 import { LogEmitter } from './types/classes';
 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';
@@ -45,9 +45,8 @@ 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 = {};
         if (typeof container === 'object' && !(container instanceof HTMLElement)) {
             const params = container;
             this.container = params.container;
@@ -80,35 +79,25 @@ export default class NpoPlayer {
         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.adBreakActive) {
-            const currentAd = this.player.ads.getActiveAdBreak().id;
-            this.player.ads.discardAdBreak(currentAd);
-        }
+        this.npoPlayerServices.discardAdBreak(this.playerContext);
         let _streamObject;
         const sourceIsUrl = isUrl(source);
         const sourceIsMedia = await isMediaUrl(source);
@@ -131,12 +120,13 @@ export default class NpoPlayer {
                     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 = {
@@ -153,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);
@@ -168,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, 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);
+            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;
@@ -192,7 +180,7 @@ export default class NpoPlayer {
                 this.streamObject.assets.preroll) {
                 this.player.on(PlayerEvent.AdBreakFinished, initAndStartTracker);
                 this.player.on(PlayerEvent.AdError, initAndStartTracker);
-                await this.npoplayerServices.schedulePreRolls(this.playerContext);
+                await this.npoPlayerServices.schedulePreRolls(this.playerContext);
             }
             else {
                 initAndStartTracker();
@@ -201,11 +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.setupNicamKijkwijzerIcons(this.playerContext);
-        this.player.on(PlayerEvent.Play, () => {
-            this.npoplayerServices.showNicamAfterUiDelay(this.playerContext, this.uiManager);
+        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.npoPlayerServices.handleVerticalVideoControls(this.playerContext, this.variant);
         this.player.on(PlayerEvent.Seek, () => {
             removeReplayClass(this.player);
         });
@@ -226,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);
@@ -328,6 +317,9 @@ export default class NpoPlayer {
                     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();

package/lib/npoplayer.test.js

@@ -3,7 +3,7 @@ const div = document.createElement('div');
 const testPlayerConfig = {
     key: 'dummy-key'
 };
-jest.mock('./services/streamoptionsHandlers/steamOptionsHandler', () => ({
+jest.mock('./services/streamoptionsHandlers/streamOptionsHandler', () => ({
     handleStreamOptions: jest.fn()
 }));
 let player;

package/lib/package.json

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

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;
 }

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);
     });
 });