repoburg 1.0.69 → 1.1.1

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,53 @@
+---
+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.