xo 0.46.0 → 0.46.1

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-implied-eval.md

@@ -0,0 +1,111 @@
+# Disallow the use of `eval()`-like methods (`no-implied-eval`)
+
+It's considered a good practice to avoid using `eval()`. There are security and performance implications involved with doing so, which is why many linters recommend disallowing `eval()`. However, there are some other ways to pass a string and have it interpreted as JavaScript code that have similar concerns.
+
+The first is using `setTimeout()`, `setInterval()`, `setImmediate` or `execScript()` (Internet Explorer only), all of which can accept a string of code as their first argument
+
+```ts
+setTimeout('alert(`Hi!`);', 100);
+```
+
+or using `new Function()`
+
+```ts
+const fn = new Function('a', 'b', 'return a + b');
+```
+
+This is considered an implied `eval()` because a string of code is
+passed in to be interpreted. The same can be done with `setInterval()`, `setImmediate()` and `execScript()`. All interpret the JavaScript code in the global scope.
+
+The best practice is to avoid using `new Function()` or `execScript()` and always use a function for the first argument of `setTimeout()`, `setInterval()` and `setImmediate()`.
+
+## Rule Details
+
+This rule aims to eliminate implied `eval()` through the use of `new Function()`, `setTimeout()`, `setInterval()`, `setImmediate()` or `execScript()`.
+
+Examples of **incorrect** code for this rule:
+
+```ts
+/* eslint @typescript-eslint/no-implied-eval: "error" */
+
+setTimeout('alert(`Hi!`);', 100);
+
+setInterval('alert(`Hi!`);', 100);
+
+setImmediate('alert(`Hi!`)');
+
+execScript('alert(`Hi!`)');
+
+window.setTimeout('count = 5', 10);
+
+window.setInterval('foo = bar', 10);
+
+const fn = '() = {}';
+setTimeout(fn, 100);
+
+const fn = () => {
+  return 'x = 10';
+};
+setTimeout(fn(), 100);
+
+const fn = new Function('a', 'b', 'return a + b');
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+/* eslint @typescript-eslint/no-implied-eval: "error" */
+
+setTimeout(function () {
+  alert('Hi!');
+}, 100);
+
+setInterval(function () {
+  alert('Hi!');
+}, 100);
+
+setImmediate(function () {
+  alert('Hi!');
+});
+
+execScript(function () {
+  alert('Hi!');
+});
+
+const fn = () => {};
+setTimeout(fn, 100);
+
+const foo = {
+  fn: function () {},
+};
+setTimeout(foo.fn, 100);
+setTimeout(foo.fn.bind(this), 100);
+
+class Foo {
+  static fn = () => {};
+}
+
+setTimeout(Foo.fn, 100);
+```
+
+## How to use
+
+```jsonc
+{
+  // note you must disable the base rule as it can report incorrect errors
+  "no-implied-eval": "off",
+  "@typescript-eslint/no-implied-eval": ["error"]
+}
+```
+
+## When Not To Use It
+
+If you want to allow `new Function()` or `setTimeout()`, `setInterval()`, `setImmediate()` and `execScript()` with string arguments, then you can safely disable this rule.
+
+<sup>Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/master/docs/rules/no-implied-eval.md)</sup>
+
+## Attributes
+
+- [x] ✅ Recommended
+- [ ] 🔧 Fixable
+- [x] 💭 Requires type information

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-inferrable-types.md

@@ -0,0 +1,152 @@
+# Disallows explicit type declarations for variables or parameters initialized to a number, string, or boolean (`no-inferrable-types`)
+
+Explicit types where they can be easily inferred may add unnecessary verbosity.
+
+## Rule Details
+
+This rule disallows explicit type declarations on parameters, variables
+and properties where the type can be easily inferred from its value.
+
+## Options
+
+This rule accepts the following options:
+
+```ts
+interface Options {
+  ignoreParameters?: boolean;
+  ignoreProperties?: boolean;
+}
+```
+
+### Default
+
+The default options are:
+
+```JSON
+{
+  "ignoreParameters": false,
+  "ignoreProperties": false,
+}
+```
+
+With these options, the following patterns are valid:
+
+```ts
+const a = 10n;
+const a = -10n;
+const a = BigInt(10);
+const a = -BigInt(10);
+const a = false;
+const a = true;
+const a = Boolean(null);
+const a = !0;
+const a = 10;
+const a = +10;
+const a = -10;
+const a = Number('1');
+const a = +Number('1');
+const a = -Number('1');
+const a = Infinity;
+const a = +Infinity;
+const a = -Infinity;
+const a = NaN;
+const a = +NaN;
+const a = -NaN;
+const a = null;
+const a = /a/;
+const a = RegExp('a');
+const a = new RegExp('a');
+const a = 'str';
+const a = `str`;
+const a = String(1);
+const a = Symbol('a');
+const a = undefined;
+const a = void someValue;
+
+class Foo {
+  prop = 5;
+}
+
+function fn(a = 5, b = true) {}
+
+function fn(a: number, b: boolean, c: string) {}
+```
+
+The following are invalid:
+
+```ts
+const a: bigint = 10n;
+const a: bigint = -10n;
+const a: bigint = BigInt(10);
+const a: bigint = -BigInt(10);
+const a: boolean = false;
+const a: boolean = true;
+const a: boolean = Boolean(null);
+const a: boolean = !0;
+const a: number = 10;
+const a: number = +10;
+const a: number = -10;
+const a: number = Number('1');
+const a: number = +Number('1');
+const a: number = -Number('1');
+const a: number = Infinity;
+const a: number = +Infinity;
+const a: number = -Infinity;
+const a: number = NaN;
+const a: number = +NaN;
+const a: number = -NaN;
+const a: null = null;
+const a: RegExp = /a/;
+const a: RegExp = RegExp('a');
+const a: RegExp = new RegExp('a');
+const a: string = 'str';
+const a: string = `str`;
+const a: string = String(1);
+const a: symbol = Symbol('a');
+const a: undefined = undefined;
+const a: undefined = void someValue;
+
+class Foo {
+  prop: number = 5;
+}
+
+function fn(a: number = 5, b: boolean = true) {}
+```
+
+### `ignoreParameters`
+
+When set to true, the following pattern is considered valid:
+
+```ts
+function foo(a: number = 5, b: boolean = true) {
+  // ...
+}
+```
+
+### `ignoreProperties`
+
+When set to true, the following pattern is considered valid:
+
+```ts
+class Foo {
+  prop: number = 5;
+}
+```
+
+## When Not To Use It
+
+If you do not want to enforce inferred types.
+
+## Further Reading
+
+TypeScript [Inference](https://www.typescriptlang.org/docs/handbook/type-inference.html)
+
+## Compatibility
+
+TSLint: [no-inferrable-types](https://palantir.github.io/tslint/rules/no-inferrable-types/)
+
+## Attributes
+
+- [x] ✅ Recommended
+- [x] 🔧 Fixable
+- [ ] 💭 Requires type information

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-invalid-this.md

@@ -0,0 +1,32 @@
+# Disallow `this` keywords outside of classes or class-like objects (`no-invalid-this`)
+
+## Rule Details
+
+This rule extends the base [`eslint/no-invalid-this`](https://eslint.org/docs/rules/no-invalid-this) rule.
+It adds support for TypeScript's `this` parameters.
+
+## How to use
+
+```jsonc
+{
+  // note you must disable the base rule as it can report incorrect errors
+  "no-invalid-this": "off",
+  "@typescript-eslint/no-invalid-this": ["error"]
+}
+```
+
+## Options
+
+See [`eslint/no-invalid-this` options](https://eslint.org/docs/rules/no-invalid-this#options).
+
+## When Not To Use It
+
+When you are indifferent as to how your variables are initialized.
+
+<sup>Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/master/docs/rules/no-invalid-this.md)</sup>
+
+## Attributes
+
+- [ ] ✅ Recommended
+- [ ] 🔧 Fixable
+- [ ] 💭 Requires type information

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-invalid-void-type.md

@@ -0,0 +1,132 @@
+# Disallows usage of `void` type outside of generic or return types (`no-invalid-void-type`)
+
+Disallows usage of `void` type outside of return types or generic type arguments.
+If `void` is used as return type, it shouldn’t be a part of intersection/union type with most other types.
+
+## Rationale
+
+The `void` type means “nothing” or that a function does not return any value,
+in contrast with implicit `undefined` type which means that a function returns a value `undefined`.
+So “nothing” cannot be mixed with any other types, other than `never`, which accepts all types.
+If you need this - use the `undefined` type instead.
+
+## Rule Details
+
+This rule aims to ensure that the `void` type is only used in valid places.
+
+The following patterns are considered warnings:
+
+```ts
+type PossibleValues = string | number | void;
+type MorePossibleValues = string | ((number & any) | (string | void));
+
+function logSomething(thing: void) {}
+function printArg<T = void>(arg: T) {}
+
+logAndReturn<void>(undefined);
+
+interface Interface {
+  lambda: () => void;
+  prop: void;
+}
+
+class MyClass {
+  private readonly propName: void;
+}
+```
+
+The following patterns are not considered warnings:
+
+```ts
+type NoOp = () => void;
+
+function noop(): void {}
+
+let trulyUndefined = void 0;
+
+async function promiseMeSomething(): Promise<void> {}
+
+type stillVoid = void | never;
+```
+
+### Options
+
+```ts
+interface Options {
+  allowInGenericTypeArguments?: boolean | string[];
+  allowAsThisParameter?: boolean;
+}
+
+const defaultOptions: Options = {
+  allowInGenericTypeArguments: true,
+  allowAsThisParameter: false,
+};
+```
+
+#### `allowInGenericTypeArguments`
+
+This option lets you control if `void` can be used as a valid value for generic type parameters.
+
+Alternatively, you can provide an array of strings which whitelist which types may accept `void` as a generic type parameter.
+
+Any types considered valid by this option will be considered valid as part of a union type with `void`.
+
+This option is `true` by default.
+
+The following patterns are considered warnings with `{ allowInGenericTypeArguments: false }`:
+
+```ts
+logAndReturn<void>(undefined);
+
+let voidPromise: Promise<void> = new Promise<void>(() => {});
+let voidMap: Map<string, void> = new Map<string, void>();
+```
+
+The following patterns are considered warnings with `{ allowInGenericTypeArguments: ['Ex.Mx.Tx'] }`:
+
+```ts
+logAndReturn<void>(undefined);
+
+type NotAllowedVoid1 = Mx.Tx<void>;
+type NotAllowedVoid2 = Tx<void>;
+type NotAllowedVoid3 = Promise<void>;
+```
+
+The following patterns are not considered warnings with `{ allowInGenericTypeArguments: ['Ex.Mx.Tx'] }`:
+
+```ts
+type AllowedVoid = Ex.Mx.Tx<void>;
+type AllowedVoidUnion = void | Ex.Mx.Tx<void>;
+```
+
+#### `allowAsThisParameter`
+
+This option allows specifying a `this` parameter of a function to be `void` when set to `true`.
+This pattern can be useful to explicitly label function types that do not use a `this` argument. [See the TypeScript docs for more information](https://www.typescriptlang.org/docs/handbook/functions.html#this-parameters-in-callbacks).
+
+This option is `false` by default.
+
+The following patterns are considered warnings with `{ allowAsThisParameter: false }` but valid with `{ allowAsThisParameter: true }`:
+
+```ts
+function doThing(this: void) {}
+class Example {
+  static helper(this: void) {}
+  callback(this: void) {}
+}
+```
+
+## When Not To Use It
+
+If you don't care about if `void` is used with other types,
+or in invalid places, then you don't need this rule.
+
+## Compatibility
+
+- TSLint: [invalid-void](https://palantir.github.io/tslint/rules/invalid-void/)
+
+## Attributes
+
+- [ ] ✅ Recommended
+- [ ] 🔧 Fixable
+- [ ] 💭 Requires type information

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-loop-func.md

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

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-loss-of-precision.md

@@ -0,0 +1,25 @@
+# Disallow literal numbers that lose precision (`no-loss-of-precision`)
+
+## Rule Details
+
+This rule extends the base [`eslint/no-loss-of-precision`](https://eslint.org/docs/rules/no-loss-of-precision) rule.
+It adds support for [numeric separators](https://github.com/tc39/proposal-numeric-separator).
+Note that this rule requires ESLint v7.
+
+## How to use
+
+```jsonc
+{
+  // note you must disable the base rule as it can report incorrect errors
+  "no-loss-of-precision": "off",
+  "@typescript-eslint/no-loss-of-precision": ["error"]
+}
+```
+
+<sup>Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/master/docs/rules/no-loss-of-precision.md)</sup>
+
+## Attributes
+
+- [x] ✅ Recommended
+- [ ] 🔧 Fixable
+- [ ] 💭 Requires type information

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-magic-numbers.md

@@ -0,0 +1,125 @@
+# Disallow magic numbers (`no-magic-numbers`)
+
+## Rule Details
+
+This rule extends the base [`eslint/no-magic-numbers`](https://eslint.org/docs/rules/no-magic-numbers) rule.
+It adds support for:
+
+- numeric literal types (`type T = 1`),
+- `enum` members (`enum Foo { bar = 1 }`),
+- `readonly` class properties (`class Foo { readonly bar = 1 }`).
+
+## How to use
+
+```jsonc
+{
+  // note you must disable the base rule as it can report incorrect errors
+  "no-magic-numbers": "off",
+  "@typescript-eslint/no-magic-numbers": [
+    "error",
+    {
+      /* options */
+    }
+  ]
+}
+```
+
+## Options
+
+See [`eslint/no-magic-numbers` options](https://eslint.org/docs/rules/no-magic-numbers#options).
+This rule adds the following options:
+
+```ts
+interface Options extends BaseNoMagicNumbersOptions {
+  ignoreEnums?: boolean;
+  ignoreNumericLiteralTypes?: boolean;
+  ignoreReadonlyClassProperties?: boolean;
+}
+
+const defaultOptions: Options = {
+  ...baseNoMagicNumbersDefaultOptions,
+  ignoreEnums: false,
+  ignoreNumericLiteralTypes: false,
+  ignoreReadonlyClassProperties: false,
+};
+```
+
+### `ignoreEnums`
+
+A boolean to specify if enums used in TypeScript are considered okay. `false` by default.
+
+Examples of **incorrect** code for the `{ "ignoreEnums": false }` option:
+
+```ts
+/*eslint @typescript-eslint/no-magic-numbers: ["error", { "ignoreEnums": false }]*/
+
+enum foo {
+  SECOND = 1000,
+}
+```
+
+Examples of **correct** code for the `{ "ignoreEnums": true }` option:
+
+```ts
+/*eslint @typescript-eslint/no-magic-numbers: ["error", { "ignoreEnums": true }]*/
+
+enum foo {
+  SECOND = 1000,
+}
+```
+
+### `ignoreNumericLiteralTypes`
+
+A boolean to specify if numbers used in TypeScript numeric literal types are considered okay. `false` by default.
+
+Examples of **incorrect** code for the `{ "ignoreNumericLiteralTypes": false }` option:
+
+```ts
+/*eslint @typescript-eslint/no-magic-numbers: ["error", { "ignoreNumericLiteralTypes": false }]*/
+
+type SmallPrimes = 2 | 3 | 5 | 7 | 11;
+```
+
+Examples of **correct** code for the `{ "ignoreNumericLiteralTypes": true }` option:
+
+```ts
+/*eslint @typescript-eslint/no-magic-numbers: ["error", { "ignoreNumericLiteralTypes": true }]*/
+
+type SmallPrimes = 2 | 3 | 5 | 7 | 11;
+```
+
+### `ignoreReadonlyClassProperties`
+
+Examples of **incorrect** code for the `{ "ignoreReadonlyClassProperties": false }` option:
+
+```ts
+/*eslint @typescript-eslint/no-magic-numbers: ["error", { "ignoreReadonlyClassProperties": false }]*/
+
+class Foo {
+  readonly A = 1;
+  readonly B = 2;
+  public static readonly C = 1;
+  static readonly D = 1;
+}
+```
+
+Examples of **correct** code for the `{ "ignoreReadonlyClassProperties": true }` option:
+
+```ts
+/*eslint @typescript-eslint/no-magic-numbers: ["error", { "ignoreReadonlyClassProperties": true }]*/
+
+class Foo {
+  readonly A = 1;
+  readonly B = 2;
+  public static readonly C = 1;
+  static readonly D = 1;
+}
+```
+
+<sup>Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/master/docs/rules/no-magic-numbers.md)</sup>
+
+## Attributes
+
+- [ ] ✅ Recommended
+- [ ] 🔧 Fixable
+- [ ] 💭 Requires type information

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-meaningless-void-operator.md

@@ -0,0 +1,56 @@
+# Disallow the `void` operator except when used to discard a value (`no-meaningless-void-operator`)
+
+Disallow the `void` operator when its argument is already of type `void` or `undefined`.
+
+## Rule Details
+
+The `void` operator is a useful tool to convey the programmer's intent to discard a value. For example, it is recommended as one way of suppressing [`@typescript-eslint/no-floating-promises`](./no-floating-promises.md) instead of adding `.catch()` to a promise.
+
+This rule helps an author catch API changes where previously a value was being discarded at a call site, but the callee changed so it no longer returns a value. When combined with [no-unused-expressions](https://eslint.org/docs/rules/no-unused-expressions), it also helps _readers_ of the code by ensuring consistency: a statement that looks like `void foo();` is **always** discarding a return value, and a statement that looks like `foo();` is **never** discarding a return value.
+
+Examples of **incorrect** code for this rule:
+
+```ts
+void (() => {})();
+
+function foo() {}
+void foo();
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+(() => {})();
+
+function foo() {}
+foo(); // nothing to discard
+
+function bar(x: number) {
+  void x; // discarding a number
+  return 2;
+}
+void bar(); // discarding a number
+```
+
+### Options
+
+This rule accepts a single object option with the following default configuration:
+
+```json
+{
+  "@typescript-eslint/no-meaningless-void-operator": [
+    "error",
+    {
+      "checkNever": false
+    }
+  ]
+}
+```
+
+- `checkNever: true` will suggest removing `void` when the argument has type `never`.
+
+## Attributes
+
+- [ ] ✅ Recommended
+- [x] 🔧 Fixable
+- [x] 💭 Requires type information

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-misused-new.md

@@ -0,0 +1,47 @@
+# Enforce valid definition of `new` and `constructor` (`no-misused-new`)
+
+Warns on apparent attempts to define constructors for interfaces or `new` for classes.
+
+## Rule Details
+
+Examples of **incorrect** code for this rule.
+
+```ts
+class C {
+  new(): C;
+}
+
+interface I {
+  new (): I;
+  constructor(): void;
+}
+```
+
+Examples of **correct** code for this rule.
+
+```ts
+class C {
+  constructor() {}
+}
+interface I {
+  new (): C;
+}
+```
+
+## Options
+
+```json
+{
+  "@typescript-eslint/no-misused-new": "error"
+}
+```
+
+## Compatibility
+
+- TSLint: [no-misused-new](https://palantir.github.io/tslint/rules/no-misused-new/)
+
+## Attributes
+
+- [x] ✅ Recommended
+- [ ] 🔧 Fixable
+- [ ] 💭 Requires type information