xo 0.48.0 → 0.51.0

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/parameter-properties.md

@@ -0,0 +1,484 @@
+# `parameter-properties`
+
+Requires or disallows parameter properties in class constructors.
+
+Parameter properties can be confusing to those new to TypeScript as they are less explicit than other ways
+of declaring and initializing class members.
+
+## Rule Details
+
+This rule disallows the use of parameter properties in constructors, forcing the user to explicitly
+declare all properties in the class.
+
+## 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"`
+
+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"`
+
+By default, the rule prefers class property (`"class-property"`).
+You can switch it to instead preferring parameter property 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-->
+
+#### ❌ 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) {}
+}
+```
+
+#### ✅ Correct
+
+```ts
+class Foo {
+  constructor(name: string) {}
+}
+```
+
+### readonly
+
+Examples of code for the `{ "allow": ["readonly"] }` options:
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+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) {}
+}
+```
+
+#### ✅ Correct
+
+```ts
+class Foo {
+  constructor(name: string) {}
+}
+
+class Foo {
+  constructor(readonly name: string) {}
+}
+```
+
+### private
+
+Examples of code for the `{ "allow": ["private"] }` options:
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+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) {}
+}
+```
+
+#### ✅ Correct
+
+```ts
+class Foo {
+  constructor(name: string) {}
+}
+
+class Foo {
+  constructor(private name: string) {}
+}
+```
+
+### protected
+
+Examples of code for the `{ "allow": ["protected"] }` options:
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+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) {}
+}
+```
+
+#### ✅ Correct
+
+```ts
+class Foo {
+  constructor(name: string) {}
+}
+
+class Foo {
+  constructor(protected name: string) {}
+}
+```
+
+### public
+
+Examples of code for the `{ "allow": ["public"] }` options:
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+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) {}
+}
+```
+
+#### ✅ Correct
+
+```ts
+class Foo {
+  constructor(name: string) {}
+}
+
+class Foo {
+  constructor(public name: string) {}
+}
+```
+
+### private readonly
+
+Examples of code for the `{ "allow": ["private readonly"] }` options:
+
+<!--tabs-->
+
+#### ❌ 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(protected readonly name: string) {}
+}
+
+class Foo {
+  constructor(public readonly name: string) {}
+}
+```
+
+#### ✅ Correct
+
+```ts
+class Foo {
+  constructor(name: string) {}
+}
+
+class Foo {
+  constructor(private readonly name: string) {}
+}
+```
+
+### protected readonly
+
+Examples of code for the `{ "allow": ["protected readonly"] }` options:
+
+<!--tabs-->
+
+#### ❌ 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(public readonly name: string) {}
+}
+```
+
+#### ✅ Correct
+
+```ts
+class Foo {
+  constructor(name: string) {}
+}
+
+class Foo {
+  constructor(protected readonly name: string) {}
+}
+```
+
+### public readonly
+
+Examples of code for the `{ "allow": ["public readonly"] }` options:
+
+<!--tabs-->
+
+#### ❌ 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) {}
+}
+```
+
+#### ✅ Correct
+
+```ts
+class Foo {
+  constructor(name: string) {}
+}
+
+class Foo {
+  constructor(public readonly name: string) {}
+}
+```
+
+### `"parameter-property"`
+
+Examples of code for the `{ "prefer": "parameter-property" }` option:
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+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;
+}
+```
+
+#### ✅ Correct
+
+```ts
+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;
+  }
+}
+```
+
+## When Not To Use It
+
+If you don't care about the using parameter properties in constructors, then you will not need this rule.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-as-const.md

@@ -1,6 +1,6 @@
 # `prefer-as-const`
 
-Prefer usage of `as const` over literal type.
+Enforces the use of `as const` over literal type.
 
 This rule recommends usage of `const` assertion when type primitive value is equal to type.
 
@@ -47,9 +47,3 @@ This rule is not configurable.
 ## When Not To Use It
 
 If you are using TypeScript < 3.4
-
-## Attributes
-
-- [x] ✅ Recommended
-- [x] 🔧 Fixable
-- [ ] 💭 Requires type information

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-enum-initializers.md

@@ -1,6 +1,6 @@
 # `prefer-enum-initializers`
 
-Prefer initializing each enums member value.
+Requires each enum member value to be explicitly initialized.
 
 This rule recommends having each `enum`s member value explicitly initialized.
 
@@ -71,12 +71,19 @@ enum Color {
 }
 ```
 
-## When Not To Use It
+## Options
 
-If you don't care about `enum`s having implicit values you can safely disable this rule.
+```jsonc
+// .eslintrc.json
+{
+  "rules": {
+    "@typescript-eslint/prefer-enum-initializers": "warn"
+  }
+}
+```
 
-## Attributes
+This rule is not configurable.
 
-- [ ] ✅ Recommended
-- [ ] 🔧 Fixable
-- [ ] 💭 Requires type information
+## When Not To Use It
+
+If you don't care about `enum`s having implicit values you can safely disable this rule.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-for-of.md

@@ -1,6 +1,6 @@
 # `prefer-for-of`
 
-Prefer a ‘for-of’ loop over a standard ‘for’ loop if the index is only used to access the array being iterated.
+Enforces the use of `for-of` loop over the standard `for` loop where possible.
 
 This rule recommends a for-of loop when the loop index is only used to read from an array that is being iterated.
 
@@ -38,16 +38,19 @@ for (let i = 0; i < arr.length; i++) {
 }
 ```
 
-## When Not To Use It
-
-If you transpile for browsers that do not support for-of loops, you may wish to use traditional for loops that produce more compact code.
+## Options
 
-## Related To
+```jsonc
+// .eslintrc.json
+{
+  "rules": {
+    "@typescript-eslint/prefer-for-of": "warn"
+  }
+}
+```
 
-- TSLint: ['prefer-for-of'](https://palantir.github.io/tslint/rules/prefer-for-of/)
+This rule is not configurable.
 
-## Attributes
+## When Not To Use It
 
-- [ ] ✅ Recommended
-- [ ] 🔧 Fixable
-- [ ] 💭 Requires type information
+If you transpile for browsers that do not support for-of loops, you may wish to use traditional for loops that produce more compact code.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-function-type.md

@@ -1,6 +1,6 @@
 # `prefer-function-type`
 
-Use function types instead of interfaces with call signatures.
+Enforces using function types instead of interfaces with call signatures.
 
 ## Rule Details
 
@@ -78,16 +78,19 @@ interface Overloaded {
 type Intersection = ((data: string) => number) & ((id: number) => string);
 ```
 
-## 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 disable this rule.
+## Options
 
-## Further Reading
+```jsonc
+// .eslintrc.json
+{
+  "rules": {
+    "@typescript-eslint/prefer-function-type": "warn"
+  }
+}
+```
 
-- TSLint: [`callable-types`](https://palantir.github.io/tslint/rules/callable-types/)
+This rule is not configurable.
 
-## Attributes
+## When Not To Use It
 
-- [ ] ✅ Recommended
-- [x] 🔧 Fixable
-- [ ] 💭 Requires type information
+If you specifically want to use an interface or type literal with a single call signature for stylistic reasons, you can disable this rule.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-includes.md

@@ -1,6 +1,6 @@
 # `prefer-includes`
 
-Enforce `includes` method over `indexOf` method.
+Enforces `includes` method over `indexOf` method.
 
 Until ES5, we were using `String#indexOf` method to check whether a string contains an arbitrary substring or not.
 Until ES2015, we were using `Array#indexOf` method to check whether an array contains an arbitrary value or not.
@@ -72,14 +72,17 @@ mismatchExample.indexOf(value) >= 0;
 
 ## Options
 
-There are no options.
+```jsonc
+// .eslintrc.json
+{
+  "rules": {
+    "@typescript-eslint/prefer-includes": "warn"
+  }
+}
+```
+
+This rule is not configurable.
 
 ## When Not To Use It
 
 If you don't want to suggest `includes`, you can safely turn this rule off.
-
-## Attributes
-
-- [ ] ✅ Recommended
-- [x] 🔧 Fixable
-- [x] 💭 Requires type information

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-literal-enum-member.md

@@ -1,6 +1,6 @@
 # `prefer-literal-enum-member`
 
-Require that all enum members be literal values to prevent unintended enum member name shadow issues.
+Requires all enum members to be literal values.
 
 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, unexpected values could be used at runtime. Example:
 
@@ -96,9 +96,3 @@ enum Foo {
 ## When Not To Use It
 
 If you want use anything other than simple literals as an enum value.
-
-## Attributes
-
-- [ ] ✅ Recommended
-- [ ] 🔧 Fixable
-- [ ] 💭 Requires type information

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-namespace-keyword.md

@@ -1,6 +1,6 @@
 # `prefer-namespace-keyword`
 
-Require the use of the `namespace` keyword instead of the `module` keyword to declare custom TypeScript modules.
+Requires using `namespace` keyword over `module` keyword to declare custom TypeScript modules.
 
 In an effort to prevent further confusion between custom TypeScript modules and the new ES2015 modules, starting
 with TypeScript `v1.5` the keyword `namespace` is now the preferred way to declare custom TypeScript modules.
@@ -31,13 +31,3 @@ This rule is not configurable.
 - [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)
-
-## Related To
-
-- TSLint: [no-internal-module](https://palantir.github.io/tslint/rules/no-internal-module/)
-
-## Attributes
-
-- [x] ✅ Recommended
-- [x] 🔧 Fixable
-- [ ] 💭 Requires type information

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-nullish-coalescing.md

@@ -1,6 +1,6 @@
 # `prefer-nullish-coalescing`
 
-Enforce the usage of the nullish coalescing operator instead of logical chaining.
+Enforces using the nullish coalescing operator instead of logical chaining.
 
 TypeScript 3.7 added support for the nullish coalescing operator.
 This operator allows you to safely cascade a value when dealing with `null` or `undefined`.
@@ -141,9 +141,3 @@ If you are not using TypeScript 3.7 (or greater), then you will not be able to u
 
 - [TypeScript 3.7 Release Notes](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html)
 - [Nullish Coalescing Operator Proposal](https://github.com/tc39/proposal-nullish-coalescing/)
-
-## Attributes
-
-- [ ] ✅ Recommended
-- [ ] 🔧 Fixable
-- [x] 💭 Requires type information