@vkontakte/videoplayer-core 2.0.36 → 2.0.37

package/package.json

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

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

@@ -22,6 +22,7 @@ export declare class BufferManager {
     private segmentDownloadPromise;
     private abortController;
     private loadAllInitsPromise;
+    private allInitsLoaded;
     private throughputEstimator;
     private tuning;
     constructor(kind: RepresentationKind, mediaSource: MediaSource, representations: Representation[], { throughputEstimator, tuning }: Dependencies);

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/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,11 +2,11 @@ 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;
     };

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

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

@@ -0,0 +1,5 @@
+export { noop } from './noop';
+export { assertNever, checkNever } from './never';
+export { isNonNullable, isNullable, assertNonNullable, assertNullable } from './nullable';
+export { addScript } from './addScript';
+export type { Milliseconds, bps, Byte, Seconds, Kbps, Mbps } from './semanticTypes';

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

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

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

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

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

@@ -0,0 +1,6 @@
+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;
+declare type INullable = null | undefined;
+export {};

package/utils/ThroughputEstimator.d.ts

@@ -1,31 +0,0 @@
-import { Subject, ValueSubject, Byte, Kbps, Milliseconds, ISubject } from '@vkontakte/videoplayer-shared';
-import { ITuningConfig } from "./tuningConfig";
-declare class ThroughputEstimator {
-    private smoothedCombination;
-    private smoothedFast;
-    private smoothedSlow;
-    private subscription;
-    private rawSeries$;
-    private smoothedSeries$;
-    private reportedSeries$;
-    xhr$: ISubject<XMLHttpRequest>;
-    rawSpeed$: ISubject<{
-        size: Byte;
-        time: Milliseconds;
-    }>;
-    rawThroughput$: ISubject<Kbps>;
-    stream$: Subject<ReadableStream<any>>;
-    private tuningConfig;
-    estimation$: ValueSubject<number>;
-    rtt$: ValueSubject<number | undefined>;
-    constructor(tuning: ITuningConfig['throughputEstimator']);
-    destroy(): void;
-    private trackXHR;
-    private trackStream;
-    private addRawSpeed;
-    private sanityCheck;
-    private addValue;
-    private load;
-    private dump;
-}
-export default ThroughputEstimator;