@typescript-eslint/eslint-plugin 8.9.1-alpha.1 → 8.9.1-alpha.10

package/docs/rules/prefer-optional-chain.mdx

@@ -68,6 +68,8 @@ Specifically the argument of the not operator (`!loose`) or a bare value in a lo
 
 ### `allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing`
 
+{/* insert option description */}
+
 When this option is `true`, the rule will provide an auto-fixer for cases where the return type of the expression would change. For example for the expression `!foo || foo.bar` the return type of the expression is `true | T`, however for the equivalent optional chain `foo?.bar` the return type of the expression is `undefined | T`. Thus changing the code from a logical expression to an optional chain expression has altered the type of the expression.
 
 In some cases this distinction _may_ matter - which is why these fixers are considered unsafe - they may break the build! For example in the following code:
@@ -89,11 +91,12 @@ When this option is `false` unsafe cases will have suggestion fixers provided in
 
 ### `checkAny`
 
-When this option is `true` the rule will check operands that are typed as `any` when inspecting "loose boolean" operands.
+{/* insert option description */}
 
-<Tabs>
+Examples of code for this rule with `{ checkAny: false }`:
 
-<TabItem value="❌ Incorrect for `checkAny: true`">
+<Tabs>
+<TabItem value="❌ Incorrect">
 
 ```ts option='{ "checkAny": true }'
 declare const thing: any;
@@ -102,7 +105,7 @@ thing && thing.toString();
 ```
 
 </TabItem>
-<TabItem value="✅ Correct for `checkAny: false`">
+<TabItem value="✅ Correct">
 
 ```ts option='{ "checkAny": false }'
 declare const thing: any;
@@ -115,11 +118,12 @@ thing && thing.toString();
 
 ### `checkUnknown`
 
-When this option is `true` the rule will check operands that are typed as `unknown` when inspecting "loose boolean" operands.
+{/* insert option description */}
 
-<Tabs>
+Examples of code for this rule with `{ checkUnknown: false }`:
 
-<TabItem value="❌ Incorrect for `checkUnknown: true`">
+<Tabs>
+<TabItem value="❌ Incorrect">
 
 ```ts option='{ "checkUnknown": true }'
 declare const thing: unknown;
@@ -128,7 +132,7 @@ thing && thing.toString();
 ```
 
 </TabItem>
-<TabItem value="✅ Correct for `checkUnknown: false`">
+<TabItem value="✅ Correct">
 
 ```ts option='{ "checkUnknown": false }'
 declare const thing: unknown;
@@ -141,11 +145,12 @@ thing && thing.toString();
 
 ### `checkString`
 
-When this option is `true` the rule will check operands that are typed as `string` when inspecting "loose boolean" operands.
+{/* insert option description */}
 
-<Tabs>
+Examples of code for this rule with `{ checkString: false }`:
 
-<TabItem value="❌ Incorrect for `checkString: true`">
+<Tabs>
+<TabItem value="❌ Incorrect">
 
 ```ts option='{ "checkString": true }'
 declare const thing: string;
@@ -154,7 +159,7 @@ thing && thing.toString();
 ```
 
 </TabItem>
-<TabItem value="✅ Correct for `checkString: false`">
+<TabItem value="✅ Correct">
 
 ```ts option='{ "checkString": false }'
 declare const thing: string;
@@ -167,11 +172,12 @@ thing && thing.toString();
 
 ### `checkNumber`
 
-When this option is `true` the rule will check operands that are typed as `number` when inspecting "loose boolean" operands.
+{/* insert option description */}
 
-<Tabs>
+Examples of code for this rule with `{ checkNumber: false }`:
 
-<TabItem value="❌ Incorrect for `checkNumber: true`">
+<Tabs>
+<TabItem value="❌ Incorrect">
 
 ```ts option='{ "checkNumber": true }'
 declare const thing: number;
@@ -180,7 +186,7 @@ thing && thing.toString();
 ```
 
 </TabItem>
-<TabItem value="✅ Correct for `checkNumber: false`">
+<TabItem value="✅ Correct">
 
 ```ts option='{ "checkNumber": false }'
 declare const thing: number;
@@ -193,7 +199,7 @@ thing && thing.toString();
 
 ### `checkBoolean`
 
-When this option is `true` the rule will check operands that are typed as `boolean` when inspecting "loose boolean" operands.
+{/* insert option description */}
 
 :::note
 
@@ -209,9 +215,10 @@ The boolean expression narrows out the non-nullish falsy cases - so converting t
 
 :::
 
-<Tabs>
+Examples of code for this rule with `{ checkBoolean: false }`:
 
-<TabItem value="❌ Incorrect for `checkBoolean: true`">
+<Tabs>
+<TabItem value="❌ Incorrect">
 
 ```ts option='{ "checkBoolean": true }'
 declare const thing: true;
@@ -220,7 +227,7 @@ thing && thing.toString();
 ```
 
 </TabItem>
-<TabItem value="✅ Correct for `checkBoolean: false`">
+<TabItem value="✅ Correct">
 
 ```ts option='{ "checkBoolean": false }'
 declare const thing: true;
@@ -233,11 +240,12 @@ thing && thing.toString();
 
 ### `checkBigInt`
 
-When this option is `true` the rule will check operands that are typed as `bigint` when inspecting "loose boolean" operands.
+{/* insert option description */}
 
-<Tabs>
+Examples of code for this rule with `{ checkBigInt: false }`:
 
-<TabItem value="❌ Incorrect for `checkBigInt: true`">
+<Tabs>
+<TabItem value="❌ Incorrect">
 
 ```ts option='{ "checkBigInt": true }'
 declare const thing: bigint;
@@ -246,7 +254,7 @@ thing && thing.toString();
 ```
 
 </TabItem>
-<TabItem value="✅ Correct for `checkBigInt: false`">
+<TabItem value="✅ Correct">
 
 ```ts option='{ "checkBigInt": false }'
 declare const thing: bigint;
@@ -259,11 +267,12 @@ thing && thing.toString();
 
 ### `requireNullish`
 
-When this option is `true` the rule will skip operands that are not typed with `null` and/or `undefined` when inspecting "loose boolean" operands.
+{/* insert option description */}
 
-<Tabs>
+Examples of code for this rule with `{ requireNullish: false }`:
 
-<TabItem value="❌ Incorrect for `requireNullish: true`">
+<Tabs>
+<TabItem value="❌ Incorrect">
 
 ```ts option='{ "requireNullish": true }'
 declare const thing1: string | null;
@@ -271,7 +280,7 @@ thing1 && thing1.toString();
 ```
 
 </TabItem>
-<TabItem value="✅ Correct for `requireNullish: true`">
+<TabItem value="✅ Correct">
 
 ```ts option='{ "requireNullish": true }'
 declare const thing1: string | null;

package/docs/rules/prefer-readonly-parameter-types.mdx

@@ -140,7 +140,8 @@ interface Foo {
 
 ### `allow`
 
-An array of type specifiers to ignore.
+{/* insert option description */}
+
 Some complex types cannot easily be made readonly, for example the `HTMLElement` type or the `JQueryStatic` type from `@types/jquery`. This option allows you to globally disable reporting of such types.
 
 This option takes the shared [`TypeOrValueSpecifier` format](/packages/type-utils/type-or-value-specifier).
@@ -251,7 +252,8 @@ function fn(arg: Foo) {}
 
 ### `checkParameterProperties`
 
-Whether to check class parameter properties.
+{/* insert option description */}
+
 Because parameter properties create properties on the class, it may be undesirable to force them to be readonly.
 
 Examples of code for this rule with `{checkParameterProperties: true}`:
@@ -290,7 +292,8 @@ class Foo {
 
 ### `ignoreInferredTypes`
 
-Whether to ignore parameters which don't explicitly specify a type.
+{/* insert option description */}
+
 This may be desirable in cases where an external dependency specifies a callback with mutable parameters, and manually annotating the callback's parameters is undesirable.
 
 Examples of code for this rule with `{ignoreInferredTypes: true}`:
@@ -348,7 +351,8 @@ export const acceptsCallback: AcceptsCallback;
 
 ### `treatMethodsAsReadonly`
 
-Whether to treat all mutable methods as though they are readonly.
+{/* insert option description */}
+
 This may be desirable when you are never reassigning methods.
 
 Examples of code for this rule with `{treatMethodsAsReadonly: false}`:

package/docs/rules/prefer-readonly.mdx

@@ -70,7 +70,7 @@ class Container {
 
 ### `onlyInlineLambdas`
 
-You may pass `"onlyInlineLambdas": true` as a rule option within an object to restrict checking only to members immediately assigned a lambda value.
+{/* insert option description */}
 
 ```jsonc
 {

package/docs/rules/prefer-string-starts-ends-with.mdx

@@ -62,6 +62,8 @@ foo.endsWith('bar');
 
 ### `allowSingleElementEquality`
 
+{/* insert option description */}
+
 If switched to `'always'`, the rule will allow equality checks against the first or last character in a string.
 This can be preferable in projects that don't deal with special character encodings and prefer a more succinct style.
 

package/docs/rules/promise-function-async.mdx

@@ -68,7 +68,8 @@ async function functionReturnsUnionWithPromiseImplicitly(p: boolean) {
 
 ### `allowAny`
 
-Whether to ignore functions that return `any` or `unknown`.
+{/* insert option description */}
+
 If you want additional safety, consider turning this option off, as it makes the rule less able to catch incorrect Promise behaviors.
 
 Examples of code with `{ "allowAny": false }`:
@@ -92,6 +93,8 @@ const returnsAny = async () => ({}) as any;
 
 ### `allowedPromiseNames`
 
+{/* insert option description */}
+
 For projects that use constructs other than the global built-in `Promise` for asynchronous code.
 This option allows specifying string names of classes or interfaces that cause a function to be checked as well.
 
@@ -120,23 +123,19 @@ const returnsBluebird = async () => new Bluebird(() => {});
 
 ### `checkArrowFunctions`
 
-Whether to check arrow functions.
-`true` by default, but can be set to `false` to ignore them.
+{/* insert option description */}
 
 ### `checkFunctionDeclarations`
 
-Whether to check standalone function declarations.
-`true` by default, but can be set to `false` to ignore them.
+{/* insert option description */}
 
 ### `checkFunctionExpressions`
 
-Whether to check inline function expressions.
-`true` by default, but can be set to `false` to ignore them.
+{/* insert option description */}
 
 ### `checkMethodDeclarations`
 
-Whether to check methods on classes and object literals.
-`true` by default, but can be set to `false` to ignore them.
+{/* insert option description */}
 
 ## When Not To Use It
 

package/docs/rules/require-array-sort-compare.mdx

@@ -57,6 +57,8 @@ userDefinedType.sort();
 
 ### `ignoreStringArrays`
 
+{/* insert option description */}
+
 Examples of code for this rule with `{ ignoreStringArrays: true }`:
 
 <Tabs>

package/docs/rules/restrict-plus-operands.mdx

@@ -74,6 +74,8 @@ Safer alternatives to using the `allow*` options include:
 
 ### `allowAny`
 
+{/* insert option description */}
+
 Examples of code for this rule with `{ allowAny: true }`:
 
 <Tabs>
@@ -97,6 +99,8 @@ let fn = (a: string, b: any) => a + b;
 
 ### `allowBoolean`
 
+{/* insert option description */}
+
 Examples of code for this rule with `{ allowBoolean: true }`:
 
 <Tabs>
@@ -120,6 +124,8 @@ let fn = (a: string, b: boolean) => a + b;
 
 ### `allowNullish`
 
+{/* insert option description */}
+
 Examples of code for this rule with `{ allowNullish: true }`:
 
 <Tabs>
@@ -147,6 +153,8 @@ let fn = (a: string, b: null) => a + b;
 
 ### `allowNumberAndString`
 
+{/* insert option description */}
+
 Examples of code for this rule with `{ allowNumberAndString: true }`:
 
 <Tabs>
@@ -170,6 +178,8 @@ let fn = (a: number, b: number | string) => a + b;
 
 ### `allowRegExp`
 
+{/* insert option description */}
+
 Examples of code for this rule with `{ allowRegExp: true }`:
 
 <Tabs>
@@ -191,6 +201,8 @@ let fn = (a: string, b: RegExp) => a + b;
 
 ### `skipCompoundAssignments`
 
+{/* insert option description */}
+
 Examples of code for this rule with `{ skipCompoundAssignments: false }`:
 
 <Tabs>

package/docs/rules/restrict-template-expressions.mdx

@@ -55,7 +55,7 @@ const msg3 = `stringWithKindProp = ${stringWithKindProp}`;
 
 ### `allowNumber`
 
-Whether to allow `number` typed values in template expressions.
+{/* insert option description */}
 
 Examples of additional **correct** code for this rule with `{ allowNumber: true }`:
 
@@ -73,7 +73,7 @@ Consider using [`.toFixed()`](https://developer.mozilla.org/en-US/docs/Web/JavaS
 
 ### `allowBoolean`
 
-Whether to allow Boolean typed values in template expressions.
+{/* insert option description */}
 
 Examples of additional **correct** code for this rule with `{ allowBoolean: true }`:
 
@@ -85,7 +85,7 @@ const msg2 = `arg = ${arg || 'not truthy'}`;
 
 ### `allowAny`
 
-Whether to allow `any` typed values in template expressions.
+{/* insert option description */}
 
 Examples of additional **correct** code for this rule with `{ allowAny: true }`:
 
@@ -97,7 +97,7 @@ const msg2 = `arg = ${user.name || 'the user with no name'}`;
 
 ### `allowNullish`
 
-Whether to allow `null` or `undefined` typed values in template expressions.
+{/* insert option description */}
 
 Examples of additional **correct** code for this rule with `{ allowNullish: true }`:
 
@@ -108,7 +108,7 @@ const msg1 = `arg = ${arg}`;
 
 ### `allowRegExp`
 
-Whether to allow `RegExp` typed values in template expressions.
+{/* insert option description */}
 
 Examples of additional **correct** code for this rule with `{ allowRegExp: true }`:
 
@@ -124,7 +124,7 @@ const msg1 = `arg = ${arg}`;
 
 ### `allowNever`
 
-Whether to allow `never` typed values in template expressions.
+{/* insert option description */}
 
 Examples of additional **correct** code for this rule with `{ allowNever: true }`:
 
@@ -135,7 +135,7 @@ const msg1 = typeof arg === 'string' ? arg : `arg = ${arg}`;
 
 ### `allowArray`
 
-Whether to allow `Array` typed values in template expressions.
+{/* insert option description */}
 
 Examples of additional **correct** code for this rule with `{ allowArray: true }`:
 
@@ -146,6 +146,8 @@ const msg1 = `arg = ${arg}`;
 
 ### `allow`
 
+{/* insert option description */}
+
 Whether to allow additional types in template expressions.
 
 This option takes the shared [`TypeOrValueSpecifier` format](/packages/type-utils/type-or-value-specifier).

package/docs/rules/return-await.mdx

@@ -189,6 +189,8 @@ async function validInTryCatch7() {
 
 ### `always`
 
+{/* insert option description */}
+
 Requires that all returned promises be awaited.
 
 This is a good option if you like the consistency of simply always awaiting promises, or prefer not having to consider the distinction between error-handling contexts and ordinary contexts.
@@ -268,6 +270,8 @@ async function asyncFunction(): Promise<void> {
 
 ### `never`
 
+{/* insert option description */}
+
 Disallows awaiting any returned promises.
 
 :::warning

package/docs/rules/sort-type-constituents.mdx

@@ -96,7 +96,7 @@ type T4 =
 
 ### `caseSensitive`
 
-Whether to sort using case sensitive string comparisons.
+{/* insert option description */}
 
 Examples of code with `{ "caseSensitive": true }`:
 
@@ -119,7 +119,7 @@ type T = 'DeleteForever' | 'DeletedAt';
 
 ### `checkIntersections`
 
-Whether to check intersection types (`&`).
+{/* insert option description */}
 
 Examples of code with `{ "checkIntersections": true }` (the default):
 
@@ -142,7 +142,7 @@ type ExampleIntersection = A & B;
 
 ### `checkUnions`
 
-Whether to check union types (`|`).
+{/* insert option description */}
 
 Examples of code with `{ "checkUnions": true }` (the default):
 
@@ -165,6 +165,8 @@ type ExampleUnion = A | B;
 
 ### `groupOrder`
 
+{/* insert option description */}
+
 Each constituent of the type is placed into a group, and then the rule sorts alphabetically within each group.
 The ordering of groups is determined by this option.
 

package/docs/rules/strict-boolean-expressions.mdx

@@ -95,55 +95,65 @@ const foo = (arg: any) => (Boolean(arg) ? 1 : 0);
 
 ### `allowString`
 
-Allows `string` in a boolean context.
-This is safe because strings have only one falsy value (`""`).
+{/* insert option description */}
+
+This can be safe because strings have only one falsy value (`""`).
 Set this to `false` if you prefer the explicit `str != ""` or `str.length > 0` style.
 
 ### `allowNumber`
 
-Allows `number` in a boolean context.
-This is safe because numbers have only two falsy values (`0` and `NaN`).
+{/* insert option description */}
+
+This can be safe because numbers have only two falsy values (`0` and `NaN`).
 Set this to `false` if you prefer the explicit `num != 0` and `!Number.isNaN(num)` style.
 
 ### `allowNullableObject`
 
-Allows `object | function | symbol | null | undefined` in a boolean context.
-This is safe because objects, functions and symbols don't have falsy values.
+{/* insert option description */}
+
+This can be safe because objects, functions, and symbols don't have falsy values.
 Set this to `false` if you prefer the explicit `obj != null` style.
 
 ### `allowNullableBoolean`
 
-Allows `boolean | null | undefined` in a boolean context.
+{/* insert option description */}
+
 This is unsafe because nullable booleans can be either `false` or nullish.
 Set this to `false` if you want to enforce explicit `bool ?? false` or `bool ?? true` style.
 Set this to `true` if you don't mind implicitly treating false the same as a nullish value.
 
 ### `allowNullableString`
 
-Allows `string | null | undefined` in a boolean context.
+{/* insert option description */}
+
 This is unsafe because nullable strings can be either an empty string or nullish.
 Set this to `true` if you don't mind implicitly treating an empty string the same as a nullish value.
 
 ### `allowNullableNumber`
 
-Allows `number | null | undefined` in a boolean context.
+{/* insert option description */}
+
 This is unsafe because nullable numbers can be either a falsy number or nullish.
 Set this to `true` if you don't mind implicitly treating zero or NaN the same as a nullish value.
 
 ### `allowNullableEnum`
 
-Allows `enum | null | undefined` in a boolean context.
+{/* insert option description */}
+
 This is unsafe because nullable enums can be either a falsy number or nullish.
 Set this to `true` if you don't mind implicitly treating an enum whose value is zero the same as a nullish value.
 
 ### `allowAny`
 
-Allows `any` in a boolean context.
-This is unsafe for obvious reasons.
+{/* insert option description */}
+
+This is unsafe for because `any` allows any values and disables many type checking checks.
 Set this to `true` at your own risk.
 
 ### `allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing`
 
+{/* insert option description */}
+
 :::danger Deprecated
 
 This option will be removed in the next major version of typescript-eslint.

package/docs/rules/switch-exhaustiveness-check.mdx

@@ -18,7 +18,9 @@ This rule reports when a `switch` statement over a value typed as a union of lit
 
 ### `allowDefaultCaseForExhaustiveSwitch`
 
-Defaults to true. If set to false, this rule will also report when a `switch` statement has a case for everything in a union and _also_ contains a `default` case. Thus, by setting this option to false, the rule becomes stricter.
+{/* insert option description */}
+
+If set to false, this rule will also report when a `switch` statement has a case for everything in a union and _also_ contains a `default` case. Thus, by setting this option to false, the rule becomes stricter.
 
 When a `switch` statement over a union type is exhaustive, a final `default` case would be a form of dead code.
 Additionally, if a new value is added to the union type, a `default` would prevent the `switch-exhaustiveness-check` rule from reporting on the new case not being handled in the `switch` statement.
@@ -34,7 +36,9 @@ If your project has many intentionally redundant `default` cases, you may want t
 
 ### `requireDefaultForNonUnion`
 
-Defaults to false. If set to true, this rule will also report when a `switch` statement switches over a non-union type (like a `number` or `string`, for example) and that `switch` statement does not have a `default` case. Thus, by setting this option to true, the rule becomes stricter.
+{/* insert option description */}
+
+If set to true, this rule will also report when a `switch` statement switches over a non-union type (like a `number` or `string`, for example) and that `switch` statement does not have a `default` case. Thus, by setting this option to true, the rule becomes stricter.
 
 This is generally desirable so that `number` and `string` switches will be subject to the same exhaustive checks that your other switches are.
 

package/docs/rules/triple-slash-reference.mdx

@@ -20,6 +20,8 @@ Specifying `'always'` disables this lint rule for that kind of reference.
 
 ### `lib`
 
+{/* insert option description */}
+
 When set to `'never'`, bans `/// <reference lib="..." />` and enforces using an `import` instead:
 
 <Tabs>
@@ -43,6 +45,8 @@ import { value } from 'code';
 
 ### `path`
 
+{/* insert option description */}
+
 When set to `'never'`, bans `/// <reference path="..." />` and enforces using an `import` instead:
 
 <Tabs>
@@ -66,6 +70,8 @@ import { value } from 'code';
 
 ### `types`
 
+{/* insert option description */}
+
 When set to `'never'`, bans `/// <reference types="..." />` and enforces using an `import` instead:
 
 <Tabs>