@vkontakte/videoplayer-interactive 1.0.19-dev.100e5528.0 → 1.0.19-dev.1ff354f7.0

package/types/modules/Interactives/Interactives.d.ts

@@ -1,7 +1,40 @@
-export class Interactives {
-    constructor(options: any);
+import { Observable, Subject, ValueSubject } from '@vkontakte/videoplayer-shared';
+import { LatestChapter, LatestManifest } from '../../movika.core/manifest';
+import { type InteractiveRange } from './utils/getInteractiveRanges';
+import type { IOptionalInteractiveOptions } from './types';
+import { IPlayer } from '@vkontakte/videoplayer-core';
+import { InstanceStatistics } from '../../modules/SeamlessController/InstanceManager';
+declare enum INTERACTIVE_APP_STATES {
+    created = 0,
+    initiated = 1,
+    ready = 2,
+    destroyed = 3
+}
+export declare class Interactives {
+    private subscription;
+    private globalEventEmitter;
+    private animation;
+    private eventManager;
+    private seekToInteractiveController;
+    private endedRanges;
+    private gameControllers;
+    private rootElement;
+    private factories;
+    private isFirstChapterFetched;
+    private options;
+    private manifestController;
+    private resizeManager;
+    private historyController;
+    private player;
+    private interactiveEvents;
+    private selectBranches;
+    private seamlessController;
+    private graph;
+    private lastFrame;
+    private noInteractionTimeout;
+    appState: INTERACTIVE_APP_STATES;
     state: {
-        prevChapter$: ValueSubject<null>;
+        prevChapter$: ValueSubject<Nullable<import("../../movika.core/manifest/types").Chapter>>;
         isInitialChapter$: ValueSubject<boolean>;
         isFirstChapter$: ValueSubject<boolean>;
         isEndChapter$: ValueSubject<boolean>;
@@ -9,98 +42,77 @@ export class Interactives {
         calledByInteractive$: ValueSubject<boolean>;
         lastChapterChangeWasInitiatedByInteractive$: ValueSubject<boolean>;
         disabledControls$: ValueSubject<boolean>;
-        interactiveRanges$: ValueSubject<never[]>;
+        interactiveRanges$: ValueSubject<InteractiveRange[]>;
         isInteractiveTime$: ValueSubject<boolean>;
-        statistics$: ValueSubject<null>;
+        statistics$: ValueSubject<Nullable<InstanceStatistics>>;
+        isSeekable$: ValueSubject<boolean>;
     };
     events: {
-        noInteraction$: Subject<any>;
+        noInteraction$: Subject<void>;
     };
-    options: any;
-    factories: Map<string, (container: any, rootElement: any) => import("./containers").ChoiceContainer | undefined>;
-    rootElement: HTMLDivElement;
-    isFirstChapterFetched: boolean;
-    appState: 0;
-    clearHistoryIfEnded: () => void;
-    /**
-     * Returns an object with observables used for sending statistics
-     * @returns {any}
-     */
-    getStatEvents(): any;
-    setPlayer(player: any): void;
-    /**
-     * Set new manifest
-     *
-     * @async
-     * @param {Record<string, any> | string} manifest whose version is higher than 3
-     * @returns {Promise<any>}
-     */
-    setManifest(manifest: Record<string, any> | string): Promise<any>;
-    /**
-     * @param {string[]} chapterIds
-     */
-    setVisitedChapters(chapterIds: string[]): void;
-    /**
-     * @typedef {Object} VideosInfo
-     * @property {string} id
-     * @property {string} cover
-     * @property {string=} title
-     */
-    /**
-     * @param {Array<VideosInfo>} videosInfo
-     */
-    updateGraphVideosInfo(videosInfo: Array<{
-        id: string;
-        cover: string;
-        title?: string | undefined;
-    }>): void;
-    /**
-     * Set new chapter
-     *
-     * @async
-     * @param {{ chapterId?: string; pushToHistory?: boolean }}
-     * @returns {Promise<any>}
-     */
-    setChapter({ chapterId, pushToHistory }?: {
+    constructor(options: IOptionalInteractiveOptions);
+    private clearHistoryIfEnded;
+    private initSubscriptions;
+    private initSeamless;
+    private handleSeamlessPlayerChanged;
+    private onPlaybackStarted;
+    private handlePositionChange;
+    private registerVideoEvents;
+    private removeControllers;
+    private setGameControllers;
+    private filterGameControllers;
+    private checkIfSeekable;
+    private updateLastEventInfo;
+    private pushChapterToHistory;
+    private completeInteractiveRange;
+    private clearNoInteractionTimeout;
+    private reset;
+    init(): void;
+    setManifest(manifest: any): Promise<LatestManifest | undefined>;
+    setPlayer(player: IPlayer): void;
+    setChapter({ chapterId, pushToHistory, playPrev }?: {
         chapterId?: string;
         pushToHistory?: boolean;
-    }): Promise<any>;
+        playPrev?: boolean;
+    }): Promise<void>;
+    getStatEvents(): {
+        click$: Observable<unknown>;
+        nextMovie$: Observable<unknown>;
+    };
     toggleGraphView(show?: boolean): void;
-    init(): void;
+    setVisitedChapters(chapterIds: string[]): void;
+    updateGraphVideosInfo(videosInfo: any): void;
     deadEndCheck(): boolean;
     allControlsAreRemoved(): boolean;
-    isEndedExpectation(): any;
+    isEndedExpectation(): boolean;
     playPrevChapter(): void;
-    setDisabledControls(value: any): void;
-    isSupport(manifest?: any): boolean;
+    setDisabledControls(value: boolean): void;
+    isSupport(manifest?: Nullable<import("../../movika.core/manifest/manifest_3_3/manifest").Manifest_3_3>): boolean;
     getInitialVideoInfo(): {
-        videoId: any;
-        chapterId: any;
+        videoId: string | null;
+        chapterId: string;
     };
-    getHistoryState(): any;
-    getIsSeekable(): ValueSubject<boolean>;
-    getInteractiveRanges(): import("./utils/getInteractiveRanges").ReduceAcc;
-    /**
-     * Description
-     * @param {number|undefined} [offsetMs="3000"]
-     * @returns {number | null}
-     */
-    getNextInteractiveStartTime(offsetMs?: number | undefined): number | null;
+    getHistoryState(): import("./utils/HistoryController").HistoryControllerState;
     /**
-     * Description
-     * @param {string} [chapterId]
-     * @returns {any}
-     */
-    getChapterBranches(chapterId?: string | undefined): any;
-    getCurrentChapter(): any;
-    getCurrentManifest(): any;
-    addFactory(type: any, factory: any): void;
-    removeFactory(type: any): void;
-    on(...args: any[]): this;
-    off(...args: any[]): this;
-    once(...args: any[]): this;
+    * @deprecated Используйте this.state.isSeekable$
+    */
+    getIsSeekable(): ValueSubject<boolean>;
+    getInteractiveRanges(): import("./utils/getInteractiveRanges").InteractiveRanges;
+    getNextInteractiveStartTime(offsetMs?: number): number | null;
+    getChapterBranches(chapterId?: string): {
+        chapter: LatestChapter;
+        graph: import("../../movika.core/manifest/manifest_3_3/graph").GraphEditChapter | import("../../movika.core/manifest/manifest_3_3/graph").GraphViewChapter | undefined;
+        media: import("../../movika.core/manifest").ManifestVideo;
+    }[];
+    getCurrentChapter(): {
+        chapter: Nullable<import("../../movika.core/manifest/types").Chapter>;
+        media: Nullable<import("../../movika.core/manifest/manifest_3_3/manifest").Media>;
+        graph: Nullable<import("../../movika.core/manifest/manifest_3_3/graph").GraphDesign>;
+    };
+    getCurrentManifest(): Nullable<import("../../movika.core/manifest/manifest_3_3/manifest").Manifest_3_3>;
+    on(eventName: string, fn: Function): this;
+    off(eventName: string, fn: Function): this;
+    once(eventName: string, fn: Function): this;
     destroy(): void;
-    #private;
 }
-import { ValueSubject } from '@vkontakte/videoplayer-shared';
-import { Subject } from '@vkontakte/videoplayer-shared';
+export {};

package/types/modules/Interactives/Layout.d.ts

@@ -1,9 +1,13 @@
-export class Layout {
-    constructor(layout: any);
-    layout: any;
+import { LatestContainer, LatestControlLayoutParams } from '../../movika.core/manifest';
+declare abstract class Layout {
+    layout: LatestContainer['layout'];
+    protected constructor(layout: LatestContainer['layout']);
+    abstract setContainerLayout(target: HTMLElement): any;
+    abstract setControlLayout(target: HTMLElement, layoutParams: LatestControlLayoutParams): any;
 }
-export function createRelativeLayout(layout: any): RelativeLayout | undefined;
-export class RelativeLayout extends Layout {
-    setContainerLayout(target: any): void;
-    setControlLayout(target: any, layoutParams: any): void;
+export declare class RelativeLayout extends Layout {
+    constructor(layout: any);
+    setContainerLayout(target: HTMLElement): void;
+    setControlLayout(target: HTMLElement, layoutParams: LatestControlLayoutParams): void;
 }
+export {};

package/types/modules/Interactives/controls/AreaControl.d.ts

@@ -1,11 +1,2 @@
-export function createAreaControl(control: any): AreaControl | undefined;
-export class AreaControl extends Control {
-    createView({ parent, layoutFn }: {
-        parent: any;
-        layoutFn: any;
-    }): HTMLDivElement;
-    controlEl: HTMLButtonElement | undefined;
-    disable(): void;
-    enable(): void;
-}
-import { Control } from './Control';
+import { type ControlCreator } from './types';
+export declare const createAreaControl: ControlCreator;

package/types/modules/Interactives/controls/ButtonControl.d.ts

@@ -1,11 +1,2 @@
-export function createButtonControl(control: any): ButtonControl | undefined;
-export class ButtonControl extends Control {
-    createView({ parent, layoutFn }: {
-        parent: any;
-        layoutFn: any;
-    }): HTMLDivElement;
-    controlEl: HTMLButtonElement | undefined;
-    disable(): void;
-    enable(): void;
-}
-import { Control } from './Control';
+import { type ControlCreator } from './types';
+export declare const createButtonControl: ControlCreator;

package/types/modules/Interactives/controls/Control.d.ts

@@ -1,13 +1,22 @@
-export class Control {
-    constructor(control: any);
-    control: any;
-    createView(layoutFn: any): {
-        controlContainerEl: HTMLDivElement;
-        dependsOn: {
-            height: string;
-            width: string;
-        };
-    };
-    setEvents(element: any, callback: any): void;
-    getElement(): Element | null;
+import { LatestControl } from '../../../movika.core/manifest';
+import { ControlEventCallback, CreateViewParams, Dimensions, LayoutCallback } from './types';
+type ControlContainer = {
+    element: HTMLElement;
+    dimensions: Dimensions;
+};
+export default abstract class Control {
+    control: LatestControl;
+    protected container: Nullable<ControlContainer>;
+    protected controlElement: Nullable<HTMLElement>;
+    private clickListener;
+    protected constructor(control: LatestControl);
+    abstract createView(params: CreateViewParams): void;
+    abstract getElement(): Nullable<HTMLElement>;
+    abstract disable(): void;
+    abstract enable(): void;
+    protected createContainerElement(layoutCallback: LayoutCallback): void;
+    private createClickListener;
+    setEvents(callback: ControlEventCallback): void;
+    removeListeners(): void;
 }
+export {};

package/types/modules/Interactives/controls/TextControl.d.ts

@@ -1,11 +1,2 @@
-export function createTextControl(control: any): TextControl | undefined;
-export class TextControl extends Control {
-    createView({ parent, layoutFn }: {
-        parent: any;
-        layoutFn: any;
-    }): HTMLDivElement;
-    controlEl: HTMLDivElement | undefined;
-    disable(): void;
-    enable(): void;
-}
-import { Control } from './Control';
+import { type ControlCreator } from './types';
+export declare const createTextControl: ControlCreator;

package/types/modules/Interactives/controls/index.d.ts

@@ -1,3 +1,4 @@
-export * from "./AreaControl";
-export * from "./ButtonControl";
-export * from "./Control";
+export * from './AreaControl.js';
+export * from './ButtonControl.js';
+export * from './Control';
+export * from './types';

package/types/modules/Interactives/controls/types.d.ts

@@ -0,0 +1,25 @@
+import { ControlEvent, ControlLayoutParams } from '../../../movika.core/manifest/manifest_3_3/control';
+import { LatestControl } from '../../../movika.core/manifest';
+import Control from '../../../modules/Interactives/controls/Control';
+export declare enum CONTROLLER_IDS {
+    AREA = "int_area",
+    TEXT = "int_text",
+    BUTTON = "int_bttn"
+}
+export type Dimensions = {
+    width: string;
+    height: string;
+};
+export type LayoutCallback = (element: HTMLElement, controlLayoutParams: ControlLayoutParams) => void;
+export type CreateViewParams = {
+    parentElement: HTMLElement;
+    layoutCallback: LayoutCallback;
+};
+type ControlEventCallbackParams = {
+    action: ControlEvent['action'];
+    controlId: string;
+    controlType: LatestControl['type'];
+};
+export type ControlEventCallback = (params: ControlEventCallbackParams) => void;
+export type ControlCreator = (control: LatestControl) => Control | undefined;
+export {};

package/types/modules/Interactives/index.d.ts

@@ -1,14 +1,14 @@
 import { Container } from './containers/index';
 export { Interactives } from './Interactives';
 export { EVENT_NAMES, graphEventTypes, interactivesEventTypes } from './utils/events';
-export type { InteractiveRange, VideoInfo } from './types';
+export type { VideoInfo, InteractiveProjectInfo } from './types';
 export { isLastChapter, hasEndTemplate } from './utils/gameUtils';
+export type { InteractiveRange } from './utils/getInteractiveRanges';
 export declare const utils: {
     Container: typeof Container;
     createChoiceContainer: (container: any, rootElement: any) => import("./containers/ChoiceContainer").ChoiceContainer | undefined;
-    createAreaControl: (control: any) => import("./controls/AreaControl").AreaControl | undefined;
-    createButtonControl: (control: any) => import("./controls/ButtonControl").ButtonControl | undefined;
-    createRelativeLayout: (layout: any) => import("./Layout").RelativeLayout | undefined;
+    createAreaControl: import("./controls").ControlCreator;
+    createButtonControl: import("./controls").ControlCreator;
     getRootEl: () => Element | null;
     classnamesPrefix: string;
 };

package/types/modules/Interactives/types.d.ts

@@ -1,9 +1,45 @@
-export type InteractiveRange = {
-    range: [number, number];
-    subjects: string[];
-};
+import type { InterfaceLanguage } from '@vkontakte/videoplayer-shared';
+import type { IOptionalTuningConfig } from '@vkontakte/videoplayer-core';
+import type { IOneStat } from '@vkontakte/videoplayer-statistics';
+import type { Loaders } from '../../modules/ManifestController/Loadable';
+import type { HistoryApi, HistorySettings } from '../../modules/Interactives/utils/HistoryController';
 export type VideoInfo = {
     id: string;
     cover: string;
     title?: string;
 };
+export type InteractiveProjectInfo = {
+    videoId: string;
+    pid?: string;
+    title?: string;
+    variantPayloadType?: string;
+};
+export type RequiredOptions = 'parentElement' | 'fullscreenTargetElement';
+export type IOptionalInteractiveOptions = Partial<Omit<IInteractiveOptions, RequiredOptions | 'config'>> & Required<Pick<IInteractiveOptions, RequiredOptions>> & {
+    config?: Partial<IInteractiveOptions['config']>;
+};
+export interface IInteractiveOptions {
+    parentElement: HTMLElement;
+    fullscreenTargetElement: HTMLElement;
+    lang: InterfaceLanguage | string;
+    config: {
+        historyMaxLength: number;
+        noInteractionEventTimeout: number;
+    };
+    graph: boolean;
+    lastFrame: boolean;
+    initSeamless: boolean;
+    permanentTextControls: boolean;
+    loaders: Partial<Loaders>;
+    initChapterId?: string;
+    projectInfo?: InteractiveProjectInfo;
+    historyApi?: HistoryApi;
+    historySettings?: HistorySettings;
+    coreConfig?: IOptionalTuningConfig;
+    vkVideoLoader?: (owner_id: string, video_id: string) => unknown;
+    createOneStat?: (video: any, configOverwrite?: any) => IOneStat | undefined;
+    /**
+    * @deprecated
+    * */
+    disableControlsOnPause?: boolean;
+}

package/types/modules/Interactives/utils/HistoryController.d.ts

@@ -3,22 +3,22 @@ import type { IValueSubject } from '@vkontakte/videoplayer-shared';
 import { EventEmitter } from '../../../utils/EventEmitter';
 import type { VideoId } from '../../../movika.core/manifest';
 import type { Interactives } from '../../../modules/Interactives';
-interface HistoryApi {
-    get: (videoId: string) => Promise<number[]>;
-    save: (videoId: string, videoIds: Array<VideoId>) => Promise<void>;
+export interface HistoryApi {
+    get: (rawId: string) => Promise<number[]>;
+    save: (rawId: string, videoIds: number[]) => Promise<void>;
 }
-interface HistorySettings {
+export interface HistorySettings {
     maxLength: number;
     initChapterId?: string;
 }
 interface HistoryControllerParams {
-    videoId: string;
     globalEventEmitter: EventEmitter;
     interactiveController: Interactives;
     settings: HistorySettings;
+    videoId?: string;
     historyApi?: Nullable<HistoryApi>;
 }
-interface HistoryControllerState {
+export interface HistoryControllerState {
     history$: IValueSubject<string[]>;
     hasPrevChapter$: IValueSubject<boolean>;
     prevChapter$: IValueSubject<Nullable<string>>;
@@ -27,7 +27,7 @@ interface HistoryControllerState {
 }
 export default class HistoryController {
     #private;
-    state: Nullable<HistoryControllerState>;
+    state: HistoryControllerState;
     constructor({ globalEventEmitter, videoId, interactiveController, historyApi, settings }: HistoryControllerParams);
     setManifest(manifest: any): Promise<void>;
     get inited(): boolean;

package/types/modules/Interactives/utils/getInteractiveRanges.d.ts

@@ -1,7 +1,7 @@
 import { type Container } from '../../../movika.core/manifest';
-export type ReduceAccItem = {
+export type InteractiveRange = {
     subjects: string[];
     range: [number, number];
 };
-export type ReduceAcc = Array<ReduceAccItem>;
-export declare const getInteractiveRanges: (containers?: Container[]) => ReduceAcc;
+export type InteractiveRanges = Array<InteractiveRange>;
+export declare const getInteractiveRanges: (containers?: Container[]) => InteractiveRanges;

package/types/modules/Interactives/utils/renderingUtils.d.ts

@@ -1,5 +1,5 @@
-export const classnamesPrefix: "SDK_NAME";
-export const rootElClassName: "SDK_NAME-controls-container";
+export const classnamesPrefix: "interactive";
+export const rootElClassName: "interactive-controls-container";
 export function getRootEl(): Element | null;
 export const DISABLE_OPACITY: 0.4;
 export namespace controlStylesFallbacks {

package/types/modules/ManifestController/Loadable.d.ts

@@ -1,14 +1,11 @@
-declare const LoaderTypes: {
-    readonly chapterLoaders: "chapterLoaders";
-    readonly manifestLoaders: "manifestLoaders";
-};
-type LoaderTypes = (typeof LoaderTypes)[keyof typeof LoaderTypes];
+type LoaderTypes = 'chapterLoaders' | 'manifestLoaders';
+export type Loaders = Record<LoaderTypes, Function[]>;
 interface ILoadable {
     exec(type: LoaderTypes, inputArg: Record<string, any>): Promise<any>;
 }
 export declare class Loadable implements ILoadable {
-    loaders: Record<LoaderTypes, any>;
-    constructor(loaders: Record<LoaderTypes, any>);
+    loaders: Loaders;
+    constructor(loaders: Partial<Loaders>);
     exec(type: LoaderTypes, inputArg: Record<string, any>): Promise<any>;
 }
 export declare function addErrorMessage(errObj: Record<string, Array<string>> | null, loaderName: string, message: string): Record<string, Array<string>>;

package/types/movika.core/manifest/index.d.ts

@@ -2,6 +2,7 @@ import type { Chapter as Chapter_3_2, ChapterContainer as ChapterContainer_3_2,
 import type { Manifest_3_2, ManifestVideo as ManifestVideo_3_2, ManifestVideoVariant as ManifestVideoVariant_3_2, Media as Media_3_2, Metadata as Metadata_3_2 } from './manifest_3_2/manifest';
 import type { Chapter as Chapter_3_3, ChapterContainer as ChapterContainer_3_3, ChapterBranch as ChapterBranch_3_3 } from './manifest_3_3/chapter';
 import type { Manifest_3_3, ManifestVideo as ManifestVideo_3_3, ManifestVideoVariant as ManifestVideoVariant_3_3, Media as Media_3_3, Metadata as Metadata_3_3, ManifestVideoVariantType, Extensions, Standard } from './manifest_3_3/manifest';
+import type { Control, ControlLayoutParams } from './manifest_3_3/control';
 export type Container = ChapterContainer_3_2 | ChapterContainer_3_3;
 export type Media = Media_3_2 | Media_3_3;
 export type Chapter = Chapter_3_2 | Chapter_3_3;
@@ -14,6 +15,9 @@ export type { ManifestVideoVariantType, Extensions, Standard };
 export type LatestMedia = Media_3_3;
 export type LatestChapter = Chapter_3_3;
 export type LatestManifest = Manifest_3_3;
+export type LatestContainer = ChapterContainer_3_3;
+export type LatestControl = Control;
+export type LatestControlLayoutParams = ControlLayoutParams;
 export * from './migrations';
 export * from './types';
 export * from './utils';

package/types/utils/EventManager.d.ts

@@ -1,12 +1,12 @@
 import { Binding } from './Binding';
 import { MultiMap } from './MultiMap';
 import type { HtmlEventType } from '../types';
-type OptionsType = undefined | boolean | AddEventListenerOptions;
+type OptionsType = boolean | AddEventListenerOptions;
 export declare class EventManager {
     bindingMap: MultiMap<Binding> | null;
     release(): void;
-    listen(target: Element, type: HtmlEventType, listener: EventListener, options: OptionsType): void;
-    listenOnce(target: Element, type: HtmlEventType, listener: EventListener, options: OptionsType): void;
+    listen(target: Element, type: HtmlEventType, listener: EventListener, options?: OptionsType): void;
+    listenOnce(target: Element, type: HtmlEventType, listener: EventListener, options?: OptionsType): void;
     unlisten(target: Element, type: HtmlEventType, listener: EventListener): void;
     removeAll(): void;
 }

package/types/utils/Raf.d.ts

@@ -2,7 +2,7 @@ export declare class Raf {
     raf: number | undefined;
     fn: VoidFunction | undefined;
     fns: Array<VoidFunction>;
-    constructor(fn: VoidFunction);
+    constructor(fn?: VoidFunction);
     addFn: (fn: VoidFunction, shouldRequest?: boolean) => void;
     removeFn: (fn: VoidFunction, shouldRequest?: boolean) => void;
     updateFn: () => void;

package/types/modules/Interactives/controls/constants.d.ts

@@ -1,5 +0,0 @@
-export namespace CONTROLLER_IDS {
-    let AREA: string;
-    let TEXT: string;
-    let BUTTON: string;
-}