aprimoração de ia

global/rules/funcoes-anonimas-arrow.md

@@ -0,0 +1,86 @@
+---
+type: rule
+name: funcoes-anonimas-arrow
+trigger: always_on
+description: Exige uso de arrow functions (const x = () => {}) em vez de function declarations (function x() {})
+scope: global
+updatedAt: "2026-07-01"
+globs:
+  - "**/*.ts"
+  - "**/*.tsx"
+  - "**/*.js"
+  - "**/*.vue"
+alwaysApply: true
+---
+
+## Contexto
+
+Este projeto adota **arrow functions** como padrão obrigatório para definição de funções. A declaração clássica `function x() {}` é proibida sempre que uma arrow function puder substituí-la, o que cobre a esmagadora maioria dos casos.
+
+Isso garante consistência de estilo, evita ambiguidades de `this`, favorece inferência de tipos em TypeScript e mantém o código visualmente uniforme em todo o ecossistema.
+
+## Regra
+
+**Sempre que possível, é obrigatório usar arrow function expression:**
+
+```ts
+// ✅ CORRETO — arrow function expression
+const calcular = (a: number, b: number): number => a + b
+
+const buscarUsuario = async (id: string): Promise<Usuario> => {
+  return api.get(`/usuarios/${id}`)
+}
+
+const transformar = <T>(lista: T[], fn: (item: T) => T): T[] =>
+  lista.map(fn)
+```
+
+```ts
+// ❌ PROIBIDO — function declaration
+function calcular(a: number, b: number): number {
+  return a + b
+}
+
+async function buscarUsuario(id: string): Promise<Usuario> {
+  return api.get(`/usuarios/${id}`)
+}
+
+function transformar<T>(lista: T[], fn: (item: T) => T): T[] {
+  return lista.map(fn)
+}
+```
+
+## Exceções permitidas
+
+As únicas situações em que `function` é tolerada:
+
+1. **Generators** — `function*` não tem equivalente em arrow function:
+   ```ts
+   function* gerador() { yield 1 }
+   ```
+
+2. **Métodos de objeto/classe** — dentro de um `class` ou object literal com método de protocolo, a sintaxe de método é aceita:
+   ```ts
+   class Servico {
+     processar() { ... } // OK dentro de classe
+   }
+   ```
+
+3. **Callbacks que exigem `this` dinâmico** — raro; apenas quando a API externa exige explicitamente (ex: certas integrações jQuery legadas).
+
+Fora dessas três exceções, `function` é **proibida**.
+
+## Diretiva para o agente
+
+Ao revisar ou escrever código, o agente deve:
+
+1. Identificar toda ocorrência de `function nome(` fora de classes e generators;
+2. Substituir pela forma `const nome = (...) => { ... }`;
+3. Ajustar a tipagem de retorno explícita quando necessário: `const fn = (): Tipo => { ... }`;
+4. Para funções genéricas, manter o generic na arrow: `const fn = <T>(arg: T): T => arg`;
+5. Nunca silenciar um erro de tipagem ao fazer a conversão — se surgir erro, resolver com tipagem correta.
+
+## Referências
+
+- Rule: `global/rules/typescript-sem-any`
+- Rule: `global/rules/jsdoc-padrao`