@rollup/plugin-commonjs 17.0.0 → 17.1.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @rollup/plugin-commonjs ChangeLog
 
+## v17.1.0
+
+_2021-01-29_
+
+### Bugfixes
+
+- fix: correctly replace shorthand `require` (#764)
+
+### Features
+
+- feature: load dynamic commonjs modules from es `import` (#766)
+- feature: support cache/resolve access inside dynamic modules (#728)
+- feature: allow keeping `require` calls inside try-catch (#729)
+
+### Updates
+
+- chore: fix lint error (#719)
+
 ## v17.0.0
 
 _2020-11-30_

package/README.md

@@ -120,6 +120,20 @@ Default: `[]`
 
 Sometimes you have to leave require statements unconverted. Pass an array containing the IDs or an `id => boolean` function.
 
+### `ignoreTryCatch`
+
+Type: `boolean | 'remove' | string[] | ((id: string) => boolean)`<br>
+Default: `false`
+
+In most cases, where `require` calls are inside a `try-catch` clause, they should be left unconverted as it requires an optional dependency that may or may not be installed beside the rolled up package.
+Due to the conversion of `require` to a static `import` - the call is hoisted to the top of the file, outside of the `try-catch` clause.
+
+- `true`: All `require` calls inside a `try` will be left unconverted.
+- `false`: All `require` calls inside a `try` will be converted as if the `try-catch` clause is not there.
+- `remove`: Remove all `require` calls from inside any `try` block.
+- `string[]`: Pass an array containing the IDs to left unconverted.
+- `((id: string) => boolean|'remove')`: Pass a function that control individual IDs.
+
 ### `esmExternals`
 
 Type: `boolean | string[] | ((id: string) => boolean)`

package/dist/index.es.js

@@ -84,7 +84,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';
 
@@ -234,10 +234,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;
@@ -246,33 +249,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;
@@ -280,10 +268,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) {
@@ -327,20 +357,26 @@ const getVirtualPathForDynamicRequirePath = (path, commonDir) => {
     : normalizedPath;
 };
 
+function getPackageEntryPoint(dirPath) {
+  let entryPoint = 'index.js';
+
+  try {
+    if (existsSync(join(dirPath, 'package.json'))) {
+      entryPoint =
+        JSON.parse(readFileSync(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 (existsSync(join(dir, 'package.json'))) {
-        entryPoint =
-          JSON.parse(readFileSync(join(dir, 'package.json'), { encoding: 'utf8' })).main ||
-          entryPoint;
-      }
-    } catch (ignored) {
-      // ignored
-    }
+    const entryPoint = getPackageEntryPoint(dir);
 
     code += `\ncommonjsRegister(${JSON.stringify(
       getVirtualPathForDynamicRequirePath(dir, commonDir)
@@ -357,21 +393,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 (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]) {
@@ -379,17 +436,13 @@ function getDynamicRequirePaths(patterns) {
     const modifySet = Set.prototype[isNegated ? 'delete' : 'add'].bind(dynamicRequireModuleSet);
     for (const path of glob.sync(isNegated ? pattern.substr(1) : pattern)) {
       modifySet(normalizePathSlashes(resolve(path)));
-    }
-  }
-  const dynamicRequireModuleDirPaths = Array.from(dynamicRequireModuleSet.values()).filter(
-    (path) => {
-      try {
-        if (statSync(path).isDirectory()) return true;
-      } catch (ignored) {
-        // Nothing to do here
+      if (isDirectory(path)) {
+        modifySet(normalizePathSlashes(resolve(join(path, getPackageEntryPoint(path)))));
       }
-      return false;
     }
+  }
+  const dynamicRequireModuleDirPaths = Array.from(dynamicRequireModuleSet.values()).filter((path) =>
+    isDirectory(path)
   );
   return { dynamicRequireModuleSet, dynamicRequireModuleDirPaths };
 }
@@ -522,7 +575,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;
@@ -530,19 +588,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;
     }
 
@@ -556,6 +623,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 };
       }
@@ -701,6 +770,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' : ''}`;
 
@@ -1038,6 +1111,7 @@ function transformCommonjs(
   isEsModule,
   ignoreGlobal,
   ignoreRequire,
+  getIgnoreTryCatchRequireStatementMode,
   sourceMap,
   isDynamicRequireModulesEnabled,
   dynamicRequireModuleSet,
@@ -1059,6 +1133,7 @@ function transformCommonjs(
   let scope = attachScopes(ast, 'scope');
   let lexicalDepth = 0;
   let programDepth = 0;
+  let currentTryBlockEnd = null;
   let shouldWrap = false;
   const defineCompiledEsmExpressions = [];
 
@@ -1068,6 +1143,7 @@ function transformCommonjs(
   const HELPERS_NAME = deconflict(scope, globals, 'commonjsHelpers');
   const namedExports = {};
   const dynamicRegisterSources = new Set();
+  let hasRemovedRequire = false;
 
   const {
     addRequireStatement,
@@ -1092,6 +1168,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;
@@ -1102,6 +1182,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);
@@ -1155,6 +1240,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(
+                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);
@@ -1163,35 +1274,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(
-                    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(
+                      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 &&
@@ -1203,6 +1340,11 @@ function transformCommonjs(
               }
             } else {
               // This is a bare import, e.g. `require('foo');`
+
+              if (!canConvertRequire && !shouldRemoveRequireStatement) {
+                return;
+              }
+
               magicString.remove(parent.start, parent.end);
             }
           }
@@ -1222,7 +1364,18 @@ function transformCommonjs(
           if (!(isReference(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(
@@ -1232,10 +1385,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':
@@ -1344,7 +1501,8 @@ function transformCommonjs(
       uses.module ||
       uses.exports ||
       uses.require ||
-      uses.commonjsHelpers
+      uses.commonjsHelpers ||
+      hasRemovedRequire
     ) &&
     (ignoreGlobal || !uses.global)
   ) {
@@ -1440,6 +1598,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;
@@ -1469,8 +1641,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,
@@ -1479,6 +1656,7 @@ function commonjs(options = {}) {
       isEsModule,
       ignoreGlobal || isEsModule,
       ignoreRequire,
+      getIgnoreTryCatchRequireStatementMode,
       sourceMap,
       isDynamicRequireModulesEnabled,
       dynamicRequireModuleSet,
@@ -1527,8 +1705,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)) {
@@ -1544,7 +1729,13 @@ function commonjs(options = {}) {
       return null;
     },
 
-    transform(code, id) {
+    transform(code, rawId) {
+      let id = rawId;
+
+      if (isModuleRegisterProxy(id)) {
+        id = unwrapModuleRegisterProxy(id);
+      }
+
       const extName = extname(id);
       if (
         extName !== '.cjs' &&
@@ -1556,7 +1747,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);
       }