p2p-media-loader-core/lib/requests/request.d.ts

P2P Media Loader core functionality

import { BandwidthCalculators, Playback } from "../internal-types.js";
import { CoreEventMap, RequestError, RequestAbortErrorType, SegmentWithStream } from "../types.js";
import * as StreamUtils from "../utils/stream.js";
import { EventTarget } from "../utils/event-target.js";
export type LoadProgress = {
    startTimestamp: number;
    lastLoadedChunkTimestamp?: number;
    startFromByte?: number;
    loadedBytes: number;
};
type HttpRequestAttempt = {
    downloadSource: "http";
    error?: RequestError;
};
type P2PRequestAttempt = {
    downloadSource: "p2p";
    peerId: string;
    error?: RequestError;
};
export type RequestAttempt = HttpRequestAttempt | P2PRequestAttempt;
export type RequestControls = Readonly<{
    firstBytesReceived: Request["firstBytesReceived"];
    addLoadedChunk: Request["addLoadedChunk"];
    completeOnSuccess: Request["completeOnSuccess"];
    abortOnError: Request["abortOnError"];
}>;
type OmitEncapsulated<T extends RequestAttempt> = Omit<T, "error" | "errorTimestamp">;
type StartRequestParameters = OmitEncapsulated<HttpRequestAttempt> | OmitEncapsulated<P2PRequestAttempt>;
export type RequestStatus = "not-started" | "loading" | "succeed" | "failed" | "aborted";
export declare class Request {
    readonly segment: SegmentWithStream;
    private readonly requestProcessQueueCallback;
    private readonly bandwidthCalculators;
    private readonly playback;
    private readonly playbackConfig;
    private currentAttempt?;
    private _failedAttempts;
    private finalData?;
    private bytes;
    private _loadedBytes;
    private _totalBytes?;
    private _status;
    private progress?;
    private notReceivingBytesTimeout;
    private _abortRequestCallback?;
    private readonly _logger;
    private _isHandledByProcessQueue;
    private readonly onSegmentError;
    private readonly onSegmentAbort;
    private readonly onSegmentStart;
    private readonly onSegmentLoaded;
    constructor(segment: SegmentWithStream, requestProcessQueueCallback: () => void, bandwidthCalculators: BandwidthCalculators, playback: Playback, playbackConfig: StreamUtils.PlaybackTimeWindowsConfig, eventTarget: EventTarget<CoreEventMap>);
    clearLoadedBytes(): void;
    get status(): RequestStatus;
    private setStatus;
    get downloadSource(): "http" | "p2p" | undefined;
    get loadedBytes(): number;
    get totalBytes(): number | undefined;
    get data(): ArrayBuffer;
    get failedAttempts(): FailedRequestAttempts;
    get isHandledByProcessQueue(): boolean;
    markHandledByProcessQueue(): void;
    setTotalBytes(value: number): void;
    start(requestData: StartRequestParameters, controls: {
        notReceivingBytesTimeoutMs?: number;
        abort: (errorType: RequestError<RequestAbortErrorType>) => void;
    }): RequestControls;
    abortFromProcessQueue(): void;
    private abortOnTimeout;
    private abortOnError;
    private completeOnSuccess;
    private addLoadedChunk;
    private firstBytesReceived;
    private throwErrorIfNotLoadingStatus;
    private logger;
    private manageBandwidthCalculatorsState;
}
declare class FailedRequestAttempts {
    private attempts;
    add(attempt: Required<RequestAttempt>): void;
    get httpAttemptsCount(): number;
    get lastAttempt(): Readonly<Required<RequestAttempt>> | undefined;
    clear(): void;
}
export declare class Timeout {
    private readonly action;
    private timeoutId?;
    private ms?;
    constructor(action: () => void);
    start(ms: number): void;
    restart(ms?: number): void;
    clear(): void;
}
export {};