@nr1e/commons 0.1.0 → 0.1.1-alpha.0

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/type-annotation-spacing.md

@@ -0,0 +1,303 @@
+---
+description: 'Require consistent spacing around type annotations.'
+---
+
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/type-annotation-spacing** for documentation.
+
+Spacing around type annotations improves readability of the code. Although the most commonly used style guideline for type annotations in TypeScript prescribes adding a space after the colon, but not before it, it is subjective to the preferences of a project. For example:
+
+<!-- prettier-ignore -->
+```ts
+// with space after, but not before (default if no option is specified)
+let foo: string = "bar";
+
+// with no spaces
+let foo:string = "bar";
+
+// with space before and after
+let foo : string = "bar";
+
+// with space before, but not after
+let foo :string = "bar";
+
+// with spaces before and after the fat arrow (default if no option is specified)
+type Foo = (string: name) => string;
+
+// with no spaces between the fat arrow
+type Foo = (string: name)=>string;
+
+// with space after, but not before the fat arrow
+type Foo = (string: name)=> string;
+
+// with space before, but not after the fat arrow
+type Foo = (string: name) =>string;
+```
+
+## Examples
+
+This rule aims to enforce specific spacing patterns around type annotations and function types in type literals.
+
+## Options
+
+Examples of code for this rule with no options at all:
+
+<!--tabs-->
+
+### ❌ Incorrect
+
+<!-- prettier-ignore -->
+```ts
+let foo:string = "bar";
+let foo :string = "bar";
+let foo : string = "bar";
+
+function foo():string {}
+function foo() :string {}
+function foo() : string {}
+
+class Foo {
+    name:string;
+}
+
+class Foo {
+    name :string;
+}
+
+class Foo {
+    name : string;
+}
+
+type Foo = ()=>{};
+type Foo = () =>{};
+type Foo = ()=> {};
+```
+
+### ✅ Correct
+
+<!-- prettier-ignore -->
+```ts
+let foo: string = "bar";
+
+function foo(): string {}
+
+class Foo {
+    name: string;
+}
+
+type Foo = () => {};
+```
+
+### after
+
+Examples of code for this rule with `{ "before": false, "after": true }`:
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+<!-- prettier-ignore -->
+```ts
+let foo:string = "bar";
+let foo :string = "bar";
+let foo : string = "bar";
+
+function foo():string {}
+function foo() :string {}
+function foo() : string {}
+
+class Foo {
+    name:string;
+}
+
+class Foo {
+    name :string;
+}
+
+class Foo {
+    name : string;
+}
+
+type Foo = ()=>{};
+type Foo = () =>{};
+type Foo = () => {};
+```
+
+#### ✅ Correct
+
+<!-- prettier-ignore -->
+```ts
+let foo: string = "bar";
+
+function foo(): string {}
+
+class Foo {
+    name: string;
+}
+
+type Foo = ()=> {};
+```
+
+### before
+
+Examples of code for this rule with `{ "before": true, "after": true }` options:
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+<!-- prettier-ignore -->
+```ts
+let foo: string = "bar";
+let foo:string = "bar";
+let foo :string = "bar";
+
+function foo(): string {}
+function foo():string {}
+function foo() :string {}
+
+class Foo {
+    name: string;
+}
+
+class Foo {
+    name:string;
+}
+
+class Foo {
+    name :string;
+}
+
+type Foo = ()=>{};
+type Foo = () =>{};
+type Foo = ()=> {};
+```
+
+#### ✅ Correct
+
+<!-- prettier-ignore -->
+```ts
+let foo : string = "bar";
+
+function foo() : string {}
+
+class Foo {
+    name : string;
+}
+
+type Foo = () => {};
+```
+
+### overrides - colon
+
+Examples of code for this rule with `{ "before": false, "after": false, overrides: { colon: { before: true, after: true }} }` options:
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+<!-- prettier-ignore -->
+```ts
+let foo: string = "bar";
+let foo:string = "bar";
+let foo :string = "bar";
+
+function foo(): string {}
+function foo():string {}
+function foo() :string {}
+
+class Foo {
+    name: string;
+}
+
+class Foo {
+    name:string;
+}
+
+class Foo {
+    name :string;
+}
+
+type Foo = () =>{};
+type Foo = ()=> {};
+type Foo = () => {};
+```
+
+#### ✅ Correct
+
+<!-- prettier-ignore -->
+```ts
+let foo : string = "bar";
+
+function foo() : string {}
+
+class Foo {
+    name : string;
+}
+
+type Foo = {
+    name: (name : string)=>string;
+}
+
+type Foo = ()=>{};
+```
+
+### overrides - arrow
+
+Examples of code for this rule with `{ "before": false, "after": false, overrides: { arrow: { before: true, after: true }} }` options:
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+<!-- prettier-ignore -->
+```ts
+let foo: string = "bar";
+let foo : string = "bar";
+let foo :string = "bar";
+
+function foo(): string {}
+function foo():string {}
+function foo() :string {}
+
+class Foo {
+    name: string;
+}
+
+class Foo {
+    name : string;
+}
+
+class Foo {
+    name :string;
+}
+
+type Foo = ()=>{};
+type Foo = () =>{};
+type Foo = ()=> {};
+```
+
+#### ✅ Correct
+
+<!-- prettier-ignore -->
+```ts
+let foo:string = "bar";
+
+function foo():string {}
+
+class Foo {
+    name:string;
+}
+
+type Foo = () => {};
+```
+
+## When Not To Use It
+
+If you don't want to enforce spacing for your type annotations, you can safely turn this rule off.
+
+## Further Reading
+
+- [TypeScript Type System](https://basarat.gitbooks.io/typescript/docs/types/type-system.html)
+- [Type Inference](https://www.typescriptlang.org/docs/handbook/type-inference.html)

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/typedef.md

@@ -0,0 +1,320 @@
+---
+description: 'Require type annotations in certain places.'
+---
+
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/typedef** for documentation.
+
+TypeScript cannot always infer types for all places in code.
+Some locations require type annotations for their types to be inferred.
+
+This rule can enforce type annotations in locations regardless of whether they're required.
+This is typically used to maintain consistency for element types that sometimes require them.
+
+```ts
+class ContainsText {
+  // There must be a type annotation here to infer the type
+  delayedText: string;
+
+  // `typedef` requires a type annotation here to maintain consistency
+  immediateTextExplicit: string = 'text';
+
+  // This is still a string type because of its initial value
+  immediateTextImplicit = 'text';
+}
+```
+
+> To enforce type definitions existing on call signatures, use [`explicit-function-return-type`](./explicit-function-return-type.md), or [`explicit-module-boundary-types`](./explicit-module-boundary-types.md).
+
+:::caution
+
+Requiring type annotations unnecessarily can be cumbersome to maintain and generally reduces code readability.
+TypeScript is often better at inferring types than easily written type annotations would allow.
+
+**Instead of enabling `typedef`, it is generally recommended to use the `--noImplicitAny` and `--strictPropertyInitialization` compiler options to enforce type annotations only when useful.**
+
+:::
+
+## Options
+
+For example, with the following configuration:
+
+```json
+{
+  "rules": {
+    "@typescript-eslint/typedef": [
+      "error",
+      {
+        "arrowParameter": true,
+        "variableDeclaration": true
+      }
+    ]
+  }
+}
+```
+
+- Type annotations on arrow function parameters are required
+- Type annotations on variables are required
+
+### `arrayDestructuring`
+
+Whether to enforce type annotations on variables declared using array destructuring.
+
+Examples of code with `{ "arrayDestructuring": true }`:
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+const [a] = [1];
+const [b, c] = [1, 2];
+```
+
+#### ✅ Correct
+
+```ts
+const [a]: number[] = [1];
+const [b]: [number] = [2];
+const [c, d]: [boolean, string] = [true, 'text'];
+
+for (const [key, val] of new Map([['key', 1]])) {
+}
+```
+
+### `arrowParameter`
+
+Whether to enforce type annotations for parameters of arrow functions.
+
+Examples of code with `{ "arrowParameter": true }`:
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+const logsSize = size => console.log(size);
+
+['hello', 'world'].map(text => text.length);
+
+const mapper = {
+  map: text => text + '...',
+};
+```
+
+#### ✅ Correct
+
+```ts
+const logsSize = (size: number) => console.log(size);
+
+['hello', 'world'].map((text: string) => text.length);
+
+const mapper = {
+  map: (text: string) => text + '...',
+};
+```
+
+### `memberVariableDeclaration`
+
+Whether to enforce type annotations on member variables of classes.
+
+Examples of code with `{ "memberVariableDeclaration": true }`:
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+class ContainsText {
+  delayedText;
+  immediateTextImplicit = 'text';
+}
+```
+
+#### ✅ Correct
+
+```ts
+class ContainsText {
+  delayedText: string;
+  immediateTextImplicit: string = 'text';
+}
+```
+
+### `objectDestructuring`
+
+Whether to enforce type annotations on variables declared using object destructuring.
+
+Examples of code with `{ "objectDestructuring": true }`:
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+const { length } = 'text';
+const [b, c] = Math.random() ? [1, 2] : [3, 4];
+```
+
+#### ✅ Correct
+
+```ts
+const { length }: { length: number } = 'text';
+const [b, c]: [number, number] = Math.random() ? [1, 2] : [3, 4];
+
+for (const { key, val } of [{ key: 'key', val: 1 }]) {
+}
+```
+
+### `parameter`
+
+Whether to enforce type annotations for parameters of functions and methods.
+
+Examples of code with `{ "parameter": true }`:
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+function logsSize(size): void {
+  console.log(size);
+}
+
+const doublesSize = function (size): number {
+  return size * 2;
+};
+
+const divider = {
+  curriesSize(size): number {
+    return size;
+  },
+  dividesSize: function (size): number {
+    return size / 2;
+  },
+};
+
+class Logger {
+  log(text): boolean {
+    console.log('>', text);
+    return true;
+  }
+}
+```
+
+#### ✅ Correct
+
+```ts
+function logsSize(size: number): void {
+  console.log(size);
+}
+
+const doublesSize = function (size: number): number {
+  return size * 2;
+};
+
+const divider = {
+  curriesSize(size: number): number {
+    return size;
+  },
+  dividesSize: function (size: number): number {
+    return size / 2;
+  },
+};
+
+class Logger {
+  log(text: boolean): boolean {
+    console.log('>', text);
+    return true;
+  }
+}
+```
+
+### `propertyDeclaration`
+
+Whether to enforce type annotations for properties of interfaces and types.
+
+Examples of code with `{ "propertyDeclaration": true }`:
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+type Members = {
+  member;
+  otherMember;
+};
+```
+
+#### ✅ Correct
+
+```ts
+type Members = {
+  member: boolean;
+  otherMember: string;
+};
+```
+
+### `variableDeclaration`
+
+Whether to enforce type annotations for variable declarations, excluding array and object destructuring.
+
+Examples of code with `{ "variableDeclaration": true }`:
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+const text = 'text';
+let initialText = 'text';
+let delayedText;
+```
+
+#### ✅ Correct
+
+```ts
+const text: string = 'text';
+let initialText: string = 'text';
+let delayedText: string;
+```
+
+### `variableDeclarationIgnoreFunction`
+
+Ignore variable declarations for non-arrow and arrow functions.
+
+Examples of code with `{ "variableDeclaration": true, "variableDeclarationIgnoreFunction": true }`:
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+const text = 'text';
+```
+
+#### ✅ Correct
+
+```ts
+const a = (): void => {};
+const b = function (): void => {};
+const c: () => void = (): void => {};
+
+class Foo {
+  a = (): void => {};
+  b = function (): void => {};
+  c = () => void = (): void => {};
+}
+```
+
+## When Not To Use It
+
+If you are using stricter TypeScript compiler options, particularly `--noImplicitAny` and/or `--strictPropertyInitialization`, you likely don't need this rule.
+
+In general, if you do not consider the cost of writing unnecessary type annotations reasonable, then do not use this rule.
+
+## Further Reading
+
+- [TypeScript Type System](https://basarat.gitbooks.io/typescript/docs/types/type-system.html)
+- [Type Inference](https://www.typescriptlang.org/docs/handbook/type-inference.html)

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/unbound-method.md

@@ -0,0 +1,103 @@
+---
+description: 'Enforce unbound methods are called with their expected scope.'
+---
+
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/unbound-method** for documentation.
+
+Class method functions don't preserve the class scope when passed as standalone variables ("unbound").
+If your function does not access `this`, [you can annotate it with `this: void`](https://www.typescriptlang.org/docs/handbook/2/functions.html#declaring-this-in-a-function), or consider using an arrow function instead.
+Otherwise, passing class methods around as values can remove type safety by failing to capture `this`.
+
+This rule reports when a class method is referenced in an unbound manner.
+
+:::note Tip
+If you're working with `jest`, you can use [`eslint-plugin-jest`'s version of this rule](https://github.com/jest-community/eslint-plugin-jest/blob/main/docs/rules/unbound-method.md) to lint your test files, which knows when it's ok to pass an unbound method to `expect` calls.
+:::
+
+## Examples
+
+<!--tabs-->
+
+### ❌ Incorrect
+
+```ts
+class MyClass {
+  public log(): void {
+    console.log(this);
+  }
+}
+
+const instance = new MyClass();
+
+// This logs the global scope (`window`/`global`), not the class instance
+const myLog = instance.log;
+myLog();
+
+// This log might later be called with an incorrect scope
+const { log } = instance;
+
+// arith.double may refer to `this` internally
+const arith = {
+  double(x: number): number {
+    return x * 2;
+  },
+};
+const { double } = arith;
+```
+
+### ✅ Correct
+
+```ts
+class MyClass {
+  public logUnbound(): void {
+    console.log(this);
+  }
+
+  public logBound = () => console.log(this);
+}
+
+const instance = new MyClass();
+
+// logBound will always be bound with the correct scope
+const { logBound } = instance;
+logBound();
+
+// .bind and lambdas will also add a correct scope
+const dotBindLog = instance.logBound.bind(instance);
+const innerLog = () => instance.logBound();
+
+// arith.double explicitly declares that it does not refer to `this` internally
+const arith = {
+  double(this: void, x: number): number {
+    return x * 2;
+  },
+};
+const { double } = arith;
+```
+
+## Options
+
+### `ignoreStatic`
+
+Examples of **correct** code for this rule with `{ ignoreStatic: true }`:
+
+```ts
+class OtherClass {
+  static log() {
+    console.log(OtherClass);
+  }
+}
+
+// With `ignoreStatic`, statics are assumed to not rely on a particular scope
+const { log } = OtherClass;
+
+log();
+```
+
+## When Not To Use It
+
+If your code intentionally waits to bind methods after use, such as by passing a `scope: this` along with the method, you can disable this rule.
+
+If you're wanting to use `toBeCalled` and similar matches in `jest` tests, you can disable this rule for your test files in favor of [`eslint-plugin-jest`'s version of this rule](https://github.com/jest-community/eslint-plugin-jest/blob/main/docs/rules/unbound-method.md).