@nr1e/commons 0.1.1-alpha.0 → 0.1.2

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/promise-function-async.md

@@ -1,59 +0,0 @@
----
-description: 'Require any function or method that returns a Promise to be marked async.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/promise-function-async** for documentation.
-
-Ensures that each function is only capable of:
-
-- returning a rejected promise, or
-- throwing an Error object.
-
-In contrast, non-`async`, `Promise`-returning functions are technically capable of either.
-Code that handles the results of those functions will often need to handle both cases, which can get complex.
-This rule's practice removes a requirement for creating code to handle both cases.
-
-> When functions return unions of `Promise` and non-`Promise` types implicitly, it is usually a mistake—this rule flags those cases. If it is intentional, make the return type explicitly to allow the rule to pass.
-
-## Examples
-
-Examples of code for this rule
-
-<!--tabs-->
-
-### ❌ Incorrect
-
-```ts
-const arrowFunctionReturnsPromise = () => Promise.resolve('value');
-
-function functionReturnsPromise() {
-  return Promise.resolve('value');
-}
-
-function functionReturnsUnionWithPromiseImplicitly(p: boolean) {
-  return p ? 'value' : Promise.resolve('value');
-}
-```
-
-### ✅ Correct
-
-```ts
-const arrowFunctionReturnsPromise = async () => Promise.resolve('value');
-
-async function functionReturnsPromise() {
-  return Promise.resolve('value');
-}
-
-// An explicit return type that is not Promise means this function cannot be made async, so it is ignored by the rule
-function functionReturnsUnionWithPromiseExplicitly(
-  p: boolean,
-): string | Promise<string> {
-  return p ? 'value' : Promise.resolve('value');
-}
-
-async function functionReturnsUnionWithPromiseImplicitly(p: boolean) {
-  return p ? 'value' : Promise.resolve('value');
-}
-```

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

@@ -1,12 +0,0 @@
----
-description: 'Enforce the consistent use of either backticks, double, or single quotes.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/quotes** for documentation.
-
-## Examples
-
-This rule extends the base [`eslint/quotes`](https://eslint.org/docs/rules/quotes) rule.
-It adds support for TypeScript features which allow quoted names, but not backtick quoted names.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/require-array-sort-compare.md

@@ -1,78 +0,0 @@
----
-description: 'Require `Array#sort` calls to always provide a `compareFunction`.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/require-array-sort-compare** for documentation.
-
-When called without a compare function, `Array#sort()` converts all non-undefined array elements into strings and then compares said strings based off their UTF-16 code units [[ECMA specification](https://www.ecma-international.org/ecma-262/9.0/#sec-sortcompare)].
-
-The result is that elements are sorted alphabetically, regardless of their type.
-For example, when sorting numbers, this results in a "10 before 2" order:
-
-```ts
-[1, 2, 3, 10, 20, 30].sort(); //→ [1, 10, 2, 20, 3, 30]
-```
-
-This rule reports on any call to the `Array#sort()` method that doesn't provide a `compare` argument.
-
-## Examples
-
-This rule aims to ensure all calls of the native `Array#sort` method provide a `compareFunction`, while ignoring calls to user-defined `sort` methods.
-
-<!--tabs-->
-
-### ❌ Incorrect
-
-```ts
-const array: any[];
-const stringArray: string[];
-
-array.sort();
-
-// String arrays should be sorted using `String#localeCompare`.
-stringArray.sort();
-```
-
-### ✅ Correct
-
-```ts
-const array: any[];
-const userDefinedType: { sort(): void };
-
-array.sort((a, b) => a - b);
-array.sort((a, b) => a.localeCompare(b));
-
-userDefinedType.sort();
-```
-
-## Options
-
-### `ignoreStringArrays`
-
-Examples of code for this rule with `{ ignoreStringArrays: true }`:
-
-<!--tabs-->
-
-#### ❌ Incorrect
-
-```ts
-const one = 1;
-const two = 2;
-const three = 3;
-[one, two, three].sort();
-```
-
-#### ✅ Correct
-
-```ts
-const one = '1';
-const two = '2';
-const three = '3';
-[one, two, three].sort();
-```
-
-## When Not To Use It
-
-If you understand the language specification enough, and/or only ever sort arrays in a string-like manner, you can turn this rule off safely.

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

@@ -1,24 +0,0 @@
----
-description: 'Disallow async functions which have no `await` expression.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/require-await** for documentation.
-
-## Examples
-
-This rule extends the base [`eslint/require-await`](https://eslint.org/docs/rules/require-await) rule.
-It uses type information to add support for `async` functions that return a `Promise`.
-
-Examples of **correct** code for this rule:
-
-```ts
-async function returnsPromise1() {
-  return Promise.resolve(1);
-}
-
-const returnsPromise2 = () => returnsPromise1();
-```
-
-## How to Use

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/restrict-plus-operands.md

@@ -1,208 +0,0 @@
----
-description: 'Require both operands of addition to be the same type and be `bigint`, `number`, or `string`.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/restrict-plus-operands** for documentation.
-
-TypeScript allows `+` adding together two values of any type(s).
-However, adding values that are not the same type and/or are not the same primitive type is often a sign of programmer error.
-
-This rule reports when a `+` operation combines two values of different types, or a type that is not `bigint`, `number`, or `string`.
-
-## Examples
-
-<!--tabs-->
-
-### ❌ Incorrect
-
-```ts
-let foo = '5.5' + 5;
-let foo = 1n + 1;
-```
-
-### ✅ Correct
-
-```ts
-let foo = parseInt('5.5', 10) + 10;
-let foo = 1n + 1n;
-```
-
-## Options
-
-:::caution
-We generally recommend against using these options, as they limit which varieties of incorrect `+` usage can be checked.
-This in turn severely limits the validation that the rule can do to ensure that resulting strings and numbers are correct.
-
-Safer alternatives to using the `allow*` options include:
-
-- Using variadic forms of logging APIs to avoid needing to `+` values.
-  ```ts
-  // Remove this line
-  console.log('The result is ' + true);
-  // Add this line
-  console.log('The result is', true);
-  ```
-- Using `.toFixed()` to coerce numbers to well-formed string representations:
-  ```ts
-  const number = 1.123456789;
-  const result = 'The number is ' + number.toFixed(2);
-  // result === 'The number is 1.12'
-  ```
-- Calling `.toString()` on other types to mark explicit and intentional string coercion:
-  ```ts
-  const arg = '11';
-  const regex = /[0-9]/;
-  const result =
-    'The result of ' +
-    regex.toString() +
-    '.test("' +
-    arg +
-    '") is ' +
-    regex.test(arg).toString();
-  // result === 'The result of /[0-9]/.test("11") is true'
-  ```
-
-:::
-
-### `allowAny`
-
-Examples of code for this rule with `{ allowAny: true }`:
-
-<!--tabs-->
-
-#### ❌ Incorrect
-
-```ts
-let fn = (a: number, b: []) => a + b;
-let fn = (a: string, b: []) => a + b;
-```
-
-#### ✅ Correct
-
-```ts
-let fn = (a: number, b: any) => a + b;
-let fn = (a: string, b: any) => a + b;
-```
-
-### `allowBoolean`
-
-Examples of code for this rule with `{ allowBoolean: true }`:
-
-<!--tabs-->
-
-#### ❌ Incorrect
-
-```ts
-let fn = (a: number, b: unknown) => a + b;
-let fn = (a: string, b: unknown) => a + b;
-```
-
-#### ✅ Correct
-
-```ts
-let fn = (a: number, b: boolean) => a + b;
-let fn = (a: string, b: boolean) => a + b;
-```
-
-### `allowNullish`
-
-Examples of code for this rule with `{ allowNullish: true }`:
-
-<!--tabs-->
-
-#### ❌ Incorrect
-
-```ts
-let fn = (a: number, b: unknown) => a + b;
-let fn = (a: number, b: never) => a + b;
-let fn = (a: string, b: unknown) => a + b;
-let fn = (a: string, b: never) => a + b;
-```
-
-#### ✅ Correct
-
-```ts
-let fn = (a: number, b: undefined) => a + b;
-let fn = (a: number, b: null) => a + b;
-let fn = (a: string, b: undefined) => a + b;
-let fn = (a: string, b: null) => a + b;
-```
-
-### `allowNumberAndString`
-
-Examples of code for this rule with `{ allowNumberAndString: true }`:
-
-<!--tabs-->
-
-#### ❌ Incorrect
-
-```ts
-let fn = (a: number, b: unknown) => a + b;
-let fn = (a: number, b: never) => a + b;
-```
-
-#### ✅ Correct
-
-```ts
-let fn = (a: number, b: string) => a + b;
-let fn = (a: number, b: number | string) => a + b;
-```
-
-### `allowRegExp`
-
-Examples of code for this rule with `{ allowRegExp: true }`:
-
-<!--tabs-->
-
-#### ❌ Incorrect
-
-```ts
-let fn = (a: number, b: RegExp) => a + b;
-```
-
-#### ✅ Correct
-
-```ts
-let fn = (a: string, b: RegExp) => a + b;
-```
-
-### `checkCompoundAssignments`
-
-Examples of code for this rule with `{ checkCompoundAssignments: true }`:
-
-<!--tabs-->
-
-#### ❌ Incorrect
-
-```ts
-let foo: string | undefined;
-foo += 'some data';
-
-let bar: string = '';
-bar += 0;
-```
-
-#### ✅ Correct
-
-```ts
-let foo: number = 0;
-foo += 1;
-
-let bar = '';
-bar += 'test';
-```
-
-## When Not To Use It
-
-If you don't mind `"[object Object]"` in your strings, then you will not need this rule.
-
-## Related To
-
-- [`no-base-to-string`](./no-base-to-string.md)
-- [`restrict-template-expressions`](./restrict-template-expressions.md)
-
-## Further Reading
-
-- [`Object.prototype.toString()` MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toString)

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/restrict-template-expressions.md

@@ -1,117 +0,0 @@
----
-description: 'Enforce template literal expressions to be of `string` type.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/restrict-template-expressions** for documentation.
-
-JavaScript automatically [converts an object to a string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String#string_coercion) in a string context, such as when concatenating it with a string using `+` or embedding it in a template literal using `${}`.
-The default `toString()` method of objects returns `"[object Object]"`, which is often not what was intended.
-This rule reports on values used in a template literal string that aren't strings, numbers, or BigInts, optionally allowing other data types that provide useful stringification results.
-
-:::note
-
-This rule intentionally does not allow objects with a custom `toString()` method to be used in template literals, because the stringification result may not be user-friendly.
-
-For example, arrays have a custom [`toString()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toString) method, which only calls `join()` internally, which joins the array elements with commas. This means that (1) array elements are not necessarily stringified to useful results (2) the commas don't have spaces after them, making the result not user-friendly. The best way to format arrays is to use [`Intl.ListFormat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat), which even supports adding the "and" conjunction where necessary.
-You must explicitly call `object.toString()` if you want to use this object in a template literal.
-The [`no-base-to-string`](./no-base-to-string.md) rule can be used to guard this case against producing `"[object Object]"` by accident.
-
-:::
-
-## Examples
-
-<!--tabs-->
-
-### ❌ Incorrect
-
-```ts
-const arg1 = [1, 2];
-const msg1 = `arg1 = ${arg1}`;
-
-const arg2 = { name: 'Foo' };
-const msg2 = `arg2 = ${arg2 || null}`;
-```
-
-### ✅ Correct
-
-```ts
-const arg = 'foo';
-const msg1 = `arg = ${arg}`;
-const msg2 = `arg = ${arg || 'default'}`;
-
-const stringWithKindProp: string & { _kind?: 'MyString' } = 'foo';
-const msg3 = `stringWithKindProp = ${stringWithKindProp}`;
-```
-
-## Options
-
-### `allowNumber`
-
-Examples of additional **correct** code for this rule with `{ allowNumber: true }`:
-
-```ts
-const arg = 123;
-const msg1 = `arg = ${arg}`;
-const msg2 = `arg = ${arg || 'zero'}`;
-```
-
-This option controls both numbers and BigInts.
-
-### `allowBoolean`
-
-Examples of additional **correct** code for this rule with `{ allowBoolean: true }`:
-
-```ts
-const arg = true;
-const msg1 = `arg = ${arg}`;
-const msg2 = `arg = ${arg || 'not truthy'}`;
-```
-
-### `allowAny`
-
-Examples of additional **correct** code for this rule with `{ allowAny: true }`:
-
-```ts
-const user = JSON.parse('{ "name": "foo" }');
-const msg1 = `arg = ${user.name}`;
-const msg2 = `arg = ${user.name || 'the user with no name'}`;
-```
-
-### `allowNullish`
-
-Examples of additional **correct** code for this rule with `{ allowNullish: true }`:
-
-```ts
-const arg = condition ? 'ok' : null;
-const msg1 = `arg = ${arg}`;
-```
-
-### `allowRegExp`
-
-Examples of additional **correct** code for this rule with `{ allowRegExp: true }`:
-
-```ts
-const arg = new RegExp('foo');
-const msg1 = `arg = ${arg}`;
-```
-
-```ts
-const arg = /foo/;
-const msg1 = `arg = ${arg}`;
-```
-
-### `allowNever`
-
-Examples of additional **correct** code for this rule with `{ allowNever: true }`:
-
-```ts
-const arg = 'something';
-const msg1 = typeof arg === 'string' ? arg : `arg = ${arg}`;
-```
-
-## Related To
-
-- [`no-base-to-string`](./no-base-to-string.md)
-- [`restrict-plus-operands`](./restrict-plus-operands.md)

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

@@ -1,216 +0,0 @@
----
-description: 'Enforce consistent returning of awaited values.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/return-await** for documentation.
-
-Returning an awaited promise can make sense for better stack trace information as well as for consistent error handling (returned promises will not be caught in an async function try/catch).
-
-## Examples
-
-This rule builds on top of the [`eslint/no-return-await`](https://eslint.org/docs/rules/no-return-await) rule.
-It expands upon the base rule to add support for optionally requiring `return await` in certain cases.
-
-## Options
-
-```ts
-type Options = 'in-try-catch' | 'always' | 'never';
-
-const defaultOptions: Options = 'in-try-catch';
-```
-
-### `in-try-catch`
-
-Requires that a returned promise must be `await`ed in `try-catch-finally` blocks, and disallows it elsewhere.
-Specifically:
-
-- if you `return` a promise within a `try`, then it must be `await`ed.
-- if you `return` a promise within a `catch`, and there **_is no_** `finally`, then it **_must not_** be `await`ed.
-- if you `return` a promise within a `catch`, and there **_is a_** `finally`, then it **_must_** be `await`ed.
-- if you `return` a promise within a `finally`, then it **_must not_** be `await`ed.
-
-Examples of code with `in-try-catch`:
-
-<!--tabs-->
-
-#### ❌ Incorrect
-
-```ts
-async function invalidInTryCatch1() {
-  try {
-    return Promise.resolve('try');
-  } catch (e) {}
-}
-
-async function invalidInTryCatch2() {
-  try {
-    throw new Error('error');
-  } catch (e) {
-    return await Promise.resolve('catch');
-  }
-}
-
-async function invalidInTryCatch3() {
-  try {
-    throw new Error('error');
-  } catch (e) {
-    return Promise.resolve('catch');
-  } finally {
-    console.log('cleanup');
-  }
-}
-
-async function invalidInTryCatch4() {
-  try {
-    throw new Error('error');
-  } catch (e) {
-    throw new Error('error2');
-  } finally {
-    return await Promise.resolve('finally');
-  }
-}
-
-async function invalidInTryCatch5() {
-  return await Promise.resolve('try');
-}
-
-async function invalidInTryCatch6() {
-  return await 'value';
-}
-```
-
-#### ✅ Correct
-
-```ts
-async function validInTryCatch1() {
-  try {
-    return await Promise.resolve('try');
-  } catch (e) {}
-}
-
-async function validInTryCatch2() {
-  try {
-    throw new Error('error');
-  } catch (e) {
-    return Promise.resolve('catch');
-  }
-}
-
-async function validInTryCatch3() {
-  try {
-    throw new Error('error');
-  } catch (e) {
-    return await Promise.resolve('catch');
-  } finally {
-    console.log('cleanup');
-  }
-}
-
-async function validInTryCatch4() {
-  try {
-    throw new Error('error');
-  } catch (e) {
-    throw new Error('error2');
-  } finally {
-    return Promise.resolve('finally');
-  }
-}
-
-async function validInTryCatch5() {
-  return Promise.resolve('try');
-}
-
-async function validInTryCatch6() {
-  return 'value';
-}
-```
-
-### `always`
-
-Requires that all returned promises are `await`ed.
-
-Examples of code with `always`:
-
-<!--tabs-->
-
-#### ❌ Incorrect
-
-```ts
-async function invalidAlways1() {
-  try {
-    return Promise.resolve('try');
-  } catch (e) {}
-}
-
-async function invalidAlways2() {
-  return Promise.resolve('try');
-}
-
-async function invalidAlways3() {
-  return await 'value';
-}
-```
-
-#### ✅ Correct
-
-```ts
-async function validAlways1() {
-  try {
-    return await Promise.resolve('try');
-  } catch (e) {}
-}
-
-async function validAlways2() {
-  return await Promise.resolve('try');
-}
-
-async function validAlways3() {
-  return 'value';
-}
-```
-
-### `never`
-
-Disallows all `await`ing any returned promises.
-
-Examples of code with `never`:
-
-<!--tabs-->
-
-#### ❌ Incorrect
-
-```ts
-async function invalidNever1() {
-  try {
-    return await Promise.resolve('try');
-  } catch (e) {}
-}
-
-async function invalidNever2() {
-  return await Promise.resolve('try');
-}
-
-async function invalidNever3() {
-  return await 'value';
-}
-```
-
-#### ✅ Correct
-
-```ts
-async function validNever1() {
-  try {
-    return Promise.resolve('try');
-  } catch (e) {}
-}
-
-async function validNever2() {
-  return Promise.resolve('try');
-}
-
-async function validNever3() {
-  return 'value';
-}
-```