@vkontakte/videoplayer-core 2.0.62 → 2.0.65

package/index.d.ts

@@ -2,8 +2,7 @@ import { VideoFormat, IMpegSource, IDashSource, IHLSSource, IDashURLSource, IHLS
 import Player from "./player/Player";
 import { IPlayer, PlaybackState, IPlayerInfo, IPlayerEvents, IConfig, ISources, ICueSettings, ChromecastState, HttpConnectionType, IExternalTextTrack, ITextTrack } from "./player/types";
 import { VideoQuality, ExactVideoQuality } from "./utils/quality/types";
-import { IRange } from "./utils/range";
-import type { ISubscription, IUnsubscriber, IEmitter, IObservable, IValueObservable, IValue, IOperator, IListener, ILogEntry } from '@vkontakte/videoplayer-shared';
+import type { ISubscription, IUnsubscriber, IEmitter, IObservable, IValueObservable, IValue, IOperator, IListener, ILogEntry, IRange } from '@vkontakte/videoplayer-shared';
 import { Subscription, Observable, Subject, ValueSubject } from '@vkontakte/videoplayer-shared';
 /**
  * Версия sdk

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vkontakte/videoplayer-core",
-  "version": "2.0.62",
+  "version": "2.0.65",
   "author": "vk.com",
   "description": "Videoplayer core library based on the vk.com platform",
   "homepage": "https://vk.com",
@@ -14,7 +14,7 @@
     "**/*.d.ts"
   ],
   "dependencies": {
-    "@vkontakte/videoplayer-shared": "^1.0.14",
+    "@vkontakte/videoplayer-shared": "^1.0.15",
     "dashjs": "4.4.0",
     "hls.js": "1.1.5",
     "lodash": "4.17.21"

package/packages/sdk/src/providers/DashVKProvider/lib/buffer.d.ts

@@ -1,13 +1,13 @@
 import { ITuningConfig } from "../../../utils/tuningConfig";
-import { IError, ISubject, IValueSubject, Milliseconds } from '@vkontakte/videoplayer-shared';
+import { IError, IRange, ISubject, IValueSubject, Milliseconds } from '@vkontakte/videoplayer-shared';
 import type { Fetcher } from './fetcher';
-import { Container, Range, Representation, RepresentationKind } from './types';
+import { Container, Representation, RepresentationKind } from './types';
 export interface Dependencies {
     fetcher: Fetcher;
     tuning: ITuningConfig;
     getCurrentPosition: () => Milliseconds | undefined;
 }
-export interface Gap extends Range<Milliseconds> {
+export interface Gap extends IRange<Milliseconds> {
     representation: Representation['id'];
 }
 export declare class BufferManager {

package/packages/sdk/src/providers/DashVKProvider/lib/fetcher.d.ts

@@ -1,7 +1,7 @@
 import { HttpConnectionType } from "../../../player/types";
-import { GenericContainerParser, Representation, Segment } from './types';
 import type ThroughputEstimator from "../../../utils/ThroughputEstimator";
-import { Byte, IValueSubject, Milliseconds } from '@vkontakte/videoplayer-shared';
+import { Byte, IValueSubject, Milliseconds, IRange } from '@vkontakte/videoplayer-shared';
+import { GenericContainerParser, Segment, SegmentReference } from './types';
 export declare enum RangeMethod {
     HEADER = 0,
     PARAM = 1
@@ -12,12 +12,17 @@ export interface IParams {
 }
 export declare type Priority = 'high' | 'low' | 'auto';
 export interface FetchParams {
-    method?: RangeMethod;
+    range?: IRange<Byte>;
+    rangeMethod?: RangeMethod;
     onProgress?: (view: DataView, loaded: Byte) => void;
     signal?: AbortSignal;
     priority?: Priority;
     measureThroughput?: boolean;
 }
+export declare type RepresentationFetchResult = {
+    segments: Segment[];
+    dataView: DataView;
+};
 export declare class Fetcher {
     private throughputEstimator;
     private requestQuic;
@@ -29,11 +34,10 @@ export declare class Fetcher {
     constructor({ throughputEstimator, requestQuic }: IParams);
     private onHeadersReceived;
     fetchManifest: (param_0: string) => Promise<string | null | undefined>;
-    fetchRange: (param_0: string, param_1: number, param_2: number, param_3: FetchParams) => Promise<ArrayBuffer | null | undefined>;
-    fetchRepresentation: (param_0: Representation, param_1: GenericContainerParser<unknown>, param_2?: Priority | undefined, param_3?: number | undefined) => Promise<{
-        segments: Segment[];
-        dataView: DataView;
-    } | null | undefined>;
+    fetch: (param_0: string, param_1: FetchParams) => Promise<ArrayBuffer | null | undefined>;
+    fetchRepresentation(segmentReference: SegmentReference, parser: GenericContainerParser<unknown>, priority?: Priority): Promise<RepresentationFetchResult | null>;
     destroy(): void;
+    private fetchByteRangeRepresentation;
+    private fetchTemplateRepresentation;
 }
 export declare const suppressAbort: (e: Error | unknown) => void;

package/packages/sdk/src/providers/DashVKProvider/lib/mpd.d.ts

@@ -1,2 +1,2 @@
 import { Manifest } from './types';
-export declare const parse: (text: string, url: string) => Manifest;
+export declare const parse: (text: string, manifestUrl: string) => Manifest;

package/packages/sdk/src/providers/types.d.ts

@@ -1,10 +1,9 @@
 import { QualityLimits } from "../utils/quality/types";
 import { ITuningConfig } from "../utils/tuningConfig";
-import { ILogger, ISubject, IValueSubject, Milliseconds, Seconds, IError } from '@vkontakte/videoplayer-shared';
+import { ILogger, ISubject, IValueSubject, Milliseconds, Seconds, IRange, IError } from '@vkontakte/videoplayer-shared';
 import { IChromecastInitializer } from "./ChromecastProvider/ChromecastInitializer/types";
 import { HttpConnectionType, ICueSettings, SeekState } from "../player/types";
 import { IExternalTextTrack, ITextTrack, IVideoTrack, IVolumeState, PlaybackState } from "../player/types";
-import { IRange } from "../utils/range";
 import { IStateMachine } from "../utils/StateMachine/types";
 import ThroughputEstimator from "../utils/ThroughputEstimator";
 export interface IProvider {
@@ -58,6 +57,7 @@ export interface IProviderOutput {
     error$: ISubject<IError>;
     endedEvent$: ISubject<void>;
     loopedEvent$: ISubject<Seconds>;
-    firstBytesEvent$: ISubject<number>;
-    firstFrameEvent$: ISubject<number>;
+    firstBytesEvent$: ISubject<void>;
+    firstFrameEvent$: ISubject<void>;
+    canplay$: ISubject<void>;
 }

package/packages/sdk/src/utils/buffer/types.d.ts

@@ -1,5 +1,4 @@
-import { Seconds } from '@vkontakte/videoplayer-shared';
-import { IRange } from "../range";
+import { Seconds, IRange } from '@vkontakte/videoplayer-shared';
 export interface IVideoBuffer extends IRange<Seconds> {
     i: number;
 }

package/player/Player.d.ts

@@ -1,6 +1,5 @@
-import { HttpConnectionType, ICueSettings } from "./types";
+import { HttpConnectionType, ICueSettings, StartEnd } from "./types";
 import { QualityLimits, VideoQuality } from "../utils/quality/types";
-import { IRange } from "../utils/range";
 import { IOptionalTuningConfig } from "../utils/tuningConfig";
 import { IError, ILogEntry, Seconds, Subject, ValueSubject } from '@vkontakte/videoplayer-shared';
 import { ChromecastState, IConfig, IExternalTextTrack, IPlayer, ISeekRequest, ITextTrack, PlaybackState, StartStatus, VideoFormat } from './types';
@@ -15,6 +14,7 @@ export default class Player implements IPlayer {
     private tuning;
     private throughputEstimator;
     private isPlaybackStarted;
+    private initedAt;
     private desiredState;
     info: {
         playbackState$: ValueSubject<PlaybackState>;
@@ -28,7 +28,7 @@ export default class Player implements IPlayer {
         isAutoQualityEnabled$: ValueSubject<boolean>;
         autoQualityLimitingAvailable$: ValueSubject<boolean>;
         autoQualityLimits$: ValueSubject<QualityLimits>;
-        currentBuffer$: ValueSubject<IRange<number> | undefined>;
+        currentBuffer$: ValueSubject<StartEnd<number> | undefined>;
         isBuffering$: ValueSubject<boolean>;
         isStalled$: ValueSubject<boolean>;
         isEnded$: ValueSubject<boolean>;
@@ -52,13 +52,14 @@ export default class Player implements IPlayer {
         } | undefined>;
     };
     events: {
+        inited$: Subject<void>;
         started$: Subject<boolean>;
         startAttempt$: Subject<StartStatus>;
         willPause$: Subject<void>;
         willResume$: Subject<void>;
         willDestruct$: Subject<void>;
-        watchCoverageRecord$: Subject<IRange<number>>;
-        watchCoverageLive$: Subject<IRange<number>>;
+        watchCoverageRecord$: Subject<StartEnd<number>>;
+        watchCoverageLive$: Subject<StartEnd<number>>;
         managedError$: Subject<IError>;
         fatalError$: Subject<IError>;
         ended$: Subject<void>;
@@ -67,6 +68,7 @@ export default class Player implements IPlayer {
         willSeek$: Subject<ISeekRequest>;
         firstBytes$: Subject<number>;
         firstFrame$: Subject<number>;
+        canplay$: Subject<number>;
         log$: Subject<ILogEntry>;
     };
     experimental: {

package/player/types.d.ts

@@ -1,7 +1,9 @@
-import { IObservable, IValueObservable, IValueSubject, ILogEntry, Kbps, Milliseconds, Seconds, IError } from '@vkontakte/videoplayer-shared';
+import { IObservable, IValueObservable, IValueSubject, ILogEntry, Kbps, Milliseconds, Seconds, IRectangle, IError } from '@vkontakte/videoplayer-shared';
 import { QualityLimits, VideoQuality } from "../utils/quality/types";
-import { IRange } from "../utils/range";
-import { IRectangle } from "../utils/rectangle";
+export interface StartEnd<Unit extends number> {
+    start: Unit;
+    end: Unit;
+}
 export interface IPlayer {
     info: IPlayerInfo;
     events: IPlayerEvents;
@@ -66,6 +68,10 @@ export interface IPlayer {
  * остальные - в момент окончания действия.
  */
 export interface IPlayerEvents {
+    /**
+     * Плеер получил ссылку и готов к взаимодействию
+     */
+    inited$: IObservable<void>;
     /**
      * Видео начало воспроизведение в первый раз
      * Соответствует первому для видео внешнему запуску воспроизведения
@@ -92,12 +98,12 @@ export interface IPlayerEvents {
      * Просмотрен промежуток видео.
      * Параметр содержит диапазон: начальная и конечная позиция просмотра (в секундах от начала ролика).
      */
-    watchCoverageRecord$: IObservable<IRange<Seconds>>;
+    watchCoverageRecord$: IObservable<StartEnd<Seconds>>;
     /**
      * Просмотрен промежуток видео. Промежуток видео, которые были просмотрены пользователем.
      * Параметр содержит диапазон: начальный и конечный UTC tipestamp?
      */
-    watchCoverageLive$: IObservable<IRange<Milliseconds>>;
+    watchCoverageLive$: IObservable<StartEnd<Milliseconds>>;
     /**
      * Ошибка в работе после которой воспроизведение было восстановлено
      */
@@ -126,15 +132,21 @@ export interface IPlayerEvents {
      * Получен первый кусок контента от сервера раздачи видео
      * Событие поддерживается не во всех провайдерах (т.к. не все способы проигрывания видео поддерживают такой интерфейс)
      *
-     * Содержит время в миллисекундах: сколько прошло с момента отправки запроса за видео данными (ping)
+     * Содержит время в миллисекундах: сколько прошло с момента инициализации
      */
-    firstBytes$: IObservable<number>;
+    firstBytes$: IObservable<Milliseconds>;
     /**
      * Показан первый кадр
      *
-     * Содержит время в миллисекундах: сколько прошло времени с момента старта воспроизведения
+     * Содержит время в миллисекундах: сколько прошло времени с инициализации
+     */
+    firstFrame$: IObservable<Milliseconds>;
+    /**
+     * Плеер готов начать воспроизведение
+     *
+     * Содержит время в миллисекундах: сколько прошло времени с инициализации
      */
-    firstFrame$: IObservable<number>;
+    canplay$: IObservable<Milliseconds>;
     /**
      * Логи для отладки
      */
@@ -199,7 +211,7 @@ export interface IPlayerInfo {
      *
      * default value: `undefined`
      */
-    currentBuffer$: IValueObservable<IRange | undefined>;
+    currentBuffer$: IValueObservable<StartEnd<Seconds> | undefined>;
     /**
      * Статус буферизации видео. true если буфер пустой и воспроизведение прервано
      * В отличии от isStalled показывает и буферизации на старте и после перемотки
@@ -304,6 +316,7 @@ export interface ISources {
     [VideoFormat.DASH_WEBM_VK]?: IDashURLSource;
     [VideoFormat.DASH_WEBM]?: IDashURLSource;
     [VideoFormat.DASH_ONDEMAND]?: IDashURLSource;
+    [VideoFormat.DASH_ONDEMAND_VK]?: IDashURLSource;
     [VideoFormat.DASH_LIVE]?: IDashURLSource;
     [VideoFormat.DASH_LIVE_WEBM]?: IDashURLSource;
     [VideoFormat.HLS]?: IHLSSource;
@@ -341,6 +354,7 @@ export declare enum VideoFormat {
     DASH_WEBM = "DASH_WEBM",
     DASH_WEBM_VK = "DASH_WEBM_VK",
     DASH_ONDEMAND = "DASH_ONDEMAND",
+    DASH_ONDEMAND_VK = "DASH_ONDEMAND_VK",
     DASH_LIVE = "DASH_LIVE",
     DASH_LIVE_WEBM = "DASH_LIVE_WEBM",
     HLS = "HLS",

package/player/utils/watchCoverage.d.ts

@@ -1,5 +1,4 @@
-import { IObservable, IValueObservable, Seconds } from '@vkontakte/videoplayer-shared';
-import { IRange } from "../../utils/range";
+import { IObservable, IValueObservable, Seconds, IRange } from '@vkontakte/videoplayer-shared';
 import { IStateMachine } from "../../utils/StateMachine/types";
 import { PlaybackState, SeekState } from "../types";
 interface IParams {

package/providers/DashLiveProvider/utils/LiveDashPlayer.d.ts

@@ -0,0 +1,135 @@
+import { Milliseconds } from '@vkontakte/videoplayer-shared';
+import { IRepresentation } from '../types';
+interface IParams {
+    videoElement: HTMLVideoElement;
+    playerCallback: (...args: any) => void;
+    config: {
+        minBuffer: Milliseconds;
+        lowLatencyMinBuffer: Milliseconds;
+        minBufferSegments: number;
+        lowLatencyMinBufferSegments: number;
+        maxParallelRequests: number;
+    };
+    logger: (...args: any[]) => void;
+}
+export default class LiveDashPlayer {
+    private paused;
+    private autoQuality;
+    private maxAutoQuality;
+    private buffering;
+    private destroyed;
+    private videoPlayStarted;
+    private lowLatency;
+    private rep?;
+    private bitrate;
+    private manifest;
+    private bitrateSwitcher?;
+    private filesFetcher?;
+    private sourceBuffer?;
+    private mediaSource?;
+    private currentManifestEntry?;
+    private manifestRequest?;
+    private manifestRefetchTimer?;
+    private bufferStates;
+    private downloadRate?;
+    private sourceJitter;
+    private chunkRateEstimator;
+    private manifestUrl;
+    private urlResolver;
+    private params;
+    constructor(params: IParams);
+    attachSource(manifestUrl: string): void;
+    /**
+     * switch to auto quality
+     */
+    setAutoQualityEnabled(enabled: boolean): void;
+    setMaxAutoQuality(height: number | undefined): void;
+    /**
+     * switch quality by name
+     */
+    switchByName(name: string): void;
+    /**
+     * seek to actual video position
+     */
+    catchUp(): void;
+    stop(): void;
+    pause(): void;
+    play(onPlayNotAllowed?: () => void): void;
+    startPlay(targetQ: IRepresentation, autoQuality: boolean): void;
+    /**
+     * destroy player
+     */
+    destroy(): void;
+    reinit(newManifestUrl: string): void;
+    /**
+     * if all retries fail...
+     */
+    private _handleNetworkError;
+    /**
+     * Retry request
+     */
+    private _retryCallback;
+    /**
+     * how many seconds are there in the buffer
+     */
+    private _getBufferSizeSec;
+    /**
+     * send buffering notification to player
+     */
+    private _notifyBuffering;
+    /**
+     * initialize video tag, add necessary event listeners
+     * @private
+     */
+    private _initVideo;
+    /**
+     * there may be small gaps of several milliseconds when switching quality
+     * we jump over these gaps here
+     */
+    private _fixupStall;
+    /**
+     * return best quality for rate
+     */
+    private _selectQuality;
+    private shouldPlay;
+    /**
+     * set video source
+     */
+    private _setVideoSrc;
+    /**
+     * initialize player with target quality
+     */
+    private _initPlayerWith;
+    /**
+     * represents specific quality stream
+     */
+    private _representation;
+    /**
+     * switch to quality
+     * TODO: Если новое качество выше старого – переключиться сразу. Если хуже, доиграть буфер
+     */
+    private _switchToQuality;
+    /**
+     * check if quality is available
+     */
+    private _qualityAvailable;
+    /**
+     * analyze bitrate data and switch qualities accordingly
+     */
+    private _initBitrateSwitcher;
+    /**
+     * load and parse manifest file
+     */
+    private _fetchManifest;
+    private _playVideoElement;
+    /**
+     * update internal state when manifest was received from remote
+     */
+    private _handleManifestUpdate;
+    /**
+     * schedule manifest update after delay
+     */
+    private _refetchManifest;
+    private _initManifest;
+}
+export {};

package/providers/DashProvider/utils/DashLite.d.ts

@@ -0,0 +1,60 @@
+import { Milliseconds } from '@vkontakte/videoplayer-shared';
+import HttpVideoBuffer from "../../../utils/buffer/HttpVideoBuffer";
+import { IDashConfig, IRef, IRepresentation } from '../types';
+interface IParams {
+    video: HTMLVideoElement;
+    buffer: HttpVideoBuffer;
+    selectRepresentation: (representations: IRepresentation[]) => IRepresentation;
+    onManifestReady: (representations: IRepresentation[]) => void;
+    onIdxRequestPing: (ping: Milliseconds) => void;
+    onResponseHeaders: (headers: Headers) => void;
+    onBandwidthChange: (payload: {
+        size: number;
+        duration: number;
+        speed: number;
+    }) => void;
+    onRepresentationPlay: (representation: IRepresentation) => void;
+    onError: (id: string, message: string, thrown?: Error | unknown) => void;
+    config: IDashConfig;
+    onDashCallback?: (eventName: string, param?: any) => any;
+}
+export default class DashLite {
+    private _params;
+    private _representations;
+    private _appendVector;
+    private _currentRepresentation?;
+    private _stream;
+    private _lastLoadOffset?;
+    private _loopTimeout?;
+    private _cachingPaused;
+    private _duration;
+    private STREAM_END_THRESHOLD;
+    private _video;
+    private _buffer;
+    private _onDashCallback;
+    private _config;
+    constructor(params: IParams);
+    /**
+     * Parse duration from ISO8601 string.
+     * @see https://en.wikipedia.org/wiki/ISO_8601#Durations
+     * @see https://github.com/moment/moment/blob/develop/src/lib/duration/create.js#L13
+     */
+    _parseDurationFromISO8601(input: string): number;
+    getRepresentations(): IRepresentation[];
+    attachSource(manifestUrl: string, failoverHosts?: string[]): void;
+    attachManifest(manifestString: string, failoverHosts?: string[], origin?: string): void;
+    _loadInitAndSidx(representation: IRepresentation, cb?: () => void): void;
+    startPlay(representation: IRepresentation): void;
+    _loadRef(representation: IRepresentation, fromTime: number, needToSeek?: boolean, forcePrecise?: boolean): void;
+    setQualityByRepresentation(newRepresentation: IRepresentation, force?: boolean): void;
+    setQuality(index: number): void;
+    pauseCaching(): void;
+    resumeCaching(): void;
+    seek(time: number, forcePrecise?: boolean): void;
+    updateRefsForCurrentTime(): void;
+    _findRef(time: number): IRef | undefined;
+    _isLastRef(ref: IRef): boolean;
+    _findBufferRangeEnd(time: number): number;
+    destroy(): void;
+}
+export {};

package/providers/DashVKProvider/lib/types.d.ts

@@ -1,4 +1,4 @@
-import { Byte, Kbps, Milliseconds } from '@vkontakte/videoplayer-shared';
+import { Byte, Kbps, Milliseconds, IRange } from '@vkontakte/videoplayer-shared';
 export declare enum RepresentationKind {
     VIDEO = "video",
     AUDIO = "audio",
@@ -8,31 +8,52 @@ export declare enum Profile {
     WEBM_AS_IN_SPEC = "urn:mpeg:dash:profile:webm-on-demand:2012",
     WEBM_AS_IN_FFMPEG = "urn:webm:dash:profile:webm-on-demand:2012"
 }
-export interface Range<Unit extends number> {
-    from: Unit;
-    to: Unit;
-}
 export interface Representation {
     id: string;
     kind: RepresentationKind;
+    segmentReference: SegmentReference;
     profiles: Array<Profile | string>;
-    initRange: Range<Byte>;
-    indexRange?: Range<Byte>;
     duration?: Milliseconds;
     bitrate: Kbps;
     mime: string;
     codecs: string;
     width: number;
     height: number;
-    url: string;
     fps?: number;
     quality?: string;
 }
-export interface Segment {
+export declare enum SegmentReferencingType {
+    BYTE_RANGE = "byteRange",
+    TEMPLATE = "template"
+}
+export declare type ByteRangeSegmentReference = {
+    type: SegmentReferencingType.BYTE_RANGE;
+    url: string;
+    initRange: IRange<Byte>;
+    indexRange?: IRange<Byte>;
+};
+export declare type TemplateSegmentReference = {
+    type: SegmentReferencingType.TEMPLATE;
+    baseUrl: string;
+    initUrl: string;
+    segments: {
+        url: string;
+        time: IRange<Milliseconds>;
+    }[];
+};
+export declare type SegmentReference = ByteRangeSegmentReference | TemplateSegmentReference;
+export interface ByteRangeSegment {
     status: SegmentStatus;
-    time: Range<Milliseconds>;
-    byte: Range<Byte>;
+    time: IRange<Milliseconds>;
+    byte: IRange<Byte>;
+}
+export interface TemplateSegment {
+    status: SegmentStatus;
+    time: IRange<Milliseconds>;
+    size: Byte | undefined;
+    url: string;
 }
+export declare type Segment = ByteRangeSegment | TemplateSegment;
 export declare enum SegmentStatus {
     NONE = "none",
     DOWNLOADING = "downloading",
@@ -41,6 +62,7 @@ export declare enum SegmentStatus {
     FED = "fed"
 }
 export interface Manifest {
+    duration: Milliseconds | undefined;
     container: Container;
     representations: {
         [key in RepresentationKind]: Representation[];
@@ -52,7 +74,7 @@ export declare enum Container {
 }
 export interface GenericContainerParser<InitData> {
     validateData(data: DataView): boolean;
-    getIndexRange(init: InitData): Range<Byte> | undefined;
+    getIndexRange(init: InitData): IRange<Byte> | undefined;
     parseInit(data: DataView): InitData;
     parseSegments(data: DataView, init: InitData): Segment[];
     parseFeedableSegmentChunk(data: DataView): DataView | null;

package/providers/HlsProvider/qualityExtractor.d.ts

@@ -1,6 +1,5 @@
-import { Kbps } from '@vkontakte/videoplayer-shared';
+import { Kbps, IRectangle } from '@vkontakte/videoplayer-shared';
 import { VideoQuality } from "../../utils/quality/types";
-import { IRectangle } from "../../utils/rectangle";
 export declare type ManifestUrl = {
     id: string;
     quality: VideoQuality;

package/providers/ProviderContainer/index.d.ts

@@ -1,7 +1,6 @@
 import { IMetadata, ISources, IVideoTrack, IVolumeState, VideoFormat } from "../../player/types";
-import { IRange } from "../../utils/range";
 import { ITuningConfig } from "../../utils/tuningConfig";
-import { IError, ISubject, IValueSubject, Subject, ValueSubject } from '@vkontakte/videoplayer-shared';
+import { IError, ISubject, IValueSubject, Subject, ValueSubject, IRange } from '@vkontakte/videoplayer-shared';
 import { IDesiredState, IProviderDependencies } from '../types';
 import { IProviderContainer, IProviderEntry } from './types';
 interface IParams extends IProviderDependencies {
@@ -31,8 +30,9 @@ export default class ProviderContainer implements IProviderContainer {
         seekedEvent$: Subject<void>;
         loopedEvent$: Subject<number>;
         endedEvent$: Subject<void>;
-        firstBytesEvent$: Subject<number>;
-        firstFrameEvent$: Subject<number>;
+        firstBytesEvent$: Subject<void>;
+        firstFrameEvent$: Subject<void>;
+        canplay$: Subject<void>;
         isLive$: ValueSubject<undefined>;
         liveTime$: ValueSubject<undefined>;
         availableTextTracks$: ValueSubject<never[]>;

package/providers/utils/observableVideo.d.ts

@@ -1,6 +1,5 @@
-import { Milliseconds, Seconds, IObservable, IError } from '@vkontakte/videoplayer-shared';
+import { Seconds, IRange, IObservable, IError } from '@vkontakte/videoplayer-shared';
 import { IVolumeState } from "../../player/types";
-import { IRange } from "../../utils/range";
 interface IObservableVideo {
     playing$: IObservable<undefined>;
     pause$: IObservable<undefined>;
@@ -11,15 +10,14 @@ interface IObservableVideo {
     seeked$: IObservable<undefined>;
     seeking$: IObservable<undefined>;
     progress$: IObservable<undefined>;
-    loadedMetadata$: IObservable<undefined>;
-    loadedData$: 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>;
-    firstBytes$: IObservable<Milliseconds>;
-    firstFrame$: IObservable<Milliseconds>;
 }
 export declare const observe: (video: HTMLVideoElement) => IObservableVideo;
 export {};

package/utils/autoSelectVideoTrack.d.ts

@@ -1,8 +1,7 @@
 import { ITuningConfig } from "./tuningConfig";
-import { Kbps, Milliseconds } from '@vkontakte/videoplayer-shared';
+import { Kbps, Milliseconds, IRectangle } from '@vkontakte/videoplayer-shared';
 import { IVideoTrack } from "../player/types";
 import { QualityLimits } from "./quality/types";
-import { IRectangle } from "./rectangle";
 export interface Constraints {
     container?: IRectangle;
     throughput?: Kbps;

package/utils/buffer/getBufferedRangeForPosition.d.ts

@@ -1,4 +1,3 @@
-import { Seconds } from '@vkontakte/videoplayer-shared';
-import { IRange } from "../range";
+import { Seconds, IRange } from '@vkontakte/videoplayer-shared';
 declare const _default: (timeRanges: TimeRanges, position: Seconds, gapTolerance?: number) => IRange<Seconds>;
 export default _default;

package/utils/buffer/isPositionBuffered.d.ts

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

package/utils/observeElementSize.d.ts

@@ -1,4 +1,3 @@
-import { IObservable, Milliseconds } from '@vkontakte/videoplayer-shared';
-import { IRectangle } from "./rectangle";
+import { IObservable, Milliseconds, IRectangle } from '@vkontakte/videoplayer-shared';
 declare const observeElementSize: (element: Element, debounceTime?: Milliseconds) => IObservable<IRectangle>;
 export default observeElementSize;

package/utils/quality/utils.d.ts

@@ -1,4 +1,4 @@
-import { IRectangle } from '../rectangle';
+import { IRectangle } from '@vkontakte/videoplayer-shared';
 import { ExactVideoQuality, VideoQuality } from './types';
 export declare const isHigher: (a: ExactVideoQuality, b: ExactVideoQuality) => boolean;
 export declare const isHigherOrEqual: (a: ExactVideoQuality, b: ExactVideoQuality) => boolean;

package/packages/sdk/src/utils/range.d.ts

@@ -1,4 +0,0 @@
-export interface IRange<Unit extends number = number> {
-    start: Unit;
-    end: Unit;
-}