@rollup/plugin-commonjs 15.1.0 → 16.0.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @rollup/plugin-commonjs ChangeLog
 
+## v16.0.0
+
+_2020-10-27_
+
+### Breaking Changes
+
+- feat!: Expose cjs detection and support offline caching (#604)
+
+### Bugfixes
+
+- fix: avoid wrapping `commonjsRegister` call in `createCommonjsModule(...)` (#602)
+- fix: register dynamic modules when a different loader (i.e typescript) loads the entry file (#599)
+- fix: fixed access to node_modules dynamic module with subfolder (i.e 'logform/json') (#601)
+
+### Features
+
+- feat: pass type of import to node-resolve (#611)
+
 ## v15.1.0
 
 _2020-09-21_

package/README.md

@@ -143,7 +143,7 @@ You can also supply an array of ids to be treated as ES modules, or a function t
 
 ### `requireReturnsDefault`
 
-Type: `boolean | "auto" | "preferred" | ((id: string) => boolean | "auto" | "preferred")`<br>
+Type: `boolean | "namespace" | "auto" | "preferred" | ((id: string) => boolean | "auto" | "preferred")`<br>
 Default: `false`
 
 Controls what is returned when requiring an ES module from a CommonJS file. When using the `esmExternals` option, this will also apply to external modules. By default, this plugin will render those imports as namespace imports, i.e.
@@ -311,6 +311,26 @@ ES modules are _always_ parsed in strict mode. That means that certain non-stric
 
 Luckily, there is absolutely no good reason _not_ to use strict mode for everything — so the solution to this problem is to lobby the authors of those modules to update them.
 
+## Inter-plugin-communication
+
+This plugin exposes the result of its CommonJS file type detection for other plugins to use. You can access it via `this.getModuleInfo` or the `moduleParsed` hook:
+
+```js
+function cjsDetectionPlugin() {
+  return {
+    name: 'cjs-detection',
+    moduleParsed({
+      id,
+      meta: {
+        commonjs: { isCommonJS }
+      }
+    }) {
+      console.log(`File ${id} is CommonJS: ${isCommonJS}`);
+    }
+  };
+}
+```
+
 ## Meta
 
 [CONTRIBUTING](/.github/CONTRIBUTING.md)

package/dist/index.es.js

@@ -9,16 +9,16 @@ import isReference from 'is-reference';
 import glob from 'glob';
 
 var peerDependencies = {
-	rollup: "^2.22.0"
+	rollup: "^2.30.0"
 };
 
-const PROXY_SUFFIX = '?commonjs-proxy';
-const getProxyId = (id) => `\0${id}${PROXY_SUFFIX}`;
-const getIdFromProxyId = (proxyId) => proxyId.slice(1, -PROXY_SUFFIX.length);
+const isWrappedId = (id, suffix) => id.endsWith(suffix);
+const wrapId = (id, suffix) => `\0${id}${suffix}`;
+const unwrapId = (wrappedId, suffix) => wrappedId.slice(1, -suffix.length);
 
+const PROXY_SUFFIX = '?commonjs-proxy';
+const REQUIRE_SUFFIX = '?commonjs-require';
 const EXTERNAL_SUFFIX = '?commonjs-external';
-const getExternalProxyId = (id) => `\0${id}${EXTERNAL_SUFFIX}`;
-const getIdFromExternalProxyId = (proxyId) => proxyId.slice(1, -EXTERNAL_SUFFIX.length);
 
 const VIRTUAL_PATH_BASE = '/$$rollup_base$$';
 const getVirtualPathForDynamicRequirePath = (path, commonDir) => {
@@ -414,6 +414,7 @@ function transformCommonjs(
   sourceMap,
   isDynamicRequireModulesEnabled,
   dynamicRequireModuleSet,
+  disableWrap,
   commonDir,
   astCache
 ) {
@@ -424,7 +425,8 @@ function transformCommonjs(
   const required = {};
   // Because objects have no guaranteed ordering, yet we need it,
   // we need to keep track of the order in a array
-  const sources = [];
+  const requiredSources = [];
+  const dynamicRegisterSources = [];
 
   let uid = 0;
 
@@ -515,8 +517,7 @@ function transformCommonjs(
     }
 
     const existing = required[sourceId];
-    // eslint-disable-next-line no-undefined
-    if (existing === undefined) {
+    if (!existing) {
       const isDynamic = hasDynamicModuleForPath(sourceId);
 
       if (!name) {
@@ -526,12 +527,15 @@ function transformCommonjs(
         } while (scope.contains(name));
       }
 
-      if (isDynamicRegister && sourceId.endsWith('.json')) {
-        sourceId = DYNAMIC_JSON_PREFIX + sourceId;
+      if (isDynamicRegister) {
+        if (sourceId.endsWith('.json')) {
+          sourceId = DYNAMIC_JSON_PREFIX + sourceId;
+        }
+        dynamicRegisterSources.push(sourceId);
       }
 
-      if (isDynamicRegister || !isDynamic || sourceId.endsWith('.json')) {
-        sources.push([sourceId, !isDynamicRegister]);
+      if (!isDynamic || sourceId.endsWith('.json')) {
+        requiredSources.push(sourceId);
       }
 
       required[sourceId] = { source: sourceId, name, importsDefault: false, isDynamic };
@@ -541,7 +545,7 @@ function transformCommonjs(
   }
 
   function hasDynamicModuleForPath(source) {
-    if (!/[/\\]/.test(source)) {
+    if (!/^(?:\.{0,2}[/\\]|[A-Za-z]:[/\\])/.test(source)) {
       try {
         const resolvedPath = normalizePathSlashes(
           sync(source, { basedir: dirname(id) })
@@ -832,42 +836,45 @@ function transformCommonjs(
     }
   });
 
+  // If `isEsModule` is on, it means it has ES6 import/export statements,
+  //   which just can't be wrapped in a function.
+  shouldWrap = shouldWrap && !disableWrap && !isEsModule;
+
+  usesCommonjsHelpers = usesCommonjsHelpers || shouldWrap;
+
   if (
-    !sources.length &&
+    !requiredSources.length &&
+    !dynamicRegisterSources.length &&
     !uses.module &&
     !uses.exports &&
     !uses.require &&
+    !usesCommonjsHelpers &&
     (ignoreGlobal || !uses.global)
   ) {
-    // not a CommonJS module
-    return null;
+    return { meta: { commonjs: { isCommonJS: false } } };
   }
 
-  // If `isEsModule` is on, it means it has ES6 import/export statements,
-  //   which just can't be wrapped in a function.
-  if (isEsModule) shouldWrap = false;
-
-  usesCommonjsHelpers = usesCommonjsHelpers || shouldWrap;
-
   const importBlock = `${(usesCommonjsHelpers
     ? [`import * as ${HELPERS_NAME} from '${HELPERS_ID}';`]
     : []
   )
     .concat(
-      sources.map(
-        ([source]) =>
-          // import the actual module before the proxy, so that we know
-          // what kind of proxy to build
-          `import '${source}';`
-      ),
-      sources
-        .filter(([, importProxy]) => importProxy)
-        .map(([source]) => {
-          const { name, importsDefault } = required[source];
-          return `import ${importsDefault ? `${name} from ` : ``}'${
-            source.startsWith('\0') ? source : getProxyId(source)
-          }';`;
-        })
+      // dynamic registers first, as the may be required in the other modules
+      dynamicRegisterSources.map((source) => `import '${source}';`),
+
+      // now the actual modules so that they are analyzed before creating the proxies;
+      // no need to do this for virtual modules as we never proxy them
+      requiredSources
+        .filter((source) => !source.startsWith('\0'))
+        .map((source) => `import '${wrapId(source, REQUIRE_SUFFIX)}';`),
+
+      // now the proxy modules
+      requiredSources.map((source) => {
+        const { name, importsDefault } = required[source];
+        return `import ${importsDefault ? `${name} from ` : ``}'${
+          source.startsWith('\0') ? source : wrapId(source, PROXY_SUFFIX)
+        }';`;
+      })
     )
     .join('\n')}\n\n`;
 
@@ -978,7 +985,12 @@ function transformCommonjs(
   code = magicString.toString();
   const map = sourceMap ? magicString.generateMap() : null;
 
-  return { code, map, syntheticNamedExports: isEsModule ? false : '__moduleExports' };
+  return {
+    code,
+    map,
+    syntheticNamedExports: isEsModule ? false : '__moduleExports',
+    meta: { commonjs: { isCommonJS: !isEsModule } }
+  };
 }
 
 function getDynamicPackagesModule(dynamicRequireModuleDirPaths, commonDir) {
@@ -1006,28 +1018,24 @@ function getDynamicPackagesModule(dynamicRequireModuleDirPaths, commonDir) {
 }
 
 function getDynamicPackagesEntryIntro(
-  id,
   dynamicRequireModuleDirPaths,
   dynamicRequireModuleSet
 ) {
-  try {
-    const code = readFileSync(id, { encoding: 'utf8' });
-    let dynamicImports = Array.from(
-      dynamicRequireModuleSet,
-      (dynamicId) => `require(${JSON.stringify(DYNAMIC_REGISTER_PREFIX + dynamicId)});`
-    ).join('\n');
+  let dynamicImports = Array.from(
+    dynamicRequireModuleSet,
+    (dynamicId) => `require(${JSON.stringify(DYNAMIC_REGISTER_PREFIX + dynamicId)});`
+  ).join('\n');
 
-    if (dynamicRequireModuleDirPaths.length) {
-      dynamicImports += `require(${JSON.stringify(
-        DYNAMIC_REGISTER_PREFIX + DYNAMIC_PACKAGES_ID
-      )});`;
-    }
-
-    return `${dynamicImports}\n${code}`;
-  } catch (ex) {
-    this.warn(`Failed to read file ${id}, dynamic modules might not work correctly`);
-    return null;
+  if (dynamicRequireModuleDirPaths.length) {
+    dynamicImports += `require(${JSON.stringify(DYNAMIC_REGISTER_PREFIX + DYNAMIC_PACKAGES_ID)});`;
   }
+
+  return dynamicImports;
+}
+
+function isModuleRegistrationProxy(id, dynamicRequireModuleSet) {
+  const normalizedPath = normalizePathSlashes(id);
+  return dynamicRequireModuleSet.has(normalizedPath) && !normalizedPath.endsWith('.json');
 }
 
 function getDynamicRequirePaths(patterns) {
@@ -1052,7 +1060,6 @@ function getDynamicRequirePaths(patterns) {
   return { dynamicRequireModuleSet, dynamicRequireModuleDirPaths };
 }
 
-/* eslint-disable no-undefined */
 const isCjsPromises = new Map();
 
 function getIsCjsPromise(id) {
@@ -1062,7 +1069,7 @@ function getIsCjsPromise(id) {
   const promise = new Promise((resolve) => {
     isCjsPromise = {
       resolve,
-      promise: undefined
+      promise: null
     };
     isCjsPromises.set(id, isCjsPromise);
   });
@@ -1076,10 +1083,10 @@ function setIsCjsPromise(id, resolution) {
   if (isCjsPromise) {
     if (isCjsPromise.resolve) {
       isCjsPromise.resolve(resolution);
-      isCjsPromise.resolve = undefined;
+      isCjsPromise.resolve = null;
     }
   } else {
-    isCjsPromises.set(id, { promise: Promise.resolve(resolution), resolve: undefined });
+    isCjsPromises.set(id, { promise: Promise.resolve(resolution), resolve: null });
   }
 }
 
@@ -1181,10 +1188,18 @@ function getResolveId(extensions) {
     return undefined;
   }
 
-  function resolveId(importee, importer) {
-    const isProxyModule = importee.endsWith(PROXY_SUFFIX);
+  return function resolveId(importee, importer) {
+    // Proxies are only importing resolved ids, no need to resolve again
+    if (importer && isWrappedId(importer, PROXY_SUFFIX)) {
+      return importee;
+    }
+
+    const isProxyModule = isWrappedId(importee, PROXY_SUFFIX);
+    const isRequiredModule = isWrappedId(importee, REQUIRE_SUFFIX);
     if (isProxyModule) {
-      importee = getIdFromProxyId(importee);
+      importee = unwrapId(importee, PROXY_SUFFIX);
+    } else if (isRequiredModule) {
+      importee = unwrapId(importee, REQUIRE_SUFFIX);
     }
     if (importee.startsWith('\0')) {
       if (
@@ -1194,32 +1209,25 @@ function getResolveId(extensions) {
       ) {
         return importee;
       }
-      if (!isProxyModule) {
-        return null;
-      }
-    }
-
-    if (importer && importer.endsWith(PROXY_SUFFIX)) {
-      importer = getIdFromProxyId(importer);
+      return null;
     }
 
-    return this.resolve(importee, importer, { skipSelf: true }).then((resolved) => {
+    return this.resolve(importee, importer, {
+      skipSelf: true,
+      custom: { 'node-resolve': { isRequire: isProxyModule || isRequiredModule } }
+    }).then((resolved) => {
       if (!resolved) {
         resolved = resolveExtensions(importee, importer);
       }
-      if (isProxyModule) {
-        if (!resolved) {
-          return { id: getExternalProxyId(importee), external: false };
-        }
-        resolved.id = (resolved.external ? getExternalProxyId : getProxyId)(resolved.id);
+      if (resolved && isProxyModule) {
+        resolved.id = wrapId(resolved.id, resolved.external ? EXTERNAL_SUFFIX : PROXY_SUFFIX);
         resolved.external = false;
-        return resolved;
+      } else if (!resolved && (isProxyModule || isRequiredModule)) {
+        return { id: wrapId(importee, EXTERNAL_SUFFIX), external: false };
       }
       return resolved;
     });
-  }
-
-  return resolveId;
+  };
 }
 
 function commonjs(options = {}) {
@@ -1265,6 +1273,11 @@ function commonjs(options = {}) {
   const sourceMap = options.sourceMap !== false;
 
   function transformAndCheckExports(code, id) {
+    if (isDynamicRequireModulesEnabled && this.getModuleInfo(id).isEntry) {
+      code =
+        getDynamicPackagesEntryIntro(dynamicRequireModuleDirPaths, dynamicRequireModuleSet) + code;
+    }
+
     const { isEsModule, hasDefaultExport, hasNamedExports, ast } = checkEsModule(
       this.parse,
       code,
@@ -1281,11 +1294,13 @@ function commonjs(options = {}) {
       !dynamicRequireModuleSet.has(normalizePathSlashes(id)) &&
       (!hasCjsKeywords(code, ignoreGlobal) || (isEsModule && !options.transformMixedEsModules))
     ) {
-      setIsCjsPromise(id, false);
-      return null;
+      return { meta: { commonjs: { isCommonJS: false } } };
     }
 
-    const transformed = transformCommonjs(
+    // avoid wrapping in createCommonjsModule, as this is a commonjsRegister call
+    const disableWrap = isModuleRegistrationProxy(id, dynamicRequireModuleSet);
+
+    return transformCommonjs(
       this.parse,
       code,
       id,
@@ -1295,12 +1310,10 @@ function commonjs(options = {}) {
       sourceMap,
       isDynamicRequireModulesEnabled,
       dynamicRequireModuleSet,
+      disableWrap,
       commonDir,
       ast
     );
-
-    setIsCjsPromise(id, isEsModule ? false : Boolean(transformed));
-    return transformed;
   }
 
   return {
@@ -1334,8 +1347,8 @@ function commonjs(options = {}) {
         return getSpecificHelperProxy(id);
       }
 
-      if (id.endsWith(EXTERNAL_SUFFIX)) {
-        const actualId = getIdFromExternalProxyId(id);
+      if (isWrappedId(id, EXTERNAL_SUFFIX)) {
+        const actualId = unwrapId(id, EXTERNAL_SUFFIX);
         return getUnknownRequireProxy(
           actualId,
           isEsmExternal(actualId) ? getRequireReturnsDefault(actualId) : true
@@ -1350,13 +1363,12 @@ function commonjs(options = {}) {
         return getDynamicJsonProxy(id, commonDir);
       }
 
-      const normalizedPath = normalizePathSlashes(id);
-      if (dynamicRequireModuleSet.has(normalizedPath) && !normalizedPath.endsWith('.json')) {
-        return getDynamicRequireProxy(normalizedPath, commonDir);
+      if (isModuleRegistrationProxy(id, dynamicRequireModuleSet)) {
+        return getDynamicRequireProxy(normalizePathSlashes(id), commonDir);
       }
 
-      if (id.endsWith(PROXY_SUFFIX)) {
-        const actualId = getIdFromProxyId(id);
+      if (isWrappedId(id, PROXY_SUFFIX)) {
+        const actualId = unwrapId(id, PROXY_SUFFIX);
         return getStaticRequireProxy(
           actualId,
           getRequireReturnsDefault(actualId),
@@ -1365,14 +1377,6 @@ function commonjs(options = {}) {
         );
       }
 
-      if (isDynamicRequireModulesEnabled && this.getModuleInfo(id).isEntry) {
-        return getDynamicPackagesEntryIntro(
-          id,
-          dynamicRequireModuleDirPaths,
-          dynamicRequireModuleSet
-        );
-      }
-
       return null;
     },
 
@@ -1384,20 +1388,25 @@ function commonjs(options = {}) {
         !id.startsWith(DYNAMIC_JSON_PREFIX) &&
         (!filter(id) || !extensions.includes(extName))
       ) {
-        setIsCjsPromise(id, null);
         return null;
       }
 
-      let transformed;
       try {
-        transformed = transformAndCheckExports.call(this, code, id);
+        return transformAndCheckExports.call(this, code, id);
       } catch (err) {
-        transformed = null;
-        setIsCjsPromise(id, false);
-        this.error(err, err.loc);
+        return this.error(err, err.loc);
       }
+    },
 
-      return transformed;
+    moduleParsed({ id, meta: { commonjs } }) {
+      if (commonjs) {
+        const isCjs = commonjs.isCommonJS;
+        if (isCjs != null) {
+          setIsCjsPromise(id, isCjs);
+          return;
+        }
+      }
+      setIsCjsPromise(id, null);
     }
   };
 }