@odg/eslint-config 1.2.0 → 1.3.0

package/README.md

@@ -300,6 +300,7 @@
   - [Sort Character Class Elements](#sort-character-class-elements)
   - [Sort Flags](#sort-flags)
   - [Prefer Named Capture Group](#prefer-named-capture-group)
+  - [Prefer Regexp Exec](#prefer-regexp-exec)
 - [Security](#security)
   - [Eval Disabled](#eval-disabled)
   - [Detect Unsafe Regex](#detect-unsafe-regex)
@@ -396,6 +397,11 @@
 - [Prefer Nullish Coalescing](#prefer-nullish-coalescing)
 - [Prefer Optional Chain](#prefer-optional-chain)
 - [Prefer Readonly](#prefer-readonly)
+- [Prefer Reduce Type Parameter](#prefer-reduce-type-parameter)
+- [Promise Function Async](#promise-function-async)
+- [Require Array Sort Compare](#require-array-sort-compare)
+- [Sort Type Constituents](#sort-type-constituents)
+- [Space Before Blocks](#space-before-blocks)
 - [Performance](#performance)
   - [No Alert](#no-alert)
   - [No Loop Func](#no-loop-func)
@@ -457,6 +463,9 @@
   - [No Non Null Asserted Optional Chain](#no-non-null-asserted-optional-chain)
   - [No Unsafe Declaration Merging](#no-unsafe-declaration-merging)
   - [No Useless Empty Export](#no-useless-empty-export)
+  - [Restrict Template Expressions](#restrict-template-expressions)
+  - [Return Await Try Catch](#return-await-try-catch)
+  - [Switch Exhaustiveness Check](#switch-exhaustiveness-check)
 - [YAML / JSON](#yaml-json)
 
 ## Introduction
@@ -993,6 +1002,7 @@ class Foo {
 
 Enforces default parameters to be last.
 
+<https://eslint.org/docs/latest/rules/space-before-function-paren>
 <https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/docs/rules/space-before-function-paren.md>
 
 👍 Examples of correct code
@@ -10362,6 +10372,39 @@ var foo = /\b(?:foo)+\b/;
 var foo = /\b(foo)+\b/;
 ```
 
+### Prefer Regexp Exec
+
+----------
+
+RegExp#exec is faster than String#match and both work the same when not using the /g flag.
+
+<https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-regexp-exec.html>
+<https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/docs/rules/prefer-regexp-exec.md>
+
+👍 Examples of correct code
+
+```typescript
+/thing/.exec('something');
+
+'some things are just things'.match(/thing/g);
+
+const text = 'something';
+const search = /thing/;
+search.exec(text);
+```
+
+👎 Examples of incorrect code
+
+```typescript
+'something'.match(/thing/);
+
+'some things are just things'.match(/thing/);
+
+const text = 'something';
+const search = /thing/;
+text.match(search);
+```
+
 ## Security
 
 ### Eval Disabled
@@ -12473,6 +12516,7 @@ string.replace(/Works for u flag too/gu, "");
 Prefer String#startsWith() & String#endsWith() over RegExp#test()
 
 <https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-string-starts-ends-with.md>
+<https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/docs/rules/prefer-string-starts-ends-with.md>
 
 👍 Examples of correct code
 
@@ -12490,6 +12534,28 @@ const foo = /^bar/i.test(baz);
 ```typescript
 const foo = /^bar/.test(baz);
 const foo = /bar$/.test(baz);
+
+// or
+
+declare const foo: string;
+
+// starts with
+foo[0] === 'b';
+foo.charAt(0) === 'b';
+foo.indexOf('bar') === 0;
+foo.slice(0, 3) === 'bar';
+foo.substring(0, 3) === 'bar';
+foo.match(/^bar/) != null;
+/^bar/.test(foo);
+
+// ends with
+foo[foo.length - 1] === 'b';
+foo.charAt(foo.length - 1) === 'b';
+foo.lastIndexOf('bar') === foo.length - 3;
+foo.slice(-3) === 'bar';
+foo.substring(foo.length - 3) === 'bar';
+foo.match(/bar$/) != null;
+/bar$/.test(foo);
 ```
 
 ## Prefer String Trim Start End
@@ -12966,12 +13032,17 @@ Instead, it's generally better to correct the types of code, to make directives
 
 ```typescript
 if (false) {
-  // @ts-ignore: Unreachable code error
+  // Compiler warns about unreachable code error
+  console.log('hello');
+}
+
+if (false) {
+  // @ts-expect-error: Unreachable code error
   console.log('hello');
 }
 if (false) {
   /*
-  @ts-ignore: Unreachable code error
+  @ts-expect-error: Unreachable code error
   */
   console.log('hello');
 }
@@ -12981,17 +13052,12 @@ if (false) {
 
 ```typescript
 if (false) {
-  // Compiler warns about unreachable code error
-  console.log('hello');
-}
-
-if (false) {
-  // @ts-expect-error: Unreachable code error
+  // @ts-ignore: Unreachable code error
   console.log('hello');
 }
 if (false) {
   /*
-  @ts-expect-error: Unreachable code error
+  @ts-ignore: Unreachable code error
   */
   console.log('hello');
 }
@@ -13960,6 +14026,256 @@ class Container {
 }
 ```
 
+## Prefer Reduce Type Parameter
+
+----------
+
+It's common to call Array#reduce with a generic type, such as an array or object, as the initial value.
+Since these values are empty, their types are not usable:
+
+<https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/docs/rules/prefer-reduce-type-parameter.md>
+
+👍 Examples of correct code
+
+```typescript
+[1, 2, 3].reduce<number[]>((arr, num) => arr.concat(num * 2), []);
+
+['a', 'b'].reduce<Record<string, boolean>>(
+  (accum, name) => ({
+    ...accum,
+    [name]: true,
+  }),
+  {},
+);
+```
+
+👎 Examples of incorrect code
+
+```typescript
+[1, 2, 3].reduce((arr, num) => arr.concat(num * 2), [] as number[]);
+
+['a', 'b'].reduce(
+  (accum, name) => ({
+    ...accum,
+    [name]: true,
+  }),
+  {} as Record<string, boolean>,
+);
+```
+
+## Promise Function Async
+
+----------
+
+In contrast, non-async Promise - returning functions are technically capable of either.
+Code that handles the results of those functions will often need to handle both cases,
+which can get complex. This rule's practice removes a requirement for creating code to handle both cases.
+
+<https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/docs/rules/promise-function-async.md>
+
+👍 Examples of correct code
+
+```typescript
+const arrowFunctionReturnsPromise = async () => Promise.resolve('value');
+
+async function functionReturnsPromise() {
+  return Promise.resolve('value');
+}
+```
+
+👎 Examples of incorrect code
+
+```typescript
+const arrowFunctionReturnsPromise = () => Promise.resolve('value');
+
+function functionReturnsPromise() {
+  return Promise.resolve('value');
+}
+```
+
+## Require Array Sort Compare
+
+----------
+
+When called without a compare function, Array#sort() converts all non-undefined array elements
+into strings and then compares said strings based off their UTF-16
+
+<https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/docs/rules/require-array-sort-compare.md>
+
+👍 Examples of correct code
+
+```typescript
+const array: any[];
+const userDefinedType: { sort(): void };
+
+array.sort((a, b) => a - b);
+array.sort((a, b) => a.localeCompare(b));
+
+userDefinedType.sort();
+
+const one = '1';
+const two = '2';
+const three = '3';
+[one, two, three].sort();
+```
+
+👎 Examples of incorrect code
+
+```typescript
+const array: any[];
+const stringArray: string[];
+
+array.sort();
+
+// String arrays should be sorted using `String#localeCompare`.
+stringArray.sort();
+```
+
+## Sort Type Constituents
+
+----------
+
+Sorting union (|) and intersection (&) types can help:
+
+keep your codebase standardized
+find repeated types
+reduce diff churn
+This rule reports on any types that aren't sorted alphabetically.
+
+<https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/docs/rules/sort-type-constituents.md>
+
+👍 Examples of correct code
+
+```typescript
+type T1 = A | B;
+
+type T2 = { a: string } & { b: string };
+
+type T3 = [1, 2, 3] & [1, 2, 4];
+
+type T4 =
+  | any
+  | string
+  | A
+  | B
+  | number[]
+  | string[]
+  | readonly number[]
+  | readonly string[]
+  | 'a'
+  | 'b'
+  | 'a'
+  | 'b'
+  | (() => string)
+  | (() => void)
+  | { a: string }
+  | { b: string }
+  | [1, 2, 3]
+  | [1, 2, 4];
+```
+
+👎 Examples of incorrect code
+
+```typescript
+type T1 = B | A;
+
+type T2 = { b: string } & { a: string };
+
+type T3 = [1, 2, 4] & [1, 2, 3];
+
+type T4 =
+  | [1, 2, 4]
+  | [1, 2, 3]
+  | { b: string }
+  | { a: string }
+  | (() => void)
+  | (() => string)
+  | 'b'
+  | 'a'
+  | 'b'
+  | 'a'
+  | readonly string[]
+  | readonly number[]
+  | string[]
+  | number[]
+  | B
+  | A
+  | string
+  | any;
+```
+
+## Space Before Blocks
+
+----------
+
+Consistency is an important part of any style guide. While it is a personal preference where to put the opening
+brace of blocks, it should be consistent across a whole project. Having an inconsistent style distracts the reader
+from seeing the important parts of the code.
+
+<https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/docs/rules/space-before-blocks.md>
+
+👍 Examples of correct code
+
+```typescript
+if (a) {
+    b();
+}
+
+if (a) {
+    b();
+} else{ /*no error. this is checked by `keyword-spacing` rule.*/
+    c();
+}
+
+class C {
+    static{} /*no error. this is checked by `keyword-spacing` rule.*/
+}
+
+function a() {}
+
+for (;;) {
+    b();
+}
+
+try {} catch(a) {}
+
+enum Breakpoint {
+  Large, Medium;
+}
+
+interface State {
+  currentBreakpoint: Breakpoint;
+}
+```
+
+👎 Examples of incorrect code
+
+```typescript
+if (a){
+    b();
+}
+
+function a(){}
+
+for (;;){
+    b();
+}
+
+try {} catch(a){}
+
+class Foo{
+  constructor(){}
+}
+
+enum Breakpoint{
+  Large, Medium;
+}
+
+interface State{
+  currentBreakpoint: Breakpoint;
+}
+```
+
 ## Performance
 
 ### No Alert
@@ -16655,7 +16971,7 @@ foo?.bar!;
 foo?.bar()!;
 ```
 
-## No Unsafe Declaration Merging
+### No Unsafe Declaration Merging
 
 ----------
 
@@ -16685,7 +17001,7 @@ interface Foo {}
 class Foo {}
 ```
 
-## No Useless Empty Export
+### No Useless Empty Export
 
 ----------
 
@@ -16712,6 +17028,229 @@ export const value = 'Hello, world!';
 import 'some-other-module';
 ```
 
+### Restrict Template Expressions
+
+----------
+
+JavaScript will call toString() on an object when it is converted to a string,
+such as when + adding to a string or in ${} template literals. The default Object .toString() returns "[object Object]",
+ which is often not what was intended. This rule reports on values used in a template literal string that aren't strings.
+ primitives and don't define a more useful .toString() method.
+
+<https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/docs/rules/restrict-template-expressions.md>
+
+👍 Examples of correct code
+
+```typescript
+const arg = 'foo';
+const msg1 = `arg = ${arg}`;
+const msg2 = `arg = ${arg || 'default'}`;
+
+const stringWithKindProp: string & { _kind?: 'MyString' } = 'foo';
+const msg3 = `stringWithKindProp = ${stringWithKindProp}`;
+
+const arg = 123;
+const msg1 = `arg = ${arg}`;
+const msg2 = `arg = ${arg || 'zero'}`;
+
+const arg = true;
+const msg1 = `arg = ${arg}`;
+const msg2 = `arg = ${arg || 'not truthy'}`;
+```
+
+👎 Examples of incorrect code
+
+```typescript
+const arg1 = [1, 2];
+const msg1 = `arg1 = ${arg1}`;
+
+const arg2 = { name: 'Foo' };
+const msg2 = `arg2 = ${arg2 || null}`;
+```
+
+### Return Await Try Catch
+
+----------
+
+Returning an awaited promise can make sense for better stack trace information as well as for consistent error
+handling (returned promises will not be caught in an async function try/catch).
+
+<https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/docs/rules/return-await.md>
+
+👍 Examples of correct code
+
+```typescript
+async function validInTryCatch1() {
+  try {
+    return await Promise.resolve('try');
+  } catch (e) {}
+}
+
+async function validInTryCatch2() {
+  try {
+    throw new Error('error');
+  } catch (e) {
+    return Promise.resolve('catch');
+  }
+}
+
+async function validInTryCatch3() {
+  try {
+    throw new Error('error');
+  } catch (e) {
+    return await Promise.resolve('catch');
+  } finally {
+    console.log('cleanup');
+  }
+}
+
+async function validInTryCatch4() {
+  try {
+    throw new Error('error');
+  } catch (e) {
+    throw new Error('error2');
+  } finally {
+    return Promise.resolve('finally');
+  }
+}
+
+async function validInTryCatch5() {
+  return Promise.resolve('try');
+}
+
+async function validInTryCatch6() {
+  return 'value';
+}
+```
+
+👎 Examples of incorrect code
+
+```typescript
+async function invalidInTryCatch1() {
+  try {
+    return Promise.resolve('try');
+  } catch (e) {}
+}
+
+async function invalidInTryCatch2() {
+  try {
+    throw new Error('error');
+  } catch (e) {
+    return await Promise.resolve('catch');
+  }
+}
+
+async function invalidInTryCatch3() {
+  try {
+    throw new Error('error');
+  } catch (e) {
+    return Promise.resolve('catch');
+  } finally {
+    console.log('cleanup');
+  }
+}
+
+async function invalidInTryCatch4() {
+  try {
+    throw new Error('error');
+  } catch (e) {
+    throw new Error('error2');
+  } finally {
+    return await Promise.resolve('finally');
+  }
+}
+
+async function invalidInTryCatch5() {
+  return await Promise.resolve('try');
+}
+
+async function invalidInTryCatch6() {
+  return await 'value';
+}
+```
+
+### Switch Exhaustiveness Check
+
+----------
+
+When working with union types in TypeScript, it's common to want to write a switch statement intended to contain a
+case for each constituent (possible type in the union). However, if the union type changes,
+it's easy to forget to modify the cases to account for any new types.
+
+<https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/docs/rules/switch-exhaustiveness-check.md>
+
+👍 Examples of correct code
+
+```typescript
+type Day =
+  | 'Monday'
+  | 'Tuesday'
+  | 'Wednesday'
+  | 'Thursday'
+  | 'Friday'
+  | 'Saturday'
+  | 'Sunday';
+
+const day = 'Monday' as Day;
+let result = 0;
+
+switch (day) {
+  case 'Monday':
+    result = 1;
+    break;
+  case 'Tuesday':
+    result = 2;
+    break;
+  case 'Wednesday':
+    result = 3;
+    break;
+  case 'Thursday':
+    result = 4;
+    break;
+  case 'Friday':
+    result = 5;
+    break;
+  case 'Saturday':
+    result = 6;
+    break;
+  case 'Sunday':
+    result = 7;
+    break;
+}
+
+// OR default
+
+switch (day) {
+  case 'Monday':
+    result = 1;
+    break;
+  default:
+    result = 42;
+}
+```
+
+👎 Examples of incorrect code
+
+```typescript
+type Day =
+  | 'Monday'
+  | 'Tuesday'
+  | 'Wednesday'
+  | 'Thursday'
+  | 'Friday'
+  | 'Saturday'
+  | 'Sunday';
+
+const day = 'Monday' as Day;
+let result = 0;
+
+switch (day) {
+  case 'Monday':
+    result = 1;
+    break;
+}
+```
+
 ## Yaml Json
 
 add suport yaml and json files

package/index.js

@@ -98,6 +98,7 @@ module.exports = {
                 ecmaFeatures: {
                     jsx: true,
                 },
+                warnOnUnsupportedTypeScriptVersion: false,
                 ecmaVersion: 2022,
                 sourceType: "module",
                 project: [ "tsconfig.json", "@odg/tsconfig/tsconfig.json" ], // Specify it only for TypeScript files

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@odg/eslint-config",
-    "version": "1.2.0",
+    "version": "1.3.0",
     "description": "Linter for JavaScript And Typescript project",
     "main": "index.js",
     "author": "Dragons Gamers <https://www.linkedin.com/in/victor-alves-odgodinho>",

package/rules/javascript/best-practices.js

@@ -9,6 +9,7 @@ module.exports = {
         "space-before-function-paren": [ "error", {
             anonymous: "never",
             named: "never",
+            asyncArrow: "always",
         } ], // Não permite espaço antes dos parenteses
         "no-unused-vars": [ "error", {
             "vars": "all",
@@ -234,6 +235,7 @@ module.exports = {
         "regexp/sort-character-class-elements": [ "error" ], // Coloque [] em ordem Alfabética
         "regexp/sort-flags": [ "error" ], // Flag em ordem alfabética
         "regexp/prefer-named-capture-group": [ "error" ], // Prefira group com nomes
+        "regexp/prefer-regexp-exec": [ "error" ], // Prefira exec em regex
         "max-statements-per-line": [ "error", { "max": 1 } ], // Máximo operação em 1 linha
         "arrow-parens": [ "error", "always" ], // Arrow Function sempre com parentese
         "padding-line-between-statements": [

package/rules/typescript/best-practices.js

@@ -143,7 +143,7 @@ module.exports = {
             after: true,
         } ],
         "no-underscore-dangle": [ "error" ], // Não permite _ no nome
-        "@typescript-eslint/prefer-return-this-type": [ "error" ], // Não permite _ no nome
+        "@typescript-eslint/prefer-return-this-type": [ "error" ], // Return this ao invés do nome classe
         "for-direction": [ "error" ], // Não faça for contador infinito.
         "no-shadow": [ "off" ], // Erro caso ja esteja declarado escopo a cima
         "@typescript-eslint/no-shadow": [ "error" ], // Erro caso ja esteja declarado escopo a cima
@@ -373,6 +373,7 @@ module.exports = {
                 ],
                 format: [
                     "strictCamelCase",
+                    "camelCase",
                 ],
 
                 // We allow double underscore because of GraphQL type names and some React names.
@@ -389,6 +390,7 @@ module.exports = {
                 selector: "classProperty",
                 format: [
                     "strictCamelCase",
+                    "camelCase",
                     "UPPER_CASE",
                 ],
             },
@@ -396,6 +398,7 @@ module.exports = {
                 selector: "typeLike",
                 format: [
                     "StrictPascalCase",
+                    "camelCase",
                 ],
             },
             {
@@ -486,5 +489,12 @@ module.exports = {
         ], // Use ?? em vez de ternário com &&
         "@typescript-eslint/prefer-optional-chain": [ "error" ], // Prefira Optional chain ao invés de &&.
         "@typescript-eslint/prefer-readonly": [ "error" ], // Prefira readonly
+        "@typescript-eslint/prefer-reduce-type-parameter": [ "error" ], // Use <> em reduce em vez de as default type
+        "@typescript-eslint/prefer-regexp-exec": [ "error" ], // Prefira regex exec
+        "@typescript-eslint/prefer-string-starts-ends-with": [ "error" ], // Prefira startsWith e endsWith
+        "@typescript-eslint/promise-function-async": [ "error" ], // Prefira async function quando retorna Promise
+        "@typescript-eslint/require-array-sort-compare": [ "error" ], // Passe parâmetro array sort
+        "@typescript-eslint/sort-type-constituents": [ "error" ], // Ordene agrupação de tipos
+        "@typescript-eslint/space-before-blocks": [ "error" ], // Espaço apos antes {} interface e enum
     }, // Convenção de nomes
 };

package/rules/typescript/possible-errors.js

@@ -11,5 +11,18 @@ module.exports = {
         ], // Não misture not null assert com optional
         "@typescript-eslint/no-unsafe-declaration-merging": [ "error" ], // Evita unir automaticamente tipos
         "@typescript-eslint/no-useless-empty-export": [ "error" ], // Bloqueia export vazio
+        "@typescript-eslint/restrict-template-expressions": [
+            "error",
+            {
+                allowNumber: true,
+                allowBoolean: true,
+            },
+        ], // Não concatene strings com tipos inválidos
+        "@typescript-eslint/return-await": [ "error" ], // Ao retornar um promise em try catch, use await evitando erros
+        "@typescript-eslint/switch-exhaustiveness-check": [
+            "error",
+        ], // Switch com typo coloque default ou todos os casos
+        "brace-style": [ "off" ], // Força formatação {}
+        "@typescript-eslint/brace-style": [ "error" ], // Força formatação {}
     },
 };