@rollup/plugin-commonjs 15.1.0 → 16.0.0

package/dist/index.js

@@ -1,28 +1,33 @@
 'use strict';
 
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
 var path = require('path');
 var pluginutils = require('@rollup/pluginutils');
-var getCommonDir = _interopDefault(require('commondir'));
+var getCommonDir = require('commondir');
 var fs = require('fs');
 var estreeWalker = require('estree-walker');
-var MagicString = _interopDefault(require('magic-string'));
+var MagicString = require('magic-string');
 var resolve = require('resolve');
-var isReference = _interopDefault(require('is-reference'));
-var glob = _interopDefault(require('glob'));
+var isReference = require('is-reference');
+var glob = require('glob');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var getCommonDir__default = /*#__PURE__*/_interopDefaultLegacy(getCommonDir);
+var MagicString__default = /*#__PURE__*/_interopDefaultLegacy(MagicString);
+var isReference__default = /*#__PURE__*/_interopDefaultLegacy(isReference);
+var glob__default = /*#__PURE__*/_interopDefaultLegacy(glob);
 
 var peerDependencies = {
-	rollup: "^2.22.0"
+	rollup: "^2.30.0"
 };
 
-const PROXY_SUFFIX = '?commonjs-proxy';
-const getProxyId = (id) => `\0${id}${PROXY_SUFFIX}`;
-const getIdFromProxyId = (proxyId) => proxyId.slice(1, -PROXY_SUFFIX.length);
+const isWrappedId = (id, suffix) => id.endsWith(suffix);
+const wrapId = (id, suffix) => `\0${id}${suffix}`;
+const unwrapId = (wrappedId, suffix) => wrappedId.slice(1, -suffix.length);
 
+const PROXY_SUFFIX = '?commonjs-proxy';
+const REQUIRE_SUFFIX = '?commonjs-require';
 const EXTERNAL_SUFFIX = '?commonjs-external';
-const getExternalProxyId = (id) => `\0${id}${EXTERNAL_SUFFIX}`;
-const getIdFromExternalProxyId = (proxyId) => proxyId.slice(1, -EXTERNAL_SUFFIX.length);
 
 const VIRTUAL_PATH_BASE = '/$$rollup_base$$';
 const getVirtualPathForDynamicRequirePath = (path, commonDir) => {
@@ -418,17 +423,19 @@ function transformCommonjs(
   sourceMap,
   isDynamicRequireModulesEnabled,
   dynamicRequireModuleSet,
+  disableWrap,
   commonDir,
   astCache
 ) {
   const ast = astCache || tryParse(parse, code, id);
 
-  const magicString = new MagicString(code);
+  const magicString = new MagicString__default['default'](code);
 
   const required = {};
   // Because objects have no guaranteed ordering, yet we need it,
   // we need to keep track of the order in a array
-  const sources = [];
+  const requiredSources = [];
+  const dynamicRegisterSources = [];
 
   let uid = 0;
 
@@ -519,8 +526,7 @@ function transformCommonjs(
     }
 
     const existing = required[sourceId];
-    // eslint-disable-next-line no-undefined
-    if (existing === undefined) {
+    if (!existing) {
       const isDynamic = hasDynamicModuleForPath(sourceId);
 
       if (!name) {
@@ -530,12 +536,15 @@ function transformCommonjs(
         } while (scope.contains(name));
       }
 
-      if (isDynamicRegister && sourceId.endsWith('.json')) {
-        sourceId = DYNAMIC_JSON_PREFIX + sourceId;
+      if (isDynamicRegister) {
+        if (sourceId.endsWith('.json')) {
+          sourceId = DYNAMIC_JSON_PREFIX + sourceId;
+        }
+        dynamicRegisterSources.push(sourceId);
       }
 
-      if (isDynamicRegister || !isDynamic || sourceId.endsWith('.json')) {
-        sources.push([sourceId, !isDynamicRegister]);
+      if (!isDynamic || sourceId.endsWith('.json')) {
+        requiredSources.push(sourceId);
       }
 
       required[sourceId] = { source: sourceId, name, importsDefault: false, isDynamic };
@@ -545,7 +554,7 @@ function transformCommonjs(
   }
 
   function hasDynamicModuleForPath(source) {
-    if (!/[/\\]/.test(source)) {
+    if (!/^(?:\.{0,2}[/\\]|[A-Za-z]:[/\\])/.test(source)) {
       try {
         const resolvedPath = normalizePathSlashes(
           resolve.sync(source, { basedir: path.dirname(id) })
@@ -659,7 +668,7 @@ function transformCommonjs(
       // rewrite `require` (if not already handled) `global` and `define`, and handle free references to
       // `module` and `exports` as these mean we need to wrap the module in commonjsHelpers.createCommonjsModule
       if (node.type === 'Identifier') {
-        if (isReference(node, parent) && !scope.contains(node.name)) {
+        if (isReference__default['default'](node, parent) && !scope.contains(node.name)) {
           if (node.name in uses) {
             if (isRequireIdentifier(node)) {
               if (isNodeRequireStatement(parent)) {
@@ -836,42 +845,45 @@ function transformCommonjs(
     }
   });
 
+  // If `isEsModule` is on, it means it has ES6 import/export statements,
+  //   which just can't be wrapped in a function.
+  shouldWrap = shouldWrap && !disableWrap && !isEsModule;
+
+  usesCommonjsHelpers = usesCommonjsHelpers || shouldWrap;
+
   if (
-    !sources.length &&
+    !requiredSources.length &&
+    !dynamicRegisterSources.length &&
     !uses.module &&
     !uses.exports &&
     !uses.require &&
+    !usesCommonjsHelpers &&
     (ignoreGlobal || !uses.global)
   ) {
-    // not a CommonJS module
-    return null;
+    return { meta: { commonjs: { isCommonJS: false } } };
   }
 
-  // If `isEsModule` is on, it means it has ES6 import/export statements,
-  //   which just can't be wrapped in a function.
-  if (isEsModule) shouldWrap = false;
-
-  usesCommonjsHelpers = usesCommonjsHelpers || shouldWrap;
-
   const importBlock = `${(usesCommonjsHelpers
     ? [`import * as ${HELPERS_NAME} from '${HELPERS_ID}';`]
     : []
   )
     .concat(
-      sources.map(
-        ([source]) =>
-          // import the actual module before the proxy, so that we know
-          // what kind of proxy to build
-          `import '${source}';`
-      ),
-      sources
-        .filter(([, importProxy]) => importProxy)
-        .map(([source]) => {
-          const { name, importsDefault } = required[source];
-          return `import ${importsDefault ? `${name} from ` : ``}'${
-            source.startsWith('\0') ? source : getProxyId(source)
-          }';`;
-        })
+      // dynamic registers first, as the may be required in the other modules
+      dynamicRegisterSources.map((source) => `import '${source}';`),
+
+      // now the actual modules so that they are analyzed before creating the proxies;
+      // no need to do this for virtual modules as we never proxy them
+      requiredSources
+        .filter((source) => !source.startsWith('\0'))
+        .map((source) => `import '${wrapId(source, REQUIRE_SUFFIX)}';`),
+
+      // now the proxy modules
+      requiredSources.map((source) => {
+        const { name, importsDefault } = required[source];
+        return `import ${importsDefault ? `${name} from ` : ``}'${
+          source.startsWith('\0') ? source : wrapId(source, PROXY_SUFFIX)
+        }';`;
+      })
     )
     .join('\n')}\n\n`;
 
@@ -982,7 +994,12 @@ function transformCommonjs(
   code = magicString.toString();
   const map = sourceMap ? magicString.generateMap() : null;
 
-  return { code, map, syntheticNamedExports: isEsModule ? false : '__moduleExports' };
+  return {
+    code,
+    map,
+    syntheticNamedExports: isEsModule ? false : '__moduleExports',
+    meta: { commonjs: { isCommonJS: !isEsModule } }
+  };
 }
 
 function getDynamicPackagesModule(dynamicRequireModuleDirPaths, commonDir) {
@@ -1010,28 +1027,24 @@ function getDynamicPackagesModule(dynamicRequireModuleDirPaths, commonDir) {
 }
 
 function getDynamicPackagesEntryIntro(
-  id,
   dynamicRequireModuleDirPaths,
   dynamicRequireModuleSet
 ) {
-  try {
-    const code = fs.readFileSync(id, { encoding: 'utf8' });
-    let dynamicImports = Array.from(
-      dynamicRequireModuleSet,
-      (dynamicId) => `require(${JSON.stringify(DYNAMIC_REGISTER_PREFIX + dynamicId)});`
-    ).join('\n');
-
-    if (dynamicRequireModuleDirPaths.length) {
-      dynamicImports += `require(${JSON.stringify(
-        DYNAMIC_REGISTER_PREFIX + DYNAMIC_PACKAGES_ID
-      )});`;
-    }
+  let dynamicImports = Array.from(
+    dynamicRequireModuleSet,
+    (dynamicId) => `require(${JSON.stringify(DYNAMIC_REGISTER_PREFIX + dynamicId)});`
+  ).join('\n');
 
-    return `${dynamicImports}\n${code}`;
-  } catch (ex) {
-    this.warn(`Failed to read file ${id}, dynamic modules might not work correctly`);
-    return null;
+  if (dynamicRequireModuleDirPaths.length) {
+    dynamicImports += `require(${JSON.stringify(DYNAMIC_REGISTER_PREFIX + DYNAMIC_PACKAGES_ID)});`;
   }
+
+  return dynamicImports;
+}
+
+function isModuleRegistrationProxy(id, dynamicRequireModuleSet) {
+  const normalizedPath = normalizePathSlashes(id);
+  return dynamicRequireModuleSet.has(normalizedPath) && !normalizedPath.endsWith('.json');
 }
 
 function getDynamicRequirePaths(patterns) {
@@ -1039,7 +1052,7 @@ function getDynamicRequirePaths(patterns) {
   for (const pattern of !patterns || Array.isArray(patterns) ? patterns || [] : [patterns]) {
     const isNegated = pattern.startsWith('!');
     const modifySet = Set.prototype[isNegated ? 'delete' : 'add'].bind(dynamicRequireModuleSet);
-    for (const path$1 of glob.sync(isNegated ? pattern.substr(1) : pattern)) {
+    for (const path$1 of glob__default['default'].sync(isNegated ? pattern.substr(1) : pattern)) {
       modifySet(normalizePathSlashes(path.resolve(path$1)));
     }
   }
@@ -1056,7 +1069,6 @@ function getDynamicRequirePaths(patterns) {
   return { dynamicRequireModuleSet, dynamicRequireModuleDirPaths };
 }
 
-/* eslint-disable no-undefined */
 const isCjsPromises = new Map();
 
 function getIsCjsPromise(id) {
@@ -1066,7 +1078,7 @@ function getIsCjsPromise(id) {
   const promise = new Promise((resolve) => {
     isCjsPromise = {
       resolve,
-      promise: undefined
+      promise: null
     };
     isCjsPromises.set(id, isCjsPromise);
   });
@@ -1080,10 +1092,10 @@ function setIsCjsPromise(id, resolution) {
   if (isCjsPromise) {
     if (isCjsPromise.resolve) {
       isCjsPromise.resolve(resolution);
-      isCjsPromise.resolve = undefined;
+      isCjsPromise.resolve = null;
     }
   } else {
-    isCjsPromises.set(id, { promise: Promise.resolve(resolution), resolve: undefined });
+    isCjsPromises.set(id, { promise: Promise.resolve(resolution), resolve: null });
   }
 }
 
@@ -1185,10 +1197,18 @@ function getResolveId(extensions) {
     return undefined;
   }
 
-  function resolveId(importee, importer) {
-    const isProxyModule = importee.endsWith(PROXY_SUFFIX);
+  return function resolveId(importee, importer) {
+    // Proxies are only importing resolved ids, no need to resolve again
+    if (importer && isWrappedId(importer, PROXY_SUFFIX)) {
+      return importee;
+    }
+
+    const isProxyModule = isWrappedId(importee, PROXY_SUFFIX);
+    const isRequiredModule = isWrappedId(importee, REQUIRE_SUFFIX);
     if (isProxyModule) {
-      importee = getIdFromProxyId(importee);
+      importee = unwrapId(importee, PROXY_SUFFIX);
+    } else if (isRequiredModule) {
+      importee = unwrapId(importee, REQUIRE_SUFFIX);
     }
     if (importee.startsWith('\0')) {
       if (
@@ -1198,32 +1218,25 @@ function getResolveId(extensions) {
       ) {
         return importee;
       }
-      if (!isProxyModule) {
-        return null;
-      }
-    }
-
-    if (importer && importer.endsWith(PROXY_SUFFIX)) {
-      importer = getIdFromProxyId(importer);
+      return null;
     }
 
-    return this.resolve(importee, importer, { skipSelf: true }).then((resolved) => {
+    return this.resolve(importee, importer, {
+      skipSelf: true,
+      custom: { 'node-resolve': { isRequire: isProxyModule || isRequiredModule } }
+    }).then((resolved) => {
       if (!resolved) {
         resolved = resolveExtensions(importee, importer);
       }
-      if (isProxyModule) {
-        if (!resolved) {
-          return { id: getExternalProxyId(importee), external: false };
-        }
-        resolved.id = (resolved.external ? getExternalProxyId : getProxyId)(resolved.id);
+      if (resolved && isProxyModule) {
+        resolved.id = wrapId(resolved.id, resolved.external ? EXTERNAL_SUFFIX : PROXY_SUFFIX);
         resolved.external = false;
-        return resolved;
+      } else if (!resolved && (isProxyModule || isRequiredModule)) {
+        return { id: wrapId(importee, EXTERNAL_SUFFIX), external: false };
       }
       return resolved;
     });
-  }
-
-  return resolveId;
+  };
 }
 
 function commonjs(options = {}) {
@@ -1251,7 +1264,7 @@ function commonjs(options = {}) {
   );
   const isDynamicRequireModulesEnabled = dynamicRequireModuleSet.size > 0;
   const commonDir = isDynamicRequireModulesEnabled
-    ? getCommonDir(null, Array.from(dynamicRequireModuleSet).concat(process.cwd()))
+    ? getCommonDir__default['default'](null, Array.from(dynamicRequireModuleSet).concat(process.cwd()))
     : null;
 
   const esModulesWithDefaultExport = new Set();
@@ -1269,6 +1282,11 @@ function commonjs(options = {}) {
   const sourceMap = options.sourceMap !== false;
 
   function transformAndCheckExports(code, id) {
+    if (isDynamicRequireModulesEnabled && this.getModuleInfo(id).isEntry) {
+      code =
+        getDynamicPackagesEntryIntro(dynamicRequireModuleDirPaths, dynamicRequireModuleSet) + code;
+    }
+
     const { isEsModule, hasDefaultExport, hasNamedExports, ast } = checkEsModule(
       this.parse,
       code,
@@ -1285,11 +1303,13 @@ function commonjs(options = {}) {
       !dynamicRequireModuleSet.has(normalizePathSlashes(id)) &&
       (!hasCjsKeywords(code, ignoreGlobal) || (isEsModule && !options.transformMixedEsModules))
     ) {
-      setIsCjsPromise(id, false);
-      return null;
+      return { meta: { commonjs: { isCommonJS: false } } };
     }
 
-    const transformed = transformCommonjs(
+    // avoid wrapping in createCommonjsModule, as this is a commonjsRegister call
+    const disableWrap = isModuleRegistrationProxy(id, dynamicRequireModuleSet);
+
+    return transformCommonjs(
       this.parse,
       code,
       id,
@@ -1299,12 +1319,10 @@ function commonjs(options = {}) {
       sourceMap,
       isDynamicRequireModulesEnabled,
       dynamicRequireModuleSet,
+      disableWrap,
       commonDir,
       ast
     );
-
-    setIsCjsPromise(id, isEsModule ? false : Boolean(transformed));
-    return transformed;
   }
 
   return {
@@ -1338,8 +1356,8 @@ function commonjs(options = {}) {
         return getSpecificHelperProxy(id);
       }
 
-      if (id.endsWith(EXTERNAL_SUFFIX)) {
-        const actualId = getIdFromExternalProxyId(id);
+      if (isWrappedId(id, EXTERNAL_SUFFIX)) {
+        const actualId = unwrapId(id, EXTERNAL_SUFFIX);
         return getUnknownRequireProxy(
           actualId,
           isEsmExternal(actualId) ? getRequireReturnsDefault(actualId) : true
@@ -1354,13 +1372,12 @@ function commonjs(options = {}) {
         return getDynamicJsonProxy(id, commonDir);
       }
 
-      const normalizedPath = normalizePathSlashes(id);
-      if (dynamicRequireModuleSet.has(normalizedPath) && !normalizedPath.endsWith('.json')) {
-        return getDynamicRequireProxy(normalizedPath, commonDir);
+      if (isModuleRegistrationProxy(id, dynamicRequireModuleSet)) {
+        return getDynamicRequireProxy(normalizePathSlashes(id), commonDir);
       }
 
-      if (id.endsWith(PROXY_SUFFIX)) {
-        const actualId = getIdFromProxyId(id);
+      if (isWrappedId(id, PROXY_SUFFIX)) {
+        const actualId = unwrapId(id, PROXY_SUFFIX);
         return getStaticRequireProxy(
           actualId,
           getRequireReturnsDefault(actualId),
@@ -1369,14 +1386,6 @@ function commonjs(options = {}) {
         );
       }
 
-      if (isDynamicRequireModulesEnabled && this.getModuleInfo(id).isEntry) {
-        return getDynamicPackagesEntryIntro(
-          id,
-          dynamicRequireModuleDirPaths,
-          dynamicRequireModuleSet
-        );
-      }
-
       return null;
     },
 
@@ -1388,20 +1397,25 @@ function commonjs(options = {}) {
         !id.startsWith(DYNAMIC_JSON_PREFIX) &&
         (!filter(id) || !extensions.includes(extName))
       ) {
-        setIsCjsPromise(id, null);
         return null;
       }
 
-      let transformed;
       try {
-        transformed = transformAndCheckExports.call(this, code, id);
+        return transformAndCheckExports.call(this, code, id);
       } catch (err) {
-        transformed = null;
-        setIsCjsPromise(id, false);
-        this.error(err, err.loc);
+        return this.error(err, err.loc);
       }
+    },
 
-      return transformed;
+    moduleParsed({ id, meta: { commonjs } }) {
+      if (commonjs) {
+        const isCjs = commonjs.isCommonJS;
+        if (isCjs != null) {
+          setIsCjsPromise(id, isCjs);
+          return;
+        }
+      }
+      setIsCjsPromise(id, null);
     }
   };
 }