xo 0.52.4 → 0.53.1

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

@@ -6,40 +6,48 @@ description: 'Disallow iterating over an array with a for-in loop.'
 >
 > See **https://typescript-eslint.io/rules/no-for-in-array** for documentation.
 
-This rule prohibits iterating over an array with a for-in loop.
-
-## Rule Details
-
-A for-in loop (`for (var k in o)`) iterates over the properties of an Object.
+A for-in loop (`for (var i in o)`) iterates over the properties of an Object.
 While it is legal to use for-in loops with array types, it is not common.
 for-in will iterate over the indices of the array as strings, omitting any "holes" in
 the array.
-More common is to use for-of, which iterates over the values of an array.
-If you want to iterate over the indices, alternatives include:
 
-```js
-array.forEach((value, index) => { ... });
-for (const [index, value] of array.entries()) { ... }
-for (let i = 0; i < array.length; i++) { ... }
-```
-
-Examples of code for this rule:
+## Examples
 
 <!--tabs-->
 
 ### ❌ Incorrect
 
 ```js
-for (const x in [3, 4, 5]) {
-  console.log(x);
+declare const array: string[];
+
+for (const i in array) {
+  console.log(array[i]);
+}
+
+for (const i in array) {
+  console.log(i, array[i]);
 }
 ```
 
 ### ✅ Correct
 
 ```js
-for (const x in { a: 3, b: 4, c: 5 }) {
-  console.log(x);
+declare const array: string[];
+
+for (const value of array) {
+  console.log(value);
+}
+
+for (let i = 0; i < array.length; i += 1) {
+  console.log(i, array[i]);
+}
+
+array.forEach((value, i) => {
+  console.log(i, value);
+})
+
+for (const [i, value] of array.entries()) {
+  console.log(i, value);
 }
 ```
 

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

@@ -19,12 +19,10 @@ The `noImplicitAny` flag in TypeScript does not cover this for backwards compati
 
 ## DEPRECATED
 
-## Rule Details
+## Examples
 
 This rule requires an explicit type to be declared on a catch clause variable.
 
-Examples of code for this rule:
-
 <!--tabs-->
 
 ### ❌ Incorrect

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

@@ -25,12 +25,10 @@ passed in to be interpreted. The same can be done with `setInterval()`, `setImme
 
 The best practice is to avoid using `new Function()` or `execScript()` and always use a function for the first argument of `setTimeout()`, `setInterval()` and `setImmediate()`.
 
-## Rule Details
+## Examples
 
 This rule aims to eliminate implied `eval()` through the use of `new Function()`, `setTimeout()`, `setInterval()`, `setImmediate()` or `execScript()`.
 
-Examples of code for this rule:
-
 <!--tabs-->
 
 ### ❌ Incorrect

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-inferrable-types.md

@@ -6,14 +6,11 @@ description: 'Disallow explicit type declarations for variables or parameters in
 >
 > See **https://typescript-eslint.io/rules/no-inferrable-types** for documentation.
 
-Explicit types where they can be easily inferred may add unnecessary verbosity.
+TypeScript is able to infer the types of parameters, properties, and variables from their default or initial values.
+There is no need to use an explicit `:` type annotation on one of those constructs initialized to a boolean, number, or string.
+Doing so adds unnecessary verbosity to code -making it harder to read- and in some cases can prevent TypeScript from inferring a more specific literal type (e.g. `10`) instead of the more general primitive type (e.g. `number`)
 
-## Rule Details
-
-This rule disallows explicit type declarations on parameters, variables
-and properties where the type can be easily inferred from its value.
-
-Examples of code with the default options:
+## Examples
 
 <!--tabs-->
 
@@ -21,30 +18,17 @@ Examples of code with the default options:
 
 ```ts
 const a: bigint = 10n;
-const a: bigint = -10n;
 const a: bigint = BigInt(10);
-const a: bigint = -BigInt(10);
-const a: boolean = false;
-const a: boolean = true;
-const a: boolean = Boolean(null);
 const a: boolean = !0;
+const a: boolean = Boolean(null);
+const a: boolean = true;
+const a: null = null;
 const a: number = 10;
-const a: number = +10;
-const a: number = -10;
-const a: number = Number('1');
-const a: number = +Number('1');
-const a: number = -Number('1');
 const a: number = Infinity;
-const a: number = +Infinity;
-const a: number = -Infinity;
 const a: number = NaN;
-const a: number = +NaN;
-const a: number = -NaN;
-const a: null = null;
+const a: number = Number('1');
 const a: RegExp = /a/;
-const a: RegExp = RegExp('a');
 const a: RegExp = new RegExp('a');
-const a: string = 'str';
 const a: string = `str`;
 const a: string = String(1);
 const a: symbol = Symbol('a');
@@ -62,30 +46,17 @@ function fn(a: number = 5, b: boolean = true) {}
 
 ```ts
 const a = 10n;
-const a = -10n;
 const a = BigInt(10);
-const a = -BigInt(10);
-const a = false;
-const a = true;
-const a = Boolean(null);
 const a = !0;
+const a = Boolean(null);
+const a = true;
+const a = null;
 const a = 10;
-const a = +10;
-const a = -10;
-const a = Number('1');
-const a = +Number('1');
-const a = -Number('1');
 const a = Infinity;
-const a = +Infinity;
-const a = -Infinity;
 const a = NaN;
-const a = +NaN;
-const a = -NaN;
-const a = null;
+const a = Number('1');
 const a = /a/;
-const a = RegExp('a');
 const a = new RegExp('a');
-const a = 'str';
 const a = `str`;
 const a = String(1);
 const a = Symbol('a');
@@ -97,8 +68,6 @@ class Foo {
 }
 
 function fn(a = 5, b = true) {}
-
-function fn(a: number, b: boolean, c: string) {}
 ```
 
 <!--/tabs-->

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-invalid-this.md

@@ -6,7 +6,7 @@ description: 'Disallow `this` keywords outside of classes or class-like objects.
 >
 > See **https://typescript-eslint.io/rules/no-invalid-this** for documentation.
 
-## Rule Details
+## Examples
 
 This rule extends the base [`eslint/no-invalid-this`](https://eslint.org/docs/rules/no-invalid-this) rule.
 It adds support for TypeScript's `this` parameters.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-invalid-void-type.md

@@ -6,21 +6,14 @@ description: 'Disallow `void` type outside of generic or return types.'
 >
 > See **https://typescript-eslint.io/rules/no-invalid-void-type** for documentation.
 
-Disallows usage of `void` type outside of return types or generic type arguments.
-If `void` is used as return type, it shouldn’t be a part of intersection/union type with most other types.
+`void` in TypeScript refers to a function return that is meant to be ignored.
+Attempting to use a `void` type outside of a return type or generic type argument is often a sign of programmer error.
+`void` can also be misleading for other developers even if used correctly.
 
-## Rationale
+> The `void` type means cannot be mixed with any other types, other than `never`, which accepts all types.
+> If you think you need this then you probably want the `undefined` type instead.
 
-The `void` type means “nothing” or that a function does not return any value,
-in contrast with implicit `undefined` type which means that a function returns a value `undefined`.
-So “nothing” cannot be mixed with any other types, other than `never`, which accepts all types.
-If you need this - use the `undefined` type instead.
-
-## Rule Details
-
-This rule aims to ensure that the `void` type is only used in valid places.
-
-Examples of code for this rule:
+## Examples
 
 <!--tabs-->
 

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-loop-func.md

@@ -6,7 +6,7 @@ description: 'Disallow function declarations that contain unsafe references insi
 >
 > See **https://typescript-eslint.io/rules/no-loop-func** for documentation.
 
-## Rule Details
+## Examples
 
 This rule extends the base [`eslint/no-loop-func`](https://eslint.org/docs/rules/no-loop-func) rule.
 It adds support for TypeScript types.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-loss-of-precision.md

@@ -6,7 +6,7 @@ description: 'Disallow literal numbers that lose precision.'
 >
 > See **https://typescript-eslint.io/rules/no-loss-of-precision** for documentation.
 
-## Rule Details
+## Examples
 
 This rule extends the base [`eslint/no-loss-of-precision`](https://eslint.org/docs/rules/no-loss-of-precision) rule.
 It adds support for [numeric separators](https://github.com/tc39/proposal-numeric-separator).

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-magic-numbers.md

@@ -6,7 +6,7 @@ description: 'Disallow magic numbers.'
 >
 > See **https://typescript-eslint.io/rules/no-magic-numbers** for documentation.
 
-## Rule Details
+## Examples
 
 This rule extends the base [`eslint/no-magic-numbers`](https://eslint.org/docs/rules/no-magic-numbers) rule.
 It adds support for:

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-meaningless-void-operator.md

@@ -6,15 +6,15 @@ description: 'Disallow the `void` operator except when used to discard a value.'
 >
 > See **https://typescript-eslint.io/rules/no-meaningless-void-operator** for documentation.
 
-Disallows the `void` operator when its argument is already of type `void` or `undefined`.
+`void` in TypeScript refers to a function return that is meant to be ignored.
+The `void` operator is a useful tool to convey the programmer's intent to discard a value.
+For example, it is recommended as one way of suppressing [`@typescript-eslint/no-floating-promises`](./no-floating-promises.md) instead of adding `.catch()` to a promise.
 
-## Rule Details
+This rule helps an authors catch API changes where previously a value was being discarded at a call site, but the callee changed so it no longer returns a value.
+When combined with [no-unused-expressions](https://eslint.org/docs/rules/no-unused-expressions), it also helps _readers_ of the code by ensuring consistency: a statement that looks like `void foo();` is **always** discarding a return value, and a statement that looks like `foo();` is **never** discarding a return value.
+This rule reports on any `void` operator whose argument is already of type `void` or `undefined`.
 
-The `void` operator is a useful tool to convey the programmer's intent to discard a value. For example, it is recommended as one way of suppressing [`@typescript-eslint/no-floating-promises`](./no-floating-promises.md) instead of adding `.catch()` to a promise.
-
-This rule helps an author catch API changes where previously a value was being discarded at a call site, but the callee changed so it no longer returns a value. When combined with [no-unused-expressions](https://eslint.org/docs/rules/no-unused-expressions), it also helps _readers_ of the code by ensuring consistency: a statement that looks like `void foo();` is **always** discarding a return value, and a statement that looks like `foo();` is **never** discarding a return value.
-
-Examples of code for this rule:
+## Examples
 
 <!--tabs-->
 
@@ -44,17 +44,4 @@ void bar(); // discarding a number
 
 ## Options
 
-This rule accepts a single object option with the following default configuration:
-
-```json
-{
-  "@typescript-eslint/no-meaningless-void-operator": [
-    "error",
-    {
-      "checkNever": false
-    }
-  ]
-}
-```
-
-- `checkNever: true` will suggest removing `void` when the argument has type `never`.
+`checkNever: true` will suggest removing `void` when the argument has type `never`.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-misused-new.md

@@ -6,18 +6,20 @@ description: 'Enforce valid definition of `new` and `constructor`.'
 >
 > See **https://typescript-eslint.io/rules/no-misused-new** for documentation.
 
-Warns on apparent attempts to define constructors for interfaces or `new` for classes.
+JavaScript classes may define a `constructor` method that runs when a class instance is newly created.
+TypeScript allows interfaces that describe a static class object to define a `new()` method (though this is rarely used in real world code).
+Developers new to JavaScript classes and/or TypeScript interfaces may sometimes confuse when to use `constructor` or `new`.
 
-## Rule Details
+This rule reports when a class defines a method named `new` or an interface defines a method named `constructor`.
 
-Examples of code for this rule:
+## Examples
 
 <!--tabs-->
 
 ### ❌ Incorrect
 
 ```ts
-class C {
+declare class C {
   new(): C;
 }
 
@@ -30,10 +32,15 @@ interface I {
 ### ✅ Correct
 
 ```ts
-class C {
-  constructor() {}
+declare class C {
+  constructor();
 }
+
 interface I {
   new (): C;
 }
 ```
+
+## When Not To Use It
+
+If you intentionally want a class with a `new` method, and you're confident nobody working in your code will mistake it with a constructor.

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

@@ -15,40 +15,8 @@ functions are handled/awaited.
 See [`no-floating-promises`](./no-floating-promises.md) for detecting unhandled Promise _statements_.
 :::
 
-## Rule Details
-
-This rule accepts a single option which is an object with `checksConditionals`,
-`checksVoidReturn`, and `checksSpreads` properties indicating which types of
-misuse to flag. All are enabled by default.
-
 ## Options
 
-```ts
-type Options = [
-  {
-    checksConditionals?: boolean;
-    checksVoidReturn?: boolean | ChecksVoidReturnOptions;
-    checksSpreads?: boolean;
-  },
-];
-
-interface ChecksVoidReturnOptions {
-  arguments?: boolean;
-  attributes?: boolean;
-  properties?: boolean;
-  returns?: boolean;
-  variables?: boolean;
-}
-
-const defaultOptions: Options = [
-  {
-    checksConditionals: true,
-    checksVoidReturn: true,
-    checksSpreads: true,
-  },
-];
-```
-
 ### `"checksConditionals"`
 
 If you don't want to check conditionals, you can configure the rule with `"checksConditionals": false`:
@@ -66,6 +34,45 @@ If you don't want to check conditionals, you can configure the rule with `"check
 
 Doing so prevents the rule from looking at code like `if (somePromise)`.
 
+Examples of code for this rule with `checksConditionals: true`:
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+const promise = Promise.resolve('value');
+
+if (promise) {
+  // Do something
+}
+
+const val = promise ? 123 : 456;
+
+while (promise) {
+  // Do something
+}
+```
+
+#### ✅ Correct
+
+```ts
+const promise = Promise.resolve('value');
+
+// Always `await` the Promise in a conditional
+if (await promise) {
+  // Do something
+}
+
+const val = (await promise) ? 123 : 456;
+
+while (await promise) {
+  // Do something
+}
+```
+
+<!--/tabs-->
+
 ### `"checksVoidReturn"`
 
 Likewise, if you don't want functions that return promises where a void return is
@@ -107,64 +114,6 @@ For example, if you don't mind that passing a `() => Promise<void>` to a `() =>
 }
 ```
 
-### `"checksSpreads"`
-
-If you don't want to check object spreads, you can add this configuration:
-
-```json
-{
-  "@typescript-eslint/no-misused-promises": [
-    "error",
-    {
-      "checksSpreads": false
-    }
-  ]
-}
-```
-
-### `checksConditionals: true`
-
-Examples of code for this rule with `checksConditionals: true`:
-
-<!--tabs-->
-
-#### ❌ Incorrect
-
-```ts
-const promise = Promise.resolve('value');
-
-if (promise) {
-  // Do something
-}
-
-const val = promise ? 123 : 456;
-
-while (promise) {
-  // Do something
-}
-```
-
-#### ✅ Correct
-
-```ts
-const promise = Promise.resolve('value');
-
-// Always `await` the Promise in a conditional
-if (await promise) {
-  // Do something
-}
-
-const val = (await promise) ? 123 : 456;
-
-while (await promise) {
-  // Do something
-}
-```
-
-<!--/tabs-->
-
-### `checksVoidReturn: true`
-
 Examples of code for this rule with `checksVoidReturn: true`:
 
 <!--tabs-->
@@ -233,7 +182,20 @@ eventEmitter.on('some-event', () => {
 
 <!--/tabs-->
 
-### `checksSpreads: true`
+### `"checksSpreads"`
+
+If you don't want to check object spreads, you can add this configuration:
+
+```json
+{
+  "@typescript-eslint/no-misused-promises": [
+    "error",
+    {
+      "checksSpreads": false
+    }
+  ]
+}
+```
 
 Examples of code for this rule with `checksSpreads: true`:
 

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

@@ -1,19 +1,18 @@
 ---
-description: 'Disallow custom TypeScript modules and namespaces.'
+description: 'Disallow TypeScript namespaces.'
 ---
 
 > 🛑 This file is source code, not the primary documentation location! 🛑
 >
 > See **https://typescript-eslint.io/rules/no-namespace** for documentation.
 
-Custom TypeScript modules (`module foo {}`) and namespaces (`namespace foo {}`) are considered outdated
-ways to organize TypeScript code. ES2015 module syntax is now preferred (`import`/`export`).
+TypeScript historically allowed a form of code organization called "custom modules" (`module Example {}`), later renamed to "namespaces" (`namespace Example`).
+Namespaces are an outdated way to organize TypeScript code.
+ES2015 module syntax is now preferred (`import`/`export`).
 
-This rule still allows the use of TypeScript module declarations to describe external APIs (`declare module 'foo' {}`).
+> This rule does not report on the use of TypeScript module declarations to describe external APIs (`declare module 'foo' {}`).
 
-## Rule Details
-
-This rule aims to standardize the way modules are declared.
+## Examples
 
 Examples of code with the default options:
 

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-non-null-asserted-nullish-coalescing.md

@@ -6,20 +6,16 @@ description: 'Disallow non-null assertions in the left operand of a nullish coal
 >
 > See **https://typescript-eslint.io/rules/no-non-null-asserted-nullish-coalescing** for documentation.
 
-## Rule Details
+The `??` nullish coalescing runtime operator allows providing a default value when dealing with `null` or `undefined`.
+Using a `!` non-null assertion type operator in the left operand of a nullish coalescing operator is redundant, and likely a sign of programmer error or confusion over the two operators.
 
-The nullish coalescing operator is designed to provide a default value when dealing with `null` or `undefined`.
-Using non-null assertions in the left operand of the nullish coalescing operator is redundant.
-
-Examples of code for this rule:
+## Examples
 
 <!--tabs-->
 
 ### ❌ Incorrect
 
 ```ts
-/* eslint @typescript-eslint/no-non-null-asserted-nullish-coalescing: "error" */
-
 foo! ?? bar;
 foo.bazz! ?? bar;
 foo!.bazz! ?? bar;
@@ -36,8 +32,6 @@ x! ?? '';
 ### ✅ Correct
 
 ```ts
-/* eslint @typescript-eslint/no-non-null-asserted-nullish-coalescing: "error" */
-
 foo ?? bar;
 foo ?? bar!;
 foo!.bazz ?? bar;
@@ -49,10 +43,6 @@ let x: string;
 x! ?? '';
 ```
 
-## When Not To Use It
-
-If you are not using TypeScript 3.7 (or greater), then you will not need to use this rule, as the nullish coalescing operator is not supported.
-
 ## Further Reading
 
 - [TypeScript 3.7 Release Notes](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html)

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-non-null-asserted-optional-chain.md

@@ -6,52 +6,29 @@ description: 'Disallow non-null assertions after an optional chain expression.'
 >
 > See **https://typescript-eslint.io/rules/no-non-null-asserted-optional-chain** for documentation.
 
-## Rule Details
+`?.` optional chain expressions provide `undefined` if an object is `null` or `undefined`.
+Using a `!` non-null assertion to assert the result of an `?.` optional chain expression is non-nullable is likely wrong.
 
-Optional chain expressions are designed to return `undefined` if the optional property is nullish.
-Using non-null assertions after an optional chain expression is wrong, and introduces a serious type safety hole into your code.
+> Most of the time, either the object was not nullable and did not need the `?.` for its property lookup, or the `!` is incorrect and introducing a type safety hole.
 
-Examples of code for this rule:
+## Examples
 
 <!--tabs-->
 
 ### ❌ Incorrect
 
 ```ts
-/* eslint @typescript-eslint/no-non-null-asserted-optional-chain: "error" */
-
 foo?.bar!;
 foo?.bar()!;
-
-// Prior to TS3.9, foo?.bar!.baz meant (foo?.bar).baz - i.e. the non-null assertion is applied to the entire chain so far.
-// For TS3.9 and greater, the non-null assertion is only applied to the property itself, so it's safe.
-// The following is incorrect code if you're using less than TS3.9
-foo?.bar!.baz;
-foo?.bar!();
-foo?.bar!().baz;
 ```
 
 ### ✅ Correct
 
 ```ts
-/* eslint @typescript-eslint/no-non-null-asserted-optional-chain: "error" */
-
 foo?.bar;
-(foo?.bar).baz;
-foo?.bar();
 foo?.bar();
-foo?.bar().baz;
-
-// The following is correct code if you're using TS3.9 or greater
-foo?.bar!.baz;
-foo?.bar!();
-foo?.bar!().baz;
 ```
 
-## When Not To Use It
-
-If you are not using TypeScript 3.7 (or greater), then you will not need to use this rule, as the operator is not supported.
-
 ## Further Reading
 
 - [TypeScript 3.7 Release Notes](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html)