InternalOptions | Electron Forge

Index

Namespaces

Enquirer

Enumerations

Enumeration members

Classes

Interfaces

Type aliases

Functions

makeUniversalApp

Enumeration members

DATA

DATA = "DATA"

ENABLED

ENABLED = "ENABLED"

MESSAGE

MESSAGE = "MESSAGE"

STATE

STATE = "STATE"

SUBTASK

SUBTASK = "SUBTASK"

TITLE

TITLE = "TITLE"

Type aliases

BaseSignOptions

BaseSignOptions: Readonly<{ app: string; identity?: string; keychain?: string; platform?: ElectronMacPlatform }>

CreateOptions

CreateOptions: { dot?: boolean; globOptions?: IOptions; ordering?: string; pattern?: string; unpack?: string; unpackDir?: string; transform?: any }

Type declaration

Optional dot?: boolean
Optional globOptions?: IOptions
Optional ordering?: string
Optional pattern?: string
Optional unpack?: string
Optional unpackDir?: string
transform?:function
- transform(filePath: string): void | ReadWriteStream
- - Defined in node_modules/@electron/asar/lib/index.d.ts:9
  Parameters
  - filePath: string
  Returns void | ReadWriteStream

ElectronMacPlatform

ElectronMacPlatform: "darwin" | "mas"

ElectronProcess

ElectronProcess: ChildProcess & { restarted: boolean }

FinalizePackageTargetsHookFunction

FinalizePackageTargetsHookFunction: (targets: TargetDefinition[], callback: HookFunctionErrorCallback) => void

ForgeHookMap

ForgeHookMap: { [ S in ForgeHookName]?: ForgeHookFn<S> }

ForgeHookName

ForgeHookName: keyof ForgeSimpleHookSignatures & ForgeMutatingHookSignatures

ForgeListrTaskDefinition

ForgeListrTaskDefinition: ListrTask<never>

ForgeMultiHookMap

ForgeMultiHookMap: { [ S in ForgeHookName]?: ForgeHookFn<S> | ForgeHookFn<S>[] }

ForgeMutatingHookFn

ForgeMutatingHookFn<Hook>: (forgeConfig: ResolvedForgeConfig, ...args: ForgeMutatingHookSignatures[Hook]) => Promise<ForgeMutatingHookSignatures[Hook][0] | undefined>

Type parameters

Hook: keyof ForgeMutatingHookSignatures

Type declaration

- (forgeConfig: ResolvedForgeConfig, ...args: ForgeMutatingHookSignatures[Hook]): Promise<ForgeMutatingHookSignatures[Hook][0] | undefined>
- Parameters
  - forgeConfig: ResolvedForgeConfig
  - Rest ...args: ForgeMutatingHookSignatures[Hook]
  Returns Promise<ForgeMutatingHookSignatures[Hook][0] | undefined>

ForgePackagerOptions

ForgePackagerOptions: Omit<Options, "dir" | "arch" | "platform" | "out" | "electronVersion">

ForgeRebuildOptions

ForgeRebuildOptions: Omit<RebuildOptions, "buildPath" | "electronVersion" | "arch">

ForgeSimpleHookFn

ForgeSimpleHookFn<Hook>: (forgeConfig: ResolvedForgeConfig, ...args: ForgeSimpleHookSignatures[Hook]) => Promise<void>

Type parameters

Hook: keyof ForgeSimpleHookSignatures

Type declaration

- (forgeConfig: ResolvedForgeConfig, ...args: ForgeSimpleHookSignatures[Hook]): Promise<void>
- Parameters
  - forgeConfig: ResolvedForgeConfig
  - Rest ...args: ForgeSimpleHookSignatures[Hook]
  Returns Promise<void>

HookFunction

HookFunction: (buildPath: string, electronVersion: string, platform: TargetArch, arch: TargetArch, callback: HookFunctionErrorCallback) => void

Type declaration

- (buildPath: string, electronVersion: string, platform: TargetArch, arch: TargetArch, callback: HookFunctionErrorCallback): void
- A function that is called on the completion of a packaging stage.
  By default, the functions are called in parallel (via Promise.all). If you need the functions called serially, there is a utility function provided. Please note that callback-style functions are not supported by serialHooks. For example:
```
const packager = require('@electron/packager')
const { serialHooks } = require('@electron/packager/src/hooks')

packager({
  // ...
  afterCopy: [serialHooks([
    (buildPath, electronVersion, platform, arch) => {
      return new Promise((resolve, reject) => {
        setTimeout(() => {
          console.log('first function')
          resolve()
        }, 1000)
      })
    },
    (buildPath, electronVersion, platform, arch) => {
      console.log('second function')
    }
  ])],
  // ...
})
```
  For real-world examples of HookFunctions, see the list of related plugins.
  Parameters
  - buildPath: string
  - electronVersion: string
  - platform: TargetArch
  - arch: TargetArch
  - callback: HookFunctionErrorCallback
  Returns void

HookFunction

HookFunction: (fileToSign: string) => void | Promise<void>

Type declaration

- (fileToSign: string): void | Promise<void>
- Parameters
  - fileToSign: string
  Returns void | Promise<void>

HookFunctionErrorCallback

HookFunctionErrorCallback: (err?: Error | null) => void

Type declaration

- (err?: Error | null): void
- Parameters
  - Optional err: Error | null
  Returns void

IgnoreFunction

IgnoreFunction: (path: string) => boolean

Type declaration

- (path: string): boolean
- A predicate function that, given an absolute file path, returns true if the file should be ignored, or false if the file should be kept. This does not use any of the default ignored files/directories listed for the ignore option.
  
  Parameters
  - path: string
  Returns boolean

InnerStartResult

InnerStartResult: ElectronProcess | string | string[] | false

ListrBaseClassOptions

ListrBaseClassOptions<Ctx, Renderer, FallbackRenderer>: ListrOptions<Ctx> & ListrDefaultRendererOptions<Renderer> & ListrDefaultNonTTYRendererOptions<FallbackRenderer>

Parent class options.

Parent class has more options where you can also select the and set renderer and non-tty renderer.

Any subtasks will respect those options so they will be stripped of that properties.

Type parameters

Ctx = ListrContext
Renderer: ListrRendererValue = ListrDefaultRendererValue
FallbackRenderer: ListrRendererValue = ListrFallbackRendererValue

ListrContext

ListrContext: any | undefined

Listr Default Context

ListrDefaultRenderer

ListrDefaultRenderer: typeof DefaultRenderer

Type of default renderer

ListrDefaultRendererValue

ListrDefaultRendererValue: "default"

The default renderer value used in Listr2 applications

ListrEvent

ListrEvent: { data?: string | boolean; type: Exclude<ListrEventType, "MESSAGE" | "DATA"> } | { data: string; type: DATA } | { data: Task<any, any>["message"]; type: MESSAGE }

The internal communication event.

ListrFallbackRenderer

ListrFallbackRenderer: typeof VerboseRenderer

Type of default fallback renderer

ListrFallbackRendererValue

ListrFallbackRendererValue: "verbose"

Name of default fallback renderer

ListrGetRendererClassFromValue

ListrGetRendererClassFromValue<T>: T extends ListrDefaultRendererValue ? ListrDefaultRenderer : T extends ListrSimpleRendererValue ? ListrSimpleRenderer : T extends ListrFallbackRendererValue ? ListrFallbackRenderer : T extends ListrSilentRenderer ? ListrSilentRenderer : T extends ListrRendererFactory ? T : never

Returns the class type from friendly names of the renderers.

Type parameters

T: ListrRendererValue

ListrGetRendererOptions

ListrGetRendererOptions<T>: T extends ListrDefaultRendererValue ? ListrDefaultRenderer["rendererOptions"] : T extends ListrSimpleRendererValue ? ListrSimpleRenderer["rendererOptions"] : T extends ListrFallbackRendererValue ? ListrFallbackRenderer["rendererOptions"] : T extends ListrSilentRenderer ? ListrSilentRenderer["rendererOptions"] : T extends ListrRendererFactory ? T["rendererOptions"] : never

Returns renderer global options depending on the renderer type.

Type parameters

T: ListrRendererValue

ListrGetRendererTaskOptions

ListrGetRendererTaskOptions<T>: T extends ListrDefaultRendererValue ? ListrDefaultRenderer["rendererTaskOptions"] : T extends ListrSimpleRendererValue ? ListrSimpleRenderer : T extends ListrFallbackRendererValue ? ListrFallbackRenderer["rendererTaskOptions"] : T extends ListrSilentRenderer ? ListrSilentRenderer["rendererTaskOptions"] : T extends ListrRendererFactory ? T["rendererTaskOptions"] : never

Returns renderer per task options depending on the renderer type.

Type parameters

T: ListrRendererValue

ListrRendererFactory

ListrRendererFactory: typeof ListrRenderer

A renderer factory from the current type

ListrRendererValue

ListrRendererValue: ListrSilentRendererValue | ListrDefaultRendererValue | ListrSimpleRendererValue | ListrFallbackRendererValue | ListrRendererFactory

Listr2 can process either the integrated renderers as string aliases, or utilize a compatible style renderer that extends the ListrRenderer abstract class.

ListrSilentRenderer

ListrSilentRenderer: typeof SilentRenderer

Typeof silent renderer

ListrSilentRendererValue

ListrSilentRendererValue: "silent"

Silent rendere for internal usage

ListrSimpleRenderer

ListrSimpleRenderer: typeof SimpleRenderer

Typeof simple renderer

ListrSimpleRendererValue

ListrSimpleRendererValue: "simple"

Simple renderer that simplifies things

ListrSubClassOptions

ListrSubClassOptions<Ctx, Renderer>: ListrOptions<Ctx> & Omit<ListrDefaultRendererOptions<Renderer>, "renderer">

Sub class options.

Subtasks has reduced set options where the missing ones are explicitly set by the base class.

Type parameters

Ctx = ListrContext
Renderer: ListrRendererValue = ListrDefaultRendererValue

ListrTaskResult

Task can be set of sync or async function, an Observable or a stream.

Type parameters

MakeUniversalOpts

MakeUniversalOpts: Parameters<typeof makeUniversalApp>[0]

MakeUniversalOpts

MakeUniversalOpts: { arm64AppPath: string; force?: boolean; infoPlistsToIgnore?: string; mergeASARs?: boolean; outAppPath: string; singleArchFiles?: string; x64AppPath: string; x64ArchFiles?: string }

Type declaration

arm64AppPath: string

Absolute file system path to the arm64 version of your application. E.g. /Foo/bar/MyApp_arm64.app
Optional force?: boolean

Forcefully overwrite any existing files that are in the way of generating the universal application
Optional infoPlistsToIgnore?: string

Minimatch pattern of paths that should not receive an injected ElectronAsarIntegrity value
Optional mergeASARs?: boolean

Merge x64 and arm64 ASARs into one.
outAppPath: string

Absolute file system path you want the universal app to be written to. E.g. /Foo/var/MyApp_universal.app

If this file exists it will be overwritten ONLY if "force" is set to true
Optional singleArchFiles?: string

Minimatch pattern of paths that are allowed to be present in one of the ASAR files, but not in the other.
x64AppPath: string

Absolute file system path to the x64 version of your application. E.g. /Foo/bar/MyApp_x64.app
Optional x64ArchFiles?: string

Minimatch pattern of binaries that are expected to be the same x64 binary in both of the ASAR files.

ModuleType

ModuleType: "prod" | "dev" | "optional"

NotaryToolCredentials

NotaryToolCredentials: NotaryToolPasswordCredentials | NotaryToolApiKeyCredentials | NotaryToolKeychainCredentials

OfficialArch

Architectures that have been supported by the official Electron prebuilt binaries, past and present.

OfficialPlatform

OfficialPlatform: "linux" | "win32" | "darwin" | "mas"

Platforms that have been supported by the official Electron prebuilt binaries, past and present.

OnlySignOptions

OnlySignOptions: { binaries?: string[]; identityValidation?: boolean; ignore?: string | string[] | ((file: string) => boolean); preAutoEntitlements?: boolean; preEmbedProvisioningProfile?: boolean; provisioningProfile?: string; strictVerify?: boolean; type?: SigningDistributionType; version?: string; optionsForFile?: any }

Type declaration

Optional binaries?: string[]
Optional identityValidation?: boolean
Optional ignore?: string | string[] | ((file: string) => boolean)
Optional preAutoEntitlements?: boolean
Optional preEmbedProvisioningProfile?: boolean
Optional provisioningProfile?: string
Optional strictVerify?: boolean
Optional type?: SigningDistributionType
Optional version?: string
optionsForFile?:function
- optionsForFile(filePath: string): PerFileSignOptions
- - Defined in node_modules/@electron/osx-sign/dist/esm/types.d.ts:43
  Parameters
  - filePath: string
  Returns PerFileSignOptions

OsxSignOptions

OsxSignOptions: Omit<SignOptions, "app" | "binaries" | "platform" | "version">

See the documentation for @electron/osx-sign for details.

OsxUniversalOptions

OsxUniversalOptions: Omit<MakeUniversalOpts, "x64AppPath" | "arm64AppPath" | "outAppPath" | "force">

See the documentation for @electron/universal for details.

PerFileSignOptions

PerFileSignOptions: { entitlements?: string | string[]; hardenedRuntime?: boolean; requirements?: string; signatureFlags?: string | string[]; timestamp?: string }

Any missing options will use the default values, providing a partial structure will shallow merge with the default values.

Type declaration

Optional entitlements?: string | string[]

The entitlements file to use when signing this file
Optional hardenedRuntime?: boolean

Whether to enable hardened runtime for this file. Enabled by default.
Optional requirements?: string

The designated requirements to embed when signing this file
Optional signatureFlags?: string | string[]

See --options of the "codesign" command.

https://www.manpagez.com/man/1/codesign
Optional timestamp?: string

The timestamp server to use when signing, by default uses the Apple provided timestamp server.

PromptOptions

PromptOptions<T>: Unionize<{ [ K in PromptTypes]-?: T extends true ? { type: K } & PromptOptionsType<K> & { name: string | (() => string) } : { type: K } & PromptOptionsType<K> }> | (({ type: string } & T) extends true ? PromptOptionsType<string> & { name: string | (() => string) } : PromptOptionsType<string>)

Returns all the prompt options depending on the type selected.

Type parameters

T: boolean = false

PromptOptions

PromptOptionsType

PromptOptionsType<T>: T extends keyof PromptOptionsMap ? PromptOptionsMap[T] : T extends string ? BasePromptOptions & Record<PropertyKey, unknown> : any

Type parameters

PromptTypes

RebuildMode

RebuildMode: "sequential" | "parallel"

SignOptions

SignOptions: Readonly<OnlySignOptions & BaseSignOptions>

SigningDistributionType

SigningDistributionType: "development" | "distribution"

SnapcraftConfig

SnapcraftConfig: Record<string, unknown>

Additional Snapcraft configuration that is merged directly into snapcraft.yaml. In general, this does not override any configuration that is set via Options.

StartResult

StartResult: InnerStartResult | { result: InnerStartResult; tasks: ForgeListrTaskDefinition[] }

TargetArch

TargetArch: OfficialArch | string

TargetDefinition

TargetDefinition: { arch: TargetArch; platform: TargetPlatform }

Type declaration

arch: TargetArch
platform: TargetPlatform

TargetPlatform

TargetPlatform: OfficialPlatform | string

TeardownLogic

TeardownLogic: Subscription | Unsubscribable | (() => void) | void

TraceOptions

TraceOptions: { category: string; extraDetails?: Record<string, string>; name: string; newRoot?: boolean }

Type declaration

category: string
Optional extraDetails?: Record<string, string>
name: string
Optional newRoot?: boolean

Unionize

Unionize<T>: { [ P in keyof T]: T[P] }[keyof T]

Type parameters

T: Record<PropertyKey, unknown>

Functions

makeUniversalApp

makeUniversalApp(opts: MakeUniversalOpts): Promise<void>

- Defined in node_modules/@electron/universal/dist/cjs/index.d.ts:37
Parameters
- opts: MakeUniversalOpts
Returns Promise<void>

Index

Namespaces

Enumerations

Enumeration members

Classes

Interfaces

Type aliases

Functions

Enumeration members

DATA

ENABLED

MESSAGE

STATE

SUBTASK

TITLE

Type aliases

BaseSignOptions

CreateOptions

Type declaration

Optional dot?: boolean

Optional globOptions?: IOptions

Optional ordering?: string

Optional pattern?: string

Optional unpack?: string

Optional unpackDir?: string

transform?:function

Parameters

filePath: string

Returns void | ReadWriteStream

ElectronMacPlatform

ElectronProcess

FinalizePackageTargetsHookFunction

Type declaration

Parameters

targets: TargetDefinition[]

callback: HookFunctionErrorCallback

Returns void

ForgeConfigMaker

ForgeConfigPlugin

ForgeConfigPublisher

ForgeHookFn

Type parameters

Hook: ForgeHookName

ForgeHookMap

ForgeHookName

ForgeListrTaskDefinition

ForgeMultiHookMap

ForgeMutatingHookFn

Type parameters

Hook: keyof ForgeMutatingHookSignatures

Type declaration

Parameters

forgeConfig: ResolvedForgeConfig

Rest ...args: ForgeMutatingHookSignatures[Hook]

Returns Promise<ForgeMutatingHookSignatures[Hook][0] | undefined>

ForgePackagerOptions

ForgeRebuildOptions

ForgeSimpleHookFn

Type parameters

Hook: keyof ForgeSimpleHookSignatures

Type declaration

Parameters

forgeConfig: ResolvedForgeConfig

Rest ...args: ForgeSimpleHookSignatures[Hook]

Returns Promise<void>

HookFunction

Type declaration

Parameters

buildPath: string

electronVersion: string

platform: TargetArch

arch: TargetArch

callback: HookFunctionErrorCallback

Returns void

HookFunction

Type declaration

Parameters

fileToSign: string

Returns void | Promise<void>

HookFunctionErrorCallback