@npo/player 1.29.1 → 2.0.0-beta.1

package/lib/services/trackingHandlers/eventBinding.js

@@ -1,129 +0,0 @@
-import { PlayerEvent, ViewMode } from 'bitmovin-player/modules/bitmovinplayer-core';
-import { logEvent } from './eventLogging';
-const logEventHandlers = new Map();
-export function bindPlayerEvents(playerContext) {
-    const { player, streamObject, adBreakActive } = playerContext.npoPlayer;
-    const { isLiveStream } = streamObject.stream;
-    if (player == undefined)
-        return;
-    let isNewSource = true;
-    let data = {};
-    const timeDifference = (time) => {
-        if (time === undefined || time === null)
-            return;
-        const currentUnixTime = Date.now() / 1000;
-        const timeOffset = time > 0 ? time - currentUnixTime : time;
-        const currentTime = isLiveStream ? timeOffset : time;
-        data = { stream_position: +currentTime.toFixed(3) };
-    };
-    const logEventHandler = (event) => {
-        return (e) => {
-            timeDifference(e.time);
-            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) => {
-        data = {
-            seek_from: e.position,
-            stream_position: e.seekTarget
-        };
-        logEvent({ playerContext, event: 'seek', data });
-    };
-    const handleSourceLoaded = (e) => {
-        timeDifference(e.time);
-        isNewSource = true;
-        if (isLiveStream) {
-            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') {
-            logEvent({ playerContext, event: 'resume', data });
-        }
-    };
-    const pausedHandler = (e) => {
-        timeDifference(e.time);
-        if (e.issuer !== 'ui-seek') {
-            logEvent({ playerContext, event: 'pause', data });
-        }
-    };
-    const handleTime = (e) => {
-        timeDifference(e.time);
-        if (isNewSource && !adBreakActive) {
-            logEvent({ playerContext, event: 'start', data });
-            isNewSource = false;
-        }
-        else {
-            logEvent({ playerContext, event: 'time', data });
-        }
-    };
-    const handleViewModeChange = (e) => {
-        const newViewMode = player.getViewMode();
-        timeDifference(e.time);
-        if (newViewMode === ViewMode.Fullscreen) {
-            logEvent({ playerContext, event: 'fullscreen', data });
-        }
-        else {
-            logEvent({ playerContext, event: 'windowed', data });
-        }
-    };
-    const stopBeforeUnload = (e) => {
-        timeDifference(e.time);
-        logEvent({ playerContext, event: 'stop', data });
-    };
-    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, 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, handler: handlePlaybackFinished },
-        { event: PlayerEvent.SourceUnloaded, name: 'stop' },
-        { event: PlayerEvent.Seek, handler: seekHandler },
-        { event: PlayerEvent.TimeShift, handler: timeShiftHandler },
-        { event: PlayerEvent.TimeChanged, handler: handleTime },
-        { event: PlayerEvent.ViewModeChanged, handler: handleViewModeChange },
-        { event: PlayerEvent.Destroy, handler: clearAllEvents }
-    ];
-    for (const { event, name, handler } of playerEvents) {
-        const effectiveName = name ?? 'unnamed_event';
-        const eventHandler = handler || logEventHandler(effectiveName);
-        logEventHandlers.set(event, eventHandler);
-        player.on(event, eventHandler);
-    }
-    logEventHandlers.set('beforeunload', stopBeforeUnload);
-    window.addEventListener('beforeunload', stopBeforeUnload);
-}

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

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

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

@@ -1,145 +0,0 @@
-import { PlayerEvent, ViewMode } from 'bitmovin-player/modules/bitmovinplayer-core';
-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) })
-            });
-        }
-    });
-    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/eventLogging.d.ts

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

package/lib/services/trackingHandlers/eventLogging.js

@@ -1,37 +0,0 @@
-export function logEvent({ playerContext, event, data }) {
-    const { npoPlayer } = playerContext;
-    if (!npoPlayer.player)
-        return;
-    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,
-        buffering_complete: npoPlayer.streamTracker.buffering_complete,
-        complete: npoPlayer.streamTracker.complete,
-        fullscreen: npoPlayer.streamTracker.fullscreen,
-        load: npoPlayer.streamTracker.load,
-        load_complete: npoPlayer.streamTracker.load_complete,
-        pause: npoPlayer.streamTracker.pause,
-        resume: npoPlayer.streamTracker.resume,
-        stop: npoPlayer.streamTracker.stop,
-        windowed: npoPlayer.streamTracker.windowed,
-        time: npoPlayer.streamTracker.time,
-        seek: () => {
-            npoPlayer.streamTracker?.seek(eventData);
-        }
-    };
-    const streamTrackerHandler = eventHandlers[event];
-    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.d.ts

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

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

@@ -1,63 +0,0 @@
-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

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

package/lib/services/trackingHandlers/index.js

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

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

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

package/lib/services/trackingHandlers/playerTrackerInit.js

@@ -1,20 +0,0 @@
-import { newATInternetPlugin, newGovoltePlugin, newPageTracker, newTag } from '@npotag/tag';
-const npoTagPlugins = [newGovoltePlugin({ maxRetryCount: 5, delayBetweenRetriesInMs: 3000 }), newATInternetPlugin()];
-export function initPlayerTracker(playerContext) {
-    const { npoPlayer } = playerContext;
-    if (!npoPlayer.npoTag) {
-        npoPlayer.npoTag = {
-            npoTagInstance: undefined,
-            pageTracker: undefined,
-            heartbeatInterval: undefined
-        };
-    }
-    if (!npoPlayer.npoTag?.npoTagInstance) {
-        npoPlayer.npoTag.npoTagInstance =
-            npoPlayer.npoTagInstance ??
-                (npoPlayer.npoTagInitialisation ? newTag(npoPlayer.npoTagInitialisation, npoTagPlugins) : undefined);
-    }
-    if (!npoPlayer.npoTag?.pageTracker && npoPlayer.npoTag?.npoTagInstance) {
-        npoPlayer.npoTag.pageTracker = npoPlayer.npoTagPageTracker ?? newPageTracker(npoPlayer.npoTag.npoTagInstance);
-    }
-}

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

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

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

@@ -1,75 +0,0 @@
-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

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

package/lib/services/trackingHandlers/playerTrackerStart.js

@@ -1,28 +0,0 @@
-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, afterAd = false }) {
-    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, durationIsInMs: !!duration }),
-        source: analyticsPrid
-    });
-    bindPlayerEvents(playerContext);
-    logEvent({ playerContext, event: 'load' });
-    if (afterAd) {
-        logEvent({ playerContext, event: 'load_complete' });
-    }
-};

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

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

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

@@ -1,76 +0,0 @@
-import { getAnalyticsPrid } from '../../js/utilities/utilities.prid';
-import { getStreamDurationInSeconds } from '../../js/utilities/utilities.stream';
-import { startPlayerTracker } from './playerTrackerStart';
-import { initStreamTracker } from './streamTrackerInit';
-import { bindPlayerEvents } from './eventBinding';
-import { logEvent } from './eventLogging';
-import { createPlayerContextMock } from '../../../tests/mocks/playerContextMock';
-jest.mock('../../js/utilities/utilities.stream', () => ({
-    getStreamDurationInSeconds: jest.fn()
-}));
-jest.mock('../../js/utilities/utilities.prid', () => ({
-    getAnalyticsPrid: jest.fn()
-}));
-jest.mock('./streamTrackerInit', () => ({
-    initStreamTracker: jest.fn()
-}));
-jest.mock('./eventBinding', () => ({
-    bindPlayerEvents: jest.fn()
-}));
-jest.mock('./eventLogging', () => ({
-    logEvent: jest.fn()
-}));
-describe('startPlayerTracker', () => {
-    let playerContextMock;
-    let playerMock;
-    beforeEach(() => {
-        playerMock = { getDuration: jest.fn().mockReturnValue(200) };
-        playerContextMock = createPlayerContextMock({
-            npoPlayer: {
-                player: playerMock,
-                sourceConfig: {},
-                streamObject: {}
-            }
-        });
-        jest.clearAllMocks();
-    });
-    it('should initialize the stream tracker with the provided duration', () => {
-        const source = 'some-source';
-        const duration = 150;
-        getAnalyticsPrid.mockReturnValue('some-prid');
-        getStreamDurationInSeconds.mockReturnValue(duration);
-        startPlayerTracker({ playerContext: playerContextMock, source, duration });
-        expect(getAnalyticsPrid).toHaveBeenCalledWith({
-            source,
-            sourceConfig: {},
-            streamObject: {}
-        });
-        expect(getStreamDurationInSeconds).toHaveBeenCalledWith({
-            duration,
-            durationIsInMs: true
-        });
-        expect(initStreamTracker).toHaveBeenCalledWith({
-            playerContext: playerContextMock,
-            duration,
-            source: 'some-prid'
-        });
-        expect(bindPlayerEvents).toHaveBeenCalledWith(playerContextMock);
-        expect(logEvent).toHaveBeenCalledWith({ playerContext: playerContextMock, event: 'load' });
-    });
-    it('should fallback to player.getDuration() if duration is not provided', () => {
-        const source = 'some-source';
-        const fallbackDuration = 200;
-        getAnalyticsPrid.mockReturnValue('some-prid');
-        getStreamDurationInSeconds.mockReturnValue(fallbackDuration);
-        startPlayerTracker({ playerContext: playerContextMock, source });
-        expect(getStreamDurationInSeconds).toHaveBeenCalledWith({
-            duration: fallbackDuration,
-            durationIsInMs: false
-        });
-        expect(initStreamTracker).toHaveBeenCalledWith({
-            playerContext: playerContextMock,
-            duration: fallbackDuration,
-            source: 'some-prid'
-        });
-    });
-});

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

@@ -1,3 +0,0 @@
-import { StreamTracker } from '@npotag/tag';
-import { PlayerTrackerParams } from 'types/interfaces';
-export declare function initStreamTracker({ playerContext, duration, source }: PlayerTrackerParams): StreamTracker;

package/lib/services/trackingHandlers/streamTrackerInit.js

@@ -1,27 +0,0 @@
-import { newStreamTracker } from '@npotag/tag';
-import { validatePrid } from '../../js/utilities/utilities.stream';
-export function initStreamTracker({ playerContext, duration, source }) {
-    const { npoPlayer } = playerContext;
-    const { npoTag, npoPlayerServices, version } = npoPlayer;
-    if (!npoTag?.npoTagInstance) {
-        throw new Error('No npoTagInstance available. Could not create streamtracker.');
-    }
-    if (!npoTag?.pageTracker) {
-        throw new Error('No pageTracker available. Could not create streamtracker.');
-    }
-    if (!duration) {
-        throw new Error('No duration specified. Could not create streamtracker.');
-    }
-    const streamTrackerConfig = {
-        stream_length: duration,
-        stream_id: validatePrid(source),
-        player_id: 'npoplayer-web',
-        av_type: npoPlayerServices.getAVType(npoPlayer.streamObject.stream.avType),
-        player_version: version,
-        sko_player_version: '1.0.0'
-    };
-    const isLiveStream = npoPlayer.streamObject.stream.isLiveStream || false;
-    return newStreamTracker(npoTag.pageTracker, streamTrackerConfig, {
-        isLive: isLiveStream
-    });
-}

package/lib/services/trackingHandlers/streamTrackerInit.test.d.ts

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