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

package/dist/cjs/index.js

@@ -16,9 +16,9 @@ var glob__default = /*#__PURE__*/_interopDefaultLegacy(glob);
 var MagicString__default = /*#__PURE__*/_interopDefaultLegacy(MagicString);
 var isReference__default = /*#__PURE__*/_interopDefaultLegacy(isReference);
 
-var version = "22.0.0-11";
+var version = "22.0.0-12";
 var peerDependencies = {
-	rollup: "^2.67.0"
+	rollup: "^2.68.0"
 };
 
 function tryParse(parse, code, id) {
@@ -462,8 +462,7 @@ function getEsImportProxy(id, defaultIsModuleExports) {
   }
   return {
     code,
-    syntheticNamedExports: '__moduleExports',
-    meta: { commonjs: { isCommonJS: false } }
+    syntheticNamedExports: '__moduleExports'
   };
 }
 
@@ -571,7 +570,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;
   };
@@ -597,7 +596,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);
@@ -646,42 +645,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 ciruclar 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 }) => !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 (
@@ -1764,7 +1798,9 @@ async function transformCommonjs(
     magicString.remove(0, commentEnd).trim();
   }
 
-  const exportMode = shouldWrap
+  const exportMode = isEsModule
+    ? 'none'
+    : shouldWrap
     ? uses.module
       ? 'module'
       : 'exports'