xo 0.46.4 → 0.49.0

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

@@ -1,4 +1,6 @@
-# Enforce `includes` method over `indexOf` method (`prefer-includes`)
+# `prefer-includes`
+
+Enforce `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.
@@ -15,7 +17,11 @@ There are such types: `String`, `Array`, `ReadonlyArray`, and typed arrays.
 
 Additionally, this rule reports the tests of simple regular expressions in favor of `String#includes`.
 
-Examples of **incorrect** code for this rule:
+Examples of code for this rule:
+
+<!--tabs-->
+
+### ❌ Incorrect
 
 ```ts
 let str: string;
@@ -39,7 +45,7 @@ userDefined.indexOf(value) >= 0;
 /foo/.test(str);
 ```
 
-Examples of **correct** code for this rule:
+### ✅ Correct
 
 ```ts
 let array: any[];
@@ -66,7 +72,16 @@ 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
 
@@ -74,6 +89,8 @@ If you don't want to suggest `includes`, you can safely turn this rule off.
 
 ## Attributes
 
-- [ ] ✅ Recommended
+- Configs:
+  - [ ] ✅ Recommended
+  - [x] 🔒 Strict
 - [x] 🔧 Fixable
 - [x] 💭 Requires type information

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

@@ -1,4 +1,6 @@
-# Require that all enum members be literal values to prevent unintended enum member name shadow issues (`prefer-literal-enum-member`)
+# `prefer-literal-enum-member`
+
+Require that all enum members be literal values to prevent unintended enum member name shadow issues.
 
 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:
 
@@ -25,7 +27,11 @@ This rule is meant to prevent unexpected results in code by requiring the use of
 
 - `allowBitwiseExpressions` set to `true` will allow you to use bitwise expressions in enum initializer (Default: `false`).
 
-Examples of **incorrect** code for this rule:
+Examples of code for this rule:
+
+<!--tabs-->
+
+### ❌ Incorrect
 
 ```ts
 const str = 'Test';
@@ -38,7 +44,7 @@ enum Invalid {
 }
 ```
 
-Examples of **correct** code for this rule:
+### ✅ Correct
 
 ```ts
 enum Valid {
@@ -50,9 +56,15 @@ enum Valid {
 }
 ```
 
+<!--/tabs-->
+
 ### `allowBitwiseExpressions`
 
-Examples of **incorrect** code for the `{ "allowBitwiseExpressions": true }` option:
+Examples of code for the `{ "allowBitwiseExpressions": true }` option:
+
+<!--tabs-->
+
+#### ❌ Incorrect
 
 ```ts
 const x = 1;
@@ -67,7 +79,7 @@ enum Foo {
 }
 ```
 
-Examples of **correct** code for the `{ "allowBitwiseExpressions": true }` option:
+#### ✅ Correct
 
 ```ts
 enum Foo {
@@ -87,6 +99,8 @@ If you want use anything other than simple literals as an enum value.
 
 ## Attributes
 
-- [ ] ✅ Recommended
+- Configs:
+  - [ ] ✅ Recommended
+  - [x] 🔒 Strict
 - [ ] 🔧 Fixable
 - [ ] 💭 Requires type information

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

@@ -1,4 +1,6 @@
-# Require the use of the `namespace` keyword instead of the `module` keyword to declare custom TypeScript modules (`prefer-namespace-keyword`)
+# `prefer-namespace-keyword`
+
+Require the use of the `namespace` keyword instead of the `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.
@@ -11,18 +13,33 @@ This rule aims to standardize the way modules are declared.
 
 If you are using the ES2015 module syntax, then you will not need this rule.
 
+## Options
+
+```jsonc
+// .eslintrc.json
+{
+  "rules": {
+    "@typescript-eslint/prefer-namespace-keyword": "error"
+  }
+}
+```
+
+This rule is not configurable.
+
 ## 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)
 
-## Compatibility
+## Related To
 
 - TSLint: [no-internal-module](https://palantir.github.io/tslint/rules/no-internal-module/)
 
 ## Attributes
 
-- [x] ✅ Recommended
+- Configs:
+  - [x] ✅ Recommended
+  - [x] 🔒 Strict
 - [x] 🔧 Fixable
 - [ ] 💭 Requires type information

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

@@ -1,4 +1,6 @@
-# Enforce the usage of the nullish coalescing operator instead of logical chaining (`prefer-nullish-coalescing`)
+# `prefer-nullish-coalescing`
+
+Enforce the usage of 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`.
@@ -142,6 +144,8 @@ If you are not using TypeScript 3.7 (or greater), then you will not be able to u
 
 ## Attributes
 
-- [ ] ✅ Recommended
+- Configs:
+  - [ ] ✅ Recommended
+  - [x] 🔒 Strict
 - [ ] 🔧 Fixable
 - [x] 💭 Requires type information

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

@@ -1,4 +1,6 @@
-# Prefer using concise optional chain expressions instead of chained logical ands (`prefer-optional-chain`)
+# `prefer-optional-chain`
+
+Prefer using concise optional chain expressions instead of chained logical ands.
 
 TypeScript 3.7 added support for the optional chain operator.
 This operator allows you to safely access properties and methods on objects when they are potentially `null` or `undefined`.
@@ -20,6 +22,10 @@ function myFunc(foo: T | null) {
 function myFunc(foo: T | null) {
   return foo && foo.a && foo.a.b && foo.a.b.c;
 }
+// or
+function myFunc(foo: T | null) {
+  return (((foo || {}).a || {}).b || {}).c;
+}
 
 function myFunc(foo: T | null) {
   return foo?.['a']?.b?.c;
@@ -44,13 +50,20 @@ Because the optional chain operator _only_ chains when the property value is `nu
 
 This rule aims enforce the usage of the safer operator.
 
-Examples of **incorrect** code for this rule:
+Examples of code for this rule:
+
+<!--tabs-->
+
+### ❌ Incorrect
 
 ```ts
 foo && foo.a && foo.a.b && foo.a.b.c;
 foo && foo['a'] && foo['a'].b && foo['a'].b.c;
 foo && foo.a && foo.a.b && foo.a.b.method && foo.a.b.method();
 
+(((foo || {}).a || {}).b {}).c;
+(((foo || {})['a'] || {}).b {}).c;
+
 // this rule also supports converting chained strict nullish checks:
 foo &&
   foo.a != null &&
@@ -60,7 +73,7 @@ foo &&
   foo.a.b.c.d.e;
 ```
 
-Examples of **correct** code for this rule:
+### ✅ Correct
 
 ```ts
 foo?.a?.b?.c;
@@ -72,6 +85,19 @@ foo?.a?.b?.c?.d?.e;
 
 **Note:** there are a few edge cases where this rule will false positive. Use your best judgement when evaluating reported errors.
 
+## Options
+
+```jsonc
+// .eslintrc.json
+{
+  "rules": {
+    "@typescript-eslint/prefer-optional-chain": "warn"
+  }
+}
+```
+
+This rule is not configurable.
+
 ## When Not To Use It
 
 If you are not using TypeScript 3.7 (or greater), then you will not be able to use this rule, as the operator is not supported.
@@ -83,6 +109,8 @@ If you are not using TypeScript 3.7 (or greater), then you will not be able to u
 
 ## Attributes
 
-- [ ] ✅ Recommended
+- Configs:
+  - [ ] ✅ Recommended
+  - [x] 🔒 Strict
 - [ ] 🔧 Fixable
 - [ ] 💭 Requires type information

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-readonly-parameter-types.md

@@ -1,4 +1,6 @@
-# Requires that function parameters are typed as readonly to prevent accidental mutation of inputs (`prefer-readonly-parameter-types`)
+# `prefer-readonly-parameter-types`
+
+Requires that function parameters are typed as readonly to prevent accidental mutation of inputs.
 
 Mutating function arguments can lead to confusing, hard to debug behavior.
 Whilst it's easy to implicitly remember to not modify function arguments, explicitly typing arguments as readonly provides clear contract to consumers.
@@ -15,7 +17,11 @@ A type is considered readonly if:
 - it is a readonly tuple type whose elements are all considered readonly.
 - it is an object type whose properties are all marked as readonly, and whose values are all considered readonly.
 
-Examples of **incorrect** code for this rule:
+Examples of code for this rule:
+
+<!--tabs-->
+
+### ❌ Incorrect
 
 ```ts
 function array1(arg: string[]) {} // array is not readonly
@@ -57,7 +63,7 @@ interface Foo {
 }
 ```
 
-Examples of **correct** code for this rule:
+### ✅ Correct
 
 ```ts
 function array1(arg: readonly string[]) {}
@@ -139,7 +145,11 @@ const defaultOptions: Options = {
 This option allows you to enable or disable the checking of parameter properties.
 Because parameter properties create properties on the class, it may be undesirable to force them to be readonly.
 
-Examples of **incorrect** code for this rule with `{checkParameterProperties: true}`:
+Examples of code for this rule with `{checkParameterProperties: true}`:
+
+<!--tabs-->
+
+#### ❌ Incorrect
 
 ```ts
 class Foo {
@@ -147,7 +157,7 @@ class Foo {
 }
 ```
 
-Examples of **correct** code for this rule with `{checkParameterProperties: true}`:
+#### ✅ Correct
 
 ```ts
 class Foo {
@@ -155,6 +165,8 @@ class Foo {
 }
 ```
 
+<!--/tabs-->
+
 Examples of **correct** code for this rule with `{checkParameterProperties: false}`:
 
 ```ts
@@ -170,7 +182,11 @@ class Foo {
 
 This option allows you to ignore parameters which don't explicitly specify a type. This may be desirable in cases where an external dependency specifies a callback with mutable parameters, and manually annotating the callback's parameters is undesirable.
 
-Examples of **incorrect** code for this rule with `{ignoreInferredTypes: true}`:
+Examples of code for this rule with `{ignoreInferredTypes: true}`:
+
+<!--tabs-->
+
+#### ❌ Incorrect
 
 ```ts
 import { acceptsCallback, CallbackOptions } from 'external-dependency';
@@ -193,7 +209,7 @@ export const acceptsCallback: AcceptsCallback;
 
 </details>
 
-Examples of **correct** code for this rule with `{ignoreInferredTypes: true}`:
+#### ✅ Correct
 
 ```ts
 import { acceptsCallback } from 'external-dependency';
@@ -218,9 +234,13 @@ export const acceptsCallback: AcceptsCallback;
 
 ### `treatMethodsAsReadonly`
 
-This option allows you to treat all mutable methods as though they were readonly. This may be desirable in when you are never reassigning methods.
+This option allows you to treat all mutable methods as though they were readonly. This may be desirable when you are never reassigning methods.
+
+Examples of code for this rule with `{treatMethodsAsReadonly: false}`:
 
-Examples of **incorrect** code for this rule with `{treatMethodsAsReadonly: false}`:
+<!--tabs-->
+
+#### ❌ Incorrect
 
 ```ts
 type MyType = {
@@ -230,7 +250,7 @@ type MyType = {
 function foo(arg: MyType) {}
 ```
 
-Examples of **correct** code for this rule with `{treatMethodsAsReadonly: false}`:
+#### ✅ Correct
 
 ```ts
 type MyType = Readonly<{
@@ -246,6 +266,8 @@ type MyOtherType = {
 function bar(arg: MyOtherType) {}
 ```
 
+<!--/tabs-->
+
 Examples of **correct** code for this rule with `{treatMethodsAsReadonly: true}`:
 
 ```ts
@@ -258,6 +280,8 @@ function foo(arg: MyType) {}
 
 ## Attributes
 
-- [ ] ✅ Recommended
+- Configs:
+  - [ ] ✅ Recommended
+  - [ ] 🔒 Strict
 - [ ] 🔧 Fixable
 - [x] 💭 Requires type information

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

@@ -1,4 +1,6 @@
-# Requires that private members are marked as `readonly` if they're never modified outside of the constructor (`prefer-readonly`)
+# `prefer-readonly`
+
+Requires that private members are marked as `readonly` if they're never modified outside of the constructor.
 
 This rule enforces that private members are marked as `readonly` if they're never modified outside of the constructor.
 
@@ -7,7 +9,11 @@ This rule enforces that private members are marked as `readonly` if they're neve
 Member variables with the privacy `private` are never permitted to be modified outside of their declaring class.
 If that class never modifies their value, they may safely be marked as `readonly`.
 
-Examples of **incorrect** code for this rule:
+Examples of code for this rule:
+
+<!--tabs-->
+
+### ❌ Incorrect
 
 ```ts
 class Container {
@@ -25,7 +31,7 @@ class Container {
 }
 ```
 
-Examples of **correct** code for this rule:
+### ✅ Correct
 
 ```ts
 class Container {
@@ -58,30 +64,36 @@ You may pass `"onlyInlineLambdas": true` as a rule option within an object to re
 }
 ```
 
-Example of **correct** code for the `{ "onlyInlineLambdas": true }` options:
+Example of code for the `{ "onlyInlineLambdas": true }` options:
+
+<!--tabs-->
+
+#### ❌ Incorrect
 
 ```ts
 class Container {
-  private neverModifiedPrivate = 'unchanged';
+  private onClick = () => {
+    /* ... */
+  };
 }
 ```
 
-Example of **incorrect** code for the `{ "onlyInlineLambdas": true }` options:
+#### ✅ Correct
 
 ```ts
 class Container {
-  private onClick = () => {
-    /* ... */
-  };
+  private neverModifiedPrivate = 'unchanged';
 }
 ```
 
-## Related to
+## Related To
 
 - TSLint: ['prefer-readonly'](https://palantir.github.io/tslint/rules/prefer-readonly)
 
 ## Attributes
 
-- [ ] ✅ Recommended
+- Configs:
+  - [ ] ✅ Recommended
+  - [ ] 🔒 Strict
 - [x] 🔧 Fixable
 - [x] 💭 Requires type information

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

@@ -1,4 +1,6 @@
-# Prefer using type parameter when calling `Array#reduce` instead of casting (`prefer-reduce-type-parameter`)
+# `prefer-reduce-type-parameter`
+
+Prefer using type parameter when calling `Array#reduce` instead of casting.
 
 It's common to call `Array#reduce` with a generic type, such as an array or object, as the initial value.
 Since these values are empty, their types are not usable:
@@ -17,7 +19,11 @@ This means that TypeScript doesn't have to try to infer the type, and avoids the
 This rule looks for calls to `Array#reduce`, and warns if an initial value is being passed & casted,
 suggesting instead to pass the cast type to `Array#reduce` as its generic parameter.
 
-Examples of **incorrect** code for this rule:
+Examples of code for this rule:
+
+<!--tabs-->
+
+### ❌ Incorrect
 
 ```ts
 [1, 2, 3].reduce((arr, num) => arr.concat(num * 2), [] as number[]);
@@ -31,7 +37,7 @@ Examples of **incorrect** code for this rule:
 );
 ```
 
-Examples of **correct** code for this rule:
+### ✅ Correct
 
 ```ts
 [1, 2, 3].reduce<number[]>((arr, num) => arr.concat(num * 2), []);
@@ -47,7 +53,16 @@ Examples of **correct** code for this rule:
 
 ## Options
 
-There are no options.
+```jsonc
+// .eslintrc.json
+{
+  "rules": {
+    "@typescript-eslint/prefer-reduce-type-parameter": "warn"
+  }
+}
+```
+
+This rule is not configurable.
 
 ## When Not To Use It
 
@@ -55,6 +70,8 @@ If you don't want to use typechecking in your linting, you can't use this rule.
 
 ## Attributes
 
-- [ ] ✅ Recommended
+- Configs:
+  - [ ] ✅ Recommended
+  - [x] 🔒 Strict
 - [x] 🔧 Fixable
 - [x] 💭 Requires type information

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

@@ -1,4 +1,6 @@
-# Enforce that `RegExp#exec` is used instead of `String#match` if no global flag is provided (`prefer-regexp-exec`)
+# `prefer-regexp-exec`
+
+Enforce that `RegExp#exec` is used instead of `String#match` if no global flag is provided.
 
 As `String#match` is defined to be the same as `RegExp#exec` when the regular expression does not include the `g` flag, prefer a consistent usage.
 
@@ -12,7 +14,11 @@ From [`String#match` on MDN](https://developer.mozilla.org/en-US/docs/Web/JavaSc
 
 `RegExp#exec` may also be slightly faster than `String#match`; this is the reason to choose it as the preferred usage.
 
-Examples of **incorrect** code for this rule:
+Examples of code for this rule:
+
+<!--tabs-->
+
+### ❌ Incorrect
 
 ```ts
 'something'.match(/thing/);
@@ -24,7 +30,7 @@ const search = /thing/;
 text.match(search);
 ```
 
-Examples of **correct** code for this rule:
+### ✅ Correct
 
 ```ts
 /thing/.exec('something');
@@ -38,20 +44,25 @@ search.exec(text);
 
 ## Options
 
-There are no options.
-
-```json
+```jsonc
+// .eslintrc.json
 {
-  "@typescript-eslint/prefer-regexp-exec": "error"
+  "rules": {
+    "@typescript-eslint/prefer-regexp-exec": "warn"
+  }
 }
 ```
 
+This rule is not configurable.
+
 ## When Not To Use It
 
 If you prefer consistent use of `String#match` for both, with `g` flag and without it, you can turn this rule off.
 
 ## Attributes
 
-- [ ] ✅ Recommended
+- Configs:
+  - [ ] ✅ Recommended
+  - [ ] 🔒 Strict
 - [x] 🔧 Fixable
 - [x] 💭 Requires type information

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

@@ -1,4 +1,6 @@
-# Enforce that `this` is used when only `this` type is returned (`prefer-return-this-type`)
+# `prefer-return-this-type`
+
+Enforce that `this` is used when only `this` type is returned.
 
 [Method chaining](https://en.wikipedia.org/wiki/Method_chaining) is a common pattern in OOP languages and TypeScript provides a special [polymorphic this type](https://www.typescriptlang.org/docs/handbook/2/classes.html#this-types).
 If any type other than `this` is specified as the return type of these chaining methods, TypeScript will fail to cast it when invoking in subclass.
@@ -43,7 +45,13 @@ const cat = new Cat();
 cat.eat().meow();
 ```
 
-Examples of **incorrect** code for this rule:
+## Rule Details
+
+Examples of code for this rule:
+
+<!--tabs-->
+
+### ❌ Incorrect
 
 ```ts
 class Foo {
@@ -59,7 +67,7 @@ class Foo {
 }
 ```
 
-Examples of **correct** code for this rule:
+### ✅ Correct
 
 ```ts
 class Foo {
@@ -85,12 +93,27 @@ class Derived extends Base {
 }
 ```
 
+## Options
+
+```jsonc
+// .eslintrc.json
+{
+  "rules": {
+    "@typescript-eslint/prefer-return-this-type": "warn"
+  }
+}
+```
+
+This rule is not configurable.
+
 ## When Not To Use It
 
 If you don't use method chaining or explicit return values, you can safely turn this rule off.
 
 ## Attributes
 
-- [ ] ✅ Recommended
+- Configs:
+  - [ ] ✅ Recommended
+  - [x] 🔒 Strict
 - [x] 🔧 Fixable
 - [x] 💭 Requires type information

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-string-starts-ends-with.md

@@ -1,4 +1,6 @@
-# Enforce the use of `String#startsWith` and `String#endsWith` instead of other equivalent methods of checking substrings (`prefer-string-starts-ends-with`)
+# `prefer-string-starts-ends-with`
+
+Enforce the use of `String#startsWith` and `String#endsWith` instead of other equivalent methods of checking substrings.
 
 There are multiple ways to verify if a string starts or ends with a specific string, such as `foo.indexOf('bar') === 0`.
 
@@ -8,7 +10,11 @@ Since ES2015 has added `String#startsWith` and `String#endsWith`, this rule repo
 
 This rule is aimed at enforcing a consistent way to check whether a string starts or ends with a specific string.
 
-Examples of **incorrect** code for this rule:
+Examples of code for this rule:
+
+<!--tabs-->
+
+### ❌ Incorrect
 
 ```ts
 let foo: string;
@@ -32,7 +38,7 @@ foo.match(/bar$/) != null;
 /bar$/.test(foo);
 ```
 
-Examples of **correct** code for this rule:
+### ✅ Correct
 
 ```ts
 foo.startsWith('bar');
@@ -41,20 +47,25 @@ foo.endsWith('bar');
 
 ## Options
 
-There are no options.
-
-```JSON
+```jsonc
+// .eslintrc.json
 {
-    "@typescript-eslint/prefer-string-starts-ends-with": "error"
+  "rules": {
+    "@typescript-eslint/prefer-string-starts-ends-with": "warn"
+  }
 }
 ```
 
+This rule is not configurable.
+
 ## When Not To Use It
 
 If you don't mind that style, you can turn this rule off safely.
 
 ## Attributes
 
-- [ ] ✅ Recommended
+- Configs:
+  - [ ] ✅ Recommended
+  - [x] 🔒 Strict
 - [x] 🔧 Fixable
 - [x] 💭 Requires type information