@npo/player 1.29.1 → 2.0.0-beta.1

package/lib/services/services.js

@@ -1,129 +0,0 @@
-import { resolveKeyPress } from './keyboardHandlers/resolvekeypress';
-import { setSegmentMarkers } from './segmentHandlers/setSegmentMarkers';
-import { convertFragmentToSegment } from './segmentHandlers/convertFragmentToSegment';
-import * as DRMHandlers from './drmHandlers/drmhandlers';
-import { setupAccessibilityAttributes } from './a11y/setup';
-import { getLocalStorage, setLocalStorage, setValuesBasedOnLocalStorage } from './localStorageHandlers/localStorageHandlers';
-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';
-import { removeEventListeners } from './eventListenerHandlers/removeEventListeners';
-import { isSegmentInBounds } from './segmentHandlers/isSegmentInBounds';
-import { addDataInInfoPanel, clearInfoPanel } from './infoPanel/infoPanel';
-import { handleBackButtons } from './backButton/backButton';
-export class NpoPlayerServices {
-    getAVType(avType) {
-        return getAVType(avType);
-    }
-    keyboardHandler(playerContext, e) {
-        resolveKeyPress(playerContext, e);
-    }
-    convertFragmentToSegment(fragment) {
-        return convertFragmentToSegment(fragment);
-    }
-    segmentMarkersHandler(segment, title) {
-        return setSegmentMarkers(segment, title);
-    }
-    decideProfile(playerContext, preferredDRM = '') {
-        return DRMHandlers.decideProfile(playerContext, preferredDRM);
-    }
-    verifyDRM(playerContext, payload) {
-        return DRMHandlers.verifyDRM(playerContext, payload);
-    }
-    setStoredUserPrefs(key, value) {
-        return setLocalStorage(key, value);
-    }
-    getStoredUserPrefs() {
-        return getLocalStorage();
-    }
-    handleUserPrefs(playerContext) {
-        if (playerContext === undefined) {
-            console.error('playerContext is undefined');
-            return;
-        }
-        return setValuesBasedOnLocalStorage(playerContext);
-    }
-    setAccessibilityAttributes(playerContext) {
-        if (playerContext === undefined) {
-            console.error('playerContext is undefined');
-            return;
-        }
-        return setupAccessibilityAttributes(playerContext);
-    }
-    async schedulePreRolls(playerContext) {
-        await handlePreRolls(playerContext);
-    }
-    discardAdBreak(playerContext) {
-        discardAdBreak(playerContext);
-    }
-    handleVerticalVideoControls(playerContext) {
-        return handleVerticalVideoControls(playerContext);
-    }
-    handleVerticalVideoSettings(playerContext) {
-        return handleVerticalVideoSettings(playerContext);
-    }
-    showNicamAfterUiDelay(playerContext) {
-        return showNicamAfterUiDelay(playerContext);
-    }
-    setupNicamKijkwijzerIcons(playerContext) {
-        return setupNicamKijkwijzerIcons(playerContext);
-    }
-    handlePreferences(playerContext) {
-        handlePreferences(playerContext);
-    }
-    addUivisiblityHandlers(playerContext) {
-        addUivisiblityHandlers(playerContext);
-    }
-    removeUivisiblityHandlers(playerContext) {
-        removeUivisiblityHandlers(playerContext);
-    }
-    handleStreamOptions(playerContext) {
-        handleStreamOptions(playerContext);
-    }
-    async handleError({ playerContext, status: input, context: context }) {
-        await handlePlayerError({ playerContext, status: input, context: context });
-    }
-    async fetchStream(playerContext, payload) {
-        return await fetchStream(playerContext, payload);
-    }
-    startPlayerTracker({ playerContext, source, duration, afterAd = false }) {
-        startPlayerTracker({
-            playerContext,
-            source,
-            duration,
-            afterAd
-        });
-    }
-    initPlayerTracker(playerContext) {
-        initPlayerTracker(playerContext);
-    }
-    logEvent({ playerContext, event, data }) {
-        logEvent({ playerContext, event, data });
-    }
-    removeEventListeners(playerContext) {
-        removeEventListeners(playerContext);
-    }
-    isSegmentInBounds(playerContext) {
-        const segment = playerContext.npoPlayer.streamObject.segment;
-        const duration = playerContext.player.getDuration();
-        return isSegmentInBounds(segment, duration);
-    }
-    addDataInInfoPanel(playerContext) {
-        addDataInInfoPanel(playerContext);
-    }
-    clearInfoPanel(playerContext) {
-        clearInfoPanel(playerContext);
-    }
-    handleBackButtons(playerContext) {
-        handleBackButtons(playerContext);
-    }
-}

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

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

package/lib/services/streamFetchHandler/fetchStream.js

@@ -1,49 +0,0 @@
-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, context }) => {
-        if (!hasHandledError) {
-            hasHandledError = true;
-            await npoPlayer.npoPlayerServices.handleError({ playerContext, status, context });
-        }
-        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;
-            const context = streamApiResponse?.context || undefined;
-            return await handleStreamError({ status, message: genericError, context });
-        }
-    }
-    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({ status: 500, message: errorMessage });
-        }
-        throw error;
-    }
-}

package/lib/services/streamFetchHandler/fetchstream.test.d.ts

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

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

@@ -1,92 +0,0 @@
-import { fetchStream } from './fetchStream';
-import { createMockNpoPlayer, createPlayerContextMock } from '../../../tests/mocks/playerContextMock';
-const setupServicesErrorMessage = 'mockNpoPlayer.npoPlayerServices is undefined, test setup is incorrect';
-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)
-        }));
-        if (!mockNpoPlayer.npoPlayerServices) {
-            throw new Error(setupServicesErrorMessage);
-        }
-        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.');
-        if (!mockNpoPlayer.npoPlayerServices) {
-            throw new Error(setupServicesErrorMessage);
-        }
-        expect(mockNpoPlayer.npoPlayerServices.handleError).toHaveBeenCalledWith({
-            playerContext: mockPlayerContext,
-            status: 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');
-        if (!mockNpoPlayer.npoPlayerServices) {
-            throw new Error(setupServicesErrorMessage);
-        }
-        expect(mockNpoPlayer.npoPlayerServices.handleError).toHaveBeenCalledWith({
-            playerContext: mockPlayerContext,
-            status: 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.');
-        if (!mockNpoPlayer.npoPlayerServices) {
-            throw new Error(setupServicesErrorMessage);
-        }
-        expect(mockNpoPlayer.npoPlayerServices.handleError).toHaveBeenCalledWith({
-            playerContext: mockPlayerContext,
-            status: 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/streamoptionsHandlers/streamOptionsHandler.d.ts

@@ -1,6 +0,0 @@
-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/services/streamoptionsHandlers/streamOptionsHandler.js

@@ -1,80 +0,0 @@
-import * as playerAction from '../../js/playeractions/playeractions';
-import { initSegment } from '../segmentHandlers/initSegment';
-import { handleLiveStreamControls } from '../liveStreamHandlers/handleLiveStreamControls';
-import { NpoPlayerEvent } from '../../types/events';
-import { updateClassFromElementByQuery } from '../../js/utilities/utilities.element';
-export function handleStreamOptions(playerContext) {
-    const { streamObject, uiManager, npoPlayerServices } = playerContext.npoPlayer;
-    if (!streamObject || !uiManager)
-        return;
-    initializeFragment(playerContext);
-    handleStartOffset(playerContext);
-    updateStreamClasses(playerContext);
-    npoPlayerServices.addDataInInfoPanel(playerContext);
-    npoPlayerServices.handleBackButtons(playerContext);
-    const isAutoplayEnabled = getAutoplayStatus(playerContext);
-    if (isAutoplayEnabled) {
-        setupAutoplay(playerContext);
-    }
-}
-export function initializeFragment(playerContext) {
-    const { streamObject, streamOptions } = playerContext.npoPlayer;
-    initSegment(playerContext, {
-        segment: streamObject.segment,
-        fragment: streamOptions?.fragments
-    });
-}
-export function handleStartOffset(playerContext) {
-    const streamOptions = playerContext.npoPlayer.streamOptions;
-    if (streamOptions?.startOffset) {
-        playerAction.handleStartOffset(playerContext, streamOptions.startOffset);
-    }
-}
-export function updateStreamClasses(playerContext) {
-    const { npoPlayer } = playerContext;
-    const { streamObject, container } = npoPlayer;
-    const { isLiveStream, hasDvrWindow, avType } = streamObject.stream;
-    const containerClassString = '.bmpui-ui-uicontainer';
-    const queries = [
-        {
-            container,
-            query: containerClassString,
-            className: 'livestream-no-dvr',
-            condition: !!(isLiveStream && !hasDvrWindow)
-        },
-        {
-            container,
-            query: containerClassString,
-            className: 'audio-only',
-            condition: avType === 'aod' || avType === 'audio'
-        },
-        {
-            container,
-            query: '.bitmovinplayer-poster',
-            className: 'audio-only',
-            condition: avType === 'aod' || avType === 'audio'
-        }
-    ];
-    for (const query of queries)
-        updateClassFromElementByQuery(query);
-    if (streamObject.stream.isLiveStream && streamObject.stream.hasDvrWindow) {
-        handleLiveStreamControls(playerContext);
-    }
-}
-function getAutoplayStatus(playerContext) {
-    return (playerContext.npoPlayer.streamOptions?.autoplay ?? playerContext.player.getConfig()?.playback?.autoplay ?? false);
-}
-export function setupAutoplay(playerContext) {
-    const { player } = playerContext;
-    const handleAutoPlay = () => {
-        doAutoPlay().catch((error) => {
-            console.error('Error attempting to autoplay:', error);
-        });
-    };
-    const doAutoPlay = async () => {
-        player.off(NpoPlayerEvent.Ready, handleAutoPlay);
-        player.off(NpoPlayerEvent.SourceLoaded, handleAutoPlay);
-        await player.play();
-    };
-    player.on(NpoPlayerEvent.SourceLoaded, handleAutoPlay);
-}

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

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

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

@@ -1,199 +0,0 @@
-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;
-        expect(playerContextMock.npoPlayer.npoPlayerServices.addDataInInfoPanel(playerContextMock)).toHaveBeenCalled;
-    });
-    it('should return early if uiManager is missing', () => {
-        const npoPlayerMock = createMockNpoPlayer({
-            UIManager: undefined
-        });
-        const playerContextMock = createPlayerContextMock({
-            npoPlayer: npoPlayerMock
-        });
-        handleStreamOptions(playerContextMock);
-        expect(removeEventListeners).not.toHaveBeenCalled();
-    });
-    it('should return early if streamObject is missing', () => {
-        const npoPlayerMock = createMockNpoPlayer({
-            streamObject: undefined
-        });
-        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({
-                query: '.bmpui-ui-uicontainer',
-                className: 'livestream-no-dvr',
-                condition: false
-            }));
-            expect(updateClassFromElementByQuery).toHaveBeenCalledWith(expect.objectContaining({
-                query: '.bmpui-ui-uicontainer',
-                className: 'audio-only',
-                condition: true
-            }));
-            expect(updateClassFromElementByQuery).toHaveBeenCalledWith(expect.objectContaining({
-                query: '.bitmovinplayer-poster',
-                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.SourceLoaded, expect.any(Function));
-            const handleAutoPlay = playerContextMock.player.on.mock.calls[0][1];
-            await handleAutoPlay();
-            expect(playerContextMock.player.play).toHaveBeenCalled();
-        });
-    });
-});

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

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