vite 2.9.0-beta.2 → 2.9.0-beta.3

package/dist/node/chunks/{dep-183d31dd.js → dep-192b3800.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./dep-6ae84d6b.js');
+var index = require('./dep-19d0f55f.js');
 var require$$1 = require('crypto');
 require('fs');
 require('path');

package/dist/node/chunks/{dep-6ae84d6b.js → dep-19d0f55f.js}

@@ -18935,7 +18935,7 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
         replacer: urlReplacer
     }));
     if (isModule) {
-        postcssPlugins.unshift((await Promise.resolve().then(function () { return require('./dep-ce77a218.js'); }).then(function (n) { return n.index; })).default({
+        postcssPlugins.unshift((await Promise.resolve().then(function () { return require('./dep-ca2a26a1.js'); }).then(function (n) { return n.index; })).default({
             ...modulesOptions,
             getJSON(cssFileName, _modules, outputFileName) {
                 modules = _modules;
@@ -21393,7 +21393,7 @@ const assetAttrsConfig = {
 const isAsyncScriptMap = new WeakMap();
 async function traverseHtml(html, filePath, visitor) {
     // lazy load compiler
-    const { parse, transform } = await Promise.resolve().then(function () { return require('./dep-c4c66661.js'); }).then(function (n) { return n.compilerDom_cjs; });
+    const { parse, transform } = await Promise.resolve().then(function () { return require('./dep-f14ba655.js'); }).then(function (n) { return n.compilerDom_cjs; });
     // @vue/compiler-core doesn't like lowercase doctypes
     html = html.replace(/<!doctype\s/i, '<!DOCTYPE ');
     try {
@@ -35633,7 +35633,8 @@ const isDebugEnabled = _debug('vite:deps').enabled;
 async function optimizeDeps(config, force = config.server.force, asCommand = false, newDeps, // missing imports encountered after server has started
 ssr) {
     const { metadata, run } = await createOptimizeDepsRun(config, force, asCommand, null, newDeps, ssr);
-    await run();
+    const result = await run();
+    result.commit();
     return metadata;
 }
 /**
@@ -35661,8 +35662,7 @@ ssr) {
         hash: mainHash,
         browserHash: mainHash,
         optimized: {},
-        discovered: {},
-        processing: processing.promise
+        discovered: {}
     };
     if (!force) {
         let prevData;
@@ -35674,9 +35674,20 @@ ssr) {
         // hash is consistent, no need to re-bundle
         if (prevData && prevData.hash === metadata.hash) {
             log('Hash is consistent. Skipping. Use --force to override.');
+            // Nothing to commit or cancel as we are using the cache, we only
+            // need to resolve the processing promise so requests can move on
+            const resolve = () => {
+                processing.resolve();
+            };
             return {
                 metadata: prevData,
-                run: () => (processing.resolve(), processing.promise)
+                run: async () => {
+                    return {
+                        alteredFiles: false,
+                        commit: resolve,
+                        cancel: resolve
+                    };
+                }
             };
         }
     }
@@ -35742,15 +35753,20 @@ ssr) {
     async function prebundleDeps() {
         // We prebundle dependencies with esbuild and cache them, but there is no need
         // to wait here. Code that needs to access the cached deps needs to await
-        // the optimizeDepsMetadata.processing promise
+        // the optimizeDepInfo.processing promise for each dep
         var _a, _b, _c, _d;
         const qualifiedIds = Object.keys(deps);
         if (!qualifiedIds.length) {
-            // Write metadata file, delete `deps` folder and rename the `processing` folder to `deps`
-            commitProcessingDepsCacheSync();
-            log(`No dependencies to bundle. Skipping.\n\n\n`);
-            processing.resolve();
-            return;
+            return {
+                alteredFiles: false,
+                commit() {
+                    // Write metadata file, delete `deps` folder and rename the `processing` folder to `deps`
+                    commitProcessingDepsCacheSync();
+                    log(`No dependencies to bundle. Skipping.\n\n\n`);
+                    processing.resolve();
+                },
+                cancel
+            };
         }
         let depsString;
         if (isDebugEnabled) {
@@ -35896,24 +35912,36 @@ ssr) {
             }
             metadata.browserHash = newBrowserHash;
         }
-        // Write metadata file, delete `deps` folder and rename the new `processing` folder to `deps` in sync
-        commitProcessingDepsCacheSync();
         debug$d(`deps bundled in ${(perf_hooks.performance.now() - start).toFixed(2)}ms`);
-        processing.resolve({ alteredFiles });
-        return processing.promise;
+        return {
+            alteredFiles,
+            commit() {
+                // Write metadata file, delete `deps` folder and rename the new `processing` folder to `deps` in sync
+                commitProcessingDepsCacheSync();
+                processing.resolve();
+            },
+            cancel
+        };
     }
     function commitProcessingDepsCacheSync() {
-        var _a;
         // Rewire the file paths from the temporal processing dir to the final deps cache dir
         const dataPath = path__default.join(processingCacheDir, '_metadata.json');
         writeFile(dataPath, stringifyOptimizedDepsMetadata(metadata, depsCacheDir));
         // Processing is done, we can now replace the depsCacheDir with processingCacheDir
-        if (fs__default.existsSync(depsCacheDir)) {
-            const rmSync = (_a = fs__default.rmSync) !== null && _a !== void 0 ? _a : fs__default.rmdirSync; // TODO: Remove after support for Node 12 is dropped
-            rmSync(depsCacheDir, { recursive: true });
-        }
+        removeDirSync(depsCacheDir);
         fs__default.renameSync(processingCacheDir, depsCacheDir);
     }
+    function cancel() {
+        removeDirSync(processingCacheDir);
+        processing.resolve();
+    }
+}
+function removeDirSync(dir) {
+    var _a;
+    if (fs__default.existsSync(dir)) {
+        const rmSync = (_a = fs__default.rmSync) !== null && _a !== void 0 ? _a : fs__default.rmdirSync; // TODO: Remove after support for Node 12 is dropped
+        rmSync(dir, { recursive: true });
+    }
 }
 async function findKnownImports(config) {
     const deps = (await scanImports(config)).deps;
@@ -36002,7 +36030,7 @@ function parseOptimizedDepsMetadata(jsonMetadata, depsCacheDir, processing) {
     for (const o of Object.keys(metadata.optimized)) {
         metadata.optimized[o].processing = processing;
     }
-    return { ...metadata, discovered: {}, processing };
+    return { ...metadata, discovered: {} };
 }
 function stringifyOptimizedDepsMetadata(metadata, depsCacheDir) {
     return JSON.stringify(metadata, (key, value) => {
@@ -43475,7 +43503,7 @@ async function getCertificate(cacheDir) {
         return content;
     }
     catch {
-        const content = (await Promise.resolve().then(function () { return require('./dep-183d31dd.js'); })).createCertificate();
+        const content = (await Promise.resolve().then(function () { return require('./dep-192b3800.js'); })).createCertificate();
         fs$n.promises
             .mkdir(cacheDir, { recursive: true })
             .then(() => fs$n.promises.writeFile(cachePath, content))
@@ -54449,13 +54477,26 @@ function isPrimitive(value) {
  * a re-bundle + page reload
  */
 const debounceMs = 100;
-function createMissingImporterRegisterFn(server) {
+function createMissingImporterRegisterFn(server, initialProcessingPromise) {
     const { logger } = server.config;
     let metadata = server._optimizeDepsMetadata;
     let handle;
-    let needFullReload = false;
+    let newDepsDiscovered = false;
     let depOptimizationProcessing = newDepOptimizationProcessing();
-    let lastDepOptimizationPromise = metadata.processing;
+    let depOptimizationProcessingQueue = [];
+    const resolveEnqueuedProcessingPromises = () => {
+        // Resolve all the processings (including the ones which were delayed)
+        for (const processing of depOptimizationProcessingQueue) {
+            processing.resolve();
+        }
+        depOptimizationProcessingQueue = [];
+    };
+    let enqueuedRerun;
+    let currentlyProcessing = true;
+    initialProcessingPromise.then(() => {
+        currentlyProcessing = false;
+        enqueuedRerun === null || enqueuedRerun === void 0 ? void 0 : enqueuedRerun();
+    });
     async function rerun(ssr) {
         // debounce time to wait for new missing deps finished, issue a new
         // optimization of deps (both old and newly found) once the previous
@@ -54467,74 +54508,70 @@ function createMissingImporterRegisterFn(server) {
         // the previous bundled dependencies have changed.
         // if the rerun fails, server._optimizeDepsMetadata remains untouched,
         // current discovered deps are cleaned, and a fullReload is issued
-        // optimizeDeps needs to be run in serie. Await until the previous
-        // rerun is finished here. It could happen that two reruns are queued
-        // in that case, we only need to run one of them
-        const awaitedOptimizeDepsPromise = lastDepOptimizationPromise;
-        await lastDepOptimizationPromise;
-        if (awaitedOptimizeDepsPromise !== lastDepOptimizationPromise) {
-            // There were two or more rerun queued and one of them already
-            // started. Only let through the first one, and discard the others
-            return;
-        }
-        if (handle) {
-            // New deps could have been found here, skip this rerun. Once the
-            // debounce time is over, a new rerun will be issued
-            return;
-        }
+        // Ensure that rerun is called sequentially
+        enqueuedRerun = undefined;
+        currentlyProcessing = true;
         logger.info(colors$1.yellow(`new dependencies found: ${Object.keys(metadata.discovered).join(', ')}, updating...`), {
             timestamp: true
         });
         // All deps, previous known and newly discovered are rebundled,
         // respect insertion order to keep the metadata file stable
+        const newDeps = {};
         // Clone optimized info objects, fileHash, browserHash may be changed for them
-        const clonedOptimizedDeps = {};
-        for (const o of Object.keys(metadata.optimized)) {
-            clonedOptimizedDeps[o] = { ...metadata.optimized[o] };
-        }
-        const newDeps = { ...clonedOptimizedDeps, ...metadata.discovered };
-        const thisDepOptimizationProcessing = depOptimizationProcessing;
-        // Other rerun will await until this run is finished
-        lastDepOptimizationPromise = thisDepOptimizationProcessing.promise;
-        let processingResult;
+        for (const dep of Object.keys(metadata.optimized)) {
+            newDeps[dep] = { ...metadata.optimized[dep] };
+        }
+        // Don't clone discovered info objects, they are read after awaited
+        for (const dep of Object.keys(metadata.discovered)) {
+            newDeps[dep] = metadata.discovered[dep];
+        }
+        newDepsDiscovered = false;
+        // Add the current depOptimizationProcessing to the queue, these
+        // promises are going to be resolved once a rerun is committed
+        depOptimizationProcessingQueue.push(depOptimizationProcessing);
         // Create a new promise for the next rerun, discovered missing
         // dependencies will be asigned this promise from this point
         depOptimizationProcessing = newDepOptimizationProcessing();
         let newData = null;
         try {
             const optimizeDeps = await createOptimizeDepsRun(server.config, true, false, metadata, newDeps, ssr);
-            // We await the optimizeDeps run here, we are only going to use
-            // the newData if there wasn't an error
-            newData = optimizeDeps.metadata;
-            processingResult = await optimizeDeps.run();
-            // update ssr externals
-            if (ssr) {
-                server._ssrExternals = resolveSSRExternal(server.config, Object.keys(newData.optimized));
-            }
-            // While optimizeDeps is running, new missing deps may be discovered,
-            // in which case they will keep being added to metadata.discovered
-            for (const o of Object.keys(metadata.discovered)) {
-                if (!newData.optimized[o]) {
-                    newData.discovered[o] = metadata.discovered[o];
-                }
-            }
-            newData.processing = thisDepOptimizationProcessing.promise;
-            metadata = server._optimizeDepsMetadata = newData;
-            if (!needFullReload && !(processingResult === null || processingResult === void 0 ? void 0 : processingResult.alteredFiles)) {
+            const processingResult = await optimizeDeps.run();
+            const commitProcessing = () => {
+                processingResult.commit();
+                newData = optimizeDeps.metadata;
+                // update ssr externals
+                if (ssr) {
+                    server._ssrExternals = resolveSSRExternal(server.config, Object.keys(newData.optimized));
+                }
+                // While optimizeDeps is running, new missing deps may be discovered,
+                // in which case they will keep being added to metadata.discovered
+                for (const o of Object.keys(metadata.discovered)) {
+                    if (!newData.optimized[o]) {
+                        newData.discovered[o] = metadata.discovered[o];
+                    }
+                }
+                metadata = server._optimizeDepsMetadata = newData;
+                resolveEnqueuedProcessingPromises();
+            };
+            if (!processingResult.alteredFiles) {
+                commitProcessing();
                 logger.info(colors$1.green(`✨ new dependencies pre-bundled...`), {
                     timestamp: true
                 });
             }
             else {
-                if (Object.keys(metadata.discovered).length > 0) {
+                if (newDepsDiscovered) {
                     // There are newly discovered deps, and another rerun is about to be
-                    // excecuted. Avoid the current full reload, but queue it for the next one
-                    needFullReload = true;
-                    logger.info(colors$1.green(`✨ dependencies updated, delaying reload as new dependencies have been found...`), {
+                    // excecuted. Avoid the current full reload discarding this rerun result
+                    // We don't resolve the processing promise, as they will be resolved
+                    // once a rerun is committed
+                    processingResult.cancel();
+                    logger.info(colors$1.green(`✨ delaying reload as new dependencies have been found...`), {
                         timestamp: true
                     });
                 }
                 else {
+                    commitProcessing();
                     logger.info(colors$1.green(`✨ dependencies updated, reloading page...`), {
                         timestamp: true
                     });
@@ -54544,15 +54581,14 @@ function createMissingImporterRegisterFn(server) {
         }
         catch (e) {
             logger.error(colors$1.red(`error while updating dependencies:\n${e.stack}`), { timestamp: true, error: e });
+            resolveEnqueuedProcessingPromises();
             // Reset missing deps, let the server rediscover the dependencies
             metadata.discovered = {};
             fullReload();
         }
-        finally {
-            // Rerun finished, resolve the promise to let awaiting requests or
-            // other rerun queued be processed
-            thisDepOptimizationProcessing.resolve();
-        }
+        currentlyProcessing = false;
+        // @ts-ignore
+        enqueuedRerun === null || enqueuedRerun === void 0 ? void 0 : enqueuedRerun();
     }
     function fullReload() {
         // Cached transform results have stale imports (resolved to
@@ -54563,7 +54599,6 @@ function createMissingImporterRegisterFn(server) {
             type: 'full-reload',
             path: '*'
         });
-        needFullReload = false;
     }
     return function registerMissingImport(id, resolved, ssr) {
         const optimized = metadata.optimized[id];
@@ -54576,6 +54611,7 @@ function createMissingImporterRegisterFn(server) {
             // It will be processed in the next rerun call
             return missing;
         }
+        newDepsDiscovered = true;
         missing = metadata.discovered[id] = {
             file: getOptimizedDepPath(id, server.config),
             src: resolved,
@@ -54590,11 +54626,15 @@ function createMissingImporterRegisterFn(server) {
         };
         // Debounced rerun, let other missing dependencies be discovered before
         // the running next optimizeDeps
+        enqueuedRerun = undefined;
         if (handle)
             clearTimeout(handle);
         handle = setTimeout(() => {
             handle = undefined;
-            rerun(ssr);
+            enqueuedRerun = () => rerun(ssr);
+            if (!currentlyProcessing) {
+                enqueuedRerun();
+            }
         }, debounceMs);
         // Return the path for the optimized bundle, this path is known before
         // esbuild is run to generate the pre-bundle
@@ -54712,7 +54752,6 @@ async function createServer(inlineConfig = {}) {
             let configFileDependencies = [];
             const metadata = server._optimizeDepsMetadata;
             if (metadata) {
-                await metadata.processing;
                 configFileDependencies = Object.keys(metadata.optimized);
             }
             server._ssrExternals || (server._ssrExternals = resolveSSRExternal(config, configFileDependencies));
@@ -54889,11 +54928,14 @@ async function createServer(inlineConfig = {}) {
         // Don't await for the optimization to finish, we can start the
         // server right away here
         server._optimizeDepsMetadata = optimizeDeps.metadata;
-        optimizeDeps.run();
+        // Run deps optimization in parallel
+        const initialProcessingPromise = optimizeDeps
+            .run()
+            .then((result) => result.commit());
         // While running the first optimizeDeps, _registerMissingImport is null
         // so the resolve plugin resolves straight to node_modules during the
         // deps discovery scan phase
-        server._registerMissingImport = createMissingImporterRegisterFn(server);
+        server._registerMissingImport = createMissingImporterRegisterFn(server, initialProcessingPromise);
     };
     if (!middlewareMode && httpServer) {
         let isOptimized = false;
@@ -55523,7 +55565,7 @@ function importAnalysisPlugin(config) {
                 const isRelative = url.startsWith('.');
                 const isSelfImport = !isRelative && cleanUrl(url) === cleanUrl(importer);
                 // normalize all imports into resolved URLs
-                // e.g. `import 'foo'` -> `import '/@fs/.../node_modules/foo/index.js`
+                // e.g. `import 'foo'` -> `import '/@fs/.../node_modules/foo/index.js'`
                 if (resolved.id.startsWith(root + '/')) {
                     // in root: infer short absolute path from root
                     url = resolved.id.slice(root.length);
@@ -55584,6 +55626,10 @@ function importAnalysisPlugin(config) {
                 }
                 return [url, resolved.id];
             };
+            // Import rewrites, we do them after all the URLs have been resolved
+            // to help with the discovery of new dependencies. If we need to wait
+            // for each dependency there could be one reload per import
+            const importRewrites = [];
             for (let index = 0; index < imports.length; index++) {
                 const { s: start, e: end, ss: expStart, se: expEnd, d: dynamicIndex, 
                 // #2083 User may use escape path,
@@ -55667,48 +55713,49 @@ function importAnalysisPlugin(config) {
                     const url = normalizedUrl;
                     // record as safe modules
                     server === null || server === void 0 ? void 0 : server.moduleGraph.safeModulesPath.add(fsPathFromUrl(url));
-                    // rewrite
                     if (url !== specifier) {
-                        let rewriteDone = false;
-                        if (isOptimizedDepFile(resolvedId, config) &&
-                            !resolvedId.match(optimizedDepChunkRE)) {
-                            // for optimized cjs deps, support named imports by rewriting named imports to const assignments.
-                            // internal optimized chunks don't need es interop and are excluded
-                            // The browserHash in resolvedId could be stale in which case there will be a full
-                            // page reload. We could return a 404 in that case but it is safe to return the request
-                            const file = cleanUrl(resolvedId); // Remove ?v={hash}
-                            const needsInterop = await optimizedDepNeedsInterop(server._optimizeDepsMetadata, file);
-                            if (needsInterop === undefined) {
-                                // Non-entry dynamic imports from dependencies will reach here as there isn't
-                                // optimize info for them, but they don't need es interop. If the request isn't
-                                // a dynamic import, then it is an internal Vite error
-                                if (!file.match(optimizedDepDynamicRE)) {
-                                    config.logger.error(colors$1.red(`Vite Error, ${url} optimized info should be defined`));
-                                }
-                            }
-                            else if (needsInterop) {
-                                debug$1(`${url} needs interop`);
-                                if (isDynamicImport) {
-                                    // rewrite `import('package')` to expose the default directly
-                                    str().overwrite(dynamicIndex, end + 1, `import('${url}').then(m => m.default && m.default.__esModule ? m.default : ({ ...m.default, default: m.default }))`);
+                        importRewrites.push(async () => {
+                            let rewriteDone = false;
+                            if (isOptimizedDepFile(resolvedId, config) &&
+                                !resolvedId.match(optimizedDepChunkRE)) {
+                                // for optimized cjs deps, support named imports by rewriting named imports to const assignments.
+                                // internal optimized chunks don't need es interop and are excluded
+                                // The browserHash in resolvedId could be stale in which case there will be a full
+                                // page reload. We could return a 404 in that case but it is safe to return the request
+                                const file = cleanUrl(resolvedId); // Remove ?v={hash}
+                                const needsInterop = await optimizedDepNeedsInterop(server._optimizeDepsMetadata, file);
+                                if (needsInterop === undefined) {
+                                    // Non-entry dynamic imports from dependencies will reach here as there isn't
+                                    // optimize info for them, but they don't need es interop. If the request isn't
+                                    // a dynamic import, then it is an internal Vite error
+                                    if (!file.match(optimizedDepDynamicRE)) {
+                                        config.logger.error(colors$1.red(`Vite Error, ${url} optimized info should be defined`));
+                                    }
                                 }
-                                else {
-                                    const exp = source.slice(expStart, expEnd);
-                                    const rewritten = transformCjsImport(exp, url, rawUrl, index);
-                                    if (rewritten) {
-                                        str().overwrite(expStart, expEnd, rewritten);
+                                else if (needsInterop) {
+                                    debug$1(`${url} needs interop`);
+                                    if (isDynamicImport) {
+                                        // rewrite `import('package')` to expose the default directly
+                                        str().overwrite(dynamicIndex, end + 1, `import('${url}').then(m => m.default && m.default.__esModule ? m.default : ({ ...m.default, default: m.default }))`);
                                     }
                                     else {
-                                        // #1439 export * from '...'
-                                        str().overwrite(start, end, url);
+                                        const exp = source.slice(expStart, expEnd);
+                                        const rewritten = transformCjsImport(exp, url, rawUrl, index);
+                                        if (rewritten) {
+                                            str().overwrite(expStart, expEnd, rewritten);
+                                        }
+                                        else {
+                                            // #1439 export * from '...'
+                                            str().overwrite(start, end, url);
+                                        }
                                     }
+                                    rewriteDone = true;
                                 }
-                                rewriteDone = true;
                             }
-                        }
-                        if (!rewriteDone) {
-                            str().overwrite(start, end, isDynamicImport ? `'${url}'` : url);
-                        }
+                            if (!rewriteDone) {
+                                str().overwrite(start, end, isDynamicImport ? `'${url}'` : url);
+                            }
+                        });
                     }
                     // record for HMR import chain analysis
                     // make sure to normalize away base
@@ -55804,9 +55851,23 @@ function importAnalysisPlugin(config) {
             if (config.server.preTransformRequests && staticImportedUrls.size) {
                 staticImportedUrls.forEach((url) => {
                     url = unwrapId$1(removeImportQuery(url)).replace(NULL_BYTE_PLACEHOLDER, '\0');
-                    transformRequest(url, server, { ssr });
+                    transformRequest(url, server, { ssr }).catch((e) => {
+                        if ((e === null || e === void 0 ? void 0 : e.code) === ERR_OUTDATED_OPTIMIZED_DEP) {
+                            // This are expected errors
+                            return;
+                        }
+                        // Unexpected error, log the issue but avoid an unhandled exception
+                        config.logger.error(e.message);
+                    });
                 });
             }
+            // Await for import rewrites that requires dependencies to be pre-bundled to
+            // know if es interop is needed after starting further transformRequest calls
+            // This will let Vite process deeper into the user code and find more missing
+            // dependencies before the next page reload
+            for (const rewrite of importRewrites) {
+                await rewrite();
+            }
             if (s) {
                 return s.toString();
             }

package/dist/node/chunks/{dep-ce77a218.js → dep-ca2a26a1.js}

@@ -1,7 +1,7 @@
 'use strict';
 
 var require$$0 = require('postcss');
-var index$1 = require('./dep-6ae84d6b.js');
+var index$1 = require('./dep-19d0f55f.js');
 var path$2 = require('path');
 var require$$1 = require('crypto');
 var fs = require('fs');

package/dist/node/chunks/{dep-c4c66661.js → dep-f14ba655.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./dep-6ae84d6b.js');
+var index = require('./dep-19d0f55f.js');
 
 function _mergeNamespaces(n, m) {
     for (var i = 0; i < m.length; i++) {

package/dist/node/cli.js

@@ -1,7 +1,7 @@
 'use strict';
 
 var require$$0 = require('events');
-var index = require('./chunks/dep-6ae84d6b.js');
+var index = require('./chunks/dep-19d0f55f.js');
 var perf_hooks = require('perf_hooks');
 require('fs');
 require('path');
@@ -683,7 +683,7 @@ cli
     .action(async (root, options) => {
     // output structure is preserved even after bundling so require()
     // is ok here
-    const { createServer } = await Promise.resolve().then(function () { return require('./chunks/dep-6ae84d6b.js'); }).then(function (n) { return n.index$1; });
+    const { createServer } = await Promise.resolve().then(function () { return require('./chunks/dep-19d0f55f.js'); }).then(function (n) { return n.index$1; });
     try {
         const server = await createServer({
             root,
@@ -732,7 +732,7 @@ cli
     .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 Promise.resolve().then(function () { return require('./chunks/dep-6ae84d6b.js'); }).then(function (n) { return n.build$1; });
+    const { build } = await Promise.resolve().then(function () { return require('./chunks/dep-19d0f55f.js'); }).then(function (n) { return n.build$1; });
     const buildOptions = cleanOptions(options);
     try {
         await build({
@@ -755,7 +755,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 Promise.resolve().then(function () { return require('./chunks/dep-6ae84d6b.js'); }).then(function (n) { return n.index; });
+    const { optimizeDeps } = await Promise.resolve().then(function () { return require('./chunks/dep-19d0f55f.js'); }).then(function (n) { return n.index; });
     try {
         const config = await index.resolveConfig({
             root,
@@ -778,7 +778,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 Promise.resolve().then(function () { return require('./chunks/dep-6ae84d6b.js'); }).then(function (n) { return n.preview$1; });
+    const { preview } = await Promise.resolve().then(function () { return require('./chunks/dep-19d0f55f.js'); }).then(function (n) { return n.preview$1; });
     try {
         const server = await preview({
             root,

package/dist/node/index.d.ts

@@ -520,11 +520,6 @@ export declare interface DepOptimizationMetadata {
      * Metadata for each newly discovered dependency after processing
      */
     discovered: Record<string, OptimizedDepInfo>;
-    /**
-     * During optimization, ids can still be resolved to their final location
-     * but the bundles may not yet be saved to disk
-     */
-    processing: Promise<DepOptimizationResult | undefined>;
 }
 
 export declare interface DepOptimizationOptions {
@@ -579,8 +574,8 @@ export declare interface DepOptimizationOptions {
 }
 
 export declare interface DepOptimizationProcessing {
-    promise: Promise<DepOptimizationResult | undefined>;
-    resolve: (result?: DepOptimizationResult) => void;
+    promise: Promise<void>;
+    resolve: () => void;
 }
 
 export declare interface DepOptimizationResult {
@@ -591,6 +586,13 @@ export declare interface DepOptimizationResult {
      * for large applications
      */
     alteredFiles: boolean;
+    /**
+     * When doing a re-run, if there are newly discovered dependendencies
+     * the page reload will be delayed until the next rerun so the
+     * result will be discarded
+     */
+    commit: () => void;
+    cancel: () => void;
 }
 
 export declare interface ErrorPayload {
@@ -1180,7 +1182,7 @@ export declare interface OptimizedDepInfo {
      * During optimization, ids can still be resolved to their final location
      * but the bundles may not yet be saved to disk
      */
-    processing: Promise<DepOptimizationResult | undefined>;
+    processing: Promise<void>;
 }
 
 /**

package/dist/node/index.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var index = require('./chunks/dep-6ae84d6b.js');
+var index = require('./chunks/dep-19d0f55f.js');
 require('fs');
 require('path');
 require('tty');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite",
-  "version": "2.9.0-beta.2",
+  "version": "2.9.0-beta.3",
   "license": "MIT",
   "author": "Evan You",
   "description": "Native-ESM powered web dev build tool",
@@ -43,7 +43,7 @@
   },
   "//": "READ CONTRIBUTING.md to understand what to put under deps vs. devDeps!",
   "dependencies": {
-    "esbuild": "^0.14.14",
+    "esbuild": "^0.14.27",
     "postcss": "^8.4.6",
     "resolve": "^1.22.0",
     "rollup": "^2.59.0"