electron-builder-util

  • Version 19.24.0
  • Published
  • 16 dependencies
  • MIT license

Install

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

Overview

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

Index

Variables

variable debug

const debug: any;

    variable debug7z

    const debug7z: any;

      Functions

      function addValue

      addValue: <K, T>(map: Map<K, Array<T>>, key: K, value: T) => void;

        function archFromString

        archFromString: (name: string) => Arch;

          function asArray

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

            function debug7zArgs

            debug7zArgs: (command: 'a' | 'x') => Array<string>;

              function doSpawn

              doSpawn: (
              command: string,
              args: Array<string>,
              options?: any,
              extraOptions?: ExtraSpawnOptions
              ) => any;

                function exec

                exec: (
                file: string,
                args?: Array<string> | null,
                options?: ExecOptions,
                isLogOutIfDebug?: boolean
                ) => Promise<string>;

                  function execWine

                  execWine: (
                  file: string,
                  args: Array<string>,
                  options?: ExecOptions
                  ) => Promise<string>;

                  function getArchSuffix

                  getArchSuffix: (arch: Arch) => string;

                    function getCacheDirectory

                    getCacheDirectory: () => string;

                      function getPlatformIconFileName

                      getPlatformIconFileName: (
                      value: string | null | undefined,
                      isMac: boolean
                      ) => string | null | undefined;

                        function handleProcess

                        handleProcess: (
                        event: string,
                        childProcess: any,
                        command: string,
                        resolve: (value?: any) => void,
                        reject: (reason?: any) => void
                        ) => void;

                          function isEmptyOrSpaces

                          isEmptyOrSpaces: (s: string | null | undefined) => s is '';

                            function isEnvTrue

                            isEnvTrue: (value: string | null | undefined) => boolean;

                              function isMacOsSierra

                              isMacOsSierra: () => Promise<boolean>;

                                function isPullRequest

                                isPullRequest: () => boolean | '' | undefined;

                                  function isTokenCharValid

                                  isTokenCharValid: (token: string) => boolean;

                                    function log

                                    log: (message: string) => void;

                                      function prepareWindowsExecutableArgs

                                      prepareWindowsExecutableArgs: (args: Array<string>, exePath: string) => string[];

                                      function removePassword

                                      removePassword: (input: string) => string;

                                        function replaceDefault

                                        replaceDefault: (
                                        inList: Array<string> | null | undefined,
                                        defaultList: Array<string>
                                        ) => Array<string>;

                                          function safeStringifyJson

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

                                            function smarten

                                            smarten: (s: string) => string;

                                              function spawn

                                              spawn: (
                                              command: string,
                                              args?: Array<string> | null,
                                              options?: any,
                                              extraOptions?: ExtraSpawnOptions
                                              ) => Promise<any>;

                                                function spawnAndWrite

                                                spawnAndWrite: (
                                                command: string,
                                                args: Array<string>,
                                                data: string,
                                                options?: any,
                                                isDebugEnabled?: boolean
                                                ) => any;

                                                  function subTask

                                                  subTask: (title: string, promise: BluebirdPromise<any> | Promise<any>) => any;

                                                    function task

                                                    task: (title: string, promise: BluebirdPromise<any> | Promise<any>) => any;

                                                      function toLinuxArchString

                                                      toLinuxArchString: (arch: Arch) => 'i386' | 'amd64' | 'armv7l';

                                                        function use

                                                        use: <T, R>(value: T | null, task: (it: T) => R) => R | null;

                                                          function warn

                                                          warn: (message: string) => void;

                                                            Interfaces

                                                            interface BaseExecOptions

                                                            interface BaseExecOptions {}

                                                              property cwd

                                                              cwd?: string;

                                                                property env

                                                                env?: any;

                                                                  property stdio

                                                                  stdio?: any;

                                                                    interface ExecOptions

                                                                    interface ExecOptions extends BaseExecOptions {}

                                                                      property customFds

                                                                      customFds?: any;

                                                                        property encoding

                                                                        encoding?: string;

                                                                          property killSignal

                                                                          killSignal?: string;

                                                                            property maxBuffer

                                                                            maxBuffer?: number;

                                                                              property timeout

                                                                              timeout?: number;

                                                                                interface ExtraSpawnOptions

                                                                                interface ExtraSpawnOptions {}

                                                                                  property isDebugEnabled

                                                                                  isDebugEnabled?: boolean;

                                                                                    property isPipeInput

                                                                                    isPipeInput?: boolean;

                                                                                      Enums

                                                                                      enum Arch

                                                                                      enum Arch {
                                                                                      ia32 = 0,
                                                                                      x64 = 1,
                                                                                      armv7l = 2,
                                                                                      }

                                                                                        member armv7l

                                                                                        armv7l = 2

                                                                                          member ia32

                                                                                          ia32 = 0

                                                                                            member x64

                                                                                            x64 = 1

                                                                                              Type Aliases

                                                                                              type ArchType

                                                                                              type ArchType = 'x64' | 'ia32' | 'armv7l';

                                                                                                Package Files (5)

                                                                                                Dependencies (16)

                                                                                                Dev Dependencies (0)

                                                                                                No dev dependencies.

                                                                                                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-builder-util.

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