@devteks/downloader/src/lib/downloader.d.ts

Simple node.js file downloader

/// <reference types="node" />
import { WriteStream } from 'fs';
import { EventEmitter } from 'events';
import * as Https from 'https';
import * as Http from 'http';
import { IncomingMessage, ClientRequest, RequestOptions } from 'http';
import { DownloadState, DownloadOptions, StatsEstimate, DownloadStats, DownloadEndedStats, DownloadInfoStats, FileRenamedStats, ErrorStats, BaseStats, RetryState, VoidCallback, ParamCallback } from './types';
declare type ResolveFn = (value: boolean) => void;
declare type RejectFn = (reason?: any) => void;
export declare class Downloader extends EventEmitter {
    _url: string;
    _requestUrl: string;
    _state: DownloadState;
    _opts: DownloadOptions;
    _pipes: {
        stream: any;
        options: any;
    }[];
    _total: number | null;
    _downloaded: number;
    _progress: number;
    _retryCount: number;
    _resolve?: ResolveFn;
    _reject?: RejectFn;
    _request: ClientRequest | null;
    _response: IncomingMessage | null;
    _isResumed: boolean;
    _isResumable: boolean;
    _isRedirected: boolean;
    _destination: string;
    _fileName: string;
    _filePath: string;
    _statsEstimate: StatsEstimate;
    _fileStream: WriteStream;
    _headers: any;
    _options: RequestOptions;
    _protocol: typeof Https | typeof Http;
    /**
     * Creates an instance of Downloader.
     * @param {String} url
     * @param {String} destFolder
     * @param {Object} [options={}]
     * @memberof Downloader
     */
    constructor(url: string, destination: string, options?: DownloadOptions);
    /**
     * request url
     *
     * @returns {String}
     * @memberof Downloader
     */
    get requestUrl(): string;
    /**
     * Where the download will be saved
     *
     * @returns {String}
     * @memberof Downloader
     */
    get downloadPath(): string;
    /**
    * Indicates if the download can be resumable (available after the start phase)
    *
    * @returns {Boolean}
    * @memberof Downloader
    */
    get isResumable(): boolean;
    /**
    * Return the current download state
    *
    * @returns {DownloadState}
    * @memberof Downloader
    */
    get state(): DownloadState;
    /**
    * Current download progress stats
    *
    * @returns {DownloadStats}
    * @memberof Downloader
    */
    get stats(): DownloadStats;
    /** Emitted when the .start method is called */
    on(event: 'start', listener: VoidCallback): this;
    /** Emitted when the .stop method is called */
    on(event: 'stop', listener: VoidCallback): this;
    /** Emitted when the .pause method is called */
    on(event: 'pause', listener: VoidCallback): this;
    /**	Emitted when the underlying socket times out from inactivity. */
    on(event: 'timeout', listener: VoidCallback): this;
    /** Emitted when the .resume method is called */
    on(event: 'resume', listener: ParamCallback<boolean>): this;
    /** Emitted when there is any error */
    on(event: 'error', listener: ParamCallback<ErrorStats>): this;
    /** Emitted when the downloading has finished */
    on(event: 'end', listener: ParamCallback<DownloadEndedStats>): this;
    /** Emitted when the download is skipped because the file already exists */
    on(event: 'skip', listener: ParamCallback<BaseStats>): this;
    /** Emitted when the download starts */
    on(event: 'download', listener: ParamCallback<DownloadInfoStats>): this;
    /** Emitted when '(number)' is appended to the end of file, this requires override:false opt, callback(filePaths) */
    on(event: 'renamed', listener: ParamCallback<FileRenamedStats>): this;
    /** Emitted when the state changes */
    on(event: 'stateChanged', listener: ParamCallback<DownloadState>): this;
    /**	Emitted every time gets data from the server */
    on(event: 'progress', listener: ParamCallback<DownloadStats>): this;
    /** The same as progress but emits every 1 second while is downloading */
    on(event: 'progressThrottled', listener: ParamCallback<DownloadStats>): this;
    /** Emitted when the download fails and retry is enabled */
    on(event: 'retry', listener: ParamCallback<RetryState>): this;
    /**
     * @returns {Promise<boolean>}
     * @memberof Downloader
     */
    start(): Promise<boolean>;
    /**
     * @returns {Promise<boolean>}
     * @memberof Downloader
     */
    pause(): Promise<boolean>;
    /**
     * @returns {void}
     * @memberof Downloader
     */
    resume(): void;
    /**
     * @returns {Promise<boolean>}
     * @memberof Downloader
     */
    stop(): Promise<boolean>;
    /**
     * Add pipes to the pipe list that will be applied later when the download starts
     * @url https://nodejs.org/api/stream.html#stream_readable_pipe_destination_options
     * @param {stream.Readable} stream https://nodejs.org/api/stream.html#stream_class_stream_readable
     * @param {Object} [options=null]
     * @returns {stream.Readable}
     * @memberof Downloader
     */
    pipe(stream: any, options?: any): any;
    /**
     * Unpipe a stream
     *
     * @param {Stream} [stream=null]
     * @returns
     * @memberof Downloader
     */
    unpipe(stream: WriteStream): this;
    /**
     * Unpipe all streams
     *
     * @returns void
     * @memberof Downloader
     */
    unpipeAll(): this;
    /**
     * Updates the options, can be use on pause/resume events
     *
     * @param {Object} [options={}]
     * @memberof Downloader
     */
    updateOptions(options?: DownloadOptions): void;
    /**
     * Gets the total file size from the server
     *
     * @returns {Promise<{name:string, total:number|null}>}
     * @memberof Downloader
     */
    getTotalSize(): Promise<{
        name: string;
        total: number;
    }>;
    private _start;
    private _downloadRequest;
    private _startDownload;
    private _onFinished;
    private _onError;
    private _retry;
    private _onTimeout;
    private _resetStats;
    private _getFilePath;
    private _getFileNameFromHeaders;
    private _calculateStats;
    private _setState;
    private _getFilesizeInBytes;
    private _initProtocol;
    private _removeFile;
    private _abort;
}
export {};