xo 0.48.0 → 0.51.0

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

@@ -1,17 +1,21 @@
 # `no-misused-promises`
 
-Avoid using promises in places not designed to handle them.
+Disallows Promises in places not designed to handle them.
 
-This rule forbids using promises in places where the TypeScript compiler
-allows them but they are not handled properly. These situations can often arise
-due to a missing `await` keyword or just a misunderstanding of the way async
+This rule forbids providing Promises to logical locations such as if statements in places where the TypeScript compiler allows them but they are not handled properly.
+These situations can often arise due to a missing `await` keyword or just a misunderstanding of the way async
 functions are handled/awaited.
 
+:::tip
+`no-misused-promises` only detects code that provides Promises to incorrect _logical_ locations.
+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`
-and `checksVoidReturn` properties indicating which types of misuse to flag.
-Both are enabled by default
+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
 
@@ -19,19 +23,48 @@ Both are enabled by default
 type Options = [
   {
     checksConditionals?: boolean;
-    checksVoidReturn?: 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,
   },
 ];
 ```
 
-If you don't want functions that return promises where a void return is
+### `"checksConditionals"`
+
+If you don't want to check conditionals, you can configure the rule with `"checksConditionals": false`:
+
+```json
+{
+  "@typescript-eslint/no-misused-promises": [
+    "error",
+    {
+      "checksConditionals": false
+    }
+  ]
+}
+```
+
+Doing so prevents the rule from looking at code like `if (somePromise)`.
+
+### `"checksVoidReturn"`
+
+Likewise, if you don't want functions that return promises where a void return is
 expected to be checked, your configuration will look like this:
 
 ```json
@@ -45,15 +78,41 @@ expected to be checked, your configuration will look like this:
 }
 ```
 
-Likewise, if you don't want to check conditionals, you can configure the rule
-like this:
+You can disable selective parts of the `checksVoidReturn` option by providing an object that disables specific checks.
+The following options are supported:
+
+- `arguments`: Disables checking an asynchronous function passed as argument where the parameter type expects a function that returns `void`
+- `attributes`: Disables checking an asynchronous function passed as a JSX attribute expected to be a function that returns `void`
+- `properties`: Disables checking an asynchronous function passed as an object property expected to be a function that returns `void`
+- `returns`: Disables checking an asynchronous function returned in a function whose return type is a function that returns `void`
+- `variables`: Disables checking an asynchronous function used as a variable whose return type is a function that returns `void`
+
+For example, if you don't mind that passing a `() => Promise<void>` to a `() => void` parameter or JSX attribute can lead to a floating unhandled Promise:
 
 ```json
 {
   "@typescript-eslint/no-misused-promises": [
     "error",
     {
-      "checksConditionals": false
+      "checksVoidReturn": {
+        "arguments": false,
+        "attributes": false
+      }
+    }
+  ]
+}
+```
+
+### `"checksSpreads"`
+
+If you don't want to check object spreads, you can add this configuration:
+
+```json
+{
+  "@typescript-eslint/no-misused-promises": [
+    "error",
+    {
+      "checksSpreads": false
     }
   ]
 }
@@ -170,6 +229,42 @@ eventEmitter.on('some-event', () => {
 
 <!--/tabs-->
 
+### `checksSpreads: true`
+
+Examples of code for this rule with `checksSpreads: true`:
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+const getData = () => someAsyncOperation({ myArg: 'foo' });
+
+return { foo: 42, ...getData() };
+
+const getData2 = async () => {
+  await someAsyncOperation({ myArg: 'foo' });
+};
+
+return { foo: 42, ...getData2() };
+```
+
+#### ✅ Correct
+
+```ts
+const getData = () => someAsyncOperation({ myArg: 'foo' });
+
+return { foo: 42, ...(await getData()) };
+
+const getData2 = async () => {
+  await someAsyncOperation({ myArg: 'foo' });
+};
+
+return { foo: 42, ...(await getData2()) };
+```
+
+<!--tabs-->
+
 ## When Not To Use It
 
 If you do not use Promises in your codebase or are not concerned with possible
@@ -182,9 +277,3 @@ misuses of them outside of what the TypeScript compiler will check.
 ## Related To
 
 - [`no-floating-promises`](./no-floating-promises.md)
-
-## Attributes
-
-- [x] ✅ Recommended
-- [ ] 🔧 Fixable
-- [x] 💭 Requires type information

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

@@ -1,6 +1,6 @@
 # `no-namespace`
 
-Disallow the use of custom TypeScript modules and namespaces.
+Disallows custom TypeScript modules and namespaces.
 
 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`).
@@ -131,13 +131,3 @@ If you are using the ES2015 module syntax, then you will not need this rule.
 - [Modules](https://www.typescriptlang.org/docs/handbook/modules.html)
 - [Namespaces](https://www.typescriptlang.org/docs/handbook/namespaces.html)
 - [Namespaces and Modules](https://www.typescriptlang.org/docs/handbook/namespaces-and-modules.html)
-
-## Related To
-
-- TSLint: [no-namespace](https://palantir.github.io/tslint/rules/no-namespace/)
-
-## Attributes
-
-- [x] ✅ Recommended
-- [ ] 🔧 Fixable
-- [ ] 💭 Requires type information

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

@@ -1,6 +1,6 @@
 # `no-non-null-asserted-nullish-coalescing`
 
-Disallows using a non-null assertion in the left operand of the nullish coalescing operator.
+Disallows non-null assertions in the left operand of a nullish coalescing operator.
 
 ## Rule Details
 
@@ -45,6 +45,19 @@ let x: string;
 x! ?? '';
 ```
 
+## Options
+
+```jsonc
+// .eslintrc.json
+{
+  "rules": {
+    "@typescript-eslint/no-non-null-asserted-nullish-coalescing": "warn"
+  }
+}
+```
+
+This rule is not configurable.
+
 ## 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.
@@ -53,9 +66,3 @@ If you are not using TypeScript 3.7 (or greater), then you will not need to use
 
 - [TypeScript 3.7 Release Notes](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html)
 - [Nullish Coalescing Proposal](https://github.com/tc39/proposal-nullish-coalescing)
-
-## Attributes
-
-- [ ] ✅ Recommended
-- [ ] 🔧 Fixable
-- [ ] 💭 Requires type information

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

@@ -1,6 +1,6 @@
 # `no-non-null-asserted-optional-chain`
 
-Disallows using a non-null assertion after an optional chain expression.
+Disallows non-null assertions after an optional chain expression.
 
 ## Rule Details
 
@@ -65,9 +65,3 @@ If you are not using TypeScript 3.7 (or greater), then you will not need to use
 
 - [TypeScript 3.7 Release Notes](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html)
 - [Optional Chaining Proposal](https://github.com/tc39/proposal-optional-chaining/)
-
-## Attributes
-
-- [x] ✅ Recommended
-- [ ] 🔧 Fixable
-- [ ] 💭 Requires type information

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

@@ -48,13 +48,3 @@ This rule is not configurable.
 ## When Not To Use It
 
 If you don't care about strict null-checking, then you will not need this rule.
-
-## Further Reading
-
-- [`no-non-null-assertion`](https://palantir.github.io/tslint/rules/no-non-null-assertion/) in [TSLint](https://palantir.github.io/tslint/)
-
-## Attributes
-
-- [x] ✅ Recommended
-- [ ] 🔧 Fixable
-- [ ] 💭 Requires type information

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

@@ -1,6 +1,6 @@
 # `no-parameter-properties`
 
-Disallow the use of parameter properties in class constructors.
+Disallows the use of parameter properties in class constructors.
 
 Parameter properties can be confusing to those new to TypeScript as they are less explicit than other ways
 of declaring and initializing class members.
@@ -395,13 +395,3 @@ class Foo {
 ## When Not To Use It
 
 If you don't care about the using parameter properties in constructors, then you will not need this rule.
-
-## Related To
-
-- TSLint: [no-parameter-properties](https://palantir.github.io/tslint/rules/no-parameter-properties/)
-
-## Attributes
-
-- [ ] ✅ Recommended
-- [ ] 🔧 Fixable
-- [ ] 💭 Requires type information

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

@@ -1,6 +1,6 @@
 # `no-redeclare`
 
-Disallow variable redeclaration.
+Disallows variable redeclaration.
 
 ## Rule Details
 
@@ -84,9 +84,3 @@ const something = 2;
 Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/main/docs/rules/no-redeclare.md)
 
 </sup>
-
-## Attributes
-
-- [ ] ✅ Recommended
-- [ ] 🔧 Fixable
-- [ ] 💭 Requires type information

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-redundant-type-constituents.md

@@ -0,0 +1,92 @@
+# `no-redundant-type-constituents`
+
+Disallows members of unions and intersections that do nothing or override type information.
+
+## Rule Details
+
+Some types can override some other types ("constituents") in a union or intersection and/or be overridden by some other types.
+TypeScript's set theory of types includes cases where a constituent type might be useless in the parent union or intersection.
+
+Within `|` unions:
+
+- `any` and `unknown` "override" all other union members
+- `never` is dropped from unions in any position except when in a return type position
+- primitive types such as `string` "override" any of their literal types such as `""`
+
+Within `&` intersections:
+
+- `any` and `never` "override" all other intersection members
+- `unknown` is dropped from intersections
+- literal types "override" any primitive types in an intersection
+- literal types such as `""` "override" any of their primitive types such as `string`
+
+Examples of code for this rule:
+
+<!--tabs-->
+
+### ❌ Incorrect
+
+```ts
+type UnionAny = any | 'foo';
+type UnionUnknown = unknown | 'foo';
+type UnionNever = never | 'foo';
+
+type UnionBooleanLiteral = boolean | false;
+type UnionNumberLiteral = number | 1;
+type UnionStringLiteral = string | 'foo';
+
+type IntersectionAny = any & 'foo';
+type IntersectionUnknown = string & unknown;
+type IntersectionNever = string | never;
+
+type IntersectionBooleanLiteral = boolean & false;
+type IntersectionNumberLiteral = number & 1;
+type IntersectionStringLiteral = string & 'foo';
+```
+
+### ✅ Correct
+
+```ts
+type UnionAny = any;
+type UnionUnknown = unknown;
+type UnionNever = never;
+
+type UnionBooleanLiteral = boolean;
+type UnionNumberLiteral = number;
+type UnionStringLiteral = string;
+
+type IntersectionAny = any;
+type IntersectionUnknown = string;
+type IntersectionNever = string;
+
+type IntersectionBooleanLiteral = false;
+type IntersectionNumberLiteral = 1;
+type IntersectionStringLiteral = 'foo';
+
+type ReturnUnionNever = () => string | never;
+```
+
+## Options
+
+```jsonc
+// .eslintrc.json
+{
+  "rules": {
+    "@typescript-eslint/no-redundant-type-constituents": "warn"
+  }
+}
+```
+
+This rule is not configurable.
+
+## Limitations
+
+This rule plays it safe and only works with bottom types, top types, and comparing literal types to primitive types.
+It also does not provide an auto-fixer just yet.
+
+## Further Reading
+
+- [Union Types](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#union-types)
+- [Intersection Types](https://www.typescriptlang.org/docs/handbook/2/objects.html#intersection-types)
+- [Bottom Types](https://en.wikipedia.org/wiki/Bottom_type)
+- [Top Types](https://en.wikipedia.org/wiki/Top_type)

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

@@ -31,16 +31,19 @@ import lib9 = lib2.anotherSubImport;
 import lib10 from 'lib10';
 ```
 
-## When Not To Use It
-
-If you don't care about TypeScript module syntax, then you will not need this rule.
-
-## Related To
+## Options
+
+```jsonc
+// .eslintrc.json
+{
+  "rules": {
+    "@typescript-eslint/no-require-imports": "warn"
+  }
+}
+```
 
-- TSLint: [no-require-imports](https://palantir.github.io/tslint/rules/no-require-imports/)
+This rule is not configurable.
 
-## Attributes
+## When Not To Use It
 
-- [ ] ✅ Recommended
-- [ ] 🔧 Fixable
-- [ ] 💭 Requires type information
+If you don't care about TypeScript module syntax, then you will not need this rule.

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

@@ -1,6 +1,6 @@
 # `no-restricted-imports`
 
-Disallow specified modules when loaded by `import`.
+Disallows specified modules when loaded by `import`.
 
 ## Rule Details
 
@@ -68,9 +68,3 @@ export type { Foo } from 'import-foo';
 import type baz from 'import-baz';
 export type { Baz } from 'import-baz';
 ```
-
-## Attributes
-
-- [ ] ✅ Recommended
-- [ ] 🔧 Fixable
-- [ ] 💭 Requires type information

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

@@ -1,6 +1,6 @@
 # `no-shadow`
 
-Disallow variable declarations from shadowing variables declared in the outer scope.
+Disallows variable declarations from shadowing variables declared in the outer scope.
 
 ## Rule Details
 
@@ -91,9 +91,3 @@ type Func = (test: string) => typeof test;
 Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/main/docs/rules/no-shadow.md)
 
 </sup>
-
-## Attributes
-
-- [ ] ✅ Recommended
-- [ ] 🔧 Fixable
-- [ ] 💭 Requires type information

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

@@ -1,33 +1,31 @@
 # `no-this-alias`
 
-Disallow aliasing `this`.
+Disallows aliasing `this`.
 
 This rule prohibits assigning variables to `this`.
 
 ## Rule Details
 
-Rationale from TSLint:
+Assigning a variable to `this` instead of properly using arrow lambdas may be a symptom of pre-ES6 practices
+or not managing scope well.
 
-> Assigning a variable to `this` instead of properly using arrow lambdas may be a symptom of pre-ES6 practices
-> or not managing scope well.
->
-> Instead of storing a reference to `this` and using it inside a `function () {`:
->
-> ```js
-> const self = this;
->
-> setTimeout(function () {
->   self.doWork();
-> });
-> ```
->
-> Use `() =>` arrow lambdas, as they preserve `this` scope for you:
+Instead of storing a reference to `this` and using it inside a `function () {`:
+
+```js
+const self = this;
 >
-> ```js
-> setTimeout(() => {
->   this.doWork();
-> });
-> ```
+setTimeout(function () {
+    self.doWork();
+});
+```
+
+Use `() =>` arrow lambdas, as they preserve `this` scope for you:
+
+```js
+setTimeout(() => {
+  this.doWork();
+});
+```
 
 Examples of **incorrect** code for this rule:
 
@@ -56,13 +54,3 @@ You can pass an object option:
 ## When Not To Use It
 
 If you need to assign `this` to variables, you shouldn’t use this rule.
-
-## Related To
-
-- TSLint: [`no-this-assignment`](https://palantir.github.io/tslint/rules/no-this-assignment/)
-
-## Attributes
-
-- [x] ✅ Recommended
-- [ ] 🔧 Fixable
-- [ ] 💭 Requires type information

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

@@ -1,6 +1,6 @@
 # `no-throw-literal`
 
-Disallow throwing literals as exceptions.
+Disallows throwing literals as exceptions.
 
 It is considered good practice to only `throw` the `Error` object itself or an object using the `Error` object as base objects for user-defined exceptions.
 The fundamental benefit of `Error` objects is that they automatically keep track of where they were built and originated.
@@ -116,9 +116,3 @@ throw new CustomError();
 Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/main/docs/rules/no-throw-literal.md)
 
 </sup>
-
-## Attributes
-
-- [ ] ✅ Recommended
-- [ ] 🔧 Fixable
-- [x] 💭 Requires type information

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

@@ -1,6 +1,6 @@
 # `no-type-alias`
 
-Disallow the use of type aliases.
+Disallows type aliases.
 
 In TypeScript, type aliases serve three purposes:
 
@@ -118,6 +118,8 @@ type Foo = string | string[];
 
 type Foo = string & string[];
 
+type Foo = `foo-${number}`;
+
 // reference types
 interface Bar {}
 class Baz implements Bar {}
@@ -139,6 +141,8 @@ type Foo = string;
 
 type Foo = string & string[];
 
+type Foo = `foo-${number}`;
+
 // reference types
 interface Bar {}
 class Baz implements Bar {}
@@ -156,6 +160,8 @@ type Foo = 'a' | 'b';
 
 type Foo = string | string[];
 
+type Foo = `a-${number}` | `b-${number}`;
+
 // reference types
 interface Bar {}
 class Baz implements Bar {}
@@ -175,6 +181,8 @@ type Foo = string;
 
 type Foo = string | string[];
 
+type Foo = `a-${number}` | `b-${number}`;
+
 // reference types
 interface Bar {}
 class Baz implements Bar {}
@@ -190,6 +198,8 @@ Examples of **correct** code for the `{ "allowAliases": "in-intersections" }` op
 // primitives
 type Foo = string & string[];
 
+type Foo = `a-${number}` & `b-${number}`;
+
 // reference types
 interface Bar {}
 class Baz implements Bar {}
@@ -205,6 +215,8 @@ type Foo = 'a';
 
 type Foo = string;
 
+type Foo = `foo-${number}`;
+
 // reference types
 interface Bar {}
 class Baz implements Bar {}
@@ -222,6 +234,10 @@ type Foo = string | string[];
 
 type Foo = string & string[];
 
+type Foo = `a-${number}` & `b-${number}`;
+
+type Foo = `a-${number}` | `b-${number}`;
+
 // reference types
 interface Bar {}
 class Baz implements Bar {}
@@ -591,14 +607,4 @@ callback, etc. that would cause the code to be unreadable or impractical.
 
 ## Further Reading
 
-- [Advance Types](https://www.typescriptlang.org/docs/handbook/advanced-types.html)
-
-## Related To
-
-- TSLint: [interface-over-type-literal](https://palantir.github.io/tslint/rules/interface-over-type-literal/)
-
-## Attributes
-
-- [ ] ✅ Recommended
-- [ ] 🔧 Fixable
-- [ ] 💭 Requires type information
+- [Advanced Types](https://www.typescriptlang.org/docs/handbook/advanced-types.html)

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-unnecessary-boolean-literal-compare.md

@@ -1,6 +1,6 @@
 # `no-unnecessary-boolean-literal-compare`
 
-Flags unnecessary equality comparisons against boolean literals.
+Disallows unnecessary equality comparisons against boolean literals.
 
 Comparing boolean values to boolean literals is unnecessary, those comparisons result in the same booleans. Using the boolean values directly, or via a unary negation (`!value`), is more concise and clearer.
 
@@ -146,13 +146,3 @@ if (!(someNullCondition ?? true)) {
 | `nullableBooleanVar !== true`  | `!nullableBooleanVar`           | Only checked/fixed if the `allowComparingNullableBooleansToTrue` option is `false`  |
 | `nullableBooleanVar === false` | `nullableBooleanVar ?? true`    | Only checked/fixed if the `allowComparingNullableBooleansToFalse` option is `false` |
 | `nullableBooleanVar !== false` | `!(nullableBooleanVar ?? true)` | Only checked/fixed if the `allowComparingNullableBooleansToFalse` option is `false` |
-
-## Related To
-
-- TSLint: [no-boolean-literal-compare](https://palantir.github.io/tslint/rules/no-boolean-literal-compare)
-
-## Attributes
-
-- [ ] ✅ Recommended
-- [x] 🔧 Fixable
-- [x] 💭 Requires type information

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

@@ -1,6 +1,6 @@
 # `no-unnecessary-condition`
 
-Prevents conditionals where the type is always truthy or always falsy.
+Disallows conditionals where the type is always truthy or always falsy.
 
 Any expression being used as a condition must be able to evaluate as truthy or falsy in order to be considered "necessary". Conversely, any expression that always evaluates to truthy or always evaluates to falsy, as determined by the type of the expression, is considered unnecessary and will be flagged by this rule.
 
@@ -112,9 +112,3 @@ The main downside to using this rule is the need for type information.
 
 - ESLint: [no-constant-condition](https://eslint.org/docs/rules/no-constant-condition) - `no-unnecessary-condition` is essentially a stronger version of `no-constant-condition`, but requires type information.
 - [strict-boolean-expressions](./strict-boolean-expressions.md) - a more opinionated version of `no-unnecessary-condition`. `strict-boolean-expressions` enforces a specific code style, while `no-unnecessary-condition` is about correctness.
-
-## Attributes
-
-- [ ] ✅ Recommended
-- [x] 🔧 Fixable
-- [x] 💭 Requires type information