• Version 19.27.5
  • Published
  • 3 dependencies
  • MIT license


npm i electron-builder-http
yarn add electron-builder-http
pnpm add electron-builder-http


Part of [electron-builder](https://github.com/electron-userland/electron-builder).



function configureRequestOptions

configureRequestOptions: (
options: RequestOptions,
token?: string | null,
method?: 'GET' | 'DELETE' | 'PUT'
) => RequestOptions;

    function configureRequestOptionsFromUrl

    configureRequestOptionsFromUrl: (
    url: string,
    options: RequestOptions
    ) => RequestOptions;

      function dumpRequestOptions

      dumpRequestOptions: (options: RequestOptions) => string;

        function parseJson

        parseJson: (result: Promise<string | null>) => Promise<any>;

          function safeGetHeader

          safeGetHeader: (response: any, headerKey: string) => any;


            class CancellationError

            class CancellationError extends Error {}



                class CancellationToken

                class CancellationToken extends EventEmitter {}


                  constructor(parent?: CancellationToken);

                    property cancelled

                    readonly cancelled: boolean;

                      property parent

                      parent: CancellationToken;

                        method cancel

                        cancel: () => void;

                          method createPromise

                          createPromise: <R>(
                          callback: (
                          resolve: (thenableOrResult?: R) => void,
                          reject: (error?: Error) => void,
                          onCancel: (callback: () => void) => void
                          ) => void
                          ) => Promise<R>;

                            method dispose

                            dispose: () => void;

                              class DigestTransform

                              class DigestTransform extends Transform {}


                                expected: string,
                                algorithm: string,
                                encoding: 'hex' | 'base64' | 'latin1'

                                  class HttpError

                                  class HttpError extends Error {}


                                    response: {
                                    statusMessage?: string | undefined;
                                    statusCode?: number | undefined;
                                    headers?: { [key: string]: string[] };
                                    description?: any

                                      property description

                                      description: any;

                                        property response

                                        readonly response: {
                                        statusMessage?: string | undefined;
                                        statusCode?: number | undefined;
                                        headers?: { [key: string]: string[] };

                                          class HttpExecutor

                                          abstract class HttpExecutor<REQUEST> {}

                                            property maxRedirects

                                            protected readonly maxRedirects: number;

                                              method addTimeOutHandler

                                              protected addTimeOutHandler: (
                                              request: any,
                                              callback: (error: Error) => void
                                              ) => void;

                                                method doApiRequest

                                                protected abstract doApiRequest: (
                                                options: RequestOptions,
                                                cancellationToken: CancellationToken,
                                                requestProcessor: (request: REQUEST, reject: (error: Error) => void) => void,
                                                redirectCount: number
                                                ) => Promise<string>;

                                                  method doDownload

                                                  protected doDownload: (
                                                  requestOptions: any,
                                                  destination: string,
                                                  redirectCount: number,
                                                  options: DownloadOptions,
                                                  callback: (error: Error | null) => void,
                                                  onCancel: (callback: () => void) => void
                                                  ) => void;

                                                    method doRequest

                                                    protected abstract doRequest: (
                                                    options: any,
                                                    callback: (response: any) => void
                                                    ) => any;

                                                      method handleResponse

                                                      protected handleResponse: (
                                                      response: Response,
                                                      options: RequestOptionsEx,
                                                      cancellationToken: CancellationToken,
                                                      resolve: (data?: any) => void,
                                                      reject: (error: Error) => void,
                                                      redirectCount: number,
                                                      requestProcessor: (request: REQUEST, reject: (error: Error) => void) => void
                                                      ) => void;

                                                        method request

                                                        request: (
                                                        options: RequestOptions,
                                                        cancellationToken?: CancellationToken,
                                                        data?: { [name: string]: any }
                                                        ) => Promise<string | null>;

                                                          class ProgressCallbackTransform

                                                          class ProgressCallbackTransform extends Transform {}


                                                            total: number,
                                                            cancellationToken: CancellationToken,
                                                            onProgress: (info: ProgressInfo) => any


                                                              interface DownloadOptions

                                                              interface DownloadOptions {}

                                                                property cancellationToken

                                                                readonly cancellationToken: CancellationToken;

                                                                  property headers

                                                                  readonly headers?: OutgoingHttpHeaders | null;

                                                                    property sha2

                                                                    readonly sha2?: string | null;

                                                                      property sha512

                                                                      readonly sha512?: string | null;

                                                                        property skipDirCreation

                                                                        readonly skipDirCreation?: boolean;

                                                                          method onProgress

                                                                          onProgress: (progress: ProgressInfo) => void;

                                                                            interface ProgressInfo

                                                                            interface ProgressInfo {}

                                                                              property bytesPerSecond

                                                                              bytesPerSecond: number;

                                                                                property delta

                                                                                delta: number;

                                                                                  property percent

                                                                                  percent: number;

                                                                                    property total

                                                                                    total: number;

                                                                                      property transferred

                                                                                      transferred: number;

                                                                                        interface RequestHeaders

                                                                                        interface RequestHeaders extends OutgoingHttpHeaders {}

                                                                                          index signature

                                                                                          [key: string]: string;

                                                                                            interface RequestOptionsEx

                                                                                            interface RequestOptionsEx extends RequestOptions {}

                                                                                              interface Response

                                                                                              interface Response extends EventEmitter {}

                                                                                                property headers

                                                                                                headers: any;

                                                                                                  property statusCode

                                                                                                  statusCode?: number;

                                                                                                    property statusMessage

                                                                                                    statusMessage?: string;

                                                                                                      method setEncoding

                                                                                                      setEncoding: (encoding: string) => void;

                                                                                                        Package Files (3)

                                                                                                        Dependencies (3)

                                                                                                        Dev Dependencies (0)

                                                                                                        No dev dependencies.

                                                                                                        Peer Dependencies (0)

                                                                                                        No peer dependencies.


                                                                                                        To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                        You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/electron-builder-http.

                                                                                                        • Markdown
                                                                                                        • HTML
                                                                                                          <a href="https://www.jsdocs.io/package/electron-builder-http"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>