feat: remove unnecessary function calls

README.md

@@ -157,3 +157,30 @@ If you want the plugin to match on all functions with a specific name, no matter
   ]
 }
 ```
+
+---
+
+| Name                     | Type      | Default value |
+| ------------------------ | --------- | ------------- |
+| `removeUnnecessaryCalls` | `boolean` | `true`        |
+
+By default the plugin will remove unnecessary function calls, if for some reason you need to keep them, you can set this option to false.
+
+Example of some unnecessary calls
+
+```javascript
+const x = clsx('foo', 'bar');
+const y = clsx({ classA: foo === 'a', classB: foo !== 'a' });
+const z = clsx({
+  classA: foo === 'a',
+  classB: foo !== 'a',
+  classC: bar === 'c',
+  classD: bar !== 'c',
+});
+
+// Transforms to
+
+const x = 'foo bar';
+const y = foo === 'a' ? 'classA' : 'classB';
+const z = (foo === 'a' ? 'classA ' : 'classB ') + (bar === 'c' ? 'classC' : 'classD');
+```

src/index.js

@@ -8,6 +8,7 @@ const visitors = [
   require('./visitors/combineStringLiterals'),
   require('./visitors/combineArguments'),
   require('./visitors/createConditionalExpression'),
+  require('./visitors/removeUnnecessaryCalls'),
 ];
 
 module.exports = () => ({

src/options.js

@@ -1,6 +1,7 @@
 const DefaultSettings = {
   libraries: ['clsx', 'classnames'],
   functionNames: [],
+  removeUnnecessaryCalls: true,
 };
 
 module.exports = options => {

src/visitors/removeUnnecessaryCalls.js

@@ -0,0 +1,65 @@
+const t = require('@babel/types');
+
+const visitor = {
+  CallExpression(path) {
+    const c = path.node.callee;
+    if (!t.isIdentifier(c) || !this.options.functionNames.includes(c.name)) {
+      return;
+    }
+
+    const argLength = path.node.arguments.length;
+    if (argLength > 0) {
+      let arg = path.node.arguments[0];
+      if (argLength === 1) {
+        if (t.isStringLiteral(arg)) {
+          path.replaceWith(arg);
+        } else if (isSafeConditional(arg)) {
+          path.replaceWith(arg);
+        }
+      } else if (argLength === 2) {
+        let arg2 = path.node.arguments[1];
+        if (isSafeConditional(arg) && isSafeConditional(arg2)) {
+          const newCond = t.conditionalExpression(
+            arg.test,
+            t.stringLiteral(arg.consequent.value + ' '),
+            t.stringLiteral(arg.alternate.value + ' '),
+          );
+          path.replaceWith(t.binaryExpression('+', newCond, arg2));
+        } else if (
+          (t.isStringLiteral(arg) || t.isStringLiteral(arg2)) &&
+          (isSafeConditional(arg) || isSafeConditional(arg2))
+        ) {
+          if (t.isStringLiteral(arg)) {
+            path.replaceWith(t.binaryExpression('+', t.stringLiteral(arg.value + ' '), arg2));
+          } else {
+            path.replaceWith(t.binaryExpression('+', t.stringLiteral(arg2.value + ' '), arg));
+          }
+        }
+      }
+    } else if (argLength === 0) {
+      path.replaceWith(t.stringLiteral(''));
+    }
+
+    function isSafeConditional(node) {
+      return (
+        t.isConditionalExpression(node) &&
+        t.isStringLiteral(node.consequent) &&
+        t.isStringLiteral(node.alternate) &&
+        node.consequent.value.length > 0 &&
+        node.alternate.value.length > 0
+      );
+    }
+  },
+};
+
+module.exports = (path, options) => {
+  if (!t.isProgram(path.node)) {
+    throw new Error('Node has to be a program node');
+  }
+
+  if (!options.removeUnnecessaryCalls) {
+    return;
+  }
+
+  path.traverse(visitor, { options });
+};

test/fixtures/options.json

@@ -1,3 +1,4 @@
 {
-  "functionNames": ["clsx"]
+  "functionNames": ["clsx"],
+  "removeUnnecessaryCalls": false
 }

test/fixtures/remove-unnecessary-calls/one-conditional-argument/code.js

@@ -0,0 +1 @@
+const baseClass = clsx(foo ? 'a' : 'b');

test/fixtures/remove-unnecessary-calls/one-conditional-argument/output.js

@@ -0,0 +1 @@
+const baseClass = foo ? 'a' : 'b';

test/fixtures/remove-unnecessary-calls/options.json

@@ -0,0 +1,3 @@
+{
+  "removeUnnecessaryCalls": true
+}

test/fixtures/remove-unnecessary-calls/string-and-conditional-argument/code.js

@@ -0,0 +1,2 @@
+const classA = clsx('foo bar', foo ? 'a' : 'b');
+const classB = clsx(foo ? 'a' : 'b', 'foo bar');

test/fixtures/remove-unnecessary-calls/string-and-conditional-argument/output.js

@@ -0,0 +1,2 @@
+const classA = 'foo bar ' + (foo ? 'a' : 'b');
+const classB = 'foo bar ' + (foo ? 'a' : 'b');

test/fixtures/remove-unnecessary-calls/string-argument/code.js

@@ -0,0 +1 @@
+const baseClass = clsx('foo bar');

test/fixtures/remove-unnecessary-calls/string-argument/output.js

@@ -0,0 +1 @@
+const baseClass = 'foo bar';

test/fixtures/remove-unnecessary-calls/two-conditional-arguments/code.js

@@ -0,0 +1 @@
+const baseClass = clsx(foo ? 'a' : 'b', bar ? 'c' : 'd');

test/fixtures/remove-unnecessary-calls/two-conditional-arguments/output.js

@@ -0,0 +1 @@
+const baseClass = (foo ? 'a ' : 'b ') + (bar ? 'c' : 'd');