@vkontakte/videoplayer-interactive 1.0.62 → 1.0.63-dev.30efab63.0

package/index.d.ts

@@ -0,0 +1,11 @@
+export type { HistoryApi } from './modules/Interactives';
+export { EVENT_NAMES, Interactives, utils, graphEventTypes, interactivesEventTypes, isLastChapter, hasEndTemplate, isOneTextCtrlContainer, } from './modules/Interactives';
+export type { IInteractiveOptions, InteractiveRange, InteractiveProjectInfo, PlayerChangedData, VideoInfo, } from './modules/Interactives';
+export { ManifestController } from './modules/ManifestController';
+export * from './manifest';
+export { compareVersions } from './utils/compareVersions';
+export { CustomError } from './utils/Error';
+export * from './utils/chapterHelpers';
+export declare const SDKInfo: {
+    version: string;
+};

package/{types/manifest → manifest}/index.d.ts

@@ -1,3 +1,3 @@
-export type { ChapterContainer, ChapterContainer as Container, Chapter, Control, Manifest, ManifestVideo, ManifestVideoVariant, Media, Metadata, VideoId, CustomManifestVideoVariant, Extension, AnyManifest, AnyControl, GraphEditChapter, GraphViewChapter, ChapterBranch, Standard, ControlLayoutParams, ControlEvent, ContainerEvent, ChapterEvent } from "@interactiveplatform/movika-manifest";
-export { isSupportedManifest, ContainerTypes, ControlTypes, EventActionTypes, EventTypes, migrateManifestToLatestVersion, compareVersions } from "@interactiveplatform/movika-manifest";
-export * from "./utils";
+export type { ChapterContainer, ChapterContainer as Container, Chapter, Control, Manifest, ManifestVideo, ManifestVideoVariant, Media, Metadata, VideoId, CustomManifestVideoVariant, Extension, AnyManifest, AnyControl, GraphEditChapter, GraphViewChapter, ChapterBranch, Standard, ControlLayoutParams, ControlEvent, ContainerEvent, ChapterEvent, } from '@interactiveplatform/movika-manifest';
+export { isSupportedManifest, ContainerTypes, ControlTypes, EventActionTypes, EventTypes, migrateManifestToLatestVersion, compareVersions, } from '@interactiveplatform/movika-manifest';
+export * from './utils';

package/manifest/utils.d.ts

@@ -0,0 +1,48 @@
+import type { EventActionTypes } from '#/manifest';
+import { type AnyManifest, type AnyControl } from '#/manifest';
+/**
+ * checks manifest object validity
+ * @param manifest - manifest to check
+ * @returns true is valid, false is invalid
+ */
+export declare const isValidManifest: (manifest: AnyManifest) => boolean;
+export declare function isTextControl(controlItem: AnyControl): boolean;
+export declare function isButtonControl(controlItem: AnyControl): boolean;
+export declare function isAreaControl(controlItem: AnyControl): boolean;
+export type EventActionKeys = keyof typeof EventActionTypes;
+/**
+ * @deprecated use ContainerTypes enum instead
+ */
+export declare const containerTypes: {
+    readonly Choice: "Choice";
+    readonly TextInput: "TextInput";
+};
+/**
+ * @deprecated use ControlTypes enum instead
+ */
+export declare const controlTypes: {
+    readonly Button: "Button";
+    readonly Area: "Area";
+    readonly Text: "Text";
+};
+/**
+ * @deprecated use EventTypes enum instead
+ */
+export declare const eventTypes: {
+    readonly onClick: "onClick";
+    readonly onSuspense: "onSuspense";
+};
+/**
+ * @deprecated use EventActionTypes enum instead
+ */
+export declare const eventActionTypes: {
+    readonly openURI: "openURI";
+    readonly setNextBranch: "setNextBranch";
+    readonly setWeightlessRandomBranch: "setWeightlessRandomBranch";
+    readonly setRandomBranch: "setRandomBranch";
+    readonly setMaxWeightBranch: "setMaxWeightBranch";
+    readonly setMinWeightBranch: "setMinWeightBranch";
+    readonly setDefaultBranch: "setDefaultBranch";
+    readonly continuePlayback: "continuePlayback";
+    readonly expect: "expect";
+};

package/modules/Graph/Graph.d.ts

@@ -0,0 +1,54 @@
+import type { Nullable } from '@vkontakte/videoplayer-shared';
+import { type InterfaceLanguage } from '@vkontakte/videoplayer-shared';
+import type { VideoInfo } from '#/modules/Interactives';
+import type { GraphEditor } from '@interactiveplatform/movika-graph-editor';
+import type { Chapter, Manifest } from '#/manifest';
+interface GraphOptions {
+    lang: InterfaceLanguage | string;
+    root: HTMLElement;
+    onError: (msg: string) => void;
+    onOpenPreviewClick: (chapterId: string) => void;
+    visitedChapters?: string[];
+}
+type Coordinates = Nullable<{
+    x: number;
+    y: number;
+    value: number;
+}>;
+export declare class Graph {
+    isHidden: boolean;
+    currentManifestId: Nullable<string>;
+    currentChapterId: Nullable<string>;
+    visitedChapterIds: Set<string>;
+    onOpenPreviewClick?: GraphOptions['onOpenPreviewClick'];
+    onError: GraphOptions['onError'];
+    lang: GraphOptions['lang'];
+    zoom: number;
+    lastZoomInfo: Coordinates;
+    isReady: boolean;
+    ngEditor: Nullable<GraphEditor>;
+    ngEditorSize: Nullable<{
+        width: number;
+        height: number;
+    }>;
+    graphWrapperElement: HTMLDivElement;
+    resizeObserver: ResizeObserver;
+    private manifest;
+    constructor(options: GraphOptions);
+    init({ root, onOpenPreviewClick, onError, lang, visitedChapters }: GraphOptions): void;
+    private handleZoomChange;
+    onResize: (entries: ResizeObserverEntry[]) => void;
+    getNextPoint(ngEditorSize?: Nullable<{
+        width: number;
+        height: number;
+    }>): Nullable<[number, number]>;
+    handleChapterChange: (chapter: Chapter) => void;
+    handleManifestChange: (manifest: Manifest, visitedChapters?: string[]) => void;
+    setVisitedChapters(chapterIds: string[]): void;
+    updateVideosInfo(videosInfo: VideoInfo[]): void;
+    show(): Promise<void>;
+    private initNgEditor;
+    hide(): void;
+    destroy(): void;
+}
+export {};

package/modules/Graph/index.d.ts

@@ -0,0 +1 @@
+export { Graph } from './Graph';

package/modules/Interactives/Interactives.d.ts

@@ -0,0 +1,143 @@
+import type { Nullable } from '@vkontakte/videoplayer-shared';
+import { Observable, ValueSubject } from '@vkontakte/videoplayer-shared';
+import { InteractiveInterfaceClick } from '@vkontakte/videoplayer-statistics';
+import type { Chapter, Manifest, AnyManifest, ManifestVideo, GraphEditChapter, GraphViewChapter } from '#/manifest';
+import { type GlobalEvents } from './utils/events';
+import { type InteractiveRange } from './utils/getInteractiveRanges';
+import { type HistoryControllerState } from './utils/HistoryController';
+import type { IInteractiveOptions, IOptionalInteractiveOptions, VideoInfo } from './types';
+import type { IPlayer } from '@vkontakte/videoplayer-core';
+import type { InstanceStatistics } from '#/modules/SeamlessController/InstanceManager';
+declare enum INTERACTIVE_APP_STATES {
+    created = 0,
+    initiated = 1,
+    ready = 2,
+    destroyed = 3
+}
+export declare class Interactives {
+    private playerSubscriptions;
+    private subscriptions;
+    private globalEventEmitter;
+    private animation;
+    private seekToInteractiveController;
+    private endedRanges;
+    private gameControllers;
+    private rootElement;
+    private factories;
+    private isFirstChapterFetched;
+    private _options;
+    private manifestController;
+    private resizeManager;
+    private readonly cssVarsManager;
+    private historyController;
+    private player;
+    private interactiveEvents;
+    private selectBranches;
+    private seamlessController;
+    private seamlessControllerSubs;
+    private graph;
+    private lastFrame;
+    private noInteractionTimeout;
+    private blinkAnimationRef;
+    appState: INTERACTIVE_APP_STATES;
+    state: {
+        prevChapter$: ValueSubject<Nullable<Chapter>>;
+        isInitialChapter$: ValueSubject<boolean>;
+        isFirstChapter$: ValueSubject<boolean>;
+        isEndChapter$: ValueSubject<boolean>;
+        isInteractiveExpectation$: ValueSubject<boolean>;
+        isReplay$: ValueSubject<boolean>;
+        calledByInteractive$: ValueSubject<boolean>;
+        lastChapterChangeWasInitiatedByInteractive$: ValueSubject<boolean>;
+        disabledControls$: ValueSubject<boolean>;
+        interactiveRanges$: ValueSubject<InteractiveRange[]>;
+        isInteractiveTime$: ValueSubject<boolean>;
+        statistics$: ValueSubject<Nullable<InstanceStatistics>>;
+        isSeekable$: ValueSubject<boolean>;
+    };
+    events: GlobalEvents;
+    constructor(options: IOptionalInteractiveOptions);
+    private emitErrorEvent;
+    private clearHistoryIfEnded;
+    private initSubscriptions;
+    private initSeamless;
+    private handleSeamlessPlayerChanged;
+    private onPlaybackStarted;
+    private handlePositionChange;
+    private registerVideoEvents;
+    private destroyGameControllers;
+    private setGameControllers;
+    private getGameControllers;
+    private checkIfSeekable;
+    private updateLastEventInfo;
+    private pushChapterToHistory;
+    private completeInteractiveRange;
+    private handleFakeRemoval;
+    private clearNoInteractionTimeout;
+    private reset;
+    private toggleBlinkAnimation;
+    private updateControlsShadowStyles;
+    get options(): IInteractiveOptions;
+    init(): void;
+    setManifest(manifest: AnyManifest | string): Promise<Manifest | undefined>;
+    setPlayer(player: IPlayer): void;
+    setChapter({ chapterId, pushToHistory, playPrev, }?: {
+        chapterId?: string;
+        pushToHistory?: boolean;
+        playPrev?: boolean;
+    }): Promise<void>;
+    getStatEvents(): {
+        click$: Observable<InteractiveInterfaceClick>;
+        nextMovie$: Observable<number>;
+    };
+    toggleGraphView(show?: boolean): Promise<void>;
+    setVisitedChapters(chapterIds: string[]): void;
+    updateGraphVideosInfo(videosInfo: VideoInfo[]): void;
+    deadEndCheck(): boolean;
+    /**
+     * Проверяет, удалены ли все контроллы.
+     *
+     * Контрол считается удалённым, если его флаг `isRemoved` установлен в `true`.
+     * Однако, есть исключение для `openURI` — если с ним было взаимодействие, он
+     * получит `isRemoved = true`, но может оставаться в DOM до завершения эпизода
+     * (`endTime`).
+     *
+     * Из-за этого метод может вернуть `true` (что все контроллы "удалены"), хотя
+     * `openURI` всё ещё присутствует в DOM.
+     *
+     * includeWillRemovedState - нужно ли считать состояние 'willRemoved' как
+     * 'removed'
+     */
+    allControlsAreRemoved(includeWillRemovedState?: boolean): boolean;
+    isEndedExpectation(): boolean;
+    playPrevChapter(): void;
+    setDisabledControls(value: boolean): void;
+    isSupport(manifest?: Nullable<Manifest>): boolean;
+    getInitialVideoInfo(): {
+        videoId: string | null;
+        chapterId: string;
+    };
+    getHistoryState(): HistoryControllerState;
+    /**
+     * @deprecated Используйте this.state.isSeekable$
+     */
+    getIsSeekable(): ValueSubject<boolean>;
+    getInteractiveRanges(): InteractiveRange[];
+    getNextInteractiveStartTime(offsetMs?: number): number | null;
+    getChapterBranches(chapterId?: string): Array<{
+        chapter: Chapter;
+        graph: GraphEditChapter | GraphViewChapter | undefined;
+        media: ManifestVideo;
+    }>;
+    getCurrentChapter(): {
+        chapter: Nullable<Chapter>;
+        media: Nullable<ManifestVideo>;
+        graph: Nullable<Manifest['graph']>;
+    };
+    getCurrentManifest(): Nullable<Manifest>;
+    on(eventName: string, fn: AnyFn): this;
+    off(eventName: string, fn: AnyFn): this;
+    once(eventName: string, fn: AnyFn): this;
+    destroy(): void;
+}
+export {};

package/modules/Interactives/Layout.d.ts

@@ -0,0 +1,16 @@
+import type { ChapterContainer, ControlLayoutParams } from '#/manifest';
+import type { CssVarsManager } from '#/utils/CssVarsManager';
+declare abstract class Layout {
+    layout: ChapterContainer['layout'];
+    cssVarsManager: CssVarsManager;
+    protected constructor(layout: ChapterContainer['layout'], cssVarsManager: CssVarsManager);
+    abstract setContainerLayout(target: HTMLElement): void;
+    abstract setControlLayout(target: HTMLElement, layoutParams: ControlLayoutParams): void;
+}
+export declare class RelativeLayout extends Layout {
+    cssVarsManager: CssVarsManager;
+    constructor(layout: ChapterContainer['layout'], cssVarsManager: CssVarsManager);
+    setContainerLayout(target: HTMLElement): void;
+    setControlLayout(target: HTMLElement, layoutParams: ControlLayoutParams): void;
+}
+export {};

package/modules/Interactives/containers/ChoiceContainer.d.ts

@@ -0,0 +1,34 @@
+import { Container } from './Container';
+import type { ChapterContainer } from '#/manifest';
+import type { ChoiceContainerOptions, ContainerCreateViewParams } from './types';
+import type { Nullable } from '@vkontakte/videoplayer-shared';
+import type { CssVarsManager } from '#/utils/CssVarsManager';
+export declare const createChoiceContainer: (container: ChapterContainer, rootElement: HTMLElement, cssVarsManager: CssVarsManager, options?: ChoiceContainerOptions) => ChoiceContainer | undefined;
+export declare class ChoiceContainer extends Container {
+    private rootElement;
+    private containerElement;
+    private layout;
+    private subscriptions;
+    isRemoved: boolean;
+    isDisabled: boolean;
+    willRemoved: boolean;
+    readonly cssVarsManager: CssVarsManager;
+    constructor(container: ChapterContainer, rootElement: HTMLElement, cssVarsManager: CssVarsManager, options?: ChoiceContainerOptions);
+    createView({ eventCallback, videoDurationMs }: ContainerCreateViewParams): HTMLElement;
+    updateControlsFillAnimationDimensions(): void;
+    hide(): void;
+    show(): void;
+    enable(): void;
+    disable(): void;
+    removeView(withTransition?: boolean, useDelay?: boolean): void;
+    private onTransitionEnd;
+    removeAllControls(withTransition?: boolean): void;
+    removeNonInteractedControls(withTransition?: boolean): void;
+    isInteracted(): boolean;
+    fakeRemove(): void;
+    getElement(): Nullable<HTMLElement>;
+    onProgress(currentTimeMs: number, isInteractiveTime: boolean): void;
+    onResize(isInteractiveTime: boolean): void;
+    updateControlsShadowStyles(isDark?: boolean): void;
+    toggleBlinkAnimation(enable?: boolean): void;
+}

package/modules/Interactives/containers/Container.d.ts

@@ -0,0 +1,21 @@
+import { Subject } from '@vkontakte/videoplayer-shared';
+import type { CustomError } from '#/utils/Error';
+import type { ChapterContainer } from '#/manifest';
+import { type Control, type ControlCreator, type Options } from '#/modules/Interactives/controls';
+import { type ChoiceContainerOptions } from './types';
+import type { CssVarsManager } from '#/utils/CssVarsManager';
+export declare class Container {
+    container: ChapterContainer;
+    options?: Options;
+    private factories;
+    controls: Control[];
+    error$: Subject<CustomError>;
+    readonly cssVarsManager: CssVarsManager;
+    constructor(container: ChapterContainer, cssVarsManager: CssVarsManager, options?: Options);
+    featureIsEnabled(name: keyof ChoiceContainerOptions['features']): boolean;
+    onError(message: string | undefined, error: unknown): void;
+    addControlFactory(type: string, factory: ControlCreator<any>): void;
+    removeControlFactory(type: string): void;
+    private setControls;
+    private chooseControls;
+}

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

@@ -0,0 +1,4 @@
+export * from './ChoiceContainer';
+export * from './Container';
+export * from './types';
+export * from './utils';

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

@@ -0,0 +1,11 @@
+import type { Options, ControlEventCallback } from '../controls';
+import type { AnimationsFeatureToggles } from '../types';
+export type ChoiceContainerOptions = {
+    isTouch: boolean;
+    features: Pick<AnimationsFeatureToggles, 'controlsExpectTimeBlinkAnimation' | 'controlsTapPlace' | 'controlsFillAnimation'>;
+};
+export declare function isChoiceContainerOptions(options: Options): options is ChoiceContainerOptions;
+export type ContainerCreateViewParams = {
+    eventCallback: ControlEventCallback;
+    videoDurationMs: number;
+};

package/{types/modules → modules}/Interactives/containers/utils.d.ts

@@ -1,6 +1,6 @@
 export declare const CONTAINERS_CLASSNAME_PREFIX = "interactive-container";
 export declare const containersClassNames: {
-	common: string;
-	hidden: string;
-	disabled: string;
+    common: string;
+    hidden: string;
+    disabled: string;
 };

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

@@ -0,0 +1,21 @@
+import { type Nullable } from '@vkontakte/videoplayer-shared';
+import { Control } from './Control';
+import { type ControlCreator, type ControlCreateViewParams, type TControl, type ControlOptions } from './types';
+export declare const createAreaControl: ControlCreator<ControlOptions, AreaControl>;
+declare class AreaControl extends Control {
+    constructor(control: TControl, options?: ControlOptions);
+    createView({ parentElement, callbacks }: ControlCreateViewParams): void;
+    registerBlinkAnimationEvents(): void;
+    disable(): void;
+    enable(): void;
+    getElement(): Nullable<HTMLElement>;
+    updateShadowStyles(isDark?: boolean): void;
+    toggleBlinkAnimation(enable?: boolean): void;
+    syncBlinkAnimation(refAnim: HTMLElement): void;
+    onBlinkHovering(): void;
+    setShowTimeRange(): void;
+    updateFillAnimationDimensions(): void;
+    onProgress(): void;
+    onResize(): void;
+}
+export {};

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

@@ -0,0 +1,25 @@
+import { type Nullable } from '@vkontakte/videoplayer-shared';
+import { Control } from './Control';
+import { type ControlCreator, type ControlCreateViewParams, type TControl, type ControlOptions } from './types';
+import { ControlFillAnimation } from '../utils/ControlFillAnimation';
+export declare const createButtonControl: ControlCreator<ControlOptions, ButtonControl>;
+declare class ButtonControl extends Control {
+    startTime?: number;
+    endTime?: number;
+    controlFillAnimation?: ControlFillAnimation;
+    constructor(control: TControl, options?: ControlOptions);
+    createView({ parentElement, callbacks }: ControlCreateViewParams): void;
+    registerBlinkAnimationEvents(): void;
+    disable(): void;
+    enable(): void;
+    getElement(): Nullable<HTMLElement>;
+    toggleBlinkAnimation(enable?: boolean): void;
+    syncBlinkAnimation(refAnim: HTMLElement): void;
+    onBlinkHovering(): void;
+    updateFillAnimationDimensions(): void;
+    setShowTimeRange(startTime: number, endTime: number): void;
+    onProgress(currentTime: number): void;
+    onResize(): void;
+    updateShadowStyles(): void;
+}
+export {};

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

@@ -0,0 +1,48 @@
+import type { Nullable } from '@vkontakte/videoplayer-shared';
+import { Subject, Subscription } from '@vkontakte/videoplayer-shared';
+import type { CustomError } from '#/utils/Error';
+import { ControlTap } from '../utils/ControlTap';
+import type { ControlEventCallback, ControlCreateViewParams, Dimensions, Callbacks, Options, TControl, ControlOptions } from './types';
+import type { CssVarsManager } from '#/utils/CssVarsManager';
+type ControlContainer = {
+    element: HTMLElement;
+    dimensions: Dimensions;
+    isManifestContainerDisabled: () => boolean;
+};
+type ClickListener = (event: MouseEvent) => void;
+export declare abstract class Control {
+    control: TControl;
+    options: Options | undefined;
+    container: Nullable<ControlContainer>;
+    controlElement: Nullable<HTMLElement>;
+    subscriptions: Subscription;
+    error$: Subject<CustomError>;
+    controlTap?: ControlTap;
+    isInteracted: boolean;
+    isRemoved: boolean;
+    cssVarsManager: Nullable<CssVarsManager>;
+    constructor(control: TControl, options?: Options | undefined);
+    setCssVarsManager(cssVarsManager: CssVarsManager): void;
+    abstract createView(params: ControlCreateViewParams): void;
+    abstract getElement(): Nullable<HTMLElement>;
+    abstract disable(): void;
+    abstract enable(): void;
+    abstract onProgress(currentTimeMs: number): void;
+    abstract onResize(): void;
+    abstract setShowTimeRange(startTime: number, endTime: number): void;
+    abstract updateFillAnimationDimensions(): void;
+    abstract updateShadowStyles(isDark?: boolean): void;
+    abstract toggleBlinkAnimation(enable?: boolean): void;
+    onControlSelect: () => void;
+    removeView(withTransition?: boolean): void;
+    onTransitionEnd: (event: TransitionEvent) => void;
+    onError(message: string | undefined, error: unknown): void;
+    addControlTap(controlElement: HTMLElement): void;
+    createContainerElement(callbacks: Callbacks): void;
+    createClickListener(callback: AnyFn): ClickListener;
+    featureIsEnabled(name: keyof ControlOptions['features']): boolean;
+    isTouch(): boolean;
+    setEvents(callback: ControlEventCallback): void;
+    removeListeners(): void;
+}
+export {};

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

@@ -0,0 +1,18 @@
+import type { Nullable } from '@vkontakte/videoplayer-shared';
+import { Control } from './Control';
+import { type ControlCreator, type ControlCreateViewParams, type TControl, type ControlOptions } from './types';
+export declare const createTextControl: ControlCreator<ControlOptions, TextControl>;
+declare class TextControl extends Control {
+    constructor(control: TControl, options?: ControlOptions);
+    createView({ parentElement, callbacks }: ControlCreateViewParams): void;
+    getElement(): Nullable<HTMLElement>;
+    disable(): void;
+    enable(): void;
+    onProgress(): void;
+    onResize(): void;
+    updateShadowStyles(): void;
+    toggleBlinkAnimation(): void;
+    setShowTimeRange(): void;
+    updateFillAnimationDimensions(): void;
+}
+export {};

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

@@ -0,0 +1,6 @@
+export * from './AreaControl';
+export * from './ButtonControl';
+export * from './TextControl';
+export * from './Control';
+export * from './types';
+export * from './utils';

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

@@ -0,0 +1,35 @@
+import type { Control as TControl, ControlEvent, ControlLayoutParams } from '#/manifest';
+import type { Control } from '#/modules/Interactives/controls/Control';
+import type { AnimationsFeatureToggles } from '#/modules/Interactives/types';
+export type { TControl };
+export declare const CONTROLLER_PREFIX = "int";
+export declare enum CONTROLLER_IDS {
+    AREA = "int_area",
+    TEXT = "int_text",
+    BUTTON = "int_bttn"
+}
+export type Dimensions<T = string | number> = {
+    width: T;
+    height: T;
+};
+export type Callbacks = {
+    setControlLayout: (element: HTMLElement, controlLayoutParams: ControlLayoutParams) => void;
+    isContainerDisabled: () => boolean;
+};
+export type ControlCreateViewParams = {
+    parentElement: HTMLElement;
+    callbacks: Callbacks;
+};
+export type Options = Record<string, unknown>;
+export type ControlOptions = {
+    isTouch: boolean;
+    features: Pick<AnimationsFeatureToggles, 'controlsExpectTimeBlinkAnimation' | 'controlsTapPlace' | 'controlsFillAnimation'>;
+};
+export declare function isControlOptions(options: Options): options is ControlOptions;
+type ControlEventCallbackParams = {
+    action: ControlEvent['action'];
+    controlId: string;
+    controlType: TControl['type'];
+};
+export type ControlEventCallback = (params: ControlEventCallbackParams) => void;
+export type ControlCreator<O extends Options = Options, C extends Control = Control> = (control: TControl, options?: O) => C | undefined;

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

@@ -0,0 +1,14 @@
+export declare const CONTROLS_CLASSNAME_PREFIX = "interactive-control";
+export declare const controlsClassNames: {
+    common: string;
+    selected: string;
+    wrapper: string;
+    disabled: string;
+    button: string;
+    area: string;
+    text: string;
+    blinkAnim: string;
+    blinkAnimButton: string;
+    blinkAnimArea: string;
+};
+export declare const TOUCH_DEVICES_CIRCLE_SIZE_PX = 40;

package/modules/Interactives/index.d.ts

@@ -0,0 +1,16 @@
+import { Container, createChoiceContainer } from './containers/index';
+import { createAreaControl, createButtonControl } from './controls';
+import { classnamesPrefix } from './utils/renderingUtils';
+export { Interactives } from './Interactives';
+export { EVENT_NAMES, graphEventTypes, interactivesEventTypes } from './utils/events';
+export type { InteractiveProjectInfo, PlayerChangedData, VideoInfo, IInteractiveOptions } from './types';
+export type { HistoryApi } from './utils/HistoryController';
+export { isLastChapter, hasEndTemplate, isOneTextCtrlContainer } from './utils/gameUtils';
+export type { InteractiveRange } from './utils/getInteractiveRanges';
+export declare const utils: {
+    Container: typeof Container;
+    createChoiceContainer: typeof createChoiceContainer;
+    createAreaControl: typeof createAreaControl;
+    createButtonControl: typeof createButtonControl;
+    classnamesPrefix: typeof classnamesPrefix;
+};

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

@@ -0,0 +1 @@
+export * from './utils';

package/modules/Interactives/types.d.ts

@@ -0,0 +1,79 @@
+import type { InterfaceLanguage } from '@vkontakte/videoplayer-shared';
+import type { IOptionalTuningConfig, IPlayer } 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';
+import type { Chapter, ManifestVideo } from '#/manifest';
+export type { VideoInfo } from '@interactiveplatform/movika-graph-editor';
+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 type AnimationsFeatureToggles = Partial<{
+    areaControlShadow: boolean;
+    controlsExpectTimeBlinkAnimation: boolean;
+    controlsTapPlace: boolean;
+    controlsFillAnimation: boolean;
+    controlsHideAnimation: boolean;
+}>;
+export interface IInteractiveOptions {
+    parentElement: HTMLElement;
+    fullscreenTargetElement: HTMLElement;
+    lang: InterfaceLanguage | string;
+    config: {
+        historyMaxLength: number;
+        noInteractionEventTimeout: number;
+    };
+    graph: boolean;
+    lastFrame: boolean;
+    initSeamless: boolean;
+    permanentTextControls: boolean;
+    interactiveTimeOpenUri: 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;
+    disableTextControlContainerVisibilityEvents?: boolean;
+    isTouch?: boolean;
+    animationsFeatureToggles?: AnimationsFeatureToggles;
+    enableAvPlayerSupport?: boolean;
+    endChapterHistoryFix?: boolean;
+}
+export type ChapterChangedData = {
+    chapter: Chapter;
+    manifestVideo: ManifestVideo;
+};
+export type PlayerChangedData<T = any> = {
+    player: IPlayer;
+    config: T;
+};
+export interface EachTickData {
+    subjectId: string;
+    subjectName: string;
+    range: number[];
+    currentTime: number;
+    isInteractiveTime: boolean;
+}
+export type IgnoreExpectState = {
+    isExpectTime: boolean;
+    hasOtherExpect: boolean;
+    hasOpenURIEvent: boolean;
+    hasOpenURIEventInCurrentContainer: boolean;
+    isAllOpenURIEventsValid: boolean;
+    isExpectEventForCurrentContainer: boolean;
+    hasShouldOpenNowEvent: boolean;
+};