less 3.10.1 → 3.11.1

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-misused-new.md

@@ -0,0 +1,41 @@
+# Enforce valid definition of `new` and `constructor`. (no-misused-new)
+
+Warns on apparent attempts to define constructors for interfaces or `new` for classes.
+
+## Rule Details
+
+Examples of **incorrect** code for this rule.
+
+```ts
+class C {
+  new(): C;
+}
+
+interface I {
+  new (): I;
+  constructor(): void;
+}
+```
+
+Examples of **correct** code for this rule.
+
+```ts
+class C {
+  constructor() {}
+}
+interface I {
+  new (): C;
+}
+```
+
+## Options
+
+```json
+{
+  "@typescript-eslint/no-misused-new": "error"
+}
+```
+
+## Compatibility
+
+- TSLint: [no-misused-new](https://palantir.github.io/tslint/rules/no-misused-new/)

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

@@ -0,0 +1,119 @@
+# Avoid using promises in places not designed to handle them (no-misused-promises)
+
+This rule forbids using promises in places where the Typescript compiler
+allows them but they are not handled properly. These situations can often arise
+due to a missing `await` keyword or just a misunderstanding of the way async
+functions are handled/awaited.
+
+## Rule Details
+
+Examples of **incorrect** code for this rule with `checksConditionals: true`:
+
+```ts
+const promise = Promise.resolve('value');
+
+if (promise) {
+  // Do something
+}
+
+const val = promise ? 123 : 456;
+
+while (promise) {
+  // Do something
+}
+```
+
+Examples of **incorrect** code for this rule with `checksVoidReturn: true`:
+
+```ts
+[1, 2, 3].forEach(async value => {
+  await doSomething(value);
+});
+
+new Promise(async (resolve, reject) => {
+  await doSomething();
+  resolve();
+});
+
+const eventEmitter = new EventEmitter();
+eventEmitter.on('some-event', async () => {
+  await doSomething();
+});
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+const promise = Promise.resolve('value');
+
+if (await promise) {
+  // Do something
+}
+
+const val = (await promise) ? 123 : 456;
+
+while (await promise) {
+  // Do something
+}
+
+for (const value of [1, 2, 3]) {
+  await doSomething(value);
+}
+
+new Promise((resolve, reject) => {
+  // Do something
+  resolve();
+});
+
+const eventEmitter = new EventEmitter();
+eventEmitter.on('some-event', () => {
+  doSomething();
+});
+```
+
+## Options
+
+This rule accepts a single option which is an object with `checksConditionals`
+and `checksVoidReturn` properties indicating which types of misuse to flag.
+Both are enabled by default
+
+If you don't want functions that return promises where a void return is
+expected to be checked, your configuration will look like this:
+
+```json
+{
+  "@typescript-eslint/no-misused-promises": [
+    "error",
+    {
+      "checksVoidReturn": false
+    }
+  ]
+}
+```
+
+Likewise, if you don't want to check conditionals, you can configure the rule
+like this:
+
+```json
+{
+  "@typescript-eslint/no-misused-promises": [
+    "error",
+    {
+      "checksConditionals": false
+    }
+  ]
+}
+```
+
+## When Not To Use It
+
+If you do not use Promises in your codebase or are not concerned with possible
+misuses of them outside of what the Typescript compiler will check.
+
+## Related to
+
+- [`no-floating-promises`](./no-floating-promises.md)
+
+## Further Reading
+
+- [Typescript void function assignability](https://github.com/Microsoft/TypeScript/wiki/FAQ#why-are-functions-returning-non-void-assignable-to-function-returning-void)

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

@@ -0,0 +1,107 @@
+# Disallow the use of custom TypeScript modules and namespaces (no-namespace)
+
+Custom TypeScript modules (`module foo {}`) and namespaces (`namespace foo {}`) are considered outdated
+ways to organize TypeScript code. ES2015 module syntax is now preferred (`import`/`export`).
+
+This rule still allows the use of TypeScript module declarations to describe external APIs (`declare module 'foo' {}`).
+
+## Rule Details
+
+This rule aims to standardise the way modules are declared.
+
+## Options
+
+This rule, in its default state, does not require any argument. If you would like to enable one
+or more of the following you may pass an object with the options set as follows:
+
+- `allowDeclarations` set to `true` will allow you to `declare` custom TypeScript modules and namespaces (Default: `false`).
+- `allowDefinitionFiles` set to `true` will allow you to `declare` and use custom TypeScript modules and namespaces
+  inside definition files (Default: `false`).
+
+Examples of **incorrect** code for the default `{ "allowDeclarations": false, "allowDefinitionFiles": false }` options:
+
+```ts
+module foo {}
+namespace foo {}
+
+declare module foo {}
+declare namespace foo {}
+
+// anything inside a d.ts file
+```
+
+Examples of **correct** code for the default `{ "allowDeclarations": false, "allowDefinitionFiles": false }` options:
+
+```ts
+declare module 'foo' {}
+```
+
+### allowDeclarations
+
+Examples of **incorrect** code for the `{ "allowDeclarations": true }` option:
+
+```ts
+module foo {}
+namespace foo {}
+```
+
+Examples of **correct** code for the `{ "allowDeclarations": true }` option:
+
+```ts
+declare module 'foo' {}
+declare module foo {}
+declare namespace foo {}
+```
+
+Examples of **incorrect** code for the `{ "allowDeclarations": false }` option:
+
+```ts
+module foo {}
+namespace foo {}
+declare module foo {}
+declare namespace foo {}
+```
+
+Examples of **correct** code for the `{ "allowDeclarations": false }` option:
+
+```ts
+declare module 'foo' {}
+```
+
+### allowDefinitionFiles
+
+Examples of **incorrect** code for the `{ "allowDefinitionFiles": true }` option:
+
+```ts
+// if outside a d.ts file
+module foo {}
+namespace foo {}
+
+// if outside a d.ts file and allowDeclarations = false
+module foo {}
+namespace foo {}
+declare module foo {}
+declare namespace foo {}
+```
+
+Examples of **correct** code for the `{ "allowDefinitionFiles": true }` option:
+
+```ts
+declare module 'foo' {}
+
+// anything inside a d.ts file
+```
+
+## 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)
+
+## Compatibility
+
+- TSLint: [no-namespace](https://palantir.github.io/tslint/rules/no-namespace/)

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-non-null-assertion.md

@@ -0,0 +1,35 @@
+# Disallows non-null assertions using the `!` postfix operator (no-non-null-assertion)
+
+## Rule Details
+
+Using non-null assertions cancels the benefits of the strict null-checking mode.
+
+Examples of **incorrect** code for this rule:
+
+```ts
+interface Foo {
+  bar?: string;
+}
+
+const foo: Foo = getFoo();
+const includesBaz: boolean = foo.bar!.includes('baz');
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+interface Foo {
+  bar?: string;
+}
+
+const foo: Foo = getFoo();
+const includesBaz: boolean = foo.bar && foo.bar.includes('baz');
+```
+
+## When Not To Use It
+
+If you don't care about strict null-checking, then you will not need this rule.
+
+## Further Reading
+
+- [`no-non-null-assertion`](https://palantir.github.io/tslint/rules/no-non-null-assertion/) in [TSLint](https://palantir.github.io/tslint/)

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-object-literal-type-assertion.md

@@ -0,0 +1,33 @@
+# Forbids an object literal to appear in a type assertion expression (no-object-literal-type-assertion)
+
+Always prefer `const x: T = { ... };` to `const x = { ... } as T;`. Casting to `any` and `unknown` is still allowed, and const assertions (`as const`) are still allowed.
+
+## Rule Details
+
+Examples of **incorrect** code for this rule.
+
+```ts
+const x = { ... } as T;
+```
+
+Examples of **correct** code for this rule.
+
+```ts
+const x: T = { ... };
+const y = { ... } as any;
+const z = { ... } as unknown;
+```
+
+## Options
+
+```cjson
+{
+  "@typescript-eslint/no-object-literal-type-assertion": ["error", {
+    allowAsParameter: false // Allow type assertion in call and new expression, default false
+  }]
+}
+```
+
+## Compatibility
+
+- TSLint: [no-object-literal-type-assertion](https://palantir.github.io/tslint/rules/no-object-literal-type-assertion/)

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

@@ -0,0 +1,367 @@
+# 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 fo 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/)