@typescript-eslint/eslint-plugin 7.5.1-alpha.4 → 7.5.1-alpha.6

package/docs/rules/ban-ts-comment.mdx

@@ -41,9 +41,7 @@ if (false) {
   console.log('hello');
 }
 if (false) {
-  /*
-  @ts-ignore: Unreachable code error
-  */
+  /* @ts-ignore: Unreachable code error */
   console.log('hello');
 }
 ```
@@ -90,9 +88,7 @@ if (false) {
   console.log('hello');
 }
 if (false) {
-  /*
-  @ts-expect-error: Unreachable code error
-  */
+  /* @ts-expect-error: Unreachable code error */
   console.log('hello');
 }
 ```

package/docs/rules/class-methods-use-this.mdx

@@ -70,7 +70,7 @@ Example of incorrect code when `ignoreClassesThatImplementAnInterface` is set to
 <Tabs>
 <TabItem value="❌ Incorrect">
 
-```ts
+```ts option='{ "ignoreClassesThatImplementAnInterface": "public-fields" }'
 class X implements Y {
   method() {}
   property = () => {};
@@ -86,7 +86,7 @@ class X implements Y {
 </TabItem>
 <TabItem value="✅ Correct">
 
-```ts
+```ts option='{ "ignoreClassesThatImplementAnInterface": "public-fields" }'
 class X implements Y {
   method() {}
   property = () => {};

package/docs/rules/consistent-type-exports.mdx

@@ -85,24 +85,6 @@ export type { T };
 export { x };
 ```
 
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts option='{ "fixMixedExportsWithInlineTypeSpecifier": true }'
-export { Button } from 'some-library';
-export type { ButtonProps } from 'some-library';
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts option='{ "fixMixedExportsWithInlineTypeSpecifier": true }'
-export { Button, type ButtonProps } from 'some-library';
-```
-
-</TabItem>
-</Tabs>
-
 ## When Not To Use It
 
 If you use `--isolatedModules` the compiler would error if a type is not re-exported using `export type`.

package/docs/rules/default-param-last.mdx

@@ -16,8 +16,6 @@ It adds support for optional parameters.
 <TabItem value="❌ Incorrect">
 
 ```ts
-/* eslint @typescript-eslint/default-param-last: "error" */
-
 function f(a = 0, b: number) {}
 function f(a: number, b = 0, c: number) {}
 function f(a: number, b?: number, c: number) {}
@@ -39,8 +37,6 @@ class Foo {
 <TabItem value="✅ Correct">
 
 ```ts
-/* eslint @typescript-eslint/default-param-last: "error" */
-
 function f(a = 0) {}
 function f(a: number, b = 0) {}
 function f(a: number, b?: number) {}

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

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

package/docs/rules/member-ordering.mdx

@@ -1011,9 +1011,9 @@ interface Foo {
   b(): void;
   a: boolean;
 
-  [a: string]: number; // Order doesn't matter (no sortable identifier)
-  new (): Bar; // Order doesn't matter (no sortable identifier)
-  (): Baz; // Order doesn't matter (no sortable identifier)
+  [a: string]: number;
+  new (): Bar;
+  (): Baz;
 }
 ```
 
@@ -1022,12 +1022,12 @@ interface Foo {
 
 ```ts option='{ "default": { "memberTypes": "never", "order": "alphabetically" } }'
 interface Foo {
+  [a: string]: number;
   a: boolean;
   b(): void;
 
-  [a: string]: number; // Order doesn't matter (no sortable identifier)
-  new (): Bar; // Order doesn't matter (no sortable identifier)
-  (): Baz; // Order doesn't matter (no sortable identifier)
+  (): Baz;
+  new (): Bar;
 }
 ```
 

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

@@ -293,7 +293,7 @@ class NotEmptyClass {
 
 ### `allowWithDecorator`
 
-The `allowWithDecorator` option adds an exemption for classes that contain a member decorated with a `@` decorator.
+The `allowWithDecorator` option adds an exemption for classes decorated with a `@` decorator.
 
 <Tabs>
 <TabItem value="❌ Incorrect">
@@ -308,8 +308,8 @@ class Constants {
 <TabItem value="✅ Correct">
 
 ```ts option='{ "allowWithDecorator": true }'
+@logOnRead()
 class Constants {
-  @logOnRead()
   static readonly version = 42;
 }
 ```

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

@@ -104,7 +104,7 @@ This allows you to skip checking of async IIFEs (Immediately Invoked function Ex
 
 Examples of **correct** code for this rule with `{ ignoreIIFE: true }`:
 
-<!-- prettier-ignore -->
+{/* prettier-ignore */}
 ```ts option='{ "ignoreIIFE": true }' showPlaygroundButton
 await (async function () {
   await res(1);

package/docs/rules/no-implied-eval.mdx

@@ -36,8 +36,6 @@ This rule aims to eliminate implied `eval()` through the use of `new Function()`
 <TabItem value="❌ Incorrect">
 
 ```ts
-/* eslint @typescript-eslint/no-implied-eval: "error" */
-
 setTimeout('alert(`Hi!`);', 100);
 
 setInterval('alert(`Hi!`);', 100);
@@ -65,8 +63,6 @@ const fn = new Function('a', 'b', 'return a + b');
 <TabItem value="✅ Correct">
 
 ```ts
-/* eslint @typescript-eslint/no-implied-eval: "error" */
-
 setTimeout(function () {
   alert('Hi!');
 }, 100);

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

@@ -44,7 +44,7 @@ function bar(x: number) {
   void x; // discarding a number
   return 2;
 }
-void bar(); // discarding a number
+void bar(1); // discarding a number
 ```
 
 </TabItem>

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

@@ -45,14 +45,14 @@ With `{allow: ['/package\\.json$']}`:
 <Tabs>
 <TabItem value="❌ Incorrect">
 
-```ts
+```ts option='{ "allow": ["/package.json$"] }'
 console.log(require('../data.json').version);
 ```
 
 </TabItem>
 <TabItem value="✅ Correct">
 
-```ts
+```ts option='{ "allow": ["/package.json$"] }'
 console.log(require('../package.json').version);
 ```
 

package/docs/rules/no-unnecessary-type-assertion.mdx

@@ -24,17 +24,17 @@ const bar = foo!;
 ```
 
 ```ts
-const foo = <3>3;
+const foo = <number>(3 + 5);
 ```
 
 ```ts
-type Foo = 3;
-const foo = <Foo>3;
+type Foo = number;
+const foo = <Foo>(3 + 5);
 ```
 
 ```ts
-type Foo = 3;
-const foo = 3 as Foo;
+type Foo = number;
+const foo = (3 + 5) as Foo;
 ```
 
 ```ts

package/docs/rules/no-var-requires.mdx

@@ -45,14 +45,14 @@ With `{allow: ['/package\\.json$']}`:
 <Tabs>
 <TabItem value="❌ Incorrect">
 
-```ts
+```ts option='{ "allow": ["/package.json$"] }'
 const foo = require('../data.json');
 ```
 
 </TabItem>
 <TabItem value="✅ Correct">
 
-```ts
+```ts option='{ "allow": ["/package.json$"] }'
 const foo = require('../package.json');
 ```
 

package/docs/rules/non-nullable-type-assertion-style.mdx

@@ -23,7 +23,7 @@ This rule reports when an `as` cast is doing the same job as a `!` would, and su
 <TabItem value="❌ Incorrect">
 
 ```ts
-const maybe = Math.random() > 0.5 ? '' : undefined;
+const maybe: string | undefined = Math.random() > 0.5 ? '' : undefined;
 
 const definitely = maybe as string;
 const alsoDefinitely = <string>maybe;
@@ -33,7 +33,7 @@ const alsoDefinitely = <string>maybe;
 <TabItem value="✅ Correct">
 
 ```ts
-const maybe = Math.random() > 0.5 ? '' : undefined;
+const maybe: string | undefined = Math.random() > 0.5 ? '' : undefined;
 
 const definitely = maybe!;
 const alsoDefinitely = maybe!;

package/docs/rules/only-throw-error.mdx

@@ -39,10 +39,10 @@ throw `${err}`;
 const err = '';
 throw err;
 
-function err() {
+function getError() {
   return '';
 }
-throw err();
+throw getError();
 
 const foo = {
   bar: '',
@@ -70,10 +70,10 @@ try {
 const err = new Error();
 throw err;
 
-function err() {
+function getError() {
   return new Error();
 }
-throw err();
+throw getError();
 
 const foo = {
   bar: new Error(),

package/docs/rules/prefer-destructuring.mdx

@@ -87,14 +87,14 @@ Examples with `{ enforceForDeclarationWithTypeAnnotation: true }`:
 <Tabs>
 <TabItem value="❌ Incorrect">
 
-```ts
+```ts option='{ "object": true }, { "enforceForDeclarationWithTypeAnnotation": true }'
 const x: string = obj.x;
 ```
 
 </TabItem>
 <TabItem value="✅ Correct">
 
-```ts
+```ts option='{ "object": true }, { "enforceForDeclarationWithTypeAnnotation": true }'
 const { x }: { x: string } = obj;
 ```
 

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

@@ -199,12 +199,26 @@ thing && thing.toString();
 
 When this option is `true` the rule will check operands that are typed as `boolean` when inspecting "loose boolean" operands.
 
+:::note
+
+This rule intentionally ignores the following case:
+
+```ts
+declare const x: false | { a: string };
+x && x.a;
+!x || x.a;
+```
+
+The boolean expression narrows out the non-nullish falsy cases - so converting the chain to `x?.a` would introduce a type error.
+
+:::
+
 <Tabs>
 
 <TabItem value="❌ Incorrect for `checkBoolean: true`">
 
 ```ts option='{ "checkBoolean": true }'
-declare const thing: boolean;
+declare const thing: true;
 
 thing && thing.toString();
 ```
@@ -214,7 +228,7 @@ thing && thing.toString();
  for `checkBoolean: false`
 
 ```ts option='{ "checkBoolean": false }'
-declare const thing: boolean;
+declare const thing: true;
 
 thing && thing.toString();
 ```
@@ -257,7 +271,7 @@ When this option is `true` the rule will skip operands that are not typed with `
 
 <TabItem value="❌ Incorrect for `requireNullish: true`">
 
-```ts option='{ "requireNullish": true }'
+```ts option='{ "requireNullish": true }' skipValidation
 declare const thing1: string | null;
 thing1 && thing1.toString();
 ```

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

@@ -303,7 +303,7 @@ Examples of code for this rule with `{ignoreInferredTypes: true}`:
 <Tabs>
 <TabItem value="❌ Incorrect">
 
-```ts option='{ "ignoreInferredTypes": true }'
+```ts option='{ "ignoreInferredTypes": true }' skipValidation
 import { acceptsCallback, CallbackOptions } from 'external-dependency';
 
 acceptsCallback((options: CallbackOptions) => {});
@@ -336,7 +336,7 @@ acceptsCallback(options => {});
 <details>
 <summary>external-dependency.d.ts</summary>
 
-```ts option='{ "ignoreInferredTypes": true }'
+```ts option='{ "ignoreInferredTypes": true }' skipValidation
 export interface CallbackOptions {
   prop: string;
 }

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

@@ -101,7 +101,7 @@ Examples of code with `{ "allowedPromiseNames": ["Bluebird"] }`:
 <TabItem value="❌ Incorrect">
 
 ```ts option='{ "allowedPromiseNames": ["Bluebird"] }'
-import { Bluebird } from 'bluebird';
+class Bluebird {}
 
 const returnsBluebird = () => new Bluebird(() => {});
 ```
@@ -110,7 +110,7 @@ const returnsBluebird = () => new Bluebird(() => {});
 <TabItem value="✅ Correct">
 
 ```ts option='{ "allowedPromiseNames": ["Bluebird"] }'
-import { Bluebird } from 'bluebird';
+class Bluebird {}
 
 const returnsBluebird = async () => new Bluebird(() => {});
 ```

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

@@ -196,23 +196,23 @@ Examples of code for this rule with `{ skipCompoundAssignments: false }`:
 <Tabs>
 <TabItem value="❌ Incorrect">
 
-```ts option='{ "skipCompoundAssignments": true }'
-let foo: string | undefined;
-foo += 'some data';
+```ts option='{ "skipCompoundAssignments": false }'
+let foo: bigint = 0n;
+foo += 1;
 
-let bar: string = '';
-bar += 0;
+let bar: number[] = [1];
+bar += 1;
 ```
 
 </TabItem>
 <TabItem value="✅ Correct">
 
-```ts option='{ "skipCompoundAssignments": true }'
-let foo: number = 0;
-foo += 1;
+```ts option='{ "skipCompoundAssignments": false }'
+let foo: bigint = 0n;
+foo += 1n;
 
-let bar = '';
-bar += 'test';
+let bar: number = 1;
+bar += 1;
 ```
 
 </TabItem>

package/docs/rules/space-before-blocks.mdx

@@ -15,7 +15,7 @@ It adds support for interfaces and enums.
 <Tabs>
 <TabItem value="❌ Incorrect">
 
-<!-- prettier-ignore -->
+{/* prettier-ignore */}
 ```ts
 enum Breakpoint{
   Large,

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

@@ -61,12 +61,6 @@ while (obj) {
 <TabItem value="✅ Correct">
 
 ```tsx
-// Using logical operator short-circuiting is allowed
-const Component = () => {
-  const entry = map.get('foo') || {};
-  return entry && <p>Name: {entry.name}</p>;
-};
-
 // nullable values should be checked explicitly against null or undefined
 let num: number | undefined = 0;
 if (num != null) {

package/docs/rules/type-annotation-spacing.mdx

@@ -257,7 +257,7 @@ class Foo {
 }
 
 type Foo = {
-    name: (name : string)=>string;
+    name : (name : string)=>string;
 }
 
 type Foo = ()=>{};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "7.5.1-alpha.4",
+  "version": "7.5.1-alpha.6",
   "description": "TypeScript plugin for ESLint",
   "files": [
     "dist",
@@ -62,10 +62,10 @@
   },
   "dependencies": {
     "@eslint-community/regexpp": "^4.5.1",
-    "@typescript-eslint/scope-manager": "7.5.1-alpha.4",
-    "@typescript-eslint/type-utils": "7.5.1-alpha.4",
-    "@typescript-eslint/utils": "7.5.1-alpha.4",
-    "@typescript-eslint/visitor-keys": "7.5.1-alpha.4",
+    "@typescript-eslint/scope-manager": "7.5.1-alpha.6",
+    "@typescript-eslint/type-utils": "7.5.1-alpha.6",
+    "@typescript-eslint/utils": "7.5.1-alpha.6",
+    "@typescript-eslint/visitor-keys": "7.5.1-alpha.6",
     "debug": "^4.3.4",
     "graphemer": "^1.4.0",
     "ignore": "^5.2.4",
@@ -76,9 +76,10 @@
   "devDependencies": {
     "@types/debug": "*",
     "@types/marked": "*",
+    "@types/mdast": "^4.0.3",
     "@types/natural-compare": "*",
-    "@typescript-eslint/rule-schema-to-typescript-types": "7.5.1-alpha.4",
-    "@typescript-eslint/rule-tester": "7.5.1-alpha.4",
+    "@typescript-eslint/rule-schema-to-typescript-types": "7.5.1-alpha.6",
+    "@typescript-eslint/rule-tester": "7.5.1-alpha.6",
     "ajv": "^6.12.6",
     "chalk": "^5.3.0",
     "cross-env": "^7.0.3",
@@ -90,11 +91,15 @@
     "json-schema": "*",
     "markdown-table": "^3.0.3",
     "marked": "^5.1.1",
+    "mdast-util-from-markdown": "^2.0.0",
+    "mdast-util-mdx": "^3.0.0",
+    "micromark-extension-mdxjs": "^3.0.0",
     "prettier": "^3.0.3",
     "rimraf": "*",
     "title-case": "^3.0.3",
     "tsx": "*",
-    "typescript": "*"
+    "typescript": "*",
+    "unist-util-visit": "^5.0.0"
   },
   "peerDependencies": {
     "@typescript-eslint/parser": "^7.0.0",