@typescript-eslint/eslint-plugin 8.0.0-alpha.9 → 8.0.0

package/dist/util/objectIterators.js

@@ -1,13 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.objectReduceKey = exports.objectMapKey = exports.objectForEachKey = void 0;
+exports.objectForEachKey = objectForEachKey;
+exports.objectMapKey = objectMapKey;
+exports.objectReduceKey = objectReduceKey;
 function objectForEachKey(obj, callback) {
     const keys = Object.keys(obj);
     for (const key of keys) {
         callback(key);
     }
 }
-exports.objectForEachKey = objectForEachKey;
 function objectMapKey(obj, callback) {
     const values = [];
     objectForEachKey(obj, key => {
@@ -15,7 +16,6 @@ function objectMapKey(obj, callback) {
     });
     return values;
 }
-exports.objectMapKey = objectMapKey;
 function objectReduceKey(obj, callback, initial) {
     let accumulator = initial;
     objectForEachKey(obj, key => {
@@ -23,5 +23,4 @@ function objectReduceKey(obj, callback, initial) {
     });
     return accumulator;
 }
-exports.objectReduceKey = objectReduceKey;
 //# sourceMappingURL=objectIterators.js.map

package/dist/util/objectIterators.js.map

@@ -1 +1 @@
-{"version":3,"file":"objectIterators.js","sourceRoot":"","sources":["../../src/util/objectIterators.ts"],"names":[],"mappings":";;;AAAA,SAAS,gBAAgB,CACvB,GAAM,EACN,QAAgC;IAEhC,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC9B,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,QAAQ,CAAC,GAAG,CAAC,CAAC;IAChB,CAAC;AACH,CAAC;AAyBQ,4CAAgB;AAvBzB,SAAS,YAAY,CACnB,GAAM,EACN,QAAkC;IAElC,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,gBAAgB,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE;QAC1B,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;IAC7B,CAAC,CAAC,CAAC;IACH,OAAO,MAAM,CAAC;AAChB,CAAC;AAc0B,oCAAY;AAZvC,SAAS,eAAe,CACtB,GAAM,EACN,QAAyD,EACzD,OAAoB;IAEpB,IAAI,WAAW,GAAG,OAAO,CAAC;IAC1B,gBAAgB,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE;QAC1B,WAAW,GAAG,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC;IAC3C,CAAC,CAAC,CAAC;IACH,OAAO,WAAW,CAAC;AACrB,CAAC;AAEwC,0CAAe"}
+{"version":3,"file":"objectIterators.js","sourceRoot":"","sources":["../../src/util/objectIterators.ts"],"names":[],"mappings":";;AAiCS,4CAAgB;AAAE,oCAAY;AAAE,0CAAe;AAjCxD,SAAS,gBAAgB,CACvB,GAAM,EACN,QAAgC;IAEhC,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC9B,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,QAAQ,CAAC,GAAG,CAAC,CAAC;IAChB,CAAC;AACH,CAAC;AAED,SAAS,YAAY,CACnB,GAAM,EACN,QAAkC;IAElC,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,gBAAgB,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE;QAC1B,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;IAC7B,CAAC,CAAC,CAAC;IACH,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,SAAS,eAAe,CACtB,GAAM,EACN,QAAyD,EACzD,OAAoB;IAEpB,IAAI,WAAW,GAAG,OAAO,CAAC;IAC1B,gBAAgB,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE;QAC1B,WAAW,GAAG,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC;IAC3C,CAAC,CAAC,CAAC;IACH,OAAO,WAAW,CAAC;AACrB,CAAC"}

package/dist/util/referenceContainsTypeQuery.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.referenceContainsTypeQuery = referenceContainsTypeQuery;
+const utils_1 = require("@typescript-eslint/utils");
+/**
+ * Recursively checks whether a given reference has a type query declaration among its parents
+ */
+function referenceContainsTypeQuery(node) {
+    switch (node.type) {
+        case utils_1.AST_NODE_TYPES.TSTypeQuery:
+            return true;
+        case utils_1.AST_NODE_TYPES.TSQualifiedName:
+        case utils_1.AST_NODE_TYPES.Identifier:
+            return referenceContainsTypeQuery(node.parent);
+        default:
+            // if we find a different node, there's no chance that we're in a TSTypeQuery
+            return false;
+    }
+}
+//# sourceMappingURL=referenceContainsTypeQuery.js.map

package/dist/util/referenceContainsTypeQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"referenceContainsTypeQuery.js","sourceRoot":"","sources":["../../src/util/referenceContainsTypeQuery.ts"],"names":[],"mappings":";;AAMA,gEAaC;AAlBD,oDAA0D;AAE1D;;GAEG;AACH,SAAgB,0BAA0B,CAAC,IAAmB;IAC5D,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC;QAClB,KAAK,sBAAc,CAAC,WAAW;YAC7B,OAAO,IAAI,CAAC;QAEd,KAAK,sBAAc,CAAC,eAAe,CAAC;QACpC,KAAK,sBAAc,CAAC,UAAU;YAC5B,OAAO,0BAA0B,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAEjD;YACE,6EAA6E;YAC7E,OAAO,KAAK,CAAC;IACjB,CAAC;AACH,CAAC"}

package/dist/util/scopeUtils.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isReferenceToGlobalFunction = isReferenceToGlobalFunction;
+function isReferenceToGlobalFunction(calleeName, node, sourceCode) {
+    const ref = sourceCode
+        .getScope(node)
+        .references.find(ref => ref.identifier.name === calleeName);
+    // ensure it's the "global" version
+    return !ref?.resolved?.defs.length;
+}
+//# sourceMappingURL=scopeUtils.js.map

package/dist/util/scopeUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scopeUtils.js","sourceRoot":"","sources":["../../src/util/scopeUtils.ts"],"names":[],"mappings":";;AAGA,kEAWC;AAXD,SAAgB,2BAA2B,CACzC,UAAkB,EAClB,IAAmB,EACnB,UAAsB;IAEtB,MAAM,GAAG,GAAG,UAAU;SACnB,QAAQ,CAAC,IAAI,CAAC;SACd,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,KAAK,UAAU,CAAC,CAAC;IAE9D,mCAAmC;IACnC,OAAO,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC;AACrC,CAAC"}

package/docs/rules/array-type.mdx

@@ -42,7 +42,8 @@ const y: readonly string[] = ['a', 'b'];
 
 ### `"generic"`
 
-Always use `Array<T>` or `ReadonlyArray<T>` for all array types.
+Always use `Array<T>`, `ReadonlyArray<T>`, or `Readonly<Array<T>>` for all array types.
+`readonly T[]` will be modified to `ReadonlyArray<T>` and `Readonly<T[]>` will be modified to `Readonly<Array<T>`.
 
 <Tabs>
 <TabItem value="❌ Incorrect">
@@ -50,6 +51,7 @@ Always use `Array<T>` or `ReadonlyArray<T>` for all array types.
 ```ts option='{ "default": "generic" }'
 const x: string[] = ['a', 'b'];
 const y: readonly string[] = ['a', 'b'];
+const z: Readonly<string[]> = ['a', 'b'];
 ```
 
 </TabItem>
@@ -58,6 +60,7 @@ const y: readonly string[] = ['a', 'b'];
 ```ts option='{ "default": "generic" }'
 const x: Array<string> = ['a', 'b'];
 const y: ReadonlyArray<string> = ['a', 'b'];
+const z: Readonly<Array<string>> = ['a', 'b'];
 ```
 
 </TabItem>

package/docs/rules/ban-types.md

@@ -0,0 +1,22 @@
+:::danger Deprecated
+
+The old `ban-types` rule encompassed multiple areas of functionality, and so has been split into several rules.
+
+**[`no-restricted-types`](./no-restricted-types.mdx)** is the new rule for banning a configurable list of type names.
+It has no options enabled by default and is akin to rules like [`no-restricted-globals`](https://eslint.org/docs/latest/rules/no-restricted-globals), [`no-restricted-properties`](https://eslint.org/docs/latest/rules/no-restricted-properties), and [`no-restricted-syntax`](https://eslint.org/docs/latest/rules/no-restricted-syntax).
+
+The default options from `ban-types` are now covered by:
+
+- **[`no-empty-object-type`](./no-empty-object-type.mdx)**: banning the built-in `{}` type in confusing locations
+- **[`no-unsafe-function-type`](./no-unsafe-function-type.mdx)**: banning the built-in `Function`
+- **[`no-wrapper-object-types`](./no-wrapper-object-types.mdx)**: banning `Object` and built-in class wrappers such as `Number`
+
+`ban-types` itself is removed in typescript-eslint v8.
+See [Announcing typescript-eslint v8 Beta](/blog/announcing-typescript-eslint-v8-beta) for more details.
+:::
+
+<!-- This doc file has been left on purpose because `ban-types` is a well-known
+rule. This exists to help direct people to the replacement rules.
+
+Note that there is no actual way to get to this page in the normal navigation,
+so end-users will only be able to get to this page from the search bar. -->

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

@@ -31,7 +31,7 @@ const defaultOptions: Options = {
 
 ### `ignoreOverrideMethods`
 
-Makes the rule to ignores any class member explicitly marked with `override`.
+Makes the rule ignore any class member explicitly marked with `override`.
 
 Example of a correct code when `ignoreOverrideMethods` is set to `true`:
 

package/docs/rules/consistent-indexed-object-style.mdx

@@ -23,7 +23,7 @@ type Foo = {
 type Foo = Record<string, unknown>;
 ```
 
-Keeping to one declaration form consistently improve code readability.
+Using one declaration form consistently improves code readability.
 
 ## Options
 

package/docs/rules/naming-convention.mdx

@@ -583,6 +583,22 @@ This allows you to emulate the old `interface-name-prefix` rule.
 }
 ```
 
+### Enforce that function names are either in camelCase or PascalCase
+
+Function names are typically camelCase, but UI library components (especially JSX, such as React and Solid) use PascalCase to distinguish them from intrinsic elements. If you are writing function components, consider allowing both camelCase and PascalCase for functions.
+
+```json
+{
+  "@typescript-eslint/naming-convention": [
+    "error",
+    {
+      "selector": "function",
+      "format": ["camelCase", "PascalCase"]
+    }
+  ]
+}
+```
+
 ### Enforce that variable and function names are in camelCase
 
 This allows you to lint multiple type with same pattern.

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

@@ -10,7 +10,7 @@ import TabItem from '@theme/TabItem';
 > See **https://typescript-eslint.io/rules/no-base-to-string** for documentation.
 
 JavaScript will call `toString()` on an object when it is converted to a string, such as when `+` adding to a string or in `${}` template literals.
-The default Object `.toString()` returns `"[object Object]"`, which is often not what was intended.
+The default Object `.toString()` uses the format `"[object Object]"`, which is often not what was intended.
 This rule reports on stringified values that aren't primitives and don't define a more useful `.toString()` method.
 
 > Note that `Function` provides its own `.toString()` that returns the function's code.

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

@@ -23,7 +23,7 @@ For example, given `type A = string` and `type T = string | A`, this rule would
 ```ts
 type T1 = 'A' | 'A';
 
-type T2 = A | A | B;
+type T2 = string | string | number;
 
 type T3 = { a: string } & { a: string };
 
@@ -40,7 +40,7 @@ type T5 = StringA | StringB;
 ```ts
 type T1 = 'A' | 'B';
 
-type T2 = A | B | C;
+type T2 = string | number | boolean;
 
 type T3 = { a: string } & { b: string };
 
@@ -70,3 +70,7 @@ It can sometimes be useful for the sake of documentation to include aliases for
 You might consider using [ESLint disable comments](https://eslint.org/docs/latest/use/configure/rules#using-configuration-comments-1) for those specific situations instead of completely disabling this rule.
 
 > In some of those cases, [branded types](https://basarat.gitbook.io/typescript/main-1/nominaltyping#using-interfaces) might be a type-safe way to represent the underlying data types.
+
+## Related To
+
+- [no-redundant-type-constituents](./no-redundant-type-constituents.mdx)

package/docs/rules/no-dynamic-delete.mdx

@@ -11,9 +11,13 @@ import TabItem from '@theme/TabItem';
 
 Deleting dynamically computed keys can be dangerous and in some cases not well optimized.
 Using the `delete` operator on keys that aren't runtime constants could be a sign that you're using the wrong data structures.
-Using `Object`s with added and removed keys can cause occasional edge case bugs, such as if a key is named `"hasOwnProperty"`.
+Consider using a `Map` or `Set` if you’re using an object as a key-value collection.
 
-> Consider using a `Map` or `Set` if you’re storing collections of objects.
+Dynamically adding and removing keys from objects can cause occasional edge case bugs. For example, some objects use "hidden properties" (such as `__data`) for private storage, and deleting them can break the object's internal state. Furthermore, [`delete`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete) cannot remove inherited properties or non-configurable properties. This makes it interact badly with anything more complicated than a plain object:
+
+- The [`length`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/length) of an array is non-configurable, and deleting it is a runtime error.
+- You can't remove properties on the prototype of an object, such as deleting methods from class instances.
+- Sometimes, `delete` only removes the own property, leaving the inherited property intact. For example, deleting the [`name`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name) property of a function only removes the own property, but there's also a `Function.prototype.name` property that remains.
 
 ## Examples
 
@@ -21,10 +25,6 @@ Using `Object`s with added and removed keys can cause occasional edge case bugs,
 <TabItem value="❌ Incorrect">
 
 ```ts
-// Can be replaced with the constant equivalents, such as container.aaa
-delete container['aaa'];
-delete container['Infinity'];
-
 // Dynamic, difficult-to-reason-about lookups
 const name = 'name';
 delete container[name];
@@ -44,7 +44,12 @@ delete container.aaa;
 
 // Constants that must be accessed by []
 delete container[7];
-delete container['-Infinity'];
+delete container[-1];
+
+// All strings are allowed, to be compatible with the noPropertyAccessFromIndexSignature
+// TS compiler option
+delete container['aaa'];
+delete container['Infinity'];
 ```
 
 </TabItem>

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

@@ -42,6 +42,8 @@ class HelloWorldLogger {
     console.log('Hello, world!');
   }
 }
+
+abstract class Foo {}
 ```
 
 </TabItem>
@@ -57,6 +59,10 @@ export function isProduction() {
 function logHelloWorld() {
   console.log('Hello, world!');
 }
+
+abstract class Foo {
+  abstract prop: string;
+}
 ```
 
 </TabItem>

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

@@ -17,6 +17,7 @@ Valid ways of handling a Promise-valued statement include:
 
 - `await`ing it
 - `return`ing it
+- `void`ing it
 - Calling its `.then()` with two arguments
 - Calling its `.catch()` with one argument
 
@@ -63,6 +64,9 @@ await promise;
 async function returnsPromise() {
   return 'value';
 }
+
+void returnsPromise();
+
 returnsPromise().then(
   () => {},
   () => {},
@@ -80,9 +84,54 @@ await Promise.all([1, 2, 3].map(async x => x + 1));
 
 ## Options
 
+### `checkThenables`
+
+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()`.
+
+The `checkThenables` option triggers `no-floating-promises` to also consider all values that satisfy the Thenable shape (a `.then()` method that takes two callback parameters), not just Promises.
+This can be useful if your code works with older `Promise` polyfills instead of the native `Promise` class.
+
+<Tabs>
+<TabItem value="❌ Incorrect">
+
+```ts option='{"checkThenables": true}'
+declare function createPromiseLike(): PromiseLike<string>;
+
+createPromiseLike();
+
+interface MyThenable {
+  then(onFulfilled: () => void, onRejected: () => void): MyThenable;
+}
+
+declare function createMyThenable(): MyThenable;
+
+createMyThenable();
+```
+
+</TabItem>
+<TabItem value="✅ Correct">
+
+```ts option='{"checkThenables": true}'
+declare function createPromiseLike(): PromiseLike<string>;
+
+await createPromiseLike();
+
+interface MyThenable {
+  then(onFulfilled: () => void, onRejected: () => void): MyThenable;
+}
+
+declare function createMyThenable(): MyThenable;
+
+await createMyThenable();
+```
+
+</TabItem>
+</Tabs>
+
 ### `ignoreVoid`
 
-This allows you to stop the rule reporting promises consumed with void operator.
+This option, which is `true` by default, allows you to stop the rule reporting promises consumed with void operator.
 This can be a good way to explicitly mark a promise as intentionally not awaited.
 
 Examples of **correct** code for this rule with `{ ignoreVoid: true }`:
@@ -100,7 +149,7 @@ With this option set to `true`, and if you are using `no-void`, you should turn
 
 ### `ignoreIIFE`
 
-This allows you to skip checking of async IIFEs (Immediately Invoked function Expressions).
+This allows you to skip checking of async IIFEs (Immediately Invoked Function Expressions).
 
 Examples of **correct** code for this rule with `{ ignoreIIFE: true }`:
 
@@ -115,6 +164,101 @@ await (async function () {
 })();
 ```
 
+### `allowForKnownSafePromises`
+
+This option allows marking specific types 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.
+
+This option takes an array of type specifiers to consider safe.
+Each item in the array must have one of the following forms:
+
+- A type defined in a file (`{ from: "file", name: "Foo", path: "src/foo-file.ts" }` with `path` being an optional path relative to the project root directory)
+- A type from the default library (`{ from: "lib", name: "PromiseLike" }`)
+- A type from a package (`{ from: "package", name: "Foo", package: "foo-lib" }`, this also works for types defined in a typings package).
+
+Examples of code for this rule with:
+
+```json
+{
+  "allowForKnownSafePromises": [
+    { "from": "file", "name": "SafePromise" },
+    { "from": "lib", "name": "PromiseLike" },
+    { "from": "package", "name": "Bar", "package": "bar-lib" }
+  ]
+}
+```
+
+<Tabs>
+<TabItem value="❌ Incorrect">
+
+```ts option='{"allowForKnownSafePromises":[{"from":"file","name":"SafePromise"},{"from":"lib","name":"PromiseLike"},{"from":"package","name":"Bar","package":"bar-lib"}]}'
+let promise: Promise<number> = Promise.resolve(2);
+promise;
+
+function returnsPromise(): Promise<number> {
+  return Promise.resolve(42);
+}
+
+returnsPromise();
+```
+
+</TabItem>
+<TabItem value="✅ Correct">
+
+```ts option='{"allowForKnownSafePromises":[{"from":"file","name":"SafePromise"},{"from":"lib","name":"PromiseLike"},{"from":"package","name":"Bar","package":"bar-lib"}]}'
+// promises can be marked as safe by using branded types
+type SafePromise = Promise<number> & { __linterBrands?: string };
+
+let promise: SafePromise = Promise.resolve(2);
+promise;
+
+function returnsSafePromise(): SafePromise {
+  return Promise.resolve(42);
+}
+
+returnsSafePromise();
+```
+
+</TabItem>
+</Tabs>
+
+### `allowForKnownSafeCalls`
+
+This option allows marking specific functions as "safe" to be called to create floating Promises.
+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 same array format as [`allowForKnownSafePromises`](#allowForKnownSafePromises).
+
+Examples of code for this rule with:
+
+```json
+{
+  "allowForKnownSafeCalls": [
+    { "from": "file", "name": "safe", "path": "input.ts" }
+  ]
+}
+```
+
+<Tabs>
+<TabItem value="❌ Incorrect">
+
+```ts option='{"allowForKnownSafeCalls":[{"from":"file","name":"safe","path":"input.ts"}]}'
+declare function unsafe(...args: unknown[]): Promise<void>;
+
+unsafe('...', () => {});
+```
+
+</TabItem>
+<TabItem value="✅ Correct">
+
+```ts option='{"allowForKnownSafeCalls":[{"from":"file","name":"safe","path":"input.ts"}]}' skipValidation
+declare function safe(...args: unknown[]): Promise<void>;
+
+safe('...', () => {});
+```
+
+</TabItem>
+</Tabs>
+
 ## When Not To Use It
 
 This rule can be difficult to enable on large existing projects that set up many floating Promises.

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

@@ -127,19 +127,18 @@ Examples of code for this rule with `checksVoidReturn: true`:
 
 ```ts option='{ "checksVoidReturn": true }'
 [1, 2, 3].forEach(async value => {
-  await doSomething(value);
+  await fetch(`/${value}`);
 });
 
-new Promise(async (resolve, reject) => {
-  await doSomething();
+new Promise<void>(async (resolve, reject) => {
+  await fetch('/');
   resolve();
 });
 
-const eventEmitter = new EventEmitter();
-eventEmitter.on('some-event', async () => {
-  synchronousCall();
-  await doSomething();
-  otherSynchronousCall();
+document.addEventListener('click', async () => {
+  console.log('synchronous call');
+  await fetch('/');
+  console.log('synchronous call');
 });
 ```
 
@@ -169,8 +168,7 @@ new Promise((resolve, reject) => {
 });
 
 // Name the async wrapper to call it later
-const eventEmitter = new EventEmitter();
-eventEmitter.on('some-event', () => {
+document.addEventListener('click', () => {
   const handler = async () => {
     await doSomething();
     otherSynchronousCall();
@@ -210,30 +208,30 @@ Examples of code for this rule with `checksSpreads: true`:
 <TabItem value="❌ Incorrect">
 
 ```ts option='{ "checksSpreads": true }'
-const getData = () => someAsyncOperation({ myArg: 'foo' });
+const getData = () => fetch('/');
 
-return { foo: 42, ...getData() };
+console.log({ foo: 42, ...getData() });
 
-const getData2 = async () => {
-  await someAsyncOperation({ myArg: 'foo' });
+const awaitData = async () => {
+  await fetch('/');
 };
 
-return { foo: 42, ...getData2() };
+console.log({ foo: 42, ...awaitData() });
 ```
 
 </TabItem>
 <TabItem value="✅ Correct">
 
 ```ts option='{ "checksSpreads": true }'
-const getData = () => someAsyncOperation({ myArg: 'foo' });
+const getData = () => fetch('/');
 
-return { foo: 42, ...(await getData()) };
+console.log({ foo: 42, ...(await getData()) });
 
-const getData2 = async () => {
-  await someAsyncOperation({ myArg: 'foo' });
+const awaitData = async () => {
+  await fetch('/');
 };
 
-return { foo: 42, ...(await getData2()) };
+console.log({ foo: 42, ...(await awaitData()) });
 ```
 
 </TabItem>

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

@@ -96,3 +96,7 @@ If you strongly feel a preference for these unnecessary type constituents, this
 - [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)
+
+## Related To
+
+- [no-duplicate-type-constituents](./no-duplicate-type-constituents.mdx)

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

@@ -38,7 +38,7 @@ import * as lib3 from 'lib3';
 
 ### `allow`
 
-A 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.
+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.
 
 With `{allow: ['/package\\.json$']}`:
 
@@ -59,6 +59,33 @@ console.log(require('../package.json').version);
 </TabItem>
 </Tabs>
 
+### `allowAsImport`
+
+When set to `true`, the `import x = require(...)` declaration won't be reported.
+This is useful if you use certain module options that require strict CommonJS interop semantics.
+
+With `{allowAsImport: true}`:
+
+<Tabs>
+<TabItem value="❌ Incorrect">
+
+```ts option='{ "allowAsImport": true }'
+var foo = require('foo');
+const foo = require('foo');
+let foo = require('foo');
+```
+
+</TabItem>
+<TabItem value="✅ Correct">
+
+```ts option='{ "allowAsImport": true }'
+import foo = require('foo');
+import foo from 'foo';
+```
+
+</TabItem>
+</Tabs>
+
 ## When Not To Use It
 
 If your project frequently uses older CommonJS `require`s, then this rule might not be applicable to you.

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

@@ -0,0 +1,71 @@
+---
+description: 'Disallow certain types.'
+---
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/no-restricted-types** for documentation.
+
+It can sometimes be useful to ban specific types from being used in type annotations.
+For example, a project might be migrating from using one type to another, and want to ban references to the old type.
+
+This rule can be configured to ban a list of specific types and can suggest alternatives.
+Note that it does not ban the corresponding runtime objects from being used.
+
+## Options
+
+### `types`
+
+An object whose keys are the types you want to ban, and the values are error messages.
+
+The type can either be a type name literal (`OldType`) or a a type name with generic parameter instantiation(s) (`OldType<MyArgument>`).
+
+The values can be:
+
+- A string, which is the error message to be reported; or
+- `false` to specifically un-ban this type (useful when you are using `extendDefaults`); or
+- An object with the following properties:
+  - `message: string`: the message to display when the type is matched.
+  - `fixWith?: string`: a string to replace the banned type with when the fixer is run. If this is omitted, no fix will be done.
+  - `suggest?: string[]`: a list of suggested replacements for the banned type.
+
+Example configuration:
+
+```jsonc
+{
+  "@typescript-eslint/no-restricted-types": [
+    "error",
+    {
+      "types": {
+        // add a custom message to help explain why not to use it
+        "OldType": "Don't use OldType because it is unsafe",
+
+        // add a custom message, and tell the plugin how to fix it
+        "OldAPI": {
+          "message": "Use NewAPI instead",
+          "fixWith": "NewAPI",
+        },
+
+        // add a custom message, and tell the plugin how to suggest a fix
+        "SoonToBeOldAPI": {
+          "message": "Use NewAPI instead",
+          "suggest": ["NewAPIOne", "NewAPITwo"],
+        },
+      },
+    },
+  ],
+}
+```
+
+## When Not To Use It
+
+If you have no need to ban specific types from being used in type annotations, you don't need this rule.
+
+## Related To
+
+- [`no-empty-object-type`](./no-empty-object-type.mdx)
+- [`no-unsafe-function-type`](./no-unsafe-function-type.mdx)
+- [`no-wrapper-object-types`](./no-wrapper-object-types.mdx)