@vkontakte/videoplayer-interactive 1.0.61 → 1.0.62-dev.04ce2cd1.0

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

@@ -1,77 +1,77 @@
-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 { 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'>;
+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;
+	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;
+	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;
+	action: ContainerEvent["action"];
+	container: ChapterContainer;
+	autoSelected?: boolean;
+	branches?: ChapterBranch[];
+	isEOV?: boolean;
 };
 export type OnChapterEventArg = {
-    action: ChapterEvent['action'];
-    chapterId: string;
-    branches?: ChapterBranch[];
+	action: ChapterEvent["action"];
+	chapterId: string;
+	branches?: ChapterBranch[];
 };
 export type SetManifestContainerEventsArg = {
-    container: ChapterContainer;
-    branches: ChapterBranch[];
-    isEOV?: boolean;
+	container: ChapterContainer;
+	branches: ChapterBranch[];
+	isEOV?: boolean;
 };
-export type AnyAction = ControlEvent['action'] | ContainerEvent['action'] | ChapterEvent['action'];
+export type AnyAction = ControlEvent["action"] | ContainerEvent["action"] | ChapterEvent["action"];
 export type ActionMap = {
-    control: ControlEvent['action'];
-    container: ContainerEvent['action'];
-    chapter: ChapterEvent['action'];
+	control: ControlEvent["action"];
+	container: ContainerEvent["action"];
+	chapter: ChapterEvent["action"];
 };
-export type SubjectType<T extends keyof ActionMap> = T extends 'control' ? Control['type'] : undefined;
+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>;
+	subjectId: string;
+	subjectName: T;
+	subjectType?: SubjectType<T>;
 };
 export type EventActionCommonWithAction<T extends keyof ActionMap> = EventActionCommon<T> & {
-    action: ActionMap[T];
+	action: ActionMap[T];
 };
 export type OpenURIArg<T extends keyof ActionMap> = EventActionCommonWithAction<T> & {
-    payload: {
-        URI?: Nullable<string>;
-    };
+	payload: {
+		URI?: Nullable<string>;
+	};
 };
 export type ChangeManifestArg<T extends keyof ActionMap> = EventActionCommonWithAction<T> & {
-    payload: {
-        behaviour?: Behaviour;
-    };
+	payload: {
+		behaviour?: Behaviour;
+	};
 };
 export type ChangeChapterArg<T extends keyof ActionMap> = EventActionCommonWithAction<T> & {
-    payload: {
-        chapterId: string;
-        autoSelect: boolean;
-        behaviour?: Behaviour;
-    };
+	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>;

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

@@ -1,25 +1,25 @@
 /**
- * use normalizeRadians before use
- */
-export declare function isPositiveXAxis(angle: number): angle is 0;
+* 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

@@ -1,4 +1,4 @@
-import type { AnyControl } from '../../../manifest';
-type Type = Lowercase<AnyControl['type']> | AnyControl['type'];
+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

@@ -1,13 +1,13 @@
-import { ErrorCategoryEnum, ErrorSeverityEnum } from '../../../types';
-import { CustomError } from '../../../utils/Error';
-import { Subject } from '@vkontakte/videoplayer-shared';
+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;
+	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 declare function emitOnError({ emitter$, error, subjectId, message, severity, category }: EmitOnErrorArg): void;
 export {};

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

@@ -1,79 +1,79 @@
-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, TInteractivesContainerFakeRemoved, SubjectName, TInteractivesVisibility } from './events.types';
+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'>>;
+	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$
+	*/
+	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$
- */
+* @deprecated Используйте interactivesInstance.events.graphVisibilityChanged$ &
+* interactivesInstance.events.watchAgainIsClicked$
+*/
 export declare const graphEventTypes: {
-    readonly visibility: "visibility";
-    readonly watchAgainClicked: "watchAgainClicked";
+	readonly visibility: "visibility";
+	readonly watchAgainClicked: "watchAgainClicked";
 };
 /**
- * @deprecated use InteractivesEventTypes enum instead
- */
+* @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";
+	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"
+	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

@@ -1,52 +1,55 @@
-import type { SubjectName, ActionMap, SubjectType, AfterExpectActionType, Behaviour } from './SelectBranches.types';
-import { InteractivesEventTypes } from './events';
-import { EventActionTypes } from '../../../manifest';
-import type { ControlEvent, ContainerEvent, ChapterEvent, ChapterContainer, Control } from '../../../manifest';
-import type { InteractiveRange } from './getInteractiveRanges';
+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;
+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;
+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: 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;
+	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']>;
+	actionType: ActionMap[T]["type"] | AfterExpectActionType;
+	subjectType?: SubjectType<T>;
+	payload?: TInteractivesActionExecEventPayload<ActionMap[T]["type"]>;
 };
 type TControlPayloadExtra = {
-    containerId: string;
-    invokeImmediately: boolean;
+	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'];
+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>;
+	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;
+export type TInteractivesContainerRemoved = TInteractiveCommon<"container", InteractivesEventTypes.CONTAINER_REMOVED>;
+export type TInteractivesContainerFakeRemoved = TInteractiveCommon<"container", InteractivesEventTypes.CONTAINER_FAKE_REMOVED> & {
+	removeAllOpenURI: boolean;
 };

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

@@ -1,23 +1,24 @@
-import { type ChapterBranch } from '../../../manifest';
+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
- */
-export declare const minFallbackStrategy: (branches: ChapterBranch[]) => ChapterBranch | null;
+*  Finds the value with minimal weight number
+*/
+export declare const minFallbackStrategy: (branches: ChapterBranch[]) => Nullable<ChapterBranch>;
 /**
- *  Finds the value with maximal weight number
- */
-export declare const maxFallbackStrategy: (branches: ChapterBranch[]) => ChapterBranch | null;
+*  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

@@ -1,5 +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 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/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,26 +16,27 @@ 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) => import("../../../manifest").ControlEvent | import("../../../manifest").ChapterEvent | import("../../../manifest").ContainerEvent | undefined;
+export declare const getExpectEvent: (events?: AnyEvent) => ExtractItemFromArray<AnyEvent> | undefined;
 export declare const isOneCtrlOneContainer: (controls: Control[]) => boolean;
 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 {};

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

@@ -1,11 +1,11 @@
-import { type Container } from '../../../manifest';
+import { type Container } from "../../../manifest";
 export type Subject = {
-    id: string;
-    isRemoved: boolean;
+	id: string;
+	isRemoved: boolean;
 };
 export type InteractiveRange = {
-    subjects: Subject[];
-    range: [number, number];
+	subjects: Subject[];
+	range: [number, number];
 };
 export type InteractiveRanges = Array<InteractiveRange>;
 export declare const getInteractiveRanges: (containers?: Container[]) => InteractiveRanges;