xo 0.46.0 → 0.46.4

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-explicit-any.md

@@ -0,0 +1,187 @@
+# Disallow usage of the `any` type (`no-explicit-any`)
+
+Using the `any` type defeats the purpose of using TypeScript.
+When `any` is used, all compiler type checks around that value are ignored.
+
+## Rule Details
+
+This rule doesn't allow `any` types to be defined.
+It aims to keep TypeScript maximally useful.
+TypeScript has a compiler flag for `--noImplicitAny` that will prevent
+an `any` type from being implied by the compiler, but doesn't prevent
+`any` from being explicitly used.
+
+The following patterns are considered warnings:
+
+```ts
+const age: any = 'seventeen';
+```
+
+```ts
+const ages: any[] = ['seventeen'];
+```
+
+```ts
+const ages: Array<any> = ['seventeen'];
+```
+
+```ts
+function greet(): any {}
+```
+
+```ts
+function greet(): any[] {}
+```
+
+```ts
+function greet(): Array<any> {}
+```
+
+```ts
+function greet(): Array<Array<any>> {}
+```
+
+```ts
+function greet(param: Array<any>): string {}
+```
+
+```ts
+function greet(param: Array<any>): Array<any> {}
+```
+
+The following patterns are not warnings:
+
+```ts
+const age: number = 17;
+```
+
+```ts
+const ages: number[] = [17];
+```
+
+```ts
+const ages: Array<number> = [17];
+```
+
+```ts
+function greet(): string {}
+```
+
+```ts
+function greet(): string[] {}
+```
+
+```ts
+function greet(): Array<string> {}
+```
+
+```ts
+function greet(): Array<Array<string>> {}
+```
+
+```ts
+function greet(param: Array<string>): string {}
+```
+
+```ts
+function greet(param: Array<string>): Array<string> {}
+```
+
+## Options
+
+The rule accepts an options object with the following properties:
+
+```ts
+type Options = {
+  // if true, auto-fixing will be made available in which the "any" type is converted to an "unknown" type
+  fixToUnknown: boolean;
+  // specify if arrays from the rest operator are considered okay
+  ignoreRestArgs: boolean;
+};
+
+const defaults = {
+  fixToUnknown: false,
+  ignoreRestArgs: false,
+};
+```
+
+### `ignoreRestArgs`
+
+A boolean to specify if arrays from the rest operator are considered okay. `false` by default.
+
+Examples of **incorrect** code for the `{ "ignoreRestArgs": false }` option:
+
+```ts
+/*eslint @typescript-eslint/no-explicit-any: ["error", { "ignoreRestArgs": false }]*/
+
+function foo1(...args: any[]): void {}
+function foo2(...args: readonly any[]): void {}
+function foo3(...args: Array<any>): void {}
+function foo4(...args: ReadonlyArray<any>): void {}
+
+declare function bar(...args: any[]): void;
+
+const baz = (...args: any[]) => {};
+const qux = function (...args: any[]) {};
+
+type Quux = (...args: any[]) => void;
+type Quuz = new (...args: any[]) => void;
+
+interface Grault {
+  (...args: any[]): void;
+}
+interface Corge {
+  new (...args: any[]): void;
+}
+interface Garply {
+  f(...args: any[]): void;
+}
+```
+
+Examples of **correct** code for the `{ "ignoreRestArgs": true }` option:
+
+```ts
+/*eslint @typescript-eslint/no-explicit-any: ["error", { "ignoreRestArgs": true }]*/
+
+function foo1(...args: any[]): void {}
+function foo2(...args: readonly any[]): void {}
+function foo3(...args: Array<any>): void {}
+function foo4(...args: ReadonlyArray<any>): void {}
+
+declare function bar(...args: any[]): void;
+
+const baz = (...args: any[]) => {};
+const qux = function (...args: any[]) {};
+
+type Quux = (...args: any[]) => void;
+type Quuz = new (...args: any[]) => void;
+
+interface Grault {
+  (...args: any[]): void;
+}
+interface Corge {
+  new (...args: any[]): void;
+}
+interface Garply {
+  f(...args: any[]): void;
+}
+```
+
+## When Not To Use It
+
+If an unknown type or a library without typings is used
+and you want to be able to specify `any`.
+
+## Further Reading
+
+- TypeScript [any type](https://www.typescriptlang.org/docs/handbook/basic-types.html#any)
+
+## Compatibility
+
+- TSLint: [no-any](https://palantir.github.io/tslint/rules/no-any/)
+
+## Attributes
+
+- [x] ✅ Recommended
+- [x] 🔧 Fixable
+- [ ] 💭 Requires type information

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-extra-non-null-assertion.md

@@ -0,0 +1,55 @@
+# Disallow extra non-null assertion (`no-extra-non-null-assertion`)
+
+## Rule Details
+
+Examples of **incorrect** code for this rule:
+
+```ts
+const foo: { bar: number } | null = null;
+const bar = foo!!!.bar;
+```
+
+```ts
+function foo(bar: number | undefined) {
+  const bar: number = bar!!!;
+}
+```
+
+```ts
+function foo(bar?: { n: number }) {
+  return bar!?.n;
+}
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+const foo: { bar: number } | null = null;
+const bar = foo!.bar;
+```
+
+```ts
+function foo(bar: number | undefined) {
+  const bar: number = bar!;
+}
+```
+
+```ts
+function foo(bar?: { n: number }) {
+  return bar?.n;
+}
+```
+
+## How to use
+
+```json
+{
+  "@typescript-eslint/no-extra-non-null-assertion": ["error"]
+}
+```
+
+## Attributes
+
+- [x] ✅ Recommended
+- [x] 🔧 Fixable
+- [ ] 💭 Requires type information

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-extra-parens.md

@@ -0,0 +1,28 @@
+# Disallow unnecessary parentheses (`no-extra-parens`)
+
+## Rule Details
+
+This rule extends the base [`eslint/no-extra-parens`](https://eslint.org/docs/rules/no-extra-parens) rule.
+It adds support for TypeScript type assertions.
+
+## How to use
+
+```jsonc
+{
+  // note you must disable the base rule as it can report incorrect errors
+  "no-extra-parens": "off",
+  "@typescript-eslint/no-extra-parens": ["error"]
+}
+```
+
+## Options
+
+See [`eslint/no-extra-parens` options](https://eslint.org/docs/rules/no-extra-parens#options).
+
+<sup>Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/master/docs/rules/no-extra-parens.md)</sup>
+
+## Attributes
+
+- [ ] ✅ Recommended
+- [x] 🔧 Fixable
+- [ ] 💭 Requires type information

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-extra-semi.md

@@ -0,0 +1,28 @@
+# Disallow unnecessary semicolons (`no-extra-semi`)
+
+## Rule Details
+
+This rule extends the base [`eslint/no-extra-semi`](https://eslint.org/docs/rules/no-extra-semi) rule.
+It adds support for class properties.
+
+## How to use
+
+```jsonc
+{
+  // note you must disable the base rule as it can report incorrect errors
+  "no-extra-semi": "off",
+  "@typescript-eslint/no-extra-semi": ["error"]
+}
+```
+
+## Options
+
+See [`eslint/no-extra-semi` options](https://eslint.org/docs/rules/no-extra-semi#options).
+
+<sup>Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/master/docs/rules/no-extra-semi.md)</sup>
+
+## Attributes
+
+- [x] ✅ Recommended
+- [x] 🔧 Fixable
+- [ ] 💭 Requires type information

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-extraneous-class.md

@@ -0,0 +1,86 @@
+# Forbids the use of classes as namespaces (`no-extraneous-class`)
+
+This rule warns when a class is accidentally used as a namespace.
+
+## Rule Details
+
+From TSLint’s docs:
+
+> Users who come from a Java-style OO language may wrap their utility functions in an extra class,
+> instead of putting them at the top level.
+
+Examples of **incorrect** code for this rule:
+
+```ts
+class EmptyClass {}
+
+class ConstructorOnly {
+  constructor() {
+    foo();
+  }
+}
+
+// Use an object instead:
+class StaticOnly {
+  static version = 42;
+  static hello() {
+    console.log('Hello, world!');
+  }
+}
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+class EmptyClass extends SuperClass {}
+
+class ParameterProperties {
+  constructor(public name: string) {}
+}
+
+const StaticOnly = {
+  version: 42,
+  hello() {
+    console.log('Hello, world!');
+  },
+};
+```
+
+### Options
+
+This rule accepts a single object option.
+
+```ts
+type Options = {
+  // allow extraneous classes if they only contain a constructor
+  allowConstructorOnly?: boolean;
+  // allow extraneous classes if they have no body (i.e. are empty)
+  allowEmpty?: boolean;
+  // allow extraneous classes if they only contain static members
+  allowStaticOnly?: boolean;
+  // allow extraneous classes if they have a decorator
+  allowWithDecorator?: boolean;
+};
+
+const defaultOptions: Options = {
+  allowConstructorOnly: false,
+  allowEmpty: false,
+  allowStaticOnly: false,
+  allowWithDecorator: false,
+};
+```
+
+## When Not To Use It
+
+You can disable this rule if you don’t have anyone who would make these kinds of mistakes on your
+team or if you use classes as namespaces.
+
+## Compatibility
+
+[`no-unnecessary-class`](https://palantir.github.io/tslint/rules/no-unnecessary-class/) from TSLint
+
+## Attributes
+
+- [ ] ✅ Recommended
+- [ ] 🔧 Fixable
+- [ ] 💭 Requires type information

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-floating-promises.md

@@ -0,0 +1,110 @@
+# Requires Promise-like values to be handled appropriately (`no-floating-promises`)
+
+This rule forbids usage of Promise-like values in statements without handling
+their errors appropriately. Unhandled promises can cause several issues, such
+as improperly sequenced operations, ignored Promise rejections and more. Valid
+ways of handling a Promise-valued statement include `await`ing, returning, and
+either calling `.then()` with two arguments or `.catch()` with one argument.
+
+## Rule Details
+
+Examples of **incorrect** code for this rule:
+
+```ts
+const promise = new Promise((resolve, reject) => resolve('value'));
+promise;
+
+async function returnsPromise() {
+  return 'value';
+}
+returnsPromise().then(() => {});
+
+Promise.reject('value').catch();
+
+Promise.reject('value').finally();
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+const promise = new Promise((resolve, reject) => resolve('value'));
+await promise;
+
+async function returnsPromise() {
+  return 'value';
+}
+returnsPromise().then(
+  () => {},
+  () => {},
+);
+
+Promise.reject('value').catch(() => {});
+
+Promise.reject('value').finally(() => {});
+```
+
+## Options
+
+The rule accepts an options object with the following properties:
+
+```ts
+type Options = {
+  // if true, checking void expressions will be skipped
+  ignoreVoid?: boolean;
+  // if true, checking for async iife will be skipped
+  ignoreIIFE?: boolean;
+};
+
+const defaults = {
+  ignoreVoid: true,
+  ignoreIIFE: false,
+};
+```
+
+### `ignoreVoid`
+
+This allows you to stop the rule reporting promises consumed with void operator.
+This can be a good way to explicitly mark a promise as intentionally not awaited.
+
+Examples of **correct** code for this rule with `{ ignoreVoid: true }`:
+
+```ts
+async function returnsPromise() {
+  return 'value';
+}
+void returnsPromise();
+
+void Promise.reject('value');
+```
+
+With this option set to `true`, and if you are using `no-void`, you should turn on the [`allowAsStatement`](https://eslint.org/docs/rules/no-void#allowasstatement) option.
+
+### `ignoreIIFE`
+
+This allows you to skip checking of async iife
+
+Examples of **correct** code for this rule with `{ ignoreIIFE: true }`:
+
+```ts
+await(async function () {
+  await res(1);
+})();
+
+(async function () {
+  await res(1);
+})();
+```
+
+## When Not To Use It
+
+If you do not use Promise-like values in your codebase, or want to allow them to remain unhandled.
+
+## Related to
+
+- TSLint: ['no-floating-promises'](https://palantir.github.io/tslint/rules/no-floating-promises/)
+
+## Attributes
+
+- [x] ✅ Recommended
+- [ ] 🔧 Fixable
+- [x] 💭 Requires type information

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-for-in-array.md

@@ -0,0 +1,50 @@
+# Disallow iterating over an array with a for-in loop (`no-for-in-array`)
+
+This rule prohibits iterating over an array with a for-in loop.
+
+## Rule Details
+
+Rationale from TSLint:
+
+A for-in loop (`for (var k in o)`) iterates over the properties of an Object.
+While it is legal to use for-in loops with array types, it is not common.
+for-in will iterate over the indices of the array as strings, omitting any "holes" in
+the array.
+More common is to use for-of, which iterates over the values of an array.
+If you want to iterate over the indices, alternatives include:
+
+```js
+array.forEach((value, index) => { ... });
+for (const [index, value] of array.entries()) { ... }
+for (let i = 0; i < array.length; i++) { ... }
+```
+
+Examples of **incorrect** code for this rule:
+
+```js
+for (const x in [3, 4, 5]) {
+  console.log(x);
+}
+```
+
+Examples of **correct** code for this rule:
+
+```js
+for (const x in { a: 3, b: 4, c: 5 }) {
+  console.log(x);
+}
+```
+
+## When Not To Use It
+
+If you want to iterate through a loop using the indices in an array as strings, you can turn off this rule.
+
+## Related to
+
+- TSLint: ['no-for-in-array'](https://palantir.github.io/tslint/rules/no-for-in-array/)
+
+## Attributes
+
+- [x] ✅ Recommended
+- [ ] 🔧 Fixable
+- [x] 💭 Requires type information

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-implicit-any-catch.md

@@ -0,0 +1,82 @@
+# Disallow usage of the implicit `any` type in catch clauses (`no-implicit-any-catch`)
+
+TypeScript 4.0 added support for adding an explicit `any` or `unknown` type annotation on a catch clause variable.
+
+By default, TypeScript will type a catch clause variable as `any`, so explicitly annotating it as `unknown` can add a lot of safety to your codebase.
+
+The `noImplicitAny` flag in TypeScript does not cover this for backwards compatibility reasons.
+
+## Rule Details
+
+This rule requires an explicit type to be declared on a catch clause variable.
+
+The following pattern is considered a warning:
+
+```ts
+try {
+  // ...
+} catch (e) {
+  // ...
+}
+```
+
+The following pattern is **_not_** considered a warning:
+
+<!-- TODO: prettier currently removes the type annotations, re-enable this once prettier is updated -->
+<!-- prettier-ignore-start -->
+
+```ts
+try {
+  // ...
+} catch (e: unknown) {
+  // ...
+}
+```
+
+<!-- prettier-ignore-end -->
+
+## Options
+
+The rule accepts an options object with the following properties:
+
+```ts
+type Options = {
+  // if false, disallow specifying `: any` as the error type as well. See also `no-explicit-any`
+  allowExplicitAny: boolean;
+};
+
+const defaults = {
+  allowExplicitAny: false,
+};
+```
+
+### `allowExplicitAny`
+
+The follow is is **_not_** considered a warning with `{ allowExplicitAny: true }`
+
+<!-- TODO: prettier currently removes the type annotations, re-enable this once prettier is updated -->
+<!-- prettier-ignore-start -->
+
+```ts
+try {
+  // ...
+} catch (e: any) {
+  // ...
+}
+```
+
+<!-- prettier-ignore-end -->
+
+## When Not To Use It
+
+If you are not using TypeScript 4.0 (or greater), then you will not be able to use this rule, annotations on catch clauses is not supported.
+
+## Further Reading
+
+- [TypeScript 4.0 Beta Release Notes](https://devblogs.microsoft.com/typescript/announcing-typescript-4-0-beta/#unknown-on-catch)
+
+## Attributes
+
+- [ ] ✅ Recommended
+- [x] 🔧 Fixable
+- [ ] 💭 Requires type information