@vkontakte/videoplayer-core 2.0.155 → 2.0.156-dev.04ce2cd1.0

package/types/providers/ChromecastProvider/index.d.ts

@@ -1,25 +1,25 @@
-import { IProvider } from '../types';
-import { IParams } from './types';
+import type { IProvider } from "../types";
+import type { IParams } from "./types";
 export default class ChromecastProvider implements IProvider {
-    private subscription;
-    private loadMediaTimeoutSubscription;
-    private videoState;
-    private params;
-    private log;
-    constructor(params: IParams);
-    destroy(): void;
-    private subscribe;
-    private restoreSession;
-    private prepare;
-    private handleRemotePause;
-    private handleRemotePlay;
-    private handleRemoteReady;
-    private handleRemoteStop;
-    private handleRemoteVolumeChange;
-    private seek;
-    private stop;
-    private createLoadRequest;
-    private loadMedia;
-    private logRemoteEvent;
-    private syncPlayback;
+	private subscription;
+	private loadMediaTimeoutSubscription;
+	private videoState;
+	private params;
+	private log;
+	constructor(params: IParams);
+	destroy(): void;
+	private subscribe;
+	private restoreSession;
+	private prepare;
+	private handleRemotePause;
+	private handleRemotePlay;
+	private handleRemoteReady;
+	private handleRemoteStop;
+	private handleRemoteVolumeChange;
+	private seek;
+	private stop;
+	private createLoadRequest;
+	private loadMedia;
+	private logRemoteEvent;
+	private syncPlayback;
 }

package/types/providers/ChromecastProvider/types.d.ts

@@ -1,8 +1,8 @@
-import { IMetadata, ISources, VideoFormat } from '../../player/types';
-import { IProviderParams } from '../types';
-import { IChromecastConnection } from './ChromecastInitializer/types';
-export interface IParams extends IProviderParams<ISources> {
-    meta: IMetadata;
-    format: VideoFormat;
-    connection: IChromecastConnection;
+import type { IMetadata, ISources, VideoFormat } from "../../player/types";
+import type { IProviderParams } from "../types";
+import type { IChromecastConnection } from "./ChromecastInitializer/types";
+export interface IParams extends Omit<IProviderParams<ISources>, "skipVideoElVolumeSync$"> {
+	meta: IMetadata;
+	format: VideoFormat;
+	connection: IChromecastConnection;
 }

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

@@ -1,2 +1,2 @@
-import { IParams } from './types';
+import type { IParams } from "./types";
 export declare const createMediaInfo: (params: Pick<IParams, "meta" | "format" | "output" | "source">) => chrome.cast.media.MediaInfo;

package/types/providers/DashLiveProvider/DashLiveProvider.d.ts

@@ -1,37 +1,37 @@
-import { IDashURLSource } from '../../player/types';
-import { IProvider, IProviderParams } from '../../providers/types';
-import { Milliseconds } from '@vkontakte/videoplayer-shared';
+import type { IDashURLSource } from "../../player/types";
+import type { IProvider, IProviderParams } from "../types";
+import type { Milliseconds } from "@vkontakte/videoplayer-shared";
 type Params = IProviderParams<IDashURLSource> & {
-    config: {
-        maxPausedTime: Milliseconds;
-        chunkDuration: number;
-        maxParallelRequests: number;
-    };
+	config: {
+		maxPausedTime: Milliseconds;
+		chunkDuration: number;
+		maxParallelRequests: number;
+	};
 };
 export default class DashLiveProvider implements IProvider {
-    private subscription;
-    private video;
-    private videoState;
-    private dash;
-    private representations$;
-    private textTracksManager;
-    private droppedFramesManager;
-    /**
-     *  Максимальное время перемотки назад из лайва в миллисекундах
-     */
-    private maxSeekBackTime$;
-    private zeroTime$;
-    private liveOffset;
-    private log;
-    private params;
-    constructor(params: Params);
-    destroy(): void;
-    private createLiveDashPlayer;
-    private prepare;
-    private setVideoTrack;
-    private setAutoQuality;
-    private seek;
-    private _dashCb;
-    private syncPlayback;
+	private subscription;
+	private volumeSubscription;
+	private video;
+	private videoState;
+	private dash;
+	private representations$;
+	private textTracksManager;
+	private droppedFramesManager;
+	/**
+	*  Максимальное время перемотки назад из лайва в миллисекундах
+	*/
+	private maxSeekBackTime$;
+	private zeroTime$;
+	private liveOffset;
+	private log;
+	private params;
+	constructor(params: Params);
+	destroy(): void;
+	private createLiveDashPlayer;
+	private prepare;
+	private setVideoTrack;
+	private setAutoQuality;
+	private seek;
+	private _dashCb;
+	private syncPlayback;
 }
-export {};

package/types/providers/DashLiveProvider/index.d.ts

@@ -1,2 +1,2 @@
-import DashLiveProvider from './DashLiveProvider';
+import DashLiveProvider from "./DashLiveProvider";
 export default DashLiveProvider;

package/types/providers/DashLiveProvider/types.d.ts

@@ -1,21 +1,21 @@
-import { bps } from '@vkontakte/videoplayer-shared';
+import type { bps } from "@vkontakte/videoplayer-shared";
 export interface IRepresentation {
-    bitrate: bps;
-    codecs: string;
-    fragUrlTemplate: string;
-    headerUrl: string;
-    index: number;
-    jidxUrl: string;
-    name: string;
-    video: {
-        height: number;
-        width: number;
-    };
+	bitrate: bps;
+	codecs: string;
+	fragUrlTemplate: string;
+	headerUrl: string;
+	index: number;
+	jidxUrl: string;
+	name: string;
+	video: {
+		height: number;
+		width: number;
+	};
 }
 export declare enum State {
-    STOPPED = "stopped",
-    MANIFEST_READY = "manifest_ready",
-    READY = "ready",
-    PLAYING = "playing",
-    PAUSED = "paused"
+	STOPPED = "stopped",
+	MANIFEST_READY = "manifest_ready",
+	READY = "ready",
+	PLAYING = "playing",
+	PAUSED = "paused"
 }

package/types/providers/DashLiveProvider/utils/FilesFetcher.d.ts

@@ -1,25 +1,25 @@
 export default class FilesFetcher {
-    private pendingQueue;
-    private activeRequests;
-    private completeRequests;
-    private averageSegmentDuration;
-    private lastPrefetchStart;
-    private throttleTimeout;
-    private RETRY_COUNT;
-    private TIMEOUT;
-    private BITRATE_ESTIMATOR;
-    private MAX_PARALLEL_REQUESTS;
-    private logger;
-    constructor(RETRY_COUNT: number, TIMEOUT: number, BITRATE_ESTIMATOR: any, MAX_PARALLEL_REQUESTS: number, logger: (...args: any[]) => void);
-    private limitCompleteCount;
-    private _sendRequest;
-    private _getParallelRequestCount;
-    private _getPrefetchDelay;
-    private _canSendPending;
-    private _sendPending;
-    private _removeFromActive;
-    abortAll(): void;
-    requestData(url: string, cb: (data: any, downloadTime: number) => void, errorCB: (arg: any) => void, retryCB: (arg: any) => void): Record<string, any>;
-    prefetch(url: string): void;
-    optimizeForSegDuration(duration: number): void;
+	private pendingQueue;
+	private activeRequests;
+	private completeRequests;
+	private averageSegmentDuration;
+	private lastPrefetchStart;
+	private throttleTimeout;
+	private RETRY_COUNT;
+	private TIMEOUT;
+	private BITRATE_ESTIMATOR;
+	private MAX_PARALLEL_REQUESTS;
+	private logger;
+	constructor(RETRY_COUNT: number, TIMEOUT: number, BITRATE_ESTIMATOR: any, MAX_PARALLEL_REQUESTS: number, logger: (...args: any[]) => void);
+	private limitCompleteCount;
+	private _sendRequest;
+	private _getParallelRequestCount;
+	private _getPrefetchDelay;
+	private _canSendPending;
+	private _sendPending;
+	private _removeFromActive;
+	abortAll(): void;
+	requestData(url: string, cb: (data: any, downloadTime: number) => void, errorCB: (arg: any) => void, retryCB: (arg: any) => void): Record<string, any>;
+	prefetch(url: string): void;
+	optimizeForSegDuration(duration: number): void;
 }

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

@@ -1,156 +1,155 @@
-import { ILiveOffset } from '../../../providers/utils/LiveOffset/types';
-import { IStateMachine } from '../../../utils/StateMachine/types';
-import { Milliseconds } from '@vkontakte/videoplayer-shared';
-import { IRepresentation, State } from '../types';
-import { Subject } from '@vkontakte/videoplayer-shared';
-import { PlaybackState } from '../../../player/types';
+import { ILiveOffset } from "../../utils/LiveOffset/types";
+import { IStateMachine } from "../../../utils/StateMachine/types";
+import { Milliseconds } from "@vkontakte/videoplayer-shared";
+import { IRepresentation, State } from "../types";
+import { Subject } from "@vkontakte/videoplayer-shared";
+import { PlaybackState } from "../../../player/types";
 interface IParams {
-    videoElement: HTMLVideoElement;
-    videoState: IStateMachine<State>;
-    playbackState: IStateMachine<PlaybackState>;
-    liveOffset: ILiveOffset;
-    playerCallback: (...args: any) => void;
-    config: {
-        minBuffer: Milliseconds;
-        lowLatencyMinBuffer: Milliseconds;
-        minBufferSegments: number;
-        lowLatencyMinBufferSegments: number;
-        maxParallelRequests: number;
-        isLiveCatchUpMode: boolean;
-        manifestRetryInterval: number;
-        manifestRetryMaxInterval: number;
-        manifestRetryMaxCount: number;
-        useInvalidBufferFix: boolean;
-    };
-    logger: (...args: any[]) => void;
+	videoElement: HTMLVideoElement;
+	videoState: IStateMachine<State>;
+	playbackState: IStateMachine<PlaybackState>;
+	liveOffset: ILiveOffset;
+	playerCallback: (...args: any) => void;
+	config: {
+		minBuffer: Milliseconds;
+		lowLatencyMinBuffer: Milliseconds;
+		minBufferSegments: number;
+		lowLatencyMinBufferSegments: number;
+		maxParallelRequests: number;
+		isLiveCatchUpMode: boolean;
+		manifestRetryInterval: number;
+		manifestRetryMaxInterval: number;
+		manifestRetryMaxCount: number;
+		useInvalidBufferFix: boolean;
+	};
+	logger: (...args: any[]) => void;
 }
 type AutoQualityLimits = {
-    max?: number;
-    min?: number;
+	max?: number;
+	min?: number;
 };
 export default class LiveDashPlayer {
-    private paused;
-    private autoQuality;
-    private autoQualityLimits;
-    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 waitingForFirstBufferAfterSrcChange;
-    private params;
-    soundProhibitedEvent$: Subject<void>;
-    constructor(params: IParams);
-    attachSource(manifestUrl: string): void;
-    /**
-     * switch to auto quality
-     */
-    setAutoQualityEnabled(enabled: boolean): void;
-    setAutoQualityLimits(limits: AutoQualityLimits | undefined): void;
-    /**
-     * switch quality by name
-     */
-    switchByName(name: string): void;
-    /**
-     * seek to actual video position
-     */
-    catchUp(): void;
-    stop(): void;
-    pause(): void;
-    play(): 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;
+	private paused;
+	private autoQuality;
+	private autoQualityLimits;
+	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 waitingForFirstBufferAfterSrcChange;
+	private params;
+	soundProhibitedEvent$: Subject<void>;
+	constructor(params: IParams);
+	attachSource(manifestUrl: string): void;
+	/**
+	* switch to auto quality
+	*/
+	setAutoQualityEnabled(enabled: boolean): void;
+	setAutoQualityLimits(limits: AutoQualityLimits | undefined): void;
+	/**
+	* switch quality by name
+	*/
+	switchByName(name: string): void;
+	/**
+	* seek to actual video position
+	*/
+	catchUp(): void;
+	stop(): void;
+	pause(): void;
+	play(): 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/types/providers/DashLiveProvider/utils/ThroughputEstimator.d.ts

@@ -1,33 +1,15 @@
-/**
- * Estimate total throughput by counting bytes received over time interval
- * The estimator receives reports of downloaded chunk sizes and time ranges
- * and calculates total bandwidth accounting for chunks downloaded in parallel
- * and network idle time
- *
- * For example:
- * chunk1:     [___1000___]
- * chunk2:          [_____900_____]
- * chunk3:                                     [___700___]
- * time:      0.2   0.3   0.4    0.5          1.0       1.1
- *           --------------------------------------------------->
- *
- * total size = 1000 + 900 + 700 = 2600
- * active time = (1.1 - 1.0) + (0.5 - 0.2) = 0.4
- * throughput = total size / active time = 6500 bytes/sec
- */
 type ILogger = (...args: any[]) => void;
 export default class ThroughputEstimator {
-    private intervals;
-    private currentRate;
-    private logger;
-    constructor(logger: ILogger);
-    private _updateRate;
-    private _createInterval;
-    private _doMergeIntervals;
-    private _mergeIntervals;
-    private _flushIntervals;
-    private _joinIntervals;
-    addInterval(timeStart: number, timeEnd: number, bytes: number): boolean;
-    getBitRate(): number;
+	private intervals;
+	private currentRate;
+	private logger;
+	constructor(logger: ILogger);
+	private _updateRate;
+	private _createInterval;
+	private _doMergeIntervals;
+	private _mergeIntervals;
+	private _flushIntervals;
+	private _joinIntervals;
+	addInterval(timeStart: number, timeEnd: number, bytes: number): boolean;
+	getBitRate(): number;
 }
-export {};

package/types/providers/DashLiveProvider/utils/liveDashPlayerUtil.d.ts

@@ -1,42 +1,39 @@
 export declare function getTimeMilliseconds(): number;
 export declare function elapsedSince(ts: number): number;
 /**
- * url resolver function
- * constructs full path if URL is relative to manifest
- * optionally adds random url parameter to bypass browser cache
- */
+* url resolver function
+* constructs full path if URL is relative to manifest
+* optionally adds random url parameter to bypass browser cache
+*/
 export declare function urlResolver(homeUrl: string): {
-    resolve: (url: string, nocache: boolean, lowLatency?: boolean) => string;
+	resolve: (url: string, nocache: boolean, lowLatency?: boolean) => string;
 };
 /**
- * event listener helper - listen just once, then remove listener
- */
+* event listener helper - listen just once, then remove listener
+*/
 export declare function listenOnce(element: HTMLElement, eventName: string, listener: (...args: any[]) => void): void;
 interface IRequestDataResult {
-    withBitrateReporting: IWithBitrateReporting;
-    withParallel: IWithParallel;
-    withJSONResponse: IWithJSONResponse;
-    withRetryCount: IWithRetryCount;
-    withRetryInterval: IWithRetryInterval;
-    withTimeout: IWithTimeout;
-    withFinally: IWithFinally;
-    send: ISend;
-    abort: () => void;
+	withBitrateReporting: IWithBitrateReporting;
+	withParallel: IWithParallel;
+	withJSONResponse: IWithJSONResponse;
+	withRetryCount: IWithRetryCount;
+	withRetryInterval: IWithRetryInterval;
+	withTimeout: IWithTimeout;
+	withFinally: IWithFinally;
+	send: ISend;
+	abort: () => void;
 }
 type IWithBitrateReporting = IBuilderMethod<[listener: any]>;
 type IWithParallel = IBuilderMethod<[parallel: any]>;
 type IWithJSONResponse = IBuilderMethod<[]>;
 type IWithRetryCount = IBuilderMethod<[count: number]>;
-type IWithRetryInterval = IBuilderMethod<[
-    interval: number | undefined,
-    maxInterval: number | undefined
-]>;
+type IWithRetryInterval = IBuilderMethod<[interval: number | undefined, maxInterval: number | undefined]>;
 type IWithTimeout = IBuilderMethod<[timeoutMs: number]>;
 type IWithFinally = IBuilderMethod<[final: () => void]>;
 type ISend = IBuilderMethod<[]>;
 type IBuilderMethod<TParams extends any[]> = (...params: TParams) => IRequestDataResult;
 /**
- * fetch data helper with retry and timeout handler
- */
+* fetch data helper with retry and timeout handler
+*/
 export declare function requestData(url: string, cb: (response: any) => void, errorCB: () => void, retryCB: () => void): IRequestDataResult;
 export {};