@vkontakte/videoplayer-interactive 1.0.19-dev.c3a364e7.0 → 1.0.19-dev.d432d6cd.0

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

@@ -1,7 +1,41 @@
-export class Interactives {
-    constructor(options: any);
+import { Observable, Subject, ValueSubject } from '@vkontakte/videoplayer-shared';
+import type { Chapter, Manifest, VideoInfo, AnyManifest } from '../../manifest';
+import { type InteractiveRange } from './utils/getInteractiveRanges';
+import type { IInteractiveOptions, IOptionalInteractiveOptions } from "./types";
+import type { 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 seamlessControllerSubs;
+    private graph;
+    private lastFrame;
+    private noInteractionTimeout;
+    appState: INTERACTIVE_APP_STATES;
     state: {
-        prevChapter$: ValueSubject<null>;
+        prevChapter$: ValueSubject<Nullable<Chapter>>;
         isInitialChapter$: ValueSubject<boolean>;
         isFirstChapter$: ValueSubject<boolean>;
         isEndChapter$: ValueSubject<boolean>;
@@ -9,98 +43,80 @@ 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>;
+        graphVisibilityChanged$: Subject<unknown>;
+        watchAgainIsClicked$: Subject<unknown>;
     };
-    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;
+    get options(): IInteractiveOptions;
+    init(): void;
+    setManifest(manifest: AnyManifest | string): Promise<Manifest | 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: VideoInfo[]): 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<Manifest>): 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: Chapter;
+        graph: import("@interactiveplatform/movika-graph-editor").GraphEditChapter | import("@interactiveplatform/movika-graph-editor").GraphViewChapter | undefined;
+        media: import("@interactiveplatform/movika-graph-editor").ManifestVideo;
+    }[];
+    getCurrentChapter(): {
+        chapter: Nullable<Chapter>;
+        media: Nullable<import("@interactiveplatform/movika-graph-editor").ManifestVideo>;
+        graph: Nullable<import("@interactiveplatform/movika-graph-editor").GraphDesign>;
+    };
+    getCurrentManifest(): Nullable<Manifest>;
+    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 { ChapterContainer, ControlLayoutParams } from '../../manifest';
+declare abstract class Layout {
+    layout: ChapterContainer['layout'];
+    protected constructor(layout: ChapterContainer['layout']);
+    abstract setContainerLayout(target: HTMLElement): void;
+    abstract setControlLayout(target: HTMLElement, layoutParams: ControlLayoutParams): void;
 }
-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: ChapterContainer['layout']);
+    setContainerLayout(target: HTMLElement): void;
+    setControlLayout(target: HTMLElement, layoutParams: ControlLayoutParams): 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,21 @@
-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 type { ControlEventCallback, CreateViewParams, Dimensions, LayoutCallback, TControl } from './types';
+type ControlContainer = {
+    element: HTMLElement;
+    dimensions: Dimensions;
+};
+export default abstract class Control {
+    control: TControl;
+    protected container: Nullable<ControlContainer>;
+    protected controlElement: Nullable<HTMLElement>;
+    private clickListener;
+    protected constructor(control: TControl);
+    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,24 @@
+import type { Control as TControl, ControlEvent, ControlLayoutParams } from '../../../manifest';
+import Control from '../../../modules/Interactives/controls/Control';
+export { TControl };
+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: TControl['type'];
+};
+export type ControlEventCallback = (params: ControlEventCallbackParams) => void;
+export type ControlCreator = (control: TControl) => Control | undefined;

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 { 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,40 @@
-export type InteractiveRange = {
-    range: [number, number];
-    subjects: string[];
-};
-export type VideoInfo = {
-    id: string;
-    cover: 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 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/GameController.d.ts

@@ -1,4 +1,37 @@
-export class GameController {
+import { type ISubscription, type IValueSubject } from '@vkontakte/videoplayer-shared';
+import { type IPlayer } from '@vkontakte/videoplayer-core';
+import type { InteractiveEventsType } from './InteractiveEvents';
+import type { ChapterBranch, ChapterContainer } from '../../../manifest';
+import type { EventEmitter } from '../../../utils/EventEmitter';
+import { SelectBranches } from './SelectBranches';
+import { GameStates } from './gameUtils';
+type Container = {
+    container: ChapterContainer;
+    getElement: () => HTMLElement;
+    disable: () => void;
+    enable: () => void;
+    hide: () => void;
+    show: () => void;
+    createView: AnyFn;
+    removeView: () => void;
+    isDisabled: boolean;
+    isRemoved: boolean;
+};
+export declare class GameController {
+    container: Container;
+    branches: ChapterBranch[];
+    selectBranches: ReturnType<typeof SelectBranches>;
+    subscription: ISubscription;
+    player: IPlayer;
+    interactiveEvents: InteractiveEventsType;
+    ignoreContainerEvent: () => boolean;
+    isPermanentText: boolean;
+    disabledControls$: IValueSubject<boolean>;
+    onRemove: () => void;
+    globalEventEmitter: EventEmitter;
+    gameState: GameStates;
+    isSelectedControlEvent: boolean;
+    isSelectedContainerEvent: boolean;
     constructor({ player, container, branches, selectBranches, interactiveEvents, globalEventEmitter, ignoreContainerEvent, permanentTextControls, disabledControls$, onRemove, }: {
         player: any;
         container: any;
@@ -11,20 +44,6 @@ export class GameController {
         disabledControls$: any;
         onRemove: any;
     });
-    container: any;
-    branches: any;
-    selectBranches: any;
-    subscription: Subscription;
-    player: any;
-    interactiveEvents: any;
-    ignoreContainerEvent: any;
-    isPermanentText: any;
-    disabledControls$: any;
-    onRemove: any;
-    globalEventEmitter: any;
-    gameState: 0;
-    isSelectedControlEvent: boolean;
-    isSelectedContainerEvent: boolean;
     registerEvents(): void;
     hide: () => void;
     show: () => void;
@@ -38,4 +57,4 @@ export class GameController {
     removeView(): void;
     destroy(): void;
 }
-import { Subscription } from '@vkontakte/videoplayer-shared';
+export {};

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

@@ -1,22 +1,32 @@
-export function GroupsStack(): {
-    map: {};
-    remove: ({ timestamp, priority, initiator }: {
-        timestamp: any;
-        priority: any;
-        initiator: any;
-    }) => boolean | undefined;
-    add: ({ timestamp, priority, initiator, ...rest }: {
-        [x: string]: any;
-        timestamp: any;
-        priority: any;
-        initiator: any;
-    }) => void;
-    removeAll: () => boolean;
-    get: ({ timestamp, priority, initiator }: {
-        timestamp: any;
-        priority: any;
-        initiator: any;
-    }) => any;
-    getLte: (timestamp: any) => {};
-    getGte: (timestamp: any) => {};
+import type { EventActionKeys } from '../../../manifest';
+export type TPriority = 'chapter' | 'container' | 'control';
+export type TPayload = {
+    actionType: EventActionKeys;
+    action: AnyFn;
 };
+export type TMapInitiator = {
+    [initiator: string]: TPayload[];
+};
+type TMapPriority = {
+    [priority in TPriority]?: TMapInitiator;
+};
+type TMap = {
+    [timestamp: number]: TMapPriority;
+};
+export type TMapFlattened = {
+    timestamp: number;
+    priority: TPriority;
+    initiator: string;
+} & TPayload;
+type GetAndRemoveArgType = Partial<Omit<TMapFlattened, keyof TPayload>> & Pick<TMapFlattened, 'timestamp'>;
+export type TGroupsStack = ReturnType<typeof GroupsStack>;
+export declare function GroupsStack(): {
+    map: TMap;
+    remove: ({ timestamp, priority, initiator }: GetAndRemoveArgType) => boolean;
+    add: ({ timestamp, priority, initiator, ...rest }: TMapFlattened) => void;
+    removeAll: () => void;
+    get: ({ timestamp, priority, initiator }: GetAndRemoveArgType) => TMapInitiator | TPayload[] | TMapPriority | null;
+    getLte: (timestamp: number) => TMap;
+    getGte: (timestamp: number) => TMap;
+};
+export {};

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

@@ -1,24 +1,24 @@
 import { Nullable } from '@vkontakte/videoplayer-shared';
 import type { IValueSubject } from '@vkontakte/videoplayer-shared';
 import { EventEmitter } from '../../../utils/EventEmitter';
-import type { VideoId } from '../../../movika.core/manifest';
+import type { VideoId } from '../../../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/InteractiveEvents.d.ts

@@ -1,12 +1,17 @@
+import { type Container } from '../../../manifest';
+import { type TPayload, type TGroupsStack } from './GroupsStack';
+import type { IPlayer } from '@vkontakte/videoplayer-core';
+export type InteractiveEventsType = ReturnType<typeof InteractiveEvents>;
+type AddMethodParamType = Parameters<TGroupsStack['add']>[0];
+type RemoveMethodParamType = Parameters<TGroupsStack['remove']>[0];
 /**
  * Executes an events at different times of the current chapter
- * @param  {object} player
  */
-export function InteractiveEvents(player: object): {
-    setPlayer: (player: any) => void;
-    add: (args: any) => void;
-    remove: (args: any) => void;
-    exec: (timestamp: any) => void;
+export declare function InteractiveEvents(player: IPlayer): {
+    setPlayer: (player: IPlayer) => void;
+    add: (args: AddMethodParamType) => void;
+    remove: (args: RemoveMethodParamType) => void;
+    exec: (timestamp: number) => void;
     execEndOfVideo: () => void;
     listen: () => void;
     unlisten: () => void;
@@ -16,10 +21,11 @@ export function InteractiveEvents(player: object): {
             timestamp: any;
             id: any;
         }) => void;
-        setData: (containers?: any[]) => void;
-        resetCalled: (timestamp: any) => void;
-        isReady: (timestamp: any) => boolean;
+        setData: (containers?: Container[]) => void;
+        resetCalled: (timestamp: number) => void;
+        isReady: (timestamp: number) => boolean;
         release: () => void;
     };
-    getPreparedToExecActions: (timestamp?: number) => any[];
+    getPreparedToExecActions: (timestamp?: number) => TPayload[];
 };
+export {};

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

@@ -1,5 +1,12 @@
-export function ResizeManager(getOptions: any): {
+import type { IPlayer } from '@vkontakte/videoplayer-core';
+type ResizeManagerArg = () => {
+    parentElement: HTMLElement;
+    player?: Nullable<IPlayer>;
+    fns?: AnyFn[];
+};
+export declare function ResizeManager(getOptions: ResizeManagerArg): {
     resizeObserver: ResizeObserver;
     calc: () => void;
     release: () => void;
 };
+export {};