@putout/plugin-types

🐊Putout plugin adds ability to help with transforming code related to types.

Install

npm i putout @putout/plugin-types -D

Rules

• ✅ apply-is-array;
• ✅ convert-typeof-to-is-type;
• ✅ declare;
• ✅ remove-double-negations;
• ✅ remove-useless-conversion;
• ✅ remove-useless-constructor;
• ✅ remove-useless-typeof;

Config

{
    "rules": {
        "types/declare": "on",
        "types/convert-typeof-to-istype": "on",
        "types/remove-useless-conversion": "on",
        "types/remove-useless-constructor": "on",
        "types/remove-double-negations": "on",
        "types/remove-useless-typeof": "on",
        "types/apply-is-array": "on"
    }
}

declare

Based on @putout/operator-declare. Supported assertions:

• isString;
• isEmptyString;
• isNumber;
• isFn;
• isBool;
• isObject;
• isUndefined;
• isSymbol;
• isNull;
• isBigInt;
• isArray;
• isEmptyArray;

❌ Example of incorrect code

isString('hello');

✅ Example of correct code

const isString = (a) => typeof a === 'string';
isString('hello');

When you want to skip some declaration use dismiss:

{
    "rules": {
        "types/declare": ["on", {
            "dismiss": ["isString"]
        }]
    }
}

convert-typeof-to-is-type

The typeof operator returns a string indicating the type of the unevaluated operand.

(c) MDN

❌ Example of incorrect code

if (typeof a === 'boolean')
    return x;

✅ Example of correct code

const isBool = (a) => typeof a === 'boolean';

if (isBool(a))
    return x;

remove-useless-conversion

❌ Example of incorrect code

const a = !![1].includes(1);
const b = Boolean([1].includes(1));

✅ Example of correct code

const a = [1].includes(1);

remove-useless-constructor

Wrapper classes have surprising behaviour, such as new Boolean(false) evaluating to true.

(c) Google TypeScript Style Guide

🐊Putout plugin adds ability to remove useless constructor. Use with new/remove-useless.

❌ Example of incorrect code

const s = String('hello');
const b = Boolean(false);
const n = Number(5);

✅ Example of correct code

const s = 'hello';
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

❌ Example of incorrect code

if (!!a)
    console.log('hi');

✅ Example of correct code

if (a)
    console.log('hi');

remove-useless-typeof

The typeof operator returns a string indicating the type of the unevaluated operand.

(c) MDN

❌ Example of incorrect code

typeof typeof 'hello';

✅ Example of correct code

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

x instanceof Array;

✅ Example of correct code

const {isArray} = Array;
isArray(x);

In case of using inline option:

{
    "rules": {
        "types/apply-is-array": ["on", {
            "inline": true
        }]
    }
}

Array.isArray will be inlined:

Array.isArray(x);

License

MIT

Comparison

Linter | Rule | Fix --------|-------|------------| 🐊 Putout | types| ✅ ⏣ ESLint | no-implicit-coercion | ✅

License

MIT