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

package/docs/rules/parameter-properties.mdx

@@ -1,522 +0,0 @@
----
-description: 'Require or disallow parameter properties in class 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/parameter-properties** for documentation.
-
-TypeScript includes a "parameter properties" shorthand for declaring a class constructor parameter and class property in one location.
-Parameter properties can be confusing to those new to TypeScript as they are less explicit than other ways of declaring and initializing class members.
-
-This rule can be configured to always disallow the use of parameter properties or enforce their usage when possible.
-
-## Options
-
-This rule, in its default state, does not require any argument and would completely disallow the use of parameter properties.
-It may take an options object containing either or both of:
-
-- `"allow"`: allowing certain kinds of properties to be ignored
-- `"prefer"`: either `"class-property"` _(default)_ or `"parameter-property"`
-
-### `allow`
-
-{/* insert option description */}
-
-If you would like to ignore certain kinds of properties then you may pass an object containing `"allow"` as an array of any of the following options:
-
-- `allow`, an array containing one or more of the allowed modifiers. Valid values are:
-  - `readonly`, allows **readonly** parameter properties.
-  - `private`, allows **private** parameter properties.
-  - `protected`, allows **protected** parameter properties.
-  - `public`, allows **public** parameter properties.
-  - `private readonly`, allows **private readonly** parameter properties.
-  - `protected readonly`, allows **protected readonly** parameter properties.
-  - `public readonly`, allows **public readonly** parameter properties.
-
-For example, to ignore `public` properties:
-
-```json
-{
-  "@typescript-eslint/parameter-properties": [
-    true,
-    {
-      "allow": ["public"]
-    }
-  ]
-}
-```
-
-### `prefer`
-
-{/* insert option description */}
-
-By default, the rule prefers class properties.
-You can switch it to instead preferring parameter properties with (`"parameter-property"`).
-
-In `"parameter-property"` mode, the rule will issue a report when:
-
-- A class property and constructor parameter have the same name and type
-- The constructor parameter is assigned to the class property at the beginning of the constructor
-
-### default
-
-Examples of code for this rule with no options at all:
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts
-class Foo {
-  constructor(readonly name: string) {}
-}
-
-class Foo {
-  constructor(private name: string) {}
-}
-
-class Foo {
-  constructor(protected name: string) {}
-}
-
-class Foo {
-  constructor(public name: string) {}
-}
-
-class Foo {
-  constructor(private readonly name: string) {}
-}
-
-class Foo {
-  constructor(protected readonly name: string) {}
-}
-
-class Foo {
-  constructor(public readonly name: string) {}
-}
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts
-class Foo {
-  constructor(name: string) {}
-}
-```
-
-</TabItem>
-</Tabs>
-
-### readonly
-
-Examples of code for the `{ "allow": ["readonly"] }` options:
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts option='{ "allow": ["readonly"] }'
-class Foo {
-  constructor(private name: string) {}
-}
-
-class Foo {
-  constructor(protected name: string) {}
-}
-
-class Foo {
-  constructor(public name: string) {}
-}
-
-class Foo {
-  constructor(private readonly name: string) {}
-}
-
-class Foo {
-  constructor(protected readonly name: string) {}
-}
-
-class Foo {
-  constructor(public readonly name: string) {}
-}
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts option='{ "allow": ["readonly"] }'
-class Foo {
-  constructor(name: string) {}
-}
-
-class Foo {
-  constructor(readonly name: string) {}
-}
-```
-
-</TabItem>
-</Tabs>
-
-### private
-
-Examples of code for the `{ "allow": ["private"] }` options:
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts option='{ "allow": ["private"] }'
-class Foo {
-  constructor(readonly name: string) {}
-}
-
-class Foo {
-  constructor(protected name: string) {}
-}
-
-class Foo {
-  constructor(public name: string) {}
-}
-
-class Foo {
-  constructor(private readonly name: string) {}
-}
-
-class Foo {
-  constructor(protected readonly name: string) {}
-}
-
-class Foo {
-  constructor(public readonly name: string) {}
-}
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts option='{ "allow": ["private"] }'
-class Foo {
-  constructor(name: string) {}
-}
-
-class Foo {
-  constructor(private name: string) {}
-}
-```
-
-</TabItem>
-</Tabs>
-
-### protected
-
-Examples of code for the `{ "allow": ["protected"] }` options:
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts option='{ "allow": ["protected"] }'
-class Foo {
-  constructor(readonly name: string) {}
-}
-
-class Foo {
-  constructor(private name: string) {}
-}
-
-class Foo {
-  constructor(public name: string) {}
-}
-
-class Foo {
-  constructor(private readonly name: string) {}
-}
-
-class Foo {
-  constructor(protected readonly name: string) {}
-}
-
-class Foo {
-  constructor(public readonly name: string) {}
-}
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts option='{ "allow": ["protected"] }'
-class Foo {
-  constructor(name: string) {}
-}
-
-class Foo {
-  constructor(protected name: string) {}
-}
-```
-
-</TabItem>
-</Tabs>
-
-### public
-
-Examples of code for the `{ "allow": ["public"] }` options:
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts option='{ "allow": ["public"] }'
-class Foo {
-  constructor(readonly name: string) {}
-}
-
-class Foo {
-  constructor(private name: string) {}
-}
-
-class Foo {
-  constructor(protected name: string) {}
-}
-
-class Foo {
-  constructor(private readonly name: string) {}
-}
-
-class Foo {
-  constructor(protected readonly name: string) {}
-}
-
-class Foo {
-  constructor(public readonly name: string) {}
-}
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts option='{ "allow": ["public"] }'
-class Foo {
-  constructor(name: string) {}
-}
-
-class Foo {
-  constructor(public name: string) {}
-}
-```
-
-</TabItem>
-</Tabs>
-
-### private readonly
-
-Examples of code for the `{ "allow": ["private readonly"] }` options:
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts option='{ "allow": ["private readonly"] }'
-class Foo {
-  constructor(readonly name: string) {}
-}
-
-class Foo {
-  constructor(private name: string) {}
-}
-
-class Foo {
-  constructor(protected name: string) {}
-}
-
-class Foo {
-  constructor(public name: string) {}
-}
-
-class Foo {
-  constructor(protected readonly name: string) {}
-}
-
-class Foo {
-  constructor(public readonly name: string) {}
-}
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts option='{ "allow": ["private readonly"] }'
-class Foo {
-  constructor(name: string) {}
-}
-
-class Foo {
-  constructor(private readonly name: string) {}
-}
-```
-
-</TabItem>
-</Tabs>
-
-### protected readonly
-
-Examples of code for the `{ "allow": ["protected readonly"] }` options:
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts option='{ "allow": ["protected readonly"] }'
-class Foo {
-  constructor(readonly name: string) {}
-}
-
-class Foo {
-  constructor(private name: string) {}
-}
-
-class Foo {
-  constructor(protected name: string) {}
-}
-
-class Foo {
-  constructor(public name: string) {}
-}
-
-class Foo {
-  constructor(private readonly name: string) {}
-}
-
-class Foo {
-  constructor(public readonly name: string) {}
-}
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts option='{ "allow": ["protected readonly"] }'
-class Foo {
-  constructor(name: string) {}
-}
-
-class Foo {
-  constructor(protected readonly name: string) {}
-}
-```
-
-</TabItem>
-</Tabs>
-
-### public readonly
-
-Examples of code for the `{ "allow": ["public readonly"] }` options:
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts option='{ "allow": ["public readonly"] }'
-class Foo {
-  constructor(readonly name: string) {}
-}
-
-class Foo {
-  constructor(private name: string) {}
-}
-
-class Foo {
-  constructor(protected name: string) {}
-}
-
-class Foo {
-  constructor(public name: string) {}
-}
-
-class Foo {
-  constructor(private readonly name: string) {}
-}
-
-class Foo {
-  constructor(protected readonly name: string) {}
-}
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts option='{ "allow": ["public readonly"] }'
-class Foo {
-  constructor(name: string) {}
-}
-
-class Foo {
-  constructor(public readonly name: string) {}
-}
-```
-
-</TabItem>
-</Tabs>
-
-### `"parameter-property"`
-
-Examples of code for the `{ "prefer": "parameter-property" }` option:
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts option='{ "prefer": "parameter-property" }'
-class Foo {
-  private name: string;
-  constructor(name: string) {
-    this.name = name;
-  }
-}
-
-class Foo {
-  public readonly name: string;
-  constructor(name: string) {
-    this.name = name;
-  }
-}
-
-class Foo {
-  constructor(name: string) {
-    this.name = name;
-  }
-  name: string;
-}
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts option='{ "prefer": "parameter-property" }'
-class Foo {
-  private differentName: string;
-  constructor(name: string) {
-    this.differentName = name;
-  }
-}
-
-class Foo {
-  private differentType: number | undefined;
-  constructor(differentType: number) {
-    this.differentType = differentType;
-  }
-}
-
-class Foo {
-  protected logicInConstructor: string;
-  constructor(logicInConstructor: string) {
-    console.log('Hello, world!');
-    this.logicInConstructor = logicInConstructor;
-  }
-}
-```
-
-</TabItem>
-</Tabs>
-
-## When Not To Use It
-
-If you don't care about which style of parameter properties in constructors is used in your classes, then you will not need this rule.
-
-However, keep in mind that inconsistent style can harm readability in a project.
-We recommend picking a single option for this rule that works best for your project.

package/docs/rules/prefer-as-const.mdx

@@ -1,51 +0,0 @@
----
-description: 'Enforce the use of `as const` over literal type.'
----
-
-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-as-const** for documentation.
-
-There are two common ways to tell TypeScript that a literal value should be interpreted as its literal type (e.g. `2`) rather than general primitive type (e.g. `number`);
-
-- `as const`: telling TypeScript to infer the literal type automatically
-- `as` with the literal type: explicitly telling the literal type to TypeScript
-
-`as const` is generally preferred, as it doesn't require re-typing the literal value.
-This rule reports when an `as` with an explicit literal type can be replaced with an `as const`.
-
-## Examples
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts
-let bar: 2 = 2;
-let foo = <'bar'>'bar';
-let foo = { bar: 'baz' as 'baz' };
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts
-let foo = 'bar';
-let foo = 'bar' as const;
-let foo: 'bar' = 'bar' as const;
-let bar = 'bar' as string;
-let foo = <string>'bar';
-let foo = { bar: 'baz' };
-```
-
-</TabItem>
-</Tabs>
-
-## When Not To Use It
-
-If you don't care about which style of literals assertions is used in your code, then you will not need this rule.
-
-However, keep in mind that inconsistent style can harm readability in a project.
-We recommend picking a single option for this rule that works best for your project.

package/docs/rules/prefer-destructuring.mdx

@@ -1,101 +0,0 @@
----
-description: 'Require destructuring from arrays and/or objects.'
----
-
-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-destructuring** for documentation.
-
-It adds support for TypeScript's type annotations in variable declarations.
-
-## Examples
-
-<Tabs>
-
-<TabItem value="`eslint/prefer-destructuring`">
-
-```ts
-const x: string = obj.x; // This is incorrect and the auto fixer provides following untyped fix.
-// const { x } = obj;
-```
-
-</TabItem>
-<TabItem value="`@typescript-eslint/prefer-destructuring`">
-
-```ts
-const x: string = obj.x; // This is correct by default. You can also forbid this by an option.
-```
-
-</TabItem>
-</Tabs>
-
-And it infers binding patterns more accurately thanks to the type checker.
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts
-const x = ['a'];
-const y = x[0];
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts
-const x = { 0: 'a' };
-const y = x[0];
-```
-
-It is correct when `enforceForRenamedProperties` is not true.
-Valid destructuring syntax is renamed style like `{ 0: y } = x` rather than `[y] = x` because `x` is not iterable.
-
-</TabItem>
-</Tabs>
-
-## Options
-
-This rule adds the following options:
-
-```ts
-type Options = [
-  BasePreferDestructuringOptions[0],
-  BasePreferDestructuringOptions[1] & {
-    enforceForDeclarationWithTypeAnnotation?: boolean;
-  },
-];
-
-const defaultOptions: Options = [
-  basePreferDestructuringDefaultOptions[0],
-  {
-    ...basePreferDestructuringDefaultOptions[1],
-    enforceForDeclarationWithTypeAnnotation: false,
-  },
-];
-```
-
-### `enforceForDeclarationWithTypeAnnotation`
-
-{/* insert option description */}
-
-Examples with `{ enforceForDeclarationWithTypeAnnotation: true }`:
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts option='{ "object": true }, { "enforceForDeclarationWithTypeAnnotation": true }'
-const x: string = obj.x;
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts option='{ "object": true }, { "enforceForDeclarationWithTypeAnnotation": true }'
-const { x }: { x: string } = obj;
-```
-
-</TabItem>
-</Tabs>