@typescript-eslint/eslint-plugin 8.9.1-alpha.6 → 8.9.1-alpha.7

package/docs/rules/explicit-module-boundary-types.mdx

@@ -97,17 +97,19 @@ If you are working on a codebase within which you lint non-TypeScript code (i.e.
 
 ### `allowArgumentsExplicitlyTypedAsAny`
 
-When this option is `true`, the rule ignores arguments that are explicitly typed as any.
+{/* insert option description */}
+
+Examples of code for this rule with `{ allowArgumentsExplicitlyTypedAsAny: false }`:
 
 <Tabs>
-<TabItem value="❌ Incorrect for `allowArgumentsExplicitlyTypedAsAny: false`">
+<TabItem value="❌ Incorrect">
 
 ```ts option='{ "allowArgumentsExplicitlyTypedAsAny": false }'
 export const func = (value: any): number => value + 1;
 ```
 
 </TabItem>
-<TabItem value="✅ Correct for `allowArgumentsExplicitlyTypedAsAny: true`">
+<TabItem value="✅ Correct">
 
 ```ts option='{ "allowArgumentsExplicitlyTypedAsAny": true }'
 export const func = (value: any): number => value + 1;
@@ -118,10 +120,12 @@ export const func = (value: any): number => value + 1;
 
 ### `allowDirectConstAssertionInArrowFunctions`
 
-When this option is `true`, the rule ignores return type annotations on body-less arrow functions that return an `as const` type assertion.
+{/* insert option description */}
+
+Examples of code for this rule with `{ allowDirectConstAssertionInArrowFunctions: false }`:
 
 <Tabs>
-<TabItem value="❌ Incorrect for `allowDirectConstAssertionInArrowFunctions: false`">
+<TabItem value="❌ Incorrect">
 
 ```ts option='{ "allowDirectConstAssertionInArrowFunctions": false }'
 export const func = (value: number) => ({ type: 'X', value });
@@ -132,7 +136,7 @@ export const bar = () => 1;
 ```
 
 </TabItem>
-<TabItem value="✅ Correct for `allowDirectConstAssertionInArrowFunctions: true`">
+<TabItem value="✅ Correct">
 
 ```ts option='{ "allowDirectConstAssertionInArrowFunctions": true }'
 export const func = (value: number) => ({ type: 'X', value }) as const;
@@ -148,6 +152,8 @@ export const bar = () => 1 as const;
 
 ### `allowedNames`
 
+{/* insert option description */}
+
 You may pass function/method names you would like this rule to ignore, like so:
 
 ```json
@@ -163,10 +169,12 @@ You may pass function/method names you would like this rule to ignore, like so:
 
 ### `allowHigherOrderFunctions`
 
-When this option is `true`, the rule ignores return type annotations on function, which is immediately returning another function expression.
+{/* insert option description */}
+
+Examples of code for this rule with `{ allowHigherOrderFunctions: false }`:
 
 <Tabs>
-<TabItem value="❌ Incorrect for `allowHigherOrderFunctions: false`">
+<TabItem value="❌ Incorrect">
 
 ```ts option='{ "allowHigherOrderFunctions": false }'
 export const arrowFn = () => () => {};
@@ -181,7 +189,7 @@ export function foo(outer: string) {
 ```
 
 </TabItem>
-<TabItem value="✅ Correct for `allowHigherOrderFunctions: true`">
+<TabItem value="✅ Correct">
 
 ```ts option='{ "allowHigherOrderFunctions": true }'
 export const arrowFn = () => (): void => {};
@@ -200,10 +208,12 @@ export function foo(outer: string) {
 
 ### `allowTypedFunctionExpressions`
 
-When this option is `true`, the rule ignores type annotations on the variable of a function expression.
+{/* insert option description */}
+
+Examples of code for this rule with `{ allowTypedFunctionExpressions: false }`:
 
 <Tabs>
-<TabItem value="❌ Incorrect for `allowTypedFunctionExpressions: false`">
+<TabItem value="❌ Incorrect">
 
 ```ts option='{ "allowTypedFunctionExpressions": false }'
 export let arrowFn = () => 'test';
@@ -220,7 +230,7 @@ export const foo = bar => {};
 ```
 
 </TabItem>
-<TabItem value="✅ Correct for `allowTypedFunctionExpressions: true`">
+<TabItem value="✅ Correct">
 
 ```ts option='{ "allowTypedFunctionExpressions": true }'
 type FuncType = () => string;

package/docs/rules/max-params.mdx

@@ -29,7 +29,7 @@ const defaultOptions: Options = {
 
 ### `countVoidThis`
 
-Whether to count a `this` declaration when the type is `void`.
+{/* insert option description */}
 
 Example of a code when `countVoidThis` is set to `false` and `max` is `1`:
 

package/docs/rules/method-signature-style.mdx

@@ -39,10 +39,10 @@ This rule accepts one string option:
 - `"property"`: Enforce using property signature for functions. Use this to enforce maximum correctness together with TypeScript's strict mode.
 - `"method"`: Enforce using method signature for functions. Use this if you aren't using TypeScript's strict mode and prefer this style.
 
-The default is `"property"`.
-
 ### `property`
 
+{/* insert option description */}
+
 Examples of code with `property` option.
 
 <Tabs>
@@ -85,6 +85,8 @@ interface T3 {
 
 ### `method`
 
+{/* insert option description */}
+
 Examples of code with `method` option.
 
 <Tabs>

package/docs/rules/no-base-to-string.mdx

@@ -66,9 +66,10 @@ const literalWithToString = {
 
 ### `ignoredTypeNames`
 
-Stringified regular expressions of type names to ignore.
-This is useful for types missing `toString()` (but actually has `toString()`).
-There are some types missing `toString()` in old version TypeScript, like `RegExp`, `URL`, `URLSearchParams` etc.
+{/* insert option description */}
+
+This is useful for types whose declarations missing `toString()`, but are known to actually have `toString()`.
+There are some types missing `toString()` in TypeScript, like `RegExp`, `URL`, `URLSearchParams` etc.
 
 The following patterns are considered correct with the default options `{ ignoredTypeNames: ["RegExp"] }`:
 
@@ -93,3 +94,4 @@ If you don't mind a risk of `"[object Object]"` or incorrect type coercions in y
 ## Further Reading
 
 - [`Object.prototype.toString()` MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toString)
+- [Microsoft/TypeScript Add missing toString declarations for base types that have them](https://github.com/microsoft/TypeScript/issues/38347)

package/docs/rules/no-confusing-void-expression.mdx

@@ -77,6 +77,8 @@ cond ? console.log('true') : console.error('false');
 
 ### `ignoreArrowShorthand`
 
+{/* insert option description */}
+
 Whether to ignore "shorthand" `() =>` arrow functions: those without `{ ... }` braces.
 
 It might be undesirable to wrap every arrow function shorthand expression.
@@ -90,6 +92,8 @@ promise.then(value => window.postMessage(value));
 
 ### `ignoreVoidOperator`
 
+{/* insert option description */}
+
 Whether to ignore returns that start with the `void` operator.
 
 It might be preferable to only use some distinct syntax

package/docs/rules/no-duplicate-type-constituents.mdx

@@ -67,10 +67,14 @@ const fn = (a?: string) => {};
 
 ### `ignoreIntersections`
 
+{/* insert option description */}
+
 When set to true, duplicate checks on intersection type constituents are ignored.
 
 ### `ignoreUnions`
 
+{/* insert option description */}
+
 When set to true, duplicate checks on union type constituents are ignored.
 
 ## When Not To Use It

package/docs/rules/no-empty-interface.mdx

@@ -62,7 +62,9 @@ interface Baz extends Foo, Bar {}
 
 ### `allowSingleExtends`
 
-`allowSingleExtends: true` will silence warnings about extending a single interface without adding additional members
+{/* insert option description */}
+
+`allowSingleExtends: true` will silence warnings about extending a single interface without adding additional members.
 
 ## When Not To Use It
 

package/docs/rules/no-empty-object-type.mdx

@@ -83,7 +83,9 @@ By default, this rule flags both interfaces and object types.
 
 ### `allowInterfaces`
 
-Whether to allow empty interfaces, as one of:
+{/* insert option description */}
+
+Allowed values are:
 
 - `'always'`: to always allow interfaces with no fields
 - `'never'` _(default)_: to never allow interfaces with no fields
@@ -101,14 +103,17 @@ interface Derived extends Base {}
 
 ### `allowObjectTypes`
 
-Whether to allow empty object type literals, as one of:
+{/* insert option description */}
+
+Allowed values are:
 
 - `'always'`: to always allow object type literals with no fields
 - `'never'` _(default)_: to never allow object type literals with no fields
 
 ### `allowWithName`
 
-A stringified regular expression to allow interfaces and object type aliases with the configured name.
+{/* insert option description */}
+
 This can be useful if your existing code style includes a pattern of declaring empty types with `{}` instead of `object`.
 
 Examples of code for this rule with `{ allowWithName: 'Props$' }`:

package/docs/rules/no-explicit-any.mdx

@@ -107,6 +107,8 @@ function greet(param: Array<string>): Array<string> {}
 
 ### `fixToUnknown`
 
+{/* insert option description */}
+
 By default, this rule will not provide automatic ESLint _fixes_: only opt-in _suggestions_.
 Switching types to `unknown` is safer but is likely to cause additional type errors.
 
@@ -114,7 +116,7 @@ Enabling `{ "fixToUnknown": true }` gives the rule an auto-fixer to replace `: a
 
 ### `ignoreRestArgs`
 
-A boolean to specify if arrays from the rest operator are considered okay. `false` by default.
+{/* insert option description */}
 
 The examples below are **incorrect** when `{ignoreRestArgs: false}`, but **correct** when `{ignoreRestArgs: true}`.
 

package/docs/rules/no-extraneous-class.mdx

@@ -221,7 +221,7 @@ 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.
+{/* insert option description */}
 
 <Tabs>
 <TabItem value="❌ Incorrect">
@@ -246,7 +246,7 @@ class NoFields {
 
 ### `allowEmpty`
 
-The `allowEmpty` option adds an exemption for classes that are entirely empty.
+{/* insert option description */}
 
 <Tabs>
 <TabItem value="❌ Incorrect">
@@ -271,7 +271,7 @@ class NoFields {}
 
 ### `allowStaticOnly`
 
-The `allowStaticOnly` option adds an exemption for classes that only contain static members.
+{/* insert option description */}
 
 :::caution
 We strongly recommend against the `allowStaticOnly` exemption.
@@ -299,7 +299,7 @@ class NotEmptyClass {
 
 ### `allowWithDecorator`
 
-The `allowWithDecorator` option adds an exemption for classes decorated with a `@` decorator.
+{/* insert option description */}
 
 <Tabs>
 <TabItem value="❌ Incorrect">

package/docs/rules/no-floating-promises.mdx

@@ -87,6 +87,8 @@ await Promise.all([1, 2, 3].map(async x => x + 1));
 
 ### `checkThenables`
 
+{/* insert option description */}
+
 A ["Thenable"](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise#thenables) value is an object which has a `then` method, such as a `Promise`.
 Other Thenables include TypeScript's built-in `PromiseLike` interface and any custom object that happens to have a `.then()`.
 
@@ -132,8 +134,9 @@ await createMyThenable();
 
 ### `ignoreVoid`
 
-This option, which is `true` by default, allows you to stop the rule reporting promises consumed with the [`void` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/void).
-This can be a good way to explicitly mark a promise as intentionally not awaited.
+{/* insert option description */}
+
+Placing the [`void` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/void) in front of a Promise can be a convenient way to explicitly mark that Promise as intentionally not awaited.
 
 :::warning
 Voiding a Promise doesn't handle it or change the runtime behavior.
@@ -152,11 +155,11 @@ void returnsPromise();
 void Promise.reject('value');
 ```
 
-With this option set to `true`, and if you are using `no-void`, you should turn on the [`allowAsStatement`](https://eslint.org/docs/rules/no-void#allowasstatement) option.
+When this option is set to `true`, if you are using `no-void`, you should turn on the [`allowAsStatement`](https://eslint.org/docs/rules/no-void#allowasstatement) option.
 
 ### `ignoreIIFE`
 
-This allows you to skip checking of async IIFEs (Immediately Invoked Function Expressions).
+{/* insert option description */}
 
 Examples of **correct** code for this rule with `{ ignoreIIFE: true }`:
 
@@ -173,7 +176,9 @@ await (async function () {
 
 ### `allowForKnownSafePromises`
 
-Specific types to be marked as "safe" to be floating. For example, you may need to do this in the case of libraries whose APIs return Promises whose rejections are safely handled by the library.
+{/* insert option description */}
+
+For example, you may need to do this in the case of libraries whose APIs return Promises whose rejections are safely handled by the library.
 
 This option takes the shared [`TypeOrValueSpecifier` format](/packages/type-utils/type-or-value-specifier).
 
@@ -225,7 +230,8 @@ returnsSafePromise();
 
 ### `allowForKnownSafeCalls`
 
-Specific functions to be marked as "safe" to be called to create floating Promises.
+{/* insert option description */}
+
 For example, you may need to do this in the case of libraries whose APIs may be called without handling the resultant Promises.
 
 This option takes the shared [`TypeOrValueSpecifier` format](/packages/type-utils/type-or-value-specifier).

package/docs/rules/no-inferrable-types.mdx

@@ -80,7 +80,7 @@ function fn(a = 5, b = true) {}
 
 ### `ignoreParameters`
 
-Whether to ignore function parameters.
+{/* insert option description */}
 
 When set to true, the following pattern is considered valid:
 
@@ -92,7 +92,7 @@ function foo(a: number = 5, b: boolean = true) {
 
 ### `ignoreProperties`
 
-Whether to ignore class properties.
+{/* insert option description */}
 
 When set to true, the following pattern is considered valid:
 

package/docs/rules/no-invalid-void-type.mdx

@@ -62,9 +62,9 @@ type stillVoid = void | never;
 
 ### `allowInGenericTypeArguments`
 
-Whether `void` can be used as a valid value for generic type parameters.
+{/* insert option description */}
 
-Alternatively, you can provide an array of strings which whitelist which types may accept `void` as a generic type parameter.
+Alternatively, you can provide an array of strings which allowlist which types may accept `void` as a generic type parameter.
 
 Any types considered valid by this option will be considered valid as part of a union type with `void`.
 
@@ -98,7 +98,8 @@ type AllowedVoidUnion = void | Ex.Mx.Tx<void>;
 
 ### `allowAsThisParameter`
 
-Whether a `this` parameter of a function may be `void`.
+{/* insert option description */}
+
 This pattern can be useful to explicitly label function types that do not use a `this` argument. [See the TypeScript docs for more information](https://www.typescriptlang.org/docs/handbook/functions.html#this-parameters-in-callbacks).
 
 This option is `false` by default.

package/docs/rules/no-magic-numbers.mdx

@@ -39,6 +39,8 @@ const defaultOptions: Options = {
 
 ### `ignoreEnums`
 
+{/* insert option description */}
+
 Whether enums used in TypeScript are considered okay. `false` by default.
 
 Examples of **incorrect** code for the `{ "ignoreEnums": false }` option:
@@ -59,6 +61,8 @@ enum foo {
 
 ### `ignoreNumericLiteralTypes`
 
+{/* insert option description */}
+
 Whether numbers used in TypeScript numeric literal types are considered okay. `false` by default.
 
 Examples of **incorrect** code for the `{ "ignoreNumericLiteralTypes": false }` option:
@@ -75,6 +79,8 @@ type SmallPrimes = 2 | 3 | 5 | 7 | 11;
 
 ### `ignoreReadonlyClassProperties`
 
+{/* insert option description */}
+
 Whether `readonly` class properties are considered okay.
 
 Examples of **incorrect** code for the `{ "ignoreReadonlyClassProperties": false }` option:
@@ -101,6 +107,8 @@ class Foo {
 
 ### `ignoreTypeIndexes`
 
+{/* insert option description */}
+
 Whether numbers used to index types are okay. `false` by default.
 
 Examples of **incorrect** code for the `{ "ignoreTypeIndexes": false }` option:

package/docs/rules/no-meaningless-void-operator.mdx

@@ -54,7 +54,7 @@ void bar(1); // discarding a number
 
 ### `checkNever`
 
-Whether to suggest removing `void` when the argument has type `never`.
+{/* insert option description */}
 
 ## When Not To Use It
 

package/docs/rules/no-misused-promises.mdx

@@ -22,6 +22,8 @@ See [`no-floating-promises`](./no-floating-promises.mdx) for detecting unhandled
 
 ### `checksConditionals`
 
+{/* insert option description */}
+
 If you don't want to check conditionals, you can configure the rule with `"checksConditionals": false`:
 
 ```json
@@ -39,6 +41,8 @@ Doing so prevents the rule from looking at code like `if (somePromise)`.
 
 ### `checksVoidReturn`
 
+{/* insert option description */}
+
 Likewise, if you don't want to check functions that return promises where a void return is
 expected, your configuration will look like this:
 
@@ -101,7 +105,7 @@ Disables checking an asynchronous function used as a variable whose return type
 
 ### `checksSpreads`
 
-Whether to warn when `...` spreading a `Promise`.
+{/* insert option description */}
 
 If you don't want to check object spreads, you can add this configuration:
 
@@ -120,6 +124,8 @@ If you don't want to check object spreads, you can add this configuration:
 
 ### `checksConditionals`
 
+{/* insert option description */}
+
 Examples of code for this rule with `checksConditionals: true`:
 
 <Tabs>
@@ -167,6 +173,8 @@ while (await promise) {
 
 ### `checksVoidReturn`
 
+{/* insert option description */}
+
 Examples of code for this rule with `checksVoidReturn: true`:
 
 <Tabs>
@@ -254,6 +262,8 @@ class MyClass implements MyAsyncInterface {
 
 ### `checksSpreads`
 
+{/* insert option description */}
+
 Examples of code for this rule with `checksSpreads: true`:
 
 <Tabs>

package/docs/rules/no-namespace.mdx

@@ -46,6 +46,8 @@ declare module 'foo' {}
 
 ### `allowDeclarations`
 
+{/* insert option description */}
+
 Examples of code with the `{ "allowDeclarations": true }` option:
 
 <Tabs>
@@ -100,6 +102,8 @@ declare module 'foo' {}
 
 ### `allowDefinitionFiles`
 
+{/* insert option description */}
+
 Examples of code for the `{ "allowDefinitionFiles": true }` option:
 
 <Tabs>

package/docs/rules/no-redeclare.mdx

@@ -33,7 +33,9 @@ const defaultOptions: Options = {
 
 ### `ignoreDeclarationMerge`
 
-Whether to ignore declaration merges between the following sets:
+{/* insert option description */}
+
+The following sets will be ignored when this option is enabled:
 
 - interface + interface
 - namespace + namespace

package/docs/rules/no-require-imports.mdx

@@ -38,7 +38,9 @@ import * as lib3 from 'lib3';
 
 ### `allow`
 
-An array of strings. These strings will be compiled into regular expressions with the `u` flag and be used to test against the imported path. A common use case is to allow importing `package.json`. This is because `package.json` commonly lives outside of the TS root directory, so statically importing it would lead to root directory conflicts, especially with `resolveJsonModule` enabled. You can also use it to allow importing any JSON if your environment doesn't support JSON modules, or use it for other cases where `import` statements cannot work.
+{/* insert option description */}
+
+These strings will be compiled into regular expressions with the `u` flag and be used to test against the imported path. A common use case is to allow importing `package.json`. This is because `package.json` commonly lives outside of the TS root directory, so statically importing it would lead to root directory conflicts, especially with `resolveJsonModule` enabled. You can also use it to allow importing any JSON if your environment doesn't support JSON modules, or use it for other cases where `import` statements cannot work.
 
 With `{allow: ['/package\\.json$']}`:
 
@@ -61,7 +63,9 @@ console.log(require('../package.json').version);
 
 ### `allowAsImport`
 
-When set to `true`, the `import x = require(...)` declaration won't be reported.
+{/* insert option description */}
+
+When set to `true`, `import ... = require(...)` declarations won't be reported.
 This is useful if you use certain module options that require strict CommonJS interop semantics.
 
 With `{allowAsImport: true}`:

package/docs/rules/no-restricted-imports.mdx

@@ -17,7 +17,10 @@ This rule adds the following options:
 
 ### `allowTypeImports`
 
-(default: `false`)
+{/* insert option description */}
+
+Whether to allow type-only imports for a path.
+Default: `false`.
 
 You can specify this option for a specific path or pattern as follows:
 

package/docs/rules/no-restricted-types.mdx

@@ -19,7 +19,7 @@ Note that it does not ban the corresponding runtime objects from being used.
 
 ### `types`
 
-An object whose keys are the types you want to ban, and the values are error messages.
+{/* insert option description */}
 
 The type can either be a type name literal (`OldType`) or a a type name with generic parameter instantiation(s) (`OldType<MyArgument>`).
 

package/docs/rules/no-shadow.mdx

@@ -31,7 +31,9 @@ const defaultOptions: Options = {
 
 ### `ignoreTypeValueShadow`
 
-Whether to ignore types named the same as a variable. This is generally safe because you cannot use variables in type locations without a `typeof` operator, so there's little risk of confusion.
+{/* insert option description */}
+
+This is generally safe because you cannot use variables in type locations without a `typeof` operator, so there's little risk of confusion.
 
 Examples of **correct** code with `{ ignoreTypeValueShadow: true }`:
 
@@ -55,7 +57,7 @@ _Shadowing_ specifically refers to two identical identifiers that are in differe
 
 ### `ignoreFunctionTypeParameterNameValueShadow`
 
-Whether to ignore function parameters named the same as a variable.
+{/* insert option description */}
 
 Each of a function type's arguments creates a value variable within the scope of the function type. This is done so that you can reference the type later using the `typeof` operator:
 

package/docs/rules/no-this-alias.mdx

@@ -41,6 +41,8 @@ setTimeout(() => {
 
 ### `allowDestructuring`
 
+{/* insert option description */}
+
 It can sometimes be useful to destructure properties from a class instance, such as retrieving multiple properties from the instance in one of its methods.
 `allowDestructuring` allows those destructures and is `true` by default.
 You can explicitly disallow them by setting `allowDestructuring` to `false`.
@@ -84,6 +86,8 @@ class ComponentLike {
 
 ### `allowedNames`
 
+{/* insert option description */}
+
 `no-this-alias` can alternately be used to allow only a specific list of names as `this` aliases.
 We recommend against this except as a transitory step towards fixing all rule violations.