Options
All
  • Public
  • Public/Protected
  • All
Menu

Module InternalOptions

Index

Namespaces

Enumerations

Enumeration members

Classes

Interfaces

Type aliases

Variables

Functions

Enumeration members

DATA

DATA = "DATA"

ENABLED

ENABLED = "ENABLED"

MESSAGE

MESSAGE = "MESSAGE"

STATE

STATE = "STATE"

SUBTASK

SUBTASK = "SUBTASK"

TITLE

TITLE = "TITLE"

Type aliases

AcceptedPlugin

AcceptedPlugin: { postcss: Processor_ | TransformCallback } | OldPlugin<any> | Plugin | PluginCreator<any> | Processor_ | TransformCallback

AddonFunction

AddonFunction: (chunk: RenderedChunk) => string | Promise<string>

Type declaration

    • (chunk: RenderedChunk): string | Promise<string>

    • Parameters

      • chunk: RenderedChunk

      Returns string | Promise<string>

AddonHook

AddonHook: string | AddonHookFunction

AddonHookFunction

AddonHookFunction: (this: PluginContext, chunk: RenderedChunk) => string | Promise<string>

Type declaration

    • (this: PluginContext, chunk: RenderedChunk): string | Promise<string>

    • Parameters

      Returns string | Promise<string>

AddonHooks

AddonHooks: "banner" | "footer" | "intro" | "outro"

AliasOptions

AliasOptions: readonly Alias[] | {}

Specifies an Object, or an Array of Object, which defines aliases used to replace values in import or require statements. With either format, the order of the entries is important, in that the first defined rules are applied first.

This is passed to @rollup/plugin-alias as the "entries" field https://github.com/rollup/plugins/tree/master/packages/alias#entries

AmdOptions

AmdOptions: ({ autoId?: false; id: string } | { autoId: true; basePath?: string; id?: undefined } | { autoId?: false; id?: undefined }) & { define?: string; forceJsExtensionForImports?: boolean }

AnymatchFn

AnymatchFn: (testString: string) => boolean

Type declaration

    • (testString: string): boolean

    • Parameters

      • testString: string

      Returns boolean

AnymatchPattern

AnymatchPattern: string | RegExp | AnymatchFn

AppType

AppType: "spa" | "mpa" | "custom"

spa: include SPA fallback middleware and configure sirv with single: true in preview

mpa: only include non-SPA HTML middlewares

custom: don't include HTML middlewares

AsyncPluginHooks

AsyncPluginHooks: Exclude<keyof FunctionPluginHooks, SyncPluginHooks>

AtRuleProcessor

AtRuleProcessor: (atRule: AtRule_, helper: Helpers) => Promise<void> | void

Type declaration

AwaitedEventListener

AwaitedEventListener<T, K>: (...parameters: Parameters<T[K]>) => void | Promise<void>

Type parameters

  • T: {}

  • K: keyof T

Type declaration

    • (...parameters: Parameters<T[K]>): void | Promise<void>

    • Parameters

      • Rest ...parameters: Parameters<T[K]>

      Returns void | Promise<void>

BaseSignOptions

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

ChangeEvent

ChangeEvent: "create" | "update" | "delete"

Charset

Charset: "ascii" | "utf8"

ChildNode

ChildNode: AtRule_ | Comment_ | Declaration_ | Rule_

ChildProps

ChildProps: AtRuleProps | CommentProps | DeclarationProps | RuleProps

CommentProcessor

CommentProcessor: (comment: Comment_, helper: Helpers) => Promise<void> | void

Type declaration

CorsOrigin

CorsOrigin: boolean | string | RegExp | (string | RegExp)[]

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

    • Parameters

      • filePath: string

      Returns void | ReadWriteStream

DeclarationProcessor

DeclarationProcessor: (decl: Declaration_, helper: Helpers) => Promise<void> | void

Type declaration

DecodedSourceMapOrMissing

DecodedSourceMapOrMissing: { mappings?: never; missing: true; plugin: string } | ExistingDecodedSourceMap

DepOptimizationOptions

DepOptimizationOptions: DepOptimizationConfig & { entries?: string | string[]; force?: boolean }

DocumentProcessor

DocumentProcessor: (document: Document_, helper: Helpers) => Promise<void> | void

Type declaration

Drop

Drop: "console" | "debugger"

ECMA

ECMA: 5 | 2015 | 2016 | 2017 | 2018 | 2019 | 2020

ElectronMacPlatform

ElectronMacPlatform: "darwin" | "mas"

ElectronProcess

ElectronProcess: ChildProcess & { restarted: boolean }

EmitFile

EmitFile: (emittedFile: EmittedFile) => string

Type declaration

EmittedFile

EmittedFile: EmittedAsset | EmittedChunk

ErrorCallback

ErrorCallback: (err: Error, req: http.IncomingMessage, res: http.ServerResponse, target?: ProxyTargetUrl) => void

Type declaration

    • (err: Error, req: http.IncomingMessage, res: http.ServerResponse, target?: ProxyTargetUrl): void

    • Parameters

      • err: Error
      • req: http.IncomingMessage
      • res: http.ServerResponse
      • Optional target: ProxyTargetUrl

      Returns void

ErrorHandleFunction

ErrorHandleFunction: (err: any, req: IncomingMessage, res: http.ServerResponse, next: NextFunction) => void

Type declaration

ExportsData

ExportsData: { exports: readonly string[]; facade: boolean; hasImports: boolean; hasReExports?: boolean; jsxLoader?: boolean }

Type declaration

  • exports: readonly string[]
  • facade: boolean
  • hasImports: boolean
  • Optional hasReExports?: boolean
  • Optional jsxLoader?: boolean

ExternalOption

ExternalOption: (string | RegExp)[] | string | RegExp | ((source: string, importer: string | undefined, isResolved: boolean) => boolean | NullValue)

FinalizePackageTargetsHookFunction

FinalizePackageTargetsHookFunction: (targets: TargetDefinition[], callback: (err?: Error | null) => void) => void

Type declaration

    • Parameters

      • targets: TargetDefinition[]
      • callback: (err?: Error | null) => void
          • (err?: Error | null): void

          • Parameters

            • Optional err: Error | null

            Returns void

      Returns void

FirstPluginHooks

FirstPluginHooks: "load" | "renderDynamicImport" | "resolveDynamicImport" | "resolveFileUrl" | "resolveId" | "resolveImportMeta" | "shouldTransformCachedModule"

ForgeConfigMaker

ForgeConfigMaker: IForgeResolvableMaker | IForgeMaker

ForgeConfigPlugin

ForgeConfigPlugin: IForgeResolvablePlugin | IForgePlugin

ForgeConfigPublisher

ForgeConfigPublisher: IForgeResolvablePublisher | IForgePublisher

ForgeHookFn

ForgeHookFn<Hook>: Hook extends keyof ForgeSimpleHookSignatures ? ForgeSimpleHookFn<Hook> : Hook extends keyof ForgeMutatingHookSignatures ? ForgeMutatingHookFn<Hook> : never

Type parameters

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

Type declaration

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

Type declaration

Format

Format: "iife" | "cjs" | "esm"

GeneratedCodePreset

GeneratedCodePreset: "es5" | "es2015"

GetInterop

GetInterop: (id: string | null) => InteropType

Type declaration

GetManualChunk

GetManualChunk: (id: string, meta: ManualChunkMeta) => string | NullValue

Type declaration

GetModuleInfo

GetModuleInfo: (moduleId: string) => ModuleInfo | null

Type declaration

GlobalsOption

GlobalsOption: {} | ((name: string) => string)

HMRPayload

HMRPayload: ConnectedPayload | UpdatePayload | FullReloadPayload | CustomPayload | ErrorPayload | PrunePayload

HandleFunction

HandleFunction: SimpleHandleFunction | NextHandleFunction | ErrorHandleFunction

HasModuleSideEffects

HasModuleSideEffects: (id: string, external: boolean) => boolean

Type declaration

    • (id: string, external: boolean): boolean

    • Parameters

      • id: string
      • external: boolean

      Returns boolean

Helpers

Helpers: { postcss: Postcss; result: Result_ } & Postcss

HookFunction

HookFunction: (buildPath: string, electronVersion: string, platform: TargetArch, arch: TargetArch, callback: (err?: Error | null) => void) => void

Type declaration

    • (buildPath: string, electronVersion: string, platform: TargetArch, arch: TargetArch, callback: (err?: Error | null) => void): 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: (err?: Error | null) => void
          • (err?: Error | null): void

          • Parameters

            • Optional err: Error | null

            Returns void

      Returns void

HookHandler

HookHandler<T>: T extends ObjectHook<infer H> ? H : T

Type parameters

  • T

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

ImportKind

ImportKind: "entry-point" | "import-statement" | "require-call" | "dynamic-import" | "require-resolve" | "import-rule" | "url-token"

IndexHtmlTransform

IndexHtmlTransform: IndexHtmlTransformHook | { enforce?: "pre" | "post"; order?: "pre" | "post" | null; transform: IndexHtmlTransformHook } | { enforce?: "pre" | "post"; handler: IndexHtmlTransformHook; order?: "pre" | "post" | null }

IndexHtmlTransformHook

IndexHtmlTransformHook: (this: void, html: string, ctx: IndexHtmlTransformContext) => IndexHtmlTransformResult | void | Promise<IndexHtmlTransformResult | void>

Type declaration

IndexHtmlTransformResult

IndexHtmlTransformResult: string | HtmlTagDescriptor[] | { html: string; tags: HtmlTagDescriptor[] }

InferCustomEventPayload

InferCustomEventPayload<T>: T extends keyof CustomEventMap ? CustomEventMap[T] : any

Type parameters

  • T: string

InnerStartResult

InnerStartResult: ElectronProcess | string | string[] | false

InputOption

InputOption: string | string[] | {}

InputPluginOption

InputPluginOption: MaybePromise<Plugin | NullValue | false | InputPluginOption[]>

InternalModuleFormat

InternalModuleFormat: "amd" | "cjs" | "es" | "iife" | "system" | "umd"

InteropType

InteropType: "compat" | "auto" | "esModule" | "default" | "defaultOnly"

IsExternal

IsExternal: (source: string, importer: string | undefined, isResolved: boolean) => boolean

Type declaration

    • (source: string, importer: string | undefined, isResolved: boolean): boolean

    • Parameters

      • source: string
      • importer: string | undefined
      • isResolved: boolean

      Returns boolean

LibraryFormats

LibraryFormats: "es" | "cjs" | "umd" | "iife"

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

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

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

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

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

ListrTaskResult

ListrTaskResult<Ctx>: string | Promise<any> | Listr<Ctx, ListrRendererValue, any> | Readable | NodeJS.ReadableStream | Observable<any>

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

Type parameters

  • Ctx

LoadHook

LoadHook: (this: PluginContext, id: string) => LoadResult

Type declaration

LoadResult

LoadResult: SourceDescription | string | NullValue

Loader

Loader: "base64" | "binary" | "copy" | "css" | "dataurl" | "default" | "empty" | "file" | "js" | "json" | "jsx" | "text" | "ts" | "tsx"

LogLevel

LogLevel: LogType | "silent"

LogLevel

LogLevel: "verbose" | "debug" | "info" | "warning" | "error" | "silent"

LogType

LogType: "error" | "warn" | "info"

MakeAsync

MakeAsync<Function_>: Function_ extends (this: infer This, ...parameters: infer Arguments) => infer Return ? (this: This, ...parameters: Arguments) => Return | Promise<Return> : never

Type parameters

  • Function_

MakeUniversalOpts

MakeUniversalOpts: Parameters<typeof makeUniversalApp>[0]

MakeUniversalOpts

MakeUniversalOpts: { arm64AppPath: string; force: boolean; 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

  • force: boolean

    Forcefully overwrite any existing files that are in the way of generating the universal application

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

ManualChunksOption

ManualChunksOption: {} | GetManualChunk

Matcher

Matcher: AnymatchPattern | AnymatchPattern[]

MaybePromise

MaybePromise<T>: T | Promise<T>

Type parameters

  • T

ModuleFormat

ModuleFormat: InternalModuleFormat | "commonjs" | "esm" | "module" | "systemjs"

ModuleParsedHook

ModuleParsedHook: (this: PluginContext, info: ModuleInfo) => void

Type declaration

ModuleSideEffectsOption

ModuleSideEffectsOption: boolean | "no-external" | string[] | HasModuleSideEffects

ModuleType

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

NextFunction

NextFunction: (err?: any) => void

Type declaration

    • (err?: any): void

    • Parameters

      • Optional err: any

      Returns void

NextHandleFunction

NextHandleFunction: (req: IncomingMessage, res: http.ServerResponse, next: NextFunction) => void

Type declaration

NormalizedAmdOptions

NormalizedAmdOptions: ({ autoId: false; id?: string } | { autoId: true; basePath: string }) & { define: string; forceJsExtensionForImports: boolean }

NotaryToolCredentials

NotaryToolCredentials: NotaryToolPasswordCredentials | NotaryToolApiKeyCredentials | NotaryToolKeychainCredentials

NullValue

NullValue: null | undefined | void

ObjectHook

ObjectHook<T, O>: T | ({ handler: T; order?: "pre" | "post" | null } & O)

Type parameters

  • T

  • O = {}

OfficialArch

OfficialArch: "ia32" | "x64" | "armv7l" | "arm64" | "mips64el" | "universal"

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

    • Parameters

      • filePath: string

      Returns PerFileSignOptions

OptionsPaths

OptionsPaths: Record<string, string> | ((id: string) => string)

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.

OutputPluginHooks

OutputPluginHooks: "augmentChunkHash" | "generateBundle" | "outputOptions" | "renderChunk" | "renderDynamicImport" | "renderError" | "renderStart" | "resolveFileUrl" | "resolveImportMeta" | "writeBundle"

OutputPluginOption

OutputPluginOption: MaybePromise<OutputPlugin | NullValue | false | OutputPluginOption[]>

PackageCache

PackageCache: Map<string, PackageData>

Cache for package.json resolution and package.json contents

ParallelPluginHooks

ParallelPluginHooks: Exclude<keyof FunctionPluginHooks | AddonHooks, FirstPluginHooks | SequentialPluginHooks>

PartialNull

PartialNull<T>: { [ P in keyof T]: T[P] | null }

Type parameters

  • T

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.

  • Optional timestamp?: string

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

Platform

Platform: "browser" | "node" | "neutral"

PluginHooks

PluginHooks: { [ K in keyof FunctionPluginHooks]: ObjectHook<K extends AsyncPluginHooks ? MakeAsync<FunctionPluginHooks[K]> : FunctionPluginHooks[K], K extends ParallelPluginHooks ? { sequential?: boolean } : {}> }

PluginOption

PluginOption: Plugin_2 | false | null | undefined | PluginOption[] | Promise<Plugin_2 | false | null | undefined | PluginOption[]>

Postcss

Postcss: typeof postcss

PreserveEntrySignaturesOption

PreserveEntrySignaturesOption: false | "strict" | "allow-extension" | "exports-only"

PreviewServerHook

PreviewServerHook: (this: void, server: { httpServer: http.Server; middlewares: Server }) => (() => void) | void | Promise<(() => void) | void>

Type declaration

    • (this: void, server: { httpServer: http.Server; middlewares: Server }): (() => void) | void | Promise<(() => void) | void>

    • Parameters

      • this: void
      • server: { httpServer: http.Server; middlewares: Server }
        • httpServer: http.Server
        • middlewares: Server

      Returns (() => void) | void | Promise<(() => void) | void>

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

PromptOptions: BasePromptOptions | ArrayPromptOptions | BooleanPromptOptions | StringPromptOptions | NumberPromptOptions | SnippetPromptOptions | SortPromptOptions

PromptOptionsType

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

Type parameters

  • T

PromptTypes

PromptTypes: "AutoComplete" | "BasicAuth" | "Confirm" | "Editable" | "Form" | "Input" | "Invisible" | "List" | "MultiSelect" | "Numeral" | "Password" | "Quiz" | "Scale" | "Select" | "Snippet" | "Sort" | "Survey" | "Text" | "Toggle"

ProxyTarget

ProxyTarget: ProxyTargetUrl | ProxyTargetDetailed

ProxyTargetUrl

ProxyTargetUrl: string | Partial<url.Url>

RawData

RawData: Buffer | ArrayBuffer | Buffer[]

Data represents the raw message payload received over the WebSocket.

RebuildMode

RebuildMode: "sequential" | "parallel"

RenderBuiltAssetUrl

RenderBuiltAssetUrl: (filename: string, type: { hostId: string; hostType: "js" | "css" | "html"; ssr: boolean; type: "asset" | "public" }) => string | { relative?: boolean; runtime?: string } | undefined

Type declaration

    • (filename: string, type: { hostId: string; hostType: "js" | "css" | "html"; ssr: boolean; type: "asset" | "public" }): string | { relative?: boolean; runtime?: string } | undefined

    • Parameters

      • filename: string
      • type: { hostId: string; hostType: "js" | "css" | "html"; ssr: boolean; type: "asset" | "public" }
        • hostId: string
        • hostType: "js" | "css" | "html"
        • ssr: boolean
        • type: "asset" | "public"

      Returns string | { relative?: boolean; runtime?: string } | undefined

RenderChunkHook

RenderChunkHook: (this: PluginContext, code: string, chunk: RenderedChunk, options: NormalizedOutputOptions, meta: { chunks: Record<string, RenderedChunk> }) => { code: string; map?: SourceMapInput } | string | NullValue

Type declaration

ResolveDynamicImportHook

ResolveDynamicImportHook: (this: PluginContext, specifier: string | AcornNode, importer: string, options: { assertions: Record<string, string> }) => ResolveIdResult

Type declaration

ResolveFileUrlHook

ResolveFileUrlHook: (this: PluginContext, options: { chunkId: string; fileName: string; format: InternalModuleFormat; moduleId: string; referenceId: string; relativePath: string }) => string | NullValue

Type declaration

ResolveFn

ResolveFn: (id: string, importer?: string, aliasOnly?: boolean, ssr?: boolean) => Promise<string | undefined>

Type declaration

    • (id: string, importer?: string, aliasOnly?: boolean, ssr?: boolean): Promise<string | undefined>

    • Parameters

      • id: string
      • Optional importer: string
      • Optional aliasOnly: boolean
      • Optional ssr: boolean

      Returns Promise<string | undefined>

ResolveIdHook

ResolveIdHook: (this: PluginContext, source: string, importer: string | undefined, options: { assertions: Record<string, string>; custom?: CustomPluginOptions; isEntry: boolean }) => ResolveIdResult

Type declaration

ResolveIdResult

ResolveIdResult: string | NullValue | false | PartialResolvedId

ResolveImportMetaHook

ResolveImportMetaHook: (this: PluginContext, property: string | null, options: { chunkId: string; format: InternalModuleFormat; moduleId: string }) => string | NullValue

Type declaration

ResolveModulePreloadDependenciesFn

ResolveModulePreloadDependenciesFn: (filename: string, deps: string[], context: { hostId: string; hostType: "html" | "js" }) => string[]

Type declaration

    • (filename: string, deps: string[], context: { hostId: string; hostType: "html" | "js" }): string[]

    • Parameters

      • filename: string
      • deps: string[]
      • context: { hostId: string; hostType: "html" | "js" }
        • hostId: string
        • hostType: "html" | "js"

      Returns string[]

ResolvedUrl

ResolvedUrl: [url: string, resolvedId: string, meta: object | null | undefined]

RollupWarning

RollupWarning: RollupLog

RollupWatcher

RollupWatcher: AwaitingEventEmitter<{ change: any; close: any; event: any; restart: any }>

RollupWatcherEvent

RollupWatcherEvent: { code: "START" } | { code: "BUNDLE_START"; input?: InputOption; output: readonly string[] } | { code: "BUNDLE_END"; duration: number; input?: InputOption; output: readonly string[]; result: RollupBuild } | { code: "END" } | { code: "ERROR"; error: RollupError; result: RollupBuild | null }

RootProcessor

RootProcessor: (root: Root_, helper: Helpers) => Promise<void> | void

Type declaration

RuleProcessor

RuleProcessor: (rule: Rule_, helper: Helpers) => Promise<void> | void

Type declaration

SSRFormat

SSRFormat: "esm" | "cjs"

SSRTarget

SSRTarget: "node" | "webworker"

SequentialPluginHooks

SequentialPluginHooks: "augmentChunkHash" | "generateBundle" | "options" | "outputOptions" | "renderChunk" | "transform"

ServerHandle

ServerHandle: HandleFunction | http.Server

ServerHook

ServerHook: (this: void, server: ViteDevServer) => (() => void) | void | Promise<(() => void) | void>

Type declaration

    • (this: void, server: ViteDevServer): (() => void) | void | Promise<(() => void) | void>

    • Parameters

      Returns (() => void) | void | Promise<(() => void) | void>

ShouldTransformCachedModuleHook

ShouldTransformCachedModuleHook: (this: PluginContext, options: { ast: AcornNode; code: string; id: string; meta: CustomPluginOptions; moduleSideEffects: boolean | "no-treeshake"; resolvedSources: ResolvedIdMap; syntheticNamedExports: boolean | string }) => boolean

Type declaration

SignOptions

SignOptions: Readonly<OnlySignOptions & BaseSignOptions>

SigningDistributionType

SigningDistributionType: "development" | "distribution"

SimpleHandleFunction

SimpleHandleFunction: (req: IncomingMessage, res: http.ServerResponse) => void

Type declaration

SourceMap

SourceMap: SourceMapGenerator & { toJSON: any }

SourceMapInput

SourceMapInput: ExistingRawSourceMap | string | null | { mappings: "" }

SourceMapSegment

SourceMapSegment: [number] | [number, number, number, number] | [number, number, number, number, number]

SourcemapIgnoreListOption

SourcemapIgnoreListOption: (relativeSourcePath: string, sourcemapPath: string) => boolean

Type declaration

    • (relativeSourcePath: string, sourcemapPath: string): boolean

    • Parameters

      • relativeSourcePath: string
      • sourcemapPath: string

      Returns boolean

SourcemapPathTransformOption

SourcemapPathTransformOption: (relativeSourcePath: string, sourcemapPath: string) => string

Type declaration

    • (relativeSourcePath: string, sourcemapPath: string): string

    • Parameters

      • relativeSourcePath: string
      • sourcemapPath: string

      Returns string

StartResult

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

SyncPluginHooks

SyncPluginHooks: "augmentChunkHash" | "outputOptions" | "renderDynamicImport" | "resolveFileUrl" | "resolveImportMeta"

TargetArch

TargetArch: OfficialArch | string

TargetDefinition

TargetDefinition: { arch: TargetArch; platform: TargetPlatform }

Type declaration

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

TransformHook

TransformHook: (this: TransformPluginContext, code: string, id: string) => TransformResult

Type declaration

TransformResult

TransformResult: string | NullValue | Partial<SourceDescription>

TreeshakingPreset

TreeshakingPreset: "smallest" | "safest" | "recommended"

Unionize

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

Type parameters

  • T: Record<PropertyKey, unknown>

WarningHandler

WarningHandler: (warning: RollupWarning) => void

Type declaration

WarningHandlerWithDefault

WarningHandlerWithDefault: (warning: RollupWarning, defaultHandler: WarningHandler) => void

Type declaration

WatchChangeHook

WatchChangeHook: (this: PluginContext, id: string, change: { event: ChangeEvent }) => void

Type declaration

WebSocketCustomListener

WebSocketCustomListener<T>: (data: T, client: WebSocketClient) => void

Type parameters

  • T

Type declaration

Variables

Const WebSocket

WebSocket: typeof WebSocketAlias

Const WebSocketAlias

WebSocketAlias: typeof WebSocket_2

Functions

makeUniversalApp

  • Parameters

    Returns Promise<void>

postcss

  • Create a new Processor instance that will apply plugins as CSS processors.

    let postcss = require('postcss')

    postcss(plugins).process(css, { from, to }).then(result => {
      console.log(result.css)
    })

    Parameters

    Returns Processor_

    Processor to process multiple CSS.

  • Parameters

    Returns Processor_