xo 0.47.0 → 0.50.0

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-extra-non-null-assertion.md

@@ -1,8 +1,14 @@
-# Disallow extra non-null assertion (`no-extra-non-null-assertion`)
+# `no-extra-non-null-assertion`
+
+Disallows extra non-null assertion.
 
 ## Rule Details
 
-Examples of **incorrect** code for this rule:
+Examples of code for this rule:
+
+<!--tabs-->
+
+### ❌ Incorrect
 
 ```ts
 const foo: { bar: number } | null = null;
@@ -21,7 +27,7 @@ function foo(bar?: { n: number }) {
 }
 ```
 
-Examples of **correct** code for this rule:
+### ✅ Correct
 
 ```ts
 const foo: { bar: number } | null = null;
@@ -40,16 +46,15 @@ function foo(bar?: { n: number }) {
 }
 ```
 
-## How to use
+## Options
 
-```json
+```jsonc
+// .eslintrc.json
 {
-  "@typescript-eslint/no-extra-non-null-assertion": ["error"]
+  "rules": {
+    "@typescript-eslint/no-extra-non-null-assertion": "error"
+  }
 }
 ```
 
-## Attributes
-
-- [x] ✅ Recommended
-- [x] 🔧 Fixable
-- [ ] 💭 Requires type information
+This rule is not configurable.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-extra-parens.md

@@ -1,11 +1,13 @@
-# Disallow unnecessary parentheses (`no-extra-parens`)
+# `no-extra-parens`
+
+Disallows unnecessary parentheses.
 
 ## Rule Details
 
 This rule extends the base [`eslint/no-extra-parens`](https://eslint.org/docs/rules/no-extra-parens) rule.
 It adds support for TypeScript type assertions.
 
-## How to use
+## How to Use
 
 ```jsonc
 {
@@ -19,10 +21,8 @@ It adds support for TypeScript type assertions.
 
 See [`eslint/no-extra-parens` options](https://eslint.org/docs/rules/no-extra-parens#options).
 
-<sup>Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/master/docs/rules/no-extra-parens.md)</sup>
+<sup>
 
-## Attributes
+Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/main/docs/rules/no-extra-parens.md)
 
-- [ ] ✅ Recommended
-- [x] 🔧 Fixable
-- [ ] 💭 Requires type information
+</sup>

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-extra-semi.md

@@ -1,11 +1,13 @@
-# Disallow unnecessary semicolons (`no-extra-semi`)
+# `no-extra-semi`
+
+Disallows unnecessary semicolons.
 
 ## Rule Details
 
 This rule extends the base [`eslint/no-extra-semi`](https://eslint.org/docs/rules/no-extra-semi) rule.
 It adds support for class properties.
 
-## How to use
+## How to Use
 
 ```jsonc
 {
@@ -19,10 +21,8 @@ It adds support for class properties.
 
 See [`eslint/no-extra-semi` options](https://eslint.org/docs/rules/no-extra-semi#options).
 
-<sup>Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/master/docs/rules/no-extra-semi.md)</sup>
+<sup>
 
-## Attributes
+Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/main/docs/rules/no-extra-semi.md)
 
-- [x] ✅ Recommended
-- [x] 🔧 Fixable
-- [ ] 💭 Requires type information
+</sup>

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-extraneous-class.md

@@ -1,52 +1,196 @@
-# Forbids the use of classes as namespaces (`no-extraneous-class`)
+# `no-extraneous-class`
 
-This rule warns when a class is accidentally used as a namespace.
+Disallows classes used as namespaces.
+
+This rule warns when a class has no non-static members, such as for a class used exclusively as a static namespace.
 
 ## Rule Details
 
-From TSLint’s docs:
+Users who come from a [OOP](https://en.wikipedia.org/wiki/Object-oriented_programming) paradigm may wrap their utility functions in an extra class, instead of putting them at the top level of an ECMAScript module.
+Doing so is generally unnecessary in JavaScript and TypeScript projects.
+
+- Wrapper classes add extra cognitive complexity to code without adding any structural improvements
+  - Whatever would be put on them, such as utility functions, are already organized by virtue of being in a module.
+  - As an alternative, you can always `import * as ...` the module to get all of them in a single object.
+- IDEs can't provide as good suggestions for static class or namespace imported properties when you start typing property names
+- It's more difficult to statically analyze code for unused variables, etc. when they're all on the class (see: [Finding dead code (and dead types) in TypeScript](https://effectivetypescript.com/2020/10/20/tsprune)).
+
+This rule also flags classes that have only a constructor and no fields.
+Those classes can generally be replaced with a standalone function.
 
-> Users who come from a Java-style OO language may wrap their utility functions in an extra class,
-> instead of putting them at the top level.
+Examples of code for this rule:
 
-Examples of **incorrect** code for this rule:
+<!--tabs-->
+
+### ❌ Incorrect
 
 ```ts
-class EmptyClass {}
+class StaticConstants {
+  static readonly version = 42;
 
-class ConstructorOnly {
-  constructor() {
-    foo();
+  static isProduction() {
+    return process.env.NODE_ENV === 'production';
   }
 }
 
-// Use an object instead:
-class StaticOnly {
-  static version = 42;
-  static hello() {
+class HelloWorldLogger {
+  constructor() {
     console.log('Hello, world!');
   }
 }
 ```
 
-Examples of **correct** code for this rule:
+### ✅ Correct
 
 ```ts
-class EmptyClass extends SuperClass {}
+export const version = 42;
+
+export function isProduction() {
+  return process.env.NODE_ENV === 'production';
+}
 
-class ParameterProperties {
-  constructor(public name: string) {}
+function logHelloWorld() {
+  console.log('Hello, world!');
 }
+```
+
+## Alternatives
+
+### Individual Exports (Recommended)
+
+Instead of using a static utility class we recommend you individually export the utilities from your module.
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+export class Utilities {
+  static util1() {
+    return Utilities.util3();
+  }
+
+  static util2() {
+    /* ... */
+  }
+
+  static util3() {
+    /* ... */
+  }
+}
+```
+
+#### ✅ Correct
+
+```ts
+export function util1() {
+  return util3();
+}
+
+export function util2() {
+  /* ... */
+}
+
+export function util3() {
+  /* ... */
+}
+```
+
+### Namespace Imports (Not Recommended)
 
-const StaticOnly = {
-  version: 42,
-  hello() {
+If you strongly prefer to have all constructs from a module available as properties of a single object, you can `import * as` the module.
+This is known as a "namespace import".
+Namespace imports are sometimes preferable because they keep all properties nested and don't need to be changed as you start or stop using various properties from the module.
+
+However, namespace imports are impacted by these downsides:
+
+- They also don't play as well with tree shaking in modern bundlers
+- They require a name prefix before each property's usage
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+// utilities.ts
+export class Utilities {
+  static sayHello() {
     console.log('Hello, world!');
-  },
-};
+  }
+}
+
+// consumers.ts
+import { Utilities } from './utilities';
+
+Utilities.sayHello();
+```
+
+#### ⚠️ Namespace Imports
+
+```ts
+// utilities.ts
+export function sayHello() {
+  console.log('Hello, world!');
+}
+
+// consumers.ts
+import * as utilities from './utilities';
+
+utilities.sayHello();
+```
+
+#### ✅ Standalone Imports
+
+```ts
+// utilities.ts
+export function sayHello() {
+  console.log('Hello, world!');
+}
+
+// consumers.ts
+import { sayHello } from './utilities';
+
+sayHello();
+```
+
+### Notes on Mutating Variables
+
+One case you need to be careful of is exporting mutable variables.
+While class properties can be mutated externally, exported variables are always constant.
+This means that importers can only ever read the first value they are assigned and cannot write to the variables.
+
+Needing to write to an exported variable is very rare and is generally considered a code smell.
+If you do need it you can accomplish it using getter and setter functions:
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+export class Utilities {
+  static mutableCount = 1;
+
+  static incrementCount() {
+    Utilities.mutableCount += 1;
+  }
+}
+```
+
+#### ✅ Correct
+
+```ts
+let mutableCount = 1;
+
+export function getMutableCount() {
+  return mutableField;
+}
+
+export function incrementCount() {
+  mutableField += 1;
+}
 ```
 
-### Options
+## Options
 
 This rule accepts a single object option.
 
@@ -70,17 +214,105 @@ const defaultOptions: Options = {
 };
 ```
 
-## When Not To Use It
+This rule normally bans classes that are empty (have no constructor or fields).
+The rule's options each add an exemption for a specific type of class.
 
-You can disable this rule if you don’t have anyone who would make these kinds of mistakes on your
-team or if you use classes as namespaces.
+### `allowConstructorOnly`
 
-## Compatibility
+`allowConstructorOnly` adds an exemption for classes that have only a constructor and no fields.
 
-[`no-unnecessary-class`](https://palantir.github.io/tslint/rules/no-unnecessary-class/) from TSLint
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+class NoFields {}
+```
+
+#### ✅ Correct
+
+```ts
+class NoFields {
+  constructor() {
+    console.log('Hello, world!');
+  }
+}
+```
+
+### `allowEmpty`
+
+The `allowEmpty` option adds an exemption for classes that are entirely empty.
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+class NoFields {
+  constructor() {
+    console.log('Hello, world!');
+  }
+}
+```
+
+#### ✅ Correct
 
-## Attributes
+```ts
+class NoFields {}
+```
+
+### `allowStaticOnly`
+
+The `allowStaticOnly` option adds an exemption for classes that only contain static members.
+
+:::caution
+We strongly recommend against the `allowStaticOnly` exemption.
+It works against this rule's primary purpose of discouraging classes used only for static members.
+:::
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+class EmptyClass {}
+```
+
+#### ✅ Correct
+
+```ts
+class NotEmptyClass {
+  static version = 42;
+}
+```
+
+### `allowWithDecorator`
 
-- [ ] ✅ Recommended
-- [ ] 🔧 Fixable
-- [ ] 💭 Requires type information
+The `allowWithDecorator` option adds an exemption for classes that contain a member decorated with a `@` decorator.
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+class Constants {
+  static readonly version = 42;
+}
+```
+
+#### ✅ Correct
+
+```ts
+class Constants {
+  @logOnRead()
+  static readonly version = 42;
+}
+```
+
+## When Not To Use It
+
+You can disable this rule if you are unable -or unwilling- to switch off using classes as namespaces.
+
+## Related To
+
+[`no-unnecessary-class`](https://palantir.github.io/tslint/rules/no-unnecessary-class/) from TSLint

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-floating-promises.md

@@ -1,14 +1,30 @@
-# Requires Promise-like values to be handled appropriately (`no-floating-promises`)
+# `no-floating-promises`
 
-This rule forbids usage of Promise-like values in statements without handling
-their errors appropriately. Unhandled promises can cause several issues, such
-as improperly sequenced operations, ignored Promise rejections and more. Valid
-ways of handling a Promise-valued statement include `await`ing, returning, and
-either calling `.then()` with two arguments or `.catch()` with one argument.
+Requires Promise-like statements to be handled appropriately.
+
+A "floating" Promise is one that is created without any code set up to handle any errors it might throw.
+
+Floating Promises can cause several issues, such as improperly sequenced operations, ignored Promise rejections, and more.
+
+Valid ways of handling a Promise-valued statement include:
+
+- `await`ing it
+- `return`ing it
+- Calling its `.then()` with two arguments
+- Calling its `.catch()` with one argument
+
+:::tip
+`no-floating-promises` only detects unhandled Promise _statements_.
+See [`no-misused-promises`](./no-misused-promises.md) for detecting code that provides Promises to _logical_ locations such as if statements.
+:::
 
 ## Rule Details
 
-Examples of **incorrect** code for this rule:
+Examples of code for this rule:
+
+<!--tabs-->
+
+### ❌ Incorrect
 
 ```ts
 const promise = new Promise((resolve, reject) => resolve('value'));
@@ -24,7 +40,7 @@ Promise.reject('value').catch();
 Promise.reject('value').finally();
 ```
 
-Examples of **correct** code for this rule:
+### ✅ Correct
 
 ```ts
 const promise = new Promise((resolve, reject) => resolve('value'));
@@ -81,7 +97,7 @@ With this option set to `true`, and if you are using `no-void`, you should turn
 
 ### `ignoreIIFE`
 
-This allows you to skip checking of async iife
+This allows you to skip checking of async IIFEs (Immediately Invocated function Expressions).
 
 Examples of **correct** code for this rule with `{ ignoreIIFE: true }`:
 
@@ -99,12 +115,7 @@ await(async function () {
 
 If you do not use Promise-like values in your codebase, or want to allow them to remain unhandled.
 
-## Related to
+## Related To
 
+- [`no-misused-promises`](./no-misused-promises.md)
 - TSLint: ['no-floating-promises'](https://palantir.github.io/tslint/rules/no-floating-promises/)
-
-## Attributes
-
-- [x] ✅ Recommended
-- [ ] 🔧 Fixable
-- [x] 💭 Requires type information

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-for-in-array.md

@@ -1,4 +1,6 @@
-# Disallow iterating over an array with a for-in loop (`no-for-in-array`)
+# `no-for-in-array`
+
+Disallows iterating over an array with a for-in loop.
 
 This rule prohibits iterating over an array with a for-in loop.
 
@@ -19,7 +21,11 @@ for (const [index, value] of array.entries()) { ... }
 for (let i = 0; i < array.length; i++) { ... }
 ```
 
-Examples of **incorrect** code for this rule:
+Examples of code for this rule:
+
+<!--tabs-->
+
+### ❌ Incorrect
 
 ```js
 for (const x in [3, 4, 5]) {
@@ -27,7 +33,7 @@ for (const x in [3, 4, 5]) {
 }
 ```
 
-Examples of **correct** code for this rule:
+### ✅ Correct
 
 ```js
 for (const x in { a: 3, b: 4, c: 5 }) {
@@ -35,16 +41,23 @@ for (const x in { a: 3, b: 4, c: 5 }) {
 }
 ```
 
+## Options
+
+```jsonc
+// .eslintrc.json
+{
+  "rules": {
+    "@typescript-eslint/no-for-in-array": "error"
+  }
+}
+```
+
+This rule is not configurable.
+
 ## When Not To Use It
 
 If you want to iterate through a loop using the indices in an array as strings, you can turn off this rule.
 
-## Related to
+## Related To
 
 - TSLint: ['no-for-in-array'](https://palantir.github.io/tslint/rules/no-for-in-array/)
-
-## Attributes
-
-- [x] ✅ Recommended
-- [ ] 🔧 Fixable
-- [x] 💭 Requires type information

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-implicit-any-catch.md

@@ -1,16 +1,24 @@
-# Disallow usage of the implicit `any` type in catch clauses (`no-implicit-any-catch`)
+# `no-implicit-any-catch`
+
+Disallows usage of the implicit `any` type in catch clauses.
 
 TypeScript 4.0 added support for adding an explicit `any` or `unknown` type annotation on a catch clause variable.
 
 By default, TypeScript will type a catch clause variable as `any`, so explicitly annotating it as `unknown` can add a lot of safety to your codebase.
 
-The `noImplicitAny` flag in TypeScript does not cover this for backwards compatibility reasons.
+The `noImplicitAny` flag in TypeScript does not cover this for backwards compatibility reasons, however you can use `useUnknownInCatchVariables` (part of `strict`) instead of this rule.
+
+## DEPRECATED
 
 ## Rule Details
 
 This rule requires an explicit type to be declared on a catch clause variable.
 
-The following pattern is considered a warning:
+Examples of code for this rule:
+
+<!--tabs-->
+
+### ❌ Incorrect
 
 ```ts
 try {
@@ -20,7 +28,7 @@ try {
 }
 ```
 
-The following pattern is **_not_** considered a warning:
+### ✅ Correct
 
 <!-- TODO: prettier currently removes the type annotations, re-enable this once prettier is updated -->
 <!-- prettier-ignore-start -->
@@ -73,10 +81,4 @@ If you are not using TypeScript 4.0 (or greater), then you will not be able to u
 
 ## Further Reading
 
-- [TypeScript 4.0 Beta Release Notes](https://devblogs.microsoft.com/typescript/announcing-typescript-4-0-beta/#unknown-on-catch)
-
-## Attributes
-
-- [ ] ✅ Recommended
-- [x] 🔧 Fixable
-- [ ] 💭 Requires type information
+- [TypeScript 4.0 Release Notes](https://devblogs.microsoft.com/typescript/announcing-typescript-4-0/#unknown-on-catch)

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-implied-eval.md

@@ -1,4 +1,6 @@
-# Disallow the use of `eval()`-like methods (`no-implied-eval`)
+# `no-implied-eval`
+
+Disallows the use of `eval()`-like methods.
 
 It's considered a good practice to avoid using `eval()`. There are security and performance implications involved with doing so, which is why many linters recommend disallowing `eval()`. However, there are some other ways to pass a string and have it interpreted as JavaScript code that have similar concerns.
 
@@ -23,7 +25,11 @@ The best practice is to avoid using `new Function()` or `execScript()` and alway
 
 This rule aims to eliminate implied `eval()` through the use of `new Function()`, `setTimeout()`, `setInterval()`, `setImmediate()` or `execScript()`.
 
-Examples of **incorrect** code for this rule:
+Examples of code for this rule:
+
+<!--tabs-->
+
+### ❌ Incorrect
 
 ```ts
 /* eslint @typescript-eslint/no-implied-eval: "error" */
@@ -51,7 +57,7 @@ setTimeout(fn(), 100);
 const fn = new Function('a', 'b', 'return a + b');
 ```
 
-Examples of **correct** code for this rule:
+### ✅ Correct
 
 ```ts
 /* eslint @typescript-eslint/no-implied-eval: "error" */
@@ -88,7 +94,7 @@ class Foo {
 setTimeout(Foo.fn, 100);
 ```
 
-## How to use
+## How to Use
 
 ```jsonc
 {
@@ -102,10 +108,8 @@ setTimeout(Foo.fn, 100);
 
 If you want to allow `new Function()` or `setTimeout()`, `setInterval()`, `setImmediate()` and `execScript()` with string arguments, then you can safely disable this rule.
 
-<sup>Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/master/docs/rules/no-implied-eval.md)</sup>
+<sup>
 
-## Attributes
+Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/main/docs/rules/no-implied-eval.md)
 
-- [x] ✅ Recommended
-- [ ] 🔧 Fixable
-- [x] 💭 Requires type information
+</sup>