@nr1e/commons 0.1.1 → 0.1.3-alpha.0

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

@@ -1,406 +0,0 @@
----
-description: 'Disallow the use of parameter properties in class constructors.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/no-parameter-properties** for documentation.
-
-:::danger Deprecated
-
-This rule has been deprecated in favour of the equivalent, better named [`parameter-properties`](./parameter-properties.md) rule.
-:::
-
-Parameter properties can be confusing to those new to TypeScript as they are less explicit than other ways
-of declaring and initializing class members.
-
-## Examples
-
-This rule disallows the use of parameter properties in constructors, forcing the user to explicitly
-declare all properties in the class.
-
-## Options
-
-This rule, in its default state, does not require any argument and would completely disallow the use of parameter properties.
-If you would like to allow certain types of parameter properties then you may pass an object with the following options:
-
-- `allows`, 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.
-
-### 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 `{ "allows": ["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 `{ "allows": ["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 `{ "allows": ["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 `{ "allows": ["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 `{ "allows": ["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 `{ "allows": ["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 `{ "allows": ["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) {}
-}
-```
-
-## 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/no-redeclare.md

@@ -1,73 +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.
-
-## Examples
-
-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
-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
-type something = string;
-// eslint-disable-next-line @typescript-eslint/no-redeclare -- intentionally naming the variable the same as the type
-const something = 2;
-```

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

@@ -1,78 +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.
-
-## 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/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-require-imports.md

@@ -1,37 +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';
-```
-
-## When Not To Use It
-
-If you don't care about using newer module syntax, then you will not need this rule.
-
-## Related To
-
-- [`no-var-requires`](./no-var-requires.md)

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

@@ -1,63 +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.
-
-## Examples
-
-This rule extends the base [`eslint/no-restricted-imports`](https://eslint.org/docs/rules/no-restricted-imports) rule.
-
-## Options
-
-This rule adds the following options:
-
-### `allowTypeImports`
-
-(default: `false`)
-
-You can specify this option for a specific path or pattern as follows:
-
-```jsonc
-"@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
-import foo from 'import-foo';
-export { Foo } from 'import-foo';
-
-import baz from 'import-baz';
-export { Baz } from 'import-baz';
-```
-
-#### ✅ Correct
-
-```ts
-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';
-```