@putout/plugin-types 10.5.0 → 10.6.1

package/README.md

@@ -13,14 +13,15 @@ npm i putout @putout/plugin-types -D
 
 ## Rules
 
+- ✅ [apply-boolean](#apply-boolean);
 - ✅ [apply-is-array](#apply-is-array);
+- ✅ [apply-is-nan](#apply-is-nan);
 - ✅ [apply-number](#apply-number);
-- ✅ [apply-boolean](#apply-boolean);
 - ✅ [convert-typeof-to-is-type](#convert-typeof-to-is-type);
 - ✅ [declare](#declare);
 - ✅ [remove-double-negations](#remove-double-negations);
-- ✅ [remove-useless-conversion](#remove-useless-conversion);
 - ✅ [remove-useless-constructor](#remove-useless-constructor);
+- ✅ [remove-useless-conversion](#remove-useless-conversion);
 - ✅ [remove-useless-typeof](#remove-useless-typeof);
 
 ## Config
@@ -29,13 +30,18 @@ npm i putout @putout/plugin-types -D
 {
     "rules": {
         "types/apply-boolean": "on",
+        
         "types/apply-is-array": "on",
+        "types/apply-is-nan": "on",
         "types/apply-number": "on",
-        "types/declare": "on",
+        
         "types/convert-typeof-to-istype": "on",
-        "types/remove-useless-conversion": "on",
-        "types/remove-useless-constructor": "on",
+        "types/declare": "on",
+        
         "types/remove-double-negations": "on",
+        "types/remove-useless-constructor": "on",
+        "types/remove-useless-conversion": "on",
+        
         "types/remove-useless-typeof": "on"
     }
 }
@@ -61,6 +67,66 @@ Checkout in 🐊[**Putout Editor**](https://putout.cloudcmd.io/#/gist/150f85ffc7
 Boolean(a || b);
 ```
 
+## apply-is-array
+
+> The `Array.isArray()` method determines whether the passed value is an `Array`.
+> When checking for `Array` instance, `Array.isArray()` is preferred over `instanceof` because it works through `iframes`.
+>
+> (c) [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray)
+
+### ❌ Example of incorrect code
+
+```js
+x instanceof Array;
+```
+
+### ✅ Example of correct code
+
+```js
+const {isArray} = Array;
+isArray(x);
+```
+
+In case of using `inline` option:
+
+```json
+{
+    "rules": {
+        "types/apply-is-array": ["on", {
+            "inline": true
+        }]
+    }
+}
+```
+
+`Array.isArray` will be inlined:
+
+```js
+Array.isArray(x);
+```
+
+## apply-is-nan
+
+> The `NaN` global property is a value representing Not-A-Number: `NaN !== NaN`.
+>
+> (c) [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN)
+
+Checkout in 🐊[**Putout Editor**](https://putout.cloudcmd.io/#/gist/e8ff80a3f522626c2d049b771692ced1/7ea6eb75d7d39f20654753fc2d800f7d881abaca)
+
+### ❌ Example of incorrect code
+
+```js
+if (a === NaN)
+    console.log();
+```
+
+### ✅ Example of correct code
+
+```js
+if (Number.isNaN(a))
+    console.log();
+```
+
 ## apply-number
 
 > The `Number` constructor contains constants and methods for working with numbers. Values of other types can be converted to numbers using the `Number()` function
@@ -93,40 +159,26 @@ const a = {
 };
 ```
 
-## apply-is-array
+## convert-typeof-to-is-type
 
-> The `Array.isArray()` method determines whether the passed value is an `Array`.
-> When checking for `Array` instance, `Array.isArray()` is preferred over `instanceof` because it works through `iframes`.
+> 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
-x instanceof Array;
+if (typeof a === 'boolean')
+    return x;
 ```
 
 ### ✅ Example of correct code
 
 ```js
-const {isArray} = Array;
-isArray(x);
-```
-
-In case of using `inline` option:
-
-```json
-{
-    "rules": {
-        "types/apply-is-array": ["on", {
-            "inline": true
-        }]
-    }
-}
-```
-
-`Array.isArray` will be inlined:
+const isBool = (a) => typeof a === 'boolean';
 
-```js
-Array.isArray(x);
+if (isBool(a))
+    return x;
 ```
 
 ## declare
@@ -181,41 +233,26 @@ When you want to skip some declaration use `dismiss`:
 }
 ```
 
-## convert-typeof-to-is-type
+## remove-double-negations
 
-> The `typeof` operator returns a string indicating the type of the unevaluated operand.
+> 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.
 >
-> (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
+> 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
-const a = !![1].includes(1);
-const b = Boolean([1].includes(1));
+if (!!a)
+    console.log('hi');
 ```
 
 ### ✅ Example of correct code
 
 ```js
-const a = [1].includes(1);
+if (a)
+    console.log('hi');
 ```
 
 ## remove-useless-constructor
@@ -242,26 +279,19 @@ const b = false;
 const n = 5;
 ```
 
-## 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)
+## remove-useless-conversion
 
 ### ❌ Example of incorrect code
 
 ```js
-if (!!a)
-    console.log('hi');
+const a = !![1].includes(1);
+const b = Boolean([1].includes(1));
 ```
 
 ### ✅ Example of correct code
 
 ```js
-if (a)
-    console.log('hi');
+const a = [1].includes(1);
 ```
 
 ## remove-useless-typeof

package/lib/apply-is-nan/index.js

@@ -0,0 +1,5 @@
+export const report = () => `Use 'isNaN' instead of comparing`;
+
+export const replace = () => ({
+    '__a === NaN': 'Number.isNaN(__a)',
+});

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

@@ -92,7 +92,7 @@ export const replace = () => ({
     [NOT_BODIES.error]: '!isError(__a)',
     [NOT_BODIES.array]: '!isArray(__a)',
     [NOT_BODIES.object]: '!isObject(__a)',
-    [NOT_BODIES.regexp]: 'isRegExp(__a)',
+    [NOT_BODIES.regexp]: '!isRegExp(__a)',
     [NOT_BODIES.equalUndefined]: '!isUndefined(__a)',
 });
 

package/lib/index.js

@@ -1,3 +1,4 @@
+import * as applyIsNan from './apply-is-nan/index.js';
 import * as applyBoolean from './apply-boolean/index.js';
 import * as applyNumber from './apply-number/index.js';
 import * as applyIsArray from './apply-is-array/index.js';
@@ -18,4 +19,5 @@ export const rules = {
     'remove-useless-typeof': removeUselessTypeof,
     'apply-number': applyNumber,
     'apply-boolean': applyBoolean,
+    'apply-is-nan': applyIsNan,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/plugin-types",
-  "version": "10.5.0",
+  "version": "10.6.1",
   "type": "module",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "🐊Putout plugin adds ability to transform code related to types assertions",