@skapxd/eslint-opinionated 0.4.0 → 0.6.0

package/README.md

@@ -13,8 +13,9 @@ Cursor o Copilot.
 
 - **Una función por archivo:** un archivo con cinco helpers escondidos no pasa;
   la regla hasta te dibuja la carpeta sugerida con formato `tree`.
-- **Errores con `Result`:** una función `async` que puede fallar lo dice en su
-  tipo de retorno (`Promise<Result<...>>`), no en una convención oral.
+- **Errores con `Result`:** ningún `await` queda fuera del sistema de errores:
+  o llamas una función que retorna `Promise<Result<...>>` o envuelves la
+  operación en `trySafe`. Nada lanza sin que el tipo lo diga.
 - **Causa preservada:** al transformar un error de dominio, el `cause` original
   no puede desaparecer — type-aware, vía el checker de TypeScript.
 - **Hooks acotados:** un hook con demasiado estado deja de pasar como "solo un
@@ -251,6 +252,70 @@ hay errores, sale con código `1` (apto para CI). Como acota por **archivo
 completo**, también dispara las reglas estructurales (p. ej.
 `one-root-function-per-file`), que un filtrado por línea se perdería.
 
+## Cómo encaja todo: `@skapxd/result` + `ts-pattern`
+
+Este plugin no es una colección de reglas sueltas: es el guardián de un
+pipeline de errores donde cada pieza cierra un hueco que las otras dejan.
+
+```text
+excepción ──trySafe──▶ Result ──map con cause──▶ error de dominio ──match()──▶ UI/respuesta
+```
+
+| Pieza | Qué aporta | Regla que lo vigila |
+| --- | --- | --- |
+| `try/catch` prohibido | Los errores no viajan invisibles al tipo. | `skapxd/no-try-catch` |
+| `.then/.catch` prohibido | Una sola forma de asincronía: `await`. | `skapxd/no-promise-chain` |
+| `trySafe` (`@skapxd/result`) | La única puerta: lo que lanza se vuelve `Result`. | `skapxd/await-requires-result` |
+| Errores de dominio con `cause` | Al traducir un error técnico, la causa sobrevive. | `skapxd/result-error-requires-cause` |
+| Un solo contrato `Result` | Nada de `{ ok: ... }` caseros que fragmenten el sistema. | `skapxd/no-ad-hoc-ok-result` |
+| `match()` (`ts-pattern`) | Consumo exhaustivo: el compilador exige manejar cada error. | `skapxd/prefer-ts-pattern` |
+
+De punta a punta:
+
+```ts
+import { Result, trySafe } from "@skapxd/result";
+import { match } from "ts-pattern";
+
+type UserError =
+  | { type: "NETWORK"; message: string; cause: unknown }
+  | { type: "NOT_FOUND"; message: string };
+
+// 1. La frontera con el mundo que lanza: trySafe + errores de dominio.
+async function getUser(id: string): Promise<Result<User, UserError>> {
+  const response = await trySafe(() => fetch(`/users/${id}`));
+
+  if (!response.ok) {
+    return Result.err({
+      cause: response.error, // result-error-requires-cause vigila esto
+      message: "No pude cargar el usuario.",
+      type: "NETWORK",
+    });
+  }
+
+  if (response.value.status === 404) {
+    return Result.err({ message: "El usuario no existe.", type: "NOT_FOUND" });
+  }
+
+  return trySafe(() => response.value.json());
+}
+
+// 2. El consumo: el await ya resuelve en Result (await-requires-result pasa)
+//    y match() obliga a manejar cada variante (prefer-ts-pattern).
+const user = await getUser(id);
+
+const label = match(user)
+  .with({ ok: true }, ({ value }) => value.name)
+  .with({ ok: false, error: { type: "NOT_FOUND" } }, () => "No existe")
+  .with({ ok: false, error: { type: "NETWORK" } }, () => "Reintenta")
+  .exhaustive();
+```
+
+El resultado: ningún error puede escaparse (sin `try/catch` ni `.catch`, todo
+pasa por `trySafe`), ningún error pierde su origen (siempre hay `cause` hasta
+la excepción original), y ningún error queda sin manejar (el `.exhaustive()`
+de ts-pattern no compila si falta una variante). Legibilidad y manejo de
+errores dejan de depender de la disciplina del autor — humano o agente.
+
 ## Estructura del paquete
 
 ```text
@@ -302,6 +367,29 @@ export default [
 ];
 ```
 
+El contrato del back es el mismo que el del front: todo `await` debe resolver
+en un `Result` (`skapxd/await-requires-result`). Exigir además la firma
+`Promise<Result<...>>` en cada función async
+(`skapxd/async-functions-return-result`) está **apagado por defecto** — los
+motivos están documentados en la sección de esa regla. Si quieres el contrato
+duro, actívala encima del preset:
+
+```js
+export default [
+  {
+    files: ["src/server/**/*.{ts,tsx}"],
+    ...skapxd.configs.shared.backend,
+    rules: {
+      ...skapxd.configs.shared.backend.rules,
+      "skapxd/async-functions-return-result": [
+        "error",
+        { checkMissingReturnType: true },
+      ],
+    },
+  },
+];
+```
+
 ### Frontend
 
 ```js
@@ -427,9 +515,9 @@ bloque con `linterOptions: { noInlineConfig: false }` para esos globs.
 | Regla | Qué protege |
 | --- | --- |
 | `skapxd/one-root-function-per-file` | Un archivo, una función top-level semántica. |
-| `skapxd/async-functions-return-result` | Funciones async de dominio deben retornar `Promise<Result<...>>`. |
+| `skapxd/async-functions-return-result` | Funciones async de dominio deben retornar `Promise<Result<...>>`. **Apagada por defecto; opt-in** (ver motivos en su sección). |
 | `skapxd/result-error-requires-cause` | Un `Result.err` derivado debe preservar `cause: result.error`. |
-| `skapxd/await-requires-result` | Todo `await` debe resolver en un `Result`: o la función llamada retorna `Promise<Result<...>>` (preferido) o se envuelve en `trySafe`. La activa `shared.frontend`. |
+| `skapxd/await-requires-result` | Todo `await` debe resolver en un `Result`: o la función llamada retorna `Promise<Result<...>>` (preferido) o se envuelve en `trySafe`. **Obligatoria en todos los presets tipados.** |
 | `skapxd/no-ad-hoc-ok-result` | Evita contratos `{ ok: ... }` hechos a mano en async exports. |
 | `skapxd/max-hook-size` | Marca hooks grandes o con demasiados `useState`. |
 | `skapxd/jsx-return-name-pascal-case` | Funciones que retornan JSX deben nombrarse como componentes. |
@@ -465,6 +553,39 @@ sugiere helpers al lado.
 
 ### `skapxd/async-functions-return-result`
 
+> **Apagada por defecto desde v0.5.0** — ningún preset la activa. La regla
+> obligatoria del sistema de errores es `skapxd/await-requires-result`.
+>
+> **Por qué se tomó esta decisión:**
+>
+> 1. **`await-requires-result` produce el mismo estado final con mejor
+>    ergonomía.** Si ningún `await` puede quedar sin `Result`, envolver con
+>    `trySafe` inline una y otra vez se vuelve incómodo rápido — la presión
+>    natural es extraer funciones que retornen `Promise<Result<...>>` con
+>    errores de dominio. Se llega a las mismas firmas que esta regla imponía,
+>    pero por gravedad, no por decreto.
+> 2. **Imponer la firma choca con los bordes del framework.** Los handlers
+>    `GET/POST` de Next, `page.tsx`, los callbacks de librerías: sus firmas no
+>    son tuyas. Esta regla necesitaba listas de excepciones
+>    (`allowFilePatterns`, `allowNamePatterns`) para convivir con eso;
+>    `await-requires-result` no necesita ninguna, porque envolver un `await`
+>    es compatible con cualquier firma.
+> 3. **Adopción incremental.** En un codebase existente, exigir la firma en
+>    cada función async lo rompe todo de golpe. Exigir `Result` en los `await`
+>    permite migrar llamada por llamada.
+>
+> Sigue disponible para quien quiera endurecer el contrato (p. ej. un backend
+> nuevo donde todas las firmas son tuyas):
+>
+> ```js
+> rules: {
+>   "skapxd/async-functions-return-result": ["error", {
+>     checkMissingReturnType: true,
+>     resultTypeNames: ["Result", "ResultValue", "SafeResult"],
+>   }],
+> }
+> ```
+
 Obliga a que funciones async en dominios configurados declaren un retorno como:
 
 ```ts
@@ -484,7 +605,8 @@ type Result<T, E> = ...;                                // ❌ Result ajeno
 async function no(): Promise<Result<number, Error>> {}  // se reporta
 ```
 
-> Requiere `projectService` (los presets `backend` y `next/server` ya lo activan).
+> Requiere `projectService` (actívalo en `languageOptions.parserOptions` o
+> apóyate en un preset tipado del plugin, que ya lo trae).
 > Sin información de tipos cae a una comprobación por nombre (`resultTypeNames`),
 > menos estricta.
 
@@ -509,10 +631,12 @@ el archivo.
 
 ### `skapxd/await-requires-result`
 
-> La activa el preset `shared.frontend` en todo el front: componentes, hooks,
-> handlers y servicios. El contrato queda así: ninguna función está obligada
-> a retornar `Result`, pero todo `await` debe **resolver** en uno. Para
-> activarla en otros globs, añádela tú mismo:
+> **Es la regla obligatoria del sistema de errores**: la activan todos los
+> presets tipados (`shared.frontend`, `shared.backend`, `next/server`,
+> `astro/typescript`). El contrato queda así: ninguna función está obligada
+> a retornar `Result` (eso es `async-functions-return-result`, apagada por
+> defecto), pero todo `await` debe **resolver** en uno. Para activarla en
+> otros globs, añádela tú mismo:
 >
 > ```js
 > rules: {
@@ -640,6 +764,23 @@ function Card() {
 helper en minúscula **sí** pueden tener funciones dentro — ahí es donde se mueve
 la lógica.
 
+**Opciones** (desde v0.6.0) para permitir los dos patrones React idiomáticos
+que la versión estricta bloqueaba — forzarlos a salir del componente producía
+workarounds peores que el problema (`.bind(null, ...)`, adapters artificiales):
+
+```js
+"skapxd/no-functions-inside-components": ["error", {
+  allowJsxCallbacks: true,       // <button onClick={() => onSelect(id)} />
+  allowArrayMapCallbacks: true,  // {entries.map((entry) => <Entry key={entry.id} />)}
+}]
+```
+
+Ambas exenciones aplican **solo a funciones anónimas inline en esa posición
+exacta**: el valor directo de una prop JSX, o el primer argumento de `.map(...)`.
+Un handler con nombre en el cuerpo (`const onClick = () => ...`), un callback de
+`useEffect` o un `.forEach` siguen reportándose — la lógica con peso sigue
+viviendo fuera del componente.
+
 ### `skapxd/no-try-catch`
 
 Prohíbe `try/catch`. La intención es que los errores se modelen como `Result` en
@@ -650,8 +791,9 @@ const result = await trySafe(() => client.execute(query)); // ✅
 if (!result.ok) return Result.err({ cause: result.error, type: "DB_FAILED" });
 ```
 
-Se complementa con `result-error-requires-cause` (preservar la causa) y, si la
-activas, con `await-requires-result` (que además exige que cada `await` resuelva en un `Result`).
+Se complementa con `result-error-requires-cause` (preservar la causa) y con
+`await-requires-result` (obligatoria en los presets tipados: cada `await`
+resuelve en un `Result`).
 
 ### `skapxd/no-promise-chain`
 

package/dist/astro/index.d.mts

@@ -47,6 +47,7 @@ declare function createAstroConfigs(pluginReference: unknown): ({
         skapxd: unknown;
     };
     rules: {
+        "skapxd/await-requires-result": string;
         "skapxd/result-error-requires-cause": string;
     };
 })[];

package/dist/astro/index.d.ts

@@ -47,6 +47,7 @@ declare function createAstroConfigs(pluginReference: unknown): ({
         skapxd: unknown;
     };
     rules: {
+        "skapxd/await-requires-result": string;
         "skapxd/result-error-requires-cause": string;
     };
 })[];

package/dist/astro/index.js

@@ -92,6 +92,7 @@ function createAstroConfigs(pluginReference) {
       name: "skapxd/astro/typescript",
       plugins: { skapxd: pluginReference },
       rules: {
+        "skapxd/await-requires-result": "error",
         "skapxd/result-error-requires-cause": "error"
       }
     }

package/dist/astro/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/astro/index.ts","../../src/shared/configs/base-rules.ts","../../src/shared/configs/create-base-language-options.ts","../../src/shared/configs/create-typed-language-options.ts","../../src/astro/configs.ts"],"sourcesContent":["export { createAstroConfigs } from \"./configs\";\n","export const baseRules = {\n  \"skapxd/no-ad-hoc-ok-result\": \"error\",\n  \"skapxd/no-deep-relative-imports\": \"error\",\n  \"skapxd/no-promise-chain\": \"error\",\n  \"skapxd/no-try-catch\": \"error\",\n  \"skapxd/one-root-function-per-file\": \"error\",\n  \"skapxd/prefer-ts-pattern\": \"error\",\n  \"skapxd/result-error-requires-cause\": \"error\",\n};\n","import tseslint from \"typescript-eslint\";\n\n// Variante sin type-checking: solo el parser, para presets que aplican a TS\n// pero no necesitan projectService (base, package, next/base, next/react).\nexport function createBaseLanguageOptions() {\n  return {\n    parser: tseslint.parser,\n  };\n}\n","import tseslint from \"typescript-eslint\";\n\nexport function createTypedLanguageOptions() {\n  return {\n    // Sin el parser explícito, un consumidor que use solo estos presets\n    // obtiene \"Parsing error\" en cada archivo TS (espree no parsea TS).\n    parser: tseslint.parser,\n    parserOptions: {\n      projectService: true,\n    },\n  };\n}\n","import {\n  baseRules,\n  createBaseLanguageOptions,\n  createTypedLanguageOptions,\n} from \"#/shared/configs\";\n\nexport function createAstroConfigs(pluginReference: unknown) {\n  const baseLanguageOptions = createBaseLanguageOptions();\n  const typedLanguageOptions = createTypedLanguageOptions();\n\n  return [\n    {\n      files: [\"src/**/*.{ts,tsx}\"],\n      languageOptions: baseLanguageOptions,\n      name: \"skapxd/astro/base\",\n      plugins: { skapxd: pluginReference },\n      rules: baseRules,\n    },\n    // Los .astro no llevan parser propio: lo aporta eslint-plugin-astro,\n    // que el consumidor debe tener configurado.\n    {\n      files: [\"src/**/*.astro\"],\n      name: \"skapxd/astro/astro-files\",\n      plugins: { skapxd: pluginReference },\n      rules: baseRules,\n    },\n    {\n      files: [\"src/**/*.{ts,tsx}\"],\n      languageOptions: typedLanguageOptions,\n      name: \"skapxd/astro/typescript\",\n      plugins: { skapxd: pluginReference },\n      rules: {\n        \"skapxd/result-error-requires-cause\": \"error\",\n      },\n    },\n  ];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAO,IAAM,YAAY;AAAA,EACvB,8BAA8B;AAAA,EAC9B,mCAAmC;AAAA,EACnC,2BAA2B;AAAA,EAC3B,uBAAuB;AAAA,EACvB,qCAAqC;AAAA,EACrC,4BAA4B;AAAA,EAC5B,sCAAsC;AACxC;;;ACRA,+BAAqB;AAId,SAAS,4BAA4B;AAC1C,SAAO;AAAA,IACL,QAAQ,yBAAAA,QAAS;AAAA,EACnB;AACF;;;ACRA,IAAAC,4BAAqB;AAEd,SAAS,6BAA6B;AAC3C,SAAO;AAAA;AAAA;AAAA,IAGL,QAAQ,0BAAAC,QAAS;AAAA,IACjB,eAAe;AAAA,MACb,gBAAgB;AAAA,IAClB;AAAA,EACF;AACF;;;ACLO,SAAS,mBAAmB,iBAA0B;AAC3D,QAAM,sBAAsB,0BAA0B;AACtD,QAAM,uBAAuB,2BAA2B;AAExD,SAAO;AAAA,IACL;AAAA,MACE,OAAO,CAAC,mBAAmB;AAAA,MAC3B,iBAAiB;AAAA,MACjB,MAAM;AAAA,MACN,SAAS,EAAE,QAAQ,gBAAgB;AAAA,MACnC,OAAO;AAAA,IACT;AAAA;AAAA;AAAA,IAGA;AAAA,MACE,OAAO,CAAC,gBAAgB;AAAA,MACxB,MAAM;AAAA,MACN,SAAS,EAAE,QAAQ,gBAAgB;AAAA,MACnC,OAAO;AAAA,IACT;AAAA,IACA;AAAA,MACE,OAAO,CAAC,mBAAmB;AAAA,MAC3B,iBAAiB;AAAA,MACjB,MAAM;AAAA,MACN,SAAS,EAAE,QAAQ,gBAAgB;AAAA,MACnC,OAAO;AAAA,QACL,sCAAsC;AAAA,MACxC;AAAA,IACF;AAAA,EACF;AACF;","names":["tseslint","import_typescript_eslint","tseslint"]}
+{"version":3,"sources":["../../src/astro/index.ts","../../src/shared/configs/base-rules.ts","../../src/shared/configs/create-base-language-options.ts","../../src/shared/configs/create-typed-language-options.ts","../../src/astro/configs.ts"],"sourcesContent":["export { createAstroConfigs } from \"./configs\";\n","export const baseRules = {\n  \"skapxd/no-ad-hoc-ok-result\": \"error\",\n  \"skapxd/no-deep-relative-imports\": \"error\",\n  \"skapxd/no-promise-chain\": \"error\",\n  \"skapxd/no-try-catch\": \"error\",\n  \"skapxd/one-root-function-per-file\": \"error\",\n  \"skapxd/prefer-ts-pattern\": \"error\",\n  \"skapxd/result-error-requires-cause\": \"error\",\n};\n","import tseslint from \"typescript-eslint\";\n\n// Variante sin type-checking: solo el parser, para presets que aplican a TS\n// pero no necesitan projectService (base, package, next/base, next/react).\nexport function createBaseLanguageOptions() {\n  return {\n    parser: tseslint.parser,\n  };\n}\n","import tseslint from \"typescript-eslint\";\n\nexport function createTypedLanguageOptions() {\n  return {\n    // Sin el parser explícito, un consumidor que use solo estos presets\n    // obtiene \"Parsing error\" en cada archivo TS (espree no parsea TS).\n    parser: tseslint.parser,\n    parserOptions: {\n      projectService: true,\n    },\n  };\n}\n","import {\n  baseRules,\n  createBaseLanguageOptions,\n  createTypedLanguageOptions,\n} from \"#/shared/configs\";\n\nexport function createAstroConfigs(pluginReference: unknown) {\n  const baseLanguageOptions = createBaseLanguageOptions();\n  const typedLanguageOptions = createTypedLanguageOptions();\n\n  return [\n    {\n      files: [\"src/**/*.{ts,tsx}\"],\n      languageOptions: baseLanguageOptions,\n      name: \"skapxd/astro/base\",\n      plugins: { skapxd: pluginReference },\n      rules: baseRules,\n    },\n    // Los .astro no llevan parser propio: lo aporta eslint-plugin-astro,\n    // que el consumidor debe tener configurado.\n    {\n      files: [\"src/**/*.astro\"],\n      name: \"skapxd/astro/astro-files\",\n      plugins: { skapxd: pluginReference },\n      rules: baseRules,\n    },\n    {\n      files: [\"src/**/*.{ts,tsx}\"],\n      languageOptions: typedLanguageOptions,\n      name: \"skapxd/astro/typescript\",\n      plugins: { skapxd: pluginReference },\n      rules: {\n        \"skapxd/await-requires-result\": \"error\",\n        \"skapxd/result-error-requires-cause\": \"error\",\n      },\n    },\n  ];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAO,IAAM,YAAY;AAAA,EACvB,8BAA8B;AAAA,EAC9B,mCAAmC;AAAA,EACnC,2BAA2B;AAAA,EAC3B,uBAAuB;AAAA,EACvB,qCAAqC;AAAA,EACrC,4BAA4B;AAAA,EAC5B,sCAAsC;AACxC;;;ACRA,+BAAqB;AAId,SAAS,4BAA4B;AAC1C,SAAO;AAAA,IACL,QAAQ,yBAAAA,QAAS;AAAA,EACnB;AACF;;;ACRA,IAAAC,4BAAqB;AAEd,SAAS,6BAA6B;AAC3C,SAAO;AAAA;AAAA;AAAA,IAGL,QAAQ,0BAAAC,QAAS;AAAA,IACjB,eAAe;AAAA,MACb,gBAAgB;AAAA,IAClB;AAAA,EACF;AACF;;;ACLO,SAAS,mBAAmB,iBAA0B;AAC3D,QAAM,sBAAsB,0BAA0B;AACtD,QAAM,uBAAuB,2BAA2B;AAExD,SAAO;AAAA,IACL;AAAA,MACE,OAAO,CAAC,mBAAmB;AAAA,MAC3B,iBAAiB;AAAA,MACjB,MAAM;AAAA,MACN,SAAS,EAAE,QAAQ,gBAAgB;AAAA,MACnC,OAAO;AAAA,IACT;AAAA;AAAA;AAAA,IAGA;AAAA,MACE,OAAO,CAAC,gBAAgB;AAAA,MACxB,MAAM;AAAA,MACN,SAAS,EAAE,QAAQ,gBAAgB;AAAA,MACnC,OAAO;AAAA,IACT;AAAA,IACA;AAAA,MACE,OAAO,CAAC,mBAAmB;AAAA,MAC3B,iBAAiB;AAAA,MACjB,MAAM;AAAA,MACN,SAAS,EAAE,QAAQ,gBAAgB;AAAA,MACnC,OAAO;AAAA,QACL,gCAAgC;AAAA,QAChC,sCAAsC;AAAA,MACxC;AAAA,IACF;AAAA,EACF;AACF;","names":["tseslint","import_typescript_eslint","tseslint"]}

package/dist/astro/index.mjs

@@ -1,7 +1,7 @@
 import {
   createAstroConfigs
-} from "../chunk-3XDQN6ZH.mjs";
-import "../chunk-NYLQRBBK.mjs";
+} from "../chunk-7H7DRTP2.mjs";
+import "../chunk-RWQGOTVZ.mjs";
 export {
   createAstroConfigs
 };

package/dist/{chunk-OYVXAPDZ.mjs → chunk-5BA4KA37.mjs}

@@ -593,8 +593,8 @@ var asyncFunctionsReturnResult = {
       description: "Exige Promise<Result<...>> en funciones async de dominio."
     },
     messages: {
-      missingReturnType: "La funcion async `{{name}}` debe declarar Promise<Result<...>> como tipo de retorno.",
-      invalidReturnType: "La funcion async `{{name}}` debe retornar Promise<Result<...>> para modelar errores de forma explicita."
+      missingReturnType: "La funcion async `{{name}}` debe declarar Promise<Result<...>> como tipo de retorno: trySafe en la frontera, errores de dominio con `cause`, y el consumidor decide con `match()` de ts-pattern.",
+      invalidReturnType: "La funcion async `{{name}}` debe retornar Promise<Result<...>> para modelar errores de forma explicita: trySafe en la frontera, errores de dominio con `cause`, y el consumidor decide con `match()` de ts-pattern."
     },
     schema: [
       {
@@ -780,7 +780,7 @@ var noAdHocOkResult = {
       description: "Prohibe retornar contratos ad hoc con ok en funciones async exportadas."
     },
     messages: {
-      adHocOkResult: "No retornes objetos ad hoc con `ok` desde la funcion async `{{name}}`. Usa Result.ok(...) / Result.err(...) con un error discriminado `{ type: ... }`."
+      adHocOkResult: "No retornes objetos ad hoc con `ok` desde la funcion async `{{name}}`. Usa Result.ok(...) / Result.err(...) de @skapxd/result con un error discriminado `{ type: ... }`: un unico contrato Result permite consumir cada variante con `match()` de ts-pattern y `.exhaustive()`."
     },
     schema: []
   },
@@ -903,7 +903,7 @@ var awaitRequiresResult = {
       description: "Exige que todo await resuelva en un Result: una funcion que retorne Promise<Result<...>> o trySafe en el sitio."
     },
     messages: {
-      awaitWithoutResult: "El await dentro de `{{name}}` no resuelve en un Result. Mejor opcion: extrae la operacion a una funcion que retorne Promise<Result<...>> y modela ahi los errores de dominio (el trySafe vive dentro de esa funcion). Alternativa: envuelvela aqui mismo: `{{suggestion}}`."
+      awaitWithoutResult: "El await dentro de `{{name}}` no resuelve en un Result. Mejor opcion: extrae la operacion a una funcion que retorne Promise<Result<...>> y modela ahi los errores de dominio con `{ type, message, cause }` (el trySafe vive dentro de esa funcion). Alternativa: envuelvela aqui mismo: `{{suggestion}}`. En ambos casos, consume el Result con `match()` de ts-pattern."
     },
     schema: [
       {
@@ -1115,7 +1115,7 @@ var resultErrorRequiresCause = {
       description: "Exige preservar result.error como cause cuando una funcion que retorna Result transforma un Result fallido en Result.err."
     },
     messages: {
-      missingCause: "El error de `{{name}}` ya existe como `{{name}}.error`. Preservalo en Result.err con `cause: {{name}}.error`."
+      missingCause: "El error de `{{name}}` ya existe como `{{name}}.error`. Preservalo en Result.err con `cause: {{name}}.error`: la cadena de causas conecta el error de dominio con la excepcion original que capturo `trySafe`; sin ella el debugging pierde el contexto."
     },
     schema: []
   },
@@ -1337,6 +1337,37 @@ var noDeepRelativeImports = {
   }
 };
 
+// src/utils/get-no-functions-inside-components-options.ts
+function getNoFunctionsInsideComponentsOptions(options = {}) {
+  return {
+    allowArrayMapCallbacks: options.allowArrayMapCallbacks ?? false,
+    allowJsxCallbacks: options.allowJsxCallbacks ?? false
+  };
+}
+
+// src/utils/is-anonymous-inline-function.ts
+function isAnonymousInlineFunction(node) {
+  if (node.type === "ArrowFunctionExpression") {
+    return true;
+  }
+  return node.type === "FunctionExpression" && !node.id;
+}
+
+// src/utils/is-array-map-callback.ts
+function isArrayMapCallback(node) {
+  const parent = node.parent;
+  if (parent?.type !== "CallExpression" || parent.arguments[0] !== node) {
+    return false;
+  }
+  const callee = parent.callee;
+  return callee?.type === "MemberExpression" && !callee.computed && callee.property?.type === "Identifier" && callee.property.name === "map";
+}
+
+// src/utils/is-jsx-attribute-callback.ts
+function isJsxAttributeCallback(node) {
+  return node.parent?.type === "JSXExpressionContainer" && node.parent.parent?.type === "JSXAttribute";
+}
+
 // src/rules/no-functions-inside-components.ts
 var noFunctionsInsideComponents = {
   meta: {
@@ -1347,17 +1378,39 @@ var noFunctionsInsideComponents = {
     messages: {
       functionInsideComponent: "No definas funciones dentro del componente `{{component}}`: se recrean en cada render. Muevela a un hook (`useX`) o a un helper fuera del componente."
     },
-    schema: []
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowArrayMapCallbacks: { type: "boolean" },
+          allowJsxCallbacks: { type: "boolean" }
+        },
+        type: "object"
+      }
+    ]
   },
   create(context) {
+    const options = getNoFunctionsInsideComponentsOptions(context.options[0]);
     function isComponentFunction(node) {
       return isFunctionNode(node) && isPascalCaseName(getFunctionName(node));
     }
+    function isAllowedInlineCallback(node) {
+      if (!isAnonymousInlineFunction(node)) {
+        return false;
+      }
+      if (options.allowJsxCallbacks && isJsxAttributeCallback(node)) {
+        return true;
+      }
+      return options.allowArrayMapCallbacks && isArrayMapCallback(node);
+    }
     function reportIfInsideComponent(node) {
       const enclosingFunction = getContainingFunction(node);
       if (!enclosingFunction || !isComponentFunction(enclosingFunction)) {
         return;
       }
+      if (isAllowedInlineCallback(node)) {
+        return;
+      }
       context.report({
         data: {
           component: getFunctionName(enclosingFunction)
@@ -1382,7 +1435,7 @@ var noTryCatch = {
       description: "Prohibe try/catch; usa trySafe de @skapxd/result para modelar el error como Result."
     },
     messages: {
-      noTryCatch: "Usa `trySafe` de @skapxd/result en lugar de try/catch. El error queda modelado como Result en vez de saltar como excepcion."
+      noTryCatch: "Usa `trySafe` de @skapxd/result en lugar de try/catch: el error queda modelado como Result en vez de saltar como excepcion. Luego mapealo a un error de dominio `{ type, message, cause }` y consumelo con `match()` de ts-pattern."
     },
     schema: []
   },
@@ -1406,8 +1459,8 @@ var preferTsPattern = {
       description: "Prefiere match() de ts-pattern sobre switch/case y ternarios anidados."
     },
     messages: {
-      noSwitch: "Usa `match()` de ts-pattern en lugar de switch/case para un control de flujo exhaustivo y tipado.",
-      noNestedTernary: "Usa `match()` de ts-pattern en lugar de ternarios anidados; mejora la legibilidad y la exhaustividad."
+      noSwitch: "Usa `match()` de ts-pattern en lugar de switch/case para un control de flujo exhaustivo y tipado. Es la pieza que cierra el sistema de errores: un Result con errores `{ type: ... }` se consume con una rama `.with()` por variante y `.exhaustive()` garantiza que ninguna quede sin manejar.",
+      noNestedTernary: "Usa `match()` de ts-pattern en lugar de ternarios anidados; mejora la legibilidad y `.exhaustive()` obliga a cubrir todos los casos."
     },
     schema: []
   },
@@ -1483,7 +1536,7 @@ var noPromiseChain = {
       description: "Prohibe encadenar .then/.catch/.finally en promesas; usa await (envuelto en trySafe)."
     },
     messages: {
-      noPromiseChain: "No encadenes `.{{method}}()` en una promesa. La unica forma de tratar funciones asincronas es `await` (envuelto en `trySafe`)."
+      noPromiseChain: "No encadenes `.{{method}}()` en una promesa. La unica forma de tratar funciones asincronas es `await`: o la funcion llamada ya retorna Promise<Result<...>> o envuelve la llamada en `trySafe` de @skapxd/result."
     },
     schema: [
       {
@@ -1556,4 +1609,4 @@ var rules = {
 export {
   rules
 };
-//# sourceMappingURL=chunk-OYVXAPDZ.mjs.map
+//# sourceMappingURL=chunk-5BA4KA37.mjs.map