xo 0.51.0 → 0.52.0

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-literal-enum-member.md

@@ -1,6 +1,10 @@
-# `prefer-literal-enum-member`
+---
+description: 'Require all enum members to be literal values.'
+---
 
-Requires all enum members to be literal values.
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/prefer-literal-enum-member** for documentation.
 
 TypeScript allows the value of an enum member to be many different kinds of valid JavaScript expressions. However, because enums create their own scope whereby each enum member becomes a variable in that scope, unexpected values could be used at runtime. Example:
 

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

@@ -1,6 +1,10 @@
-# `prefer-namespace-keyword`
+---
+description: 'Require using `namespace` keyword over `module` keyword to declare custom TypeScript modules.'
+---
 
-Requires using `namespace` keyword over `module` keyword to declare custom TypeScript modules.
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/prefer-namespace-keyword** for documentation.
 
 In an effort to prevent further confusion between custom TypeScript modules and the new ES2015 modules, starting
 with TypeScript `v1.5` the keyword `namespace` is now the preferred way to declare custom TypeScript modules.
@@ -13,19 +17,6 @@ This rule aims to standardize the way modules are declared.
 
 If you are using the ES2015 module syntax, then you will not need this rule.
 
-## Options
-
-```jsonc
-// .eslintrc.json
-{
-  "rules": {
-    "@typescript-eslint/prefer-namespace-keyword": "error"
-  }
-}
-```
-
-This rule is not configurable.
-
 ## Further Reading
 
 - [Modules](https://www.typescriptlang.org/docs/handbook/modules.html)

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-nullish-coalescing.md

@@ -1,6 +1,10 @@
-# `prefer-nullish-coalescing`
+---
+description: 'Enforce using the nullish coalescing operator instead of logical chaining.'
+---
 
-Enforces using the nullish coalescing operator instead of logical chaining.
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/prefer-nullish-coalescing** for documentation.
 
 TypeScript 3.7 added support for the nullish coalescing operator.
 This operator allows you to safely cascade a value when dealing with `null` or `undefined`.
@@ -46,6 +50,7 @@ This rule aims enforce the usage of the safer operator.
 ```ts
 type Options = [
   {
+    ignoreTernaryTests?: boolean;
     ignoreConditionalTests?: boolean;
     ignoreMixedLogicalExpressions?: boolean;
   },
@@ -53,12 +58,53 @@ type Options = [
 
 const defaultOptions = [
   {
+    ignoreTernaryTests: true;
     ignoreConditionalTests: true,
     ignoreMixedLogicalExpressions: true,
   },
 ];
 ```
 
+### `ignoreTernaryTests`
+
+Setting this option to `true` (the default) will cause the rule to ignore any ternary expressions that could be simplified by using the nullish coalescing operator.
+
+Incorrect code for `ignoreTernaryTests: false`, and correct code for `ignoreTernaryTests: true`:
+
+```ts
+const foo: any = 'bar';
+foo !== undefined && foo !== null ? foo : 'a string';
+foo === undefined || foo === null ? 'a string' : foo;
+foo == undefined ? 'a string' : foo;
+foo == null ? 'a string' : foo;
+
+const foo: string | undefined = 'bar';
+foo !== undefined ? foo : 'a string';
+foo === undefined ? 'a string' : foo;
+
+const foo: string | null = 'bar';
+foo !== null ? foo : 'a string';
+foo === null ? 'a string' : foo;
+```
+
+Correct code for `ignoreTernaryTests: false`:
+
+```ts
+const foo: any = 'bar';
+foo ?? 'a string';
+foo ?? 'a string';
+foo ?? 'a string';
+foo ?? 'a string';
+
+const foo: string | undefined = 'bar';
+foo ?? 'a string';
+foo ?? 'a string';
+
+const foo: string | null = 'bar';
+foo ?? 'a string';
+foo ?? 'a string';
+```
+
 ### `ignoreConditionalTests`
 
 Setting this option to `true` (the default) will cause the rule to ignore any cases that are located within a conditional test.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-optional-chain.md

@@ -1,6 +1,10 @@
-# `prefer-optional-chain`
+---
+description: 'Enforce using concise optional chain expressions instead of chained logical ands, negated logical ors, or empty objects.'
+---
 
-Enforces using concise optional chain expressions instead of chained logical ands.
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/prefer-optional-chain** for documentation.
 
 TypeScript 3.7 added support for the optional chain operator.
 This operator allows you to safely access properties and methods on objects when they are potentially `null` or `undefined`.
@@ -61,9 +65,15 @@ foo && foo.a && foo.a.b && foo.a.b.c;
 foo && foo['a'] && foo['a'].b && foo['a'].b.c;
 foo && foo.a && foo.a.b && foo.a.b.method && foo.a.b.method();
 
+// With empty objects
 (((foo || {}).a || {}).b || {}).c;
 (((foo || {})['a'] || {}).b || {}).c;
 
+// With negated `or`s
+!foo || !foo.bar;
+!foo || !foo[bar];
+!foo || !foo.bar || !foo.bar.baz || !foo.bar.baz();
+
 // this rule also supports converting chained strict nullish checks:
 foo &&
   foo.a != null &&
@@ -81,22 +91,13 @@ foo?.['a']?.b?.c;
 foo?.a?.b?.method?.();
 
 foo?.a?.b?.c?.d?.e;
-```
-
-**Note:** there are a few edge cases where this rule will false positive. Use your best judgement when evaluating reported errors.
 
-## Options
-
-```jsonc
-// .eslintrc.json
-{
-  "rules": {
-    "@typescript-eslint/prefer-optional-chain": "warn"
-  }
-}
+!foo?.bar;
+!foo?.[bar];
+!foo?.bar?.baz?.();
 ```
 
-This rule is not configurable.
+**Note:** there are a few edge cases where this rule will false positive. Use your best judgement when evaluating reported errors.
 
 ## When Not To Use It
 

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-readonly-parameter-types.md

@@ -1,6 +1,10 @@
-# `prefer-readonly-parameter-types`
+---
+description: 'Require function parameters to be typed as `readonly` to prevent accidental mutation of inputs.'
+---
 
-Requires function parameters to be typed as `readonly` to prevent accidental mutation of inputs.
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/prefer-readonly-parameter-types** for documentation.
 
 Mutating function arguments can lead to confusing, hard to debug behavior.
 Whilst it's easy to implicitly remember to not modify function arguments, explicitly typing arguments as readonly provides clear contract to consumers.
@@ -127,19 +131,6 @@ interface Foo {
 
 ## Options
 
-```ts
-interface Options {
-  checkParameterProperties?: boolean;
-  ignoreInferredTypes?: boolean;
-}
-
-const defaultOptions: Options = {
-  checkParameterProperties: true,
-  ignoreInferredTypes: false,
-  treatMethodsAsReadonly: false,
-};
-```
-
 ### `checkParameterProperties`
 
 This option allows you to enable or disable the checking of parameter properties.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-readonly.md

@@ -1,6 +1,10 @@
-# `prefer-readonly`
+---
+description: "Require private members to be marked as `readonly` if they're never modified outside of the constructor."
+---
 
-Requires private members to be marked as `readonly` if they're never modified outside of the constructor.
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/prefer-readonly** for documentation.
 
 This rule enforces that private members are marked as `readonly` if they're never modified outside of the constructor.
 
@@ -52,8 +56,6 @@ class Container {
 
 ## Options
 
-This rule, in its default state, does not require any argument.
-
 ### `onlyInlineLambdas`
 
 You may pass `"onlyInlineLambdas": true` as a rule option within an object to restrict checking only to members immediately assigned a lambda value.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-reduce-type-parameter.md

@@ -1,6 +1,10 @@
-# `prefer-reduce-type-parameter`
+---
+description: 'Enforce using type parameter when calling `Array#reduce` instead of casting.'
+---
 
-Enforces using type parameter when calling `Array#reduce` instead of casting.
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/prefer-reduce-type-parameter** for documentation.
 
 It's common to call `Array#reduce` with a generic type, such as an array or object, as the initial value.
 Since these values are empty, their types are not usable:
@@ -51,19 +55,6 @@ Examples of code for this rule:
 );
 ```
 
-## Options
-
-```jsonc
-// .eslintrc.json
-{
-  "rules": {
-    "@typescript-eslint/prefer-reduce-type-parameter": "warn"
-  }
-}
-```
-
-This rule is not configurable.
-
 ## When Not To Use It
 
 If you don't want to use typechecking in your linting, you can't use this rule.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-regexp-exec.md

@@ -1,6 +1,10 @@
-# `prefer-regexp-exec`
+---
+description: 'Enforce `RegExp#exec` over `String#match` if no global flag is provided.'
+---
 
-Enforces `RegExp#exec` over `String#match` if no global flag is provided.
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/prefer-regexp-exec** for documentation.
 
 As `String#match` is defined to be the same as `RegExp#exec` when the regular expression does not include the `g` flag, prefer a consistent usage.
 
@@ -42,19 +46,6 @@ const search = /thing/;
 search.exec(text);
 ```
 
-## Options
-
-```jsonc
-// .eslintrc.json
-{
-  "rules": {
-    "@typescript-eslint/prefer-regexp-exec": "warn"
-  }
-}
-```
-
-This rule is not configurable.
-
 ## When Not To Use It
 
 If you prefer consistent use of `String#match` for both, with `g` flag and without it, you can turn this rule off.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-return-this-type.md

@@ -1,6 +1,10 @@
-# `prefer-return-this-type`
+---
+description: 'Enforce that `this` is used when only `this` type is returned.'
+---
 
-Enforces that `this` is used when only `this` type is returned.
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/prefer-return-this-type** for documentation.
 
 [Method chaining](https://en.wikipedia.org/wiki/Method_chaining) is a common pattern in OOP languages and TypeScript provides a special [polymorphic this type](https://www.typescriptlang.org/docs/handbook/2/classes.html#this-types).
 If any type other than `this` is specified as the return type of these chaining methods, TypeScript will fail to cast it when invoking in subclass.
@@ -93,19 +97,6 @@ class Derived extends Base {
 }
 ```
 
-## Options
-
-```jsonc
-// .eslintrc.json
-{
-  "rules": {
-    "@typescript-eslint/prefer-return-this-type": "warn"
-  }
-}
-```
-
-This rule is not configurable.
-
 ## When Not To Use It
 
 If you don't use method chaining or explicit return values, you can safely turn this rule off.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-string-starts-ends-with.md

@@ -1,9 +1,12 @@
-# `prefer-string-starts-ends-with`
+---
+description: 'Enforce using `String#startsWith` and `String#endsWith` over other equivalent methods of checking substrings.'
+---
 
-Enforces using `String#startsWith` and `String#endsWith` over other equivalent methods of checking substrings.
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/prefer-string-starts-ends-with** for documentation.
 
 There are multiple ways to verify if a string starts or ends with a specific string, such as `foo.indexOf('bar') === 0`.
-
 Since ES2015 has added `String#startsWith` and `String#endsWith`, this rule reports other ways to be consistent.
 
 ## Rule Details
@@ -45,19 +48,6 @@ foo.startsWith('bar');
 foo.endsWith('bar');
 ```
 
-## Options
-
-```jsonc
-// .eslintrc.json
-{
-  "rules": {
-    "@typescript-eslint/prefer-string-starts-ends-with": "warn"
-  }
-}
-```
-
-This rule is not configurable.
-
 ## When Not To Use It
 
 If you don't mind that style, you can turn this rule off safely.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-ts-expect-error.md

@@ -1,6 +1,10 @@
-# `prefer-ts-expect-error`
+---
+description: 'Enforce using `@ts-expect-error` over `@ts-ignore`.'
+---
 
-Enforces using `@ts-expect-error` over `@ts-ignore`.
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/prefer-ts-expect-error** for documentation.
 
 TypeScript allows you to suppress all errors on a line by placing a single-line comment or a comment block line starting with `@ts-ignore` immediately before the erroring line.
 While powerful, there is no way to know if a `@ts-ignore` is actually suppressing an error without manually investigating what happens when the `@ts-ignore` is removed.
@@ -62,19 +66,6 @@ const isOptionEnabled = (key: string): boolean => {
 };
 ```
 
-## Options
-
-```jsonc
-// .eslintrc.json
-{
-  "rules": {
-    "@typescript-eslint/prefer-ts-expect-error": "warn"
-  }
-}
-```
-
-This rule is not configurable.
-
 ## When Not To Use It
 
 If you are **NOT** using TypeScript 3.9 (or greater), then you will not be able to use this rule, as the directive is not supported

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/promise-function-async.md

@@ -1,6 +1,10 @@
-# `promise-function-async`
+---
+description: 'Require any function or method that returns a Promise to be marked async.'
+---
 
-Requires any function or method that returns a Promise to be marked async.
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/promise-function-async** for documentation.
 
 Ensures that each function is only capable of:
 
@@ -36,32 +40,3 @@ async function functionReturnsPromise() {
   return Promise.resolve('value');
 }
 ```
-
-## Options
-
-Options may be provided as an object with:
-
-- `allowAny` to indicate that `any` or `unknown` shouldn't be considered Promises (`true` by default).
-- `allowedPromiseNames` to indicate any extra names of classes or interfaces to be considered Promises when returned.
-
-In addition, each of the following properties may be provided, and default to `true`:
-
-- `checkArrowFunctions`
-- `checkFunctionDeclarations`
-- `checkFunctionExpressions`
-- `checkMethodDeclarations`
-
-```json
-{
-  "@typescript-eslint/promise-function-async": [
-    "error",
-    {
-      "allowedPromiseNames": ["Thenable"],
-      "checkArrowFunctions": true,
-      "checkFunctionDeclarations": true,
-      "checkFunctionExpressions": true,
-      "checkMethodDeclarations": true
-    }
-  ]
-}
-```

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

@@ -1,28 +1,12 @@
-# `quotes`
+---
+description: 'Enforce the consistent use of either backticks, double, or single quotes.'
+---
 
-Enforces the consistent use of either backticks, double, or single quotes.
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/quotes** for documentation.
 
 ## Rule Details
 
 This rule extends the base [`eslint/quotes`](https://eslint.org/docs/rules/quotes) rule.
 It adds support for TypeScript features which allow quoted names, but not backtick quoted names.
-
-## How to Use
-
-```jsonc
-{
-  // note you must disable the base rule as it can report incorrect errors
-  "quotes": "off",
-  "@typescript-eslint/quotes": ["error"]
-}
-```
-
-## Options
-
-See [`eslint/quotes` options](https://eslint.org/docs/rules/quotes#options).
-
-<sup>
-
-Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/main/docs/rules/quotes.md)
-
-</sup>

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/require-array-sort-compare.md

@@ -1,9 +1,12 @@
-# `require-array-sort-compare`
+---
+description: 'Require `Array#sort` calls to always provide a `compareFunction`.'
+---
 
-Requires `Array#sort` calls to always provide a `compareFunction`.
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/require-array-sort-compare** for documentation.
 
 This rule prevents invoking the `Array#sort()` method without providing a `compare` argument.
-
 When called without a compare function, `Array#sort()` converts all non-undefined array elements into strings and then compares said strings based off their UTF-16 code units.
 
 The result is that elements are sorted alphabetically, regardless of their type.
@@ -55,21 +58,6 @@ userDefinedType.sort();
 
 ## Options
 
-The rule accepts an options object with the following properties:
-
-```ts
-type Options = {
-  /**
-   * If true, an array which all elements are string is ignored.
-   */
-  ignoreStringArrays?: boolean;
-};
-
-const defaults = {
-  ignoreStringArrays: false,
-};
-```
-
 ### `ignoreStringArrays`
 
 Examples of code for this rule with `{ ignoreStringArrays: true }`:

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

@@ -1,6 +1,10 @@
-# `require-await`
+---
+description: 'Disallow async functions which have no `await` expression.'
+---
 
-Disallows async functions which have no `await` expression.
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/require-await** for documentation.
 
 ## Rule Details
 
@@ -18,21 +22,3 @@ const returnsPromise2 = () => returnsPromise1();
 ```
 
 ## How to Use
-
-```jsonc
-{
-  // note you must disable the base rule as it can report incorrect errors
-  "require-await": "off",
-  "@typescript-eslint/require-await": "error"
-}
-```
-
-## Options
-
-See [`eslint/require-await` options](https://eslint.org/docs/rules/require-await#options).
-
-<sup>
-
-Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/main/docs/rules/require-await.md)
-
-</sup>

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/restrict-plus-operands.md

@@ -1,6 +1,10 @@
-# `restrict-plus-operands`
+---
+description: 'Require both operands of addition to have type `number` or `string`.'
+---
 
-Requires both operands of addition to have type `number` or `string`.
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/restrict-plus-operands** for documentation.
 
 ## Rule Details
 
@@ -24,22 +28,6 @@ var foo = 1n + 1n;
 
 ## Options
 
-The rule accepts an options object with the following properties:
-
-```ts
-type Options = {
-  // if true, check compound assignments (`+=`)
-  checkCompoundAssignments?: boolean;
-  // if true, 'any' itself and `string`,`bigint`, `number` is allowed.
-  allowAny?: boolean;
-};
-
-const defaults = {
-  checkCompoundAssignments: false,
-  allowAny: false,
-};
-```
-
 ### `checkCompoundAssignments`
 
 Examples of code for this rule with `{ checkCompoundAssignments: true }`:
@@ -94,9 +82,3 @@ var fn = (a: any, b: number) => a + b;
 ```
 
 ## How to Use
-
-```json
-{
-  "@typescript-eslint/restrict-plus-operands": "error"
-}
-```

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/restrict-template-expressions.md

@@ -1,6 +1,10 @@
-# `restrict-template-expressions`
+---
+description: 'Enforce template literal expressions to be of `string` type.'
+---
 
-Enforces template literal expressions to be of `string` type.
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/restrict-template-expressions** for documentation.
 
 ## Rule Details
 
@@ -31,31 +35,6 @@ const msg3 = `stringWithKindProp = ${stringWithKindProp}`;
 
 ## Options
 
-The rule accepts an options object with the following properties:
-
-```ts
-type Options = {
-  // if true, also allow number type in template expressions
-  allowNumber?: boolean;
-  // if true, also allow boolean type in template expressions
-  allowBoolean?: boolean;
-  // if true, also allow any in template expressions
-  allowAny?: boolean;
-  // if true, also allow null and undefined in template expressions
-  allowNullish?: boolean;
-  // if true, also allow RegExp in template expressions
-  allowRegExp?: boolean;
-};
-
-const defaults = {
-  allowNumber: true,
-  allowBoolean: false,
-  allowAny: false,
-  allowNullish: false,
-  allowRegExp: false,
-};
-```
-
 ### `allowNumber`
 
 Examples of additional **correct** code for this rule with `{ allowNumber: true }`: