@putout/plugin-types 1.0.0 → 1.2.0

package/README.md

@@ -16,7 +16,10 @@ npm i putout @putout/plugin-types -D
 ```json
 {
     "rules": {
-        "types/declare": "on"
+        "types/declare": "on",
+        "types/convert-typeof-to-istype": "on",
+        "types/remove-useless-conversion": "on",
+        "types/remove-double-negations": "on"
     }
 }
 ```
@@ -26,7 +29,7 @@ npm i putout @putout/plugin-types -D
 ### declare
 
 Based on [`@putout/operator-declare`](https://github.com/coderaiser/putout/tree/master/packages/operator-declare#putoutoperator-declare-).
-Suported assertions:
+Supported assertions:
 
 - `isString`;
 - `isNumber`;
@@ -64,6 +67,75 @@ When you want to skip some declaration use `dismiss`:
 }
 ```
 
+### convert-typeof-to-is-type
+
+> The `typeof` operator returns a string indicating the type of the unevaluated operand.
+>
+> (c) [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof)
+
+#### ❌ Example of incorrect code
+
+```js
+if (typeof a === 'boolean')
+    return x;
+```
+
+#### ✅ Example of correct code
+
+```js
+const isBool = (a) => typeof a === 'boolean';
+
+if (isBool(a))
+    return x;
+```
+
+
+### remove-useless-conversion
+
+#### ❌ Example of incorrect code
+
+```js
+const a = !![1].includes(1);
+const b = Boolean([1].includes(1));
+```
+
+#### ✅ Example of correct code
+
+```js
+const a = [1].includes(1);
+```
+
+### remove-double-negations
+
+> It is possible to use a couple of **NOT** operators (`!!`) in series to explicitly force the conversion of any value to the corresponding boolean primitive. The conversion is based on the "truthyness" or "falsyness" of the value.
+>
+> The same conversion can be done through the `Boolean` function.
+>
+> (c) [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_NOT)
+
+#### ❌ Example of incorrect code
+
+```js
+if (!!a) {
+    console.log('hi');
+}
+```
+
+#### ✅ Example of correct code
+
+```js
+if (a) {
+    console.log('hi');
+}
+```
+
+## Comparison
+
+Linter | Rule | Fix
+--------|-------|------------|
+🐊 **Putout** | [`types`](https://github.com/coderaiser/putout/tree/master/packages/plugin-types#readme)| ✅
+⏣ **ESLint** | [`no-implicit-coercion`](https://eslint.org/docs/rules/no-implicit-coercion) | ✅
+
 ## License
 
 MIT

package/lib/convert-typeof-to-is-type/index.js

@@ -0,0 +1,64 @@
+'use strict';
+
+const {operator} = require('putout');
+const {compare, getBindingPath} = operator;
+
+const NAMES = {
+    function: 'isFn',
+    string: 'isString',
+    number: 'isNumber',
+    boolean: 'isBool',
+    undefined: 'isUndefined',
+    symbol: 'isSymbol',
+};
+
+const BODIES = {
+    function: `typeof __a === 'function'`,
+    string: `typeof __a === 'string'`,
+    number: `typeof __a === 'number'`,
+    boolean: `typeof __a === 'boolean'`,
+    undefined: `typeof __a === 'undefined'`,
+    symbol: `typeof __a === 'symbol'`,
+};
+
+module.exports.report = () => `Use function to check type instead of 'typeof'`;
+module.exports.match = () => ({
+    'typeof __a === "__b"': ({__a, __b}, path) => {
+        if (path.parentPath.isFunction())
+            return false;
+        
+        if (path.parentPath.isVariableDeclarator())
+            return false;
+        
+        if (isBind(path, __b.value))
+            return false;
+        
+        if (!getBindingPath(path, __a))
+            return false;
+        
+        return true;
+    },
+});
+
+module.exports.replace = () => ({
+    [BODIES.function]: 'isFn(__a)',
+    [BODIES.string]: 'isString(__a)',
+    [BODIES.number]: 'isNumber(__a)',
+    [BODIES.boolean]: 'isBool(__a)',
+    [BODIES.undefined]: 'isUndefined(__a)',
+    [BODIES.symbol]: 'isSymbol(__a)',
+});
+
+function isBind(path, name) {
+    const fnName = NAMES[name];
+    const fnBody = BODIES[name];
+    const bindingPath = getBindingPath(path, fnName);
+    
+    if (!bindingPath)
+        return false;
+    
+    const {body} = bindingPath.node.init;
+    
+    return !compare(body, fnBody);
+}
+

package/lib/index.js

@@ -6,5 +6,8 @@ const getRule = (a) => ({
 
 module.exports.rules = {
     ...getRule('declare'),
+    ...getRule('convert-typeof-to-is-type'),
+    ...getRule('remove-useless-conversion'),
+    ...getRule('remove-double-negations'),
 };
 

package/lib/remove-double-negations/index.js

@@ -0,0 +1,16 @@
+'use strict';
+
+module.exports.report = () => `Avoid double negations in conditions`;
+
+module.exports.filter = ({parentPath}) => !parentPath.isJSXExpressionContainer();
+
+module.exports.replace = () => ({
+    'if (!!__a) __b': 'if (__a) __b',
+    '!!__a ? __b : __c': '__a ? __b : __c',
+    '!!__a && __b': '__a && __b',
+    '!!__a.includes(__b)': '__a.includes(__b)',
+    'while(!!__a) __b': 'while(__a) __b',
+    'do __a; while(!!__b)': 'do __a; while(__b)',
+    'for (__a; !!__b; __c) __d': 'for (__a; __b; __c) __d',
+});
+

package/lib/remove-useless-conversion/index.js

@@ -0,0 +1,16 @@
+'use strict';
+
+module.exports.report = () => `Avoid useless type conversion`;
+
+module.exports.replace = () => ({
+    'Boolean(__a.includes(__b))': '__a.includes(__b)',
+    'String(typeof __a)': 'typeof __a',
+    'if (Boolean(__a)) __b': 'if (__a) __b',
+    'while (Boolean(__a)) __b': 'while (__a) __b',
+    'do __b; while (Boolean(__a))': 'do __b; while (__a)',
+    'for (__a; Boolean(__b); __c) __d': 'for (__a; __b; __c) __d',
+    'for (__a; Boolean(__b);) __d': 'for (__a; __b;) __d',
+    'for (; Boolean(__b);__c) __d': 'for (; __b; __c) __d',
+    'for (; Boolean(__b);) __d': 'for (; __b;) __d',
+});
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/plugin-types",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "type": "commonjs",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "🐊Putout plugin adds ability to transform code related to types assertions",
@@ -32,7 +32,7 @@
   ],
   "devDependencies": {
     "@putout/plugin-putout": "*",
-    "@putout/test": "^5.0.0",
+    "@putout/test": "^6.0.0",
     "c8": "^7.5.0",
     "eslint": "^8.0.1",
     "eslint-plugin-n": "^15.2.4",