repoburg 1.3.98 → 1.3.100

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

@@ -1,61 +0,0 @@
----
-description: 'Disallow iterating over an array with a for-in loop.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/no-for-in-array** for documentation.
-
-A for-in loop (`for (const i in o)`) iterates over the properties of an Object.
-While it is legal to use for-in loops with array values, it is not common. There are several potential bugs with this:
-
-1. It iterates over all enumerable properties, including non-index ones and the entire prototype chain. For example, [`RegExp.prototype.exec`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec) returns an array with additional properties, and `for-in` will iterate over them. Some libraries or even your own code may add additional methods to `Array.prototype` (either as polyfill or as custom methods), and if not done properly, they may be iterated over as well.
-2. It skips holes in the array. While sparse arrays are rare and advised against, they are still possible and your code should be able to handle them.
-3. The "index" is returned as a string, not a number. This can be caught by TypeScript, but can still lead to subtle bugs.
-
-You may have confused for-in with for-of, which iterates over the elements of the array. If you actually need the index, use a regular `for` loop or the `forEach` method.
-
-## Examples
-
-<!--tabs-->
-
-### ❌ Incorrect
-
-```ts
-declare const array: string[];
-
-for (const i in array) {
-  console.log(array[i]);
-}
-
-for (const i in array) {
-  console.log(i, array[i]);
-}
-```
-
-### ✅ Correct
-
-```ts
-declare const array: string[];
-
-for (const value of array) {
-  console.log(value);
-}
-
-for (let i = 0; i < array.length; i += 1) {
-  console.log(i, array[i]);
-}
-
-array.forEach((value, i) => {
-  console.log(i, value);
-});
-
-for (const [i, value] of array.entries()) {
-  console.log(i, value);
-}
-```
-
-## When Not To Use It
-
-If your project is a rare one that intentionally loops over string indices of arrays, you can turn off this rule.
-You might consider using [ESLint disable comments](https://eslint.org/docs/latest/use/configure/rules#using-configuration-comments-1) for those specific situations instead of completely disabling this rule.

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

@@ -1,102 +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 your project is a rare one that needs to allow `new Function()` or `setTimeout()`, `setInterval()`, `setImmediate()` and `execScript()` with string arguments, then you can disable this rule.
-You might consider using [ESLint disable comments](https://eslint.org/docs/latest/use/configure/rules#using-configuration-comments-1) for those specific situations instead of completely disabling this rule.

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

@@ -1,74 +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're not using TypeScript 5.0's `verbatimModuleSyntax` option and your project is built with a bundler that manages import side effects for you, this rule may not be as useful for you.
-
-## 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/backend/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 option='{ "ignoreParameters": true }' showPlaygroundButton
-function foo(a: number = 5, b: boolean = true) {
-  // ...
-}
-```
-
-### `ignoreProperties`
-
-When set to true, the following pattern is considered valid:
-
-```ts option='{ "ignoreProperties": true }' showPlaygroundButton
-class Foo {
-  prop: number = 5;
-}
-```
-
-## When Not To Use It
-
-If you strongly prefer to have explicit types regardless of whether they can be inferred, this rule may not be for you.
-
-## Further Reading
-
-- [TpeScript Inference](https://www.typescriptlang.org/docs/handbook/type-inference.html)

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

@@ -1,14 +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.
-
-import TypeScriptOverlap from "@site/src/components/TypeScriptOverlap";
-
-<TypeScriptOverlap strict />
-
-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/backend/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-invalid-void-type.md

@@ -1,112 +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 option='{ "allowInGenericTypeArguments": false }' showPlaygroundButton
-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 option='{ "allowInGenericTypeArguments": ["Ex.Mx.Tx"] }' showPlaygroundButton
-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 option='{ "allowInGenericTypeArguments": ["Ex.Mx.Tx"] }' showPlaygroundButton
-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 option='{ "allowAsThisParameter": false }' showPlaygroundButton
-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/backend/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-loop-func.md

@@ -1,10 +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.
-
-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/backend/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-loss-of-precision.md

@@ -1,10 +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.
-
-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/backend/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-magic-numbers.md

@@ -1,119 +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.
-
-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 option='{ "ignoreEnums": false }' showPlaygroundButton
-enum foo {
-  SECOND = 1000,
-}
-```
-
-Examples of **correct** code for the `{ "ignoreEnums": true }` option:
-
-```ts option='{ "ignoreEnums": true }' showPlaygroundButton
-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 option='{ "ignoreNumericLiteralTypes": false }' showPlaygroundButton
-type SmallPrimes = 2 | 3 | 5 | 7 | 11;
-```
-
-Examples of **correct** code for the `{ "ignoreNumericLiteralTypes": true }` option:
-
-```ts option='{ "ignoreNumericLiteralTypes": true }' showPlaygroundButton
-type SmallPrimes = 2 | 3 | 5 | 7 | 11;
-```
-
-### `ignoreReadonlyClassProperties`
-
-Examples of **incorrect** code for the `{ "ignoreReadonlyClassProperties": false }` option:
-
-```ts option='{ "ignoreReadonlyClassProperties": false }' showPlaygroundButton
-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 option='{ "ignoreReadonlyClassProperties": true }' showPlaygroundButton
-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 option='{ "ignoreTypeIndexes": false }' showPlaygroundButton
-type Foo = Bar[0];
-type Baz = Parameters<Foo>[2];
-```
-
-Examples of **correct** code for the `{ "ignoreTypeIndexes": true }` option:
-
-```ts option='{ "ignoreTypeIndexes": true }' showPlaygroundButton
-type Foo = Bar[0];
-type Baz = Parameters<Foo>[2];
-```
-
-## When Not To Use It
-
-If your project frequently deals with constant numbers and you don't wish to take up extra space to declare them, this rule might not be for you.
-We recommend at least using descriptive comments and/or names to describe constants.
-You might consider using [ESLint disable comments](https://eslint.org/docs/latest/use/configure/rules#using-configuration-comments-1) instead of completely disabling this rule.

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

@@ -1,53 +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`
-
-`checkNever: true` will suggest removing `void` when the argument has type `never`.
-
-## When Not To Use It
-
-If you don't mind extra `void`s in your project, you can avoid this rule.