@nr1e/commons 0.1.1 → 0.1.3-alpha.0

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

@@ -1,16 +0,0 @@
----
-description: 'Require or disallow semicolons instead of ASI.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/semi** for documentation.
-
-This rule enforces consistent use of semicolons after statements.
-
-## Examples
-
-This rule extends the base [`eslint/semi`](https://eslint.org/docs/rules/semi) rule.
-It adds support for TypeScript features that require semicolons.
-
-See also the [`@typescript-eslint/member-delimiter-style`](member-delimiter-style.md) rule, which allows you to specify the delimiter for `type` and `interface` members.

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

@@ -1,101 +0,0 @@
----
-description: 'Enforce constituents of a type union/intersection to be sorted alphabetically.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/sort-type-constituents** for documentation.
-
-Sorting union (`|`) and intersection (`&`) types can help:
-
-- keep your codebase standardized
-- find repeated types
-- reduce diff churn
-
-This rule reports on any types that aren't sorted alphabetically.
-
-> Types are sorted case-insensitively and treating numbers like a human would, falling back to character code sorting in case of ties.
-
-## Examples
-
-<!--tabs-->
-
-### ❌ Incorrect
-
-```ts
-type T1 = B | A;
-
-type T2 = { b: string } & { a: string };
-
-type T3 = [1, 2, 4] & [1, 2, 3];
-
-type T4 =
-  | [1, 2, 4]
-  | [1, 2, 3]
-  | { b: string }
-  | { a: string }
-  | (() => void)
-  | (() => string)
-  | 'b'
-  | 'a'
-  | 'b'
-  | 'a'
-  | readonly string[]
-  | readonly number[]
-  | string[]
-  | number[]
-  | B
-  | A
-  | string
-  | any;
-```
-
-### ✅ Correct
-
-```ts
-type T1 = A | B;
-
-type T2 = { a: string } & { b: string };
-
-type T3 = [1, 2, 3] & [1, 2, 4];
-
-type T4 =
-  | A
-  | B
-  | number[]
-  | string[]
-  | any
-  | string
-  | readonly number[]
-  | readonly string[]
-  | 'a'
-  | 'a'
-  | 'b'
-  | 'b'
-  | (() => string)
-  | (() => void)
-  | { a: string }
-  | { b: string }
-  | [1, 2, 3]
-  | [1, 2, 4];
-```
-
-## Options
-
-### `groupOrder`
-
-Each constituent of the type is placed into a group, and then the rule sorts alphabetically within each group.
-The ordering of groups is determined by this option.
-
-- `conditional` - Conditional types (`A extends B ? C : D`)
-- `function` - Function and constructor types (`() => void`, `new () => type`)
-- `import` - Import types (`import('path')`)
-- `intersection` - Intersection types (`A & B`)
-- `keyword` - Keyword types (`any`, `string`, etc)
-- `literal` - Literal types (`1`, `'b'`, `true`, etc)
-- `named` - Named types (`A`, `A['prop']`, `B[]`, `Array<C>`)
-- `object` - Object types (`{ a: string }`, `{ [key: string]: number }`)
-- `operator` - Operator types (`keyof A`, `typeof B`, `readonly C[]`)
-- `tuple` - Tuple types (`[A, B, C]`)
-- `union` - Union types (`A | B`)
-- `nullish` - `null` and `undefined`

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/sort-type-union-intersection-members.md

@@ -1,106 +0,0 @@
----
-description: 'Enforce members of a type union/intersection to be sorted alphabetically.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/sort-type-union-intersection-members** for documentation.
-
-:::danger Deprecated
-
-This rule has been renamed to [`sort-type-constituents`](./sort-type-constituents.md).
-:::
-
-Sorting union (`|`) and intersection (`&`) types can help:
-
-- keep your codebase standardized
-- find repeated types
-- reduce diff churn
-
-This rule reports on any types that aren't sorted alphabetically.
-
-> Types are sorted case-insensitively and treating numbers like a human would, falling back to character code sorting in case of ties.
-
-## Examples
-
-<!--tabs-->
-
-### ❌ Incorrect
-
-```ts
-type T1 = B | A;
-
-type T2 = { b: string } & { a: string };
-
-type T3 = [1, 2, 4] & [1, 2, 3];
-
-type T4 =
-  | [1, 2, 4]
-  | [1, 2, 3]
-  | { b: string }
-  | { a: string }
-  | (() => void)
-  | (() => string)
-  | 'b'
-  | 'a'
-  | 'b'
-  | 'a'
-  | readonly string[]
-  | readonly number[]
-  | string[]
-  | number[]
-  | B
-  | A
-  | string
-  | any;
-```
-
-### ✅ Correct
-
-```ts
-type T1 = A | B;
-
-type T2 = { a: string } & { b: string };
-
-type T3 = [1, 2, 3] & [1, 2, 4];
-
-type T4 =
-  | any
-  | string
-  | A
-  | B
-  | number[]
-  | string[]
-  | readonly number[]
-  | readonly string[]
-  | 'a'
-  | 'b'
-  | 'a'
-  | 'b'
-  | (() => string)
-  | (() => void)
-  | { a: string }
-  | { b: string }
-  | [1, 2, 3]
-  | [1, 2, 4];
-```
-
-## Options
-
-### `groupOrder`
-
-Each member of the type is placed into a group, and then the rule sorts alphabetically within each group.
-The ordering of groups is determined by this option.
-
-- `conditional` - Conditional types (`A extends B ? C : D`)
-- `function` - Function and constructor types (`() => void`, `new () => type`)
-- `import` - Import types (`import('path')`)
-- `intersection` - Intersection types (`A & B`)
-- `keyword` - Keyword types (`any`, `string`, etc)
-- `literal` - Literal types (`1`, `'b'`, `true`, etc)
-- `named` - Named types (`A`, `A['prop']`, `B[]`, `Array<C>`)
-- `object` - Object types (`{ a: string }`, `{ [key: string]: number }`)
-- `operator` - Operator types (`keyof A`, `typeof B`, `readonly C[]`)
-- `tuple` - Tuple types (`[A, B, C]`)
-- `union` - Union types (`A | B`)
-- `nullish` - `null` and `undefined`

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/space-before-blocks.md

@@ -1,42 +0,0 @@
----
-description: 'Enforce consistent spacing before blocks.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/space-before-blocks** for documentation.
-
-## Examples
-
-This rule extends the base [`eslint/space-before-blocks`](https://eslint.org/docs/rules/space-before-blocks) rule.
-It adds support for interfaces and enums.
-
-<!-- tabs -->
-
-### ❌ Incorrect
-
-```ts
-enum Breakpoint{
-  Large, Medium;
-}
-
-interface State{
-  currentBreakpoint: Breakpoint;
-}
-```
-
-### ✅ Correct
-
-```ts
-enum Breakpoint {
-  Large, Medium;
-}
-
-interface State {
-  currentBreakpoint: Breakpoint;
-}
-```
-
-## Options
-
-In case a more specific options object is passed these blocks will follow `classes` configuration option.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/space-before-function-paren.md

@@ -1,12 +0,0 @@
----
-description: 'Enforce consistent spacing before function parenthesis.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/space-before-function-paren** for documentation.
-
-## Examples
-
-This rule extends the base [`eslint/space-before-function-paren`](https://eslint.org/docs/rules/space-before-function-paren) rule.
-It adds support for generic type parameters on function calls.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/space-infix-ops.md

@@ -1,16 +0,0 @@
----
-description: 'Require spacing around infix operators.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/space-infix-ops** for documentation.
-
-This rule extends the base [`eslint/space-infix-ops`](https://eslint.org/docs/rules/space-infix-ops) rule.
-It adds support for enum members.
-
-```ts
-enum MyEnum {
-  KEY = 'value',
-}
-```

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/strict-boolean-expressions.md

@@ -1,183 +0,0 @@
----
-description: 'Disallow certain types in boolean expressions.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/strict-boolean-expressions** for documentation.
-
-Forbids usage of non-boolean types in expressions where a boolean is expected.
-`boolean` and `never` types are always allowed.
-Additional types which are considered safe in a boolean context can be configured via options.
-
-The following nodes are considered boolean expressions and their type is checked:
-
-- Argument to the logical negation operator (`!arg`).
-- The condition in a conditional expression (`cond ? x : y`).
-- Conditions for `if`, `for`, `while`, and `do-while` statements.
-- Operands of logical binary operators (`lhs || rhs` and `lhs && rhs`).
-  - Right-hand side operand is ignored when it's not a descendant of another boolean expression.
-    This is to allow usage of boolean operators for their short-circuiting behavior.
-
-## Examples
-
-<!--tabs-->
-
-### ❌ Incorrect
-
-```ts
-// nullable numbers are considered unsafe by default
-let num: number | undefined = 0;
-if (num) {
-  console.log('num is defined');
-}
-
-// nullable strings are considered unsafe by default
-let str: string | null = null;
-if (!str) {
-  console.log('str is empty');
-}
-
-// nullable booleans are considered unsafe by default
-function foo(bool?: boolean) {
-  if (bool) {
-    bar();
-  }
-}
-
-// `any`, unconstrained generics and unions of more than one primitive type are disallowed
-const foo = <T>(arg: T) => (arg ? 1 : 0);
-
-// always-truthy and always-falsy types are disallowed
-let obj = {};
-while (obj) {
-  obj = getObj();
-}
-```
-
-### ✅ Correct
-
-```tsx
-// Using logical operator short-circuiting is allowed
-const Component = () => {
-  const entry = map.get('foo') || {};
-  return entry && <p>Name: {entry.name}</p>;
-};
-
-// nullable values should be checked explicitly against null or undefined
-let num: number | undefined = 0;
-if (num != null) {
-  console.log('num is defined');
-}
-
-let str: string | null = null;
-if (str != null && !str) {
-  console.log('str is empty');
-}
-
-function foo(bool?: boolean) {
-  if (bool ?? false) {
-    bar();
-  }
-}
-
-// `any` types should be cast to boolean explicitly
-const foo = (arg: any) => (Boolean(arg) ? 1 : 0);
-```
-
-## Options
-
-### `allowString`
-
-Allows `string` in a boolean context.
-This is safe because strings have only one falsy value (`""`).
-Set this to `false` if you prefer the explicit `str != ""` or `str.length > 0` style.
-
-### `allowNumber`
-
-Allows `number` in a boolean context.
-This is safe because numbers have only two falsy values (`0` and `NaN`).
-Set this to `false` if you prefer the explicit `num != 0` and `!Number.isNaN(num)` style.
-
-### `allowNullableObject`
-
-Allows `object | function | symbol | null | undefined` in a boolean context.
-This is safe because objects, functions and symbols don't have falsy values.
-Set this to `false` if you prefer the explicit `obj != null` style.
-
-### `allowNullableBoolean`
-
-Allows `boolean | null | undefined` in a boolean context.
-This is unsafe because nullable booleans can be either `false` or nullish.
-Set this to `false` if you want to enforce explicit `bool ?? false` or `bool ?? true` style.
-Set this to `true` if you don't mind implicitly treating false the same as a nullish value.
-
-### `allowNullableString`
-
-Allows `string | null | undefined` in a boolean context.
-This is unsafe because nullable strings can be either an empty string or nullish.
-Set this to `true` if you don't mind implicitly treating an empty string the same as a nullish value.
-
-### `allowNullableNumber`
-
-Allows `number | null | undefined` in a boolean context.
-This is unsafe because nullable numbers can be either a falsy number or nullish.
-Set this to `true` if you don't mind implicitly treating zero or NaN the same as a nullish value.
-
-### `allowNullableEnum`
-
-Allows `enum | null | undefined` in a boolean context.
-This is unsafe because nullable enums can be either a falsy number or nullish.
-Set this to `true` if you don't mind implicitly treating an enum whose value is zero the same as a nullish value.
-
-### `allowAny`
-
-Allows `any` in a boolean context.
-This is unsafe for obvious reasons.
-Set this to `true` at your own risk.
-
-### `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 a lot less useful.
-
-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.
-
-## Fixes and Suggestions
-
-This rule provides following fixes and suggestions for particular types in boolean context:
-
-- `boolean` - Always allowed - no fix needed.
-- `string` - (when `allowString` is `false`) - Provides following suggestions:
-  - Change condition to check string's length (`str` → `str.length > 0`)
-  - Change condition to check for empty string (`str` → `str !== ""`)
-  - Explicitly cast value to a boolean (`str` → `Boolean(str)`)
-- `number` - (when `allowNumber` is `false`):
-  - For `array.length` - Provides **autofix**:
-    - Change condition to check for 0 (`array.length` → `array.length > 0`)
-  - For other number values - Provides following suggestions:
-    - Change condition to check for 0 (`num` → `num !== 0`)
-    - Change condition to check for NaN (`num` → `!Number.isNaN(num)`)
-    - Explicitly cast value to a boolean (`num` → `Boolean(num)`)
-- `object | null | undefined` - (when `allowNullableObject` is `false`) - Provides **autofix**:
-  - Change condition to check for null/undefined (`maybeObj` → `maybeObj != null`)
-- `boolean | null | undefined` - Provides following suggestions:
-  - Explicitly treat nullish value the same as false (`maybeBool` → `maybeBool ?? false`)
-  - Change condition to check for true/false (`maybeBool` → `maybeBool === true`)
-- `string | null | undefined` - Provides following suggestions:
-  - Change condition to check for null/undefined (`maybeStr` → `maybeStr != null`)
-  - Explicitly treat nullish value the same as an empty string (`maybeStr` → `maybeStr ?? ""`)
-  - Explicitly cast value to a boolean (`maybeStr` → `Boolean(maybeStr)`)
-- `number | null | undefined` - Provides following suggestions:
-  - Change condition to check for null/undefined (`maybeNum` → `maybeNum != null`)
-  - Explicitly treat nullish value the same as 0 (`maybeNum` → `maybeNum ?? 0`)
-  - Explicitly cast value to a boolean (`maybeNum` → `Boolean(maybeNum)`)
-- `any` and `unknown` - Provides following suggestions:
-  - Explicitly cast value to a boolean (`value` → `Boolean(value)`)
-
-## Related To
-
-- [no-unnecessary-condition](./no-unnecessary-condition.md) - Similar rule which reports always-truthy and always-falsy values in conditions

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/switch-exhaustiveness-check.md

@@ -1,106 +0,0 @@
----
-description: 'Require switch-case statements to be exhaustive with union type.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/switch-exhaustiveness-check** for documentation.
-
-When working with union types in TypeScript, it's common to want to write a `switch` statement intended to contain a `case` for each constituent (possible type in the union).
-However, if the union type changes, it's easy to forget to modify the cases to account for any new types.
-
-This rule reports when a `switch` statement over a value typed as a union of literals is missing a case for any of those literal types and does not have a `default` clause.
-
-## Examples
-
-<!--tabs-->
-
-### ❌ Incorrect
-
-```ts
-type Day =
-  | 'Monday'
-  | 'Tuesday'
-  | 'Wednesday'
-  | 'Thursday'
-  | 'Friday'
-  | 'Saturday'
-  | 'Sunday';
-
-const day = 'Monday' as Day;
-let result = 0;
-
-switch (day) {
-  case 'Monday':
-    result = 1;
-    break;
-}
-```
-
-### ✅ Correct
-
-```ts
-type Day =
-  | 'Monday'
-  | 'Tuesday'
-  | 'Wednesday'
-  | 'Thursday'
-  | 'Friday'
-  | 'Saturday'
-  | 'Sunday';
-
-const day = 'Monday' as Day;
-let result = 0;
-
-switch (day) {
-  case 'Monday':
-    result = 1;
-    break;
-  case 'Tuesday':
-    result = 2;
-    break;
-  case 'Wednesday':
-    result = 3;
-    break;
-  case 'Thursday':
-    result = 4;
-    break;
-  case 'Friday':
-    result = 5;
-    break;
-  case 'Saturday':
-    result = 6;
-    break;
-  case 'Sunday':
-    result = 7;
-    break;
-}
-```
-
-### ✅ Correct
-
-```ts
-type Day =
-  | 'Monday'
-  | 'Tuesday'
-  | 'Wednesday'
-  | 'Thursday'
-  | 'Friday'
-  | 'Saturday'
-  | 'Sunday';
-
-const day = 'Monday' as Day;
-let result = 0;
-
-switch (day) {
-  case 'Monday':
-    result = 1;
-    break;
-  default:
-    result = 42;
-}
-```
-
-## When Not To Use It
-
-If you don't frequently `switch` over union types with many parts, or intentionally wish to leave out some parts.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/triple-slash-reference.md

@@ -1,61 +0,0 @@
----
-description: 'Disallow certain triple slash directives in favor of ES6-style import declarations.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/triple-slash-reference** for documentation.
-
-TypeScript's `///` triple-slash references are a way to indicate that types from another module are available in a file.
-Use of triple-slash reference type directives is generally discouraged in favor of ECMAScript Module `import`s.
-This rule reports on the use of `/// <reference path="..." />`, `/// <reference types="..." />`, or `/// <reference lib="..." />` directives.
-
-## Examples
-
-## Options
-
-With `{ "path": "never", "types": "never", "lib": "never" }` options set, the following will all be **incorrect** usage:
-
-```ts
-/// <reference path="foo" />
-/// <reference types="bar" />
-/// <reference lib="baz" />
-```
-
-Examples of **incorrect** code for the `{ "types": "prefer-import" }` option. Note that these are only errors when **both** styles are used for the **same** module:
-
-```ts
-/// <reference types="foo" />
-import * as foo from 'foo';
-```
-
-```ts
-/// <reference types="foo" />
-import foo = require('foo');
-```
-
-With `{ "path": "always", "types": "always", "lib": "always" }` options set, the following will all be **correct** usage:
-
-```ts
-/// <reference path="foo" />
-/// <reference types="bar" />
-/// <reference lib="baz" />
-```
-
-Examples of **correct** code for the `{ "types": "prefer-import" }` option:
-
-```ts
-import * as foo from 'foo';
-```
-
-```ts
-import foo = require('foo');
-```
-
-## When To Use It
-
-If you want to ban use of one or all of the triple slash reference directives, or any time you might use triple-slash type reference directives and ES6 import declarations in the same file.
-
-## When Not To Use It
-
-If you want to use all flavors of triple slash reference directives.