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

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

@@ -1,6 +1,5 @@
 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,
@@ -25,5 +24,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 evaluateContainerEventStatus: (container: ChapterContainer, gameControllers: GameController[]) => IgnoreExpectState;
+export declare const shouldIgnoreContainerEvent: (container: ChapterContainer, gameControllers: GameController[]) => boolean;
 export {};

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

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

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

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

@@ -0,0 +1,17 @@
+export type Color = [number, number, number, number];
+export type Options = {
+    width: number;
+    height: number;
+    step?: number;
+    defaultColor?: Color;
+    debug?: boolean;
+};
+export declare function makeCanvas(): OffscreenCanvas | HTMLCanvasElement | null;
+export declare function isDark(color: Color): boolean;
+export declare const DEFAULT_COLOR: Color;
+export declare const DEFAULT_STEP = 1;
+export declare function getError(message: string): Error;
+export declare function getVideoContentSize(element: HTMLElement): {
+    width: number;
+    height: number;
+};

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

@@ -0,0 +1,2 @@
+export { FrameAverageColor } from './FrameAverageColor';
+export { getVideoContentSize } from './helpers';

package/types/utils/getVideoContentSize.d.ts

@@ -1,5 +1,5 @@
 import type { IPlayer } from '@vkontakte/videoplayer-core';
-export declare const getVideoContentSize: (containerEl: Element, player: IPlayer) => {
+export declare const getVideoContentSize: (player: IPlayer) => {
     videoContentHeight: number;
     videoContentWidth: number;
 };

package/types/utils/Binding.d.ts

@@ -1,34 +0,0 @@
-import type { Nullable } from '@vkontakte/videoplayer-shared';
-import type { HtmlEventType } from '../types';
-type OptionsType = undefined | boolean | AddEventListenerOptions;
-export declare class Binding {
-    target: Nullable<Element>;
-    type: Nullable<HtmlEventType>;
-    listener: Nullable<EventListener>;
-    options: Nullable<OptionsType>;
-    /**
-     *  passive = true -> function never call preventDefault()
-     */
-    constructor(target: Element, type: HtmlEventType, listener: EventListener, options: OptionsType);
-    /**
-     * Detaches the event listener from the event target. This does nothing if
-     * the event listener is already detached.
-     */
-    unlisten(): void;
-    /**
-     * Converts the provided options value into a value accepted by the browser.
-     * Some browsers (e.g. Tizen) don't support passing options as an
-     * object.  So this detects this case and converts it.
-     */
-    private static _convertOptions;
-    /**
-     * Checks whether the browser supports passing objects as the third argument
-     * to addEventListener.  This caches the result value in a static field to
-     * avoid a bunch of checks.
-     *
-     * See https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Safely_detecting_option_support
-     */
-    private static _supportsObject;
-    private static _doesSupportObject;
-}
-export {};

package/types/utils/EventManager.d.ts

@@ -1,13 +0,0 @@
-import { Binding } from './Binding';
-import { MultiMap } from './MultiMap';
-import type { HtmlEventType } from '../types';
-type OptionsType = boolean | AddEventListenerOptions;
-export declare class EventManager {
-    bindingMap: MultiMap<Binding> | null;
-    release(): void;
-    listen(target: Element, type: HtmlEventType, listener: EventListener, options?: OptionsType): void;
-    listenOnce(target: Element, type: HtmlEventType, listener: EventListener, options?: OptionsType): void;
-    unlisten(target: Element, type: HtmlEventType, listener: EventListener): void;
-    removeAll(): void;
-}
-export {};