vite 3.0.0-alpha.1 → 3.0.0-alpha.4

package/dist/node/http.d.ts

@@ -0,0 +1,88 @@
+/// <reference types="node" />
+import type { Server as HttpServer, OutgoingHttpHeaders as HttpServerHeaders } from 'http';
+import type { ServerOptions as HttpsServerOptions } from 'https';
+import type { Connect } from 'types/connect';
+import type { ProxyOptions } from './server/middlewares/proxy';
+import type { Logger } from './logger';
+export interface CommonServerOptions {
+    /**
+     * Specify server port. Note if the port is already being used, Vite will
+     * automatically try the next available port so this may not be the actual
+     * port the server ends up listening on.
+     */
+    port?: number;
+    /**
+     * If enabled, vite will exit if specified port is already in use
+     */
+    strictPort?: boolean;
+    /**
+     * Specify which IP addresses the server should listen on.
+     * Set to 0.0.0.0 to listen on all addresses, including LAN and public addresses.
+     */
+    host?: string | boolean;
+    /**
+     * Enable TLS + HTTP/2.
+     * Note: this downgrades to TLS only when the proxy option is also used.
+     */
+    https?: boolean | HttpsServerOptions;
+    /**
+     * Open browser window on startup
+     */
+    open?: boolean | string;
+    /**
+     * Configure custom proxy rules for the dev server. Expects an object
+     * of `{ key: options }` pairs.
+     * Uses [`http-proxy`](https://github.com/http-party/node-http-proxy).
+     * Full options [here](https://github.com/http-party/node-http-proxy#options).
+     *
+     * Example `vite.config.js`:
+     * ``` js
+     * module.exports = {
+     *   proxy: {
+     *     // string shorthand
+     *     '/foo': 'http://localhost:4567/foo',
+     *     // with options
+     *     '/api': {
+     *       target: 'http://jsonplaceholder.typicode.com',
+     *       changeOrigin: true,
+     *       rewrite: path => path.replace(/^\/api/, '')
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    proxy?: Record<string, string | ProxyOptions>;
+    /**
+     * Configure CORS for the dev server.
+     * Uses https://github.com/expressjs/cors.
+     * Set to `true` to allow all methods from any origin, or configure separately
+     * using an object.
+     */
+    cors?: CorsOptions | boolean;
+    /**
+     * Specify server response headers.
+     */
+    headers?: HttpServerHeaders;
+}
+/**
+ * https://github.com/expressjs/cors#configuration-options
+ */
+export 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 resolveHttpServer({ proxy }: CommonServerOptions, app: Connect.Server, httpsOptions?: HttpsServerOptions): Promise<HttpServer>;
+export declare function resolveHttpsConfig(https: boolean | HttpsServerOptions | undefined, cacheDir: string): Promise<HttpsServerOptions | undefined>;
+export declare function httpServerStart(httpServer: HttpServer, serverOptions: {
+    port: number;
+    strictPort: boolean | undefined;
+    host: string | undefined;
+    logger: Logger;
+}): Promise<number>;

package/dist/node/index.d.ts

@@ -23,6 +23,7 @@ import type * as net from 'net';
 import type { OutgoingHttpHeaders } from 'http';
 import type { OutputBundle } from 'rollup';
 import type { OutputChunk } from 'rollup';
+import { parse } from 'es-module-lexer';
 import type { PartialResolvedId } from 'rollup';
 import type { Plugin as Plugin_3 } from 'rollup';
 import type { PluginContext } from 'rollup';
@@ -47,7 +48,6 @@ import type { TransformResult as TransformResult_3 } from 'esbuild';
 import type * as url from 'url';
 import type { URL as URL_2 } from 'url';
 import type { WatcherOptions } from 'rollup';
-import type { Worker as Worker_2 } from 'okie';
 import type { ZlibOptions } from 'zlib';
 
 export declare interface Alias {
@@ -544,6 +544,12 @@ export declare interface DepOptimizationOptions {
      * cannot be globs).
      */
     exclude?: string[];
+    /**
+     * Force ESM interop when importing for these dependencies. Some legacy
+     * packages advertise themselves as ESM but use `require` internally
+     * @experimental
+     */
+    needsInterop?: string[];
     /**
      * Options to pass to esbuild during the dep scanning and optimization
      *
@@ -630,6 +636,11 @@ export declare interface ExperimentalOptions {
     importGlobRestoreExtension?: boolean;
 }
 
+export declare type ExportsData = ReturnType<typeof parse> & {
+    hasReExports?: true;
+    jsxLoader?: true;
+};
+
 export declare interface FileSystemServeOptions {
     /**
      * Strictly restrict file accessing outside of allowing paths.
@@ -657,7 +668,7 @@ export declare interface FileSystemServeOptions {
     deny?: string[];
 }
 
-export declare function formatPostcssSourceMap(rawMap: ExistingRawSourceMap, file: string): ExistingRawSourceMap;
+export declare function formatPostcssSourceMap(rawMap: ExistingRawSourceMap, file: string): Promise<ExistingRawSourceMap>;
 
 export declare class FSWatcher extends EventEmitter implements fs.FSWatcher {
     options: WatchOptions
@@ -1150,7 +1161,7 @@ export declare interface JsonOptions {
 export declare interface KnownAsTypeMap {
     raw: string
     url: string
-    worker: Worker_2<any, any>
+    worker: Worker
 }
 
 export declare type LibraryFormats = 'es' | 'cjs' | 'umd' | 'iife';
@@ -1214,6 +1225,8 @@ export declare interface ManifestChunk {
 
 export declare type Matcher = AnymatchPattern | AnymatchPattern[]
 
+export declare function mergeAlias(a?: AliasOptions, b?: AliasOptions): AliasOptions | undefined;
+
 export declare function mergeConfig(defaults: Record<string, any>, overrides: Record<string, any>, isRoot?: boolean): Record<string, any>;
 
 export declare class ModuleGraph {
@@ -1280,6 +1293,11 @@ export declare interface OptimizedDepInfo {
      * but the bundles may not yet be saved to disk
      */
     processing?: Promise<void>;
+    /**
+     * ExportData cache, discovered deps will parse the src entry to get exports
+     * data used both to define if interop is needed and when pre-bundling
+     */
+    exportsData?: Promise<ExportsData>;
 }
 
 export declare interface OptimizedDeps {
@@ -1536,6 +1554,7 @@ export declare type ResolvedConfig = Readonly<Omit<UserConfig, 'plugins' | 'asse
     optimizeDeps: DepOptimizationOptions;
     /* Excluded from this release type: packageCache */
     worker: ResolveWorkerOptions;
+    spa: boolean;
 }>;
 
 export declare interface ResolvedPreviewOptions extends PreviewOptions {
@@ -2201,6 +2220,12 @@ export declare interface UserConfig {
          */
         rollupOptions?: Omit<RollupOptions, 'plugins' | 'input' | 'onwarn' | 'preserveEntrySignatures'>;
     };
+    /**
+     * Whether your application is a Single Page Application (SPA). Set to `false`
+     * for other kinds of apps like MPAs.
+     * @default true
+     */
+    spa?: boolean;
 }
 
 export declare type UserConfigExport = UserConfig | Promise<UserConfig> | UserConfigFn;

package/dist/node/index.js

@@ -1,33 +1,34 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var index = require('./chunks/dep-5cb039d6.js');
-require('fs');
-require('path');
-require('url');
-require('perf_hooks');
-require('tty');
-require('os');
-require('esbuild');
-require('events');
-require('assert');
-require('resolve');
-require('util');
-require('net');
-require('http');
-require('stream');
-require('child_process');
-require('crypto');
-require('module');
-require('buffer');
-require('querystring');
-require('zlib');
-require('https');
-require('tls');
-require('worker_threads');
-require('readline');
+export { b as build, i as createLogger, c as createServer, d as defineConfig, f as formatPostcssSourceMap, l as loadConfigFromFile, k as loadEnv, g as mergeAlias, m as mergeConfig, n as normalizePath, o as optimizeDeps, p as preview, e as resolveConfig, q as resolveEnvPrefix, a as resolvePackageData, r as resolvePackageEntry, j as searchForWorkspaceRoot, h as send, s as sortUserPlugins, t as transformWithEsbuild } from './chunks/dep-aea1d487.js';
+import 'fs';
+import 'path';
+import 'url';
+import 'perf_hooks';
+import 'module';
+import 'tty';
+import 'esbuild';
+import 'events';
+import 'assert';
+import 'resolve';
+import 'util';
+import 'net';
+import 'http';
+import 'stream';
+import 'os';
+import 'child_process';
+import 'crypto';
+import './constants.js';
+import 'buffer';
+import 'querystring';
+import 'zlib';
+import 'https';
+import 'tls';
+import 'worker_threads';
+import 'readline';
 
+// This file will be built for both ESM and CJS. Avoid relying on other modules as possible.
+const cssLangs = `\\.(css|less|sass|scss|styl|stylus|pcss|postcss)($|\\?)`;
+const cssLangRE = new RegExp(cssLangs);
+const isCSSRequest = (request) => cssLangRE.test(request);
 // Use splitVendorChunkPlugin() to get the same manualChunks strategy as Vite 2.7
 // We don't recommend using this strategy as a general solution moving forward
 // splitVendorChunk is a simple index/vendor strategy that was used in Vite
@@ -44,11 +45,10 @@ class SplitVendorChunkCache {
     }
 }
 function splitVendorChunk(options = {}) {
-    var _a;
-    const cache = (_a = options.cache) !== null && _a !== void 0 ? _a : new SplitVendorChunkCache();
+    const cache = options.cache ?? new SplitVendorChunkCache();
     return (id, { getModuleInfo }) => {
         if (id.includes('node_modules') &&
-            !index.isCSSRequest(id) &&
+            !isCSSRequest(id) &&
             staticImportedByEntry(id, getModuleInfo, cache.cache)) {
             return 'vendor';
         }
@@ -79,11 +79,10 @@ function staticImportedByEntry(id, getModuleInfo, cache, importStack = []) {
 function splitVendorChunkPlugin() {
     const caches = [];
     function createSplitVendorChunk(output, config) {
-        var _a;
         const cache = new SplitVendorChunkCache();
         caches.push(cache);
-        const build = (_a = config.build) !== null && _a !== void 0 ? _a : {};
-        const format = output === null || output === void 0 ? void 0 : output.format;
+        const build = config.build ?? {};
+        const format = output?.format;
         if (!build.ssr && !build.lib && format !== 'umd' && format !== 'iife') {
             return splitVendorChunk({ cache });
         }
@@ -91,8 +90,7 @@ function splitVendorChunkPlugin() {
     return {
         name: 'vite:split-vendor-chunk',
         config(config) {
-            var _a, _b;
-            let outputs = (_b = (_a = config === null || config === void 0 ? void 0 : config.build) === null || _a === void 0 ? void 0 : _a.rollupOptions) === null || _b === void 0 ? void 0 : _b.output;
+            let outputs = config?.build?.rollupOptions?.output;
             if (outputs) {
                 outputs = Array.isArray(outputs) ? outputs : [outputs];
                 for (const output of outputs) {
@@ -102,8 +100,7 @@ function splitVendorChunkPlugin() {
                             if (typeof output.manualChunks === 'function') {
                                 const userManualChunks = output.manualChunks;
                                 output.manualChunks = (id, api) => {
-                                    var _a;
-                                    return (_a = userManualChunks(id, api)) !== null && _a !== void 0 ? _a : viteManualChunks(id, api);
+                                    return userManualChunks(id, api) ?? viteManualChunks(id, api);
                                 };
                             }
                             // else, leave the object form of manualChunks untouched, as
@@ -133,24 +130,4 @@ function splitVendorChunkPlugin() {
     };
 }
 
-exports.build = index.build;
-exports.createLogger = index.createLogger;
-exports.createServer = index.createServer;
-exports.defineConfig = index.defineConfig;
-exports.formatPostcssSourceMap = index.formatPostcssSourceMap;
-exports.loadConfigFromFile = index.loadConfigFromFile;
-exports.loadEnv = index.loadEnv;
-exports.mergeConfig = index.mergeConfig;
-exports.normalizePath = index.normalizePath;
-exports.optimizeDeps = index.optimizeDeps;
-exports.preview = index.preview;
-exports.resolveConfig = index.resolveConfig;
-exports.resolveEnvPrefix = index.resolveEnvPrefix;
-exports.resolvePackageData = index.resolvePackageData;
-exports.resolvePackageEntry = index.resolvePackageEntry;
-exports.searchForWorkspaceRoot = index.searchForWorkspaceRoot;
-exports.send = index.send;
-exports.sortUserPlugins = index.sortUserPlugins;
-exports.transformWithEsbuild = index.transformWithEsbuild;
-exports.splitVendorChunk = splitVendorChunk;
-exports.splitVendorChunkPlugin = splitVendorChunkPlugin;
+export { splitVendorChunk, splitVendorChunkPlugin };

package/dist/node/logger.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="node" />
+import type { Server } from 'net';
+import type { RollupError } from 'rollup';
+import type { CommonServerOptions } from './http';
+import type { ResolvedConfig } from '.';
+export declare type LogType = 'error' | 'warn' | 'info';
+export declare type LogLevel = LogType | 'silent';
+export interface Logger {
+    info(msg: string, options?: LogOptions): void;
+    warn(msg: string, options?: LogOptions): void;
+    warnOnce(msg: string, options?: LogOptions): void;
+    error(msg: string, options?: LogErrorOptions): void;
+    clearScreen(type: LogType): void;
+    hasErrorLogged(error: Error | RollupError): boolean;
+    hasWarned: boolean;
+}
+export interface LogOptions {
+    clear?: boolean;
+    timestamp?: boolean;
+}
+export interface LogErrorOptions extends LogOptions {
+    error?: Error | RollupError | null;
+}
+export declare const LogLevels: Record<LogLevel, number>;
+export interface LoggerOptions {
+    prefix?: string;
+    allowClearScreen?: boolean;
+    customLogger?: Logger;
+}
+export declare function createLogger(level?: LogLevel, options?: LoggerOptions): Logger;
+export declare function printCommonServerUrls(server: Server, options: CommonServerOptions, config: ResolvedConfig): void;

package/dist/node/optimizer/esbuildDepPlugin.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from 'esbuild';
+import type { ResolvedConfig } from '..';
+import type { ExportsData } from '.';
+export declare function esbuildDepPlugin(qualified: Record<string, string>, exportsData: Record<string, ExportsData>, config: ResolvedConfig): Plugin;

package/dist/node/optimizer/index.d.ts

@@ -0,0 +1,167 @@
+import type { BuildOptions as EsbuildBuildOptions } from 'esbuild';
+import { parse } from 'es-module-lexer';
+import type { ResolvedConfig } from '../config';
+export declare const debuggerViteDeps: (...args: any[]) => any;
+export declare type ExportsData = ReturnType<typeof parse> & {
+    hasReExports?: true;
+    jsxLoader?: true;
+};
+export interface OptimizedDeps {
+    metadata: DepOptimizationMetadata;
+    scanProcessing?: Promise<void>;
+    registerMissingImport: (id: string, resolved: string) => OptimizedDepInfo;
+}
+export 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[];
+    /**
+     * Force ESM interop when importing for these dependencies. Some legacy
+     * packages advertise themselves as ESM but use `require` internally
+     * @experimental
+     */
+    needsInterop?: 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
+     *
+     * https://esbuild.github.io/api
+     */
+    esbuildOptions?: Omit<EsbuildBuildOptions, 'bundle' | 'entryPoints' | 'external' | 'write' | 'watch' | 'outdir' | 'outfile' | 'outbase' | 'outExtension' | 'metafile'>;
+    /**
+     * List of file extensions that can be optimized. A corresponding esbuild
+     * plugin must exist to handle the specific extension.
+     *
+     * By default, Vite can optimize `.mjs`, `.js`, and `.ts` files. This option
+     * allows specifying additional extensions.
+     *
+     * @experimental
+     */
+    extensions?: string[];
+    /**
+     * Disables dependencies optimizations
+     * @default false
+     * @experimental
+     */
+    disabled?: boolean;
+}
+export interface DepOptimizationResult {
+    metadata: DepOptimizationMetadata;
+    /**
+     * When doing a re-run, if there are newly discovered dependendencies
+     * the page reload will be delayed until the next rerun so we need
+     * to be able to discard the result
+     */
+    commit: () => Promise<void>;
+    cancel: () => void;
+}
+export interface DepOptimizationProcessing {
+    promise: Promise<void>;
+    resolve: () => void;
+}
+export interface OptimizedDepInfo {
+    id: string;
+    file: string;
+    src?: string;
+    needsInterop?: boolean;
+    browserHash?: string;
+    fileHash?: string;
+    /**
+     * During optimization, ids can still be resolved to their final location
+     * but the bundles may not yet be saved to disk
+     */
+    processing?: Promise<void>;
+    /**
+     * ExportData cache, discovered deps will parse the src entry to get exports
+     * data used both to define if interop is needed and when pre-bundling
+     */
+    exportsData?: Promise<ExportsData>;
+}
+export 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;
+    /**
+     * Metadata for each already optimized dependency
+     */
+    optimized: Record<string, OptimizedDepInfo>;
+    /**
+     * Metadata for non-entry optimized chunks and dynamic imports
+     */
+    chunks: Record<string, OptimizedDepInfo>;
+    /**
+     * Metadata for each newly discovered dependency after processing
+     */
+    discovered: Record<string, OptimizedDepInfo>;
+    /**
+     * OptimizedDepInfo list
+     */
+    depInfoList: OptimizedDepInfo[];
+}
+/**
+ * Used by Vite CLI when running `vite optimize`
+ */
+export declare function optimizeDeps(config: ResolvedConfig, force?: boolean | undefined, asCommand?: boolean): Promise<DepOptimizationMetadata>;
+export declare function createOptimizedDepsMetadata(config: ResolvedConfig, timestamp?: string): DepOptimizationMetadata;
+export declare function addOptimizedDepInfo(metadata: DepOptimizationMetadata, type: 'optimized' | 'discovered' | 'chunks', depInfo: OptimizedDepInfo): OptimizedDepInfo;
+/**
+ * Creates the initial dep optimization metadata, loading it from the deps cache
+ * if it exists and pre-bundling isn't forced
+ */
+export declare function loadCachedDepOptimizationMetadata(config: ResolvedConfig, force?: boolean | undefined, asCommand?: boolean): DepOptimizationMetadata | undefined;
+/**
+ * Initial optimizeDeps at server start. Perform a fast scan using esbuild to
+ * find deps to pre-bundle and include user hard-coded dependencies
+ */
+export declare function discoverProjectDependencies(config: ResolvedConfig, timestamp?: string): Promise<Record<string, OptimizedDepInfo>>;
+export declare function depsLogString(qualifiedIds: string[]): string;
+/**
+ * Internally, Vite uses this function to prepare a optimizeDeps run. When Vite starts, we can get
+ * the metadata and start the server without waiting for the optimizeDeps processing to be completed
+ */
+export declare function runOptimizeDeps(config: ResolvedConfig, depsInfo: Record<string, OptimizedDepInfo>): Promise<DepOptimizationResult>;
+export declare function findKnownImports(config: ResolvedConfig): Promise<string[]>;
+export declare function newDepOptimizationProcessing(): DepOptimizationProcessing;
+export declare function depsFromOptimizedDepInfo(depsInfo: Record<string, OptimizedDepInfo>): {
+    [k: string]: string;
+};
+export declare function getOptimizedDepPath(id: string, config: ResolvedConfig): string;
+export declare function getDepsCacheDir(config: ResolvedConfig): string;
+export declare function isOptimizedDepFile(id: string, config: ResolvedConfig): boolean;
+export declare function createIsOptimizedDepUrl(config: ResolvedConfig): (url: string) => boolean;
+export declare function extractExportsData(filePath: string, config: ResolvedConfig): Promise<ExportsData>;
+export declare function getDepHash(config: ResolvedConfig): string;
+export declare function optimizedDepInfoFromId(metadata: DepOptimizationMetadata, id: string): OptimizedDepInfo | undefined;
+export declare function optimizedDepInfoFromFile(metadata: DepOptimizationMetadata, file: string): OptimizedDepInfo | undefined;
+export declare function optimizedDepNeedsInterop(metadata: DepOptimizationMetadata, file: string, config: ResolvedConfig): Promise<boolean | undefined>;

package/dist/node/optimizer/registerMissing.d.ts

@@ -0,0 +1,3 @@
+import type { ViteDevServer } from '..';
+import type { OptimizedDeps } from '.';
+export declare function createOptimizedDeps(server: ViteDevServer): OptimizedDeps;

package/dist/node/optimizer/scan.d.ts

@@ -0,0 +1,8 @@
+import type { ResolvedConfig } from '..';
+export declare const importsRE: RegExp;
+export declare function scanImports(config: ResolvedConfig): Promise<{
+    deps: Record<string, string>;
+    missing: Record<string, string>;
+}>;
+export declare const scriptRE: RegExp;
+export declare const commentRE: RegExp;

package/dist/node/packages.d.ts

@@ -0,0 +1,27 @@
+import type { ResolvedConfig } from './config';
+import type { Plugin } from './plugin';
+/** Cache for package.json resolution and package.json contents */
+export declare type PackageCache = Map<string, PackageData>;
+export interface PackageData {
+    dir: string;
+    hasSideEffects: (id: string) => boolean | 'no-treeshake';
+    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;
+        name: string;
+        type: string;
+        version: string;
+        main: string;
+        module: string;
+        browser: string | Record<string, string | false>;
+        exports: string | Record<string, any> | string[];
+        dependencies: Record<string, string>;
+    };
+}
+export declare function invalidatePackageData(packageCache: PackageCache, pkgPath: string): void;
+export declare function resolvePackageData(id: string, basedir: string, preserveSymlinks?: boolean, packageCache?: PackageCache): PackageData | null;
+export declare function loadPackageData(pkgPath: string, preserveSymlinks?: boolean, packageCache?: PackageCache): PackageData;
+export declare function watchPackageDataPlugin(config: ResolvedConfig): Plugin;