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

package/docs/rules/no-array-constructor.mdx

@@ -1,34 +0,0 @@
----
-description: 'Disallow generic `Array` constructors.'
----
-
-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-array-constructor** for documentation.
-
-It adds support for the generically typed `Array` constructor (`new Array<Foo>()`).
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts
-Array(0, 1, 2);
-new Array(0, 1, 2);
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts
-Array<number>(0, 1, 2);
-new Array<Foo>(x, y, z);
-
-Array(500);
-new Array(someOtherArray.length);
-```
-
-</TabItem>
-</Tabs>

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

@@ -1,44 +0,0 @@
----
-description: 'Disallow using the `delete` operator on array values.'
----
-
-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-array-delete** for documentation.
-
-When using the `delete` operator with an array value, the array's `length` property is not affected,
-but the element at the specified index is removed and leaves an empty slot in the array.
-This is likely to lead to unexpected behavior. As mentioned in the
-[MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete#deleting_array_elements),
-the recommended way to remove an element from an array is by using the
-[`Array#splice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice) method.
-
-## Examples
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts
-declare const arr: number[];
-
-delete arr[0];
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts
-declare const arr: number[];
-
-arr.splice(0, 1);
-```
-
-</TabItem>
-</Tabs>
-
-## When Not To Use It
-
-When you want to allow the delete operator with array expressions.

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

@@ -1,115 +0,0 @@
----
-description: 'Require `.toString()` and `.toLocaleString()` to only be called on objects which provide useful information when stringified.'
----
-
-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-base-to-string** for documentation.
-
-JavaScript will call `toString()` on an object when it is converted to a string, such as when concatenated with a string (`expr + ''`), when interpolated into template literals (`${expr}`), or when passed as an argument to the String constructor (`String(expr)`).
-The default Object `.toString()` and `toLocaleString()` use 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()` or `toLocaleString()` method.
-
-> Note that `Function` provides its own `.toString()` and `toLocaleString()` that return the function's code.
-> Functions are not flagged by this rule.
-
-## Examples
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts
-// Passing an object or class instance to string concatenation:
-'' + {};
-
-class MyClass {}
-const value = new MyClass();
-value + '';
-
-// Interpolation and manual .toString() and `toLocaleString()` calls too:
-`Value: ${value}`;
-String({});
-({}).toString();
-({}).toLocaleString();
-
-// Stringifying objects or instances in an array with the `Array.prototype.join`.
-[{}, new MyClass()].join('');
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts
-// These types all have useful .toString() and `toLocaleString()` methods
-'Text' + true;
-`Value: ${123}`;
-`Arrays too: ${[1, 2, 3]}`;
-(() => {}).toString();
-String(42);
-(() => {}).toLocaleString();
-
-// Defining a custom .toString class is considered acceptable
-class CustomToString {
-  toString() {
-    return 'Hello, world!';
-  }
-}
-`Value: ${new CustomToString()}`;
-
-const literalWithToString = {
-  toString: () => 'Hello, world!',
-};
-
-`Value: ${literalWithToString}`;
-```
-
-</TabItem>
-</Tabs>
-
-## Alternatives
-
-Consider using `JSON.stringify` when you want to convert non-primitive things to string for logging, debugging, etc.
-
-```typescript
-declare const o: object;
-const errorMessage = 'Found unexpected value: ' + JSON.stringify(o);
-```
-
-## Options
-
-### `ignoredTypeNames`
-
-{/* insert option description */}
-
-This is useful for types missing `toString()` or `toLocaleString()` (but actually has `toString()` or `toLocaleString()`).
-There are some types missing `toString()` or `toLocaleString()` in old versions of TypeScript, like `RegExp`, `URL`, `URLSearchParams` etc.
-
-The following patterns are considered correct with the default options `{ ignoredTypeNames: ["RegExp"] }`:
-
-```ts option='{ "ignoredTypeNames": ["RegExp"] }' showPlaygroundButton
-`${/regex/}`;
-'' + /regex/;
-/regex/.toString();
-let value = /regex/;
-value.toString();
-let text = `${value}`;
-String(/regex/);
-```
-
-## When Not To Use It
-
-If you don't mind a risk of `"[object Object]"` or incorrect type coercions in your values, then you will not need this rule.
-
-## Related To
-
-- [`restrict-plus-operands`](./restrict-plus-operands.mdx)
-- [`restrict-template-expressions`](./restrict-template-expressions.mdx)
-
-## Further Reading
-
-- [`Object.prototype.toString()` MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toString)
-- [`Object.prototype.toLocaleString()` MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toLocaleString)
-- [Microsoft/TypeScript Add missing toString declarations for base types that have them](https://github.com/microsoft/TypeScript/issues/38347)

package/docs/rules/no-confusing-non-null-assertion.mdx

@@ -1,75 +0,0 @@
----
-description: 'Disallow non-null assertion in locations that may be confusing.'
----
-
-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-confusing-non-null-assertion** for documentation.
-
-Using a non-null assertion (`!`) next to an assignment or equality check (`=` or `==` or `===`) creates code that is confusing as it looks similar to an inequality check (`!=` `!==`).
-
-```typescript
-a! == b; // a non-null assertion(`!`) and an equals test(`==`)
-a !== b; // not equals test(`!==`)
-a! === b; // a non-null assertion(`!`) and a triple equals test(`===`)
-```
-
-Using a non-null assertion (`!`) next to an in test (`in`) or an instanceof test (`instanceof`) creates code that is confusing since it may look like the operator is negated, but it is actually not.
-
-{/* prettier-ignore */}
-```typescript
-a! in b; // a non-null assertion(`!`) and an in test(`in`)
-a !in b; // also a non-null assertion(`!`) and an in test(`in`)
-!(a in b); // a negated in test
-
-a! instanceof b; // a non-null assertion(`!`) and an instanceof test(`instanceof`)
-a !instanceof b; // also a non-null assertion(`!`) and an instanceof test(`instanceof`)
-!(a instanceof b); // a negated instanceof test
-````
-
-This rule flags confusing `!` assertions and suggests either removing them or wrapping the asserted expression in `()` parenthesis.
-
-## Examples
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts
-interface Foo {
-  bar?: string;
-  num?: number;
-}
-
-const foo: Foo = getFoo();
-const isEqualsBar = foo.bar! == 'hello';
-const isEqualsNum = 1 + foo.num! == 2;
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-{/* prettier-ignore */}
-```ts
-interface Foo {
-  bar?: string;
-  num?: number;
-}
-
-const foo: Foo = getFoo();
-const isEqualsBar = foo.bar == 'hello';
-const isEqualsNum = (1 + foo.num!) == 2;
-```
-
-</TabItem>
-</Tabs>
-
-## When Not To Use It
-
-If you don't care about this confusion, then you will not need this rule.
-
-## Further Reading
-
-- [`Issue: Easy misunderstanding: "! ==="`](https://github.com/microsoft/TypeScript/issues/37837) in [TypeScript repo](https://github.com/microsoft/TypeScript)

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

@@ -1,148 +0,0 @@
----
-description: 'Require expressions of type void to appear in statement position.'
----
-
-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-confusing-void-expression** for documentation.
-
-`void` in TypeScript refers to a function return that is meant to be ignored.
-Attempting to use a `void`-typed value, such as storing the result of a called function in a variable, is often a sign of a programmer error.
-`void` can also be misleading for other developers even if used correctly.
-
-This rule prevents `void` type expressions from being used in misleading locations such as being assigned to a variable, provided as a function argument, or returned from a function.
-
-## Examples
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts
-// somebody forgot that `alert` doesn't return anything
-const response = alert('Are you sure?');
-console.log(alert('Are you sure?'));
-
-// it's not obvious whether the chained promise will contain the response (fixable)
-promise.then(value => window.postMessage(value));
-
-// it looks like we are returning the result of `console.error` (fixable)
-function doSomething() {
-  if (!somethingToDo) {
-    return console.error('Nothing to do!');
-  }
-
-  console.log('Doing a thing...');
-}
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts
-// just a regular void function in a statement position
-alert('Hello, world!');
-
-// this function returns a boolean value so it's ok
-const response = confirm('Are you sure?');
-console.log(confirm('Are you sure?'));
-
-// now it's obvious that `postMessage` doesn't return any response
-promise.then(value => {
-  window.postMessage(value);
-});
-
-// now it's explicit that we want to log the error and return early
-function doSomething() {
-  if (!somethingToDo) {
-    console.error('Nothing to do!');
-    return;
-  }
-
-  console.log('Doing a thing...');
-}
-
-// using logical expressions for their side effects is fine
-cond && console.log('true');
-cond || console.error('false');
-cond ? console.log('true') : console.error('false');
-```
-
-</TabItem>
-</Tabs>
-
-## Options
-
-### `ignoreArrowShorthand`
-
-{/* insert option description */}
-
-It might be undesirable to wrap every arrow function shorthand expression.
-Especially when using the Prettier formatter, which spreads such code across 3 lines instead of 1.
-
-Examples of additional **correct** code with this option enabled:
-
-```ts option='{ "ignoreArrowShorthand": true }' showPlaygroundButton
-promise.then(value => window.postMessage(value));
-```
-
-### `ignoreVoidOperator`
-
-{/* insert option description */}
-
-It might be preferable to only use some distinct syntax
-to explicitly mark the confusing but valid usage of void expressions.
-This option allows void expressions which are explicitly wrapped in the `void` operator.
-This can help avoid confusion among other developers as long as they are made aware of this code style.
-
-This option also changes the automatic fixes for common cases to use the `void` operator.
-It also enables a suggestion fix to wrap the void expression with `void` operator for every problem reported.
-
-Examples of additional **correct** code with this option enabled:
-
-```ts option='{ "ignoreVoidOperator": true }' showPlaygroundButton
-// now it's obvious that we don't expect any response
-promise.then(value => void window.postMessage(value));
-
-// now it's explicit that we don't want to return anything
-function doSomething() {
-  if (!somethingToDo) {
-    return void console.error('Nothing to do!');
-  }
-
-  console.log('Doing a thing...');
-}
-
-// we are sure that we want to always log `undefined`
-console.log(void alert('Hello, world!'));
-```
-
-### `ignoreVoidReturningFunctions`
-
-{/* insert option description */}
-
-Some projects prefer allowing functions that explicitly return `void` to return `void` expressions. Doing so allows more writing more succinct functions.
-
-:::note
-This is technically risky as the `void`-returning function might actually be returning a value not seen by the type system.
-:::
-
-```ts option='{ "ignoreVoidReturningFunctions": true }' showPlaygroundButton
-function foo(): void {
-  return console.log();
-}
-
-function onError(callback: () => void): void {
-  callback();
-}
-
-onError(() => console.log('oops'));
-```
-
-## When Not To Use It
-
-The return type of a function can be inspected by going to its definition or hovering over it in an IDE.
-If you don't care about being explicit about the void type in actual code then don't use this rule.
-Also, if you strongly prefer a concise coding style more strongly than any fear of `void`-related bugs then you can avoid this rule.

package/docs/rules/no-deprecated.mdx

@@ -1,119 +0,0 @@
----
-description: 'Disallow using code marked as `@deprecated`.'
----
-
-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-deprecated** for documentation.
-
-The [JSDoc `@deprecated` tag](https://jsdoc.app/tags-deprecated) can be used to document some piece of code being deprecated.
-It's best to avoid using code marked as deprecated.
-This rule reports on any references to code marked as `@deprecated`.
-
-:::note
-[TypeScript recognizes the `@deprecated` tag](https://www.typescriptlang.org/docs/handbook/jsdoc-supported-types.html#deprecated), allowing editors to visually indicate deprecated code — usually with a ~strikethrough~.
-However, TypeScript doesn't report type errors for deprecated code on its own.
-:::
-
-## Examples
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts
-/** @deprecated Use apiV2 instead. */
-declare function apiV1(): Promise<string>;
-
-declare function apiV2(): Promise<string>;
-
-await apiV1();
-```
-
-```ts
-import { parse } from 'node:url';
-
-// 'parse' is deprecated. Use the WHATWG URL API instead.
-const url = parse('/foo');
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts
-/** @deprecated Use apiV2 instead. */
-declare function apiV1(): Promise<string>;
-
-declare function apiV2(): Promise<string>;
-
-await apiV2();
-```
-
-```ts
-// Modern Node.js API, uses `new URL()`
-const url2 = new URL('/foo', 'http://www.example.com');
-```
-
-</TabItem>
-</Tabs>
-
-## Options
-
-### `allow`
-
-{/* insert option description */}
-
-This option takes the shared [`TypeOrValueSpecifier` format](/packages/type-utils/type-or-value-specifier).
-
-Examples of code for this rule with:
-
-```json
-{
-  "allow": [
-    { "from": "file", "name": "apiV1" },
-    { "from": "lib", "name": "escape" }
-  ]
-}
-```
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts option='{"allow":[{"from":"file","name":"apiV1"},{"from":"lib","name":"escape"}]}'
-/** @deprecated */
-declare function apiV2(): Promise<string>;
-
-await apiV2();
-
-// `unescape` has been deprecated since ES5.
-unescape('...');
-```
-
-</TabItem>
-
-<TabItem value="✅ Correct">
-
-```ts option='{"allow":[{"from":"file","name":"apiV1"},{"from":"lib","name":"escape"}]}'
-import { Bar } from 'bar-lib';
-/** @deprecated */
-declare function apiV1(): Promise<string>;
-
-await apiV1();
-
-// `escape` has been deprecated since ES5.
-escape('...');
-```
-
-</TabItem>
-</Tabs>
-
-## When Not To Use It
-
-If portions of your project heavily use deprecated APIs and have no plan for moving to non-deprecated ones, you might want to disable this rule in those portions.
-
-## Related To
-
-- [`import/no-deprecated`](https://github.com/import-js/eslint-plugin-import/blob/main/docs/rules/no-deprecated.md) and [`import-x/no-deprecated`](https://github.com/un-ts/eslint-plugin-import-x/blob/master/docs/rules/no-deprecated.md): Does not use type information, but does also support [TomDoc](http://tomdoc.org)
-- [`eslint-plugin-deprecation`](https://github.com/gund/eslint-plugin-deprecation) ([`deprecation/deprecation`](https://github.com/gund/eslint-plugin-deprecation?tab=readme-ov-file#rules)): Predecessor to this rule in a separate plugin

package/docs/rules/no-dupe-class-members.mdx

@@ -1,16 +0,0 @@
----
-description: 'Disallow duplicate class 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-dupe-class-members** for documentation.
-
-import TypeScriptOverlap from '@site/src/components/TypeScriptOverlap';
-
-<TypeScriptOverlap />
-
-It adds support for TypeScript's method overload definitions.

package/docs/rules/no-duplicate-enum-values.mdx

@@ -1,66 +0,0 @@
----
-description: 'Disallow duplicate enum member values.'
----
-
-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-duplicate-enum-values** for documentation.
-
-Although TypeScript supports duplicate enum member values, people usually expect members to have unique values within the same enum. Duplicate values can lead to bugs that are hard to track down.
-
-## Examples
-
-This rule disallows defining an enum with multiple members initialized to the same value.
-
-> This rule only enforces on enum members initialized with string or number literals.
-> Members without an initializer or initialized with an expression are not checked by this rule.
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts
-enum E {
-  A = 0,
-  B = 0,
-}
-```
-
-```ts
-enum E {
-  A = 'A',
-  B = 'A',
-  C = `A`,
-}
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts
-enum E {
-  A = 0,
-  B = 1,
-}
-```
-
-```ts
-enum E {
-  A = 'A',
-  B = 'B',
-  C = `C`,
-}
-```
-
-</TabItem>
-</Tabs>
-
-## When Not To Use It
-
-It can sometimes be useful to include duplicate enum members for very specific use cases.
-For example, when renaming an enum member, it can sometimes be useful to keep the old name until a scheduled major breaking change.
-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 general, if your project intentionally duplicates enum member values, you can avoid this rule.

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

@@ -1,17 +0,0 @@
----
-displayed_sidebar: rulesSidebar
----
-
-:::danger Deprecated
-
-This rule has been deprecated in favour of the [`import/no-duplicates`](https://github.com/import-js/eslint-plugin-import/blob/HEAD/docs/rules/no-duplicates.md) rule.
-
-:::
-
-<!--
-This doc file has been left on purpose because `import/no-duplicates` is
-commonly requested. This exists to help direct people to the replacement rule.
-
-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.
--->