@rollup/plugin-commonjs 15.0.0 → 17.1.0

package/CHANGELOG.md

@@ -1,5 +1,58 @@
 # @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_
+
+### Breaking Changes
+
+- feat!: reconstruct real es module from \_\_esModule marker (#537)
+
+## 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_
+
+### Features
+
+- feat: inject \_\_esModule marker into ES namespaces and add Object prototype (#552)
+- feat: add requireReturnsDefault to types (#579)
+
 ## v15.0.0
 
 _2020-08-13_

package/README.md

@@ -76,21 +76,21 @@ commonjs({
 Type: `string | string[]`<br>
 Default: `null`
 
-A [minimatch pattern](https://github.com/isaacs/minimatch), or array of patterns, which specifies the files in the build the plugin should _ignore_. By default non-CommonJS modules are ignored.
+A [minimatch pattern](https://github.com/isaacs/minimatch), or array of patterns, which specifies the files in the build the plugin should _ignore_. By default, all files with extensions other than those in `extensions` or `".cjs"` are ignored, but you can exclude additional files. See also the `include` option.
 
 ### `include`
 
 Type: `string | string[]`<br>
 Default: `null`
 
-A [minimatch pattern](https://github.com/isaacs/minimatch), or array of patterns, which specifies the files in the build the plugin should operate on. By default CommonJS modules are targeted.
+A [minimatch pattern](https://github.com/isaacs/minimatch), or array of patterns, which specifies the files in the build the plugin should operate on. By default, all files with extension `".cjs"` or those in `extensions` are included, but you can narrow this list by only including specific files. These files will be analyzed and transpiled if either the analysis does not find ES module specific statements or `transformMixedEsModules` is `true`.
 
 ### `extensions`
 
 Type: `string[]`<br>
 Default: `['.js']`
 
-Search for extensions other than .js in the order specified.
+For extensionless imports, search for extensions other than .js in the order specified. Note that you need to make sure that non-JavaScript files are transpiled by another plugin first.
 
 ### `ignoreGlobal`
 
@@ -104,28 +104,42 @@ If true, uses of `global` won't be dealt with by this plugin.
 Type: `boolean`<br>
 Default: `true`
 
-If false, skips source map generation for CommonJS modules.
+If false, skips source map generation for CommonJS modules. This will improve performance.
 
 ### `transformMixedEsModules`
 
 Type: `boolean`<br>
 Default: `false`
 
-Instructs the plugin whether or not to enable mixed module transformations. This is useful in scenarios with mixed ES and CommonJS modules. Set to `true` if it's known that `require` calls should be transformed, or `false` if the code contains env detection and the `require` should survive a transformation.
+Instructs the plugin whether to enable mixed module transformations. This is useful in scenarios with modules that contain a mix of ES `import` statements and CommonJS `require` expressions. Set to `true` if `require` calls should be transformed to imports in mixed modules, or `false` if the `require` expressions should survive the transformation. The latter can be important if the code contains environment detection, or you are coding for an environment with special treatment for `require` calls such as [ElectronJS](https://www.electronjs.org/). See also the "ignore" option.
 
 ### `ignore`
 
 Type: `string[] | ((id: string) => boolean)`<br>
 Default: `[]`
 
-Sometimes you have to leave require statements unconverted. Pass an array containing the IDs or an `id => boolean` function. Only use this option if you know what you're doing!
+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)`
+Type: `boolean | string[] | ((id: string) => boolean)`
 Default: `false`
 
-Controls how imports from external dependencies are rendered. By default, all external dependencies are assumed to be CommonJS. This means they are rendered as default imports to be compatible with e.g. NodeJS where ES modules can only import a default export from a CommonJS dependency:
+Controls how to render imports from external dependencies. By default, this plugin assumes that all external dependencies are CommonJS. This means they are rendered as default imports to be compatible with e.g. NodeJS where ES modules can only import a default export from a CommonJS dependency:
 
 ```js
 // input
@@ -137,16 +151,16 @@ import foo from 'foo';
 
 This is likely not desired for ES module dependencies: Here `require` should usually return the namespace to be compatible with how bundled modules are handled.
 
-If you set `esmExternals` to `true`, all external dependencies are assumed to be ES modules and will adhere to the `requireReturnsDefault` option. If that option is not set, they will be rendered as namespace imports.
+If you set `esmExternals` to `true`, this plugins assumes that all external dependencies are ES modules and will adhere to the `requireReturnsDefault` option. If that option is not set, they will be rendered as namespace imports.
 
-You can also supply an array of ids that are to be treated as ES modules, or a function that will be passed each external id to determine if it is an ES module.
+You can also supply an array of ids to be treated as ES modules, or a function that will be passed each external id to determine if it is an ES module.
 
 ### `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 or external dependency from a CommonJS file. By default, this plugin will render it as a namespace import, i.e.
+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.
 
 ```js
 // input
@@ -182,13 +196,44 @@ This is in line with how other bundlers handle this situation and is also the mo
 
 For these situations, you can change Rollup's behaviour either globally or per module. To change it globally, set the `requireReturnsDefault` option to one of the following values:
 
-- `false`: This is the default, requiring an ES module returns its namespace. For external dependencies when using `esmExternals: true`, no additional interop code is generated:
+- `false`: This is the default, requiring an ES module returns its namespace. This is the only option that will also add a marker `__esModule: true` to the namespace to support interop patterns in CommonJS modules that are transpiled ES modules.
 
   ```js
   // input
   const dep = require('dep');
   console.log(dep);
 
+  // output
+  import * as dep$1 from 'dep';
+
+  function getAugmentedNamespace(n) {
+    var a = Object.defineProperty({}, '__esModule', { value: true });
+    Object.keys(n).forEach(function (k) {
+      var d = Object.getOwnPropertyDescriptor(n, k);
+      Object.defineProperty(
+        a,
+        k,
+        d.get
+          ? d
+          : {
+              enumerable: true,
+              get: function () {
+                return n[k];
+              }
+            }
+      );
+    });
+    return a;
+  }
+
+  var dep = /*@__PURE__*/ getAugmentedNamespace(dep$1);
+
+  console.log(dep);
+  ```
+
+- `"namespace"`: Like `false`, requiring an ES module returns its namespace, but the plugin does not add the `__esModule` marker and thus creates more efficient code. For external dependencies when using `esmExternals: true`, no additional interop code is generated.
+
+  ```js
   // output
   import * as dep from 'dep';
 
@@ -202,11 +247,7 @@ For these situations, you can change Rollup's behaviour either globally or per m
   import * as dep$1 from 'dep';
 
   function getDefaultExportFromNamespaceIfNotNamed(n) {
-    return n &&
-      Object.prototype.hasOwnProperty.call(n, 'default') &&
-      Object.keys(n).length === 1
-      ? n['default']
-      : n;
+    return n && Object.prototype.hasOwnProperty.call(n, 'default') && Object.keys(n).length === 1 ? n['default'] : n;
   }
 
   var dep = getDefaultExportFromNamespaceIfNotNamed(dep$1);
@@ -221,9 +262,7 @@ For these situations, you can change Rollup's behaviour either globally or per m
   import * as dep$1 from 'dep';
 
   function getDefaultExportFromNamespaceIfPresent(n) {
-    return n && Object.prototype.hasOwnProperty.call(n, 'default')
-      ? n['default']
-      : n;
+    return n && Object.prototype.hasOwnProperty.call(n, 'default') ? n['default'] : n;
   }
 
   var dep = getDefaultExportFromNamespaceIfPresent(dep$1);
@@ -280,6 +319,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)