@vkontakte/videoplayer-shared 1.0.36 → 1.0.37-dev.0bef53b3.0

package/types/reactive/index.d.ts

@@ -0,0 +1,21 @@
+export { default as Subscription } from './Subscription';
+export { default as Observable } from './Observable';
+export { default as Subject } from './Subject';
+export { default as ValueSubject } from './ValueSubject';
+export { default as combine } from './combine';
+export { default as merge } from './merge';
+export { default as timeout } from './timeout';
+export { default as interval } from './interval';
+export { default as observableFrom } from './observableFrom';
+export { default as fromEvent } from './fromEvent';
+export { default as buffer } from './operators/buffer';
+export { default as debounce } from './operators/debounce';
+export { default as throttle } from './operators/throttle';
+export { default as filter } from './operators/filter';
+export { default as filterChanged } from './operators/filterChanged';
+export { default as map } from './operators/map';
+export { default as mapTo } from './operators/mapTo';
+export { default as once } from './operators/once';
+export { default as pairwise } from './operators/pairwise';
+export { default as tap } from './operators/tap';
+export type { ISubscription, IUnsubscriber, IObservable, ISubject, IValueSubject, IValueObservable, IListener, IEmitter, IValue, IOperator, } from './types';

package/types/reactive/interval.d.ts

@@ -0,0 +1,4 @@
+import { Milliseconds } from '../utils';
+import type { IObservable } from './types';
+declare const _default: (time: Milliseconds) => IObservable<void>;
+export default _default;

package/types/reactive/merge.d.ts

@@ -0,0 +1,12 @@
+import type { IObservable } from './types';
+export default function merge<T1, T2>(v1: IObservable<T1>, v2: IObservable<T2>): IObservable<T1 | T2>;
+export default function merge<T1, T2, T3>(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>): IObservable<T1 | T2 | T3>;
+export default function merge<T1, T2, T3, T4>(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>, v4: IObservable<T4>): IObservable<T1 | T2 | T3 | T4>;
+export default function merge<T1, T2, T3, T4, T5>(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>, v4: IObservable<T4>, v5: IObservable<T5>): IObservable<T1 | T2 | T3 | T4 | T5>;
+export default function merge<T1, T2, T3, T4, T5, T6>(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>, v4: IObservable<T4>, v5: IObservable<T5>, v6: IObservable<T6>): IObservable<T1 | T2 | T3 | T4 | T5 | T6>;
+export default function merge<T1, T2, T3, T4, T5, T6>(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>, v4: IObservable<T4>, v5: IObservable<T5>, v6: IObservable<T6>): IObservable<T1 | T2 | T3 | T4 | T5 | T6>;
+export default function merge<T1, T2, T3, T4, T5, T6, T7>(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>, v4: IObservable<T4>, v5: IObservable<T5>, v6: IObservable<T6>, v7: IObservable<T7>): IObservable<T1 | T2 | T3 | T4 | T5 | T6 | T7>;
+export default function merge<T1, T2, T3, T4, T5, T6, T7, T8>(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>, v4: IObservable<T4>, v5: IObservable<T5>, v6: IObservable<T6>, v7: IObservable<T7>, v8: IObservable<T8>): IObservable<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8>;
+export default function merge<T1, T2, T3, T4, T5, T6, T7, T8, T9>(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>, v4: IObservable<T4>, v5: IObservable<T5>, v6: IObservable<T6>, v7: IObservable<T7>, v8: IObservable<T8>, v9: IObservable<T9>): IObservable<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9>;
+export default function merge<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>, v4: IObservable<T4>, v5: IObservable<T5>, v6: IObservable<T6>, v7: IObservable<T7>, v8: IObservable<T8>, v9: IObservable<T9>, v10: IObservable<T10>): IObservable<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9 | T10>;
+export default function merge<R>(...observables: IObservable<unknown>[]): IObservable<R>;

package/types/reactive/observableFrom.d.ts

@@ -0,0 +1,3 @@
+import type { IObservable } from './types';
+declare const _default: <T>(values: T[]) => IObservable<T>;
+export default _default;

package/types/reactive/operators/buffer.d.ts

@@ -0,0 +1,2 @@
+import type { IOperator } from '../types';
+export default function buffer<T>(size: number): IOperator<T, T[]>;

package/types/reactive/operators/debounce.d.ts

@@ -0,0 +1,6 @@
+import type { Milliseconds } from '../../utils/semanticTypes';
+import type { IOperator } from '../types';
+export default function debounce<T>(time: Milliseconds, config?: {
+    leading: boolean;
+    trailing: boolean;
+}): IOperator<T>;

package/types/reactive/operators/filter.d.ts

@@ -0,0 +1,3 @@
+import type { IOperator } from '../types';
+export default function filter<T, S extends T>(predicate: (value: T) => value is S): IOperator<T, S>;
+export default function filter<T>(predicate: (value: T) => boolean): IOperator<T>;

package/types/reactive/operators/filterChanged.d.ts

@@ -0,0 +1,5 @@
+import type { IOperator } from '../types';
+/**
+ * Пропускает только события, содержащие значения, отличные от предыдущего
+ */
+export default function filterChanged<T>(equal?: (prev: T, next: T) => boolean): IOperator<T>;

package/types/reactive/operators/map.d.ts

@@ -0,0 +1,2 @@
+import type { IOperator } from '../types';
+export default function map<T, S>(mapper: (value: T) => S): IOperator<T, S>;

package/types/reactive/operators/mapTo.d.ts

@@ -0,0 +1,2 @@
+import type { IOperator } from '../types';
+export default function mapTo<T, S>(value: S): IOperator<T, S>;

package/types/reactive/operators/once.d.ts

@@ -0,0 +1,5 @@
+import type { IOperator } from '../types';
+/**
+ *  Отписывается от исходного потока после получения первого события.
+ */
+export default function once<T>(): IOperator<T>;

package/types/reactive/operators/pairwise.d.ts

@@ -0,0 +1,4 @@
+import type { IOperator } from '../types';
+type IPair<T> = [previous: T, current: T];
+export default function pairwise<T>(): IOperator<T, IPair<T>>;
+export {};

package/types/reactive/operators/tap.d.ts

@@ -0,0 +1,2 @@
+import type { IOperator } from '../types';
+export default function tap<T>(effect: (value: T) => void): IOperator<T>;

package/types/reactive/operators/throttle.d.ts

@@ -0,0 +1,5 @@
+import type { IOperator } from '../types';
+export default function throttle<T>(time: number, config?: {
+    leading: boolean;
+    trailing: boolean;
+}): IOperator<T>;

package/types/reactive/timeout.d.ts

@@ -0,0 +1,4 @@
+import { Milliseconds } from '../utils';
+import type { IObservable } from './types';
+declare const _default: (time: Milliseconds) => IObservable<void>;
+export default _default;

package/types/reactive/types.d.ts

@@ -0,0 +1,29 @@
+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);
+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,53 @@
+export interface IError {
+    /**
+     * Код или другой идентификатор для статистики
+     */
+    id: string;
+    category: ErrorCategory;
+    /**
+     * Сообщение по которому можно разобрать что случилось
+     */
+    message: string;
+    /**
+     * Данные, полезные для отладки
+     */
+    data?: any;
+    /**
+     * Возникшее исключение
+     */
+    thrown?: Error | unknown;
+}
+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];
+};

package/types/utils/abortable.d.ts

@@ -0,0 +1,3 @@
+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/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> | undefined) => T;
+export {};

package/types/utils/config.d.ts

@@ -0,0 +1,2 @@
+import { 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/detectBrowser.d.ts

@@ -0,0 +1,31 @@
+export declare enum CurrentClientBrowser {
+    Unknown = "Unknown",
+    Yandex = "Yandex",
+    Chrome = "Chrome",
+    Chromium = "Chromium",
+    Firefox = "Firefox",
+    Safari = "Safari",
+    Opera = "Opera",
+    Edge = "Edge",
+    Rest = "Rest"
+}
+export declare enum CurrentClientDevice {
+    Unknown = "Unknown",
+    Android = "Android",
+    iPhone = "iPhone",
+    iPad = "iPad",
+    iPod = "iPod",
+    RestMobile = "RestMobile",
+    Mac = "Mac",
+    Desktop = "Desktop"
+}
+export type ICurrentBrowserInfo = {
+    browser: CurrentClientBrowser;
+    device: CurrentClientDevice;
+};
+export declare const getCurrentBrowser: () => ICurrentBrowserInfo;
+export declare const isIOS: (checkForceDesktop?: boolean) => boolean;
+export declare const getIOSVersion: () => number | null;
+export declare const isAndroid: () => boolean;
+export declare const isMacLike: () => boolean;
+export declare const isMobile: () => any;

package/types/utils/detectEmbed.d.ts

@@ -0,0 +1,4 @@
+export declare const detectEmbed: () => {
+    isEmbed: boolean;
+    host?: string | undefined;
+};

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 { 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/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,22 @@
+export { noop } from './noop';
+export { assertNever, checkNever } from './never';
+export { isNonNullable, isNullable, assertNonNullable, assertNullable, 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 } from './now';
+export { abortable } from './abortable';
+export { getCurrentBrowser, CurrentClientBrowser, CurrentClientDevice, isIOS, getIOSVersion, isMacLike, isMobile, isAndroid } from './detectBrowser';
+export type { ICurrentBrowserInfo } from './detectBrowser';
+export { getExponentialDelay, ExponentialBackoffConfig } from './exponentialBackoff';
+export * as safeStorage from './iframeSafeStorage';
+export { detectEmbed } from './detectEmbed';
+export { VideoQuality, type ExactVideoQuality, QualityLimits } from './quality/types';
+export { isHigher, isHigherOrEqual, isLower, isLowerOrEqual, getHighestQuality, videoHeightToQuality, videoSizeToQuality, videoQualityToHeight, isInvariantQuality, areQualitiesExact, assertQualityIsExact, } from './quality';
+export * from './config';
+export * from './timecode';
+export { debounceFn, DebouncedFn } from './debounceFn';
+export { throttleFn, ThrottleOptions } from './throttleFn';
+export { cloneDeep } from './cloneDeep';
+export { observeElementSize } from './observeElementSize';
+export { cloneDeepWith } from './cloneDeepWith';

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,2 @@
+import type { Milliseconds } from './semanticTypes';
+export declare const now: () => Milliseconds;

package/types/utils/nullable.d.ts

@@ -0,0 +1,7 @@
+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 {};

package/types/utils/observeElementSize.d.ts

@@ -0,0 +1,3 @@
+import type { IObservable, IRectangle } from '../index';
+import { Milliseconds } from '../index';
+export declare const observeElementSize: (element: Element, throttleTime?: Milliseconds) => IObservable<IRectangle>;

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

@@ -0,0 +1,20 @@
+import { 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;

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

@@ -0,0 +1,21 @@
+export declare enum VideoQuality {
+    INVARIANT = "Invariant quality",
+    Q_144P = "144p",
+    Q_240P = "240p",
+    Q_360P = "360p",
+    Q_480P = "480p",
+    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/throttleFn.d.ts

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

package/types/utils/timecode.d.ts

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