@skapxd/eslint-opinionated 0.5.0 → 0.7.0

package/README.md

@@ -510,6 +510,50 @@ export default [
 Si necesitas una excepción puntual (p. ej. archivos generados), añade después un
 bloque con `linterOptions: { noInlineConfig: false }` para esos globs.
 
+## Configurar y sobrescribir reglas
+
+Los presets son flat configs normales de ESLint: **el último config que
+matchea un archivo gana**. Para ajustar una regla encima de un preset, esparce
+sus `rules` y sobrescribe la entrada:
+
+```js
+export default [
+  {
+    files: ["src/**/*.{ts,tsx}"],
+    ...skapxd.configs.shared.frontend,
+    rules: {
+      ...skapxd.configs.shared.frontend.rules,
+      // mismo id, nuevas opciones: esta entrada reemplaza a la del preset
+      "skapxd/no-deep-relative-imports": ["error", { maxDepth: 1 }],
+    },
+  },
+];
+```
+
+> Las opciones de una regla **se reemplazan completas**, no se mergean: si el
+> preset pasaba opciones y tú la redeclaras, incluye también las que quieras
+> conservar. (Excepción: los patrones *integrados* de `no-default-export` —
+> configs y stories — viven dentro de la regla y nunca se pierden; tus
+> `allowFilePatterns` se suman a ellos.)
+
+Referencia rápida de qué se puede configurar (detalle y defaults en la sección
+de cada regla):
+
+| Regla | Opciones |
+| --- | --- |
+| `async-functions-return-result` | `allowFilePatterns` (globs), `allowNamePatterns` (regex), `checkMissingReturnType`, `checkMissingReturnTypeWhenCallNames`, `requireCallNames`, `promiseTypeNames`, `resultTypeNames` |
+| `await-requires-result` | `allowFilePatterns` (globs), `trySafeCallNames` |
+| `max-hook-size` | `maxLines`, `maxUseState` |
+| `no-deep-relative-imports` | `maxDepth` |
+| `no-default-export` | `allowFilePatterns` (globs, aditivos a los integrados) |
+| `no-functions-inside-components` | `allowJsxCallbacks`, `allowArrayMapCallbacks` (ambas `true` por defecto) |
+| `no-promise-chain` | `methods` |
+
+Los `allowFilePatterns` de todas las reglas son **globs** (`*` un segmento,
+`**` cualquier profundidad, `{a,b}` alternativas; un patrón sin prefijo
+matchea en cualquier carpeta). Las 7 reglas restantes no tienen opciones: su
+única configuración es activarlas, apagarlas o cambiar la severidad.
+
 ## Reglas
 
 | Regla | Qué protege |
@@ -522,6 +566,7 @@ bloque con `linterOptions: { noInlineConfig: false }` para esos globs.
 | `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. |
 | `skapxd/no-deep-relative-imports` | Limita la profundidad de los imports relativos (`../`). |
+| `skapxd/no-default-export` | Prohíbe `export default`; el nombre del símbolo es el contrato. Exime configs/stories y, en el preset `next`, los entrypoints del App Router. |
 | `skapxd/no-functions-inside-components` | Prohíbe definir funciones dentro de componentes React. |
 | `skapxd/no-try-catch` | Prohíbe `try/catch`; usa `trySafe` de `@skapxd/result`. |
 | `skapxd/no-promise-chain` | Prohíbe `.then/.catch/.finally`; usa `await` (+ `trySafe`). |
@@ -610,6 +655,20 @@ async function no(): Promise<Result<number, Error>> {}  // se reporta
 > Sin información de tipos cae a una comprobación por nombre (`resultTypeNames`),
 > menos estricta.
 
+Todas las opciones, con sus defaults:
+
+```js
+"skapxd/async-functions-return-result": ["error", {
+  allowFilePatterns: [],       // globs de archivos exentos, p. ej. ["src/legacy/**"]
+  allowNamePatterns: [],       // regex de nombres exentos, p. ej. ["^(GET|POST)$"]
+  checkMissingReturnType: true, // reportar también funciones SIN anotación de retorno
+  checkMissingReturnTypeWhenCallNames: [], // ...o solo si el cuerpo llama a estos nombres
+  requireCallNames: [],        // acotar la regla a funciones que llamen a estos nombres
+  promiseTypeNames: ["Promise"],  // wrappers de promesa aceptados (fallback sin tipos)
+  resultTypeNames: ["Result"],    // nombres de Result aceptados (fallback sin tipos)
+}]
+```
+
 ### `skapxd/result-error-requires-cause`
 
 Evita perder el error original al transformar un `Result` fallido:
@@ -698,6 +757,30 @@ Sirve para código de pegamento, pero deja el error sin modelar (`Result<T,
 unknown>`). Cuando la misma operación se repite o el error importa, el mensaje
 de la regla empuja hacia el camino 1.
 
+### `skapxd/no-ad-hoc-ok-result`
+
+Prohíbe que una función async **exportada** retorne objetos literales con la
+forma `{ ok: ... }` armados a mano. Un contrato casero fragmenta el sistema:
+cada módulo inventa su variante, la exención type-aware de
+`await-requires-result` no lo reconoce, y `match()` pierde la exhaustividad.
+
+```ts
+export async function getUser(id: string) {
+  return { ok: false, message: "falló" };          // ❌ contrato inventado
+}
+
+export async function getUser(id: string): Promise<Result<User, UserError>> {
+  return Result.err({                               // ✅ el Result real
+    cause: error,
+    message: "No pude cargar el usuario.",
+    type: "USER_FETCH_FAILED",
+  });
+}
+```
+
+Solo mira funciones async exportadas: un helper interno con un objeto `ok`
+cualquiera no es un contrato público y no se reporta.
+
 ### `skapxd/max-hook-size`
 
 Marca hooks que crecen demasiado o acumulan muchos `useState`.
@@ -705,6 +788,35 @@ Marca hooks que crecen demasiado o acumulan muchos `useState`.
 La intención es empujar el diseño hacia `useReducer`, hooks más pequeños o
 módulos de transición de estado.
 
+Opciones (los presets `frontend` y `next` usan `maxLines: 120`, `maxUseState: 1`):
+
+```js
+"skapxd/max-hook-size": ["error", {
+  maxLines: 120,   // líneas máximas del cuerpo del hook
+  maxUseState: 1,  // useState propios permitidos antes de exigir useReducer
+}]
+```
+
+### `skapxd/jsx-return-name-pascal-case`
+
+Si una función devuelve JSX, es un componente, y debe llamarse como tal:
+PascalCase. El mensaje sugiere el rename concreto.
+
+```tsx
+function renderUserCard(user: User) {  // ❌ "render*" devuelve JSX → es un componente
+  return <article>{user.name}</article>;
+}
+
+function UserCard({ user }: { user: User }) {  // ✅ nombre de componente + props
+  return <article>{user.name}</article>;
+}
+```
+
+Esta regla es la que mantiene honesto al resto del sistema React: las reglas
+de componentes detectan "componente" por nombre PascalCase, así que una
+función `renderX` que devuelve JSX escaparía de ellas. Esta la captura y
+fuerza el rename — y con el nombre corregido, las demás ya la ven.
+
 ### `skapxd/no-deep-relative-imports`
 
 Limita cuántos niveles puede subir un import relativo. Por defecto **prohíbe
@@ -730,20 +842,73 @@ Revisa imports estáticos (`import`), re-exports (`export ... from`) e imports
 dinámicos (`import(...)`). El remedio habitual es un alias de ruta (`@/...`) o
 acercar el módulo a quien lo usa.
 
+### `skapxd/no-default-export`
+
+Prohíbe `export default` (incluida la forma `export { x as default }`). Con
+exports nombrados, el nombre del símbolo es el contrato del módulo: renombrar
+con el IDE actualiza todos los usos, `grep` encuentra definición y consumo, y
+los autoimports no inventan nombres distintos por archivo.
+
+```ts
+export default function getUser() {}   // ❌ cada import puede llamarlo distinto
+export function getUser() {}            // ✅ un solo nombre canónico
+```
+
+**Dónde sí se permite el default.** Hay entrypoints donde el ecosistema lo
+exige, y la regla los reconoce en capas:
+
+1. **Integrados (siempre activos):** configs de tooling (`*.config.{js,mjs,cjs,ts}`:
+   `next.config`, `tailwind.config`, `vitest.config`, `eslint.config`, ...) y
+   stories de Storybook (`*.stories.*`).
+2. **Preset `next` (automático):** los entrypoints del App Router donde Next
+   exige el default — `page`, `layout`, `template`, `error`, `loading`,
+   `not-found`, `sitemap`, `robots`, `manifest`, `icon`, `opengraph-image`,
+   etc. No hay que configurar nada.
+3. **`allowFilePatterns` (extensible):** si usas un framework o tool que la
+   regla aún no contempla, agrega su glob. Los patrones propios se **suman**
+   a los integrados, no los reemplazan. Son globs legibles (`*` un segmento,
+   `**` cualquier profundidad, `{a,b}` alternativas) y un patrón sin prefijo
+   matchea en cualquier carpeta:
+
+```js
+"skapxd/no-default-export": ["error", {
+  // p. ej. SvelteKit exige default en +page.ts / +layout.ts
+  allowFilePatterns: ["+page.ts", "+layout.ts"],
+}]
+```
+
+Detalle útil con `React.lazy` (que espera `{ default }`): no hace falta volver
+al default export, basta mapear el named en el import dinámico:
+
+```ts
+const Card = lazy(() => import("./card").then((m) => ({ default: m.Card })));
+```
+
 ### `skapxd/no-functions-inside-components`
 
-Prohíbe **cualquier** función definida dentro de un componente React (una función
-con nombre PascalCase). Cada render recrea esas funciones, lo que dispara
-re-renders innecesarios en hijos memoizados y mezcla lógica con composición.
+Prohíbe definir funciones **con peso propio** dentro de un componente React
+(una función con nombre PascalCase): handlers con nombre, helpers, callbacks de
+`useEffect`. Cada render las recrea, dispara re-renders en hijos memoizados y
+mezcla lógica con composición.
 
 ```tsx
 function Card() {
-  const onClick = () => save();          // ❌ se recrea en cada render
+  const onClick = () => save();          // ❌ handler con nombre en el cuerpo
   useEffect(() => subscribe(), []);      // ❌ callback dentro del componente
-  return <ul>{items.map((i) => <Li />)}</ul>; // ❌ callback de .map en el render
+  return (
+    <ul>
+      {items.map((i) => <Li key={i} />)}            {/* ✅ React idiomático */}
+      <button onClick={() => save()}>Guardar</button> {/* ✅ React idiomático */}
+    </ul>
+  );
 }
 ```
 
+Los dos patrones idiomáticos de React están **permitidos por defecto**: el
+callback anónimo como valor directo de una prop JSX y el callback anónimo de
+`.map(...)` en el render. Forzarlos a salir del componente produce workarounds
+peores que el problema (`.bind(null, ...)`, adapters artificiales).
+
 El cuerpo del componente queda como composición declarativa; **toda** función
 —handlers, efectos, memos, mapeos— vive fuera:
 
@@ -764,6 +929,28 @@ function Card() {
 helper en minúscula **sí** pueden tener funciones dentro — ahí es donde se mueve
 la lógica.
 
+**Opciones.** Las exenciones aplican solo a **flechas de expresión** (sin
+cuerpo `{ }`) en esa posición exacta: el valor directo de una prop JSX, o el
+primer argumento de `.map(...)`. La distinción importa: una flecha de expresión
+solo puede contener una expresión — es declarativa por construcción —, mientras
+que un bloque da pie a `if`s, variables y llamadas que pertenecen fuera:
+
+```tsx
+{items.map((i) => <li key={i} />)}              // ✅ flecha de expresión
+{items.map((i) => { return <li key={i} />; })}  // ❌ bloque: invita a meter lógica
+```
+
+Un handler con nombre en el cuerpo (`const onClick = () => ...`), un callback
+de `useEffect` o un `.forEach` siguen reportándose. Para el modo ultraestricto
+(ninguna función inline, como en v0.6.0 y anteriores), apágalas explícitamente:
+
+```js
+"skapxd/no-functions-inside-components": ["error", {
+  allowJsxCallbacks: false,       // también reporta onClick={() => ...}
+  allowArrayMapCallbacks: false,  // también reporta items.map((i) => ...)
+}]
+```
+
 ### `skapxd/no-try-catch`
 
 Prohíbe `try/catch`. La intención es que los errores se modelen como `Result` en

package/dist/astro/index.d.mts

@@ -12,6 +12,7 @@ declare function createAstroConfigs(pluginReference: unknown): ({
     rules: {
         "skapxd/no-ad-hoc-ok-result": string;
         "skapxd/no-deep-relative-imports": string;
+        "skapxd/no-default-export": string;
         "skapxd/no-promise-chain": string;
         "skapxd/no-try-catch": string;
         "skapxd/one-root-function-per-file": string;
@@ -27,6 +28,7 @@ declare function createAstroConfigs(pluginReference: unknown): ({
     rules: {
         "skapxd/no-ad-hoc-ok-result": string;
         "skapxd/no-deep-relative-imports": string;
+        "skapxd/no-default-export": string;
         "skapxd/no-promise-chain": string;
         "skapxd/no-try-catch": string;
         "skapxd/one-root-function-per-file": string;

package/dist/astro/index.d.ts

@@ -12,6 +12,7 @@ declare function createAstroConfigs(pluginReference: unknown): ({
     rules: {
         "skapxd/no-ad-hoc-ok-result": string;
         "skapxd/no-deep-relative-imports": string;
+        "skapxd/no-default-export": string;
         "skapxd/no-promise-chain": string;
         "skapxd/no-try-catch": string;
         "skapxd/one-root-function-per-file": string;
@@ -27,6 +28,7 @@ declare function createAstroConfigs(pluginReference: unknown): ({
     rules: {
         "skapxd/no-ad-hoc-ok-result": string;
         "skapxd/no-deep-relative-imports": string;
+        "skapxd/no-default-export": string;
         "skapxd/no-promise-chain": string;
         "skapxd/no-try-catch": string;
         "skapxd/one-root-function-per-file": string;

package/dist/astro/index.js

@@ -38,6 +38,7 @@ module.exports = __toCommonJS(astro_exports);
 var baseRules = {
   "skapxd/no-ad-hoc-ok-result": "error",
   "skapxd/no-deep-relative-imports": "error",
+  "skapxd/no-default-export": "error",
   "skapxd/no-promise-chain": "error",
   "skapxd/no-try-catch": "error",
   "skapxd/one-root-function-per-file": "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/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"]}
+{"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-default-export\": \"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,4BAA4B;AAAA,EAC5B,2BAA2B;AAAA,EAC3B,uBAAuB;AAAA,EACvB,qCAAqC;AAAA,EACrC,4BAA4B;AAAA,EAC5B,sCAAsC;AACxC;;;ACTA,+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-7H7DRTP2.mjs";
-import "../chunk-RWQGOTVZ.mjs";
+} from "../chunk-OVPAO7Q3.mjs";
+import "../chunk-LDAR6XT6.mjs";
 export {
   createAstroConfigs
 };

package/dist/{chunk-QJQ2E2NG.mjs → chunk-72XIHMY7.mjs}

@@ -1,10 +1,18 @@
+import {
+  nextAppMetadataFileStems,
+  nextAppRouteSegmentFileStems
+} from "./chunk-HB755SJQ.mjs";
 import {
   baseRules,
   createBaseLanguageOptions,
   createTypedLanguageOptions
-} from "./chunk-RWQGOTVZ.mjs";
+} from "./chunk-LDAR6XT6.mjs";
 
 // src/next/configs.ts
+var nextDefaultExportFileGlob = `{${[
+  ...nextAppRouteSegmentFileStems,
+  ...nextAppMetadataFileStems
+].join(",")}}.{js,jsx,ts,tsx}`;
 function createNextConfigs(pluginReference) {
   const baseLanguageOptions = createBaseLanguageOptions();
   const typedLanguageOptions = createTypedLanguageOptions();
@@ -13,7 +21,15 @@ function createNextConfigs(pluginReference) {
       languageOptions: baseLanguageOptions,
       name: "skapxd/next/base",
       plugins: { skapxd: pluginReference },
-      rules: baseRules
+      rules: {
+        ...baseRules,
+        "skapxd/no-default-export": [
+          "error",
+          {
+            allowFilePatterns: [nextDefaultExportFileGlob]
+          }
+        ]
+      }
     },
     {
       files: ["src/app/api/**/*.{ts,tsx}", "src/server/**/*.{ts,tsx}"],
@@ -53,4 +69,4 @@ function createNextConfigs(pluginReference) {
 export {
   createNextConfigs
 };
-//# sourceMappingURL=chunk-QJQ2E2NG.mjs.map
+//# sourceMappingURL=chunk-72XIHMY7.mjs.map

package/dist/chunk-72XIHMY7.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/next/configs.ts"],"sourcesContent":["import { nextAppMetadataFileStems } from \"#/constants/next-app-metadata-file-stems\";\nimport { nextAppRouteSegmentFileStems } from \"#/constants/next-app-route-segment-file-stems\";\nimport {\n  baseRules,\n  createBaseLanguageOptions,\n  createTypedLanguageOptions,\n} from \"#/shared/configs\";\n\n// Entrypoints donde Next exige `export default` (page, layout, sitemap, ...):\n// la regla no-default-export los exime automáticamente en este preset.\nconst nextDefaultExportFileGlob = `{${[\n  ...nextAppRouteSegmentFileStems,\n  ...nextAppMetadataFileStems,\n].join(\",\")}}.{js,jsx,ts,tsx}`;\n\nexport function createNextConfigs(pluginReference: unknown) {\n  const baseLanguageOptions = createBaseLanguageOptions();\n  const typedLanguageOptions = createTypedLanguageOptions();\n\n  return [\n    {\n      languageOptions: baseLanguageOptions,\n      name: \"skapxd/next/base\",\n      plugins: { skapxd: pluginReference },\n      rules: {\n        ...baseRules,\n        \"skapxd/no-default-export\": [\n          \"error\",\n          {\n            allowFilePatterns: [nextDefaultExportFileGlob],\n          },\n        ],\n      },\n    },\n    {\n      files: [\"src/app/api/**/*.{ts,tsx}\", \"src/server/**/*.{ts,tsx}\"],\n      languageOptions: typedLanguageOptions,\n      name: \"skapxd/next/server\",\n      plugins: { skapxd: pluginReference },\n      rules: {\n        ...baseRules,\n        // Obligatoria: todo await resuelve en Result. A diferencia de\n        // async-functions-return-result (apagada por defecto), no necesita\n        // excepciones para los entrypoints de Next: envolver un await en\n        // trySafe es compatible con cualquier firma que imponga el framework.\n        \"skapxd/await-requires-result\": \"error\",\n      },\n    },\n    {\n      files: [\"**/*.tsx\"],\n      languageOptions: baseLanguageOptions,\n      name: \"skapxd/next/react\",\n      plugins: { skapxd: pluginReference },\n      rules: {\n        \"skapxd/jsx-return-name-pascal-case\": \"error\",\n        \"skapxd/no-functions-inside-components\": \"error\",\n        \"skapxd/no-jsx-ternary-null\": \"error\",\n        \"skapxd/max-hook-size\": [\n          \"error\",\n          {\n            maxLines: 120,\n            maxUseState: 1,\n          },\n        ],\n      },\n    },\n  ];\n}\n"],"mappings":";;;;;;;;;;;AAUA,IAAM,4BAA4B,IAAI;AAAA,EACpC,GAAG;AAAA,EACH,GAAG;AACL,EAAE,KAAK,GAAG,CAAC;AAEJ,SAAS,kBAAkB,iBAA0B;AAC1D,QAAM,sBAAsB,0BAA0B;AACtD,QAAM,uBAAuB,2BAA2B;AAExD,SAAO;AAAA,IACL;AAAA,MACE,iBAAiB;AAAA,MACjB,MAAM;AAAA,MACN,SAAS,EAAE,QAAQ,gBAAgB;AAAA,MACnC,OAAO;AAAA,QACL,GAAG;AAAA,QACH,4BAA4B;AAAA,UAC1B;AAAA,UACA;AAAA,YACE,mBAAmB,CAAC,yBAAyB;AAAA,UAC/C;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,IACA;AAAA,MACE,OAAO,CAAC,6BAA6B,0BAA0B;AAAA,MAC/D,iBAAiB;AAAA,MACjB,MAAM;AAAA,MACN,SAAS,EAAE,QAAQ,gBAAgB;AAAA,MACnC,OAAO;AAAA,QACL,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA,QAKH,gCAAgC;AAAA,MAClC;AAAA,IACF;AAAA,IACA;AAAA,MACE,OAAO,CAAC,UAAU;AAAA,MAClB,iBAAiB;AAAA,MACjB,MAAM;AAAA,MACN,SAAS,EAAE,QAAQ,gBAAgB;AAAA,MACnC,OAAO;AAAA,QACL,sCAAsC;AAAA,QACtC,yCAAyC;AAAA,QACzC,8BAA8B;AAAA,QAC9B,wBAAwB;AAAA,UACtB;AAAA,UACA;AAAA,YACE,UAAU;AAAA,YACV,aAAa;AAAA,UACf;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

package/dist/{chunk-QNSHGNVQ.mjs → chunk-G6TJUBFT.mjs}

@@ -1,3 +1,8 @@
+import {
+  nextAppMetadataFileStems,
+  nextAppRouteSegmentFileStems
+} from "./chunk-HB755SJQ.mjs";
+
 // src/utils/get-file-name.ts
 function getFileName(filename) {
   return filename.split(/[\\/]/).at(-1) ?? filename;
@@ -47,33 +52,6 @@ function isInsideAppDirectory(filename) {
   return getPathParts(filename).includes("app");
 }
 
-// src/constants/next-app-metadata-file-stems.ts
-var nextAppMetadataFileStems = [
-  "apple-icon",
-  "icon",
-  "manifest",
-  "opengraph-image",
-  "robots",
-  "sitemap",
-  "twitter-image"
-];
-
-// src/constants/next-app-route-segment-file-stems.ts
-var nextAppRouteSegmentFileStems = [
-  "default",
-  "error",
-  "forbidden",
-  "global-error",
-  "global-not-found",
-  "layout",
-  "loading",
-  "not-found",
-  "page",
-  "route",
-  "template",
-  "unauthorized"
-];
-
 // src/constants/next-project-root-file-stems.ts
 var nextProjectRootFileStems = [
   "instrumentation",
@@ -580,6 +558,16 @@ function isSkapxdResultOrPromiseResultType(type, typeContext) {
   return Boolean(promisedType && isSkapxdResultType(promisedType, typeContext));
 }
 
+// src/utils/matches-any-glob.ts
+import picomatch from "picomatch";
+function matchesAnyGlob(filePath, globs) {
+  const normalized = filePath.replaceAll("\\", "/");
+  return globs.some((glob) => {
+    const anchored = glob.startsWith("/") || glob.startsWith("**") ? glob : `**/${glob}`;
+    return picomatch(anchored)(normalized);
+  });
+}
+
 // src/utils/matches-any-pattern.ts
 function matchesAnyPattern(value, patterns) {
   return patterns.some((pattern) => new RegExp(pattern).test(value));
@@ -642,7 +630,7 @@ var asyncFunctionsReturnResult = {
       return isPromiseOfResultType(annotation, options);
     }
     function reportIfInvalidAsyncReturn(node, name, reportNode = node) {
-      if (!node.async || matchesAnyPattern(filename, options.allowFilePatterns)) {
+      if (!node.async || matchesAnyGlob(filename, options.allowFilePatterns)) {
         return;
       }
       const functionName = name ?? "anonymous";
@@ -939,7 +927,7 @@ var awaitRequiresResult = {
     }
     return {
       AwaitExpression(node) {
-        if (matchesAnyPattern(filename, options.allowFilePatterns)) {
+        if (matchesAnyGlob(filename, options.allowFilePatterns)) {
           return;
         }
         if (typeContext && isSkapxdResultOrPromiseResultExpression(node.argument, typeContext)) {
@@ -1337,6 +1325,96 @@ var noDeepRelativeImports = {
   }
 };
 
+// src/constants/default-export-allowed-file-patterns.ts
+var defaultExportAllowedFilePatterns = [
+  "*.config.*",
+  "*.stories.*"
+];
+
+// src/utils/get-no-default-export-options.ts
+function getNoDefaultExportOptions(options = {}) {
+  return {
+    allowFilePatterns: [
+      ...defaultExportAllowedFilePatterns,
+      ...options.allowFilePatterns ?? []
+    ]
+  };
+}
+
+// src/rules/no-default-export.ts
+var noDefaultExport = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Prohibe export default; un export nombrado hace del nombre el contrato del modulo."
+    },
+    messages: {
+      noDefaultExport: 'No uses `export default`: un export nombrado hace el simbolo renombrable con el IDE, grepeable y estable en autoimports. Si este archivo es un entrypoint donde un framework o tool exige el default, agrega su glob en `allowFilePatterns` de skapxd/no-default-export (p. ej. "+page.ts").'
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowFilePatterns: {
+            items: { type: "string" },
+            type: "array"
+          }
+        },
+        type: "object"
+      }
+    ]
+  },
+  create(context) {
+    const options = getNoDefaultExportOptions(context.options[0]);
+    const filename = context.filename ?? context.getFilename();
+    if (matchesAnyGlob(filename, options.allowFilePatterns)) {
+      return {};
+    }
+    return {
+      ExportDefaultDeclaration(node) {
+        context.report({ messageId: "noDefaultExport", node });
+      },
+      // Cubre la forma indirecta: `export { algo as default }`.
+      ExportNamedDeclaration(node) {
+        for (const specifier of node.specifiers ?? []) {
+          const exportedName = specifier.exported?.name ?? specifier.exported?.value;
+          if (exportedName === "default") {
+            context.report({ messageId: "noDefaultExport", node: specifier });
+          }
+        }
+      }
+    };
+  }
+};
+
+// src/utils/get-no-functions-inside-components-options.ts
+function getNoFunctionsInsideComponentsOptions(options = {}) {
+  return {
+    allowArrayMapCallbacks: options.allowArrayMapCallbacks ?? true,
+    allowJsxCallbacks: options.allowJsxCallbacks ?? true
+  };
+}
+
+// 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-expression-arrow-function.ts
+function isExpressionArrowFunction(node) {
+  return node.type === "ArrowFunctionExpression" && node.body.type !== "BlockStatement";
+}
+
+// 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: {
@@ -1345,19 +1423,41 @@ var noFunctionsInsideComponents = {
       description: "Prohibe definir funciones dentro de componentes React; se recrean en cada render."
     },
     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."
+      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. Los callbacks inline de JSX y .map solo se permiten como flecha de expresion (sin cuerpo `{ }`): un bloque ya da pie a ifs y logica que pertenece fuera."
     },
-    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 (!isExpressionArrowFunction(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)
@@ -1546,6 +1646,7 @@ var rules = {
   "result-error-requires-cause": resultErrorRequiresCause,
   "max-hook-size": maxHookSize,
   "no-deep-relative-imports": noDeepRelativeImports,
+  "no-default-export": noDefaultExport,
   "no-functions-inside-components": noFunctionsInsideComponents,
   "no-try-catch": noTryCatch,
   "prefer-ts-pattern": preferTsPattern,
@@ -1556,4 +1657,4 @@ var rules = {
 export {
   rules
 };
-//# sourceMappingURL=chunk-QNSHGNVQ.mjs.map
+//# sourceMappingURL=chunk-G6TJUBFT.mjs.map