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

package/docs/rules/prefer-enum-initializers.mdx

@@ -1,68 +0,0 @@
----
-description: 'Require each enum member value to be explicitly initialized.'
----
-
-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/prefer-enum-initializers** for documentation.
-
-TypeScript `enum`s are a practical way to organize semantically related constant values.
-Members of `enum`s that don't have explicit values are by default given sequentially increasing numbers.
-
-In projects where the value of `enum` members are important, allowing implicit values for enums can cause bugs if `enum`s are modified over time.
-
-This rule recommends having each `enum` member value explicitly initialized.
-
-## Examples
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts
-enum Status {
-  Open = 1,
-  Close,
-}
-
-enum Direction {
-  Up,
-  Down,
-}
-
-enum Color {
-  Red,
-  Green = 'Green',
-  Blue = 'Blue',
-}
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts
-enum Status {
-  Open = 'Open',
-  Close = 'Close',
-}
-
-enum Direction {
-  Up = 1,
-  Down = 2,
-}
-
-enum Color {
-  Red = 'Red',
-  Green = 'Green',
-  Blue = 'Blue',
-}
-```
-
-</TabItem>
-</Tabs>
-
-## When Not To Use It
-
-If you don't care about `enum`s having implicit values you can safely disable this rule.

package/docs/rules/prefer-find.mdx

@@ -1,45 +0,0 @@
----
-description: 'Enforce the use of Array.prototype.find() over Array.prototype.filter() followed by [0] when looking for a single result.'
----
-
-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/prefer-find** for documentation.
-
-When searching for the first item in an array matching a condition, it may be tempting to use code like `arr.filter(x => x > 0)[0]`.
-However, it is simpler to use [Array.prototype.find()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find) instead, `arr.find(x => x > 0)`, which also returns the first entry matching a condition.
-Because the `.find()` only needs to execute the callback until it finds a match, it's also more efficient.
-
-:::info
-
-Beware the difference in short-circuiting behavior between the approaches.
-`.find()` will only execute the callback on array elements until it finds a match, whereas `.filter()` executes the callback for all array elements.
-Therefore, when fixing errors from this rule, be sure that your `.filter()` callbacks do not have side effects.
-
-:::
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts
-[1, 2, 3].filter(x => x > 1)[0];
-
-[1, 2, 3].filter(x => x > 1).at(0);
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts
-[1, 2, 3].find(x => x > 1);
-```
-
-</TabItem>
-</Tabs>
-
-## When Not To Use It
-
-If you intentionally use patterns like `.filter(callback)[0]` to execute side effects in `callback` on all array elements, you will want to avoid this rule.

package/docs/rules/prefer-for-of.mdx

@@ -1,50 +0,0 @@
----
-description: 'Enforce the use of `for-of` loop over the standard `for` loop where possible.'
----
-
-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/prefer-for-of** for documentation.
-
-Many developers default to writing `for (let i = 0; i < ...` loops to iterate over arrays.
-However, in many of those arrays, the loop iterator variable (e.g. `i`) is only used to access the respective element of the array.
-In those cases, a `for-of` loop is easier to read and write.
-
-This rule recommends a for-of loop when the loop index is only used to read from an array that is being iterated.
-
-## Examples
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts
-declare const array: string[];
-
-for (let i = 0; i < array.length; i++) {
-  console.log(array[i]);
-}
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts
-declare const array: string[];
-
-for (const x of array) {
-  console.log(x);
-}
-
-for (let i = 0; i < array.length; i++) {
-  // i is used, so for-of could not be used.
-  console.log(i, array[i]);
-}
-```
-
-</TabItem>
-</Tabs>
-
-{/* Intentionally Omitted: When Not To Use It */}

package/docs/rules/prefer-function-type.mdx

@@ -1,98 +0,0 @@
----
-description: 'Enforce using function types instead of interfaces with call signatures.'
----
-
-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/prefer-function-type** for documentation.
-
-TypeScript allows for two common ways to declare a type for a function:
-
-- Function type: `() => string`
-- Object type with a signature: `{ (): string }`
-
-The function type form is generally preferred when possible for being more succinct.
-
-This rule suggests using a function type instead of an interface or object type literal with a single call signature.
-
-## Examples
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts
-interface Example {
-  (): string;
-}
-```
-
-```ts
-function foo(example: { (): number }): number {
-  return example();
-}
-```
-
-```ts
-interface ReturnsSelf {
-  // returns the function itself, not the `this` argument.
-  (arg: string): this;
-}
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts
-type Example = () => string;
-```
-
-```ts
-function foo(example: () => number): number {
-  return bar();
-}
-```
-
-```ts
-// returns the function itself, not the `this` argument.
-type ReturnsSelf = (arg: string) => ReturnsSelf;
-```
-
-```ts
-function foo(bar: { (): string; baz: number }): string {
-  return bar();
-}
-```
-
-```ts
-interface Foo {
-  bar: string;
-}
-interface Bar extends Foo {
-  (): void;
-}
-```
-
-```ts
-// multiple call signatures (overloads) is allowed:
-interface Overloaded {
-  (data: string): number;
-  (id: number): string;
-}
-// this is equivelent to Overloaded interface.
-type Intersection = ((data: string) => number) & ((id: number) => string);
-```
-
-</TabItem>
-</Tabs>
-
-## When Not To Use It
-
-If you specifically want to use an interface or type literal with a single call signature for stylistic reasons, you can avoid this rule.
-
-This rule has a known edge case of sometimes triggering on global augmentations such as `interface Function`.
-These edge cases are rare and often symptomatic of odd code.
-We recommend you use an [inline ESLint disable comment](https://eslint.org/docs/latest/use/configure/rules#using-configuration-comments-1).
-See [#454](https://github.com/typescript-eslint/typescript-eslint/issues/454) for details.

package/docs/rules/prefer-includes.mdx

@@ -1,81 +0,0 @@
----
-description: 'Enforce `includes` method over `indexOf` method.'
----
-
-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/prefer-includes** for documentation.
-
-Prior to ES2015, `Array#indexOf` and `String#indexOf` comparisons against `-1` were the standard ways to check whether a value exists in an array or string, respectively.
-Alternatives that are easier to read and write now exist: ES2015 added `String#includes` and ES2016 added `Array#includes`.
-
-This rule reports when an `.indexOf` call can be replaced with an `.includes`.
-Additionally, this rule reports the tests of simple regular expressions in favor of `String#includes`.
-
-> This rule will report on any receiver object of an `indexOf` method call that has an `includes` method where the two methods have the same parameters.
-> Matching types include: `String`, `Array`, `ReadonlyArray`, and typed arrays.
-
-## Examples
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts
-const str: string;
-const array: any[];
-const readonlyArray: ReadonlyArray<any>;
-const typedArray: UInt8Array;
-const maybe: string;
-const userDefined: {
-  indexOf(x: any): number;
-  includes(x: any): boolean;
-};
-
-str.indexOf(value) !== -1;
-array.indexOf(value) !== -1;
-readonlyArray.indexOf(value) === -1;
-typedArray.indexOf(value) > -1;
-maybe?.indexOf('') !== -1;
-userDefined.indexOf(value) >= 0;
-
-/example/.test(str);
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts
-const str: string;
-const array: any[];
-const readonlyArray: ReadonlyArray<any>;
-const typedArray: UInt8Array;
-const maybe: string;
-const userDefined: {
-  indexOf(x: any): number;
-  includes(x: any): boolean;
-};
-
-str.includes(value);
-array.includes(value);
-!readonlyArray.includes(value);
-typedArray.includes(value);
-maybe?.includes('');
-userDefined.includes(value);
-
-str.includes('example');
-
-// The two methods have different parameters.
-declare const mismatchExample: {
-  indexOf(x: unknown, fromIndex?: number): number;
-  includes(x: unknown): boolean;
-};
-mismatchExample.indexOf(value) >= 0;
-```
-
-</TabItem>
-</Tabs>
-
-{/* Intentionally Omitted: When Not To Use It */}

package/docs/rules/prefer-literal-enum-member.mdx

@@ -1,111 +0,0 @@
----
-description: 'Require all enum members to be literal 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/prefer-literal-enum-member** for documentation.
-
-TypeScript allows the value of an enum member to be many different kinds of valid JavaScript expressions.
-However, because enums create their own scope whereby each enum member becomes a variable in that scope, developers are often surprised at the resultant values.
-For example:
-
-```ts
-const imOutside = 2;
-const b = 2;
-enum Foo {
-  outer = imOutside,
-  a = 1,
-  b = a,
-  c = b,
-  // does c == Foo.b == Foo.c == 1?
-  // or does c == b == 2?
-}
-```
-
-> The answer is that `Foo.c` will be `1` at runtime [[TypeScript playground](https://www.typescriptlang.org/play/#src=const%20imOutside%20%3D%202%3B%0D%0Aconst%20b%20%3D%202%3B%0D%0Aenum%20Foo%20%7B%0D%0A%20%20%20%20outer%20%3D%20imOutside%2C%0D%0A%20%20%20%20a%20%3D%201%2C%0D%0A%20%20%20%20b%20%3D%20a%2C%0D%0A%20%20%20%20c%20%3D%20b%2C%0D%0A%20%20%20%20%2F%2F%20does%20c%20%3D%3D%20Foo.b%20%3D%3D%20Foo.c%20%3D%3D%201%3F%0D%0A%20%20%20%20%2F%2F%20or%20does%20c%20%3D%3D%20b%20%3D%3D%202%3F%0D%0A%7D)].
-
-Therefore, it's often better to prevent unexpected results in code by requiring the use of literal values as enum members.
-This rule reports when an enum member is given a value that is not a literal.
-
-## Examples
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts
-const str = 'Test';
-const string1 = 'string1';
-const string2 = 'string2';
-
-enum Invalid {
-  A = str, // Variable assignment
-  B = `Interpolates ${string1} and ${string2}`, // Template literal with interpolation
-  C = 2 + 2, // Expression assignment
-  D = C, // Assignment to another enum member
-}
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts
-enum Valid {
-  A, // No initializer; initialized with ascending integers starting from 0
-  B = 'TestStr', // A regular string
-  C = `A template literal string`, // A template literal without interpolation
-  D = 4, // A number
-}
-```
-
-</TabItem>
-</Tabs>
-
-## Options
-
-### `allowBitwiseExpressions`
-
-{/* insert option description */}
-
-Examples of code for the `{ "allowBitwiseExpressions": true }` option:
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts option='{ "allowBitwiseExpressions": true }'
-const x = 1;
-enum Foo {
-  A = x << 0,
-  B = x >> 0,
-  C = x >>> 0,
-  D = x | 0,
-  E = x & 0,
-  F = x ^ 0,
-  G = ~x,
-}
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts option='{ "allowBitwiseExpressions": true }'
-enum Foo {
-  A = 1 << 0,
-  B = 1 >> 0,
-  C = 1 >>> 0,
-  D = 1 | 0,
-  E = 1 & 0,
-  F = 1 ^ 0,
-  G = ~1,
-}
-```
-
-</TabItem>
-</Tabs>
-
-## When Not To Use It
-
-If you want use anything other than simple literals as an enum value, this rule might not be for you.

package/docs/rules/prefer-namespace-keyword.mdx

@@ -1,51 +0,0 @@
----
-description: 'Require using `namespace` keyword over `module` keyword to declare custom TypeScript modules.'
----
-
-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/prefer-namespace-keyword** for documentation.
-
-TypeScript historically allowed a form of code organization called "custom modules" (`module Example {}`), later renamed to "namespaces" (`namespace Example`).
-
-Namespaces are an outdated way to organize TypeScript code.
-ES2015 module syntax is now preferred (`import`/`export`).
-
-For projects still using custom modules / namespaces, it's preferred to refer to them as namespaces.
-This rule reports when the `module` keyword is used instead of `namespace`.
-
-> This rule does not report on the use of TypeScript module declarations to describe external APIs (`declare module 'foo' {}`).
-
-## Examples
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts
-module Example {}
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts
-namespace Example {}
-
-declare module 'foo' {}
-```
-
-</TabItem>
-</Tabs>
-
-## When Not To Use It
-
-If you are not using TypeScript's older `module`/`namespace` keywords, then you will not need this rule.
-
-## Further Reading
-
-- [Modules](https://www.typescriptlang.org/docs/handbook/modules.html)
-- [Namespaces](https://www.typescriptlang.org/docs/handbook/namespaces.html)
-- [Namespaces and Modules](https://www.typescriptlang.org/docs/handbook/namespaces-and-modules.html)