repoburg 1.0.31 → 1.0.33

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

@@ -1,75 +0,0 @@
----
-description: 'Disallow variable redeclaration.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/no-redeclare** for documentation.
-
-import TypeScriptOverlap from "@site/src/components/TypeScriptOverlap";
-
-<TypeScriptOverlap />
-
-This rule extends the base [`eslint/no-redeclare`](https://eslint.org/docs/rules/no-redeclare) rule.
-It adds support for TypeScript function overloads, and declaration merging.
-
-## Options
-
-This rule adds the following options:
-
-```ts
-interface Options extends BaseNoRedeclareOptions {
-  ignoreDeclarationMerge?: boolean;
-}
-
-const defaultOptions: Options = {
-  ...baseNoRedeclareDefaultOptions,
-  ignoreDeclarationMerge: true,
-};
-```
-
-### `ignoreDeclarationMerge`
-
-When set to `true`, the rule will ignore declaration merges between the following sets:
-
-- interface + interface
-- namespace + namespace
-- class + interface
-- class + namespace
-- class + interface + namespace
-- function + namespace
-- enum + namespace
-
-Examples of **correct** code with `{ ignoreDeclarationMerge: true }`:
-
-```ts option='{ "ignoreDeclarationMerge": true }' showPlaygroundButton
-interface A {
-  prop1: 1;
-}
-interface A {
-  prop2: 2;
-}
-
-namespace Foo {
-  export const a = 1;
-}
-namespace Foo {
-  export const b = 2;
-}
-
-class Bar {}
-namespace Bar {}
-
-function Baz() {}
-namespace Baz {}
-```
-
-**Note:** Even with this option set to true, this rule will report if you name a type and a variable the same name. **_This is intentional_**.
-Declaring a variable and a type and a variable the same is usually an accident, and it can lead to hard-to-understand code.
-If you have a rare case where you're intentionally naming a type the same name as a variable, use a disable comment. For example:
-
-```ts option='{ "ignoreDeclarationMerge": true }' showPlaygroundButton
-type something = string;
-// eslint-disable-next-line @typescript-eslint/no-redeclare -- intentionally naming the variable the same as the type
-const something = 2;
-```

package/backend/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-redundant-type-constituents.md

@@ -1,92 +0,0 @@
----
-description: 'Disallow members of unions and intersections that do nothing or override type information.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/no-redundant-type-constituents** for documentation.
-
-Some types can override some other types ("constituents") in a union or intersection and/or be overridden by some other types.
-TypeScript's set theory of types includes cases where a constituent type might be useless in the parent union or intersection.
-
-Within `|` unions:
-
-- `any` and `unknown` "override" all other union members
-- `never` is dropped from unions in any position except when in a return type position
-- primitive types such as `string` "override" any of their literal types such as `""`
-
-Within `&` intersections:
-
-- `any` and `never` "override" all other intersection members
-- `unknown` is dropped from intersections
-- literal types "override" any primitive types in an intersection
-- literal types such as `""` "override" any of their primitive types such as `string`
-
-## Examples
-
-<!--tabs-->
-
-### ❌ Incorrect
-
-```ts
-type UnionAny = any | 'foo';
-type UnionUnknown = unknown | 'foo';
-type UnionNever = never | 'foo';
-
-type UnionBooleanLiteral = boolean | false;
-type UnionNumberLiteral = number | 1;
-type UnionStringLiteral = string | 'foo';
-
-type IntersectionAny = any & 'foo';
-type IntersectionUnknown = string & unknown;
-type IntersectionNever = string | never;
-
-type IntersectionBooleanLiteral = boolean & false;
-type IntersectionNumberLiteral = number & 1;
-type IntersectionStringLiteral = string & 'foo';
-```
-
-### ✅ Correct
-
-```ts
-type UnionAny = any;
-type UnionUnknown = unknown;
-type UnionNever = never;
-
-type UnionBooleanLiteral = boolean;
-type UnionNumberLiteral = number;
-type UnionStringLiteral = string;
-
-type IntersectionAny = any;
-type IntersectionUnknown = string;
-type IntersectionNever = string;
-
-type IntersectionBooleanLiteral = false;
-type IntersectionNumberLiteral = 1;
-type IntersectionStringLiteral = 'foo';
-```
-
-## Limitations
-
-This rule plays it safe and only works with bottom types, top types, and comparing literal types to primitive types.
-
-## When Not To Use It
-
-Some projects choose to occasionally intentionally include a redundant type constituent for documentation purposes.
-For example, the following code includes `string` in a union even though the `unknown` makes it redundant:
-
-```ts
-/**
- * Normally a string name, but sometimes arbitrary unknown data.
- */
-type NameOrOther = string | unknown;
-```
-
-If you strongly feel a preference for these unnecessary type constituents, this rule might not be for you.
-
-## Further Reading
-
-- [Union Types](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#union-types)
-- [Intersection Types](https://www.typescriptlang.org/docs/handbook/2/objects.html#intersection-types)
-- [Bottom Types](https://en.wikipedia.org/wiki/Bottom_type)
-- [Top Types](https://en.wikipedia.org/wiki/Top_type)

package/backend/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-require-imports.md

@@ -1,60 +0,0 @@
----
-description: 'Disallow invocation of `require()`.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/no-require-imports** for documentation.
-
-Prefer the newer ES6-style imports over `require()`.
-
-## Examples
-
-<!--tabs-->
-
-### ❌ Incorrect
-
-```ts
-const lib1 = require('lib1');
-const { lib2 } = require('lib2');
-import lib3 = require('lib3');
-```
-
-### ✅ Correct
-
-```ts
-import * as lib1 from 'lib1';
-import { lib2 } from 'lib2';
-import * as lib3 from 'lib3';
-```
-
-## Options
-
-### `allow`
-
-A array of strings. These strings will be compiled into regular expressions with the `u` flag and be used to test against the imported path. A common use case is to allow importing `package.json`. This is because `package.json` commonly lives outside of the TS root directory, so statically importing it would lead to root directory conflicts, especially with `resolveJsonModule` enabled. You can also use it to allow importing any JSON if your environment doesn't support JSON modules, or use it for other cases where `import` statements cannot work.
-
-With `{allow: ['/package\\.json$']}`:
-
-<!--tabs-->
-
-### ❌ Incorrect
-
-```ts
-console.log(require('../data.json').version);
-```
-
-### ✅ Correct
-
-```ts
-console.log(require('../package.json').version);
-```
-
-## When Not To Use It
-
-If your project frequently uses older CommonJS `require`s, then this rule might not be applicable to you.
-If only a subset of your project uses `require`s then 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.
-
-## Related To
-
-- [`no-var-requires`](./no-var-requires.md)

package/backend/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-restricted-imports.md

@@ -1,71 +0,0 @@
----
-description: 'Disallow specified modules when loaded by `import`.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/no-restricted-imports** for documentation.
-
-This rule extends the base [`eslint/no-restricted-imports`](https://eslint.org/docs/rules/no-restricted-imports) rule. It adds support for the type import (`import type X from "..."`, `import { type X } from "..."`) and `import x = require("...")` syntaxes.
-
-## Options
-
-This rule adds the following options:
-
-### `allowTypeImports`
-
-(default: `false`)
-
-You can specify this option for a specific path or pattern as follows:
-
-```jsonc
-{
-  "rules": {
-    "@typescript-eslint/no-restricted-imports": [
-      "error",
-      {
-        "paths": [
-          {
-            "name": "import-foo",
-            "message": "Please use import-bar instead.",
-            "allowTypeImports": true,
-          },
-          {
-            "name": "import-baz",
-            "message": "Please use import-quux instead.",
-            "allowTypeImports": true,
-          },
-        ],
-      },
-    ],
-  },
-}
-```
-
-When set to `true`, the rule will allow [Type-Only Imports](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-8.html#type-only-imports-and-export).
-
-Examples of code with the above config:
-
-<!--tabs-->
-
-#### ❌ Incorrect
-
-```ts option='{"paths":[{"name":"import-foo","message":"Please use import-bar instead.","allowTypeImports":true},{"name":"import-baz","message":"Please use import-quux instead.","allowTypeImports":true}]}'
-import foo from 'import-foo';
-export { Foo } from 'import-foo';
-
-import baz from 'import-baz';
-export { Baz } from 'import-baz';
-```
-
-#### ✅ Correct
-
-```ts option='{"paths":[{"name":"import-foo","message":"Please use import-bar instead.","allowTypeImports":true},{"name":"import-baz","message":"Please use import-quux instead.","allowTypeImports":true}]}'
-import { foo } from 'other-module';
-
-import type foo from 'import-foo';
-export type { Foo } from 'import-foo';
-
-import type baz from 'import-baz';
-export type { Baz } from 'import-baz';
-```

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

@@ -1,105 +0,0 @@
----
-description: 'Disallow variable declarations from shadowing variables declared in the outer scope.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/no-shadow** for documentation.
-
-This rule extends the base [`eslint/no-shadow`](https://eslint.org/docs/rules/no-shadow) rule.
-It adds support for TypeScript's `this` parameters and global augmentation, and adds options for TypeScript features.
-
-## Options
-
-This rule adds the following options:
-
-```ts
-interface Options extends BaseNoShadowOptions {
-  ignoreTypeValueShadow?: boolean;
-  ignoreFunctionTypeParameterNameValueShadow?: boolean;
-}
-
-const defaultOptions: Options = {
-  ...baseNoShadowDefaultOptions,
-  ignoreTypeValueShadow: true,
-  ignoreFunctionTypeParameterNameValueShadow: true,
-};
-```
-
-### `ignoreTypeValueShadow`
-
-When set to `true`, the rule will ignore the case when you name a type the same as a variable. This is generally safe because you cannot use variables in type locations without a `typeof` operator, so there's little risk of confusion.
-
-Examples of **correct** code with `{ ignoreTypeValueShadow: true }`:
-
-```ts option='{ "ignoreTypeValueShadow": true }' showPlaygroundButton
-type Foo = number;
-interface Bar {
-  prop: number;
-}
-
-function f() {
-  const Foo = 1;
-  const Bar = 'test';
-}
-```
-
-:::note
-
-_Shadowing_ specifically refers to two identical identifiers that are in different, nested scopes. This is different from _redeclaration_, which is when two identical identifiers are in the same scope. Redeclaration is covered by the [`no-redeclare`](./no-redeclare.md) rule instead.
-
-:::
-
-### `ignoreFunctionTypeParameterNameValueShadow`
-
-When set to `true`, the rule will ignore the case when you name a parameter in a function type the same as a variable.
-
-Each of a function type's arguments creates a value variable within the scope of the function type. This is done so that you can reference the type later using the `typeof` operator:
-
-```ts
-type Func = (test: string) => typeof test;
-
-declare const fn: Func;
-const result = fn('str'); // typeof result === string
-```
-
-This means that function type arguments shadow value variable names in parent scopes:
-
-```ts
-let test = 1;
-type TestType = typeof test; // === number
-type Func = (test: string) => typeof test; // this "test" references the argument, not the variable
-
-declare const fn: Func;
-const result = fn('str'); // typeof result === string
-```
-
-If you do not use the `typeof` operator in a function type return type position, you can safely turn this option on.
-
-Examples of **correct** code with `{ ignoreFunctionTypeParameterNameValueShadow: true }`:
-
-```ts option='{ "ignoreFunctionTypeParameterNameValueShadow": true }' showPlaygroundButton
-const test = 1;
-type Func = (test: string) => typeof test;
-```
-
-## FAQ
-
-### Why does the rule report on enum members that share the same name as a variable in a parent scope?
-
-Reporting on this case isn't a bug - it is completely intentional and correct reporting! The rule reports due to a relatively unknown feature of enums - enum members create a variable within the enum scope so that they can be referenced within the enum without a qualifier.
-
-To illustrate this with an example:
-
-```ts
-const A = 2;
-enum Test {
-  A = 1,
-  B = A,
-}
-
-console.log(Test.B);
-// what should be logged?
-```
-
-Naively looking at the above code, it might look like the log should output `2`, because the outer variable `A`'s value is `2` - however, the code instead outputs `1`, which is the value of `Test.A`. This is because the unqualified code `B = A` is equivalent to the fully-qualified code `B = Test.A`. Due to this behavior, the enum member has **shadowed** the outer variable declaration.

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

@@ -1,108 +0,0 @@
----
-description: 'Disallow aliasing `this`.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/no-this-alias** for documentation.
-
-Assigning a variable to `this` instead of properly using arrow lambdas may be a symptom of pre-ES6 practices
-or not managing scope well.
-
-## Examples
-
-<!--tabs-->
-
-### ❌ Incorrect
-
-```ts
-const self = this;
-
-setTimeout(function () {
-  self.doWork();
-});
-```
-
-### ✅ Correct
-
-```ts
-setTimeout(() => {
-  this.doWork();
-});
-```
-
-## Options
-
-### `allowDestructuring`
-
-It can sometimes be useful to destructure properties from a class instance, such as retrieving multiple properties from the instance in one of its methods.
-`allowDestructuring` allows those destructures and is `true` by default.
-You can explicitly disallow them by setting `allowDestructuring` to `false`.
-
-Examples of code for the `{ "allowDestructuring": false }` option:
-
-<!--tabs-->
-
-#### ❌ Incorrect
-
-```ts option='{ "allowDestructuring": false }'
-class ComponentLike {
-  props: unknown;
-  state: unknown;
-
-  render() {
-    const { props, state } = this;
-
-    console.log(props);
-    console.log(state);
-  }
-}
-```
-
-#### ✅ Correct
-
-```ts option='{ "allowDestructuring": false }'
-class ComponentLike {
-  props: unknown;
-  state: unknown;
-
-  render() {
-    console.log(this.props);
-    console.log(this.state);
-  }
-}
-```
-
-### `allowedNames`
-
-`no-this-alias` can alternately be used to allow only a specific list of names as `this` aliases.
-We recommend against this except as a transitory step towards fixing all rule violations.
-
-Examples of code for the `{ "allowedNames": ["self"] }` option:
-
-<!--tabs-->
-
-#### ❌ Incorrect
-
-```ts option='{ "allowedNames": ["self"] }'
-class Example {
-  method() {
-    const that = this;
-  }
-}
-```
-
-#### ✅ Correct
-
-```ts option='{ "allowedNames": ["self"] }'
-class Example {
-  method() {
-    const self = this;
-  }
-}
-```
-
-## When Not To Use It
-
-If your project is structured in a way that it needs to assign `this` to variables, this rule is likely not for you.
-If only a subset of your project assigns `this` to variables then 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-throw-literal.md

@@ -1,109 +0,0 @@
----
-description: 'Disallow throwing literals as exceptions.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/no-throw-literal** for documentation.
-
-It is considered good practice to only `throw` the `Error` object itself or an object using the `Error` object as base objects for user-defined exceptions.
-The fundamental benefit of `Error` objects is that they automatically keep track of where they were built and originated.
-
-This rule restricts what can be thrown as an exception. When it was first created, it only prevented literals from being thrown (hence the name), but it has now been expanded to only allow expressions which have a possibility of being an `Error` object. With the `allowThrowingAny` and `allowThrowingUnknown`, it can be configured to only allow throwing values which are guaranteed to be an instance of `Error`.
-
-## Examples
-
-This rule is aimed at maintaining consistency when throwing exception by disallowing to throw literals and other expressions which cannot possibly be an `Error` object.
-
-<!--tabs-->
-
-### ❌ Incorrect
-
-```ts
-throw 'error';
-
-throw 0;
-
-throw undefined;
-
-throw null;
-
-const err = new Error();
-throw 'an ' + err;
-
-const err = new Error();
-throw `${err}`;
-
-const err = '';
-throw err;
-
-function err() {
-  return '';
-}
-throw err();
-
-const foo = {
-  bar: '',
-};
-throw foo.bar;
-```
-
-### ✅ Correct
-
-```ts
-throw new Error();
-
-throw new Error('error');
-
-const e = new Error('error');
-throw e;
-
-try {
-  throw new Error('error');
-} catch (e) {
-  throw e;
-}
-
-const err = new Error();
-throw err;
-
-function err() {
-  return new Error();
-}
-throw err();
-
-const foo = {
-  bar: new Error(),
-};
-throw foo.bar;
-
-class CustomError extends Error {
-  // ...
-}
-throw new CustomError();
-```
-
-## Options
-
-This rule adds the following options:
-
-```ts
-interface Options {
-  /**
-   * Whether to always allow throwing values typed as `any`.
-   */
-  allowThrowingAny?: boolean;
-
-  /**
-   * Whether to always allow throwing values typed as `unknown`.
-   */
-  allowThrowingUnknown?: boolean;
-}
-
-const defaultOptions: Options = {
-  allowThrowingAny: false,
-  allowThrowingUnknown: false,
-};
-```
-
-<!-- Intentionally omitted: When Not To Use It -->