@nr1e/commons 0.1.1-alpha.0 → 0.1.2

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

@@ -1,77 +0,0 @@
----
-description: 'Enforce `includes` method over `indexOf` method.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/prefer-includes** for documentation.
-
-Prior to ES2015, `Array#indexOf` and `String#indexOf` comparisons against `-1` were the standard ways to check whether a value exists in an array or string, respectively.
-Alternatives that are easier to read and write now exist: ES2015 added `String#includes` and ES2016 added `Array#includes`.
-
-This rule reports when an `.indexOf` call can be replaced with an `.includes`.
-Additionally, this rule reports the tests of simple regular expressions in favor of `String#includes`.
-
-> This rule will report on any receiver object of an `indexOf` method call that has an `includes` method where the two methods have the same parameters.
-> Matching types include: `String`, `Array`, `ReadonlyArray`, and typed arrays.
-
-## Examples
-
-<!--tabs-->
-
-### ❌ Incorrect
-
-```ts
-const str: string;
-const array: any[];
-const readonlyArray: ReadonlyArray<any>;
-const typedArray: UInt8Array;
-const maybe: string;
-const userDefined: {
-  indexOf(x: any): number;
-  includes(x: any): boolean;
-};
-
-str.indexOf(value) !== -1;
-array.indexOf(value) !== -1;
-readonlyArray.indexOf(value) === -1;
-typedArray.indexOf(value) > -1;
-maybe?.indexOf('') !== -1;
-userDefined.indexOf(value) >= 0;
-
-/example/.test(str);
-```
-
-### ✅ Correct
-
-```ts
-const str: string;
-const array: any[];
-const readonlyArray: ReadonlyArray<any>;
-const typedArray: UInt8Array;
-const maybe: string;
-const userDefined: {
-  indexOf(x: any): number;
-  includes(x: any): boolean;
-};
-
-str.includes(value);
-array.includes(value);
-!readonlyArray.includes(value);
-typedArray.includes(value);
-maybe?.includes('');
-userDefined.includes(value);
-
-str.includes('example');
-
-// The two methods have different parameters.
-declare const mismatchExample: {
-  indexOf(x: unknown, fromIndex?: number): number;
-  includes(x: unknown): boolean;
-};
-mismatchExample.indexOf(value) >= 0;
-```
-
-## When Not To Use It
-
-If you don't want to suggest `includes`, you can safely turn this rule off.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-literal-enum-member.md

@@ -1,101 +0,0 @@
----
-description: 'Require all enum members to be literal values.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/prefer-literal-enum-member** for documentation.
-
-TypeScript allows the value of an enum member to be many different kinds of valid JavaScript expressions.
-However, because enums create their own scope whereby each enum member becomes a variable in that scope, developers are often surprised at the resultant values.
-For example:
-
-```ts
-const imOutside = 2;
-const b = 2;
-enum Foo {
-  outer = imOutside,
-  a = 1,
-  b = a,
-  c = b,
-  // does c == Foo.b == Foo.c == 1?
-  // or does c == b == 2?
-}
-```
-
-> The answer is that `Foo.c` will be `1` at runtime [[TypeScript playground](https://www.typescriptlang.org/play/#src=const%20imOutside%20%3D%202%3B%0D%0Aconst%20b%20%3D%202%3B%0D%0Aenum%20Foo%20%7B%0D%0A%20%20%20%20outer%20%3D%20imOutside%2C%0D%0A%20%20%20%20a%20%3D%201%2C%0D%0A%20%20%20%20b%20%3D%20a%2C%0D%0A%20%20%20%20c%20%3D%20b%2C%0D%0A%20%20%20%20%2F%2F%20does%20c%20%3D%3D%20Foo.b%20%3D%3D%20Foo.c%20%3D%3D%201%3F%0D%0A%20%20%20%20%2F%2F%20or%20does%20c%20%3D%3D%20b%20%3D%3D%202%3F%0D%0A%7D)].
-
-Therefore, it's often better to prevent unexpected results in code by requiring the use of literal values as enum members.
-This rule reports when an enum member is given a value that is not a literal.
-
-## Examples
-
-<!--tabs-->
-
-### ❌ Incorrect
-
-```ts
-const str = 'Test';
-enum Invalid {
-  A = str, // Variable assignment
-  B = {}, // Object assignment
-  C = `A template literal string`, // Template literal
-  D = new Set(1, 2, 3), // Constructor in assignment
-  E = 2 + 2, // Expression assignment
-}
-```
-
-### ✅ Correct
-
-```ts
-enum Valid {
-  A,
-  B = 'TestStr', // A regular string
-  C = 4, // A number
-  D = null,
-  E = /some_regex/,
-}
-```
-
-<!--/tabs-->
-
-## Options
-
-- `allowBitwiseExpressions` set to `true` will allow you to use bitwise expressions in enum initializer (Default: `false`).
-
-Examples of code for the `{ "allowBitwiseExpressions": true }` option:
-
-<!--tabs-->
-
-### ❌ Incorrect
-
-```ts
-const x = 1;
-enum Foo {
-  A = x << 0,
-  B = x >> 0,
-  C = x >>> 0,
-  D = x | 0,
-  E = x & 0,
-  F = x ^ 0,
-  G = ~x,
-}
-```
-
-### ✅ Correct
-
-```ts
-enum Foo {
-  A = 1 << 0,
-  B = 1 >> 0,
-  C = 1 >>> 0,
-  D = 1 | 0,
-  E = 1 & 0,
-  F = 1 ^ 0,
-  G = ~1,
-}
-```
-
-## When Not To Use It
-
-If you want use anything other than simple literals as an enum value.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-namespace-keyword.md

@@ -1,47 +0,0 @@
----
-description: 'Require using `namespace` keyword over `module` keyword to declare custom TypeScript modules.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/prefer-namespace-keyword** for documentation.
-
-TypeScript historically allowed a form of code organization called "custom modules" (`module Example {}`), later renamed to "namespaces" (`namespace Example`).
-
-Namespaces are an outdated way to organize TypeScript code.
-ES2015 module syntax is now preferred (`import`/`export`).
-
-For projects still using custom modules / namespaces, it's preferred to refer to them as namespaces.
-This rule reports when the `module` keyword is used instead of `namespace`.
-
-> This rule does not report on the use of TypeScript module declarations to describe external APIs (`declare module 'foo' {}`).
-
-## Examples
-
-<!--tabs-->
-
-### ❌ Incorrect
-
-```ts
-module Example {}
-```
-
-### ✅ Correct
-
-```ts
-namespace Example {}
-
-declare module 'foo' {}
-```
-
-<!--/tabs-->
-
-## When Not To Use It
-
-If you are using the ES2015 module syntax, then you will not need this rule.
-
-## Further Reading
-
-- [Modules](https://www.typescriptlang.org/docs/handbook/modules.html)
-- [Namespaces](https://www.typescriptlang.org/docs/handbook/namespaces.html)
-- [Namespaces and Modules](https://www.typescriptlang.org/docs/handbook/namespaces-and-modules.html)

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-nullish-coalescing.md

@@ -1,164 +0,0 @@
----
-description: 'Enforce using the nullish coalescing operator instead of logical chaining.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/prefer-nullish-coalescing** for documentation.
-
-The `??` nullish coalescing runtime operator allows providing a default value when dealing with `null` or `undefined`.
-Because the nullish coalescing operator _only_ coalesces when the original value is `null` or `undefined`, it is much safer than relying upon logical OR operator chaining `||`, which coalesces on any _falsy_ value.
-
-This rule reports when an `||` operator can be safely replaced with a `??`.
-
-:::caution
-This rule will not work as expected if [`strictNullChecks`](https://www.typescriptlang.org/tsconfig#strictNullChecks) is not enabled.
-:::
-
-## Options
-
-### `ignoreTernaryTests`
-
-Setting this option to `true` (the default) will cause the rule to ignore any ternary expressions that could be simplified by using the nullish coalescing operator.
-
-Incorrect code for `ignoreTernaryTests: false`, and correct code for `ignoreTernaryTests: true`:
-
-```ts
-const foo: any = 'bar';
-foo !== undefined && foo !== null ? foo : 'a string';
-foo === undefined || foo === null ? 'a string' : foo;
-foo == undefined ? 'a string' : foo;
-foo == null ? 'a string' : foo;
-
-const foo: string | undefined = 'bar';
-foo !== undefined ? foo : 'a string';
-foo === undefined ? 'a string' : foo;
-
-const foo: string | null = 'bar';
-foo !== null ? foo : 'a string';
-foo === null ? 'a string' : foo;
-```
-
-Correct code for `ignoreTernaryTests: false`:
-
-```ts
-const foo: any = 'bar';
-foo ?? 'a string';
-foo ?? 'a string';
-foo ?? 'a string';
-foo ?? 'a string';
-
-const foo: string | undefined = 'bar';
-foo ?? 'a string';
-foo ?? 'a string';
-
-const foo: string | null = 'bar';
-foo ?? 'a string';
-foo ?? 'a string';
-```
-
-### `ignoreConditionalTests`
-
-Setting this option to `true` (the default) will cause the rule to ignore any cases that are located within a conditional test.
-
-Generally expressions within conditional tests intentionally use the falsy fallthrough behavior of the logical or operator, meaning that fixing the operator to the nullish coalesce operator could cause bugs.
-
-If you're looking to enforce stricter conditional tests, you should consider using the `strict-boolean-expressions` rule.
-
-Incorrect code for `ignoreConditionalTests: false`, and correct code for `ignoreConditionalTests: true`:
-
-```ts
-declare const a: string | null;
-declare const b: string | null;
-
-if (a || b) {
-}
-while (a || b) {}
-do {} while (a || b);
-for (let i = 0; a || b; i += 1) {}
-a || b ? true : false;
-```
-
-Correct code for `ignoreConditionalTests: false`:
-
-```ts
-declare const a: string | null;
-declare const b: string | null;
-
-if (a ?? b) {
-}
-while (a ?? b) {}
-do {} while (a ?? b);
-for (let i = 0; a ?? b; i += 1) {}
-a ?? b ? true : false;
-```
-
-### `ignoreMixedLogicalExpressions`
-
-Setting this option to `true` (the default) will cause the rule to ignore any logical or expressions that are part of a mixed logical expression (with `&&`).
-
-Generally expressions within mixed logical expressions intentionally use the falsy fallthrough behavior of the logical or operator, meaning that fixing the operator to the nullish coalesce operator could cause bugs.
-
-If you're looking to enforce stricter conditional tests, you should consider using the `strict-boolean-expressions` rule.
-
-Incorrect code for `ignoreMixedLogicalExpressions: false`, and correct code for `ignoreMixedLogicalExpressions: true`:
-
-```ts
-declare const a: string | null;
-declare const b: string | null;
-declare const c: string | null;
-declare const d: string | null;
-
-a || (b && c);
-(a && b) || c || d;
-a || (b && c) || d;
-a || (b && c && d);
-```
-
-Correct code for `ignoreMixedLogicalExpressions: false`:
-
-```ts
-declare const a: string | null;
-declare const b: string | null;
-declare const c: string | null;
-declare const d: string | null;
-
-a ?? (b && c);
-(a && b) ?? c ?? d;
-a ?? (b && c) ?? d;
-a ?? (b && c && d);
-```
-
-**_NOTE:_** Errors for this specific case will be presented as suggestions (see below), instead of fixes. This is because it is not always safe to automatically convert `||` to `??` within a mixed logical expression, as we cannot tell the intended precedence of the operator. Note that by design, `??` requires parentheses when used with `&&` or `||` in the same expression.
-
-### `ignorePrimitives`
-
-If you would like to ignore certain primitive types that can be falsy then you may pass an object containing a boolean value for each primitive:
-
-- `string: true`, ignores `null` or `undefined` unions with `string` (default: false).
-- `number: true`, ignores `null` or `undefined` unions with `number` (default: false).
-- `bigint: true`, ignores `null` or `undefined` unions with `bigint` (default: false).
-- `boolean: true`, ignores `null` or `undefined` unions with `boolean` (default: false).
-
-Incorrect code for `ignorePrimitives: { string: true }`, and correct code for `ignorePrimitives: { string: false }`:
-
-```ts
-const foo: string | undefined = 'bar';
-foo || 'a string';
-```
-
-Correct code for `ignorePrimitives: { string: true }`:
-
-```ts
-const foo: string | undefined = 'bar';
-foo ?? 'a string';
-```
-
-## When Not To Use It
-
-If you are not using TypeScript 3.7 (or greater), then you will not be able to use this rule, as the operator is not supported.
-
-## Further Reading
-
-- [TypeScript 3.7 Release Notes](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html)
-- [Nullish Coalescing Operator Proposal](https://github.com/tc39/proposal-nullish-coalescing/)

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-optional-chain.md

@@ -1,71 +0,0 @@
----
-description: 'Enforce using concise optional chain expressions instead of chained logical ands, negated logical ors, or empty objects.'
----
-
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/prefer-optional-chain** for documentation.
-
-`?.` optional chain expressions provide `undefined` if an object is `null` or `undefined`.
-Because the optional chain operator _only_ chains when the property value is `null` or `undefined`, it is much safer than relying upon logical AND operator chaining `&&`; which chains on any _truthy_ value.
-It is also often less code to use `?.` optional chaining than `&&` truthiness checks.
-
-This rule reports on code where an `&&` operator can be safely replaced with `?.` optional chaining.
-
-## Examples
-
-<!--tabs-->
-
-### ❌ Incorrect
-
-```ts
-foo && foo.a && foo.a.b && foo.a.b.c;
-foo && foo['a'] && foo['a'].b && foo['a'].b.c;
-foo && foo.a && foo.a.b && foo.a.b.method && foo.a.b.method();
-
-// With empty objects
-(((foo || {}).a || {}).b || {}).c;
-(((foo || {})['a'] || {}).b || {}).c;
-
-// With negated `or`s
-!foo || !foo.bar;
-!foo || !foo[bar];
-!foo || !foo.bar || !foo.bar.baz || !foo.bar.baz();
-
-// this rule also supports converting chained strict nullish checks:
-foo &&
-  foo.a != null &&
-  foo.a.b !== null &&
-  foo.a.b.c != undefined &&
-  foo.a.b.c.d !== undefined &&
-  foo.a.b.c.d.e;
-```
-
-### ✅ Correct
-
-```ts
-foo?.a?.b?.c;
-foo?.['a']?.b?.c;
-foo?.a?.b?.method?.();
-
-foo?.a?.b?.c?.d?.e;
-
-!foo?.bar;
-!foo?.[bar];
-!foo?.bar?.baz?.();
-```
-
-<!--/tabs-->
-
-:::note
-There are a few edge cases where this rule will false positive. Use your best judgement when evaluating reported errors.
-:::
-
-## When Not To Use It
-
-If you don't mind using more explicit `&&`s, you don't need this rule.
-
-## Further Reading
-
-- [TypeScript 3.7 Release Notes](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html)
-- [Optional Chaining Proposal](https://github.com/tc39/proposal-optional-chaining/)