fix(strip): support specifying both functions and labels

packages/strip/README.md

@@ -36,59 +36,88 @@ export default {
     dir: 'output',
     format: 'cjs'
   },
-  plugins: [
-    strip({
-      labels: ['unittest']
-    })
-  ]
+  plugins: [strip({})]
 };
 ```
 
 Then call `rollup` either via the [CLI](https://www.rollupjs.org/guide/en/#command-line-reference) or the [API](https://www.rollupjs.org/guide/en/#javascript-api).
 
+### Default Options
+
+By default the **strip** plugin applies the following options, you can override by specifing options manually.
+
+> consider files matching **'\*\*/\*.js'**  
+> remove functions matching '**console.\***' and '**assert.\***'  
+> remove any **debugger** statements
+
+### Custom Options Example
+
+```js
+plugins: [
+  strip({
+    include: '**/*.(mjs|js)',
+    exclude: 'tests/**/*',
+    debugger: true,
+    functions: ['console.log', 'assert.*'],
+    labels: ['unittest'],
+    sourceMap: true
+  })
+];
+```
+
 ## Options
 
 ### `include`
 
 Type: `String | RegExp | Array[...String|RegExp]`<br>
-Default: `['**/*.js']`
+Default: `['**/*.js']`<br>
+Example: `include: '**/*.(mjs|js)',`<br>
 
 A pattern, or array of patterns, which specify the files in the build the plugin should operate on.
 
 ### `exclude`
 
 Type: `String | RegExp | Array[...String|RegExp]`<br>
-Default: `[]`
+Default: `[]`<br>
+Example: `exlude: 'tests/**/*',`<br>
 
 A pattern, or array of patterns, which specify the files in the build the plugin should _ignore_.
 
 ### `debugger`
 
 Type: `Boolean`<br>
-Default: `true`
+Default: `true`<br>
+Example: `debugger: false,`<br>
 
-If `true`, instructs the plugin to remove debugger statements.
+If `true` or unspecified, instructs the plugin to remove debugger statements.
 
 ### `functions`
 
 Type: `Array[...String]`<br>
-Default: `[ 'console.*', 'assert.*' ]`
+Default: `[ 'console.*', 'assert.*' ]`<br>
+Example: `functions: [ 'console.log', 'MyClass.Test' ],`<br>
 
 Specifies the functions that the plugin will target and remove.
 
+_Note: specifying functions that are used at the begining of a chain, such as 'a().b().c()', will result in '(void 0).b().c()' which will generate an error at runtime._
+
 ### `labels`
 
 Type: `Array[...String]`<br>
-Default: `[]`
+Default: `[]`<br>
+Example: `labels: ['unittest'],`<br>
+
+Specifies the [labeled blocks or statements](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/label) that the plugin will target and remove.
 
-Specifies the [labeled blocks](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/label) that the plugin will target and remove.
+_Note: the '**:**' is implied and should not be specified in the config._
 
 ### `sourceMap`
 
 Type: `Boolean`<br>
-Default: `true`
+Default: `true`<br>
+Example: `sourceMap: false,`<br>
 
-If `true`, instructs the plugin to update source maps accordingly after removing configured targets from the bundle.
+If `true` or unspecified, instructs the plugin to update source maps accordingly after removing configured targets from the bundle.
 
 ## Meta
 

packages/strip/src/index.js

@@ -38,21 +38,34 @@ export default function strip(options = {}) {
   const sourceMap = options.sourceMap !== false;
 
   const removeDebuggerStatements = options.debugger !== false;
-  const functions = (options.functions || ['console.*', 'assert.*']).map((keypath) =>
-    keypath.replace(/\./g, '\\.').replace(/\*/g, '\\w+')
-  );
 
+  const functions = options.functions || ['console.*', 'assert.*'];
   const labels = options.labels || [];
 
-  const firstpass = new RegExp(`\\b(?:${functions.join('|')}|debugger)\\b`);
-  const pattern = new RegExp(`^(?:${functions.join('|')})$`);
+  const functionsPatterns = functions.map((f) =>
+    f.replace(/\*/g, '\\w+').replace(/\./g, '\\.\\s*')
+  );
+  const labelsPatterns = labels.map((l) => `${l}\\s*:`);
+
+  const firstPassPatterns = removeDebuggerStatements
+    ? [...functionsPatterns, ...labelsPatterns, 'debugger\\b']
+    : [...functionsPatterns, ...labelsPatterns];
+
+  const functionsRE = new RegExp(`^(?:${functionsPatterns.join('|')})$`);
+  const firstpassRE = new RegExp(`\\b(?:${firstPassPatterns.join('|')})`);
+
+  const firstPassFilter =
+    firstPassPatterns.length > 0 ? (code) => firstpassRE.test(code) : () => false;
+
+  const UNCHANGED = null;
 
   return {
     name: 'strip',
 
     transform(code, id) {
-      if (!filter(id)) return null;
-      if (functions.length > 0 && !firstpass.test(code)) return null;
+      if (!filter(id) || !firstPassFilter(code)) {
+        return UNCHANGED;
+      }
 
       let ast;
 
@@ -81,7 +94,7 @@ export default function strip(options = {}) {
         if (parent.type === 'ExpressionStatement') {
           removeStatement(parent);
         } else {
-          magicString.overwrite(node.start, node.end, 'void 0');
+          magicString.overwrite(node.start, node.end, '(void 0)');
         }
 
         edited = true;
@@ -93,7 +106,7 @@ export default function strip(options = {}) {
         if (isBlock(parent)) {
           remove(node.start, node.end);
         } else {
-          magicString.overwrite(node.start, node.end, 'void 0;');
+          magicString.overwrite(node.start, node.end, '(void 0);');
         }
 
         edited = true;
@@ -114,21 +127,25 @@ export default function strip(options = {}) {
 
           if (removeDebuggerStatements && node.type === 'DebuggerStatement') {
             removeStatement(node);
+            this.skip();
           } else if (node.type === 'LabeledStatement') {
             if (node.label && labels.includes(node.label.name)) {
               removeStatement(node);
+              this.skip();
             }
           } else if (node.type === 'CallExpression') {
             const keypath = flatten(node.callee);
-            if (keypath && pattern.test(keypath)) {
+            if (keypath && functionsRE.test(keypath)) {
               removeExpression(node);
               this.skip();
             }
           }
         }
       });
 
-      if (!edited) return null;
+      if (!edited) {
+        return UNCHANGED;
+      }
 
       code = magicString.toString();
       const map = sourceMap ? magicString.generateMap() : null;