@vkontakte/videoplayer-core 2.0.103 → 2.0.104

package/types/providers/types.d.ts

@@ -0,0 +1,83 @@
+import { ITuningConfig } from '../utils/tuningConfig';
+import { ILogger, ISubject, IValueSubject, Milliseconds, Seconds, IRange, IError, QualityLimits, IWarning, IComponentLogger } from '@vkontakte/videoplayer-shared';
+import { IChromecastInitializer } from '../providers/ChromecastProvider/ChromecastInitializer/types';
+import { HttpConnectionType, IAudioTrack, ICueSettings, ISources, SeekState } from '../player/types';
+import { IExternalTextTrack, IInternalTextTrack, ITextTrack, IVideoTrack, IVolumeState, PlaybackState, PlaybackRate } from '../player/types';
+import { IStateMachine } from '../utils/StateMachine/types';
+import ThroughputEstimator from '../utils/ThroughputEstimator';
+import { Scene3D } from '../utils/3d/Scene3D';
+import { Vector2D } from '../utils/3d/types';
+export interface IProvider {
+    scene3D?: Scene3D;
+    destroy(): void;
+}
+export interface IProviderDependencies {
+    dependencies: {
+        throughputEstimator: ThroughputEstimator;
+        chromecastInitializer: IChromecastInitializer;
+        logger: ILogger;
+        abrLogger: IComponentLogger;
+    };
+}
+export interface IProviderParams<TSourceType> extends IProviderDependencies {
+    container: HTMLElement;
+    source: TSourceType;
+    desiredState: IDesiredState;
+    output: IProviderOutput;
+    tuning: ITuningConfig;
+}
+export interface IDesiredState {
+    playbackState: IStateMachine<PlaybackState>;
+    seekState: IStateMachine<SeekState>;
+    volume: IStateMachine<IVolumeState>;
+    playbackRate: IStateMachine<PlaybackRate>;
+    videoTrack: IStateMachine<IVideoTrack | undefined>;
+    autoVideoTrackSwitching: IStateMachine<boolean>;
+    autoVideoTrackLimits: IStateMachine<QualityLimits>;
+    isLooped: IStateMachine<boolean>;
+    externalTextTracks: IStateMachine<IExternalTextTrack[]>;
+    internalTextTracks: IStateMachine<IInternalTextTrack[]>;
+    currentTextTrack: IStateMachine<ITextTrack['id'] | undefined>;
+    textTrackCuesSettings: IStateMachine<ICueSettings>;
+    cameraOrientation: IStateMachine<Vector2D>;
+}
+export interface IProviderOutput {
+    position$: IValueSubject<Seconds>;
+    duration$: IValueSubject<Seconds>;
+    volume$: IValueSubject<IVolumeState>;
+    autoVideoTrackLimits$: IValueSubject<QualityLimits | undefined>;
+    currentVideoTrack$: IValueSubject<IVideoTrack | undefined>;
+    currentVideoSegmentLength$: IValueSubject<number>;
+    currentAudioSegmentLength$: IValueSubject<number>;
+    availableVideoTracks$: IValueSubject<IVideoTrack[]>;
+    availableAudioTracks$: IValueSubject<IAudioTrack[]>;
+    isAudioAvailable$: IValueSubject<boolean>;
+    autoVideoTrackLimitingAvailable$: IValueSubject<boolean>;
+    canChangePlaybackSpeed$: IValueSubject<boolean | undefined>;
+    currentBuffer$: IValueSubject<IRange<Seconds> | undefined>;
+    isBuffering$: IValueSubject<boolean>;
+    isLive$: IValueSubject<boolean | undefined>;
+    isLowLatency$: IValueSubject<boolean | undefined>;
+    liveTime$: IValueSubject<Milliseconds | undefined>;
+    liveBufferTime$: IValueSubject<Milliseconds | undefined>;
+    availableTextTracks$: IValueSubject<ITextTrack[]>;
+    currentTextTrack$: IValueSubject<ITextTrack['id'] | undefined>;
+    hostname$: IValueSubject<string | undefined>;
+    httpConnectionType$: IValueSubject<HttpConnectionType | undefined>;
+    httpConnectionReused$: IValueSubject<boolean | undefined>;
+    element$: IValueSubject<HTMLVideoElement | undefined>;
+    elementVisible$: IValueSubject<boolean>;
+    availableSources$: IValueSubject<ISources | undefined>;
+    willSeekEvent$: ISubject<void>;
+    seekedEvent$: ISubject<void>;
+    error$: ISubject<IError>;
+    warning$: ISubject<IWarning>;
+    endedEvent$: ISubject<void>;
+    loopedEvent$: ISubject<Seconds>;
+    firstBytesEvent$: ISubject<Milliseconds | void>;
+    firstFrameEvent$: ISubject<void>;
+    canplay$: ISubject<void>;
+    is3DVideo$: ISubject<boolean>;
+    inPiP$: IValueSubject<boolean>;
+    inFullscreen$: IValueSubject<boolean>;
+}

package/types/providers/utils/HTMLVideoElement/DroppedFramesManager.d.ts

@@ -0,0 +1,44 @@
+import { type ExactVideoQuality, ILogger, IObservable, Subject } from '@vkontakte/videoplayer-shared';
+import { ITuningConfig } from '../../../utils/tuningConfig';
+import { IVideoTrack } from '../../../player/types';
+import { IStateMachine } from '../../../utils/StateMachine/types';
+interface IConnectData {
+    logger: ILogger;
+    video: HTMLVideoElement;
+    droppedFramesChecker: ITuningConfig['droppedFramesChecker'];
+    isAuto: IStateMachine<boolean>;
+    playing$: IObservable<undefined>;
+    pause$: IObservable<undefined>;
+    tracks$: IObservable<IVideoTrack[]>;
+}
+declare class DroppedFramesManager {
+    onDroopedVideoFramesLimit$: Subject<void>;
+    private subscription;
+    private log;
+    private video;
+    private droppedFramesChecker;
+    private isAuto;
+    private playing;
+    private tracks;
+    private forceChecker$;
+    private isForceCheckCounter;
+    private prevTotalVideoFrames;
+    private prevDroppedVideoFrames;
+    private currentTimer;
+    private limitCounts;
+    private currentQuality;
+    private maxQualityLimit;
+    connect(data: IConnectData): void;
+    destroy(): void;
+    get droppedVideoMaxQualityLimit(): ExactVideoQuality | undefined;
+    private subscribe;
+    private handleChangeVideoQuality;
+    private onChangeQuality;
+    private checkDroppedFrames;
+    private onDroopedVideoFramesLimitTrigger;
+    private getMaxQualityLimit;
+    private get isEnabled();
+    private get isDroppedFramesCheckerSupport();
+    private savePrevFrameCounts;
+}
+export default DroppedFramesManager;

package/types/providers/utils/HTMLVideoElement/TextTrackManager.d.ts

@@ -0,0 +1,30 @@
+import { IExternalTextTrack, IInternalTextTrack, ITextTrack } from '../../../player/types';
+import { IDesiredState, IProviderOutput } from '../../../providers/types';
+/**
+ * TODO: сейчас externalTextTracks и internalTextTracks записываются в availableTextTracks отсюда
+ * нужно будет выпилить этот класс за исключением этой логики,
+ * когда перестанет быть необходима поддержка браузерных субтитров
+ */
+declare class TextTrackManager {
+    private available$;
+    private current$;
+    private error$;
+    private video;
+    private cueSettings;
+    private subscription;
+    private externalTracks;
+    private internalTracks;
+    connect(video: HTMLVideoElement, desiredState: Pick<IDesiredState, 'externalTextTracks' | 'internalTextTracks' | 'currentTextTrack' | 'textTrackCuesSettings'>, providerOutput: Pick<IProviderOutput, 'availableTextTracks$' | 'currentTextTrack$' | 'error$'>): void;
+    private subscribe;
+    private applyCueSettings;
+    private htmlTextTracksAsArray;
+    private htmlTextTrackToITextTrack;
+    private static isHealthyTrack;
+    setExternal(tracks: IExternalTextTrack[]): void;
+    setInternal(tracks: IInternalTextTrack[]): void;
+    select(selectedId: ITextTrack['id'] | undefined): void;
+    destroy(): void;
+    private attach;
+    private detach;
+}
+export default TextTrackManager;

package/types/providers/utils/HTMLVideoElement/clear.d.ts

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

package/types/providers/utils/HTMLVideoElement/destroy.d.ts

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

package/types/providers/utils/HTMLVideoElement/forcePlay.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Пытаемся запустить видео обходя ошибку `NotAllowedError` путём включения `mute`.
+ * @param {HTMLVideoElement} video - видеообъект
+ * @return {Promise}<boolean> - получилось начать воспроизведение
+ */
+declare const _default: (video: HTMLVideoElement) => Promise<boolean>;
+export default _default;

package/types/providers/utils/HTMLVideoElement/observable.d.ts

@@ -0,0 +1,25 @@
+import { Seconds, IRange, IObservable, IError, IValueObservable } from '@vkontakte/videoplayer-shared';
+import { IVolumeState, PlaybackRate } from '../../../player/types';
+export interface IObservableVideo {
+    playing$: IObservable<undefined>;
+    pause$: IObservable<undefined>;
+    canplay$: IObservable<undefined>;
+    ended$: IObservable<undefined>;
+    looped$: IObservable<Seconds>;
+    error$: IObservable<IError>;
+    seeked$: IObservable<undefined>;
+    seeking$: IObservable<undefined>;
+    progress$: IObservable<undefined>;
+    timeUpdate$: IObservable<Seconds>;
+    durationChange$: IObservable<Seconds>;
+    loadStart$: IObservable<void>;
+    loadedMetadata$: IObservable<undefined>;
+    loadedData$: IObservable<undefined>;
+    isBuffering$: IObservable<boolean>;
+    currentBuffer$: IObservable<IRange<Seconds>>;
+    volumeState$: IObservable<IVolumeState>;
+    playbackRateState$: IObservable<PlaybackRate>;
+    inPiP$: IValueObservable<boolean>;
+    inFullscreen$: IValueObservable<boolean>;
+}
+export declare const observe: (video: HTMLVideoElement) => IObservableVideo;

package/types/providers/utils/HTMLVideoElement/pool.d.ts

@@ -0,0 +1,2 @@
+export declare const allocate: (container: HTMLElement) => HTMLVideoElement;
+export declare const dispose: (element: HTMLVideoElement) => void;

package/types/providers/utils/HTMLVideoElement/surface.d.ts

@@ -0,0 +1,2 @@
+export declare const isInFullscreen: (element: HTMLElement) => boolean;
+export declare const isInPip: (element: HTMLElement) => boolean;

package/types/providers/utils/LiveOffset/index.d.ts

@@ -0,0 +1,14 @@
+import { Milliseconds } from '@vkontakte/videoplayer-shared';
+import { ILiveOffset } from './types';
+export default class LiveOffset implements ILiveOffset {
+    private pausedTime;
+    private streamOffset;
+    private pauseTimestamp;
+    getTotalPausedTime(): Milliseconds;
+    getCurrentPausedTime(): Milliseconds;
+    getStreamOffset(): Milliseconds;
+    getTotalOffset(): Milliseconds;
+    pause(): void;
+    resume(): void;
+    resetTo(offset: Milliseconds, isPaused?: boolean): void;
+}

package/types/providers/utils/LiveOffset/types.d.ts

@@ -0,0 +1,10 @@
+import { Milliseconds } from '@vkontakte/videoplayer-shared';
+export interface ILiveOffset {
+    getTotalPausedTime(): Milliseconds;
+    getCurrentPausedTime(): Milliseconds;
+    getStreamOffset(): Milliseconds;
+    getTotalOffset(): Milliseconds;
+    pause(): void;
+    resume(): void;
+    resetTo(offset: Milliseconds, isPaused?: boolean): void;
+}

package/types/providers/utils/addQuicParam.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (url: string) => string;
+export default _default;

package/types/providers/utils/extractConnectionHeaders.d.ts

@@ -0,0 +1,6 @@
+import { HttpConnectionType } from '../../player/types';
+declare const _default: (headers: Headers) => {
+    type: HttpConnectionType | undefined;
+    reused: boolean | undefined;
+};
+export default _default;

package/types/providers/utils/generateLiveUrl.d.ts

@@ -0,0 +1,9 @@
+import { Milliseconds } from '@vkontakte/videoplayer-shared';
+export declare enum OffsetParameterType {
+    OFFSET_P = 0,
+    PLAYBACK_SHIFT = 1,
+    DASH_CMAF_OFFSET_P = 2
+}
+declare const _default: (url: string, offset?: Milliseconds, type?: OffsetParameterType) => string;
+export default _default;
+export declare const getLiveUrlOffset: (url: string, type: OffsetParameterType) => number;

package/types/providers/utils/okQualityStringToVideoQuality.d.ts

@@ -0,0 +1,3 @@
+import { type ExactVideoQuality } from '@vkontakte/videoplayer-shared';
+declare const _default: (string: string) => ExactVideoQuality | undefined;
+export default _default;

package/types/providers/utils/parseFps.d.ts

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

package/types/providers/utils/syncDesiredState.d.ts

@@ -0,0 +1,12 @@
+import { IListener, IObservable, ISubscription } from '@vkontakte/videoplayer-shared';
+import { IVolumeState, PlaybackRate } from '../../player/types';
+import { IStateMachine } from '../../utils/StateMachine/types';
+declare const syncDesiredState: <Value>(desiredState: IStateMachine<Value | undefined>, get: () => Value | undefined, set: (value: Value | undefined) => void, { equal, changed$, onError, }?: {
+    equal?: ((a: Value | undefined, b: Value | undefined) => boolean) | undefined;
+    changed$?: IObservable<Value | undefined> | undefined;
+    onError?: IListener<unknown> | undefined;
+}) => ISubscription;
+export declare const syncVideoLooped: (video: HTMLVideoElement, desiredState: IStateMachine<boolean>, onError?: IListener<Error | unknown>) => ISubscription;
+export declare const syncVideoVolumeState: (video: HTMLVideoElement, desiredState: IStateMachine<IVolumeState>, changed$: IObservable<IVolumeState>, onError?: IListener<Error | unknown>) => ISubscription;
+export declare const syncVideoPlaybackRate: (video: HTMLVideoElement, desiredState: IStateMachine<PlaybackRate>, changed$: IObservable<PlaybackRate>, onError?: IListener<Error | unknown>) => ISubscription;
+export default syncDesiredState;

package/types/providers/utils/syncPlaybackState.d.ts

@@ -0,0 +1,4 @@
+import { IStateMachine } from '../../utils/StateMachine/types';
+import { PlaybackState } from '../../player/types';
+declare const _default: (playbackState: IStateMachine<PlaybackState>, value: PlaybackState, ignoreCurrentTransition?: boolean) => void;
+export default _default;

package/types/utils/3d/Camera3D.d.ts

@@ -0,0 +1,14 @@
+import { Degree, Vector2D, Vector3D } from '../../utils/3d/types';
+/**
+ * Модель камеры трехмерной сцены
+ */
+export declare class Camera3D {
+    fov: Vector2D<Degree>;
+    /**
+     *  x: Degree; // yaw (around vertical Y axis)
+     *  y: Degree; // pitch (around horizontal X axis)
+     *  z: Degree; // roll (around normal Z axis)
+     */
+    orientation: Vector3D<Degree>;
+    constructor(fov: Vector2D<Degree>, orientation: Vector3D<Degree>);
+}

package/types/utils/3d/CameraRotationManager.d.ts

@@ -0,0 +1,62 @@
+import { Camera3D } from '../../utils/3d/Camera3D';
+import { DegreePerSecond, CameraRotationManagerParams, Degree, Vector3D } from '../../utils/3d/types';
+/**
+ * Класс управляющий вращением камеры
+ */
+export declare class CameraRotationManager {
+    private options;
+    private camera;
+    private rotating;
+    private fading;
+    private lastTickTS;
+    private lastCameraTurn;
+    private lastCameraTurnTS;
+    private fadeStartSpeed;
+    private fadeCorrection;
+    private fadeTime;
+    rotationSpeed: Vector3D<DegreePerSecond>;
+    constructor(camera: Camera3D, options: CameraRotationManagerParams);
+    /**
+     * Поворот камеры из текущего положения на заданное количество градусов
+     */
+    turnCamera(dx?: Degree, dy?: Degree, dz?: Degree): void;
+    /**
+     * Поворот камеры в заданное положение
+     */
+    pointCameraTo(x?: Degree, y?: Degree, z?: Degree): void;
+    /**
+     * Устанавливает угловые скорости по осям
+     * Если скорость для оси не задана будет использована ее текущая скорость
+     */
+    setRotationSpeed(sx?: DegreePerSecond, sy?: DegreePerSecond, sz?: DegreePerSecond): void;
+    /**
+     * Start permanent rotation
+     */
+    startRotation(): void;
+    /**
+     * Выставляет нулевую скорость, что приводит к плавной остановке
+     * при передаче поднятого флага останавливает движение мгновенно
+     */
+    stopRotation(immediate?: boolean): void;
+    /**
+     * "Толкает" камеру для плавного затухания при наличии остаточного "крутящего момента"
+     */
+    onCameraRelease(): void;
+    /**
+     * Запускает режим затухания
+     */
+    private startFading;
+    /**
+     * Останавливает режим затухания
+     */
+    private stopFading;
+    /**
+     * Ограничивает угол поворота по вертикальной оси
+     */
+    private limitCameraRotationY;
+    /**
+     * Рассчитывает положение камеры согласно текущей скорости с эмуляцией инерции
+     * @param time - ms from page load
+     */
+    tick(time: number): void;
+}

package/types/utils/3d/Scene3D.d.ts

@@ -0,0 +1,132 @@
+import { Degree, Pixel, Scene3DParams, Vector2D, Vector3D } from '../../utils/3d/types';
+/**
+ * Класс описывающий 3D сцену - канву на которой будет рисоваться проекция
+ */
+export declare class Scene3D {
+    private container;
+    private sourceVideoElement;
+    private canvas;
+    private gl;
+    private params;
+    private frameWidth;
+    private frameHeight;
+    private viewportWidth;
+    private viewportHeight;
+    private videoInitialized;
+    private program;
+    private videoTexture;
+    private vertexBuffer;
+    private textureMappingBuffer;
+    private camera;
+    private cameraRotationManager;
+    private videoElementDataLoadedFn;
+    private renderFn;
+    private active;
+    constructor(container: HTMLElement, sourceVideoElement: HTMLVideoElement, params: Scene3DParams);
+    /**
+     * Запускает отрисовку сцены
+     */
+    play(): void;
+    /**
+     * Останавливает отрисовку сцены
+     */
+    stop(): void;
+    /**
+     * Запускает режим постоянного вращение камеры согласно переданным коэффициентам угловых скоростей
+     * Базовая величина скорости задается в конфиге
+     * Итоговая скорость будет равна произведению базовой скорости и переданного коэффициента
+     * Принимает как положительные так и отрицательные значения (для противоположного вращения)
+     */
+    startCameraManualRotation(mx: number, my: number): void;
+    /**
+     * Останавливает режим постоянного вращение камеры
+     */
+    stopCameraManualRotation(immediate?: boolean): void;
+    /**
+     * Перемещает точку фокуса камеры на заданный угол
+     */
+    turnCamera(dx: Degree, dy: Degree): void;
+    /**
+     * Перемещает точку фокуса камеры на заданный угол
+     */
+    pointCameraTo(dx: Degree, dy: Degree): void;
+    /**
+     * Преобразовывает экранные координаты в градусы в соответствии с текущим полем обзора
+     */
+    pixelToDegree(vector: Vector2D<Pixel>): Vector2D<Degree>;
+    /**
+     * Возвращает текущую ориентацию камеры
+     */
+    getCameraRotation(): Vector3D;
+    /**
+     * Захват камеры - переход в ручное управление
+     */
+    holdCamera(): void;
+    /**
+     * Возвращает управление внутренним алгоритмам
+     */
+    releaseCamera(): void;
+    /**
+     * Уничтожает сцену
+     */
+    destroy(): void;
+    /**
+     * Устанавливает размер "экрана"
+     */
+    setViewportSize(vpx: number, vpy: number): void;
+    /**
+     * Обработчик события загрузки данных на видеоэлементе
+     */
+    private onDataLoadedHandler;
+    /**
+     * Запускает режим отрисовки
+     */
+    private doPlay;
+    /**
+     * Основная функция отрисовки
+     *
+     * @param ts - ms from page load
+     */
+    private render;
+    /**
+     * Создает шейдер
+     */
+    private createShader;
+    /**
+     * Создает webGL програму
+     */
+    private createProgram;
+    /**
+     * Создает текстуру
+     */
+    private createTexture;
+    /**
+     * Обновляет текстуру
+     * Считывает текущий кадр из видео
+     */
+    private updateTexture;
+    /**
+     * Создает буфер вершин плоскости с учетом поправки на отношение сторон
+     */
+    private createVertexBuffer;
+    /**
+     * Создает буффер маппинга текстуры
+     */
+    private createTextureMappingBuffer;
+    /**
+     * Рассчитывает положение текстуры на плоскости
+     */
+    private calculateTexturePosition;
+    /**
+     * Обновляет значения в буффере маппинга текстуры
+     */
+    private updateTextureMappingBuffer;
+    /**
+     * Обновляет кэш различных размеров
+     */
+    private updateFrameSize;
+    /**
+     * Создает канву для сцены
+     */
+    createCanvas(): HTMLCanvasElement;
+}

package/types/utils/3d/types.d.ts

@@ -0,0 +1,25 @@
+import { Milliseconds } from '@vkontakte/videoplayer-shared';
+export interface Vector3D<T = number> {
+    x: T;
+    y: T;
+    z: T;
+}
+export interface Vector2D<T = number> {
+    x: T;
+    y: T;
+}
+export type Pixel = number;
+export type Degree = number;
+export type DegreePerSecond = number;
+export interface CameraRotationManagerParams {
+    rotationSpeed: DegreePerSecond;
+    maxYawAngle: Degree;
+    speedFadeTime: Milliseconds;
+    speedFadeThreshold: Milliseconds;
+    degreeToPixelCorrection: number;
+    rotationSpeedCorrection: number;
+}
+export interface Scene3DParams extends CameraRotationManagerParams {
+    fov: Vector2D;
+    orientation: Vector3D;
+}

package/types/utils/StateMachine/StateMachine.d.ts

@@ -0,0 +1,19 @@
+import { IObservable, ISubject } from '@vkontakte/videoplayer-shared';
+import { IStateMachine, ITransition } from './types';
+export default class StateMachine<TState> implements IStateMachine<TState> {
+    private state;
+    private prevState;
+    private transition?;
+    transitionStarted$: ISubject<ITransition<TState>>;
+    transitionEnded$: ISubject<ITransition<TState>>;
+    transitionUpdated$: ISubject<ITransition<TState>>;
+    forceChanged$: ISubject<ITransition<TState>>;
+    stateChangeStarted$: IObservable<ITransition<TState>>;
+    stateChangeEnded$: IObservable<ITransition<TState>>;
+    constructor(initialState: TState);
+    setState(newState: TState): void;
+    startTransitionTo(newState: TState): void;
+    getTransition(): ITransition<TState> | undefined;
+    getState(): TState;
+    getPrevState(): TState | undefined;
+}

package/types/utils/StateMachine/types.d.ts

@@ -0,0 +1,60 @@
+import { IObservable } from '@vkontakte/videoplayer-shared';
+export interface IStateMachine<TState> {
+    /**
+     * Событие о начале перехода между состояниями
+     */
+    transitionStarted$: IObservable<ITransition<TState>>;
+    /**
+     * Событие об изменении целевого состояния в процессе осуществления перехода
+     */
+    transitionUpdated$: IObservable<ITransition<TState>>;
+    /**
+     * Событие об окончании перехода между состояниями
+     */
+    transitionEnded$: IObservable<ITransition<TState>>;
+    /**
+     * Событие о переходе в состояние, transition в которое не начинался
+     */
+    forceChanged$: IObservable<ITransition<TState>>;
+    /**
+     * Приозводное от `transitionStarted$` и `transitionUpdated$` событие.
+     */
+    stateChangeStarted$: IObservable<ITransition<TState>>;
+    /**
+     * Приозводное от `transitionEnded$` и `forceChanged$` событие.
+     */
+    stateChangeEnded$: IObservable<ITransition<TState>>;
+    /**
+     * Начало перехода в состояние.
+     * Если в этот момент не было активного transition - будет отправлено событие `transitionStarted$`,
+     * иначе - `transitionUpdated$`
+     */
+    startTransitionTo(state: TState): void;
+    /**
+     * Окончание перехода в состояние.
+     * Если transition в это состояние был начат - будет отправлено событие `transitionEnded$`,
+     * иначе - `forceChanged$`
+     */
+    setState(state: TState): void;
+    /**
+     * Возвращает текущее состояние.
+     * Если сейчас есть активный transition - будет возвращено состояние, transition в которое сейчас выполняется (оптимистичноая стратегия изменений)
+     */
+    getState(): TState;
+    /**
+     * Возвращает предыдущее состояние.
+     */
+    getPrevState(): TState | undefined;
+    /**
+     * Возвращает текущий transition (если есть). Иначе - `undefined`
+     */
+    getTransition(): ITransition<TState> | undefined;
+}
+export interface ITransition<TState> {
+    from: TState;
+    to: TState;
+    /**
+     * Информация о том, что переход был осуществлён с прерыванием другого перехода
+     */
+    canceledTransition?: ITransition<TState>;
+}

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

@@ -0,0 +1,13 @@
+export interface IStatefulIterator<T> {
+    next(): void;
+    getValue(): T;
+    isCompleted(): boolean;
+}
+export declare class StatefulIterator<T> implements IStatefulIterator<T> {
+    private iterator;
+    private current;
+    constructor(iteratorOrIterable: Iterable<T>);
+    next(): void;
+    getValue(): T;
+    isCompleted(): boolean;
+}

package/types/utils/ThroughputEstimator.d.ts

@@ -0,0 +1,25 @@
+import { Byte, Kbps, Milliseconds, IValueSubject } from '@vkontakte/videoplayer-shared';
+import { ITuningConfig } from '../utils/tuningConfig';
+declare class ThroughputEstimator {
+    private throughput;
+    private rtt;
+    private subscription;
+    private tuningConfig;
+    private concurrentDownloads;
+    throughput$: IValueSubject<Kbps>;
+    rtt$: IValueSubject<Milliseconds>;
+    rttAdjustedThroughput$: IValueSubject<Kbps>;
+    constructor(tuning: ITuningConfig['throughputEstimator']);
+    destroy(): void;
+    trackXHR(xhr: XMLHttpRequest): void;
+    trackStream(stream: ReadableStream, isLowLatency?: boolean): void;
+    addRawSpeed(size: Byte, time: Milliseconds, concurrency?: number, isLowLatency?: boolean): void;
+    /**
+     * Стоит использовать только когда другие методы совсем не получается
+     */
+    addRawThroughput(rate: Kbps): void;
+    addRawRtt(time: Milliseconds): void;
+    private static sanityCheck;
+    private static load;
+}
+export default ThroughputEstimator;

package/types/utils/addScript.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (src: string) => Promise<void>;
+export default _default;