@rollup/plugin-commonjs 17.0.0 → 17.1.0

package/dist/index.js

@@ -93,7 +93,7 @@ const PROXY_SUFFIX = '?commonjs-proxy';
 const REQUIRE_SUFFIX = '?commonjs-require';
 const EXTERNAL_SUFFIX = '?commonjs-external';
 
-const DYNAMIC_REGISTER_PREFIX = '\0commonjs-dynamic-register:';
+const DYNAMIC_REGISTER_SUFFIX = '?commonjs-dynamic-register';
 const DYNAMIC_JSON_PREFIX = '\0commonjs-dynamic-json:';
 const DYNAMIC_PACKAGES_ID = '\0commonjs-dynamic-packages';
 
@@ -243,10 +243,13 @@ function dirname (path) {
   return '.';
 }
 
-export function commonjsRequire (path, originalModuleDir) {
+export function commonjsResolveImpl (path, originalModuleDir, testCache) {
 	const shouldTryNodeModules = isPossibleNodeModulesPath(path);
 	path = normalize(path);
 	let relPath;
+	if (path[0] === '/') {
+		originalModuleDir = '/';
+	}
 	while (true) {
 		if (!shouldTryNodeModules) {
 			relPath = originalModuleDir ? normalize(originalModuleDir + '/' + path) : path;
@@ -255,33 +258,18 @@ export function commonjsRequire (path, originalModuleDir) {
 		} else {
 			relPath = normalize(join('node_modules', path));
 		}
+
+		if (relPath.endsWith('/..')) {
+			break; // Travelled too far up, avoid infinite loop
+		}
+
 		for (let extensionIndex = 0; extensionIndex < CHECKED_EXTENSIONS.length; extensionIndex++) {
 			const resolvedPath = relPath + CHECKED_EXTENSIONS[extensionIndex];
-			let cachedModule = DYNAMIC_REQUIRE_CACHE[resolvedPath];
-			if (cachedModule) return cachedModule.exports;
-			const loader = DYNAMIC_REQUIRE_LOADERS[resolvedPath];
-			if (loader) {
-				DYNAMIC_REQUIRE_CACHE[resolvedPath] = cachedModule = {
-					id: resolvedPath,
-					filename: resolvedPath,
-					path: dirname(resolvedPath),
-					exports: {},
-					parent: DEFAULT_PARENT_MODULE,
-					loaded: false,
-					children: [],
-					paths: [],
-					require: function (path, base) {
-					  return commonjsRequire(path, (base === undefined || base === null) ? cachedModule.path : base);
-					}
-				};
-				try {
-					loader.call(commonjsGlobal, cachedModule, cachedModule.exports);
-				} catch (error) {
-					delete DYNAMIC_REQUIRE_CACHE[resolvedPath];
-					throw error;
-				}
-				cachedModule.loaded = true;
-				return cachedModule.exports;
+			if (DYNAMIC_REQUIRE_CACHE[resolvedPath]) {
+				return resolvedPath;
+			};
+			if (DYNAMIC_REQUIRE_LOADERS[resolvedPath]) {
+				return resolvedPath;
 			};
 		}
 		if (!shouldTryNodeModules) break;
@@ -289,10 +277,52 @@ export function commonjsRequire (path, originalModuleDir) {
 		if (nextDir === originalModuleDir) break;
 		originalModuleDir = nextDir;
 	}
+	return null;
+}
+
+export function commonjsResolve (path, originalModuleDir) {
+	const resolvedPath = commonjsResolveImpl(path, originalModuleDir);
+	if (resolvedPath !== null) {
+		return resolvedPath;
+	}
+	return require.resolve(path);
+}
+
+export function commonjsRequire (path, originalModuleDir) {
+	const resolvedPath = commonjsResolveImpl(path, originalModuleDir, true);
+	if (resolvedPath !== null) {
+    let cachedModule = DYNAMIC_REQUIRE_CACHE[resolvedPath];
+    if (cachedModule) return cachedModule.exports;
+    const loader = DYNAMIC_REQUIRE_LOADERS[resolvedPath];
+    if (loader) {
+      DYNAMIC_REQUIRE_CACHE[resolvedPath] = cachedModule = {
+        id: resolvedPath,
+        filename: resolvedPath,
+        path: dirname(resolvedPath),
+        exports: {},
+        parent: DEFAULT_PARENT_MODULE,
+        loaded: false,
+        children: [],
+        paths: [],
+        require: function (path, base) {
+          return commonjsRequire(path, (base === undefined || base === null) ? cachedModule.path : base);
+        }
+      };
+      try {
+        loader.call(commonjsGlobal, cachedModule, cachedModule.exports);
+      } catch (error) {
+        delete DYNAMIC_REQUIRE_CACHE[resolvedPath];
+        throw error;
+      }
+      cachedModule.loaded = true;
+      return cachedModule.exports;
+    };
+	}
 	return require(path);
 }
 
 commonjsRequire.cache = DYNAMIC_REQUIRE_CACHE;
+commonjsRequire.resolve = commonjsResolve;
 `;
 
 function getHelpersModule(isDynamicRequireModulesEnabled) {
@@ -336,20 +366,26 @@ const getVirtualPathForDynamicRequirePath = (path, commonDir) => {
     : normalizedPath;
 };
 
+function getPackageEntryPoint(dirPath) {
+  let entryPoint = 'index.js';
+
+  try {
+    if (fs.existsSync(path.join(dirPath, 'package.json'))) {
+      entryPoint =
+        JSON.parse(fs.readFileSync(path.join(dirPath, 'package.json'), { encoding: 'utf8' })).main ||
+        entryPoint;
+    }
+  } catch (ignored) {
+    // ignored
+  }
+
+  return entryPoint;
+}
+
 function getDynamicPackagesModule(dynamicRequireModuleDirPaths, commonDir) {
   let code = `const commonjsRegister = require('${HELPERS_ID}?commonjsRegister');`;
   for (const dir of dynamicRequireModuleDirPaths) {
-    let entryPoint = 'index.js';
-
-    try {
-      if (fs.existsSync(path.join(dir, 'package.json'))) {
-        entryPoint =
-          JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), { encoding: 'utf8' })).main ||
-          entryPoint;
-      }
-    } catch (ignored) {
-      // ignored
-    }
+    const entryPoint = getPackageEntryPoint(dir);
 
     code += `\ncommonjsRegister(${JSON.stringify(
       getVirtualPathForDynamicRequirePath(dir, commonDir)
@@ -366,21 +402,42 @@ function getDynamicPackagesEntryIntro(
 ) {
   let dynamicImports = Array.from(
     dynamicRequireModuleSet,
-    (dynamicId) => `require(${JSON.stringify(DYNAMIC_REGISTER_PREFIX + dynamicId)});`
+    (dynamicId) => `require(${JSON.stringify(wrapModuleRegisterProxy(dynamicId))});`
   ).join('\n');
 
   if (dynamicRequireModuleDirPaths.length) {
-    dynamicImports += `require(${JSON.stringify(DYNAMIC_REGISTER_PREFIX + DYNAMIC_PACKAGES_ID)});`;
+    dynamicImports += `require(${JSON.stringify(wrapModuleRegisterProxy(DYNAMIC_PACKAGES_ID))});`;
   }
 
   return dynamicImports;
 }
 
-function isModuleRegistrationProxy(id, dynamicRequireModuleSet) {
+function wrapModuleRegisterProxy(id) {
+  return wrapId(id, DYNAMIC_REGISTER_SUFFIX);
+}
+
+function unwrapModuleRegisterProxy(id) {
+  return unwrapId(id, DYNAMIC_REGISTER_SUFFIX);
+}
+
+function isModuleRegisterProxy(id) {
+  return isWrappedId(id, DYNAMIC_REGISTER_SUFFIX);
+}
+
+function isDynamicModuleImport(id, dynamicRequireModuleSet) {
   const normalizedPath = normalizePathSlashes(id);
   return dynamicRequireModuleSet.has(normalizedPath) && !normalizedPath.endsWith('.json');
 }
 
+function isDirectory(path) {
+  try {
+    if (fs.statSync(path).isDirectory()) return true;
+  } catch (ignored) {
+    // Nothing to do here
+  }
+  return false;
+}
+
 function getDynamicRequirePaths(patterns) {
   const dynamicRequireModuleSet = new Set();
   for (const pattern of !patterns || Array.isArray(patterns) ? patterns || [] : [patterns]) {
@@ -388,17 +445,13 @@ function getDynamicRequirePaths(patterns) {
     const modifySet = Set.prototype[isNegated ? 'delete' : 'add'].bind(dynamicRequireModuleSet);
     for (const path$1 of glob__default['default'].sync(isNegated ? pattern.substr(1) : pattern)) {
       modifySet(normalizePathSlashes(path.resolve(path$1)));
-    }
-  }
-  const dynamicRequireModuleDirPaths = Array.from(dynamicRequireModuleSet.values()).filter(
-    (path) => {
-      try {
-        if (fs.statSync(path).isDirectory()) return true;
-      } catch (ignored) {
-        // Nothing to do here
+      if (isDirectory(path$1)) {
+        modifySet(normalizePathSlashes(path.resolve(path.join(path$1, getPackageEntryPoint(path$1)))));
       }
-      return false;
     }
+  }
+  const dynamicRequireModuleDirPaths = Array.from(dynamicRequireModuleSet.values()).filter((path) =>
+    isDirectory(path)
   );
   return { dynamicRequireModuleSet, dynamicRequireModuleDirPaths };
 }
@@ -531,7 +584,12 @@ function getResolveId(extensions) {
     return undefined;
   }
 
-  return function resolveId(importee, importer) {
+  return function resolveId(importee, rawImporter) {
+    const importer =
+      rawImporter && isModuleRegisterProxy(rawImporter)
+        ? unwrapModuleRegisterProxy(rawImporter)
+        : rawImporter;
+
     // Proxies are only importing resolved ids, no need to resolve again
     if (importer && isWrappedId(importer, PROXY_SUFFIX)) {
       return importee;
@@ -539,19 +597,28 @@ function getResolveId(extensions) {
 
     const isProxyModule = isWrappedId(importee, PROXY_SUFFIX);
     const isRequiredModule = isWrappedId(importee, REQUIRE_SUFFIX);
+    let isModuleRegistration = false;
+
     if (isProxyModule) {
       importee = unwrapId(importee, PROXY_SUFFIX);
     } else if (isRequiredModule) {
       importee = unwrapId(importee, REQUIRE_SUFFIX);
+
+      isModuleRegistration = isModuleRegisterProxy(importee);
+      if (isModuleRegistration) {
+        importee = unwrapModuleRegisterProxy(importee);
+      }
+    }
+
+    if (
+      importee.startsWith(HELPERS_ID) ||
+      importee === DYNAMIC_PACKAGES_ID ||
+      importee.startsWith(DYNAMIC_JSON_PREFIX)
+    ) {
+      return importee;
     }
+
     if (importee.startsWith('\0')) {
-      if (
-        importee.startsWith(HELPERS_ID) ||
-        importee === DYNAMIC_PACKAGES_ID ||
-        importee.startsWith(DYNAMIC_JSON_PREFIX)
-      ) {
-        return importee;
-      }
       return null;
     }
 
@@ -565,6 +632,8 @@ function getResolveId(extensions) {
       if (resolved && isProxyModule) {
         resolved.id = wrapId(resolved.id, resolved.external ? EXTERNAL_SUFFIX : PROXY_SUFFIX);
         resolved.external = false;
+      } else if (resolved && isModuleRegistration) {
+        resolved.id = wrapModuleRegisterProxy(resolved.id);
       } else if (!resolved && (isProxyModule || isRequiredModule)) {
         return { id: wrapId(importee, EXTERNAL_SUFFIX), external: false };
       }
@@ -710,6 +779,10 @@ function isLocallyShadowed(name, scope) {
   return false;
 }
 
+function isShorthandProperty(parent) {
+  return parent && parent.type === 'Property' && parent.shorthand;
+}
+
 function wrapCode(magicString, uses, moduleName, HELPERS_NAME, virtualDynamicRequirePath) {
   const args = `module${uses.exports ? ', exports' : ''}`;
 
@@ -1047,6 +1120,7 @@ function transformCommonjs(
   isEsModule,
   ignoreGlobal,
   ignoreRequire,
+  getIgnoreTryCatchRequireStatementMode,
   sourceMap,
   isDynamicRequireModulesEnabled,
   dynamicRequireModuleSet,
@@ -1068,6 +1142,7 @@ function transformCommonjs(
   let scope = pluginutils.attachScopes(ast, 'scope');
   let lexicalDepth = 0;
   let programDepth = 0;
+  let currentTryBlockEnd = null;
   let shouldWrap = false;
   const defineCompiledEsmExpressions = [];
 
@@ -1077,6 +1152,7 @@ function transformCommonjs(
   const HELPERS_NAME = deconflict(scope, globals, 'commonjsHelpers');
   const namedExports = {};
   const dynamicRegisterSources = new Set();
+  let hasRemovedRequire = false;
 
   const {
     addRequireStatement,
@@ -1101,6 +1177,10 @@ function transformCommonjs(
         return;
       }
 
+      if (currentTryBlockEnd !== null && node.start > currentTryBlockEnd) {
+        currentTryBlockEnd = null;
+      }
+
       programDepth += 1;
       if (node.scope) ({ scope } = node);
       if (functionType.test(node.type)) lexicalDepth += 1;
@@ -1111,6 +1191,11 @@ function transformCommonjs(
 
       // eslint-disable-next-line default-case
       switch (node.type) {
+        case 'TryStatement':
+          if (currentTryBlockEnd === null) {
+            currentTryBlockEnd = node.block.end;
+          }
+          return;
         case 'AssignmentExpression':
           if (node.left.type === 'MemberExpression') {
             const flattened = getKeypath(node.left);
@@ -1164,6 +1249,32 @@ function transformCommonjs(
             }
             return;
           }
+
+          if (
+            node.callee.object &&
+            node.callee.object.name === 'require' &&
+            node.callee.property.name === 'resolve' &&
+            hasDynamicModuleForPath(id, '/', dynamicRequireModuleSet)
+          ) {
+            const requireNode = node.callee.object;
+            magicString.appendLeft(
+              node.end - 1,
+              `,${JSON.stringify(
+                path.dirname(id) === '.' ? null /* default behavior */ : virtualDynamicRequirePath
+              )}`
+            );
+            magicString.overwrite(
+              requireNode.start,
+              requireNode.end,
+              `${HELPERS_NAME}.commonjsRequire`,
+              {
+                storeName: true
+              }
+            );
+            uses.commonjsHelpers = true;
+            return;
+          }
+
           if (!isStaticRequireStatement(node, scope)) return;
           if (!isDynamicRequireModulesEnabled) {
             skippedNodes.add(node.callee);
@@ -1172,35 +1283,61 @@ function transformCommonjs(
             skippedNodes.add(node.callee);
             const usesReturnValue = parent.type !== 'ExpressionStatement';
 
+            let canConvertRequire = true;
+            let shouldRemoveRequireStatement = false;
+
+            if (currentTryBlockEnd !== null) {
+              ({
+                canConvertRequire,
+                shouldRemoveRequireStatement
+              } = getIgnoreTryCatchRequireStatementMode(node.arguments[0].value));
+
+              if (shouldRemoveRequireStatement) {
+                hasRemovedRequire = true;
+              }
+            }
+
             let sourceId = getRequireStringArg(node);
-            const isDynamicRegister = sourceId.startsWith(DYNAMIC_REGISTER_PREFIX);
+            const isDynamicRegister = isModuleRegisterProxy(sourceId);
             if (isDynamicRegister) {
-              sourceId = sourceId.substr(DYNAMIC_REGISTER_PREFIX.length);
+              sourceId = unwrapModuleRegisterProxy(sourceId);
               if (sourceId.endsWith('.json')) {
                 sourceId = DYNAMIC_JSON_PREFIX + sourceId;
               }
-              dynamicRegisterSources.add(sourceId);
+              dynamicRegisterSources.add(wrapModuleRegisterProxy(sourceId));
             } else {
               if (
                 !sourceId.endsWith('.json') &&
                 hasDynamicModuleForPath(sourceId, id, dynamicRequireModuleSet)
               ) {
-                magicString.overwrite(
-                  node.start,
-                  node.end,
-                  `${HELPERS_NAME}.commonjsRequire(${JSON.stringify(
-                    getVirtualPathForDynamicRequirePath(sourceId, commonDir)
-                  )}, ${JSON.stringify(
-                    path.dirname(id) === '.' ? null /* default behavior */ : virtualDynamicRequirePath
-                  )})`
-                );
-                uses.commonjsHelpers = true;
+                if (shouldRemoveRequireStatement) {
+                  magicString.overwrite(node.start, node.end, `undefined`);
+                } else if (canConvertRequire) {
+                  magicString.overwrite(
+                    node.start,
+                    node.end,
+                    `${HELPERS_NAME}.commonjsRequire(${JSON.stringify(
+                      getVirtualPathForDynamicRequirePath(sourceId, commonDir)
+                    )}, ${JSON.stringify(
+                      path.dirname(id) === '.' ? null /* default behavior */ : virtualDynamicRequirePath
+                    )})`
+                  );
+                  uses.commonjsHelpers = true;
+                }
                 return;
               }
-              addRequireStatement(sourceId, node, scope, usesReturnValue);
+
+              if (canConvertRequire) {
+                addRequireStatement(sourceId, node, scope, usesReturnValue);
+              }
             }
 
             if (usesReturnValue) {
+              if (shouldRemoveRequireStatement) {
+                magicString.overwrite(node.start, node.end, `undefined`);
+                return;
+              }
+
               if (
                 parent.type === 'VariableDeclarator' &&
                 !scope.parent &&
@@ -1212,6 +1349,11 @@ function transformCommonjs(
               }
             } else {
               // This is a bare import, e.g. `require('foo');`
+
+              if (!canConvertRequire && !shouldRemoveRequireStatement) {
+                return;
+              }
+
               magicString.remove(parent.start, parent.end);
             }
           }
@@ -1231,7 +1373,18 @@ function transformCommonjs(
           if (!(isReference__default['default'](node, parent) && !scope.contains(name))) return;
           switch (name) {
             case 'require':
-              if (isNodeRequirePropertyAccess(parent)) return;
+              if (isNodeRequirePropertyAccess(parent)) {
+                if (hasDynamicModuleForPath(id, '/', dynamicRequireModuleSet)) {
+                  if (parent.property.name === 'cache') {
+                    magicString.overwrite(node.start, node.end, `${HELPERS_NAME}.commonjsRequire`, {
+                      storeName: true
+                    });
+                    uses.commonjsHelpers = true;
+                  }
+                }
+
+                return;
+              }
 
               if (isDynamicRequireModulesEnabled && isRequireStatement(parent, scope)) {
                 magicString.appendLeft(
@@ -1241,10 +1394,14 @@ function transformCommonjs(
                   )}`
                 );
               }
+              if (isShorthandProperty(parent)) {
+                magicString.appendRight(node.end, `: ${HELPERS_NAME}.commonjsRequire`);
+              } else {
+                magicString.overwrite(node.start, node.end, `${HELPERS_NAME}.commonjsRequire`, {
+                  storeName: true
+                });
+              }
 
-              magicString.overwrite(node.start, node.end, `${HELPERS_NAME}.commonjsRequire`, {
-                storeName: true
-              });
               uses.commonjsHelpers = true;
               return;
             case 'module':
@@ -1353,7 +1510,8 @@ function transformCommonjs(
       uses.module ||
       uses.exports ||
       uses.require ||
-      uses.commonjsHelpers
+      uses.commonjsHelpers ||
+      hasRemovedRequire
     ) &&
     (ignoreGlobal || !uses.global)
   ) {
@@ -1449,6 +1607,20 @@ function commonjs(options = {}) {
       ? (id) => options.ignore.includes(id)
       : () => false;
 
+  const getIgnoreTryCatchRequireStatementMode = (id) => {
+    const mode =
+      typeof options.ignoreTryCatch === 'function'
+        ? options.ignoreTryCatch(id)
+        : Array.isArray(options.ignoreTryCatch)
+        ? options.ignoreTryCatch.includes(id)
+        : options.ignoreTryCatch || false;
+
+    return {
+      canConvertRequire: mode !== 'remove' && mode !== true,
+      shouldRemoveRequireStatement: mode === 'remove'
+    };
+  };
+
   const resolveId = getResolveId(extensions);
 
   const sourceMap = options.sourceMap !== false;
@@ -1478,8 +1650,13 @@ function commonjs(options = {}) {
       return { meta: { commonjs: { isCommonJS: false } } };
     }
 
+    let disableWrap = false;
+
     // avoid wrapping in createCommonjsModule, as this is a commonjsRegister call
-    const disableWrap = isModuleRegistrationProxy(id, dynamicRequireModuleSet);
+    if (isModuleRegisterProxy(id)) {
+      disableWrap = true;
+      id = unwrapModuleRegisterProxy(id);
+    }
 
     return transformCommonjs(
       this.parse,
@@ -1488,6 +1665,7 @@ function commonjs(options = {}) {
       isEsModule,
       ignoreGlobal || isEsModule,
       ignoreRequire,
+      getIgnoreTryCatchRequireStatementMode,
       sourceMap,
       isDynamicRequireModulesEnabled,
       dynamicRequireModuleSet,
@@ -1536,8 +1714,15 @@ function commonjs(options = {}) {
         return getDynamicJsonProxy(id, commonDir);
       }
 
-      if (isModuleRegistrationProxy(id, dynamicRequireModuleSet)) {
-        return getDynamicRequireProxy(normalizePathSlashes(id), commonDir);
+      if (isDynamicModuleImport(id, dynamicRequireModuleSet)) {
+        return `export default require(${JSON.stringify(normalizePathSlashes(id))});`;
+      }
+
+      if (isModuleRegisterProxy(id)) {
+        return getDynamicRequireProxy(
+          normalizePathSlashes(unwrapModuleRegisterProxy(id)),
+          commonDir
+        );
       }
 
       if (isWrappedId(id, PROXY_SUFFIX)) {
@@ -1553,7 +1738,13 @@ function commonjs(options = {}) {
       return null;
     },
 
-    transform(code, id) {
+    transform(code, rawId) {
+      let id = rawId;
+
+      if (isModuleRegisterProxy(id)) {
+        id = unwrapModuleRegisterProxy(id);
+      }
+
       const extName = path.extname(id);
       if (
         extName !== '.cjs' &&
@@ -1565,7 +1756,7 @@ function commonjs(options = {}) {
       }
 
       try {
-        return transformAndCheckExports.call(this, code, id);
+        return transformAndCheckExports.call(this, code, rawId);
       } catch (err) {
         return this.error(err, err.loc);
       }