@nr1e/commons 0.1.0 → 0.1.1-alpha.0

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/explicit-member-accessibility.md

@@ -0,0 +1,331 @@
+---
+description: 'Require explicit accessibility modifiers on class properties and methods.'
+---
+
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/explicit-member-accessibility** for documentation.
+
+TypeScript allows placing explicit `public`, `protected`, and `private` accessibility modifiers in front of class members.
+The modifiers exist solely in the type system and just server to describe who is allowed to access those members.
+
+Leaving off accessibility modifiers makes for less code to read and write.
+Members are `public` by default.
+
+However, adding in explicit accessibility modifiers can be helpful in codebases with many classes for enforcing proper privacy of members.
+Some developers also find it preferable for code readability to keep member publicity explicit.
+
+## Examples
+
+This rule aims to make code more readable and explicit about who can use
+which properties.
+
+## Options
+
+### Configuring in a mixed JS/TS codebase
+
+If you are working on a codebase within which you lint non-TypeScript code (i.e. `.js`/`.mjs`/`.cjs`/`.jsx`), you should ensure that you should use [ESLint `overrides`](https://eslint.org/docs/user-guide/configuring#disabling-rules-only-for-a-group-of-files) to only enable the rule on `.ts`/`.mts`/`.cts`/`.tsx` files. If you don't, then you will get unfixable lint errors reported within `.js`/`.mjs`/`.cjs`/`.jsx` files.
+
+```jsonc
+{
+  "rules": {
+    // disable the rule for all files
+    "@typescript-eslint/explicit-member-accessibility": "off"
+  },
+  "overrides": [
+    {
+      // enable the rule specifically for TypeScript files
+      "files": ["*.ts", "*.mts", "*.cts", "*.tsx"],
+      "rules": {
+        "@typescript-eslint/explicit-member-accessibility": "error"
+      }
+    }
+  ]
+}
+```
+
+### `accessibility`
+
+This rule in its default state requires no configuration and will enforce that every class member has an accessibility modifier. If you would like to allow for some implicit public members then you have the following options:
+
+```ts
+{
+  accessibility: 'explicit',
+  overrides: {
+    accessors: 'explicit',
+    constructors: 'no-public',
+    methods: 'explicit',
+    properties: 'off',
+    parameterProperties: 'explicit'
+  }
+}
+```
+
+Note the above is an example of a possible configuration you could use - it is not the default configuration.
+
+The following patterns are considered incorrect code if no options are provided:
+
+```ts
+class Animal {
+  constructor(name) {
+    // No accessibility modifier
+    this.animalName = name;
+  }
+  animalName: string; // No accessibility modifier
+  get name(): string {
+    // No accessibility modifier
+    return this.animalName;
+  }
+  set name(value: string) {
+    // No accessibility modifier
+    this.animalName = value;
+  }
+  walk() {
+    // method
+  }
+}
+```
+
+The following patterns are considered correct with the default options `{ accessibility: 'explicit' }`:
+
+```ts
+class Animal {
+  public constructor(public breed, name) {
+    // Parameter property and constructor
+    this.animalName = name;
+  }
+  private animalName: string; // Property
+  get name(): string {
+    // get accessor
+    return this.animalName;
+  }
+  set name(value: string) {
+    // set accessor
+    this.animalName = value;
+  }
+  public walk() {
+    // method
+  }
+}
+```
+
+The following patterns are considered incorrect with the accessibility set to **no-public** `[{ accessibility: 'no-public' }]`:
+
+```ts
+class Animal {
+  public constructor(public breed, name) {
+    // Parameter property and constructor
+    this.animalName = name;
+  }
+  public animalName: string; // Property
+  public get name(): string {
+    // get accessor
+    return this.animalName;
+  }
+  public set name(value: string) {
+    // set accessor
+    this.animalName = value;
+  }
+  public walk() {
+    // method
+  }
+}
+```
+
+The following patterns are considered correct with the accessibility set to **no-public** `[{ accessibility: 'no-public' }]`:
+
+```ts
+class Animal {
+  constructor(protected breed, name) {
+    // Parameter property and constructor
+    this.name = name;
+  }
+  private animalName: string; // Property
+  get name(): string {
+    // get accessor
+    return this.animalName;
+  }
+  private set name(value: string) {
+    // set accessor
+    this.animalName = value;
+  }
+  protected walk() {
+    // method
+  }
+}
+```
+
+### Overrides
+
+There are three ways in which an override can be used.
+
+- To disallow the use of public on a given member.
+- To enforce explicit member accessibility when the root has allowed implicit public accessibility
+- To disable any checks on given member type
+
+#### Disallow the use of public on a given member
+
+e.g. `[ { overrides: { constructors: 'no-public' } } ]`
+
+The following patterns are considered incorrect with the example override
+
+```ts
+class Animal {
+  public constructor(protected animalName) {}
+  public get name() {
+    return this.animalName;
+  }
+}
+```
+
+The following patterns are considered correct with the example override
+
+```ts
+class Animal {
+  constructor(protected animalName) {}
+  public get name() {
+    return this.animalName;
+  }
+}
+```
+
+#### Require explicit accessibility for a given member
+
+e.g. `[ { accessibility: 'no-public', overrides: { properties: 'explicit' } } ]`
+
+The following patterns are considered incorrect with the example override
+
+```ts
+class Animal {
+  constructor(protected animalName) {}
+  get name() {
+    return this.animalName;
+  }
+  protected set name(value: string) {
+    this.animalName = value;
+  }
+  legs: number;
+  private hasFleas: boolean;
+}
+```
+
+The following patterns are considered correct with the example override
+
+```ts
+class Animal {
+  constructor(protected animalName) {}
+  get name() {
+    return this.animalName;
+  }
+  protected set name(value: string) {
+    this.animalName = value;
+  }
+  public legs: number;
+  private hasFleas: boolean;
+}
+```
+
+e.g. `[ { accessibility: 'off', overrides: { parameterProperties: 'explicit' } } ]`
+
+The following code is considered incorrect with the example override
+
+```ts
+class Animal {
+  constructor(readonly animalName: string) {}
+}
+```
+
+The following code patterns are considered correct with the example override
+
+```ts
+class Animal {
+  constructor(public readonly animalName: string) {}
+}
+
+class Animal {
+  constructor(public animalName: string) {}
+}
+
+class Animal {
+  constructor(animalName: string) {}
+}
+```
+
+e.g. `[ { accessibility: 'off', overrides: { parameterProperties: 'no-public' } } ]`
+
+The following code is considered incorrect with the example override
+
+```ts
+class Animal {
+  constructor(public readonly animalName: string) {}
+}
+```
+
+The following code is considered correct with the example override
+
+```ts
+class Animal {
+  constructor(public animalName: string) {}
+}
+```
+
+#### Disable any checks on given member type
+
+e.g. `[{ overrides: { accessors : 'off' } } ]`
+
+As no checks on the overridden member type are performed all permutations of visibility are permitted for that member type
+
+The follow pattern is considered incorrect for the given configuration
+
+```ts
+class Animal {
+  constructor(protected animalName) {}
+  public get name() {
+    return this.animalName;
+  }
+  get legs() {
+    return this.legCount;
+  }
+}
+```
+
+The following patterns are considered correct with the example override
+
+```ts
+class Animal {
+  public constructor(protected animalName) {}
+  public get name() {
+    return this.animalName;
+  }
+  get legs() {
+    return this.legCount;
+  }
+}
+```
+
+### Except specific methods
+
+If you want to ignore some specific methods, you can do it by specifying method names. Note that this option does not care for the context, and will ignore every method with these names, which could lead to it missing some cases. You should use this sparingly.
+e.g. `[ { ignoredMethodNames: ['specificMethod', 'whateverMethod'] } ]`
+
+```ts
+class Animal {
+  get specificMethod() {
+    console.log('No error because you specified this method on option');
+  }
+  get whateverMethod() {
+    console.log('No error because you specified this method on option');
+  }
+  public get otherMethod() {
+    console.log('This method comply with this rule');
+  }
+}
+```
+
+## When Not To Use It
+
+If you think defaulting to public is a good default, then you should consider using the `no-public` setting. If you want to mix implicit and explicit public members then disable this rule.
+
+## Further Reading
+
+- TypeScript [Accessibility Modifiers Handbook Docs](https://www.typescriptlang.org/docs/handbook/2/classes.html#member-visibility)

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/explicit-module-boundary-types.md

@@ -0,0 +1,250 @@
+---
+description: "Require explicit return and argument types on exported functions' and classes' public class methods."
+---
+
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/explicit-module-boundary-types** for documentation.
+
+Explicit types for function return values and arguments makes it clear to any calling code what is the module boundary's input and output.
+Adding explicit type annotations for those types can help improve code readability.
+It can also improve TypeScript type checking performance on larger codebases.
+
+## Examples
+
+<!--tabs-->
+
+### ❌ Incorrect
+
+```ts
+// Should indicate that no value is returned (void)
+export function test() {
+  return;
+}
+
+// Should indicate that a number is returned
+export default function () {
+  return 1;
+}
+
+// Should indicate that a string is returned
+export var arrowFn = () => 'test';
+
+// All arguments should be typed
+export var arrowFn = (arg): string => `test ${arg}`;
+export var arrowFn = (arg: any): string => `test ${arg}`;
+
+export class Test {
+  // Should indicate that no value is returned (void)
+  method() {
+    return;
+  }
+}
+```
+
+### ✅ Correct
+
+```ts
+// Function is not exported
+function test() {
+  return;
+}
+
+// A return value of type number
+export var fn = function (): number {
+  return 1;
+};
+
+// A return value of type string
+export var arrowFn = (): string => 'test';
+
+// All arguments should be typed
+export var arrowFn = (arg: string): string => `test ${arg}`;
+export var arrowFn = (arg: unknown): string => `test ${arg}`;
+
+// Class is not exported
+class Test {
+  method() {
+    return;
+  }
+}
+```
+
+## Options
+
+### Configuring in a mixed JS/TS codebase
+
+If you are working on a codebase within which you lint non-TypeScript code (i.e. `.js`/`.mjs`/`.cjs`/`.jsx`), you should ensure that you should use [ESLint `overrides`](https://eslint.org/docs/user-guide/configuring#disabling-rules-only-for-a-group-of-files) to only enable the rule on `.ts`/`.mts`/`.cts`/`.tsx` files. If you don't, then you will get unfixable lint errors reported within `.js`/`.mjs`/`.cjs`/`.jsx` files.
+
+```jsonc
+{
+  "rules": {
+    // disable the rule for all files
+    "@typescript-eslint/explicit-module-boundary-types": "off"
+  },
+  "overrides": [
+    {
+      // enable the rule specifically for TypeScript files
+      "files": ["*.ts", "*.mts", "*.cts", "*.tsx"],
+      "rules": {
+        "@typescript-eslint/explicit-module-boundary-types": "error"
+      }
+    }
+  ]
+}
+```
+
+### `allowArgumentsExplicitlyTypedAsAny`
+
+Examples of code for this rule with `{ allowArgumentsExplicitlyTypedAsAny: false }`:
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+export const func = (value: any): number => value + 1;
+```
+
+#### ✅ Correct
+
+```ts
+export const func = (value: number): number => value + 1;
+```
+
+### `allowDirectConstAssertionInArrowFunctions`
+
+Examples of code for this rule with `{ allowDirectConstAssertionInArrowFunctions: false }`:
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+export const func = (value: number) => ({ type: 'X', value });
+export const foo = () => ({
+  bar: true,
+});
+export const bar = () => 1;
+```
+
+#### ✅ Correct
+
+```ts
+export const func = (value: number) => ({ type: 'X', value } as const);
+export const foo = () =>
+  ({
+    bar: true,
+  } as const);
+export const bar = () => 1 as const;
+```
+
+### `allowedNames`
+
+You may pass function/method names you would like this rule to ignore, like so:
+
+```json
+{
+  "@typescript-eslint/explicit-module-boundary-types": [
+    "error",
+    {
+      "allowedNames": ["ignoredFunctionName", "ignoredMethodName"]
+    }
+  ]
+}
+```
+
+### `allowHigherOrderFunctions`
+
+Examples of code for this rule with `{ allowHigherOrderFunctions: false }`:
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+export const arrowFn = () => () => {};
+
+export function fn() {
+  return function () {};
+}
+
+export function foo(outer: string) {
+  return function (inner: string) {};
+}
+```
+
+#### ✅ Correct
+
+```ts
+export const arrowFn = () => (): void => {};
+
+export function fn() {
+  return function (): void {};
+}
+
+export function foo(outer: string) {
+  return function (inner: string): void {};
+}
+```
+
+### `allowTypedFunctionExpressions`
+
+Examples of code for this rule with `{ allowTypedFunctionExpressions: false }`:
+
+<!--tabs-->
+
+#### ❌ Incorrect
+
+```ts
+export let arrowFn = () => 'test';
+
+export let funcExpr = function () {
+  return 'test';
+};
+
+export let objectProp = {
+  foo: () => 1,
+};
+
+export const foo = bar => {};
+```
+
+#### ✅ Correct
+
+```ts
+type FuncType = () => string;
+
+export let arrowFn: FuncType = () => 'test';
+
+export let funcExpr: FuncType = function () {
+  return 'test';
+};
+
+export let asTyped = (() => '') as () => string;
+export let castTyped = <() => string>(() => '');
+
+interface ObjectType {
+  foo(): number;
+}
+export let objectProp: ObjectType = {
+  foo: () => 1,
+};
+export let objectPropAs = {
+  foo: () => 1,
+} as ObjectType;
+export let objectPropCast = <ObjectType>{
+  foo: () => 1,
+};
+
+type FooType = (bar: string) => void;
+export const foo: FooType = bar => {};
+```
+
+## When Not To Use It
+
+If you wish to make sure all functions have explicit return types, as opposed to only the module boundaries, you can use [explicit-function-return-type](./explicit-function-return-type.md)
+
+## Further Reading
+
+- TypeScript [Functions](https://www.typescriptlang.org/docs/handbook/functions.html#function-types)

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/func-call-spacing.md

@@ -0,0 +1,12 @@
+---
+description: 'Require or disallow spacing between function identifiers and their invocations.'
+---
+
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/func-call-spacing** for documentation.
+
+## Examples
+
+This rule extends the base [`eslint/func-call-spacing`](https://eslint.org/docs/rules/func-call-spacing) rule.
+It adds support for generic type parameters on function calls.

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

@@ -0,0 +1,20 @@
+---
+description: 'Enforce consistent indentation.'
+---
+
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/indent** for documentation.
+
+## Warning
+
+:::warning
+
+Please read [Issue #1824: Problems with the indent rule](https://github.com/typescript-eslint/typescript-eslint/issues/1824) before using this rule!
+
+:::
+
+## Examples
+
+This rule extends the base [`eslint/indent`](https://eslint.org/docs/rules/indent) rule.
+It adds support for TypeScript nodes.

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

@@ -0,0 +1,12 @@
+---
+description: 'Require or disallow initialization in variable declarations.'
+---
+
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/init-declarations** for documentation.
+
+## Examples
+
+This rule extends the base [`eslint/init-declarations`](https://eslint.org/docs/rules/init-declarations) rule.
+It adds support for TypeScript's `declare` variables.

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

@@ -0,0 +1,12 @@
+---
+description: 'Enforce consistent spacing between property names and type annotations in types and interfaces.'
+---
+
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/key-spacing** for documentation.
+
+## Examples
+
+This rule extends the base [`eslint/key-spacing`](https://eslint.org/docs/rules/key-spacing) rule.
+This version adds support for type annotations on interfaces, classes and type literals properties.

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

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

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/lines-around-comment.md

@@ -0,0 +1,37 @@
+---
+description: 'Require empty lines around comments.'
+---
+
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/lines-around-comment** for documentation.
+
+## Rule Details
+
+This rule extends the base [`eslint/lines-around-comment`](https://eslint.org/docs/rules/lines-around-comment) rule.
+It adds support for TypeScript syntax.
+
+See the [ESLint documentation](https://eslint.org/docs/rules/lines-around-comment) for more details on the `comma-dangle` rule.
+
+## Rule Changes
+
+```jsonc
+{
+  // note you must disable the base rule as it can report incorrect errors
+  "lines-around-comment": "off",
+  "@typescript-eslint/lines-around-comment": ["error"]
+}
+```
+
+## Options
+
+In addition to the options supported by the `lines-around-comment` rule in ESLint core, the rule adds the following options:
+
+- `allowEnumEnd: true` doesn't require a blank line after an enum body block end
+- `allowEnumStart: true` doesn't require a blank line before an enum body block start
+- `allowInterfaceEnd: true` doesn't require a blank line before an interface body block end
+- `allowInterfaceStart: true` doesn't require a blank line after an interface body block start
+- `allowModuleEnd: true` doesn't require a blank line before a module body block end
+- `allowModuleStart: true` doesn't require a blank line after a module body block start
+- `allowTypeEnd: true` doesn't require a blank line before a type literal block end
+- `allowTypeStart: true` doesn't require a blank line after a type literal block start