xo 0.46.1 → 0.46.2

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-parameter-properties.md

@@ -1,373 +0,0 @@
-# Disallow the use of parameter properties in class constructors (`no-parameter-properties`)
-
-Parameter properties can be confusing to those new to TypeScript as they are less explicit than other ways
-of declaring and initializing class members.
-
-## Rule Details
-
-This rule disallows the use of parameter properties in constructors, forcing the user to explicitly
-declare all properties in the class.
-
-## Options
-
-This rule, in its default state, does not require any argument and would completely disallow the use of parameter properties.
-If you would like to allow certain types of parameter properties then you may pass an object with the following options:
-
-- `allows`, an array containing one or more of the allowed modifiers. Valid values are:
-  - `readonly`, allows **readonly** parameter properties.
-  - `private`, allows **private** parameter properties.
-  - `protected`, allows **protected** parameter properties.
-  - `public`, allows **public** parameter properties.
-  - `private readonly`, allows **private readonly** parameter properties.
-  - `protected readonly`, allows **protected readonly** parameter properties.
-  - `public readonly`, allows **public readonly** parameter properties.
-
-### default
-
-Examples of **incorrect** code for this rule with no options at all:
-
-```ts
-class Foo {
-  constructor(readonly name: string) {}
-}
-
-class Foo {
-  constructor(private name: string) {}
-}
-
-class Foo {
-  constructor(protected name: string) {}
-}
-
-class Foo {
-  constructor(public name: string) {}
-}
-
-class Foo {
-  constructor(private readonly name: string) {}
-}
-
-class Foo {
-  constructor(protected readonly name: string) {}
-}
-
-class Foo {
-  constructor(public readonly name: string) {}
-}
-```
-
-Examples of **correct** code for this rule with no options at all:
-
-```ts
-class Foo {
-  constructor(name: string) {}
-}
-```
-
-### readonly
-
-Examples of **incorrect** code for the `{ "allows": ["readonly"] }` options:
-
-```ts
-class Foo {
-  constructor(private name: string) {}
-}
-
-class Foo {
-  constructor(protected name: string) {}
-}
-
-class Foo {
-  constructor(public name: string) {}
-}
-
-class Foo {
-  constructor(private readonly name: string) {}
-}
-
-class Foo {
-  constructor(protected readonly name: string) {}
-}
-
-class Foo {
-  constructor(public readonly name: string) {}
-}
-```
-
-Examples of **correct** code for the `{ "allows": ["readonly"] }` options:
-
-```ts
-class Foo {
-  constructor(name: string) {}
-}
-
-class Foo {
-  constructor(readonly name: string) {}
-}
-```
-
-### private
-
-Examples of **incorrect** code for the `{ "allows": ["private"] }` options:
-
-```ts
-class Foo {
-  constructor(readonly name: string) {}
-}
-
-class Foo {
-  constructor(protected name: string) {}
-}
-
-class Foo {
-  constructor(public name: string) {}
-}
-
-class Foo {
-  constructor(private readonly name: string) {}
-}
-
-class Foo {
-  constructor(protected readonly name: string) {}
-}
-
-class Foo {
-  constructor(public readonly name: string) {}
-}
-```
-
-Examples of **correct** code for the `{ "allows": ["private"] }` options:
-
-```ts
-class Foo {
-  constructor(name: string) {}
-}
-
-class Foo {
-  constructor(private name: string) {}
-}
-```
-
-### protected
-
-Examples of **incorrect** code for the `{ "allows": ["protected"] }` options:
-
-```ts
-class Foo {
-  constructor(readonly name: string) {}
-}
-
-class Foo {
-  constructor(private name: string) {}
-}
-
-class Foo {
-  constructor(public name: string) {}
-}
-
-class Foo {
-  constructor(private readonly name: string) {}
-}
-
-class Foo {
-  constructor(protected readonly name: string) {}
-}
-
-class Foo {
-  constructor(public readonly name: string) {}
-}
-```
-
-Examples of **correct** code for the `{ "allows": ["protected"] }` options:
-
-```ts
-class Foo {
-  constructor(name: string) {}
-}
-
-class Foo {
-  constructor(protected name: string) {}
-}
-```
-
-### public
-
-Examples of **incorrect** code for the `{ "allows": ["public"] }` options:
-
-```ts
-class Foo {
-  constructor(readonly name: string) {}
-}
-
-class Foo {
-  constructor(private name: string) {}
-}
-
-class Foo {
-  constructor(protected name: string) {}
-}
-
-class Foo {
-  constructor(private readonly name: string) {}
-}
-
-class Foo {
-  constructor(protected readonly name: string) {}
-}
-
-class Foo {
-  constructor(public readonly name: string) {}
-}
-```
-
-Examples of **correct** code for the `{ "allows": ["public"] }` options:
-
-```ts
-class Foo {
-  constructor(name: string) {}
-}
-
-class Foo {
-  constructor(public name: string) {}
-}
-```
-
-### private readonly
-
-Examples of **incorrect** code for the `{ "allows": ["private readonly"] }` options:
-
-```ts
-class Foo {
-  constructor(readonly name: string) {}
-}
-
-class Foo {
-  constructor(private name: string) {}
-}
-
-class Foo {
-  constructor(protected name: string) {}
-}
-
-class Foo {
-  constructor(public name: string) {}
-}
-
-class Foo {
-  constructor(protected readonly name: string) {}
-}
-
-class Foo {
-  constructor(public readonly name: string) {}
-}
-```
-
-Examples of **correct** code for the `{ "allows": ["private readonly"] }` options:
-
-```ts
-class Foo {
-  constructor(name: string) {}
-}
-
-class Foo {
-  constructor(private readonly name: string) {}
-}
-```
-
-### protected readonly
-
-Examples of **incorrect** code for the `{ "allows": ["protected readonly"] }` options:
-
-```ts
-class Foo {
-  constructor(readonly name: string) {}
-}
-
-class Foo {
-  constructor(private name: string) {}
-}
-
-class Foo {
-  constructor(protected name: string) {}
-}
-
-class Foo {
-  constructor(public name: string) {}
-}
-
-class Foo {
-  constructor(private readonly name: string) {}
-}
-
-class Foo {
-  constructor(public readonly name: string) {}
-}
-```
-
-Examples of **correct** code for the `{ "allows": ["protected readonly"] }` options:
-
-```ts
-class Foo {
-  constructor(name: string) {}
-}
-
-class Foo {
-  constructor(protected readonly name: string) {}
-}
-```
-
-### public readonly
-
-Examples of **incorrect** code for the `{ "allows": ["public readonly"] }` options:
-
-```ts
-class Foo {
-  constructor(readonly name: string) {}
-}
-
-class Foo {
-  constructor(private name: string) {}
-}
-
-class Foo {
-  constructor(protected name: string) {}
-}
-
-class Foo {
-  constructor(public name: string) {}
-}
-
-class Foo {
-  constructor(private readonly name: string) {}
-}
-
-class Foo {
-  constructor(protected readonly name: string) {}
-}
-```
-
-Examples of **correct** code for the `{ "allows": ["public readonly"] }` options:
-
-```ts
-class Foo {
-  constructor(name: string) {}
-}
-
-class Foo {
-  constructor(public readonly name: string) {}
-}
-```
-
-## When Not To Use It
-
-If you don't care about the using parameter properties in constructors, then you will not need this rule.
-
-## Compatibility
-
-- TSLint: [no-parameter-properties](https://palantir.github.io/tslint/rules/no-parameter-properties/)
-
-## Attributes
-
-- [ ] ✅ Recommended
-- [ ] 🔧 Fixable
-- [ ] 💭 Requires type information

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

@@ -1,86 +0,0 @@
-# Disallow variable redeclaration (`no-redeclare`)
-
-## Rule Details
-
-This rule extends the base [`eslint/no-redeclare`](https://eslint.org/docs/rules/no-redeclare) rule.
-It adds support for TypeScript function overloads, and declaration merging.
-
-## How to use
-
-```jsonc
-{
-  // note you must disable the base rule as it can report incorrect errors
-  "no-redeclare": "off",
-  "@typescript-eslint/no-redeclare": ["error"]
-}
-```
-
-## Options
-
-See [`eslint/no-redeclare` options](https://eslint.org/docs/rules/no-redeclare#options).
-This rule adds the following options:
-
-```ts
-interface Options extends BaseNoRedeclareOptions {
-  ignoreDeclarationMerge?: boolean;
-}
-
-const defaultOptions: Options = {
-  ...baseNoRedeclareDefaultOptions,
-  ignoreDeclarationMerge: true,
-};
-```
-
-### `ignoreDeclarationMerge`
-
-When set to `true`, the rule will ignore declaration merges between the following sets:
-
-- interface + interface
-- namespace + namespace
-- class + interface
-- class + namespace
-- class + interface + namespace
-- function + namespace
-- enum + namespace
-
-Examples of **correct** code with `{ ignoreDeclarationMerge: true }`:
-
-```ts
-interface A {
-  prop1: 1;
-}
-interface A {
-  prop2: 2;
-}
-
-namespace Foo {
-  export const a = 1;
-}
-namespace Foo {
-  export const b = 2;
-}
-
-class Bar {}
-namespace Bar {}
-
-function Baz() {}
-namespace Baz {}
-```
-
-**Note:** Even with this option set to true, this rule will report if you name a type and a variable the same name. **_This is intentional_**.
-Declaring a variable and a type and a variable the same is usually an accident, and it can lead to hard-to-understand code.
-If you have a rare case where you're intentionally naming a type the same name as a variable, use a disable comment. For example:
-
-```ts
-type something = string;
-// eslint-disable-next-line @typescript-eslint/no-redeclare -- intentionally naming the variable the same as the type
-const something = 2;
-```
-
-<sup>Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/master/docs/rules/no-redeclare.md)</sup>
-
-## Attributes
-
-- [ ] ✅ Recommended
-- [ ] 🔧 Fixable
-- [ ] 💭 Requires type information

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

@@ -1,40 +0,0 @@
-# Disallows invocation of `require()` (`no-require-imports`)
-
-Prefer the newer ES6-style imports over `require()`.
-
-## Rule Details
-
-Examples of **incorrect** code for this rule:
-
-```ts
-var lib = require('lib');
-let lib2 = require('lib2');
-var lib5 = require('lib5'),
-  lib6 = require('lib6');
-import lib8 = require('lib8');
-```
-
-Examples of **correct** code for this rule:
-
-```ts
-import { l } from 'lib';
-var lib3 = load('not_an_import');
-var lib4 = lib2.subImport;
-var lib7 = 700;
-import lib9 = lib2.anotherSubImport;
-import lib10 from 'lib10';
-```
-
-## When Not To Use It
-
-If you don't care about TypeScript module syntax, then you will not need this rule.
-
-## Compatibility
-
-- TSLint: [no-require-imports](https://palantir.github.io/tslint/rules/no-require-imports/)
-
-## Attributes
-
-- [ ] ✅ Recommended
-- [ ] 🔧 Fixable
-- [ ] 💭 Requires type information

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-restricted-imports.md

@@ -1,70 +0,0 @@
-# Disallow specified modules when loaded by `import` (`no-restricted-imports`)
-
-## Rule Details
-
-This rule extends the base [`eslint/no-restricted-imports`](https://eslint.org/docs/rules/no-restricted-imports) rule.
-
-## How to use
-
-```jsonc
-{
-  // note you must disable the base rule as it can report incorrect errors
-  "no-restricted-imports": "off",
-  "@typescript-eslint/no-restricted-imports": "off"
-}
-```
-
-## Options
-
-See [`eslint/no-restricted-imports` options](https://eslint.org/docs/rules/no-restricted-imports#options).
-This rule adds the following options:
-
-### `allowTypeImports`
-
-(default: `false`)
-
-You can specify this option for a specific path or pattern as follows:
-
-```jsonc
-"@typescript-eslint/no-restricted-imports": ["error", {
-  "paths": [{
-    "name": "import-foo",
-    "message": "Please use import-bar instead.",
-    "allowTypeImports": true
-  }, {
-    "name": "import-baz",
-    "message": "Please use import-quux instead.",
-    "allowTypeImports": true
-  }]
-}]
-```
-
-When set to `true`, the rule will allow [Type-Only Imports](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-8.html#type-only-imports-and-export).
-
-Examples of **correct** code with the above config:
-
-```ts
-import { foo } from 'other-module';
-
-import type foo from 'import-foo';
-export type { Foo } from 'import-foo';
-
-import type baz from 'import-baz';
-export type { Baz } from 'import-baz';
-```
-
-Example of **incorrect** code with the above config:
-
-```ts
-import foo from 'import-foo';
-export { Foo } from 'import-foo';
-
-import baz from 'import-baz';
-export { Baz } from 'import-baz';
-```
-
-## Attributes
-
-- [ ] ✅ Recommended
-- [ ] 🔧 Fixable
-- [ ] 💭 Requires type information

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

@@ -1,93 +0,0 @@
-# Disallow variable declarations from shadowing variables declared in the outer scope (`no-shadow`)
-
-## Rule Details
-
-This rule extends the base [`eslint/no-shadow`](https://eslint.org/docs/rules/no-shadow) rule.
-It adds support for TypeScript's `this` parameters and global augmentation, and adds options for TypeScript features.
-
-## How to use
-
-```jsonc
-{
-  // note you must disable the base rule as it can report incorrect errors
-  "no-shadow": "off",
-  "@typescript-eslint/no-shadow": ["error"]
-}
-```
-
-## Options
-
-See [`eslint/no-shadow` options](https://eslint.org/docs/rules/no-shadow#options).
-This rule adds the following options:
-
-```ts
-interface Options extends BaseNoShadowOptions {
-  ignoreTypeValueShadow?: boolean;
-  ignoreFunctionTypeParameterNameValueShadow?: boolean;
-}
-
-const defaultOptions: Options = {
-  ...baseNoShadowDefaultOptions,
-  ignoreTypeValueShadow: true,
-  ignoreFunctionTypeParameterNameValueShadow: true,
-};
-```
-
-### `ignoreTypeValueShadow`
-
-When set to `true`, the rule will ignore the case when you name a type the same as a variable.
-
-TypeScript allows types and variables to shadow one-another. This is generally safe because you cannot use variables in type locations without a `typeof` operator, so there's little risk of confusion.
-
-Examples of **correct** code with `{ ignoreTypeValueShadow: true }`:
-
-```ts
-type Foo = number;
-const Foo = 1;
-
-interface Bar {
-  prop: number;
-}
-const Bar = 'test';
-```
-
-### `ignoreFunctionTypeParameterNameValueShadow`
-
-When set to `true`, the rule will ignore the case when you name a function type argument the same as a variable.
-
-Each of a function type's arguments creates a value variable within the scope of the function type. This is done so that you can reference the type later using the `typeof` operator:
-
-```ts
-type Func = (test: string) => typeof test;
-
-declare const fn: Func;
-const result = fn('str'); // typeof result === string
-```
-
-This means that function type arguments shadow value variable names in parent scopes:
-
-```ts
-let test = 1;
-type TestType = typeof test; // === number
-type Func = (test: string) => typeof test; // this "test" references the argument, not the variable
-
-declare const fn: Func;
-const result = fn('str'); // typeof result === string
-```
-
-If you do not use the `typeof` operator in a function type return type position, you can safely turn this option on.
-
-Examples of **correct** code with `{ ignoreFunctionTypeParameterNameValueShadow: true }`:
-
-```ts
-const test = 1;
-type Func = (test: string) => typeof test;
-```
-
-<sup>Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/master/docs/rules/no-shadow.md)</sup>
-
-## Attributes
-
-- [ ] ✅ Recommended
-- [ ] 🔧 Fixable
-- [ ] 💭 Requires type information