@npo/player 1.24.7 → 1.26.0

package/lib/services/streamoptionsHandlers/streamOptionsHandler.test.js

@@ -0,0 +1,187 @@
+import { handleStreamOptions, initializeFragment, handleStartOffset, updateStreamClasses, setupAutoplay } from './streamOptionsHandler';
+import '@testing-library/jest-dom';
+import { createMockNpoPlayer, createPlayerContextMock, createMockNpoPlayerAPI } from '../../../tests/mocks/playerContextMock';
+import * as playerAction from '../../js/playeractions/playeractions';
+import { updateClassFromElementByQuery } from '../../js/utilities/utilities.element';
+import { handleLiveStreamControls } from '../liveStreamHandlers/handleLiveStreamControls';
+import { initSegment } from '../segmentHandlers/initSegment';
+import { NpoPlayerEvent } from '../../types/events';
+import { removeEventListeners } from '../eventListenerHandlers/removeEventListeners';
+jest.mock('../segmentHandlers/initSegment');
+jest.mock('../eventListenerHandlers/removeEventListeners');
+jest.mock('../../js/playeractions/playeractions');
+jest.mock('../liveStreamHandlers/handleLiveStreamControls');
+jest.mock('../../js/utilities/utilities.element', () => ({
+    updateClassFromElementByQuery: jest.fn()
+}));
+describe('handleStreamOptions', () => {
+    let mockElement;
+    beforeEach(() => {
+        mockElement = { innerHTML: '', appendChild: jest.fn() };
+        document.querySelector = jest.fn().mockReturnValue(mockElement);
+    });
+    it('correctly calls all of the functions when the conditions are met', () => {
+        const mockNpoPlayerAPI = createMockNpoPlayerAPI({
+            on: jest.fn(),
+            off: jest.fn()
+        });
+        const npoPlayerMock = createMockNpoPlayer({
+            playerconfig: {
+                playback: {
+                    muted: false,
+                    autoplay: true
+                }
+            },
+            streamObject: {
+                stream: {
+                    isLiveStream: true
+                }
+            }
+        });
+        const playerContextMock = createPlayerContextMock({
+            player: mockNpoPlayerAPI,
+            npoPlayer: npoPlayerMock
+        });
+        handleStreamOptions(playerContextMock);
+        expect(initializeFragment(playerContextMock)).toHaveBeenCalled;
+        expect(handleStartOffset(playerContextMock)).toHaveBeenCalled;
+        expect(updateStreamClasses(playerContextMock)).toHaveBeenCalled;
+        expect(setupAutoplay(playerContextMock)).toHaveBeenCalled;
+    });
+    it('should return early if uiManager is missing', () => {
+        const npoPlayerMock = createMockNpoPlayer({
+            UIManager: null
+        });
+        const playerContextMock = createPlayerContextMock({
+            npoPlayer: npoPlayerMock
+        });
+        handleStreamOptions(playerContextMock);
+        expect(removeEventListeners).not.toHaveBeenCalled();
+    });
+    it('should return early if streamObject is missing', () => {
+        const npoPlayerMock = createMockNpoPlayer({
+            streamObject: null
+        });
+        const playerContextMock = createPlayerContextMock({
+            npoPlayer: npoPlayerMock
+        });
+        handleStreamOptions(playerContextMock);
+        expect(removeEventListeners).not.toHaveBeenCalled();
+    });
+    it('should return early if autoplay is false', () => {
+        const npoPlayerMock = createMockNpoPlayer({
+            playerconfig: {
+                playback: {
+                    muted: false,
+                    autoplay: true
+                }
+            },
+            streamOptions: {
+                autoplay: false
+            }
+        });
+        const playerContextMock = createPlayerContextMock({
+            npoPlayer: npoPlayerMock
+        });
+        const setupAutoplayMock = jest.fn();
+        handleStreamOptions(playerContextMock);
+        expect(setupAutoplayMock).not.toHaveBeenCalled();
+    });
+    describe('updateStreamClasses', () => {
+        it('should add "livestream-no-dvr" class when isLiveStream is true and hasDvrWindow is false', () => {
+            const npoPlayerMock = createMockNpoPlayer({
+                streamObject: {
+                    stream: {
+                        isLiveStream: true,
+                        hasDvrWindow: false
+                    }
+                }
+            });
+            const playerContextMock = createPlayerContextMock({
+                npoPlayer: npoPlayerMock
+            });
+            updateStreamClasses(playerContextMock);
+            expect(updateClassFromElementByQuery).toHaveBeenCalledWith(expect.objectContaining({
+                className: 'livestream-no-dvr',
+                condition: true
+            }));
+        });
+        it('should add "audio-only" class when avType is "aod" or "audio"', () => {
+            const npoPlayerMock = createMockNpoPlayer({
+                streamObject: {
+                    stream: {
+                        avType: 'aod'
+                    }
+                }
+            });
+            const playerContextMock = createPlayerContextMock({
+                npoPlayer: npoPlayerMock
+            });
+            updateStreamClasses(playerContextMock);
+            expect(updateClassFromElementByQuery).toHaveBeenCalledWith(expect.objectContaining({
+                className: 'audio-only',
+                condition: true
+            }));
+        });
+        it('should call handleLiveStreamControls when isLiveStream is true and hasDvrWindow is true', () => {
+            const npoPlayerMock = createMockNpoPlayer({
+                streamObject: {
+                    stream: {
+                        isLiveStream: true,
+                        hasDvrWindow: true
+                    }
+                }
+            });
+            const playerContextMock = createPlayerContextMock({
+                npoPlayer: npoPlayerMock
+            });
+            updateStreamClasses(playerContextMock);
+            expect(handleLiveStreamControls).toHaveBeenCalledWith(playerContextMock);
+        });
+    });
+    describe('initializeFragment', () => {
+        it('should call initSegment with correct parameters', () => {
+            const npoPlayerMock = createMockNpoPlayer({
+                streamObject: { segment: 'segment' },
+                streamOptions: { fragments: { sections: [{ duration: 10, time: 0 }] } }
+            });
+            const playerContextMock = createPlayerContextMock({
+                npoPlayer: npoPlayerMock
+            });
+            initializeFragment(playerContextMock);
+            expect(initSegment).toHaveBeenCalledWith(playerContextMock, {
+                segment: 'segment',
+                fragment: { sections: [{ duration: 10, time: 0 }] }
+            });
+        });
+    });
+    describe('handleStartOffset', () => {
+        it('should call handleStartOffset with correct parameters', () => {
+            const npoPlayerMock = createMockNpoPlayer({
+                streamOptions: { startOffset: 10 }
+            });
+            const playerContextMock = createPlayerContextMock({
+                npoPlayer: npoPlayerMock
+            });
+            handleStartOffset(playerContextMock);
+            expect(playerAction.handleStartOffset).toHaveBeenCalledWith(playerContextMock, 10);
+        });
+    });
+    describe('setupAutoplay', () => {
+        it('should setup autoplay correctly', async () => {
+            const mockNpoPlayerAPI = createMockNpoPlayerAPI({
+                on: jest.fn(),
+                off: jest.fn(),
+                play: jest.fn().mockResolvedValue(undefined)
+            });
+            const playerContextMock = createPlayerContextMock({
+                player: mockNpoPlayerAPI
+            });
+            setupAutoplay(playerContextMock);
+            expect(playerContextMock.player.on).toHaveBeenCalledWith(NpoPlayerEvent.Ready, expect.any(Function));
+            const handleAutoPlay = playerContextMock.player.on.mock.calls[0][1];
+            await handleAutoPlay();
+            expect(playerContextMock.player.play).toHaveBeenCalled();
+        });
+    });
+});

package/lib/services/uiHandlers/uiVisiblityHandler.d.ts

@@ -0,0 +1,3 @@
+import { PlayerContext } from '../../types/interfaces';
+export declare function addUivisiblityHandlers(playerContext: PlayerContext): void;
+export declare function removeUivisiblityHandlers(playerContext: PlayerContext): void;

package/lib/services/uiHandlers/uiVisiblityHandler.js

@@ -0,0 +1,26 @@
+import { NpoPlayerUIVariants } from '../../types/interfaces';
+export function addUivisiblityHandlers(playerContext) {
+    const { uiManager, variant } = playerContext.npoPlayer;
+    if (!uiManager)
+        return;
+    if (variant === NpoPlayerUIVariants.DEFAULT) {
+        uiManager.activeUi.onControlsHide.subscribe(() => {
+            playerContext.npoPlayer.logEmitter.emit('logControlsVisibilityChange', false);
+        });
+        uiManager.activeUi.onControlsShow.subscribe(() => {
+            playerContext.npoPlayer.logEmitter.emit('logControlsVisibilityChange', true);
+        });
+        uiManager.activeUi.getUI().showUi();
+    }
+}
+export function removeUivisiblityHandlers(playerContext) {
+    const { uiManager } = playerContext.npoPlayer;
+    if (!uiManager)
+        return;
+    uiManager.activeUi.onControlsHide.unsubscribe(() => {
+        playerContext.npoPlayer.logEmitter.emit('logControlsVisibilityChange', false);
+    });
+    uiManager.activeUi.onControlsShow.unsubscribe(() => {
+        playerContext.npoPlayer.logEmitter.emit('logControlsVisibilityChange', true);
+    });
+}

package/lib/services/uiHandlers/uiVisiblityHandler.test.d.ts

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

package/lib/services/uiHandlers/uiVisiblityHandler.test.js

@@ -0,0 +1,62 @@
+import createPlayerContextMock from '../../../tests/mocks/playerContextMock';
+import { addUivisiblityHandlers, removeUivisiblityHandlers } from './uiVisiblityHandler';
+import { NpoPlayerUIVariants } from '../../types/interfaces';
+import { createLogEmitterMock } from '../../../tests/mocks/mockLogEmitter';
+describe('UI Visibility Handlers', () => {
+    let mockPlayerContext;
+    let mockLogEmitter;
+    let mockUIManager;
+    beforeEach(() => {
+        mockLogEmitter = createLogEmitterMock();
+        mockUIManager = {
+            activeUi: {
+                onControlsHide: { subscribe: jest.fn(), unsubscribe: jest.fn() },
+                onControlsShow: { subscribe: jest.fn(), unsubscribe: jest.fn() },
+                getUI: jest.fn().mockReturnValue({ showUi: jest.fn() })
+            }
+        };
+        mockPlayerContext = createPlayerContextMock();
+        mockPlayerContext.npoPlayer.logEmitter = mockLogEmitter;
+        mockPlayerContext.npoPlayer.uiManager = mockUIManager;
+        mockPlayerContext.npoPlayer.variant = NpoPlayerUIVariants.DEFAULT;
+    });
+    describe('addUivisiblityHandlers', () => {
+        it('should subscribe to visibility handlers and call showUi', () => {
+            addUivisiblityHandlers(mockPlayerContext);
+            expect(mockUIManager.activeUi.onControlsHide.subscribe).toHaveBeenCalled();
+            expect(mockUIManager.activeUi.onControlsShow.subscribe).toHaveBeenCalled();
+            expect(mockUIManager.activeUi.getUI().showUi).toHaveBeenCalled();
+        });
+        it('should emit logControlsVisibilityChange when controls are shown', () => {
+            addUivisiblityHandlers(mockPlayerContext);
+            const onControlsShowCallback = mockUIManager.activeUi.onControlsShow.subscribe.mock.calls[0][0];
+            onControlsShowCallback();
+            expect(mockLogEmitter.emit).toHaveBeenCalledWith('logControlsVisibilityChange', true);
+        });
+        it('should emit logControlsVisibilityChange when controls are hidden', () => {
+            addUivisiblityHandlers(mockPlayerContext);
+            const onControlsHideCallback = mockUIManager.activeUi.onControlsHide.subscribe.mock.calls[0][0];
+            onControlsHideCallback();
+            expect(mockLogEmitter.emit).toHaveBeenCalledWith('logControlsVisibilityChange', false);
+        });
+        it('should not do anything if uiManager is not defined', () => {
+            mockPlayerContext.npoPlayer.uiManager = undefined;
+            addUivisiblityHandlers(mockPlayerContext);
+            expect(mockLogEmitter.emit).not.toHaveBeenCalled();
+        });
+    });
+    describe('removeUivisiblityHandlers', () => {
+        it('should unsubscribe from visibility handlers', () => {
+            addUivisiblityHandlers(mockPlayerContext);
+            removeUivisiblityHandlers(mockPlayerContext);
+            expect(mockUIManager.activeUi.onControlsHide.unsubscribe).toHaveBeenCalled();
+            expect(mockUIManager.activeUi.onControlsShow.unsubscribe).toHaveBeenCalled();
+        });
+        it('should not do anything if uiManager is not defined', () => {
+            mockPlayerContext.npoPlayer.uiManager = undefined;
+            removeUivisiblityHandlers(mockPlayerContext);
+            expect(mockUIManager.activeUi.onControlsHide.unsubscribe).not.toHaveBeenCalled();
+            expect(mockUIManager.activeUi.onControlsShow.unsubscribe).not.toHaveBeenCalled();
+        });
+    });
+});

package/lib/src/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/src/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/src/js/playeractions/handlers/processplayerconfig.test.d.ts

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

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

@@ -1,4 +1,6 @@
 import { StreamObject, StreamOptions } from 'types/interfaces';
 import { SourceConfig } from 'bitmovin-player';
 import { NpoPlayerServices } from '../../../services/services';
-export declare function processSourceConfig(NpoPlayerServices: NpoPlayerServices, _sourceConfig: SourceConfig | undefined, _streamObject: StreamObject, drm: string | undefined, streamOptions: StreamOptions, version: string, npoTagPartyId: string | undefined, npoPlayerServices: NpoPlayerServices): Promise<SourceConfig>;
+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/src/js/playeractions/handlers/processsourceconfig.test.d.ts

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

package/lib/src/js/settings/localization.d.ts

@@ -1,6 +1,81 @@
 export declare const localizationConfig: {
     language: string;
     vocabularies: {
-        nl: Record<string, string>;
+        nl: {
+            "settings.video.quality": string;
+            "settings.audio.quality": string;
+            "settings.audio.track": string;
+            "settings.audio.mute": string;
+            "settings.audio.unmute": string;
+            "settings.audio.volume": string;
+            "settings.subtitles.window.color": string;
+            "settings.subtitles.window.opacity": string;
+            "settings.subtitles": string;
+            "settings.subtitles.font.color": string;
+            "settings.subtitles.font.opacity": string;
+            "settings.subtitles.background.color": string;
+            "settings.subtitles.background.opacity": string;
+            "colors.white": string;
+            "colors.black": string;
+            "colors.red": string;
+            "colors.green": string;
+            "colors.blue": string;
+            "colors.cyan": string;
+            "colors.yellow": string;
+            "colors.magenta": string;
+            percent: string;
+            "settings.subtitles.font.size": string;
+            "settings.subtitles.characterEdge": string;
+            "settings.subtitles.characterEdge.raised": string;
+            "settings.subtitles.characterEdge.depressed": string;
+            "settings.subtitles.characterEdge.uniform": string;
+            "settings.subtitles.characterEdge.dropshadowed": string;
+            "settings.subtitles.font.family": string;
+            "settings.subtitles.font.family.monospacedserif": string;
+            "settings.subtitles.font.family.proportionalserif": string;
+            "settings.subtitles.font.family.monospacedsansserif": string;
+            "settings.subtitles.font.family.proportionalsansserif": string;
+            "settings.subtitles.font.family.casual": string;
+            "settings.subtitles.font.family.cursive": string;
+            "settings.subtitles.font.family.smallcapital": string;
+            "settings.time.hours": string;
+            "settings.time.minutes": string;
+            "settings.time.seconds": string;
+            "ads.remainingTime": string;
+            settings: string;
+            fullscreen: string;
+            speed: string;
+            playPause: string;
+            play: string;
+            pause: string;
+            open: string;
+            close: string;
+            pictureInPicture: string;
+            appleAirplay: string;
+            googleCast: string;
+            vr: string;
+            off: string;
+            auto: string;
+            back: string;
+            reset: string;
+            replay: string;
+            normal: string;
+            default: string;
+            live: string;
+            "subtitle.example": string;
+            "subtitle.select": string;
+            playingOn: string;
+            connectingTo: string;
+            watermarkLink: string;
+            controlBar: string;
+            player: string;
+            videoPlayer: string;
+            audioPlayer: string;
+            seekBar: string;
+            "seekBar.value": string;
+            "seekBar.timeshift": string;
+            "seekBar.durationText": string;
+            "segment.unplayableTitle": string;
+        };
     };
 };

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

@@ -1,4 +1,4 @@
-import { type NPOTag } from '@npotag/tag';
+import { type NPOTag, type PageTracker } from '@npotag/tag';
 import { type InitialisationProps } from '@npotag/tag/dist/types/src/npoTag';
 import type NpoPlayer from '../../../npoplayer';
-export declare function initPlayerTracker(npoplayer: NpoPlayer, _npotag?: InitialisationProps | undefined, _npotaginstance?: NPOTag): void;
+export declare function initPlayerTracker(npoPlayer: NpoPlayer, _npoTag?: InitialisationProps, _npoTagInstance?: NPOTag, _npoTagPageTracker?: PageTracker): void;

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

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

package/lib/src/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/src/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/src/services/nicamHandlers/nicamhandler.d.ts

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

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

@@ -0,0 +1 @@
+import '@testing-library/jest-dom';

package/lib/src/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;
@@ -25,6 +26,7 @@ export declare class NpoPlayerAPI {
     getSupportedTech(): Technology[];
     off(eventType: NpoPlayerEvent, callback: NpoPlayerEventCallback): void;
     on(eventType: NpoPlayerEvent, callback: NpoPlayerEventCallback): void;
+    isCastAvailable(): boolean;
     seek(time: number): void;
     timeShift(time: number): void;
     getContainer(): HTMLElement;
@@ -37,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>;
 }

package/lib/src/services/preferences/handlePreferences.d.ts

@@ -0,0 +1,2 @@
+import { PlayerContext } from '../../types/interfaces';
+export declare function handlePreferences(playerContext: PlayerContext): void;

package/lib/src/services/preferences/handlePreferences.test.d.ts

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

package/lib/src/services/services.d.ts

@@ -12,5 +12,12 @@ export declare class NpoPlayerServices {
     handleUserPrefs(playerContext: PlayerContext): void;
     setAccessibilityAttributes(playerContext: PlayerContext): void;
     schedulePreRolls(playerContext: PlayerContext): Promise<void>;
+    discardAdBreak(playerContext: PlayerContext): void;
     handleVerticalVideoControls(playerContext: PlayerContext, variant: NpoPlayerUIVariants): void;
+    showNicamAfterUiDelay(playerContext: PlayerContext | undefined): void;
+    setupNicamKijkwijzerIcons(playerContext: PlayerContext): void;
+    handlePreferences(playerContext: PlayerContext): void;
+    addUivisiblityHandlers(playerContext: PlayerContext): void;
+    removeUivisiblityHandlers(playerContext: PlayerContext): void;
+    handleStreamOptions(playerContext: PlayerContext): void;
 }

package/lib/src/services/streamoptionsHandlers/streamOptionsHandler.d.ts

@@ -0,0 +1,6 @@
+import { PlayerContext } from '../../types/interfaces';
+export declare function handleStreamOptions(playerContext: PlayerContext): void;
+export declare function initializeFragment(playerContext: PlayerContext): void;
+export declare function handleStartOffset(playerContext: PlayerContext): void;
+export declare function updateStreamClasses(playerContext: PlayerContext): void;
+export declare function setupAutoplay(playerContext: PlayerContext): void;

package/lib/src/services/streamoptionsHandlers/streamOptionsHandler.test.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom';

package/lib/src/services/uiHandlers/uiVisiblityHandler.d.ts

@@ -0,0 +1,3 @@
+import { PlayerContext } from '../../types/interfaces';
+export declare function addUivisiblityHandlers(playerContext: PlayerContext): void;
+export declare function removeUivisiblityHandlers(playerContext: PlayerContext): void;

package/lib/src/services/uiHandlers/uiVisiblityHandler.test.d.ts

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

package/lib/src/types/classes.d.ts

@@ -1,4 +1,10 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
+type AllowedEvents = 'logControlsVisibilityChange' | 'logError' | 'logEvent';
 export declare class LogEmitter extends EventEmitter {
+    emit(event: AllowedEvents, ...args: any[]): boolean;
+    on(event: AllowedEvents, listener: (...args: any[]) => void): this;
+    once(event: AllowedEvents, listener: (...args: any[]) => void): this;
+    off(event: AllowedEvents, listener: (...args: any[]) => void): this;
 }
+export {};

package/lib/src/types/interfaces.d.ts

@@ -4,7 +4,7 @@ import { ButtonConfig } from 'bitmovin-player-ui/dist/js/framework/components/bu
 import NpoPlayer from '../npoplayer';
 import { NpoPlayerAPI } from '../services/npoPlayerAPI/npoPlayerAPI';
 import { NpoPlayerEventCallback } from './events';
-import { SourceConfig } from 'bitmovin-player';
+import { AnalyticsConfig, DRMConfig, GoogleCastRemoteControlConfig, ProgressiveSourceConfig, SourceConfigOptions, SourceLabelingStreamTypeConfig, SubtitleTrack, ThumbnailTrack, VRConfig } from 'bitmovin-player';
 export { Technology } from 'bitmovin-player';
 export interface Profile {
     profileName: string;
@@ -31,7 +31,7 @@ export interface StreamObject {
 }
 export interface PlayerContext {
     player: NpoPlayerAPI;
-    npoplayer: NpoPlayer;
+    npoPlayer: NpoPlayer;
 }
 export interface ApiPayload {
     baseURL: string;
@@ -95,6 +95,26 @@ interface FragmentSection {
 export interface Fragment {
     sections: FragmentSection[];
 }
+export interface SourceConfig {
+    dash?: string;
+    hls?: string;
+    progressive?: string | ProgressiveSourceConfig[];
+    smooth?: string;
+    whep?: string;
+    poster?: string;
+    drm?: DRMConfig;
+    options?: SourceConfigOptions;
+    subtitleTracks?: SubtitleTrack[];
+    thumbnailTrack?: ThumbnailTrack;
+    vr?: VRConfig;
+    title?: string;
+    description?: string;
+    labeling?: SourceLabelingStreamTypeConfig;
+    analytics?: AnalyticsConfig;
+    metadata?: {
+        [key: string]: string;
+    };
+}
 export interface StreamOptions {
     sourceConfig?: SourceConfig;
     fragments?: Fragment;
@@ -197,6 +217,8 @@ export type TimeLineMarker = {
 export declare enum LocalStorageValues {
     IS_MUTED = "ismuted",
     VOLUME = "volume",
-    SUBTITLES_ENABLED = "subtitles_enabled"
+    SUBTITLES_ENABLED = "subtitles_enabled",
+    SUBTITLES_LANGUAGE = "subtitles_language"
 }
 export type LocalStorageData = Partial<Record<LocalStorageValues, string | number>>;
+export type NPOGoogleCastRemoteControlConfig = GoogleCastRemoteControlConfig;

package/lib/src/ui/components/adbutton.d.ts

@@ -1,6 +1,6 @@
 import { Button } from 'bitmovin-player-ui';
 import type NpoPlayer from '../../npoplayer';
-export declare function createAdButton(npoplayer: NpoPlayer): Button<{
+export declare function createAdButton(npoPlayer: NpoPlayer): Button<{
     cssClass: string;
     text: string;
     hidden: true;

package/lib/src/ui/components/adlabel.d.ts

@@ -1,6 +1,6 @@
 import { Label } from 'bitmovin-player-ui';
 import type NpoPlayer from '../../npoplayer';
-export declare function createAdLabel(npoplayer: NpoPlayer): Label<{
+export declare function createAdLabel(npoPlayer: NpoPlayer): Label<{
     text: string;
     cssClass: string;
     hidden: true;