@odg/eslint-config 3.0.4 → 3.2.0

package/index.d.ts

@@ -1,4 +1,4 @@
-import type { Linter } from 'eslint';
+import type { Linter } from "eslint";
 
 /**
  * ODG ESLint Configuration
@@ -22,4 +22,4 @@ import type { Linter } from 'eslint';
  */
 declare const config: Linter.Config[];
 
-export default config;
+export default config;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@odg/eslint-config",
-    "version": "3.0.4",
+    "version": "3.2.0",
     "description": "Linter for JavaScript And Typescript project",
     "type": "module",
     "main": "index.mjs",

package/rules/any/base.mjs

@@ -6,9 +6,11 @@ export default {
             {
                 code: 120,
                 ignoreUrls: true,
-                ignoreStrings: true,
+                ignoreStrings: false,
                 ignoreTemplateLiterals: true,
                 ignoreRegExpLiterals: true,
+                ignoreComments: false,
+                ignoreTrailingComments: false,
             },
         ], // Caracteres máximo por linhas
     },

package/rules/global/base.mjs

@@ -1,6 +1,15 @@
 const indentSize = 4;
 const complexity = 15;
 const alwaysMultiline = "always-multiline";
+const multiLineBlock = "multiline-block-like";
+
+// 1. DEFINIÇÕES (Para deixar a regra limpa)
+const VARIABLES = [ "const", "let", "var" ];
+const EXPORTS = [ "export", "cjs-export" ];
+const IMPORTS = [ "import", "cjs-import" ];
+const TYPES = [ "interface", "type", "enum", "class" ];
+const FLOW_CONTROL = [ "if", "switch", "try", "for", "do", "while" ];
+const BLOCK_LIKE = [ "block-like", multiLineBlock ];
 
 export default {
     rules: {
@@ -86,6 +95,48 @@ export default {
         // "regexp/prefer-regexp-exec": [ "error" ], // Prefira exec em regex // Match retorna 1 resultado apenas
 
         "unicorn/no-empty-file": [ "error" ], // Não crie arquivo vazio
+        "unicorn/filename-case": [
+            "error",
+            {
+                "cases": {
+                    "kebabCase": true,
+                    "pascalCase": true,
+                },
+                "ignore": [ ".md$" ],
+            },
+        ],
+        "no-restricted-syntax": [
+            "error",
+            {
+                "selector": "NewExpression[callee.name='Error']",
+                "message": "Do not use 'new Error()'. Use the exception classes from the @odg/exception"
+                    + " package to maintain logging standardization.",
+            },
+            {
+                "selector": "CallExpression[callee.property.name='log']",
+                "message": "Do not use console.log. Use the @odg/log injected in the container to ensure traceability.",
+            },
+            {
+                "selector": "CallExpression[callee.property.name='forEach'][arguments.0.async=true]",
+                "message": "Do not use `.forEach` with async functions. `.forEach` does not wait for Promises."
+                    + " Use `for...of` or`Promise.all()` instead.",
+            },
+            {
+                "selector": "CallExpression[callee.property.name='waitForTimeout']",
+                "message": "The use of 'waitForTimeout' is prohibited because it's intimidating."
+                    + " Use 'waitForSelector', 'waitForResponse', or 'waitForFunction' instead.",
+            },
+            {
+                "selector": String.raw`CallExpression[callee.property.name=/^(click|waitForSelector|\$|\$\$|eval|type)$/][arguments.0.type='Literal'][arguments.0.value=/^[.#].*/]`,
+                "message": "Do not use hardcoded selectors."
+                    + " Move a string to a file in the 'Selectors' folder to ensure decoupling.",
+            },
+            {
+                "selector": "BinaryExpression[operator='instanceof'][right.name='Error']",
+                "message": "Avoid 'error instances'. Use the specific specifications of your @odg/exception"
+                    + "(Exception.isError) or structural type checking for greater security between packets.",
+            },
+        ],
         "no-magic-numbers": [
             "warn",
             {
@@ -193,6 +244,7 @@ export default {
                 allowBlockStart: true,
                 allowInterfaceStart: true,
                 allowTypeStart: true,
+                allowArrayStart: true,
             },
         ], // Linha em branco antes do comentário
         "@stylistic/lines-between-class-members": [
@@ -205,9 +257,11 @@ export default {
             {
                 code: 120,
                 ignoreUrls: true,
-                ignoreStrings: true,
+                ignoreStrings: false,
                 ignoreTemplateLiterals: true,
                 ignoreRegExpLiterals: true,
+                ignoreComments: false,
+                ignoreTrailingComments: false,
             },
         ], // Caracteres máximo por linhas
         "@stylistic/max-statements-per-line": [ "error", { max: 1 } ], // Máximo operação em 1 linha
@@ -323,16 +377,85 @@ export default {
         ], // Força não usar blocos com espaços
         "@stylistic/padding-line-between-statements": [
             "error",
-            { "blankLine": "always", "prev": "*", "next": "export" }, // Uma linha em branco antes do export
-            { "blankLine": "always", "prev": "export", "next": "*" }, // Uma linha em branco apos o export
-            { "blankLine": "always", "prev": "*", "next": "class" }, // Uma linha em branco antes da classe
-            { "blankLine": "always", "prev": "class", "next": "*" }, // Uma linha em branco apos a classe
-            { "blankLine": "always", "prev": "*", "next": "interface" }, // Uma linha em branco antes da interface
-            { "blankLine": "always", "prev": "interface", "next": "*" }, // Uma linha em branco apos a interface
-            { "blankLine": "always", "prev": "*", "next": "type" }, // Uma linha em branco antes do type
-            { "blankLine": "always", "prev": "type", "next": "*" }, // Uma linha em branco apos o type
-            { "blankLine": "always", "prev": "multiline-block-like", "next": "*" },
-            { "blankLine": "always", "prev": "*", "next": [ "enum", "interface", "type" ] },
+
+            /*
+             * ------------------------------------------------------
+             * 1. DIRETIVAS (ex: "use strict")
+             * ------------------------------------------------------
+             * Separa diretivas do resto do código
+             */
+            { "blankLine": "always", "prev": "directive", "next": "*" },
+            { "blankLine": "any", "prev": "directive", "next": "directive" },
+
+            /*
+             * ------------------------------------------------------
+             * 2. IMPORTS
+             * ------------------------------------------------------
+             * Imports sempre separados do código que vem depois
+             */
+            { "blankLine": "always", "prev": IMPORTS, "next": "*" },
+
+            // Entre imports, não força espaço (deixa agrupar)
+            { "blankLine": "any", "prev": IMPORTS, "next": IMPORTS },
+
+            /*
+             * ------------------------------------------------------
+             * 3. VARIÁVEIS
+             * ------------------------------------------------------
+             * A. REGRA GERAL: Variável seguida de *Qualquer coisa* = Espaço
+             */
+            { "blankLine": "always", "prev": VARIABLES, "next": "*" },
+
+            // B. EXCEÇÃO 1: Variável seguida de Variável = Pode colar
+            { "blankLine": "any", "prev": VARIABLES, "next": VARIABLES },
+
+            // C. EXCEÇÃO 2: Variável seguida de IF = Pode colar (Guard Clauses)
+            { "blankLine": "any", "prev": VARIABLES, "next": "if" },
+
+            /*
+             * ------------------------------------------------------
+             * 4. ESTRUTURAS DE TIPO (Types, Interfaces, Enums, Classes)
+             * ------------------------------------------------------
+             * Sempre dá espaço antes de declarar um tipo/classe
+             */
+            { "blankLine": "always", "prev": "*", "next": TYPES },
+
+            // Sempre dá espaço depois de declarar um tipo/classe
+            { "blankLine": "always", "prev": TYPES, "next": "*" },
+
+            /*
+             * ------------------------------------------------------
+             * 5. FLUXO E LÓGICA (If, For, While, Return)
+             * ------------------------------------------------------
+             * Espaço antes de comandos de saída (return, throw, break)
+             */
+            { "blankLine": "always", "prev": "*", "next": [ "return", "throw", "break", "continue" ] },
+
+            // Espaço ao redor de blocos de controle (if, for, while)
+            { "blankLine": "always", "prev": "*", "next": [ ...BLOCK_LIKE, ...FLOW_CONTROL ] },
+            { "blankLine": "always", "prev": [ ...BLOCK_LIKE, ...FLOW_CONTROL ], "next": "*" },
+
+            // EXCEÇÃO: IF seguido de IF (if-inline vai funcionar)
+            { "blankLine": "any", "prev": "if", "next": "if" },
+
+            /*
+             * ------------------------------------------------------
+             * 6. EXPORTS
+             * ------------------------------------------------------
+             * Export sempre isolado (antes e depois)
+             */
+            { "blankLine": "always", "prev": "*", "next": EXPORTS },
+            { "blankLine": "always", "prev": EXPORTS, "next": EXPORTS },
+
+            /*
+             * ------------------------------------------------------
+             * 7. O MARTELO (Regras de Segurança para Blocos Grandes)
+             * ------------------------------------------------------
+             * Se qualquer coisa for seguida por um bloco multilinha, OBRIGA espaço.
+             * Isso garante que se o seu 'if' colado crescer e virar um bloco, ele ganha espaço.
+             */
+            { "blankLine": "always", "prev": "*", "next": multiLineBlock },
+            { "blankLine": "always", "prev": multiLineBlock, "next": "*" },
         ],
         "@stylistic/quote-props": [ "error", "consistent" ], // Objeto com aspas ou sem consistent
         "@stylistic/quotes": [ "error", "double" ], // Força aspas dupla
@@ -344,10 +467,10 @@ export default {
         "@stylistic/space-before-function-paren": [
             "error",
             {
-                anonymous: "never",
-                named: "never",
-                asyncArrow: "always",
-                catch: "always",
+                "anonymous": "never",
+                "named": "never",
+                "asyncArrow": "always",
+                "catch": "always",
             },
         ], // Não permite espaço antes dos parenteses
         "@stylistic/space-in-parens": [ "error", "never" ], // Não permite espaço entre parenteses
@@ -358,7 +481,6 @@ export default {
                 words: true, // Espaço apos Await e palavras chaves
                 nonwords: false, // Força nao ter espaço antes de operadores unários !, -, +
                 overrides: {
-                    "new": false,
                     "++": false, // Nao permite espaço no ++
                 },
             },

package/rules/ini/base.mjs

@@ -6,9 +6,11 @@ export default {
             {
                 code: 120,
                 ignoreUrls: true,
-                ignoreStrings: true,
+                ignoreStrings: false,
                 ignoreTemplateLiterals: true,
                 ignoreRegExpLiterals: true,
+                ignoreComments: false,
+                ignoreTrailingComments: false,
             },
         ], // Caracteres máximo por linhas
         "toml/indent": [ "error" ], // Indent

package/rules/javascript/best-practices.mjs

@@ -343,6 +343,84 @@ export default {
         "vars-on-top": [ "error" ], // Caso a regra de var seja desativa elas devem ficar no topo
         "strict": [ "error" ], // Strict javascript top file
         "no-shadow-restricted-names": [ "error" ], // Sem variável com palavra reservada
+        "id-denylist": [
+            "error",
+
+            // Tipos TS
+            "number",
+            "string",
+            "boolean",
+            "any",
+            "void",
+            "never",
+            "unknown",
+
+            // Controle de Fluxo
+            "yield",
+            "await",
+            "async",
+
+            // Modificadores de Acesso
+            "public",
+            "protected",
+            "private",
+            "readonly",
+            "static",
+
+            // Estrutura
+            "class",
+            "interface",
+            "type",
+            "enum",
+            "namespace",
+            "module",
+
+            // Declaração
+            "function",
+            "var",
+            "let",
+            "const",
+
+            // Condicionais/Loops
+            "if",
+            "else",
+            "for",
+            "while",
+            "do",
+            "switch",
+            "case",
+            "default",
+
+            // Exceções
+            "try",
+            "catch",
+            "finally",
+            "throw",
+
+            // Módulos
+            "import",
+            "export",
+            "from",
+            "as",
+
+            // POO
+            "this",
+            "super",
+            "new",
+            "extends",
+            "implements",
+
+            // Genéricos proibidos
+            "data",
+            "val",
+            "obj",
+            "item",
+            "list",
+            "res",
+            "req",
+
+            // "callback", Callback parâmetro é bloqueado tb
+        ], // Sem variável com palavra reservada
         "logical-assignment-operators": [ "error", "always" ], // Faça ||= ao invés a = a || b
         "no-with": [ "error" ], // Não use with
 

package/rules/json/base.mjs

@@ -19,9 +19,11 @@ export default {
             {
                 code: 120,
                 ignoreUrls: true,
-                ignoreStrings: true,
+                ignoreStrings: false,
                 ignoreTemplateLiterals: true,
                 ignoreRegExpLiterals: true,
+                ignoreComments: false,
+                ignoreTrailingComments: false,
             },
         ], // Caracteres máximo por linhas
         "jsonc/no-irregular-whitespace": [ "error" ], // Não faça espaço irregular

package/rules/typescript/best-practices.mjs

@@ -14,20 +14,20 @@ const allAccessibility = [
 /**
  * Order member of class
  *
- * @param {Array<string>} types Tags name position
+ * @param {Array<string>} propertyTypes Tags name position
  * @param {string} tag Type of order
  * @param {Array<string>} accessibilityList Accessibility list of class
  * @returns {Array<string>}
  */
-function orderMember(types, tag, accessibilityList) {
+function orderMember(propertyTypes, tag, accessibilityList) {
     return [
-        ...accessibilityList.flatMap((accessibility) => types.map(
-            (type) => {
+        ...accessibilityList.flatMap((accessibility) => propertyTypes.map(
+            (propertyType) => {
                 const accessibilityName = accessibility ? `${accessibility}-` : "";
 
-                if (accessibility === "private" && type === "abstract") return "";
+                if (accessibility === "private" && propertyType === "abstract") return "";
 
-                return `${accessibilityName}${type}-${tag}`;
+                return `${accessibilityName}${propertyType}-${tag}`;
             },
         )).filter(Boolean),
         `${tag}`,
@@ -61,6 +61,7 @@ export default {
         ], // Não Crie tipos vazios
         "@typescript-eslint/no-import-type-side-effects": [ "error" ], // Coloque type fora para n importar no build
         "@typescript-eslint/explicit-function-return-type": [ "error" ], // Força tipo de retorno
+        "@typescript-eslint/explicit-module-boundary-types": [ "error" ], // Força tipo de retorno
         "no-unused-vars": [ "off" ], // Não permite variáveis não utilizadas
         "@typescript-eslint/no-unused-vars": [
             "error",
@@ -94,8 +95,8 @@ export default {
         "@typescript-eslint/array-type": [
             "error",
             {
-                default: "array-simple",
-                readonly: "array-simple",
+                "default": "array-simple",
+                "readonly": "array-simple",
             },
         ], // Não permite tipos de array incorretos
         "jsdoc/require-returns-check": [ "off" ],
@@ -104,7 +105,7 @@ export default {
             "error",
             "method",
         ], // Use arrow function em method signature interface
-        "@typescript-eslint/no-unnecessary-type-assertion": [ "error" ], // Não permite declaração que não altera expressão
+        "@typescript-eslint/no-unnecessary-type-assertion": [ "error" ], // Não As declaração que não altera expressão
         "@typescript-eslint/no-unsafe-call": [ "error" ], // Não permite chamadas de funções em tipo any
         "space-infix-ops": [ "off" ], // Espaço na separação operadores
         "no-underscore-dangle": [ "error" ], // Não permite _ no nome
@@ -166,6 +167,7 @@ export default {
                     "call-signature",
 
                     ...orderMember([ "static", "decorated", "instance" ], "field", allAccessibility),
+                    ...orderMember([ "abstract" ], "field", allAccessibility),
 
                     // Static initialization
                     "static-initialization",
@@ -184,7 +186,6 @@ export default {
 
                     // Methods
                     ...orderMember([ "static", "decorated", "instance" ], "method", allAccessibility),
-                    ...orderMember([ "abstract" ], "field", allAccessibility),
                     ...orderMember([ "abstract" ], "method", allAccessibility),
                 ],
             },
@@ -202,6 +203,7 @@ export default {
                     "[accessors]",
                     "[setters]",
                     "[non-accessors]",
+                    "[static-methods]",
                     "[methods]",
                     "[conventional-private-methods]",
                     "[readonly]",

package/rules/yaml/base.mjs

@@ -26,9 +26,11 @@ export default {
             {
                 code: 120,
                 ignoreUrls: true,
-                ignoreStrings: true,
+                ignoreStrings: false,
                 ignoreTemplateLiterals: true,
                 ignoreRegExpLiterals: true,
+                ignoreComments: false,
+                ignoreTrailingComments: false,
             },
         ], // Caracteres máximo por linhas
     },