@npo/player 1.29.1 → 2.0.0-beta.1

package/lib/services/preferences/handlePreferences.test.js

@@ -1,138 +0,0 @@
-import createPlayerContextMock, { createMockNpoPlayer, createMockNpoPlayerAPI } from '../../../tests/mocks/playerContextMock';
-import { handlePreferences } from './handlePreferences';
-import { NpoPlayerEvent } from '../../types/events';
-import { LocalStorageValues } from '../../types/interfaces';
-const setupServicesErrorMessage = 'mockNpoPlayer.npoPlayerServices is undefined, test setup is incorrect';
-const setupStreamOptionsErrorMessage = 'mockNpoPlayer.streamOptions is undefined, test setup is incorrect';
-describe('handlePreferences', () => {
-    let mockPlayerAPI;
-    let mockNpoPlayer;
-    let playerContextMock;
-    beforeEach(() => {
-        mockPlayerAPI = createMockNpoPlayerAPI();
-        mockNpoPlayer = createMockNpoPlayer({
-            streamOptions: {
-                enableSubtitles: false
-            },
-            npoPlayerServices: {
-                getStoredUserPrefs: jest.fn().mockReturnValue({
-                    subtitles_enabled: 'false',
-                    subtitles_language: 'nl'
-                }),
-                setStoredUserPrefs: jest.fn()
-            }
-        });
-        playerContextMock = createPlayerContextMock({
-            player: mockPlayerAPI,
-            npoPlayer: mockNpoPlayer
-        });
-        handlePreferences(playerContextMock);
-    });
-    test('should enable subtitles if streamOptions.enableSubtitles is true', () => {
-        if (!mockNpoPlayer.streamOptions) {
-            throw new Error(setupStreamOptionsErrorMessage);
-        }
-        mockNpoPlayer.streamOptions.enableSubtitles = true;
-        for (const [event, callback] of mockPlayerAPI.on.mock.calls) {
-            if (event === NpoPlayerEvent.Ready) {
-                callback(NpoPlayerEvent.Ready);
-            }
-        }
-        expect(mockPlayerAPI.enableSubtitles).toHaveBeenCalledWith('nl');
-    });
-    test('should enable subtitles if subtitles_enabled in preferences is true', () => {
-        if (!mockNpoPlayer.streamOptions) {
-            throw new Error(setupStreamOptionsErrorMessage);
-        }
-        if (!mockNpoPlayer.npoPlayerServices) {
-            throw new Error(setupServicesErrorMessage);
-        }
-        mockNpoPlayer.streamOptions.enableSubtitles = false;
-        mockNpoPlayer.npoPlayerServices.getStoredUserPrefs.mockReturnValueOnce({
-            subtitles_enabled: 'true',
-            subtitles_language: 'nl'
-        });
-        for (const [event, callback] of mockPlayerAPI.on.mock.calls) {
-            if (event === NpoPlayerEvent.Ready) {
-                callback(NpoPlayerEvent.Ready);
-            }
-        }
-        expect(mockPlayerAPI.enableSubtitles).toHaveBeenCalledWith('nl');
-    });
-    test('should disable subtitles and set the preferences', () => {
-        ;
-        mockPlayerAPI.listSubtitles.mockReturnValueOnce([{ lang: 'nl', enabled: true }]);
-        for (const [event, callback] of mockPlayerAPI.on.mock.calls) {
-            if (event === NpoPlayerEvent.SubtitleEnabled) {
-                callback(NpoPlayerEvent.SubtitleEnable);
-            }
-        }
-        if (!mockNpoPlayer.npoPlayerServices) {
-            throw new Error(setupServicesErrorMessage);
-        }
-        expect(mockNpoPlayer.npoPlayerServices.setStoredUserPrefs).toHaveBeenCalledWith(LocalStorageValues.SUBTITLES_LANGUAGE, 'nl');
-        expect(mockNpoPlayer.npoPlayerServices.setStoredUserPrefs).toHaveBeenCalledWith(LocalStorageValues.SUBTITLES_ENABLED, 'true');
-    });
-    test('should disable subtitles and set preferences to false', () => {
-        for (const [event, callback] of mockPlayerAPI.on.mock.calls) {
-            if (event === NpoPlayerEvent.SubtitleDisabled) {
-                callback(NpoPlayerEvent.SubtitleDisabled);
-            }
-        }
-        if (!mockNpoPlayer.npoPlayerServices) {
-            throw new Error(setupServicesErrorMessage);
-        }
-        expect(mockNpoPlayer.npoPlayerServices.setStoredUserPrefs).toHaveBeenCalledWith(LocalStorageValues.SUBTITLES_ENABLED, 'false');
-    });
-    test('should set volume preferences', () => {
-        for (const [event, callback] of mockPlayerAPI.on.mock.calls) {
-            if (event === NpoPlayerEvent.VolumeChanged) {
-                callback(NpoPlayerEvent.VolumeChanged);
-            }
-        }
-        if (!mockNpoPlayer.npoPlayerServices) {
-            throw new Error(setupServicesErrorMessage);
-        }
-        expect(mockNpoPlayer.npoPlayerServices.setStoredUserPrefs).toHaveBeenCalledWith(LocalStorageValues.VOLUME, 50);
-    });
-    test('should set muted preferences with volume > 0', () => {
-        for (const [event, callback] of mockPlayerAPI.on.mock.calls) {
-            if (event === NpoPlayerEvent.Muted) {
-                callback(NpoPlayerEvent.Muted);
-            }
-        }
-        if (!mockNpoPlayer.npoPlayerServices) {
-            throw new Error(setupServicesErrorMessage);
-        }
-        expect(mockNpoPlayer.npoPlayerServices.setStoredUserPrefs).toHaveBeenCalledWith(LocalStorageValues.IS_MUTED, 'true');
-        expect(mockPlayerAPI.getVolume).toHaveBeenCalled();
-        expect(mockPlayerAPI.setVolume).not.toHaveBeenCalled();
-    });
-    test('should set muted preferences and reset volume when volume === 0', () => {
-        ;
-        mockPlayerAPI.getVolume.mockReturnValueOnce(0);
-        for (const [event, callback] of mockPlayerAPI.on.mock.calls) {
-            if (event === NpoPlayerEvent.Muted) {
-                callback(NpoPlayerEvent.Muted);
-            }
-        }
-        if (!mockNpoPlayer.npoPlayerServices) {
-            throw new Error(setupServicesErrorMessage);
-        }
-        expect(mockNpoPlayer.npoPlayerServices.setStoredUserPrefs).toHaveBeenCalledWith(LocalStorageValues.IS_MUTED, 'true');
-        expect(mockPlayerAPI.getVolume).toHaveBeenCalled();
-        expect(mockPlayerAPI.setVolume).toHaveBeenCalledWith(100);
-        expect(mockPlayerAPI.mute).toHaveBeenCalled();
-    });
-    test('should set unmuted preferences', () => {
-        for (const [event, callback] of mockPlayerAPI.on.mock.calls) {
-            if (event === NpoPlayerEvent.Unmuted) {
-                callback(NpoPlayerEvent.Unmuted);
-            }
-        }
-        if (!mockNpoPlayer.npoPlayerServices) {
-            throw new Error(setupServicesErrorMessage);
-        }
-        expect(mockNpoPlayer.npoPlayerServices.setStoredUserPrefs).toHaveBeenCalledWith(LocalStorageValues.IS_MUTED, 'false');
-    });
-});

package/lib/services/segmentHandlers/addSegmentEventListeners.d.ts

@@ -1,2 +0,0 @@
-import { PlayerContext, Segment } from '../../types/interfaces';
-export declare const addSegmentEventListeners: (playerContext: PlayerContext, segment: Segment) => void;

package/lib/services/segmentHandlers/addSegmentEventListeners.js

@@ -1,15 +0,0 @@
-import { NpoPlayerEvent } from '../../types/events';
-import { handleSegmentTimeChanged } from './handleSegmentTimeChanged';
-import { handleSegmentSeek } from './handleSegmentSeek';
-export const addSegmentEventListeners = (playerContext, segment) => {
-    const segmentHandleTimeChangedCallback = handleSegmentTimeChanged(playerContext, segment);
-    const segmentSeekFunctionCallback = handleSegmentSeek(playerContext, segment);
-    const { player, npoPlayer } = playerContext;
-    player.on(NpoPlayerEvent.TimeChanged, segmentHandleTimeChangedCallback);
-    player.on(NpoPlayerEvent.Seek, segmentSeekFunctionCallback);
-    npoPlayer.eventListeners = {
-        ...npoPlayer.eventListeners,
-        segmentHandleTimeChangedCallback,
-        segmentSeekFunctionCallback
-    };
-};

package/lib/services/segmentHandlers/addSegmentEventListeners.test.d.ts

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

package/lib/services/segmentHandlers/addSegmentEventListeners.test.js

@@ -1,44 +0,0 @@
-import { PlayerEvent } from 'bitmovin-player/modules/bitmovinplayer-core';
-import { addSegmentEventListeners } from './addSegmentEventListeners';
-import { handleSegmentTimeChanged } from './handleSegmentTimeChanged';
-import { handleSegmentSeek } from './handleSegmentSeek';
-import createPlayerContextMock from '../../../tests/mocks/playerContextMock';
-jest.mock('./handleSegmentTimeChanged', () => ({
-    handleSegmentTimeChanged: jest.fn()
-}));
-jest.mock('./handleSegmentSeek', () => ({
-    handleSegmentSeek: jest.fn()
-}));
-describe('addSegmentEventListeners', () => {
-    let mockPlayerContext;
-    const segment = { inpoint: 10, outpoint: 20, duration: 10 };
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockPlayerContext = createPlayerContextMock();
-    });
-    it('should add TimeChanged event listener', () => {
-        const segmentHandleTimeChangedCallback = jest.fn();
-        handleSegmentTimeChanged.mockReturnValue(segmentHandleTimeChangedCallback);
-        addSegmentEventListeners(mockPlayerContext, segment);
-        expect(mockPlayerContext.player.on).toHaveBeenCalledWith(PlayerEvent.TimeChanged, segmentHandleTimeChangedCallback);
-        expect(handleSegmentTimeChanged).toHaveBeenCalledWith(mockPlayerContext, segment);
-    });
-    it('should add Seek event listener', () => {
-        const segmentSeekFunctionCallback = jest.fn();
-        handleSegmentSeek.mockReturnValue(segmentSeekFunctionCallback);
-        addSegmentEventListeners(mockPlayerContext, segment);
-        expect(mockPlayerContext.player.on).toHaveBeenCalledWith(PlayerEvent.Seek, segmentSeekFunctionCallback);
-        expect(handleSegmentSeek).toHaveBeenCalledWith(mockPlayerContext, segment);
-    });
-    it('should set segmentEventListeners in playerContext', () => {
-        const segmentHandleTimeChangedCallback = jest.fn();
-        const segmentSeekFunctionCallback = jest.fn();
-        handleSegmentTimeChanged.mockReturnValue(segmentHandleTimeChangedCallback);
-        handleSegmentSeek.mockReturnValue(segmentSeekFunctionCallback);
-        addSegmentEventListeners(mockPlayerContext, segment);
-        expect(mockPlayerContext.npoPlayer.eventListeners).toEqual({
-            segmentHandleTimeChangedCallback,
-            segmentSeekFunctionCallback
-        });
-    });
-});

package/lib/services/segmentHandlers/convertFragmentToSegment.d.ts

@@ -1,2 +0,0 @@
-import { Fragment, Segment } from '../../types/interfaces';
-export declare function convertFragmentToSegment(fragment: Fragment): Segment;

package/lib/services/segmentHandlers/convertFragmentToSegment.js

@@ -1,8 +0,0 @@
-export function convertFragmentToSegment(fragment) {
-    const { duration, time } = fragment.sections[0];
-    return {
-        inpoint: time,
-        outpoint: time + duration,
-        duration: duration
-    };
-}

package/lib/services/segmentHandlers/convertFragmentToSegment.test.d.ts

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

package/lib/services/segmentHandlers/convertFragmentToSegment.test.js

@@ -1,17 +0,0 @@
-import { convertFragmentToSegment } from './convertFragmentToSegment';
-describe('convertFragmentToSegment', () => {
-    const SECTION_START = 500;
-    const SECTION_DURATION = 610;
-    it('should convert fragment to segment correctly', () => {
-        const fragment = {
-            sections: [{ time: SECTION_START, duration: SECTION_DURATION, title: 'Section 1' }]
-        };
-        const expectedSegment = {
-            inpoint: SECTION_START,
-            outpoint: SECTION_START + SECTION_DURATION,
-            duration: SECTION_DURATION
-        };
-        const result = convertFragmentToSegment(fragment);
-        expect(result).toEqual(expectedSegment);
-    });
-});

package/lib/services/segmentHandlers/handleSegmentSeek.d.ts

@@ -1,5 +0,0 @@
-import { PlayerContext, Segment } from '../../types/interfaces';
-export declare const handleSegmentSeek: (playerContext: PlayerContext, segment: Segment) => (e: any) => void;
-export declare const getSeekTarget: (event: any) => number;
-export declare const isSeekOutsideSegment: (seekTarget: number, segment: Segment) => boolean;
-export declare const clampSeekTarget: (seekTarget: number, segment: Segment) => number;

package/lib/services/segmentHandlers/handleSegmentSeek.js

@@ -1,15 +0,0 @@
-export const handleSegmentSeek = (playerContext, segment) => (e) => {
-    const seekTarget = getSeekTarget(e);
-    if (isSeekOutsideSegment(seekTarget, segment)) {
-        playerContext.player.seek(clampSeekTarget(seekTarget, segment));
-    }
-};
-export const getSeekTarget = (event) => {
-    return event.seekTarget ? event.seekTarget : event.to.time;
-};
-export const isSeekOutsideSegment = (seekTarget, segment) => {
-    return seekTarget > segment.outpoint || seekTarget < segment.inpoint;
-};
-export const clampSeekTarget = (seekTarget, segment) => {
-    return Math.max(segment.inpoint, Math.min(segment.outpoint, seekTarget));
-};

package/lib/services/segmentHandlers/handleSegmentSeek.test.d.ts

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

package/lib/services/segmentHandlers/handleSegmentSeek.test.js

@@ -1,73 +0,0 @@
-import { handleSegmentSeek, getSeekTarget, isSeekOutsideSegment, clampSeekTarget } from './handleSegmentSeek';
-import createPlayerContextMock from '../../../tests/mocks/playerContextMock';
-describe('handleSegmentSeek', () => {
-    const SEGMENT_INPOINT = 500;
-    const SEGMENT_OUTPOINT = 1500;
-    const SEGMENT_DURATION = 1000;
-    const SEEK_TARGET_WITHIN = 800;
-    const SEEK_TARGET_ABOVE = 1600;
-    const SEEK_TARGET_BELOW = 400;
-    let segment;
-    let mockPlayerContext;
-    beforeEach(() => {
-        segment = {
-            inpoint: SEGMENT_INPOINT,
-            outpoint: SEGMENT_OUTPOINT,
-            duration: SEGMENT_DURATION
-        };
-        mockPlayerContext = createPlayerContextMock();
-        jest.clearAllMocks();
-    });
-    describe('getSeekTarget', () => {
-        it('should return seekTarget if present in event', () => {
-            const event = { seekTarget: SEEK_TARGET_WITHIN };
-            expect(getSeekTarget(event)).toBe(SEEK_TARGET_WITHIN);
-        });
-        it('should return event.to.time if seekTarget is not present', () => {
-            const event = { to: { time: SEEK_TARGET_WITHIN } };
-            expect(getSeekTarget(event)).toBe(SEEK_TARGET_WITHIN);
-        });
-    });
-    describe('isSeekOutsideSegment', () => {
-        it('should return true if seekTarget is greater than segment.outpoint', () => {
-            expect(isSeekOutsideSegment(SEEK_TARGET_ABOVE, segment)).toBe(true);
-        });
-        it('should return true if seekTarget is less than segment.inpoint', () => {
-            expect(isSeekOutsideSegment(SEEK_TARGET_BELOW, segment)).toBe(true);
-        });
-        it('should return false if seekTarget is within segment bounds', () => {
-            expect(isSeekOutsideSegment(SEEK_TARGET_WITHIN, segment)).toBe(false);
-        });
-    });
-    describe('clampSeekTarget', () => {
-        it('should return inpoint if seekTarget is less than inpoint', () => {
-            expect(clampSeekTarget(SEEK_TARGET_BELOW, segment)).toBe(SEGMENT_INPOINT);
-        });
-        it('should return outpoint if seekTarget is greater than outpoint', () => {
-            expect(clampSeekTarget(SEEK_TARGET_ABOVE, segment)).toBe(SEGMENT_OUTPOINT);
-        });
-        it('should return seekTarget if it is within segment bounds', () => {
-            expect(clampSeekTarget(SEEK_TARGET_WITHIN, segment)).toBe(SEEK_TARGET_WITHIN);
-        });
-    });
-    describe('handleSegmentSeek', () => {
-        it('should seek to the clamped seekTarget if outside segment', () => {
-            const event = { seekTarget: SEEK_TARGET_ABOVE };
-            const handler = handleSegmentSeek(mockPlayerContext, segment);
-            handler(event);
-            expect(mockPlayerContext.player.seek).toHaveBeenCalledWith(SEGMENT_OUTPOINT);
-        });
-        it('should not seek if the seekTarget is within segment', () => {
-            const event = { seekTarget: SEEK_TARGET_WITHIN };
-            const handler = handleSegmentSeek(mockPlayerContext, segment);
-            handler(event);
-            expect(mockPlayerContext.player.seek).not.toHaveBeenCalled();
-        });
-        it('should seek to the clamped seekTarget using event.to.time', () => {
-            const event = { to: { time: SEEK_TARGET_ABOVE } };
-            const handler = handleSegmentSeek(mockPlayerContext, segment);
-            handler(event);
-            expect(mockPlayerContext.player.seek).toHaveBeenCalledWith(SEGMENT_OUTPOINT);
-        });
-    });
-});

package/lib/services/segmentHandlers/handleSegmentTimeChanged.d.ts

@@ -1,2 +0,0 @@
-import { PlayerContext, Segment } from '../../types/interfaces';
-export declare const handleSegmentTimeChanged: (playerContext: PlayerContext, segment: Segment) => (e: any) => void;

package/lib/services/segmentHandlers/handleSegmentTimeChanged.js

@@ -1,21 +0,0 @@
-export const handleSegmentTimeChanged = (playerContext, segment) => {
-    let isFinished = false;
-    const handleTimeGreaterThanOutpoint = (e) => {
-        if (e.time > segment.outpoint && !isFinished) {
-            isFinished = true;
-            playerContext.player.seek(Math.max(segment.inpoint, segment.outpoint));
-            playerContext.player.pause();
-            playerContext?.player.addClassToNpoPlayerElement('bmpui-player-state-replay');
-        }
-    };
-    const handleTimeLessThanInpoint = (e) => {
-        if (e.time < segment.inpoint || (e.time > segment.outpoint && isFinished)) {
-            isFinished = false;
-            playerContext.player.seek(segment.inpoint);
-        }
-    };
-    return (e) => {
-        handleTimeGreaterThanOutpoint(e);
-        handleTimeLessThanInpoint(e);
-    };
-};

package/lib/services/segmentHandlers/handleSegmentTimeChanged.test.d.ts

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

package/lib/services/segmentHandlers/handleSegmentTimeChanged.test.js

@@ -1,43 +0,0 @@
-import { handleSegmentTimeChanged } from './handleSegmentTimeChanged';
-import createPlayerContextMock from '../../../tests/mocks/playerContextMock';
-describe('handleSegmentTimeChanged', () => {
-    let mockPlayerContext;
-    let mockSegment;
-    const INPOINT = 10;
-    const OUTPOINT = 20;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockPlayerContext = createPlayerContextMock();
-        mockSegment = { inpoint: INPOINT, outpoint: OUTPOINT, duration: OUTPOINT - INPOINT };
-    });
-    it('should seek to inpoint and pause when time is greater than outpoint', () => {
-        const event = { time: OUTPOINT + 1 };
-        const handler = handleSegmentTimeChanged(mockPlayerContext, mockSegment);
-        handler(event);
-        expect(mockPlayerContext.player.seek).toHaveBeenCalledWith(Math.max(INPOINT, OUTPOINT));
-        expect(mockPlayerContext.player.pause).toHaveBeenCalled();
-        expect(mockPlayerContext.player.addClassToNpoPlayerElement).toHaveBeenCalledWith('bmpui-player-state-replay');
-    });
-    it('should seek to inpoint when time is less than inpoint', () => {
-        const event = { time: INPOINT - 1 };
-        const handler = handleSegmentTimeChanged(mockPlayerContext, mockSegment);
-        handler(event);
-        expect(mockPlayerContext.player.seek).toHaveBeenCalledWith(INPOINT);
-    });
-    it('should seek to inpoint when time is greater than outpoint and isFinished is true', () => {
-        const event = { time: OUTPOINT + 1 };
-        const handler = handleSegmentTimeChanged(mockPlayerContext, mockSegment);
-        handler(event);
-        handler({ time: INPOINT - 1 });
-        handler(event);
-        expect(mockPlayerContext.player.seek).toHaveBeenCalledWith(INPOINT);
-    });
-    it('should not seek or pause when time is between inpoint and outpoint', () => {
-        const event = { time: (INPOINT + OUTPOINT) / 2 };
-        const handler = handleSegmentTimeChanged(mockPlayerContext, mockSegment);
-        handler(event);
-        expect(mockPlayerContext.player.seek).not.toHaveBeenCalled();
-        expect(mockPlayerContext.player.pause).not.toHaveBeenCalled();
-        expect(mockPlayerContext.player.addClassToNpoPlayerElement).not.toHaveBeenCalled();
-    });
-});

package/lib/services/segmentHandlers/initSegment.d.ts

@@ -1,7 +0,0 @@
-import { Fragment, PlayerContext, Segment } from '../../types/interfaces';
-type SegmentOrFragment = {
-    segment?: Segment;
-    fragment?: Fragment;
-};
-export declare const initSegment: (playerContext: PlayerContext, options: SegmentOrFragment) => void;
-export {};

package/lib/services/segmentHandlers/initSegment.js

@@ -1,10 +0,0 @@
-import { addSegmentEventListeners } from './addSegmentEventListeners';
-import { convertFragmentToSegment } from './convertFragmentToSegment';
-export const initSegment = (playerContext, options) => {
-    const { segment, fragment } = options;
-    const activeSegment = fragment ? convertFragmentToSegment(fragment) : segment;
-    if (activeSegment) {
-        playerContext.player.seek(activeSegment.inpoint);
-        addSegmentEventListeners(playerContext, activeSegment);
-    }
-};

package/lib/services/segmentHandlers/initSegment.test.d.ts

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

package/lib/services/segmentHandlers/initSegment.test.js

@@ -1,38 +0,0 @@
-import { initSegment } from './initSegment';
-import { addSegmentEventListeners } from './addSegmentEventListeners';
-import { convertFragmentToSegment } from './convertFragmentToSegment';
-import createPlayerContextMock from '../../../tests/mocks/playerContextMock';
-jest.mock('./addSegmentEventListeners');
-jest.mock('./convertFragmentToSegment');
-const createMockSegment = () => ({ inpoint: 10, outpoint: 20, duration: 10 });
-const createMockFragment = () => ({
-    sections: [{ time: 0, duration: 10, title: 'Dummy fragment' }]
-});
-describe('initSegment', () => {
-    let mockPlayerContext;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockPlayerContext = createPlayerContextMock();
-    });
-    it('should convert fragment to segment and seek to inpoint', () => {
-        const mockFragment = createMockFragment();
-        const mockSegment = createMockSegment();
-        convertFragmentToSegment.mockReturnValue(mockSegment);
-        initSegment(mockPlayerContext, { fragment: mockFragment });
-        expect(convertFragmentToSegment).toHaveBeenCalledWith(mockFragment);
-        expect(mockPlayerContext.player.seek).toHaveBeenCalledWith(mockSegment.inpoint);
-        expect(addSegmentEventListeners).toHaveBeenCalledWith(mockPlayerContext, mockSegment);
-    });
-    it('should seek to inpoint and add event listeners if segment is provided', () => {
-        const mockSegment = createMockSegment();
-        initSegment(mockPlayerContext, { segment: mockSegment });
-        expect(mockPlayerContext.player.seek).toHaveBeenCalledWith(mockSegment.inpoint);
-        expect(addSegmentEventListeners).toHaveBeenCalledWith(mockPlayerContext, mockSegment);
-    });
-    it('should do nothing if neither segment nor fragment is provided', () => {
-        initSegment(mockPlayerContext, {});
-        expect(mockPlayerContext.player.seek).not.toHaveBeenCalled();
-        expect(addSegmentEventListeners).not.toHaveBeenCalled();
-        expect(convertFragmentToSegment).not.toHaveBeenCalled();
-    });
-});

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

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

package/lib/services/segmentHandlers/isSegmentInBounds.js

@@ -1,5 +0,0 @@
-export function isSegmentInBounds(segment, duration) {
-    if (!segment)
-        return true;
-    return segment.inpoint < duration && segment.outpoint < duration;
-}

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

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

package/lib/services/segmentHandlers/isSegmentInBounds.test.js

@@ -1,27 +0,0 @@
-import { isSegmentInBounds } from './isSegmentInBounds';
-describe('isSegmentInBounds', () => {
-    const DUMMY_DURATION = 100;
-    it('returns true if segment is undefined', () => {
-        expect(isSegmentInBounds(undefined, DUMMY_DURATION)).toBe(true);
-    });
-    it('returns true if inpoint and outpoint are within duration', () => {
-        const segment = { inpoint: 10, outpoint: 50, duration: 40 };
-        expect(isSegmentInBounds(segment, DUMMY_DURATION)).toBe(true);
-    });
-    it('returns false if inpoint is greater than or equal to duration', () => {
-        const segment = { inpoint: 100, outpoint: 110, duration: 10 };
-        expect(isSegmentInBounds(segment, DUMMY_DURATION)).toBe(false);
-    });
-    it('returns false if outpoint is greater than or equal to duration', () => {
-        const segment = { inpoint: 10, outpoint: 120, duration: 110 };
-        expect(isSegmentInBounds(segment, DUMMY_DURATION)).toBe(false);
-    });
-    it('returns false if both inpoint and outpoint are greater than duration', () => {
-        const segment = { inpoint: 150, outpoint: 200, duration: 50 };
-        expect(isSegmentInBounds(segment, DUMMY_DURATION)).toBe(false);
-    });
-    it('returns false if outpoint is equal to duration', () => {
-        const segment = { inpoint: 10, outpoint: 100, duration: 90 };
-        expect(isSegmentInBounds(segment, DUMMY_DURATION)).toBe(false);
-    });
-});

package/lib/services/segmentHandlers/setSegmentMarkers.d.ts

@@ -1,2 +0,0 @@
-import { Segment, TimeLineMarker } from '../../types/interfaces';
-export declare function setSegmentMarkers(segment: Segment, title: string): Array<TimeLineMarker>;

package/lib/services/segmentHandlers/setSegmentMarkers.js

@@ -1,25 +0,0 @@
-import nlJson from '../../lang/nl.json';
-export function setSegmentMarkers(segment, title) {
-    const unplayableClass = 'seekbar-marker-unplayable';
-    const unplayableTitle = nlJson['segment.unplayableTitle'];
-    const ONE_DAY_IN_SECONDS = 86400;
-    return [
-        {
-            time: 0,
-            duration: segment.inpoint,
-            title: unplayableTitle,
-            cssClasses: [unplayableClass]
-        },
-        {
-            time: segment.inpoint,
-            duration: segment.outpoint - segment.inpoint,
-            title: title
-        },
-        {
-            time: segment.outpoint,
-            duration: ONE_DAY_IN_SECONDS,
-            title: unplayableTitle,
-            cssClasses: [unplayableClass]
-        }
-    ];
-}

package/lib/services/segmentHandlers/setSegmentMarkers.test.d.ts

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

package/lib/services/segmentHandlers/setSegmentMarkers.test.js

@@ -1,32 +0,0 @@
-import { setSegmentMarkers } from './setSegmentMarkers';
-describe('setSegmentMarkers', () => {
-    it('should create markers correctly for a given segment', () => {
-        const ONE_DAY_IN_SECONDS = 86400;
-        const segment = {
-            inpoint: 10,
-            outpoint: 50,
-            duration: 60
-        };
-        const expectedMarkers = [
-            {
-                time: 0,
-                duration: segment.inpoint,
-                title: 'Niet beschikbaar',
-                cssClasses: ['seekbar-marker-unplayable']
-            },
-            {
-                time: 10,
-                duration: segment.outpoint - segment.inpoint,
-                title: 'Test title'
-            },
-            {
-                time: segment.outpoint,
-                duration: ONE_DAY_IN_SECONDS,
-                title: 'Niet beschikbaar',
-                cssClasses: ['seekbar-marker-unplayable']
-            }
-        ];
-        const result = setSegmentMarkers(segment, 'Test title');
-        expect(result).toEqual(expectedMarkers);
-    });
-});

package/lib/services/services.d.ts

@@ -1,34 +0,0 @@
-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;
-    keyboardHandler(playerContext: PlayerContext, e: KeyboardEvent): void;
-    convertFragmentToSegment(fragment: Fragment): Segment;
-    segmentMarkersHandler(segment: Segment, title: string): Array<TimeLineMarker>;
-    decideProfile(playerContext: PlayerContext, preferredDRM?: string): Promise<Profile>;
-    verifyDRM(playerContext: PlayerContext, payload: ApiPayload): Promise<void>;
-    setStoredUserPrefs(key: LocalStorageValues, value: any): void;
-    getStoredUserPrefs(): LocalStorageData;
-    handleUserPrefs(playerContext: PlayerContext): void;
-    setAccessibilityAttributes(playerContext: PlayerContext): void;
-    schedulePreRolls(playerContext: PlayerContext): Promise<void>;
-    discardAdBreak(playerContext: PlayerContext): void;
-    handleVerticalVideoControls(playerContext: PlayerContext): void;
-    handleVerticalVideoSettings(playerContext: PlayerContext): void;
-    showNicamAfterUiDelay(playerContext: PlayerContext | undefined): void;
-    setupNicamKijkwijzerIcons(playerContext: PlayerContext): void;
-    handlePreferences(playerContext: PlayerContext): void;
-    addUivisiblityHandlers(playerContext: PlayerContext): void;
-    removeUivisiblityHandlers(playerContext: PlayerContext): void;
-    handleStreamOptions(playerContext: PlayerContext): void;
-    handleError({ playerContext, status: input, context: context }: LogErrorParams): Promise<void>;
-    fetchStream(playerContext: PlayerContext, payload: ApiPayload): Promise<StreamObject>;
-    startPlayerTracker({ playerContext, source, duration, afterAd }: 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;
-    handleBackButtons(playerContext: PlayerContext): void;
-}