@mocoto/mahoraga 0.14.8 → 0.14.9

package/dist/analysts/js-ts/detectors/detector-interfaces-inline.js

@@ -1,27 +1,9 @@
-// @mahoraga-disable ml-deep-nesting
-// SPDX-License-Identifier: MIT
-/**
- * Detector de Interfaces Inline
- * Identifica definições de interfaces e tipos complexos inline que deveriam estar em arquivos de tipos
- *
- * Estratégia:
- * - Detecta interfaces inline em funções, classes e variáveis
- * - Identifica tipos complexos que deveriam ser extraídos
- * - Sugere movimentação para o diretório de tipos configurado (conventions.typesDirectory)
- * - Analisa reutilização e complexidade para priorizar extrações
- */
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import { buildTypesFsPath, getTypesDirectoryDisplay, isInsideTypesDirectory } from '../../../core/config/index.js';
 import { messages } from '../../../core/messages/index.js';
 import { isInStringOrComment } from '../../../shared/helpers/index.js';
-/**
- * Cache de tipos existentes escaneados do diretório de tipos
- */
 let tiposExistentesCache = null;
-/**
- * Escaneia o diretório de tipos para encontrar nomes de tipos/interfaces já existentes.
- */
 async function scanExistingTypeNames() {
     if (tiposExistentesCache) {
         return tiposExistentesCache;
@@ -32,7 +14,6 @@ async function scanExistingTypeNames() {
         await scanDirForTypeNames(tiposDir, names);
     }
     catch {
-        // Diretório pode não existir
     }
     tiposExistentesCache = names;
     return names;
@@ -59,13 +40,11 @@ async function scanDirForTypeNames(dir, names) {
                     }
                 }
                 catch {
-                    // Ignorar erros de leitura
                 }
             }
         }
     }
     catch {
-        // Ignorar erros de leitura ou diretório inexistente
     }
 }
 const ANALISTA = {
@@ -73,19 +52,15 @@ const ANALISTA = {
     categoria: 'code-organization',
     descricao: 'Detecta interfaces e tipos complexos inline que deveriam estar em arquivos de tipos',
     test: (relPath) => {
-        // Não analisar arquivos que já estão na pasta de tipos
         if (isInsideTypesDirectory(relPath)) {
             return false;
         }
-        // Não analisar arquivos de definição de tipos do TypeScript
         if (relPath.endsWith('.d.ts')) {
             return false;
         }
-        // Não analisar arquivos deprecados
         if (relPath.includes('/.deprecados/') || relPath.includes('\\.deprecados\\')) {
             return false;
         }
-        // Não analisar node_modules
         if (relPath.includes('/node_modules/') || relPath.includes('\\node_modules\\')) {
             return false;
         }
@@ -93,11 +68,8 @@ const ANALISTA = {
     },
     aplicar: async (srcParam, relPath, _ast, _fullPath) => {
         const ocorrencias = [];
-        // Normalização de line endings
         const src = srcParam.replace(/\r\n/g, '\n');
         const _linhas = src.split('\n');
-        // 1. Detectar interfaces inline em funções EXPORTADAS
-        // Funções locais podem ter tipos inline simples sem problema
         const interfaceInlinePadrao = /export\s+function\s+\w+\s*\([^)]*\):\s*{[^}]+}/g;
         let match;
         while ((match = interfaceInlinePadrao.exec(src)) !== null) {
@@ -107,13 +79,10 @@ const ANALISTA = {
                 continue;
             }
             const detection = analyzeInlineInterface(match[0], linha, 'function-return');
-            // Aumentar threshold para 5 propriedades em tipos de retorno
             if (detection && detection.complexidade >= 5) {
                 ocorrencias.push(createOcorrencia(detection, relPath));
             }
         }
-        // 2. Detectar tipos literais complexos em parâmetros
-        // Apenas reportar parâmetros realmente complexos (5+ propriedades)
         const complexParamPadrao = /\w+\s*:\s*{\s*[^}]+;\s*[^}]+;\s*[^}]+}/g;
         while ((match = complexParamPadrao.exec(src)) !== null) {
             const position = match.index ?? 0;
@@ -122,13 +91,10 @@ const ANALISTA = {
                 continue;
             }
             const detection = analyzeInlineInterface(match[0], linha, 'parameter');
-            // Aumentar threshold para 5 propriedades em parâmetros
             if (detection && detection.complexidade >= 5) {
                 ocorrencias.push(createOcorrencia(detection, relPath));
             }
         }
-        // 3. Detectar type aliases inline com uniões complexas
-        // Buscar declarações de type e depois extrair o conteúdo completo
         const typeInicioPadrao = /type\s+(\w+)\s*=/g;
         let startMatch;
         while ((startMatch = typeInicioPadrao.exec(src)) !== null) {
@@ -137,7 +103,6 @@ const ANALISTA = {
             if (isInStringOrComment(src, position)) {
                 continue;
             }
-            // Extrair o tipo completo (até o próximo ponto-e-vírgula no nível raiz)
             const afterEquals = src.substring(position + startMatch[0].length);
             const tipoCompleto = extractTypeDefinition(afterEquals);
             if (!tipoCompleto) {
@@ -145,7 +110,6 @@ const ANALISTA = {
             }
             const linha = src.substring(0, position).split('\n').length;
             const complexidade = calculateComplexidade(tipoCompleto);
-            // Aumentar threshold para 5 propriedades em type aliases
             if (complexidade >= 5) {
                 const detection = {
                     tipo: 'type-alias',
@@ -158,8 +122,6 @@ const ANALISTA = {
                 ocorrencias.push(createOcorrencia(detection, relPath));
             }
         }
-        // 4. Detectar interfaces exportadas inline (PRIORIDADE MÁXIMA)
-        // Pattern para capturar 'export interface Nome' de forma precisa
         const exportInterfacePadrao = /export\s+interface\s+(\w+)\s*(<[^>]*>)?\s*\{/g;
         const existingTypes = await scanExistingTypeNames();
         while ((match = exportInterfacePadrao.exec(src)) !== null) {
@@ -169,11 +131,9 @@ const ANALISTA = {
             if (isInStringOrComment(src, position)) {
                 continue;
             }
-            // Pular interfaces que são específicas de módulo (usam o nome do módulo como prefixo)
             if (isInterfaceEspecificaDeModulo(nomeInterface, relPath)) {
                 continue;
             }
-            // Se já existe um tipo com mesmo nome no diretório de tipos, sugerir reutilização
             if (existingTypes.has(nomeInterface)) {
                 const detection = {
                     tipo: 'interface',
@@ -186,22 +146,16 @@ const ANALISTA = {
                 ocorrencias.push(createOcorrencia(detection, relPath));
                 continue;
             }
-            // Interfaces exportadas SEMPRE devem estar em tipos/
             const detection = {
                 tipo: 'interface',
                 nome: nomeInterface,
                 linha,
                 complexidade: 0,
-                // Não importa - exportada sempre reporta
                 contexto: `export interface ${nomeInterface}`,
                 sugestao: messages.DetectorInterfacesInlineMensagens.interfaceExportadaParaTipos(nomeInterface)
             };
             ocorrencias.push(createOcorrencia(detection, relPath));
         }
-        // 5. Detectar interfaces declaradas inline (não exportadas, mas complexas)
-        // Pattern melhorado para capturar interfaces multi-linha
-        // NOTA: Interfaces não exportadas são inerentemente locais ao módulo.
-        // Só reportamos as extremamente complexas (>=10) para evitar ruído.
         const interfaceDeclarationPadrao = /(?<!export\s+)interface\s+(\w+)\s*\{[\s\S]+?\}/g;
         while ((match = interfaceDeclarationPadrao.exec(src)) !== null) {
             const position = match.index ?? 0;
@@ -210,12 +164,10 @@ const ANALISTA = {
             if (isInStringOrComment(src, position)) {
                 continue;
             }
-            // Verificar se não foi já detectada como exportada
             const jaDetetada = ocorrencias.some(ocorrencia => ocorrencia.linha === linha && ocorrencia.mensagem.includes(nomeInterface));
             if (jaDetetada) {
                 continue;
             }
-            // Só reportar interfaces não exportadas se forem extremamente complexas (>=10)
             const interfaceCompleta = match[0];
             const complexidade = calculateComplexidade(interfaceCompleta);
             if (complexidade >= 10) {
@@ -230,16 +182,13 @@ const ANALISTA = {
                 ocorrencias.push(createOcorrencia(detection, relPath));
             }
         }
-        // 6. Detectar tipos inline repetidos (possível duplicação)
         const tiposInline = extractAllInlineTypes(src);
         const tiposRepetidos = findDuplicateTypes(tiposInline);
         for (const [estrutura, ocorrenciasArray] of tiposRepetidos.entries()) {
             const totalOcorrencias = ocorrenciasArray.length;
             const primeiraOcorrencia = ocorrenciasArray[0];
-            // Extrair assinatura das propriedades para mensagem
             const propriedades = estrutura.split(';').map(caminho => caminho.split(':')[0]).slice(0, 3);
             const nomesSugeridos = propriedades.join('_');
-            // Detectar contextos de uso
             const contextosUnicos = [...new Set(ocorrenciasArray.map(ocorrencia => ocorrencia.contexto))];
             const contextoDesc = contextosUnicos.length > 1 ? `em ${contextosUnicos.length} contextos diferentes` : 'no mesmo contexto';
             ocorrencias.push({
@@ -265,13 +214,9 @@ const ANALISTA = {
     }
 };
 export const detectorInterfacesInline = ANALISTA;
-/**
- * Analisa uma interface inline e determina se deve ser extraída
- */
 function analyzeInlineInterface(code, linha, contexto) {
     const tiposDirDisplay = getTypesDirectoryDisplay();
     const complexidade = calculateComplexidade(code);
-    // Só reportar se for realmente complexo (5+ propriedades)
     if (complexidade < 5) {
         return null;
     }
@@ -295,66 +240,41 @@ function analyzeInlineInterface(code, linha, contexto) {
         sugestao
     };
 }
-/**
- * Calcula complexidade de um tipo baseado em propriedades, união, interseção, etc
- */
 function calculateComplexidade(tipoString) {
     let score = 0;
-    // Contar propriedades: cada `;` ou `,` seguido de algo indica uma propriedade
-    // Também conta `:` para capturar propriedades sem separador final
     const propriedadesMultilinha = (tipoString.match(/[;:]\s*\n/g) ?? []).length;
     const propriedadesInline = (tipoString.match(/;\s*\w+\s*:/g) ?? []).length;
     const propriedadesTotal = (tipoString.match(/\w+\s*\??\s*:/g) ?? []).length;
-    // Usar o maior valor entre as contagens (sem fator de redução para inline)
     score += Math.max(propriedadesMultilinha, propriedadesInline + 1, propriedadesTotal);
-    // Contar operadores de união
     const unioes = (tipoString.match(/\|/g) ?? []).length;
     score += unioes * 0.5;
-    // Contar operadores de interseção
     const intersecoes = (tipoString.match(/&/g) ?? []).length;
     score += intersecoes * 0.5;
-    // Contar genéricos aninhados
     const genericosAninhados = (tipoString.match(/<[^>]*</g) ?? []).length;
     score += genericosAninhados * 2;
-    // Contar arrays e objetos aninhados
     const aninhamento = (tipoString.match(/{\s*\w+\s*:/g) ?? []).length;
     score += aninhamento;
     return Math.floor(score);
 }
-/**
- * Extrai estrutura normalizada de propriedades de um tipo objeto
- */
 function extractTypeStructure(tipoString) {
-    // Extrair apenas nomes e tipos das propriedades, ignorando valores específicos
     const props = [];
-    // Pattern melhorado para capturar propriedades com seus tipos
     const propPadrao = /(\w+)\??\s*:\s*([^;,}]+)/g;
     let match;
     while ((match = propPadrao.exec(tipoString)) !== null) {
         const propNome = match[1];
         let propTipo = match[2].trim();
-        // Normalizar tipos comuns
         propTipo = propTipo.replace(/\s+/g, ' ').replace(/string|number|boolean|null|undefined/gi, metrica => metrica.toLowerCase()).replace(/\[\]/g, 'Array').replace(/Record<[^>]+>/g, 'Record').replace(/Promise<[^>]+>/g, 'Promise').trim();
         props.push(`${propNome}:${propTipo}`);
     }
-    // Retornar assinatura normalizada ordenada
     return props.sort().join(';');
 }
-/**
- * Extrai todos os tipos inline do código com estrutura normalizada
- */
 function extractAllInlineTypes(src) {
     const tipos = [];
-    // Pattern melhorado para capturar objetos tipo literal (incluindo multi-linha)
-    // Procura por padrões como: { prop: type, ... } em contextos de tipo
     const lines = src.split('\n');
     for (let indice = 0; indice < lines.length; indice++) {
         const line = lines[indice];
-        // Detectar início de tipo objeto literal
-        // Contextos: : { ... }, < { ... }, = { ... } (em tipos, não valores)
         const typeObjInicio = /[:=<]\s*\{\s*$/;
         const inlineTipoObj = /:\s*\{[^}]+\}/g;
-        // Tentar match inline simples primeiro
         let match;
         while ((match = inlineTipoObj.exec(line)) !== null) {
             const matchIndex = match.index ?? 0;
@@ -375,7 +295,6 @@ function extractAllInlineTypes(src) {
                 }
             }
         }
-        // Detectar objetos tipo multi-linha
         if (typeObjInicio.test(line) && !line.includes('//')) {
             let depth = 1;
             const tipoLines = ['{'];
@@ -383,7 +302,6 @@ function extractAllInlineTypes(src) {
             while (innerIndice < lines.length && depth > 0) {
                 const nextLine = lines[innerIndice];
                 tipoLines.push(nextLine);
-                // Contar abertura/fechamento de chaves (simplificado)
                 for (const char of nextLine) {
                     if (char === '{') {
                         depth++;
@@ -422,12 +340,8 @@ function extractAllInlineTypes(src) {
     }
     return tipos;
 }
-/**
- * Encontra tipos inline duplicados com base na estrutura normalizada
- */
 function findDuplicateTypes(tipos) {
     const mapa = new Map();
-    // Agrupar por estrutura normalizada (não por tipo literal exato)
     for (const { estrutura, linha, tipo, contexto } of tipos) {
         if (!mapa.has(estrutura)) {
             mapa.set(estrutura, []);
@@ -441,12 +355,8 @@ function findDuplicateTypes(tipos) {
             });
         }
     }
-    // Filtrar apenas duplicados significativos
     const duplicados = new Map();
     for (const [estrutura, ocorrencias] of mapa.entries()) {
-        // Critérios mais refinados:
-        // - >= 4 ocorrências: duplicação clara que deve ser extraída
-        // - >= 3 ocorrências com contextos diferentes: possível tipo comum
         const contextosUnicos = new Set(ocorrencias.map(ocorrencia => ocorrencia.contexto)).size;
         if (ocorrencias.length >= 4 || ocorrencias.length >= 3 && contextosUnicos >= 2) {
             duplicados.set(estrutura, ocorrencias);
@@ -454,9 +364,6 @@ function findDuplicateTypes(tipos) {
     }
     return duplicados;
 }
-/**
- * Cria ocorrência a partir de uma detecção
- */
 function createOcorrencia(detection, relPath) {
     const tiposDirDisplay = getTypesDirectoryDisplay();
     let tipo = '';
@@ -487,28 +394,18 @@ function createOcorrencia(detection, relPath) {
         linha: detection.linha
     };
 }
-/**
- * Verifica se uma interface parece ser específica de um módulo
- * com base no nome e no caminho do arquivo.
- * Interfaces específicas de módulo não devem ser extraídas para types/
- * pois quebram o encapsulamento.
- */
 function isInterfaceEspecificaDeModulo(nomeInterface, relPath) {
     const pathLower = relPath.toLowerCase();
     const nomeLower = nomeInterface.toLowerCase();
-    // Se o arquivo está em diretórios de módulo conhecidos, provavelmente é específica
     if (/analistas\/[^/]+\/(corrections|pontuadores|relatorios|analistas)\//.test(pathLower)) {
         return true;
     }
-    // Extrair possíveis prefixos de módulo do caminho
     const moduleMatch = pathLower.match(/(?:analistas|integrations)\/([^/]+)/);
     if (moduleMatch) {
         const moduleName = moduleMatch[1].toLowerCase();
-        // Se o nome da interface começa com o nome do módulo (ex: AzureCorrection em azure/)
         if (nomeLower.startsWith(moduleName)) {
             return true;
         }
-        // Verificar também camelCase/PascalCase: "CircleCI" vs "circleci"
         const parts = moduleName.split(/[-_]/);
         for (const part of parts) {
             if (part.length >= 3 && nomeLower.startsWith(part)) {
@@ -518,9 +415,6 @@ function isInterfaceEspecificaDeModulo(nomeInterface, relPath) {
     }
     return false;
 }
-/**
- * Extrai definição completa de um tipo a partir do ponto após o '='
- */
 function extractTypeDefinition(afterEquals) {
     let depth = 0;
     let inString = false;
@@ -529,7 +423,6 @@ function extractTypeDefinition(afterEquals) {
     for (let indice = 0; indice < afterEquals.length; indice++) {
         const char = afterEquals[indice];
         const prevChar = indice > 0 ? afterEquals[indice - 1] : '';
-        // Controle de strings
         if ((char === '"' || char === "'" || char === '`') && prevChar !== '\\') {
             if (inString && char === stringChar) {
                 inString = false;
@@ -543,7 +436,6 @@ function extractTypeDefinition(afterEquals) {
             result += char;
             continue;
         }
-        // Contar chaves
         if (char === '{' || char === '<' || char === '[' || char === '(') {
             depth++;
         }
@@ -551,7 +443,6 @@ function extractTypeDefinition(afterEquals) {
             depth--;
         }
         result += char;
-        // Parar no ponto-e-vírgula no nível raiz
         if (char === ';' && depth === 0) {
             return result;
         }

package/dist/analysts/js-ts/detectors/detector-leaks-memory.js

@@ -13,12 +13,10 @@ const visitorMemoria = {
                     lines.add(path.node.loc?.start.line ?? 0);
                 }
             }
-            // Check for cleanup calls to see if they exist in the file
             if (callee.type === 'Identifier' && callee.name === cleanupName) {
-                lines.delete(0); // mark that cleanup exists
+                lines.delete(0);
             }
         };
-        // setInterval without clearInterval
         if (callee.type === 'Identifier' && callee.name === 'setInterval') {
             const parent = path.parent;
             if (parent.type !== 'VariableDeclarator' && parent.type !== 'AssignmentExpression') {
@@ -37,7 +35,6 @@ const visitorMemoria = {
         if (callee.type === 'Identifier' && callee.name === 'clearInterval') {
             state.setIntervalIds.delete(path.node.loc?.start.line.toString() ?? '0');
         }
-        // setInterval via window
         if (callee.type === 'MemberExpression') {
             const prop = callee.property;
             const propName = prop.type === 'Identifier' ? prop.name : '';
@@ -55,7 +52,6 @@ const visitorMemoria = {
                     });
                 }
             }
-            // addEventListener without cleanup
             if (propName === 'addEventListener') {
                 state.addEventListenerLines.add(path.node.loc?.start.line ?? 0);
                 const isGlobal = callee.object.type === 'Identifier' && ['window', 'document', 'body'].includes(callee.object.name);
@@ -63,25 +59,21 @@ const visitorMemoria = {
                     state.hasGlobalListeners = true;
                 }
             }
-            // removeEventListener - marks cleanup
             if (propName === 'removeEventListener') {
                 state.addEventListenerLines.delete(0);
             }
-            // Observer without disconnect
             if (propName === 'observe' && callee.object.type === 'Identifier') {
                 state.observerCalls.add(path.node.loc?.start.line ?? 0);
             }
             if (propName === 'disconnect') {
                 state.observerCalls.delete(0);
             }
-            // WebSocket without close
             if (propName === 'send' && callee.object.type === 'Identifier') {
                 state.webSocketCalls.add(path.node.loc?.start.line ?? 0);
             }
             if (propName === 'close') {
                 state.webSocketCalls.delete(0);
             }
-            // Worker without terminate
             if (callee.object.type === 'NewExpression' && callee.object.callee.type === 'Identifier' && callee.object.callee.name === 'Worker') {
                 state.workerCalls.add(path.node.loc?.start.line ?? 0);
             }
@@ -89,15 +81,12 @@ const visitorMemoria = {
                 state.workerCalls.delete(0);
             }
         }
-        // new Worker(...) detection
         if (callee.type === 'Identifier' && callee.name === 'Worker' && path.node.arguments.length > 0) {
             state.workerCalls.add(path.node.loc?.start.line ?? 0);
         }
-        // new WebSocket(...) detection
         if (callee.type === 'Identifier' && callee.name === 'WebSocket' && path.node.arguments.length > 0) {
             state.webSocketCalls.add(path.node.loc?.start.line ?? 0);
         }
-        // new MutationObserver / IntersectionObserver
         if (callee.type === 'Identifier' && (callee.name === 'MutationObserver' || callee.name === 'IntersectionObserver' || callee.name === 'ResizeObserver')) {
             state.observerCalls.add(path.node.loc?.start.line ?? 0);
         }
@@ -106,7 +95,6 @@ const visitorMemoria = {
         if (!textoTitulo.isFunctionExpression(path.node) && !textoTitulo.isFunctionDeclaration(path.node)) {
             return;
         }
-        // Detect closures that return functions referencing large objects
         if (textoTitulo.isBlockStatement(path.node.body)) {
             let hasReturnFunction = false;
             let referencesLargeData = false;
@@ -125,7 +113,6 @@ const visitorMemoria = {
                 });
             }
             catch { }
-            /* eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- path.traverse callbacks set these synchronously */
             if (hasReturnFunction && referencesLargeData) {
                 state.closureLargeObjects.add(path.node.loc?.start.line ?? 0);
                 state.ocorrencias.push({
@@ -141,7 +128,6 @@ const visitorMemoria = {
         }
     },
     AssignmentExpression(path, state) {
-        // Global variable growth detection
         if (state.currentLoopDepth > 0 && textoTitulo.isMemberExpression(path.node.left)) {
             const obj = path.node.left.object;
             if (textoTitulo.isIdentifier(obj) && (obj.name === 'global' || obj.name === 'globalThis' || obj.name === 'window')) {