@typescript-eslint/eslint-plugin 8.33.1-alpha.5 → 8.33.1

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

@@ -1,61 +0,0 @@
----
-description: 'Disallow the `void` operator except when used to discard a value.'
----
-
-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-meaningless-void-operator** for documentation.
-
-`void` in TypeScript refers to a function return that is meant to be ignored.
-The `void` operator is a useful tool to convey the programmer's intent to discard a value.
-For example, it is recommended as one way of suppressing [`@typescript-eslint/no-floating-promises`](./no-floating-promises.mdx) instead of adding `.catch()` to a promise.
-
-This rule helps an authors catch API changes where previously a value was being discarded at a call site, but the callee changed so it no longer returns a value.
-When combined with [no-unused-expressions](https://eslint.org/docs/rules/no-unused-expressions), it also helps _readers_ of the code by ensuring consistency: a statement that looks like `void foo();` is **always** discarding a return value, and a statement that looks like `foo();` is **never** discarding a return value.
-This rule reports on any `void` operator whose argument is already of type `void` or `undefined`.
-
-## Examples
-
-## Examples
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts
-void (() => {})();
-
-function foo() {}
-void foo();
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts
-(() => {})();
-
-function foo() {}
-foo(); // nothing to discard
-
-function bar(x: number) {
-  void x; // discarding a number
-  return 2;
-}
-void bar(1); // discarding a number
-```
-
-</TabItem>
-</Tabs>
-
-## Options
-
-### `checkNever`
-
-{/* insert option description */}
-
-## When Not To Use It
-
-If you don't mind extra `void`s in your project, you can avoid this rule.

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

@@ -1,53 +0,0 @@
----
-description: 'Enforce valid definition of `new` and `constructor`.'
----
-
-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-misused-new** for documentation.
-
-JavaScript classes may define a `constructor` method that runs when a class instance is newly created.
-TypeScript allows interfaces that describe a static class object to define a `new()` method (though this is rarely used in real world code).
-Developers new to JavaScript classes and/or TypeScript interfaces may sometimes confuse when to use `constructor` or `new`.
-
-This rule reports when a class defines a method named `new` or an interface defines a method named `constructor`.
-
-## Examples
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts
-declare class C {
-  new(): C;
-}
-
-interface I {
-  new (): I;
-  constructor(): void;
-}
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts
-declare class C {
-  constructor();
-}
-
-interface I {
-  new (): C;
-}
-```
-
-</TabItem>
-</Tabs>
-
-## When Not To Use It
-
-If you intentionally want a class with a `new` method, and you're confident nobody working in your code will mistake it with a constructor, you might not want this rule.
-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.

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

@@ -1,314 +0,0 @@
----
-description: 'Disallow Promises in places not designed to handle them.'
----
-
-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-misused-promises** for documentation.
-
-This rule forbids providing Promises to logical locations such as if statements in places where the TypeScript compiler allows them but they are not handled properly.
-These situations can often arise due to a missing `await` keyword or just a misunderstanding of the way async
-functions are handled/awaited.
-
-:::tip
-`no-misused-promises` only detects code that provides Promises to incorrect _logical_ locations.
-See [`no-floating-promises`](./no-floating-promises.mdx) for detecting unhandled Promise _statements_.
-:::
-
-## Options
-
-### `checksConditionals`
-
-{/* insert option description */}
-
-If you don't want to check conditionals, you can configure the rule with `"checksConditionals": false`:
-
-```json
-{
-  "@typescript-eslint/no-misused-promises": [
-    "error",
-    {
-      "checksConditionals": false
-    }
-  ]
-}
-```
-
-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:
-
-```json
-{
-  "@typescript-eslint/no-misused-promises": [
-    "error",
-    {
-      "checksVoidReturn": false
-    }
-  ]
-}
-```
-
-You can disable selective parts of the `checksVoidReturn` option by providing an object that disables specific checks. For example, if you don't mind that passing a `() => Promise<void>` to a `() => void` parameter or JSX attribute can lead to a floating unhandled Promise:
-
-```json
-{
-  "@typescript-eslint/no-misused-promises": [
-    "error",
-    {
-      "checksVoidReturn": {
-        "arguments": false,
-        "attributes": false
-      }
-    }
-  ]
-}
-```
-
-The following sub-options are supported:
-
-#### `arguments`
-
-Disables checking an asynchronous function passed as argument where the parameter type expects a function that returns `void`.
-
-#### `attributes`
-
-Disables checking an asynchronous function passed as a JSX attribute expected to be a function that returns `void`.
-
-#### `inheritedMethods`
-
-Disables checking an asynchronous method in a type that extends or implements another type expecting that method to return `void`.
-
-:::note
-For now, `no-misused-promises` only checks _named_ methods against extended/implemented types: that is, call/construct/index signatures are ignored. Call signatures are not required in TypeScript to be consistent with one another, and construct signatures cannot be `async` in the first place. Index signature checking may be implemented in the future.
-:::
-
-#### `properties`
-
-Disables checking an asynchronous function passed as an object property expected to be a function that returns `void`.
-
-#### `returns`
-
-Disables checking an asynchronous function returned in a function whose return type is a function that returns `void`.
-
-#### `variables`
-
-Disables checking an asynchronous function used as a variable whose return type is a function that returns `void`.
-
-### `checksSpreads`
-
-{/* insert option description */}
-
-If you don't want to check object spreads, you can add this configuration:
-
-```json
-{
-  "@typescript-eslint/no-misused-promises": [
-    "error",
-    {
-      "checksSpreads": false
-    }
-  ]
-}
-```
-
-## Examples
-
-### `checksConditionals`
-
-{/* insert option description */}
-
-Examples of code for this rule with `checksConditionals: true`:
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts option='{ "checksConditionals": true }'
-const promise = Promise.resolve('value');
-
-if (promise) {
-  // Do something
-}
-
-const val = promise ? 123 : 456;
-
-[1, 2, 3].filter(() => promise);
-
-while (promise) {
-  // Do something
-}
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts option='{ "checksConditionals": true }'
-const promise = Promise.resolve('value');
-
-// Always `await` the Promise in a conditional
-if (await promise) {
-  // Do something
-}
-
-const val = (await promise) ? 123 : 456;
-
-const returnVal = await promise;
-[1, 2, 3].filter(() => returnVal);
-
-while (await promise) {
-  // Do something
-}
-```
-
-</TabItem>
-</Tabs>
-
-### `checksVoidReturn`
-
-{/* insert option description */}
-
-Examples of code for this rule with `checksVoidReturn: true`:
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts option='{ "checksVoidReturn": true }'
-[1, 2, 3].forEach(async value => {
-  await fetch(`/${value}`);
-});
-
-new Promise<void>(async (resolve, reject) => {
-  await fetch('/');
-  resolve();
-});
-
-document.addEventListener('click', async () => {
-  console.log('synchronous call');
-  await fetch('/');
-  console.log('synchronous call');
-});
-
-interface MySyncInterface {
-  setThing(): void;
-}
-class MyClass implements MySyncInterface {
-  async setThing(): Promise<void> {
-    this.thing = await fetchThing();
-  }
-}
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts option='{ "checksVoidReturn": true }'
-// for-of puts `await` in outer context
-for (const value of [1, 2, 3]) {
-  await doSomething(value);
-}
-
-// If outer context is not `async`, handle error explicitly
-Promise.all(
-  [1, 2, 3].map(async value => {
-    await doSomething(value);
-  }),
-).catch(handleError);
-
-// Use an async IIFE wrapper
-new Promise((resolve, reject) => {
-  // combine with `void` keyword to tell `no-floating-promises` rule to ignore unhandled rejection
-  void (async () => {
-    await doSomething();
-    resolve();
-  })();
-});
-
-// Name the async wrapper to call it later
-document.addEventListener('click', () => {
-  const handler = async () => {
-    await doSomething();
-    otherSynchronousCall();
-  };
-
-  try {
-    synchronousCall();
-  } catch (err) {
-    handleSpecificError(err);
-  }
-
-  handler().catch(handleError);
-});
-
-interface MyAsyncInterface {
-  setThing(): Promise<void>;
-}
-class MyClass implements MyAsyncInterface {
-  async setThing(): Promise<void> {
-    this.thing = await fetchThing();
-  }
-}
-```
-
-</TabItem>
-</Tabs>
-
-### `checksSpreads`
-
-{/* insert option description */}
-
-Examples of code for this rule with `checksSpreads: true`:
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts option='{ "checksSpreads": true }'
-const getData = () => fetch('/');
-
-console.log({ foo: 42, ...getData() });
-
-const awaitData = async () => {
-  await fetch('/');
-};
-
-console.log({ foo: 42, ...awaitData() });
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts option='{ "checksSpreads": true }'
-const getData = () => fetch('/');
-
-console.log({ foo: 42, ...(await getData()) });
-
-const awaitData = async () => {
-  await fetch('/');
-};
-
-console.log({ foo: 42, ...(await awaitData()) });
-```
-
-</TabItem>
-</Tabs>
-
-## When Not To Use It
-
-This rule can be difficult to enable on large existing projects that set up many misused Promises.
-Alternately, if you're not worried about crashes from floating or misused Promises -such as if you have global unhandled Promise handlers registered- then in some cases it may be safe to not use this rule.
-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.
-
-## Further Reading
-
-- [TypeScript void function assignability](https://github.com/Microsoft/TypeScript/wiki/FAQ#why-are-functions-returning-non-void-assignable-to-function-returning-void)
-
-## Related To
-
-- [`no-floating-promises`](./no-floating-promises.mdx)

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

@@ -1,132 +0,0 @@
----
-description: 'Disallow using the spread operator when it might cause unexpected behavior.'
----
-
-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-misused-spread** for documentation.
-
-[Spread syntax](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax) (`...`) is a JavaScript feature for creating an object with the joined properties of one or more other objects.
-TypeScript allows spreading objects whose properties are not typically meant to be enumerated, such as arrays and class instances.
-
-This rule disallows using the spread syntax on values whose types indicate doing so may cause unexpected behavior.
-That includes the following cases:
-
-- Spreading a `Promise` into an object.
-  You probably meant to `await` it.
-- Spreading a function without properties into an object.
-  You probably meant to call it.
-- Spreading an iterable (`Array`, `Map`, etc.) into an object.
-  Iterable objects usually do not have meaningful enumerable properties and you probably meant to spread it into an array instead.
-- Spreading a string into an array.
-  String enumeration behaviors in JavaScript around encoded characters are often surprising.
-- Spreading a `class` into an object.
-  This copies all static own properties of the class, but none of the inheritance chain.
-- Spreading a class instance into an object.
-  This does not faithfully copy the instance because only its own properties are copied, but the inheritance chain is lost, including all its methods.
-
-## Examples
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts
-declare const promise: Promise<number>;
-const spreadPromise = { ...promise };
-
-declare function getObject(): Record<string, strings>;
-const getObjectSpread = { ...getObject };
-
-declare const map: Map<string, number>;
-const mapSpread = { ...map };
-
-declare const userName: string;
-const characters = [...userName];
-```
-
-```ts
-declare class Box {
-  value: number;
-}
-const boxSpread = { ...Box };
-
-declare const instance: Box;
-const instanceSpread = { ...instance };
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts
-declare const promise: Promise<number>;
-const spreadPromise = { ...(await promise) };
-
-declare function getObject(): Record<string, strings>;
-const getObjectSpread = { ...getObject() };
-
-declare const map: Map<string, number>;
-const mapObject = Object.fromEntries(map);
-
-declare const userName: string;
-const characters = userName.split('');
-```
-
-</TabItem>
-</Tabs>
-
-## Options
-
-### `allow`
-
-{/* insert option description */}
-
-This option takes the shared [`TypeOrValueSpecifier` format](/packages/type-utils/type-or-value-specifier).
-
-Examples of a configuration for this option in a `file.ts` file:
-
-```json
-"@typescript-eslint/no-misused-spread": [
-  "error",
-  {
-    "allow": [
-      { "from": "file", "name": "BrandedString", "path": "file.ts" },
-    ]
-  }
-]
-```
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts option='{"allow":[{ "from": "file", "name": "BrandedString" }]}'
-declare const unbrandedString: string;
-
-const spreadUnbrandedString = [...unbrandedString];
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts option='{"allow":[{ "from": "file", "name": "BrandedString" }]}'
-type BrandedString = string & { __brand: 'safe' };
-
-declare const brandedString: BrandedString;
-
-const spreadBrandedString = [...brandedString];
-```
-
-</TabItem>
-</Tabs>
-
-## When Not To Use It
-
-If your application intentionally works with raw data in unusual ways, such as directly manipulating class prototype chains, you might not want this rule.
-
-If your use cases for unusual spreads only involve a few types, you might consider using [ESLint disable comments](https://eslint.org/docs/latest/use/configure/rules#using-configuration-comments-1) and/or the [`allow` option](#allow) instead of completely disabling this rule.
-
-## Further Reading
-
-- [Strings Shouldn't Be Iterable By Default](https://www.xanthir.com/b4wJ1)

package/docs/rules/no-mixed-enums.mdx

@@ -1,96 +0,0 @@
----
-description: 'Disallow enums from having both number and string members.'
----
-
-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-mixed-enums** for documentation.
-
-TypeScript enums are allowed to assign numeric or string values to their members.
-Most enums contain either all numbers or all strings, but in theory you can mix-and-match within the same enum.
-Mixing enum member types is generally considered confusing and a bad practice.
-
-## Examples
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts
-enum Status {
-  Unknown,
-  Closed = 1,
-  Open = 'open',
-}
-```
-
-</TabItem>
-<TabItem value="✅ Correct (Explicit Numbers)">
-
-```ts
-enum Status {
-  Unknown = 0,
-  Closed = 1,
-  Open = 2,
-}
-```
-
-</TabItem>
-<TabItem value="✅ Correct (Implicit Numbers)">
-
-```ts
-enum Status {
-  Unknown,
-  Closed,
-  Open,
-}
-```
-
-</TabItem>
-<TabItem value="✅ Correct (Strings)">
-
-```ts
-enum Status {
-  Unknown = 'unknown',
-  Closed = 'closed',
-  Open = 'open',
-}
-```
-
-</TabItem>
-</Tabs>
-
-## Iteration Pitfalls of Mixed Enum Member Values
-
-Enum values may be iterated over using `Object.entries`/`Object.keys`/`Object.values`.
-
-If all enum members are strings, the number of items will match the number of enum members:
-
-```ts
-enum Status {
-  Closed = 'closed',
-  Open = 'open',
-}
-
-// ['closed', 'open']
-Object.values(Status);
-```
-
-But if the enum contains members that are initialized with numbers -including implicitly initialized numbers— then iteration over that enum will include those numbers as well:
-
-```ts
-enum Status {
-  Unknown,
-  Closed = 1,
-  Open = 'open',
-}
-
-// ["Unknown", "Closed", 0, 1, "open"]
-Object.values(Status);
-```
-
-## When Not To Use It
-
-If you don't mind the confusion of mixed enum member values and don't iterate over enums, you can safely disable this rule.