@rollup/plugin-node-resolve 11.0.1 → 11.2.1

package/dist/es/index.js

@@ -4,13 +4,22 @@ import deepMerge from 'deepmerge';
 import isModule from 'is-module';
 import fs, { realpathSync } from 'fs';
 import { promisify } from 'util';
+import { pathToFileURL, fileURLToPath } from 'url';
 import resolve$1 from 'resolve';
 import { createFilter } from '@rollup/pluginutils';
 
-const exists = promisify(fs.exists);
+const access = promisify(fs.access);
 const readFile = promisify(fs.readFile);
 const realpath = promisify(fs.realpath);
 const stat = promisify(fs.stat);
+async function exists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
 
 const onError = (error) => {
   if (error.code === 'ENOENT') {
@@ -102,7 +111,16 @@ function getMainFields(options) {
 }
 
 function getPackageInfo(options) {
-  const { cache, extensions, pkg, mainFields, preserveSymlinks, useBrowserOverrides } = options;
+  const {
+    cache,
+    extensions,
+    pkg,
+    mainFields,
+    preserveSymlinks,
+    useBrowserOverrides,
+    rootDir,
+    ignoreSideEffectsForRoot
+  } = options;
   let { pkgPath } = options;
 
   if (cache.has(pkgPath)) {
@@ -192,13 +210,15 @@ function getPackageInfo(options) {
     packageInfo.browserMappedMain = false;
   }
 
-  const packageSideEffects = pkg.sideEffects;
-  if (typeof packageSideEffects === 'boolean') {
-    internalPackageInfo.hasModuleSideEffects = () => packageSideEffects;
-  } else if (Array.isArray(packageSideEffects)) {
-    internalPackageInfo.hasModuleSideEffects = createFilter(packageSideEffects, null, {
-      resolve: pkgRoot
-    });
+  if (!ignoreSideEffectsForRoot || rootDir !== pkgRoot) {
+    const packageSideEffects = pkg.sideEffects;
+    if (typeof packageSideEffects === 'boolean') {
+      internalPackageInfo.hasModuleSideEffects = () => packageSideEffects;
+    } else if (Array.isArray(packageSideEffects)) {
+      internalPackageInfo.hasModuleSideEffects = createFilter(packageSideEffects, null, {
+        resolve: pkgRoot
+      });
+    }
   }
 
   cache.set(pkgPath, internalPackageInfo);
@@ -216,168 +236,332 @@ function normalizeInput(input) {
   return [input];
 }
 
-const resolveImportPath = promisify(resolve$1);
-const readFile$1 = promisify(fs.readFile);
+/* eslint-disable no-await-in-loop */
+
+const fileExists = promisify(fs.exists);
+
+function isModuleDir(current, moduleDirs) {
+  return moduleDirs.some((dir) => current.endsWith(dir));
+}
+
+async function findPackageJson(base, moduleDirs) {
+  const { root } = path.parse(base);
+  let current = base;
 
-const pathNotFoundError = (importPath, importer, subPath, pkgPath) =>
-  new Error(
-    `Could not resolve import "${importPath}" in "${importer}".` +
-      ` Package subpath "${subPath}" is not defined by "exports" in ${pkgPath}`
-  );
+  while (current !== root && !isModuleDir(current, moduleDirs)) {
+    const pkgJsonPath = path.join(current, 'package.json');
+    if (await fileExists(pkgJsonPath)) {
+      const pkgJsonString = fs.readFileSync(pkgJsonPath, 'utf-8');
+      return { pkgJson: JSON.parse(pkgJsonString), pkgPath: current, pkgJsonPath };
+    }
+    current = path.resolve(current, '..');
+  }
+  return null;
+}
 
-function findExportKeyMatch(exportMap, subPath) {
-  if (subPath in exportMap) {
-    return subPath;
+function isUrl(str) {
+  try {
+    return !!new URL(str);
+  } catch (_) {
+    return false;
   }
+}
 
-  const matchKeys = Object.keys(exportMap)
-    .filter((key) => key.endsWith('/') || key.endsWith('*'))
-    .sort((a, b) => b.length - a.length);
+function isConditions(exports) {
+  return typeof exports === 'object' && Object.keys(exports).every((k) => !k.startsWith('.'));
+}
+
+function isMappings(exports) {
+  return typeof exports === 'object' && !isConditions(exports);
+}
+
+function isMixedExports(exports) {
+  const keys = Object.keys(exports);
+  return keys.some((k) => k.startsWith('.')) && keys.some((k) => !k.startsWith('.'));
+}
+
+function createBaseErrorMsg(importSpecifier, importer) {
+  return `Could not resolve import "${importSpecifier}" in ${importer}`;
+}
+
+function createErrorMsg(context, reason, internal) {
+  const { importSpecifier, importer, pkgJsonPath } = context;
+  const base = createBaseErrorMsg(importSpecifier, importer);
+  const field = internal ? 'imports' : 'exports';
+  return `${base} using ${field} defined in ${pkgJsonPath}.${reason ? ` ${reason}` : ''}`;
+}
+
+class ResolveError extends Error {}
+
+class InvalidConfigurationError extends ResolveError {
+  constructor(context, reason) {
+    super(createErrorMsg(context, `Invalid "exports" field. ${reason}`));
+  }
+}
+
+class InvalidModuleSpecifierError extends ResolveError {
+  constructor(context, internal) {
+    super(createErrorMsg(context, internal));
+  }
+}
+
+class InvalidPackageTargetError extends ResolveError {
+  constructor(context, reason) {
+    super(createErrorMsg(context, reason));
+  }
+}
+
+/* eslint-disable no-await-in-loop, no-undefined */
 
-  for (const key of matchKeys) {
-    if (key.endsWith('*')) {
-      // star match: "./foo/*": "./foo/*.js"
-      const keyWithoutStar = key.substring(0, key.length - 1);
-      if (subPath.startsWith(keyWithoutStar)) {
-        return key;
+function includesInvalidSegments(pathSegments, moduleDirs) {
+  return pathSegments
+    .split('/')
+    .slice(1)
+    .some((t) => ['.', '..', ...moduleDirs].includes(t));
+}
+
+async function resolvePackageTarget(context, { target, subpath, pattern, internal }) {
+  if (typeof target === 'string') {
+    if (!pattern && subpath.length > 0 && !target.endsWith('/')) {
+      throw new InvalidModuleSpecifierError(context);
+    }
+
+    if (!target.startsWith('./')) {
+      if (internal && !['/', '../'].some((p) => target.startsWith(p)) && !isUrl(target)) {
+        // this is a bare package import, remap it and resolve it using regular node resolve
+        if (pattern) {
+          const result = await context.resolveId(
+            target.replace(/\*/g, subpath),
+            context.pkgURL.href
+          );
+          return result ? pathToFileURL(result.location) : null;
+        }
+
+        const result = await context.resolveId(`${target}${subpath}`, context.pkgURL.href);
+        return result ? pathToFileURL(result.location) : null;
       }
+      throw new InvalidPackageTargetError(context, `Invalid mapping: "${target}".`);
+    }
+
+    if (includesInvalidSegments(target, context.moduleDirs)) {
+      throw new InvalidPackageTargetError(context, `Invalid mapping: "${target}".`);
     }
 
-    if (key.endsWith('/') && subPath.startsWith(key)) {
-      // directory match (deprecated by node): "./foo/": "./foo/.js"
-      return key;
+    const resolvedTarget = new URL(target, context.pkgURL);
+    if (!resolvedTarget.href.startsWith(context.pkgURL.href)) {
+      throw new InvalidPackageTargetError(
+        context,
+        `Resolved to ${resolvedTarget.href} which is outside package ${context.pkgURL.href}`
+      );
+    }
+
+    if (includesInvalidSegments(subpath, context.moduleDirs)) {
+      throw new InvalidModuleSpecifierError(context);
     }
 
-    if (key === subPath) {
-      // literal match
-      return key;
+    if (pattern) {
+      return resolvedTarget.href.replace(/\*/g, subpath);
     }
+    return new URL(subpath, resolvedTarget).href;
   }
-  return null;
-}
 
-function mapSubPath({ importPath, importer, pkgJsonPath, subPath, key, value }) {
-  if (typeof value === 'string') {
-    if (typeof key === 'string' && key.endsWith('*')) {
-      // star match: "./foo/*": "./foo/*.js"
-      const keyWithoutStar = key.substring(0, key.length - 1);
-      const subPathAfterKey = subPath.substring(keyWithoutStar.length);
-      return value.replace(/\*/g, subPathAfterKey);
+  if (Array.isArray(target)) {
+    let lastError;
+    for (const item of target) {
+      try {
+        const resolved = await resolvePackageTarget(context, {
+          target: item,
+          subpath,
+          pattern,
+          internal
+        });
+
+        // return if defined or null, but not undefined
+        if (resolved !== undefined) {
+          return resolved;
+        }
+      } catch (error) {
+        if (!(error instanceof InvalidPackageTargetError)) {
+          throw error;
+        } else {
+          lastError = error;
+        }
+      }
     }
 
-    if (value.endsWith('/')) {
-      // directory match (deprecated by node): "./foo/": "./foo/.js"
-      return `${value}${subPath.substring(key.length)}`;
+    if (lastError) {
+      throw lastError;
     }
+    return null;
+  }
+
+  if (target && typeof target === 'object') {
+    for (const [key, value] of Object.entries(target)) {
+      if (key === 'default' || context.conditions.includes(key)) {
+        const resolved = await resolvePackageTarget(context, {
+          target: value,
+          subpath,
+          pattern,
+          internal
+        });
 
-    // mapping is a string, for example { "./foo": "./dist/foo.js" }
-    return value;
+        // return if defined or null, but not undefined
+        if (resolved !== undefined) {
+          return resolved;
+        }
+      }
+    }
+    return undefined;
   }
 
-  if (Array.isArray(value)) {
-    // mapping is an array with fallbacks, for example { "./foo": ["foo:bar", "./dist/foo.js"] }
-    return value.find((v) => v.startsWith('./'));
+  if (target === null) {
+    return null;
   }
 
-  throw pathNotFoundError(importPath, importer, subPath, pkgJsonPath);
+  throw new InvalidPackageTargetError(context, `Invalid exports field.`);
 }
 
-function findEntrypoint({
-  importPath,
-  importer,
-  pkgJsonPath,
-  subPath,
-  exportMap,
-  conditions,
-  key
-}) {
-  if (typeof exportMap !== 'object') {
-    return mapSubPath({ importPath, importer, pkgJsonPath, subPath, key, value: exportMap });
+/* eslint-disable no-await-in-loop */
+
+async function resolvePackageImportsExports(context, { matchKey, matchObj, internal }) {
+  if (!matchKey.endsWith('*') && matchKey in matchObj) {
+    const target = matchObj[matchKey];
+    const resolved = await resolvePackageTarget(context, { target, subpath: '', internal });
+    return resolved;
   }
 
-  // iterate conditions recursively, find the first that matches all conditions
-  for (const [condition, subExportMap] of Object.entries(exportMap)) {
-    if (conditions.includes(condition)) {
-      const mappedSubPath = findEntrypoint({
-        importPath,
-        importer,
-        pkgJsonPath,
-        subPath,
-        exportMap: subExportMap,
-        conditions,
-        key
+  const expansionKeys = Object.keys(matchObj)
+    .filter((k) => k.endsWith('/') || k.endsWith('*'))
+    .sort((a, b) => b.length - a.length);
+
+  for (const expansionKey of expansionKeys) {
+    const prefix = expansionKey.substring(0, expansionKey.length - 1);
+
+    if (expansionKey.endsWith('*') && matchKey.startsWith(prefix)) {
+      const target = matchObj[expansionKey];
+      const subpath = matchKey.substring(expansionKey.length - 1);
+      const resolved = await resolvePackageTarget(context, {
+        target,
+        subpath,
+        pattern: true,
+        internal
       });
-      if (mappedSubPath) {
-        return mappedSubPath;
-      }
+      return resolved;
     }
-  }
-  throw pathNotFoundError(importer, subPath, pkgJsonPath);
-}
 
-function findEntrypointTopLevel({
-  importPath,
-  importer,
-  pkgJsonPath,
-  subPath,
-  exportMap,
-  conditions
-}) {
-  if (typeof exportMap !== 'object') {
-    // the export map shorthand, for example { exports: "./index.js" }
-    if (subPath !== '.') {
-      // shorthand only supports a main entrypoint
-      throw pathNotFoundError(importPath, importer, subPath, pkgJsonPath);
+    if (matchKey.startsWith(expansionKey)) {
+      const target = matchObj[expansionKey];
+      const subpath = matchKey.substring(expansionKey.length);
+
+      const resolved = await resolvePackageTarget(context, { target, subpath, internal });
+      return resolved;
     }
-    return mapSubPath({ importPath, importer, pkgJsonPath, subPath, key: null, value: exportMap });
   }
 
-  // export map is an object, the top level can be either conditions or sub path mappings
-  const keys = Object.keys(exportMap);
-  const isConditions = keys.every((k) => !k.startsWith('.'));
-  const isMappings = keys.every((k) => k.startsWith('.'));
+  throw new InvalidModuleSpecifierError(context, internal);
+}
 
-  if (!isConditions && !isMappings) {
-    throw new Error(
-      `Invalid package config ${pkgJsonPath}, "exports" cannot contain some keys starting with '.'` +
-        ' and some not. The exports object must either be an object of package subpath keys or an object of main entry' +
-        ' condition name keys only.'
+async function resolvePackageExports(context, subpath, exports) {
+  if (isMixedExports(exports)) {
+    throw new InvalidConfigurationError(
+      context,
+      'All keys must either start with ./, or without one.'
     );
   }
 
-  let key = null;
-  let exportMapForSubPath;
+  if (subpath === '.') {
+    let mainExport;
+    // If exports is a String or Array, or an Object containing no keys starting with ".", then
+    if (typeof exports === 'string' || Array.isArray(exports) || isConditions(exports)) {
+      mainExport = exports;
+    } else if (isMappings(exports)) {
+      mainExport = exports['.'];
+    }
 
-  if (isConditions) {
-    // top level is conditions, for example { "import": ..., "require": ..., "module": ... }
-    if (subPath !== '.') {
-      // package with top level conditions means it only supports a main entrypoint
-      throw pathNotFoundError(importPath, importer, subPath, pkgJsonPath);
+    if (mainExport) {
+      const resolved = await resolvePackageTarget(context, { target: mainExport, subpath: '' });
+      if (resolved) {
+        return resolved;
+      }
     }
-    exportMapForSubPath = exportMap;
-  } else {
-    // top level is sub path mappings, for example { ".": ..., "./foo": ..., "./bar": ... }
-    key = findExportKeyMatch(exportMap, subPath);
-    if (!key) {
-      throw pathNotFoundError(importPath, importer, subPath, pkgJsonPath);
+  } else if (isMappings(exports)) {
+    const resolvedMatch = await resolvePackageImportsExports(context, {
+      matchKey: subpath,
+      matchObj: exports
+    });
+
+    if (resolvedMatch) {
+      return resolvedMatch;
     }
-    exportMapForSubPath = exportMap[key];
   }
 
-  return findEntrypoint({
-    importPath,
+  throw new InvalidModuleSpecifierError(context);
+}
+
+async function resolvePackageImports({
+  importSpecifier,
+  importer,
+  moduleDirs,
+  conditions,
+  resolveId
+}) {
+  const result = await findPackageJson(importer, moduleDirs);
+  if (!result) {
+    throw new Error(createBaseErrorMsg('. Could not find a parent package.json.'));
+  }
+
+  const { pkgPath, pkgJsonPath, pkgJson } = result;
+  const pkgURL = pathToFileURL(`${pkgPath}/`);
+  const context = {
     importer,
+    importSpecifier,
+    moduleDirs,
+    pkgURL,
     pkgJsonPath,
-    subPath,
-    exportMap: exportMapForSubPath,
     conditions,
-    key
+    resolveId
+  };
+
+  const { imports } = pkgJson;
+  if (!imports) {
+    throw new InvalidModuleSpecifierError(context, true);
+  }
+
+  if (importSpecifier === '#' || importSpecifier.startsWith('#/')) {
+    throw new InvalidModuleSpecifierError(context, 'Invalid import specifier.');
+  }
+
+  return resolvePackageImportsExports(context, {
+    matchKey: importSpecifier,
+    matchObj: imports,
+    internal: true
   });
 }
 
+const resolveImportPath = promisify(resolve$1);
+const readFile$1 = promisify(fs.readFile);
+
+async function getPackageJson(importer, pkgName, resolveOptions, moduleDirectories) {
+  if (importer) {
+    const selfPackageJsonResult = await findPackageJson(importer, moduleDirectories);
+    if (selfPackageJsonResult && selfPackageJsonResult.pkgJson.name === pkgName) {
+      // the referenced package name is the current package
+      return selfPackageJsonResult;
+    }
+  }
+
+  try {
+    const pkgJsonPath = await resolveImportPath(`${pkgName}/package.json`, resolveOptions);
+    const pkgJson = JSON.parse(await readFile$1(pkgJsonPath, 'utf-8'));
+    return { pkgJsonPath, pkgJson };
+  } catch (_) {
+    return null;
+  }
+}
+
 async function resolveId({
   importer,
-  importPath,
+  importSpecifier,
   exportConditions,
   warn,
   packageInfoCache,
@@ -386,7 +570,9 @@ async function resolveId({
   preserveSymlinks,
   useBrowserOverrides,
   baseDir,
-  moduleDirectories
+  moduleDirectories,
+  rootDir,
+  ignoreSideEffectsForRoot
 }) {
   let hasModuleSideEffects = () => null;
   let hasPackageEntry = true;
@@ -401,7 +587,9 @@ async function resolveId({
       pkgPath,
       mainFields,
       preserveSymlinks,
-      useBrowserOverrides
+      useBrowserOverrides,
+      rootDir,
+      ignoreSideEffectsForRoot
     });
 
     ({ packageInfo, hasModuleSideEffects, hasPackageEntry, packageBrowserField } = info);
@@ -423,41 +611,70 @@ async function resolveId({
 
   let location;
 
-  const pkgName = getPackageName(importPath);
-  if (pkgName) {
-    let pkgJsonPath;
-    let pkgJson;
-    try {
-      pkgJsonPath = await resolveImportPath(`${pkgName}/package.json`, resolveOptions);
-      pkgJson = JSON.parse(await readFile$1(pkgJsonPath, 'utf-8'));
-    } catch (_) {
-      // if there is no package.json we defer to regular resolve behavior
-    }
+  const pkgName = getPackageName(importSpecifier);
+  if (importSpecifier.startsWith('#')) {
+    // this is a package internal import, resolve using package imports field
+    const resolveResult = await resolvePackageImports({
+      importSpecifier,
+      importer,
+      moduleDirs: moduleDirectories,
+      conditions: exportConditions,
+      resolveId(id, parent) {
+        return resolveId({
+          importSpecifier: id,
+          importer: parent,
+          exportConditions,
+          warn,
+          packageInfoCache,
+          extensions,
+          mainFields,
+          preserveSymlinks,
+          useBrowserOverrides,
+          baseDir,
+          moduleDirectories
+        });
+      }
+    });
+    location = fileURLToPath(resolveResult);
+  } else if (pkgName) {
+    // it's a bare import, find the package.json and resolve using package exports if available
+    const result = await getPackageJson(importer, pkgName, resolveOptions, moduleDirectories);
 
-    if (pkgJsonPath && pkgJson && pkgJson.exports) {
+    if (result && result.pkgJson.exports) {
+      const { pkgJson, pkgJsonPath } = result;
       try {
-        const packageSubPath =
-          pkgName === importPath ? '.' : `.${importPath.substring(pkgName.length)}`;
-        const mappedSubPath = findEntrypointTopLevel({
+        const subpath =
+          pkgName === importSpecifier ? '.' : `.${importSpecifier.substring(pkgName.length)}`;
+        const pkgDr = pkgJsonPath.replace('package.json', '');
+        const pkgURL = pathToFileURL(pkgDr);
+
+        const context = {
           importer,
-          importPath,
+          importSpecifier,
+          moduleDirs: moduleDirectories,
+          pkgURL,
           pkgJsonPath,
-          subPath: packageSubPath,
-          exportMap: pkgJson.exports,
           conditions: exportConditions
-        });
-        const pkgDir = path.dirname(pkgJsonPath);
-        location = path.join(pkgDir, mappedSubPath);
+        };
+        const resolvedPackageExport = await resolvePackageExports(
+          context,
+          subpath,
+          pkgJson.exports
+        );
+        location = fileURLToPath(resolvedPackageExport);
       } catch (error) {
-        warn(error);
-        return null;
+        if (error instanceof ResolveError) {
+          return error;
+        }
+        throw error;
       }
     }
   }
 
   if (!location) {
+    // package has no imports or exports, use classic node resolve
     try {
-      location = await resolveImportPath(importPath, resolveOptions);
+      location = await resolveImportPath(importSpecifier, resolveOptions);
     } catch (error) {
       if (error.code !== 'MODULE_NOT_FOUND') {
         throw error;
@@ -494,13 +711,17 @@ async function resolveImportSpecifiers({
   preserveSymlinks,
   useBrowserOverrides,
   baseDir,
-  moduleDirectories
+  moduleDirectories,
+  rootDir,
+  ignoreSideEffectsForRoot
 }) {
+  let lastResolveError;
+
   for (let i = 0; i < importSpecifierList.length; i++) {
     // eslint-disable-next-line no-await-in-loop
-    const resolved = await resolveId({
+    const result = await resolveId({
       importer,
-      importPath: importSpecifierList[i],
+      importSpecifier: importSpecifierList[i],
       exportConditions,
       warn,
       packageInfoCache,
@@ -509,12 +730,22 @@ async function resolveImportSpecifiers({
       preserveSymlinks,
       useBrowserOverrides,
       baseDir,
-      moduleDirectories
+      moduleDirectories,
+      rootDir,
+      ignoreSideEffectsForRoot
     });
-    if (resolved) {
-      return resolved;
+
+    if (result instanceof ResolveError) {
+      lastResolveError = result;
+    } else if (result) {
+      return result;
     }
   }
+
+  if (lastResolveError) {
+    // only log the last failed resolve error
+    warn(lastResolveError);
+  }
   return null;
 }
 
@@ -590,7 +821,8 @@ const defaults = {
   // which deploy both ESM .mjs and CommonJS .js files as ESM.
   extensions: ['.mjs', '.js', '.json', '.node'],
   resolveOnly: [],
-  moduleDirectories: ['node_modules']
+  moduleDirectories: ['node_modules'],
+  ignoreSideEffectsForRoot: false
 };
 const DEFAULTS = deepFreeze(deepMerge({}, defaults));
 
@@ -598,7 +830,7 @@ function nodeResolve(opts = {}) {
   const { warnings } = handleDeprecatedOptions(opts);
 
   const options = { ...defaults, ...opts };
-  const { extensions, jail, moduleDirectories } = options;
+  const { extensions, jail, moduleDirectories, ignoreSideEffectsForRoot } = options;
   const conditionsEsm = [...baseConditionsEsm, ...(options.exportConditions || [])];
   const conditionsCjs = [...baseConditionsCjs, ...(options.exportConditions || [])];
   const packageInfoCache = new Map();
@@ -607,7 +839,7 @@ function nodeResolve(opts = {}) {
   const useBrowserOverrides = mainFields.indexOf('browser') !== -1;
   const isPreferBuiltinsSet = options.preferBuiltins === true || options.preferBuiltins === false;
   const preferBuiltins = isPreferBuiltinsSet ? options.preferBuiltins : true;
-  const rootDir = options.rootDir || process.cwd();
+  const rootDir = resolve(options.rootDir || process.cwd());
   let { dedupe } = options;
   let rollupOptions;
 
@@ -756,7 +988,9 @@ function nodeResolve(opts = {}) {
         preserveSymlinks,
         useBrowserOverrides,
         baseDir,
-        moduleDirectories
+        moduleDirectories,
+        rootDir,
+        ignoreSideEffectsForRoot
       });
 
       const resolved =