vite 2.9.0-beta.0 → 2.9.0-beta.3

package/dist/node/chunks/{dep-5f1b3f27.js → dep-192b3800.js}

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

package/dist/node/chunks/{dep-429629d5.js → dep-19d0f55f.js}

@@ -4464,7 +4464,7 @@ function checkPublicFile(url, { publicDir }) {
         return;
     }
 }
-function fileToUrl(id, config, ctx) {
+async function fileToUrl(id, config, ctx) {
     if (config.command === 'serve') {
         return fileToDevUrl(id, config);
     }
@@ -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-229a03bb.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-026034b4.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
+                    };
+                }
             };
         }
     }
@@ -35692,6 +35703,7 @@ ssr) {
     // a hint for Node.js
     // all files in the cache directory should be recognized as ES modules
     writeFile(path__default.resolve(processingCacheDir, 'package.json'), JSON.stringify({ type: 'module' }));
+    let newBrowserHash;
     let deps;
     if (!newDeps) {
         // Initial optimizeDeps at server start. Perform a fast scan using esbuild to
@@ -35713,7 +35725,7 @@ ssr) {
             throw e;
         }
         // update browser hash
-        metadata.browserHash = getOptimizedBrowserHash(metadata.hash, deps);
+        newBrowserHash = metadata.browserHash = getOptimizedBrowserHash(metadata.hash, deps);
         // We generate the mapping of dependency ids to their cache file location
         // before processing the dependencies with esbuild. This allow us to continue
         // processing files in the importAnalysis and resolve plugins
@@ -35722,7 +35734,7 @@ ssr) {
             metadata.optimized[id] = {
                 file: getOptimizedDepPath(id, config),
                 src: entry,
-                browserHash: metadata.browserHash,
+                browserHash: newBrowserHash,
                 processing: processing.promise
             };
         }
@@ -35731,27 +35743,30 @@ ssr) {
         // Missing dependencies were found at run-time, optimizeDeps called while the
         // server is running
         deps = depsFromOptimizedDepInfo(newDeps);
-        // Clone optimized info objects, fileHash, browserHash may be changed for them
-        for (const o of Object.keys(newDeps)) {
-            metadata.optimized[o] = { ...newDeps[o] };
-        }
-        // update global browser hash, but keep newDeps individual hashs until we know
+        metadata.optimized = newDeps;
+        // For reruns keep current global browser hash and newDeps individual hashes until we know
         // if files are stable so we can avoid a full page reload
-        metadata.browserHash = getOptimizedBrowserHash(metadata.hash, deps);
+        metadata.browserHash = currentData.browserHash;
+        newBrowserHash = getOptimizedBrowserHash(metadata.hash, deps);
     }
     return { metadata, run: prebundleDeps };
     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) {
@@ -35893,27 +35908,40 @@ ssr) {
             // New deps that ended up with a different hash replaced while doing analysis import are going to
             // return a not found so the browser doesn't cache them. And will properly get loaded after the reload
             for (const id in deps) {
-                metadata.optimized[id].browserHash = metadata.browserHash;
+                metadata.optimized[id].browserHash = newBrowserHash;
             }
+            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));
+        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;
@@ -35991,16 +36019,27 @@ function createIsOptimizedDepUrl(config) {
     };
 }
 function parseOptimizedDepsMetadata(jsonMetadata, depsCacheDir, processing) {
-    const metadata = JSON.parse(jsonMetadata);
+    const metadata = JSON.parse(jsonMetadata, (key, value) => {
+        // Paths can be absolute or relative to the deps cache dir where
+        // the _metadata.json is located
+        if (key === 'file' || key === 'src') {
+            return normalizePath$4(path__default.resolve(depsCacheDir, value));
+        }
+        return value;
+    });
     for (const o of Object.keys(metadata.optimized)) {
         metadata.optimized[o].processing = processing;
     }
-    return { ...metadata, discovered: {}, processing };
+    return { ...metadata, discovered: {} };
 }
-function stringifyOptimizedDepsMetadata(metadata) {
+function stringifyOptimizedDepsMetadata(metadata, depsCacheDir) {
     return JSON.stringify(metadata, (key, value) => {
-        if (key === 'processing' || key === 'discovered')
+        if (key === 'processing' || key === 'discovered') {
             return;
+        }
+        if (key === 'file' || key === 'src') {
+            return normalizePath$4(path__default.relative(depsCacheDir, value));
+        }
         return value;
     }, 2);
 }
@@ -36068,6 +36107,26 @@ function getDepHash(root, config) {
     });
     return require$$1$1.createHash('sha256').update(content).digest('hex').substring(0, 8);
 }
+function optimizeDepInfoFromFile(metadata, file) {
+    return (findFileInfo(metadata.optimized, file) ||
+        findFileInfo(metadata.discovered, file));
+}
+function findFileInfo(dependenciesInfo, file) {
+    for (const o of Object.keys(dependenciesInfo)) {
+        const info = dependenciesInfo[o];
+        if (info.file === file) {
+            return info;
+        }
+    }
+}
+async function optimizedDepNeedsInterop(metadata, file) {
+    const depInfo = optimizeDepInfoFromFile(metadata, file);
+    if (!depInfo)
+        return undefined;
+    // Wait until the dependency has been pre-bundled
+    await depInfo.processing;
+    return depInfo === null || depInfo === void 0 ? void 0 : depInfo.needsInterop;
+}
 
 var index$1 = {
 	__proto__: null,
@@ -36081,7 +36140,9 @@ var index$1 = {
 	getDepsCacheDir: getDepsCacheDir,
 	getProcessingDepsCacheDir: getProcessingDepsCacheDir,
 	isOptimizedDepFile: isOptimizedDepFile,
-	createIsOptimizedDepUrl: createIsOptimizedDepUrl
+	createIsOptimizedDepUrl: createIsOptimizedDepUrl,
+	optimizeDepInfoFromFile: optimizeDepInfoFromFile,
+	optimizedDepNeedsInterop: optimizedDepNeedsInterop
 };
 
 /**
@@ -36679,7 +36740,7 @@ function tryNodeResolve(id, importer, options, targetWeb, server, ssr) {
             // can cache it without re-validation, but only do so for known js types.
             // otherwise we may introduce duplicated modules for externalized files
             // from pre-bundled deps.
-            const versionHash = (_b = server._optimizeDepsMetadata) === null || _b === void 0 ? void 0 : _b.hash;
+            const versionHash = (_b = server._optimizeDepsMetadata) === null || _b === void 0 ? void 0 : _b.browserHash;
             if (versionHash && isJsType) {
                 resolved = injectQuery(resolved, `v=${versionHash}`);
             }
@@ -36934,12 +36995,24 @@ function getRealPath(resolved, preserveSymlinks) {
 }
 
 const debug$a = createDebugger('vite:ssr-external');
+/**
+ * Converts "parent > child" syntax to just "child"
+ */
+function stripNesting(packages) {
+    return packages.map((s) => {
+        const arr = s.split('>');
+        return arr[arr.length - 1].trim();
+    });
+}
 /**
  * Heuristics for determining whether a dependency should be externalized for
  * server-side rendering.
  */
 function resolveSSRExternal(config, knownImports) {
     var _a;
+    // strip nesting since knownImports may be passed in from optimizeDeps which
+    // supports a "parent > child" syntax
+    knownImports = stripNesting(knownImports);
     const ssrConfig = config.ssr;
     if ((ssrConfig === null || ssrConfig === void 0 ? void 0 : ssrConfig.noExternal) === true) {
         return [];
@@ -37207,7 +37280,12 @@ function assetImportMetaUrlPlugin(config) {
                     }
                     const url = rawUrl.slice(1, -1);
                     const file = path__default.resolve(path__default.dirname(id), url);
-                    const builtUrl = await fileToUrl(file, config, this);
+                    // Get final asset URL. Catch error if the file does not exist,
+                    // in which we can resort to the initial URL and let it resolve in runtime
+                    const builtUrl = await fileToUrl(file, config, this).catch(() => {
+                        config.logger.warnOnce(`\n${exp} doesn't exist at build time, it will remain unchanged to be resolved at runtime`);
+                        return url;
+                    });
                     s.overwrite(index, index + exp.length, `new URL(${JSON.stringify(builtUrl)}, self.location)`);
                 }
                 if (s) {
@@ -43425,7 +43503,7 @@ async function getCertificate(cacheDir) {
         return content;
     }
     catch {
-        const content = (await Promise.resolve().then(function () { return require('./dep-5f1b3f27.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))
@@ -47657,7 +47735,8 @@ function createWebSocketServer(server, config, httpsOptions) {
     let wss;
     let httpsServer = undefined;
     const hmr = isObject$3(config.server.hmr) && config.server.hmr;
-    const wsServer = (hmr && hmr.server) || server;
+    const wsServer = (hmr && hmr.server) ||
+        ((!(hmr && hmr.port) || hmr.port !== config.server.port) && server);
     if (wsServer) {
         wss = new websocketServer({ noServer: true });
         wsServer.on('upgrade', (req, socket, head) => {
@@ -51294,16 +51373,66 @@ const debugCache$1 = createDebugger('vite:cache');
 const isDebug$3 = !!process.env.DEBUG;
 function transformRequest(url, server, options = {}) {
     const cacheKey = (options.ssr ? 'ssr:' : options.html ? 'html:' : '') + url;
-    let request = server._pendingRequests.get(cacheKey);
-    if (!request) {
-        request = doTransform(url, server, options);
-        server._pendingRequests.set(cacheKey, request);
-        const done = () => server._pendingRequests.delete(cacheKey);
-        request.then(done, done);
+    // This module may get invalidated while we are processing it. For example
+    // when a full page reload is needed after the re-processing of pre-bundled
+    // dependencies when a missing dep is discovered. We save the current time
+    // to compare it to the last invalidation performed to know if we should
+    // cache the result of the transformation or we should discard it as stale.
+    //
+    // A module can be invalidated due to:
+    // 1. A full reload because of pre-bundling newly discovered deps
+    // 2. A full reload after a config change
+    // 3. The file that generated the module changed
+    // 4. Invalidation for a virtual module
+    //
+    // For 1 and 2, a new request for this module will be issued after
+    // the invalidation as part of the browser reloading the page. For 3 and 4
+    // there may not be a new request right away because of HMR handling.
+    // In all cases, the next time this module is requested, it should be
+    // re-processed.
+    //
+    // We save the timestap when we start processing and compare it with the
+    // last time this module is invalidated
+    const timestamp = Date.now();
+    const pending = server._pendingRequests.get(cacheKey);
+    if (pending) {
+        return server.moduleGraph
+            .getModuleByUrl(removeTimestampQuery(url), options.ssr)
+            .then((module) => {
+            if (!module || pending.timestamp > module.lastInvalidationTimestamp) {
+                // The pending request is still valid, we can safely reuse its result
+                return pending.request;
+            }
+            else {
+                // Request 1 for module A     (pending.timestamp)
+                // Invalidate module A        (module.lastInvalidationTimestamp)
+                // Request 2 for module A     (timestamp)
+                // First request has been invalidated, abort it to clear the cache,
+                // then perform a new doTransform.
+                pending.abort();
+                return transformRequest(url, server, options);
+            }
+        });
     }
+    const request = doTransform(url, server, options, timestamp);
+    // Avoid clearing the cache of future requests if aborted
+    let cleared = false;
+    const clearCache = () => {
+        if (!cleared) {
+            server._pendingRequests.delete(cacheKey);
+            cleared = true;
+        }
+    };
+    // Cache the request and clear it once processing is done
+    server._pendingRequests.set(cacheKey, {
+        request,
+        timestamp,
+        abort: clearCache
+    });
+    request.then(clearCache, clearCache);
     return request;
 }
-async function doTransform(url, server, options) {
+async function doTransform(url, server, options, timestamp) {
     var _a, _b;
     url = removeTimestampQuery(url);
     const { config, pluginContainer, moduleGraph, watcher } = server;
@@ -51411,16 +51540,22 @@ async function doTransform(url, server, options) {
             await injectSourcesContent(map, mod.file, logger);
         }
     }
-    if (ssr) {
-        return (mod.ssrTransformResult = await ssrTransform(code, map, url));
-    }
-    else {
-        return (mod.transformResult = {
+    const result = ssr
+        ? await ssrTransform(code, map, url)
+        : {
             code,
             map,
             etag: etag_1(code, { weak: true })
-        });
+        };
+    // Only cache the result if the module wasn't invalidated while it was
+    // being processed, so it is re-processed next time if it is stale
+    if (timestamp > mod.lastInvalidationTimestamp) {
+        if (ssr)
+            mod.ssrTransformResult = result;
+        else
+            mod.transformResult = result;
     }
+    return result;
 }
 
 const ERR_OPTIMIZE_DEPS_PROCESSING_ERROR = 'ERR_OPTIMIZE_DEPS_PROCESSING_ERROR';
@@ -51443,6 +51578,7 @@ function optimizedDepsPlugin() {
                     const browserHash = versionMatch
                         ? versionMatch[1].split('=')[1]
                         : undefined;
+                    // Search in both the currently optimized and newly discovered deps
                     const info = optimizeDepInfoFromFile(metadata, file);
                     if (info) {
                         if (browserHash && info.browserHash !== browserHash) {
@@ -51499,18 +51635,6 @@ function throwOutdatedRequest(id) {
     // send a 504 status code request timeout
     throw err;
 }
-function optimizeDepInfoFromFile(metadata, file) {
-    return (findFileInfo(metadata.optimized, file) ||
-        findFileInfo(metadata.discovered, file));
-}
-function findFileInfo(dependenciesInfo, file) {
-    for (const o of Object.keys(dependenciesInfo)) {
-        const info = dependenciesInfo[o];
-        if (info.file === file) {
-            return info;
-        }
-    }
-}
 
 const debugCache = createDebugger('vite:cache');
 const isDebug$1 = !!process.env.DEBUG;
@@ -51633,8 +51757,8 @@ function transformMiddleware(server) {
         }
         catch (e) {
             if ((e === null || e === void 0 ? void 0 : e.code) === ERR_OPTIMIZE_DEPS_PROCESSING_ERROR) {
+                // Skip if response has already been sent
                 if (!res.writableEnded) {
-                    // Don't do anything if response has already been sent
                     res.statusCode = 504; // status code request timeout
                     res.end();
                 }
@@ -51643,8 +51767,8 @@ function transformMiddleware(server) {
                 return;
             }
             if ((e === null || e === void 0 ? void 0 : e.code) === ERR_OUTDATED_OPTIMIZED_DEP) {
+                // Skip if response has already been sent
                 if (!res.writableEnded) {
-                    // Don't do anything if response has already been sent
                     res.statusCode = 504; // status code request timeout
                     res.end();
                 }
@@ -51710,8 +51834,25 @@ const devHtmlHook = async (html, { path: htmlPath, server, originalUrl }) => {
     const { config, moduleGraph } = server;
     const base = config.base || '/';
     const s = new MagicString(html);
-    let scriptModuleIndex = -1;
+    let inlineModuleIndex = -1;
     const filePath = cleanUrl(htmlPath);
+    const addInlineModule = (node, ext) => {
+        inlineModuleIndex++;
+        const url = filePath.replace(normalizePath$4(config.root), '');
+        const contents = node.children
+            .map((child) => child.content || '')
+            .join('');
+        // add HTML Proxy to Map
+        addToHTMLProxyCache(config, url, inlineModuleIndex, contents);
+        // inline js module. convert to src="proxy"
+        const modulePath = `${config.base + htmlPath.slice(1)}?html-proxy&index=${inlineModuleIndex}.${ext}`;
+        // invalidate the module so the newly cached contents will be served
+        const module = server === null || server === void 0 ? void 0 : server.moduleGraph.getModuleById(modulePath);
+        if (module) {
+            server === null || server === void 0 ? void 0 : server.moduleGraph.invalidateModule(module);
+        }
+        s.overwrite(node.loc.start.offset, node.loc.end.offset, `<script type="module" src="${modulePath}"></script>`);
+    };
     await traverseHtml(html, htmlPath, (node) => {
         if (node.type !== 1 /* ELEMENT */) {
             return;
@@ -51719,29 +51860,16 @@ const devHtmlHook = async (html, { path: htmlPath, server, originalUrl }) => {
         // script tags
         if (node.tag === 'script') {
             const { src, isModule } = getScriptInfo(node);
-            if (isModule) {
-                scriptModuleIndex++;
-            }
             if (src) {
                 processNodeUrl(src, s, config, htmlPath, originalUrl, moduleGraph);
             }
             else if (isModule) {
-                const url = filePath.replace(normalizePath$4(config.root), '');
-                const contents = node.children
-                    .map((child) => child.content || '')
-                    .join('');
-                // add HTML Proxy to Map
-                addToHTMLProxyCache(config, url, scriptModuleIndex, contents);
-                // inline js module. convert to src="proxy"
-                const modulePath = `${config.base + htmlPath.slice(1)}?html-proxy&index=${scriptModuleIndex}.js`;
-                // invalidate the module so the newly cached contents will be served
-                const module = server === null || server === void 0 ? void 0 : server.moduleGraph.getModuleById(modulePath);
-                if (module) {
-                    server === null || server === void 0 ? void 0 : server.moduleGraph.invalidateModule(module);
-                }
-                s.overwrite(node.loc.start.offset, node.loc.end.offset, `<script type="module" src="${modulePath}"></script>`);
+                addInlineModule(node, 'js');
             }
         }
+        if (node.tag === 'style' && node.children.length) {
+            addInlineModule(node, 'css');
+        }
         // elements with [href/src] attrs
         const assetAttrs = assetAttrsConfig[node.tag];
         if (assetAttrs) {
@@ -51826,6 +51954,7 @@ class ModuleNode {
         this.ssrTransformResult = null;
         this.ssrModule = null;
         this.lastHMRTimestamp = 0;
+        this.lastInvalidationTimestamp = 0;
         this.url = url;
         this.type = isDirectCSSRequest(url) ? 'css' : 'js';
     }
@@ -51866,16 +51995,21 @@ class ModuleGraph {
             });
         }
     }
-    invalidateModule(mod, seen = new Set()) {
-        mod.info = undefined;
+    invalidateModule(mod, seen = new Set(), timestamp = Date.now()) {
+        // Save the timestamp for this invalidation, so we can avoid caching the result of possible already started
+        // processing being done for this module
+        mod.lastInvalidationTimestamp = timestamp;
+        // Don't invalidate mod.info and mod.meta, as they are part of the processing pipeline
+        // Invalidating the transform result is enough to ensure this module is re-processed next time it is requested
         mod.transformResult = null;
         mod.ssrTransformResult = null;
         invalidateSSRModule(mod, seen);
     }
     invalidateAll() {
+        const timestamp = Date.now();
         const seen = new Set();
         this.idToModuleMap.forEach((mod) => {
-            this.invalidateModule(mod, seen);
+            this.invalidateModule(mod, seen, timestamp);
         });
     }
     /**
@@ -54343,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
@@ -54361,70 +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 = { ...metadata.optimized, ...metadata.discovered };
-        const thisDepOptimizationProcessing = depOptimizationProcessing;
-        // Other rerun will await until this run is finished
-        lastDepOptimizationPromise = thisDepOptimizationProcessing.promise;
-        let processingResult;
+        const newDeps = {};
+        // Clone optimized info objects, fileHash, browserHash may be changed for them
+        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]) {
-                    newData.discovered[o] = metadata.discovered[o];
-                    delete 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
                     });
@@ -54434,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
@@ -54453,7 +54599,6 @@ function createMissingImporterRegisterFn(server) {
             type: 'full-reload',
             path: '*'
         });
-        needFullReload = false;
     }
     return function registerMissingImport(id, resolved, ssr) {
         const optimized = metadata.optimized[id];
@@ -54466,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,
@@ -54480,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
@@ -54602,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));
@@ -54614,6 +54763,9 @@ async function createServer(inlineConfig = {}) {
                 rebindErrorStacktrace(e, stacktrace);
             }
         },
+        ssrRewriteStacktrace(stack) {
+            return ssrRewriteStacktrace(stack, moduleGraph);
+        },
         listen(port, isRestart) {
             return startServer(server, port, isRestart);
         },
@@ -54776,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;
@@ -55277,6 +55432,7 @@ const clientDir = normalizePath$4(CLIENT_DIR);
 const skipRE = /\.(map|json)$/;
 const canSkip = (id) => skipRE.test(id) || isDirectCSSRequest(id);
 const optimizedDepChunkRE = /\/chunk-[A-Z0-9]{8}\.js/;
+const optimizedDepDynamicRE = /-[A-Z0-9]{8}\.js/;
 function isExplicitImportRequired(url) {
     return !isJSRequest(cleanUrl(url)) && !isCSSRequest(url);
 }
@@ -55409,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);
@@ -55470,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,
@@ -55553,43 +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)) {
-                            // for optimized cjs deps, support named imports by rewriting named
-                            // imports to const assignments.
-                            const optimizeDepsMetadata = server._optimizeDepsMetadata;
-                            const { optimized } = optimizeDepsMetadata;
-                            // 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 dep = Object.keys(optimized).find((k) => optimized[k].file === file);
-                            // Wait until the dependency has been pre-bundled
-                            dep && (await optimized[dep].processing);
-                            if (dep && optimized[dep].needsInterop) {
-                                debug$1(`${dep} 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
@@ -55685,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();
             }
@@ -56050,6 +56230,8 @@ function preAliasPlugin() {
     };
 }
 
+const nonJsRe = /\.(json)($|\?)/;
+const isNonJsRequest = (request) => nonJsRe.test(request);
 function definePlugin(config) {
     const isBuild = config.command === 'build';
     const processNodeEnv = {
@@ -56125,6 +56307,7 @@ function definePlugin(config) {
             // exclude html, css and static assets for performance
             isHTMLRequest(id) ||
                 isCSSRequest(id) ||
+                isNonJsRequest(id) ||
                 config.assetsInclude(id)) {
                 return;
             }

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

@@ -1,7 +1,7 @@
 'use strict';
 
 var require$$0 = require('postcss');
-var index$1 = require('./dep-429629d5.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-026034b4.js → dep-f14ba655.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./dep-429629d5.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-429629d5.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-429629d5.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-429629d5.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-429629d5.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-429629d5.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 {
@@ -1130,7 +1132,7 @@ export declare class ModuleGraph {
     getModuleById(id: string): ModuleNode | undefined;
     getModulesByFile(file: string): Set<ModuleNode> | undefined;
     onFileChange(file: string): void;
-    invalidateModule(mod: ModuleNode, seen?: Set<ModuleNode>): void;
+    invalidateModule(mod: ModuleNode, seen?: Set<ModuleNode>, timestamp?: number): void;
     invalidateAll(): void;
     /**
      * Update the module graph based on a module's updated imports information
@@ -1164,6 +1166,7 @@ export declare class ModuleNode {
     ssrTransformResult: TransformResult | null;
     ssrModule: Record<string, any> | null;
     lastHMRTimestamp: number;
+    lastInvalidationTimestamp: number;
     constructor(url: string);
 }
 
@@ -1179,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>;
 }
 
 /**
@@ -2160,7 +2163,11 @@ export declare interface ViteDevServer {
         fixStacktrace?: boolean;
     }): Promise<Record<string, any>>;
     /**
-     * Fix ssr error stacktrace
+     * Returns a fixed version of the given stack
+     */
+    ssrRewriteStacktrace(stack: string): string;
+    /**
+     * Mutates the given SSR error by rewriting the stacktrace
      */
     ssrFixStacktrace(e: Error): void;
     /**

package/dist/node/index.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var index = require('./chunks/dep-429629d5.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.0",
+  "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"