xo 0.49.0 → 0.50.0

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

@@ -1,6 +1,6 @@
 # `no-explicit-any`
 
-Disallow usage of the `any` type.
+Disallows the `any` type.
 
 Using the `any` type defeats the purpose of using TypeScript.
 When `any` is used, all compiler type checks around that value are ignored.
@@ -183,11 +183,3 @@ and you want to be able to specify `any`.
 ## Related To
 
 - TSLint: [no-any](https://palantir.github.io/tslint/rules/no-any/)
-
-## Attributes
-
-- Configs:
-  - [x] ✅ Recommended
-  - [x] 🔒 Strict
-- [x] 🔧 Fixable
-- [ ] 💭 Requires type information

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

@@ -1,6 +1,6 @@
 # `no-extra-non-null-assertion`
 
-Disallow extra non-null assertion.
+Disallows extra non-null assertion.
 
 ## Rule Details
 
@@ -58,11 +58,3 @@ function foo(bar?: { n: number }) {
 ```
 
 This rule is not configurable.
-
-## Attributes
-
-- Configs:
-  - [x] ✅ Recommended
-  - [x] 🔒 Strict
-- [x] 🔧 Fixable
-- [ ] 💭 Requires type information

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

@@ -1,6 +1,6 @@
 # `no-extra-parens`
 
-Disallow unnecessary parentheses.
+Disallows unnecessary parentheses.
 
 ## Rule Details
 
@@ -26,11 +26,3 @@ See [`eslint/no-extra-parens` options](https://eslint.org/docs/rules/no-extra-pa
 Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/main/docs/rules/no-extra-parens.md)
 
 </sup>
-
-## Attributes
-
-- Configs:
-  - [ ] ✅ Recommended
-  - [ ] 🔒 Strict
-- [x] 🔧 Fixable
-- [ ] 💭 Requires type information

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

@@ -1,6 +1,6 @@
 # `no-extra-semi`
 
-Disallow unnecessary semicolons.
+Disallows unnecessary semicolons.
 
 ## Rule Details
 
@@ -26,11 +26,3 @@ See [`eslint/no-extra-semi` options](https://eslint.org/docs/rules/no-extra-semi
 Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/main/docs/rules/no-extra-semi.md)
 
 </sup>
-
-## Attributes
-
-- Configs:
-  - [x] ✅ Recommended
-  - [x] 🔒 Strict
-- [x] 🔧 Fixable
-- [ ] 💭 Requires type information

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;
+
+export function isProduction() {
+  return process.env.NODE_ENV === 'production';
+}
+
+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();
+}
 
-class ParameterProperties {
-  constructor(public name: string) {}
+export function util2() {
+  /* ... */
 }
 
-const StaticOnly = {
-  version: 42,
-  hello() {
+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,19 +214,105 @@ const defaultOptions: Options = {
 };
 ```
 
+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.
+
+:::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`
+
+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 don’t have anyone who would make these kinds of mistakes on your
-team or if you use classes as namespaces.
+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
-
-## Attributes
-
-- Configs:
-  - [ ] ✅ Recommended
-  - [x] 🔒 Strict
-- [ ] 🔧 Fixable
-- [ ] 💭 Requires type information

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

@@ -119,11 +119,3 @@ If you do not use Promise-like values in your codebase, or want to allow them to
 
 - [`no-misused-promises`](./no-misused-promises.md)
 - TSLint: ['no-floating-promises'](https://palantir.github.io/tslint/rules/no-floating-promises/)
-
-## Attributes
-
-- Configs:
-  - [x] ✅ Recommended
-  - [x] 🔒 Strict
-- [ ] 🔧 Fixable
-- [x] 💭 Requires type information

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

@@ -1,6 +1,6 @@
 # `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.
 
@@ -61,11 +61,3 @@ If you want to iterate through a loop using the indices in an array as strings,
 ## Related To
 
 - TSLint: ['no-for-in-array'](https://palantir.github.io/tslint/rules/no-for-in-array/)
-
-## Attributes
-
-- Configs:
-  - [x] ✅ Recommended
-  - [x] 🔒 Strict
-- [ ] 🔧 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,11 +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
-
-- Configs:
-  - [ ] ✅ Recommended
-  - [ ] 🔒 Strict
-- [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,11 +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
-
-- Configs:
-  - [x] ✅ Recommended
-  - [x] 🔒 Strict
-- [ ] 🔧 Fixable
-- [x] 💭 Requires type information

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

@@ -152,11 +152,3 @@ TypeScript [Inference](https://www.typescriptlang.org/docs/handbook/type-inferen
 ## Related To
 
 TSLint: [no-inferrable-types](https://palantir.github.io/tslint/rules/no-inferrable-types/)
-
-## Attributes
-
-- Configs:
-  - [x] ✅ Recommended
-  - [x] 🔒 Strict
-- [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,11 +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
-
-- Configs:
-  - [ ] ✅ Recommended
-  - [ ] 🔒 Strict
-- [ ] 🔧 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.
@@ -130,11 +130,3 @@ 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
-
-- Configs:
-  - [ ] ✅ Recommended
-  - [x] 🔒 Strict
-- [ ] 🔧 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,11 +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
-
-- Configs:
-  - [ ] ✅ Recommended
-  - [ ] 🔒 Strict
-- [ ] 🔧 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,11 +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
-
-- Configs:
-  - [x] ✅ Recommended
-  - [x] 🔒 Strict
-- [ ] 🔧 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
 
@@ -147,11 +147,3 @@ type Baz = Parameters<Foo>[2];
 Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/main/docs/rules/no-magic-numbers.md)
 
 </sup>
-
-## Attributes
-
-- Configs:
-  - [ ] ✅ Recommended
-  - [ ] 🔒 Strict
-- [ ] 🔧 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,11 +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
-
-- Configs:
-  - [ ] ✅ Recommended
-  - [x] 🔒 Strict
-- [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.
 
@@ -50,11 +50,3 @@ This rule is not configurable.
 ## Related To
 
 - TSLint: [no-misused-new](https://palantir.github.io/tslint/rules/no-misused-new/)
-
-## Attributes
-
-- Configs:
-  - [x] ✅ Recommended
-  - [x] 🔒 Strict
-- [ ] 🔧 Fixable
-- [ ] 💭 Requires type information