xo 0.54.2 → 0.55.1

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

@@ -1,73 +0,0 @@
----
-description: 'Disallow usage of the implicit `any` type in catch clauses.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/no-implicit-any-catch** for documentation.
-
-:::danger Deprecated
-
-This rule has been deprecated as TypeScript versions >=4 includes a `useUnknownInCatchVariables` compiler option with the same check.
-:::
-
-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, however you can use `useUnknownInCatchVariables` (part of `strict`) instead of this rule.
-
-## DEPRECATED
-
-## Examples
-
-This rule requires an explicit type to be declared on a catch clause variable.
-
-<!--tabs-->
-
-### ❌ Incorrect
-
-```ts
-try {
-  // ...
-} catch (e) {
-  // ...
-}
-```
-
-### ✅ Correct
-
-<!-- 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
-
-### `allowExplicitAny`
-
-The follow is is **_not_** considered a warning with `{ allowExplicitAny: true }`
-
-```ts
-try {
-  // ...
-} catch (e: any) {
-  // ...
-}
-```
-
-## 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 Release Notes](https://devblogs.microsoft.com/typescript/announcing-typescript-4-0/#unknown-on-catch)

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

@@ -1,101 +0,0 @@
----
-description: 'Disallow the use of `eval()`-like methods.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/no-implied-eval** for documentation.
-
-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()`.
-
-## Examples
-
-This rule aims to eliminate implied `eval()` through the use of `new Function()`, `setTimeout()`, `setInterval()`, `setImmediate()` or `execScript()`.
-
-<!--tabs-->
-
-### ❌ Incorrect
-
-```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');
-```
-
-### ✅ Correct
-
-```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);
-```
-
-## 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.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-import-type-side-effects.md

@@ -1,75 +0,0 @@
----
-description: 'Enforce the use of top-level import type qualifier when an import only has specifiers with inline type qualifiers.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/no-import-type-side-effects** for documentation.
-
-The [`--verbatimModuleSyntax`](https://www.typescriptlang.org/tsconfig#verbatimModuleSyntax) compiler option causes TypeScript to do simple and predictable transpilation on import declarations.
-Namely, it completely removes import declarations with a top-level `type` qualifier, and it removes any import specifiers with an inline `type` qualifier.
-
-The latter behavior does have one potentially surprising effect in that in certain cases TS can leave behind a "side effect" import at runtime:
-
-```ts
-import { type A, type B } from 'mod';
-
-// is transpiled to
-
-import {} from 'mod';
-// which is the same as
-import 'mod';
-```
-
-For the rare case of needing to import for side effects, this may be desirable - but for most cases you will not want to leave behind an unnecessary side effect import.
-
-## Examples
-
-This rule enforces that you use a top-level `type` qualifier for imports when it only imports specifiers with an inline `type` qualifier
-
-<!--tabs-->
-
-### ❌ Incorrect
-
-```ts
-import { type A } from 'mod';
-import { type A as AA } from 'mod';
-import { type A, type B } from 'mod';
-import { type A as AA, type B as BB } from 'mod';
-```
-
-### ✅ Correct
-
-```ts
-import type { A } from 'mod';
-import type { A as AA } from 'mod';
-import type { A, B } from 'mod';
-import type { A as AA, B as BB } from 'mod';
-
-import T from 'mod';
-import type T from 'mod';
-
-import * as T from 'mod';
-import type * as T from 'mod';
-
-import { T } from 'mod';
-import type { T } from 'mod';
-import { T, U } from 'mod';
-import type { T, U } from 'mod';
-import { type T, U } from 'mod';
-import { T, type U } from 'mod';
-
-import type T, { U } from 'mod';
-import T, { type U } from 'mod';
-```
-
-## When Not To Use It
-
-- If you want to leave behind side effect imports, then you shouldn't use this rule.
-- If you're not using TypeScript 5.0's `verbatimModuleSyntax` option, then you don't need this rule.
-
-## Related To
-
-- [`consistent-type-imports`](./consistent-type-imports.md)
-- [`import/consistent-type-specifier-style`](https://github.com/import-js/eslint-plugin-import/blob/main/docs/rules/consistent-type-specifier-style.md)
-- [`import/no-duplicates` with `{"prefer-inline": true}`](https://github.com/import-js/eslint-plugin-import/blob/main/docs/rules/no-duplicates.md#inline-type-imports)

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

@@ -1,103 +0,0 @@
----
-description: 'Disallow explicit type declarations for variables or parameters initialized to a number, string, or boolean.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/no-inferrable-types** for documentation.
-
-TypeScript is able to infer the types of parameters, properties, and variables from their default or initial values.
-There is no need to use an explicit `:` type annotation on one of those constructs initialized to a boolean, number, or string.
-Doing so adds unnecessary verbosity to code -making it harder to read- and in some cases can prevent TypeScript from inferring a more specific literal type (e.g. `10`) instead of the more general primitive type (e.g. `number`)
-
-## Examples
-
-<!--tabs-->
-
-### ❌ Incorrect
-
-```ts
-const a: bigint = 10n;
-const a: bigint = BigInt(10);
-const a: boolean = !0;
-const a: boolean = Boolean(null);
-const a: boolean = true;
-const a: null = null;
-const a: number = 10;
-const a: number = Infinity;
-const a: number = NaN;
-const a: number = Number('1');
-const a: RegExp = /a/;
-const a: RegExp = new RegExp('a');
-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) {}
-```
-
-### ✅ Correct
-
-```ts
-const a = 10n;
-const a = BigInt(10);
-const a = !0;
-const a = Boolean(null);
-const a = true;
-const a = null;
-const a = 10;
-const a = Infinity;
-const a = NaN;
-const a = Number('1');
-const a = /a/;
-const a = new RegExp('a');
-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) {}
-```
-
-<!--/tabs-->
-
-## Options
-
-### `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)

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

@@ -1,12 +0,0 @@
----
-description: 'Disallow `this` keywords outside of classes or class-like objects.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/no-invalid-this** for documentation.
-
-## Examples
-
-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.

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

@@ -1,113 +0,0 @@
----
-description: 'Disallow `void` type outside of generic or return types.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/no-invalid-void-type** for documentation.
-
-`void` in TypeScript refers to a function return that is meant to be ignored.
-Attempting to use a `void` type outside of a return type or generic type argument is often a sign of programmer error.
-`void` can also be misleading for other developers even if used correctly.
-
-> The `void` type means cannot be mixed with any other types, other than `never`, which accepts all types.
-> If you think you need this then you probably want the `undefined` type instead.
-
-## Examples
-
-<!--tabs-->
-
-### ❌ Incorrect
-
-```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;
-}
-```
-
-### ✅ Correct
-
-```ts
-type NoOp = () => void;
-
-function noop(): void {}
-
-let trulyUndefined = void 0;
-
-async function promiseMeSomething(): Promise<void> {}
-
-type stillVoid = void | never;
-```
-
-## Options
-
-### `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.

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

@@ -1,12 +0,0 @@
----
-description: 'Disallow function declarations that contain unsafe references inside loop statements.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/no-loop-func** for documentation.
-
-## Examples
-
-This rule extends the base [`eslint/no-loop-func`](https://eslint.org/docs/rules/no-loop-func) rule.
-It adds support for TypeScript types.

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

@@ -1,12 +0,0 @@
----
-description: 'Disallow literal numbers that lose precision.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/no-loss-of-precision** for documentation.
-
-## Examples
-
-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).

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

@@ -1,131 +0,0 @@
----
-description: 'Disallow magic numbers.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/no-magic-numbers** for documentation.
-
-## Examples
-
-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 }`).
-
-## Options
-
-This rule adds the following options:
-
-```ts
-interface Options extends BaseNoMagicNumbersOptions {
-  ignoreEnums?: boolean;
-  ignoreNumericLiteralTypes?: boolean;
-  ignoreReadonlyClassProperties?: boolean;
-  ignoreTypeIndexes?: boolean;
-}
-
-const defaultOptions: Options = {
-  ...baseNoMagicNumbersDefaultOptions,
-  ignoreEnums: false,
-  ignoreNumericLiteralTypes: false,
-  ignoreReadonlyClassProperties: false,
-  ignoreTypeIndexes: 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;
-}
-```
-
-### `ignoreTypeIndexes`
-
-A boolean to specify if numbers used to index types are okay. `false` by default.
-
-Examples of **incorrect** code for the `{ "ignoreTypeIndexes": false }` option:
-
-```ts
-/*eslint @typescript-eslint/no-magic-numbers: ["error", { "ignoreTypeIndexes": false }]*/
-
-type Foo = Bar[0];
-type Baz = Parameters<Foo>[2];
-```
-
-Examples of **correct** code for the `{ "ignoreTypeIndexes": true }` option:
-
-```ts
-/*eslint @typescript-eslint/no-magic-numbers: ["error", { "ignoreTypeIndexes": true }]*/
-
-type Foo = Bar[0];
-type Baz = Parameters<Foo>[2];
-```

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

@@ -1,47 +0,0 @@
----
-description: 'Disallow the `void` operator except when used to discard a value.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/no-meaningless-void-operator** for documentation.
-
-`void` in TypeScript refers to a function return that is meant to be ignored.
-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 authors 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.
-This rule reports on any `void` operator whose argument is already of type `void` or `undefined`.
-
-## Examples
-
-<!--tabs-->
-
-### ❌ Incorrect
-
-```ts
-void (() => {})();
-
-function foo() {}
-void foo();
-```
-
-### ✅ Correct
-
-```ts
-(() => {})();
-
-function foo() {}
-foo(); // nothing to discard
-
-function bar(x: number) {
-  void x; // discarding a number
-  return 2;
-}
-void bar(); // discarding a number
-```
-
-## Options
-
-`checkNever: true` will suggest removing `void` when the argument has type `never`.