builder-util-runtime

builder-util-runtime

Version 9.5.1
Published 3 months ago
174 kB
2 dependencies
MIT license

Install

npm i builder-util-runtime

yarn add builder-util-runtime

pnpm add builder-util-runtime

Overview

HTTP utilities. Used by [electron-builder](https://github.com/electron-userland/electron-builder).

Index

Variables

variable CURRENT_APP_INSTALLER_FILE_NAME

const CURRENT_APP_INSTALLER_FILE_NAME: string;

variable CURRENT_APP_PACKAGE_FILE_NAME

const CURRENT_APP_PACKAGE_FILE_NAME: string;

Functions

function asArray

asArray: <T>(v: Nullish | T | Array<T>) => Array<T>;

function configureRequestOptions

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

function configureRequestOptionsFromUrl

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

function configureRequestUrl

configureRequestUrl: (url: URL, options: RequestOptions) => void;

function createHttpError

createHttpError: (
    response: IncomingMessage,
    description?: any | null
) => HttpError;

function getS3LikeProviderBaseUrl

getS3LikeProviderBaseUrl: (configuration: PublishConfiguration) => string;

function githubTagPrefix

githubTagPrefix: (options: GithubOptions) => string;

function githubUrl

githubUrl: (options: GithubOptions, defaultHost?: string) => string;

function newError

newError: (message: string, code: string) => Error;

function parseDn

parseDn: (seq: string) => Map<string, string>;

function parseJson

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

function parseXml

parseXml: (data: string) => XElement;

function retry

retry: <T>(
    task: () => Promise<T>,
    options: {
        retries: number;
        interval: number;
        backoff?: number;
        attempt?: number;
        cancellationToken?: CancellationToken;
        shouldRetry?: (e: any) => boolean | Promise<boolean>;
    }
) => Promise<T>;

function safeGetHeader

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

function safeStringifyJson

safeStringifyJson: (data: any, skippedNames?: Set<string>) => string;

Classes

class CancellationError

class CancellationError extends Error {}

constructor

constructor();

class CancellationToken

class CancellationToken extends EventEmitter {}

constructor

constructor(parent?: CancellationToken);

property cancelled

readonly cancelled: boolean;

method cancel

cancel: () => void;

method createPromise

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

method dispose

dispose: () => void;

class DigestTransform

class DigestTransform extends Transform {}

constructor

constructor(
    expected: string,
    algorithm?: string,
    encoding?: BinaryToTextEncoding
);

property actual

readonly actual: string;

property expected

readonly expected: string;

property isValidateOnEnd

isValidateOnEnd: boolean;

method validate

validate: () => null;

class HttpError

class HttpError extends Error {}

constructor

constructor(statusCode: number, message?: string, description?: any);

property description

readonly description: any;

property statusCode

readonly statusCode: number;

method isServerError

isServerError: () => boolean;

class HttpExecutor

abstract class HttpExecutor<T extends Request> {}

property maxRedirects

protected readonly maxRedirects: number;

method addErrorAndTimeoutHandlers

addErrorAndTimeoutHandlers: (
    request: any,
    reject: (error: Error) => void,
    timeout?: number
) => void;

method addRedirectHandlers

protected addRedirectHandlers: (
    request: any,
    options: RequestOptions,
    reject: (error: Error) => void,
    redirectCount: number,
    handler: (options: RequestOptions) => void
) => void;

method createMaxRedirectError

protected createMaxRedirectError: () => Error;

method createRequest

abstract createRequest: (
    options: RequestOptions,
    callback: (response: any) => void
) => T;

method doApiRequest

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

method doDownload

protected doDownload: (
    requestOptions: RequestOptions,
    options: DownloadCallOptions,
    redirectCount: number
) => void;

method downloadToBuffer

downloadToBuffer: (url: URL, options: DownloadOptions) => Promise<Buffer>;

method prepareRedirectUrlOptions

static prepareRedirectUrlOptions: (
    redirectUrl: string,
    options: RequestOptions
) => RequestOptions;

method request

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

method retryOnServerError

static retryOnServerError: (
    task: () => Promise<any>,
    maxRetries?: number
) => Promise<any>;

class MemoLazy

class MemoLazy<S, V> {}

constructor

constructor(selector: () => S, creator: (selected: S) => Promise<V>);

property hasValue

readonly hasValue: boolean;

property value

value: Promise<V>;

class ProgressCallbackTransform

class ProgressCallbackTransform extends Transform {}

constructor

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

class UUID

class UUID {}

constructor

constructor(uuid: any);

property OID

static readonly OID: Buffer;

method check

static check: (
    uuid: Buffer | string,
    offset?: number
) =>
    | false
    | { version: undefined; variant: string; format: string }
    | { version: number; variant: string; format: string };

method inspect

inspect: () => string;

method parse

static parse: (input: string) => Buffer;

method toString

toString: () => string;

method v5

static v5: (name: string | Buffer, namespace: Buffer) => any;

class XElement

class XElement {}

constructor

constructor(name: string);

property attributes

attributes: Record<string, string>;

property elements

elements: XElement[];

property isCData

isCData: boolean;

property name

readonly name: string;

property value

value: string;

method attribute

attribute: (name: string) => string;

method element

element: (
    name: string,
    ignoreCase?: boolean,
    errorIfMissed?: string | null
) => XElement;

method elementOrNull

elementOrNull: (name: string, ignoreCase?: boolean) => XElement | null;

method elementValueOrEmpty

elementValueOrEmpty: (name: string, ignoreCase?: boolean) => string;

method getElements

getElements: (name: string, ignoreCase?: boolean) => XElement[];

method removeAttribute

removeAttribute: (name: string) => void;

Interfaces

interface BaseS3Options

interface BaseS3Options extends PublishConfiguration {}

property acl

readonly acl?: 'private' | 'public-read' | null;

The ACL. Set to null to not [add](https://github.com/electron-userland/electron-builder/issues/1822).
public-read

property channel

channel?: string | null;

The update channel. latest

property path

readonly path?: string | null;

The directory path. /

interface BitbucketOptions

interface BitbucketOptions extends PublishConfiguration {}

Bitbucket options. https://bitbucket.org/ Define BITBUCKET_TOKEN environment variable.

For converting an app password to a usable token, you can utilize this

convertAppPassword(owner: string, appPassword: string) {
  const base64encodedData = Buffer.from(`${owner}:${appPassword.trim()}`).toString("base64")
  return `Basic ${base64encodedData}`
}

property channel

readonly channel?: string | null;

The channel. latest

property owner

readonly owner: string;

Repository owner

property provider

readonly provider: 'bitbucket';

The provider. Must be bitbucket.

property slug

readonly slug: string;

Repository slug/name

property token

readonly token?: string | null;

The [app password](https://bitbucket.org/account/settings/app-passwords) to support auto-update from private bitbucket repositories.

property username

readonly username?: string | null;

The user name to support auto-update from private bitbucket repositories.

interface BlockMap

interface BlockMap {}

property files

files: Array<BlockMapFile>;

property version

version: '1' | '2';

interface BlockMapDataHolder

interface BlockMapDataHolder {}

property blockMapSize

blockMapSize?: number;

The block map file size. Used when block map data is embedded into the file (appimage, windows web installer package). This information can be obtained from the file itself, but it requires additional HTTP request, so, to reduce request count, block map size is specified in the update metadata too.

property isAdminRightsRequired

readonly isAdminRightsRequired?: boolean;

property sha512

readonly sha512: string;

The file checksum.

property size

size?: number;

The file size. Used to verify downloaded size (save one HTTP request to get length). Also used when block map data is embedded into the file (appimage, windows web installer package).

interface CustomPublishOptions

interface CustomPublishOptions extends PublishConfiguration {}

property provider

readonly provider: 'custom';

The provider. Must be custom.

property updateProvider

updateProvider?: new (
    options: CustomPublishOptions,
    updater: any,
    runtimeOptions: any
) => any;

The Provider to provide UpdateInfo regarding available updates. Required to use custom providers with electron-updater.

index signature

[index: string]: any;

interface DownloadOptions

interface DownloadOptions {}

property cancellationToken

readonly cancellationToken: CancellationToken;

property headers

readonly headers?: OutgoingHttpHeaders | null;

property onProgress

onProgress?: (progress: ProgressInfo) => void;

property sha2

readonly sha2?: string | null;

property sha512

readonly sha512?: string | null;

interface GenericServerOptions

interface GenericServerOptions extends PublishConfiguration {}

Generic (any HTTP(S) server) options. In all publish options [File Macros](./file-patterns.md#file-macros) are supported.

property channel

readonly channel?: string | null;

The channel. latest

property provider

readonly provider: 'generic';

The provider. Must be generic.

property url

readonly url: string;

The base url. e.g. https://bucket_name.s3.amazonaws.com.

property useMultipleRangeRequest

readonly useMultipleRangeRequest?: boolean;

Whether to use multiple range requests for differential update. Defaults to true if url doesn't contain s3.amazonaws.com.

interface GithubOptions

interface GithubOptions extends PublishConfiguration {}

[GitHub](https://help.github.com/articles/about-releases/) options.
GitHub [personal access token](https://help.github.com/articles/creating-an-access-token-for-command-line-use/) is required. You can generate by going to [https://github.com/settings/tokens/new](https://github.com/settings/tokens/new). The access token should have the repo scope/permission. Define GH_TOKEN environment variable.

property channel

readonly channel?: string | null;

The channel. latest

property host

readonly host?: string | null;

The host (including the port if need). github.com

property owner

readonly owner?: string | null;

The owner.

property private

readonly private?: boolean | null;

Whether to use private github auto-update provider if GH_TOKEN environment variable is defined. See [Private GitHub Update Repo](./auto-update.md#private-github-update-repo).

property protocol

readonly protocol?: 'https' | 'http' | null;

The protocol. GitHub Publisher supports only https. https

property provider

readonly provider: 'github';

The provider. Must be github.

property releaseType

releaseType?: 'draft' | 'prerelease' | 'release' | null;

The type of release. By default draft release will be created.
Also you can set release type using environment variable. If EP_DRAFTis set to true — draft, if EP_PRE_RELEASEis set to true — prerelease. draft

property repo

readonly repo?: string | null;

The repository name. [Detected automatically](#github-repository-and-bintray-package).

property tagNamePrefix

readonly tagNamePrefix?: string;

If defined, sets the prefix of the tag name that comes before the semver number. e.g. "v" in "v1.2.3" or "test" of "test1.2.3". Overrides vPrefixedTagName

property token

readonly token?: string | null;

The access token to support auto-update from private github repositories. Never specify it in the configuration files. Only for [setFeedURL](./auto-update.md#appupdatersetfeedurloptions).

property vPrefixedTagName

readonly vPrefixedTagName?: boolean;

Whether to use v-prefixed tag name. true
Deprecated
please use #tagNamePrefix instead.

interface GitlabOptions

interface GitlabOptions extends PublishConfiguration {}

[GitLab](https://docs.gitlab.com/ee/user/project/releases/) options.
GitLab [personal access token](https://docs.gitlab.com/ee/user/profile/personal_access_tokens.html) is required for private repositories. You can generate one by going to your GitLab profile settings. Define GITLAB_TOKEN environment variable.

property channel

readonly channel?: string | null;

The channel. latest

property host

readonly host?: string | null;

The GitLab host (including the port if need). gitlab.com

property projectId

readonly projectId?: string | number | null;

The GitLab project ID or path (e.g., "12345678" or "namespace/project").

property provider

readonly provider: 'gitlab';

The provider. Must be gitlab.

property token

readonly token?: string | null;

The access token to support auto-update from private GitLab repositories. Never specify it in the configuration files.

property uploadTarget

readonly uploadTarget?: 'project_upload' | 'generic_package' | null;

Upload target method. Can be "project_upload" for GitLab project uploads or "generic_package" for GitLab generic packages. "project_upload"

property vPrefixedTagName

readonly vPrefixedTagName?: boolean;

Whether to use v-prefixed tag name. true

interface GitlabReleaseAsset

interface GitlabReleaseAsset {}

property count

count: number;

property links

links: Array<{
    id: number;
    name: string;
    url: string;
    direct_asset_url: string;
    link_type: string;
}>;

property sources

sources: Array<{
    format: string;
    url: string;
}>;

interface GitlabReleaseInfo

interface GitlabReleaseInfo {}

property assets

assets: GitlabReleaseAsset;

property created_at

created_at: string;

property description

description: string;

property name

name: string;

property released_at

released_at: string;

property tag_name

tag_name: string;

property upcoming_release

upcoming_release: boolean;

interface KeygenOptions

interface KeygenOptions extends PublishConfiguration {}

Keygen options. https://keygen.sh/ Define KEYGEN_TOKEN environment variable.

property account

readonly account: string;

Keygen account's UUID

property channel

readonly channel?: 'stable' | 'rc' | 'beta' | 'alpha' | 'dev' | null;

The channel. stable

property host

readonly host?: string;

Keygen host for self-hosted instances "api.keygen.sh"

property platform

readonly platform?: string | null;

The target Platform. Is set programmatically explicitly during publishing.

property product

readonly product: string;

Keygen product's UUID

property provider

readonly provider: 'keygen';

The provider. Must be keygen.

interface PackageFileInfo

interface PackageFileInfo extends BlockMapDataHolder {}

property path

readonly path: string;

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 PublishConfiguration

interface PublishConfiguration {}

property provider

readonly provider: PublishProvider;

The provider.

property publishAutoUpdate

readonly publishAutoUpdate?: boolean;

Whether to publish auto update info files.
Auto update relies only on the first provider in the list (you can specify several publishers). Thus, probably, there`s no need to upload the metadata files for the other configured providers. But by default will be uploaded.
true

property publisherName

publisherName?: Array<string> | null;

win-only

property requestHeaders

readonly requestHeaders?: OutgoingHttpHeaders;

Any custom request headers

property timeout

readonly timeout?: number | null;

Request timeout in milliseconds. (Default is 2 minutes; O is ignored)
120000

property updaterCacheDirName

readonly updaterCacheDirName?: string | null;

win-only

interface ReleaseNoteInfo

interface ReleaseNoteInfo {}

property note

readonly note: string | null;

The note.

property version

readonly version: string;

The version.

interface RequestHeaders

interface RequestHeaders extends OutgoingHttpHeaders {}

index signature

[key: string]: OutgoingHttpHeader | undefined;

interface S3Options

interface S3Options extends BaseS3Options {}

[Amazon S3](https://aws.amazon.com/s3/) options. AWS credentials are required, please see [getting your credentials](http://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/getting-your-credentials.html). To set credentials define AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY [environment variables](http://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/loading-node-credentials-environment.html) directly, or use [~/.aws/credentials](http://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/loading-node-credentials-shared.html) file, or use [~/.aws/config](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) file. For the last method to work you will also need to define AWS_SDK_LOAD_CONFIG=1 environment variable.
Example configuration:
{ "build": "publish": { "provider": "s3", "bucket": "bucket-name" } } }

property accelerate

readonly accelerate?: boolean;

If set to true, this will enable the s3 accelerated endpoint These endpoints have a particular format of: ${bucketname}.s3-accelerate.amazonaws.com

property acl

readonly acl?: 'private' | 'public-read' | null;

The ACL. Set to null to not [add](https://github.com/electron-userland/electron-builder/issues/1822).
Please see [required permissions for the S3 provider](https://github.com/electron-userland/electron-builder/issues/1618#issuecomment-314679128).
public-read

property bucket

readonly bucket: string;

The bucket name.

property encryption

readonly encryption?: 'AES256' | 'aws:kms' | null;

Server-side encryption algorithm to use for the object.

property endpoint

readonly endpoint?: string | null;

The endpoint URI to send requests to. The default endpoint is built from the configured region. The endpoint should be a string like https://{service}.{region}.amazonaws.com.

property forcePathStyle

readonly forcePathStyle?: boolean;

When true, force a path-style endpoint to be used where the bucket name is part of the path. [Path-style Access](https://docs.aws.amazon.com/AmazonS3/latest/userguide/VirtualHosting.html#path-style-access)

property provider

readonly provider: 's3';

The provider. Must be s3.

property region

region?: string | null;

The region. Is determined and set automatically when publishing.

property storageClass

readonly storageClass?: 'STANDARD' | 'REDUCED_REDUNDANCY' | 'STANDARD_IA' | null;

The type of storage to use for the object. STANDARD

interface SnapStoreOptions

interface SnapStoreOptions extends PublishConfiguration {}

[Snap Store](https://snapcraft.io/) options. To publish directly to Snapcraft, see Snapcraft authentication options for local or CI/CD authentication options.

property channels

readonly channels?: string | Array<string> | null;

The list of channels the snap would be released. ["edge"]

property provider

readonly provider: 'snapStore';

The provider. Must be snapStore.

property repo

readonly repo?: string;

snapcraft repo name

interface SpacesOptions

interface SpacesOptions extends BaseS3Options {}

[DigitalOcean Spaces](https://www.digitalocean.com/community/tutorials/an-introduction-to-digitalocean-spaces) options. Access key is required, define DO_KEY_ID and DO_SECRET_KEY environment variables.

property name

readonly name: string;

The space name.

property provider

readonly provider: 'spaces';

The provider. Must be spaces.

property region

readonly region: string;

The region (e.g. nyc3).

interface UpdateFileInfo

interface UpdateFileInfo extends BlockMapDataHolder {}

property url

url: string;

interface UpdateInfo

interface UpdateInfo {}

property files

readonly files: Array<UpdateFileInfo>;

property minimumSystemVersion

readonly minimumSystemVersion?: string;

The minimum version of system required for the app to run. Sample value: macOS 23.1.0, Windows 10.0.22631. Same with os.release() value, this is a kernel version.

property path

readonly path: string;

Deprecated

property releaseDate

releaseDate: string;

The release date.

property releaseName

releaseName?: string | null;

The release name.

property releaseNotes

releaseNotes?: string | Array<ReleaseNoteInfo> | null;

The release notes. List if updater.fullChangelog is set to true, string otherwise.

property sha512

readonly sha512: string;

Deprecated

property stagingPercentage

readonly stagingPercentage?: number;

The [staged rollout](./auto-update.md#staged-rollouts) percentage, 0-100.

property version

readonly version: string;

The version.

interface WindowsUpdateInfo

interface WindowsUpdateInfo extends UpdateInfo {}

property packages

packages?: {
    [arch: string]: PackageFileInfo;
} | null;

property sha2

sha2?: string;

Deprecated

Type Aliases

type AllPublishOptions

type AllPublishOptions =
    | string
    | GithubOptions
    | GitlabOptions
    | S3Options
    | SpacesOptions
    | GenericServerOptions
    | CustomPublishOptions
    | KeygenOptions
    | SnapStoreOptions
    | BitbucketOptions;

type Nullish

type Nullish = null | undefined;

type PublishProvider

type PublishProvider =
    | 'github'
    | 'gitlab'
    | 's3'
    | 'spaces'
    | 'generic'
    | 'custom'
    | 'snapStore'
    | 'keygen'
    | 'bitbucket';

Package Files (13)

Dependencies (2)

Dev Dependencies (2)

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto 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/builder-util-runtime.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/builder-util-runtime)

HTML

<a href="https://www.jsdocs.io/package/builder-util-runtime"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 1 month ago.
Package analyzed in 4324 ms.
Missing or incorrect documentation? Open an issue for this package.