@vkontakte/videoplayer-core 2.0.33 → 2.0.37

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vkontakte/videoplayer-core",
-  "version": "2.0.33",
+  "version": "2.0.37",
   "author": "vk.com",
   "description": "Videoplayer core library based on the vk.com platform",
   "homepage": "https://vk.com",

package/{player → sdk/src/player}/Player.d.ts

@@ -46,6 +46,7 @@ export default class Player implements IPlayer {
         startAttempt$: Subject<StartStatus>;
         willPause$: Subject<void>;
         willResume$: Subject<void>;
+        willDestruct$: Subject<void>;
         watchCoverageRecord$: Subject<IRange<number>>;
         watchCoverageLive$: Subject<IRange<number>>;
         managedError$: Subject<IError>;

package/{player → sdk/src/player}/types.d.ts

@@ -78,6 +78,10 @@ export interface IPlayerEvents {
      * Запрошено возобновление воспроизведения после паузы
      */
     willResume$: IObservable<void>;
+    /**
+     * Плеер будет уничтожен, в момент события можно синхронно запросить последние данные о его состоянии.
+     */
+    willDestruct$: IObservable<void>;
     /**
      * Просмотрен промежуток видео.
      * Параметр содержит диапазон: начальная и конечная позиция просмотра (в секундах от начала ролика).

package/{player → sdk/src/player}/utils/watchCoverage.d.ts

@@ -2,13 +2,12 @@ import { IObservable, IValueObservable } from '@vkontakte/videoplayer-shared';
 import { IRange } from "../../utils/range";
 import { IStateMachine } from "../../utils/StateMachine/types";
 import { PlaybackState } from "../types";
-import { IProviderEntry } from "../../providers/ProviderContainer/types";
 interface IParams {
     playbackState: IStateMachine<PlaybackState>;
     seekPosition: IStateMachine<number | undefined>;
-    provider$: IValueObservable<IProviderEntry>;
+    playbackAbort$: IObservable<void>;
     position$: IValueObservable<number>;
 }
-export declare const watchCoverageRecord: ({ playbackState, seekPosition, provider$, position$, }: IParams) => IObservable<IRange<number>>;
-export declare const watchCoverageLive: ({ playbackState, seekPosition, provider$, position$, }: IParams) => IObservable<IRange<number>>;
+export declare const watchCoverageRecord: ({ playbackState, seekPosition, playbackAbort$, position$, }: IParams) => IObservable<IRange<number>>;
+export declare const watchCoverageLive: ({ playbackState, seekPosition, playbackAbort$, position$, }: IParams) => IObservable<IRange<number>>;
 export {};

package/{providers → sdk/src/providers}/DashVKProvider/lib/buffer.d.ts

@@ -1,8 +1,10 @@
 import type ThroughputEstimator from "../../../utils/ThroughputEstimator";
+import { ITuningConfig } from "../../../utils/tuningConfig";
 import { IError, ISubject, IValueSubject, Milliseconds } from '@vkontakte/videoplayer-shared';
 import { Representation, RepresentationKind } from './types';
 export interface Dependencies {
     throughputEstimator: ThroughputEstimator;
+    tuning: ITuningConfig['dash'];
 }
 export declare class BufferManager {
     ended$: IValueSubject<boolean>;
@@ -20,8 +22,10 @@ export declare class BufferManager {
     private segmentDownloadPromise;
     private abortController;
     private loadAllInitsPromise;
+    private allInitsLoaded;
     private throughputEstimator;
-    constructor(kind: RepresentationKind, mediaSource: MediaSource, representations: Representation[], { throughputEstimator }: Dependencies);
+    private tuning;
+    constructor(kind: RepresentationKind, mediaSource: MediaSource, representations: Representation[], { throughputEstimator, tuning }: Dependencies);
     startWith(id: Representation['id']): Promise<void>;
     switchTo(newRepresentationId: Representation['id']): Promise<void>;
     maintain(currentPosition: Milliseconds): Promise<void>;

package/{providers → sdk/src/providers}/DashVKProvider/lib/player.d.ts

@@ -1,7 +1,8 @@
 import { Representation, RepresentationKind } from "./types";
 import StateMachine from "../../../utils/StateMachine/StateMachine";
 import type ThroughputEstimator from "../../../utils/ThroughputEstimator";
-import { IValueSubject, Milliseconds } from '@vkontakte/videoplayer-shared';
+import { ITuningConfig } from "../../../utils/tuningConfig";
+import { ISubject, IValueSubject, Milliseconds, IError } from '@vkontakte/videoplayer-shared';
 import { Manifest } from './mpd';
 export declare enum State {
     NONE = "none",
@@ -10,17 +11,21 @@ export declare enum State {
 }
 export interface Params {
     throughputEstimator: ThroughputEstimator;
+    tuning: ITuningConfig;
 }
 export declare class Player {
     private element;
     private source;
     private manifest;
+    private tuning;
     private videoBufferManager;
     private audioBufferManager;
     private throughputEstimator;
     private subscription;
     state$: StateMachine<State>;
     currentVideoRepresentation$: IValueSubject<Representation['id'] | undefined>;
+    error$: ISubject<IError>;
+    private forceEnded$;
     constructor(params: Params);
     initManifest(element: HTMLVideoElement, manifestUrl: string): Promise<Manifest>;
     initRepresentations(initialVideo: Representation['id'], initialAudio: Representation['id']): Promise<void>;

package/sdk/src/utils/ThroughputEstimator.d.ts

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

package/{utils → sdk/src/utils}/autoSelectVideoTrack.d.ts

@@ -6,6 +6,7 @@ export interface Constraints {
     container?: IRectangle;
     throughput?: Kbps;
     tuning: ITuningConfig['autoTrackSelection'];
+    forwardBufferHealth?: number;
 }
-declare const autoSelectVideoTrack: (tracks: IVideoTrack[], { container, throughput, tuning, }: Constraints) => IVideoTrack;
+declare const autoSelectVideoTrack: (tracks: IVideoTrack[], { container, throughput, tuning, forwardBufferHealth, }: Constraints) => IVideoTrack;
 export default autoSelectVideoTrack;

package/sdk/src/utils/buffer/getForwardBufferDuration.d.ts

@@ -0,0 +1,3 @@
+import { Milliseconds } from '@vkontakte/videoplayer-shared';
+declare const _default: (timeRanges: TimeRanges, position: Milliseconds) => Milliseconds;
+export default _default;

package/sdk/src/utils/smoothedValue.d.ts

@@ -0,0 +1,24 @@
+import { IValueSubject } from '@vkontakte/videoplayer-shared';
+interface IParams {
+    initial: number;
+    emaAlphaSlow: number;
+    emaAlphaFast: number;
+    changeThreshold: number;
+    fastDirection: 1 | -1;
+    label?: string;
+}
+export declare class SmoothedValue {
+    private prevReported;
+    private slow;
+    private fast;
+    private smoothed;
+    private params;
+    private rawSeries$;
+    private smoothedSeries$;
+    private reportedSeries$;
+    smoothed$: IValueSubject<number>;
+    debounced$: IValueSubject<number>;
+    constructor(params: IParams);
+    next(value: number): void;
+}
+export {};

package/{utils → sdk/src/utils}/tuningConfig.d.ts

@@ -2,21 +2,26 @@ import { VideoFormat } from "../player/types";
 import { Byte, Milliseconds } from '@vkontakte/videoplayer-shared';
 export declare type ITuningConfig = {
     throughputEstimator: {
-        emaAlpha: number;
         emaAlphaSlow: number;
         emaAlphaFast: number;
         changeThreshold: number;
         useBrowserEstimation: boolean;
+        rttPenaltyRequestSize: Byte;
         streamMinSampleSize: Byte;
         streamMinSampleTime: Milliseconds;
     };
     autoTrackSelection: {
-        bitrateFactor: number;
+        bitrateFactorAtEmptyBuffer: number;
+        bitrateFactorAtFullBuffer: number;
         limitByContainer: boolean;
         usePixelRatio: boolean;
         containerSizeFactor: number;
-        stepQualityDown: boolean;
-        stepQualityDownExceptForTop: boolean;
+    };
+    dash: {
+        extraInitSize: Milliseconds;
+        forwardBufferTarget: Milliseconds;
+        segmentRequestSize: Byte;
+        representationSwitchForwardBufferGap: Milliseconds;
     };
     enableTelemetryAtStart: boolean;
     formatsToAvoid: VideoFormat[];
@@ -30,6 +35,7 @@ export declare type ITuningConfig = {
     insufficientBufferRuleMargin: Milliseconds;
     dashSeekInSegmentDurationThreshold: Milliseconds;
     dashSeekInSegmentAlwaysSeekDelta: Milliseconds;
+    endGapTolerance: Milliseconds;
 };
 export declare type IOptionalTuningConfig = {
     [key in keyof ITuningConfig]?: Partial<ITuningConfig[key]>;

package/shared/src/Logger/Logger.d.ts

@@ -0,0 +1,10 @@
+import Subject from '../reactive/Subject';
+import { ILogger, ILogInputEntry, IComponentLogger, ILogEntry } from './types';
+export declare class Logger implements ILogger {
+    log$: Subject<ILogEntry>;
+    private logs;
+    log: (inputEntry: ILogInputEntry) => void;
+    createCustomLog<TArgs extends unknown[]>(transform: (...args: TArgs) => ILogInputEntry): (...args: TArgs) => void;
+    createComponentLog(component: string): IComponentLogger;
+    getAllLogs: () => ILogEntry[];
+}

package/shared/src/Logger/index.d.ts

@@ -0,0 +1,2 @@
+export { Logger } from './Logger';
+export type { ILogger, ILogInputEntry, IComponentLogEntry, IComponentLogger, ILogEntry } from './types';

package/shared/src/index.d.ts

@@ -0,0 +1,4 @@
+export * from './Logger';
+export * from './utils';
+export * from './reactive';
+export * from './types';

package/shared/src/reactive/Observable.d.ts

@@ -0,0 +1,7 @@
+import { IEmitter, IListener, IObservable, IOperator, ISubscription, IUnsubscriber } from './types';
+export default class Observable<T> implements IObservable<T> {
+    constructor(subscribe?: (emitter: IEmitter<T>) => IUnsubscriber | ISubscription | void);
+    subscribe(listener: IListener<T>, error?: IListener<Error | unknown>): ISubscription;
+    pipe(...operators: IOperator<unknown, unknown>[]): IObservable<unknown>;
+    protected _subscribe(_emitter: IEmitter<T>): IUnsubscriber | ISubscription | void;
+}

package/shared/src/reactive/Subject.d.ts

@@ -0,0 +1,10 @@
+import { IEmitter, ISubject, ISubscription, IUnsubscriber } from './types';
+import Observable from './Observable';
+export default class Subject<T> extends Observable<T> implements ISubject<T> {
+    private keyCounter;
+    private subscribers;
+    constructor();
+    next(value: T): void;
+    error(value: T): void;
+    protected _subscribe(emitter: IEmitter<T>): IUnsubscriber | ISubscription | void;
+}

package/shared/src/reactive/Subscription.d.ts

@@ -0,0 +1,6 @@
+import { ISubscription, IUnsubscriber } from './types';
+export default class Subscription implements ISubscription {
+    private subscriptions;
+    unsubscribe(): void;
+    add(item: ISubscription | IUnsubscriber): ISubscription;
+}

package/shared/src/reactive/ValueSubject.d.ts

@@ -0,0 +1,10 @@
+import { IEmitter, ISubscription, IUnsubscriber, IValueSubject } from './types';
+import Subject from './Subject';
+export default class ValueSubject<T> extends Subject<T> implements IValueSubject<T> {
+    private value;
+    constructor(initialValue: T);
+    next(value: T): void;
+    error(value: T): void;
+    getValue(): T;
+    protected _subscribe(emitter: IEmitter<T>): IUnsubscriber | ISubscription | void;
+}

package/shared/src/reactive/combine.d.ts

@@ -0,0 +1,10 @@
+import { IObservable, TypeOfObservable } from './types';
+/**
+ *  Создаёт Observable, который состоит из объектов, ключами которых являются последние значения исходных Observable.
+ *  Первое событие возникает тогда, когда каждый исходный Observable выдал хотя бы одно значение.
+ */
+declare type CombineObservables<T extends Record<string, IObservable<unknown>>> = {
+    [key in keyof T]: TypeOfObservable<T[key]>;
+};
+export default function combine<T extends Record<string, IObservable<unknown>>>(observables: T): IObservable<CombineObservables<T>>;
+export {};

package/shared/src/reactive/fromEvent.d.ts

@@ -0,0 +1,7 @@
+import { IObservable } from './types';
+interface IEventTarget {
+    addEventListener(type: string, handler: (...params: any[]) => void): void;
+    removeEventListener(type: string, handler: (...params: any[]) => void): void;
+}
+declare const _default: <T>(target: IEventTarget, eventName: string) => IObservable<T>;
+export default _default;

package/shared/src/reactive/index.d.ts

@@ -0,0 +1,19 @@
+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 observableFrom } from './observableFrom';
+export { default as fromEvent } from './fromEvent';
+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/shared/src/reactive/merge.d.ts

@@ -0,0 +1,12 @@
+import { 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/shared/src/reactive/observableFrom.d.ts

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

package/shared/src/reactive/operators/debounce.d.ts

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

package/shared/src/reactive/operators/filter.d.ts

@@ -0,0 +1,3 @@
+import { 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/shared/src/reactive/operators/filterChanged.d.ts

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

package/shared/src/reactive/operators/map.d.ts

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

package/shared/src/reactive/operators/mapTo.d.ts

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

package/shared/src/reactive/operators/once.d.ts

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

package/shared/src/reactive/operators/pairwise.d.ts

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

package/shared/src/reactive/operators/tap.d.ts

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

package/shared/src/reactive/operators/throttle.d.ts

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

package/shared/src/reactive/timeout.d.ts

@@ -0,0 +1,3 @@
+import { IObservable } from './types';
+declare const _default: (interval: number) => IObservable<void>;
+export default _default;

package/shared/src/types/index.d.ts

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

package/shared/src/utils/addScript.d.ts

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