@vkontakte/videoplayer 1.1.37-dev.aaebf6d2.0 → 1.1.38-beta.0

package/types/types/index.d.ts

@@ -0,0 +1,467 @@
+import type { VideoQuality, VideoFormat, ISources, IExternalTextTrack } from '@vkontakte/videoplayer-core';
+import type { IValueObservable, InterfaceLanguage, Subscription } from '@vkontakte/videoplayer-shared';
+import type { Manifest, VideoInfo } from '@vkontakte/videoplayer-interactive';
+import { PlaybackState } from '@vkontakte/videoplayer-core';
+import type { Writable, Readable } from 'svelte/store';
+import type { ISDKConfig } from '../config';
+import type { IStore } from '../store';
+import { Controls, GridTypes, type SeekToInteractiveDisabledTooltipKey } from '../constans';
+import type { Key } from '../translation/types';
+import type { IUIStatistics } from '../services/statistics';
+import { UISentry } from '../services/sentry';
+export declare const enum AdditionalVideoQuality {
+    AUTO = "auto"
+}
+export type VideoQualityUI = VideoQuality | AdditionalVideoQuality;
+export interface IVKVideoPlayerCallbacks {
+    onInited?: () => void;
+    onStarted?: () => void;
+    onEnded?: () => void;
+    onPlay?: () => void;
+    onPause?: () => void;
+    onVolumeChange?: (volume: number) => void;
+    onFullscreenEnter?: () => void;
+    onFullscreenExit?: () => void;
+    onMute?: () => void;
+    onUnmute?: () => void;
+    onAudioDisabledHint?: () => void;
+    onAudioDoesNotExistHint?: () => void;
+    onEpisodeClicked?: (byKeyboard: boolean) => void;
+    onEpisodeChanged?: (episode: IVideoEpisode) => void;
+    onTimeupdate?: (duration: number, position: number) => void;
+    onSeek?: (from: number, to: number) => void;
+    onCrashed?: () => void;
+    onCurrentFormatChanged?: (currentFormat: VideoFormat | undefined) => void;
+    onThroughputEstimationChanged?: (throughputEstimation: number | undefined) => void;
+    onVideoBitrateChanged?: (videoBitrate: number | undefined) => void;
+    onPlayerPhaseChanged?: (value?: PlayerPhase) => void;
+    onPlaybackStateChanged?: (value?: PlaybackState) => void;
+    onIsLiveChanged?: (value?: boolean) => void;
+    onIsActiveLiveChanged?: (value?: boolean) => void;
+    onIsAudioAvailableChanged?: (value?: boolean) => void;
+    onCopyVideoLink?: (withTimestamp: boolean, currentTimestamp: number) => string;
+    onOpenHotKeyMap?: (mapData: HotKeyMapData) => void;
+    onCurrentQualityChanged?: (currentQuality: VideoQuality | undefined) => void;
+    onAvailableQualitiesChanged?: (availableQualities: VideoQuality[]) => void;
+    onPiPEnter?: () => void;
+    onPiPExit?: () => void;
+    onLiveTime?: (liveTime: number | undefined) => void;
+    onReplayInteractiveVideo?: () => void;
+    onInteractiveHistoryChanged?: (chapterIds: string[]) => void;
+    onDisabledInteractiveClick?: () => void;
+    onDisabledPlayPrevChapterClick?: (message: string | undefined) => void;
+    onDisabledSeekToInteractiveClick?: (message: string | undefined) => void;
+    onInteractiveTimeIndicatorClick?: () => void;
+    onInteractiveTimeIndicatorHintDeactivated?: () => void;
+    onPrevVideoClick?: () => boolean;
+    onNextVideoClick?: () => boolean;
+    onTrafficSavingEnabledChanged?: (isEnabled: boolean) => void;
+    onCurrentPlaybackRateChanged?: (rate: number) => void;
+    onStalledChanged?: (isStalled: boolean) => void;
+    onLogoClicked?: () => void;
+    uiInfo?: {
+        onControlsVisibleChanged?: (value?: boolean) => void;
+        onIsMobileChanged?: (value?: boolean) => void;
+        onPrevButtonChanged?: (value?: IControlInfo) => void;
+        onPlayButtonChanged?: (value?: IControlInfo) => void;
+        onReplayButtonChanged?: (value?: IControlInfo) => void;
+        onNextButtonChanged?: (value?: IControlInfo) => void;
+        onPlayPrevChapterChanged?: (value?: IControlInfo) => void;
+        onSeekToInteractiveButtonChanged?: (value?: IControlInfo) => void;
+        onGraphButtonChanged?: (value?: IControlInfo) => void;
+        onLiveButtonChanged?: (value?: IControlInfo) => void;
+        onTimeUpdateChanged?: (value?: IControlInfo) => void;
+        onEpisodesChanged?: (value?: IControlInfo) => void;
+        onVolumeChanged?: (value?: IControlInfo) => void;
+        onSubtitlesChanged?: (value?: IControlInfo) => void;
+        onSettingsChanged?: (value?: IControlInfo) => void;
+        onFullscreenChanged?: (value?: IControlInfo) => void;
+        onChromecastChanged?: (value?: IControlInfo) => void;
+        onPipChanged?: (value?: IControlInfo) => void;
+        onVkLogoChanged?: (value?: IControlInfo) => void;
+        onInteractiveTimeIndicatorChanged?: (value?: IControlInfo) => void;
+        onPlayerSizeChanged?: (value?: {
+            width: number;
+            height: number;
+        }) => void;
+    };
+    adsInfo?: {
+        onStarted?: () => void;
+        onCompleted?: () => void;
+    };
+}
+export interface IVKVideoPlayerUICallbacks {
+    onStarted?: (isMuted: boolean) => void;
+}
+export interface IVKVideoPlayerStatistics extends Partial<IUIStatistics> {
+    config: ISDKConfig['statistics'];
+}
+export interface IVKVideoPlayerSentry extends Partial<UISentry> {
+    config: ISDKConfig['ui']['sentry'];
+}
+export type AdsParams = Record<string, unknown>;
+export interface IVideoEpisodesNormalizedTimeline {
+    from: number;
+    width: number;
+    loadedWidth: number;
+    filledWidth: number;
+    interactive?: boolean;
+    completed?: boolean;
+}
+export interface IVideoEpisode {
+    time: number;
+    text: string;
+    interactive?: boolean;
+    completed?: boolean;
+}
+export interface ITimelinePreviewThumbsData {
+    countPerImage: number;
+    countPerRow: number;
+    countTotal: number;
+    frameHeight: number;
+    frameWidth: number;
+    frequency: number;
+    isUV: boolean;
+    links: string[];
+}
+export interface IVideoLive {
+    status: 'started' | 'upcoming' | 'waiting' | 'finished' | 'postlive' | 'failed';
+    startTime?: number;
+}
+export interface IVideoDataBase {
+    title: string;
+    thumbUrl?: string;
+    unitedVideoId?: number;
+    duration: number;
+    adsParams?: AdsParams;
+    videoEpisodes?: IVideoEpisode[];
+    previewThumbsData?: ITimelinePreviewThumbsData;
+    isClip?: boolean;
+    subtitles?: Array<Omit<IExternalTextTrack, 'type'>>;
+}
+export interface IVideoDataWithSources extends IVideoDataBase {
+    sources: ISources;
+    live?: never;
+}
+export interface IVideoDataWithLive extends IVideoDataBase {
+    live: IVideoLive;
+    sources?: never;
+}
+export type IVideoData = IVideoDataWithSources | IVideoDataWithLive;
+export interface IInteractiveData {
+    manifest: string | Manifest;
+    initChapterId?: string;
+    visitedChapters?: string[];
+    videosInfo?: VideoInfo[];
+    videoLoader?: (owner_id: string, video_id: string) => Promise<IVKVideoPlayerConfig>;
+    historyApi: {
+        get: (videoId: string) => Promise<number[]>;
+        save: (videoId: string, videoIds: number[]) => Promise<void>;
+    };
+    projectInfo?: {
+        pid: string;
+        title: string;
+        videoId: string;
+        variantPayloadType: string;
+    };
+    tooltipHelpHintActive?: boolean;
+}
+export interface AdditionalButton {
+    iconUrl: string;
+    onClick?: (event?: MouseEvent) => void;
+    tooltip?: string;
+    ariaLabel?: string;
+    testId?: string;
+    hideOnDesktopGridTypes?: GridTypes[];
+    hideOnMobile?: boolean;
+}
+export interface IVKVideoPlayerConfig {
+    videos: IVideoData[];
+    interactiveData?: IInteractiveData;
+    albumId?: string;
+    statPlace?: 'embed' | 'direct' | string;
+    statAuthToken?: string;
+    statUserSalt?: string;
+    statTrackCode?: string;
+    refreshStatAuthToken?: () => Promise<string | undefined>;
+    preload?: boolean;
+    autoplay?: boolean;
+    repeat?: boolean;
+    volume?: number;
+    muted?: boolean;
+    fromTime?: number;
+    canRewindLive?: boolean;
+    supportLink?: string;
+    showAds?: boolean;
+    adsSlotId?: number;
+    adsParams?: AdsParams;
+    adsPreviewParam?: number;
+    interfaceLanguage?: InterfaceLanguage | string;
+    logoClickable?: boolean;
+    logoHidden?: boolean;
+    isMobile?: boolean;
+    /** @deprecated */
+    isMediaSessionEnabled?: boolean;
+    /** @deprecated */
+    isPictureInPictureEnabled?: boolean;
+    isAudioDisabled?: boolean;
+    isLiveCatchUpMode?: boolean;
+    canDownload?: boolean;
+    fullScreenTarget?: HTMLElement;
+    failoverHosts?: string[];
+    showThumbTimer?: boolean;
+    is3DVideo?: boolean;
+    callbacks?: IVKVideoPlayerCallbacks;
+    additionalButtons?: AdditionalButton[];
+    refDomain?: string;
+    volumeMultiplier?: number;
+    saveRate?: boolean;
+}
+export interface IControlInfo {
+    /** @deprecated Используйте новое поле left */
+    positionStartX: number;
+    /** @deprecated Используйте новое поле right */
+    positionEndX: number;
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+    isDisplayed: boolean;
+}
+export interface IPlayerControlsRef {
+    prevButton?: HTMLElement;
+    playButton?: HTMLElement;
+    replayButton?: HTMLElement;
+    nextButton?: HTMLElement;
+    playPrevChapterButton?: HTMLElement;
+    seekToInteractiveButton?: HTMLElement;
+    interactiveGraphButton?: HTMLElement;
+    liveButton?: HTMLElement;
+    time?: HTMLElement;
+    episodes?: HTMLElement;
+    volume?: HTMLElement;
+    subtitles?: HTMLElement;
+    settings?: HTMLElement;
+    context?: HTMLElement;
+    fullscreen?: HTMLElement;
+    chromecast?: HTMLElement;
+    pip?: HTMLElement;
+    vkLogo?: HTMLElement;
+    interactiveTimeIndicator?: HTMLElement;
+}
+export interface IPlayerDesktopControlsWidth {
+    prevButton: number;
+    playButton: number;
+    replayButton: number;
+    nextButton: number;
+    playPrevChapterButton: number;
+    seekToInteractiveButton: number;
+    interactiveGraphButton: number;
+    liveButton: number;
+    time: number;
+    episodes: number;
+    volume: number;
+    subtitles: number;
+    settings: number;
+    context: number;
+    fullscreen: number;
+    chromecast: number;
+    vkLogo: number;
+    additionalButtons: number[];
+}
+export declare const enum PlayerPhase {
+    Thumb = "thumb",
+    Video = "video",
+    Ads = "ads",
+    Crashed = "crashed",
+    WaitingLive = "waitingLive",
+    WaitingRecord = "waitingRecord"
+}
+export declare const enum AdsSection {
+    Preroll = "preroll",
+    Midroll = "midroll",
+    Postroll = "postroll"
+}
+export declare const enum AdsPlaybackState {
+    INACTIVE = "inactive",
+    PLAYING = "playing",
+    PAUSED = "paused"
+}
+export type VideoQualityForRender = {
+    value: VideoQualityUI;
+    displayValue: string;
+    selected: boolean;
+};
+export type VideoPlaybackRate = {
+    value: number;
+    displayValue: string;
+    selected: boolean;
+};
+export type MediaSessionApiMetadata = {
+    title: string;
+    artist?: string;
+    thumbUrl?: string;
+};
+export type MediaSessionApiActionHandler = [MediaSessionAction, MediaSessionActionHandler];
+export interface PictureInPictureResizeEvent extends Event {
+    target: PictureInPictureWindow;
+}
+export interface DocumentPictureInPictureRequestWindow {
+    width?: number;
+    height?: number;
+    initialAspectRatio?: number;
+    copyStyleSheets: boolean;
+}
+export interface DocumentPictureInPicture {
+    onenter?: (event: Event) => void;
+    window: Window;
+    requestWindow: (params: DocumentPictureInPictureRequestWindow) => Promise<Window>;
+}
+export declare enum PictureInPictureType {
+    PictureInPicture = 0,
+    DocumentPictureInPicture = 1
+}
+export interface IPictureInPictureApiInfo {
+    isActive$: IValueObservable<boolean>;
+    type: PictureInPictureType;
+}
+export interface IPictureInPictureApi {
+    isSupported: () => boolean;
+    isActive: () => boolean;
+    setContext: (svelteContext: Map<unknown, unknown>) => void;
+    request: () => Promise<void>;
+    remove: () => Promise<void>;
+    info: IPictureInPictureApiInfo;
+    dispose: () => Promise<void>;
+}
+export interface IAnnotationsApi {
+    /** @deprecated Больше не используется. Контейнер теперь определяется самостоятельно */
+    registryRootContainer: (container: HTMLElement) => void;
+    /** @deprecated Логики со слоями больше нет. Теперь все аннотации добавляются на единый общий слой */
+    addLayer: (layerName: string) => HTMLElement | never;
+    /** @deprecated Логики со слоями больше нет. Теперь все аннотации добавляются на единый общий слой */
+    getLayer: (layerName: string) => HTMLElement | undefined;
+    /** @deprecated Логики со слоями больше нет. Теперь все аннотации добавляются на единый общий слой */
+    removeLayer: (layerName: string) => void;
+    /** @deprecated Логики со слоями больше нет. Теперь все аннотации добавляются на единый общий слой */
+    clearLayer: (layerName: string) => void;
+    /** @deprecated Метод больше не является публичным */
+    detach: () => void;
+    /** @deprecated Больше нет необходимости переназначать контейнер для аннотаций в ходе работы плеера */
+    reattach: () => void;
+    add: (annotationName: string, annotation: HTMLElement) => void | never;
+    get: (annotationName: string) => HTMLElement | never;
+    remove: (annotationName: string) => void | never;
+    clear: () => void;
+    destroy: () => void;
+}
+export type VideoSubtitle = {
+    value: string;
+    displayValue: string;
+    selected: boolean;
+    isAuto?: boolean;
+};
+export type VideoSubtitleParsed = {
+    startTime: number;
+    endTime: number;
+    lang: string;
+    texts: ({
+        type: 'text';
+        value: string;
+    } | {
+        type: 'timestamp';
+        value: number;
+    })[];
+};
+export type VideoSubtitlesParsed = {
+    lang: string;
+    isAuto: boolean;
+    subtitles: VideoSubtitleParsed[];
+}[];
+export type ControlsEnumType = keyof typeof Controls;
+export type ControlsKeys = ControlsEnumType[];
+export interface IPlayerPhase extends Readable<PlayerPhase> {
+    is: (playerPhase: PlayerPhase) => boolean;
+}
+export interface IDisabledControls extends Writable<Set<ControlsEnumType>> {
+    add: (addData: ControlsEnumType | ControlsKeys) => void;
+    remove: (removeData: ControlsEnumType | ControlsKeys) => void;
+    includes: (includeData: ControlsEnumType | ControlsKeys) => boolean;
+}
+export interface HotKeyMapItem {
+    description: string;
+    value: string;
+}
+export interface HotKeyMapGroup {
+    title: string;
+    items: HotKeyMapItem[];
+}
+export interface HotKeyMapData {
+    title: string;
+    groups: HotKeyMapGroup[];
+    closeBtnText: string;
+}
+export declare enum HotKeyHelperType {
+    PLAY = "PLAY",
+    PAUSE = "PAUSE",
+    REPLAY = "REPLAY",
+    BACKWARD_SEEK = "BACKWARD_SEEK",
+    FORWARD_SEEK = "FORWARD_SEEK",
+    SUBTITLES_ON = "SUBTITLES_ON",
+    SUBTITLES_OFF = "SUBTITLES_OFF",
+    RATE_UP = "RATE_UP",
+    RATE_DOWN = "RATE_DOWN",
+    EPISODE_PREV = "EPISODE_PREV",
+    EPISODE_NEXT = "EPISODE_NEXT",
+    MUTE = "MUTE",
+    VOLUME = "VOLUME"
+}
+export interface HotKeyHelperData {
+    type: HotKeyHelperType;
+    text?: string;
+    t?: {
+        key: Key;
+        value?: string;
+    };
+}
+export declare enum EpisodesModes {
+    FULL = "FULL",
+    COUNT = "COUNT",
+    SHORT = "SHORT"
+}
+export type IToggleable<T> = T & {
+    toggle: () => void;
+};
+type MicroStoreWritableBase<T = unknown> = Writable<T>;
+type ToggleableMicroStore = IToggleable<MicroStoreWritableBase<boolean | null>>;
+export interface IMicroStores {
+    fakeIsPlaying$: ToggleableMicroStore;
+    interactiveControlsOpacity$: ToggleableMicroStore;
+    seekToInteractiveDisabledTooltip$: MicroStoreWritableBase<SeekToInteractiveDisabledTooltipKey>;
+    showInteractiveTimeIndicatorTooltip$: MicroStoreWritableBase<boolean> & {
+        set: (newValue: boolean, useTimeout: boolean) => void;
+        clearTimeout: () => void;
+    };
+}
+export interface InitMicroStoreParams {
+    store: IStore;
+    microStores: IMicroStores;
+    config: IVKVideoPlayerConfig;
+}
+export interface IMicroStore<StateName extends keyof IMicroStores = keyof IMicroStores> {
+    readonly stateName: StateName;
+    state$: IMicroStores[StateName];
+    subscription: Subscription;
+    init: (initStoreParams: InitMicroStoreParams) => Subscription;
+}
+export type IMicroStoresRoot = {
+    subscribers: IMicroStore[];
+    stores: IMicroStores;
+};
+export type Position = {
+    top?: number;
+    left?: number;
+    bottom?: number;
+    right?: number;
+};
+export {};

package/types/utils/WebVttParser.d.ts

@@ -0,0 +1,19 @@
+type ITextCueWebVttParser = ({
+    type: 'text';
+    value: string;
+} | {
+    type: 'timestamp';
+    value: number;
+})[];
+interface ICueWebVttParser {
+    startTime: number;
+    endTime: number;
+    lang: string;
+    texts: ITextCueWebVttParser;
+}
+declare class WebVttParser {
+    private readonly oneLineRegExp;
+    private readonly twoLinesRegExp;
+    parse(vtt: string): ICueWebVttParser[];
+}
+export default WebVttParser;

package/types/utils/changeVolume.d.ts

@@ -0,0 +1,6 @@
+export declare const isAvailableVolumeChange: ({ isAudioDisabled, audioDisabledHintCallback, isAudioAvailable, audioIsNotExistHintCallback, }: {
+    isAudioDisabled: boolean;
+    audioDisabledHintCallback?: (() => void) | undefined;
+    isAudioAvailable: boolean;
+    audioIsNotExistHintCallback?: (() => void) | undefined;
+}) => boolean;

package/types/utils/clipboard.d.ts

@@ -0,0 +1 @@
+export declare const copyToClipboard: (text: string) => void;

package/types/utils/dom.d.ts

@@ -0,0 +1,2 @@
+export declare function matchesSelector(el: HTMLElement, selector: string): boolean;
+export declare function isHover(el: HTMLElement): boolean;

package/types/utils/fetchFile.d.ts

@@ -0,0 +1 @@
+export declare const fetchFile: (url: string, filename: string, fileExtension: string) => void;

package/types/utils/findCurrentSubtltlePhrase.d.ts

@@ -0,0 +1,2 @@
+import type { VideoSubtitle, VideoSubtitleParsed, VideoSubtitlesParsed } from '../types';
+export declare const findCurrentSubtitlePhrase: (position: number, currentSubtitle: Omit<VideoSubtitle, 'selected'>, availableSubtitlesParsed: VideoSubtitlesParsed) => VideoSubtitleParsed | undefined;

package/types/utils/formatSeconds.d.ts

@@ -0,0 +1 @@
+export declare const formatSeconds: (inputSeconds: number) => string;

package/types/utils/fullscreen.d.ts

@@ -0,0 +1,24 @@
+interface DocumentWithFullscreen extends HTMLDocument {
+    mozFullScreenElement?: Element;
+    msFullscreenElement?: Element;
+    webkitFullscreenElement?: Element;
+    msExitFullscreen?: () => Promise<void>;
+    mozCancelFullScreen?: () => Promise<void>;
+    webkitExitFullscreen?: () => Promise<void>;
+}
+interface DocumentElementWithFullscreen extends HTMLElement {
+    msRequestFullscreen?: () => Promise<void>;
+    mozRequestFullScreen?: () => Promise<void>;
+    webkitRequestFullscreen?: () => Promise<void>;
+}
+export declare const requestFullscreen: (element: DocumentElementWithFullscreen) => Promise<void>;
+export declare const exitFullscreen: (doc: DocumentWithFullscreen) => Promise<void>;
+export declare const exitIosSafariVideoElementFullscreen: (videoElement: HTMLVideoElement) => Promise<void>;
+export declare const checkIsFullscreen: () => boolean;
+export declare const registerFullscreenChangeEvent: (callback: () => void) => void;
+export declare const removeFullscreenChangeEvent: (callback: () => void) => void;
+export declare const requestLockScreenOrientation: (videoSize?: {
+    width: number;
+    height: number;
+}) => Promise<void>;
+export {};

package/types/utils/getActualEpisode.d.ts

@@ -0,0 +1,10 @@
+import type { IVideoEpisode } from '../types';
+/**
+  * Функция для получения актуального (текущего) воспроизводимого эпизода
+
+  * @param progress - вещественное число от 0 до 1. Отображает процент прогрессии видео
+  * @param duration - общая продолжительность видеоролика
+  * @param videoEpisodes - массив размеченных эпизодов с временными метками
+  * @return {IVideoEpisode|undefined} - актуальный эпизод, если он есть, или undefined
+ */
+export declare const getActualEpisode: (progress: number, duration: number, videoEpisodes: IVideoEpisode[]) => IVideoEpisode | undefined;

package/types/utils/getHotKeyMapData.d.ts

@@ -0,0 +1,2 @@
+import type { HotKeyMapData } from '../types';
+export declare const getHotKeyMapData: () => HotKeyMapData;

package/types/utils/getQualityLabel.d.ts

@@ -0,0 +1,2 @@
+import type { VideoQualityUI } from '../types';
+export declare const getQualityLabel: (quality?: VideoQualityUI) => any;

package/types/utils/grid.d.ts

@@ -0,0 +1,6 @@
+import { GridTypes } from '../constans';
+export declare const isHigher: (a: GridTypes, b: GridTypes) => boolean;
+export declare const isHigherOrEqual: (a: GridTypes, b: GridTypes) => boolean;
+export declare const isLower: (a: GridTypes, b: GridTypes) => boolean;
+export declare const isLowerOrEqual: (a: GridTypes, b: GridTypes) => boolean;
+export declare const getGridTypeByWidth: (width: number) => GridTypes;

package/types/utils/isIphoneOrOldIpad.d.ts

@@ -0,0 +1,2 @@
+import type { ICurrentBrowserInfo } from '@vkontakte/videoplayer-shared';
+export declare const isIphoneOrOldIpad: (clientInfo: ICurrentBrowserInfo) => boolean;

package/types/utils/keyboardHandleCases.d.ts

@@ -0,0 +1,2 @@
+import type { Writable } from 'svelte/store';
+export declare const handleStartedByKeyboard: (startedByKeyboard$: Writable<boolean>, startedByKeyboard: boolean, btnRef: HTMLElement | undefined) => Promise<void>;

package/types/utils/menuNavigation.d.ts

@@ -0,0 +1,13 @@
+import { type Writable } from 'svelte/store';
+import type { Position } from '../types';
+export declare const isKeyboardHandleCase: (event?: MouseEvent) => boolean;
+export declare const handleFocusReturnToBtn: (ref: HTMLButtonElement, menuVisible: boolean, openedByKeyboard$: Writable<boolean>) => Promise<void>;
+export declare const handleFocusReturnToElem: (ref: HTMLButtonElement, menuVisible: boolean, openedByKeyboard$: Writable<boolean>) => Promise<void>;
+export declare const handleFocusOnMenu: (ref: HTMLUListElement, menuVisible: boolean, isOpenedByKeyboard: boolean) => Promise<void>;
+export declare const returnFocusToMenuItem: (ref: HTMLLIElement, returnCase: Writable<boolean>, isReturnCase: boolean) => Promise<void>;
+export declare const handleKeyDownMainMenu: (event: KeyboardEvent, closeCallback: () => void) => void;
+export declare const handleKeyDownOpenSubMenuItem: (event: KeyboardEvent, openSubmenuFn: () => void, getSubItemFn: () => HTMLLIElement) => Promise<void>;
+export declare const handleKeyDownSubMenu: (event: KeyboardEvent, backToMainSettingsFn: () => void, mainMenuReturnCase: Writable<boolean>, closeSettingsMenuFn: () => void) => Promise<void>;
+export declare const handleChoseMenuItem: (event: KeyboardEvent, selectFn: () => void) => void;
+export declare const getContextMenuPositionByButton: (btnRef: HTMLButtonElement) => Position;
+export declare const getContextMenuPositionByHotKey: (overlayRef: HTMLDivElement | undefined) => Position;

package/types/utils/roundFps.d.ts

@@ -0,0 +1 @@
+export declare const roundFps: (fps: number) => "" | 50 | 60 | 120 | 240;

package/types/utils/sanitizeHtml.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Помогает защитится от XSS атак
+ * @param html string
+ */
+export declare const sanitizeHtml: (html: string) => string;

package/types/utils/stack/index.d.ts

@@ -0,0 +1,9 @@
+export declare class StackFixedSize {
+    private top;
+    private bottom;
+    private size;
+    private readonly maxSize;
+    constructor(maxSize: number);
+    push(value: number): void;
+    getValuesFromBottom(): number[];
+}

package/types/utils/stack/node.d.ts

@@ -0,0 +1,5 @@
+export declare class StackNode {
+    value: number;
+    next: StackNode | null;
+    constructor(value: number);
+}

package/types/utils/subtitleLanguages.d.ts

@@ -0,0 +1 @@
+export declare const subtitleLanguages: Record<string, string>;

package/types/utils/updatePlayerControlsInfo.d.ts

@@ -0,0 +1,3 @@
+import type { IPlayerControlsRef } from '../types';
+import { type IUIState } from '../store';
+export declare const updatePlayerControlsInfo: (videoElement: HTMLVideoElement | null, controls: IUIState['controls'], controlsRef: IPlayerControlsRef, showControls: boolean) => void;

package/types/utils/userSettings.d.ts

@@ -0,0 +1,13 @@
+import { VideoQuality } from '@vkontakte/videoplayer-shared';
+import { type PlaybackRate } from '@vkontakte/videoplayer-core';
+export declare const savePreferredVolume: (volume: number) => void;
+export declare const getPreferredVolume: () => number | undefined;
+export declare const savePreferredQuality: (videoId: number | undefined, value: VideoQuality) => void;
+export declare const deletePreferredQuality: () => void;
+export declare const getPreferredQuality: (currentVideoId: number | undefined) => VideoQuality | undefined;
+export declare const savePreferMute: (preferMute: boolean) => void;
+export declare const getPreferMute: () => boolean;
+export declare const savePreferTrafficSavingEnabled: (trafficSavingEnabled: boolean) => void;
+export declare const getPreferTrafficSavingEnabled: () => boolean;
+export declare const savePreferredRate: (rate: PlaybackRate) => void;
+export declare const getPreferredRate: () => PlaybackRate | undefined;

package/types/utils/videoConfig.d.ts

@@ -0,0 +1,2 @@
+import type { IVKVideoPlayerConfig } from '../types';
+export declare function overrideVideoConfig<Base extends Partial<IVKVideoPlayerConfig>, Override extends Partial<IVKVideoPlayerConfig>, Key extends keyof Partial<IVKVideoPlayerConfig>>(base: Base, override: Override): Base & Override;

package/types/utils/volumeChange.d.ts

@@ -0,0 +1,5 @@
+import type { IStore } from '../store';
+export declare const getNextVolumeUp: (currentVolume: number, step: number) => number;
+export declare const getNextVolumeDown: (currentVolume: number, step: number) => number;
+export declare const volumeDiscreteChangeUp: (store: IStore, currentVolume: number, step: number) => void;
+export declare const volumeDiscreteChangeDown: (store: IStore, currentVolume: number, step: number) => void;