@rollup/plugin-commonjs 22.0.0-4 → 22.0.0-8

package/dist/{index.es.js → 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-4";
+var version = "22.0.0-8";
 var peerDependencies = {
-	rollup: "^2.61.1"
+	rollup: "^2.66.1"
 };
 
 function tryParse(parse, code, id) {
@@ -328,7 +328,8 @@ const WRAPPED_SUFFIX = '?commonjs-wrapped';
 const EXTERNAL_SUFFIX = '?commonjs-external';
 const EXPORTS_SUFFIX = '?commonjs-exports';
 const MODULE_SUFFIX = '?commonjs-module';
-const ES_IMPORT_SUFFIX = '?es-import';
+const ENTRY_SUFFIX = '?commonjs-entry';
+const ES_IMPORT_SUFFIX = '?commonjs-es-import';
 
 const DYNAMIC_MODULES_ID = '\0commonjs-dynamic-modules';
 const HELPERS_ID = '\0commonjsHelpers.js';
@@ -396,21 +397,15 @@ function getUnknownRequireProxy(id, requireReturnsDefault) {
   return `import * as ${name} from ${JSON.stringify(id)}; ${exported}`;
 }
 
-async function getStaticRequireProxy(
-  id,
-  requireReturnsDefault,
-  esModulesWithDefaultExport,
-  esModulesWithNamedExports,
-  loadModule
-) {
+async function getStaticRequireProxy(id, requireReturnsDefault, loadModule) {
   const name = getName(id);
   const {
     meta: { commonjs: commonjsMeta }
   } = await loadModule({ id });
-  if (commonjsMeta && commonjsMeta.isCommonJS) {
-    return `export { __moduleExports as default } from ${JSON.stringify(id)};`;
-  } else if (!commonjsMeta) {
+  if (!commonjsMeta) {
     return getUnknownRequireProxy(id, requireReturnsDefault);
+  } else if (commonjsMeta.isCommonJS) {
+    return `export { __moduleExports as default } from ${JSON.stringify(id)};`;
   } else if (!requireReturnsDefault) {
     return `import { getAugmentedNamespace } from "${HELPERS_ID}"; import * as ${name} from ${JSON.stringify(
       id
@@ -418,14 +413,30 @@ async function getStaticRequireProxy(
   } else if (
     requireReturnsDefault !== true &&
     (requireReturnsDefault === 'namespace' ||
-      !esModulesWithDefaultExport.has(id) ||
-      (requireReturnsDefault === 'auto' && esModulesWithNamedExports.has(id)))
+      !commonjsMeta.hasDefaultExport ||
+      (requireReturnsDefault === 'auto' && commonjsMeta.hasNamedExports))
   ) {
     return `import * as ${name} from ${JSON.stringify(id)}; export default ${name};`;
   }
   return `export { default } from ${JSON.stringify(id)};`;
 }
 
+async function getEntryProxy(id, defaultIsModuleExports, loadModule) {
+  const {
+    meta: { commonjs: commonjsMeta },
+    hasDefaultExport
+  } = await loadModule({ id, moduleSideEffects: true });
+  if (!commonjsMeta || commonjsMeta.isCommonJS !== IS_WRAPPED_COMMONJS) {
+    const stringifiedId = JSON.stringify(id);
+    let code = `export * from ${stringifiedId};`;
+    if (hasDefaultExport) {
+      code += `export { default } from ${stringifiedId};`;
+    }
+    return code;
+  }
+  return getEsImportProxy(id, defaultIsModuleExports);
+}
+
 function getEsImportProxy(id, defaultIsModuleExports) {
   const name = getName(id);
   const exportsName = `${name}Exports`;
@@ -494,6 +505,7 @@ function getResolveId(extensions) {
     }
 
     if (
+      importee.endsWith(ENTRY_SUFFIX) ||
       isWrappedId(importee, MODULE_SUFFIX) ||
       isWrappedId(importee, EXPORTS_SUFFIX) ||
       isWrappedId(importee, PROXY_SUFFIX) ||
@@ -510,7 +522,8 @@ function getResolveId(extensions) {
         importer === DYNAMIC_MODULES_ID ||
         // Proxies are only importing resolved ids, no need to resolve again
         isWrappedId(importer, PROXY_SUFFIX) ||
-        isWrappedId(importer, ES_IMPORT_SUFFIX)
+        isWrappedId(importer, ES_IMPORT_SUFFIX) ||
+        importer.endsWith(ENTRY_SUFFIX)
       ) {
         return importee;
       }
@@ -540,9 +553,19 @@ function getResolveId(extensions) {
     const resolved =
       (await this.resolve(importee, importer, Object.assign({ skipSelf: true }, resolveOptions))) ||
       resolveExtensions(importee, importer, extensions);
-    if (!resolved || resolved.external) {
+    // Make sure that even if other plugins resolve again, we ignore our own proxies
+    if (
+      !resolved ||
+      resolved.external ||
+      resolved.id.endsWith(ENTRY_SUFFIX) ||
+      isWrappedId(resolved.id, ES_IMPORT_SUFFIX)
+    ) {
       return resolved;
     }
+    if (resolveOptions.isEntry) {
+      // We must not precede entry proxies with a `\0` as that will mess up relative external resolution
+      return resolved.id + ENTRY_SUFFIX;
+    }
     const {
       meta: { commonjs: commonjsMeta }
     } = await this.load(resolved);
@@ -553,7 +576,7 @@ function getResolveId(extensions) {
   };
 }
 
-function getResolveRequireSourcesAndGetMeta(extensions, detectCyclesAndConditional) {
+function getRequireResolver(extensions, detectCyclesAndConditional) {
   const knownCjsModuleTypes = Object.create(null);
   const requiredIds = Object.create(null);
   const unconditionallyRequiredIds = Object.create(null);
@@ -577,11 +600,7 @@ function getResolveRequireSourcesAndGetMeta(extensions, detectCyclesAndCondition
 
   const getTypeForFullyAnalyzedModule = (id) => {
     const knownType = knownCjsModuleTypes[id];
-    if (
-      knownType === IS_WRAPPED_COMMONJS ||
-      !detectCyclesAndConditional ||
-      fullyAnalyzedModules[id]
-    ) {
+    if (knownType !== true || !detectCyclesAndConditional || fullyAnalyzedModules[id]) {
       return knownType;
     }
     fullyAnalyzedModules[id] = true;
@@ -591,26 +610,80 @@ function getResolveRequireSourcesAndGetMeta(extensions, detectCyclesAndCondition
     return knownType;
   };
 
+  const setInitialParentType = (id, initialCommonJSType) => {
+    // It is possible a transformed module is already fully analyzed when using
+    // the cache and one dependency introduces a new cycle. Then transform is
+    // run for a fully analzyed module again. Fully analyzed modules may never
+    // change their type as importers already trust their type.
+    knownCjsModuleTypes[id] = fullyAnalyzedModules[id]
+      ? knownCjsModuleTypes[id]
+      : initialCommonJSType;
+    if (
+      detectCyclesAndConditional &&
+      knownCjsModuleTypes[id] === true &&
+      requiredIds[id] &&
+      !unconditionallyRequiredIds[id]
+    ) {
+      knownCjsModuleTypes[id] = IS_WRAPPED_COMMONJS;
+    }
+  };
+
+  const setTypesForRequiredModules = async (parentId, resolved, isConditional, loadModule) => {
+    const childId = resolved.id;
+    requiredIds[childId] = true;
+    if (!(isConditional || knownCjsModuleTypes[parentId] === IS_WRAPPED_COMMONJS)) {
+      unconditionallyRequiredIds[childId] = true;
+    }
+
+    getDependencies(parentId).add(childId);
+    if (!isCyclic(childId)) {
+      // This makes sure the current transform handler waits for all direct dependencies to be
+      // loaded and transformed and therefore for all transitive CommonJS dependencies to be
+      // loaded as well so that all cycles have been found and knownCjsModuleTypes is reliable.
+      await loadModule(resolved);
+    }
+  };
+
   return {
     getWrappedIds: () =>
       Object.keys(knownCjsModuleTypes).filter(
         (id) => knownCjsModuleTypes[id] === IS_WRAPPED_COMMONJS
       ),
     isRequiredId: (id) => requiredIds[id],
-    resolveRequireSourcesAndGetMeta: (rollupContext) => async (
+    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 }) =>
+          setTypesForRequiredModules(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]) {
+          return true;
+        }
+      }
+      return false;
+    },
+    /* eslint-disable no-param-reassign */
+    resolveRequireSourcesAndUpdateMeta: (rollupContext) => async (
       parentId,
       isParentCommonJS,
+      parentMeta,
       sources
     ) => {
-      knownCjsModuleTypes[parentId] = isParentCommonJS;
-      if (
-        detectCyclesAndConditional &&
-        knownCjsModuleTypes[parentId] &&
-        requiredIds[parentId] &&
-        !unconditionallyRequiredIds[parentId]
-      ) {
-        knownCjsModuleTypes[parentId] = IS_WRAPPED_COMMONJS;
-      }
+      parentMeta.initialCommonJSType = isParentCommonJS;
+      parentMeta.requires = [];
+      parentMeta.isRequiredCommonJS = Object.create(null);
+      setInitialParentType(parentId, isParentCommonJS);
       const requireTargets = await Promise.all(
         sources.map(async ({ source, isConditional }) => {
           // Never analyze or proxy internal modules
@@ -628,38 +701,27 @@ function getResolveRequireSourcesAndGetMeta(extensions, detectCyclesAndCondition
           if (resolved.external) {
             return { id: wrapId(childId, EXTERNAL_SUFFIX), allowProxy: false };
           }
-          requiredIds[childId] = true;
-          if (!(isConditional || knownCjsModuleTypes[parentId] === IS_WRAPPED_COMMONJS)) {
-            unconditionallyRequiredIds[childId] = true;
-          }
-
-          getDependencies(parentId).add(childId);
-          if (!isCyclic(childId)) {
-            // This makes sure the current transform handler waits for all direct dependencies to be
-            // loaded and transformed and therefore for all transitive CommonJS dependencies to be
-            // loaded as well so that all cycles have been found and knownCjsModuleTypes is reliable.
-            await rollupContext.load(resolved);
-          } else if (detectCyclesAndConditional && knownCjsModuleTypes[parentId]) {
-            knownCjsModuleTypes[parentId] = IS_WRAPPED_COMMONJS;
-          }
+          parentMeta.requires.push({ resolved, isConditional });
+          await setTypesForRequiredModules(parentId, resolved, isConditional, rollupContext.load);
           return { id: childId, allowProxy: true };
         })
       );
-      return {
-        requireTargets: requireTargets.map(({ id: dependencyId, allowProxy }, index) => {
-          const isCommonJS = getTypeForFullyAnalyzedModule(dependencyId);
-          return {
-            source: sources[index].source,
-            id: allowProxy
-              ? isCommonJS === IS_WRAPPED_COMMONJS
-                ? wrapId(dependencyId, WRAPPED_SUFFIX)
-                : wrapId(dependencyId, PROXY_SUFFIX)
-              : dependencyId,
-            isCommonJS
-          };
-        }),
-        usesRequireWrapper: getTypeForFullyAnalyzedModule(parentId) === IS_WRAPPED_COMMONJS
-      };
+      parentMeta.isCommonJS = getTypeForFullyAnalyzedModule(parentId);
+      return requireTargets.map(({ id: dependencyId, allowProxy }, index) => {
+        // eslint-disable-next-line no-multi-assign
+        const isCommonJS = (parentMeta.isRequiredCommonJS[
+          dependencyId
+        ] = getTypeForFullyAnalyzedModule(dependencyId));
+        return {
+          source: sources[index].source,
+          id: allowProxy
+            ? isCommonJS === IS_WRAPPED_COMMONJS
+              ? wrapId(dependencyId, WRAPPED_SUFFIX)
+              : wrapId(dependencyId, PROXY_SUFFIX)
+            : dependencyId,
+          isCommonJS
+        };
+      });
     }
   };
 }
@@ -1133,11 +1195,12 @@ function getRequireHandlers() {
     exportsName,
     id,
     exportMode,
-    resolveRequireSourcesAndGetMeta,
+    resolveRequireSourcesAndUpdateMeta,
     needsRequireWrapper,
     isEsModule,
     isDynamicRequireModulesEnabled,
-    getIgnoreTryCatchRequireStatementMode
+    getIgnoreTryCatchRequireStatementMode,
+    commonjsMeta
   ) {
     const imports = [];
     imports.push(`import * as ${helpersName} from "${HELPERS_ID}";`);
@@ -1160,9 +1223,10 @@ function getRequireHandlers() {
       );
     }
     const requiresBySource = collectSources(requireExpressions);
-    const { requireTargets, usesRequireWrapper } = await resolveRequireSourcesAndGetMeta(
+    const requireTargets = await resolveRequireSourcesAndUpdateMeta(
       id,
       needsRequireWrapper ? IS_WRAPPED_COMMONJS : !isEsModule,
+      commonjsMeta,
       Object.keys(requiresBySource).map((source) => {
         return {
           source,
@@ -1177,10 +1241,7 @@ function getRequireHandlers() {
       getIgnoreTryCatchRequireStatementMode,
       magicString
     );
-    return {
-      importBlock: imports.length ? `${imports.join('\n')}\n\n` : '',
-      usesRequireWrapper
-    };
+    return imports.length ? `${imports.join('\n')}\n\n` : '';
   }
 
   return {
@@ -1283,9 +1344,10 @@ async function transformCommonjs(
   astCache,
   defaultIsModuleExports,
   needsRequireWrapper,
-  resolveRequireSourcesAndGetMeta,
+  resolveRequireSourcesAndUpdateMeta,
   isRequired,
-  checkDynamicRequire
+  checkDynamicRequire,
+  commonjsMeta
 ) {
   const ast = astCache || tryParse(parse, code, id);
   const magicString = new MagicString(code);
@@ -1669,7 +1731,7 @@ async function transformCommonjs(
     ) &&
     (ignoreGlobal || !uses.global)
   ) {
-    return { meta: { commonjs: { isCommonJS: false, isMixedModule: false } } };
+    return { meta: { commonjs: { isCommonJS: false } } };
   }
 
   let leadingComment = '';
@@ -1691,7 +1753,7 @@ async function transformCommonjs(
     ? 'exports'
     : 'module';
 
-  const { importBlock, usesRequireWrapper } = await rewriteRequireExpressionsAndGetImportBlock(
+  const importBlock = await rewriteRequireExpressionsAndGetImportBlock(
     magicString,
     topLevelDeclarations,
     reassignedNames,
@@ -1701,12 +1763,14 @@ async function transformCommonjs(
     exportsName,
     id,
     exportMode,
-    resolveRequireSourcesAndGetMeta,
+    resolveRequireSourcesAndUpdateMeta,
     needsRequireWrapper,
     isEsModule,
     isDynamicRequireModulesEnabled,
-    getIgnoreTryCatchRequireStatementMode
+    getIgnoreTryCatchRequireStatementMode,
+    commonjsMeta
   );
+  const usesRequireWrapper = commonjsMeta.isCommonJS === IS_WRAPPED_COMMONJS;
   const exportBlock = isEsModule
     ? ''
     : rewriteExportsAndGetExportsBlock(
@@ -1759,15 +1823,12 @@ function ${requireName} () {
     code: magicString.toString(),
     map: sourceMap ? magicString.generateMap() : null,
     syntheticNamedExports: isEsModule || usesRequireWrapper ? false : '__moduleExports',
-    meta: {
-      commonjs: {
-        isCommonJS: !isEsModule && (usesRequireWrapper ? IS_WRAPPED_COMMONJS : true),
-        isMixedModule: isEsModule
-      }
-    }
+    meta: { commonjs: commonjsMeta }
   };
 }
 
+const PLUGIN_NAME = 'commonjs';
+
 function commonjs(options = {}) {
   const {
     ignoreGlobal,
@@ -1795,11 +1856,6 @@ function commonjs(options = {}) {
   const defaultIsModuleExports =
     typeof options.defaultIsModuleExports === 'boolean' ? options.defaultIsModuleExports : 'auto';
 
-  const {
-    resolveRequireSourcesAndGetMeta,
-    getWrappedIds,
-    isRequiredId
-  } = getResolveRequireSourcesAndGetMeta(extensions, detectCyclesAndConditional);
   const dynamicRequireRoot =
     typeof options.dynamicRequireRoot === 'string'
       ? resolve(options.dynamicRequireRoot)
@@ -1810,9 +1866,6 @@ function commonjs(options = {}) {
   );
   const isDynamicRequireModulesEnabled = dynamicRequireModules.size > 0;
 
-  const esModulesWithDefaultExport = new Set();
-  const esModulesWithNamedExports = new Set();
-
   const ignoreRequire =
     typeof options.ignore === 'function'
       ? options.ignore
@@ -1840,25 +1893,31 @@ function commonjs(options = {}) {
 
   const sourceMap = options.sourceMap !== false;
 
+  // Initialized in buildStart
+  let requireResolver;
+
   function transformAndCheckExports(code, id) {
     const { isEsModule, hasDefaultExport, hasNamedExports, ast } = analyzeTopLevelStatements(
       this.parse,
       code,
       id
     );
+
+    const commonjsMeta = this.getModuleInfo(id).meta.commonjs || {};
     if (hasDefaultExport) {
-      esModulesWithDefaultExport.add(id);
+      commonjsMeta.hasDefaultExport = true;
     }
     if (hasNamedExports) {
-      esModulesWithNamedExports.add(id);
+      commonjsMeta.hasNamedExports = true;
     }
 
     if (
       !dynamicRequireModules.has(normalizePathSlashes(id)) &&
-      (!(hasCjsKeywords(code, ignoreGlobal) || isRequiredId(id)) ||
+      (!(hasCjsKeywords(code, ignoreGlobal) || requireResolver.isRequiredId(id)) ||
         (isEsModule && !options.transformMixedEsModules))
     ) {
-      return { meta: { commonjs: { isCommonJS: false } } };
+      commonjsMeta.isCommonJS = false;
+      return { meta: { commonjs: commonjsMeta } };
     }
 
     const needsRequireWrapper =
@@ -1897,14 +1956,15 @@ function commonjs(options = {}) {
       ast,
       defaultIsModuleExports,
       needsRequireWrapper,
-      resolveRequireSourcesAndGetMeta(this),
-      isRequiredId(id),
-      checkDynamicRequire
+      requireResolver.resolveRequireSourcesAndUpdateMeta(this),
+      requireResolver.isRequiredId(id),
+      checkDynamicRequire,
+      commonjsMeta
     );
   }
 
   return {
-    name: 'commonjs',
+    name: PLUGIN_NAME,
 
     version,
 
@@ -1912,7 +1972,7 @@ function commonjs(options = {}) {
       // We inject the resolver in the beginning so that "catch-all-resolver" like node-resolver
       // do not prevent our plugin from resolving entry points ot proxies.
       const plugins = Array.isArray(rawOptions.plugins)
-        ? rawOptions.plugins
+        ? [...rawOptions.plugins]
         : rawOptions.plugins
         ? [rawOptions.plugins]
         : [];
@@ -1934,11 +1994,12 @@ function commonjs(options = {}) {
           'The namedExports option from "@rollup/plugin-commonjs" is deprecated. Named exports are now handled automatically.'
         );
       }
+      requireResolver = getRequireResolver(extensions, detectCyclesAndConditional);
     },
 
     buildEnd() {
       if (options.strictRequires === 'debug') {
-        const wrappedIds = getWrappedIds();
+        const wrappedIds = requireResolver.getWrappedIds();
         if (wrappedIds.length) {
           this.warn({
             code: 'WRAPPED_IDS',
@@ -1987,6 +2048,11 @@ function commonjs(options = {}) {
         );
       }
 
+      // entry suffix is just appended to not mess up relative external resolution
+      if (id.endsWith(ENTRY_SUFFIX)) {
+        return getEntryProxy(id.slice(0, -ENTRY_SUFFIX.length), defaultIsModuleExports, this.load);
+      }
+
       if (isWrappedId(id, ES_IMPORT_SUFFIX)) {
         return getEsImportProxy(unwrapId(id, ES_IMPORT_SUFFIX), defaultIsModuleExports);
       }
@@ -2002,18 +2068,16 @@ function commonjs(options = {}) {
 
       if (isWrappedId(id, PROXY_SUFFIX)) {
         const actualId = unwrapId(id, PROXY_SUFFIX);
-        return getStaticRequireProxy(
-          actualId,
-          getRequireReturnsDefault(actualId),
-          esModulesWithDefaultExport,
-          esModulesWithNamedExports,
-          this.load
-        );
+        return getStaticRequireProxy(actualId, getRequireReturnsDefault(actualId), this.load);
       }
 
       return null;
     },
 
+    shouldTransformCachedModule(...args) {
+      return requireResolver.shouldTransformCachedModule.call(this, ...args);
+    },
+
     transform(code, id) {
       const extName = extname(id);
       if (extName !== '.cjs' && (!filter(id) || !extensions.includes(extName))) {
@@ -2030,4 +2094,4 @@ function commonjs(options = {}) {
 }
 
 export { commonjs as default };
-//# sourceMappingURL=index.es.js.map
+//# sourceMappingURL=index.js.map