vite
Version:
Native-ESM powered web dev build tool
1,613 lines (1,432 loc) • 83.9 kB
TypeScript
/// <reference types="node" />
import { BuildOptions as BuildOptions_2 } from 'esbuild';
import { ChangeEvent } from 'rollup';
import { CustomPluginOptions } from 'rollup';
import * as events from 'events';
import * as fs from 'fs';
import * as http from 'http';
import * as https from 'https';
import { IncomingMessage } from 'http';
import { InputOptions } from 'rollup';
import { LoadResult } from 'rollup';
import * as net from 'net';
import { OutputBundle } from 'rollup';
import { OutputChunk } from 'rollup';
import { PartialResolvedId } from 'rollup';
import { Plugin as Plugin_2 } from 'rollup';
import { PluginContext } from 'rollup';
import { PluginHooks } from 'rollup';
import * as Postcss from 'postcss';
import { RequestOptions } from 'http';
import { RequestOptions as RequestOptions_2 } from 'https';
import { ResolveIdResult } from 'rollup';
import { RollupOptions } from 'rollup';
import { RollupOutput } from 'rollup';
import { RollupWatcher } from 'rollup';
import { Server } from 'http';
import { ServerResponse } from 'http';
import { SourceDescription } from 'rollup';
import { SourceMap } from 'rollup';
import * as stream from 'stream';
import { TransformOptions as TransformOptions_2 } from 'esbuild';
import { TransformPluginContext } from 'rollup';
import { TransformResult as TransformResult_2 } from 'rollup';
import { TransformResult as TransformResult_3 } from 'esbuild';
import * as url from 'url';
import { WatcherOptions } from 'rollup';
export declare interface Alias {
find: string | RegExp
replacement: string
/**
* Instructs the plugin to use an alternative resolving algorithm,
* rather than the Rollup's resolver.
* @default null
*/
customResolver?: ResolverFunction | ResolverObject | null
}
/**
* 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
*/
export declare type AliasOptions = readonly Alias[] | { [find: string]: string }
/**
* Bundles the app for production.
* Returns a Promise containing the build result.
*/
export declare function build(inlineConfig?: InlineConfig): Promise<RollupOutput | RollupOutput[] | RollupWatcher>;
export declare interface BuildOptions {
/**
* Base public path when served in production.
* @deprecated `base` is now a root-level config option.
*/
base?: string;
/**
* Compatibility transform target. The transform is performed with esbuild
* and the lowest supported target is es2015/es6. Note this only handles
* syntax transformation and does not cover polyfills (except for dynamic
* import)
*
* Default: 'modules' - Similar to `@babel/preset-env`'s targets.esmodules,
* transpile targeting browsers that natively support dynamic es module imports.
* https://caniuse.com/es6-module-dynamic-import
*
* Another special value is 'esnext' - which only performs minimal transpiling
* (for minification compat) and assumes native dynamic imports support.
*
* For custom targets, see https://esbuild.github.io/api/#target and
* https://esbuild.github.io/content-types/#javascript for more details.
*/
target?: 'modules' | TransformOptions_2['target'] | false;
/**
* whether to inject dynamic import polyfill.
* Note: does not apply to library mode.
* @default false
*/
polyfillDynamicImport?: boolean;
/**
* Directory relative from `root` where build output will be placed. If the
* directory exists, it will be removed before the build.
* @default 'dist'
*/
outDir?: string;
/**
* Directory relative from `outDir` where the built js/css/image assets will
* be placed.
* @default 'assets'
*/
assetsDir?: string;
/**
* Static asset files smaller than this number (in bytes) will be inlined as
* base64 strings. Default limit is `4096` (4kb). Set to `0` to disable.
* @default 4096
*/
assetsInlineLimit?: number;
/**
* Whether to code-split CSS. When enabled, CSS in async chunks will be
* inlined as strings in the chunk and inserted via dynamically created
* style tags when the chunk is loaded.
* @default true
*/
cssCodeSplit?: boolean;
/**
* If `true`, a separate sourcemap file will be created. If 'inline', the
* sourcemap will be appended to the resulting output file as data URI.
* 'hidden' works like `true` except that the corresponding sourcemap
* comments in the bundled files are suppressed.
* @default false
*/
sourcemap?: boolean | 'inline' | 'hidden';
/**
* Set to `false` to disable minification, or specify the minifier to use.
* Available options are 'terser' or 'esbuild'.
* @default 'terser'
*/
minify?: boolean | 'terser' | 'esbuild';
/**
* Options for terser
* https://terser.org/docs/api-reference#minify-options
*/
terserOptions?: Terser.MinifyOptions;
/**
* Options for clean-css
* https://github.com/jakubpawlowicz/clean-css#constructor-options
*/
cleanCssOptions?: CleanCSS.Options;
/**
* Will be merged with internal rollup options.
* https://rollupjs.org/guide/en/#big-list-of-options
*/
rollupOptions?: RollupOptions;
/**
* Options to pass on to `@rollup/plugin-commonjs`
*/
commonjsOptions?: RollupCommonJSOptions;
/**
* Options to pass on to `@rollup/plugin-dynamic-import-vars`
*/
dynamicImportVarsOptions?: RollupDynamicImportVarsOptions;
/**
* Whether to write bundle to disk
* @default true
*/
write?: boolean;
/**
* Empty outDir on write.
* @default true when outDir is a sub directory of project root
*/
emptyOutDir?: boolean | null;
/**
* Whether to emit a manifest.json under assets dir to map hash-less filenames
* to their hashed versions. Useful when you want to generate your own HTML
* instead of using the one generated by Vite.
*
* Example:
*
* ```json
* {
* "main.js": {
* "file": "main.68fe3fad.js",
* "css": "main.e6b63442.css",
* "imports": [...],
* "dynamicImports": [...]
* }
* }
* ```
* @default false
*/
manifest?: boolean;
/**
* Build in library mode. The value should be the global name of the lib in
* UMD mode. This will produce esm + cjs + umd bundle formats with default
* configurations that are suitable for distributing libraries.
*/
lib?: LibraryOptions | false;
/**
* Produce SSR oriented build. Note this requires specifying SSR entry via
* `rollupOptions.input`.
*/
ssr?: boolean | string;
/**
* Generate SSR manifest for determining style links and asset preload
* directives in production.
*/
ssrManifest?: boolean;
/**
* Set to false to disable brotli compressed size reporting for build.
* Can slightly improve build speed.
*/
brotliSize?: boolean;
/**
* Adjust chunk size warning limit (in kbs).
* @default 500
*/
chunkSizeWarningLimit?: number;
/**
* Rollup watch options
* https://rollupjs.org/guide/en/#watchoptions
*/
watch?: WatcherOptions | null;
}
export declare namespace CleanCSS {
/**
* Shared options passed when initializing a new instance of CleanCSS that returns either a promise or output
*/
export interface OptionsBase {
/**
* Controls compatibility mode used; defaults to ie10+ using `'*'`.
* Compatibility hash exposes the following properties: `colors`, `properties`, `selectors`, and `units`
*/
compatibility?: '*' | 'ie9' | 'ie8' | 'ie7' | CompatibilityOptions
/**
* Controls a function for handling remote requests; Defaults to the build in `loadRemoteResource` function
*/
fetch?: (
uri: string,
inlineRequest: RequestOptions | RequestOptions_2,
inlineTimeout: number,
done: (message: string | number, body: string) => void
) => void
/**
* Controls output CSS formatting; defaults to `false`.
* Format hash exposes the following properties: `breaks`, `breakWith`, `indentBy`, `indentWith`, `spaces`, and `wrapAt`.
*/
format?: 'beautify' | 'keep-breaks' | FormatOptions | false
/**
* inline option whitelists which @import rules will be processed. Defaults to `'local'`
* Accepts the following values:
* 'local': enables local inlining;
* 'remote': enables remote inlining;
* 'none': disables all inlining;
* 'all': enables all inlining, same as ['local', 'remote'];
* '[uri]': enables remote inlining from the specified uri;
* '![url]': disables remote inlining from the specified uri;
*/
inline?: ReadonlyArray<string> | false
/**
* Controls extra options for inlining remote @import rules
*/
inlineRequest?: RequestOptions | RequestOptions_2
/**
* Controls number of milliseconds after which inlining a remote @import fails; defaults to `5000`;
*/
inlineTimeout?: number
/**
* Controls optimization level used; defaults to `1`.
* Level hash exposes `1`, and `2`.
*/
level?: 0 | 1 | 2 | OptimizationsOptions
/**
* Controls URL rebasing; defaults to `true`;
*/
rebase?: boolean
/**
* controls a directory to which all URLs are rebased, most likely the directory under which the output file
* will live; defaults to the current directory;
*/
rebaseTo?: string
/**
* Controls whether an output source map is built; defaults to `false`
*/
sourceMap?: boolean
/**
* Controls embedding sources inside a source map's `sourcesContent` field; defaults to `false`
*/
sourceMapInlineSources?: boolean
}
/**
* Fine grained configuration for compatibility option
*/
export interface CompatibilityOptions {
/**
* A hash of compatibility options related to color
*/
colors?: {
/**
* Controls `rgba()` / `hsla()` color support; defaults to `true`
*/
opacity?: boolean
}
/**
* A hash of properties that can be set with compatibility
*/
properties?: {
/**
* Controls background-clip merging into shorthand; defaults to `true`
*/
backgroundClipMerging?: boolean
/**
* Controls background-origin merging into shorthand; defaults to `true`
*/
backgroundOriginMerging?: boolean
/**
* Controls background-size merging into shorthand; defaults to `true`
*/
backgroundSizeMerging?: boolean
/**
* controls color optimizations; defaults to `true`
*/
colors?: boolean
/**
* Controls keeping IE bang hack; defaults to `false`
*/
ieBangHack?: boolean
/**
* Controls keeping IE `filter` / `-ms-filter`; defaults to `false`
*/
ieFilters?: boolean
/**
* Controls keeping IE prefix hack; defaults to `false`
*/
iePrefixHack?: boolean
/**
* Controls keeping IE suffix hack; defaults to `false`
*/
ieSuffixHack?: boolean
/**
* Controls property merging based on understandably; defaults to `true`
*/
merging?: boolean
/**
* Controls shortening pixel units into `pc`, `pt`, or `in` units; defaults to `false`
*/
shorterLengthUnits?: false
/**
* Controls keeping space after closing brace - `url() no-repeat` into `url()no-repeat`; defaults to `true`
*/
spaceAfterClosingBrace?: true
/**
* Controls keeping quoting inside `url()`; defaults to `false`
*/
urlQuotes?: boolean
/**
* Controls removal of units `0` value; defaults to `true`
*/
zeroUnits?: boolean
}
/**
* A hash of options related to compatibility of selectors
*/
selectors?: {
/**
* Controls extra space before `nav` element; defaults to `false`
*/
adjacentSpace?: boolean
/**
* Controls removal of IE7 selector hacks, e.g. `*+html...`; defaults to `true`
*/
ie7Hack?: boolean
/**
* Controls a whitelist of mergeable pseudo classes; defaults to `[':active', ...]`
*/
mergeablePseudoClasses?: ReadonlyArray<string>
/**
* Controls a whitelist of mergeable pseudo elements; defaults to `['::after', ...]`
*/
mergeablePseudoElements: ReadonlyArray<string>
/**
* Controls maximum number of selectors in a single rule (since 4.1.0); defaults to `8191`
*/
mergeLimit: number
/**
* Controls merging of rules with multiple pseudo classes / elements (since 4.1.0); defaults to `true`
*/
multiplePseudoMerging: boolean
}
/**
* A hash of options related to comparability of supported units
*/
units?: {
/**
* Controls treating `ch` as a supported unit; defaults to `true`
*/
ch?: boolean
/**
* Controls treating `in` as a supported unit; defaults to `true`
*/
in?: boolean
/**
* Controls treating `pc` as a supported unit; defaults to `true`
*/
pc?: boolean
/**
* Controls treating `pt` as a supported unit; defaults to `true`
*/
pt?: boolean
/**
* Controls treating `rem` as a supported unit; defaults to `true`
*/
rem?: boolean
/**
* Controls treating `vh` as a supported unit; defaults to `true`
*/
vh?: boolean
/**
* Controls treating `vm` as a supported unit; defaults to `true`
*/
vm?: boolean
/**
* Controls treating `vmax` as a supported unit; defaults to `true`
*/
vmax?: boolean
/**
* Controls treating `vmin` as a supported unit; defaults to `true`
*/
vmin?: boolean
}
}
/**
* Fine grained options for configuring the CSS formatting
*/
export interface FormatOptions {
/**
* Controls where to insert breaks
*/
breaks?: {
/**
* Controls if a line break comes after an at-rule; e.g. `@charset`; defaults to `false`
*/
afterAtRule?: boolean
/**
* Controls if a line break comes after a block begins; e.g. `@media`; defaults to `false`
*/
afterBlockBegins?: boolean
/**
* Controls if a line break comes after a block ends, defaults to `false`
*/
afterBlockEnds?: boolean
/**
* Controls if a line break comes after a comment; defaults to `false`
*/
afterComment?: boolean
/**
* Controls if a line break comes after a property; defaults to `false`
*/
afterProperty?: boolean
/**
* Controls if a line break comes after a rule begins; defaults to `false`
*/
afterRuleBegins?: boolean
/**
* Controls if a line break comes after a rule ends; defaults to `false`
*/
afterRuleEnds?: boolean
/**
* Controls if a line break comes before a block ends; defaults to `false`
*/
beforeBlockEnds?: boolean
/**
* Controls if a line break comes between selectors; defaults to `false`
*/
betweenSelectors?: boolean
}
/**
* Controls the new line character, can be `'\r\n'` or `'\n'`(aliased as `'windows'` and `'unix'`
* or `'crlf'` and `'lf'`); defaults to system one, so former on Windows and latter on Unix
*/
breakWith?: string
/**
* Controls number of characters to indent with; defaults to `0`
*/
indentBy?: number
/**
* Controls a character to indent with, can be `'space'` or `'tab'`; defaults to `'space'`
*/
indentWith?: 'space' | 'tab'
/**
* Controls where to insert spaces
*/
spaces?: {
/**
* Controls if spaces come around selector relations; e.g. `div > a`; defaults to `false`
*/
aroundSelectorRelation?: boolean
/**
* Controls if a space comes before a block begins; e.g. `.block {`; defaults to `false`
*/
beforeBlockBegins?: boolean
/**
* Controls if a space comes before a value; e.g. `width: 1rem`; defaults to `false`
*/
beforeValue?: boolean
}
/**
* Controls maximum line length; defaults to `false`
*/
wrapAt?: false | number
/**
* Controls removing trailing semicolons in rule; defaults to `false` - means remove
*/
semicolonAfterLastProperty?: boolean
}
/**
* Fine grained options for configuring optimizations
*/
export interface OptimizationsOptions {
1?: {
/**
* Sets all optimizations at this level unless otherwise specified
*/
all?: boolean
/**
* Controls `@charset` moving to the front of a stylesheet; defaults to `true`
*/
cleanupCharsets?: boolean
/**
* Controls URL normalization; defaults to `true`
*/
normalizeUrls?: boolean
/**
* Controls `background` property optimizations; defaults to `true`
*/
optimizeBackground?: boolean
/**
* Controls `border-radius` property optimizations; defaults to `true`
*/
optimizeBorderRadius?: boolean
/**
* Controls `filter` property optimizations; defaults to `true`
*/
optimizeFilter?: boolean
/**
* Controls `font` property optimizations; defaults to `true`
*/
optimizeFont?: boolean
/**
* Controls `font-weight` property optimizations; defaults to `true`
*/
optimizeFontWeight?: boolean
/**
* Controls `outline` property optimizations; defaults to `true`
*/
optimizeOutline?: boolean
/**
* Controls removing empty rules and nested blocks; defaults to `true`
*/
removeEmpty?: boolean
/**
* Controls removing negative paddings; defaults to `true`
*/
removeNegativePaddings?: boolean
/**
* Controls removing quotes when unnecessary; defaults to `true`
*/
removeQuotes?: boolean
/**
* Controls removing unused whitespace; defaults to `true`
*/
removeWhitespace?: boolean
/**
* Contols removing redundant zeros; defaults to `true`
*/
replaceMultipleZeros?: boolean
/**
* Controls replacing time units with shorter values; defaults to `true`
*/
replaceTimeUnits?: boolean
/**
* Controls replacing zero values with units; defaults to `true`
*/
replaceZeroUnits?: boolean
/**
* Rounds pixel values to `N` decimal places; `false` disables rounding; defaults to `false`
*/
roundingPrecision?: boolean
/**
* denotes selector sorting method; can be `'natural'` or `'standard'`, `'none'`, or false (the last two
* since 4.1.0); defaults to `'standard'`
*/
selectorsSortingMethod?: 'standard' | 'natural' | 'none'
/**
* denotes a number of /*! ... * / comments preserved; defaults to `all`
*/
specialComments?: 'all' | '1' | 1 | '0' | 0
/**
* Controls at-rules (e.g. `@charset`, `@import`) optimizing; defaults to `true`
*/
tidyAtRules?: boolean
/**
* Controls block scopes (e.g. `@media`) optimizing; defaults to `true`
*/
tidyBlockScopes?: boolean
/**
* Controls selectors optimizing; defaults to `true`
*/
tidySelectors?: boolean
/**
* Defines a callback for fine-grained property optimization; defaults to no-op
*/
transform?: (
propertyName: string,
propertyValue: string,
selector?: string
) => string
}
2?: {
/**
* Sets all optimizations at this level unless otherwise specified
*/
all?: boolean
/**
* Controls adjacent rules merging; defaults to true
*/
mergeAdjacentRules?: boolean
/**
* Controls merging properties into shorthands; defaults to true
*/
mergeIntoShorthands?: boolean
/**
* Controls `@media` merging; defaults to true
*/
mergeMedia?: boolean
/**
* Controls non-adjacent rule merging; defaults to true
*/
mergeNonAdjacentRules?: boolean
/**
* Controls semantic merging; defaults to false
*/
mergeSemantically?: boolean
/**
* Controls property overriding based on understandably; defaults to true
*/
overrideProperties?: boolean
/**
* Controls removing empty rules and nested blocks; defaults to `true`
*/
removeEmpty?: boolean
/**
* Controls non-adjacent rule reducing; defaults to true
*/
reduceNonAdjacentRules?: boolean
/**
* Controls duplicate `@font-face` removing; defaults to true
*/
removeDuplicateFontRules?: boolean
/**
* Controls duplicate `@media` removing; defaults to true
*/
removeDuplicateMediaBlocks?: boolean
/**
* Controls duplicate rules removing; defaults to true
*/
removeDuplicateRules?: boolean
/**
* Controls unused at rule removing; defaults to false (available since 4.1.0)
*/
removeUnusedAtRules?: boolean
/**
* Controls rule restructuring; defaults to false
*/
restructureRules?: boolean
/**
* Controls which properties won't be optimized, defaults to `[]` which means all will be optimized (since 4.1.0)
*/
skipProperties?: ReadonlyArray<string>
}
}
/**
* Options when returning a promise
*/
export type OptionsPromise = OptionsBase & {
/**
* If you prefer clean-css to return a Promise object then you need to explicitly ask for it; defaults to `false`
*/
returnPromise: true
}
/**
* Options when returning an output
*/
export type OptionsOutput = OptionsBase & {
/**
* If you prefer clean-css to return a Promise object then you need to explicitly ask for it; defaults to `false`
*/
returnPromise?: false
}
/**
* Discriminant union of both sets of options types. If you initialize without setting `returnPromise: true`
* and want to return a promise, you will need to cast to the correct options type so that TypeScript
* knows what the expected return type will be:
* `(options = options as CleanCSS.OptionsPromise).returnPromise = true`
*/
export type Options = OptionsPromise | OptionsOutput
}
export declare interface ConfigEnv {
command: 'build' | 'serve';
mode: string;
}
export declare namespace Connect {
export type ServerHandle = HandleFunction | http.Server
export class IncomingMessage extends http.IncomingMessage {
originalUrl?: http.IncomingMessage['url']
}
export type NextFunction = (err?: any) => void
export type SimpleHandleFunction = (
req: IncomingMessage,
res: http.ServerResponse
) => void
export type NextHandleFunction = (
req: IncomingMessage,
res: http.ServerResponse,
next: NextFunction
) => void
export type ErrorHandleFunction = (
err: any,
req: IncomingMessage,
res: http.ServerResponse,
next: NextFunction
) => void
export type HandleFunction =
| SimpleHandleFunction
| NextHandleFunction
| ErrorHandleFunction
export interface ServerStackItem {
route: string
handle: ServerHandle
}
export interface Server extends NodeJS.EventEmitter {
(req: http.IncomingMessage, res: http.ServerResponse, next?: Function): void
route: string
stack: ServerStackItem[]
/**
* Utilize the given middleware `handle` to the given `route`,
* defaulting to _/_. This "route" is the mount-point for the
* middleware, when given a value other than _/_ the middleware
* is only effective when that segment is present in the request's
* pathname.
*
* For example if we were to mount a function at _/admin_, it would
* be invoked on _/admin_, and _/admin/settings_, however it would
* not be invoked for _/_, or _/posts_.
*/
use(fn: NextHandleFunction): Server
use(fn: HandleFunction): Server
use(route: string, fn: NextHandleFunction): Server
use(route: string, fn: HandleFunction): Server
/**
* Handle server requests, punting them down
* the middleware stack.
*/
handle(
req: http.IncomingMessage,
res: http.ServerResponse,
next: Function
): void
/**
* Listen for connections.
*
* This method takes the same arguments
* as node's `http.Server#listen()`.
*
* HTTP and HTTPS:
*
* If you run your application both as HTTP
* and HTTPS you may wrap them individually,
* since your Connect "server" is really just
* a JavaScript `Function`.
*
* var connect = require('connect')
* , http = require('http')
* , https = require('https');
*
* var app = connect();
*
* http.createServer(app).listen(80);
* https.createServer(options, app).listen(443);
*/
listen(
port: number,
hostname?: string,
backlog?: number,
callback?: Function
): http.Server
listen(port: number, hostname?: string, callback?: Function): http.Server
listen(path: string, callback?: Function): http.Server
listen(handle: any, listeningListener?: Function): http.Server
}
}
export declare interface ConnectedPayload {
type: 'connected'
}
/**
* https://github.com/expressjs/cors#configuration-options
*/
export declare interface CorsOptions {
origin?: CorsOrigin | ((origin: string, cb: (err: Error, origins: CorsOrigin) => void) => void);
methods?: string | string[];
allowedHeaders?: string | string[];
exposedHeaders?: string | string[];
credentials?: boolean;
maxAge?: number;
preflightContinue?: boolean;
optionsSuccessStatus?: number;
}
export declare type CorsOrigin = boolean | string | RegExp | (string | RegExp)[];
export declare function createLogger(level?: LogLevel, options?: LoggerOptions): Logger;
export declare function createServer(inlineConfig?: InlineConfig): Promise<ViteDevServer>;
export declare interface CSSModulesOptions {
getJSON?: (cssFileName: string, json: Record<string, string>, outputFileName: string) => void;
scopeBehaviour?: 'global' | 'local';
globalModulePaths?: RegExp[];
generateScopedName?: string | ((name: string, filename: string, css: string) => string);
hashPrefix?: string;
/**
* default: null
*/
localsConvention?: 'camelCase' | 'camelCaseOnly' | 'dashes' | 'dashesOnly' | null;
}
export declare interface CSSOptions {
/**
* https://github.com/css-modules/postcss-modules
*/
modules?: CSSModulesOptions | false;
preprocessorOptions?: Record<string, any>;
postcss?: string | (Postcss.ProcessOptions & {
plugins?: Postcss.Plugin[];
});
}
export declare interface CustomPayload {
type: 'custom'
event: string
data?: any
}
/**
* Type helper to make it easier to use vite.config.ts
* accepts a direct {@link UserConfig} object, or a function that returns it.
* The function receives a {@link ConfigEnv} object that exposes two properties:
* `command` (either `'build'` or `'serve'`), and `mode`.
*/
export declare function defineConfig(config: UserConfigExport): UserConfigExport;
export declare interface DepOptimizationMetadata {
/**
* The main hash is determined by user config and dependency lockfiles.
* This is checked on server startup to avoid unnecessary re-bundles.
*/
hash: string;
/**
* The browser hash is determined by the main hash plus additional dependencies
* discovered at runtime. This is used to invalidate browser requests to
* optimized deps.
*/
browserHash: string;
optimized: Record<string, {
file: string;
src: string;
needsInterop: boolean;
}>;
}
export declare interface DepOptimizationOptions {
/**
* By default, Vite will crawl your index.html to detect dependencies that
* need to be pre-bundled. If build.rollupOptions.input is specified, Vite
* will crawl those entry points instead.
*
* If neither of these fit your needs, you can specify custom entries using
* this option - the value should be a fast-glob pattern or array of patterns
* (https://github.com/mrmlnc/fast-glob#basic-syntax) that are relative from
* vite project root. This will overwrite default entries inference.
*/
entries?: string | string[];
/**
* Force optimize listed dependencies (must be resolvable import paths,
* cannot be globs).
*/
include?: string[];
/**
* Do not optimize these dependencies (must be resolvable import paths,
* cannot be globs).
*/
exclude?: string[];
/**
* Options to pass to esbuild during the dep scanning and optimization
*
* Certain options are omitted since changing them would not be compatible
* with Vite's dep optimization.
*
* - `external` is also omitted, use Vite's `optimizeDeps.exclude` option
* - `plugins` are merged with Vite's dep plugin
* - `keepNames` takes precedence over the deprecated `optimizeDeps.keepNames`
*
* https://esbuild.github.io/api
*/
esbuildOptions?: Omit<BuildOptions_2, 'bundle' | 'entryPoints' | 'external' | 'write' | 'watch' | 'outdir' | 'outfile' | 'outbase' | 'outExtension' | 'metafile'>;
/**
* @deprecated use `esbuildOptions.keepNames`
*/
keepNames?: boolean;
}
export declare interface ErrorPayload {
type: 'error'
err: {
[name: string]: any
message: string
stack: string
id?: string
frame?: string
plugin?: string
pluginCode?: string
loc?: {
file?: string
line: number
column: number
}
}
}
export declare interface ESBuildOptions extends TransformOptions_2 {
include?: string | RegExp | string[] | RegExp[];
exclude?: string | RegExp | string[] | RegExp[];
jsxInject?: string;
}
export declare type ESBuildTransformResult = Omit<TransformResult_3, 'map'> & {
map: SourceMap;
};
export declare interface FileSystemServeOptions {
/**
* Strictly restrict file accessing outside of allowing paths.
*
* Set to `false` to disable the warning
* Default to false at this moment, will enabled by default in the future versions.
*
* @expiremental
* @default undefined
*/
strict?: boolean | undefined;
/**
* Restrict accessing files outside the allowed directories.
*
* Accepts absolute path or a path relative to project root.
* Will try to search up for workspace root by default.
*
* @expiremental
*/
allow?: string[];
}
export declare interface FSWatcher extends fs.FSWatcher {
options: WatchOptions
/**
* Constructs a new FSWatcher instance with optional WatchOptions parameter.
*/
(options?: WatchOptions): void
/**
* Add files, directories, or glob patterns for tracking. Takes an array of strings or just one
* string.
*/
add(paths: string | ReadonlyArray<string>): void
/**
* Stop watching files, directories, or glob patterns. Takes an array of strings or just one
* string.
*/
unwatch(paths: string | ReadonlyArray<string>): void
/**
* Returns an object representing all the paths on the file system being watched by this
* `FSWatcher` instance. The object's keys are all the directories (using absolute paths unless
* the `cwd` option was used), and the values are arrays of the names of the items contained in
* each directory.
*/
getWatched(): {
[directory: string]: string[]
}
/**
* Removes all listeners from watched files.
*/
close(): Promise<void>
on(
event: 'add' | 'addDir' | 'change',
listener: (path: string, stats?: fs.Stats) => void
): this
on(
event: 'all',
listener: (
eventName: 'add' | 'addDir' | 'change' | 'unlink' | 'unlinkDir',
path: string,
stats?: fs.Stats
) => void
): this
/**
* Error occurred
*/
on(event: 'error', listener: (error: Error) => void): this
/**
* Exposes the native Node `fs.FSWatcher events`
*/
on(
event: 'raw',
listener: (eventName: string, path: string, details: any) => void
): this
/**
* Fires when the initial scan is complete
*/
on(event: 'ready', listener: () => void): this
on(event: 'unlink' | 'unlinkDir', listener: (path: string) => void): this
on(event: string, listener: (...args: any[]) => void): this
}
export declare interface FullReloadPayload {
type: 'full-reload'
path?: string
}
export declare interface HmrContext {
file: string;
timestamp: number;
modules: Array<ModuleNode>;
read: () => string | Promise<string>;
server: ViteDevServer;
}
export declare interface HmrOptions {
protocol?: string;
host?: string;
port?: number;
clientPort?: number;
path?: string;
timeout?: number;
overlay?: boolean;
server?: Server;
}
export declare type HMRPayload =
| ConnectedPayload
| UpdatePayload
| FullReloadPayload
| CustomPayload
| ErrorPayload
| PrunePayload
export declare interface HtmlTagDescriptor {
tag: string;
attrs?: Record<string, string | boolean | undefined>;
children?: string | HtmlTagDescriptor[];
/**
* default: 'head-prepend'
*/
injectTo?: 'head' | 'body' | 'head-prepend' | 'body-prepend';
}
export declare namespace HttpProxy {
export type ProxyTarget = ProxyTargetUrl | ProxyTargetDetailed
export type ProxyTargetUrl = string | Partial<url.Url>
export interface ProxyTargetDetailed {
host: string
port: number
protocol?: string
hostname?: string
socketPath?: string
key?: string
passphrase?: string
pfx?: Buffer | string
cert?: string
ca?: string
ciphers?: string
secureProtocol?: string
}
export type ErrorCallback = (
err: Error,
req: http.IncomingMessage,
res: http.ServerResponse,
target?: ProxyTargetUrl
) => void
export class Server extends events.EventEmitter {
/**
* Creates the proxy server with specified options.
* @param options - Config object passed to the proxy
*/
constructor(options?: ServerOptions)
/**
* Used for proxying regular HTTP(S) requests
* @param req - Client request.
* @param res - Client response.
* @param options - Additionnal options.
*/
web(
req: http.IncomingMessage,
res: http.ServerResponse,
options?: ServerOptions,
callback?: ErrorCallback
): void
/**
* Used for proxying regular HTTP(S) requests
* @param req - Client request.
* @param socket - Client socket.
* @param head - Client head.
* @param options - Additionnal options.
*/
ws(
req: http.IncomingMessage,
socket: any,
head: any,
options?: ServerOptions,
callback?: ErrorCallback
): void
/**
* A function that wraps the object in a webserver, for your convenience
* @param port - Port to listen on
*/
listen(port: number): Server
/**
* A function that closes the inner webserver and stops listening on given port
*/
close(callback?: () => void): void
/**
* Creates the proxy server with specified options.
* @param options - Config object passed to the proxy
* @returns Proxy object with handlers for `ws` and `web` requests
*/
static createProxyServer(options?: ServerOptions): Server
/**
* Creates the proxy server with specified options.
* @param options - Config object passed to the proxy
* @returns Proxy object with handlers for `ws` and `web` requests
*/
static createServer(options?: ServerOptions): Server
/**
* Creates the proxy server with specified options.
* @param options - Config object passed to the proxy
* @returns Proxy object with handlers for `ws` and `web` requests
*/
static createProxy(options?: ServerOptions): Server
addListener(event: string, listener: () => void): this
on(event: string, listener: () => void): this
on(event: 'error', listener: ErrorCallback): this
on(
event: 'start',
listener: (
req: http.IncomingMessage,
res: http.ServerResponse,
target: ProxyTargetUrl
) => void
): this
on(
event: 'proxyReq',
listener: (
proxyReq: http.ClientRequest,
req: http.IncomingMessage,
res: http.ServerResponse,
options: ServerOptions
) => void
): this
on(
event: 'proxyRes',
listener: (
proxyRes: http.IncomingMessage,
req: http.IncomingMessage,
res: http.ServerResponse
) => void
): this
on(
event: 'proxyReqWs',
listener: (
proxyReq: http.ClientRequest,
req: http.IncomingMessage,
socket: net.Socket,
options: ServerOptions,
head: any
) => void
): this
on(
event: 'econnreset',
listener: (
err: Error,
req: http.IncomingMessage,
res: http.ServerResponse,
target: ProxyTargetUrl
) => void
): this
on(
event: 'end',
listener: (
req: http.IncomingMessage,
res: http.ServerResponse,
proxyRes: http.IncomingMessage
) => void
): this
on(
event: 'close',
listener: (
proxyRes: http.IncomingMessage,
proxySocket: net.Socket,
proxyHead: any
) => void
): this
once(event: string, listener: () => void): this
removeListener(event: string, listener: () => void): this
removeAllListeners(event?: string): this
getMaxListeners(): number
setMaxListeners(n: number): this
listeners(event: string): Array<() => void>
emit(event: string, ...args: any[]): boolean
listenerCount(type: string): number
}
export interface ServerOptions {
/** URL string to be parsed with the url module. */
target?: ProxyTarget
/** URL string to be parsed with the url module. */
forward?: ProxyTargetUrl
/** Object to be passed to http(s).request. */
agent?: any
/** Object to be passed to https.createServer(). */
ssl?: any
/** If you want to proxy websockets. */
ws?: boolean
/** Adds x- forward headers. */
xfwd?: boolean
/** Verify SSL certificate. */
secure?: boolean
/** Explicitly specify if we are proxying to another proxy. */
toProxy?: boolean
/** Specify whether you want to prepend the target's path to the proxy path. */
prependPath?: boolean
/** Specify whether you want to ignore the proxy path of the incoming request. */
ignorePath?: boolean
/** Local interface string to bind for outgoing connections. */
localAddress?: string
/** Changes the origin of the host header to the target URL. */
changeOrigin?: boolean
/** specify whether you want to keep letter case of response header key */
preserveHeaderKeyCase?: boolean
/** Basic authentication i.e. 'user:password' to compute an Authorization header. */
auth?: string
/** Rewrites the location hostname on (301 / 302 / 307 / 308) redirects, Default: null. */
hostRewrite?: string
/** Rewrites the location host/ port on (301 / 302 / 307 / 308) redirects based on requested host/ port.Default: false. */
autoRewrite?: boolean
/** Rewrites the location protocol on (301 / 302 / 307 / 308) redirects to 'http' or 'https'.Default: null. */
protocolRewrite?: string
/** rewrites domain of set-cookie headers. */
cookieDomainRewrite?: false | string | { [oldDomain: string]: string }
/** rewrites path of set-cookie headers. Default: false */
cookiePathRewrite?: false | string | { [oldPath: string]: string }
/** object with extra headers to be added to target requests. */
headers?: { [header: string]: string }
/** Timeout (in milliseconds) when proxy receives no response from target. Default: 120000 (2 minutes) */
proxyTimeout?: number
/** Timeout (in milliseconds) for incoming requests */
timeout?: number
/** Specify whether you want to follow redirects. Default: false */
followRedirects?: boolean
/** If set to true, none of the webOutgoing passes are called and it's your responsibility to appropriately return the response by listening and acting on the proxyRes event */
selfHandleResponse?: boolean
/** Buffer */
buffer?: stream.Stream
}
}
export declare type IndexHtmlTransform = IndexHtmlTransformHook | {
enforce?: 'pre' | 'post';
transform: IndexHtmlTransformHook;
};
export declare interface IndexHtmlTransformContext {
/**
* public path when served
*/
path: string;
/**
* filename on disk
*/
filename: string;
server?: ViteDevServer;
bundle?: OutputBundle;
chunk?: OutputChunk;
originalUrl?: string;
}
export declare type IndexHtmlTransformHook = (html: string, ctx: IndexHtmlTransformContext) => IndexHtmlTransformResult | void | Promise<IndexHtmlTransformResult | void>;
export declare type IndexHtmlTransformResult = string | HtmlTagDescriptor[] | {
html: string;
tags: HtmlTagDescriptor[];
};
export declare interface InlineConfig extends UserConfig {
configFile?: string | false;
envFile?: false;
}
export declare interface InternalResolveOptions extends ResolveOptions {
root: string;
isBuild: boolean;
isProduction: boolean;
ssrTarget?: SSRTarget;
/**
* src code mode also attempts the following:
* - resolving /xxx as URLs
* - resolving bare imports from optimized deps
*/
asSrc?: boolean;
tryIndex?: boolean;
tryPrefix?: string;
preferRelative?: boolean;
isRequire?: boolean;
}
export declare interface JsonOptions {
/**
* Generate a named export for every property of the JSON object
* @default true
*/
namedExports?: boolean;
/**
* Generate performant output as JSON.parse("stringified").
* Enabling this will disable namedExports.
* @default false
*/
stringify?: boolean;
}
export declare type LibraryFormats = 'es' | 'cjs' | 'umd' | 'iife';
export declare interface LibraryOptions {
entry: string;
name?: string;
formats?: LibraryFormats[];
fileName?: string;
}
export declare function loadConfigFromFile(configEnv: ConfigEnv, configFile?: string, configRoot?: string, logLevel?: LogLevel): Promise<{
path: string;
config: UserConfig;
dependencies: string[];
} | null>;
export declare function loadEnv(mode: string, envDir: string, prefix?: string): Record<string, string>;
export declare interface Logger {
info(msg: string, options?: LogOptions): void;
warn(msg: string, options?: LogOptions): void;
warnOnce(msg: string, options?: LogOptions): void;
error(msg: string, options?: LogOptions): void;
clearScreen(type: LogType): void;
hasWarned: boolean;
}
export declare interface LoggerOptions {
prefix?: string;
allowClearScreen?: boolean;
}
export declare type LogLevel = LogType | 'silent';
export declare interface LogOptions {
clear?: boolean;
timestamp?: boolean;
}
export declare type LogType = 'error' | 'warn' | 'info';
export declare type Manifest = Record<string, ManifestChunk>;
export declare interface ManifestChunk {
src?: string;
file: string;
css?: string[];
assets?: string[];
isEntry?: boolean;
isDynamicEntry?: boolean;
imports?: string[];
dynamicImports?: string[];
}
export declare function mergeConfig(a: Record<string, any>, b: Record<string, any>, isRoot?: boolean): Record<string, any>;
export declare class ModuleGraph {
urlToModuleMap: Map<string, ModuleNode>;
idToModuleMap: Map<string, ModuleNode>;
fileToModulesMap: Map<string, Set<ModuleNode>>;
safeModulesPath: Set<string>;
container: PluginContainer;
constructor(container: PluginContainer);
getModuleByUrl(rawUrl: string): Promise<ModuleNode | undefined>;
getModuleById(id: string): ModuleNode | undefined;
getModulesByFile(file: string): Set<ModuleNode> | undefined;
onFileChange(file: string): void;
invalidateModule(mod: ModuleNode, seen?: Set<ModuleNode>): void;
invalidateAll(): void;
/**
* Update the module graph based on a module's updated imports information
* If there are dependencies that no longer have any importers, they are
* returned as a Set.
*/
updateModuleInfo(mod: ModuleNode, importedModules: Set<string | ModuleNode>, acceptedModules: Set<string | ModuleNode>, isSelfAccepting: boolean): Promise<Set<ModuleNode> | undefined>;
ensureEntryFromUrl(rawUrl: string): Promise<ModuleNode>;
createFileOnlyEntry(file: string): ModuleNode;
resolveUrl(url: string): Promise<[string, string]>;
}
export declare class ModuleNode {
/**
* Public served url path, starts with /
*/
url: string;
/**
* Resolved file system path + query
*/
id: string | null;
file: string | null;
type: 'js' | 'css';
importers: Set<ModuleNode>;
importedModules: Set<ModuleNode>;
acceptedHmrDeps: Set<ModuleNode>;
isSelfAccepting: boolean;
transformResult: TransformResult | null;
ssrTransformResult: TransformResult | null;
ssrModule: Record<string, any> | null;
lastHMRTimestamp: number;
constructor(url: string);
}
export declare function normalizePath(id: string): string;
export declare function optimizeDeps(config: ResolvedConfig, force?: boolean | undefined, asCommand?: boolean, newDeps?: Record<string, string>, // missing imports encountered after server has started
ssr?: boolean): Promise<DepOptimizationMetadata | null>;
export declare interface PackageData {
dir: string;
hasSideEffects: (id: string) => boolean;
webResolvedImports: Record<string, string | undefined>;
nodeResolvedImports: Record<string, string | undefined>;
setResolvedCache: (key: string, entry: string, targetWeb: boolean) => void;
getResolvedCache: (key: string, targetWeb: boolean) => string | undefined;
data: {
[field: string]: any;
version: string;
main: string;
module: string;
browser: string | Record<string, string | false>;
exports: string | Record<string, any> | string[];
dependencies: Record<string, string>;
};
}
/**
* Vite plugins extends the Rollup plugin interface with a few extra
* vite-specific options. A valid vite plugin is also a valid Rollup plugin.
* On the contrary, a Rollup plugin may or may NOT be a valid vite universal
* plugin, since some Rollup features do not make sense in an unbundled
* dev server context. That said, as long as a rollup plugin doesn't have strong
* coupling between its bundle phase and output phase hooks then it should
* just work (that means, most of them).
*
* By default, the plugins are run during both serve and build. When a plugin
* is applied during serve, it will only run **non output plugin hooks** (see
* rollup type definition of {@link rollup#PluginHooks}). You can think of the
* dev server as only running `const bundle = rollup.rollup()` but never calling
* `bundle.generate()`.
*
* A plugin that expects to have different behavior depending on serve/build can
* export a factory function that receives the command being run via options.
*
* If a plugin should be applied only for server or