@putout/plugin-conditions 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) coderaiser
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,184 @@
+# @putout/plugin-conditions [![NPM version][NPMIMGURL]][NPMURL]
+
+[NPMIMGURL]: https://img.shields.io/npm/v/@putout/plugin-conditions.svg?style=flat&longCache=true
+[NPMURL]: https://npmjs.org/package/@putout/plugin-conditions "npm"
+
+🐊[**Putout**](https://github.com/coderaiser/putout) adds support of conditions transformations.
+
+## Install
+
+```
+npm i @putout/plugin-conditions -D
+```
+
+## Rules
+
+```json
+{
+    "rules": {
+        "conditions/apply-comparison-order": "on",
+        "conditions/convert-comparison-to-boolean": "on",
+        "conditions/convert-equal-to-strict-equal": "on",
+        "conditions/evaluate": "on",
+        "conditions/remove-boolean": "on",
+        "conditions/remove-constant": "on"
+    }
+}
+```
+
+## apply-comparison-order
+
+> The result of evaluating an equality operator is always of type boolean based on whether the comparison is true.
+>
+> (c) [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators)
+ 
+Checkout it 🐊[Putout Editor](https://putout.cloudcmd.io/#/gist/c61c94d2e1990f59b160aaf462f9a903/0855844b114079ec46098be6f3602dfdaa74290c).
+
+### ❌ Example of incorrect code
+
+```js
+3 === a;
+3 < b;
+```
+
+### ✅ Example of correct code
+
+```js
+a === 3;
+b > 3;
+```
+
+### Comparison
+
+Linter | Rule | Fix
+--------|-------|------------|
+🐊 **Putout**| [`conditions/apply-comparison-order`](https://github.com/coderaiser/putout/tree/master/packages/plugin-conditions/#apply-comparison-order)| ✅
+⏣ **ESLint** | [`yoda`](https://eslint.org/docs/rules/yoda) | ½
+
+## convert-comparison-to-boolean
+
+> Strict equality compares two values for equality. Neither value is implicitly converted to some other value before being compared. If the values have different types, the values are considered unequal.
+>
+> (c) [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Equality_comparisons_and_sameness)
+## ❌ Example of incorrect code
+
+```js
+const t = 2 < 3;
+```
+
+## ✅ Example of correct code
+
+```js
+const t = false;
+```
+
+## convert-equal-to-strict-equal
+
+> The **strict equality** operator (`===`) checks whether its two operands are equal, returning a `Boolean` result. Unlike the **equality** operator (`==`), the **strict equality** operator always considers operands of different types to be different.
+>
+> (c) [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality)
+
+### ❌ Example of incorrect code
+
+```js
+if (a == b) {
+}
+```
+
+### ✅ Example of correct code
+
+```js
+if (a === b) {
+}
+```
+
+## evaluate
+
+> The **if** statement executes a statement if a specified condition is **truthy**. If the condition is **falsy**, another statement can be executed.
+>
+> (c) [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/if...else)
+
+### ❌ Example of incorrect code
+
+```js
+const a = [];
+const c = a;
+
+if (a) {
+    console.log(a);
+}
+```
+
+### ✅ Example of correct code
+
+```js
+const a = [];
+const c = a;
+
+console.log(a);
+```
+
+## remove-boolean
+
+### ❌ Example of incorrect code
+
+```js
+if (a === true)
+    alert();
+```
+
+### ✅ Example of correct code
+
+```js
+if (a)
+    alert();
+```
+
+## remove-constant
+
+### ❌ Example of incorrect code
+
+```js
+function hi(a) {
+    if (2 < 3) {
+        console.log('hello');
+        console.log('world');
+    }
+}
+```
+
+### ✅ Example of correct code
+
+```js
+function hi(b) {
+    console.log('hello');
+    console.log('world');
+}
+```
+
+## simplify
+
+## ❌ Example of incorrect code
+
+```js
+if (zone?.tooltipCallback) {
+    zone.tooltipCallback(e);
+}
+
+if (a)
+    alert('hello');
+else
+    alert('hello');
+```
+
+## ✅ Example of correct code
+
+```js
+zone?.tooltipCallback(e);
+
+alert('hello');
+```
+
+## License
+
+MIT

package/lib/apply-comparison-order/index.js

@@ -0,0 +1,68 @@
+'use strict';
+
+module.exports.report = ({leftPath, rightPath}) => {
+    return `Swap '${leftPath.toString()}' with '${rightPath}'`;
+};
+
+const {replaceWith} = require('putout').operator;
+
+module.exports.fix = ({path, leftPath, rightPath, operator}) => {
+    const leftNode = leftPath.node;
+    const rightNode = rightPath.node;
+    
+    replaceWith(rightPath, leftNode);
+    replaceWith(leftPath, rightNode);
+    
+    path.node.operator = convertOperator(operator);
+};
+
+module.exports.traverse = ({push}) => ({
+    BinaryExpression: (path) => {
+        const {operator} = path.node;
+        
+        if (!/^[<>]=?|===?$/.test(operator))
+            return;
+        
+        if (operator.includes('>>') || operator.includes('<<'))
+            return;
+        
+        const leftPath = path.get('left');
+        const rightPath = path.get('right');
+        
+        if (leftPath.isUpdateExpression())
+            return;
+        
+        if (!isLeftValid(leftPath))
+            return;
+        
+        if (!rightPath.isIdentifier() && !rightPath.isMemberExpression() && !rightPath.isCallExpression())
+            return;
+        
+        push({
+            path,
+            operator,
+            leftPath,
+            rightPath,
+        });
+    },
+});
+
+function isLeftValid(leftPath) {
+    if (leftPath.isIdentifier() || leftPath.isMemberExpression() || leftPath.isCallExpression())
+        return false;
+    
+    if (leftPath.isOptionalMemberExpression())
+        return false;
+    
+    return true;
+}
+
+function convertOperator(operator) {
+    if (operator.includes('>'))
+        return operator.replace('>', '<');
+    
+    if (operator.includes('<'))
+        return operator.replace('<', '>');
+    
+    return operator;
+}

package/lib/convert-comparison-to-boolean/index.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const {
+    types,
+    operator,
+} = require('putout');
+
+const {replaceWith, compute} = operator;
+const {
+    isIdentifier,
+    BooleanLiteral,
+} = types;
+
+module.exports.report = () => 'Avoid constant conditions';
+
+module.exports.fix = ({path, value}) => {
+    replaceWith(path, BooleanLiteral(value));
+};
+
+module.exports.traverse = ({push}) => ({
+    BinaryExpression(path) {
+        const {
+            left,
+            right,
+            operator,
+        } = path.node;
+        
+        if (!/<|>|===?|!===?/.test(operator))
+            return;
+        
+        if (/<<|>>/.test(operator))
+            return;
+        
+        const [confident, value] = compute(path);
+        
+        if (confident) {
+            return push({
+                path,
+                value,
+            });
+        }
+        
+        if (sameIdentifiers(left, right))
+            return push({
+                path,
+                value: /^===?$/.test(operator),
+            });
+    },
+});
+
+function sameIdentifiers(left, right) {
+    if (!isIdentifier(left))
+        return false;
+    
+    if (!isIdentifier(right))
+        return false;
+    
+    return left.name === right.name;
+}

package/lib/convert-equal-to-strict-equal/index.js

@@ -0,0 +1,14 @@
+'use strict';
+
+module.exports.report = () => 'Strict equal should be used instead of equal';
+
+module.exports.exclude = () => [
+    '__ == null',
+    '__ != null',
+];
+
+module.exports.replace = () => ({
+    '__a == __b': '__a === __b',
+    '__a != __b': '__a !== __b',
+});
+

package/lib/evaluate/index.js

@@ -0,0 +1,25 @@
+'use strict';
+
+module.exports.report = () => 'Avoid useless conditions';
+
+module.exports.match = () => ({
+    'if (__a) __b': (vars, path) => {
+        const testPath = path.get('test');
+        const {confident} = testPath.evaluate();
+        
+        return confident;
+    },
+});
+
+module.exports.replace = () => ({
+    'if (__a) __b': (vars, path) => {
+        const testPath = path.get('test');
+        const {value} = testPath.evaluate();
+        
+        if (!value)
+            return '';
+        
+        return '__b';
+    },
+});
+

package/lib/index.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const getRule = (a) => ({
+    [a]: require(`./${a}`),
+});
+
+module.exports.rules = {
+    ...getRule('apply-comparison-order'),
+    ...getRule('evaluate'),
+    ...getRule('convert-comparison-to-boolean'),
+    ...getRule('convert-equal-to-strict-equal'),
+    ...getRule('remove-boolean'),
+    ...getRule('simplify'),
+};
+

package/lib/remove-boolean/index.js

@@ -0,0 +1,23 @@
+'use strict';
+
+module.exports.report = () => 'Avoid boolean in assertions';
+
+module.exports.replace = () => ({
+    'return __a === true': 'return Boolean(__a)',
+    'return __a == true': 'return Boolean(__a)',
+    
+    'const __a = __b === true': 'const __a = __b === Boolean(__a)',
+    'const __a = __b == true': 'const __a = __b == Boolean(__a)',
+    
+    '__a = __b === true': '__a = __b === Boolean(__a)',
+    '__a = __b == true': '__a = __b == Boolean(__a)',
+    
+    '__a === true': '__a',
+    '__a === false': '!__a',
+    '__a == true': '__a',
+    '__a == false': '!__a',
+    
+    '__a !== true': '!__a',
+    '__a != true': '!__a',
+});
+

package/lib/remove-constant/index.js

@@ -0,0 +1,81 @@
+'use strict';
+
+const {
+    types,
+    operator,
+} = require('putout');
+
+const {runInNewContext} = require('vm');
+
+const {
+    replaceWith,
+    replaceWithMultiple,
+    remove,
+} = operator;
+const {isIdentifier} = types;
+
+module.exports.report = () => 'Avoid constant conditions';
+
+module.exports.fix = ({path, result}) => {
+    const {
+        alternate,
+        consequent,
+    } = path.node;
+    
+    const {
+        body = [consequent],
+    } = consequent;
+    
+    if (result)
+        return replaceWithMultiple(path, body);
+    
+    if (!alternate)
+        return remove(path);
+    
+    replaceWith(path, alternate);
+};
+
+module.exports.traverse = ({push, generate}) => ({
+    IfStatement(path) {
+        const testPath = path.get('test');
+        const {
+            left,
+            right,
+            operator,
+        } = testPath.node;
+        
+        if (!containsIdentifiers(testPath)) {
+            const {node} = testPath;
+            const {code} = generate(node);
+            const result = runInNewContext(code);
+            
+            return push({
+                path,
+                result,
+            });
+        }
+        
+        if (isIdentifier(left) && isIdentifier(right) && left.name === right.name)
+            return push({
+                path,
+                result: /^===?$/.test(operator),
+            });
+    },
+});
+
+function containsIdentifiers(testPath) {
+    if (testPath.isIdentifier())
+        return true;
+    
+    let is = false;
+    
+    testPath.traverse({
+        Identifier(path) {
+            is = true;
+            path.stop();
+        },
+    });
+    
+    return is;
+}
+

package/lib/simplify/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+module.exports.report = () => 'Avoid useless conditions';
+
+module.exports.replace = () => ({
+    'if (__a?.__b) {__a.__b(__args)}': '__a?.__b(__args)',
+    'if (__a?.__b) __a.__b(__args)': '__a?.__b(__args)',
+    'if (__a) __b; else __b': '__b',
+});

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@putout/plugin-conditions",
+  "version": "1.0.0",
+  "type": "commonjs",
+  "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
+  "description": "🐊Putout plugin adds support of conditions transformations",
+  "homepage": "https://github.com/coderaiser/conditions/tree/master/packages/plugin-conditions#readme",
+  "main": "lib/index.js",
+  "release": false,
+  "tag": false,
+  "changelog": false,
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/coderaiser/conditions.git"
+  },
+  "scripts": {
+    "wisdom": "madrun wisdom",
+    "test": "madrun test",
+    "watch:test": "madrun watch:test",
+    "lint": "madrun lint",
+    "fresh:lint": "madrun fresh:lint",
+    "lint:fresh": "madrun lint:fresh",
+    "fix:lint": "madrun fix:lint",
+    "coverage": "madrun coverage",
+    "report": "madrun report"
+  },
+  "dependencies": {},
+  "keywords": [
+    "putout-plugin",
+    "putout",
+    "plugin",
+    "conditions"
+  ],
+  "devDependencies": {
+    "@putout/plugin-convert-for-each-to-for-of": "^8.1.0",
+    "@putout/plugin-remove-useless-variables": "^7.3.0",
+    "@putout/test": "^6.0.0",
+    "c8": "^7.5.0",
+    "eslint": "^8.0.1",
+    "eslint-plugin-n": "^15.2.4",
+    "eslint-plugin-putout": "^16.0.0",
+    "lerna": "^6.0.1",
+    "madrun": "^9.0.0",
+    "montag": "^1.2.1",
+    "nodemon": "^2.0.1"
+  },
+  "peerDependencies": {
+    "putout": ">=29"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=16"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}