@nr1e/commons 0.1.0-alpha.1 → 0.1.1-alpha.0

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

@@ -0,0 +1,485 @@
+---
+description: 'Require or disallow parameter properties in class constructors.'
+---
+
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/parameter-properties** for documentation.
+
+TypeScript includes a "parameter properties" shorthand for declaring a class constructor parameter and class property in one location.
+Parameter properties can be confusing to those new to TypeScript as they are less explicit than other ways of declaring and initializing class members.
+
+This rule can be configured to always disallow the use of parameter properties or enforce their usage when possible.
+
+## Options
+
+This rule, in its default state, does not require any argument and would completely disallow the use of parameter properties.
+It may take an options object containing either or both of:
+
+- `"allow"`: allowing certain kinds of properties to be ignored
+- `"prefer"`: either `"class-property"` _(default)_ or `"parameter-property"`
+
+### `"allow"`
+
+If you would like to ignore certain kinds of properties then you may pass an object containing `"allow"` as an array of any of the following options:
+
+- `allow`, an array containing one or more of the allowed modifiers. Valid values are:
+  - `readonly`, allows **readonly** parameter properties.
+  - `private`, allows **private** parameter properties.
+  - `protected`, allows **protected** parameter properties.
+  - `public`, allows **public** parameter properties.
+  - `private readonly`, allows **private readonly** parameter properties.
+  - `protected readonly`, allows **protected readonly** parameter properties.
+  - `public readonly`, allows **public readonly** parameter properties.
+
+For example, to ignore `public` properties:
+
+```json
+{
+  "@typescript-eslint/parameter-properties": [
+    true,
+    {
+      "allow": ["public"]
+    }
+  ]
+}
+```
+
+### `"prefer"`
+
+By default, the rule prefers class property (`"class-property"`).
+You can switch it to instead preferring parameter property with (`"parameter-property"`).
+
+In `"parameter-property"` mode, the rule will issue a report when:
+
+- A class property and constructor parameter have the same name and type
+- The constructor parameter is assigned to the class property at the beginning of the constructor
+
+### default
+
+Examples of code for this rule with no options at all:
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+class Foo {
+  constructor(readonly name: string) {}
+}
+
+class Foo {
+  constructor(private name: string) {}
+}
+
+class Foo {
+  constructor(protected name: string) {}
+}
+
+class Foo {
+  constructor(public name: string) {}
+}
+
+class Foo {
+  constructor(private readonly name: string) {}
+}
+
+class Foo {
+  constructor(protected readonly name: string) {}
+}
+
+class Foo {
+  constructor(public readonly name: string) {}
+}
+```
+
+#### ✅ Correct
+
+```ts
+class Foo {
+  constructor(name: string) {}
+}
+```
+
+### readonly
+
+Examples of code for the `{ "allow": ["readonly"] }` options:
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+class Foo {
+  constructor(private name: string) {}
+}
+
+class Foo {
+  constructor(protected name: string) {}
+}
+
+class Foo {
+  constructor(public name: string) {}
+}
+
+class Foo {
+  constructor(private readonly name: string) {}
+}
+
+class Foo {
+  constructor(protected readonly name: string) {}
+}
+
+class Foo {
+  constructor(public readonly name: string) {}
+}
+```
+
+#### ✅ Correct
+
+```ts
+class Foo {
+  constructor(name: string) {}
+}
+
+class Foo {
+  constructor(readonly name: string) {}
+}
+```
+
+### private
+
+Examples of code for the `{ "allow": ["private"] }` options:
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+class Foo {
+  constructor(readonly name: string) {}
+}
+
+class Foo {
+  constructor(protected name: string) {}
+}
+
+class Foo {
+  constructor(public name: string) {}
+}
+
+class Foo {
+  constructor(private readonly name: string) {}
+}
+
+class Foo {
+  constructor(protected readonly name: string) {}
+}
+
+class Foo {
+  constructor(public readonly name: string) {}
+}
+```
+
+#### ✅ Correct
+
+```ts
+class Foo {
+  constructor(name: string) {}
+}
+
+class Foo {
+  constructor(private name: string) {}
+}
+```
+
+### protected
+
+Examples of code for the `{ "allow": ["protected"] }` options:
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+class Foo {
+  constructor(readonly name: string) {}
+}
+
+class Foo {
+  constructor(private name: string) {}
+}
+
+class Foo {
+  constructor(public name: string) {}
+}
+
+class Foo {
+  constructor(private readonly name: string) {}
+}
+
+class Foo {
+  constructor(protected readonly name: string) {}
+}
+
+class Foo {
+  constructor(public readonly name: string) {}
+}
+```
+
+#### ✅ Correct
+
+```ts
+class Foo {
+  constructor(name: string) {}
+}
+
+class Foo {
+  constructor(protected name: string) {}
+}
+```
+
+### public
+
+Examples of code for the `{ "allow": ["public"] }` options:
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+class Foo {
+  constructor(readonly name: string) {}
+}
+
+class Foo {
+  constructor(private name: string) {}
+}
+
+class Foo {
+  constructor(protected name: string) {}
+}
+
+class Foo {
+  constructor(private readonly name: string) {}
+}
+
+class Foo {
+  constructor(protected readonly name: string) {}
+}
+
+class Foo {
+  constructor(public readonly name: string) {}
+}
+```
+
+#### ✅ Correct
+
+```ts
+class Foo {
+  constructor(name: string) {}
+}
+
+class Foo {
+  constructor(public name: string) {}
+}
+```
+
+### private readonly
+
+Examples of code for the `{ "allow": ["private readonly"] }` options:
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+class Foo {
+  constructor(readonly name: string) {}
+}
+
+class Foo {
+  constructor(private name: string) {}
+}
+
+class Foo {
+  constructor(protected name: string) {}
+}
+
+class Foo {
+  constructor(public name: string) {}
+}
+
+class Foo {
+  constructor(protected readonly name: string) {}
+}
+
+class Foo {
+  constructor(public readonly name: string) {}
+}
+```
+
+#### ✅ Correct
+
+```ts
+class Foo {
+  constructor(name: string) {}
+}
+
+class Foo {
+  constructor(private readonly name: string) {}
+}
+```
+
+### protected readonly
+
+Examples of code for the `{ "allow": ["protected readonly"] }` options:
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+class Foo {
+  constructor(readonly name: string) {}
+}
+
+class Foo {
+  constructor(private name: string) {}
+}
+
+class Foo {
+  constructor(protected name: string) {}
+}
+
+class Foo {
+  constructor(public name: string) {}
+}
+
+class Foo {
+  constructor(private readonly name: string) {}
+}
+
+class Foo {
+  constructor(public readonly name: string) {}
+}
+```
+
+#### ✅ Correct
+
+```ts
+class Foo {
+  constructor(name: string) {}
+}
+
+class Foo {
+  constructor(protected readonly name: string) {}
+}
+```
+
+### public readonly
+
+Examples of code for the `{ "allow": ["public readonly"] }` options:
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+class Foo {
+  constructor(readonly name: string) {}
+}
+
+class Foo {
+  constructor(private name: string) {}
+}
+
+class Foo {
+  constructor(protected name: string) {}
+}
+
+class Foo {
+  constructor(public name: string) {}
+}
+
+class Foo {
+  constructor(private readonly name: string) {}
+}
+
+class Foo {
+  constructor(protected readonly name: string) {}
+}
+```
+
+#### ✅ Correct
+
+```ts
+class Foo {
+  constructor(name: string) {}
+}
+
+class Foo {
+  constructor(public readonly name: string) {}
+}
+```
+
+### `"parameter-property"`
+
+Examples of code for the `{ "prefer": "parameter-property" }` option:
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+class Foo {
+  private name: string;
+  constructor(name: string) {
+    this.name = name;
+  }
+}
+
+class Foo {
+  public readonly name: string;
+  constructor(name: string) {
+    this.name = name;
+  }
+}
+
+class Foo {
+  constructor(name: string) {
+    this.name = name;
+  }
+  name: string;
+}
+```
+
+#### ✅ Correct
+
+```ts
+class Foo {
+  private differentName: string;
+  constructor(name: string) {
+    this.differentName = name;
+  }
+}
+
+class Foo {
+  private differentType: number | undefined;
+  constructor(differentType: number) {
+    this.differentType = differentType;
+  }
+}
+
+class Foo {
+  protected logicInConstructor: string;
+  constructor(logicInConstructor: string) {
+    console.log('Hello, world!');
+    this.logicInConstructor = logicInConstructor;
+  }
+}
+```
+
+## When Not To Use It
+
+If you don't care about the using parameter properties in constructors, then you will not need this rule.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-as-const.md

@@ -0,0 +1,44 @@
+---
+description: 'Enforce the use of `as const` over literal type.'
+---
+
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/prefer-as-const** for documentation.
+
+There are two common ways to tell TypeScript that a literal value should be interpreted as its literal type (e.g. `2`) rather than general primitive type (e.g. `number`);
+
+- `as const`: telling TypeScript to infer the literal type automatically
+- `as` with the literal type: explicitly telling the literal type to TypeScript
+
+`as const` is generally preferred, as it doesn't require re-typing the literal value.
+This rule reports when an `as` with an explicit literal type can be replaced with an `as const`.
+
+## Examples
+
+<!--tabs-->
+
+### ❌ Incorrect
+
+```ts
+let bar: 2 = 2;
+let foo = <'bar'>'bar';
+let foo = { bar: 'baz' as 'baz' };
+```
+
+### ✅ Correct
+
+```ts
+let foo = 'bar';
+let foo = 'bar' as const;
+let foo: 'bar' = 'bar' as const;
+let bar = 'bar' as string;
+let foo = <string>'bar';
+let foo = { bar: 'baz' };
+```
+
+<!--/tabs-->
+
+## When Not To Use It
+
+If you are using TypeScript < 3.4

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-enum-initializers.md

@@ -0,0 +1,62 @@
+---
+description: 'Require each enum member value to be explicitly initialized.'
+---
+
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/prefer-enum-initializers** for documentation.
+
+TypeScript `enum`s are a practical way to organize semantically related constant values.
+Members of `enum`s that don't have explicit values are by default given sequentially increasing numbers.
+
+In projects where the value of `enum` members are important, allowing implicit values for enums can cause bugs if `enum`s are modified over time.
+
+This rule recommends having each `enum` member value explicitly initialized.
+
+## Examples
+
+<!--tabs-->
+
+### ❌ Incorrect
+
+```ts
+enum Status {
+  Open = 1,
+  Close,
+}
+
+enum Direction {
+  Up,
+  Down,
+}
+
+enum Color {
+  Red,
+  Green = 'Green'
+  Blue = 'Blue',
+}
+```
+
+### ✅ Correct
+
+```ts
+enum Status {
+  Open = 'Open',
+  Close = 'Close',
+}
+
+enum Direction {
+  Up = 1,
+  Down = 2,
+}
+
+enum Color {
+  Red = 'Red',
+  Green = 'Green',
+  Blue = 'Blue',
+}
+```
+
+## When Not To Use It
+
+If you don't care about `enum`s having implicit values you can safely disable this rule.

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

@@ -0,0 +1,46 @@
+---
+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
+
+```js
+declare const array: string[];
+
+for (let i = 0; i < array.length; i++) {
+  console.log(array[i]);
+}
+```
+
+### ✅ Correct
+
+```js
+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]);
+}
+```
+
+## When Not To Use It
+
+If you transpile for browsers that do not support for-of loops, you may wish to use traditional for loops that produce more compact code.

package/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 disable 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.