@nr1e/commons 0.1.1 → 0.1.3-alpha.0

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

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

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

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

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

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