less 3.10.1 → 3.11.1

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-empty-function.md

@@ -0,0 +1,47 @@
+# Disallow Empty Functions (@typescript-eslint/no-empty-function)
+
+Empty functions can reduce readability because readers need to guess whether it’s intentional or not. So writing a clear comment for empty functions is a good practice.
+
+## Rule Details
+
+The `@typescript-eslint/no-empty-function` rule extends the `no-empty-function` rule from ESLint core, and adds support for handling Typescript specific code that would otherwise trigger the rule.
+
+One example of valid Typescript specific code that would otherwise trigger the `no-empty-function` rule is the use of [parameter properties](https://www.typescriptlang.org/docs/handbook/classes.html#parameter-properties) in constructor functions:
+
+```typescript
+class Person {
+  constructor(private firstName: string, private surname: string) {}
+}
+```
+
+The above code is functionally equivalent to:
+
+```typescript
+class Person {
+  private firstName: string;
+  private surname: string;
+
+  constructor(firstName: string, surname: string) {
+    this.firstName = firstName;
+    this.surname = surname;
+  }
+}
+```
+
+Parameter properties enable both the _declaration_ and _initialization_ of member properties in a single location, avoiding the boilerplate & duplication that is common when initializing member properties from parameter values in a constructor function.
+
+In these cases, although the constructor has an empty function body, it is technically valid and should not trigger an error.
+
+See the [ESLint documentation](https://eslint.org/docs/rules/no-empty-function) for more details on the `no-empty-function` rule.
+
+## Rule Changes
+
+```cjson
+{
+    // note you must disable the base rule as it can report incorrect errors
+    "no-empty-function": "off",
+    "@typescript-eslint/no-empty-function": "error"
+}
+```
+
+<sup>Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/master/docs/rules/no-empty-function.md)</sup>

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-empty-interface.md

@@ -0,0 +1,64 @@
+# Disallow the declaration of empty interfaces (no-empty-interface)
+
+An empty interface is equivalent to its supertype. If the interface does not implement a supertype, then
+the interface is equivalent to an empty object (`{}`). In both cases it can be omitted.
+
+## Rule Details
+
+This rule aims to ensure that only meaningful interfaces are declared in the code.
+
+The following patterns are considered warnings:
+
+```ts
+// an empty interface
+interface Foo {}
+
+// an interface with only one supertype (Bar === Foo)
+interface Bar extends Foo {}
+
+// an interface with an empty list of supertypes
+interface Baz {}
+```
+
+The following patterns are not warnings:
+
+```ts
+// an interface with any number of members
+interface Foo {
+  name: string;
+}
+
+// same as above
+interface Bar {
+  age: number;
+}
+
+// an interface with more than one supertype
+// in this case the interface can be used as a replacement of a union type.
+interface Baz extends Foo, Bar {}
+```
+
+### Options
+
+This rule accepts a single object option with the following default configuration:
+
+```json
+{
+  "@typescript-eslint/no-empty-interface": [
+    "error",
+    {
+      "allowSingleExtends": false
+    }
+  ]
+}
+```
+
+- `allowSingleExtends: true` will silence warnings about extending a single interface without adding additional members
+
+## When Not To Use It
+
+If you don't care about having empty/meaningless interfaces, then you will not need this rule.
+
+## Compatibility
+
+- TSLint: [no-empty-interface](https://palantir.github.io/tslint/rules/no-empty-interface/)

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-explicit-any.md

@@ -0,0 +1,165 @@
+# Disallow usage of the `any` type (no-explicit-any)
+
+Using the `any` type defeats the purpose of using TypeScript.
+When `any` is used, all compiler type checks around that value are ignored.
+
+## Rule Details
+
+This rule doesn't allow `any` types to be defined.
+It aims to keep TypeScript maximally useful.
+TypeScript has a compiler flag for `--noImplicitAny` that will prevent
+an `any` type from being implied by the compiler, but doesn't prevent
+`any` from being explicitly used.
+
+The following patterns are considered warnings:
+
+```ts
+const age: any = 'seventeen';
+```
+
+```ts
+const ages: any[] = ['seventeen'];
+```
+
+```ts
+const ages: Array<any> = ['seventeen'];
+```
+
+```ts
+function greet(): any {}
+```
+
+```ts
+function greet(): any[] {}
+```
+
+```ts
+function greet(): Array<any> {}
+```
+
+```ts
+function greet(): Array<Array<any>> {}
+```
+
+```ts
+function greet(param: Array<any>): string {}
+```
+
+```ts
+function greet(param: Array<any>): Array<any> {}
+```
+
+The following patterns are not warnings:
+
+```ts
+const age: number = 17;
+```
+
+```ts
+const ages: number[] = [17];
+```
+
+```ts
+const ages: Array<number> = [17];
+```
+
+```ts
+function greet(): string {}
+```
+
+```ts
+function greet(): string[] {}
+```
+
+```ts
+function greet(): Array<string> {}
+```
+
+```ts
+function greet(): Array<Array<string>> {}
+```
+
+```ts
+function greet(param: Array<string>): string {}
+```
+
+```ts
+function greet(param: Array<string>): Array<string> {}
+```
+
+## Options
+
+The rule accepts an options object with the following properties:
+
+```ts
+type Options = {
+  // if true, auto-fixing will be made available in which the "any" type is converted to an "unknown" type
+  fixToUnknown: boolean;
+  // specify if arrays from the rest operator are considered okay
+  ignoreRestArgs: boolean;
+};
+
+const defaults = {
+  fixToUnknown: false,
+  ignoreRestArgs: false,
+};
+```
+
+### ignoreRestArgs
+
+A boolean to specify if arrays from the rest operator are considered okay. `false` by default.
+
+Examples of **incorrect** code for the `{ "ignoreRestArgs": false }` option:
+
+```ts
+/*eslint @typescript-eslint/no-explicit-any: ["error", { "ignoreRestArgs": false }]*/
+
+function foo1(...args: any[]): void {}
+function foo2(...args: readonly any[]): void {}
+function foo3(...args: Array<any>): void {}
+function foo4(...args: ReadonlyArray<any>): void {}
+
+const bar1 = (...args: any[]): void {}
+const bar2 = (...args: readonly any[]): void {}
+const bar3 = (...args: Array<any>): void {}
+const bar4 = (...args: ReadonlyArray<any>): void {}
+
+const baz1 = function (...args: any[]) {}
+const baz2 = function (...args: readonly any[]) {}
+const baz3 = function (...args: Array<any>) {}
+const baz4 = function (...args: ReadonlyArray<any>) {}
+```
+
+Examples of **correct** code for the `{ "ignoreRestArgs": true }` option:
+
+```ts
+/*eslint @typescript-eslint/no-explicit-any: ["error", { "ignoreRestArgs": true }]*/
+
+function foo1(...args: any[]): void {}
+function foo2(...args: readonly any[]): void {}
+function foo3(...args: Array<any>): void {}
+function foo4(...args: ReadonlyArray<any>): void {}
+
+const bar1 = (...args: any[]): void {}
+const bar2 = (...args: readonly any[]): void {}
+const bar3 = (...args: Array<any>): void {}
+const bar4 = (...args: ReadonlyArray<any>): void {}
+
+const baz1 = function (...args: any[]) {}
+const baz2 = function (...args: readonly any[]) {}
+const baz3 = function (...args: Array<any>) {}
+const baz4 = function (...args: ReadonlyArray<any>) {}
+```
+
+## When Not To Use It
+
+If an unknown type or a library without typings is used
+and you want to be able to specify `any`.
+
+## Further Reading
+
+- TypeScript [any type](https://www.typescriptlang.org/docs/handbook/basic-types.html#any)
+
+## Compatibility
+
+- TSLint: [no-any](https://palantir.github.io/tslint/rules/no-any/)

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-extra-parens.md

@@ -0,0 +1,22 @@
+# disallow unnecessary parentheses (no-extra-parens)
+
+This rule restricts the use of parentheses to only where they are necessary.
+
+## Rule Details
+
+This rule extends the base [eslint/no-extra-parens](https://eslint.org/docs/rules/no-extra-parens) rule.
+It supports all options and features of the base rule plus TS type assertions.
+
+## How to use
+
+```cjson
+{
+    // note you must disable the base rule as it can report incorrect errors
+    "no-extra-parens": "off",
+    "@typescript-eslint/no-extra-parens": ["error"]
+}
+```
+
+## Options
+
+See [eslint/no-extra-parens options](https://eslint.org/docs/rules/no-extra-parens#options).

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-extraneous-class.md

@@ -0,0 +1,64 @@
+# Forbids the use of classes as namespaces (no-extraneous-class)
+
+This rule warns when a class is accidentally used as a namespace.
+
+## Rule Details
+
+From TSLint’s docs:
+
+> Users who come from a Java-style OO language may wrap their utility functions in an extra class,
+> instead of putting them at the top level.
+
+Examples of **incorrect** code for this rule:
+
+```ts
+class EmptyClass {}
+
+class ConstructorOnly {
+  constructor() {
+    foo();
+  }
+}
+
+// Use an object instead:
+class StaticOnly {
+  static version = 42;
+  static hello() {
+    console.log('Hello, world!');
+  }
+}
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+class EmptyClass extends SuperClass {}
+
+class ParameterProperties {
+  constructor(public name: string) {}
+}
+
+const StaticOnly = {
+  version: 42,
+  hello() {
+    console.log('Hello, world!');
+  },
+};
+```
+
+### Options
+
+This rule accepts a single object option.
+
+- `allowConstructorOnly: true` will silence warnings about classes containing only a constructor.
+- `allowEmpty: true` will silence warnings about empty classes.
+- `allowStaticOnly: true` will silence warnings about classes containing only static members.
+
+## When Not To Use It
+
+You can disable this rule if you don’t have anyone who would make these kinds of mistakes on your
+team or if you use classes as namespaces.
+
+## Compatibility
+
+[`no-unnecessary-class`](https://palantir.github.io/tslint/rules/no-unnecessary-class/) from TSLint

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-floating-promises.md

@@ -0,0 +1,46 @@
+# Requires Promise-like values to be handled appropriately (no-floating-promises)
+
+This rule forbids usage of Promise-like values in statements without handling
+their errors appropriately. Unhandled promises can cause several issues, such
+as improperly sequenced operations, ignored Promise rejections and more. Valid
+ways of handling a Promise-valued statement include `await`ing, returning, and
+either calling `.then()` with two arguments or `.catch()` with one argument.
+
+## Rule Details
+
+Examples of **incorrect** code for this rule:
+
+```ts
+const promise = new Promise((resolve, reject) => resolve('value'));
+promise;
+
+async function returnsPromise() {
+  return 'value';
+}
+returnsPromise().then(() => {});
+
+Promise.reject('value').catch();
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+const promise = new Promise((resolve, reject) => resolve('value'));
+await promise;
+
+async function returnsPromise() {
+  return 'value';
+}
+returnsPromise().then(() => {}, () => {});
+
+Promise.reject('value').catch(() => {});
+```
+
+## When Not To Use It
+
+If you do not use Promise-like values in your codebase or want to allow them to
+remain unhandled.
+
+## Related to
+
+- Tslint: ['no-floating-promises'](https://palantir.github.io/tslint/rules/no-floating-promises/)

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-for-in-array.md

@@ -0,0 +1,44 @@
+# Disallow iterating over an array with a for-in loop (no-for-in-array)
+
+This rule prohibits iterating over an array with a for-in loop.
+
+## Rule Details
+
+Rationale from TSLint:
+
+A for-in loop (`for (var k in o)`) iterates over the properties of an Object.
+While it is legal to use for-in loops with array types, it is not common.
+for-in will iterate over the indices of the array as strings, omitting any "holes" in
+the array.
+More common is to use for-of, which iterates over the values of an array.
+If you want to iterate over the indices, alternatives include:
+
+```js
+array.forEach((value, index) => { ... });
+for (const [index, value] of array.entries()) { ... }
+for (let i = 0; i < array.length; i++) { ... }
+```
+
+Examples of **incorrect** code for this rule:
+
+```js
+for (const x in [3, 4, 5]) {
+  console.log(x);
+}
+```
+
+Examples of **correct** code for this rule:
+
+```js
+for (const x in { a: 3, b: 4, c: 5 }) {
+  console.log(x);
+}
+```
+
+## When Not To Use It
+
+If you want to iterate through a loop using the indices in an array as strings, you can turn off this rule.
+
+## Related to
+
+- TSLint: ['no-for-in-array'](https://palantir.github.io/tslint/rules/no-for-in-array/)

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-inferrable-types.md

@@ -0,0 +1,146 @@
+# Disallows explicit type declarations for variables or parameters initialized to a number, string, or boolean. (no-inferrable-types)
+
+Explicit types where they can be easily inferred may add unnecessary verbosity.
+
+## Rule Details
+
+This rule disallows explicit type declarations on parameters, variables
+and properties where the type can be easily inferred from its value.
+
+## Options
+
+This rule accepts the following options:
+
+```ts
+interface Options {
+  ignoreParameters?: boolean;
+  ignoreProperties?: boolean;
+}
+```
+
+### Default
+
+The default options are:
+
+```JSON
+{
+  "ignoreParameters": true,
+  "ignoreProperties": true,
+}
+```
+
+With these options, the following patterns are valid:
+
+```ts
+const a = 10n;
+const a = -10n;
+const a = BigInt(10);
+const a = -BigInt(10);
+const a = false;
+const a = true;
+const a = Boolean(null);
+const a = !0;
+const a = 10;
+const a = +10;
+const a = -10;
+const a = Number('1');
+const a = +Number('1');
+const a = -Number('1');
+const a = Infinity;
+const a = +Infinity;
+const a = -Infinity;
+const a = NaN;
+const a = +NaN;
+const a = -NaN;
+const a = null;
+const a = /a/;
+const a = RegExp('a');
+const a = new RegExp('a');
+const a = 'str';
+const a = `str`;
+const a = String(1);
+const a = Symbol('a');
+const a = undefined;
+const a = void someValue;
+
+class Foo {
+  prop = 5;
+}
+
+function fn(a = 5, b = true) {}
+
+function fn(a: number, b: boolean, c: string) {}
+```
+
+The following are invalid:
+
+```ts
+const a: bigint = 10n;
+const a: bigint = -10n;
+const a: bigint = BigInt(10);
+const a: bigint = -BigInt(10);
+const a: boolean = false;
+const a: boolean = true;
+const a: boolean = Boolean(null);
+const a: boolean = !0;
+const a: number = 10;
+const a: number = +10;
+const a: number = -10;
+const a: number = Number('1');
+const a: number = +Number('1');
+const a: number = -Number('1');
+const a: number = Infinity;
+const a: number = +Infinity;
+const a: number = -Infinity;
+const a: number = NaN;
+const a: number = +NaN;
+const a: number = -NaN;
+const a: null = null;
+const a: RegExp = /a/;
+const a: RegExp = RegExp('a');
+const a: RegExp = new RegExp('a');
+const a: string = 'str';
+const a: string = `str`;
+const a: string = String(1);
+const a: symbol = Symbol('a');
+const a: undefined = undefined;
+const a: undefined = void someValue;
+
+class Foo {
+  prop: number = 5;
+}
+
+function fn(a: number = 5, b: boolean = true) {}
+```
+
+### `ignoreParameters`
+
+When set to true, the following pattern is considered valid:
+
+```ts
+function foo(a: number = 5, b: boolean = true) {
+  // ...
+}
+```
+
+### `ignoreProperties`
+
+When set to true, the following pattern is considered valid:
+
+```ts
+class Foo {
+  prop: number = 5;
+}
+```
+
+## When Not To Use It
+
+If you do not want to enforce inferred types.
+
+## Further Reading
+
+TypeScript [Inference](https://www.typescriptlang.org/docs/handbook/type-inference.html)
+
+## Compatibility
+
+TSLint: [no-inferrable-types](https://palantir.github.io/tslint/rules/no-inferrable-types/)

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-magic-numbers.md

@@ -0,0 +1,68 @@
+# Disallow Magic Numbers (@typescript-eslint/no-magic-numbers)
+
+'Magic numbers' are numbers that occur multiple times in code without an explicit meaning.
+They should preferably be replaced by named constants.
+
+## Rule Details
+
+The `@typescript-eslint/no-magic-numbers` rule extends the `no-magic-numbers` rule from ESLint core, and adds support for handling Typescript specific code that would otherwise trigger the rule.
+
+See the [ESLint documentation](https://eslint.org/docs/rules/no-magic-numbers) for more details on the `no-magic-numbers` rule.
+
+## Rule Changes
+
+```cjson
+{
+    // note you must disable the base rule as it can report incorrect errors
+    "no-magic-numbers": "off",
+    "@typescript-eslint/no-magic-numbers": ["error", { "ignoreNumericLiteralTypes": true }]
+}
+```
+
+In addition to the options supported by the `no-magic-numbers` rule in ESLint core, the rule adds the following options:
+
+### ignoreNumericLiteralTypes
+
+A boolean to specify if numbers used in Typescript numeric literal types are considered okay. `false` by default.
+
+Examples of **incorrect** code for the `{ "ignoreNumericLiteralTypes": false }` option:
+
+```ts
+/*eslint @typescript-eslint/no-magic-numbers: ["error", { "ignoreNumericLiteralTypes": false }]*/
+
+type SmallPrimes = 2 | 3 | 5 | 7 | 11;
+```
+
+Examples of **correct** code for the `{ "ignoreNumericLiteralTypes": true }` option:
+
+```ts
+/*eslint @typescript-eslint/no-magic-numbers: ["error", { "ignoreNumericLiteralTypes": true }]*/
+
+type SmallPrimes = 2 | 3 | 5 | 7 | 11;
+```
+
+### ignoreEnums
+
+A boolean to specify if enums used in Typescript are considered okay. `false` by default.
+
+Examples of **incorrect** code for the `{ "ignoreEnums": false }` option:
+
+```ts
+/*eslint @typescript-eslint/no-magic-numbers: ["error", { "ignoreEnums": false }]*/
+
+enum foo = {
+    SECOND = 1000,
+}
+```
+
+Examples of **correct** code for the `{ "ignoreEnums": true }` option:
+
+```ts
+/*eslint @typescript-eslint/no-magic-numbers: ["error", { "ignoreEnums": true }]*/
+
+enum foo = {
+    SECOND = 1000,
+}
+```
+
+<sup>Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/master/docs/rules/no-magic-numbers.md)</sup>