repoburg 1.1.0 → 1.1.1

package/backend/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-for-of.md

@@ -0,0 +1,44 @@
+---
+description: 'Enforce the use of `for-of` loop over the standard `for` loop where possible.'
+---
+
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/prefer-for-of** for documentation.
+
+Many developers default to writing `for (let i = 0; i < ...` loops to iterate over arrays.
+However, in many of those arrays, the loop iterator variable (e.g. `i`) is only used to access the respective element of the array.
+In those cases, a `for-of` loop is easier to read and write.
+
+This rule recommends a for-of loop when the loop index is only used to read from an array that is being iterated.
+
+## Examples
+
+<!--tabs-->
+
+### ❌ Incorrect
+
+```ts
+declare const array: string[];
+
+for (let i = 0; i < array.length; i++) {
+  console.log(array[i]);
+}
+```
+
+### ✅ Correct
+
+```ts
+declare const array: string[];
+
+for (const x of array) {
+  console.log(x);
+}
+
+for (let i = 0; i < array.length; i++) {
+  // i is used, so for-of could not be used.
+  console.log(i, array[i]);
+}
+```
+
+<!-- Intentionally Omitted: When Not To Use It -->

package/backend/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-function-type.md

@@ -0,0 +1,92 @@
+---
+description: 'Enforce using function types instead of interfaces with call signatures.'
+---
+
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/prefer-function-type** for documentation.
+
+TypeScript allows for two common ways to declare a type for a function:
+
+- Function type: `() => string`
+- Object type with a signature: `{ (): string }`
+
+The function type form is generally preferred when possible for being more succinct.
+
+This rule suggests using a function type instead of an interface or object type literal with a single call signature.
+
+## Examples
+
+<!--tabs-->
+
+### ❌ Incorrect
+
+```ts
+interface Example {
+  (): string;
+}
+```
+
+```ts
+function foo(example: { (): number }): number {
+  return example();
+}
+```
+
+```ts
+interface ReturnsSelf {
+  // returns the function itself, not the `this` argument.
+  (arg: string): this;
+}
+```
+
+### ✅ Correct
+
+```ts
+type Example = () => string;
+```
+
+```ts
+function foo(example: () => number): number {
+  return bar();
+}
+```
+
+```ts
+// returns the function itself, not the `this` argument.
+type ReturnsSelf = (arg: string) => ReturnsSelf;
+```
+
+```ts
+function foo(bar: { (): string; baz: number }): string {
+  return bar();
+}
+```
+
+```ts
+interface Foo {
+  bar: string;
+}
+interface Bar extends Foo {
+  (): void;
+}
+```
+
+```ts
+// multiple call signatures (overloads) is allowed:
+interface Overloaded {
+  (data: string): number;
+  (id: number): string;
+}
+// this is equivelent to Overloaded interface.
+type Intersection = ((data: string) => number) & ((id: number) => string);
+```
+
+## When Not To Use It
+
+If you specifically want to use an interface or type literal with a single call signature for stylistic reasons, you can avoid this rule.
+
+This rule has a known edge case of sometimes triggering on global augmentations such as `interface Function`.
+These edge cases are rare and often symptomatic of odd code.
+We recommend you use an [inline ESLint disable comment](https://eslint.org/docs/latest/use/configure/rules#using-configuration-comments-1).
+See [#454](https://github.com/typescript-eslint/typescript-eslint/issues/454) for details.

package/backend/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-includes.md

@@ -0,0 +1,75 @@
+---
+description: 'Enforce `includes` method over `indexOf` method.'
+---
+
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/prefer-includes** for documentation.
+
+Prior to ES2015, `Array#indexOf` and `String#indexOf` comparisons against `-1` were the standard ways to check whether a value exists in an array or string, respectively.
+Alternatives that are easier to read and write now exist: ES2015 added `String#includes` and ES2016 added `Array#includes`.
+
+This rule reports when an `.indexOf` call can be replaced with an `.includes`.
+Additionally, this rule reports the tests of simple regular expressions in favor of `String#includes`.
+
+> This rule will report on any receiver object of an `indexOf` method call that has an `includes` method where the two methods have the same parameters.
+> Matching types include: `String`, `Array`, `ReadonlyArray`, and typed arrays.
+
+## Examples
+
+<!--tabs-->
+
+### ❌ Incorrect
+
+```ts
+const str: string;
+const array: any[];
+const readonlyArray: ReadonlyArray<any>;
+const typedArray: UInt8Array;
+const maybe: string;
+const userDefined: {
+  indexOf(x: any): number;
+  includes(x: any): boolean;
+};
+
+str.indexOf(value) !== -1;
+array.indexOf(value) !== -1;
+readonlyArray.indexOf(value) === -1;
+typedArray.indexOf(value) > -1;
+maybe?.indexOf('') !== -1;
+userDefined.indexOf(value) >= 0;
+
+/example/.test(str);
+```
+
+### ✅ Correct
+
+```ts
+const str: string;
+const array: any[];
+const readonlyArray: ReadonlyArray<any>;
+const typedArray: UInt8Array;
+const maybe: string;
+const userDefined: {
+  indexOf(x: any): number;
+  includes(x: any): boolean;
+};
+
+str.includes(value);
+array.includes(value);
+!readonlyArray.includes(value);
+typedArray.includes(value);
+maybe?.includes('');
+userDefined.includes(value);
+
+str.includes('example');
+
+// The two methods have different parameters.
+declare const mismatchExample: {
+  indexOf(x: unknown, fromIndex?: number): number;
+  includes(x: unknown): boolean;
+};
+mismatchExample.indexOf(value) >= 0;
+```
+
+<!-- Intentionally Omitted: When Not To Use It -->

package/backend/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-literal-enum-member.md

@@ -0,0 +1,103 @@
+---
+description: 'Require all enum members to be literal values.'
+---
+
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/prefer-literal-enum-member** for documentation.
+
+TypeScript allows the value of an enum member to be many different kinds of valid JavaScript expressions.
+However, because enums create their own scope whereby each enum member becomes a variable in that scope, developers are often surprised at the resultant values.
+For example:
+
+```ts
+const imOutside = 2;
+const b = 2;
+enum Foo {
+  outer = imOutside,
+  a = 1,
+  b = a,
+  c = b,
+  // does c == Foo.b == Foo.c == 1?
+  // or does c == b == 2?
+}
+```
+
+> The answer is that `Foo.c` will be `1` at runtime [[TypeScript playground](https://www.typescriptlang.org/play/#src=const%20imOutside%20%3D%202%3B%0D%0Aconst%20b%20%3D%202%3B%0D%0Aenum%20Foo%20%7B%0D%0A%20%20%20%20outer%20%3D%20imOutside%2C%0D%0A%20%20%20%20a%20%3D%201%2C%0D%0A%20%20%20%20b%20%3D%20a%2C%0D%0A%20%20%20%20c%20%3D%20b%2C%0D%0A%20%20%20%20%2F%2F%20does%20c%20%3D%3D%20Foo.b%20%3D%3D%20Foo.c%20%3D%3D%201%3F%0D%0A%20%20%20%20%2F%2F%20or%20does%20c%20%3D%3D%20b%20%3D%3D%202%3F%0D%0A%7D)].
+
+Therefore, it's often better to prevent unexpected results in code by requiring the use of literal values as enum members.
+This rule reports when an enum member is given a value that is not a literal.
+
+## Examples
+
+<!--tabs-->
+
+### ❌ Incorrect
+
+```ts
+const str = 'Test';
+enum Invalid {
+  A = str, // Variable assignment
+  B = {}, // Object assignment
+  C = `A template literal string`, // Template literal
+  D = new Set(1, 2, 3), // Constructor in assignment
+  E = 2 + 2, // Expression assignment
+}
+```
+
+### ✅ Correct
+
+```ts
+enum Valid {
+  A,
+  B = 'TestStr', // A regular string
+  C = 4, // A number
+  D = null,
+  E = /some_regex/,
+}
+```
+
+<!--/tabs-->
+
+## Options
+
+### `allowBitwiseExpressions`
+
+When set to `true` will allow you to use bitwise expressions in enum initializer (default: `false`).
+
+Examples of code for the `{ "allowBitwiseExpressions": true }` option:
+
+<!--tabs-->
+
+### ❌ Incorrect
+
+```ts option='{ "allowBitwiseExpressions": true }'
+const x = 1;
+enum Foo {
+  A = x << 0,
+  B = x >> 0,
+  C = x >>> 0,
+  D = x | 0,
+  E = x & 0,
+  F = x ^ 0,
+  G = ~x,
+}
+```
+
+### ✅ Correct
+
+```ts option='{ "allowBitwiseExpressions": true }'
+enum Foo {
+  A = 1 << 0,
+  B = 1 >> 0,
+  C = 1 >>> 0,
+  D = 1 | 0,
+  E = 1 & 0,
+  F = 1 ^ 0,
+  G = ~1,
+}
+```
+
+## When Not To Use It
+
+If you want use anything other than simple literals as an enum value, this rule might not be for you.

package/backend/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-namespace-keyword.md

@@ -0,0 +1,47 @@
+---
+description: 'Require using `namespace` keyword over `module` keyword to declare custom TypeScript modules.'
+---
+
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/prefer-namespace-keyword** for documentation.
+
+TypeScript historically allowed a form of code organization called "custom modules" (`module Example {}`), later renamed to "namespaces" (`namespace Example`).
+
+Namespaces are an outdated way to organize TypeScript code.
+ES2015 module syntax is now preferred (`import`/`export`).
+
+For projects still using custom modules / namespaces, it's preferred to refer to them as namespaces.
+This rule reports when the `module` keyword is used instead of `namespace`.
+
+> This rule does not report on the use of TypeScript module declarations to describe external APIs (`declare module 'foo' {}`).
+
+## Examples
+
+<!--tabs-->
+
+### ❌ Incorrect
+
+```ts
+module Example {}
+```
+
+### ✅ Correct
+
+```ts
+namespace Example {}
+
+declare module 'foo' {}
+```
+
+<!--/tabs-->
+
+## When Not To Use It
+
+If you are not using TypeScript's older `module`/`namespace` keywords, then you will not need this rule.
+
+## Further Reading
+
+- [Modules](https://www.typescriptlang.org/docs/handbook/modules.html)
+- [Namespaces](https://www.typescriptlang.org/docs/handbook/namespaces.html)
+- [Namespaces and Modules](https://www.typescriptlang.org/docs/handbook/namespaces-and-modules.html)

package/backend/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-nullish-coalescing.md

@@ -0,0 +1,187 @@
+---
+description: 'Enforce using the nullish coalescing operator instead of logical assignments or chaining.'
+---
+
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/prefer-nullish-coalescing** for documentation.
+
+The `??` nullish coalescing runtime operator allows providing a default value when dealing with `null` or `undefined`.
+Because the nullish coalescing operator _only_ coalesces when the original value is `null` or `undefined`, it is much safer than relying upon logical OR operator chaining `||`, which coalesces on any _falsy_ value.
+
+This rule reports when you may consider replacing:
+
+- An `||` operator with `??`
+- An `||=` operator with `??=`
+
+:::caution
+This rule will not work as expected if [`strictNullChecks`](https://www.typescriptlang.org/tsconfig#strictNullChecks) is not enabled.
+:::
+
+## Options
+
+### `ignoreTernaryTests`
+
+Setting this option to `true` will cause the rule to ignore any ternary expressions that could be simplified by using the nullish coalescing operator. This is set to `false` by default.
+
+Incorrect code for `ignoreTernaryTests: false`, and correct code for `ignoreTernaryTests: true`:
+
+```ts option='{ "ignoreTernaryTests": false }' showPlaygroundButton
+const foo: any = 'bar';
+foo !== undefined && foo !== null ? foo : 'a string';
+foo === undefined || foo === null ? 'a string' : foo;
+foo == undefined ? 'a string' : foo;
+foo == null ? 'a string' : foo;
+
+const foo: string | undefined = 'bar';
+foo !== undefined ? foo : 'a string';
+foo === undefined ? 'a string' : foo;
+
+const foo: string | null = 'bar';
+foo !== null ? foo : 'a string';
+foo === null ? 'a string' : foo;
+```
+
+Correct code for `ignoreTernaryTests: false`:
+
+```ts option='{ "ignoreTernaryTests": false }' showPlaygroundButton
+const foo: any = 'bar';
+foo ?? 'a string';
+foo ?? 'a string';
+foo ?? 'a string';
+foo ?? 'a string';
+
+const foo: string | undefined = 'bar';
+foo ?? 'a string';
+foo ?? 'a string';
+
+const foo: string | null = 'bar';
+foo ?? 'a string';
+foo ?? 'a string';
+```
+
+### `ignoreConditionalTests`
+
+Setting this option to `true` will cause the rule to ignore any cases that are located within a conditional test. This is set to `false` by default.
+
+Generally expressions within conditional tests intentionally use the falsy fallthrough behavior of the logical or operator, meaning that fixing the operator to the nullish coalesce operator could cause bugs.
+
+If you're looking to enforce stricter conditional tests, you should consider using the `strict-boolean-expressions` rule.
+
+Incorrect code for `ignoreConditionalTests: false`, and correct code for `ignoreConditionalTests: true`:
+
+```ts option='{ "ignoreConditionalTests": false }' showPlaygroundButton
+declare const a: string | null;
+declare const b: string | null;
+
+if (a || b) {
+}
+if ((a ||= b)) {
+}
+while (a || b) {}
+while ((a ||= b)) {}
+do {} while (a || b);
+for (let i = 0; a || b; i += 1) {}
+a || b ? true : false;
+```
+
+Correct code for `ignoreConditionalTests: false`:
+
+```ts option='{ "ignoreConditionalTests": false }' showPlaygroundButton
+declare const a: string | null;
+declare const b: string | null;
+
+if (a ?? b) {
+}
+if ((a ??= b)) {
+}
+while (a ?? b) {}
+while ((a ??= b)) {}
+do {} while (a ?? b);
+for (let i = 0; a ?? b; i += 1) {}
+a ?? b ? true : false;
+```
+
+### `ignoreMixedLogicalExpressions`
+
+Setting this option to `true` will cause the rule to ignore any logical or expressions that are part of a mixed logical expression (with `&&`). This is set to `false` by default.
+
+Generally expressions within mixed logical expressions intentionally use the falsy fallthrough behavior of the logical or operator, meaning that fixing the operator to the nullish coalesce operator could cause bugs.
+
+If you're looking to enforce stricter conditional tests, you should consider using the `strict-boolean-expressions` rule.
+
+Incorrect code for `ignoreMixedLogicalExpressions: false`, and correct code for `ignoreMixedLogicalExpressions: true`:
+
+```ts option='{ "ignoreMixedLogicalExpressions": false }' showPlaygroundButton
+declare const a: string | null;
+declare const b: string | null;
+declare const c: string | null;
+declare const d: string | null;
+
+a || (b && c);
+a ||= b && c;
+(a && b) || c || d;
+a || (b && c) || d;
+a || (b && c && d);
+```
+
+Correct code for `ignoreMixedLogicalExpressions: false`:
+
+```ts option='{ "ignoreMixedLogicalExpressions": false }' showPlaygroundButton
+declare const a: string | null;
+declare const b: string | null;
+declare const c: string | null;
+declare const d: string | null;
+
+a ?? (b && c);
+a ??= b && c;
+(a && b) ?? c ?? d;
+a ?? (b && c) ?? d;
+a ?? (b && c && d);
+```
+
+**_NOTE:_** Errors for this specific case will be presented as suggestions (see below), instead of fixes. This is because it is not always safe to automatically convert `||` to `??` within a mixed logical expression, as we cannot tell the intended precedence of the operator. Note that by design, `??` requires parentheses when used with `&&` or `||` in the same expression.
+
+### `ignorePrimitives`
+
+If you would like to ignore expressions containing operands of certain primitive types that can be falsy then you may pass an object containing a boolean value for each primitive:
+
+- `string: true`, ignores `null` or `undefined` unions with `string` (default: false).
+- `number: true`, ignores `null` or `undefined` unions with `number` (default: false).
+- `bigint: true`, ignores `null` or `undefined` unions with `bigint` (default: false).
+- `boolean: true`, ignores `null` or `undefined` unions with `boolean` (default: false).
+
+Incorrect code for `ignorePrimitives: { string: false }`, and correct code for `ignorePrimitives: { string: true }`:
+
+```ts option='{ "ignorePrimitives": { "string": true } }' showPlaygroundButton
+const foo: string | undefined = 'bar';
+foo || 'a string';
+```
+
+Correct code for both `ignorePrimitives: { string: false }` and `ignorePrimitives: { string: true }`:
+
+```ts option='{ "ignorePrimitives": { "string": true } }' showPlaygroundButton
+const foo: string | undefined = 'bar';
+foo ?? 'a string';
+```
+
+Also, if you would like to ignore all primitives types, you can set `ignorePrimitives: true`. It is equivalent to `ignorePrimitives: { string: true, number: true, bigint: true, boolean: true }`.
+
+### `allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing`
+
+If this is set to `false`, then the rule will error on every file whose `tsconfig.json` does _not_ have the `strictNullChecks` compiler option (or `strict`) set to `true`.
+
+Without `strictNullChecks`, TypeScript essentially erases `undefined` and `null` from the types. This means when this rule inspects the types from a variable, **it will not be able to tell that the variable might be `null` or `undefined`**, which essentially makes this rule useless.
+
+You should be using `strictNullChecks` to ensure complete type-safety in your codebase.
+
+If for some reason you cannot turn on `strictNullChecks`, but still want to use this rule - you can use this option to allow it - but know that the behavior of this rule is _undefined_ with the compiler option turned off. We will not accept bug reports if you are using this option.
+
+## When Not To Use It
+
+If you are not using TypeScript 3.7 (or greater), then you will not be able to use this rule, as the operator is not supported.
+
+## Further Reading
+
+- [TypeScript 3.7 Release Notes](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html)
+- [Nullish Coalescing Operator Proposal](https://github.com/tc39/proposal-nullish-coalescing/)