vite 2.7.0-beta.7 → 2.7.0-beta.8

package/dist/node/chunks/{dep-56ab4c22.js → dep-d87be5e9.js}

@@ -2961,7 +2961,7 @@ if (typeof process === 'undefined' || process.type === 'renderer' || process.bro
 	src$2.exports = node$1.exports;
 }
 
-var debug$f = src$2.exports;
+var debug$g = src$2.exports;
 
 const DEFAULT_MAIN_FIELDS = [
     'module',
@@ -2988,9 +2988,15 @@ const FS_PREFIX = `/@fs/`;
  */
 const VALID_ID_PREFIX = `/@id/`;
 /**
- * Some Rollup plugins use ids that starts with the null byte \0 to avoid
- * collisions, but it is not permitted in import URLs so we have to replace
- * them.
+ * Plugins that use 'virtual modules' (e.g. for helper functions), prefix the
+ * module ID with `\0`, a convention from the rollup ecosystem.
+ * This prevents other plugins from trying to process the id (like node resolution),
+ * and core features like sourcemaps can use this info to differentiate between
+ * virtual modules and regular files.
+ * `\0` is not a permitted char in import URLs so we have to replace them during
+ * import analysis. The id will be decoded back before entering the plugins pipeline.
+ * These encoded virtual ids are also prefixed by the VALID_ID_PREFIX, so virtual
+ * modules in the browser end up encoded as `/@id/__x00__{id}`
  */
 const NULL_BYTE_PLACEHOLDER = `__x00__`;
 const CLIENT_PUBLIC_PATH = `/@vite/client`;
@@ -3924,7 +3930,7 @@ function nestedResolveFrom(id, basedir, preserveSymlinks = false) {
 const filter$1 = process.env.VITE_DEBUG_FILTER;
 const DEBUG$1 = process.env.DEBUG;
 function createDebugger(namespace, options = {}) {
-    const log = debug$f(namespace);
+    const log = debug$g(namespace);
     const { onlyWhenFocused } = options;
     const focus = typeof onlyWhenFocused === 'string' ? onlyWhenFocused : namespace;
     return (msg, ...args) => {
@@ -20386,7 +20392,7 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
         replacer: urlReplacer
     }));
     if (isModule) {
-        postcssPlugins.unshift((await Promise.resolve().then(function () { return require('./dep-707302f6.js'); }).then(function (n) { return n.index; })).default({
+        postcssPlugins.unshift((await Promise.resolve().then(function () { return require('./dep-b192ffe4.js'); }).then(function (n) { return n.index; })).default({
             ...modulesOptions,
             getJSON(cssFileName, _modules, outputFileName) {
                 modules = _modules;
@@ -21091,7 +21097,7 @@ function buildImportAnalysisPlugin(config) {
                 }
                 // Differentiate CSS imports that use the default export from those that
                 // do not by injecting a ?used query - this allows us to avoid including
-                // the CSS string when unnecessary (esbuild has trouble treeshaking
+                // the CSS string when unnecessary (esbuild has trouble tree-shaking
                 // them)
                 if (specifier &&
                     isCSSRequest(specifier) &&
@@ -21351,7 +21357,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-9a51c06c.js'); }).then(function (n) { return n.compilerDom_cjs; });
+    const { parse, transform } = await Promise.resolve().then(function () { return require('./dep-8fdf8f48.js'); }).then(function (n) { return n.compilerDom_cjs; });
     // @vue/compiler-core doesn't like lowercase doctypes
     html = html.replace(/<!doctype\s/i, '<!DOCTYPE ');
     try {
@@ -22300,7 +22306,7 @@ var TSConfckParseError = class extends Error {
   }
 };
 
-const debug$e = createDebugger('vite:esbuild');
+const debug$f = createDebugger('vite:esbuild');
 let server;
 async function transformWithEsbuild(code, filename, options, inMap) {
     var _a, _b, _c;
@@ -22390,7 +22396,7 @@ async function transformWithEsbuild(code, filename, options, inMap) {
         };
     }
     catch (e) {
-        debug$e(`esbuild error with options used: `, resolvedOptions);
+        debug$f(`esbuild error with options used: `, resolvedOptions);
         // patch error information
         if (e.errors) {
             e.frame = '';
@@ -29949,6 +29955,126 @@ function resolve(pkg, entry='.', options={}) {
 	}
 }
 
+const isDebug$6 = process.env.DEBUG;
+const debug$e = createDebugger('vite:resolve-details', {
+    onlyWhenFocused: true
+});
+function invalidatePackageData(packageCache, pkgPath) {
+    packageCache.delete(pkgPath);
+    const pkgDir = path__default.dirname(pkgPath);
+    packageCache.forEach((pkg, cacheKey) => {
+        if (pkg.dir === pkgDir) {
+            packageCache.delete(cacheKey);
+        }
+    });
+}
+function resolvePackageData(id, basedir, preserveSymlinks = false, packageCache) {
+    let pkg;
+    let cacheKey;
+    if (packageCache) {
+        cacheKey = `${id}&${basedir}&${preserveSymlinks}`;
+        if ((pkg = packageCache.get(cacheKey))) {
+            return pkg;
+        }
+    }
+    let pkgPath;
+    try {
+        pkgPath = resolveFrom$3(`${id}/package.json`, basedir, preserveSymlinks);
+        pkg = loadPackageData(pkgPath, true, packageCache);
+        if (packageCache) {
+            packageCache.set(cacheKey, pkg);
+        }
+        return pkg;
+    }
+    catch (e) {
+        if (e instanceof SyntaxError) {
+            isDebug$6 && debug$e(`Parsing failed: ${pkgPath}`);
+        }
+        // Ignore error for missing package.json
+        else if (e.code !== 'MODULE_NOT_FOUND') {
+            throw e;
+        }
+    }
+    return null;
+}
+function loadPackageData(pkgPath, preserveSymlinks, packageCache) {
+    if (!preserveSymlinks) {
+        pkgPath = fs__default.realpathSync.native(pkgPath);
+    }
+    let cached;
+    if ((cached = packageCache === null || packageCache === void 0 ? void 0 : packageCache.get(pkgPath))) {
+        return cached;
+    }
+    const data = JSON.parse(fs__default.readFileSync(pkgPath, 'utf-8'));
+    const pkgDir = path__default.dirname(pkgPath);
+    const { sideEffects } = data;
+    let hasSideEffects;
+    if (typeof sideEffects === 'boolean') {
+        hasSideEffects = () => sideEffects;
+    }
+    else if (Array.isArray(sideEffects)) {
+        hasSideEffects = createFilter$1(sideEffects, null, { resolve: pkgDir });
+    }
+    else {
+        hasSideEffects = () => true;
+    }
+    const pkg = {
+        dir: pkgDir,
+        data,
+        hasSideEffects,
+        webResolvedImports: {},
+        nodeResolvedImports: {},
+        setResolvedCache(key, entry, targetWeb) {
+            if (targetWeb) {
+                pkg.webResolvedImports[key] = entry;
+            }
+            else {
+                pkg.nodeResolvedImports[key] = entry;
+            }
+        },
+        getResolvedCache(key, targetWeb) {
+            if (targetWeb) {
+                return pkg.webResolvedImports[key];
+            }
+            else {
+                return pkg.nodeResolvedImports[key];
+            }
+        }
+    };
+    packageCache === null || packageCache === void 0 ? void 0 : packageCache.set(pkgPath, pkg);
+    return pkg;
+}
+function watchPackageDataPlugin(config) {
+    const watchQueue = new Set();
+    let watchFile = (id) => {
+        watchQueue.add(id);
+    };
+    const { packageCache } = config;
+    const setPackageData = packageCache.set.bind(packageCache);
+    packageCache.set = (id, pkg) => {
+        if (id.endsWith('.json')) {
+            watchFile(id);
+        }
+        return setPackageData(id, pkg);
+    };
+    return {
+        name: 'vite:watch-package-data',
+        buildStart() {
+            watchFile = this.addWatchFile;
+            watchQueue.forEach(watchFile);
+            watchQueue.clear();
+        },
+        buildEnd() {
+            watchFile = (id) => watchQueue.add(id);
+        },
+        watchChange(id) {
+            if (id.endsWith('/package.json')) {
+                invalidatePackageData(packageCache, id);
+            }
+        }
+    };
+}
+
 // special id for paths marked with browser: false
 // https://github.com/defunctzombie/package-browser-field-spec#ignore-a-module
 const browserExternalId = '__vite-browser-external';
@@ -30158,12 +30284,17 @@ function tryResolveFile(file, postfix, options, tryIndex, targetWeb, tryPrefix,
         else if (tryIndex) {
             if (!skipPackageJson) {
                 const pkgPath = file + '/package.json';
-                if (fs__default.existsSync(pkgPath)) {
+                try {
                     // path points to a node package
-                    const pkg = loadPackageData(pkgPath);
+                    const pkg = loadPackageData(pkgPath, options.preserveSymlinks);
                     const resolved = resolvePackageEntry(file, pkg, targetWeb, options);
                     return resolved;
                 }
+                catch (e) {
+                    if (e.code !== 'ENOENT') {
+                        throw e;
+                    }
+                }
             }
             const index = tryFsResolve(file + '/index', options);
             if (index)
@@ -30183,7 +30314,7 @@ function tryResolveFile(file, postfix, options, tryIndex, targetWeb, tryPrefix,
 const idToPkgMap = new Map();
 function tryNodeResolve(id, importer, options, targetWeb, server, ssr) {
     var _a, _b, _c;
-    const { root, dedupe, isBuild } = options;
+    const { root, dedupe, isBuild, preserveSymlinks, packageCache } = options;
     // split id by last '>' for nested selected packages, for example:
     // 'foo > bar > baz' => 'foo > bar' & 'baz'
     // 'foo'             => ''          & 'foo'
@@ -30224,11 +30355,11 @@ function tryNodeResolve(id, importer, options, targetWeb, server, ssr) {
     }
     // nested node module, step-by-step resolve to the basedir of the nestedPath
     if (nestedRoot) {
-        basedir = nestedResolveFrom(nestedRoot, basedir, options.preserveSymlinks);
+        basedir = nestedResolveFrom(nestedRoot, basedir, preserveSymlinks);
     }
     let pkg;
     const pkgId = possiblePkgIds.reverse().find((pkgId) => {
-        pkg = resolvePackageData(pkgId, basedir, options.preserveSymlinks);
+        pkg = resolvePackageData(pkgId, basedir, preserveSymlinks, packageCache);
         return pkg;
     });
     if (!pkg) {
@@ -30346,60 +30477,6 @@ function tryOptimizedResolve(id, server, importer) {
         }
     }
 }
-const packageCache = new Map();
-function resolvePackageData(id, basedir, preserveSymlinks = false) {
-    const cacheKey = id + basedir;
-    if (packageCache.has(cacheKey)) {
-        return packageCache.get(cacheKey);
-    }
-    try {
-        const pkgPath = resolveFrom$3(`${id}/package.json`, basedir, preserveSymlinks);
-        return loadPackageData(pkgPath, cacheKey);
-    }
-    catch (e) {
-        isDebug$5 && debug$d(`${source.red(`[failed loading package.json]`)} ${id}`);
-    }
-}
-function loadPackageData(pkgPath, cacheKey = pkgPath) {
-    const data = JSON.parse(fs__default.readFileSync(pkgPath, 'utf-8'));
-    const pkgDir = path__default.dirname(pkgPath);
-    const { sideEffects } = data;
-    let hasSideEffects;
-    if (typeof sideEffects === 'boolean') {
-        hasSideEffects = () => sideEffects;
-    }
-    else if (Array.isArray(sideEffects)) {
-        hasSideEffects = createFilter$1(sideEffects, null, { resolve: pkgDir });
-    }
-    else {
-        hasSideEffects = () => true;
-    }
-    const pkg = {
-        dir: pkgDir,
-        data,
-        hasSideEffects,
-        webResolvedImports: {},
-        nodeResolvedImports: {},
-        setResolvedCache(key, entry, targetWeb) {
-            if (targetWeb) {
-                pkg.webResolvedImports[key] = entry;
-            }
-            else {
-                pkg.nodeResolvedImports[key] = entry;
-            }
-        },
-        getResolvedCache(key, targetWeb) {
-            if (targetWeb) {
-                return pkg.webResolvedImports[key];
-            }
-            else {
-                return pkg.nodeResolvedImports[key];
-            }
-        }
-    };
-    packageCache.set(cacheKey, pkg);
-    return pkg;
-}
 function resolvePackageEntry(id, { dir, data, setResolvedCache, getResolvedCache }, targetWeb, options) {
     var _a, _b;
     const cached = getResolvedCache('.', targetWeb);
@@ -43264,6 +43341,7 @@ function resolveBuildPlugins(config) {
     const options = config.build;
     return {
         pre: [
+            watchPackageDataPlugin(config),
             buildHtmlPlugin(config),
             commonjs(options.commonjsOptions),
             dataURIPlugin(),
@@ -49375,7 +49453,7 @@ function readFileIfExists(value) {
  * https://github.com/webpack/webpack-dev-server/blob/master/LICENSE
  */
 async function createCertificate() {
-    const { generate } = await Promise.resolve().then(function () { return require('./dep-606d0866.js'); }).then(function (n) { return n.index; });
+    const { generate } = await Promise.resolve().then(function () { return require('./dep-03d6dbab.js'); }).then(function (n) { return n.index; });
     const pems = generate(null, {
         algorithm: 'sha256',
         days: 30,
@@ -56556,16 +56634,20 @@ function walk(root, { onIdentifier, onImportMeta, onDynamicImport }) {
                 // so that we don't prefix them
                 node.params.forEach((p) => walk$1(p.type === 'AssignmentPattern' ? p.left : p, {
                     enter(child, parent) {
-                        if (child.type === 'Identifier' &&
-                            // do not record as scope variable if is a destructuring key
-                            !isStaticPropertyKey(child, parent) &&
-                            // do not record if this is a default value
-                            // assignment of a destructuring variable
-                            !(parent &&
-                                parent.type === 'AssignmentPattern' &&
-                                parent.right === child)) {
-                            setScope(node, child.name);
+                        if (child.type !== 'Identifier')
+                            return;
+                        // do not record as scope variable if is a destructuring keyword
+                        if (isStaticPropertyKey(child, parent))
+                            return;
+                        // do not record if this is a default value
+                        // assignment of a destructuring variable
+                        if (((parent === null || parent === void 0 ? void 0 : parent.type) === 'AssignmentPattern' &&
+                            (parent === null || parent === void 0 ? void 0 : parent.right) === child) ||
+                            ((parent === null || parent === void 0 ? void 0 : parent.type) === 'TemplateLiteral' &&
+                                (parent === null || parent === void 0 ? void 0 : parent.expressions.includes(child)))) {
+                            return;
                         }
+                        setScope(node, child.name);
                     }
                 }));
             }
@@ -56585,6 +56667,11 @@ function walk(root, { onIdentifier, onImportMeta, onDynamicImport }) {
                             }
                         });
                     }
+                    else if (node.id.type === 'ArrayPattern') {
+                        node.id.elements.forEach((element) => {
+                            setScope(parentFunction, element.name);
+                        });
+                    }
                     else {
                         setScope(parentFunction, node.id.name);
                     }
@@ -57781,7 +57868,7 @@ async function handleHMRUpdate(file, server) {
         // auto restart server
         debugHmr(`[config change] ${source.dim(shortFile)}`);
         config.logger.info(source.green(`${path__default.relative(process.cwd(), file)} changed, restarting server...`), { clear: true, timestamp: true });
-        await restartServer(server);
+        await server.restart();
         return;
     }
     debugHmr(`[file change] ${source.dim(shortFile)}`);
@@ -58124,34 +58211,6 @@ async function readModifiedFile(file) {
         return content;
     }
 }
-async function restartServer(server) {
-    // @ts-ignore
-    global.__vite_start_time = perf_hooks.performance.now();
-    const { port } = server.config.server;
-    await server.close();
-    let newServer = null;
-    try {
-        newServer = await createServer(server.config.inlineConfig);
-    }
-    catch (err) {
-        server.config.logger.error(err.message, {
-            timestamp: true
-        });
-        return;
-    }
-    for (const key in newServer) {
-        if (key !== 'app') {
-            // @ts-ignore
-            server[key] = newServer[key];
-        }
-    }
-    if (!server.config.server.middlewareMode) {
-        await server.listen(port, true);
-    }
-    else {
-        server.config.logger.info('server restarted.', { timestamp: true });
-    }
-}
 
 var isWsl$2 = {exports: {}};
 
@@ -67461,9 +67520,21 @@ async function createServer(inlineConfig = {}) {
                 throw new Error('cannot print server URLs in middleware mode.');
             }
         },
+        async restart(forceOptimize) {
+            if (!server._restartPromise) {
+                server._forceOptimizeOnRestart = !!forceOptimize;
+                server._restartPromise = restartServer(server).finally(() => {
+                    server._restartPromise = null;
+                    server._forceOptimizeOnRestart = false;
+                });
+            }
+            return server._restartPromise;
+        },
         _optimizeDepsMetadata: null,
         _ssrExternals: null,
         _globImporters: Object.create(null),
+        _restartPromise: null,
+        _forceOptimizeOnRestart: false,
         _isRunningOptimizer: false,
         _registerMissingImport: null,
         _pendingReload: null,
@@ -67482,8 +67553,19 @@ async function createServer(inlineConfig = {}) {
     if (!middlewareMode && process.env.CI !== 'true') {
         process.stdin.on('end', exitProcess);
     }
+    const { packageCache } = config;
+    const setPackageData = packageCache.set.bind(packageCache);
+    packageCache.set = (id, pkg) => {
+        if (id.endsWith('.json')) {
+            watcher.add(id);
+        }
+        return setPackageData(id, pkg);
+    };
     watcher.on('change', async (file) => {
         file = normalizePath$4(file);
+        if (file.endsWith('/package.json')) {
+            return invalidatePackageData(packageCache, file);
+        }
         // invalidate module graph cache on file change
         moduleGraph.onFileChange(file);
         if (serverConfig.hmr !== false) {
@@ -67578,7 +67660,7 @@ async function createServer(inlineConfig = {}) {
         if (config.cacheDir) {
             server._isRunningOptimizer = true;
             try {
-                server._optimizeDepsMetadata = await optimizeDeps(config);
+                server._optimizeDepsMetadata = await optimizeDeps(config, config.server.force || server._forceOptimizeOnRestart);
             }
             finally {
                 server._isRunningOptimizer = false;
@@ -67707,6 +67789,34 @@ function resolveServerOptions(root, raw) {
     };
     return server;
 }
+async function restartServer(server) {
+    // @ts-ignore
+    global.__vite_start_time = perf_hooks.performance.now();
+    const { port } = server.config.server;
+    await server.close();
+    let newServer = null;
+    try {
+        newServer = await createServer(server.config.inlineConfig);
+    }
+    catch (err) {
+        server.config.logger.error(err.message, {
+            timestamp: true
+        });
+        return;
+    }
+    for (const key in newServer) {
+        if (key !== 'app') {
+            // @ts-ignore
+            server[key] = newServer[key];
+        }
+    }
+    if (!server.config.server.middlewareMode) {
+        await server.listen(port, true);
+    }
+    else {
+        server.config.logger.info('server restarted.', { timestamp: true });
+    }
+}
 
 var index = {
 	__proto__: null,
@@ -80942,6 +81052,12 @@ function importAnalysisPlugin(config) {
                 if (pluginImports) {
                     (await Promise.all([...pluginImports].map((id) => normalizeUrl(id, 0)))).forEach(([url]) => importedUrls.add(url));
                 }
+                // HMR transforms are no-ops in SSR, so an `accept` call will
+                // never be injected. Avoid updating the `isSelfAccepting`
+                // property for our module node in that case.
+                if (ssr && importerModule.isSelfAccepting) {
+                    isSelfAccepting = true;
+                }
                 const prunedImports = await moduleGraph.updateModuleInfo(importerModule, importedUrls, normalizedAcceptedUrls, isSelfAccepting);
                 if (hasHMR && prunedImports) {
                     handlePrunedModules(prunedImports, server);
@@ -81002,11 +81118,14 @@ function transformCjsImport(importExp, url, rawUrl, importIndex) {
         ecmaVersion: 'latest',
         sourceType: 'module'
     }).body[0];
-    if (node.type === 'ImportDeclaration') {
+    if (node.type === 'ImportDeclaration' ||
+        node.type === 'ExportNamedDeclaration') {
         if (!node.specifiers.length) {
             return `import "${url}"`;
         }
         const importNames = [];
+        const exportNames = [];
+        let defaultExports = '';
         for (const spec of node.specifiers) {
             if (spec.type === 'ImportSpecifier' &&
                 spec.imported.type === 'Identifier') {
@@ -81023,6 +81142,21 @@ function transformCjsImport(importExp, url, rawUrl, importIndex) {
             else if (spec.type === 'ImportNamespaceSpecifier') {
                 importNames.push({ importedName: '*', localName: spec.local.name });
             }
+            else if (spec.type === 'ExportSpecifier' &&
+                spec.exported.type === 'Identifier') {
+                // for ExportSpecifier, local name is same as imported name
+                const importedName = spec.local.name;
+                // we want to specify exported name as variable and re-export it
+                const exportedName = spec.exported.name;
+                if (exportedName === 'default') {
+                    defaultExports = makeLegalIdentifier$1(`__vite__cjsExportDefault_${importIndex}`);
+                    importNames.push({ importedName, localName: defaultExports });
+                }
+                else {
+                    importNames.push({ importedName, localName: exportedName });
+                    exportNames.push(exportedName);
+                }
+            }
         }
         // If there is multiple import for same id in one file,
         // importIndex will prevent the cjsModuleName to be duplicate
@@ -81039,6 +81173,12 @@ function transformCjsImport(importExp, url, rawUrl, importIndex) {
                 lines.push(`const ${localName} = ${cjsModuleName}["${importedName}"]`);
             }
         });
+        if (defaultExports) {
+            lines.push(`export default ${defaultExports}`);
+        }
+        if (exportNames.length) {
+            lines.push(`export { ${exportNames.join(', ')} }`);
+        }
         return lines.join('; ');
     }
 }
@@ -81396,6 +81536,7 @@ async function resolvePlugins(config, prePlugins, normalPlugins, postPlugins) {
             root: config.root,
             isProduction: config.isProduction,
             isBuild,
+            packageCache: config.packageCache,
             ssrConfig: config.ssr,
             asSrc: true
         }),
@@ -81772,6 +81913,7 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development')
             return DEFAULT_ASSETS_RE.test(file) || assetsFilter(file);
         },
         logger,
+        packageCache: new Map(),
         createResolver,
         optimizeDeps: {
             ...config.optimizeDeps,
@@ -82067,8 +82209,7 @@ async function loadConfigFromFile(configEnv, configFile, configRoot = process.cw
         if (!userConfig) {
             // 2. if we reach here, the file is ts or using es import syntax, or
             // the user has type: "module" in their package.json (#917)
-            // transpile es import syntax to require syntax using rollup.
-            // lazy require rollup (it's actually in dependencies)
+            // transpile es import syntax to require syntax using esbuild.
             const bundled = await bundleConfigFile(resolvedPath);
             dependencies = bundled.dependencies;
             userConfig = await loadConfigFromBundledFile(resolvedPath, bundled.code);
@@ -82239,4 +82380,4 @@ exports.send = send$1;
 exports.sortUserPlugins = sortUserPlugins;
 exports.source = source;
 exports.transformWithEsbuild = transformWithEsbuild;
-//# sourceMappingURL=dep-56ab4c22.js.map
+//# sourceMappingURL=dep-d87be5e9.js.map