@vkontakte/videoplayer-interactive 1.0.63-dev.fcdd1bac.0 → 1.0.63

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

@@ -0,0 +1,17 @@
+type Options = {
+	controlRotateAngleRad: number;
+	circleDiameterPx?: number;
+	useDimensionsBasedSize?: boolean;
+	clickCancelCondition: () => boolean;
+};
+export declare class ControlTap {
+	element: HTMLDivElement;
+	controlRotateAngleRad: number;
+	clickCancelCondition: () => boolean;
+	circleDiameterPx: number;
+	useDimensionsBasedSize: boolean;
+	constructor({ controlRotateAngleRad, clickCancelCondition, circleDiameterPx, useDimensionsBasedSize }: Options);
+	onElementClick: (e: MouseEvent) => void;
+	onAnimationEnd: (e: TransitionEvent) => void;
+}
+export {};

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

@@ -0,0 +1 @@
+export * from "./ControlTap";

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

@@ -1,6 +1,6 @@
 export declare const CONTROL_TAP_CLASSNAME_PREFIX = "interactive-control-tap";
 export declare const controlTapClassNames: {
-    common: string;
-    animation: string;
-    visible: string;
+	common: string;
+	animation: string;
+	visible: string;
 };

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

@@ -0,0 +1,71 @@
+import { type ISubscription, type IValueSubject } from "@vkontakte/videoplayer-shared";
+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 { CustomError } from "../../../utils/Error";
+import type { SelectBranchesType } from "./SelectBranches";
+import type { IgnoreExpectState, AnimationsFeatureToggles, IInteractiveOptions } from "../types";
+import type { ChoiceContainer } from "../containers";
+import { type GlobalEvents } from "./events";
+import { GameStates } from "./gameUtils";
+type Features = Pick<AnimationsFeatureToggles, "controlsHideAnimation"> & Pick<IInteractiveOptions, "enableAvPlayerSupport">;
+type ConstructorArg = {
+	player: IPlayer;
+	container: ChoiceContainer;
+	branches: ChapterBranch[];
+	selectBranches: ReturnType<SelectBranchesType>;
+	interactiveEvents: InteractiveEventsType;
+	globalEventEmitter: EventEmitter;
+	globalEvents: GlobalEvents;
+	getContainerEventState: () => IgnoreExpectState;
+	permanentTextControls: boolean;
+	interactiveTimeOpenUri: boolean;
+	disabledControls$: IValueSubject<boolean>;
+	onRemove: () => void;
+	onError: (error: CustomError) => void;
+	disableTextControlContainerVisibilityEvents?: boolean;
+	features: Features;
+};
+export declare class GameController {
+	container: ChoiceContainer;
+	branches: ChapterBranch[];
+	selectBranches: ReturnType<SelectBranchesType>;
+	subscription: ISubscription;
+	player: IPlayer;
+	interactiveEvents: InteractiveEventsType;
+	getContainerEventState: () => IgnoreExpectState;
+	isPermanentText: boolean;
+	interactiveTimeOpenUri: boolean;
+	disabledControls$: IValueSubject<boolean>;
+	onRemove: () => void;
+	globalEventEmitter: EventEmitter;
+	gameState: GameStates;
+	isSelectedControlEvent: boolean;
+	isSelectedContainerEvent: boolean;
+	globalEvents: GlobalEvents;
+	onError: ConstructorArg["onError"];
+	disableTextControlContainerVisibilityEvents: boolean;
+	features: Features;
+	constructor({ player, container, branches, selectBranches, interactiveEvents, globalEvents, globalEventEmitter, getContainerEventState, permanentTextControls, interactiveTimeOpenUri, disabledControls$, onRemove, onError, disableTextControlContainerVisibilityEvents, features }: ConstructorArg);
+	private emitContainerVisibilityEvent;
+	registerEvents(): void;
+	hide: () => void;
+	show: () => void;
+	selectContainerEvent(isEOV?: boolean): void;
+	onStartTime(): void;
+	onEndTime(): void;
+	onBeforeStartTime(): void;
+	onEndOfVideo: () => void;
+	whilePlaying: () => void;
+	onResize(isInteractiveTime: boolean): void;
+	reset(): void;
+	removeView(withTransition?: boolean | undefined): void;
+	fakeRemoveView(remove?: boolean): void;
+	updateControlsShadowStyles(isDark?: boolean): void;
+	toggleBlinkAnimation(value: boolean): void;
+	isInteracted(): boolean;
+	isRemovedOrDestroyed(includeWillRemovedState?: boolean): boolean;
+	destroy(withTransition?: boolean): void;
+}
+export {};

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

@@ -0,0 +1,30 @@
+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: (args: GetAndRemoveArgType) => boolean;
+	add: (args: TMapFlattened) => void;
+	removeAll: () => void;
+	get: (args: GetAndRemoveArgType) => TMapPriority | TMapInitiator | TPayload[] | null;
+	getLte: (timestamp: number) => TMap;
+	getGte: (timestamp: number) => TMap;
+};
+export {};

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

@@ -0,0 +1,51 @@
+import { Subject } from "@vkontakte/videoplayer-shared";
+import type { IValueSubject, Nullable } from "@vkontakte/videoplayer-shared";
+import type { EventEmitter } from "../../../utils/EventEmitter";
+import type { Manifest, VideoId } from "../../../manifest";
+import type { VideoInfo } from "..";
+import type { Interactives } from "..";
+import { CustomError } from "../../../utils/Error";
+export interface HistoryApi {
+	get: (rawId: string) => Promise<number[]>;
+	save: (rawId: string, videoIds: number[]) => Promise<void>;
+}
+export interface HistorySettings {
+	maxLength: number;
+	initChapterId?: string;
+}
+interface HistoryControllerParams {
+	globalEventEmitter: EventEmitter;
+	interactiveController: Interactives;
+	settings: HistorySettings;
+	videoId?: string;
+	historyApi?: Nullable<HistoryApi>;
+}
+export interface HistoryControllerState {
+	history$: IValueSubject<string[]>;
+	hasPrevChapter$: IValueSubject<boolean>;
+	prevChapter$: IValueSubject<Nullable<string>>;
+	isInitialChapter$: IValueSubject<boolean>;
+	isGoBackLimited$: IValueSubject<boolean>;
+}
+interface HistoryInitedEventData {
+	initChapterId: string;
+	videosInfo?: VideoInfo[];
+}
+export default class HistoryController {
+	#private;
+	state: HistoryControllerState;
+	events: {
+		inited$: Subject<HistoryInitedEventData>;
+		destroyed$: Subject<void>;
+		error$: Subject<CustomError>;
+	};
+	constructor({ globalEventEmitter, videoId, interactiveController, historyApi, settings }: HistoryControllerParams);
+	setManifest(manifest: Manifest): Promise<void>;
+	get inited(): boolean;
+	updateHistory(chapterIds: string[], shouldSave?: boolean): Promise<void>;
+	goBack(): Promise<void>;
+	getProjectHistory(): Promise<void>;
+	getInitialChapterId(): string;
+	getInitialVideoId(): VideoId | null;
+	destroy(): void;
+}

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

@@ -0,0 +1,32 @@
+import { type Container } from "../../../manifest";
+import { type TPayload, type TGroupsStack } from "./GroupsStack";
+import type { IPlayer } from "@vkontakte/videoplayer-core";
+type AddMethodParamType = Parameters<TGroupsStack["add"]>[0];
+type RemoveMethodParamType = Parameters<TGroupsStack["remove"]>[0];
+export interface ContainersEventsCallStateType {
+	setCalled: (args: {
+		timestamp: number;
+		id: string;
+	}) => void;
+	setData: (containers?: Container[]) => void;
+	resetCalled: (timestamp: number) => void;
+	isReady: (timestamp: number) => boolean;
+	release: () => void;
+}
+export interface InteractiveEventsType {
+	setPlayer: (player: IPlayer) => void;
+	add: (args: AddMethodParamType) => void;
+	remove: (args: RemoveMethodParamType) => void;
+	exec: (timestamp: number) => void;
+	execEndOfVideo: () => void;
+	listen: () => void;
+	unlisten: () => void;
+	release: () => void;
+	containersEventsCallState: ContainersEventsCallStateType;
+	getPreparedToExecActions: (timestamp?: number) => TPayload[];
+}
+/**
+* Executes an events at different times of the current chapter
+*/
+export declare function InteractiveEvents(player: IPlayer, interactiveTimeOpenUri: boolean): InteractiveEventsType;
+export {};

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

@@ -0,0 +1,15 @@
+import type { IPlayer } from "@vkontakte/videoplayer-core";
+import type { Nullable } from "@vkontakte/videoplayer-shared";
+import type { CssVarsManager } from "../../../utils/CssVarsManager";
+type ResizeManagerArg = () => {
+	parentElement: HTMLElement;
+	cssVarsManager: CssVarsManager;
+	player?: Nullable<IPlayer>;
+	fns?: AnyFn[];
+};
+export declare function ResizeManager(getOptions: ResizeManagerArg): {
+	resizeObserver: ResizeObserver;
+	calc: () => void;
+	release: () => void;
+};
+export {};

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

@@ -0,0 +1,23 @@
+import type { Chapter } from "../../../manifest";
+import type { SelectBranchesArg, OnControlEventArg, ChangeChapterArg, ContinuePlaybackArg, ExpectEventHandlerArg, OnChapterEventArg, OnContainerEventArg, OnExpectEventArg, SetManifestContainerEventsArg, OpenURIArg, ActionMap, AnyAction, AfterExpectActionType } from "./SelectBranches.types";
+export declare const defaultArgs: {
+	readonly shouldOpenNow: true;
+	readonly isDetachContainer: true;
+};
+export declare const AFTER_EXPECT_ACTION: AfterExpectActionType;
+export declare const extendArgs: <T extends AnyAction>(action: T, rewrite?: boolean) => T;
+export type ExtendArgsReturnType = ReturnType<typeof extendArgs>;
+export declare const SelectBranches: ({ globalEventEmitter, globalEvents, player, interactiveEvents }: SelectBranchesArg) => {
+	onControlEvent: (arg: OnControlEventArg) => void;
+	onContainerEvent: (arg: OnContainerEventArg) => void;
+	onChapterEvent: (arg: OnChapterEventArg) => (() => ChangeChapterArg<"chapter">) | (() => ContinuePlaybackArg<"chapter">) | (() => OpenURIArg<"chapter">) | undefined;
+	onExpectEvent: <T extends keyof ActionMap>(arg: OnExpectEventArg<T>) => void;
+	expectEventHandler: <T extends keyof ActionMap>(arg: ExpectEventHandlerArg<T>) => void;
+	setManifestChapterEvents: (chapter: Chapter) => void;
+	setManifestContainerEvents: (arg: SetManifestContainerEventsArg) => void;
+	stopExpect: () => void;
+	state: {
+		isExpect: boolean;
+	};
+};
+export type SelectBranchesType = typeof SelectBranches;

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

@@ -0,0 +1,78 @@
+import type { ChapterContainer, Control, ChapterBranch, ControlEvent, ContainerEvent, ChapterEvent } from "../../../manifest";
+import type { EventEmitter } from "../../../utils/EventEmitter";
+import type { IPlayer } from "@vkontakte/videoplayer-core";
+import type { InteractiveEventsType } from "./InteractiveEvents";
+import type { GlobalEvents } from "./events";
+import type { Nullable } from "@vkontakte/videoplayer-shared";
+export type SubjectName = "chapter" | "container" | "control";
+export type AfterExpectActionType = "after-expect";
+export type Behaviour = "change-chapter" | "change-manifest";
+export type ControlAfterExpectCallbackType = () => ExpectEventHandlerArg<"control">;
+export type SelectBranchesArg = {
+	globalEventEmitter: EventEmitter;
+	globalEvents: GlobalEvents;
+	player: IPlayer;
+	interactiveEvents: InteractiveEventsType;
+};
+export type OnControlEventArg = {
+	action: ControlEvent["action"];
+	controlType: Control["type"];
+	controlId: Control["id"];
+	containerId: ChapterContainer["id"];
+	onEvent: AnyFn;
+	branches?: ChapterBranch[];
+	isEOV?: () => boolean;
+	isDisabled?: () => boolean;
+};
+export type OnContainerEventArg = {
+	action: ContainerEvent["action"];
+	container: ChapterContainer;
+	autoSelected?: boolean;
+	branches?: ChapterBranch[];
+	isEOV?: boolean;
+};
+export type OnChapterEventArg = {
+	action: ChapterEvent["action"];
+	chapterId: string;
+	branches?: ChapterBranch[];
+};
+export type SetManifestContainerEventsArg = {
+	container: ChapterContainer;
+	branches: ChapterBranch[];
+	isEOV?: boolean;
+};
+export type AnyAction = ControlEvent["action"] | ContainerEvent["action"] | ChapterEvent["action"];
+export type ActionMap = {
+	control: ControlEvent["action"];
+	container: ContainerEvent["action"];
+	chapter: ChapterEvent["action"];
+};
+export type SubjectType<T extends keyof ActionMap> = T extends "control" ? Control["type"] : undefined;
+export type EventActionCommon<T extends keyof ActionMap> = {
+	subjectId: string;
+	subjectName: T;
+	subjectType?: SubjectType<T>;
+};
+export type EventActionCommonWithAction<T extends keyof ActionMap> = EventActionCommon<T> & {
+	action: ActionMap[T];
+};
+export type OpenURIArg<T extends keyof ActionMap> = EventActionCommonWithAction<T> & {
+	payload: {
+		URI?: Nullable<string>;
+	};
+};
+export type ChangeManifestArg<T extends keyof ActionMap> = EventActionCommonWithAction<T> & {
+	payload: {
+		behaviour?: Behaviour;
+	};
+};
+export type ChangeChapterArg<T extends keyof ActionMap> = EventActionCommonWithAction<T> & {
+	payload: {
+		chapterId: string;
+		autoSelect: boolean;
+		behaviour?: Behaviour;
+	};
+};
+export type ContinuePlaybackArg<T extends keyof ActionMap> = EventActionCommonWithAction<T>;
+export type OnExpectEventArg<T extends keyof ActionMap> = EventActionCommon<T>;
+export type ExpectEventHandlerArg<T extends keyof ActionMap> = EventActionCommon<T>;

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

@@ -1,25 +1,25 @@
 /**
- * use normalizeRadians before use
- */
+* use normalizeRadians before use
+*/
 export declare function isPositiveXAxis(angle: number): boolean;
 /**
- * use normalizeRadians before use
- */
+* use normalizeRadians before use
+*/
 export declare function isPositiveYAxis(angle: number): boolean;
 /**
- * use normalizeRadians before use
- */
+* use normalizeRadians before use
+*/
 export declare function isNegativeXAxis(angle: number): boolean;
 /**
- * use normalizeRadians before use
- */
+* use normalizeRadians before use
+*/
 export declare function isNegativeYAxis(angle: number): boolean;
 /**
- *  normalizes to [0, 2π)
- */
+*  normalizes to [0, 2π)
+*/
 export declare function normalizeRadians(rad: number): number;
 /**
- * use normalizeRadians before use
- */
+* use normalizeRadians before use
+*/
 export declare function getQuadrant(rad: number): number | null;
 export declare function radiansToDegrees(rad: number): number;

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

@@ -0,0 +1,4 @@
+import type { AnyControl } from "../../../manifest";
+type Type = Lowercase<AnyControl["type"]> | AnyControl["type"];
+export declare const createControlText: (type: Type) => HTMLElement;
+export {};

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

@@ -0,0 +1,13 @@
+import { ErrorCategoryEnum, ErrorSeverityEnum } from "../../../types";
+import { CustomError } from "../../../utils/Error";
+import type { Subject } from "@vkontakte/videoplayer-shared";
+type EmitOnErrorArg = {
+	emitter$: Subject<CustomError>;
+	error?: unknown;
+	subjectId?: string;
+	message?: string;
+	severity?: ErrorSeverityEnum;
+	category?: ErrorCategoryEnum;
+};
+export declare function emitOnError({ emitter$, error, subjectId, message, severity, category }: EmitOnErrorArg): void;
+export {};

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

@@ -0,0 +1,79 @@
+import type { Subject } from "@vkontakte/videoplayer-shared";
+import type { ChapterChangedData, EachTickData, PlayerChangedData } from "../types";
+import type { CustomError } from "../../../utils/Error";
+import type { Manifest } from "../../../manifest";
+import type { TInteractiveRangeEndedEvent, TInteractivesActionChoiceEvent, TInteractivesActionExecutionEvent, TInteractivesContainerRemoved, TInteractivesContainerFakeRemoved, SubjectName, TInteractivesVisibility } from "./events.types";
+export interface GlobalEvents {
+	noInteraction$: Subject<void>;
+	graphVisibilityChanged$: Subject<boolean>;
+	watchAgainIsClicked$: Subject<string>;
+	chapterChanged$: Subject<ChapterChangedData>;
+	playerChanged$: Subject<PlayerChangedData>;
+	error$: Subject<CustomError>;
+	eachTick$: Subject<EachTickData>;
+	manifestChanged$: Subject<Manifest>;
+	interactiveRangeEnded$: Subject<TInteractiveRangeEndedEvent>;
+	interactiveContainerRemoved$: Subject<TInteractivesContainerRemoved>;
+	interactiveContainerFakeRemoved$: Subject<TInteractivesContainerFakeRemoved>;
+	interactiveActionExecution$: Subject<TInteractivesActionExecutionEvent<SubjectName>>;
+	interactiveActionChoice$: Subject<TInteractivesActionChoiceEvent<SubjectName>>;
+	interactiveVisibilityChanged$: Subject<TInteractivesVisibility<"container">>;
+}
+export declare const EVENT_NAMES: {
+	/**
+	* @deprecated Используйте interactivesInstance.events.graphVisibilityChanged$
+	* & interactivesInstance.events.watchAgainIsClicked$
+	*/
+	readonly graph: "graph";
+	/**
+	* @deprecated Используйте interactivesInstance.events
+	*/
+	readonly interactives: "interactives";
+	/**
+	* @deprecated Используйте interactivesInstance.events.chapterChanged$
+	*/
+	readonly chapterChanged: "chapter-changed";
+	/**
+	* @deprecated Используйте interactivesInstance.events.playerChanged$
+	*/
+	readonly playerChanged: "player-changed";
+	/**
+	* @deprecated Используйте interactivesInstance.events.manifestChanged$
+	*/
+	readonly manifestChanged: "manifest-changed";
+	/**
+	* @deprecated Используйте interactivesInstance.events.error$
+	*/
+	readonly errors: "errors";
+	readonly eachTick: "eachTick";
+	readonly historyInited: "history-inited";
+	readonly historyDestroyed: "history-destroyed";
+};
+/**
+* @deprecated Используйте interactivesInstance.events.graphVisibilityChanged$ &
+* interactivesInstance.events.watchAgainIsClicked$
+*/
+export declare const graphEventTypes: {
+	readonly visibility: "visibility";
+	readonly watchAgainClicked: "watchAgainClicked";
+};
+/**
+* @deprecated use InteractivesEventTypes enum instead
+*/
+export declare const interactivesEventTypes: {
+	readonly actionChoiceCanceled: "action-choice-canceled";
+	readonly actionChoice: "action-choice";
+	readonly actionExecution: "action-execution";
+	readonly visibility: "visibility";
+	readonly containerRemoved: "container-removed";
+	readonly rangeEnded: "range-ended";
+};
+export declare enum InteractivesEventTypes {
+	ACTION_CHOICE_CANCELED = "action-choice-canceled",
+	ACTION_CHOICE = "action-choice",
+	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

@@ -0,0 +1,55 @@
+import type { SubjectName, ActionMap, SubjectType, AfterExpectActionType, Behaviour } from "./SelectBranches.types";
+import type { InteractivesEventTypes } from "./events";
+import type { EventActionTypes } from "../../../manifest";
+import type { ControlEvent, ContainerEvent, ChapterEvent, ChapterContainer, Control } from "../../../manifest";
+import type { InteractiveRange } from "./getInteractiveRanges";
+export type { SubjectName };
+type InteractivesEventTypesValues = `${InteractivesEventTypes}`;
+type InteractivesEventTypesValuesChapter = InteractivesEventTypes.ACTION_CHOICE | InteractivesEventTypes.ACTION_CHOICE_CANCELED | InteractivesEventTypes.ACTION_EXECUTION;
+type InteractivesEventTypesValuesContainer = InteractivesEventTypesValues;
+type InteractivesEventTypesValuesControl = InteractivesEventTypesValuesChapter | InteractivesEventTypes.VISIBILITY;
+type InteractiveEventType<T extends SubjectName> = T extends "container" ? InteractivesEventTypesValuesContainer : InteractivesEventTypesValuesControl;
+type TInteractiveCommon<
+	T extends SubjectName,
+	U extends InteractiveEventType<T>
+> = {
+	subjectId: string;
+	subjectName: T;
+	type: U;
+};
+export type TInteractivesVisibility<T extends Exclude<SubjectName, "chapter">> = TInteractiveCommon<T, InteractivesEventTypes.VISIBILITY> & {
+	visibility: boolean;
+	isFirst?: boolean;
+};
+type EventActionTypesValues = `${EventActionTypes}`;
+export type TInteractiveRangeEndedEvent = {
+	type: InteractivesEventTypes.RANGE_ENDED;
+	payload: InteractiveRange;
+};
+type NonChapterChangeEvents = EventActionTypes.openURI | EventActionTypes.continuePlayback | EventActionTypes.expect;
+type TInteractivesActionExecEventPayload<T extends EventActionTypesValues> = T extends Exclude<EventActionTypesValues, NonChapterChangeEvents> ? Partial<{
+	chapterId: string;
+	autoSelect: boolean;
+	behaviour: Behaviour;
+	manifestURL: string;
+}> : undefined;
+export type TInteractivesActionExecutionEvent<T extends SubjectName> = TInteractiveCommon<T, InteractivesEventTypes.ACTION_EXECUTION> & {
+	actionType: ActionMap[T]["type"] | AfterExpectActionType;
+	subjectType?: SubjectType<T>;
+	payload?: TInteractivesActionExecEventPayload<ActionMap[T]["type"]>;
+};
+type TControlPayloadExtra = {
+	containerId: string;
+	invokeImmediately: boolean;
+};
+type TInteractivesActionChoiceEventPayload<T extends SubjectName> = T extends "chapter" ? ChapterEvent["action"]["args"] : T extends "container" ? ContainerEvent["action"]["args"] & Pick<TControlPayloadExtra, "invokeImmediately"> : ControlEvent["action"]["args"] & TControlPayloadExtra;
+type TSubjectTypeValues<T extends SubjectName> = T extends "chapter" ? undefined : T extends "container" ? ChapterContainer["type"] : Control["type"];
+export type TInteractivesActionChoiceEvent<T extends SubjectName> = TInteractiveCommon<T, InteractivesEventTypes.ACTION_CHOICE | InteractivesEventTypes.ACTION_CHOICE_CANCELED> & {
+	subjectType?: TSubjectTypeValues<T>;
+	actionType: EventActionTypesValues;
+	payload: TInteractivesActionChoiceEventPayload<T>;
+};
+export type TInteractivesContainerRemoved = TInteractiveCommon<"container", InteractivesEventTypes.CONTAINER_REMOVED>;
+export type TInteractivesContainerFakeRemoved = TInteractiveCommon<"container", InteractivesEventTypes.CONTAINER_FAKE_REMOVED> & {
+	removeAllOpenURI: boolean;
+};

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

@@ -1,24 +1,24 @@
-import { type ChapterBranch } from '#/manifest';
-import type { Nullable } from '@vkontakte/videoplayer-shared';
+import { type ChapterBranch } from "../../../manifest";
+import type { Nullable } from "@vkontakte/videoplayer-shared";
 /**
- * Returns a random number in the range [0, limit) or [limit, 0) if the 'limit'
- * value is negative
- */
+* Returns a random number in the range [0, limit) or [limit, 0) if the 'limit'
+* value is negative
+*/
 export declare const getRandomNumber: (limit: number) => number;
 /**
- *  Finds the value with minimal weight number
- */
+*  Finds the value with minimal weight number
+*/
 export declare const minFallbackStrategy: (branches: ChapterBranch[]) => Nullable<ChapterBranch>;
 /**
- *  Finds the value with maximal weight number
- */
+*  Finds the value with maximal weight number
+*/
 export declare const maxFallbackStrategy: (branches: ChapterBranch[]) => Nullable<ChapterBranch>;
 /**
- *  Finds first branch with `isDefault === true` value
- */
+*  Finds first branch with `isDefault === true` value
+*/
 export declare const defaultFallbackStrategy: (branches: ChapterBranch[]) => ChapterBranch | undefined;
 /**
- *  Returns the random branch
- */
+*  Returns the random branch
+*/
 export declare const weightlessRandomFallbackStrategy: (branches: ChapterBranch[]) => ChapterBranch;
 export declare const weightyRandomFallbackStrategy: (branches: ChapterBranch[]) => ChapterBranch;

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

@@ -0,0 +1,12 @@
+type Reverse<T extends unknown[]> = T extends [infer First, ...infer Rest] ? [...Reverse<Rest>, First] : T;
+export declare function reverseArgs<Fn extends AnyFn>(fn: Fn): (...args: Reverse<Parameters<Fn>>) => ReturnType<Fn>;
+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 {};

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

@@ -1,14 +1,14 @@
-import { type Control, type Chapter, type ChapterContainer } from '#/manifest';
-import type { GameController } from './GameController';
-import type { IgnoreExpectState } from '#/modules/Interactives/types';
+import { type Control, type Chapter, type ChapterContainer } from "../../../manifest";
+import type { GameController } from "./GameController";
+import type { IgnoreExpectState } from "../types";
 export declare enum GameStates {
-    nothing = 0,
-    beforeInteractive = 1,
-    interactive = 2,
-    afterInteractive = 3,
-    end = 4,
-    removed = 5,
-    destroyed = 6
+	nothing = 0,
+	beforeInteractive = 1,
+	interactive = 2,
+	afterInteractive = 3,
+	end = 4,
+	removed = 5,
+	destroyed = 6
 }
 export declare const isControlsExist: (controls: Control[]) => boolean;
 export declare const isLastChapter: (chapter: Chapter) => boolean;
@@ -16,7 +16,7 @@ export declare const hasEndTemplate: (chapter: Chapter) => boolean;
 export declare const isBeforeStartTime: (currentTime: number, container: ChapterContainer) => boolean;
 export declare const isInteractiveTime: (currentTime: number, container: ChapterContainer) => boolean;
 export declare const isAfterInteractiveTime: (currentTime: number, container: ChapterContainer) => boolean;
-type AnyEvent = (ChapterContainer | Chapter | Control)['events'];
+type AnyEvent = (ChapterContainer | Chapter | Control)["events"];
 type ExtractItemFromArray<T> = T extends (infer U)[] ? U : never;
 export declare const isExpectEvent: (events?: AnyEvent) => boolean;
 export declare const getExpectEvent: (events?: AnyEvent) => ExtractItemFromArray<AnyEvent> | undefined;
@@ -25,18 +25,18 @@ export declare const isOneTextCtrlContainer: (controls: Control[]) => boolean;
 export declare function excludeTextControl(containers?: ChapterContainer[]): ChapterContainer[];
 export declare const isEOVEndTime: (target: HTMLVideoElement, endTime: ChapterContainer["endTime"]) => boolean;
 /**
- * @param {GameController[]} [gameControllers=[]] список контрллеров
- * @param {(number | null | undefined)} [expectTime=Infinity] expectTime = endTime - какой expectTime мы ищем
- * @param {string[]} [ignoreIds=[]] какие контейнеры игнорировать
- */
+* @param {GameController[]} [gameControllers=[]] список контрллеров
+* @param {(number | null | undefined)} [expectTime=Infinity] expectTime = endTime - какой expectTime мы ищем
+* @param {string[]} [ignoreIds=[]] какие контейнеры игнорировать
+*/
 export declare function getGameControllerContainersWithExpect(gameControllers?: GameController[], expectTime?: number | null | undefined, ignoreIds?: string[]): GameController[];
 type ExecForAllExpectContainersParamsType = {
-    gameControllers: GameController[];
-    subjectName: string;
-    subjectId: string;
-    execFn: (gameController: GameController) => void;
+	gameControllers: GameController[];
+	subjectName: string;
+	subjectId: string;
+	execFn: (gameController: GameController) => void;
 };
-export declare function execForAllExpectContainers({ gameControllers, subjectName, subjectId, execFn, }: ExecForAllExpectContainersParamsType): void;
+export declare function execForAllExpectContainers({ gameControllers, subjectName, subjectId, execFn }: ExecForAllExpectContainersParamsType): void;
 export declare function isControlHasOpenURIEvent(control: Control): boolean;
 export declare const evaluateContainerEventStatus: (container: ChapterContainer, gameControllers: GameController[]) => IgnoreExpectState;
 export {};