@npo/player 1.24.7 → 1.26.0

package/lib/services/nicamHandlers/nicamhandler.test.js

@@ -0,0 +1,132 @@
+import { processNicam, showNicamAfterUiDelay } from './nicamhandler';
+import '@testing-library/jest-dom';
+import { createMockNpoPlayer, createPlayerContextMock } from '../../../tests/mocks/playerContextMock';
+import { NpoPlayerEvent } from '../../types/events';
+describe('NICAM Processing', () => {
+    let mockElement;
+    beforeEach(() => {
+        mockElement = { innerHTML: '', appendChild: jest.fn() };
+        document.querySelector = jest.fn().mockReturnValue(mockElement);
+    });
+    it('processes NICAM from the streamObject', () => {
+        const mockElement = document.createElement('div');
+        const npoPlayerMock = createMockNpoPlayer({
+            streamObject: {
+                metadata: {
+                    ageRating: '12',
+                    nicam: ['GEWELD', 'ANGST', 'DRUGS_EN_ALCOHOL', 'GROF_TAALGEBRUIK']
+                }
+            }
+        });
+        const playerContextMock = createPlayerContextMock({
+            npoPlayer: npoPlayerMock
+        });
+        processNicam(playerContextMock, mockElement);
+        expect(mockElement.children).toHaveLength(5);
+    });
+    it('processes NICAM and age rating with streamOptions taking priority', () => {
+        const mockElement = document.createElement('div');
+        const npoPlayerMock = createMockNpoPlayer({
+            streamObject: {
+                metadata: {
+                    ageRating: '12',
+                    nicam: ['GEWELD', 'ANGST', 'GROF_TAALGEBRUIK']
+                }
+            },
+            streamOptions: {
+                ageRating: '16',
+                nicam: ['DRUGS_EN_ALCOHOL']
+            }
+        });
+        const playerContextMock = createPlayerContextMock({
+            npoPlayer: npoPlayerMock
+        });
+        processNicam(playerContextMock, mockElement);
+        expect(mockElement.children).toHaveLength(2);
+    });
+    it('does nothing if no NICAM element found', () => {
+        document.querySelector = jest.fn().mockReturnValue(undefined);
+        const npoPlayerMock = createMockNpoPlayer({
+            streamObject: {
+                metadata: {
+                    ageRating: '12',
+                    nicam: ['GEWELD', 'ANGST', 'GROF_TAALGEBRUIK']
+                }
+            }
+        });
+        const playerContextMock = createPlayerContextMock({
+            npoPlayer: npoPlayerMock
+        });
+        processNicam(playerContextMock, mockElement);
+    });
+    it('does nothing if no metadata and no streamOptions', () => {
+        const npoPlayerMock = createMockNpoPlayer({});
+        const playerContextMock = createPlayerContextMock({
+            npoPlayer: npoPlayerMock
+        });
+        processNicam(playerContextMock, mockElement);
+        expect(mockElement.appendChild).not.toHaveBeenCalled();
+    });
+});
+describe('NICAM Visibility Management', () => {
+    let mockPlayerContext;
+    let mockContainer;
+    let mockPlayer;
+    let mockUiManager;
+    beforeEach(() => {
+        mockContainer = document.createElement('div');
+        mockPlayer = {
+            getNpoPlayerElement: jest.fn().mockReturnValue(mockContainer),
+            off: jest.fn()
+        };
+        mockUiManager = {
+            activeUi: {
+                onControlsHide: {
+                    subscribe: jest.fn(),
+                    unsubscribe: jest.fn()
+                },
+                onControlsShow: {
+                    subscribe: jest.fn(),
+                    unsubscribe: jest.fn()
+                }
+            }
+        };
+        mockPlayerContext = createPlayerContextMock({
+            player: mockPlayer,
+            npoPlayer: {
+                uiManager: mockUiManager,
+                container: mockContainer
+            }
+        });
+    });
+    describe('showNicamAfterUiDelay', () => {
+        it('should add showNicam class when controls are hidden', () => {
+            jest.useFakeTimers();
+            const showNicamClass = 'bmpui-show-nicam';
+            showNicamAfterUiDelay(mockPlayerContext);
+            mockUiManager.activeUi.onControlsHide.subscribe.mock.calls[0][0]();
+            expect(mockContainer).toHaveClass(showNicamClass);
+            jest.advanceTimersByTime(3000);
+            expect(mockContainer).not.toHaveClass(showNicamClass);
+            jest.useRealTimers();
+        });
+        it('should remove showNicam class when controls are shown', () => {
+            showNicamAfterUiDelay(mockPlayerContext);
+            const showNicamClass = 'bmpui-show-nicam';
+            mockUiManager.activeUi.onControlsHide.subscribe.mock.calls[0][0]();
+            expect(mockContainer).toHaveClass(showNicamClass);
+            mockUiManager.activeUi.onControlsShow.subscribe.mock.calls[0][0]();
+            expect(mockContainer).not.toHaveClass(showNicamClass);
+        });
+        it('should not execute if player container or uiManager is undefined', () => {
+            mockPlayerContext.npoPlayer.uiManager = undefined;
+            showNicamAfterUiDelay(mockPlayerContext);
+            expect(mockUiManager.activeUi.onControlsHide.subscribe).not.toHaveBeenCalled();
+            expect(mockUiManager.activeUi.onControlsShow.subscribe).not.toHaveBeenCalled();
+        });
+        it('should clean up event listeners when the player is ready', () => {
+            showNicamAfterUiDelay(mockPlayerContext);
+            expect(mockPlayer.off).toHaveBeenCalledWith(NpoPlayerEvent.Ready, expect.any(Function));
+        });
+    });
+});

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

@@ -17,7 +17,8 @@ export declare class NpoPlayerAPI {
     setViewMode(viewMode: ViewMode): void;
     getViewMode(): ViewMode;
     areSubtitlesEnabled(): boolean;
-    enableSubtitles(): void;
+    getCurrentSubtitle(): string | undefined;
+    enableSubtitles(selectedLang?: string): void;
     isPaused(): boolean;
     isMuted(): boolean;
     isLive(): boolean;
@@ -25,6 +26,7 @@ export declare class NpoPlayerAPI {
     getSupportedTech(): Technology[];
     off(eventType: NpoPlayerEvent, callback: NpoPlayerEventCallback): void;
     on(eventType: NpoPlayerEvent, callback: NpoPlayerEventCallback): void;
+    isCastAvailable(): boolean;
     seek(time: number): void;
     timeShift(time: number): void;
     getContainer(): HTMLElement;
@@ -37,7 +39,6 @@ export declare class NpoPlayerAPI {
     getTimeShift(): number;
     scheduleAds(adConfig: AdConfig): Promise<AdBreak[]>;
     getActiveAdBreak(): AdBreak | null;
-    discardAdBreak(adBreakId: string): void;
     getConfig(mergedConfig?: boolean): PlayerConfig;
     createUIManager(playerContext: PlayerContext, variant: NpoPlayerUIVariants): Promise<void | UIManager>;
 }

package/lib/services/npoPlayerAPI/npoPlayerAPI.js

@@ -1,6 +1,5 @@
 import { UIManager } from 'bitmovin-player-ui';
 import { customSpecificErrorMessageOverlayConfig } from '../../js/playeractions/handlers/customerrors';
-import { processStream } from '../../ui/handlers/streamhandler';
 import { createUIContainer } from '../../ui/uicontainer';
 import { playerEventMap } from '../../types/events';
 import { VOLUME_MAX, VOLUME_MIN, VOLUME_STEP } from './contants';
@@ -46,23 +45,17 @@ export class NpoPlayerAPI {
         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;
+        return this.playerAPI.subtitles.list().some((subtitle) => subtitle.enabled);
+    }
+    getCurrentSubtitle() {
+        const currentSubtitle = this.playerAPI.subtitles.list().find((subtitle) => subtitle.enabled);
+        return currentSubtitle ? currentSubtitle.lang : undefined;
     }
-    enableSubtitles() {
+    enableSubtitles(selectedLang = 'nl') {
         const subtitleTracks = this.playerAPI.subtitles.list();
-        for (const subtitle of subtitleTracks) {
-            if (!subtitle.enabled) {
-                this.playerAPI.subtitles.enable(subtitle.id);
-                break;
-            }
+        const subtitleToEnable = subtitleTracks.find((subtitle) => subtitle.lang === selectedLang);
+        if (subtitleToEnable && !subtitleToEnable.enabled) {
+            this.playerAPI.subtitles.enable(subtitleToEnable.id);
         }
     }
     isPaused() {
@@ -99,6 +92,9 @@ export class NpoPlayerAPI {
         }
         this.playerAPI.on(externalEventType, externalCallback);
     }
+    isCastAvailable() {
+        return this.playerAPI.isCastAvailable();
+    }
     seek(time) {
         this.playerAPI.seek(time);
     }
@@ -135,22 +131,22 @@ export class NpoPlayerAPI {
     getActiveAdBreak() {
         return this.playerAPI.ads.getActiveAdBreak();
     }
-    discardAdBreak(adBreakId) {
-        return this.playerAPI.ads.discardAdBreak(adBreakId);
-    }
     getConfig(mergedConfig) {
         return this.playerAPI.getConfig(mergedConfig);
     }
     async createUIManager(playerContext, variant) {
-        if (playerContext.npoplayer.uiManager === undefined || variant !== playerContext.npoplayer.variant) {
+        const { npoPlayerServices } = playerContext.npoPlayer;
+        npoPlayerServices.removeUivisiblityHandlers(playerContext);
+        if (playerContext.npoPlayer.uiManager === undefined || variant !== playerContext.npoPlayer.variant) {
             const uiConfig = {
                 errorMessages: customSpecificErrorMessageOverlayConfig,
                 disableAutoHideWhenHovered: true,
                 seekbarSnappingEnabled: false
             };
-            playerContext.npoplayer.uiManager = new UIManager(this.playerAPI, createUIContainer(playerContext.npoplayer, this.playerAPI, variant, playerContext.npoplayer.container), uiConfig);
-            playerContext.npoplayer.variant = variant;
+            playerContext.npoPlayer.variant = variant;
+            const uiManager = new UIManager(this.playerAPI, createUIContainer(playerContext, this.playerAPI, variant), uiConfig);
+            playerContext.npoPlayer.uiManager = uiManager;
+            npoPlayerServices.addUivisiblityHandlers(playerContext);
         }
-        processStream(playerContext);
     }
 }

package/lib/services/preferences/handlePreferences.d.ts

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

package/lib/services/preferences/handlePreferences.js

@@ -0,0 +1,42 @@
+import { NpoPlayerEvent } from '../../types/events';
+import { LocalStorageValues } from '../../types/interfaces';
+export function handlePreferences(playerContext) {
+    const { player, npoPlayer } = playerContext;
+    const { npoPlayerServices } = npoPlayer;
+    const handleSourceLoaded = () => {
+        const storedUserPrefs = npoPlayerServices.getStoredUserPrefs();
+        const subtitlesEnabledInPrefs = storedUserPrefs?.subtitles_enabled === 'true';
+        const preferredSubtitleLang = storedUserPrefs?.subtitles_language?.toString();
+        const shouldEnableSubtitles = npoPlayer.streamOptions.enableSubtitles || subtitlesEnabledInPrefs;
+        if (shouldEnableSubtitles) {
+            player.enableSubtitles(preferredSubtitleLang);
+        }
+    };
+    const handleSubtitleEnabled = () => {
+        const currentSubtitleTrack = player.playerAPI.subtitles.list();
+        const enabledSubtitle = currentSubtitleTrack.find((subtitle) => subtitle.enabled);
+        if (enabledSubtitle) {
+            npoPlayerServices.setStoredUserPrefs(LocalStorageValues.SUBTITLES_LANGUAGE, enabledSubtitle.lang);
+            npoPlayerServices.setStoredUserPrefs(LocalStorageValues.SUBTITLES_ENABLED, 'true');
+        }
+    };
+    const handleSubtitleDisabled = () => {
+        npoPlayerServices.setStoredUserPrefs(LocalStorageValues.SUBTITLES_ENABLED, 'false');
+    };
+    const handleVolumeChanged = () => {
+        const volume = player.getVolume();
+        npoPlayerServices.setStoredUserPrefs(LocalStorageValues.VOLUME, volume);
+    };
+    const handleMuted = () => {
+        npoPlayerServices.setStoredUserPrefs(LocalStorageValues.IS_MUTED, 'true');
+    };
+    const handleUnmuted = () => {
+        npoPlayerServices.setStoredUserPrefs(LocalStorageValues.IS_MUTED, 'false');
+    };
+    player.on(NpoPlayerEvent.SourceLoaded, handleSourceLoaded);
+    player.on(NpoPlayerEvent.SubtitleEnabled, handleSubtitleEnabled);
+    player.on(NpoPlayerEvent.SubtitleDisabled, handleSubtitleDisabled);
+    player.on(NpoPlayerEvent.VolumeChanged, handleVolumeChanged);
+    player.on(NpoPlayerEvent.Muted, handleMuted);
+    player.on(NpoPlayerEvent.Unmuted, handleUnmuted);
+}

package/lib/services/preferences/handlePreferences.test.d.ts

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

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

@@ -0,0 +1,102 @@
+import createPlayerContextMock, { createMockNpoPlayer, createMockNpoPlayerAPI } from '../../../tests/mocks/playerContextMock';
+import { handlePreferences } from './handlePreferences';
+import { NpoPlayerEvent } from '../../types/events';
+import { LocalStorageValues } from '../../types/interfaces';
+describe('handlePreferences', () => {
+    let mockPlayerAPI;
+    let mockNpoPlayer;
+    beforeEach(() => {
+        mockPlayerAPI = createMockNpoPlayerAPI({
+            getVolume: jest.fn().mockReturnValue(50),
+            on: jest.fn(),
+            enableSubtitles: jest.fn(),
+            playerAPI: {
+                subtitles: {
+                    list: jest.fn()
+                }
+            }
+        });
+        mockNpoPlayer = createMockNpoPlayer({
+            streamOptions: {
+                enableSubtitles: false
+            },
+            npoPlayerServices: {
+                getStoredUserPrefs: jest.fn().mockReturnValue({
+                    subtitles_enabled: 'false',
+                    subtitles_language: 'nl'
+                }),
+                setStoredUserPrefs: jest.fn()
+            }
+        });
+        const playerContextMock = createPlayerContextMock({
+            player: mockPlayerAPI,
+            npoPlayer: mockNpoPlayer
+        });
+        handlePreferences(playerContextMock);
+    });
+    test('should enable subtitles if streamOptions.enableSubtitles is true', () => {
+        mockNpoPlayer.streamOptions.enableSubtitles = true;
+        for (const [event, callback] of mockPlayerAPI.on.mock.calls) {
+            if (event === NpoPlayerEvent.SourceLoaded) {
+                callback(NpoPlayerEvent.SourceLoaded);
+            }
+        }
+        expect(mockPlayerAPI.enableSubtitles).toHaveBeenCalledWith('nl');
+    });
+    test('should enable subtitles if subtitles_enabled in preferences is true', () => {
+        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.SourceLoaded) {
+                callback(NpoPlayerEvent.SourceLoaded);
+            }
+        }
+        expect(mockPlayerAPI.enableSubtitles).toHaveBeenCalledWith('nl');
+    });
+    test('should disable subtitles and set the preferences', () => {
+        ;
+        mockPlayerAPI.playerAPI.subtitles.list.mockReturnValueOnce([{ lang: 'nl', enabled: true }]);
+        for (const [event, callback] of mockPlayerAPI.on.mock.calls) {
+            if (event === NpoPlayerEvent.SubtitleEnabled) {
+                callback(NpoPlayerEvent.SubtitleEnable);
+            }
+        }
+        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);
+            }
+        }
+        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);
+            }
+        }
+        expect(mockNpoPlayer.npoPlayerServices.setStoredUserPrefs).toHaveBeenCalledWith(LocalStorageValues.VOLUME, 50);
+    });
+    test('should set muted preferences', () => {
+        for (const [event, callback] of mockPlayerAPI.on.mock.calls) {
+            if (event === NpoPlayerEvent.Muted) {
+                callback(NpoPlayerEvent.Muted);
+            }
+        }
+        expect(mockNpoPlayer.npoPlayerServices.setStoredUserPrefs).toHaveBeenCalledWith(LocalStorageValues.IS_MUTED, 'true');
+    });
+    test('should set unmuted preferences', () => {
+        for (const [event, callback] of mockPlayerAPI.on.mock.calls) {
+            if (event === NpoPlayerEvent.Unmuted) {
+                callback(NpoPlayerEvent.Unmuted);
+            }
+        }
+        expect(mockNpoPlayer.npoPlayerServices.setStoredUserPrefs).toHaveBeenCalledWith(LocalStorageValues.IS_MUTED, 'false');
+    });
+});

package/lib/services/segmentHandlers/addSegmentEventListeners.js

@@ -4,10 +4,10 @@ import { handleSegmentSeek } from './handleSegmentSeek';
 export const addSegmentEventListeners = (playerContext, segment) => {
     const segmentHandleTimeChangedCallback = handleSegmentTimeChanged(playerContext, segment);
     const segmentSeekFunctionCallback = handleSegmentSeek(playerContext, segment);
-    const { player, npoplayer } = playerContext;
+    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.js

@@ -36,7 +36,7 @@ describe('addSegmentEventListeners', () => {
         handleSegmentTimeChanged.mockReturnValue(segmentHandleTimeChangedCallback);
         handleSegmentSeek.mockReturnValue(segmentSeekFunctionCallback);
         addSegmentEventListeners(mockPlayerContext, segment);
-        expect(mockPlayerContext.npoplayer.eventListeners).toEqual({
+        expect(mockPlayerContext.npoPlayer.eventListeners).toEqual({
             segmentHandleTimeChangedCallback,
             segmentSeekFunctionCallback
         });

package/lib/services/segmentHandlers/setSegmentMarkers.js

@@ -1,4 +1,4 @@
-import * as nlJson from '../../lang/nl.json';
+import nlJson from '../../lang/nl.json';
 export function setSegmentMarkers(segment, title) {
     const unplayableClass = 'seekbar-marker-unplayable';
     const unplayableTitle = nlJson['segment.unplayableTitle'];

package/lib/services/services.d.ts

@@ -12,5 +12,12 @@ export declare class NpoPlayerServices {
     handleUserPrefs(playerContext: PlayerContext): void;
     setAccessibilityAttributes(playerContext: PlayerContext): void;
     schedulePreRolls(playerContext: PlayerContext): Promise<void>;
+    discardAdBreak(playerContext: PlayerContext): void;
     handleVerticalVideoControls(playerContext: PlayerContext, variant: NpoPlayerUIVariants): 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;
 }

package/lib/services/services.js

@@ -7,6 +7,11 @@ import { getLocalStorage, setLocalStorage, setValuesBasedOnLocalStorage } from '
 import { getAVType } from './avTypeHandlers/getAVType';
 import { handlePreRolls } from './advertHandlers/handlePreRolls';
 import { handleVerticalVideoControls } from './verticalVideoHandlers/handleVerticalVideoControls';
+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';
 export class NpoPlayerServices {
     getAVType(avType) {
         return getAVType(avType);
@@ -49,7 +54,28 @@ export class NpoPlayerServices {
     async schedulePreRolls(playerContext) {
         await handlePreRolls(playerContext);
     }
+    discardAdBreak(playerContext) {
+        discardAdBreak(playerContext);
+    }
     handleVerticalVideoControls(playerContext, variant) {
         return handleVerticalVideoControls(playerContext, variant);
     }
+    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);
+    }
 }

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

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

@@ -0,0 +1,78 @@
+import * as playerAction from '../../js/playeractions/playeractions';
+import { initSegment } from '../segmentHandlers/initSegment';
+import { handleLiveStreamControls } from '../liveStreamHandlers/handleLiveStreamControls';
+import { removeEventListeners } from '../eventListenerHandlers/removeEventListeners';
+import { NpoPlayerEvent } from '../../types/events';
+import { updateClassFromElementByQuery } from '../../js/utilities/utilities.element';
+export function handleStreamOptions(playerContext) {
+    const { streamObject, uiManager } = playerContext.npoPlayer;
+    if (!streamObject || !uiManager)
+        return;
+    removeEventListeners(playerContext);
+    initializeFragment(playerContext);
+    handleStartOffset(playerContext);
+    updateStreamClasses(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 { streamObject, container } = playerContext.npoPlayer;
+    const containerClassString = '.bmpui-ui-uicontainer';
+    const playerContainer = container;
+    const queries = [
+        {
+            container: playerContainer,
+            query: containerClassString,
+            className: 'livestream-no-dvr',
+            condition: !!(streamObject.stream.isLiveStream && !streamObject.stream.hasDvrWindow)
+        },
+        {
+            container: playerContainer,
+            query: containerClassString,
+            className: 'audio-only',
+            condition: !!(streamObject.stream.avType === 'aod' || streamObject.stream.avType === 'audio')
+        },
+        {
+            container: playerContainer,
+            query: '.bitmovinplayer-poster',
+            className: 'audio-only',
+            condition: !!(streamObject.stream.avType === 'aod' || streamObject.stream.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);
+        await player.play();
+    };
+    player.on(NpoPlayerEvent.Ready, handleAutoPlay);
+}