npaw-plugin-nwf/dist/src/balancer/CdnBalancer.d.ts

NPAW's Plugin

import Interceptors from './Interceptors/Interceptors';
import BalancerOptions from './Utils/Options';
import Loader from './Loaders/Loader';
import Emitter from './Utils/Emitter';
import { VideoSegment } from './Storage/VideoSegment';
import NpawPluginOptions from '../core/NpawPluginOptions';
import BalancerAnalytics from './video/BalancerAnalytics';
import PeakBandwidthSampler from './Utils/PeakBandwidthSampler';
import { FirstChunkProbeRegistry } from './Utils/FirstChunkProbe';
declare global {
    interface XMLHttpRequest {
        isAsync: boolean;
        __balancerConnectTimer?: ReturnType<typeof setTimeout>;
        __balancerTotalTimer?: ReturnType<typeof setTimeout>;
    }
}
/**
 * @class
 * @description Core class for the p2p plugin. It includes the options, the websocket communication,
 * @exports CdnBalancer
 */
export default class CdnBalancer extends Emitter {
    interceptors: Interceptors;
    options: BalancerOptions;
    /**
     * Central peak-bandwidth sampler (PR5). One per balancer instance; tags are
     * registered at xhr.send and unregistered at loadend / abort. Public so
     * Loader.progressEM can update read counters without an extra hop.
     */
    peakBandwidthSampler: PeakBandwidthSampler;
    /**
     * First-chunk probe registry (PR6). Holds FirstChunkProbeTag per in-flight
     * probe; consumed by the sampler's evaluateFirstChunkAborts on every tick.
     */
    firstChunkProbeRegistry: FirstChunkProbeRegistry;
    private loader;
    private videoLogic?;
    private readonly _accountCode;
    private isEnabled;
    private defaultChunkDownloadTimeout;
    private isBitmovin;
    private isTheoplayer;
    private responseHeader;
    private allResponseHeader;
    private abort;
    private overrideMimeType;
    private requestHeader;
    private send;
    private open;
    private lastDecisionTimestamp;
    private apiHost;
    /**
     * Constructs CdnBalancer.
     * @param {string} accountCode NPAW Suite account code
     * @param npawPluginOptions Plugin-wide options
     */
    constructor(accountCode: string, npawPluginOptions?: NpawPluginOptions, videoLogic?: BalancerAnalytics);
    /**
     * @internal
     */
    destroy(): void;
    /**
     * @internal
     */
    getAccountCode(): string;
    /**
     * @internal
     * @param options
     */
    setOptions(options: BalancerOptions): void;
    private openAndSend;
    /**
     * Redirects adapter's requests to loader.
     * If loader is not yet ready it retries again after 200ms.
     *
     * @internal
     * @param {URL} url URL object for the request.
     * @param download
     * @param {callback} callbacks Callback method to call back when loaded.
     * @param {Object} headers Optional headers of the request.
     * @param {number} retries Number of retries before giving up to load a segment if it fails, optional.
     * @param {boolean} forceArrayBuffer set as true if is expected to get the manifest response in ArrayBuffer format.
     * @param stats
     * @public
     */
    request(url: URL, download: true, callbacks: callback[], headers: {
        [key: string]: string;
    }, retries?: number, forceArrayBuffer?: boolean, stats?: fragStats): void;
    /**
     * Sets the manifest URL of the played content to the options object.
     * For url changes the loader is restarted.
     *
     * @internal
     * @param {string} url Manifest url of the content being played.
     * @public
     */
    setManifestResource(url: string): void;
    /**
     * @internal
     */
    getLoader(): Loader;
    getManifestResolutionStats(): {
        parseCount: number;
        resolveCount: number;
        resolveHits: number;
        resolveMisses: number;
        lookaheadHits: number;
        lastHitFastHits: number;
        lastHitForceHits: number;
        multiPassHits: number;
        subManifestAttachments: number;
        manifestCount: number;
        lookaheadSize: number;
        modelHits: number;
        fallbackCount: number;
    };
    setVideoLogic(videoLogic?: BalancerAnalytics): void;
    /**
     * @internal
     * @param name
     * @param player
     */
    addInterceptor(name: string, player: any): void;
    /**
     * @internal
     */
    getRecommendedManifest(): Promise<string>;
    /**
     * @internal
     */
    useTheoplayer(): void;
    /**
     * @internal
     */
    getBitmovinSendHttpRequest(): (type: any, request: any) => {
        getResponse(): any;
        cancel(): void;
        setProgressListener(): void;
    } | null;
    /**
     * Restarts P2P connection in case the client needs to play another video
     *
     * @internal
     */
    resetP2PConnection(): void;
    /**
     * @internal
     * @param urlString
     * @param params
     * @param headers
     */
    simpleRequest(urlString: string, params: any, headers: {
        [key: string]: string;
    }): VideoSegment;
    enable(): void;
    disable(): void;
    getIsEnabled(): boolean;
    isCdnBalancerSupported(): boolean;
    /**
     * @internal
     * @param constructionOptions
     */
    reload(constructionOptions?: constructionOptions): void;
}