@mocoto/mahoraga 0.14.0 → 0.14.2

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,27 +50,79 @@ 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));
         }
     }
+    // React 19: <form action={...}>
+    for (const match of src.matchAll(/<form[^>]*>/gi)) {
+        const hasAction = /\saction\s*=\s*\{/.test(match[0]);
+        if (hasAction) {
+            const line = lineOf(match.index);
+            ocorrencias.push(warn('React 19 form action detected', relPath, line, messages.SeverityNiveis.info));
+        }
+    }
+    // React 19: use() hook (called at top level in render)
+    for (const match of src.matchAll(/\bconst\s+\w+\s*=\s*use\s*\(/g)) {
+        const line = lineOf(match.index);
+        if (!/use[A-Z]/.test(match[0])) {
+            ocorrencias.push(warn('React 19 use() hook detected — ensure wrapped in Suspense boundary', relPath, line, messages.SeverityNiveis.info));
+        }
+    }
+    // 'use client' / 'use server' directives
+    if (/^['"]use (client|server)['"];/m.test(src)) {
+        ocorrencias.push(warn('Server Component directive detected', relPath, 1, messages.SeverityNiveis.info));
+    }
+    if (!/^['"]use client['"];/m.test(src) && /useState|useEffect|useContext|onClick/.test(src)) {
+        // This file uses client-side features without 'use client'
+        const hasClientFeatures = /useState|useEffect|useContext|onClick/.test(src);
+        if (hasClientFeatures) {
+            const firstLine = src.split('\n')[0]?.trim() ?? '';
+            if (firstLine.startsWith('import')) {
+                ocorrencias.push(warn('File uses client-side features (hooks/events) but missing \'use client\' directive (React 19 Server Components)', relPath, 1, messages.SeverityNiveis.suggestion));
+            }
+        }
+    }
+    // React 19: forwardRef deprecation
+    for (const match of src.matchAll(/\bforwardRef\s*\(/g)) {
+        const line = lineOf(match.index);
+        ocorrencias.push(warn('forwardRef is deprecated in React 19 — pass ref as a regular prop instead', relPath, line, messages.SeverityNiveis.suggestion));
+    }
+    // React 19: React.FC / React.FunctionComponent / React.VoidFunctionComponent
+    for (const match of src.matchAll(/\bReact\.(FC|FunctionComponent|VoidFunctionComponent)\b/g)) {
+        const line = lineOf(match.index);
+        ocorrencias.push(warn(`React.${match[1]} is deprecated in React 19 — type props directly: (props: Props) => JSX.Element`, relPath, line, messages.SeverityNiveis.suggestion));
+    }
+    // React 19: defaultProps
+    for (const match of src.matchAll(/\.defaultProps\s*=\s*\{/g)) {
+        const line = lineOf(match.index);
+        ocorrencias.push(warn('defaultProps is deprecated in React 19 — use default parameter values instead', relPath, line, messages.SeverityNiveis.suggestion));
+    }
     return ocorrencias;
 }
 function normalizeStringValue(valor) {
@@ -74,19 +132,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);
+        const name = 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 +168,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 +191,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 +201,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 +215,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 +227,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 +235,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 +266,12 @@ function parseReactWithBabel(scan, relPath) {
                             }
                         }
                         catch {
+                            // ignora
                         }
                     }
                 }
                 catch {
+                    // ignora
                 }
             },
             ClassMethod(path) {
@@ -202,34 +281,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 +320,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 +344,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 +386,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 +429,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 +469,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

@@ -87,6 +87,46 @@ export function detectarCorrecoesReact(src, _relPath) {
                 confianca: 50
             });
         }
+        // React 19: forwardRef replacement
+        if (/\bforwardRef\s*\(/.test(linha)) {
+            correcoes.push({
+                tipo: 'react-forwardref-to-prop',
+                original: linha.trim(),
+                sugerido: '// React 19: passe ref como prop em vez de forwardRef\n// Ex: function MeuComponente({ ref, ...props }) { ... }',
+                linha: numeroLinha,
+                confianca: 85
+            });
+        }
+        // React 19: React.FC replacement
+        if (/\bReact\.(FC|FunctionComponent)\s*</.test(linha)) {
+            correcoes.push({
+                tipo: 'react-fc-to-direct-type',
+                original: linha.trim(),
+                sugerido: '// React 19: tipagem direta de props\n// Ex: function MeuComponente({ prop1, prop2 }: Props)',
+                linha: numeroLinha,
+                confianca: 85
+            });
+        }
+        // React 19: defaultProps replacement
+        if (/\.defaultProps\s*=/.test(linha)) {
+            correcoes.push({
+                tipo: 'react-default-props-to-params',
+                original: linha.trim(),
+                sugerido: '// React 19: use default parameter values\n// Ex: function MeuComponente({ prop = valor })',
+                linha: numeroLinha,
+                confianca: 90
+            });
+        }
+        // React 19: 'use client' directive missing
+        if (/^\s*import\s+/.test(linha) && /useState|useEffect|onClick/.test(linha)) {
+            correcoes.push({
+                tipo: 'react-use-client-missing',
+                original: linha.trim(),
+                sugerido: "'use client';\n\n" + linha.trim(),
+                linha: numeroLinha,
+                confianca: 70
+            });
+        }
     });
     return correcoes;
 }
@@ -96,8 +136,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 +150,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