@npo/player 1.26.0 → 1.27.1

package/lib/services/services.js

@@ -7,11 +7,15 @@ import { getLocalStorage, setLocalStorage, setValuesBasedOnLocalStorage } from '
 import { getAVType } from './avTypeHandlers/getAVType';
 import { handlePreRolls } from './advertHandlers/handlePreRolls';
 import { handleVerticalVideoControls } from './verticalVideoHandlers/handleVerticalVideoControls';
+import { handleVerticalVideoSettings } from './verticalVideoHandlers/handleVerticalVideoSettings';
 import { setupNicamKijkwijzerIcons, showNicamAfterUiDelay } from './nicamHandlers/nicamhandler';
 import { handlePreferences } from './preferences/handlePreferences';
 import { addUivisiblityHandlers, removeUivisiblityHandlers } from './uiHandlers/uiVisiblityHandler';
 import { discardAdBreak } from './advertHandlers/discardAdBreak';
 import { handleStreamOptions } from './streamoptionsHandlers/streamOptionsHandler';
+import { handlePlayerError } from './errors/errorHandler';
+import { fetchStream } from './streamFetchHandler/fetchStream';
+import { startPlayerTracker, initPlayerTracker, logEvent } from './trackingHandlers';
 export class NpoPlayerServices {
     getAVType(avType) {
         return getAVType(avType);
@@ -57,8 +61,11 @@ export class NpoPlayerServices {
     discardAdBreak(playerContext) {
         discardAdBreak(playerContext);
     }
-    handleVerticalVideoControls(playerContext, variant) {
-        return handleVerticalVideoControls(playerContext, variant);
+    handleVerticalVideoControls(playerContext) {
+        return handleVerticalVideoControls(playerContext);
+    }
+    handleVerticalVideoSettings(playerContext) {
+        return handleVerticalVideoSettings(playerContext);
     }
     showNicamAfterUiDelay(playerContext) {
         return showNicamAfterUiDelay(playerContext);
@@ -78,4 +85,23 @@ export class NpoPlayerServices {
     handleStreamOptions(playerContext) {
         handleStreamOptions(playerContext);
     }
+    async handleError(playerContext, input) {
+        await handlePlayerError(playerContext, input);
+    }
+    async fetchStream(playerContext, payload) {
+        return await fetchStream(playerContext, payload);
+    }
+    startPlayerTracker({ playerContext, source, duration }) {
+        startPlayerTracker({
+            playerContext,
+            source,
+            duration
+        });
+    }
+    initPlayerTracker(playerContext) {
+        initPlayerTracker(playerContext);
+    }
+    logEvent({ playerContext, event, data }) {
+        logEvent({ playerContext, event, data });
+    }
 }

package/lib/services/streamFetchHandler/fetchStream.d.ts

@@ -0,0 +1,2 @@
+import { type ApiPayload, PlayerContext, StreamObject } from '../../types/interfaces';
+export declare function fetchStream(playerContext: PlayerContext, payload: ApiPayload): Promise<StreamObject>;

package/lib/services/streamFetchHandler/fetchStream.js

@@ -0,0 +1,48 @@
+import { removeTrailingSlash } from '../../js/utilities/utilities.url';
+export async function fetchStream(playerContext, payload) {
+    const { npoPlayer } = playerContext;
+    const genericError = 'Dit item on niet worden geladen.';
+    let hasHandledError = false;
+    const handleStreamError = async (status, message) => {
+        if (!hasHandledError) {
+            hasHandledError = true;
+            await npoPlayer.npoPlayerServices.handleError(playerContext, status);
+        }
+        throw new Error(message);
+    };
+    try {
+        const controller = new AbortController();
+        const { signal } = controller;
+        const timeout = setTimeout(() => {
+            controller.abort();
+        }, 5000);
+        const response = await fetch(removeTrailingSlash(payload.baseURL) + '/stream-link', {
+            method: 'post',
+            headers: {
+                'Accept': '*/*',
+                'Authorization': payload.jwt,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(payload.data),
+            signal
+        });
+        clearTimeout(timeout);
+        const streamApiResponse = await response.json();
+        if (response.ok && streamApiResponse && typeof streamApiResponse === 'object') {
+            return streamApiResponse;
+        }
+        else {
+            const status = streamApiResponse?.status || 500;
+            return await handleStreamError(status, genericError);
+        }
+    }
+    catch (error) {
+        if (!hasHandledError) {
+            const errorMessage = error instanceof Error && error.message === 'AbortError'
+                ? 'aborterror'
+                : 'Dit item on niet worden geladen. Het ophalen van de stream duurde te lang.';
+            return await handleStreamError(500, errorMessage);
+        }
+        throw error;
+    }
+}

package/lib/services/streamFetchHandler/fetchstream.test.js

@@ -0,0 +1,70 @@
+import { fetchStream } from './fetchStream';
+import { createMockNpoPlayer, createPlayerContextMock } from '../../../tests/mocks/playerContextMock';
+describe('fetchStream', () => {
+    let mockPlayerContext;
+    let mockNpoPlayer;
+    const mockPayload = {
+        baseURL: 'https://api.example.com',
+        jwt: 'mock-jwt-token',
+        data: { some: 'data' }
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockNpoPlayer = createMockNpoPlayer({
+            npoPlayerServices: {
+                handleError: jest.fn()
+            }
+        });
+        mockPlayerContext = createPlayerContextMock({
+            npoPlayer: mockNpoPlayer
+        });
+    });
+    it('returns a StreamObject when the fetch is successful', async () => {
+        const mockStreamObject = { streamUrl: 'https://stream.example.com' };
+        global.fetch = jest.fn().mockResolvedValue({
+            ok: true,
+            json: jest.fn().mockResolvedValue(mockStreamObject)
+        });
+        const result = await fetchStream(mockPlayerContext, mockPayload);
+        expect(result).toEqual(mockStreamObject);
+        expect(global.fetch).toHaveBeenCalledWith('https://api.example.com/stream-link', expect.objectContaining({
+            method: 'post',
+            headers: expect.objectContaining({
+                'Authorization': mockPayload.jwt,
+                'Content-Type': 'application/json'
+            }),
+            body: JSON.stringify(mockPayload.data)
+        }));
+        expect(mockNpoPlayer.npoPlayerServices.handleError).not.toHaveBeenCalled();
+    });
+    it('calls handleError with 402 status and throws an error', async () => {
+        global.fetch = jest.fn().mockResolvedValue({
+            ok: false,
+            json: jest.fn().mockResolvedValue({ status: 402 })
+        });
+        await expect(fetchStream(mockPlayerContext, mockPayload)).rejects.toThrow('Dit item on niet worden geladen.');
+        expect(mockNpoPlayer.npoPlayerServices.handleError).toHaveBeenCalledWith(mockPlayerContext, 402);
+    });
+    it('calls handleError with 500 for timeout (AbortError)', async () => {
+        global.fetch = jest.fn().mockImplementation(() => new Promise((_, reject) => reject(new Error('AbortError'))));
+        await expect(fetchStream(mockPlayerContext, mockPayload)).rejects.toThrow('aborterror');
+        expect(mockNpoPlayer.npoPlayerServices.handleError).toHaveBeenCalledWith(mockPlayerContext, 500);
+    });
+    it('calls handleError with 500 for unexpected errors', async () => {
+        global.fetch = jest.fn().mockRejectedValue(new Error('Unexpected error'));
+        await expect(fetchStream(mockPlayerContext, mockPayload)).rejects.toThrow('Dit item on niet worden geladen. Het ophalen van de stream duurde te lang.');
+        expect(mockNpoPlayer.npoPlayerServices.handleError).toHaveBeenCalledWith(mockPlayerContext, 500);
+    });
+    it('clears the timeout if fetch resolves before timeout', async () => {
+        jest.useFakeTimers();
+        const mockStreamObject = { streamUrl: 'https://stream.example.com' };
+        global.fetch = jest.fn().mockResolvedValue({
+            ok: true,
+            json: jest.fn().mockResolvedValue(mockStreamObject)
+        });
+        const result = await fetchStream(mockPlayerContext, mockPayload);
+        jest.runOnlyPendingTimers();
+        expect(result).toEqual(mockStreamObject);
+        jest.useRealTimers();
+    });
+});

package/lib/services/trackingHandlers/eventBinding.d.ts

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

package/lib/{js/tracking/handlers/eventbinding.js → services/trackingHandlers/eventBinding.js}

@@ -1,10 +1,12 @@
 import { PlayerEvent, ViewMode } from 'bitmovin-player';
-import { logEvent } from './eventlogging';
+import { logEvent } from './eventLogging';
 const logEventHandlers = new Map();
-export function bindPlayerEvents(npoPlayer, player) {
+export function bindPlayerEvents(playerContext) {
+    const { npoPlayer } = playerContext;
+    const { player, streamObject } = npoPlayer;
     if (player == undefined)
         return;
-    const isLiveStream = npoPlayer.streamObject.stream.isLiveStream;
+    const isLiveStream = streamObject.stream.isLiveStream;
     let isNewSource = true;
     let data = {};
     const timeDifference = (time) => {
@@ -16,10 +18,10 @@ export function bindPlayerEvents(npoPlayer, player) {
         const currentTime = isLiveStream ? +timeOffset : +threeDecimalTime;
         data = { stream_position: currentTime };
     };
-    const logEventHandler = (eventName) => {
+    const logEventHandler = (event) => {
         return (e) => {
             timeDifference(e.time);
-            logEvent(npoPlayer, eventName, data);
+            logEvent({ playerContext, event, data });
         };
     };
     const seekHandler = (e) => {
@@ -37,50 +39,50 @@ export function bindPlayerEvents(npoPlayer, player) {
                 stream_position: e.seekTarget
             };
         }
-        logEvent(npoPlayer, 'seek', data);
+        logEvent({ playerContext, event: 'seek', data });
     };
     const handleSourceLoaded = (e) => {
         timeDifference(e.time);
         isNewSource = true;
         if (isLiveStream) {
-            logEvent(npoPlayer, 'stop', data);
+            logEvent({ playerContext, event: 'stop', data });
         }
     };
     const handlePlay = (e) => {
         timeDifference(e.time);
         if (!isNewSource && e.issuer !== 'ui-seek') {
-            logEvent(npoPlayer, 'resume', data);
+            logEvent({ playerContext, event: 'resume', data });
         }
     };
     const pausedHandler = (e) => {
         timeDifference(e.time);
         if (e.issuer !== 'ui-seek') {
-            logEvent(npoPlayer, 'pause', data);
+            logEvent({ playerContext, event: 'pause', data });
         }
     };
     const handleTime = (e) => {
         timeDifference(e.time);
         if (isNewSource && !npoPlayer.adBreakActive) {
-            logEvent(npoPlayer, 'start', data);
+            logEvent({ playerContext, event: 'start', data });
             isNewSource = false;
         }
         else {
-            logEvent(npoPlayer, 'time', data);
+            logEvent({ playerContext, event: 'time', data });
         }
     };
     const handleViewModeChange = (e) => {
         const newViewMode = player.getViewMode();
         timeDifference(e.time);
         if (newViewMode === ViewMode.Fullscreen) {
-            logEvent(npoPlayer, 'fullscreen', data);
+            logEvent({ playerContext, event: 'fullscreen', data });
         }
         else {
-            logEvent(npoPlayer, 'windowed', data);
+            logEvent({ playerContext, event: 'windowed', data });
         }
     };
     const stopBeforeUnload = (e) => {
         timeDifference(e.time);
-        logEvent(npoPlayer, 'stop', data);
+        logEvent({ playerContext, event: 'stop', data });
     };
     for (const [key, value] of logEventHandlers) {
         player.off(key, value);

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

@@ -0,0 +1,89 @@
+import { PlayerEvent, ViewMode } from 'bitmovin-player';
+import { bindPlayerEvents } from './eventBinding';
+import { logEvent } from './eventLogging';
+import { createPlayerContextMock } from '../../../tests/mocks/playerContextMock';
+jest.mock('./eventLogging', () => ({
+    logEvent: jest.fn()
+}));
+describe('bindPlayerEvents', () => {
+    let mockPlayer;
+    let playerContextMock;
+    beforeEach(() => {
+        mockPlayer = {
+            on: jest.fn(),
+            off: jest.fn(),
+            getViewMode: jest.fn().mockReturnValue(ViewMode.Inline)
+        };
+        playerContextMock = createPlayerContextMock({
+            npoPlayer: {
+                player: mockPlayer,
+                streamObject: {
+                    stream: { isLiveStream: false }
+                },
+                adBreakActive: false,
+                logEmitter: { emit: jest.fn() }
+            }
+        });
+        jest.clearAllMocks();
+    });
+    it('should handle the "beforeunload" event correctly', () => {
+        const addEventListenerSpy = jest.spyOn(window, 'addEventListener');
+        bindPlayerEvents(playerContextMock);
+        expect(addEventListenerSpy).toHaveBeenCalledWith('beforeunload', expect.any(Function));
+        const beforeUnloadHandler = addEventListenerSpy.mock.calls.find(([event]) => event === 'beforeunload')?.[1];
+        if (beforeUnloadHandler && typeof beforeUnloadHandler === 'function') {
+            beforeUnloadHandler({ time: 123 });
+        }
+        addEventListenerSpy.mockRestore();
+    });
+    it('should log events when handlers are triggered', () => {
+        bindPlayerEvents(playerContextMock);
+        const timeChangedHandler = mockPlayer.on.mock.calls.find(([event]) => event === PlayerEvent.TimeChanged)?.[1];
+        if (timeChangedHandler && typeof timeChangedHandler === 'function') {
+            timeChangedHandler({ time: 456 });
+            expect(logEvent).toHaveBeenCalledWith({
+                playerContext: playerContextMock,
+                event: 'start',
+                data: expect.objectContaining({ stream_position: expect.any(Number) })
+            });
+        }
+    });
+    it('should handle seek events correctly', () => {
+        bindPlayerEvents(playerContextMock);
+        const seekHandler = mockPlayer.on.mock.calls.find(([event]) => event === PlayerEvent.Seek)?.[1];
+        if (seekHandler && typeof seekHandler === 'function') {
+            seekHandler({
+                type: 'seek',
+                position: 100,
+                seekTarget: 200
+            });
+            expect(logEvent).toHaveBeenCalledWith({
+                playerContext: playerContextMock,
+                event: 'seek',
+                data: {
+                    seek_from: 100,
+                    stream_position: 200
+                }
+            });
+        }
+    });
+    it('should handle ViewModeChanged events', () => {
+        mockPlayer.getViewMode = jest.fn().mockReturnValueOnce(ViewMode.Fullscreen).mockReturnValueOnce(ViewMode.Inline);
+        bindPlayerEvents(playerContextMock);
+        const viewModeChangedHandler = mockPlayer.on.mock.calls.find(([event]) => event === PlayerEvent.ViewModeChanged)?.[1];
+        if (viewModeChangedHandler && typeof viewModeChangedHandler === 'function') {
+            viewModeChangedHandler({ time: 300 });
+            expect(logEvent).toHaveBeenCalledWith({
+                playerContext: playerContextMock,
+                event: 'fullscreen',
+                data: expect.objectContaining({ stream_position: expect.any(Number) })
+            });
+            viewModeChangedHandler({ time: 301 });
+            expect(logEvent).toHaveBeenCalledWith({
+                playerContext: playerContextMock,
+                event: 'windowed',
+                data: expect.objectContaining({ stream_position: expect.any(Number) })
+            });
+        }
+    });
+});

package/lib/services/trackingHandlers/eventLogging.d.ts

@@ -0,0 +1,2 @@
+import { LogEventParams } from 'types/interfaces';
+export declare function logEvent({ playerContext, event, data }: LogEventParams): void;

package/lib/{js/tracking/handlers/eventlogging.js → services/trackingHandlers/eventLogging.js}

@@ -1,8 +1,14 @@
-export function logEvent(npoPlayer, event, data) {
-    if (!npoPlayer.player || !npoPlayer.streamTracker || npoPlayer.adBreakActive || npoPlayer.player.isCasting())
+export function logEvent({ playerContext, event, data }) {
+    const { npoPlayer } = playerContext;
+    if (!npoPlayer.player)
         return;
-    if (data === undefined || Object.keys(data).length === 0)
-        data = { stream_position: 0 };
+    if (npoPlayer.adBreakActive || npoPlayer.player.isCasting())
+        return;
+    if (!npoPlayer.streamTracker) {
+        console.error('No streamTracker available, no tracking will be performed.');
+        return;
+    }
+    const eventData = data ?? { stream_position: 0 };
     const eventHandlers = {
         start: npoPlayer.streamTracker.start,
         buffering: npoPlayer.streamTracker.buffering,
@@ -17,10 +23,15 @@ export function logEvent(npoPlayer, event, data) {
         windowed: npoPlayer.streamTracker.windowed,
         time: npoPlayer.streamTracker.time,
         seek: () => {
-            npoPlayer.streamTracker?.seek(data);
+            npoPlayer.streamTracker?.seek(eventData);
         }
     };
     const streamTrackerHandler = eventHandlers[event];
-    npoPlayer.logEmitter.emit('logEvent', event, data);
-    streamTrackerHandler(data);
+    npoPlayer.logEmitter.emit('logEvent', event, eventData);
+    if (streamTrackerHandler) {
+        streamTrackerHandler(eventData);
+    }
+    else {
+        console.warn(`No handler found for event: ${event}`);
+    }
 }

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

@@ -0,0 +1,63 @@
+import { logEvent } from './eventLogging';
+import { createPlayerContextMock, createMockNpoPlayerAPI } from '../../../tests/mocks/playerContextMock';
+describe('logEvent', () => {
+    let playerContextMock;
+    beforeEach(() => {
+        playerContextMock = createPlayerContextMock({
+            npoPlayer: {
+                player: createMockNpoPlayerAPI(),
+                streamTracker: {
+                    start: jest.fn(),
+                    seek: jest.fn()
+                },
+                logEmitter: {
+                    emit: jest.fn()
+                },
+                adBreakActive: false
+            }
+        });
+    });
+    it('should not log event if player is not available', () => {
+        playerContextMock.npoPlayer.player = undefined;
+        logEvent({ playerContext: playerContextMock, event: 'start' });
+        expect(playerContextMock.npoPlayer.streamTracker?.start).not.toHaveBeenCalled();
+        expect(playerContextMock.npoPlayer.logEmitter.emit).not.toHaveBeenCalled();
+    });
+    it('should not log event if streamTracker is not available', () => {
+        playerContextMock.npoPlayer.streamTracker = undefined;
+        logEvent({ playerContext: playerContextMock, event: 'start' });
+        expect(playerContextMock.npoPlayer.logEmitter.emit).not.toHaveBeenCalled();
+    });
+    it('should not log event if adBreakActive is true', () => {
+        playerContextMock.npoPlayer.adBreakActive = true;
+        logEvent({ playerContext: playerContextMock, event: 'start' });
+        expect(playerContextMock.npoPlayer.streamTracker?.start).not.toHaveBeenCalled();
+        expect(playerContextMock.npoPlayer.logEmitter.emit).not.toHaveBeenCalled();
+    });
+    it('should log event and call the corresponding streamTracker handler', () => {
+        logEvent({ playerContext: playerContextMock, event: 'start' });
+        expect(playerContextMock.npoPlayer.streamTracker?.start).toHaveBeenCalledWith({ stream_position: 0 });
+        expect(playerContextMock.npoPlayer.logEmitter.emit).toHaveBeenCalledWith('logEvent', 'start', {
+            stream_position: 0
+        });
+    });
+    it('should log event and call the seek streamTracker handler with data', () => {
+        const data = { position: 20 };
+        logEvent({ playerContext: playerContextMock, event: 'seek', data });
+        expect(playerContextMock.npoPlayer.streamTracker?.seek).toHaveBeenCalledWith(data);
+        expect(playerContextMock.npoPlayer.logEmitter.emit).toHaveBeenCalledWith('logEvent', 'seek', data);
+    });
+    it('should log event with default data if data is undefined', () => {
+        logEvent({ playerContext: playerContextMock, event: 'seek' });
+        expect(playerContextMock.npoPlayer.streamTracker?.seek).toHaveBeenCalledWith({ stream_position: 0 });
+        expect(playerContextMock.npoPlayer.logEmitter.emit).toHaveBeenCalledWith('logEvent', 'seek', { stream_position: 0 });
+    });
+    it('should not throw but log a warning for unsupported events', () => {
+        console.warn = jest.fn();
+        logEvent({ playerContext: playerContextMock, event: 'unsupportedEvent' });
+        expect(console.warn).toHaveBeenCalledWith('No handler found for event: unsupportedEvent');
+        expect(playerContextMock.npoPlayer.logEmitter.emit).toHaveBeenCalledWith('logEvent', 'unsupportedEvent', {
+            stream_position: 0
+        });
+    });
+});

package/lib/services/trackingHandlers/index.d.ts

@@ -0,0 +1,3 @@
+export { startPlayerTracker } from './playerTrackerStart';
+export { initPlayerTracker } from './playerTrackerInit';
+export { logEvent } from './eventLogging';

package/lib/services/trackingHandlers/index.js

@@ -0,0 +1,3 @@
+export { startPlayerTracker } from './playerTrackerStart';
+export { initPlayerTracker } from './playerTrackerInit';
+export { logEvent } from './eventLogging';

package/lib/services/trackingHandlers/playerTrackerInit.d.ts

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

package/lib/{js/tracking/handlers/playertrackerinit.js → services/trackingHandlers/playerTrackerInit.js}

@@ -1,6 +1,7 @@
 import { newATInternetPlugin, newGovoltePlugin, newPageTracker, newTag } from '@npotag/tag';
 const npoTagPlugins = [newGovoltePlugin({ maxRetryCount: 5, delayBetweenRetriesInMs: 3000 }), newATInternetPlugin()];
-export function initPlayerTracker(npoPlayer, _npoTag, _npoTagInstance, _npoTagPageTracker) {
+export function initPlayerTracker(playerContext) {
+    const { npoPlayer } = playerContext;
     if (!npoPlayer.npoTag) {
         npoPlayer.npoTag = {
             npoTagInstance: undefined,
@@ -9,9 +10,11 @@ export function initPlayerTracker(npoPlayer, _npoTag, _npoTagInstance, _npoTagPa
         };
     }
     if (!npoPlayer.npoTag?.npoTagInstance) {
-        npoPlayer.npoTag.npoTagInstance = _npoTagInstance ?? (_npoTag ? newTag(_npoTag, npoTagPlugins) : undefined);
+        npoPlayer.npoTag.npoTagInstance =
+            npoPlayer.npoTagInstance ??
+                (npoPlayer.npoTagInitialisation ? newTag(npoPlayer.npoTagInitialisation, npoTagPlugins) : undefined);
     }
     if (!npoPlayer.npoTag?.pageTracker && npoPlayer.npoTag?.npoTagInstance) {
-        npoPlayer.npoTag.pageTracker = _npoTagPageTracker ?? newPageTracker(npoPlayer.npoTag.npoTagInstance);
+        npoPlayer.npoTag.pageTracker = npoPlayer.npoTagPageTracker ?? newPageTracker(npoPlayer.npoTag.npoTagInstance);
     }
 }

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

@@ -0,0 +1,75 @@
+import { newPageTracker, newTag } from '@npotag/tag';
+import { initPlayerTracker } from './playerTrackerInit';
+import { createPlayerContextMock } from '../../../tests/mocks/playerContextMock';
+jest.mock('@npotag/tag', () => ({
+    newATInternetPlugin: jest.fn(),
+    newGovoltePlugin: jest.fn(),
+    newPageTracker: jest.fn(),
+    newTag: jest.fn()
+}));
+describe('initPlayerTracker', () => {
+    let playerContextMock;
+    beforeEach(() => {
+        playerContextMock = createPlayerContextMock({
+            npoPlayer: {
+                npoTag: undefined,
+                npoTagInitialisation: undefined,
+                npoTagInstance: undefined,
+                npoTagPageTracker: undefined
+            }
+        });
+        jest.clearAllMocks();
+    });
+    it('should initialize npoTag if it is undefined', () => {
+        initPlayerTracker(playerContextMock);
+        expect(playerContextMock.npoPlayer.npoTag).toBeDefined();
+        expect(playerContextMock.npoPlayer.npoTag?.npoTagInstance).toBeUndefined();
+        expect(playerContextMock.npoPlayer.npoTag?.pageTracker).toBeUndefined();
+    });
+    it('should initialize npoTagInstance if npoTagInstance is already provided', () => {
+        const mockNpoTagInstance = {};
+        playerContextMock.npoPlayer.npoTagInstance = mockNpoTagInstance;
+        initPlayerTracker(playerContextMock);
+        expect(playerContextMock.npoPlayer.npoTag?.npoTagInstance).toBe(mockNpoTagInstance);
+        expect(playerContextMock.npoPlayer.npoTag?.pageTracker).toBeUndefined();
+    });
+    it('should create a new npoTagInstance if npoTagInitialisation is provided and npoTagInstance is undefined', () => {
+        const mockNpoTag = {};
+        const mockNewTagInstance = {};
+        newTag.mockReturnValue(mockNewTagInstance);
+        playerContextMock.npoPlayer.npoTagInitialisation = mockNpoTag;
+        initPlayerTracker(playerContextMock);
+        expect(newTag).toHaveBeenCalledWith(mockNpoTag, expect.any(Array));
+        expect(playerContextMock.npoPlayer.npoTag?.npoTagInstance).toBe(mockNewTagInstance);
+        expect(playerContextMock.npoPlayer.npoTag?.pageTracker).toBeUndefined();
+    });
+    it('should initialize pageTracker if npoTagInstance is present and npoTagPageTracker is provided', () => {
+        const mockPageTracker = {};
+        const mockNpoTagInstance = {};
+        playerContextMock.npoPlayer.npoTagInstance = mockNpoTagInstance;
+        playerContextMock.npoPlayer.npoTagPageTracker = mockPageTracker;
+        initPlayerTracker(playerContextMock);
+        expect(playerContextMock.npoPlayer.npoTag?.pageTracker).toBe(mockPageTracker);
+    });
+    it('should create a new pageTracker if npoTagPageTracker is undefined', () => {
+        const mockNpoTagInstance = {};
+        const mockNewPageTracker = {};
+        newPageTracker.mockReturnValue(mockNewPageTracker);
+        playerContextMock.npoPlayer.npoTagInstance = mockNpoTagInstance;
+        initPlayerTracker(playerContextMock);
+        expect(newPageTracker).toHaveBeenCalledWith(mockNpoTagInstance);
+        expect(playerContextMock.npoPlayer.npoTag?.pageTracker).toBe(mockNewPageTracker);
+    });
+    it('should not overwrite existing pageTracker', () => {
+        const mockPageTracker = {};
+        const mockNpoTagInstance = {};
+        playerContextMock.npoPlayer.npoTag = {
+            npoTagInstance: mockNpoTagInstance,
+            pageTracker: mockPageTracker,
+            heartbeatInterval: undefined
+        };
+        initPlayerTracker(playerContextMock);
+        expect(playerContextMock.npoPlayer.npoTag?.pageTracker).toBe(mockPageTracker);
+        expect(newPageTracker).not.toHaveBeenCalled();
+    });
+});

package/lib/services/trackingHandlers/playerTrackerStart.d.ts

@@ -0,0 +1,2 @@
+import { PlayerTrackerParams } from 'types/interfaces';
+export declare const startPlayerTracker: ({ playerContext, source, duration }: PlayerTrackerParams) => void;

package/lib/services/trackingHandlers/playerTrackerStart.js

@@ -0,0 +1,25 @@
+import { getAnalyticsPrid } from '../../js/utilities/utilities.prid';
+import { getStreamDurationInSeconds } from '../../js/utilities/utilities.stream';
+import { initStreamTracker } from './streamTrackerInit';
+import { bindPlayerEvents } from './eventBinding';
+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;
+    if (!source) {
+        throw new Error('Could not initialize streamTracker, no source specified.');
+    }
+    const analyticsPrid = getAnalyticsPrid({
+        source,
+        sourceConfig,
+        streamObject
+    }) || 'unknown';
+    npoPlayer.streamTracker = initStreamTracker({
+        playerContext: playerContext,
+        duration: getStreamDurationInSeconds({ duration: playerDuration }),
+        source: analyticsPrid
+    });
+    bindPlayerEvents(playerContext);
+    logEvent({ playerContext, event: 'load' });
+};