@skapxd/eslint-opinionated 0.15.0 → 0.17.0

package/README.md

@@ -98,11 +98,11 @@ la que defiende el axioma más fundamental (el orden es jerárquico).
 
 | # | Axioma | Reglas que lo ejecutan |
 | --- | --- | --- |
-| A1 | **Los estados imposibles son irrepresentables.** El tipo modela exactamente los estados válidos; lo inválido no compila. | `prefer-tagged-union-state`, `no-runtime-state-guard`, `requires-strict-tsconfig`, `no-impossible-branch`, `no-explicit-any`, `consistent-type-definitions` |
-| A2 | **Ningún efecto es invisible al tipo.** Si una operación puede fallar, su firma lo confiesa — no una convención oral ni un `throw` sorpresa. | `await-requires-result`, `no-try-catch`, `no-promise-chain`, `no-ad-hoc-ok-result`, `@typescript-eslint/no-floating-promises` |
+| A1 | **Los estados imposibles son irrepresentables.** El tipo modela exactamente los estados válidos; lo inválido no compila. | `prefer-tagged-union-state`, `no-runtime-state-guard`, `requires-strict-tsconfig`, `no-impossible-branch`, `no-explicit-any`, `prefer-type-over-interface` |
+| A2 | **Ningún efecto es invisible al tipo.** Si una operación puede fallar, su firma lo confiesa — no una convención oral ni un `throw` sorpresa. | `await-requires-result`, `no-try-catch`, `no-promise-chain`, `no-ad-hoc-ok-result`, `no-floating-promises` |
 | A3 | **La información no se destruye.** Un error que se transforma conserva su `cause`; uno que se detecta llega a alguien. Nadie decide "esto no importa" en silencio. | `result-error-requires-cause`, `result-error-requires-handling` |
 | A4 | **Una unidad, una responsabilidad, un nombre semántico.** El árbol de archivos cuenta una historia; una clase expone una intención. | `one-root-function-per-file`, `max-public-methods`, `no-default-export`, `jsx-return-name-pascal-case`, `max-hook-size` |
-| A5 | **Las decisiones se declaran, no se interpretan.** Cada rama es explícita y exhaustiva; un caso ignorado es una decisión visible, no un hueco. | `no-else`, `no-nested-if`, `prefer-ts-pattern`, `@typescript-eslint/ban-ts-comment`, el `void promesa()` de `no-floating-promises` |
+| A5 | **Las decisiones se declaran, no se interpretan.** Cada rama es explícita y exhaustiva; un caso ignorado es una decisión visible, no un hueco. | `no-else`, `no-nested-if`, `prefer-ts-pattern`, `no-silenced-compiler`, el `void promesa()` de `no-floating-promises` |
 | A6 | **Evidencia sobre convención.** Una regla decide por lo que el type-checker o los imports demuestran, no por cómo se llama un archivo o un campo. | la implementación type-aware de las reglas de Result, `nest-no-direct-instantiation` (@Injectable resuelto por símbolo), la exención ORM por decorador de `class-properties-require-readonly` |
 | A7 | **Las fronteras son explícitas y únicas.** Lo que cruza una capa lo hace por un contrato, una sola vez, sin túneles. | `no-deep-relative-imports`, `no-tunnel-props`, `nest-no-result-response`, `nest-no-swagger-in-controllers`, `nest-no-inline-query-params` |
 | A8 | **Inmutable por defecto.** La mutación es la excepción que se pide con evidencia, no el estado natural de las cosas. | `class-properties-require-readonly`, `no-accessors` |
@@ -333,7 +333,7 @@ El orden no es arbitrario: va de "cada hallazgo es un bug que ya tienes" hacia
 **Ola 1 — bugs gratis y fixes únicos.** Señal pura, arreglo puntual, cero
 rediseño. Aquí el equipo aprende que el linter encuentra cosas reales:
 
-- `@typescript-eslint/no-floating-promises` — cada hallazgo es un error que
+- `skapxd/no-floating-promises` — cada hallazgo es un error que
   hoy muere sin que nadie lo vea (en un backend real en producción: 12).
 - `skapxd/nest-requires-swagger-plugin` y `skapxd/nest-validation-pipe-config`
   — un hallazgo por proyecto, un fix de configuración, y quedan vigiladas las
@@ -398,8 +398,9 @@ diseño, no solo disciplina. Para cuando el equipo ya vio el patrón en la ola 3
 - `requires-strict-tsconfig` al máximo: `["strict", "noImplicitReturns",
   "noUncheckedIndexedAccess"]`. Sube un flag a la vez — cada uno aflora
   errores de compilación que son bugs latentes, no burocracia.
-- `@typescript-eslint/no-explicit-any`, `no-non-null-assertion` y
-  `ban-ts-comment` — se cierran las tres puertas de escape del compilador.
+- `skapxd/no-explicit-any`, `skapxd/no-non-null-assertion` y
+  `skapxd/no-silenced-compiler` — se cierran las tres puertas de escape del
+  compilador.
 - `skapxd/class-properties-require-readonly` — el cambio se modela con
   instancias nuevas.
 - `skapxd/prefer-tagged-union-state` y `skapxd/no-runtime-state-guard` — los
@@ -677,7 +678,7 @@ Detalles del preset:
   se escribe `void bootstrap();` — fire-and-forget declarado.
 - Los specs colocados (`*.spec.ts`, `*.e2e-spec.ts`) relajan
   `await-requires-result`, `no-try-catch`, `result-error-requires-handling` y
-  `@typescript-eslint/no-non-null-assertion` (el `!` sobre un fixture es el
+  `no-non-null-assertion` (el `!` sobre un fixture es el
   arrange del test): un test awaitea helpers libremente y descartar un Result
   en una aserción no es perder un trace. `no-floating-promises` sigue activa
   en specs: un `await` olvidado es un falso verde.
@@ -747,6 +748,19 @@ export default [
 ];
 ```
 
+Para librerías npm escritas en TypeScript (tsup o equivalente). Trae las
+bases completas + el set type-driven (tipado, con `projectService`) +
+`await-requires-result` + el contrato de empaquetado:
+
+- `skapxd/package-requires-typed-exports` — los `exports` del package.json
+  cablean los tipos **por condición** (`import` → `.d.mts`, `require` →
+  `.d.ts`); el `types` único por subpath es el bug "FalseCJS".
+- `skapxd/untrusted-module-requires-adapter` — inerte hasta que declares tu
+  inventario de paquetes con tipos mentirosos (ver su sección).
+
+**Este mismo repo se lintea con este preset** — dogfood: la regla de exports
+nos obligó a corregir nuestro propio package.json al nacer.
+
 ### Strict (sin escape via `eslint-disable`)
 
 Un prompt o un agente puede saltarse cualquier regla con
@@ -819,14 +833,20 @@ de cada regla):
 | `no-default-export` | `allowFilePatterns` (globs, aditivos a los integrados) |
 | `no-else` | `allowFilePatterns` (globs) |
 | `no-emoji` | `allowFilePatterns` (globs) |
+| `no-explicit-any` | las de la regla original de typescript-eslint (`fixToUnknown`, ...) |
+| `no-floating-promises` | las de la regla original de typescript-eslint (`ignoreVoid`, `allowList`, ...) |
 | `no-impossible-branch` | las de la regla original de typescript-eslint (`allowConstantLoopConditions`, ...) |
+| `no-silenced-compiler` | las de `ban-ts-comment` (`ts-expect-error`, `ts-ignore`, `ts-nocheck`, `minimumDescriptionLength`) |
+| `prefer-type-over-interface` | la de `consistent-type-definitions` (`"type"` o `"interface"`; los presets pasan `"type"`) |
 | `no-functions-inside-components` | `allowJsxCallbacks`, `allowArrayMapCallbacks` (ambas `true` por defecto) |
 | `no-nested-if` | `allowFilePatterns` (globs) |
 | `no-promise-chain` | `methods` |
 | `no-runtime-state-guard` | `allowFilePatterns` (globs) |
 | `no-tunnel-props` | `allowFilePatterns` (globs), `allowPropPatterns` (regex) |
 | `prefer-abort-signal` | `allowFilePatterns` (globs), `effectNames` (default `["useEffect", "useLayoutEffect"]`) |
+| `package-requires-typed-exports` | `allowFilePatterns` (globs), `anchorFilePatterns` (default `src/index.ts(x)`, `src/main.ts`) |
 | `prefer-tagged-union-state` | `allowFilePatterns` (globs), `loadingPatterns` (regex, en minúsculas), `errorPatterns` (regex, en minúsculas) |
+| `untrusted-module-requires-adapter` | `modules` (default `[]` — inerte), `adapterFilePatterns` (globs), `allowFilePatterns` (globs) |
 | `requires-strict-tsconfig` | `allowFilePatterns` (globs), `anchorFilePatterns` (globs), `requiredCompilerOptions` |
 | `result-error-requires-handling` | `allowFilePatterns` (globs) |
 
@@ -863,16 +883,23 @@ matchea en cualquier carpeta). Las 7 reglas restantes no tienen opciones: su
 | `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-else` | Prohíbe `else`/`else if`: el else es el estado sin nombre. Retorno anticipado, ternario simple o `match()`. |
 | `skapxd/no-emoji` | Prohíbe emojis en strings y JSX; cada sistema los renderiza distinto. Usa un icono SVG. |
+| `skapxd/no-explicit-any` | Prohíbe `any`: apaga el sistema de tipos donde más se necesita. `unknown` para lo desconocido, el tipo real para lo demás. Wrapper de typescript-eslint. |
+| `skapxd/no-floating-promises` | Promesas sin `await` ni `void`: el rechazo muere sin pasar por trySafe. El mensaje corrige el consejo upstream (`.then/.catch` aquí están prohibidos). Wrapper de typescript-eslint. |
 | `skapxd/no-impossible-branch` | Condiciones que el type-checker demuestra constantes: la pregunta ya tiene respuesta. Es `@typescript-eslint/no-unnecessary-condition` con nombre semántico y mensajes que enseñan el fix. |
 | `skapxd/no-nested-if` | Prohíbe `if` anidados: retorno anticipado o `match()`. Menos carga cognitiva y sin puntos ciegos para las demás reglas. |
+| `skapxd/no-non-null-assertion` | Prohíbe el `!`: es "cállate, yo sé más que tú" dicho al compilador. Modela el tipo o maneja la duda. Wrapper de typescript-eslint. |
 | `skapxd/no-runtime-state-guard` | Prohíbe `if (this.x) throw` en métodos: el estado inválido se hace irrepresentable en el tipo, no se vigila en runtime. |
+| `skapxd/no-silenced-compiler` | Prohíbe `@ts-ignore`/`@ts-nocheck`: silenciar la alarma no arregla el incendio. `@ts-expect-error` con descripción queda para tests de tipos. Wrapper de `ban-ts-comment`. |
 | `skapxd/no-tunnel-props` | Ninguna prop viaja más de un nivel: quien la recibe no puede reenviarla a otro componente. Mata el prop drilling. |
 | `skapxd/prefer-abort-signal` | Listeners en efectos se limpian con `AbortController` (`{ signal }` + `abort()`), no con `removeEventListener`. |
 | `skapxd/prefer-tagged-union-state` | Prohíbe estados inconsistentes representables: flag de loading + campo de error independientes → unión etiquetada. |
+| `skapxd/prefer-type-over-interface` | Las uniones discriminadas son types; un `type` no crece en silencio por declaration merging. Wrapper de `consistent-type-definitions`. |
 | `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`). |
 | `skapxd/prefer-ts-pattern` | Prohíbe `switch` y ternarios anidados; usa `match()` de ts-pattern. |
+| `skapxd/package-requires-typed-exports` | Los `exports` del package.json declaran `types` por condición (`import` → `.d.mts`, `require` → `.d.ts`): mata el bug FalseCJS. Preset `package`. |
+| `skapxd/untrusted-module-requires-adapter` | Los paquetes con tipos mentirosos (@types desfasados) solo se importan desde su adaptador: la mentira vive en UN archivo. Preset `package`. |
 | `skapxd/no-jsx-ternary-null` | Prefiere `cond && <El />` sobre `cond ? <El /> : null` en JSX. |
 
 ### `skapxd/one-root-function-per-file`
@@ -995,34 +1022,29 @@ Fuera del default, a propósito: `exactOptionalPropertyTypes` y
 con muchas librerías — se agregan vía `requiredCompilerOptions` si el
 proyecto los soporta.
 
-Además, los **presets tipados activan reglas curadas de typescript-eslint**
-(que ya es peer dependency — no se reimplementan):
-
-- `@typescript-eslint/no-explicit-any` — `any` apaga el sistema de tipos:
-  todo el esfuerzo muere donde aparece uno.
-- `@typescript-eslint/consistent-type-definitions` con `type` — las uniones
-  discriminadas son types.
-- `@typescript-eslint/no-floating-promises` — cierra el hueco que
-  `await-requires-result` no ve: una llamada async **sin** `await` no produce
-  `AwaitExpression`, así que el rechazo muere sin pasar por `trySafe`
-  (medido: 12 promesas flotantes vivas en un backend Nest real). La única
-  salida es `void promesa()`: fire-and-forget declarado y greppeable.
-- `@typescript-eslint/no-non-null-assertion` — `!` es "cállate, yo sé más
-  que tú" dicho al compilador. Si no puede ser nulo, que lo diga el tipo.
-  (En `nest/tests` queda apagada: el `!` sobre un fixture cuya existencia el
-  propio test garantiza es el arrange, no una mentira.)
-- `skapxd/no-impossible-branch` — la generalización type-aware de
-  `no-runtime-state-guard`: si el tipo dice que un estado es imposible, el
-  guard defensivo sobra; si el guard hace falta, lo que está mal es el tipo.
-  Es `@typescript-eslint/no-unnecessary-condition` **re-registrada bajo
-  nuestro namespace** (ver su sección): mismo motor, nombre que dice lo que
-  defiende y mensajes que enseñan el fix. Por eso esta regla y
-  `requires-strict-tsconfig` van juntas: sin `noUncheckedIndexedAccess`,
-  `array[i]` miente y la regla acusaría guards necesarios.
-- `@typescript-eslint/ban-ts-comment` — un error de tipos se arregla
-  modelando mejor, no silenciando la alarma: `@ts-ignore` y `@ts-nocheck`
-  prohibidos. `@ts-expect-error` **con descripción** queda permitido: es la
-  forma legítima de testear que un estado inválido de verdad no compila.
+Además, los **presets tipados activan reglas curadas de typescript-eslint**,
+todas **re-registradas bajo el namespace skapxd** (mismo motor, cero
+reimplementación — typescript-eslint ya es peer dependency): nombres que
+dicen lo que defienden, mensajes en español que enseñan el fix, y un solo
+namespace en toda tu lista de pendientes. Cada una tiene su sección propia:
+
+- `skapxd/no-explicit-any` — `any` apaga el sistema de tipos: todo el
+  esfuerzo muere donde aparece uno.
+- `skapxd/prefer-type-over-interface` (era `consistent-type-definitions`) —
+  las uniones discriminadas son types.
+- `skapxd/no-floating-promises` — cierra el hueco que `await-requires-result`
+  no ve: una llamada async **sin** `await` no produce `AwaitExpression`, así
+  que el rechazo muere sin pasar por `trySafe` (medido: 12 promesas
+  flotantes vivas en un backend Nest real).
+- `skapxd/no-non-null-assertion` — `!` es "cállate, yo sé más que tú" dicho
+  al compilador. (En `nest/tests` queda apagada: el `!` sobre un fixture es
+  el arrange, no una mentira.)
+- `skapxd/no-impossible-branch` (era `no-unnecessary-condition`) — la
+  generalización type-aware de `no-runtime-state-guard`. Va de la mano de
+  `requires-strict-tsconfig`: sin `noUncheckedIndexedAccess`, `array[i]`
+  miente y la regla acusaría guards necesarios.
+- `skapxd/no-silenced-compiler` (era `ban-ts-comment`) — un error de tipos
+  se arregla modelando mejor, no silenciando la alarma.
 
 Ausencias deliberadas, no olvidos:
 
@@ -1907,6 +1929,83 @@ del críptico "Unnecessary conditional". Los presets tipados activan este
 nombre y **no** el original: una sola fuente de verdad para configurarla,
 silenciarla o buscarla.
 
+### `skapxd/no-explicit-any`
+
+Prohíbe `any`. No es una regla de estilo: `any` apaga el sistema de tipos en
+todo lo que toca — el esfuerzo de modelar estados imposibles muere donde
+aparece uno, y se propaga en silencio a cada valor derivado. El mensaje
+enseña la salida: `unknown` para lo genuinamente desconocido (obliga a
+estrechar antes de usar — la duda queda declarada y verificada), el tipo
+real para lo que tiene forma conocida.
+
+Bajo el capó es `@typescript-eslint/no-explicit-any`
+([doc original](https://typescript-eslint.io/rules/no-explicit-any/))
+re-registrada bajo nuestro namespace con mensajes que enseñan (ver
+`skapxd/no-impossible-branch` para el patrón). Los presets tipados activan
+este nombre, no el original.
+
+### `skapxd/no-floating-promises`
+
+Una llamada async **sin** `await` no produce `AwaitExpression` — es el punto
+ciego de `await-requires-result`: el rechazo muere sin pasar por `trySafe`,
+sin trace y sin que nadie lo decidiera (medido al absorberla: 12 promesas
+flotantes vivas en un backend en producción).
+
+Esta regla existía en typescript-eslint
+([doc original](https://typescript-eslint.io/rules/no-floating-promises/)),
+pero su mensaje recomendaba *"end with a call to `.catch`, or end with a
+call to `.then` with a rejection handler"* — **dos caminos que
+`no-promise-chain` prohíbe**. Obedecer a una regla te estrellaba con la
+otra. El wrapper corrige el consejo para este sistema: las dos salidas
+legales son `await` (y ahí entra el pipeline de Result) o `void promesa()`
+— el fire-and-forget declarado y greppeable del axioma A5 (así se escribe
+el `bootstrap()` del `main.ts` de Nest: `void bootstrap();`).
+
+### `skapxd/no-non-null-assertion`
+
+Prohíbe el `!` (non-null assertion): es "cállate, yo sé más que tú" dicho al
+compilador — y un `!` equivocado es un crash en runtime que el tipo juraba
+imposible. Si el valor de verdad no puede ser nulo, que lo diga el tipo
+(modela mejor, o estrecha con un guard que el compilador verifique); si
+puede serlo, el `!` no resuelve la duda: la esconde.
+
+La excepción legítima vive en los tests: el `!` sobre un fixture cuya
+existencia el propio test garantiza es el arrange, no una mentira — por eso
+`nest/tests` la apaga en specs. Bajo el capó es
+`@typescript-eslint/no-non-null-assertion`
+([doc original](https://typescript-eslint.io/rules/no-non-null-assertion/))
+re-registrada con mensajes propios.
+
+### `skapxd/no-silenced-compiler`
+
+No silencies al compilador: `@ts-ignore` y `@ts-nocheck` apagan la alarma en
+vez de arreglar el incendio. Si el compilador es el muro de contención del
+sistema, nadie lo apaga cuando el modelado se pone difícil — un error de
+tipos se resuelve modelando mejor el dominio.
+
+La puerta que queda abierta, a propósito: `@ts-expect-error` **con
+descripción**. Es la forma legítima de testear que un estado inválido de
+verdad NO compila (la otra mitad son los tests de tipos con `expectTypeOf`,
+ver la sección de `requires-strict-tsconfig`) — y a diferencia de
+`@ts-ignore`, avisa cuando la supresión deja de hacer falta. Bajo el capó es
+`@typescript-eslint/ban-ts-comment`
+([doc original](https://typescript-eslint.io/rules/ban-ts-comment/)) con un
+nombre que dice lo que defiende y mensajes propios.
+
+### `skapxd/prefer-type-over-interface`
+
+Usa `type`, no `interface`. Las uniones discriminadas — la columna vertebral
+del modelado de estados de este paquete — son types, y la homogeneidad
+elimina la pregunta "¿esto puede crecer por declaration merging?": un `type`
+no puede ser extendido en silencio desde otro archivo; lo que declara es
+todo lo que hay.
+
+Bajo el capó es `@typescript-eslint/consistent-type-definitions`
+([doc original](https://typescript-eslint.io/rules/consistent-type-definitions/))
+re-registrada con un nombre que declara la opinión (como los demás
+`prefer-*`). Ojo si la activas suelta: el default upstream prefiere
+`interface` — los presets la pasan como `["error", "type"]`.
+
 ### `skapxd/no-functions-inside-components`
 
 Prohíbe definir funciones **con peso propio** dentro de un componente React
@@ -2147,6 +2246,68 @@ no puede traer `signal`.
 `effectNames` permite cubrir wrappers propios (`["useEffect",
 "useLayoutEffect", "useIsomorphicEffect"]`).
 
+### `skapxd/package-requires-typed-exports`
+
+El contrato de empaquetado de una librería TypeScript dual (ESM + CJS): cada
+condición del mapa `exports` declara **sus propios tipos**, del sabor
+correcto.
+
+```jsonc
+"exports": {
+  ".": {
+    "import": { "types": "./dist/index.d.mts", "default": "./dist/index.mjs" },
+    "require": { "types": "./dist/index.d.ts", "default": "./dist/index.js" }
+  }
+}
+```
+
+El antipatrón que mata es el **"FalseCJS"** (el hallazgo #1 de
+[arethetypeswrong](https://arethetypeswrong.github.io)): un `types` único por
+subpath apuntando al `.d.ts` — los consumidores ESM con
+`moduleResolution: node16` reciben tipos CJS y el contrato miente en la
+frontera más pública que tiene una librería. tsup con `dts: true` ya genera
+los dos sabores (`.d.mts` y `.d.ts`); esta regla verifica que el package.json
+de verdad los cablee y que los archivos existan en disco. Anclada al
+entrypoint (`src/index.ts` por defecto): un reporte por paquete.
+
+Dogfood: esta regla nació reportando a este mismo repo — nuestros `exports`
+tenían el bug y el lint no volvió a verde hasta corregirlos.
+
+### `skapxd/untrusted-module-requires-adapter`
+
+¿Qué pasa cuando los tipos de un paquete de terceros **mienten**? El clásico:
+un paquete escrito en JS cuyos tipos viven aparte (`@types/...`) y van
+desfasados del runtime real, o índices que juran nunca devolver `undefined`.
+Todo el sistema de este paquete descansa en que el tipo dice la verdad
+(`no-impossible-branch` le cree ciegamente) — un tipo mentiroso envenena cada
+regla type-aware que lo toque.
+
+El playbook, en orden:
+
+1. **Armadura de tsconfig primero**: `noUncheckedIndexedAccess` corrige de
+   raíz la clase más común de mentira (index signatures optimistas) sin
+   tocar al tercero — `requires-strict-tsconfig` ya lo exige.
+2. **Frontera anticorrupción** (lo que esta regla impone): declara el módulo
+   como no confiable y enciérralo tras UN adaptador. El adaptador importa el
+   paquete, re-declara los tipos honestos (lo que el runtime de verdad
+   devuelve) y exporta esa versión. El resto del código importa el adaptador
+   y razona con tipos veraces — la mentira queda en un archivo auditable.
+3. **`@ts-expect-error` con descripción** dentro del adaptador si hace falta
+   forzar la corrección — es la puerta que `no-silenced-compiler` deja
+   abierta, declarada y con porqué.
+4. **Arregla el upstream**: PR a DefinitelyTyped. Mientras llega, los pasos
+   1-3 te protegen.
+
+```js
+"skapxd/untrusted-module-requires-adapter": ["error", {
+  adapterFilePatterns: ["src/lib/xlsx-adapter.ts"],
+  modules: ["xlsx"],
+}]
+```
+
+Sin `modules` declarados la regla es inerte: el inventario de sospechosos es
+una decisión del proyecto, no una adivinanza del linter (axioma A5).
+
 ### `skapxd/no-jsx-ternary-null`
 
 Cuando renderizas JSX condicional y una rama del ternario es `null`, prefiere la

package/dist/astro/index.js

@@ -64,9 +64,6 @@ function createBaseLanguageOptions() {
   };
 }
 
-// src/shared/configs/create-shared-configs.ts
-var import_typescript_eslint3 = __toESM(require("typescript-eslint"));
-
 // src/shared/configs/create-typed-language-options.ts
 var import_typescript_eslint2 = __toESM(require("typescript-eslint"));
 function createTypedLanguageOptions() {

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-shared-configs.ts","../../src/shared/configs/create-typed-language-options.ts","../../src/astro/configs.ts"],"sourcesContent":["export { createAstroConfigs } from \"./configs\";\n","export const baseRules = {\n  \"skapxd/class-properties-require-readonly\": \"error\",\n  \"skapxd/max-public-methods\": \"error\",\n  \"skapxd/no-accessors\": \"error\",\n  \"skapxd/no-ad-hoc-ok-result\": \"error\",\n  \"skapxd/no-deep-relative-imports\": \"error\",\n  \"skapxd/no-default-export\": \"error\",\n  \"skapxd/no-else\": \"error\",\n  \"skapxd/no-emoji\": \"error\",\n  \"skapxd/no-nested-if\": \"error\",\n  \"skapxd/no-runtime-state-guard\": \"error\",\n  \"skapxd/no-promise-chain\": \"error\",\n  \"skapxd/no-try-catch\": \"error\",\n  \"skapxd/one-root-function-per-file\": \"error\",\n  \"skapxd/prefer-tagged-union-state\": \"error\",\n  \"skapxd/requires-strict-tsconfig\": \"error\",\n  \"skapxd/prefer-ts-pattern\": \"error\",\n  \"skapxd/result-error-requires-cause\": \"error\",\n  \"skapxd/result-error-requires-handling\": \"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\";\nimport { baseRules } from \"./base-rules\";\nimport { createBaseLanguageOptions } from \"./create-base-language-options\";\nimport { createTypedLanguageOptions } from \"./create-typed-language-options\";\nimport { typeDrivenRules } from \"./type-driven-rules\";\n\nexport function createSharedConfigs(pluginReference: unknown) {\n  const baseLanguageOptions = createBaseLanguageOptions();\n  const typedLanguageOptions = createTypedLanguageOptions();\n\n  return {\n    backend: {\n      languageOptions: typedLanguageOptions,\n      name: \"skapxd/shared/backend\",\n      plugins: {\n        \"@typescript-eslint\": tseslint.plugin,\n        skapxd: pluginReference,\n      },\n      rules: {\n        ...baseRules,\n        ...typeDrivenRules,\n        // La regla obligatoria del sistema de errores es await-requires-result\n        // (todo await resuelve en Result). async-functions-return-result queda\n        // apagada por defecto: exigir la firma por decreto choca con los bordes\n        // del framework y bloquea la adopción incremental; la presión sobre los\n        // awaits produce el mismo estado final. Ver \"¿Por qué está apagada por\n        // defecto?\" en el README.\n        \"skapxd/await-requires-result\": \"error\",\n      },\n    },\n    base: {\n      languageOptions: baseLanguageOptions,\n      name: \"skapxd/shared/base\",\n      plugins: { skapxd: pluginReference },\n      rules: baseRules,\n    },\n    frontend: {\n      languageOptions: typedLanguageOptions,\n      name: \"skapxd/shared/frontend\",\n      plugins: {\n        \"@typescript-eslint\": tseslint.plugin,\n        skapxd: pluginReference,\n      },\n      rules: {\n        ...baseRules,\n        ...typeDrivenRules,\n        // En el front no se obliga a retornar Result, pero todo await debe\n        // resolver en uno: o la función llamada ya retorna Promise<Result>\n        // (camino preferido: errores modelados en el dominio) o se envuelve\n        // en trySafe en el sitio.\n        \"skapxd/await-requires-result\": \"error\",\n        \"skapxd/jsx-return-name-pascal-case\": \"error\",\n        // Anti prop-drilling: ninguna prop viaja más de un nivel. Quien la\n        // crea puede pasarla a UN hijo; quien la recibe no la reenvía —\n        // estado y acciones a un store global o custom hook.\n        \"skapxd/no-functions-inside-components\": \"error\",\n        \"skapxd/no-tunnel-props\": \"error\",\n        // Listeners en efectos: un AbortController por efecto, cleanup con\n        // un solo abort() en vez de removeEventListener por listener.\n        \"skapxd/prefer-abort-signal\": \"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    package: {\n      languageOptions: baseLanguageOptions,\n      name: \"skapxd/shared/package\",\n      plugins: { skapxd: pluginReference },\n      rules: {\n        \"skapxd/one-root-function-per-file\": \"error\",\n      },\n    },\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        \"skapxd/result-error-requires-handling\": \"error\",\n      },\n    },\n  ];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAO,IAAM,YAAY;AAAA,EACvB,4CAA4C;AAAA,EAC5C,6BAA6B;AAAA,EAC7B,uBAAuB;AAAA,EACvB,8BAA8B;AAAA,EAC9B,mCAAmC;AAAA,EACnC,4BAA4B;AAAA,EAC5B,kBAAkB;AAAA,EAClB,mBAAmB;AAAA,EACnB,uBAAuB;AAAA,EACvB,iCAAiC;AAAA,EACjC,2BAA2B;AAAA,EAC3B,uBAAuB;AAAA,EACvB,qCAAqC;AAAA,EACrC,oCAAoC;AAAA,EACpC,mCAAmC;AAAA,EACnC,4BAA4B;AAAA,EAC5B,sCAAsC;AAAA,EACtC,yCAAyC;AAC3C;;;ACnBA,+BAAqB;AAId,SAAS,4BAA4B;AAC1C,SAAO;AAAA,IACL,QAAQ,yBAAAA,QAAS;AAAA,EACnB;AACF;;;ACRA,IAAAC,4BAAqB;;;ACArB,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,QACtC,yCAAyC;AAAA,MAC3C;AAAA,IACF;AAAA,EACF;AACF;","names":["tseslint","import_typescript_eslint","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/class-properties-require-readonly\": \"error\",\n  \"skapxd/max-public-methods\": \"error\",\n  \"skapxd/no-accessors\": \"error\",\n  \"skapxd/no-ad-hoc-ok-result\": \"error\",\n  \"skapxd/no-deep-relative-imports\": \"error\",\n  \"skapxd/no-default-export\": \"error\",\n  \"skapxd/no-else\": \"error\",\n  \"skapxd/no-emoji\": \"error\",\n  \"skapxd/no-nested-if\": \"error\",\n  \"skapxd/no-runtime-state-guard\": \"error\",\n  \"skapxd/no-promise-chain\": \"error\",\n  \"skapxd/no-try-catch\": \"error\",\n  \"skapxd/one-root-function-per-file\": \"error\",\n  \"skapxd/prefer-tagged-union-state\": \"error\",\n  \"skapxd/requires-strict-tsconfig\": \"error\",\n  \"skapxd/prefer-ts-pattern\": \"error\",\n  \"skapxd/result-error-requires-cause\": \"error\",\n  \"skapxd/result-error-requires-handling\": \"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        \"skapxd/result-error-requires-handling\": \"error\",\n      },\n    },\n  ];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAO,IAAM,YAAY;AAAA,EACvB,4CAA4C;AAAA,EAC5C,6BAA6B;AAAA,EAC7B,uBAAuB;AAAA,EACvB,8BAA8B;AAAA,EAC9B,mCAAmC;AAAA,EACnC,4BAA4B;AAAA,EAC5B,kBAAkB;AAAA,EAClB,mBAAmB;AAAA,EACnB,uBAAuB;AAAA,EACvB,iCAAiC;AAAA,EACjC,2BAA2B;AAAA,EAC3B,uBAAuB;AAAA,EACvB,qCAAqC;AAAA,EACrC,oCAAoC;AAAA,EACpC,mCAAmC;AAAA,EACnC,4BAA4B;AAAA,EAC5B,sCAAsC;AAAA,EACtC,yCAAyC;AAC3C;;;ACnBA,+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,QACtC,yCAAyC;AAAA,MAC3C;AAAA,IACF;AAAA,EACF;AACF;","names":["tseslint","import_typescript_eslint","tseslint"]}

package/dist/astro/index.mjs

@@ -1,7 +1,7 @@
 import {
   createAstroConfigs
-} from "../chunk-DJDXQWCP.mjs";
-import "../chunk-F6GJW5A4.mjs";
+} from "../chunk-GSQWHSHV.mjs";
+import "../chunk-QDQUU6QK.mjs";
 export {
   createAstroConfigs
 };

package/dist/{chunk-O5BXMSNR.mjs → chunk-3GEFHNU7.mjs}

@@ -2,10 +2,7 @@ import {
   baseRules,
   createTypedLanguageOptions,
   typeDrivenRules
-} from "./chunk-F6GJW5A4.mjs";
-
-// src/nest/configs.ts
-import tseslint from "typescript-eslint";
+} from "./chunk-QDQUU6QK.mjs";
 
 // src/constants/nest-entrypoint-file-patterns.ts
 var nestEntrypointFilePatterns = [
@@ -46,10 +43,9 @@ function createNestConfigs(pluginReference) {
       files: ["src/**/*.ts"],
       languageOptions: typedLanguageOptions,
       name: "skapxd/nest/base",
-      plugins: {
-        "@typescript-eslint": tseslint.plugin,
-        skapxd: pluginReference
-      },
+      // Solo el plugin skapxd: las reglas de typescript-eslint entran
+      // re-registradas bajo nuestro namespace (typeDrivenRules).
+      plugins: { skapxd: pluginReference },
       rules: {
         ...baseRules,
         ...typeDrivenRules,
@@ -117,16 +113,13 @@ function createNestConfigs(pluginReference) {
     {
       files: ["**/*.spec.ts", "**/*.e2e-spec.ts"],
       name: "skapxd/nest/tests",
-      plugins: {
-        "@typescript-eslint": tseslint.plugin,
-        skapxd: pluginReference
-      },
+      plugins: { skapxd: pluginReference },
       rules: {
         // El `!` sobre un fixture cuya existencia el propio test garantiza
         // no es mentirle al compilador: es el arrange. no-floating-promises
         // sí queda activa — un await olvidado en un spec es un falso verde.
-        "@typescript-eslint/no-non-null-assertion": "off",
         "skapxd/await-requires-result": "off",
+        "skapxd/no-non-null-assertion": "off",
         "skapxd/no-try-catch": "off",
         "skapxd/result-error-requires-handling": "off"
       }
@@ -137,4 +130,4 @@ function createNestConfigs(pluginReference) {
 export {
   createNestConfigs
 };
-//# sourceMappingURL=chunk-O5BXMSNR.mjs.map
+//# sourceMappingURL=chunk-3GEFHNU7.mjs.map

package/dist/chunk-3GEFHNU7.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/constants/nest-entrypoint-file-patterns.ts","../src/constants/nest-framework-hook-names.ts","../src/nest/configs.ts"],"sourcesContent":["// @ts-nocheck\n// Entrypoints de un proyecto Nest donde exigir Promise<Result> no aplica:\n// el bootstrap debe crashear ruidoso, no modelar errores de dominio.\n// Globs (matchean en cualquier carpeta), basados en proyectos reales:\n// main.ts, main.module.ts/app.module.ts, instrumentation.ts, app-cluster.ts.\nexport const nestEntrypointFilePatterns = [\n  \"src/main.ts\",\n  \"src/app-cluster.ts\",\n  \"src/instrumentation.ts\",\n];\n","// @ts-nocheck\n// Métodos públicos que NO cuentan hacia el límite porque son callbacks del\n// framework (NestJS): los llama el container/router/HTTP layer, nunca el\n// código de negocio. Contarlos forzaría refactors sin semántica.\nexport const nestFrameworkHookNames = [\n  // Lifecycle hooks — https://docs.nestjs.com/fundamentals/lifecycle-events\n  \"onModuleInit\",\n  \"onModuleDestroy\",\n  \"onApplicationBootstrap\",\n  \"onApplicationShutdown\",\n  \"beforeApplicationShutdown\",\n  // Interfaces del request pipeline\n  \"canActivate\", // CanActivate (Guard)\n  \"intercept\", // NestInterceptor\n  \"transform\", // PipeTransform\n  \"catch\", // ExceptionFilter\n  \"use\", // NestMiddleware\n];\n","import { nestEntrypointFilePatterns } from \"#/constants/nest-entrypoint-file-patterns\";\nimport { nestFrameworkHookNames } from \"#/constants/nest-framework-hook-names\";\nimport {\n  baseRules,\n  createTypedLanguageOptions,\n  typeDrivenRules,\n} from \"#/shared/configs\";\n\nexport function createNestConfigs(pluginReference: unknown) {\n  const typedLanguageOptions = createTypedLanguageOptions();\n\n  return [\n    // El dominio completo (services, controllers, modules, guards, ...).\n    // Las carpetas fuera de src (dev/, scripts/, e2e/, integration-test/)\n    // quedan fuera del preset a propósito: no son la app.\n    {\n      files: [\"src/**/*.ts\"],\n      languageOptions: typedLanguageOptions,\n      name: \"skapxd/nest/base\",\n      // Solo el plugin skapxd: las reglas de typescript-eslint entran\n      // re-registradas bajo nuestro namespace (typeDrivenRules).\n      plugins: { skapxd: pluginReference },\n      rules: {\n        ...baseRules,\n        ...typeDrivenRules,\n        // Nota: class-properties-require-readonly viene de las bases sin\n        // override — la exención de la capa de persistencia es por\n        // PROPIEDAD (decoradores @Prop/@Column verificados contra los\n        // imports de @nestjs/mongoose/typeorm), no por nombre de archivo.\n        // La regla agnóstica de las bases, con el conocimiento del\n        // framework inyectado: los hooks de Nest (onModuleInit,\n        // canActivate, intercept, ...) no cuentan como superficie pública.\n        \"skapxd/max-public-methods\": [\n          \"error\",\n          { ignore: [...nestFrameworkHookNames] },\n        ],\n        // Todo await resuelve en Result, salvo los entrypoints (main.ts,\n        // instrumentation): ahí el bootstrap debe crashear ruidoso.\n        \"skapxd/await-requires-result\": [\n          \"error\",\n          { allowFilePatterns: [...nestEntrypointFilePatterns] },\n        ],\n        // El contrato HTTP se documenta en los DTOs (@ApiProperty), no en el\n        // controller: el plugin @nestjs/swagger introspecciona el resto.\n        \"skapxd/nest-dto-requires-api-property\": \"error\",\n        // Los DTOs de input validan en runtime con class-validator (+ @Type\n        // de class-transformer para anidados); los out-*/-response quedan\n        // exentos: el server los produce, no los recibe.\n        \"skapxd/nest-dto-requires-validation\": \"error\",\n        // El controller es la frontera: consume el Result con match() y\n        // traduce a DTO o HttpException. Devolverlo crudo serializa el\n        // envelope { ok, error } al cliente.\n        \"skapxd/nest-no-result-response\": \"error\",\n        \"skapxd/nest-no-swagger-in-controllers\": \"error\",\n        // Configuración del proyecto verificada por el lint: el plugin de\n        // swagger en nest-cli.json (la premisa de las reglas de swagger) y\n        // un ValidationPipe con transform + whitelist (la premisa de las\n        // reglas de DTOs).\n        \"skapxd/nest-requires-swagger-plugin\": \"error\",\n        \"skapxd/nest-validation-pipe-config\": \"error\",\n      },\n    },\n    // En services, las dependencias entran por el constructor (DI), no con\n    // `new`.\n    {\n      files: [\"src/**/*.service.ts\"],\n      name: \"skapxd/nest/services\",\n      plugins: { skapxd: pluginReference },\n      rules: {\n        \"skapxd/nest-no-direct-instantiation\": \"error\",\n      },\n    },\n    // La forma de controllers y gateways la dicta el framework (un método\n    // por ruta/evento): ahí el límite de métodos públicos no aporta\n    // semántica. Y 2+ query params individuales son un DTO disfrazado.\n    {\n      files: [\"src/**/*.controller.ts\", \"src/**/*.gateway.ts\"],\n      name: \"skapxd/nest/controllers\",\n      plugins: { skapxd: pluginReference },\n      rules: {\n        \"skapxd/max-public-methods\": \"off\",\n        \"skapxd/nest-no-inline-query-params\": \"error\",\n      },\n    },\n    // Specs colocados: los tests awaitean helpers y SUTs libremente, y\n    // descartar un Result en una aserción no es perder un trace.\n    {\n      files: [\"**/*.spec.ts\", \"**/*.e2e-spec.ts\"],\n      name: \"skapxd/nest/tests\",\n      plugins: { skapxd: pluginReference },\n      rules: {\n        // El `!` sobre un fixture cuya existencia el propio test garantiza\n        // no es mentirle al compilador: es el arrange. no-floating-promises\n        // sí queda activa — un await olvidado en un spec es un falso verde.\n        \"skapxd/await-requires-result\": \"off\",\n        \"skapxd/no-non-null-assertion\": \"off\",\n        \"skapxd/no-try-catch\": \"off\",\n        \"skapxd/result-error-requires-handling\": \"off\",\n      },\n    },\n  ];\n}\n"],"mappings":";;;;;;;AAKO,IAAM,6BAA6B;AAAA,EACxC;AAAA,EACA;AAAA,EACA;AACF;;;ACLO,IAAM,yBAAyB;AAAA;AAAA,EAEpC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAEA;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AACF;;;ACTO,SAAS,kBAAkB,iBAA0B;AAC1D,QAAM,uBAAuB,2BAA2B;AAExD,SAAO;AAAA;AAAA;AAAA;AAAA,IAIL;AAAA,MACE,OAAO,CAAC,aAAa;AAAA,MACrB,iBAAiB;AAAA,MACjB,MAAM;AAAA;AAAA;AAAA,MAGN,SAAS,EAAE,QAAQ,gBAAgB;AAAA,MACnC,OAAO;AAAA,QACL,GAAG;AAAA,QACH,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QAQH,6BAA6B;AAAA,UAC3B;AAAA,UACA,EAAE,QAAQ,CAAC,GAAG,sBAAsB,EAAE;AAAA,QACxC;AAAA;AAAA;AAAA,QAGA,gCAAgC;AAAA,UAC9B;AAAA,UACA,EAAE,mBAAmB,CAAC,GAAG,0BAA0B,EAAE;AAAA,QACvD;AAAA;AAAA;AAAA,QAGA,yCAAyC;AAAA;AAAA;AAAA;AAAA,QAIzC,uCAAuC;AAAA;AAAA;AAAA;AAAA,QAIvC,kCAAkC;AAAA,QAClC,yCAAyC;AAAA;AAAA;AAAA;AAAA;AAAA,QAKzC,uCAAuC;AAAA,QACvC,sCAAsC;AAAA,MACxC;AAAA,IACF;AAAA;AAAA;AAAA,IAGA;AAAA,MACE,OAAO,CAAC,qBAAqB;AAAA,MAC7B,MAAM;AAAA,MACN,SAAS,EAAE,QAAQ,gBAAgB;AAAA,MACnC,OAAO;AAAA,QACL,uCAAuC;AAAA,MACzC;AAAA,IACF;AAAA;AAAA;AAAA;AAAA,IAIA;AAAA,MACE,OAAO,CAAC,0BAA0B,qBAAqB;AAAA,MACvD,MAAM;AAAA,MACN,SAAS,EAAE,QAAQ,gBAAgB;AAAA,MACnC,OAAO;AAAA,QACL,6BAA6B;AAAA,QAC7B,sCAAsC;AAAA,MACxC;AAAA,IACF;AAAA;AAAA;AAAA,IAGA;AAAA,MACE,OAAO,CAAC,gBAAgB,kBAAkB;AAAA,MAC1C,MAAM;AAAA,MACN,SAAS,EAAE,QAAQ,gBAAgB;AAAA,MACnC,OAAO;AAAA;AAAA;AAAA;AAAA,QAIL,gCAAgC;AAAA,QAChC,gCAAgC;AAAA,QAChC,uBAAuB;AAAA,QACvB,yCAAyC;AAAA,MAC3C;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

package/dist/{chunk-OVC5GQV3.mjs → chunk-54EOEKYS.mjs}

@@ -6,7 +6,7 @@ import {
   baseRules,
   createBaseLanguageOptions,
   createTypedLanguageOptions
-} from "./chunk-F6GJW5A4.mjs";
+} from "./chunk-QDQUU6QK.mjs";
 
 // src/next/configs.ts
 var nextDefaultExportFileGlob = `{${[
@@ -71,4 +71,4 @@ function createNextConfigs(pluginReference) {
 export {
   createNextConfigs
 };
-//# sourceMappingURL=chunk-OVC5GQV3.mjs.map
+//# sourceMappingURL=chunk-54EOEKYS.mjs.map

package/dist/{chunk-DJDXQWCP.mjs → chunk-GSQWHSHV.mjs}

@@ -2,7 +2,7 @@ import {
   baseRules,
   createBaseLanguageOptions,
   createTypedLanguageOptions
-} from "./chunk-F6GJW5A4.mjs";
+} from "./chunk-QDQUU6QK.mjs";
 
 // src/astro/configs.ts
 function createAstroConfigs(pluginReference) {
@@ -41,4 +41,4 @@ function createAstroConfigs(pluginReference) {
 export {
   createAstroConfigs
 };
-//# sourceMappingURL=chunk-DJDXQWCP.mjs.map
+//# sourceMappingURL=chunk-GSQWHSHV.mjs.map