@vkontakte/videoplayer-shared 1.0.86-dev.fcdd1bac.0 → 1.0.86

package/types/reactive/types.d.ts

@@ -0,0 +1,47 @@
+export type IUnsubscriber = () => void;
+export interface ISubscription {
+	unsubscribe: IUnsubscriber;
+	add(item: ISubscription | IUnsubscriber): ISubscription;
+}
+export interface IObservable<T> {
+	subscribe(listener: IListener<T>, error?: IListener<Error | unknown>): ISubscription;
+	pipe<T1>(op1: IOperator<T, T1>): IObservable<T1>;
+	pipe<
+		T1,
+		T2
+	>(op1: IOperator<T, T1>, op2: IOperator<T1, T2>): IObservable<T2>;
+	pipe<
+		T1,
+		T2,
+		T3
+	>(op1: IOperator<T, T1>, op2: IOperator<T1, T2>, op3: IOperator<T2, T3>): IObservable<T3>;
+	pipe<
+		T1,
+		T2,
+		T3,
+		T4
+	>(op1: IOperator<T, T1>, op2: IOperator<T1, T2>, op3: IOperator<T2, T3>, op4: IOperator<T3, T4>): IObservable<T4>;
+	pipe<
+		T1,
+		T2,
+		T3,
+		T4,
+		T5
+	>(op1: IOperator<T, T1>, op2: IOperator<T1, T2>, op3: IOperator<T2, T3>, op4: IOperator<T3, T4>, op5: IOperator<T4, T5>): IObservable<T5>;
+}
+export interface IValue<T> {
+	getValue(): T;
+}
+export interface IEmitter<T> {
+	next(value: T): void;
+	error?(value: Error | unknown): void;
+}
+export interface IValueObservable<T> extends IObservable<T>, IValue<T> {}
+export interface ISubject<T> extends IEmitter<T>, IObservable<T> {}
+export interface IValueSubject<T> extends IEmitter<T>, IObservable<T>, IValue<T> {}
+export type IListener<T> = IEmitter<T> | ((value: T) => void) | ((value: T) => Promise<void>);
+export type IOperator<
+	TInput,
+	TOutput = TInput
+> = (input: IObservable<TInput>) => IObservable<TOutput>;
+export type TypeOfObservable<TObservable> = TObservable extends IObservable<infer TType> ? TType : never;

package/types/translation/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./loadVKLangPack";
+export * from "./types";

package/types/translation/loadVKLangPack.d.ts

@@ -0,0 +1,16 @@
+import type { StringRecord } from "./types";
+export declare enum VKNumericLanguage {
+	Armenian = "58",
+	Azerbaijani = "57",
+	Belarusian = "114",
+	English = "3",
+	Kazakh = "97",
+	Portuguese = "73",
+	Russian = "0",
+	Spanish = "4",
+	Ukrainian = "1",
+	Uzbek = "65",
+	Vietnamese = "75"
+}
+export type VKLanguage = VKNumericLanguage | string;
+export declare const loadVKLangPack: <T extends StringRecord>(language: VKLanguage, packName: string, packPrefix: string) => Promise<T>;

package/types/translation/types.d.ts

@@ -0,0 +1,5 @@
+export declare enum InterfaceLanguage {
+	RU = "ru",
+	EN = "en"
+}
+export type StringRecord = Record<string, string>;

package/types/types/index.d.ts

@@ -0,0 +1,71 @@
+export type SafeAny = any;
+export interface IError {
+	/**
+	* Код или другой идентификатор для статистики
+	*/
+	id: string;
+	category: ErrorCategory;
+	/**
+	* Сообщение по которому можно разобрать что случилось
+	*/
+	message: string;
+	/**
+	* Данные, полезные для отладки
+	*/
+	data?: any;
+	/**
+	* Возникшее исключение
+	*/
+	thrown?: Error | unknown;
+	/**
+	* Отправлять в трейс не как error а как log
+	*/
+	traceAsLog?: boolean;
+	/**
+	* HTTP-code ошибки
+	*/
+	httpCode?: number;
+	/**
+	* Код ошибки, который вернул backend Единого Видео
+	*/
+	UVBackendErrorCode?: string;
+}
+export interface IWarning {
+	/**
+	* Код или другой идентификатор для статистики
+	*/
+	id: string;
+	/**
+	* Сообщение по которому можно разобрать что случилось
+	*/
+	message: string;
+	/**
+	* Данные, полезные для отладки
+	*/
+	data?: any;
+}
+export declare enum ErrorCategory {
+	NETWORK = "network",
+	VIDEO_PIPELINE = "video_pipeline",
+	EXTERNAL_API = "external_api",
+	PARSER = "parser",
+	DOM = "dom",
+	WTF = "wtf",
+	FATAL = "fatal"
+}
+export interface IRange<Unit extends number = number> {
+	from: Unit;
+	to: Unit;
+}
+export interface IRectangle<Unit extends number = number> {
+	width: Unit;
+	height: Unit;
+}
+export type RecursivePartial<T> = { [P in keyof T]? : T[P] extends (infer U)[] ? RecursivePartial<U>[] : T[P] extends object | undefined ? RecursivePartial<T[P]> : T[P] };
+export type WithRequired<
+	T,
+	K extends keyof T
+> = T & { [P in K]-? : T[P] };
+export type Constructor<T> = new () => T;
+export type AbstractConstructor<T> = abstract new () => T;
+export type AnyConstructor<T> = Constructor<T> | AbstractConstructor<T>;

package/types/utils/abortable.d.ts

@@ -0,0 +1,6 @@
+type AbortableDecorator = <
+	Params extends unknown[] = void[],
+	Return = void
+>(signal: AbortSignal, createGenerator: (...param: Params) => AsyncGenerator<unknown, Return, unknown>) => (...param: Params) => Promise<Return | undefined>;
+export declare const abortable: AbortableDecorator;
+export {};

package/types/utils/addScript.d.ts

@@ -0,0 +1 @@
+export declare const addScript: (scriptSrc: string, abortSignal: AbortSignal, timeout?: number) => Promise<void>;

package/types/utils/browser.d.ts

@@ -0,0 +1,2 @@
+export declare const getWindow: () => Window & typeof globalThis;
+export declare const isBrowserWindow: (root?: any) => root is Window;

package/types/utils/clearVideoElement.d.ts

@@ -0,0 +1 @@
+export declare const clearVideoElement: (video: HTMLVideoElement, clearVideoElementInnerHTML?: boolean) => void;

package/types/utils/cloneDeep.d.ts

@@ -0,0 +1 @@
+export declare const cloneDeep: <T>(obj: T) => T;

package/types/utils/cloneDeepWith.d.ts

@@ -0,0 +1,3 @@
+type CloneDeepWithCustomizer<TObject> = (value: unknown, key: number | string | undefined, object: TObject | undefined, stack: any) => any;
+export declare const cloneDeepWith: <T>(obj: T, customizer?: CloneDeepWithCustomizer<T>) => T;
+export {};

package/types/utils/config.d.ts

@@ -0,0 +1,2 @@
+import type { RecursivePartial } from "../types";
+export declare const fillWithDefault: <Config extends object>(partial: RecursivePartial<Config>, defaultConfig: Config) => Config;

package/types/utils/debounceFn.d.ts

@@ -0,0 +1,13 @@
+interface DebounceSettings {
+	leading?: boolean;
+	maxWait?: number;
+	trailing?: boolean;
+}
+export interface DebouncedFn<T extends (...args: any[]) => any> {
+	(...args: Parameters<T>): ReturnType<T> | undefined;
+	cancel(): void;
+	flush(): ReturnType<T> | undefined;
+	pending(): boolean;
+}
+export declare function debounceFn<T extends (...args: any) => any>(func: T, wait?: number, options?: DebounceSettings): DebouncedFn<T>;
+export {};

package/types/utils/detectEmbed.d.ts

@@ -0,0 +1,8 @@
+interface Result {
+	isEmbed: boolean;
+	origins: string[];
+	topOrigin?: string;
+	immediateOrigin?: string;
+}
+export declare const detectEmbed: () => Result;
+export {};

package/types/utils/empty.d.ts

@@ -0,0 +1,2 @@
+export declare function assertNotEmptyArray<T extends Array<unknown>>(value: T, failMessage: string): void;
+export declare function assertEmptyArray<T extends Array<unknown>>(value: T, failMessage: string): void;

package/types/utils/exponentialBackoff.d.ts

@@ -0,0 +1,9 @@
+import type { Milliseconds } from "./semanticTypes";
+export type ExponentialBackoffConfig = Partial<{
+	start: Milliseconds;
+	factor: number;
+	min: Milliseconds;
+	max: Milliseconds;
+	random: number;
+}>;
+export declare const getExponentialDelay: (errorsCount: number, { start, factor, max, min, random }?: ExponentialBackoffConfig) => Milliseconds;

package/types/utils/flattenObject.d.ts

@@ -0,0 +1,9 @@
+/**
+* Функция, которая "сплющивает" вложенный объект. Делает так, чтобы все проперти в объекте были примитивами и
+* не содержали вложенных объектов
+* @param obj - исходный объект
+* @param maxDeep - максимальная глубина рекурсивного обхода
+* @param separator - символ разделитель. По умолчанию точка '.'
+* @return - новый сплющенный объект, который не содержит больше вложенных объектов
+*/
+export declare const flattenObject: (obj: Record<string, any> | undefined, maxDeep?: number, separator?: string) => Record<string, any>;

package/types/utils/getPlayerId.d.ts

@@ -0,0 +1 @@
+export declare const getPlayerId: (playerId?: string) => string;

package/types/utils/getRangeAroundIndex.d.ts

@@ -0,0 +1,7 @@
+/**
+* Возвращает диапозон индексов вокруг определнного индекса.
+* @param totalItems Размер массива.
+* @param currentIndex Индекс вокруг которого нужно собрать массив.
+* @param max Максимальный размер индекса.
+*/
+export declare function getRangeAroundIndex(totalItems: number, currentIndex: number, max: number): number[];

package/types/utils/iframeSafeStorage.d.ts

@@ -0,0 +1,6 @@
+export declare const isPersistent: () => boolean;
+export declare const get: (key: string) => string | undefined;
+export declare const set: (key: string, value: string) => void;
+export declare const has: (key: string) => boolean;
+export declare const remove: (key: string) => void;
+export declare const clear: () => void;

package/types/utils/index.d.ts

@@ -0,0 +1,34 @@
+export { noop } from "./noop";
+export { assertNever, checkNever } from "./never";
+export { isNonNullable, isNullable, assertNonNullable, assertNullable, withoutNullable } from "./nullable";
+export type { Nullable } from "./nullable";
+export { assertNotEmptyArray, assertEmptyArray } from "./empty";
+export { addScript } from "./addScript";
+export type { Milliseconds, bps, Byte, Seconds, Kbps, Mbps, Percentage } from "./semanticTypes";
+export { now, nowInt } from "./now";
+export { abortable } from "./abortable";
+export { getExponentialDelay } from "./exponentialBackoff";
+export type { ExponentialBackoffConfig } from "./exponentialBackoff";
+export * as safeStorage from "./iframeSafeStorage";
+export { detectEmbed } from "./detectEmbed";
+export { VideoQuality } from "./quality/types";
+export type { ExactVideoQuality, QualityLimits } from "./quality/types";
+export { isHigher, isHigherOrEqual, isLower, isLowerOrEqual, getHighestQuality, videoHeightToQuality, videoSizeToQuality, videoQualityToHeight, isInvariantQuality, areQualitiesExact, assertQualityIsExact, getVideoQualityLabel } from "./quality";
+export * from "./config";
+export * from "./timecode";
+export { debounceFn } from "./debounceFn";
+export type { DebouncedFn } from "./debounceFn";
+export { throttleFn } from "./throttleFn";
+export type { ThrottleOptions } from "./throttleFn";
+export { cloneDeep } from "./cloneDeep";
+export { observeElementSize } from "./observeElementSize";
+export { cloneDeepWith } from "./cloneDeepWith";
+export { flattenObject } from "./flattenObject";
+export { clearVideoElement } from "./clearVideoElement";
+export * from "./isValidURL";
+export { isIntersecting } from "./isIntersecting";
+export { getPlayerId } from "./getPlayerId";
+export { interpolate } from "./interpolate";
+export { getRangeAroundIndex } from "./getRangeAroundIndex";
+export * from "./browser";
+export { suppressAbort, isAbortError } from "./suppressAbort";

package/types/utils/interpolate.d.ts

@@ -0,0 +1,12 @@
+/**
+* clamp - значение не выходит за outputRange, прибиваем его к краям диапозона.
+*/
+export type Extrapolate = "clamp";
+/**
+* Линейно интерполирует значение из inputRange в outputRange.
+* @param value - Входное значение (например, прогресс анимации)
+* @param inputRange - Диапазон входных значений (должен быть отсортирован)
+* @param outputRange - Диапазон выходных значений
+* @returns - Интерполированное значение
+*/
+export declare function interpolate(value: number, inputRange: [number, number], outputRange: [number, number]): number;

package/types/utils/isIntersecting.d.ts

@@ -0,0 +1,6 @@
+type Rect = Pick<DOMRect, "top" | "bottom" | "left" | "right">;
+/**
+* Проверяет пересекаются ли прямоугольники.
+*/
+export declare const isIntersecting: (rect1: Rect, rect2: Rect) => boolean;
+export {};

package/types/utils/isValidURL.d.ts

@@ -0,0 +1 @@
+export declare const isValidURL: (urlParam: unknown) => urlParam is string | URL;

package/types/utils/never.d.ts

@@ -0,0 +1,2 @@
+export declare const assertNever: (x: never) => never;
+export declare const checkNever: (_x: never) => void;

package/types/utils/noop.d.ts

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

package/types/utils/now.d.ts

@@ -0,0 +1,4 @@
+import type { Milliseconds } from "./semanticTypes";
+export declare const now: () => Milliseconds;
+/** возвращает `Int` значение `now` */
+export declare const nowInt: () => Milliseconds;

package/types/utils/nullable.d.ts

@@ -0,0 +1,8 @@
+export declare function assertNonNullable<T>(value: T, failMessage?: string): asserts value is NonNullable<T>;
+export declare function assertNullable<T extends INullable = INullable>(value: unknown, failMessage?: string): asserts value is T;
+export declare function isNonNullable<T>(value: T): value is NonNullable<T>;
+export declare function isNullable<T extends INullable = INullable>(value: unknown): value is T;
+type INullable = null | undefined;
+export type Nullable<T> = T | INullable;
+export declare const withoutNullable: <T extends object>(target: T) => Required<T>;
+export {};

package/types/utils/observeElementSize.d.ts

@@ -0,0 +1,4 @@
+import type { IObservable } from "../reactive";
+import type { IRectangle } from "../types";
+import type { Milliseconds } from "./semanticTypes";
+export declare const observeElementSize: (element: Element, throttleTime?: Milliseconds) => IObservable<IRectangle>;

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

@@ -0,0 +1,21 @@
+import type { IRectangle } from "../../types";
+import { type ExactVideoQuality, VideoQuality } from "./types";
+export declare const isHigher: (a: ExactVideoQuality, b: ExactVideoQuality) => boolean;
+export declare const isHigherOrEqual: (a: ExactVideoQuality, b: ExactVideoQuality) => boolean;
+export declare const isLower: (a: ExactVideoQuality, b: ExactVideoQuality) => boolean;
+export declare const isLowerOrEqual: (a: ExactVideoQuality, b: ExactVideoQuality) => boolean;
+export declare const getHighestQuality: (qualities: VideoQuality[]) => VideoQuality | undefined;
+/**
+* Выбирает качество, наиболее близкое к указанной высоте кадра, но не менее её.
+* @param tolerance позволяет выбрать качество менее заданной высоты на величину погрешности (в процентах)
+*/
+export declare const videoHeightToQuality: (height: number, tolerance?: number) => ExactVideoQuality | undefined;
+/**
+* Выбирает качество описывающее заданные размеры видео потока, т.е. не меньше его.
+*/
+export declare const videoSizeToQuality: ({ width, height }: IRectangle) => ExactVideoQuality | undefined;
+export declare const videoQualityToHeight: (quality: ExactVideoQuality) => number;
+export declare const isInvariantQuality: (quality: VideoQuality) => quality is VideoQuality.INVARIANT;
+export declare const areQualitiesExact: (qualities: VideoQuality[]) => qualities is ExactVideoQuality[];
+export declare function assertQualityIsExact(quality: VideoQuality): asserts quality is ExactVideoQuality;
+export declare const getVideoQualityLabel: (q: VideoQuality) => string;

package/types/utils/quality/types.d.ts

@@ -0,0 +1,22 @@
+export declare enum VideoQuality {
+	INVARIANT = "Invariant quality",
+	Q_144P = "144p",
+	Q_240P = "240p",
+	Q_360P = "360p",
+	Q_480P = "480p",
+	Q_576P = "576p",
+	Q_720P = "720p",
+	Q_1080P = "1080p",
+	Q_1440P = "1440p",
+	Q_2160P = "2160p",
+	Q_4320P = "4320p"
+}
+export type ExactVideoQuality = Exclude<VideoQuality, VideoQuality.INVARIANT>;
+/**
+* Лимиты трактуются включительно
+* Значение undefined снимает лимит
+*/
+export type QualityLimits = {
+	max?: ExactVideoQuality;
+	min?: ExactVideoQuality;
+};

package/types/utils/semanticTypes.d.ts

@@ -0,0 +1,7 @@
+export type Seconds = number;
+export type Milliseconds = number;
+export type bps = number;
+export type Kbps = number;
+export type Mbps = number;
+export type Byte = number;
+export type Percentage = number;

package/types/utils/suppressAbort.d.ts

@@ -0,0 +1,2 @@
+export declare const isAbortError: (e: Error | unknown) => boolean;
+export declare const suppressAbort: (e: Error | unknown) => void | never;

package/types/utils/throttleFn.d.ts

@@ -0,0 +1,6 @@
+import { type DebouncedFn } from "./debounceFn";
+export interface ThrottleOptions {
+	leading?: boolean;
+	trailing?: boolean;
+}
+export declare const throttleFn: <T extends (...args: any) => any>(func: T, wait?: number, options?: ThrottleOptions) => DebouncedFn<T>;

package/types/utils/timecode.d.ts

@@ -0,0 +1 @@
+export declare const timeCodeToString: (t: number) => string;