@rollup/plugin-commonjs 22.0.0-11 → 22.0.0-14

package/dist/es/index.js

@@ -7,9 +7,9 @@ import { walk } from 'estree-walker';
 import MagicString from 'magic-string';
 import isReference from 'is-reference';
 
-var version = "22.0.0-11";
+var version = "22.0.0-14";
 var peerDependencies = {
-	rollup: "^2.67.0"
+	rollup: "^2.68.0"
 };
 
 function tryParse(parse, code, id) {
@@ -453,8 +453,7 @@ function getEsImportProxy(id, defaultIsModuleExports) {
   }
   return {
     code,
-    syntheticNamedExports: '__moduleExports',
-    meta: { commonjs: { isCommonJS: false } }
+    syntheticNamedExports: '__moduleExports'
   };
 }
 
@@ -562,7 +561,7 @@ function getResolveId(extensions) {
       meta: { commonjs: commonjsMeta }
     } = moduleInfo;
     if (commonjsMeta && commonjsMeta.isCommonJS === IS_WRAPPED_COMMONJS) {
-      return wrapId(resolved.id, ES_IMPORT_SUFFIX);
+      return { id: wrapId(resolved.id, ES_IMPORT_SUFFIX), meta: { commonjs: { resolved } } };
     }
     return resolved;
   };
@@ -588,7 +587,7 @@ function getRequireResolver(extensions, detectCyclesAndConditional) {
     return false;
   };
 
-  // Once a module is listed here, its type (wrapped or not) is fixed any may
+  // Once a module is listed here, its type (wrapped or not) is fixed and may
   // not change for the rest of the current build, to not break already
   // transformed modules.
   const fullyAnalyzedModules = Object.create(null);
@@ -637,42 +636,77 @@ function getRequireResolver(extensions, detectCyclesAndConditional) {
     }
   };
 
+  const getTypeForImportedModule = async (resolved, loadModule) => {
+    if (resolved.id in knownCjsModuleTypes) {
+      // This handles cyclic ES dependencies
+      return knownCjsModuleTypes[resolved.id];
+    }
+    const {
+      meta: { commonjs }
+    } = await loadModule(resolved);
+    return (commonjs && commonjs.isCommonJS) || false;
+  };
+
   return {
     getWrappedIds: () =>
       Object.keys(knownCjsModuleTypes).filter(
         (id) => knownCjsModuleTypes[id] === IS_WRAPPED_COMMONJS
       ),
     isRequiredId: (id) => requiredIds[id],
-    async shouldTransformCachedModule({ id: parentId, meta: { commonjs: parentMeta } }) {
-      // Ignore modules that did not pass through the original transformer in a previous build
-      if (!(parentMeta && parentMeta.requires)) {
-        return false;
-      }
-      setInitialParentType(parentId, parentMeta.initialCommonJSType);
-      await Promise.all(
-        parentMeta.requires.map(({ resolved, isConditional }) =>
-          analyzeRequiredModule(parentId, resolved, isConditional, this.load)
-        )
-      );
-      if (getTypeForFullyAnalyzedModule(parentId) !== parentMeta.isCommonJS) {
-        return true;
-      }
-      for (const {
-        resolved: { id }
-      } of parentMeta.requires) {
-        if (getTypeForFullyAnalyzedModule(id) !== parentMeta.isRequiredCommonJS[id]) {
+    async shouldTransformCachedModule({
+      id: parentId,
+      resolvedSources,
+      meta: { commonjs: parentMeta }
+    }) {
+      // We explicitly track ES modules to handle circular imports
+      if (!(parentMeta && parentMeta.isCommonJS)) knownCjsModuleTypes[parentId] = false;
+      if (isWrappedId(parentId, ES_IMPORT_SUFFIX)) return false;
+      const parentRequires = parentMeta && parentMeta.requires;
+      if (parentRequires) {
+        setInitialParentType(parentId, parentMeta.initialCommonJSType);
+        await Promise.all(
+          parentRequires.map(({ resolved, isConditional }) =>
+            analyzeRequiredModule(parentId, resolved, isConditional, this.load)
+          )
+        );
+        if (getTypeForFullyAnalyzedModule(parentId) !== parentMeta.isCommonJS) {
           return true;
         }
+        for (const {
+          resolved: { id }
+        } of parentRequires) {
+          if (getTypeForFullyAnalyzedModule(id) !== parentMeta.isRequiredCommonJS[id]) {
+            return true;
+          }
+        }
+        // Now that we decided to go with the cached copy, neither the parent
+        // module nor any of its children may change types anymore
+        fullyAnalyzedModules[parentId] = true;
+        for (const {
+          resolved: { id }
+        } of parentRequires) {
+          fullyAnalyzedModules[id] = true;
+        }
       }
-      // Now that we decided to go with the cached copy, neither the parent
-      // module nor any of its children may change types anymore
-      fullyAnalyzedModules[parentId] = true;
-      for (const {
-        resolved: { id }
-      } of parentMeta.requires) {
-        fullyAnalyzedModules[id] = true;
-      }
-      return false;
+      const parentRequireSet = new Set((parentRequires || []).map(({ resolved: { id } }) => id));
+      return (
+        await Promise.all(
+          Object.keys(resolvedSources)
+            .map((source) => resolvedSources[source])
+            .filter(({ id, external }) => !(external || parentRequireSet.has(id)))
+            .map(async (resolved) => {
+              if (isWrappedId(resolved.id, ES_IMPORT_SUFFIX)) {
+                return (
+                  (await getTypeForImportedModule(
+                    (await this.load({ id: resolved.id })).meta.commonjs.resolved,
+                    this.load
+                  )) !== IS_WRAPPED_COMMONJS
+                );
+              }
+              return (await getTypeForImportedModule(resolved, this.load)) === IS_WRAPPED_COMMONJS;
+            })
+        )
+      ).some((shouldTransform) => shouldTransform);
     },
     /* eslint-disable no-param-reassign */
     resolveRequireSourcesAndUpdateMeta: (rollupContext) => async (
@@ -1168,7 +1202,7 @@ function getRequireStringArg(node) {
 function getRequireHandlers() {
   const requireExpressions = [];
 
-  function addRequireStatement(
+  function addRequireExpression(
     sourceId,
     node,
     scope,
@@ -1248,7 +1282,7 @@ function getRequireHandlers() {
   }
 
   return {
-    addRequireStatement,
+    addRequireExpression,
     rewriteRequireExpressionsAndGetImportBlock
   };
 }
@@ -1374,7 +1408,7 @@ async function transformCommonjs(
   // unconditional require elsewhere.
   let currentConditionalNodeEnd = null;
   const conditionalNodes = new Set();
-  const { addRequireStatement, rewriteRequireExpressionsAndGetImportBlock } = getRequireHandlers();
+  const { addRequireExpression, rewriteRequireExpressionsAndGetImportBlock } = getRequireHandlers();
 
   // See which names are assigned to. This is necessary to prevent
   // illegally replacing `var foo = require('foo')` with `import foo from 'foo'`,
@@ -1529,14 +1563,22 @@ async function transformCommonjs(
           const requireStringArg = getRequireStringArg(node);
           if (!ignoreRequire(requireStringArg)) {
             const usesReturnValue = parent.type !== 'ExpressionStatement';
-            addRequireStatement(
+            const toBeRemoved =
+              parent.type === 'ExpressionStatement' &&
+              (!currentConditionalNodeEnd ||
+                // We should completely remove requires directly in a try-catch
+                // so that Rollup can remove up the try-catch
+                (currentTryBlockEnd !== null && currentTryBlockEnd < currentConditionalNodeEnd))
+                ? parent
+                : node;
+            addRequireExpression(
               requireStringArg,
               node,
               scope,
               usesReturnValue,
               currentTryBlockEnd !== null,
               currentConditionalNodeEnd !== null,
-              parent.type === 'ExpressionStatement' ? parent : node
+              toBeRemoved
             );
             if (parent.type === 'VariableDeclarator' && parent.id.type === 'Identifier') {
               for (const name of extractAssignedNames(parent.id)) {
@@ -1738,6 +1780,7 @@ async function transformCommonjs(
     !(
       shouldWrap ||
       isRequired ||
+      needsRequireWrapper ||
       uses.module ||
       uses.exports ||
       uses.require ||
@@ -1755,7 +1798,9 @@ async function transformCommonjs(
     magicString.remove(0, commentEnd).trim();
   }
 
-  const exportMode = shouldWrap
+  const exportMode = isEsModule
+    ? 'none'
+    : shouldWrap
     ? uses.module
       ? 'module'
       : 'exports'