@npo/player 1.27.8 → 1.28.1

package/lib/services/trackingHandlers/eventBinding.js

@@ -1,22 +1,20 @@
-import { PlayerEvent, ViewMode } from 'bitmovin-player';
+import { PlayerEvent, ViewMode } from 'bitmovin-player/modules/bitmovinplayer-core';
 import { logEvent } from './eventLogging';
 const logEventHandlers = new Map();
 export function bindPlayerEvents(playerContext) {
-    const { npoPlayer } = playerContext;
-    const { player, streamObject } = npoPlayer;
+    const { player, streamObject, adBreakActive } = playerContext.npoPlayer;
+    const { isLiveStream } = streamObject.stream;
     if (player == undefined)
         return;
-    const isLiveStream = streamObject.stream.isLiveStream;
     let isNewSource = true;
     let data = {};
     const timeDifference = (time) => {
         if (time === undefined || time === null)
             return;
         const currentUnixTime = Date.now() / 1000;
-        const timeOffset = (time - currentUnixTime).toFixed(3);
-        const threeDecimalTime = time.toFixed(3);
-        const currentTime = isLiveStream ? +timeOffset : +threeDecimalTime;
-        data = { stream_position: currentTime };
+        const timeOffset = time > 0 ? time - currentUnixTime : time;
+        const currentTime = isLiveStream ? timeOffset : time;
+        data = { stream_position: +currentTime.toFixed(3) };
     };
     const logEventHandler = (event) => {
         return (e) => {
@@ -24,21 +22,21 @@ export function bindPlayerEvents(playerContext) {
             logEvent({ playerContext, event, data });
         };
     };
+    const timeShiftHandler = (e) => {
+        const from = data.stream_position ?? 0;
+        const currentTime = playerContext.player.getCurrentTime();
+        const to = e.target - currentTime + from;
+        data = {
+            seek_from: +from.toFixed(3),
+            stream_position: +to.toFixed(3)
+        };
+        logEvent({ playerContext, event: 'seek', data });
+    };
     const seekHandler = (e) => {
-        if (e.type === 'timeshift') {
-            const timeDifferencePosition = -1 * (Date.now() / 1000 - e.position);
-            const timeDifferenceTarget = -1 * (Date.now() / 1000 - e.target);
-            data = {
-                seek_from: Number.parseFloat(timeDifferencePosition.toFixed(3)),
-                stream_position: Number.parseFloat(timeDifferenceTarget.toFixed(3))
-            };
-        }
-        else if (e.type === 'seek') {
-            data = {
-                seek_from: e.position,
-                stream_position: e.seekTarget
-            };
-        }
+        data = {
+            seek_from: e.position,
+            stream_position: e.seekTarget
+        };
         logEvent({ playerContext, event: 'seek', data });
     };
     const handleSourceLoaded = (e) => {
@@ -48,6 +46,19 @@ export function bindPlayerEvents(playerContext) {
             logEvent({ playerContext, event: 'stop', data });
         }
     };
+    const handlePlaybackFinished = (e) => {
+        timeDifference(e.time);
+        logEvent({ playerContext, event: 'complete', data });
+        logEvent({ playerContext, event: 'stop', data });
+        isNewSource = true;
+    };
+    const readyHandler = (e) => {
+        timeDifference(e.time);
+        if (isLiveStream) {
+            data = { stream_position: 0 };
+        }
+        logEvent({ playerContext, event: 'load_complete', data });
+    };
     const handlePlay = (e) => {
         timeDifference(e.time);
         if (!isNewSource && e.issuer !== 'ui-seek') {
@@ -62,7 +73,7 @@ export function bindPlayerEvents(playerContext) {
     };
     const handleTime = (e) => {
         timeDifference(e.time);
-        if (isNewSource && !npoPlayer.adBreakActive) {
+        if (isNewSource && !adBreakActive) {
             logEvent({ playerContext, event: 'start', data });
             isNewSource = false;
         }
@@ -84,27 +95,31 @@ export function bindPlayerEvents(playerContext) {
         timeDifference(e.time);
         logEvent({ playerContext, event: 'stop', data });
     };
-    for (const [key, value] of logEventHandlers) {
-        player.off(key, value);
-    }
-    window.removeEventListener('beforeunload', logEventHandlers.get('stopBeforeUnload'));
-    logEventHandlers.clear();
+    const clearAllEvents = () => {
+        for (const [key, value] of logEventHandlers) {
+            player.off(key, value);
+        }
+        window.removeEventListener('beforeunload', logEventHandlers.get('stopBeforeUnload'));
+        logEventHandlers.clear();
+    };
+    clearAllEvents();
     const playerEvents = [
-        { event: PlayerEvent.Ready, name: 'load_complete' },
+        { event: PlayerEvent.Ready, handler: readyHandler },
         { event: PlayerEvent.Paused, handler: pausedHandler },
         { event: PlayerEvent.Play, handler: handlePlay },
         { event: PlayerEvent.SourceLoaded, handler: handleSourceLoaded },
         { event: PlayerEvent.StallStarted, name: 'buffering' },
         { event: PlayerEvent.StallEnded, name: 'buffering_complete' },
-        { event: PlayerEvent.PlaybackFinished, name: 'complete' },
+        { event: PlayerEvent.PlaybackFinished, handler: handlePlaybackFinished },
         { event: PlayerEvent.SourceUnloaded, name: 'stop' },
         { event: PlayerEvent.Seek, handler: seekHandler },
-        { event: PlayerEvent.TimeShift, handler: seekHandler },
+        { event: PlayerEvent.TimeShift, handler: timeShiftHandler },
         { event: PlayerEvent.TimeChanged, handler: handleTime },
-        { event: PlayerEvent.ViewModeChanged, handler: handleViewModeChange }
+        { event: PlayerEvent.ViewModeChanged, handler: handleViewModeChange },
+        { event: PlayerEvent.Destroy, handler: clearAllEvents }
     ];
     for (const { event, name, handler } of playerEvents) {
-        const effectiveName = name || 'unnamed_event';
+        const effectiveName = name ?? 'unnamed_event';
         const eventHandler = handler || logEventHandler(effectiveName);
         logEventHandlers.set(event, eventHandler);
         player.on(event, eventHandler);

package/lib/services/trackingHandlers/eventBinding.test.js

@@ -1,4 +1,4 @@
-import { PlayerEvent, ViewMode } from 'bitmovin-player';
+import { PlayerEvent, ViewMode } from 'bitmovin-player/modules/bitmovinplayer-core';
 import { bindPlayerEvents } from './eventBinding';
 import { logEvent } from './eventLogging';
 import { createPlayerContextMock } from '../../../tests/mocks/playerContextMock';
@@ -86,4 +86,60 @@ describe('bindPlayerEvents', () => {
             });
         }
     });
+    it('should handle playback finished correctly', () => {
+        bindPlayerEvents(playerContextMock);
+        const playbackFinishedHandler = mockPlayer.on.mock.calls.find(([event]) => event === PlayerEvent.PlaybackFinished)?.[1];
+        if (playbackFinishedHandler && typeof playbackFinishedHandler === 'function') {
+            playbackFinishedHandler({ time: 789 });
+            expect(logEvent).toHaveBeenCalledWith({
+                playerContext: playerContextMock,
+                event: 'complete',
+                data: expect.objectContaining({ stream_position: expect.any(Number) })
+            });
+            expect(logEvent).toHaveBeenCalledWith({
+                playerContext: playerContextMock,
+                event: 'stop',
+                data: expect.objectContaining({ stream_position: expect.any(Number) })
+            });
+        }
+    });
+    it('should handle TimeShift events correctly', () => {
+        mockPlayer.getCurrentTime = jest.fn().mockReturnValue(1000);
+        bindPlayerEvents(playerContextMock);
+        const timeShiftHandler = mockPlayer.on.mock.calls.find(([event]) => event === PlayerEvent.TimeShift)?.[1];
+        if (timeShiftHandler && typeof timeShiftHandler === 'function') {
+            timeShiftHandler({
+                target: -10
+            });
+            expect(logEvent).toHaveBeenCalledWith({
+                playerContext: playerContextMock,
+                event: 'seek',
+                data: {
+                    seek_from: 0,
+                    stream_position: -10
+                }
+            });
+        }
+    });
+    it('should clean up event listeners on destroy', () => {
+        bindPlayerEvents(playerContextMock);
+        const destroyHandler = mockPlayer.on.mock.calls.find(([event]) => event === PlayerEvent.Destroy)?.[1];
+        if (destroyHandler && typeof destroyHandler === 'function') {
+            destroyHandler({});
+            expect(mockPlayer.off).toHaveBeenCalled();
+            expect(mockPlayer.off).toHaveBeenCalledWith(PlayerEvent.Ready, expect.any(Function));
+            expect(mockPlayer.off).toHaveBeenCalledWith(PlayerEvent.Paused, expect.any(Function));
+            expect(mockPlayer.off).toHaveBeenCalledWith(PlayerEvent.Play, expect.any(Function));
+            expect(mockPlayer.off).toHaveBeenCalledWith(PlayerEvent.SourceLoaded, expect.any(Function));
+            expect(mockPlayer.off).toHaveBeenCalledWith(PlayerEvent.StallStarted, expect.any(Function));
+            expect(mockPlayer.off).toHaveBeenCalledWith(PlayerEvent.StallEnded, expect.any(Function));
+            expect(mockPlayer.off).toHaveBeenCalledWith(PlayerEvent.PlaybackFinished, expect.any(Function));
+            expect(mockPlayer.off).toHaveBeenCalledWith(PlayerEvent.SourceUnloaded, expect.any(Function));
+            expect(mockPlayer.off).toHaveBeenCalledWith(PlayerEvent.Seek, expect.any(Function));
+            expect(mockPlayer.off).toHaveBeenCalledWith(PlayerEvent.TimeShift, expect.any(Function));
+            expect(mockPlayer.off).toHaveBeenCalledWith(PlayerEvent.TimeChanged, expect.any(Function));
+            expect(mockPlayer.off).toHaveBeenCalledWith(PlayerEvent.ViewModeChanged, expect.any(Function));
+            expect(mockPlayer.off).toHaveBeenCalledWith(PlayerEvent.Destroy, expect.any(Function));
+        }
+    });
 });

package/lib/services/trackingHandlers/playerTrackerStart.js

@@ -6,7 +6,7 @@ import { logEvent } from './eventLogging';
 export const startPlayerTracker = function ({ playerContext, source, duration }) {
     const { npoPlayer } = playerContext;
     const { player, sourceConfig, streamObject } = npoPlayer;
-    const playerDuration = duration || player?.getDuration() || undefined;
+    const playerDuration = duration ?? player?.getDuration() ?? undefined;
     if (!source) {
         throw new Error('Could not initialize streamTracker, no source specified.');
     }

package/lib/services/uiHandlers/uiVisiblityHandler.js

@@ -6,9 +6,15 @@ export function addUivisiblityHandlers(playerContext) {
     if (variant === NpoPlayerUIVariants.DEFAULT) {
         uiManager.activeUi.onControlsHide.subscribe(() => {
             playerContext.npoPlayer.logEmitter.emit('logControlsVisibilityChange', false);
+            if (playerContext.npoPlayer.chapterHandler) {
+                playerContext.npoPlayer.chapterHandler.setControlsVisibility(false);
+            }
         });
         uiManager.activeUi.onControlsShow.subscribe(() => {
             playerContext.npoPlayer.logEmitter.emit('logControlsVisibilityChange', true);
+            if (playerContext.npoPlayer.chapterHandler) {
+                playerContext.npoPlayer.chapterHandler.setControlsVisibility(true);
+            }
         });
         uiManager.activeUi.getUI().showUi();
     }

package/lib/services/verticalVideoHandlers/handleVerticalVideoSettings.test.js

@@ -1,15 +1,6 @@
 import { handleVerticalVideoSettings } from './handleVerticalVideoSettings';
 import { NpoPlayerEvent } from '../../types/events';
 import { createMockNpoPlayer, createPlayerContextMock } from '../../../tests/mocks/playerContextMock';
-jest.mock('bitmovin-player', () => ({
-    PlayerEvent: {
-        Ready: 'ready',
-        SourceLoaded: 'sourceLoaded',
-        SourceUnloaded: 'sourceUnloaded',
-        SubtitleDisable: 'subtitleDisable',
-        SubtitleEnable: 'subtitleEnable'
-    }
-}));
 describe('handleVerticalVideoSettings', () => {
     let playerContextMock;
     let mockAddEventListener;

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

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

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

@@ -1,2 +1,7 @@
-import { PlayerAPI, SourceConfig } from 'bitmovin-player';
-export declare function setupMediaSessionActionHandlers(player: PlayerAPI, sourceConfig: SourceConfig, _streamObject: any): void;
+import { PlayerAPI, SourceConfig } from 'bitmovin-player/modules/bitmovinplayer-core';
+import { StreamObject } from 'types/interfaces';
+export declare function setupMediaSessionActionHandlers({ player, sourceConfig, streamObject }: {
+    player: PlayerAPI;
+    sourceConfig: SourceConfig;
+    streamObject: StreamObject;
+}): void;

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

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

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

@@ -1,6 +1,15 @@
 import { StreamObject, StreamOptions } from 'types/interfaces';
-import { SourceConfig } from 'bitmovin-player';
+import { SourceConfig } from 'bitmovin-player/modules/bitmovinplayer-core';
 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>;
+export declare function processSourceConfig({ npoPlayerServices, source, _sourceConfig, _streamObject, drm, streamOptions, version, npoTagInstance }: {
+    npoPlayerServices: NpoPlayerServices;
+    source: string;
+    _sourceConfig: SourceConfig;
+    _streamObject: StreamObject;
+    drm: string | undefined;
+    streamOptions: StreamOptions;
+    version: string;
+    npoTagInstance: NPOTag | undefined;
+}): Promise<SourceConfig>;

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

@@ -1,2 +1,2 @@
-import { PlayerAPI } from 'bitmovin-player';
+import { PlayerAPI } from 'bitmovin-player/modules/bitmovinplayer-core';
 export declare function removeReplayClass(player: PlayerAPI | undefined): void;

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

@@ -68,6 +68,7 @@ export declare const localizationConfig: {
             connectingTo: string;
             watermarkLink: string;
             controlBar: string;
+            "controlBar.bottom": string;
             player: string;
             videoPlayer: string;
             audioPlayer: string;

package/lib/src/js/utilities/utilities.jwt.d.ts

@@ -1,3 +1,5 @@
 export declare const convertBase64ToObject: (value: string) => Record<string, any>;
 export declare const convertJwtToBase64: (jwt: string) => string;
 export declare function isJWTToken(token: string): boolean;
+export declare function getJwtIat(jwt: string): number;
+export declare function isJwtFresh(jwt: string, maxAgeSeconds?: number): boolean;

package/lib/src/npoplayer.d.ts

@@ -1,10 +1,11 @@
 import { NpoPlayerServices } from './services/services';
 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 { type PlayerAPI, type PlayerConfig, type SourceConfig } from 'bitmovin-player/modules/bitmovinplayer-core';
 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 PlayerContext, type EventListeners, NpoPlayerUIVariants } from './types/interfaces';
+import { ChapterHandler } from './services/chapterHandlers/chapterHandler';
 export { type PlayerConfig, type InitialisationProps, type NPOTagObject, type StreamOptions, NpoPlayerUIVariants };
 export default class NpoPlayer {
     playerConfig: PlayerConfig | undefined;
@@ -32,14 +33,14 @@ export default class NpoPlayer {
     playerContext: PlayerContext | undefined;
     npoPlayerServices: NpoPlayerServices;
     eventListeners: EventListeners | undefined;
-    mockNpoPlayer: any;
+    chapterHandler: ChapterHandler | undefined;
     constructor(container: HTMLElement | {
         container: HTMLElement;
         playerConfig: PlayerConfig;
-        npoTag?: InitialisationProps | undefined;
-        npoTagInstance?: NPOTag | undefined;
+        npoTag?: InitialisationProps;
+        npoTagInstance?: NPOTag;
         variant?: NpoPlayerUIVariants;
-        npoTagPageTracker?: PageTracker | undefined;
+        npoTagPageTracker?: PageTracker;
     }, playerConfig?: PlayerConfig | undefined, npoTag?: InitialisationProps | undefined, npoTagInstance?: NPOTag | undefined, variant?: NpoPlayerUIVariants, npoTagPageTracker?: PageTracker | undefined);
     keydownHandler: (e: KeyboardEvent) => void;
     initPlayer(_container: HTMLElement, playerConfig: PlayerConfig): void;

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

@@ -0,0 +1,35 @@
+import { Chapter, PlayerContext } from '../../types/interfaces';
+export declare const defaultSkippableChapterTypes: string[];
+export interface ChapterHandlerOptions {
+    chapters: Chapter[];
+    showSkipButtons?: boolean;
+    skippableTypes?: string[];
+}
+export declare class ChapterHandler {
+    private readonly playerContext;
+    private readonly defaultSkippableTypes;
+    private readonly options;
+    private lastShownFrom?;
+    private hideTimeout?;
+    private controlsVisible;
+    private currentChapter?;
+    private isForceShowing;
+    private isPaused;
+    private pausedTimeRemaining?;
+    constructor(playerContext: PlayerContext, options: ChapterHandlerOptions);
+    getCurrentChapter(currentTimeMs: number): Chapter | undefined;
+    isChapterSkippable(chapter: Chapter): boolean;
+    handleTimeChange(): void;
+    reset(): void;
+    handlePause(): void;
+    handlePlay(): void;
+    setControlsVisibility(visible: boolean): void;
+    private setupSkipButtonHandler;
+    private skipCurrentChapter;
+    private updateSkipButtonVisibility;
+    private startFadeOut;
+    private forceShowButton;
+    private getCurrentControlsVisibility;
+    private startHideTimeout;
+    private clearHideTimeout;
+}

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

@@ -1,3 +1,5 @@
-import { PlayerContext } from '../../types/interfaces';
-export declare function handlePlayerError(playerContext: PlayerContext, status: number): Promise<void>;
+import { LogErrorParams, PlayerContext } from '../../types/interfaces';
+export declare function handlePlayerError({ playerContext, status, context }: LogErrorParams): Promise<void>;
+export declare function generateErrorMessage(status: number, shouldRetry: boolean): string;
+export declare function setupRetryHandler(playerContext: PlayerContext, errorContainerClass: string): void;
 export declare function setErrorBackground(playerContext: PlayerContext): void;

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

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

package/lib/src/services/errors/errorRetryHandler.test.d.ts

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

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

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

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

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

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

@@ -1,4 +1,5 @@
 import { PlayerContext } from '../../types/interfaces';
+export declare const SHOW_NICAM_AFTER_UI_HIDE_DURATION = 5000;
 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;

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

@@ -1,4 +1,6 @@
-import { AdBreak, AdConfig, PlayerAPI, PlayerConfig, SourceConfig, TimeMode, ViewMode } from 'bitmovin-player';
+import { PlayerAPI, PlayerConfig, SourceConfig, TimeMode, VideoQuality, ViewMode } from 'bitmovin-player/modules/bitmovinplayer-core';
+import { AdBreak, AdConfig } from 'bitmovin-player/modules/bitmovinplayer-advertising-core';
+import { SubtitleTrack } from 'bitmovin-player/modules/bitmovinplayer-subtitles';
 import { UIManager } from 'bitmovin-player-ui';
 import { NpoPlayerUIVariants, PlayerContext, Technology } from 'types/interfaces';
 import { NpoPlayerEventCallback, NpoPlayerEvent } from '../../types/events';
@@ -40,8 +42,12 @@ export declare class NpoPlayerAPI {
     getDuration(): number;
     getTimeShift(): number;
     scheduleAds(adConfig: AdConfig): Promise<AdBreak[]>;
-    handleErrorRetry(playerContext: PlayerContext): void;
+    handleErrorRetry(playerContext: PlayerContext): Promise<void>;
     getActiveAdBreak(): AdBreak | null;
     getConfig(mergedConfig?: boolean): PlayerConfig;
     createUIManager(playerContext: PlayerContext, variant: NpoPlayerUIVariants): void | UIManager;
+    getAvailableVideoQualities(): VideoQuality[];
+    listSubtitles(): SubtitleTrack[];
+    setPlaybackSpeed(speed: number): void;
+    setVideoQuality(VideoQualityId: string): void;
 }

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

@@ -0,0 +1 @@
+export declare const playerModules: any[];

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

@@ -0,0 +1,2 @@
+import { Segment } from 'types/interfaces';
+export declare function isSegmentInBounds(segment: Segment | undefined, duration: number): boolean;

package/lib/src/services/segmentHandlers/isSegmentInBounds.test.d.ts

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

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

@@ -1,4 +1,4 @@
-import { ApiPayload, Fragment, PlayerContext, Profile, Segment, TimeLineMarker, LocalStorageData, LocalStorageValues, StreamObject, PlayerTrackerParams, LogEventParams } from '../types/interfaces';
+import { ApiPayload, Fragment, PlayerContext, Profile, Segment, TimeLineMarker, LocalStorageData, LocalStorageValues, StreamObject, PlayerTrackerParams, LogEventParams, LogErrorParams } from '../types/interfaces';
 import { AVType } from '@npotag/tag/dist/types/src/streamTracker';
 export declare class NpoPlayerServices {
     getAVType(avType: string): AVType;
@@ -21,10 +21,13 @@ export declare class NpoPlayerServices {
     addUivisiblityHandlers(playerContext: PlayerContext): void;
     removeUivisiblityHandlers(playerContext: PlayerContext): void;
     handleStreamOptions(playerContext: PlayerContext): void;
-    handleError(playerContext: PlayerContext, input: number): Promise<void>;
+    handleError({ playerContext, status: input, context: context }: LogErrorParams): Promise<void>;
     fetchStream(playerContext: PlayerContext, payload: ApiPayload): Promise<StreamObject>;
     startPlayerTracker({ playerContext, source, duration }: PlayerTrackerParams): void;
     initPlayerTracker(playerContext: PlayerContext): void;
     logEvent({ playerContext, event, data }: LogEventParams): void;
     removeEventListeners(playerContext: PlayerContext): void;
+    isSegmentInBounds(playerContext: PlayerContext): boolean;
+    addDataInInfoPanel(playerContext: PlayerContext): void;
+    clearInfoPanel(playerContext: PlayerContext): void;
 }

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

@@ -1,4 +1,4 @@
-import { PlayerEvent } from 'bitmovin-player';
+import { PlayerEvent } from 'bitmovin-player/modules/bitmovinplayer-core';
 type PlayerEventMap = {
     [key in NpoPlayerEvent]: PlayerEvent;
 };

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

@@ -1,11 +1,15 @@
-import { type ErrorMessageOverlay, type Label, ControlBar, SettingsPanelItem, Button, SeekBar, CastToggleButton, SettingsPanel, SettingsToggleButton } from 'bitmovin-player-ui';
+import { type ErrorMessageOverlay, type Label, ControlBar, SettingsPanelItem, Button, SeekBar, CastToggleButton, SettingsPanel, SettingsToggleButton, Container, ContainerConfig, ToggleButton, ToggleButtonConfig } from 'bitmovin-player-ui';
 import { type NPOTag, type PageTracker } from '@npotag/tag';
 import { ButtonConfig } from 'bitmovin-player-ui/dist/js/framework/components/button';
 import NpoPlayer from '../npoplayer';
 import { NpoPlayerAPI } from '../services/npoPlayerAPI/npoPlayerAPI';
 import { NpoPlayerEventCallback } from './events';
-import { AnalyticsConfig, DRMConfig, GoogleCastRemoteControlConfig, ProgressiveSourceConfig, SourceConfigOptions, SourceLabelingStreamTypeConfig, SubtitleTrack, ThumbnailTrack, VRConfig } from 'bitmovin-player';
-export { Technology } from 'bitmovin-player';
+import { ProgressiveSourceConfig, SourceConfigOptions, SourceLabelingStreamTypeConfig, ThumbnailTrack } from 'bitmovin-player/modules/bitmovinplayer-core';
+import type { AnalyticsConfig } from 'bitmovin-player/types/analytics/ConfigAPI';
+import type { GoogleCastRemoteControlConfig } from 'bitmovin-player/types/remotecontrol/ConfigAPI';
+import DRMConfig from 'bitmovin-player/modules/bitmovinplayer-drm';
+import { SubtitleTrack } from 'bitmovin-player/modules/bitmovinplayer-subtitles';
+export { Technology } from 'bitmovin-player/modules/bitmovinplayer-core';
 export interface Profile {
     profileName: string;
     drm: string | undefined;
@@ -82,6 +86,7 @@ interface StreamObject_Assets {
     preroll?: string;
 }
 export interface StreamObject_Metadata {
+    chapters?: Chapter[];
     broadcaster?: string;
     description: string;
     duration?: string;
@@ -108,11 +113,10 @@ export interface SourceConfig {
     smooth?: string;
     whep?: string;
     poster?: string;
-    drm?: DRMConfig;
+    drm?: typeof DRMConfig;
     options?: SourceConfigOptions;
     subtitleTracks?: SubtitleTrack[];
     thumbnailTrack?: ThumbnailTrack;
-    vr?: VRConfig;
     title?: string;
     description?: string;
     labeling?: SourceLabelingStreamTypeConfig;
@@ -138,8 +142,10 @@ export interface StreamOptions {
     customFallbackPoster?: string;
     autoFillTimeLineMarkerDuration?: boolean;
     autoplay?: boolean;
+    skippableChapters?: string[];
     npoTagPageTracker?: PageTracker;
     retryCallback?: () => void;
+    infoPanelHTML?: string;
 }
 export interface UIComponents {
     errorMessageOverlay?: ErrorMessageOverlay;
@@ -150,6 +156,7 @@ export interface UIComponents {
     subtitlesButton?: SettingsPanelItem | undefined;
     qualityButton?: SettingsPanelItem | undefined;
     watchFromStartButton?: Button<ButtonConfig> | undefined;
+    skipChapterButton?: Button<ButtonConfig> | undefined;
     controlBar?: ControlBar | undefined;
     adbutton?: Button<ButtonConfig> | undefined;
     adlabel?: Label<{
@@ -161,44 +168,8 @@ export interface UIComponents {
     settingsPanels?: SettingsPanel[] | undefined;
     settingsPanel?: SettingsPanel | undefined;
     settingsToggleButton?: SettingsToggleButton | undefined;
-}
-export interface CustomMessageHandlerInterface {
-    defaultActionRequired?: boolean;
-    isChecked?: boolean;
-    playNext?: {
-        remainingCountDownDuration: number;
-    };
-    error?: ErrorEvent;
-    errorMessage?: {
-        input: string;
-        status: number;
-    };
-}
-export declare enum CustomMessages {
-    CLICK_CAST = "castButtonClick",
-    CLICK_GO_BACK_TO_LIVE = "clickGoBackToLive",
-    CLICK_WATCH_FROM_START = "clickWatchFromStart",
-    DO_ERROR = "doError",
-    ERROR_TRIGGERED = "errorTriggerd",
-    JAVASCRIPT_READY = "javascriptReady",
-    PLAY_NEXT_CANCEL_CLICK = "playNextCancelClick",
-    PLAY_NEXT_COUNTDOWN_CANCELED = "playNextCountdownCanceled",
-    PLAY_NEXT_COUNTDOWN_FINISHED = "playNextCountdownFinished",
-    PLAY_NEXT_COUNTDOWN_PROGRESS = "playNextCountdownProgress",
-    PLAY_NEXT_OVERLAY_HIDDEN = "playNextOverlayHidden",
-    PLAY_NEXT_OVERLAY_HIDE = "playNextOverlayHide",
-    PLAY_NEXT_OVERLAY_SHOW = "playNextOverlayShow",
-    PLAY_NEXT_OVERLAY_SHOWN = "playNextOverlayShown",
-    PLAY_NEXT_PROCEED_CLICK = "playNextProceedClick",
-    SET_STREAM_LINK = "setStreamLink",
-    SET_WEB_DATA = "setWebData",
-    TOGGLE_AIRPLAY = "toggleAirplay",
-    TOGGLE_FULLSCREEN = "toggleFullScreen",
-    TOGGLE_FULLSCREEN_UI = "toggleFullscreenUI",
-    TOGGLE_MUTE = "toggleMute",
-    TOGGLE_PIP = "togglePiP",
-    TOGGLE_PLAY_PAUSE = "togglePlayPause",
-    TOGGLE_SETTINGS_PANEL = "toggleSettingsPanel"
+    infoPanel?: Container<ContainerConfig>;
+    infoPanelToggleButtons?: ToggleButton<ToggleButtonConfig>[];
 }
 export declare enum NpoPlayerUIVariants {
     DEFAULT = "default",
@@ -242,3 +213,28 @@ export interface LogEventParams {
     event: string;
     data?: any;
 }
+export interface LogErrorContext {
+    programAvailableFrom?: string;
+    programAvailableUntil?: string;
+}
+export interface LogErrorParams {
+    playerContext: PlayerContext;
+    status: number;
+    body?: string;
+    context?: LogErrorContext;
+}
+export interface CreateButtonConfig {
+    text: string;
+    onClick: () => void;
+    ariaLabel?: string;
+    cssClass?: string;
+    hidden?: boolean;
+    acceptsTouchWithUiHidden?: boolean;
+}
+export interface Chapter {
+    description: string;
+    from: number;
+    until: number;
+    title: string;
+    type: string;
+}

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

@@ -1,7 +1,4 @@
 import { Button } from 'bitmovin-player-ui';
-import type NpoPlayer from '../../npoplayer';
-export declare function createAdButton(npoPlayer: NpoPlayer): Button<{
-    cssClass: string;
-    text: string;
-    hidden: true;
-}>;
+import { ButtonConfig } from 'bitmovin-player-ui/dist/js/framework/components/button';
+import { PlayerContext } from '../../types/interfaces';
+export declare function createAdButton(playerContext: PlayerContext): Button<ButtonConfig>;

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

@@ -1,7 +1,4 @@
 import { Label } from 'bitmovin-player-ui';
-import type NpoPlayer from '../../npoplayer';
-export declare function createAdLabel(npoPlayer: NpoPlayer): Label<{
-    text: string;
-    cssClass: string;
-    hidden: true;
-}>;
+import { LabelConfig } from 'bitmovin-player-ui/dist/js/framework/components/label';
+import { PlayerContext } from '../../types/interfaces';
+export declare function createAdLabel(playerContext: PlayerContext): Label<LabelConfig>;