less 3.10.1 → 3.11.1

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

@@ -0,0 +1,202 @@
+# Enforce camelCase naming convention (camelcase)
+
+When it comes to naming variables, style guides generally fall into one of two
+camps: camelcase (`variableName`) and underscores (`variable_name`). This rule
+focuses on using the camelcase approach. If your style guide calls for
+camelCasing your variable names, then this rule is for you!
+
+## Rule Details
+
+This rule looks for any underscores (`_`) located within the source code.
+It ignores leading and trailing underscores and only checks those in the middle
+of a variable name. If ESLint decides that the variable is a constant
+(all uppercase), then no warning will be thrown. Otherwise, a warning will be
+thrown. This rule only flags definitions and assignments but not function calls.
+In case of ES6 `import` statements, this rule only targets the name of the
+variable that will be imported into the local module scope.
+
+**_This rule was taken from the ESLint core rule `camelcase`._**
+**_Available options and test cases may vary depending on the version of ESLint installed in the system._**
+
+## Options
+
+```cjson
+{
+    // note you must disable the base rule as it can report incorrect errors
+    "camelcase": "off",
+    "@typescript-eslint/camelcase": ["error", { "properties": "always" }]
+}
+```
+
+This rule has an object option:
+
+- `"properties": "always"` (default) enforces camelcase style for property names
+- `"properties": "never"` does not check property names
+- `"ignoreDestructuring": false` (default) enforces camelcase style for destructured identifiers
+- `"ignoreDestructuring": true` does not check destructured identifiers
+- `allow` (`string[]`) list of properties to accept. Accept regex.
+
+### properties: "always"
+
+Examples of **incorrect** code for this rule with the default `{ "properties": "always" }` option:
+
+```js
+/*eslint @typescript-eslint/camelcase: "error"*/
+
+import { no_camelcased } from 'external-module';
+
+var my_favorite_color = '#112C85';
+
+function do_something() {
+  // ...
+}
+
+obj.do_something = function() {
+  // ...
+};
+
+function foo({ no_camelcased }) {
+  // ...
+}
+
+function foo({ isCamelcased: no_camelcased }) {
+  // ...
+}
+
+function foo({ no_camelcased = 'default value' }) {
+  // ...
+}
+
+var obj = {
+  my_pref: 1,
+};
+
+var { category_id = 1 } = query;
+
+var { foo: no_camelcased } = bar;
+
+var { foo: bar_baz = 1 } = quz;
+```
+
+Examples of **correct** code for this rule with the default `{ "properties": "always" }` option:
+
+```js
+/*eslint @typescript-eslint/camelcase: "error"*/
+
+import { no_camelcased as camelCased } from 'external-module';
+
+var myFavoriteColor = '#112C85';
+var _myFavoriteColor = '#112C85';
+var myFavoriteColor_ = '#112C85';
+var MY_FAVORITE_COLOR = '#112C85';
+var foo = bar.baz_boom;
+var foo = { qux: bar.baz_boom };
+
+obj.do_something();
+do_something();
+new do_something();
+
+var { category_id: category } = query;
+
+function foo({ isCamelCased }) {
+  // ...
+}
+
+function foo({ isCamelCased: isAlsoCamelCased }) {
+  // ...
+}
+
+function foo({ isCamelCased = 'default value' }) {
+  // ...
+}
+
+var { categoryId = 1 } = query;
+
+var { foo: isCamelCased } = bar;
+
+var { foo: isCamelCased = 1 } = quz;
+```
+
+### properties: "never"
+
+Examples of **correct** code for this rule with the `{ "properties": "never" }` option:
+
+```js
+/*eslint @typescript-eslint/camelcase: ["error", {properties: "never"}]*/
+
+var obj = {
+  my_pref: 1,
+};
+```
+
+### ignoreDestructuring: false
+
+Examples of **incorrect** code for this rule with the default `{ "ignoreDestructuring": false }` option:
+
+```js
+/*eslint @typescript-eslint/camelcase: "error"*/
+
+var { category_id } = query;
+
+var { category_id = 1 } = query;
+
+var { category_id: category_id } = query;
+
+var { category_id: category_alias } = query;
+
+var { category_id: categoryId, ...other_props } = query;
+```
+
+### ignoreDestructuring: true
+
+Examples of **incorrect** code for this rule with the `{ "ignoreDestructuring": true }` option:
+
+```js
+/*eslint @typescript-eslint/camelcase: ["error", {ignoreDestructuring: true}]*/
+
+var { category_id: category_alias } = query;
+
+var { category_id, ...other_props } = query;
+```
+
+Examples of **correct** code for this rule with the `{ "ignoreDestructuring": true }` option:
+
+```js
+/*eslint @typescript-eslint/camelcase: ["error", {ignoreDestructuring: true}]*/
+
+var { category_id } = query;
+
+var { category_id = 1 } = query;
+
+var { category_id: category_id } = query;
+```
+
+## allow
+
+Examples of **correct** code for this rule with the `allow` option:
+
+```js
+/*eslint @typescript-eslint/camelcase: ["error", {allow: ["UNSAFE_componentWillMount"]}]*/
+
+function UNSAFE_componentWillMount() {
+  // ...
+}
+```
+
+```js
+/*eslint @typescript-eslint/camelcase: ["error", {allow: ["^UNSAFE_"]}]*/
+
+function UNSAFE_componentWillMount() {
+  // ...
+}
+
+function UNSAFE_componentWillMount() {
+  // ...
+}
+```
+
+## When Not To Use It
+
+If you have established coding standards using a different naming convention (separating words with underscores), turn this rule off.
+
+<sup>Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/master/docs/rules/camelcase.md)</sup>

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/docs/rules/class-name-casing.md

@@ -0,0 +1,40 @@
+# Require PascalCased class and interface names (class-name-casing)
+
+This rule enforces PascalCased names for classes and interfaces.
+
+## Rule Details
+
+This rule aims to make it easy to differentiate classes from regular variables at a glance.
+
+Examples of **incorrect** code for this rule:
+
+```ts
+class invalidClassName {}
+
+class Another_Invalid_Class_Name {}
+
+var bar = class invalidName {};
+
+interface someInterface {}
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+class ValidClassName {}
+
+export default class {}
+
+var foo = class {};
+
+interface SomeInterface {}
+```
+
+## When Not To Use It
+
+You should turn off this rule if you do not care about class name casing, or if
+you use a different type of casing.
+
+## Further Reading
+
+- [`class-name`](https://palantir.github.io/tslint/rules/class-name/) in [TSLint](https://palantir.github.io/tslint/)

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/docs/rules/consistent-type-definitions.md

@@ -0,0 +1,74 @@
+# Consistent with type definition either `interface` or `type` (consistent-type-definitions)
+
+There are two ways to define a type.
+
+```ts
+// type alias
+type T1 = {
+  a: string;
+  b: number;
+};
+
+// interface keyword
+interface T2 {
+  a: string;
+  b: number;
+}
+```
+
+## Options
+
+This rule accepts one string option:
+
+- `"interface"`: enforce using `interface`s for object type definitions.
+- `"type"`: enforce using `type`s for object type definitions.
+
+For example:
+
+```CJSON
+{
+    // Use type for object definitions
+    "@typescript-eslint/consistent-type-definitions": ["error", "type"]
+}
+```
+
+## Rule Details
+
+Examples of **incorrect** code with `interface` option.
+
+```ts
+type T = { x: number };
+```
+
+Examples of **correct** code with `interface` option.
+
+```ts
+type T = string;
+type Foo = string | {};
+
+interface T {
+  x: number;
+}
+```
+
+Examples of **incorrect** code with `type` option.
+
+```ts
+interface T {
+  x: number;
+}
+```
+
+Examples of **correct** code with `type` option.
+
+```ts
+type T = { x: number };
+```
+
+## When Not To Use It
+
+If you specifically want to use an interface or type literal for stylistic reasons, you can disable this rule.
+
+## Compatibility
+
+- 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/explicit-function-return-type.md

@@ -0,0 +1,179 @@
+# Require explicit return types on functions and class methods (explicit-function-return-type)
+
+Explicit types for function return values makes it clear to any calling code what type is returned.
+This ensures that the return value is assigned to a variable of the correct type; or in the case
+where there is no return value, that the calling code doesn't try to use the undefined value when it
+shouldn't.
+
+## Rule Details
+
+This rule aims to ensure that the values returned from functions are of the expected type.
+
+The following patterns are considered warnings:
+
+```ts
+// Should indicate that no value is returned (void)
+function test() {
+  return;
+}
+
+// Should indicate that a number is returned
+var fn = function() {
+  return 1;
+};
+
+// Should indicate that a string is returned
+var arrowFn = () => 'test';
+
+class Test {
+  // Should indicate that no value is returned (void)
+  method() {
+    return;
+  }
+}
+```
+
+The following patterns are not warnings:
+
+```ts
+// No return value should be expected (void)
+function test(): void {
+  return;
+}
+
+// A return value of type number
+var fn = function(): number {
+  return 1;
+};
+
+// A return value of type string
+var arrowFn = (): string => 'test';
+
+class Test {
+  // No return value should be expected (void)
+  method(): void {
+    return;
+  }
+}
+```
+
+## Options
+
+The rule accepts an options object with the following properties:
+
+```ts
+type Options = {
+  // if true, only functions which are part of a declaration will be checked
+  allowExpressions?: boolean;
+  // if true, type annotations are also allowed on the variable of a function expression rather than on the function directly
+  allowTypedFunctionExpressions?: boolean;
+  // if true, functions immediately returning another function expression will not be checked
+  allowHigherOrderFunctions?: boolean;
+};
+
+const defaults = {
+  allowExpressions: false,
+  allowTypedFunctionExpressions: false,
+  allowHigherOrderFunctions: false,
+};
+```
+
+### allowExpressions
+
+Examples of **incorrect** code for this rule with `{ allowExpressions: true }`:
+
+```ts
+function test() {}
+```
+
+Examples of **correct** code for this rule with `{ allowExpressions: true }`:
+
+```ts
+node.addEventListener('click', () => {});
+
+node.addEventListener('click', function() {});
+
+const foo = arr.map(i => i * i);
+```
+
+### allowTypedFunctionExpressions
+
+Examples of **incorrect** code for this rule with `{ allowTypedFunctionExpressions: true }`:
+
+```ts
+let arrowFn = () => 'test';
+
+let funcExpr = function() {
+  return 'test';
+};
+
+let objectProp = {
+  foo: () => 1,
+};
+```
+
+Examples of additional **correct** code for this rule with `{ allowTypedFunctionExpressions: true }`:
+
+```ts
+type FuncType = () => string;
+
+let arrowFn: FuncType = () => 'test';
+
+let funcExpr: FuncType = function() {
+  return 'test';
+};
+
+let asTyped = (() => '') as () => string;
+let castTyped = <() => string>(() => '');
+
+interface ObjectType {
+  foo(): number;
+}
+let objectProp: ObjectType = {
+  foo: () => 1,
+};
+let objectPropAs = {
+  foo: () => 1,
+} as ObjectType;
+let objectPropCast = <ObjectType>{
+  foo: () => 1,
+};
+
+declare functionWithArg(arg: () => number);
+functionWithArg(() => 1);
+```
+
+### allowHigherOrderFunctions
+
+Examples of **incorrect** code for this rule with `{ allowHigherOrderFunctions: true }`:
+
+```ts
+var arrowFn = (x: number) => (y: number) => x + y;
+
+function fn(x: number) {
+  return function(y: number) {
+    return x + y;
+  };
+}
+```
+
+Examples of **correct** code for this rule with `{ allowHigherOrderFunctions: true }`:
+
+```ts
+var arrowFn = (x: number) => (y: number): number => x + y;
+
+function fn(x: number) {
+  return function(y: number): number {
+    return x + y;
+  };
+}
+```
+
+## When Not To Use It
+
+If you don't wish to prevent calling code from using function return values in unexpected ways, then
+you will not need this rule.
+
+## Further Reading
+
+- TypeScript [Functions](https://www.typescriptlang.org/docs/handbook/functions.html#function-types)