@odg/eslint-config 0.9.4 → 1.0.0

package/README.md

@@ -40,6 +40,7 @@
 - [EOL last Rule](#eol-last-rule)
 - [Max Line Len Rule](#max-line-len-rule)
 - [Camel Case Rule](#camel-case-rule)
+- [Strict](#strict)
 - [Padded Block Rule](#padded-block-rule)
 - [Lines Between Class Members](#lines-between-class-members)
 - [No Multi Assign Rule](#no-multi-assign-rule)
@@ -60,10 +61,12 @@
 - [Unused Vars](#unused-vars)
 - [Comma Spacing](#comma-spacing)
 - [Comma Dangle](#comma-dangle)
+- [Arrow Spacing](#arrow-spacing)
 - [Prefer Arrow Function](#prefer-arrow-function)
 - [Prefer Destructuring](#prefer-destructuring)
 - [Arrow Function Body](#arrow-function-body)
 - [Arrow Function Parentheses](#arrow-function-parentheses)
+- [Arrow Function No Break Line](#arrow-function-no-break-line)
 - [No Empty Block](#no-empty-block)
 - [No Long Syntax](#no-long-syntax)
 - [Useless Call Code](#useless-call-code)
@@ -195,6 +198,15 @@
 - [Comma Style](#comma-style)
 - [Object BreakLine](#object-break-line)
 - [No Shadow](#no-shadow)
+- [Parentheses New Line](#parentheses-new-line)
+- [No Func Call Spacing](#no-func-call-spacing)
+- [Array Element New Line](#array-element-new-line)
+- [Wrap Iife](#wrap-iife)
+- [Disallow Template Tag Space](#disallow-template-tag-space)
+- [No Space Spread](#no-space-spread)
+- [Inline IF](#inline-if)
+- [New Instance Use Parentheses](#new-instance-use-parentheses)
+- [Logical Assignment Operators](#logical-assignment-operators)
 - [Promise Rules](#promise-rules)
   - [No New Statics](#no-new-statics)
   - [No Return Wrap](#no-return-wrap)
@@ -310,6 +322,7 @@
   - [Protect XSS Render](#protect-xss-render)
   - [Force Integrity](#force-integrity)
   - [DNS prefetching](#dns-prefetching)
+  - [No Prototype Builtins](#no-prototype-builtins)
 - [Catch Error Name](#catch-error-name)
 - [Consistent Destructured](#consistent-destructured)
 - [Consistent Function Scope](#consistent-function-scope)
@@ -351,6 +364,7 @@
 - [Prefer String Trim Start End](#prefer-string-trim-start-end)
 - [Prefer Switch](#prefer-switch)
 - [Prefer Ternary](#prefer-ternary)
+- [Multiline Ternary Multiple](#multiline-ternary-multiple)
 - [Prevent Abbreviations](#prevent-abbreviations)
 - [Consistent Relative URL](#consistent-relative-url)
 - [Require Array Join Separator](#require-array-join-separator)
@@ -377,6 +391,10 @@
   - [No Import Resolve](#no-import-resolve)
   - [Import Not Found](#import-not-found)
   - [JS Type](#js-type)
+  - [No Invalid This](#no-invalid-this)
+  - [No This Before Super](#no-this-before-super)
+  - [No Obj Calls](#no-obj-calls)
+  - [No Empty Pattern](#no-empty-pattern)
 - [Possible Errors](#possible-errors)
   - [For Direction](#for-direction)
   - [No Extra Bind](#no-extra-bind)
@@ -391,6 +409,9 @@
   - [Assertions In Tests](#assertions-in-tests)
   - [Test Multiple Possible Assert](#test-multiple-possible-assert)
   - [No Disable Timeout](#no-disable-timeout)
+  - [No Empty Static Block](#no-empty-static-block)
+  - [No Fallthrough](#no-fallthrough)
+- [YAML / JSON](#yaml-json)
 
 ## Introduction
 
@@ -480,7 +501,10 @@ class Foo {
 
 Requires the use of double quotes wherever possible
 
-<https://eslint.org/docs/rules/quotes#quotes>
+Enforces the use of double quotes for all JSX attribute values that don’t contain a double quote.
+
+<https://eslint.org/docs/rules/quotes>
+<https://eslint.org/docs/rules/jsx-quotes>
 
 👍 Examples of correct code
 
@@ -504,9 +528,11 @@ var backtick = `back\ntick`; // you can use \n in single or double quoted string
 ----------
 
 Requires indent with 4 spaces
+Tabs Disallow
 
 <https://eslint.org/docs/rules/indent#indent>
 <https://sonarsource.github.io/rspec/#/rspec/S3973/javascript>
+<https://eslint.org/docs/latest/rules/no-tabs>
 
 👍 Examples of correct code
 
@@ -630,6 +656,31 @@ function do_something() {
 }
 ```
 
+## Strict
+
+----------
+
+A strict mode directive is a "use strict" literal at the beginning of a script or function body.
+It enables strict mode semantics.
+
+<https://eslint.org/docs/latest/rules/strict>
+
+👍 Examples of correct code
+
+```typescript
+"use strict";
+
+function foo() {
+}
+```
+
+👎 Examples of incorrect code
+
+```typescript
+function foo() {
+}
+```
+
 ## Padded Block Rule
 
 ----------
@@ -993,6 +1044,7 @@ var c = object[ "foo"];
 Enforces consistent spacing before and after keywords.
 
 <https://eslint.org/docs/rules/keyword-spacing#keyword-spacing>
+<https://eslint.org/docs/rules/yield-star-spacing>
 
 👍 Examples of correct code
 
@@ -1010,6 +1062,10 @@ try {
 } catch(e) {
     // code ...
 }
+
+function *generator() {
+  yield *other();
+}
 ```
 
 👎 Examples of incorrect code
@@ -1028,6 +1084,18 @@ try{
 }catch(e){
     // code ...
 }
+
+function*generator() {
+  yield*other();
+}
+
+function* generator() {
+  yield* other();
+}
+
+function * generator() {
+  yield * other();
+}
 ```
 
 ## Space Format
@@ -1478,6 +1546,35 @@ function baz(
 }
 ```
 
+## Arrow Spacing
+
+----------
+
+This rule normalize style of spacing before/after an arrow function’s arrow(=>).
+
+<https://eslint.org/docs/latest/rules/arrow-spacing>
+
+👍 Examples of correct code
+
+```typescript
+() => {};
+(a) => {};
+() => {'\n'};
+```
+
+👎 Examples of incorrect code
+
+```typescript
+()=> {};
+() =>{};
+(a)=> {};
+(a) =>{};
+a =>a;
+a=> a;
+()=> {'\n'};
+() =>{'\n'};
+```
+
 ## Prefer Arrow Function
 
 ----------
@@ -1613,6 +1710,58 @@ let foo = () => {
 };
 ```
 
+## Arrow Function No Break Line
+
+----------
+
+Enforces parentheses around arguments in all cases.
+
+<https://eslint.org/docs/rules/arrow-parens>
+
+👍 Examples of correct code
+
+```typescript
+(foo) => bar;
+
+(foo) => (bar);
+
+(foo) => bar => baz;
+
+(foo) => (
+  bar()
+);
+
+// functions with block bodies allowed with this rule using any style
+// to enforce a consistent location for this case, see the rule: `brace-style`
+(foo) => {
+  return bar();
+}
+
+(foo) =>
+{
+  return bar();
+}
+```
+
+👎 Examples of incorrect code
+
+```typescript
+(foo) =>
+  bar;
+
+(foo) =>
+  (bar);
+
+(foo) =>
+  bar =>
+    baz;
+
+(foo) =>
+(
+  bar()
+);
+```
+
 ## No Empty Block
 
 ----------
@@ -6410,6 +6559,8 @@ Requires using either T[] instead of Array\<T\>.
 ```typescript
 const x: string[] = ['a', 'b'];
 const y: readonly string[] = ['a', 'b'];
+
+const a: Array<string | number> = ['a', 'b'];
 ```
 
 👎 Examples of incorrect code
@@ -7178,7 +7329,11 @@ const obj3 = {
 
 Enforces placing object properties on separate lines.
 
-<https://eslint.org/docs/rules/object-property-newline>
+Then any code used within the same scope would not get the global undefined,
+but rather the local version with a very different meaning.
+
+<https://eslint.org/docs/rules/no-shadow>
+<https://eslint.org/docs/rules/no-shadow-restricted-names>
 
 👍 Examples of correct code
 
@@ -7196,6 +7351,8 @@ function b(a) {
     var c = 10;
 }
 b(a);
+
+function f(a, b){}
 ```
 
 👎 Examples of incorrect code
@@ -7218,215 +7375,585 @@ b(a);
 if (true) {
     let a = 5;
 }
-```
 
-## Promise Rules
+function NaN(){}
 
-### No New Statics
+!function(Infinity){};
+
+var undefined = 5;
+
+try {} catch(eval){}
+```
+
+## Parentheses New Line
 
 ----------
 
-Calling a Promise static method with new is invalid, resulting in a TypeError at runtime.
+This rule enforces consistent line breaks inside parentheses of function parameters or arguments.
 
-<https://github.com/xjamundx/eslint-plugin-promise/blob/development/docs/rules/no-new-statics.md>
+<https://eslint.org/docs/latest/rules/function-paren-newline>
+<https://eslint.org/docs/latest/rules/function-call-argument-newline>
 
 👍 Examples of correct code
 
 ```typescript
-Promise.resolve(value)
-Promise.reject(error)
-Promise.race([p1, p2])
-Promise.all([p1, p2])
+function foo(
+  bar,
+  baz
+) {}
+
+var foo = function(bar, baz) {};
+
+var foo = (
+  bar
+) => {};
+
+foo(
+  function() {
+    return baz;
+  }
+);
+
+foo("one", "two", "three");
+// or
+foo(
+    "one",
+    "two",
+    "three"
+);
+
+bar("one", "two", {
+    one: 1,
+    two: 2
+});
+// or
+bar(
+    "one",
+    "two",
+    { one: 1, two: 2 }
+);
+// or
+bar(
+    "one",
+    "two",
+    {
+        one: 1,
+        two: 2
+    }
+);
+
+baz("one", "two", (x) => {
+    console.log(x);
+});
+// or
+baz(
+    "one",
+    "two",
+    (x) => {
+        console.log(x);
+    }
+);
 ```
 
 👎 Examples of incorrect code
 
 ```typescript
-new Promise.resolve(value)
-new Promise.reject(error)
-new Promise.race([p1, p2])
-new Promise.all([p1, p2])
+function foo(bar,
+  baz
+) {}
+
+var foo = function(bar,
+baz) {};
+
+var foo = (
+  bar) => {};
+
+foo(
+  function() {
+    return baz;
+  });
+
+foo("one", "two",
+    "three");
+//or
+foo("one",
+    "two", "three");
+
+bar("one", "two",
+    { one: 1, two: 2}
+);
+
+baz("one", "two",
+    (x) => { console.log(x); }
+);
 ```
 
-### No Return Wrap
+## No Func Call Spacing
 
 ----------
 
-Ensure that inside a then() or a catch() we always return or throw a raw value instead of wrapping in Promise.resolve or Promise.reject
+Disallows space between the function name and the opening parenthesis.
 
-<https://github.com/xjamundx/eslint-plugin-promise/blob/development/docs/rules/no-new-statics.md>
+<https://eslint.org/docs/latest/rules/func-call-spacing>
 
 👍 Examples of correct code
 
 ```typescript
-myPromise.then(function (val) {
-  return val * 2
-})
-myPromise.then(function (val) {
-  throw new Exception("Message");
-})
+fn();
 ```
 
 👎 Examples of incorrect code
 
 ```typescript
-myPromise.then(function (val) {
-  return Promise.resolve(val * 2)
-})
-myPromise.then(function (val) {
-  return Promise.reject('bad thing')
-})
+fn ();
+
+fn
+();
 ```
 
-### Param Name
+## Array Element New Line
 
 ----------
 
-Ensure that inside a then() or a catch() we always return or throw a raw value instead of wrapping in Promise.resolve or Promise.reject
+This rule enforces line breaks between array elements.
 
-<https://github.com/xjamundx/eslint-plugin-promise/blob/development/docs/rules/param-names.md>
+<https://eslint.org/docs/latest/rules/array-element-newline>
 
 👍 Examples of correct code
 
 ```typescript
-new Promise(function (resolve) { ... })
-new Promise(function (resolve, reject) { ... })
-new Promise(function (_resolve, _reject) { ... }) // Unused marker for parameters are allowed
+var a = [];
+var b = [1];
+var c = [1, 2];
+var d = [1, 2, 3];
+var e = [
+    1,
+    2
+];
+var f = [
+    1,
+    2,
+    3
+];
+var g = [
+    function foo() {
+        dosomething();
+    }, function bar() {
+        dosomething();
+    }, function baz() {
+        dosomething();
+    }
+];
+var h = [
+    function foo() {
+        dosomething();
+    },
+    function bar() {
+        dosomething();
+    },
+    function baz() {
+        dosomething();
+    }
+];
 ```
 
 👎 Examples of incorrect code
 
 ```typescript
-new Promise(function (reject, resolve) { ... }) // incorrect order
-new Promise(function (ok, fail) { ... }) // non-standard parameter names
-new Promise(function (_, reject) { ... }) // a simple underscore is not allowed
+var a = [
+    1, 2,
+    3
+];
+var b = [
+    function foo() {
+        dosomething();
+    }, function bar() {
+        dosomething();
+    },
+    function baz() {
+        dosomething();
+    }
+];
 ```
 
-### Always Return
+## Wrap Iife
 
 ----------
 
-Ensure that inside a then() or a catch() we always return or throw a raw value instead of wrapping in Promise.resolve or Promise.reject
+Enforces always wrapping the function expression
 
-<https://github.com/xjamundx/eslint-plugin-promise/blob/development/docs/rules/always-return.md>
+<https://eslint.org/docs/latest/rules/wrap-iife>
 
 👍 Examples of correct code
 
 ```typescript
-myPromise.then((val) => val * 2);
-myPromise.then(function(val) { return val * 2; });
-myPromise.then(doSomething); // could be either
-myPromise.then((b) => { if (b) { return "yes" } else { return "no" } });
+var x = (function () { return { y: 1 }; })(); // wrapped function expression
 ```
 
 👎 Examples of incorrect code
 
 ```typescript
-myPromise.then(function (val) {})
-myPromise.then(() => {
-  doSomething()
-})
-myPromise.then((b) => {
-  if (b) {
-    return 'yes'
-  } else {
-    forgotToReturn()
-  }
-})
+var x = function () { return { y: 1 };}(); // unwrapped
+var x = (function () { return { y: 1 };}()); // wrapped call expression
 ```
 
-### No Nesting
+## Disallow Template Tag Space
 
 ----------
 
-`Warning` Avoid nested then() or catch() statements (no-nesting)
+Disallows spaces between a tag function and its template literal.
 
-<https://github.com/xjamundx/eslint-plugin-promise/blob/development/docs/rules/no-nesting.md>
+<https://eslint.org/docs/latest/rules/template-tag-spacing>
 
 👍 Examples of correct code
 
 ```typescript
-myPromise.then(doSomething).then(doSomethingElse).catch(errors)
+func`Hello world`;
 ```
 
 👎 Examples of incorrect code
 
 ```typescript
-myPromise.then((val) => doSomething(val).then(doSomethingElse))
-
-myPromise.then((val) => doSomething(val).catch(errors))
-
-myPromise.catch((err) => doSomething(err).then(doSomethingElse))
-
-myPromise.catch((err) => doSomething(err).catch(errors))
+func `Hello world`;
 ```
 
-### No Return Finally
+## No Space Spread
 
 ----------
 
-Disallow return statements inside a callback passed to finally(), since nothing would consume what's returned.
+Enforce spacing between rest and spread operators and their expressions
 
-<https://github.com/xjamundx/eslint-plugin-promise/blob/development/docs/rules/no-return-in-finally.md>
+<https://eslint.org/docs/latest/rules/rest-spread-spacing>
 
 👍 Examples of correct code
 
 ```typescript
-myPromise.finally(function (val) {
-  console.log('value:', val)
-})
+fn(...args)
+[...arr, 4, 5, 6]
+let [a, b, ...arr] = [1, 2, 3, 4, 5];
+function fn(...args) { console.log(args); }
+let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };
+let n = { x, y, ...z };
 ```
 
 👎 Examples of incorrect code
 
 ```typescript
-myPromise.finally(function (val) {
-  return val
-})
+fn(... args)
+[... arr, 4, 5, 6]
+let [a, b, ... arr] = [1, 2, 3, 4, 5];
+function fn(... args) { console.log(args); }
+let { x, y, ... z } = { x: 1, y: 2, a: 3, b: 4 };
+let n = { x, y, ... z };
 ```
 
-### Valid Params
+## Inline IF
 
 ----------
 
-Disallow return statements inside a callback passed to finally(), since nothing would consume what's returned.
+Disallows a newline before a single-line statement.
 
-<https://github.com/xjamundx/eslint-plugin-promise/blob/development/docs/rules/valid-params.md>
+<https://eslint.org/docs/latest/rules/nonblock-statement-body-position>
 
 👍 Examples of correct code
 
 ```typescript
-// Promise.all() requires 1 argument
-Promise.all([p1, p2, p3])
-Promise.all(iterable)
+if (foo) bar();
+else baz();
 
-// Promise.race() requires 1 argument
-Promise.race([p1, p2, p3])
-Promise.race(iterable)
+while (foo) bar();
 
-// Promise.resolve() requires 0 or 1 arguments
-Promise.resolve()
-Promise.resolve({})
-Promise.resolve([1, 2, 3])
-Promise.resolve(referenceToObject)
+for (let i = 1; i < foo; i++) bar();
 
-// Promise.reject() requires 0 or 1 arguments
-Promise.reject()
-Promise.reject(Error())
-Promise.reject(referenceToError)
+do bar(); while (foo)
 
-// Promise.then() requires 1 or 2 arguments
-somePromise().then((value) => doSomething(value))
-somePromise().then(successCallback, errorCallback)
+if (foo) { // block statements are always allowed with this rule
+  bar();
+} else {
+  baz();
+}
+```
 
-// Promise.catch() requires 1 argument
-somePromise().catch((error) => {
-  handleError(error)
-})
-somePromise().catch(console.error)
+👎 Examples of incorrect code
 
-// Promise.finally() requires 1 argument
-somePromise().finally(() => {
+```typescript
+if (foo)
+  bar();
+else
+  baz();
+
+while (foo)
+  bar();
+
+for (let i = 1; i < foo; i++)
+  bar();
+
+do
+  bar();
+while (foo)
+```
+
+## New Instance Use Parentheses
+
+----------
+
+This rule can enforce or disallow parentheses when invoking a constructor with no arguments using the new keyword.
+
+<https://eslint.org/docs/latest/rules/new-parens>
+
+👍 Examples of correct code
+
+```typescript
+var person = new Person();
+var person = new Person("name");
+```
+
+👎 Examples of incorrect code
+
+```typescript
+var person = new Person;
+var person = new (Person);
+```
+
+## Logical Assignment Operators
+
+----------
+
+The shorthand can be used if the assignment target and the left expression of a logical expression are the same.
+For example `a = a || b` can be shortened to `a ||= b`.
+
+<https://eslint.org/docs/latest/rules/logical-assignment-operators>
+
+👍 Examples of correct code
+
+```typescript
+a = b
+a += b
+a ||= b
+a = b || c
+a || (b = c)
+
+if (a) a = b
+```
+
+👎 Examples of incorrect code
+
+```typescript
+a = a || b
+a = a && b
+a = a ?? b
+a || (a = b)
+a && (a = b)
+a ?? (a = b)
+```
+
+## Promise Rules
+
+### No New Statics
+
+----------
+
+Calling a Promise static method with new is invalid, resulting in a TypeError at runtime.
+
+<https://github.com/xjamundx/eslint-plugin-promise/blob/development/docs/rules/no-new-statics.md>
+
+👍 Examples of correct code
+
+```typescript
+Promise.resolve(value)
+Promise.reject(error)
+Promise.race([p1, p2])
+Promise.all([p1, p2])
+```
+
+👎 Examples of incorrect code
+
+```typescript
+new Promise.resolve(value)
+new Promise.reject(error)
+new Promise.race([p1, p2])
+new Promise.all([p1, p2])
+```
+
+### No Return Wrap
+
+----------
+
+Ensure that inside a then() or a catch() we always return or throw a raw value instead of wrapping in Promise.resolve or Promise.reject
+
+<https://github.com/xjamundx/eslint-plugin-promise/blob/development/docs/rules/no-new-statics.md>
+
+👍 Examples of correct code
+
+```typescript
+myPromise.then(function (val) {
+  return val * 2
+})
+myPromise.then(function (val) {
+  throw new Exception("Message");
+})
+```
+
+👎 Examples of incorrect code
+
+```typescript
+myPromise.then(function (val) {
+  return Promise.resolve(val * 2)
+})
+myPromise.then(function (val) {
+  return Promise.reject('bad thing')
+})
+```
+
+### Param Name
+
+----------
+
+Ensure that inside a then() or a catch() we always return or throw a raw value instead of wrapping in Promise.resolve or Promise.reject
+
+<https://github.com/xjamundx/eslint-plugin-promise/blob/development/docs/rules/param-names.md>
+
+👍 Examples of correct code
+
+```typescript
+new Promise(function (resolve) { ... })
+new Promise(function (resolve, reject) { ... })
+new Promise(function (_resolve, _reject) { ... }) // Unused marker for parameters are allowed
+```
+
+👎 Examples of incorrect code
+
+```typescript
+new Promise(function (reject, resolve) { ... }) // incorrect order
+new Promise(function (ok, fail) { ... }) // non-standard parameter names
+new Promise(function (_, reject) { ... }) // a simple underscore is not allowed
+```
+
+### Always Return
+
+----------
+
+Ensure that inside a then() or a catch() we always return or throw a raw value instead of wrapping in Promise.resolve or Promise.reject
+
+<https://github.com/xjamundx/eslint-plugin-promise/blob/development/docs/rules/always-return.md>
+
+👍 Examples of correct code
+
+```typescript
+myPromise.then((val) => val * 2);
+myPromise.then(function(val) { return val * 2; });
+myPromise.then(doSomething); // could be either
+myPromise.then((b) => { if (b) { return "yes" } else { return "no" } });
+```
+
+👎 Examples of incorrect code
+
+```typescript
+myPromise.then(function (val) {})
+myPromise.then(() => {
+  doSomething()
+})
+myPromise.then((b) => {
+  if (b) {
+    return 'yes'
+  } else {
+    forgotToReturn()
+  }
+})
+```
+
+### No Nesting
+
+----------
+
+`Warning` Avoid nested then() or catch() statements (no-nesting)
+
+<https://github.com/xjamundx/eslint-plugin-promise/blob/development/docs/rules/no-nesting.md>
+
+👍 Examples of correct code
+
+```typescript
+myPromise.then(doSomething).then(doSomethingElse).catch(errors)
+```
+
+👎 Examples of incorrect code
+
+```typescript
+myPromise.then((val) => doSomething(val).then(doSomethingElse))
+
+myPromise.then((val) => doSomething(val).catch(errors))
+
+myPromise.catch((err) => doSomething(err).then(doSomethingElse))
+
+myPromise.catch((err) => doSomething(err).catch(errors))
+```
+
+### No Return Finally
+
+----------
+
+Disallow return statements inside a callback passed to finally(), since nothing would consume what's returned.
+
+<https://github.com/xjamundx/eslint-plugin-promise/blob/development/docs/rules/no-return-in-finally.md>
+
+👍 Examples of correct code
+
+```typescript
+myPromise.finally(function (val) {
+  console.log('value:', val)
+})
+```
+
+👎 Examples of incorrect code
+
+```typescript
+myPromise.finally(function (val) {
+  return val
+})
+```
+
+### Valid Params
+
+----------
+
+Disallow return statements inside a callback passed to finally(), since nothing would consume what's returned.
+
+<https://github.com/xjamundx/eslint-plugin-promise/blob/development/docs/rules/valid-params.md>
+
+👍 Examples of correct code
+
+```typescript
+// Promise.all() requires 1 argument
+Promise.all([p1, p2, p3])
+Promise.all(iterable)
+
+// Promise.race() requires 1 argument
+Promise.race([p1, p2, p3])
+Promise.race(iterable)
+
+// Promise.resolve() requires 0 or 1 arguments
+Promise.resolve()
+Promise.resolve({})
+Promise.resolve([1, 2, 3])
+Promise.resolve(referenceToObject)
+
+// Promise.reject() requires 0 or 1 arguments
+Promise.reject()
+Promise.reject(Error())
+Promise.reject(referenceToError)
+
+// Promise.then() requires 1 or 2 arguments
+somePromise().then((value) => doSomething(value))
+somePromise().then(successCallback, errorCallback)
+
+// Promise.catch() requires 1 argument
+somePromise().catch((error) => {
+  handleError(error)
+})
+somePromise().catch(console.error)
+
+// Promise.finally() requires 1 argument
+somePromise().finally(() => {
   console.log('done!')
 })
 somePromise().finally(console.log)
@@ -7836,6 +8363,7 @@ import typescript from "typescript"; // exists in dev dependency package.json
 ----------
 
 Enforce a convention in the order of require() / import statements
+Use: Alphabetic order import
 
 <https://github.com/import-js/eslint-plugin-import/blob/HEAD/docs/rules/order.md>
 
@@ -7979,9 +8507,13 @@ export {
 
 ----------
 
-Require space after comment block
+Require space after comment block.
+
+Many style guides require empty lines before or after comments.
+The primary goal of these rules is to make the comments easier to read and improve readability of the code.
 
 <https://eslint.org/docs/rules/spaced-comment>
+<https://eslint.org/docs/latest/rules/lines-around-comment>
 
 👍 Examples of correct code
 
@@ -7993,6 +8525,12 @@ Require space after comment block
 /*
  * This is a comment with a whitespace at the beginning
  */
+
+
+/**
+ * valid
+ */
+function() {}
 ```
 
 👎 Examples of incorrect code
@@ -8001,6 +8539,12 @@ Require space after comment block
 //This is a comment with no whitespace at the beginning
 
 /*This is a comment with no whitespace at the beginning */
+
+/**
+ * invalid after space
+ */
+
+function() {}
 ```
 
 ### Capitalized Comments
@@ -10465,28 +11009,61 @@ Allowing browsers to perform DNS prefetching is security-sensitive
 const express = require('express');
 const helmet = require('helmet');
 
-let app = express();
+let app = express();
+
+app.use(
+  helmet.dnsPrefetchControl({
+    allow: false // Compliant
+  })
+);
+```
+
+👎 Examples of incorrect code
+
+```typescript
+const express = require('express');
+const helmet = require('helmet');
+
+let app = express();
+
+app.use(
+  helmet.dnsPrefetchControl({
+    allow: true // Sensitive: allowing DNS prefetching is security-sensitive
+  })
+);
+```
+
+### No Prototype Builtins
+
+----------
+
+Additionally, objects can have properties that shadow the builtins on Object.prototype,
+potentially causing unintended behavior or denial-of-service security vulnerabilities.
+For example, it would be unsafe for a webserver to parse JSON input from a client and call hasOwnProperty directly
+on the resulting object, because a malicious client could send a JSON value like {"hasOwnProperty": 1}
+and cause the server to crash.
+
+To avoid subtle bugs like this, it’s better to always call these methods from Object.prototype.
+For example, foo.hasOwnProperty("bar") should be replaced with Object.prototype.hasOwnProperty.call(foo, "bar").
+
+<https://eslint.org/docs/latest/rules/No-Prototype-Builtins>
+
+```typescript
+var hasBarProperty = Object.prototype.hasOwnProperty.call(foo, "bar");
+
+var isPrototypeOfBar = Object.prototype.isPrototypeOf.call(foo, bar);
 
-app.use(
-  helmet.dnsPrefetchControl({
-    allow: false // Compliant
-  })
-);
+var barIsEnumerable = {}.propertyIsEnumerable.call(foo, "bar");
 ```
 
 👎 Examples of incorrect code
 
 ```typescript
-const express = require('express');
-const helmet = require('helmet');
+var hasBarProperty = foo.hasOwnProperty("bar");
 
-let app = express();
+var isPrototypeOfBar = foo.isPrototypeOf(bar);
 
-app.use(
-  helmet.dnsPrefetchControl({
-    allow: true // Sensitive: allowing DNS prefetching is security-sensitive
-  })
-);
+var barIsEnumerable = foo.propertyIsEnumerable("bar");
 ```
 
 ## Catch Error Name
@@ -11938,6 +12515,52 @@ if (test) {
 }
 ```
 
+## Multiline Ternary Multiple
+
+----------
+
+Enforces newlines between the operands of a ternary expression if the expression spans multiple lines.
+
+<https://eslint.org/docs/latest/rules/multiline-ternary>
+
+👍 Examples of correct code
+
+```tsx
+foo > bar ? value1 : value2;
+
+foo > bar ?
+    value1 :
+    value2;
+
+foo > bar ?
+    (baz > qux ? value1 : value2) :
+    value3;
+
+foo > bar ?
+    (baz > qux ?
+        value1 :
+        value2) :
+    value3;
+
+foo > bar &&
+    bar > baz ?
+        value1 :
+        value2;
+```
+
+👎 Examples of incorrect code
+
+```tsx
+foo > bar ? value1 :
+    value2;
+
+foo > bar ?
+    value1 : value2;
+
+foo > bar &&
+    bar > baz ? value1 : value2;
+```
+
 ## Prevent Abbreviations
 
 ----------
@@ -12786,165 +13409,479 @@ function findSomething(arr) {
             throw new Error("Doesn't exist.");
         }
     }
-}
+}
+
+for (key in obj) {
+    if (key.startsWith("_")) {
+        break;
+    }
+    firstKey = key;
+    firstValue = obj[key];
+    break;
+}
+
+for (foo of bar) {
+    if (foo.id === id) {
+        doSomething(foo);
+    }
+    break;
+}
+```
+
+### No Loss Of Precision
+
+----------
+
+Disallow literal numbers that lose precision
+
+<https://eslint.org/docs/latest/rules/no-loss-of-precision>
+
+👍 Examples of correct code
+
+```typescript
+const x = 12345
+const x = 123.456
+const x = 123e34
+const x = 12300000000000000000000000
+const x = 0x1FFFFFFFFFFFFF
+const x = 9007199254740991
+const x = 9007_1992547409_91
+```
+
+👎 Examples of incorrect code
+
+```typescript
+const x = 9007199254740993
+const x = 5123000000000000000000000000001
+const x = 1230000000000000000000000.0
+const x = .1230000000000000000000000
+const x = 0X20000000000001
+const x = 0X2_000000000_0001;
+```
+
+### Import Default Not Fount
+
+----------
+
+If a default import is requested, report if there is no default export in the imported module.
+
+<https://github.com/import-js/eslint-plugin-import/blob/main/docs/rules/default.md>
+
+👍 Examples of correct code
+
+```typescript
+// ./foo.js
+export class Example {}
+```
+
+```typescript
+import foo from './foo'
+
+// assuming 'node_modules' are ignored (true by default)
+import someModule from 'some-module'
+```
+
+👎 Examples of incorrect code
+
+```typescript
+import bar from './bar' // no default export found in ./bar
+import baz from './baz' // no default export found in ./baz
+```
+
+### Import Namespace
+
+### No Import Resolve
+
+----------
+
+Ensures an imported module can be resolved to a module on the local filesystem, as defined by standard Node require.resolve behavior.
+
+<https://github.com/import-js/eslint-plugin-import/blob/HEAD/docs/rules/no-unresolved.md>
+
+👍 Examples of correct code
+
+```typescript
+import x from './bar' // file found
+```
+
+👎 Examples of incorrect code
+
+```typescript
+import x from './foo' // File not found
+```
+
+### Import Not Found
+
+----------
+
+Verifies that all named imports are part of the set of named exports in the referenced module.
+
+<https://github.com/import-js/eslint-plugin-import/blob/HEAD/docs/rules/named.md>
+
+👍 Examples of correct code
+
+```typescript
+// ./foo.js
+export const foo = "I'm so foo"
+
+// -------------------
+
+// ./bar.js
+import { foo } from './foo';
+
+// ES7 proposal
+export { foo as bar } from './foo';
+
+// node_modules without jsnext:main are not analyzed by default
+// (import/ignore setting)
+import { SomeNonsenseThatDoesntExist } from 'react';
+```
+
+👎 Examples of incorrect code
+
+```typescript
+// ./baz.js
+import { notFoo } from './foo';
+
+// ES7 proposal
+export { notFoo as defNotBar } from './foo';
+
+// will follow 'jsnext:main', if available
+import { dontCreateStore } from 'redux';
+```
+
+### JS Type
+
+----------
+
+The types of the arguments to built-in functions are specified in the JavaScript language specifications
+
+<https://sonarsource.github.io/rspec/#/rspec/S3782/javascript>
+
+👍 Examples of correct code
+
+```typescript
+const isTooSmall = Math.abs(x) < 0.0042;
+```
+
+👎 Examples of incorrect code
+
+```typescript
+const isTooSmall = Math.abs(x < 0.0042); // Type require number no boolean
+```
+
+### No Invalid This
+
+----------
+
+Under the strict mode, this keywords outside of classes or class-like objects might be undefined and raise a TypeError.
+
+<https://eslint.org/docs/latest/rules/no-invalid-this#rule-details>
+<https://typescript-eslint.io/rules/no-invalid-this>
+
+👍 Examples of correct code
+
+```typescript
+"use strict";
+
+this.a = 0;
+baz(() => this);
+
+function Foo() {
+    // OK, this is in a legacy style constructor.
+    this.a = 0;
+    baz(() => this);
+}
+
+class Foo {
+    constructor() {
+        // OK, this is in a constructor.
+        this.a = 0;
+        baz(() => this);
+    }
+}
+
+var obj = {
+    foo: function foo() {
+        // OK, this is in a method (this function is on object literal).
+        this.a = 0;
+    }
+};
+
+var obj = {
+    foo() {
+        // OK, this is in a method (this function is on object literal).
+        this.a = 0;
+    }
+};
+
+var obj = {
+    get foo() {
+        // OK, this is in a method (this function is on object literal).
+        return this.a;
+    }
+};
+
+var obj = Object.create(null, {
+    foo: {value: function foo() {
+        // OK, this is in a method (this function is on object literal).
+        this.a = 0;
+    }}
+});
+
+Object.defineProperty(obj, "foo", {
+    value: function foo() {
+        // OK, this is in a method (this function is on object literal).
+        this.a = 0;
+    }
+});
+
+Object.defineProperties(obj, {
+    foo: {value: function foo() {
+        // OK, this is in a method (this function is on object literal).
+        this.a = 0;
+    }}
+});
+
+function Foo() {
+    this.foo = function foo() {
+        // OK, this is in a method (this function assigns to a property).
+        this.a = 0;
+        baz(() => this);
+    };
+}
+
+obj.foo = function foo() {
+    // OK, this is in a method (this function assigns to a property).
+    this.a = 0;
+};
+
+Foo.prototype.foo = function foo() {
+    // OK, this is in a method (this function assigns to a property).
+    this.a = 0;
+};
+
+class Foo {
+
+    // OK, this is in a class field initializer.
+    a = this.b;
+
+    // OK, static initializers also have valid this.
+    static a = this.b;
+
+    foo() {
+        // OK, this is in a method.
+        this.a = 0;
+        baz(() => this);
+    }
+
+    static foo() {
+        // OK, this is in a method (static methods also have valid this).
+        this.a = 0;
+        baz(() => this);
+    }
 
-for (key in obj) {
-    if (key.startsWith("_")) {
-        break;
+    static {
+        // OK, static blocks also have valid this.
+        this.a = 0;
+        baz(() => this);
     }
-    firstKey = key;
-    firstValue = obj[key];
-    break;
 }
 
-for (foo of bar) {
-    if (foo.id === id) {
-        doSomething(foo);
-    }
-    break;
+var foo = (function foo() {
+    // OK, the `bind` method of this function is called directly.
+    this.a = 0;
+}).bind(obj);
+
+foo.forEach(function() {
+    // OK, `thisArg` of `.forEach()` is given.
+    this.a = 0;
+    baz(() => this);
+}, thisArg);
+
+/** @this Foo */
+function foo() {
+    // OK, this function has a `@this` tag in its JSDoc comment.
+    this.a = 0;
 }
 ```
 
-### No Loss Of Precision
+👎 Examples of incorrect code
 
-----------
+```typescript
+"use strict";
 
-Disallow literal numbers that lose precision
+(function() {
+    this.a = 0;
+    baz(() => this);
+})();
 
-<https://eslint.org/docs/latest/rules/no-loss-of-precision>
+function foo() {
+    this.a = 0;
+    baz(() => this);
+}
 
-👍 Examples of correct code
+var foo = function() {
+    this.a = 0;
+    baz(() => this);
+};
 
-```typescript
-const x = 12345
-const x = 123.456
-const x = 123e34
-const x = 12300000000000000000000000
-const x = 0x1FFFFFFFFFFFFF
-const x = 9007199254740991
-const x = 9007_1992547409_91
-```
+foo(function() {
+    this.a = 0;
+    baz(() => this);
+});
 
-👎 Examples of incorrect code
+var obj = {
+    aaa: function() {
+        return function foo() {
+            // There is in a method `aaa`, but `foo` is not a method.
+            this.a = 0;
+            baz(() => this);
+        };
+    }
+};
 
-```typescript
-const x = 9007199254740993
-const x = 5123000000000000000000000000001
-const x = 1230000000000000000000000.0
-const x = .1230000000000000000000000
-const x = 0X20000000000001
-const x = 0X2_000000000_0001;
+foo.forEach(function() {
+    this.a = 0;
+    baz(() => this);
+});
 ```
 
-### Import Default Not Fount
+### No This Before Super
 
 ----------
 
-If a default import is requested, report if there is no default export in the imported module.
+In the constructor of derived classes, if this/super are used before super() calls, it raises a reference error.
 
-<https://github.com/import-js/eslint-plugin-import/blob/main/docs/rules/default.md>
+<https://eslint.org/docs/latest/rules/no-this-before-super>
 
 👍 Examples of correct code
 
 ```typescript
-// ./foo.js
-export class Example {}
-```
+class A {
+    constructor() {
+        this.a = 0; // OK, this class doesn't have an `extends` clause.
+    }
+}
 
-```typescript
-import foo from './foo'
+class A extends B {
+    constructor() {
+        super();
+        this.a = 0; // OK, this is after `super()`.
+    }
+}
 
-// assuming 'node_modules' are ignored (true by default)
-import someModule from 'some-module'
+class A extends B {
+    foo() {
+        this.a = 0; // OK. this is not in a constructor.
+    }
+}
 ```
 
 👎 Examples of incorrect code
 
 ```typescript
-import bar from './bar' // no default export found in ./bar
-import baz from './baz' // no default export found in ./baz
-```
+class A extends B {
+    constructor() {
+        this.a = 0;
+        super();
+    }
+}
 
-### Import Namespace
+class A extends B {
+    constructor() {
+        this.foo();
+        super();
+    }
+}
 
-### No Import Resolve
+class A extends B {
+    constructor() {
+        super.foo();
+        super();
+    }
+}
 
-----------
+class A extends B {
+    constructor() {
+        super(this.foo());
+    }
+}
+```
 
-Ensures an imported module can be resolved to a module on the local filesystem, as defined by standard Node require.resolve behavior.
+### No Obj Calls
 
-<https://github.com/import-js/eslint-plugin-import/blob/HEAD/docs/rules/no-unresolved.md>
+----------
 
-👍 Examples of correct code
+Disallow calling global object properties as functions
 
-```typescript
-import x from './bar' // file found
-```
+<https://eslint.org/docs/latest/rules/no-obj-calls>
 
-👎 Examples of incorrect code
+👍 Examples of correct code
 
 ```typescript
-import x from './foo' // File not found
-```
+function area(r) {
+    return Math.PI * r * r;
+}
 
-### Import Not Found
+var object = JSON.parse("{}");
 
-----------
+var value = Reflect.get({ x: 1, y: 2 }, "x");
 
-Verifies that all named imports are part of the set of named exports in the referenced module.
+var first = Atomics.load(foo, 0);
 
-<https://github.com/import-js/eslint-plugin-import/blob/HEAD/docs/rules/named.md>
+var segmenterFr = new Intl.Segmenter("fr", { granularity: "word" });
+```
 
-👍 Examples of correct code
+👎 Examples of incorrect code
 
 ```typescript
-// ./foo.js
-export const foo = "I'm so foo"
+var math = Math();
 
-// -------------------
+var newMath = new Math();
 
-// ./bar.js
-import { foo } from './foo';
+var json = JSON();
 
-// ES7 proposal
-export { foo as bar } from './foo';
+var newJSON = new JSON();
 
-// node_modules without jsnext:main are not analyzed by default
-// (import/ignore setting)
-import { SomeNonsenseThatDoesntExist } from 'react';
-```
+var reflect = Reflect();
 
-👎 Examples of incorrect code
+var newReflect = new Reflect();
 
-```typescript
-// ./baz.js
-import { notFoo } from './foo';
+var atomics = Atomics();
 
-// ES7 proposal
-export { notFoo as defNotBar } from './foo';
+var newAtomics = new Atomics();
 
-// will follow 'jsnext:main', if available
-import { dontCreateStore } from 'redux';
+var intl = Intl();
+
+var newIntl = new Intl();
 ```
 
-### JS Type
+### No Empty Pattern
 
 ----------
 
-The types of the arguments to built-in functions are specified in the JavaScript language specifications
+Disallow empty destructuring patterns
 
-<https://sonarsource.github.io/rspec/#/rspec/S3782/javascript>
+<https://eslint.org/docs/latest/rules/no-empty-pattern>
 
 👍 Examples of correct code
 
 ```typescript
-const isTooSmall = Math.abs(x) < 0.0042;
+
 ```
 
 👎 Examples of incorrect code
 
 ```typescript
-const isTooSmall = Math.abs(x < 0.0042); // Type require number no boolean
+var {} = foo;
+var [] = foo;
+var {a: {}} = foo;
+var {a: []} = foo;
+function foo({}) {}
+function foo([]) {}
+function foo({a: {}}) {}
+function foo({a: []}) {}
 ```
 
 ## Possible Errors
@@ -13523,3 +14460,122 @@ describe("testing this.timeout", function() {
   });
 });
 ```
+
+### No Empty Static Block
+
+----------
+
+Empty static blocks, while not technically errors, usually occur due to refactoring that wasn’t completed.
+They can cause confusion when reading code.
+
+<https://eslint.org/docs/latest/rules/no-empty-static-block>
+
+👍 Examples of correct code
+
+```typescript
+class Foo {
+    static {
+        bar();
+    }
+}
+
+class Foo {
+    static {
+        // comment
+    }
+}
+```
+
+👎 Examples of incorrect code
+
+```typescript
+class Foo {
+    static {}
+}
+```
+
+### No Fallthrough
+
+----------
+
+The switch statement in JavaScript is one of the more error-prone constructs of the language
+thanks in part to the ability to “fall through” from one case to the next. For example:
+
+Use `// falls through` comments to run multiple cases
+
+<https://eslint.org/docs/latest/rules/no-fallthrough>
+
+👍 Examples of correct code
+
+```typescript
+switch(foo) {
+    case 1:
+        doSomething();
+        break;
+
+    case 2:
+        doSomething();
+}
+
+function bar(foo) {
+    switch(foo) {
+        case 1:
+            doSomething();
+            return;
+
+        case 2:
+            doSomething();
+    }
+}
+
+switch(foo) {
+    case 1:
+        doSomething();
+        throw new Error("Boo!");
+
+    case 2:
+        doSomething();
+}
+
+switch(foo) {
+    case 1:
+    case 2:
+        doSomething();
+}
+
+switch(foo) {
+    case 1:
+        doSomething();
+        // falls through
+
+    case 2:
+        doSomething();
+}
+
+switch(foo) {
+    case 1: {
+        doSomething();
+        // falls through
+    }
+
+    case 2: {
+        doSomethingElse();
+    }
+}
+```
+
+👎 Examples of incorrect code
+
+```typescript
+switch(foo) {
+    case 1:
+        doSomething();
+
+    case 2:
+        doSomething();
+}
+```
+
+## Yaml Json
+
+add suport yaml and json files