@nr1e/commons 0.1.1-alpha.0 → 0.1.2

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-unsafe-call.md

@@ -1,58 +0,0 @@
----
-description: 'Disallow calling a value with type `any`.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/no-unsafe-call** for documentation.
-
-The `any` type in TypeScript is a dangerous "escape hatch" from the type system.
-Using `any` disables many type checking rules and is generally best used only as a last resort or when prototyping code.
-
-Despite your best intentions, the `any` type can sometimes leak into your codebase.
-Calling an `any`-typed value as a function creates a potential type safety hole and source of bugs in your codebase.
-
-This rule disallows calling any value that is typed as `any`.
-
-## Examples
-
-<!--tabs-->
-
-### ❌ Incorrect
-
-```ts
-declare const anyVar: any;
-declare const nestedAny: { prop: any };
-
-anyVar();
-anyVar.a.b();
-
-nestedAny.prop();
-nestedAny.prop['a']();
-
-new anyVar();
-new nestedAny.prop();
-
-anyVar`foo`;
-nestedAny.prop`foo`;
-```
-
-### ✅ Correct
-
-```ts
-declare const typedVar: () => void;
-declare const typedNested: { prop: { a: () => void } };
-
-typedVar();
-typedNested.prop.a();
-
-(() => {})();
-
-new Map();
-
-String.raw`foo`;
-```
-
-## Related To
-
-- [`no-explicit-any`](./no-explicit-any.md)

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-unsafe-declaration-merging.md

@@ -1,54 +0,0 @@
----
-description: 'Disallow unsafe declaration merging.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/no-unsafe-declaration-merging** for documentation.
-
-TypeScript's "declaration merging" supports merging separate declarations with the same name.
-
-Declaration merging between classes and interfaces is unsafe.
-The TypeScript compiler doesn't check whether properties are initialized, which can cause lead to TypeScript not detecting code that will cause runtime errors.
-
-```ts
-interface Foo {
-  nums: number[];
-}
-
-class Foo {}
-
-const foo = new Foo();
-
-foo.nums.push(1); // Runtime Error: Cannot read properties of undefined.
-```
-
-## Examples
-
-<!--tabs-->
-
-### ❌ Incorrect
-
-```ts
-interface Foo {}
-
-class Foo {}
-```
-
-### ✅ Correct
-
-```ts
-interface Foo {}
-class Bar implements Foo {}
-
-namespace Baz {}
-namespace Baz {}
-enum Baz {}
-
-namespace Qux {}
-function Qux() {}
-```
-
-## Further Reading
-
-- [Declaration Merging](https://www.typescriptlang.org/docs/handbook/declaration-merging.html)

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-unsafe-enum-comparison.md

@@ -1,75 +0,0 @@
----
-description: 'Disallow comparing an enum value with a non-enum value.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/no-unsafe-enum-comparison** for documentation.
-
-The TypeScript compiler can be surprisingly lenient when working with enums.
-For example, it will allow you to compare enum values against numbers even though they might not have any type overlap:
-
-```ts
-enum Fruit {
-  Apple,
-  Banana,
-}
-
-declare let fruit: Fruit;
-
-fruit === 999; // No error
-```
-
-This rule flags when an enum typed value is compared to a non-enum `number`.
-
-<!--tabs-->
-
-### ❌ Incorrect
-
-```ts
-enum Fruit {
-  Apple,
-}
-
-declare let fruit: Fruit;
-
-fruit === 999;
-```
-
-```ts
-enum Vegetable {
-  Asparagus = 'asparagus',
-}
-
-declare let vegetable: Vegetable;
-
-vegetable === 'asparagus';
-```
-
-### ✅ Correct
-
-```ts
-enum Fruit {
-  Apple,
-}
-
-declare let fruit: Fruit;
-
-fruit === Fruit.Banana;
-```
-
-```ts
-enum Vegetable {
-  Asparagus = 'asparagus',
-}
-
-declare let vegetable: Vegetable;
-
-vegetable === Vegetable.Asparagus;
-```
-
-<!--/tabs-->
-
-## When Not to Use It
-
-If you don't mind number and/or literal string constants being compared against enums, you likely don't need this rule.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-unsafe-member-access.md

@@ -1,64 +0,0 @@
----
-description: 'Disallow member access on a value with type `any`.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/no-unsafe-member-access** for documentation.
-
-The `any` type in TypeScript is a dangerous "escape hatch" from the type system.
-Using `any` disables many type checking rules and is generally best used only as a last resort or when prototyping code.
-
-Despite your best intentions, the `any` type can sometimes leak into your codebase.
-Accessing a member of an `any`-typed value creates a potential type safety hole and source of bugs in your codebase.
-
-This rule disallows member access on any variable that is typed as `any`.
-
-## Examples
-
-<!--tabs-->
-
-### ❌ Incorrect
-
-```ts
-declare const anyVar: any;
-declare const nestedAny: { prop: any };
-
-anyVar.a;
-anyVar.a.b;
-anyVar['a'];
-anyVar['a']['b'];
-
-nestedAny.prop.a;
-nestedAny.prop['a'];
-
-const key = 'a';
-nestedAny.prop[key];
-
-// Using an any to access a member is unsafe
-const arr = [1, 2, 3];
-arr[anyVar];
-nestedAny[anyVar];
-```
-
-### ✅ Correct
-
-```ts
-declare const properlyTyped: { prop: { a: string } };
-
-properlyTyped.prop.a;
-properlyTyped.prop['a'];
-
-const key = 'a';
-properlyTyped.prop[key];
-
-const arr = [1, 2, 3];
-arr[1];
-const idx = 1;
-arr[idx];
-arr[idx++];
-```
-
-## Related To
-
-- [`no-explicit-any`](./no-explicit-any.md)

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-unsafe-return.md

@@ -1,103 +0,0 @@
----
-description: 'Disallow returning a value with type `any` from a function.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/no-unsafe-return** for documentation.
-
-The `any` type in TypeScript is a dangerous "escape hatch" from the type system.
-Using `any` disables many type checking rules and is generally best used only as a last resort or when prototyping code.
-
-Despite your best intentions, the `any` type can sometimes leak into your codebase.
-Returning an an `any`-typed value from a function creates a potential type safety hole and source of bugs in your codebase.
-
-This rule disallows returning `any` or `any[]` from a function.
-
-This rule also compares generic type argument types to ensure you don't return an unsafe `any` in a generic position to a function that's expecting a specific type.
-For example, it will error if you return `Set<any>` from a function declared as returning `Set<string>`.
-
-## Examples
-
-<!--tabs-->
-
-### ❌ Incorrect
-
-```ts
-function foo1() {
-  return 1 as any;
-}
-function foo2() {
-  return Object.create(null);
-}
-const foo3 = () => {
-  return 1 as any;
-};
-const foo4 = () => Object.create(null);
-
-function foo5() {
-  return [] as any[];
-}
-function foo6() {
-  return [] as Array<any>;
-}
-function foo7() {
-  return [] as readonly any[];
-}
-function foo8() {
-  return [] as Readonly<any[]>;
-}
-const foo9 = () => {
-  return [] as any[];
-};
-const foo10 = () => [] as any[];
-
-const foo11 = (): string[] => [1, 2, 3] as any[];
-
-// generic position examples
-function assignability1(): Set<string> {
-  return new Set<any>([1]);
-}
-type TAssign = () => Set<string>;
-const assignability2: TAssign = () => new Set<any>([true]);
-```
-
-### ✅ Correct
-
-```ts
-function foo1() {
-  return 1;
-}
-function foo2() {
-  return Object.create(null) as Record<string, unknown>;
-}
-
-const foo3 = () => [];
-const foo4 = () => ['a'];
-
-function assignability1(): Set<string> {
-  return new Set<string>(['foo']);
-}
-type TAssign = () => Set<string>;
-const assignability2: TAssign = () => new Set(['foo']);
-```
-
-<!--/tabs-->
-
-There are cases where the rule allows to return `any` to `unknown`.
-
-Examples of `any` to `unknown` return that are allowed:
-
-```ts
-function foo1(): unknown {
-  return JSON.parse(singleObjString); // Return type for JSON.parse is any.
-}
-
-function foo2(): unknown[] {
-  return [] as any[];
-}
-```
-
-## Related To
-
-- [`no-explicit-any`](./no-explicit-any.md)

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-unused-expressions.md

@@ -1,12 +0,0 @@
----
-description: 'Disallow unused expressions.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/no-unused-expressions** for documentation.
-
-## Examples
-
-This rule extends the base [`eslint/no-unused-expressions`](https://eslint.org/docs/rules/no-unused-expressions) rule.
-It adds support for optional call expressions `x?.()`, and directive in module declarations.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-unused-vars.md

@@ -1,12 +0,0 @@
----
-description: 'Disallow unused variables.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/no-unused-vars** for documentation.
-
-## Examples
-
-This rule extends the base [`eslint/no-unused-vars`](https://eslint.org/docs/rules/no-unused-vars) rule.
-It adds support for TypeScript features, such as types.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-use-before-define.md

@@ -1,97 +0,0 @@
----
-description: 'Disallow the use of variables before they are defined.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/no-use-before-define** for documentation.
-
-## Examples
-
-This rule extends the base [`eslint/no-use-before-define`](https://eslint.org/docs/rules/no-use-before-define) rule.
-It adds support for `type`, `interface` and `enum` declarations.
-
-## Options
-
-This rule adds the following options:
-
-```ts
-interface Options extends BaseNoUseBeforeDefineOptions {
-  enums?: boolean;
-  typedefs?: boolean;
-  ignoreTypeReferences?: boolean;
-}
-
-const defaultOptions: Options = {
-  ...baseNoUseBeforeDefineDefaultOptions,
-  enums: true,
-  typedefs: true,
-  ignoreTypeReferences: true,
-};
-```
-
-### `enums`
-
-If this is `true`, this rule warns every reference to a enum before the enum declaration.
-If this is `false`, this rule will ignore references to enums, when the reference is in a child scope.
-
-Examples of code for the `{ "enums": true }` option:
-
-<!--tabs-->
-
-#### ❌ Incorrect
-
-```ts
-/*eslint no-use-before-define: ["error", { "enums": true }]*/
-
-const x = Foo.FOO;
-
-enum Foo {
-  FOO,
-}
-```
-
-#### ✅ Correct
-
-```ts
-/*eslint no-use-before-define: ["error", { "enums": false }]*/
-
-function foo() {
-  return Foo.FOO;
-}
-
-enum Foo {
-  FOO,
-}
-```
-
-### `typedefs`
-
-If this is `true`, this rule warns every reference to a type before the type declaration.
-If this is `false`, this rule will ignore references to types.
-
-Examples of **correct** code for the `{ "typedefs": false }` option:
-
-```ts
-/*eslint no-use-before-define: ["error", { "typedefs": false }]*/
-
-let myVar: StringOrNumber;
-type StringOrNumber = string | number;
-```
-
-### `ignoreTypeReferences`
-
-If this is `true`, this rule ignores all type references, such as in type annotations and assertions.
-If this is `false`, this will will check all type references.
-
-Examples of **correct** code for the `{ "ignoreTypeReferences": true }` option:
-
-```ts
-/*eslint no-use-before-define: ["error", { "ignoreTypeReferences": true }]*/
-
-let var1: StringOrNumber;
-type StringOrNumber = string | number;
-
-let var2: Enum;
-enum Enum {}
-```

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-useless-constructor.md

@@ -1,21 +0,0 @@
----
-description: 'Disallow unnecessary constructors.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/no-useless-constructor** for documentation.
-
-## Examples
-
-This rule extends the base [`eslint/no-useless-constructor`](https://eslint.org/docs/rules/no-useless-constructor) rule.
-It adds support for:
-
-- constructors marked as `protected` / `private` (i.e. marking a constructor as non-public),
-- `public` constructors when there is no superclass,
-- constructors with only parameter properties.
-
-### Caveat
-
-This lint rule will report on constructors whose sole purpose is to change visibility of a parent constructor.
-See [discussion on this rule's lack of type information](https://github.com/typescript-eslint/typescript-eslint/issues/3820#issuecomment-917821240) for context.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-useless-empty-export.md

@@ -1,43 +0,0 @@
----
-description: "Disallow empty exports that don't change anything in a module file."
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/no-useless-empty-export** for documentation.
-
-An empty `export {}` statement is sometimes useful in TypeScript code to turn a file that would otherwise be a script file into a module file.
-Per the [TypeScript Handbook Modules page](https://www.typescriptlang.org/docs/handbook/modules.html):
-
-> In TypeScript, just as in ECMAScript 2015, any file containing a top-level import or export is considered a module.
-> Conversely, a file without any top-level import or export declarations is treated as a script whose contents are available in the global scope (and therefore to modules as well).
-
-However, an `export {}` statement does nothing if there are any other top-level import or export statements in a file.
-
-This rule reports an `export {}` that doesn't do anything in a file already using ES modules.
-
-## Examples
-
-<!--tabs-->
-
-### ❌ Incorrect
-
-```ts
-export const value = 'Hello, world!';
-export {};
-```
-
-```ts
-import 'some-other-module';
-export {};
-```
-
-### ✅ Correct
-
-```ts
-export const value = 'Hello, world!';
-```
-
-```ts
-import 'some-other-module';
-```

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-var-requires.md

@@ -1,37 +0,0 @@
----
-description: 'Disallow `require` statements except in import statements.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/no-var-requires** for documentation.
-
-In other words, the use of forms such as `var foo = require("foo")` are banned. Instead use ES6 style imports or `import foo = require("foo")` imports.
-
-## Examples
-
-<!--tabs-->
-
-### ❌ Incorrect
-
-```ts
-var foo = require('foo');
-const foo = require('foo');
-let foo = require('foo');
-```
-
-### ✅ Correct
-
-```ts
-import foo = require('foo');
-require('foo');
-import foo from 'foo';
-```
-
-## 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-require-imports`](./no-require-imports.md)

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/non-nullable-type-assertion-style.md

@@ -1,41 +0,0 @@
----
-description: 'Enforce non-null assertions over explicit type casts.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/non-nullable-type-assertion-style** for documentation.
-
-There are two common ways to assert to TypeScript that a value is its type without `null` or `undefined`:
-
-- `!`: Non-null assertion
-- `as`: Traditional type assertion with a coincidentally equivalent type
-
-`!` non-null assertions are generally preferred for requiring less code and being harder to fall out of sync as types change.
-This rule reports when an `as` cast is doing the same job as a `!` would, and suggests fixing the code to be an `!`.
-
-## Examples
-
-<!--tabs-->
-
-### ❌ Incorrect
-
-```ts
-const maybe = Math.random() > 0.5 ? '' : undefined;
-
-const definitely = maybe as string;
-const alsoDefinitely = <string>maybe;
-```
-
-### ✅ Correct
-
-```ts
-const maybe = Math.random() > 0.5 ? '' : undefined;
-
-const definitely = maybe!;
-const alsoDefinitely = maybe!;
-```
-
-## When Not To Use It
-
-If you don't mind having unnecessarily verbose type casts, you can avoid this rule.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/object-curly-spacing.md

@@ -1,12 +0,0 @@
----
-description: 'Enforce consistent spacing inside braces.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/object-curly-spacing** for documentation.
-
-## Examples
-
-This rule extends the base [`eslint/object-curly-spacing`](https://eslint.org/docs/rules/object-curly-spacing) rule.
-It adds support for TypeScript's object types.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/padding-line-between-statements.md

@@ -1,35 +0,0 @@
----
-description: 'Require or disallow padding lines between statements.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/padding-line-between-statements** for documentation.
-
-## Examples
-
-This rule extends the base [`eslint/padding-line-between-statements`](https://eslint.org/docs/rules/padding-line-between-statements) rule.
-It adds support for TypeScript constructs such as `interface` and `type`.
-
-## Options
-
-In addition to options provided by ESLint, `interface` and `type` can be used as statement types.
-
-For example, to add blank lines before interfaces and type definitions:
-
-```jsonc
-{
-  // Example - Add blank lines before interface and type definitions.
-  "padding-line-between-statements": "off",
-  "@typescript-eslint/padding-line-between-statements": [
-    "error",
-    {
-      "blankLine": "always",
-      "prev": "*",
-      "next": ["interface", "type"]
-    }
-  ]
-}
-```
-
-**Note:** ESLint `cjs-export` and `cjs-import` statement types are renamed to `exports` and `require` respectively.