@putout/plugin-typescript [![NPM version][NPMIMGURL]][NPMURL]

[NPMIMGURL]: https://img.shields.io/npm/v/@putout/plugin-typescript.svg?style=flat&longCache=true
[NPMURL]: https://npmjs.org/package/@putout/plugin-typescript "npm"

> TypeScript is JavaScript with syntax for types.
>
> (c) typescriptcriptlang.org

🐊Putout plugin adds ability to transform TypeScript code. Enabled by default for ts and tsx files.

Install

``
npm i putout @putout/plugin-typescript -D
`

Rules

- ✅ apply-as-type-assertion;
- ✅ apply-type-guards;
- ✅ apply-utility-types;
- ✅ convert-commonjs-to-esm;
- ✅ convert-esm-to-commonjs;
- ✅ convert-generic-to-shorthand;
- ✅ convert-namespace-to-global;
- ✅ cts-file;
- ✅ find-file;
- ✅ mts-file;
- ✅ remove-duplicate-exports;
- ✅ remove-duplicate-interface-keys;
- ✅ remove-duplicates-from-union;
- ✅ remove-unused-types;
- ✅ remove-getter-arguments;
- ✅ remove-setter-return-type;
- ✅ remove-useless-mapped-types;
- ✅ remove-useless-mapping-modifiers;
- ✅ remove-useless-non-null-expressions;
- ✅ remove-useless-parens;
- ✅ remove-useless-promise;
- ✅ remove-useless-types;
- ✅ remove-useless-types-from-constants;
- ✅ rename-file-cts-to-ts;
- ✅ rename-file-mts-to-ts;

Config

`json
{
"rules": {
"typescript/apply-as-type-assertion": "on",
"typescript/apply-utility-types": "on",
"typescript/apply-type-guards": "on",
"typescript/convert-generic-to-shorthand": "on",
"typescript/convert-commonjs-to-esm": "off",
"typescript/convert-esm-to-commonjs": "off",
"typescript/convert-namespace-to-global": "off",
"typescript/remove-duplicates-from-union": "on",
"typescript/remove-duplicates-interface-keys": "on",
"typescript/remove-duplicates-exports": "on",
"typescript/remove-useless-types-from-constants": "on",
"typescript/remove-unused-types": "on",
"typescript/remove-useless-types": "on",
"typescript/remove-useless-parens": "on",
"typescript/remove-useless-promise": "on",
"typescript/remove-getter-arguments": "on",
"typescript/remove-setter-return-type": "on",
"typescript/remove-useless-mapped-types": "on",
"typescript/remove-useless-non-null-expressions": "on",
"typescript/cts-file": "off",
"typescript/mts-file": "off",
"typescript/rename-file-cts-to-ts": "off",
"typescript/rename-file-mts-to-ts": "off",
"typescript/find-file": ["off", {
"ignore": []
}]
}
}
`

apply-as-type-assertion

According to best practice.

$3

`ts
const boundaryElement = e.target;
`

$3

`ts
const boundaryElement1 = e.target as HTMLElement;
`

apply-utility-types

$3

`ts
type SuperType1 = {
[Key in keyof Type]?: Type[Key];
};
`

$3

`ts
type SuperType1 = Partial;
`

apply-type-guards

> It just so happens that TypeScript has something called a type guard.
> A type guard is some expression that performs a runtime check that guarantees the type in some scope.
>
> (c) typescript.org

Check out in 🐊Putout Editor.

$3

`ts
const isNumber = (a) => typeof a === 'number';
`

$3

`ts
const isNumber = (a): a is number => typeof a === 'number';
`

convert-generic-to-shorthand

> There is no difference at all. Type[] is the shorthand syntax for an array of Type. Array is the generic syntax. They are completely equivalent.
>
> (c) https://stackoverflow.com/a/36843084/4536327

Convert generic to shorthand.

$3

`ts
interface A {
x: Array;
y: Array;
}
`

$3

`ts
interface A {
x: X[];
y: X[] | Y[];
}
`

$3

Linter | Rule | Fix
--------|-------|------------|
🐊 Putout | typescript/convert-generic-to-shorthand | ✅
⏣ ESLint | @typescript-eslint/array-type | ✅

convert-commonjs-to-esm

Checkout in 🐊Putout Editor.

$3

`ts
import foo = require('foo');
export = 5;
`

$3

`ts
import foo from 'foo';

export default 5;
`

convert-esm-to-commonjs

Checkout in 🐊Putout Editor.

$3

`ts
import foo from 'foo';

export default 5;
`

$3

`ts
import foo = require('foo');
export = 5;
`

convert-namespace-to-global

Checkout in 🐊Putout Editor.

$3

`ts
declare namespace global {
var al: any;
}
`

$3

`ts
declare global {
var al: any;
}
`

$3

Linter | Rule | Fix
--------|-------|------------|
🐊 Putout | typescript/convert-namespace-to-global | ✅
⏣ ESLint | @typescript-eslint/no-namespace | ❌

remove-duplicates-from-union

$3

`ts
type x =
| boolean[]
| A
| string
| A
| string[]
| boolean[];
`

$3

`ts
type x =
| boolean[]
| A
| string
| string[];
`

remove-duplicate-exports

In JavaScript duplicate exports leads to SyntaxError, anyways TypeScript parses such code and reports Duplicates Identifier diagnostic.

It gives us ability to automate fixing of such code 😏. Check it out in 🐊Putout Editor.

$3

`ts
export {
a,
hello,
a,
world,
};
`

#### ✅ Example of correct code

`ts
export {
hello,
a,
world,
};
`

☝️ The rule fits good with putout/add-newlines-between-specifiers of eslint-plugin-putout.

$3

> The get syntax binds an object property to a function that will be called when that property is looked up
>
> (c) MDN

#### ❌ Example of incorrect code

`ts
export interface IParamsConstructor {
get fromArray: IParams;
}
`

#### ✅ Example of correct code

`ts
export interface IParamsConstructor {
get [fromArray](): IParams;
}
`

$3

> The set syntax binds an object property to a function to be called when there is an attempt to set that property.
>
> (c) MDN

#### ❌ Example of incorrect code

`ts
export interface IParamsConstructor {
set fromArray(values: ParamsArray): string;
}
`

#### ✅ Example of correct code

`ts
export interface IParamsConstructor {
set fromArray(values: ParamsArray);
}
`

$3

#### ❌ Example of incorrect code

`ts
const x: any = 5;
`

#### ✅ Example of correct code

`ts
const x = 5;
`

remove-unused-types

$3

`ts
type n = number;
type s = string;

const x: n = 5;
`

$3

`ts
type n = number;

const x: n = 5;
`

remove-useless-types

$3

`ts
type oldType = {
a: number;
b: string;
};
type newType = oldType;

const x: newType = {
a: 5,
b: 'hello',
};
`

$3

`ts
type oldType = {
a: number;
b: string;
};

const x: oldType = {
a: 5,
b: 'hello',
};
`

remove-useless-parens

Check it out in 🐊Putout Editor.

$3

`ts
const m: X[] = [];
const z: X | Y = 5;
const f: X = 5;
`

$3

`ts
const x: X[] | Y[] = [];
const m: X[] = [];
const z: X | Y = 5;
const f: X = 5;
`

remove-useless-promise

Check it out in 🐊Putout Editor.

$3

`ts
function doStuff(): Promise {
return 'hello';
}
`

$3

`ts
function doStuff(): string {
return 'hello';
}
`

remove-useless-mapped-types

Remove useless mapped types.

$3

`ts
type SuperType = {
[Key in keyof Type]: Type[Key];
};
`

$3

`ts
type SuperType = Type;
`

remove-useless-non-null-expressions

Checkout in 🐊Putout Editor.

$3

`ts
const bar = foo!!.str;
const baz = bar!?.n;
`

$3

`ts
const bar = foo!.str;
const baz = bar?.n;
`

remove-useless-mapping-modifiers

Remove useless mapping modifiers.

$3

`ts
type SuperType = {
[Key in keyof Type]+?: Type[Key];
};
`

$3

`ts
type SuperType = {
[Key in keyof Type]?: Type[Key];
};
`

remove-duplicate-interface-keys

$3

`ts
interface Hello {
hello: any;
hello: string;
}
`

$3

`ts
interface Hello {
hello: string;
}
`

cts-file

Run convert-esm-to-commonjs for all *.cts files with help of redlint.

Check out in 🐊Putout Editor.

mts-file

Run convert-esm-to-commonjs for all *.mts files with help of redlint.

Check out in 🐊Putout Editor.

find-file

Checkout in 🐊Putout Editor.

$3

`ts
__putout_processor_filesystem(['/', [
'/hello.ts',
'const a: number = 5;',
]]);
`

$3

`ts
__putout_processor_filesystem(['/', [
'/hello.ts',
'const a = 5;',
]]);
`

rename-file-cts-to-ts

Rename *.cts files when type === "commonjs":

`diff
/
|-- package.json
-- lib/
- -- hello.cts
+ -- hello.ts
``

Check out in 🐊Putout Editor.

rename-file-mts-to-ts

Rename *.mts files when type === "module":

`diff
/
|-- package.json
-- lib/
- -- hello.mts
+ -- hello.ts
```

Check out in 🐊Putout Editor.

License

MIT