xo 0.46.1 → 0.46.2

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

@@ -1,111 +0,0 @@
-# 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

@@ -1,152 +0,0 @@
-# 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

@@ -1,32 +0,0 @@
-# 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

@@ -1,132 +0,0 @@
-# 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

@@ -1,28 +0,0 @@
-# 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

@@ -1,25 +0,0 @@
-# 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

@@ -1,125 +0,0 @@
-# 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

@@ -1,56 +0,0 @@
-# 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

@@ -1,47 +0,0 @@
-# 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