electron-publish

  • Version 26.3.4
  • Published
  • 179 kB
  • 8 dependencies
  • MIT license

Install

npm i electron-publish
yarn add electron-publish
pnpm add electron-publish

Overview

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

Index

Functions

function getCiTag

getCiTag: () => string | null;

    Classes

    class BitbucketPublisher

    class BitbucketPublisher extends HttpPublisher {}

      constructor

      constructor(context: PublishContext, info: BitbucketOptions);

        property hostname

        readonly hostname: string;

          property providerName

          readonly providerName: string;

            method convertAppPassword

            static convertAppPassword: (username: string, token: string) => string;

              method deleteRelease

              deleteRelease: (filename: string) => Promise<void>;

                method doUpload

                protected doUpload: (
                fileName: string,
                _arch: Arch,
                _dataLength: number,
                _requestProcessor: (
                request: ClientRequest,
                reject: (error: Error) => void
                ) => void,
                file: string
                ) => Promise<any>;

                  method toString

                  toString: () => string;

                    class GitHubPublisher

                    class GitHubPublisher extends HttpPublisher {}

                      constructor

                      constructor(
                      context: PublishContext,
                      info: GithubOptions,
                      version: string,
                      options?: PublishOptions
                      );

                        property providerName

                        readonly providerName: string;

                          method deleteRelease

                          deleteRelease: () => Promise<any>;

                            method doUpload

                            protected doUpload: (
                            fileName: string,
                            arch: Arch,
                            dataLength: number,
                            requestProcessor: (
                            request: ClientRequest,
                            reject: (error: Error) => void
                            ) => void
                            ) => Promise<any>;

                              method getRelease

                              getRelease: () => Promise<any>;

                                method toString

                                toString: () => string;

                                  class GitlabPublisher

                                  class GitlabPublisher extends HttpPublisher {}

                                    constructor

                                    constructor(context: PublishContext, info: GitlabOptions, version: string);

                                      property providerName

                                      readonly providerName: string;

                                        method doUpload

                                        protected doUpload: (
                                        fileName: string,
                                        arch: Arch,
                                        dataLength: number,
                                        requestProcessor: RequestProcessor,
                                        filePath: string
                                        ) => Promise<any>;

                                          method toString

                                          toString: () => string;

                                            class HttpPublisher

                                            abstract class HttpPublisher extends Publisher {}

                                              constructor

                                              protected constructor(context: PublishContext, useSafeArtifactName?: boolean);

                                                property context

                                                protected readonly context: PublishContext;

                                                  method doUpload

                                                  protected abstract doUpload: (
                                                  fileName: string,
                                                  arch: Arch,
                                                  dataLength: number,
                                                  requestProcessor: (
                                                  request: ClientRequest,
                                                  reject: (error: Error) => void
                                                  ) => void,
                                                  file: string
                                                  ) => Promise<any>;

                                                    method upload

                                                    upload: (task: UploadTask) => Promise<any>;

                                                      class KeygenPublisher

                                                      class KeygenPublisher extends HttpPublisher {}

                                                        constructor

                                                        constructor(context: PublishContext, info: KeygenOptions, version: string);

                                                          property defaultHostname

                                                          readonly defaultHostname: string;

                                                            property hostname

                                                            readonly hostname: string;

                                                              property providerName

                                                              readonly providerName: string;

                                                                method deleteRelease

                                                                deleteRelease: (releaseId: string) => Promise<void>;

                                                                  method doUpload

                                                                  protected doUpload: (
                                                                  fileName: string,
                                                                  _arch: Arch,
                                                                  dataLength: number,
                                                                  requestProcessor: (
                                                                  request: ClientRequest,
                                                                  reject: (error: Error) => void
                                                                  ) => void,
                                                                  _file: string
                                                                  ) => Promise<string>;

                                                                    method toString

                                                                    toString: () => string;

                                                                      class ProgressCallback

                                                                      class ProgressCallback {}

                                                                        constructor

                                                                        constructor(progressBar: ProgressBar);

                                                                          method update

                                                                          update: (transferred: number, total: number) => void;

                                                                            class Publisher

                                                                            abstract class Publisher {}

                                                                              constructor

                                                                              protected constructor(context: PublishContext);

                                                                                property context

                                                                                protected readonly context: PublishContext;

                                                                                  property providerName

                                                                                  readonly providerName: PublishProvider;

                                                                                    method createProgressBar

                                                                                    protected createProgressBar: (
                                                                                    fileName: string,
                                                                                    size: number
                                                                                    ) => ProgressBar | null;

                                                                                      method createReadStreamAndProgressBar

                                                                                      protected createReadStreamAndProgressBar: (
                                                                                      file: string,
                                                                                      fileStat: Stats,
                                                                                      progressBar: ProgressBar | null,
                                                                                      reject: (error: Error) => void
                                                                                      ) => NodeJS.ReadableStream;

                                                                                        method toString

                                                                                        abstract toString: () => string;

                                                                                          method upload

                                                                                          abstract upload: (task: UploadTask) => Promise<any>;

                                                                                            class S3Publisher

                                                                                            class S3Publisher extends BaseS3Publisher {}

                                                                                              constructor

                                                                                              constructor(context: PublishContext, info: S3Options);

                                                                                                property providerName

                                                                                                readonly providerName: string;

                                                                                                  method checkAndResolveOptions

                                                                                                  static checkAndResolveOptions: (
                                                                                                  options: S3Options,
                                                                                                  channelFromAppVersion: string | null,
                                                                                                  errorIfCannot: boolean
                                                                                                  ) => Promise<void>;

                                                                                                    method configureS3Options

                                                                                                    protected configureS3Options: (args: Array<string>) => void;

                                                                                                      method getBucketName

                                                                                                      protected getBucketName: () => string;

                                                                                                        method toString

                                                                                                        toString: () => string;

                                                                                                          class SnapStorePublisher

                                                                                                          class SnapStorePublisher extends Publisher {}

                                                                                                            constructor

                                                                                                            constructor(context: PublishContext, options: SnapStoreOptions);

                                                                                                              property providerName

                                                                                                              readonly providerName: string;

                                                                                                                method toString

                                                                                                                toString: () => string;

                                                                                                                  method upload

                                                                                                                  upload: (task: UploadTask) => Promise<any>;

                                                                                                                    class SpacesPublisher

                                                                                                                    class SpacesPublisher extends BaseS3Publisher {}

                                                                                                                      constructor

                                                                                                                      constructor(context: PublishContext, info: SpacesOptions);

                                                                                                                        property providerName

                                                                                                                        readonly providerName: string;

                                                                                                                          method checkAndResolveOptions

                                                                                                                          static checkAndResolveOptions: (
                                                                                                                          options: SpacesOptions,
                                                                                                                          channelFromAppVersion: string | null,
                                                                                                                          errorIfCannot: boolean
                                                                                                                          ) => Promise<void>;

                                                                                                                            method configureS3Options

                                                                                                                            protected configureS3Options: (args: Array<string>) => void;

                                                                                                                              method getBucketName

                                                                                                                              protected getBucketName: () => string;

                                                                                                                                Interfaces

                                                                                                                                interface PublishContext

                                                                                                                                interface PublishContext {}

                                                                                                                                  property cancellationToken

                                                                                                                                  readonly cancellationToken: CancellationToken;

                                                                                                                                    property progress

                                                                                                                                    readonly progress: MultiProgress | null;

                                                                                                                                      interface PublishOptions

                                                                                                                                      interface PublishOptions {}

                                                                                                                                        property publish

                                                                                                                                        publish?: PublishPolicy | null;

                                                                                                                                          interface UploadTask

                                                                                                                                          interface UploadTask {}

                                                                                                                                            property arch

                                                                                                                                            arch: Arch | null;

                                                                                                                                              property file

                                                                                                                                              file: string;

                                                                                                                                                property fileContent

                                                                                                                                                fileContent?: Buffer | null;

                                                                                                                                                  property safeArtifactName

                                                                                                                                                  safeArtifactName?: string | null;

                                                                                                                                                    property timeout

                                                                                                                                                    timeout?: number | null;

                                                                                                                                                      Type Aliases

                                                                                                                                                      type PublishPolicy

                                                                                                                                                      type PublishPolicy = 'onTag' | 'onTagOrDraft' | 'always' | 'never';

                                                                                                                                                        Package Files (11)

                                                                                                                                                        Dependencies (8)

                                                                                                                                                        Dev Dependencies (1)

                                                                                                                                                        Peer Dependencies (0)

                                                                                                                                                        No peer dependencies.

                                                                                                                                                        Badge

                                                                                                                                                        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-publish.

                                                                                                                                                        • Markdown
                                                                                                                                                          [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/electron-publish)
                                                                                                                                                        • HTML
                                                                                                                                                          <a href="https://www.jsdocs.io/package/electron-publish"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>