less 3.10.1 → 3.11.1

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

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

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

@@ -0,0 +1,60 @@
+# Disallow aliasing `this` (no-this-alias)
+
+This rule prohibts assigning variables to `this`.
+
+## Rule Details
+
+Rationale from TSLint:
+
+> Assigning a variable to `this` instead of properly using arrow lambdas may be a symptom of pre-ES6 practices
+> or not managing scope well.
+>
+> Instead of storing a reference to `this` and using it inside a `function () {`:
+>
+> ```js
+> const self = this;
+>
+> setTimeout(function() {
+>   self.doWork();
+> });
+> ```
+>
+> Use `() =>` arrow lambdas, as they preserve `this` scope for you:
+>
+> ```js
+> setTimeout(() => {
+>   this.doWork();
+> });
+> ```
+
+Examples of **incorrect** code for this rule:
+
+(see the rationale above)
+
+Examples of **correct** code for this rule:
+
+(see the rationale above)
+
+### Options
+
+You can pass an object option:
+
+```json5
+{
+  '@typescript-eslint/no-this-alias': [
+    'error',
+    {
+      allowDestructuring: true, // Allow `const { props, state } = this`; false by default
+      allowedNames: ['self'], // Allow `const self = this`; `[]` by default
+    },
+  ],
+}
+```
+
+## When Not To Use It
+
+If you need to assign `this` to variables, you shouldn’t use this rule.
+
+## Related to
+
+- TSLint: [`no-this-assignment`](https://palantir.github.io/tslint/rules/no-this-assignment/)

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-triple-slash-reference.md

@@ -0,0 +1,43 @@
+# Disallow `/// <reference path="" />` comments (no-triple-slash-reference)
+
+Triple-slash reference directive comments should not be used anymore. Use `import` instead.
+
+Before TypeScript adopted ES6 Module syntax,
+triple-slash reference directives were used to specify dependencies.
+Now that we have `import`, triple-slash reference directives are discouraged for specifying dependencies
+in favor of `import`.
+
+A triple-slash reference directive is a comment beginning with three slashes followed by a path to the module being imported:
+`/// <reference path="./Animal" />`.
+ES6 Modules handle this now:
+`import animal from "./Animal"`
+
+## DEPRECATED - this rule has been deprecated in favour of [`triple-slash-reference`](./triple-slash-reference.md)
+
+## Rule Details
+
+Does not allow the use of `/// <reference />` comments.
+
+The following patterns are considered warnings:
+
+```ts
+/// <reference path="Animal">
+```
+
+The following patterns are not warnings:
+
+```ts
+import Animal from 'Animal';
+```
+
+## When Not To Use It
+
+If you use `/// <reference />` style imports.
+
+## Further Reading
+
+- TypeScript [Triple-Slash Directives](https://www.typescriptlang.org/docs/handbook/triple-slash-directives.html)
+
+## Compatibility
+
+- TSLint: [no-reference](http://palantir.github.io/tslint/rules/no-reference/)

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

@@ -0,0 +1,467 @@
+# Disallow the use of type aliases (no-type-alias)
+
+In TypeScript, type aliases serve three purposes:
+
+- Aliasing other types so that we can refer to them using a simpler name.
+
+```ts
+// this...
+type Person = {
+    firstName: string,
+    lastName: string,
+    age: number
+};
+
+function addPerson(person : Person) { ... }
+
+// is easier to read than this...
+function addPerson(person : { firstName: string, lastName: string, age: number}) { ... }
+```
+
+- Act sort of like an interface, providing a set of methods and properties that must exist
+  in the objects implementing the type.
+
+```ts
+type Person = {
+    firstName: string,
+    lastName: string,
+    age: number,
+    walk: () => void,
+    talk: () => void
+};
+
+// you know person will have 3 properties and 2 methods,
+// because the structure has already been defined.
+var person : Person = { ... }
+
+// so we can be sure that this will work
+person.walk();
+```
+
+- Act like mapping tools between types to allow quick modifications.
+
+```ts
+type Immutable<T> = { readonly [P in keyof T]: T[P] };
+
+type Person = {
+  name: string;
+  age: number;
+};
+
+type ImmutablePerson = Immutable<Person>;
+
+var person: ImmutablePerson = { name: 'John', age: 30 };
+person.name = 'Brad'; // error, readonly property
+```
+
+When aliasing, the type alias does not create a new type, it just creates a new name
+to refer to the original type. So aliasing primitives and other simple types, tuples, unions
+or intersections can some times be redundant.
+
+```ts
+// this doesn't make much sense
+type myString = string;
+```
+
+On the other hand, using a type alias as an interface can limit your ability to:
+
+- Reuse your code: interfaces can be extended or implemented by other types. Type aliases cannot.
+- Debug your code: interfaces create a new name, so is easy to identify the base type of an object
+  while debugging the application.
+
+Finally, mapping types is an advance technique, leaving it open can quickly become a pain point
+in your application.
+
+## Rule Details
+
+This rule disallows the use of type aliases in favor of interfaces
+and simplified types (primitives, tuples, unions, intersections, etc).
+
+## 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:
+
+- `allowAliases` set to `"always"` will allow you to do aliasing (Defaults to `"never"`).
+- `allowCallbacks` set to `"always"` will allow you to use type aliases with callbacks (Defaults to `"never"`)
+- `allowLiterals` set to `"always"` will allow you to use type aliases with literal objects (Defaults to `"never"`)
+- `allowMappedTypes` set to `"always"` will allow you to use type aliases as mapping tools (Defaults to `"never"`)
+
+### allowAliases
+
+This applies to primitive types and reference types.
+
+The setting accepts the following values:
+
+- `"always"` or `"never"` to active or deactivate the feature.
+- `"in-unions"`, allows aliasing in union statements, e.g. `type Foo = string | string[];`
+- `"in-intersections"`, allows aliasing in intersection statements, e.g. `type Foo = string & string[];`
+- `"in-unions-and-intersections"`, allows aliasing in union and/or intersection statements.
+
+Examples of **correct** code for the `{ "allowAliases": "always" }` options:
+
+```ts
+// primitives
+type Foo = 'a';
+
+type Foo = 'a' | 'b';
+
+type Foo = string;
+
+type Foo = string | string[];
+
+type Foo = string & string[];
+
+// reference types
+interface Bar {}
+class Baz implements Bar {}
+
+type Foo = Bar;
+
+type Foo = Bar | Baz;
+
+type Foo = Bar & Baz;
+```
+
+Examples of **incorrect** code for the `{ "allowAliases": "in-unions" }` option:
+
+```ts
+// primitives
+type Foo = 'a';
+
+type Foo = string;
+
+type Foo = string & string[];
+
+// reference types
+interface Bar {}
+class Baz implements Bar {}
+
+type Foo = Bar;
+
+type Foo = Bar & Baz;
+```
+
+Examples of **correct** code for the `{ "allowAliases": "in-unions" }` option:
+
+```ts
+// primitives
+type Foo = 'a' | 'b';
+
+type Foo = string | string[];
+
+// reference types
+interface Bar {}
+class Baz implements Bar {}
+
+type Foo = Bar | Baz;
+```
+
+Examples of **incorrect** code for the `{ "allowAliases": "in-intersections" }` option:
+
+```ts
+// primitives
+type Foo = 'a';
+
+type Foo = 'a' | 'b';
+
+type Foo = string;
+
+type Foo = string | string[];
+
+// reference types
+interface Bar {}
+class Baz implements Bar {}
+
+type Foo = Bar;
+
+type Foo = Bar | Baz;
+```
+
+Examples of **correct** code for the `{ "allowAliases": "in-intersections" }` option:
+
+```ts
+// primitives
+type Foo = string & string[];
+
+// reference types
+interface Bar {}
+class Baz implements Bar {}
+
+type Foo = Bar & Baz;
+```
+
+Examples of **incorrect** code for the `{ "allowAliases": "in-unions-and-intersections" }` option:
+
+```ts
+// primitives
+type Foo = 'a';
+
+type Foo = string;
+
+// reference types
+interface Bar {}
+class Baz implements Bar {}
+
+type Foo = Bar;
+```
+
+Examples of **correct** code for the `{ "allowAliases": "in-unions-and-intersections" }` option:
+
+```ts
+// primitives
+type Foo = 'a' | 'b';
+
+type Foo = string | string[];
+
+type Foo = string & string[];
+
+// reference types
+interface Bar {}
+class Baz implements Bar {}
+
+type Foo = Bar | Baz;
+
+type Foo = Bar & Baz;
+```
+
+### allowCallbacks
+
+This applies to function types.
+
+The setting accepts the following values:
+
+- `"always"` or `"never"` to active or deactivate the feature.
+
+Examples of **correct** code for the `{ "allowCallbacks": "always" }` option:
+
+```ts
+type Foo = () => void;
+
+type Foo = (name: string) => string;
+
+class Person {}
+
+type Foo = (name: string, age: number) => string | Person;
+
+type Foo = (name: string, age: number) => string & Person;
+```
+
+### allowLiterals
+
+This applies to literal types (`type Foo = { ... }`).
+
+The setting accepts the following options:
+
+- `"always"` or `"never"` to active or deactivate the feature.
+- `"in-unions"`, allows literals in union statements, e.g. `type Foo = string | string[];`
+- `"in-intersections"`, allows literals in intersection statements, e.g. `type Foo = string & string[];`
+- `"in-unions-and-intersections"`, allows literals in union and/or intersection statements.
+
+Examples of **correct** code for the `{ "allowLiterals": "always" }` options:
+
+```ts
+type Foo = {};
+
+type Foo = {
+  name: string;
+  age: number;
+};
+
+type Foo = {
+  name: string;
+  age: number;
+  walk: (miles: number) => void;
+};
+
+type Foo = { name: string } | { age: number };
+
+type Foo = { name: string } & { age: number };
+```
+
+Examples of **incorrect** code for the `{ "allowLiterals": "in-unions" }` option:
+
+```ts
+type Foo = {};
+
+type Foo = {
+  name: string;
+  age: number;
+};
+
+type Foo = {
+  name: string;
+  age: number;
+  walk: (miles: number) => void;
+};
+
+type Foo = { name: string } & { age: number };
+```
+
+Examples of **correct** code for the `{ "allowLiterals": "in-unions" }` option:
+
+```ts
+type Foo = { name: string } | { age: number };
+```
+
+Examples of **incorrect** code for the `{ "allowLiterals": "in-intersections" }` option:
+
+```ts
+type Foo = {};
+
+type Foo = {
+  name: string;
+  age: number;
+};
+
+type Foo = {
+  name: string;
+  age: number;
+  walk: (miles: number) => void;
+};
+
+type Foo = { name: string } | { age: number };
+```
+
+Examples of **correct** code for the `{ "allowLiterals": "in-intersections" }` option:
+
+```ts
+type Foo = { name: string } & { age: number };
+```
+
+Examples of **incorrect** code for the `{ "allowLiterals": "in-unions-and-intersections" }` option:
+
+```ts
+type Foo = {};
+
+type Foo = {
+  name: string;
+  age: number;
+};
+
+type Foo = {
+  name: string;
+  age: number;
+  walk: (miles: number) => void;
+};
+```
+
+Examples of **correct** code for the `{ "allowLiterals": "in-unions-and-intersections" }` option:
+
+```ts
+type Foo = { name: string } | { age: number };
+
+type Foo = { name: string } & { age: number };
+```
+
+### allowMappedTypes
+
+This applies to literal types.
+
+The setting accepts the following values:
+
+- `"always"` or `"never"` to active or deactivate the feature.
+- `"in-unions"`, allows aliasing in union statements, e.g. `type Foo = string | string[];`
+- `"in-intersections"`, allows aliasing in intersection statements, e.g. `type Foo = string & string[];`
+- `"in-unions-and-intersections"`, allows aliasing in union and/or intersection statements.
+
+Examples of **correct** code for the `{ "allowMappedTypes": "always" }` options:
+
+```ts
+type Foo<T> = { readonly [P in keyof T]: T[P] };
+
+type Foo<T> = { [P in keyof T]?: T[P] };
+
+type Foo<T, U> =
+  | { readonly [P in keyof T]: T[P] }
+  | { readonly [P in keyof U]: U[P] };
+
+type Foo<T, U> = { [P in keyof T]?: T[P] } | { [P in keyof U]?: U[P] };
+
+type Foo<T, U> = { readonly [P in keyof T]: T[P] } &
+  { readonly [P in keyof U]: U[P] };
+
+type Foo<T, U> = { [P in keyof T]?: T[P] } & { [P in keyof U]?: U[P] };
+```
+
+Examples of **incorrect** code for the `{ "allowMappedTypes": "in-unions" }` option:
+
+```ts
+type Foo<T> = { readonly [P in keyof T]: T[P] };
+
+type Foo<T> = { [P in keyof T]?: T[P] };
+
+type Foo<T, U> = { readonly [P in keyof T]: T[P] } &
+  { readonly [P in keyof U]: U[P] };
+
+type Foo<T, U> = { [P in keyof T]?: T[P] } & { [P in keyof U]?: U[P] };
+```
+
+Examples of **correct** code for the `{ "allowMappedTypes": "in-unions" }` option:
+
+```ts
+type Foo<T, U> =
+  | { readonly [P in keyof T]: T[P] }
+  | { readonly [P in keyof U]: U[P] };
+
+type Foo<T, U> = { [P in keyof T]?: T[P] } | { [P in keyof U]?: U[P] };
+```
+
+Examples of **incorrect** code for the `{ "allowMappedTypes": "in-intersections" }` option:
+
+```ts
+type Foo<T> = { readonly [P in keyof T]: T[P] };
+
+type Foo<T> = { [P in keyof T]?: T[P] };
+
+type Foo<T, U> =
+  | { readonly [P in keyof T]: T[P] }
+  | { readonly [P in keyof U]: U[P] };
+
+type Foo<T, U> = { [P in keyof T]?: T[P] } | { [P in keyof U]?: U[P] };
+```
+
+Examples of **correct** code for the `{ "allowMappedTypes": "in-intersections" }` option:
+
+```ts
+type Foo<T, U> = { readonly [P in keyof T]: T[P] } &
+  { readonly [P in keyof U]: U[P] };
+
+type Foo<T, U> = { [P in keyof T]?: T[P] } & { [P in keyof U]?: U[P] };
+```
+
+Examples of **incorrect** code for the `{ "allowMappedTypes": "in-unions-and-intersections" }` option:
+
+```ts
+type Foo<T> = { readonly [P in keyof T]: T[P] };
+
+type Foo<T> = { [P in keyof T]?: T[P] };
+```
+
+Examples of **correct** code for the `{ "allowMappedTypes": "in-unions-and-intersections" }` option:
+
+```ts
+type Foo<T, U> =
+  | { readonly [P in keyof T]: T[P] }
+  | { readonly [P in keyof U]: U[P] };
+
+type Foo<T, U> = { [P in keyof T]?: T[P] } | { [P in keyof U]?: U[P] };
+
+type Foo<T, U> = { readonly [P in keyof T]: T[P] } &
+  { readonly [P in keyof U]: U[P] };
+
+type Foo<T, U> = { [P in keyof T]?: T[P] } & { [P in keyof U]?: U[P] };
+```
+
+## When Not To Use It
+
+When you can't express some shape with an interface or you need to use a union, tuple type,
+callback, etc. that would cause the code to be unreadable or impractical.
+
+## Further Reading
+
+- [Advance Types](https://www.typescriptlang.org/docs/handbook/advanced-types.html)
+
+## Related to
+
+- TSLint: [interface-over-type-literal](https://palantir.github.io/tslint/rules/interface-over-type-literal/)

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

@@ -0,0 +1,79 @@
+# Warns when a namespace qualifier is unnecessary. (no-unnecessary-qualifier)
+
+## Rule Details
+
+This rule aims to let users know when a namespace or enum qualifier is unnecessary,
+whether used for a type or for a value.
+
+Examples of **incorrect** code for this rule:
+
+```ts
+namespace A {
+  export type B = number;
+  const x: A.B = 3;
+}
+```
+
+```ts
+namespace A {
+  export const x = 3;
+  export const y = A.x;
+}
+```
+
+```ts
+enum A {
+  B,
+  C = A.B,
+}
+```
+
+```ts
+namespace A {
+  export namespace B {
+    export type T = number;
+    const x: A.B.T = 3;
+  }
+}
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+namespace X {
+  export type T = number;
+}
+
+namespace Y {
+  export const x: X.T = 3;
+}
+```
+
+```ts
+enum A {
+  X,
+  Y,
+}
+
+enum B {
+  Z = A.X,
+}
+```
+
+```ts
+namespace X {
+  export type T = number;
+  namespace Y {
+    type T = string;
+    const x: X.T = 0;
+  }
+}
+```
+
+## When Not To Use It
+
+If you don't care about having unneeded namespace or enum qualifiers, then you don't need to use this rule.
+
+## Further Reading
+
+- TSLint: [no-unnecessary-qualifier](https://palantir.github.io/tslint/rules/no-unnecessary-qualifier/)