@vkontakte/videoplayer-interactive 1.0.29-dev.e881d3ff.0 → 1.0.30-beta.0

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

@@ -2,6 +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';
 export interface GlobalEvents {
     noInteraction$: Subject<void>;
     graphVisibilityChanged$: Subject<boolean>;
@@ -11,13 +12,21 @@ export interface GlobalEvents {
     error$: Subject<CustomError>;
     eachTick$: Subject<EachTickData>;
     manifestChanged$: Subject<Manifest>;
+    interactiveRangeEnded$: Subject<TInteractiveRangeEndedEvent>;
+    interactiveContainerRemoved$: Subject<TInteractivesContainerRemoved>;
+    interactiveActionExecution$: Subject<TInteractivesActionExecutionEvent<SubjectName>>;
+    interactiveActionChoice$: Subject<TInteractivesActionChoiceEvent<SubjectName>>;
+    interactiveVisibilityChanged$: Subject<TInteractivesVisibility<'container'>>;
 }
 export declare const EVENT_NAMES: {
     /**
-    * @deprecated Используйте interactivesInstance.events.graphVisibilityChanged$
-    * & interactivesInstance.events.watchAgainIsClicked$
-    */
+     * @deprecated Используйте interactivesInstance.events.graphVisibilityChanged$
+     * & interactivesInstance.events.watchAgainIsClicked$
+     */
     readonly graph: "graph";
+    /**
+     * @deprecated Используйте interactivesInstance.events
+     */
     readonly interactives: "interactives";
     /**
      * @deprecated Используйте interactivesInstance.events.chapterChanged$
@@ -31,24 +40,39 @@ export declare const EVENT_NAMES: {
      * @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";
 };
+/**
+ * @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 containerFakeRemoved: "container-fake-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",
+    RANGE_ENDED = "range-ended"
+}

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

@@ -0,0 +1,47 @@
+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';
+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 TInteractivesActionChoiceEventPayload<T extends SubjectName> = T extends 'chapter' ? ChapterEvent['action']['args'] : T extends 'container' ? ContainerEvent['action']['args'] : ControlEvent['action']['args'] & {
+    containerId: string;
+};
+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>;

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>;