xo 0.48.0 → 0.51.0

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

@@ -1,15 +1,22 @@
 # `no-extraneous-class`
 
-Forbids the use of classes as namespaces.
+Disallows classes used as namespaces.
 
-This rule warns when a class is accidentally used as a namespace.
+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.
 
-> 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.
+- 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.
 
 Examples of code for this rule:
 
@@ -18,18 +25,16 @@ Examples of code for this rule:
 ### ❌ 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!');
   }
 }
@@ -38,18 +43,151 @@ class StaticOnly {
 ### ✅ Correct
 
 ```ts
-class EmptyClass extends SuperClass {}
+export const version = 42;
 
-class ParameterProperties {
-  constructor(public name: string) {}
+export function isProduction() {
+  return process.env.NODE_ENV === 'production';
 }
 
-const StaticOnly = {
-  version: 42,
-  hello() {
+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)
+
+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
@@ -76,17 +214,101 @@ 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.
+
+### `allowConstructorOnly`
+
+`allowConstructorOnly` adds an exemption for classes that have only a constructor and no fields.
+
+<!--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
+
+```ts
+class NoFields {}
+```
+
+### `allowStaticOnly`
+
+The `allowStaticOnly` option adds an exemption for classes that only contain static members.
 
-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.
+:::caution
+We strongly recommend against the `allowStaticOnly` exemption.
+It works against this rule's primary purpose of discouraging classes used only for static members.
+:::
 
-## Related To
+<!--tabs-->
+
+#### ❌ Incorrect
 
-[`no-unnecessary-class`](https://palantir.github.io/tslint/rules/no-unnecessary-class/) from TSLint
+```ts
+class EmptyClass {}
+```
 
-## Attributes
+#### ✅ Correct
+
+```ts
+class NotEmptyClass {
+  static version = 42;
+}
+```
+
+### `allowWithDecorator`
+
+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
 
-- [ ] ✅ Recommended
-- [ ] 🔧 Fixable
-- [ ] 💭 Requires type information
+You can disable this rule if you are unable -or unwilling- to switch off using classes as namespaces.

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

@@ -1,12 +1,22 @@
 # `no-floating-promises`
 
-Requires Promise-like values to be handled appropriately.
+Requires Promise-like statements to be handled appropriately.
 
-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.
+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
 
@@ -87,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 }`:
 
@@ -107,10 +117,4 @@ If you do not use Promise-like values in your codebase, or want to allow them to
 
 ## Related To
 
-- TSLint: ['no-floating-promises'](https://palantir.github.io/tslint/rules/no-floating-promises/)
-
-## Attributes
-
-- [x] ✅ Recommended
-- [ ] 🔧 Fixable
-- [x] 💭 Requires type information
+- [`no-misused-promises`](./no-misused-promises.md)

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

@@ -1,13 +1,11 @@
 # `no-for-in-array`
 
-Disallow iterating over an array with a for-in loop.
+Disallows iterating over an array with a for-in loop.
 
 This rule prohibits iterating over an array with a for-in loop.
 
 ## Rule Details
 
-Rationale from TSLint:
-
 A for-in loop (`for (var k 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
@@ -57,13 +55,3 @@ 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
-
-- 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,6 +1,6 @@
 # `no-implicit-any-catch`
 
-Disallow usage of the implicit `any` type in catch clauses.
+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.
 
@@ -8,6 +8,8 @@ By default, TypeScript will type a catch clause variable as `any`, so explicitly
 
 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.
@@ -80,9 +82,3 @@ If you are not using TypeScript 4.0 (or greater), then you will not be able to u
 ## Further Reading
 
 - [TypeScript 4.0 Release Notes](https://devblogs.microsoft.com/typescript/announcing-typescript-4-0/#unknown-on-catch)
-
-## Attributes
-
-- [ ] ✅ Recommended
-- [x] 🔧 Fixable
-- [ ] 💭 Requires type information

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

@@ -1,6 +1,6 @@
 # `no-implied-eval`
 
-Disallow the use of `eval()`-like methods.
+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.
 
@@ -113,9 +113,3 @@ If you want to allow `new Function()` or `setTimeout()`, `setInterval()`, `setIm
 Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/main/docs/rules/no-implied-eval.md)
 
 </sup>
-
-## Attributes
-
-- [x] ✅ Recommended
-- [ ] 🔧 Fixable
-- [x] 💭 Requires type information

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

@@ -148,13 +148,3 @@ If you do not want to enforce inferred types.
 ## Further Reading
 
 TypeScript [Inference](https://www.typescriptlang.org/docs/handbook/type-inference.html)
-
-## Related To
-
-TSLint: [no-inferrable-types](https://palantir.github.io/tslint/rules/no-inferrable-types/)
-
-## Attributes
-
-- [x] ✅ Recommended
-- [x] 🔧 Fixable
-- [ ] 💭 Requires type information

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

@@ -1,6 +1,6 @@
 # `no-invalid-this`
 
-Disallow `this` keywords outside of classes or class-like objects.
+Disallows `this` keywords outside of classes or class-like objects.
 
 ## Rule Details
 
@@ -30,9 +30,3 @@ When you are indifferent as to how your variables are initialized.
 Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/main/docs/rules/no-invalid-this.md)
 
 </sup>
-
-## Attributes
-
-- [ ] ✅ Recommended
-- [ ] 🔧 Fixable
-- [ ] 💭 Requires type information

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

@@ -1,6 +1,6 @@
 # `no-invalid-void-type`
 
-Disallows usage of `void` type outside of generic or return types.
+Disallows `void` type outside of generic or return types.
 
 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.
@@ -126,13 +126,3 @@ class Example {
 
 If you don't care about if `void` is used with other types,
 or in invalid places, then you don't need this rule.
-
-## Related To
-
-- TSLint: [invalid-void](https://palantir.github.io/tslint/rules/invalid-void/)
-
-## Attributes
-
-- [ ] ✅ Recommended
-- [ ] 🔧 Fixable
-- [ ] 💭 Requires type information

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

@@ -1,6 +1,6 @@
 # `no-loop-func`
 
-Disallow function declarations that contain unsafe references inside loop statements.
+Disallows function declarations that contain unsafe references inside loop statements.
 
 ## Rule Details
 
@@ -26,9 +26,3 @@ See [`eslint/no-loop-func` options](https://eslint.org/docs/rules/no-loop-func#o
 Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/main/docs/rules/no-loop-func.md)
 
 </sup>
-
-## Attributes
-
-- [ ] ✅ Recommended
-- [ ] 🔧 Fixable
-- [ ] 💭 Requires type information

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

@@ -1,6 +1,6 @@
 # `no-loss-of-precision`
 
-Disallow literal numbers that lose precision.
+Disallows literal numbers that lose precision.
 
 ## Rule Details
 
@@ -23,9 +23,3 @@ Note that this rule requires ESLint v7.
 Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/main/docs/rules/no-loss-of-precision.md)
 
 </sup>
-
-## Attributes
-
-- [x] ✅ Recommended
-- [ ] 🔧 Fixable
-- [ ] 💭 Requires type information

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

@@ -1,6 +1,6 @@
 # `no-magic-numbers`
 
-Disallow magic numbers.
+Disallows magic numbers.
 
 ## Rule Details
 
@@ -36,6 +36,7 @@ interface Options extends BaseNoMagicNumbersOptions {
   ignoreEnums?: boolean;
   ignoreNumericLiteralTypes?: boolean;
   ignoreReadonlyClassProperties?: boolean;
+  ignoreTypeIndexes?: boolean;
 }
 
 const defaultOptions: Options = {
@@ -43,6 +44,7 @@ const defaultOptions: Options = {
   ignoreEnums: false,
   ignoreNumericLiteralTypes: false,
   ignoreReadonlyClassProperties: false,
+  ignoreTypeIndexes: false,
 };
 ```
 
@@ -118,14 +120,30 @@ class Foo {
 }
 ```
 
+### `ignoreTypeIndexes`
+
+A boolean to specify if numbers used to index types are okay. `false` by default.
+
+Examples of **incorrect** code for the `{ "ignoreTypeIndexes": false }` option:
+
+```ts
+/*eslint @typescript-eslint/no-magic-numbers: ["error", { "ignoreTypeIndexes": false }]*/
+
+type Foo = Bar[0];
+type Baz = Parameters<Foo>[2];
+```
+
+Examples of **correct** code for the `{ "ignoreTypeIndexes": true }` option:
+
+```ts
+/*eslint @typescript-eslint/no-magic-numbers: ["error", { "ignoreTypeIndexes": true }]*/
+
+type Foo = Bar[0];
+type Baz = Parameters<Foo>[2];
+```
+
 <sup>
 
 Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/main/docs/rules/no-magic-numbers.md)
 
 </sup>
-
-## Attributes
-
-- [ ] ✅ Recommended
-- [ ] 🔧 Fixable
-- [ ] 💭 Requires type information

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

@@ -1,8 +1,8 @@
 # `no-meaningless-void-operator`
 
-Disallow the `void` operator except when used to discard a value.
+Disallows the `void` operator except when used to discard a value.
 
-Disallow the `void` operator when its argument is already of type `void` or `undefined`.
+Disallows the `void` operator when its argument is already of type `void` or `undefined`.
 
 ## Rule Details
 
@@ -54,9 +54,3 @@ This rule accepts a single object option with the following default configuratio
 ```
 
 - `checkNever: true` will suggest removing `void` when the argument has type `never`.
-
-## Attributes
-
-- [ ] ✅ Recommended
-- [x] 🔧 Fixable
-- [x] 💭 Requires type information

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

@@ -1,6 +1,6 @@
 # `no-misused-new`
 
-Enforce valid definition of `new` and `constructor`.
+Enforces valid definition of `new` and `constructor`.
 
 Warns on apparent attempts to define constructors for interfaces or `new` for classes.
 
@@ -46,13 +46,3 @@ interface I {
 ```
 
 This rule is not configurable.
-
-## Related To
-
-- TSLint: [no-misused-new](https://palantir.github.io/tslint/rules/no-misused-new/)
-
-## Attributes
-
-- [x] ✅ Recommended
-- [ ] 🔧 Fixable
-- [ ] 💭 Requires type information