@mocoto/mahoraga 0.14.0 → 0.14.1

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

@@ -1,18 +1,37 @@
+// 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)
+    if (tiposExistentesCache) {
         return tiposExistentesCache;
+    }
     const names = new Set();
     try {
         const tiposDir = buildTypesFsPath('');
         await scanDirForTypeNames(tiposDir, names);
     }
     catch {
+        // Diretório pode não existir
     }
     tiposExistentesCache = names;
     return names;
@@ -31,17 +50,21 @@ async function scanDirForTypeNames(dir, names) {
                     const interfaceRe = /export\s+(?:default\s+)?interface\s+(\w+)/g;
                     const typeRe = /export\s+(?:default\s+)?type\s+(\w+)/g;
                     let m;
-                    while ((m = interfaceRe.exec(content)) !== null)
+                    while ((m = interfaceRe.exec(content)) !== null) {
                         names.add(m[1]);
-                    while ((m = typeRe.exec(content)) !== null)
+                    }
+                    while ((m = typeRe.exec(content)) !== null) {
                         names.add(m[1]);
+                    }
                 }
                 catch {
+                    // Ignorar erros de leitura
                 }
             }
         }
     }
     catch {
+        // Ignorar erros de leitura ou diretório inexistente
     }
 }
 const ANALISTA = {
@@ -49,15 +72,19 @@ 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;
         }
@@ -65,41 +92,51 @@ 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) {
-            const position = match.index || 0;
+            const position = match.index ?? 0;
             const linha = src.substring(0, position).split('\n').length;
             if (isInStringOrComment(src, position)) {
                 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;
+            const position = match.index ?? 0;
             const linha = src.substring(0, position).split('\n').length;
             if (isInStringOrComment(src, position)) {
                 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) {
-            const position = startMatch.index || 0;
+            const position = startMatch.index ?? 0;
             const nomeTipo = startMatch[1];
             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) {
@@ -107,6 +144,7 @@ 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',
@@ -119,18 +157,22 @@ 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) {
-            const position = match.index || 0;
+            const position = match.index ?? 0;
             const linha = src.substring(0, position).split('\n').length;
             const nomeInterface = match[1];
             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',
@@ -143,28 +185,36 @@ 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;
+            const position = match.index ?? 0;
             const linha = src.substring(0, position).split('\n').length;
             const nomeInterface = match[1];
             if (isInStringOrComment(src, position)) {
                 continue;
             }
-            const jaDetetada = ocorrencias.some(ocorrencia => ocorrencia.linha === linha && ocorrencia.mensagem?.includes(nomeInterface));
+            // 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) {
@@ -179,13 +229,16 @@ 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({
@@ -211,9 +264,13 @@ 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;
     }
@@ -237,41 +294,66 @@ 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;
-    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;
+    // 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);
-    const unioes = (tipoString.match(/\|/g) || []).length;
+    // Contar operadores de união
+    const unioes = (tipoString.match(/\|/g) ?? []).length;
     score += unioes * 0.5;
-    const intersecoes = (tipoString.match(/&/g) || []).length;
+    // Contar operadores de interseção
+    const intersecoes = (tipoString.match(/&/g) ?? []).length;
     score += intersecoes * 0.5;
-    const genericosAninhados = (tipoString.match(/<[^>]*</g) || []).length;
+    // Contar genéricos aninhados
+    const genericosAninhados = (tipoString.match(/<[^>]*</g) ?? []).length;
     score += genericosAninhados * 2;
-    const aninhamento = (tipoString.match(/{\s*\w+\s*:/g) || []).length;
+    // 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;
@@ -292,6 +374,7 @@ function extractAllInlineTypes(src) {
                 }
             }
         }
+        // Detectar objetos tipo multi-linha
         if (typeObjInicio.test(line) && !line.includes('//')) {
             let depth = 1;
             const tipoLines = ['{'];
@@ -299,17 +382,22 @@ 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 === '{')
+                    if (char === '{') {
                         depth++;
-                    if (char === '}')
+                    }
+                    if (char === '}') {
                         depth--;
-                    if (depth === 0)
+                    }
+                    if (depth === 0) {
                         break;
+                    }
                 }
                 innerIndice++;
-                if (innerIndice - indice > 50)
+                if (innerIndice - indice > 50) {
                     break;
+                }
             }
             if (depth === 0) {
                 const tipoOriginal = tipoLines.join('\n').trim();
@@ -333,8 +421,12 @@ 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, []);
@@ -348,8 +440,12 @@ 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);
@@ -357,6 +453,9 @@ function findDuplicateTypes(tipos) {
     }
     return duplicados;
 }
+/**
+ * Cria ocorrência a partir de uma detecção
+ */
 function createOcorrencia(detection, relPath) {
     const tiposDirDisplay = getTypesDirectoryDisplay();
     let tipo = '';
@@ -387,18 +486,28 @@ 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)) {
@@ -408,6 +517,9 @@ 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;
@@ -416,6 +528,7 @@ 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;
@@ -429,6 +542,7 @@ function extractTypeDefinition(afterEquals) {
             result += char;
             continue;
         }
+        // Contar chaves
         if (char === '{' || char === '<' || char === '[' || char === '(') {
             depth++;
         }
@@ -436,10 +550,10 @@ function extractTypeDefinition(afterEquals) {
             depth--;
         }
         result += char;
+        // Parar no ponto-e-vírgula no nível raiz
         if (char === ';' && depth === 0) {
             return result;
         }
     }
     return null;
 }
-//# sourceMappingURL=detector-interfaces-inline.js.map

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

@@ -10,31 +10,34 @@ const visitorMemoria = {
             if (callee.type === 'Identifier' && callee.name === callName) {
                 const parent = path.parent;
                 if (parent.type === 'VariableDeclarator' || parent.type === 'AssignmentExpression') {
-                    lines.add(path.node.loc?.start.line || 0);
+                    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);
+                lines.delete(0); // mark that cleanup exists
             }
         };
+        // setInterval without clearInterval
         if (callee.type === 'Identifier' && callee.name === 'setInterval') {
             const parent = path.parent;
             if (parent.type !== 'VariableDeclarator' && parent.type !== 'AssignmentExpression') {
                 state.ocorrencias.push({
                     tipo: 'setinterval-unassigned',
-                    linha: path.node.loc?.start.line || 0,
-                    coluna: path.node.loc?.start.column || 0,
+                    linha: path.node.loc?.start.line ?? 0,
+                    coluna: path.node.loc?.start.column ?? 0,
                     severidade: 'media',
                     nivel: 'aviso',
                     mensagem: messages.DetectorJsTsMensagens.setIntervalUnassigned,
                     relPath: state.relPath
                 });
             }
-            state.setIntervalIds.add(path.node.loc?.start.line.toString() || '0');
+            state.setIntervalIds.add(path.node.loc?.start.line.toString() ?? '0');
         }
         if (callee.type === 'Identifier' && callee.name === 'clearInterval') {
-            state.setIntervalIds.delete(path.node.loc?.start.line.toString() || '0');
+            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 : '';
@@ -43,8 +46,8 @@ const visitorMemoria = {
                 if (parent.type !== 'VariableDeclarator' && parent.type !== 'AssignmentExpression') {
                     state.ocorrencias.push({
                         tipo: 'setinterval-unassigned',
-                        linha: path.node.loc?.start.line || 0,
-                        coluna: path.node.loc?.start.column || 0,
+                        linha: path.node.loc?.start.line ?? 0,
+                        coluna: path.node.loc?.start.column ?? 0,
                         severidade: 'media',
                         nivel: 'aviso',
                         mensagem: messages.DetectorJsTsMensagens.windowSetIntervalUnassigned,
@@ -52,48 +55,58 @@ const visitorMemoria = {
                     });
                 }
             }
+            // addEventListener without cleanup
             if (propName === 'addEventListener') {
-                state.addEventListenerLines.add(path.node.loc?.start.line || 0);
+                state.addEventListenerLines.add(path.node.loc?.start.line ?? 0);
                 const isGlobal = callee.object.type === 'Identifier' && ['window', 'document', 'body'].includes(callee.object.name);
                 if (isGlobal) {
                     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);
+                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);
+                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);
+                state.workerCalls.add(path.node.loc?.start.line ?? 0);
             }
             if (propName === 'terminate') {
                 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);
+            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);
+            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);
+            state.observerCalls.add(path.node.loc?.start.line ?? 0);
         }
     },
     Function(path, state) {
-        if (!textoTitulo.isFunctionExpression(path.node) && !textoTitulo.isFunctionDeclaration(path.node))
+        if (!textoTitulo.isFunctionExpression(path.node) && !textoTitulo.isFunctionDeclaration(path.node)) {
             return;
+        }
+        // Detect closures that return functions referencing large objects
         if (path.node.body && textoTitulo.isBlockStatement(path.node.body)) {
             let hasReturnFunction = false;
             let referencesLargeData = false;
@@ -113,11 +126,11 @@ const visitorMemoria = {
             }
             catch { }
             if (hasReturnFunction && referencesLargeData) {
-                state.closureLargeObjects.add(path.node.loc?.start.line || 0);
+                state.closureLargeObjects.add(path.node.loc?.start.line ?? 0);
                 state.ocorrencias.push({
                     tipo: 'closure-large-object',
-                    linha: path.node.loc?.start.line || 0,
-                    coluna: path.node.loc?.start.column || 0,
+                    linha: path.node.loc?.start.line ?? 0,
+                    coluna: path.node.loc?.start.column ?? 0,
                     severidade: 'media',
                     nivel: 'aviso',
                     mensagem: messages.DetectorJsTsMensagens.closureRetainingLargeObject,
@@ -127,14 +140,15 @@ 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')) {
                 state.globalAssignInLoop = true;
                 state.ocorrencias.push({
                     tipo: 'global-variable-growth',
-                    linha: path.node.loc?.start.line || 0,
-                    coluna: path.node.loc?.start.column || 0,
+                    linha: path.node.loc?.start.line ?? 0,
+                    coluna: path.node.loc?.start.column ?? 0,
                     severidade: 'media',
                     nivel: 'aviso',
                     mensagem: messages.DetectorJsTsMensagens.globalVariableGrowth,
@@ -172,9 +186,10 @@ export const analistaVazamentoMemoria = {
     test: (relPath) => {
         return /\.(js|jsx|ts|tsx)$/.test(relPath) && !/\.test\.(ts|js)$/.test(relPath);
     },
-    aplicar: async (src, relPath, ast) => {
-        if (!ast)
+    aplicar: (src, relPath, ast) => {
+        if (!ast) {
             return [];
+        }
         if (shouldSuppressOccurrence('vazamento-memoria', relPath)) {
             return [];
         }
@@ -208,12 +223,11 @@ export const analistaVazamentoMemoria = {
         }
         return stateObj.ocorrencias.map(ocorrencia => criarOcorrencia({
             tipo: ocorrencia.tipo ?? 'vazamento-memoria',
-            nivel: ocorrencia.nivel || 'aviso',
+            nivel: ocorrencia.nivel ?? 'aviso',
             mensagem: ocorrencia.mensagem,
-            linha: ocorrencia.linha || 0,
+            linha: ocorrencia.linha ?? 0,
             relPath,
             origem: 'vazamento-memoria'
         }));
     }
 };
-//# sourceMappingURL=detector-leaks-memory.js.map