@npo/player 1.22.4 → 1.23.0

package/lib/{js/playeractions/handlers → services/keyboardHandlers}/resolvekeypress.test.js

@@ -1,10 +1,11 @@
 import { resolveKeyPress } from './resolvekeypress';
-import { ViewMode } from 'bitmovin-player';
-import { mockNpoPlayer } from '../../../../tests/mocks/mockNpoplayer';
+import { mockNpoPlayer } from '../../../tests/mocks/mockNpoplayer';
+import { ViewMode } from '../../types/interfaces';
 describe('resolveKeyPress', () => {
     let mockPlayer;
-    let mockNpoplayer = mockNpoPlayer;
+    const mockNpoplayer = mockNpoPlayer;
     let e;
+    let mockPlayerContext;
     beforeEach(() => {
         jest.clearAllMocks();
         mockPlayer = {
@@ -31,50 +32,57 @@ describe('resolveKeyPress', () => {
             })
         };
         e = new KeyboardEvent('keydown');
+        mockPlayerContext = { player: mockPlayer, npoplayer: mockNpoplayer };
     });
     it('should mute/unmute the player when "KeyM" is pressed', () => {
         mockPlayer.isMuted.mockReturnValue(true);
-        resolveKeyPress(mockPlayer, mockNpoplayer, { ...e, code: 'KeyM' });
+        resolveKeyPress(mockPlayerContext, { ...e, code: 'KeyM' });
         expect(mockPlayer.unmute).toHaveBeenCalled();
     });
     it('should enter/exit fullscreen mode when "KeyF" is pressed', () => {
         mockPlayer.getViewMode.mockReturnValue(ViewMode.Inline);
-        resolveKeyPress(mockPlayer, mockNpoplayer, { ...e, code: 'KeyF' });
+        resolveKeyPress(mockPlayerContext, { ...e, code: 'KeyF' });
         expect(mockPlayer.setViewMode).toHaveBeenCalledWith(ViewMode.Fullscreen);
     });
     it('should play/pause the player when "Space" is pressed', () => {
         mockPlayer.isPaused.mockReturnValue(true);
-        resolveKeyPress(mockPlayer, mockNpoplayer, { ...e, code: 'Space' });
+        mockPlayer.play.mockImplementation(() => Promise.resolve().catch(() => {
+            console.log('Failed to play');
+        }));
+        const preventDefault = jest.fn();
+        resolveKeyPress(mockPlayerContext, { ...e, code: 'Space', preventDefault });
         expect(mockPlayer.play).toHaveBeenCalled();
     });
     it('should increase the volume when "ArrowUp" is pressed', () => {
+        const preventDefault = jest.fn();
         mockPlayer.isMuted.mockReturnValue(true);
         mockNpoplayer.increaseVolume = jest.fn();
-        resolveKeyPress(mockPlayer, mockNpoplayer, { ...e, code: 'ArrowUp' });
+        resolveKeyPress(mockPlayerContext, { ...e, code: 'ArrowUp', preventDefault });
         expect(mockPlayer.unmute).toHaveBeenCalled();
         expect(mockNpoplayer.increaseVolume).toHaveBeenCalled();
     });
     it('should decrease the volume when "ArrowDown" is pressed', () => {
+        const preventDefault = jest.fn();
         mockPlayer.isMuted.mockReturnValue(true);
         mockNpoplayer.decreaseVolume = jest.fn();
-        resolveKeyPress(mockPlayer, mockNpoplayer, { ...e, code: 'ArrowDown' });
+        resolveKeyPress(mockPlayerContext, { ...e, code: 'ArrowDown', preventDefault });
         expect(mockPlayer.unmute).toHaveBeenCalled();
         expect(mockNpoplayer.decreaseVolume).toHaveBeenCalled();
     });
     it('should go backwards when "ArrowLeft" is pressed', () => {
         mockNpoplayer.goBackwards = jest.fn();
-        resolveKeyPress(mockPlayer, mockNpoplayer, { ...e, code: 'ArrowLeft' });
+        resolveKeyPress(mockPlayerContext, { ...e, code: 'ArrowLeft' });
         expect(mockNpoplayer.goBackwards).toHaveBeenCalledWith(10);
     });
     it('should go forward when "ArrowRight" is pressed', () => {
         mockNpoplayer.goForward = jest.fn();
-        resolveKeyPress(mockPlayer, mockNpoplayer, { ...e, code: 'ArrowRight' });
+        resolveKeyPress(mockPlayerContext, { ...e, code: 'ArrowRight' });
         expect(mockNpoplayer.goForward).toHaveBeenCalledWith(10);
     });
     it('should hide the settings panel when "Escape" is pressed', () => {
-        if (mockNpoplayer.uiComponents.settingsPanel) {
-            resolveKeyPress(mockPlayer, mockNpoplayer, { ...e, code: 'Escape' });
-            expect(mockNpoplayer.uiComponents.settingsPanel.hide).toHaveBeenCalled();
+        if (mockNpoplayer.uiComponents.settingsPanels) {
+            resolveKeyPress(mockPlayerContext, { ...e, code: 'Escape' });
+            expect(mockNpoplayer.uiComponents.settingsPanels[0].hide).toHaveBeenCalled();
         }
     });
 });

package/lib/services/liveStreamHandlers/handleLiveStreamControls.d.ts

@@ -0,0 +1,6 @@
+import { PlayerContext } from 'types/interfaces';
+export declare const handleLiveStreamControls: (playerContext: PlayerContext) => void;
+export declare function updateForwardButtonState(player: any): void;
+export declare function toggleForwardButtons(forwardButtons: NodeListOf<Element>, timeShift: number): void;
+export declare function disableForwardButton(button: Element): void;
+export declare function enableForwardButton(button: Element): void;

package/lib/services/liveStreamHandlers/handleLiveStreamControls.js

@@ -0,0 +1,35 @@
+import { PlayerEvent } from 'bitmovin-player';
+export const handleLiveStreamControls = (playerContext) => {
+    const liveStreamHandleTimeChangedCallback = () => updateForwardButtonState(playerContext.player);
+    const { player, npoplayer } = playerContext;
+    player.on(PlayerEvent.TimeChanged, liveStreamHandleTimeChangedCallback);
+    npoplayer.eventListeners = {
+        liveStreamHandleTimeChangedCallback
+    };
+};
+export function updateForwardButtonState(player) {
+    const timeShift = player?.getTimeShift();
+    const forwardButtons = player?.getContainer().querySelectorAll('.bmpui-ui-forwardbutton');
+    player.off(PlayerEvent.TimeChanged, () => {
+        updateForwardButtonState(player);
+    });
+    if (forwardButtons && timeShift !== undefined) {
+        toggleForwardButtons(forwardButtons, timeShift);
+    }
+}
+export function toggleForwardButtons(forwardButtons, timeShift) {
+    for (const forwardButton of forwardButtons) {
+        if (timeShift > -10) {
+            disableForwardButton(forwardButton);
+        }
+        else {
+            enableForwardButton(forwardButton);
+        }
+    }
+}
+export function disableForwardButton(button) {
+    button.setAttribute('disabled', 'true');
+}
+export function enableForwardButton(button) {
+    button.removeAttribute('disabled');
+}

package/lib/services/localStorageHandlers/localStorageHandlers.d.ts

@@ -0,0 +1,4 @@
+import { LocalStorageData, LocalStorageValues, PlayerContext } from 'types/interfaces';
+export declare function setLocalStorage(key: LocalStorageValues, value: any): void;
+export declare function getLocalStorage(): LocalStorageData;
+export declare function setValuesBasedOnLocalStorage(playerContext: PlayerContext): void;

package/lib/services/localStorageHandlers/localStorageHandlers.js

@@ -0,0 +1,33 @@
+export function setLocalStorage(key, value) {
+    const prefixedKey = `npoplayer-${key}`;
+    localStorage.setItem(prefixedKey, JSON.stringify(value));
+}
+export function getLocalStorage() {
+    const result = {};
+    for (let i = 0; i < localStorage.length; i++) {
+        const key = localStorage.key(i);
+        if (key && key.startsWith('npoplayer-')) {
+            const item = localStorage.getItem(key);
+            if (item !== null) {
+                const originalKey = key.replace('npoplayer-', '');
+                result[originalKey] = JSON.parse(item);
+            }
+        }
+    }
+    return result;
+}
+export function setValuesBasedOnLocalStorage(playerContext) {
+    const localStorageData = getLocalStorage();
+    const player = playerContext.player;
+    if (!player) {
+        console.error('Player is undefined in playerContext');
+        return;
+    }
+    player.setVolume(localStorageData.volume ?? 100);
+    if (localStorageData.ismuted === 'true') {
+        player.mute();
+    }
+    if (localStorageData.subtitles_enabled === 'true') {
+        playerContext.npoplayer.streamOptions.enableSubtitles = true;
+    }
+}

package/lib/services/localStorageHandlers/localStorageHandlers.test.js

@@ -0,0 +1,109 @@
+import { mockNpoPlayer } from '../../../tests/mocks/mockNpoplayer';
+import { setLocalStorage, getLocalStorage, setValuesBasedOnLocalStorage } from './localStorageHandlers';
+import { LocalStorageValues } from '../../types/interfaces';
+describe('localStorageHandler', () => {
+    beforeEach(() => {
+        localStorage.clear();
+    });
+    describe('setLocalStorage', () => {
+        it('should set an item in local storage with a prefixed key', () => {
+            const key = LocalStorageValues.VOLUME;
+            const value = 50;
+            setLocalStorage(key, value);
+            const storedValue = localStorage.getItem('npoplayer-volume');
+            expect(storedValue).toEqual(JSON.stringify(value));
+        });
+    });
+    describe('getLocalStorage', () => {
+        beforeEach(() => {
+            localStorage.clear();
+        });
+        it('should retrieve all items with the npoplayer prefix from local storage and return them as an object', () => {
+            const key1 = `npoplayer-${LocalStorageValues.VOLUME}`;
+            const value1 = 50;
+            const key2 = `npoplayer-${LocalStorageValues.IS_MUTED}`;
+            const value2 = false;
+            localStorage.setItem(key1, JSON.stringify(value1));
+            localStorage.setItem(key2, JSON.stringify(value2));
+            const localStorageData = getLocalStorage();
+            expect(localStorageData).toEqual({
+                [LocalStorageValues.VOLUME]: value1,
+                [LocalStorageValues.IS_MUTED]: value2
+            });
+        });
+        it('should ignore items without the npoplayer prefix', () => {
+            const key1 = 'npoplayer-key1';
+            const value1 = { foo: 'bar1' };
+            const key2 = 'key2';
+            const value2 = { foo: 'bar2' };
+            localStorage.setItem(key1, JSON.stringify(value1));
+            localStorage.setItem(key2, JSON.stringify(value2));
+            const localStorageData = getLocalStorage();
+            expect(localStorageData).toEqual({
+                key1: value1
+            });
+        });
+    });
+    describe('setValuesBasedOnLocalStorage', () => {
+        let mockPlayerAPI;
+        let playerContext;
+        beforeEach(() => {
+            mockPlayerAPI = {
+                setVolume: jest.fn(),
+                mute: jest.fn()
+            };
+            playerContext = {
+                player: mockPlayerAPI,
+                npoplayer: {
+                    ...mockNpoPlayer,
+                    streamOptions: {
+                        enableSubtitles: false
+                    },
+                    userPreferences: {
+                        subtitles_enabled: 'false'
+                    },
+                    container: document.createElement('div'),
+                    streamObject: {},
+                    playerConfig: {},
+                    initPlayer: () => { },
+                    loadStream: () => Promise.resolve(),
+                    createUIManager: async () => { },
+                    doError: () => { },
+                    play: async () => { },
+                    pause: () => { },
+                    setVolume: () => { },
+                    increaseVolume: () => { },
+                    decreaseVolume: () => { },
+                    goForward: () => { },
+                    goBackwards: () => { },
+                    watchFromStart: () => { },
+                    showPlayNextScreen: () => { },
+                    updateMarkers: () => { },
+                    cancelPlayNextScreen: () => { },
+                    hidePlayNextScreen: () => { },
+                    doPlayNext: () => { },
+                    destroy: () => false,
+                    unload: () => {
+                        return true;
+                    },
+                    printVersion: () => { }
+                }
+            };
+        });
+        it('should set the volume based on local storage', () => {
+            localStorage.setItem('npoplayer-volume', JSON.stringify(50));
+            setValuesBasedOnLocalStorage(playerContext);
+            expect(mockPlayerAPI.setVolume).toHaveBeenCalledWith(50);
+        });
+        it('should mute the player if localStorage ismuted is true', () => {
+            localStorage.setItem('npoplayer-ismuted', JSON.stringify('true'));
+            setValuesBasedOnLocalStorage(playerContext);
+            expect(mockPlayerAPI.mute).toHaveBeenCalled();
+        });
+        it('should enable subtitles if localStorage subtitles_enabled is true', () => {
+            localStorage.setItem('npoplayer-subtitles_enabled', JSON.stringify('true'));
+            setValuesBasedOnLocalStorage(playerContext);
+            expect(playerContext.npoplayer.streamOptions.enableSubtitles).toBe(true);
+        });
+    });
+});

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

@@ -0,0 +1,30 @@
+import { PlayerAPI, PlayerEvent, PlayerEventCallback, SourceConfig, TimeMode, ViewMode } from 'bitmovin-player';
+import { Technology } from 'types/interfaces';
+export declare class NpoPlayerAPI {
+    playerAPI: PlayerAPI;
+    constructor(playerAPI: PlayerAPI);
+    load(sourceConfig: SourceConfig): Promise<void>;
+    play(): Promise<void>;
+    pause(): void;
+    mute(): void;
+    unmute(): void;
+    getVolume(): number;
+    setVolume(level: number): void;
+    setViewMode(viewMode: ViewMode): void;
+    getViewMode(): ViewMode;
+    areSubtitlesEnabled(): boolean;
+    enableSubtitles(): void;
+    isPaused(): boolean;
+    isMuted(): boolean;
+    getSupportedDRM(): Promise<string[]>;
+    getSupportedTech(): Technology[];
+    off(eventType: PlayerEvent, callback: PlayerEventCallback): void;
+    on(eventType: PlayerEvent, callback: PlayerEventCallback): void;
+    seek(time: number): void;
+    getContainer(): HTMLElement;
+    getNpoPlayerElement(): Element | null;
+    addClassToNpoPlayerElement(className: string): void | undefined;
+    removeClassFromNpoPlayerElement(className: string): void | undefined;
+    getCurrentTime(mode?: TimeMode | undefined): number;
+    getTimeShift(): number;
+}

package/lib/services/npoPlayerAPI/npoPlayerAPI.js

@@ -0,0 +1,91 @@
+export class NpoPlayerAPI {
+    constructor(playerAPI) {
+        this.playerAPI = playerAPI;
+    }
+    async load(sourceConfig) {
+        await this.playerAPI.load(sourceConfig);
+    }
+    async play() {
+        await this.playerAPI.play();
+    }
+    pause() {
+        this.playerAPI.pause();
+    }
+    mute() {
+        this.playerAPI.mute();
+    }
+    unmute() {
+        this.playerAPI.unmute();
+    }
+    getVolume() {
+        return this.playerAPI.getVolume();
+    }
+    setVolume(level) {
+        this.playerAPI.setVolume(level);
+    }
+    setViewMode(viewMode) {
+        this.playerAPI.setViewMode(viewMode);
+    }
+    getViewMode() {
+        return this.playerAPI.getViewMode();
+    }
+    areSubtitlesEnabled() {
+        let subsEnabled = false;
+        const currentSubtitleTrack = this.playerAPI.subtitles.list();
+        for (const subtitle of currentSubtitleTrack) {
+            if (subtitle.enabled) {
+                subsEnabled = true;
+                break;
+            }
+        }
+        return subsEnabled;
+    }
+    enableSubtitles() {
+        const subtitleTracks = this.playerAPI.subtitles.list();
+        for (const subtitle of subtitleTracks) {
+            if (!subtitle.enabled) {
+                this.playerAPI.subtitles.enable(subtitle.id);
+                break;
+            }
+        }
+    }
+    isPaused() {
+        return this.playerAPI.isPaused();
+    }
+    isMuted() {
+        return this.playerAPI.isMuted();
+    }
+    async getSupportedDRM() {
+        return (await this.playerAPI.getSupportedDRM());
+    }
+    getSupportedTech() {
+        return this.playerAPI.getSupportedTech();
+    }
+    off(eventType, callback) {
+        this.playerAPI.off(eventType, callback);
+    }
+    on(eventType, callback) {
+        this.playerAPI.on(eventType, callback);
+    }
+    seek(time) {
+        this.playerAPI.seek(time);
+    }
+    getContainer() {
+        return this.playerAPI.getContainer();
+    }
+    getNpoPlayerElement() {
+        return this.getContainer().querySelector('.bmpui-npo-player');
+    }
+    addClassToNpoPlayerElement(className) {
+        this.getNpoPlayerElement()?.classList.add(className);
+    }
+    removeClassFromNpoPlayerElement(className) {
+        this.getNpoPlayerElement()?.classList.remove(className);
+    }
+    getCurrentTime(mode) {
+        return this.playerAPI.getCurrentTime(mode);
+    }
+    getTimeShift() {
+        return this.playerAPI.getTimeShift();
+    }
+}

package/lib/services/npoPlayerAPI/npoPlayerAPI.test.js

@@ -0,0 +1,51 @@
+import { NpoPlayerAPI } from './npoPlayerAPI';
+describe('NpoPlayerAPI', () => {
+    let mockPlayerAPI;
+    let npoPlayerAPI;
+    beforeEach(() => {
+        mockPlayerAPI = {
+            play: jest.fn(),
+            pause: jest.fn(),
+            mute: jest.fn(),
+            unmute: jest.fn(),
+            setViewMode: jest.fn(),
+            getViewMode: jest.fn(),
+            isPaused: jest.fn(),
+            isMuted: jest.fn()
+        };
+        npoPlayerAPI = new NpoPlayerAPI(mockPlayerAPI);
+    });
+    it('should call play on the PlayerAPI', async () => {
+        await npoPlayerAPI.play();
+        expect(mockPlayerAPI.play).toHaveBeenCalled();
+    });
+    it('should call pause on the PlayerAPI', () => {
+        npoPlayerAPI.pause();
+        expect(mockPlayerAPI.pause).toHaveBeenCalled();
+    });
+    it('should call mute on the PlayerAPI', () => {
+        npoPlayerAPI.mute();
+        expect(mockPlayerAPI.mute).toHaveBeenCalled();
+    });
+    it('should call unmute on the PlayerAPI', () => {
+        npoPlayerAPI.unmute();
+        expect(mockPlayerAPI.unmute).toHaveBeenCalled();
+    });
+    it('should call setViewMode on the PlayerAPI', () => {
+        const viewMode = 'fullscreen';
+        npoPlayerAPI.setViewMode(viewMode);
+        expect(mockPlayerAPI.setViewMode).toHaveBeenCalledWith(viewMode);
+    });
+    it('should call getViewMode on the PlayerAPI', () => {
+        npoPlayerAPI.getViewMode();
+        expect(mockPlayerAPI.getViewMode).toHaveBeenCalled();
+    });
+    it('should call isPaused on the PlayerAPI', () => {
+        npoPlayerAPI.isPaused();
+        expect(mockPlayerAPI.isPaused).toHaveBeenCalled();
+    });
+    it('should call isMuted on the PlayerAPI', () => {
+        npoPlayerAPI.isMuted();
+        expect(mockPlayerAPI.isMuted).toHaveBeenCalled();
+    });
+});

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

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

package/lib/services/segmentHandlers/addSegmentEventListeners.js

@@ -0,0 +1,14 @@
+import { PlayerEvent } from 'bitmovin-player';
+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(PlayerEvent.TimeChanged, segmentHandleTimeChangedCallback);
+    player.on(PlayerEvent.Seek, segmentSeekFunctionCallback);
+    npoplayer.eventListeners = {
+        segmentHandleTimeChangedCallback,
+        segmentSeekFunctionCallback
+    };
+};

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

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

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

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

package/lib/services/segmentHandlers/convertFragmentToSegment.js

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

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

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

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

@@ -0,0 +1,15 @@
+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.js

@@ -0,0 +1,73 @@
+import { handleSegmentSeek, getSeekTarget, isSeekOutsideSegment, clampSeekTarget } from './handleSegmentSeek';
+import { mockPlayerContext } from '../../../tests/mocks/mockPlayerContext';
+describe('segmentHandler', () => {
+    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;
+    beforeEach(() => {
+        segment = {
+            inpoint: SEGMENT_INPOINT,
+            outpoint: SEGMENT_OUTPOINT,
+            duration: SEGMENT_DURATION
+        };
+    });
+    afterEach(() => {
+        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

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