vite 2.7.0-beta.5 → 2.7.0-beta.6

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+# [2.7.0-beta.6](https://github.com/vitejs/vite/compare/v2.7.0-beta.5...v2.7.0-beta.6) (2021-11-16)
+
+
+### Bug Fixes
+
+* **dev:** Fix infinite recursion on query imports ([#5671](https://github.com/vitejs/vite/issues/5671)) ([#5674](https://github.com/vitejs/vite/issues/5674)) ([bce4e56](https://github.com/vitejs/vite/commit/bce4e56cb12b3c76f48bf2ddc37423025e79a0d2))
+* **ssr:** avoid resolving ESM for CJS dependencies ([#5693](https://github.com/vitejs/vite/issues/5693)) ([b937ea4](https://github.com/vitejs/vite/commit/b937ea4cb1642a76d7a650802c0db2fede338474))
+
+
+
 # [2.7.0-beta.5](https://github.com/vitejs/vite/compare/v2.7.0-beta.4...v2.7.0-beta.5) (2021-11-13)
 
 

package/dist/node/chunks/{dep-6920cd01.js → dep-0183a921.js}

@@ -3974,7 +3974,7 @@ const knownTsRE = /\.(ts|mts|cts|tsx)$/;
 const knownTsOutputRE = /\.(js|mjs|cjs|jsx)$/;
 const isTsRequest = (url) => knownTsRE.test(cleanUrl(url));
 const isPossibleTsOutput = (url) => knownTsOutputRE.test(cleanUrl(url));
-const getTsSrcPath = (filename) => filename.replace(/\.([cm])?(js)(x?)$/, '.$1ts$3');
+const getTsSrcPath = (filename) => filename.replace(/\.([cm])?(js)(x?)(\?|$)/, '.$1ts$3');
 const importQueryRE = /(\?|&)import=?(?:&|$)/;
 const internalPrefixes = [
     FS_PREFIX,
@@ -20385,7 +20385,7 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
         replacer: urlReplacer
     }));
     if (isModule) {
-        postcssPlugins.unshift((await Promise.resolve().then(function () { return require('./dep-0a2fa784.js'); }).then(function (n) { return n.index; })).default({
+        postcssPlugins.unshift((await Promise.resolve().then(function () { return require('./dep-48461e78.js'); }).then(function (n) { return n.index; })).default({
             ...modulesOptions,
             getJSON(cssFileName, _modules, outputFileName) {
                 modules = _modules;
@@ -21350,7 +21350,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-bc61ebc7.js'); }).then(function (n) { return n.compilerDom_cjs; });
+    const { parse, transform } = await Promise.resolve().then(function () { return require('./dep-1b2328e8.js'); }).then(function (n) { return n.compilerDom_cjs; });
     // @vue/compiler-core doesn't like lowercase doctypes
     html = html.replace(/<!doctype\s/i, '<!DOCTYPE ');
     try {
@@ -29974,12 +29974,11 @@ function resolvePlugin(baseOptions) {
                 isRequire,
                 isFromTsImporter: isTsRequest(importer !== null && importer !== void 0 ? importer : '')
             };
-            const preserveSymlinks = !!(server === null || server === void 0 ? void 0 : server.config.resolve.preserveSymlinks);
             let res;
             // explicit fs paths that starts with /@fs/*
             if (asSrc && id.startsWith(FS_PREFIX)) {
                 const fsPath = fsPathFromId(id);
-                res = tryFsResolve(fsPath, options, preserveSymlinks);
+                res = tryFsResolve(fsPath, options);
                 isDebug$5 && debug$d(`[@fs] ${source.cyan(id)} -> ${source.dim(res)}`);
                 // always return here even if res doesn't exist since /@fs/ is explicit
                 // if the file doesn't exist it should be a 404
@@ -29989,7 +29988,7 @@ function resolvePlugin(baseOptions) {
             // /foo -> /fs-root/foo
             if (asSrc && id.startsWith('/')) {
                 const fsPath = path__default.resolve(root, id.slice(1));
-                if ((res = tryFsResolve(fsPath, options, preserveSymlinks))) {
+                if ((res = tryFsResolve(fsPath, options))) {
                     isDebug$5 && debug$d(`[url] ${source.cyan(id)} -> ${source.dim(res)}`);
                     return res;
                 }
@@ -30011,10 +30010,10 @@ function resolvePlugin(baseOptions) {
                     }
                 }
                 if (targetWeb &&
-                    (res = tryResolveBrowserMapping(fsPath, importer, options, true, preserveSymlinks))) {
+                    (res = tryResolveBrowserMapping(fsPath, importer, options, true))) {
                     return res;
                 }
-                if ((res = tryFsResolve(fsPath, options, preserveSymlinks))) {
+                if ((res = tryFsResolve(fsPath, options))) {
                     isDebug$5 && debug$d(`[relative] ${source.cyan(id)} -> ${source.dim(res)}`);
                     const pkg = importer != null && idToPkgMap.get(importer);
                     if (pkg) {
@@ -30028,8 +30027,7 @@ function resolvePlugin(baseOptions) {
                 }
             }
             // absolute fs paths
-            if (path__default.isAbsolute(id) &&
-                (res = tryFsResolve(id, options, preserveSymlinks))) {
+            if (path__default.isAbsolute(id) && (res = tryFsResolve(id, options))) {
                 isDebug$5 && debug$d(`[fs] ${source.cyan(id)} -> ${source.dim(res)}`);
                 return res;
             }
@@ -30054,7 +30052,7 @@ function resolvePlugin(baseOptions) {
                     return res;
                 }
                 if (targetWeb &&
-                    (res = tryResolveBrowserMapping(id, importer, options, false, preserveSymlinks))) {
+                    (res = tryResolveBrowserMapping(id, importer, options, false))) {
                     return res;
                 }
                 if ((res = tryNodeResolve(id, importer, options, targetWeb, server, ssr))) {
@@ -30103,7 +30101,7 @@ function resolvePlugin(baseOptions) {
         }
     };
 }
-function tryFsResolve(fsPath, options, preserveSymlinks, tryIndex = true, targetWeb = true) {
+function tryFsResolve(fsPath, options, tryIndex = true, targetWeb = true) {
     let file = fsPath;
     let postfix = '';
     let postfixIndex = fsPath.indexOf('?');
@@ -30117,36 +30115,36 @@ function tryFsResolve(fsPath, options, preserveSymlinks, tryIndex = true, target
     let res;
     // if we fould postfix exist, we should first try resolving file with postfix. details see #4703.
     if (postfix &&
-        (res = tryResolveFile(fsPath, '', options, false, targetWeb, preserveSymlinks, options.tryPrefix, options.skipPackageJson))) {
+        (res = tryResolveFile(fsPath, '', options, false, targetWeb, options.tryPrefix, options.skipPackageJson))) {
         return res;
     }
-    if ((res = tryResolveFile(file, postfix, options, false, targetWeb, preserveSymlinks, options.tryPrefix, options.skipPackageJson))) {
+    if ((res = tryResolveFile(file, postfix, options, false, targetWeb, options.tryPrefix, options.skipPackageJson))) {
         return res;
     }
     for (const ext of options.extensions || DEFAULT_EXTENSIONS$1) {
         if (postfix &&
-            (res = tryResolveFile(fsPath + ext, '', options, false, targetWeb, preserveSymlinks, options.tryPrefix, options.skipPackageJson))) {
+            (res = tryResolveFile(fsPath + ext, '', options, false, targetWeb, options.tryPrefix, options.skipPackageJson))) {
             return res;
         }
-        if ((res = tryResolveFile(file + ext, postfix, options, false, targetWeb, preserveSymlinks, options.tryPrefix, options.skipPackageJson))) {
+        if ((res = tryResolveFile(file + ext, postfix, options, false, targetWeb, options.tryPrefix, options.skipPackageJson))) {
             return res;
         }
     }
     if (postfix &&
-        (res = tryResolveFile(fsPath, '', options, tryIndex, targetWeb, preserveSymlinks, options.tryPrefix, options.skipPackageJson))) {
+        (res = tryResolveFile(fsPath, '', options, tryIndex, targetWeb, options.tryPrefix, options.skipPackageJson))) {
         return res;
     }
-    if ((res = tryResolveFile(file, postfix, options, tryIndex, targetWeb, preserveSymlinks, options.tryPrefix, options.skipPackageJson))) {
+    if ((res = tryResolveFile(file, postfix, options, tryIndex, targetWeb, options.tryPrefix, options.skipPackageJson))) {
         return res;
     }
 }
-function tryResolveFile(file, postfix, options, tryIndex, targetWeb, preserveSymlinks, tryPrefix, skipPackageJson) {
+function tryResolveFile(file, postfix, options, tryIndex, targetWeb, tryPrefix, skipPackageJson) {
     // #2051 if we don't have read permission on a directory, existsSync() still
     // works and will result in massively slow subsequent checks (which are
     // unnecessary in the first place)
     if (isFileReadable(file)) {
         if (!fs__default.statSync(file).isDirectory()) {
-            return getRealPath(file, preserveSymlinks) + postfix;
+            return getRealPath(file, options.preserveSymlinks) + postfix;
         }
         else if (tryIndex) {
             if (!skipPackageJson) {
@@ -30154,11 +30152,11 @@ function tryResolveFile(file, postfix, options, tryIndex, targetWeb, preserveSym
                 if (fs__default.existsSync(pkgPath)) {
                     // path points to a node package
                     const pkg = loadPackageData(pkgPath);
-                    const resolved = resolvePackageEntry(file, pkg, options, targetWeb, preserveSymlinks);
+                    const resolved = resolvePackageEntry(file, pkg, targetWeb, options);
                     return resolved;
                 }
             }
-            const index = tryFsResolve(file + '/index', options, preserveSymlinks);
+            const index = tryFsResolve(file + '/index', options);
             if (index)
                 return index + postfix;
         }
@@ -30166,11 +30164,11 @@ function tryResolveFile(file, postfix, options, tryIndex, targetWeb, preserveSym
     const tryTsExtension = options.isFromTsImporter && isPossibleTsOutput(file);
     if (tryTsExtension) {
         const tsSrcPath = getTsSrcPath(file);
-        return tryResolveFile(tsSrcPath, postfix, options, tryIndex, targetWeb, preserveSymlinks, tryPrefix, skipPackageJson);
+        return tryResolveFile(tsSrcPath, postfix, options, tryIndex, targetWeb, tryPrefix, skipPackageJson);
     }
     if (tryPrefix) {
         const prefixed = `${path__default.dirname(file)}/${tryPrefix}${path__default.basename(file)}`;
-        return tryResolveFile(prefixed, postfix, options, tryIndex, targetWeb, preserveSymlinks);
+        return tryResolveFile(prefixed, postfix, options, tryIndex, targetWeb);
     }
 }
 const idToPkgMap = new Map();
@@ -30227,9 +30225,29 @@ function tryNodeResolve(id, importer, options, targetWeb, server, ssr) {
     if (!pkg) {
         return;
     }
-    let resolved = nestedPath !== pkgId
-        ? resolveDeepImport('.' + nestedPath.slice(pkgId.length), pkg, options, targetWeb, options.preserveSymlinks)
-        : resolvePackageEntry(nestedPath, pkg, options, targetWeb, options.preserveSymlinks);
+    let resolveId = resolvePackageEntry;
+    let unresolvedId = pkgId;
+    if (unresolvedId !== nestedPath) {
+        resolveId = resolveDeepImport;
+        unresolvedId = '.' + nestedPath.slice(pkgId.length);
+    }
+    let resolved;
+    try {
+        resolved = resolveId(unresolvedId, pkg, targetWeb, options);
+    }
+    catch (err) {
+        if (!options.tryEsmOnly) {
+            throw err;
+        }
+    }
+    if (!resolved && options.tryEsmOnly) {
+        resolved = resolveId(unresolvedId, pkg, targetWeb, {
+            ...options,
+            isRequire: false,
+            mainFields: DEFAULT_MAIN_FIELDS,
+            extensions: DEFAULT_EXTENSIONS$1
+        });
+    }
     if (!resolved) {
         return;
     }
@@ -30373,7 +30391,7 @@ function loadPackageData(pkgPath, cacheKey = pkgPath) {
     packageCache.set(cacheKey, pkg);
     return pkg;
 }
-function resolvePackageEntry(id, { dir, data, setResolvedCache, getResolvedCache }, options, targetWeb, preserveSymlinks = false) {
+function resolvePackageEntry(id, { dir, data, setResolvedCache, getResolvedCache }, targetWeb, options) {
     var _a, _b;
     const cached = getResolvedCache('.', targetWeb);
     if (cached) {
@@ -30405,7 +30423,7 @@ function resolvePackageEntry(id, { dir, data, setResolvedCache, getResolvedCache
                     // the heuristics here is to actually read the browser entry when
                     // possible and check for hints of UMD. If it is UMD, prefer "module"
                     // instead; Otherwise, assume it's ESM and use it.
-                    const resolvedBrowserEntry = tryFsResolve(path__default.join(dir, browserEntry), options, preserveSymlinks);
+                    const resolvedBrowserEntry = tryFsResolve(path__default.join(dir, browserEntry), options);
                     if (resolvedBrowserEntry) {
                         const content = fs__default.readFileSync(resolvedBrowserEntry, 'utf-8');
                         if ((/typeof exports\s*==/.test(content) &&
@@ -30442,7 +30460,7 @@ function resolvePackageEntry(id, { dir, data, setResolvedCache, getResolvedCache
             entryPoint = mapWithBrowserField(entryPoint, browserField) || entryPoint;
         }
         entryPoint = path__default.join(dir, entryPoint);
-        const resolvedEntryPoint = tryFsResolve(entryPoint, options, preserveSymlinks);
+        const resolvedEntryPoint = tryFsResolve(entryPoint, options);
         if (resolvedEntryPoint) {
             isDebug$5 &&
                 debug$d(`[package entry] ${source.cyan(id)} -> ${source.dim(resolvedEntryPoint)}`);
@@ -30476,7 +30494,7 @@ function resolveExports(pkg, key, options, targetWeb) {
         conditions
     });
 }
-function resolveDeepImport(id, { webResolvedImports, setResolvedCache, getResolvedCache, dir, data }, options, targetWeb, preserveSymlinks) {
+function resolveDeepImport(id, { webResolvedImports, setResolvedCache, getResolvedCache, dir, data }, targetWeb, options) {
     const cache = getResolvedCache(id, targetWeb);
     if (cache) {
         return cache;
@@ -30507,7 +30525,7 @@ function resolveDeepImport(id, { webResolvedImports, setResolvedCache, getResolv
         }
     }
     if (relativeId) {
-        const resolved = tryFsResolve(path__default.join(dir, relativeId), options, preserveSymlinks, !exportsField, // try index only if no exports field
+        const resolved = tryFsResolve(path__default.join(dir, relativeId), options, !exportsField, // try index only if no exports field
         targetWeb);
         if (resolved) {
             isDebug$5 &&
@@ -30517,7 +30535,7 @@ function resolveDeepImport(id, { webResolvedImports, setResolvedCache, getResolv
         }
     }
 }
-function tryResolveBrowserMapping(id, importer, options, isFilePath, preserveSymlinks) {
+function tryResolveBrowserMapping(id, importer, options, isFilePath) {
     let res;
     const pkg = importer && idToPkgMap.get(importer);
     if (pkg && isObject$3(pkg.data.browser)) {
@@ -30525,7 +30543,7 @@ function tryResolveBrowserMapping(id, importer, options, isFilePath, preserveSym
         const browserMappedPath = mapWithBrowserField(mapId, pkg.data.browser);
         if (browserMappedPath) {
             const fsPath = path__default.join(pkg.dir, browserMappedPath);
-            if ((res = tryFsResolve(fsPath, options, preserveSymlinks))) {
+            if ((res = tryFsResolve(fsPath, options))) {
                 isDebug$5 &&
                     debug$d(`[browser mapped] ${source.cyan(id)} -> ${source.dim(res)}`);
                 idToPkgMap.set(res, pkg);
@@ -43186,9 +43204,7 @@ function resolveBuildOptions(root, raw) {
         input = Array.isArray(raw.rollupOptions.input)
             ? raw.rollupOptions.input.map(input => resolve(input))
             : typeof raw.rollupOptions.input === 'object'
-                ? Object.assign(
-                // @ts-ignore
-                ...Object.keys(raw.rollupOptions.input).map(key => ({ [key]: resolve(raw.rollupOptions.input[key]) })))
+                ? Object.fromEntries(Object.entries(raw.rollupOptions.input).map(([key, value]) => [key, resolve(value)]))
                 : resolve(raw.rollupOptions.input);
     }
     else {
@@ -49346,7 +49362,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-732fded6.js'); }).then(function (n) { return n.index; });
+    const { generate } = await Promise.resolve().then(function () { return require('./dep-146e2d5f.js'); }).then(function (n) { return n.index; });
     const pems = generate(null, {
         algorithm: 'sha256',
         days: 30,
@@ -67073,28 +67089,20 @@ async function instantiateModule(url, server, context = { global }, urlStack = [
     };
     urlStack = urlStack.concat(url);
     const isCircular = (url) => urlStack.includes(url);
-    const { isProduction, resolve: { dedupe }, root } = server.config;
+    const { isProduction, resolve: { dedupe, preserveSymlinks }, root } = server.config;
     // The `extensions` and `mainFields` options are used to ensure that
     // CommonJS modules are preferred. We want to avoid ESM->ESM imports
     // whenever possible, because `hookNodeResolve` can't intercept them.
     const resolveOptions = {
-        // By adding "require" to the `conditions` array, resolution of the
-        // pkg.exports field will use "require" condition whenever it comes
-        // before "import" condition.
-        conditions: ['node', 'require'],
         dedupe,
-        extensions: ['.js', '.cjs', '.mjs', '.jsx', '.json'],
+        extensions: ['.js', '.cjs', '.json'],
         isBuild: true,
         isProduction,
-        mainFields: ['main', ...DEFAULT_MAIN_FIELDS],
+        isRequire: true,
+        mainFields: ['main'],
+        preserveSymlinks,
         root
     };
-    // Prevent ESM modules from being resolved during test runs, since Jest
-    // cannot `require` them. Note: This prevents testing of ESM-only packages.
-    if (typeof jest !== 'undefined') {
-        resolveOptions.isRequire = true;
-        resolveOptions.mainFields = ['main'];
-    }
     // Since dynamic imports can happen in parallel, we need to
     // account for multiple pending deps and duplicate imports.
     const pendingDeps = [];
@@ -67164,8 +67172,8 @@ async function instantiateModule(url, server, context = { global }, urlStack = [
 async function nodeImport(id, importer, resolveOptions) {
     // Node's module resolution is hi-jacked so Vite can ensure the
     // configured `resolve.dedupe` and `mode` options are respected.
-    const viteResolve = (id, importer) => {
-        const resolved = tryNodeResolve(id, importer, resolveOptions, false);
+    const viteResolve = (id, importer, options = resolveOptions) => {
+        const resolved = tryNodeResolve(id, importer, options, false);
         if (!resolved) {
             const err = new Error(`Cannot find module '${id}' imported from '${importer}'`);
             err.code = 'ERR_MODULE_NOT_FOUND';
@@ -67178,18 +67186,25 @@ async function nodeImport(id, importer, resolveOptions) {
         if (id[0] === '.' || isBuiltin(id)) {
             return nodeResolve(id, parent, isMain, options);
         }
-        if (!parent) {
-            return id;
+        if (parent) {
+            return viteResolve(id, parent.id);
         }
-        return viteResolve(id, parent.id);
+        // Importing a CJS module from an ESM module. In this case, the import
+        // specifier is already an absolute path, so this is a no-op.
+        // Options like `resolve.dedupe` and `mode` are not respected.
+        return id;
     });
     let url;
-    // `resolve` doesn't handle `node:` builtins, so handle them directly
     if (id.startsWith('node:') || isBuiltin(id)) {
         url = id;
     }
     else {
-        url = viteResolve(id, importer);
+        url = viteResolve(id, importer, 
+        // Non-external modules can import ESM-only modules, but only outside
+        // of test runs, because we use Node `require` in Jest to avoid segfault.
+        typeof jest === 'undefined'
+            ? { ...resolveOptions, tryEsmOnly: true }
+            : resolveOptions);
         if (usingDynamicImport) {
             url = require$$0$7.pathToFileURL(url).toString();
         }
@@ -82204,4 +82219,4 @@ exports.send = send$1;
 exports.sortUserPlugins = sortUserPlugins;
 exports.source = source;
 exports.transformWithEsbuild = transformWithEsbuild;
-//# sourceMappingURL=dep-6920cd01.js.map
+//# sourceMappingURL=dep-0183a921.js.map