@mocoto/mahoraga 0.14.0 → 0.14.1

package/dist/analysts/react/analysts/analyst-react.js

@@ -4,8 +4,11 @@ import * as textoTitulo from '@babel/types';
 import { messages } from '../../../core/messages/index.js';
 import { createLineLookup, maskJsComments } from '../../../shared/helpers/index.js';
 import { criarAnalista, criarOcorrencia } from '../../../types/index.js';
-const disableEnv = process.env.MAHORAGA_DISABLE_PLUGIN_REACT === '1';
+const disableEnv = process.env.SUKUNA_DISABLE_PLUGIN_REACT === '1';
 function hasJSX(src) {
+    // Evita falsos positivos com genéricos TypeScript (ex.: foo<Bar>(...)).
+    // Heurística: JSX normalmente aparece após um separador (início de arquivo/linha, whitespace,
+    // pontuação), enquanto genéricos aparecem logo após identificadores.
     const hasTagLike = /(^|[^A-Za-z0-9_$])<([A-Za-z][A-Za-z0-9]*)\b/.test(src);
     const hasFragment = /<>|<\/>|<\/\s*>|<\/\s*Fragment\s*>/i.test(src);
     return hasTagLike || hasFragment || /React\.createElement/.test(src);
@@ -24,6 +27,7 @@ function warn(message, relPath, line, nivel = messages.SeverityNiveis.warning) {
 function collectReactIssues(src, relPath) {
     const ocorrencias = [];
     const lineOf = createLineLookup(src).lineAt;
+    // <a target="_blank"> sem rel
     for (const match of src.matchAll(/<a[^>]*target=['"]?_blank['"]?[^>]*>/gi)) {
         const hasRelSafe = /rel=['"][^'"]*(noopener|noreferrer)[^'"]*['"]/i.test(match[0]);
         if (!hasRelSafe) {
@@ -31,10 +35,12 @@ function collectReactIssues(src, relPath) {
             ocorrencias.push(warn(messages.ReactMensagens.linkTargetBlank, relPath, line));
         }
     }
+    // dangerouslySetInnerHTML
     for (const match of src.matchAll(/dangerouslySetInnerHTML/gi)) {
         const line = lineOf(match.index);
         ocorrencias.push(warn(messages.ReactMensagens.dangerouslySetInnerHTML, relPath, line));
     }
+    // <img> sem alt
     for (const match of src.matchAll(/<img[^>]*>/gi)) {
         const hasAlt = /\salt=/.test(match[0]);
         const ariaHidden = /\saria-hidden=['"]true['"]/i.test(match[0]);
@@ -44,23 +50,31 @@ function collectReactIssues(src, relPath) {
             ocorrencias.push(warn(messages.ReactMensagens.imgWithoutAlt, relPath, line));
         }
     }
+    // fetch/axios com HTTP (inseguro)
     for (const match of src.matchAll(/\b(fetch|axios\.get|axios\.post|axios\.[a-z]+)\s*\(\s*['"]http:\/\//gi)) {
         const line = lineOf(match.index);
         ocorrencias.push(warn(messages.ReactMensagens.httpFetch, relPath, line));
     }
+    // Hardcoded secrets (heurística)
     for (const match of src.matchAll(/(api[key]?|token|secret|senha|password|passphrase)\s*[:=]\s*['"]([A-Za-z0-9\/_+=.-]{16,})['"]/gi)) {
         const valor = match[2] || '';
-        if (valor.length < 24 || /^https?:\/\//i.test(valor))
+        if (valor.length < 24 || /^https?:\/\//i.test(valor)) {
             continue;
+        }
         const line = lineOf(match.index);
         ocorrencias.push(warn(messages.ReactMensagens.hardcodedCredential, relPath, line));
     }
+    // Redirecionamento direto via location.href em handlers
+    // Ignorar router.push/replace do Next.js (navegação segura via client-side routing)
     const usesNextRouter = /useRouter|router\.(push|replace)/.test(src);
     for (const match of src.matchAll(/location\.href\s*=\s*([^;]+)/gi)) {
         const assignedValor = match[1] || '';
         const line = lineOf(match.index);
+        // Ignorar se valor é string literal (não vem de input do usuário)
         const isStaticString = /^['"`][^'"\`]*['"`]$/.test(assignedValor.trim());
+        // Ignorar se é window.location.href = '/path' (navegação interna estática)
         const isInternalNavigation = /^['"`]\//.test(assignedValor.trim());
+        // Só reportar se for atribuição dinâmica (potencialmente de input do usuário)
         if (!isStaticString && !isInternalNavigation && !usesNextRouter) {
             ocorrencias.push(warn(messages.ReactMensagens.locationHrefRedirect, relPath, line));
         }
@@ -74,19 +88,23 @@ function isBabelNode(valor) {
     return typeof valor === 'object' && valor !== null && 'type' in valor;
 }
 function attrsToFlatList(attrs) {
-    if (!Array.isArray(attrs))
+    if (!Array.isArray(attrs)) {
         return [];
+    }
     return attrs.filter(isBabelNode).filter((arquivo) => textoTitulo.isJSXAttribute(arquivo)).filter(arquivo => textoTitulo.isJSXIdentifier(arquivo.name)).map(arquivo => {
         const name = String(arquivo.name.name);
         let value;
-        if (!arquivo.value)
+        if (!arquivo.value) {
             value = null;
-        else if (textoTitulo.isStringLiteral(arquivo.value))
+        }
+        else if (textoTitulo.isStringLiteral(arquivo.value)) {
             value = arquivo.value.value;
+        }
         else if (textoTitulo.isJSXExpressionContainer(arquivo.value)) {
             const expr = arquivo.value.expression;
-            if (textoTitulo.isStringLiteral(expr))
+            if (textoTitulo.isStringLiteral(expr)) {
                 value = expr.value;
+            }
         }
         return {
             name,
@@ -106,14 +124,20 @@ function parseReactWithBabel(scan, relPath) {
     const isTs = lower.endsWith('.ts') || lower.endsWith('.tsx');
     const isJsxLike = lower.endsWith('.tsx') || lower.endsWith('.jsx');
     const isJsFamily = /\.(js|mjs|cjs|jsx)$/i.test(lower);
-    if (lower.endsWith('.ts') && !isJsxLike)
+    // Em .ts puro o Babel com JSX pode aumentar falsos positivos; só parseamos quando o
+    // arquivo já passou pela heurística de JSX antes.
+    if (lower.endsWith('.ts') && !isJsxLike) {
         return null;
+    }
     try {
-        const plugins = ['decorators-legacy'];
-        if (isTs)
+        const plugins = ['decorators-legacy', 'classProperties', 'classPrivateProperties', 'classPrivateMethods', 'optionalChaining', 'nullishCoalescingOperator', 'topLevelAwait', 'importAttributes'];
+        if (isTs) {
             plugins.unshift('typescript');
-        if (isJsxLike || isJsFamily)
+        }
+        // Robustez: projetos React frequentemente usam JSX em .js
+        if (isJsxLike || isJsFamily) {
             plugins.unshift('jsx');
+        }
         const ast = babelParse(scan, {
             sourceType: 'unambiguous',
             errorRecovery: true,
@@ -123,8 +147,9 @@ function parseReactWithBabel(scan, relPath) {
         const seen = new Set();
         const pushOnce = (metrica) => {
             const chave = `${metrica.mensagem}|${metrica.relPath}|${metrica.linha ?? 0}`;
-            if (seen.has(chave))
+            if (seen.has(chave)) {
                 return;
+            }
             seen.add(chave);
             ocorrencias.push(metrica);
         };
@@ -132,11 +157,12 @@ function parseReactWithBabel(scan, relPath) {
             JSXOpeningElement(path) {
                 try {
                     const node = path.node;
-                    const locLine = node.loc?.start?.line;
+                    const locLine = node.loc?.start.line;
                     const nameNode = node.name;
-                    const tag = textoTitulo.isJSXIdentifier(nameNode) ? String(nameNode.name) : '';
-                    if (!tag)
+                    const tag = textoTitulo.isJSXIdentifier(nameNode) ? nameNode.name : '';
+                    if (!tag) {
                         return;
+                    }
                     const attrs = attrsToFlatList(node.attributes);
                     if (tag.toLowerCase() === 'a') {
                         const target = findAttr(attrs, 'target');
@@ -145,8 +171,9 @@ function parseReactWithBabel(scan, relPath) {
                             const rel = findAttr(attrs, 'rel');
                             const relVal = normalizeStringValue(rel?.value);
                             const safe = /(noopener|noreferrer)/i.test(relVal);
-                            if (!safe)
+                            if (!safe) {
                                 pushOnce(warn(messages.ReactMensagens.linkTargetBlank, relPath, locLine));
+                            }
                         }
                     }
                     if (tag.toLowerCase() === 'img') {
@@ -156,6 +183,7 @@ function parseReactWithBabel(scan, relPath) {
                         const ariaHiddenVal = normalizeStringValue(ariaHidden?.value);
                         const roleVal = normalizeStringValue(role?.value);
                         const decorative = ariaHiddenVal === 'true' || /^(presentation|none)$/i.test(roleVal);
+                        // Considerar alt presente se há atributo alt, mesmo se valor é expressão
                         if (!alt && !decorative) {
                             pushOnce(warn(messages.ReactMensagens.imgWithoutAlt, relPath, locLine));
                         }
@@ -163,23 +191,28 @@ function parseReactWithBabel(scan, relPath) {
                     if (findAttr(attrs, 'dangerouslySetInnerHTML')) {
                         pushOnce(warn(messages.ReactMensagens.dangerouslySetInnerHTML, relPath, locLine));
                     }
+                    // Inline Styles
                     const styleAttr = findAttr(attrs, 'style');
-                    if (styleAttr && styleAttr.value && styleAttr.value.includes('{')) {
-                        const numProps = (styleAttr.value.match(/:/g) || []).length;
+                    if (styleAttr?.value?.includes('{')) {
+                        // Heurística: se o estilo tem mais de 2 propriedades, sugere mover para CSS/Styled
+                        const numProps = (styleAttr.value.match(/:/g) ?? []).length;
                         if (numProps > 2) {
                             pushOnce(warn(messages.ReactMensagens.complexInlineStyles, relPath, locLine, messages.SeverityNiveis.warning));
                         }
                     }
+                    // Verificar handlers inline em atributos JSX (ex.: onClick={() => ...})
                     for (const arquivo of node.attributes) {
                         try {
-                            if (!textoTitulo.isJSXAttribute(arquivo) || !textoTitulo.isJSXIdentifier(arquivo.name))
+                            if (!textoTitulo.isJSXAttribute(arquivo) || !textoTitulo.isJSXIdentifier(arquivo.name)) {
                                 continue;
-                            const attrNome = String(arquivo.name.name);
+                            }
+                            const attrNome = arquivo.name.name;
                             if (arquivo.value && textoTitulo.isJSXExpressionContainer(arquivo.value)) {
                                 const expr = arquivo.value.expression;
                                 if (textoTitulo.isArrowFunctionExpression(expr) || textoTitulo.isFunctionExpression(expr)) {
                                     pushOnce(warn(messages.ReactMensagens.inlineHandlerJsx, relPath, locLine));
                                 }
+                                // Detectar uso de índice como key (key={i} / key={index})
                                 if (attrNome === 'key' && textoTitulo.isJSXExpressionContainer(arquivo.value) && textoTitulo.isIdentifier(arquivo.value.expression)) {
                                     const id = arquivo.value.expression.name;
                                     if (['i', 'index', 'idx'].includes(id)) {
@@ -189,10 +222,12 @@ function parseReactWithBabel(scan, relPath) {
                             }
                         }
                         catch {
+                            // ignora
                         }
                     }
                 }
                 catch {
+                    // ignora
                 }
             },
             ClassMethod(path) {
@@ -202,34 +237,38 @@ function parseReactWithBabel(scan, relPath) {
                         const name = key.name;
                         const deprecated = ['componentWillMount', 'componentWillReceiveProps', 'componentWillUpdate'];
                         if (deprecated.includes(name)) {
-                            pushOnce(warn(messages.ReactMensagens.deprecatedLifecycleMethod(name), relPath, path.node.loc?.start?.line, messages.SeverityNiveis.warning));
+                            pushOnce(warn(messages.ReactMensagens.deprecatedLifecycleMethod(name), relPath, path.node.loc?.start.line, messages.SeverityNiveis.warning));
                         }
                     }
                 }
                 catch {
+                    // ignora
                 }
             },
             CallExpression(path) {
                 try {
                     const node = path.node;
-                    const locLine = node.loc?.start?.line;
+                    const locLine = node.loc?.start.line;
                     const args = node.arguments;
                     const first = args[0];
-                    const firstStr = textoTitulo.isStringLiteral(first) ? String(first.value) : '';
+                    const firstStr = textoTitulo.isStringLiteral(first) ? first.value : '';
                     if (textoTitulo.isIdentifier(node.callee) && node.callee.name === 'fetch') {
-                        if (/^http:\/\//i.test(firstStr))
+                        if (/^http:\/\//i.test(firstStr)) {
                             pushOnce(warn(messages.ReactMensagens.httpFetch, relPath, locLine));
+                        }
                         return;
                     }
                     if (textoTitulo.isMemberExpression(node.callee)) {
                         const obj = node.callee.object;
                         const prop = node.callee.property;
-                        const objNome = textoTitulo.isIdentifier(obj) ? String(obj.name) : '';
-                        const propNome = textoTitulo.isIdentifier(prop) ? String(prop.name) : '';
+                        const objNome = textoTitulo.isIdentifier(obj) ? obj.name : '';
+                        const propNome = textoTitulo.isIdentifier(prop) ? prop.name : '';
                         if (objNome === 'axios' && propNome) {
-                            if (/^http:\/\//i.test(firstStr))
+                            if (/^http:\/\//i.test(firstStr)) {
                                 pushOnce(warn(messages.ReactMensagens.httpFetch, relPath, locLine));
+                            }
                         }
+                        // Detectar Array#map com callback retornando JSX sem key
                         if (propNome === 'map' && args.length >= 1) {
                             const cb = args[0];
                             const checkCallback = (fn) => {
@@ -237,13 +276,14 @@ function parseReactWithBabel(scan, relPath) {
                                     const body = fn.body;
                                     const checkJsxNode = (jsx) => {
                                         if (textoTitulo.isJSXElement(jsx)) {
-                                            const hasChave = jsx.openingElement.attributes.some(arquivo => textoTitulo.isJSXAttribute(arquivo) && textoTitulo.isJSXIdentifier(arquivo.name) && String(arquivo.name.name) === 'key');
+                                            const hasChave = jsx.openingElement.attributes.some(arquivo => textoTitulo.isJSXAttribute(arquivo) && textoTitulo.isJSXIdentifier(arquivo.name) && arquivo.name.name === 'key');
                                             if (!hasChave) {
-                                                pushOnce(warn(messages.ReactMensagens.listItemNoKey, relPath, jsx.loc?.start?.line ?? locLine));
+                                                pushOnce(warn(messages.ReactMensagens.listItemNoKey, relPath, jsx.loc?.start.line ?? locLine));
                                             }
                                         }
                                         else {
-                                            pushOnce(warn(messages.ReactMensagens.listItemNoKey, relPath, jsx.loc?.start?.line ?? locLine));
+                                            // JSXFragment (<>...</>) não aceita atributo key - tratar como sem key
+                                            pushOnce(warn(messages.ReactMensagens.listItemNoKey, relPath, jsx.loc?.start.line ?? locLine));
                                         }
                                     };
                                     if (textoTitulo.isJSXElement(body) || textoTitulo.isJSXFragment(body)) {
@@ -260,30 +300,36 @@ function parseReactWithBabel(scan, relPath) {
                                     }
                                 }
                                 catch {
+                                    // ignora
                                 }
                             };
-                            if (textoTitulo.isFunctionExpression(cb))
+                            if (textoTitulo.isFunctionExpression(cb)) {
                                 checkCallback(cb);
-                            if (textoTitulo.isArrowFunctionExpression(cb))
+                            }
+                            if (textoTitulo.isArrowFunctionExpression(cb)) {
                                 checkCallback(cb);
+                            }
                         }
                     }
                 }
                 catch {
+                    // ignora
                 }
             },
             AssignmentExpression(path) {
                 try {
                     const node = path.node;
-                    const locLine = node.loc?.start?.line;
+                    const locLine = node.loc?.start.line;
                     const left = node.left;
-                    if (!textoTitulo.isMemberExpression(left))
+                    if (!textoTitulo.isMemberExpression(left)) {
                         return;
+                    }
                     const obj = left.object;
                     const prop = left.property;
-                    const objNome = textoTitulo.isIdentifier(obj) ? String(obj.name) : '';
-                    const propNome = textoTitulo.isIdentifier(prop) ? String(prop.name) : '';
+                    const objNome = textoTitulo.isIdentifier(obj) ? obj.name : '';
+                    const propNome = textoTitulo.isIdentifier(prop) ? prop.name : '';
                     if (objNome === 'location' && propNome === 'href') {
+                        // Ignorar se RHS é string literal estática ou navegação interna
                         const right = node.right;
                         let isSafe = false;
                         if (textoTitulo.isStringLiteral(right)) {
@@ -296,27 +342,33 @@ function parseReactWithBabel(scan, relPath) {
                     }
                 }
                 catch {
+                    // ignora
                 }
             },
             ObjectProperty(path) {
                 try {
                     const node = path.node;
-                    const locLine = node.loc?.start?.line;
+                    const locLine = node.loc?.start.line;
                     const key = node.key;
                     const value = node.value;
-                    const keyNome = textoTitulo.isIdentifier(key) ? String(key.name) : textoTitulo.isStringLiteral(key) ? String(key.value) : '';
-                    if (!keyNome || !isSensitiveKeyName(keyNome))
+                    const keyNome = textoTitulo.isIdentifier(key) ? key.name : textoTitulo.isStringLiteral(key) ? key.value : '';
+                    if (!keyNome || !isSensitiveKeyName(keyNome)) {
                         return;
-                    if (!textoTitulo.isStringLiteral(value))
+                    }
+                    if (!textoTitulo.isStringLiteral(value)) {
                         return;
-                    const string = String(value.value || '');
-                    if (string.length < 24)
+                    }
+                    const string = (value.value || '');
+                    if (string.length < 24) {
                         return;
-                    if (/^https?:\/\//i.test(string))
+                    }
+                    if (/^https?:\/\//i.test(string)) {
                         return;
+                    }
                     pushOnce(warn(messages.ReactMensagens.hardcodedCredential, relPath, locLine));
                 }
                 catch {
+                    // ignora
                 }
             }
         };
@@ -333,29 +385,38 @@ export const analistaReact = criarAnalista({
     descricao: 'Heurísticas leves de React (sem ESLint).',
     global: false,
     test: (relPath) => /\.(jsx|tsx|js|ts)$/i.test(relPath),
-    aplicar: async (src, relPath) => {
-        if (disableEnv)
+    aplicar: (src, relPath) => {
+        if (disableEnv) {
             return null;
-        if (relPath.includes('src/analysts/react/analysts/analyst-react.ts'))
+        }
+        if (relPath.includes('src/analysts/react/analysts/analyst-react.ts')) {
             return null;
+        }
         const scan = maskJsComments(src);
+        // Em arquivos .ts (não TSX), seja mais conservador para evitar falsos positivos
+        // com assertions/generics usando <T>.
         if (/\.ts$/i.test(relPath) && !/\.tsx$/i.test(relPath)) {
             const hasStrongJsxEvidence = /<\/[A-Za-z][^>]*>/.test(scan) || /\/>/.test(scan) || /React\.createElement/.test(scan);
-            if (!hasStrongJsxEvidence)
+            if (!hasStrongJsxEvidence) {
                 return null;
+            }
         }
-        if (!hasJSX(scan))
+        if (!hasJSX(scan)) {
             return null;
+        }
         const astMsgs = parseReactWithBabel(scan, relPath) ?? [];
         const heuristicMsgs = collectReactIssues(scan, relPath);
-        if (!astMsgs.length && !heuristicMsgs.length)
+        if (!astMsgs.length && !heuristicMsgs.length) {
             return null;
+        }
+        // Dedupe para evitar duplicatas quando AST e regex cobrem o mesmo caso.
         const seen = new Set();
         const merged = [];
         const pushOnce = (metrica) => {
             const chave = `${metrica.mensagem}|${metrica.relPath}|${metrica.linha ?? 0}`;
-            if (seen.has(chave))
+            if (seen.has(chave)) {
                 return;
+            }
             seen.add(chave);
             merged.push(metrica);
         };
@@ -364,4 +425,3 @@ export const analistaReact = criarAnalista({
         return merged.length ? merged : null;
     }
 });
-//# sourceMappingURL=analyst-react.js.map

package/dist/analysts/react/analysts/index.js

@@ -1,3 +1,2 @@
 export * from './analyst-react.js';
 export * from './analyst-react-hooks.js';
-//# sourceMappingURL=index.js.map

package/dist/analysts/react/corrections/correction-react.js

@@ -96,8 +96,9 @@ export const correctionReact = {
     descricao: 'Correções automáticas para problemas React',
     test: (relPath) => /\.(jsx|tsx)$/i.test(relPath),
     aplicar: (src, relPath, _ast) => {
-        if (!src)
+        if (!src) {
             return [];
+        }
         const correcoes = detectarCorrecoesReact(src, relPath);
         return correcoes.map(c => criarOcorrencia({
             tipo: `correction-${c.tipo}`,
@@ -109,4 +110,3 @@ export const correctionReact = {
         }));
     }
 };
-//# sourceMappingURL=correction-react.js.map

package/dist/analysts/react/corrections/index.js

@@ -1,2 +1,2 @@
+// SPDX-License-Identifier: MIT
 export * from './correction-react.js';
-//# sourceMappingURL=index.js.map

package/dist/analysts/react/detectors/detector-react-best-practices.js

@@ -15,8 +15,9 @@ export const detectorReactBestPractices = {
     descricao: 'Detecta más práticas em componentes React',
     test: (relPath) => /\.(jsx|tsx)$/i.test(relPath),
     aplicar: (src, relPath) => {
-        if (!src)
+        if (!src) {
             return [];
+        }
         const ocorrencias = [];
         const linhas = splitLines(src);
         linhas.forEach((linha, index) => {
@@ -48,8 +49,9 @@ export const detectorReactBestPractices = {
             const seen = new Set();
             for (const o of deeper) {
                 const chave = `${o.tipo}|${o.relPath}|${o.linha ?? 0}`;
-                if (seen.has(chave))
+                if (seen.has(chave)) {
                     continue;
+                }
                 seen.add(chave);
                 const dup = ocorrencias.findIndex(ex => ex.tipo === o.tipo && ex.linha === o.linha);
                 if (dup === -1) {
@@ -62,15 +64,16 @@ export const detectorReactBestPractices = {
 };
 function detectWithBabel(src, relPath) {
     try {
-        const plugins = ['decorators-legacy', 'jsx'];
+        const plugins = ['decorators-legacy', 'classProperties', 'classPrivateProperties', 'classPrivateMethods', 'optionalChaining', 'nullishCoalescingOperator', 'topLevelAwait', 'importAttributes', 'jsx'];
         plugins.unshift('typescript');
         const ast = babelParse(src, { sourceType: 'unambiguous', errorRecovery: true, plugins });
         const out = [];
         const seen = new Set();
         const pushOnce = (o) => {
             const chave = `${o.tipo}|${o.relPath}|${o.linha ?? 0}`;
-            if (seen.has(chave))
+            if (seen.has(chave)) {
                 return;
+            }
             seen.add(chave);
             out.push(o);
         };
@@ -87,13 +90,16 @@ function detectWithBabel(src, relPath) {
                 const node = path.node;
                 const callee = node.callee;
                 let name = '';
-                if (t.isIdentifier(callee))
+                if (t.isIdentifier(callee)) {
                     name = callee.name;
-                else if (t.isMemberExpression(callee) && t.isIdentifier(callee.property))
+                }
+                else if (t.isMemberExpression(callee) && t.isIdentifier(callee.property)) {
                     name = callee.property.name;
-                if (!name)
+                }
+                if (!name) {
                     return;
-                const locLine = path.node.loc?.start?.line;
+                }
+                const locLine = path.node.loc?.start.line;
                 if (isHookName(name)) {
                     const parent = path.findParent(p => p.isIfStatement() || p.isConditionalExpression() || p.isLogicalExpression() || p.isSwitchStatement() || p.isSwitchCase() || p.isForStatement() || p.isWhileStatement() || p.isDoWhileStatement() || p.isLoop());
                     if (parent) {
@@ -108,7 +114,7 @@ function detectWithBabel(src, relPath) {
                             pushOnce(warn('react-hook-inside-callback', D.hookInsideCallback, relPath, locLine, D.hookInsideCallbackSugestao, 'erro'));
                         }
                     }
-                    if (fnParent && fnParent.isFunction()) {
+                    if (fnParent?.isFunction()) {
                         const fnBody = fnParent.node.body;
                         if (t.isBlockStatement(fnBody)) {
                             const bodyStmts = fnBody.body;
@@ -140,8 +146,9 @@ function detectWithBabel(src, relPath) {
                             const depsArg = node.arguments[1];
                             if (t.isArrayExpression(depsArg)) {
                                 for (const el of depsArg.elements) {
-                                    if (t.isIdentifier(el))
+                                    if (t.isIdentifier(el)) {
                                         refsInDeps.add(el.name);
+                                    }
                                 }
                             }
                             const bodyText = src.slice(bodyArg.start ?? 0, bodyArg.end ?? 0);
@@ -243,10 +250,11 @@ function detectWithBabel(src, relPath) {
             },
             JSXOpeningElement(path) {
                 const node = path.node;
-                const locLine = node.loc?.start?.line;
+                const locLine = node.loc?.start.line;
                 const tag = t.isJSXIdentifier(node.name) ? node.name.name : '';
-                if (!tag)
+                if (!tag) {
                     return;
+                }
                 if (tag === 'img' || tag === 'input' || tag === 'textarea' || tag === 'select' || tag === 'button') {
                     const hasAria = node.attributes.some(a => {
                         if (t.isJSXAttribute(a) && t.isJSXIdentifier(a.name)) {
@@ -264,17 +272,18 @@ function detectWithBabel(src, relPath) {
                     pushOnce(warn('react-onclick-nokeydown', D.onClickWithoutKeyDown, relPath, locLine, D.onClickWithoutKeyDownSugestao, 'aviso'));
                 }
                 const fragmentParent = path.findParent(p => p.isJSXFragment());
-                if (fragmentParent && fragmentParent.isJSXFragment()) {
-                    const children = fragmentParent.node.children?.filter(c => !t.isJSXText(c) || (c.value?.trim() ?? '') !== '') ?? [];
+                if (fragmentParent?.isJSXFragment()) {
+                    const children = fragmentParent.node.children.filter(c => !t.isJSXText(c) || (c.value.trim() ?? '') !== '') ?? [];
                     if (children.length <= 1) {
                         pushOnce(warn('react-unnecessary-fragment', D.unnecessaryFragment, relPath, locLine, undefined, 'info'));
                     }
                 }
             },
             JSXAttribute(path) {
-                const locLine = path.node.loc?.start?.line;
-                if (!t.isJSXIdentifier(path.node.name))
+                const locLine = path.node.loc?.start.line;
+                if (!t.isJSXIdentifier(path.node.name)) {
                     return;
+                }
                 const name = path.node.name.name;
                 if (name.startsWith('on') && path.node.value && t.isJSXExpressionContainer(path.node.value)) {
                     const expr = path.node.value.expression;
@@ -296,7 +305,7 @@ function detectWithBabel(src, relPath) {
                 }
             },
             MemberExpression(path) {
-                const locLine = path.node.loc?.start?.line;
+                const locLine = path.node.loc?.start.line;
                 if (t.isIdentifier(path.node.object) && t.isIdentifier(path.node.property)) {
                     const obj = path.node.object.name;
                     const prop = path.node.property.name;
@@ -313,4 +322,3 @@ function detectWithBabel(src, relPath) {
         return null;
     }
 }
-//# sourceMappingURL=detector-react-best-practices.js.map

package/dist/analysts/react/detectors/index.js

@@ -1,2 +1,2 @@
+// SPDX-License-Identifier: MIT
 export * from './detector-react-best-practices.js';
-//# sourceMappingURL=index.js.map

package/dist/analysts/react/index.js

@@ -1,6 +1,11 @@
+// SPDX-License-Identifier: MIT
+/**
+ * [BUSCA] Analistas de React
+ *
+ * Heurísticas leves de React e React Hooks (sem ESLint).
+ */
 export * from './analysts/analyst-react.js';
 export * from './analysts/analyst-react-hooks.js';
 export * from './corrections/index.js';
 export * from './detectors/index.js';
 export * from './scorers/index.js';
-//# sourceMappingURL=index.js.map

package/dist/analysts/react/scorers/index.js

@@ -1,2 +1,2 @@
+// SPDX-License-Identifier: MIT
 export * from './scorer-react.js';
-//# sourceMappingURL=index.js.map