Posted on Aug 17, 2023

Update eslint-config-ts-prefixer@v0.23.3

Here is original post

I've published eslint-config-ts-prefixer@v0.23.3.

eslint-config-ts-prefixer is ESLint rule set that integrated prettier as one of ESLint rule and specialized fixable rule set.
And

📦 Zero extend for explicit rules.
💅 Prettier integration, specialized fixable import rules.
✅ Meamingful rules code behavior.

I added these new rules this update.
One of my favorite rule is @typescript-eslint/promise-function-async.\
This is available --fix so auto adding async keyword property position.

1. @typescript-eslint/no-misused-new

This rule enforces that constructors within classes are marked with the new keyword.

// Bad interface Foo { new (): Foo; } // Good class Foo { constructor() {} }

2. @typescript-eslint/no-misused-promises

This rule avoids using promises in places not designed to handle them.

// Bad addEventListener('click', async () => { await doSomethingAsync(); }); // Good addEventListener('click', () => { doSomethingAsync(); });

3. @typescript-eslint/promise-function-async

This rule requires any function or method that returns a Promise to be marked async.

// Bad function foo(): Promise<void> { return Promise.resolve(); } // Good async function foo(): Promise<void> { return; }

4. no-await-in-loop

This rule disallows await inside of loops.

// Bad for (let i = 0; i < 10; i++) { await asyncFunction() } // Good const promises = [] for (let i = 0; i < 10; i++) { promises.push(asyncFunction()) } await Promise.all(promises)

5. no-return-await

This rule disallows unnecessary return await.

// Bad async function foo() { return await bar() } // Good async function foo() { return bar() }

6. prefer-promise-reject-errors

This rule requires using Error objects as Promise rejection reasons.

// Bad Promise.reject('something went wrong') // Good Promise.reject(new Error('something went wrong'))

7. require-atomic-updates

This rule disallows assignments that can lead to race conditions due to usage of await or yield.

// Bad async function foo() { c = a + b await somethingAsync() c = c + 1 // This might be an outdated value of c } // Good async function foo() { const temp = a + b await somethingAsync() c = temp + 1 }