vite 3.0.0-alpha.4 → 3.0.0-alpha.5

package/dist/node/chunks/{dep-35b61ee3.js → dep-13a14c32.js}

@@ -1,4 +1,4 @@
-import { w as getAugmentedNamespace, x as getDefaultExportFromCjs } from './dep-aea1d487.js';
+import { x as getAugmentedNamespace, y as getDefaultExportFromCjs } from './dep-0232e200.js';
 
 import { fileURLToPath as __cjs_fileURLToPath } from 'url';
 import { dirname as __cjs_dirname } from 'path';
@@ -424,6 +424,11 @@ function looseEqual(a, b) {
     if (aValidType || bValidType) {
         return aValidType && bValidType ? a.getTime() === b.getTime() : false;
     }
+    aValidType = isSymbol(a);
+    bValidType = isSymbol(b);
+    if (aValidType || bValidType) {
+        return a === b;
+    }
     aValidType = isArray(a);
     bValidType = isArray(b);
     if (aValidType || bValidType) {
@@ -520,7 +525,7 @@ const hasOwn = (val, key) => hasOwnProperty.call(val, key);
 const isArray = Array.isArray;
 const isMap = (val) => toTypeString(val) === '[object Map]';
 const isSet = (val) => toTypeString(val) === '[object Set]';
-const isDate = (val) => val instanceof Date;
+const isDate = (val) => toTypeString(val) === '[object Date]';
 const isFunction = (val) => typeof val === 'function';
 const isString = (val) => typeof val === 'string';
 const isSymbol = (val) => typeof val === 'symbol';
@@ -604,7 +609,13 @@ const getGlobalThis = () => {
                         : typeof global !== 'undefined'
                             ? global
                             : {}));
-};
+};
+const identRE = /^[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*$/;
+function genPropsAccessExp(name) {
+    return identRE.test(name)
+        ? `__props.${name}`
+        : `__props[${JSON.stringify(name)}]`;
+}
 
 var shared_esmBundler = {
     __proto__: null,
@@ -619,6 +630,7 @@ var shared_esmBundler = {
     escapeHtml: escapeHtml,
     escapeHtmlComment: escapeHtmlComment,
     extend: extend,
+    genPropsAccessExp: genPropsAccessExp,
     generateCodeFrame: generateCodeFrame,
     getGlobalThis: getGlobalThis,
     hasChanged: hasChanged,
@@ -2452,6 +2464,14 @@ function getConstantType(node, context) {
                 // static then they don't need to be blocks since there will be no
                 // nested updates.
                 if (codegenNode.isBlock) {
+                    // except set custom directives.
+                    for (let i = 0; i < node.props.length; i++) {
+                        const p = node.props[i];
+                        if (p.type === 7 /* DIRECTIVE */) {
+                            constantCache.set(node, 0 /* NOT_CONSTANT */);
+                            return 0 /* NOT_CONSTANT */;
+                        }
+                    }
                     context.removeHelper(OPEN_BLOCK);
                     context.removeHelper(getVNodeBlockHelper(context.inSSR, codegenNode.isComponent));
                     codegenNode.isBlock = false;
@@ -2858,6 +2878,7 @@ function createStructuralDirectiveTransform(name, fn) {
 }
 
 const PURE_ANNOTATION = `/*#__PURE__*/`;
+const aliasHelper = (s) => `${helperNameMap[s]}: _${helperNameMap[s]}`;
 function createCodegenContext(ast, { mode = 'function', prefixIdentifiers = mode === 'module', sourceMap = false, filename = `template.vue.html`, scopeId = null, optimizeImports = false, runtimeGlobalName = `Vue`, runtimeModuleName = `vue`, ssrRuntimeModuleName = 'vue/server-renderer', ssr = false, isTS = false, inSSR = false }) {
     const context = {
         mode,
@@ -2934,9 +2955,7 @@ function generate(ast, options = {}) {
         // function mode const declarations should be inside with block
         // also they should be renamed to avoid collision with user properties
         if (hasHelpers) {
-            push(`const { ${ast.helpers
-                .map(s => `${helperNameMap[s]}: _${helperNameMap[s]}`)
-                .join(', ')} } = _Vue`);
+            push(`const { ${ast.helpers.map(aliasHelper).join(', ')} } = _Vue`);
             push(`\n`);
             newline();
         }
@@ -2996,7 +3015,6 @@ function generate(ast, options = {}) {
 function genFunctionPreamble(ast, context) {
     const { ssr, prefixIdentifiers, push, newline, runtimeModuleName, runtimeGlobalName, ssrRuntimeModuleName } = context;
     const VueBinding = runtimeGlobalName;
-    const aliasHelper = (s) => `${helperNameMap[s]}: _${helperNameMap[s]}`;
     // Generate const declaration for helpers
     // In prefix mode, we place the const declaration at top so it's done
     // only once; But if we not prefixing, we place the declaration inside the
@@ -3714,14 +3732,14 @@ function processIf(node, dir, context, processCodegen) {
     }
 }
 function createIfBranch(node, dir) {
+    const isTemplateIf = node.tagType === 3 /* TEMPLATE */;
     return {
         type: 10 /* IF_BRANCH */,
         loc: node.loc,
         condition: dir.name === 'else' ? undefined : dir.exp,
-        children: node.tagType === 3 /* TEMPLATE */ && !findDir(node, 'for')
-            ? node.children
-            : [node],
-        userKey: findProp(node, `key`)
+        children: isTemplateIf && !findDir(node, 'for') ? node.children : [node],
+        userKey: findProp(node, `key`),
+        isTemplateIf
     };
 }
 function createCodegenNodeForBranch(branch, keyIndex, context) {
@@ -3757,6 +3775,7 @@ function createChildrenCodegenNode(branch, keyIndex, context) {
             // check if the fragment actually contains a single valid child with
             // the rest being comments
             if ((process.env.NODE_ENV !== 'production') &&
+                !branch.isTemplateIf &&
                 children.filter(c => c.type !== 3 /* COMMENT */).length === 1) {
                 patchFlag |= 2048 /* DEV_ROOT_FRAGMENT */;
                 patchFlagText += `, ${PatchFlagNames[2048 /* DEV_ROOT_FRAGMENT */]}`;
@@ -4333,7 +4352,7 @@ const transformElement = (node, context) => {
                 (tag === 'svg' || tag === 'foreignObject'));
         // props
         if (props.length > 0) {
-            const propsBuildResult = buildProps(node, context);
+            const propsBuildResult = buildProps(node, context, undefined, isComponent, isDynamicComponent);
             vnodeProps = propsBuildResult.props;
             patchFlag = propsBuildResult.patchFlag;
             dynamicPropNames = propsBuildResult.dynamicPropNames;
@@ -4475,9 +4494,8 @@ function resolveComponentType(node, context, ssr = false) {
     context.components.add(tag);
     return toValidAssetId(tag, `component`);
 }
-function buildProps(node, context, props = node.props, ssr = false) {
+function buildProps(node, context, props = node.props, isComponent, isDynamicComponent, ssr = false) {
     const { tag, loc: elementLoc, children } = node;
-    const isComponent = node.tagType === 1 /* COMPONENT */;
     let properties = [];
     const mergeArgs = [];
     const runtimeDirectives = [];
@@ -4496,8 +4514,8 @@ function buildProps(node, context, props = node.props, ssr = false) {
         if (isStaticExp(key)) {
             const name = key.content;
             const isEventHandler = isOn(name);
-            if (!isComponent &&
-                isEventHandler &&
+            if (isEventHandler &&
+                (!isComponent || isDynamicComponent) &&
                 // omit the flag for click handlers because hydration gives click
                 // dedicated fast path.
                 name.toLowerCase() !== 'onclick' &&
@@ -4752,10 +4770,11 @@ function buildProps(node, context, props = node.props, ssr = false) {
                         classProp.value = createCallExpression(context.helper(NORMALIZE_CLASS), [classProp.value]);
                     }
                     if (styleProp &&
-                        !isStaticExp(styleProp.value) &&
                         // the static style is compiled into an object,
                         // so use `hasStyleBinding` to ensure that it is a dynamic style binding
                         (hasStyleBinding ||
+                            (styleProp.value.type === 4 /* SIMPLE_EXPRESSION */ &&
+                                styleProp.value.content.trim()[0] === `[`) ||
                             // v-bind:style and style both exist,
                             // v-bind:style with static literal object
                             styleProp.value.type === 17 /* JS_ARRAY_EXPRESSION */)) {
@@ -4953,7 +4972,7 @@ function processSlotOutlet(node, context) {
         }
     }
     if (nonNameProps.length > 0) {
-        const { props, directives } = buildProps(node, context, nonNameProps);
+        const { props, directives } = buildProps(node, context, nonNameProps, false, false);
         slotProps = props;
         if (directives.length) {
             context.onError(createCompilerError(36 /* X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET */, directives[0].loc));
@@ -5124,11 +5143,7 @@ const transformText = (node, context) => {
                         const next = children[j];
                         if (isText(next)) {
                             if (!currentContainer) {
-                                currentContainer = children[i] = {
-                                    type: 8 /* COMPOUND_EXPRESSION */,
-                                    loc: child.loc,
-                                    children: [child]
-                                };
+                                currentContainer = children[i] = createCompoundExpression([child], child.loc);
                             }
                             // merge adjacent text node into current
                             currentContainer.children.push(` + `, next);
@@ -5597,6 +5612,7 @@ var compilerCore_esmBundler = {
     findProp: findProp,
     generate: generate,
     getBaseTransformPreset: getBaseTransformPreset,
+    getConstantType: getConstantType,
     getInnerRange: getInnerRange,
     getMemoedVNodeCall: getMemoedVNodeCall,
     getVNodeBlockHelper: getVNodeBlockHelper,
@@ -8178,7 +8194,9 @@ const transformVText = (dir, node, context) => {
     return {
         props: [
             compilerCore.createObjectProperty(compilerCore.createSimpleExpression(`textContent`, true), exp
-                ? compilerCore.createCallExpression(context.helperString(compilerCore.TO_DISPLAY_STRING), [exp], loc)
+                ? compilerCore.getConstantType(exp, context) > 0
+                    ? exp
+                    : compilerCore.createCallExpression(context.helperString(compilerCore.TO_DISPLAY_STRING), [exp], loc)
                 : compilerCore.createSimpleExpression('', true))
         ]
     };
@@ -8390,19 +8408,38 @@ const transformShow = (dir, node, context) => {
     };
 };
 
-const warnTransitionChildren = (node, context) => {
+const transformTransition = (node, context) => {
     if (node.type === 1 /* ELEMENT */ &&
         node.tagType === 1 /* COMPONENT */) {
         const component = context.isBuiltInComponent(node.tag);
         if (component === TRANSITION) {
             return () => {
-                if (node.children.length && hasMultipleChildren(node)) {
+                if (!node.children.length) {
+                    return;
+                }
+                // warn multiple transition children
+                if (hasMultipleChildren(node)) {
                     context.onError(createDOMCompilerError(59 /* X_TRANSITION_INVALID_CHILDREN */, {
                         start: node.children[0].loc.start,
                         end: node.children[node.children.length - 1].loc.end,
                         source: ''
                     }));
                 }
+                // check if it's s single child w/ v-show
+                // if yes, inject "persisted: true" to the transition props
+                const child = node.children[0];
+                if (child.type === 1 /* ELEMENT */) {
+                    for (const p of child.props) {
+                        if (p.type === 7 /* DIRECTIVE */ && p.name === 'show') {
+                            node.props.push({
+                                type: 6 /* ATTRIBUTE */,
+                                name: 'persisted',
+                                value: undefined,
+                                loc: node.loc
+                            });
+                        }
+                    }
+                }
             };
         }
     }
@@ -8618,6 +8655,7 @@ function stringifyNode(node, context) {
 }
 function stringifyElement(node, context) {
     let res = `<${node.tag}`;
+    let innerHTML = '';
     for (let i = 0; i < node.props.length; i++) {
         const p = node.props[i];
         if (p.type === 6 /* ATTRIBUTE */) {
@@ -8626,25 +8664,35 @@ function stringifyElement(node, context) {
                 res += `="${shared.escapeHtml(p.value.content)}"`;
             }
         }
-        else if (p.type === 7 /* DIRECTIVE */ && p.name === 'bind') {
-            const exp = p.exp;
-            if (exp.content[0] === '_') {
-                // internally generated string constant references
-                // e.g. imported URL strings via compiler-sfc transformAssetUrl plugin
-                res += ` ${p.arg.content}="__VUE_EXP_START__${exp.content}__VUE_EXP_END__"`;
-                continue;
-            }
-            // constant v-bind, e.g. :foo="1"
-            let evaluated = evaluateConstant(exp);
-            if (evaluated != null) {
-                const arg = p.arg && p.arg.content;
-                if (arg === 'class') {
-                    evaluated = shared.normalizeClass(evaluated);
+        else if (p.type === 7 /* DIRECTIVE */) {
+            if (p.name === 'bind') {
+                const exp = p.exp;
+                if (exp.content[0] === '_') {
+                    // internally generated string constant references
+                    // e.g. imported URL strings via compiler-sfc transformAssetUrl plugin
+                    res += ` ${p.arg.content}="__VUE_EXP_START__${exp.content}__VUE_EXP_END__"`;
+                    continue;
                 }
-                else if (arg === 'style') {
-                    evaluated = shared.stringifyStyle(shared.normalizeStyle(evaluated));
+                // constant v-bind, e.g. :foo="1"
+                let evaluated = evaluateConstant(exp);
+                if (evaluated != null) {
+                    const arg = p.arg && p.arg.content;
+                    if (arg === 'class') {
+                        evaluated = shared.normalizeClass(evaluated);
+                    }
+                    else if (arg === 'style') {
+                        evaluated = shared.stringifyStyle(shared.normalizeStyle(evaluated));
+                    }
+                    res += ` ${p.arg.content}="${shared.escapeHtml(evaluated)}"`;
                 }
-                res += ` ${p.arg.content}="${shared.escapeHtml(evaluated)}"`;
+            }
+            else if (p.name === 'html') {
+                // #5439 v-html with constant value
+                // not sure why would anyone do this but it can happen
+                innerHTML = evaluateConstant(p.exp);
+            }
+            else if (p.name === 'text') {
+                innerHTML = shared.escapeHtml(shared.toDisplayString(evaluateConstant(p.exp)));
             }
         }
     }
@@ -8652,8 +8700,13 @@ function stringifyElement(node, context) {
         res += ` ${context.scopeId}`;
     }
     res += `>`;
-    for (let i = 0; i < node.children.length; i++) {
-        res += stringifyNode(node.children[i], context);
+    if (innerHTML) {
+        res += innerHTML;
+    }
+    else {
+        for (let i = 0; i < node.children.length; i++) {
+            res += stringifyNode(node.children[i], context);
+        }
     }
     if (!shared.isVoidTag(node.tag)) {
         res += `</${node.tag}>`;
@@ -8666,7 +8719,7 @@ function stringifyElement(node, context) {
 // here, e.g. `{{ 1 }}` or `{{ 'foo' }}`
 // in addition, constant exps bail on presence of parens so you can't even
 // run JSFuck in here. But we mark it unsafe for security review purposes.
-// (see compiler-core/src/transformExpressions)
+// (see compiler-core/src/transforms/transformExpression)
 function evaluateConstant(exp) {
     if (exp.type === 4 /* SIMPLE_EXPRESSION */) {
         return new Function(`return ${exp.content}`)();
@@ -8703,7 +8756,7 @@ const ignoreSideEffectTags = (node, context) => {
 
 const DOMNodeTransforms = [
     transformStyle,
-    ...([warnTransitionChildren] )
+    ...([transformTransition] )
 ];
 const DOMDirectiveTransforms = {
     cloak: compilerCore.noopDirectiveTransform,

package/dist/node/chunks/{dep-28f8c91c.js → dep-21067347.js}

@@ -1,5 +1,5 @@
 import require$$0 from 'postcss';
-import { v as commonjsGlobal } from './dep-aea1d487.js';
+import { w as commonjsGlobal } from './dep-0232e200.js';
 import path$2 from 'path';
 import require$$1 from 'crypto';
 import fs__default from 'fs';

package/dist/node/chunks/{dep-ce833324.js → dep-cd161504.js}

@@ -1,4 +1,4 @@
-import { v as commonjsGlobal } from './dep-aea1d487.js';
+import { w as commonjsGlobal } from './dep-0232e200.js';
 import require$$1 from 'crypto';
 import 'fs';
 import 'path';

package/dist/node/cli.js

@@ -1,6 +1,6 @@
 import { performance } from 'perf_hooks';
 import { EventEmitter } from 'events';
-import { u as colors, i as createLogger, e as resolveConfig } from './chunks/dep-aea1d487.js';
+import { v as colors, j as createLogger, e as resolveConfig } from './chunks/dep-0232e200.js';
 import { VERSION } from './constants.js';
 import 'fs';
 import 'path';
@@ -682,7 +682,7 @@ cli
     .action(async (root, options) => {
     // output structure is preserved even after bundling so require()
     // is ok here
-    const { createServer } = await import('./chunks/dep-aea1d487.js').then(function (n) { return n.A; });
+    const { createServer } = await import('./chunks/dep-0232e200.js').then(function (n) { return n.B; });
     try {
         const server = await createServer({
             root,
@@ -724,10 +724,11 @@ cli
     `or specify minifier to use (default: esbuild)`)
     .option('--manifest [name]', `[boolean | string] emit build manifest json`)
     .option('--ssrManifest [name]', `[boolean | string] emit ssr manifest json`)
+    .option('--force', `[boolean] force the optimizer to ignore the cache and re-bundle (experimental)`)
     .option('--emptyOutDir', `[boolean] force empty outDir when it's outside of root`)
     .option('-w, --watch', `[boolean] rebuilds when modules have changed on disk`)
     .action(async (root, options) => {
-    const { build } = await import('./chunks/dep-aea1d487.js').then(function (n) { return n.z; });
+    const { build } = await import('./chunks/dep-0232e200.js').then(function (n) { return n.A; });
     const buildOptions = cleanOptions(options);
     try {
         await build({
@@ -737,6 +738,7 @@ cli
             configFile: options.config,
             logLevel: options.logLevel,
             clearScreen: options.clearScreen,
+            force: options.force,
             build: buildOptions
         });
     }
@@ -750,7 +752,7 @@ cli
     .command('optimize [root]', 'pre-bundle dependencies')
     .option('--force', `[boolean] force the optimizer to ignore the cache and re-bundle`)
     .action(async (root, options) => {
-    const { optimizeDeps } = await import('./chunks/dep-aea1d487.js').then(function (n) { return n.y; });
+    const { optimizeDeps } = await import('./chunks/dep-0232e200.js').then(function (n) { return n.z; });
     try {
         const config = await resolveConfig({
             root,
@@ -773,7 +775,7 @@ cli
     .option('--https', `[boolean] use TLS + HTTP/2`)
     .option('--open [path]', `[boolean | string] open browser on startup`)
     .action(async (root, options) => {
-    const { preview } = await import('./chunks/dep-aea1d487.js').then(function (n) { return n.B; });
+    const { preview } = await import('./chunks/dep-0232e200.js').then(function (n) { return n.C; });
     try {
         const server = await preview({
             root,

package/dist/node/config.d.ts

@@ -105,6 +105,11 @@ export interface UserConfig {
      * Preview specific options, e.g. host, port, https...
      */
     preview?: PreviewOptions;
+    /**
+     * Force dep pre-optimization regardless of whether deps have changed.
+     * @experimental
+     */
+    force?: boolean;
     /**
      * Dep optimization options
      */
@@ -238,3 +243,4 @@ export declare function loadConfigFromFile(configEnv: ConfigEnv, configFile?: st
     config: UserConfig;
     dependencies: string[];
 } | null>;
+export declare function isDepsOptimizerEnabled(config: ResolvedConfig): boolean;

package/dist/node/constants.js

@@ -1,7 +1,7 @@
 import path, { resolve } from 'path';
 import { fileURLToPath } from 'url';
 
-var version = "3.0.0-alpha.4";
+var version = "3.0.0-alpha.5";
 
 const VERSION = version;
 const DEFAULT_MAIN_FIELDS = [

package/dist/node/index.d.ts

@@ -573,11 +573,13 @@ export declare interface DepOptimizationOptions {
      */
     extensions?: string[];
     /**
-     * Disables dependencies optimizations
+     * Disables dependencies optimizations, true disables the optimizer during
+     * build and dev. Pass 'build' or 'dev' to only disable the optimizer in
+     * one of the modes. Deps optimization is enabled by default in both
      * @default false
      * @experimental
      */
-    disabled?: boolean;
+    disabled?: boolean | 'build' | 'dev';
 }
 
 export declare interface DepOptimizationProcessing {
@@ -596,6 +598,17 @@ export declare interface DepOptimizationResult {
     cancel: () => void;
 }
 
+export declare interface DepsOptimizer {
+    metadata: DepOptimizationMetadata;
+    scanProcessing?: Promise<void>;
+    registerMissingImport: (id: string, resolved: string) => OptimizedDepInfo;
+    run: () => void;
+    isOptimizedDepFile: (id: string) => boolean;
+    isOptimizedDepUrl: (url: string) => boolean;
+    getOptimizedDepId: (depInfo: OptimizedDepInfo) => string;
+    options: DepOptimizationOptions;
+}
+
 export declare interface ErrorPayload {
     type: 'error'
     err: {
@@ -1142,8 +1155,11 @@ export declare interface InternalResolveOptions extends ResolveOptions {
     isFromTsImporter?: boolean;
     tryEsmOnly?: boolean;
     scan?: boolean;
+    getDepsOptimizer?: () => DepsOptimizer | undefined;
 }
 
+export declare function isDepsOptimizerEnabled(config: ResolvedConfig): boolean;
+
 export declare interface JsonOptions {
     /**
      * Generate a named export for every property of the JSON object
@@ -1300,12 +1316,6 @@ export declare interface OptimizedDepInfo {
     exportsData?: Promise<ExportsData>;
 }
 
-export declare interface OptimizedDeps {
-    metadata: DepOptimizationMetadata;
-    scanProcessing?: Promise<void>;
-    registerMissingImport: (id: string, resolved: string) => OptimizedDepInfo;
-}
-
 /**
  * Used by Vite CLI when running `vite optimize`
  */
@@ -1817,10 +1827,6 @@ export declare interface SendOptions {
 export declare type ServerHook = (server: ViteDevServer) => (() => void) | void | Promise<(() => void) | void>;
 
 export declare interface ServerOptions extends CommonServerOptions {
-    /**
-     * Force dep pre-optimization regardless of whether deps have changed.
-     */
-    force?: boolean;
     /**
      * Configure HMR-specific options (port, host, path & protocol)
      */
@@ -2162,6 +2168,11 @@ export declare interface UserConfig {
      * Preview specific options, e.g. host, port, https...
      */
     preview?: PreviewOptions;
+    /**
+     * Force dep pre-optimization regardless of whether deps have changed.
+     * @experimental
+     */
+    force?: boolean;
     /**
      * Dep optimization options
      */
@@ -2314,7 +2325,6 @@ export declare interface ViteDevServer {
      * @param forceOptimize - force the optimizer to re-bundle, same as --force cli flag
      */
     restart(forceOptimize?: boolean): Promise<void>;
-    /* Excluded from this release type: _optimizedDeps */
     /* Excluded from this release type: _importGlobMap */
     /* Excluded from this release type: _ssrExternals */
     /* Excluded from this release type: _restartPromise */

package/dist/node/index.js

@@ -1,4 +1,4 @@
-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';
+export { b as build, j as createLogger, c as createServer, d as defineConfig, f as formatPostcssSourceMap, i as isDepsOptimizerEnabled, l as loadConfigFromFile, q as loadEnv, g as mergeAlias, m as mergeConfig, n as normalizePath, o as optimizeDeps, p as preview, e as resolveConfig, u as resolveEnvPrefix, a as resolvePackageData, r as resolvePackageEntry, k as searchForWorkspaceRoot, h as send, s as sortUserPlugins, t as transformWithEsbuild } from './chunks/dep-0232e200.js';
 import 'fs';
 import 'path';
 import 'url';

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

@@ -1,15 +1,21 @@
 import type { BuildOptions as EsbuildBuildOptions } from 'esbuild';
 import { parse } from 'es-module-lexer';
 import type { ResolvedConfig } from '../config';
+export { initDepsOptimizer, getDepsOptimizer } from './optimizer';
 export declare const debuggerViteDeps: (...args: any[]) => any;
 export declare type ExportsData = ReturnType<typeof parse> & {
     hasReExports?: true;
     jsxLoader?: true;
 };
-export interface OptimizedDeps {
+export interface DepsOptimizer {
     metadata: DepOptimizationMetadata;
     scanProcessing?: Promise<void>;
     registerMissingImport: (id: string, resolved: string) => OptimizedDepInfo;
+    run: () => void;
+    isOptimizedDepFile: (id: string) => boolean;
+    isOptimizedDepUrl: (url: string) => boolean;
+    getOptimizedDepId: (depInfo: OptimizedDepInfo) => string;
+    options: DepOptimizationOptions;
 }
 export interface DepOptimizationOptions {
     /**
@@ -62,11 +68,13 @@ export interface DepOptimizationOptions {
      */
     extensions?: string[];
     /**
-     * Disables dependencies optimizations
+     * Disables dependencies optimizations, true disables the optimizer during
+     * build and dev. Pass 'build' or 'dev' to only disable the optimizer in
+     * one of the modes. Deps optimization is enabled by default in both
      * @default false
      * @experimental
      */
-    disabled?: boolean;
+    disabled?: boolean | 'build' | 'dev';
 }
 export interface DepOptimizationResult {
     metadata: DepOptimizationMetadata;
@@ -133,7 +141,7 @@ export interface DepOptimizationMetadata {
  * 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 initDepsOptimizerMetadata(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
@@ -145,12 +153,18 @@ export declare function loadCachedDepOptimizationMetadata(config: ResolvedConfig
  * find deps to pre-bundle and include user hard-coded dependencies
  */
 export declare function discoverProjectDependencies(config: ResolvedConfig, timestamp?: string): Promise<Record<string, OptimizedDepInfo>>;
+/**
+ * Create the initial discovered deps list. At build time we only
+ * have the manually included deps. During dev, a scan phase is
+ * performed and knownDeps is the list of discovered deps
+ */
+export declare function initialProjectDependencies(config: ResolvedConfig, timestamp?: string, knownDeps?: Record<string, 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 runOptimizeDeps(resolvedConfig: 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>): {

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

@@ -0,0 +1,4 @@
+import type { ResolvedConfig, ViteDevServer } from '..';
+import type { DepsOptimizer } from '.';
+export declare function getDepsOptimizer(config: ResolvedConfig): DepsOptimizer | undefined;
+export declare function initDepsOptimizer(config: ResolvedConfig, server?: ViteDevServer): Promise<DepsOptimizer>;

package/dist/node/plugin.d.ts

@@ -1,4 +1,5 @@
 import type { CustomPluginOptions, LoadResult, PluginContext, ResolveIdResult, Plugin as RollupPlugin, TransformPluginContext, TransformResult } from 'rollup';
+export type { PluginContext } from 'rollup';
 import type { UserConfig } from './config';
 import type { ServerHook } from './server';
 import type { IndexHtmlTransform } from './plugins/html';

package/dist/node/plugins/optimizedDeps.d.ts

@@ -1,4 +1,7 @@
+import type { ResolvedConfig } from '..';
 import type { Plugin } from '../plugin';
 export declare const ERR_OPTIMIZE_DEPS_PROCESSING_ERROR = "ERR_OPTIMIZE_DEPS_PROCESSING_ERROR";
 export declare const ERR_OUTDATED_OPTIMIZED_DEP = "ERR_OUTDATED_OPTIMIZED_DEP";
-export declare function optimizedDepsPlugin(): Plugin;
+export declare function registerWorkersSource(config: ResolvedConfig, id: string): void;
+export declare function optimizedDepsPlugin(config: ResolvedConfig): Plugin;
+export declare function optimizedDepsBuildPlugin(config: ResolvedConfig): Plugin;

package/dist/node/plugins/preAlias.d.ts

@@ -1,5 +1,6 @@
+import type { ResolvedConfig } from '..';
 import type { Plugin } from '../plugin';
 /**
  * A plugin to avoid an aliased AND optimized dep from being aliased in src
  */
-export declare function preAliasPlugin(): Plugin;
+export declare function preAliasPlugin(config: ResolvedConfig): Plugin;

package/dist/node/plugins/resolve.d.ts

@@ -1,6 +1,7 @@
 import type { PartialResolvedId } from 'rollup';
 import type { Plugin } from '../plugin';
-import type { SSROptions, ViteDevServer } from '..';
+import type { DepsOptimizer } from '../optimizer';
+import type { SSROptions } from '..';
 import type { PackageCache, PackageData } from '../packages';
 export declare const browserExternalId = "__vite-browser-external";
 export interface ResolveOptions {
@@ -31,9 +32,10 @@ export interface InternalResolveOptions extends ResolveOptions {
     isFromTsImporter?: boolean;
     tryEsmOnly?: boolean;
     scan?: boolean;
+    getDepsOptimizer?: () => DepsOptimizer | undefined;
 }
 export declare function resolvePlugin(baseOptions: InternalResolveOptions): Plugin;
 export declare const idToPkgMap: Map<string, PackageData>;
-export declare function tryNodeResolve(id: string, importer: string | null | undefined, options: InternalResolveOptions, targetWeb: boolean, server?: ViteDevServer, ssr?: boolean): PartialResolvedId | undefined;
-export declare function tryOptimizedResolve(id: string, server: ViteDevServer, importer?: string): Promise<string | undefined>;
+export declare function tryNodeResolve(id: string, importer: string | null | undefined, options: InternalResolveOptions, targetWeb: boolean, depsOptimizer?: DepsOptimizer, ssr?: boolean): PartialResolvedId | undefined;
+export declare function tryOptimizedResolve(depsOptimizer: DepsOptimizer, id: string, importer?: string): Promise<string | undefined>;
 export declare function resolvePackageEntry(id: string, { dir, data, setResolvedCache, getResolvedCache }: PackageData, targetWeb: boolean, options: InternalResolveOptions): string | undefined;