@vkontakte/videoplayer-interactive 1.0.31 → 1.0.32-beta.0

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

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

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

@@ -1,24 +1,33 @@
 import type { Control as TControl, ControlEvent, ControlLayoutParams } from '../../../manifest';
-import Control from '../../../modules/Interactives/controls/Control';
+import type { Control } from '../../../modules/Interactives/controls/Control';
+import { AnimationsFeatureToggles } from '../../../modules/Interactives/types';
 export { TControl };
+export declare const CONTROLLER_PREFIX = "int";
 export declare enum CONTROLLER_IDS {
     AREA = "int_area",
     TEXT = "int_text",
     BUTTON = "int_bttn"
 }
-export type Dimensions = {
-    width: string;
-    height: string;
+export type Dimensions<T = string> = {
+    width: T;
+    height: T;
 };
-export type LayoutCallback = (element: HTMLElement, controlLayoutParams: ControlLayoutParams) => void;
-export type CreateViewParams = {
+export type Callbacks = {
+    setControlLayout: (element: HTMLElement, controlLayoutParams: ControlLayoutParams) => void;
+};
+export type ControlCreateViewParams = {
     parentElement: HTMLElement;
-    layoutCallback: LayoutCallback;
+    callbacks: Callbacks;
+};
+export type Options = Record<string, unknown>;
+export type ControlOptions = {
+    features: Pick<AnimationsFeatureToggles, never>;
 };
+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 = (control: TControl) => Control | undefined;
+export type ControlCreator<O extends Options = Options, C extends Control = Control> = (control: TControl, options?: O) => C | undefined;

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

@@ -0,0 +1,9 @@
+export declare const CONTROLS_CLASSNAME_PREFIX = "interactive-control";
+export declare const controlsClassNames: {
+    common: string;
+    wrapper: string;
+    disabled: string;
+    button: string;
+    area: string;
+    text: string;
+};

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

@@ -6,9 +6,44 @@ export { isLastChapter, hasEndTemplate, isOneTextCtrlContainer } from './utils/g
 export type { InteractiveRange } from './utils/getInteractiveRanges';
 export declare const utils: {
     Container: typeof Container;
-    createChoiceContainer: (container: import("@interactiveplatform/movika-manifest").ChapterContainer, rootElement: HTMLElement) => import("./containers/ChoiceContainer").ChoiceContainer | undefined;
-    createAreaControl: import("./controls").ControlCreator;
-    createButtonControl: import("./controls").ControlCreator;
-    getRootEl: () => Element | null;
+    createChoiceContainer: (container: import("@interactiveplatform/movika-manifest").ChapterContainer, rootElement: HTMLElement, options?: import("./containers/types").ChoiceContainerOptions) => import("./containers/ChoiceContainer").ChoiceContainer | undefined;
+    createAreaControl: import("./controls").ControlCreator<import("./controls").ControlOptions, {
+        createView({ parentElement, callbacks }: import("./controls").ControlCreateViewParams): void;
+        disable(): void;
+        enable(): void;
+        getElement(): Nullable<HTMLElement>;
+        container: Nullable<{
+            element: HTMLElement;
+            dimensions: import("./controls").Dimensions;
+        }>;
+        controlElement: Nullable<HTMLElement>;
+        clickListener: Nullable<(event: MouseEvent) => void>;
+        control: import("@interactiveplatform/movika-manifest/dist/chapter-COPBtRYg").e;
+        options?: import("./controls").Options;
+        createContainerElement(callbacks: import("./controls").Callbacks): void;
+        createClickListener(callback: AnyFn): (event: MouseEvent) => void;
+        featureIsEnabled(name: keyof import("./controls").ControlOptions["features"]): false | undefined;
+        setEvents(callback: import("./controls").ControlEventCallback): void;
+        removeListeners(): void;
+    }>;
+    createButtonControl: import("./controls").ControlCreator<import("./controls").ControlOptions, {
+        createView({ parentElement, callbacks }: import("./controls").ControlCreateViewParams): void;
+        disable(): void;
+        enable(): void;
+        getElement(): Nullable<HTMLElement>;
+        container: Nullable<{
+            element: HTMLElement;
+            dimensions: import("./controls").Dimensions;
+        }>;
+        controlElement: Nullable<HTMLElement>;
+        clickListener: Nullable<(event: MouseEvent) => void>;
+        control: import("@interactiveplatform/movika-manifest/dist/chapter-COPBtRYg").e;
+        options?: import("./controls").Options;
+        createContainerElement(callbacks: import("./controls").Callbacks): void;
+        createClickListener(callback: AnyFn): (event: MouseEvent) => void;
+        featureIsEnabled(name: keyof import("./controls").ControlOptions["features"]): false | undefined;
+        setEvents(callback: import("./controls").ControlEventCallback): void;
+        removeListeners(): void;
+    }>;
     classnamesPrefix: string;
 };

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

@@ -0,0 +1 @@
+export declare const applyStyles: (attachToElement: HTMLElement) => void;

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

@@ -19,6 +19,7 @@ export type RequiredOptions = 'parentElement' | 'fullscreenTargetElement';
 export type IOptionalInteractiveOptions = Partial<Omit<IInteractiveOptions, RequiredOptions | 'config'>> & Required<Pick<IInteractiveOptions, RequiredOptions>> & {
     config?: Partial<IInteractiveOptions['config']>;
 };
+export type AnimationsFeatureToggles = {};
 export interface IInteractiveOptions {
     parentElement: HTMLElement;
     fullscreenTargetElement: HTMLElement;
@@ -31,6 +32,7 @@ export interface IInteractiveOptions {
     lastFrame: boolean;
     initSeamless: boolean;
     permanentTextControls: boolean;
+    interactiveTimeOpenUri: boolean;
     loaders: Partial<Loaders>;
     initChapterId?: string;
     projectInfo?: InteractiveProjectInfo;
@@ -40,9 +42,10 @@ export interface IInteractiveOptions {
     vkVideoLoader?: (owner_id: string, video_id: string) => unknown;
     createOneStat?: (video: any, configOverwrite?: any) => IOneStat | undefined;
     /**
-    * @deprecated
-    * */
+     * @deprecated
+     * */
     disableControlsOnPause?: boolean;
+    animationFeatureToggles?: AnimationsFeatureToggles;
 }
 export type ChapterChangedData = {
     chapter: Chapter;
@@ -59,3 +62,12 @@ export interface EachTickData {
     currentTime: number;
     isInteractiveTime: boolean;
 }
+export type IgnoreExpectState = {
+    isExpectTime: boolean;
+    hasOtherExpect: boolean;
+    hasOpenURIEvent: boolean;
+    hasOpenURIEventInCurrentContainer: boolean;
+    isAllOpenURIEventsValid: boolean;
+    isExpectEventForCurrentContainer: boolean;
+    hasShouldOpenNowEvent: boolean;
+};

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

@@ -3,8 +3,9 @@ import { type IPlayer } from '@vkontakte/videoplayer-core';
 import type { InteractiveEventsType } from './InteractiveEvents';
 import type { ChapterBranch } from '../../../manifest';
 import type { EventEmitter } from '../../../utils/EventEmitter';
-import type { ChoiceContainer } from '../../../modules/Interactives/containers';
 import type { SelectBranchesType } from './SelectBranches';
+import type { IgnoreExpectState } from '../../../modules/Interactives/types';
+import type { ChoiceContainer } from '../../../modules/Interactives/containers';
 import { type GlobalEvents } from './events';
 import { GameStates } from './gameUtils';
 type ConstructorArg = {
@@ -15,8 +16,9 @@ type ConstructorArg = {
     interactiveEvents: InteractiveEventsType;
     globalEventEmitter: EventEmitter;
     globalEvents: GlobalEvents;
-    ignoreContainerEvent: () => boolean;
+    getContainerEventState: () => IgnoreExpectState;
     permanentTextControls: boolean;
+    interactiveTimeOpenUri: boolean;
     disabledControls$: IValueSubject<boolean>;
     onRemove: () => void;
 };
@@ -27,8 +29,9 @@ export declare class GameController {
     subscription: ISubscription;
     player: IPlayer;
     interactiveEvents: InteractiveEventsType;
-    ignoreContainerEvent: () => boolean;
+    getContainerEventState: () => IgnoreExpectState;
     isPermanentText: boolean;
+    interactiveTimeOpenUri: boolean;
     disabledControls$: IValueSubject<boolean>;
     onRemove: () => void;
     globalEventEmitter: EventEmitter;
@@ -36,7 +39,7 @@ export declare class GameController {
     isSelectedControlEvent: boolean;
     isSelectedContainerEvent: boolean;
     globalEvents: GlobalEvents;
-    constructor({ player, container, branches, selectBranches, interactiveEvents, globalEvents, globalEventEmitter, ignoreContainerEvent, permanentTextControls, disabledControls$, onRemove, }: ConstructorArg);
+    constructor({ player, container, branches, selectBranches, interactiveEvents, globalEvents, globalEventEmitter, getContainerEventState, permanentTextControls, interactiveTimeOpenUri, disabledControls$, onRemove, }: ConstructorArg);
     private emitContainerVisibilityEvent;
     registerEvents(): void;
     hide: () => void;
@@ -49,6 +52,7 @@ export declare class GameController {
     whilePlaying: () => void;
     reset(): void;
     removeView(): void;
+    fakeRemoveView(remove?: boolean): void;
     destroy(): void;
 }
 export {};

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

@@ -2,7 +2,7 @@ import { Nullable, Subject } from '@vkontakte/videoplayer-shared';
 import type { IValueSubject } from '@vkontakte/videoplayer-shared';
 import { EventEmitter } from '../../../utils/EventEmitter';
 import type { VideoId } from '../../../manifest';
-import type { VideoInfo } from "../../../modules/Interactives";
+import type { VideoInfo } from '../../../modules/Interactives';
 import type { Interactives } from '../../../modules/Interactives';
 import { CustomError } from '../../../utils/Error';
 export interface HistoryApi {

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

@@ -7,7 +7,7 @@ type RemoveMethodParamType = Parameters<TGroupsStack['remove']>[0];
 /**
  * Executes an events at different times of the current chapter
  */
-export declare function InteractiveEvents(player: IPlayer): {
+export declare function InteractiveEvents(player: IPlayer, interactiveTimeOpenUri: boolean): {
     setPlayer: (player: IPlayer) => void;
     add: (args: AddMethodParamType) => void;
     remove: (args: RemoveMethodParamType) => void;

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

@@ -2,7 +2,7 @@ import type { Subject } from '@vkontakte/videoplayer-shared';
 import type { ChapterChangedData, EachTickData, PlayerChangedData } from '../../../modules/Interactives/types';
 import type { CustomError } from '../../../utils/Error';
 import type { Manifest } from '../../../manifest';
-import { TInteractiveRangeEndedEvent, TInteractivesActionChoiceEvent, TInteractivesActionExecutionEvent, TInteractivesContainerRemoved, SubjectName, TInteractivesVisibility } from './events.types';
+import { TInteractiveRangeEndedEvent, TInteractivesActionChoiceEvent, TInteractivesActionExecutionEvent, TInteractivesContainerRemoved, TInteractivesContainerFakeRemoved, SubjectName, TInteractivesVisibility } from './events.types';
 export interface GlobalEvents {
     noInteraction$: Subject<void>;
     graphVisibilityChanged$: Subject<boolean>;
@@ -14,6 +14,7 @@ export interface GlobalEvents {
     manifestChanged$: Subject<Manifest>;
     interactiveRangeEnded$: Subject<TInteractiveRangeEndedEvent>;
     interactiveContainerRemoved$: Subject<TInteractivesContainerRemoved>;
+    interactiveContainerFakeRemoved$: Subject<TInteractivesContainerFakeRemoved>;
     interactiveActionExecution$: Subject<TInteractivesActionExecutionEvent<SubjectName>>;
     interactiveActionChoice$: Subject<TInteractivesActionChoiceEvent<SubjectName>>;
     interactiveVisibilityChanged$: Subject<TInteractivesVisibility<'container'>>;
@@ -73,5 +74,6 @@ export declare enum InteractivesEventTypes {
     ACTION_EXECUTION = "action-execution",
     VISIBILITY = "visibility",
     CONTAINER_REMOVED = "container-removed",
+    CONTAINER_FAKE_REMOVED = "container-fake-removed",
     RANGE_ENDED = "range-ended"
 }

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

@@ -47,3 +47,6 @@ export type TInteractivesActionChoiceEvent<T extends SubjectName> = TInteractive
     payload: TInteractivesActionChoiceEventPayload<T>;
 };
 export type TInteractivesContainerRemoved = TInteractiveCommon<'container', InteractivesEventTypes.CONTAINER_REMOVED>;
+export type TInteractivesContainerFakeRemoved = TInteractiveCommon<'container', InteractivesEventTypes.CONTAINER_FAKE_REMOVED> & {
+    removeAllOpenURI: boolean;
+};

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

@@ -1,5 +1,6 @@
 import { type Control, type Chapter, type ChapterContainer } from '../../../manifest';
 import type { GameController } from './GameController';
+import type { IgnoreExpectState } from '../../../modules/Interactives/types';
 export declare enum GameStates {
     nothing = 0,
     beforeInteractive = 1,
@@ -24,5 +25,5 @@ export declare function excludeTextControl(containers?: ChapterContainer[]): Cha
 export declare const isEOVEndTime: (target: HTMLVideoElement, endTime: ChapterContainer["endTime"]) => boolean;
 export declare function partial<T extends unknown[], U extends unknown[], R>(fn: (...args: [...T, ...U]) => R, ...presetArgs: T): (...laterArgs: U) => R;
 export declare function partial<T extends Record<string, unknown>, P extends Partial<T>>(fn: (args: T) => unknown, presetArgs: P): (laterArgs: Omit<T, keyof P>) => ReturnType<typeof fn>;
-export declare const shouldIgnoreContainerEvent: (container: ChapterContainer, gameControllers: GameController[]) => boolean;
+export declare const evaluateContainerEventStatus: (container: ChapterContainer, gameControllers: GameController[]) => IgnoreExpectState;
 export {};

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

@@ -1,6 +1,10 @@
 import { type Container } from '../../../manifest';
+export type Subject = {
+    id: string;
+    isRemoved: boolean;
+};
 export type InteractiveRange = {
-    subjects: string[];
+    subjects: Subject[];
     range: [number, number];
 };
 export type InteractiveRanges = Array<InteractiveRange>;

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

@@ -1,9 +1,6 @@
 import { type Control } from '../../../manifest';
 import { type Dimensions } from '../../../modules/Interactives/controls';
 export declare const classnamesPrefix = "interactive";
-export declare const rootElClassName = "interactive-controls-container";
-export declare const getRootEl: () => Element | null;
-export declare const DISABLE_OPACITY = 0.4;
 export declare const controlStylesFallbacks: {
     textColor: string;
     textSize: number;