@vkontakte/videoplayer-interactive 1.0.30-dev.9aa27113.0 → 1.0.30-dev.b736679d.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vkontakte/videoplayer-interactive",
-  "version": "1.0.30-dev.9aa27113.0",
+  "version": "1.0.30-dev.b736679d.0",
   "author": "vk.com",
   "description": "Movika interactive SDK",
   "homepage": "https://vk.com",
@@ -51,8 +51,8 @@
   "dependencies": {
     "@interactiveplatform/movika-graph-editor": "1.11.0",
     "@interactiveplatform/movika-manifest": "^1.0.0",
-    "@vkontakte/videoplayer-core": "2.0.124-dev.09b35b2f.0",
-    "@vkontakte/videoplayer-shared": "1.0.53-dev.d276b825.0",
-    "@vkontakte/videoplayer-statistics": "1.0.70-dev.929095b2.0"
+    "@vkontakte/videoplayer-core": "2.0.124-dev.c81f9f40.0",
+    "@vkontakte/videoplayer-shared": "1.0.53-dev.9233f32f.0",
+    "@vkontakte/videoplayer-statistics": "1.0.70-dev.f572f826.0"
   }
 }

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

@@ -12,11 +12,11 @@ declare enum INTERACTIVE_APP_STATES {
     destroyed = 3
 }
 export declare class Interactives {
-    private subscription;
+    private playerSubscriptions;
+    private subscriptions;
     private globalEventEmitter;
     private eventsSubs;
     private animation;
-    private eventManager;
     private seekToInteractiveController;
     private endedRanges;
     private gameControllers;
@@ -35,6 +35,7 @@ export declare class Interactives {
     private graph;
     private lastFrame;
     private noInteractionTimeout;
+    private frameAverageColor;
     appState: INTERACTIVE_APP_STATES;
     state: {
         prevChapter$: ValueSubject<Nullable<Chapter>>;
@@ -53,17 +54,27 @@ export declare class Interactives {
     };
     events: GlobalEvents;
     constructor(options: IOptionalInteractiveOptions);
+    private getVideoFrameAverageColorInfo;
     private emitErrorEvent;
     private clearHistoryIfEnded;
     private initSubscriptions;
+    private getGameControllerContainersWithExpect;
+    private execForAllExpectContainers;
+    private updateControlsShadowStyles;
+    private toggleControlsCTAAnimation;
     private initSeamless;
     private handleSeamlessPlayerChanged;
     private onPlaybackStarted;
     private handlePositionChange;
     private registerVideoEvents;
-    private removeControllers;
+    removeGameControllersViews: ({ includeTextControls }?: {
+        includeTextControls?: boolean | undefined;
+    }) => void;
+    destroyGameControllers: ({ includeTextControls }?: {
+        includeTextControls?: boolean | undefined;
+    }) => void;
     private setGameControllers;
-    private filterGameControllers;
+    private addGameControllers;
     private checkIfSeekable;
     private updateLastEventInfo;
     private pushChapterToHistory;
@@ -87,7 +98,7 @@ export declare class Interactives {
     setVisitedChapters(chapterIds: string[]): void;
     updateGraphVideosInfo(videosInfo: VideoInfo[]): void;
     deadEndCheck(): boolean;
-    allControlsAreRemoved(): boolean;
+    allControlsAreRemoved(includeWillRemovedState?: boolean): boolean;
     isEndedExpectation(): boolean;
     playPrevChapter(): void;
     setDisabledControls(value: boolean): void;
@@ -114,9 +125,9 @@ export declare class Interactives {
         graph: Nullable<import("@interactiveplatform/movika-manifest").GraphDesign>;
     };
     getCurrentManifest(): Nullable<Manifest>;
-    on(eventName: string, fn: Function): this;
-    off(eventName: string, fn: Function): this;
-    once(eventName: string, fn: Function): this;
+    on(eventName: string, fn: AnyFn): this;
+    off(eventName: string, fn: AnyFn): this;
+    once(eventName: string, fn: AnyFn): this;
     destroy(): void;
 }
 export {};

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

@@ -9,5 +9,9 @@ export declare class RelativeLayout extends Layout {
     constructor(layout: ChapterContainer['layout']);
     setContainerLayout(target: HTMLElement): void;
     setControlLayout(target: HTMLElement, layoutParams: ControlLayoutParams): void;
+    getComputedDimensions(mountedElement: HTMLElement, layoutParams: ControlLayoutParams): {
+        width: number;
+        height: number;
+    };
 }
 export {};

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

@@ -1,18 +1,28 @@
 import { Container } from './Container';
-import { ChapterContainer } from "../../../manifest";
-import { ControlEventCallback } from "../../../modules/Interactives/controls";
-export declare const createChoiceContainer: (container: ChapterContainer, rootElement: HTMLElement) => ChoiceContainer | undefined;
+import { ChapterContainer, ControlTypes } from '../../../manifest';
+import type { ChoiceContainerOptions, ContainerCreateView } from '../../../modules/Interactives/controls';
+export declare const createChoiceContainer: (container: ChapterContainer, rootElement: HTMLElement, options: ChoiceContainerOptions) => ChoiceContainer | undefined;
 export declare class ChoiceContainer extends Container {
     private rootElement;
     private layout;
     isRemoved: boolean;
     isDisabled: boolean;
-    constructor(container: ChapterContainer, rootElement: HTMLElement);
-    createView(eventCallback: ControlEventCallback): HTMLElement;
+    willRemoved: boolean;
+    constructor(container: ChapterContainer, rootElement: HTMLElement, options: ChoiceContainerOptions);
+    createView({ eventCallback, videoDurationMs }: ContainerCreateView): HTMLElement;
+    onProgress(currentTime: number, isInteractive: boolean): void;
+    onResize(): void;
     hide(): void;
     show(): void;
     enable(): void;
     disable(): void;
-    removeView(): void;
+    removeView(withTransition?: boolean, useDelay?: boolean): void;
+    private onTransitionEnd;
+    removeAllControls(withTransition?: boolean): void;
+    removeNonInteractedControls(withTransition?: boolean): void;
+    isInteracted(): boolean;
     getElement(): HTMLElement | null;
+    toggleCTAAnimation(enable?: boolean): void;
+    updateControlsShadowStyles(isFrameBased?: boolean): void;
+    setupControlsBlinkAnimSync(ctrlElement: HTMLElement, controlType: Extract<`${ControlTypes}`, 'Button' | 'Area'>): void;
 }

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

@@ -1,12 +1,15 @@
-import Control from '../../../modules/Interactives/controls/Control';
-import { ChapterContainer } from "../../../manifest";
-import { ControlCreator } from "../../../modules/Interactives/controls";
+import { Control } from '../../../modules/Interactives/controls/Control';
+import type { ChapterContainer } from '../../../manifest';
+import type { ControlCreator, Options } from '../../../modules/Interactives/controls';
+import { type ChoiceContainerOptions } from '../../../modules/Interactives/controls';
 export declare class Container {
     container: ChapterContainer;
-    private factories;
     controls: Control[];
-    constructor(container: ChapterContainer);
-    addControlFactory(type: string, factory: ControlCreator): void;
+    options?: Options;
+    private factories;
+    constructor(container: ChapterContainer, options?: Options);
+    addControlFactory(type: string, factory: ControlCreator<any>): void;
+    featureIsEnabled(name: keyof ChoiceContainerOptions['features']): boolean | undefined;
     removeControlFactory(type: string): void;
     private setControls;
     private chooseControls;

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

@@ -1,2 +1,22 @@
-import { type ControlCreator } from './types';
-export declare const createAreaControl: ControlCreator;
+import { Control } from './Control';
+import { type ControlCreator, type CreateViewParams, type TControl, type ChoiceContainerOptions } from './types';
+import { TapElement } from '../utils/TapElement';
+export declare const createAreaControl: ControlCreator<ChoiceContainerOptions, AreaControl>;
+declare class AreaControl extends Control {
+    tapElement?: TapElement;
+    constructor(control: TControl, options?: ChoiceContainerOptions);
+    createView({ parentElement, callbacks }: CreateViewParams): void;
+    onControlSelect: () => void;
+    updateShadowStyles(dependOnFrameTone?: boolean): void;
+    disable(): void;
+    enable(): void;
+    setShowTimeRange(): void;
+    onProgress(): void;
+    onResize(): void;
+    removeView(withTransition?: boolean): void;
+    onTransitionEnd: (event: TransitionEvent) => void;
+    removeListeners(): void;
+    getElement(): Nullable<HTMLElement>;
+    toggleCTAAnimation(enable?: boolean): void;
+}
+export {};

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

@@ -1,2 +1,27 @@
-import { type ControlCreator } from './types';
-export declare const createButtonControl: ControlCreator;
+import { Control } from './Control';
+import { type ControlCreator, type CreateViewParams, type TControl, type ChoiceContainerOptions } from './types';
+import { FillAnimation } from '../utils/FillAnimation';
+import { TapElement } from '../utils/TapElement';
+export declare const createButtonControl: ControlCreator<ChoiceContainerOptions, ButtonControl>;
+declare class ButtonControl extends Control {
+    startTime?: number;
+    endTime?: number;
+    fillAnimation?: FillAnimation;
+    tapElement?: TapElement;
+    constructor(control: TControl, options?: ChoiceContainerOptions);
+    createView({ parentElement, callbacks }: CreateViewParams): void;
+    onControlSelect: () => void;
+    disable(): void;
+    enable(): void;
+    setShowTimeRange(startTime: number, endTime: number): void;
+    onProgress(currentTime: number): void;
+    updateFillAnimationDimension(): void;
+    onResize(): void;
+    getElement(): Nullable<HTMLElement>;
+    removeView(withTransition?: boolean): void;
+    onTransitionEnd: (event: TransitionEvent) => void;
+    removeListeners(): void;
+    toggleCTAAnimation(enable?: boolean): void;
+    updateShadowStyles(): void;
+}
+export {};

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

@@ -1,20 +1,33 @@
-import type { ControlEventCallback, CreateViewParams, Dimensions, LayoutCallback, TControl } from './types';
+import type { ControlEventCallback, CreateViewParams, Dimensions, Callbacks, TControl, Options, ChoiceContainerOptions } from './types';
 type ControlContainer = {
     element: HTMLElement;
-    dimensions: Dimensions;
+    dimensions: Dimensions<string>;
+    getComputedDimensions: () => Dimensions<number>;
+    isManifestContainerDisabled: () => boolean;
 };
-export default abstract class Control {
+type ClickListener = (event: MouseEvent) => void;
+export declare abstract class Control {
     control: TControl;
-    protected container: Nullable<ControlContainer>;
-    protected controlElement: Nullable<HTMLElement>;
-    private clickListener;
-    protected constructor(control: TControl);
+    options?: Options | undefined;
+    container: Nullable<ControlContainer>;
+    controlElement: Nullable<HTMLElement>;
+    clickListener: Nullable<ClickListener>;
+    isInteracted: boolean;
+    isRemoved: boolean;
+    constructor(control: TControl, options?: Options | undefined);
     abstract createView(params: CreateViewParams): void;
     abstract getElement(): Nullable<HTMLElement>;
     abstract disable(): void;
     abstract enable(): void;
-    protected createContainerElement(layoutCallback: LayoutCallback): void;
-    private createClickListener;
+    abstract onProgress(currentTime: number): void;
+    abstract onResize(): void;
+    abstract setShowTimeRange(startTime: number, endTime: number): void;
+    abstract removeView(withTransition?: boolean): void;
+    abstract toggleCTAAnimation(enable?: boolean): void;
+    abstract updateShadowStyles(isFrameBased?: boolean): void;
+    createContainerElement(callbacks: Callbacks): void;
+    createClickListener(callback: any): ClickListener;
+    featureIsEnabled(name: keyof ChoiceContainerOptions['features']): boolean | undefined;
     setEvents(callback: ControlEventCallback): void;
     removeListeners(): void;
 }

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

@@ -1,24 +1,38 @@
 import type { Control as TControl, ControlEvent, ControlLayoutParams } from '../../../manifest';
-import Control from '../../../modules/Interactives/controls/Control';
+import type { ControlsAnimationFeatureToggles } from '../../../modules/Interactives/types';
+import { Control } from '../../../modules/Interactives/controls/Control';
 export { TControl };
 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 Callbacks = {
+    setControlLayout: (element: HTMLElement, controlLayoutParams: ControlLayoutParams) => void;
+    getComputedDimensions: () => Dimensions<number>;
+    isContainerDisabled?: () => boolean;
 };
-export type LayoutCallback = (element: HTMLElement, controlLayoutParams: ControlLayoutParams) => void;
 export type CreateViewParams = {
     parentElement: HTMLElement;
-    layoutCallback: LayoutCallback;
+    callbacks: Callbacks;
 };
 type ControlEventCallbackParams = {
     action: ControlEvent['action'];
     controlId: string;
     controlType: TControl['type'];
 };
+export type Options = Record<string, unknown>;
+export type ChoiceContainerOptions = {
+    features: Pick<ControlsAnimationFeatureToggles, 'buttonControlInteractiveTimeTimer' | 'areaControlFrameBasedShadow' | 'tapPlaceShow' | 'controlsShowAnimation' | 'controlsCTAAnimation'>;
+};
+export declare function isChoiceContainerOptions(options: Options): options is ChoiceContainerOptions;
 export type ControlEventCallback = (params: ControlEventCallbackParams) => void;
-export type ControlCreator = (control: TControl) => Control | undefined;
+export type ContainerCreateView = {
+    videoDurationMs: number;
+    eventCallback: ControlEventCallback;
+};
+export type ControlCreator<O extends Options = Options, C extends Control = Control> = (control: TControl, options?: O) => C | undefined;

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

@@ -6,9 +6,74 @@ 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("./controls").ChoiceContainerOptions) => import("./containers/ChoiceContainer").ChoiceContainer | undefined;
+    createAreaControl: import("./controls").ControlCreator<import("./controls").ChoiceContainerOptions, {
+        tapElement?: import("./utils/TapElement").TapElement;
+        createView({ parentElement, callbacks }: import("./controls").CreateViewParams): void;
+        onControlSelect: () => void;
+        updateShadowStyles(dependOnFrameTone?: boolean): void;
+        disable(): void;
+        enable(): void;
+        setShowTimeRange(): void;
+        onProgress(): void;
+        onResize(): void;
+        removeView(withTransition?: boolean): void;
+        onTransitionEnd: (event: TransitionEvent) => void;
+        removeListeners(): void;
+        getElement(): Nullable<HTMLElement>;
+        toggleCTAAnimation(enable?: boolean): void;
+        container: Nullable<{
+            element: HTMLElement;
+            dimensions: import("./controls").Dimensions<string>;
+            getComputedDimensions: () => import("./controls").Dimensions<number>;
+            isManifestContainerDisabled: () => boolean;
+        }>;
+        controlElement: Nullable<HTMLElement>;
+        clickListener: Nullable<(event: MouseEvent) => void>;
+        isInteracted: boolean;
+        isRemoved: boolean;
+        control: import("@interactiveplatform/movika-manifest/dist/chapter-COPBtRYg").e;
+        options?: import("./controls").Options;
+        createContainerElement(callbacks: import("./controls").Callbacks): void;
+        createClickListener(callback: any): (event: MouseEvent) => void;
+        featureIsEnabled(name: keyof import("./controls").ChoiceContainerOptions["features"]): boolean | undefined;
+        setEvents(callback: import("./controls").ControlEventCallback): void;
+    }>;
+    createButtonControl: import("./controls").ControlCreator<import("./controls").ChoiceContainerOptions, {
+        startTime?: number;
+        endTime?: number;
+        fillAnimation?: import("./utils/FillAnimation").FillAnimation;
+        tapElement?: import("./utils/TapElement").TapElement;
+        createView({ parentElement, callbacks }: import("./controls").CreateViewParams): void;
+        onControlSelect: () => void;
+        disable(): void;
+        enable(): void;
+        setShowTimeRange(startTime: number, endTime: number): void;
+        onProgress(currentTime: number): void;
+        updateFillAnimationDimension(): void;
+        onResize(): void;
+        getElement(): Nullable<HTMLElement>;
+        removeView(withTransition?: boolean): void;
+        onTransitionEnd: (event: TransitionEvent) => void;
+        removeListeners(): void;
+        toggleCTAAnimation(enable?: boolean): void;
+        updateShadowStyles(): void;
+        container: Nullable<{
+            element: HTMLElement;
+            dimensions: import("./controls").Dimensions<string>;
+            getComputedDimensions: () => import("./controls").Dimensions<number>;
+            isManifestContainerDisabled: () => boolean;
+        }>;
+        controlElement: Nullable<HTMLElement>;
+        clickListener: Nullable<(event: MouseEvent) => void>;
+        isInteracted: boolean;
+        isRemoved: boolean;
+        control: import("@interactiveplatform/movika-manifest/dist/chapter-COPBtRYg").e;
+        options?: import("./controls").Options;
+        createContainerElement(callbacks: import("./controls").Callbacks): void;
+        createClickListener(callback: any): (event: MouseEvent) => void;
+        featureIsEnabled(name: keyof import("./controls").ChoiceContainerOptions["features"]): boolean | undefined;
+        setEvents(callback: import("./controls").ControlEventCallback): void;
+    }>;
     classnamesPrefix: string;
 };

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

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

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

@@ -19,7 +19,15 @@ export type RequiredOptions = 'parentElement' | 'fullscreenTargetElement';
 export type IOptionalInteractiveOptions = Partial<Omit<IInteractiveOptions, RequiredOptions | 'config'>> & Required<Pick<IInteractiveOptions, RequiredOptions>> & {
     config?: Partial<IInteractiveOptions['config']>;
 };
-export interface IInteractiveOptions {
+export type ControlsAnimationFeatureToggles = {
+    buttonControlInteractiveTimeTimer: boolean;
+    areaControlFrameBasedShadow: boolean;
+    tapPlaceShow: boolean;
+    controlsCTAAnimation: boolean;
+    controlsShowAnimation: boolean;
+    controlsHideAnimation: boolean;
+};
+export type IInteractiveOptions = {
     parentElement: HTMLElement;
     fullscreenTargetElement: HTMLElement;
     lang: InterfaceLanguage | string;
@@ -40,10 +48,10 @@ export interface IInteractiveOptions {
     vkVideoLoader?: (owner_id: string, video_id: string) => unknown;
     createOneStat?: (video: any, configOverwrite?: any) => IOneStat | undefined;
     /**
-    * @deprecated
-    * */
+     * @deprecated
+     * */
     disableControlsOnPause?: boolean;
-}
+} & ControlsAnimationFeatureToggles;
 export type ChapterChangedData = {
     chapter: Chapter;
     manifestVideo: ManifestVideo;

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

@@ -0,0 +1,2 @@
+export declare const createBlinkAnimationRef: () => HTMLDivElement;
+export declare const restartBlinkAnimationRef: (blinkAnimationRefElement: HTMLElement) => void;

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

@@ -0,0 +1,30 @@
+export declare function normalizeRadians(rad: number): number;
+export declare function radiansToDegrees(rad: number): number;
+export type Options = {
+    startTime: number;
+    endTime: number;
+    rotateAngle: number;
+    borderRadius: string;
+    debug?: boolean;
+};
+export declare class FillAnimation {
+    fillAnimationElement: HTMLDivElement;
+    private fillAnimationFillerElement;
+    private fillAnimationFillerWrapperElement;
+    private startTime;
+    private endTime;
+    private shouldFillHeight;
+    private widthExpansionCoef;
+    private isDebug;
+    private fromLeft;
+    private useSkew;
+    private rotateAngle;
+    constructor(opts: Options);
+    updateDimension(opts: {
+        width: number;
+        height: number;
+        borderWidth: number;
+    }): void;
+    updateAnimation(currentTime: number): void;
+    private calcWidthExpansionCoef;
+}

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

@@ -3,15 +3,17 @@ 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 { SelectBranches } from './SelectBranches';
+import type { ControlsAnimationFeatureToggles } from '../../../modules/Interactives/types';
+import type { ChoiceContainer } from '../../../modules/Interactives/containers';
+import type { SelectBranchesType } from './SelectBranches';
 import { type GlobalEvents } from './events';
 import { GameStates } from './gameUtils';
+type Features = Pick<ControlsAnimationFeatureToggles, 'controlsHideAnimation'>;
 type ConstructorArg = {
     player: IPlayer;
     container: ChoiceContainer;
     branches: ChapterBranch[];
-    selectBranches: ReturnType<typeof SelectBranches>;
+    selectBranches: ReturnType<SelectBranchesType>;
     interactiveEvents: InteractiveEventsType;
     globalEventEmitter: EventEmitter;
     globalEvents: GlobalEvents;
@@ -19,11 +21,12 @@ type ConstructorArg = {
     permanentTextControls: boolean;
     disabledControls$: IValueSubject<boolean>;
     onRemove: () => void;
+    features: Features;
 };
 export declare class GameController {
     container: ChoiceContainer;
     branches: ChapterBranch[];
-    selectBranches: ReturnType<typeof SelectBranches>;
+    selectBranches: ReturnType<SelectBranchesType>;
     subscription: ISubscription;
     player: IPlayer;
     interactiveEvents: InteractiveEventsType;
@@ -36,7 +39,8 @@ export declare class GameController {
     isSelectedControlEvent: boolean;
     isSelectedContainerEvent: boolean;
     globalEvents: GlobalEvents;
-    constructor({ player, container, branches, selectBranches, interactiveEvents, globalEvents, globalEventEmitter, ignoreContainerEvent, permanentTextControls, disabledControls$, onRemove, }: ConstructorArg);
+    features: Features;
+    constructor({ player, container, branches, selectBranches, interactiveEvents, globalEvents, globalEventEmitter, ignoreContainerEvent, permanentTextControls, disabledControls$, onRemove, features, }: ConstructorArg);
     private emitContainerVisibilityEvent;
     registerEvents(): void;
     hide: () => void;
@@ -48,7 +52,11 @@ export declare class GameController {
     onEndOfVideo: () => void;
     whilePlaying: () => void;
     reset(): void;
-    removeView(): void;
+    isInteracted(): boolean;
+    isRemovedOrDestroyed(includeWillRemovedState?: boolean): boolean;
+    removeView(withTransition?: boolean): void;
+    toggleControlsCTAAnimation(value: boolean): void;
+    updateControlsShadowStyles(isFrameBased?: boolean): void;
     destroy(): void;
 }
 export {};

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

@@ -18,8 +18,8 @@ export declare function InteractiveEvents(player: IPlayer): {
     release: () => void;
     containersEventsCallState: {
         setCalled: ({ timestamp, id }: {
-            timestamp: any;
-            id: any;
+            timestamp: number;
+            id: string;
         }) => void;
         setData: (containers?: Container[]) => void;
         resetCalled: (timestamp: number) => void;

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

@@ -7,7 +7,7 @@ export declare const defaultArgs: {
 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, removeControllers, }: SelectBranchesArg) => {
+export declare const SelectBranches: ({ globalEventEmitter, globalEvents, player, interactiveEvents }: SelectBranchesArg) => {
     onControlEvent: ({ action, controlType, controlId, containerId, branches, onEvent, isEOV, isDisabled, }: OnControlEventArg) => void;
     onContainerEvent: ({ action, container: { id: containerId, endTime }, branches, isEOV, autoSelected, }: OnContainerEventArg) => void;
     onChapterEvent: ({ chapterId, action, branches }: OnChapterEventArg) => (() => ContinuePlaybackArg<"chapter">) | undefined;
@@ -20,3 +20,4 @@ export declare const SelectBranches: ({ globalEventEmitter, globalEvents, player
         isExpect: boolean;
     };
 };
+export type SelectBranchesType = typeof SelectBranches;

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

@@ -6,6 +6,7 @@ import type { GlobalEvents } from './events';
 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;

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

@@ -0,0 +1,10 @@
+export declare class TapElement {
+    element: HTMLDivElement;
+    controlRotateAngleRad: number;
+    clickCancelCondition: () => boolean;
+    constructor(controlRotateAngleRad: number, clickCancelCondition: () => boolean);
+    onElementClick: (e: Event & {
+        clientX: number;
+        clientY: number;
+    }) => void;
+}

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

@@ -35,9 +35,11 @@ export type TInteractivesActionExecutionEvent<T extends SubjectName> = TInteract
     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'] & {
+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>;

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

@@ -2,20 +2,23 @@ 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;
     textContent: string;
     roundCorners: number;
     borderWidth: number;
+    borderWidthRawValue: string;
+    roundCornersRawValue: string;
     borderColor: string;
     borderAlpha: number;
     backgroundColor: string;
     backgroundAlpha: number;
     innerSizesDependOn: string;
     angle: number;
+    shadowColorLight: string;
+    shadowColorDark: string;
+    shadowColorAlpha: number;
 };
 type ControlStylesFallbacks = typeof controlStylesFallbacks;
 export declare enum ALIGN_ITEMS {
@@ -58,8 +61,17 @@ type SetBorderStylesProps = {
     props: Control['props'];
     fallback: ControlStylesFallbacks;
     dependsOn: Dimensions;
+    useRawValues?: boolean;
 };
-export declare const setBorderStyles: ({ target, props, fallback, dependsOn }: SetBorderStylesProps) => void;
+export declare const setBorderStyles: ({ target, props, fallback, dependsOn, useRawValues }: SetBorderStylesProps) => void;
+type SetShadowStylesProps = {
+    target: HTMLElement;
+    props?: Control['props'];
+    fallback: ControlStylesFallbacks;
+    frameToneIsDark: boolean;
+    baseDimension: string;
+};
+export declare const setShadowStyles: ({ target, frameToneIsDark, baseDimension, fallback }: SetShadowStylesProps) => void;
 type SetAngleProps = {
     target: HTMLElement;
     fallback: ControlStylesFallbacks;

package/types/utils/AverageColor/FrameAverageColor.d.ts

@@ -0,0 +1,19 @@
+import { type Options } from './helpers';
+export declare class FrameAverageColor {
+    canvas: HTMLCanvasElement | OffscreenCanvas | null;
+    ctx: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D | null;
+    getColorAsync(resource: HTMLVideoElement, options: Options): Promise<{
+        rgba: string;
+        isDark: boolean;
+        error: Error | undefined;
+    }>;
+    getColor(resource: HTMLVideoElement, options: Options): {
+        rgba: string;
+        isDark: boolean;
+        error: Error | undefined;
+    };
+    private getColorFromArray;
+    private sqrtAlgorithm;
+    private prepareResult;
+    destroy(): void;
+}