@putout/plugin-types 1.2.0 → 1.4.0

package/README.md

@@ -19,11 +19,12 @@ npm i putout @putout/plugin-types -D
         "types/declare": "on",
         "types/convert-typeof-to-istype": "on",
         "types/remove-useless-conversion": "on",
-        "types/remove-double-negations": "on"
+        "types/remove-double-negations": "on",
+        "types/remove-useless-typeof": "on",
+        "types/apply-is-array": "on"
     }
 }
 ```
-
 ## Rules
 
 ### declare
@@ -89,7 +90,6 @@ if (isBool(a))
     return x;
 ```
 
-
 ### remove-useless-conversion
 
 #### ❌ Example of incorrect code
@@ -129,6 +129,65 @@ if (a) {
 }
 ```
 
+### remove-useless-typeof
+
+> 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
+typeof typeof 'hello';
+```
+
+#### ✅ Example of correct code
+
+```js
+typeof 'hello';
+```
+
+### 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`.
+
+#### ❌ 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": {
+        "apply-is-array": ["on", {
+            "inline": true
+        }]
+    }
+}
+```
+
+`Array.isArray` will be inlined:
+
+```js
+Array.isArray(x);
+```
+
+## License
+
+MIT
+
+
 ## Comparison
 
 Linter | Rule | Fix

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

@@ -0,0 +1,17 @@
+'use strict';
+
+module.exports.report = () => `Use 'Array.isArray()' instead of 'instanceof'`;
+
+module.exports.replace = ({options}) => {
+    const {inline} = options;
+    
+    return {
+        '__a instanceof Array': () => {
+            if (inline)
+                return 'Array.isArray(__a)';
+            
+            return 'isArray(__a)';
+        },
+    };
+};
+

package/lib/index.js

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

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

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports.report = () => `Useless typeof should be avoided`;
+
+module.exports.replace = () => ({
+    'typeof typeof __a': 'typeof __a',
+});
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/plugin-types",
-  "version": "1.2.0",
+  "version": "1.4.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",