@skapxd/eslint-opinionated 0.9.0 → 0.11.0

package/README.md

@@ -548,8 +548,10 @@ de cada regla):
 | `no-default-export` | `allowFilePatterns` (globs, aditivos a los integrados) |
 | `no-emoji` | `allowFilePatterns` (globs) |
 | `no-functions-inside-components` | `allowJsxCallbacks`, `allowArrayMapCallbacks` (ambas `true` por defecto) |
+| `no-nested-if` | `allowFilePatterns` (globs) |
 | `no-promise-chain` | `methods` |
 | `no-tunnel-props` | `allowFilePatterns` (globs), `allowPropPatterns` (regex) |
+| `prefer-abort-signal` | `allowFilePatterns` (globs), `effectNames` (default `["useEffect", "useLayoutEffect"]`) |
 
 Los `allowFilePatterns` de todas las reglas son **globs** (`*` un segmento,
 `**` cualquier profundidad, `{a,b}` alternativas; un patrón sin prefijo
@@ -570,7 +572,9 @@ matchea en cualquier carpeta). Las 7 reglas restantes no tienen opciones: su
 | `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-emoji` | Prohíbe emojis en strings y JSX; cada sistema los renderiza distinto. Usa un icono SVG. |
+| `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-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/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`). |
@@ -687,10 +691,19 @@ if (!result.ok) {
 }
 ```
 
+Reconoce todas las formas del guard de Result fallido — `!result.ok`,
+`result.ok === false`, `result.ok !== true`, `Result.isErr(result)` y
+`if (result.error)` — y dentro del guard exige el `cause` en todo
+`Result.err(...)`. Un `Result.err()` **sin argumentos** también se reporta:
+descartar el error por completo es el peor caso, no una exención. Y un `cause`
+con otro valor (`cause: new Error(...)`) no cuenta: tiene que ser literalmente
+el `result.error` del guard.
+
 Esta regla es type-aware. Usa TypeScript parser services para confirmar que el
 valor del guard y `Result.err` vienen de `@skapxd/result`. Por eso funciona con
 aliases, re-exports y tipos inferidos, sin depender solo del nombre importado en
-el archivo.
+el archivo. Su punto ciego histórico —el `Result.err` escondido en un `if`
+anidado— lo elimina `skapxd/no-nested-if` de raíz.
 
 ### `skapxd/await-requires-result`
 
@@ -846,6 +859,35 @@ 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-nested-if`
+
+Prohíbe un `if` dentro de otro `if` (en la misma función). Cada nivel de
+anidación suma carga cognitiva para quien lee — y además crea puntos ciegos
+para las demás reglas: un `Result.err` dentro de un if anidado quedaba fuera
+del alcance de `result-error-requires-cause`. Esta regla elimina la categoría
+completa de evasión en vez de parchear cada caso.
+
+```ts
+// ❌ anidado: el lector mantiene dos condiciones en la cabeza
+if (!response.ok) {
+  if (shouldReport) {
+    return Result.err({ cause: response.error, message: "...", type: "X" });
+  }
+}
+
+// ✅ retorno anticipado: una condición a la vez, camino feliz sin sangría
+if (!response.ok && shouldReport) {
+  return Result.err({ cause: response.error, message: "...", type: "X" });
+}
+
+// ✅ o match() si son variantes de un mismo valor
+```
+
+No cuenta como anidación: la cadena `else if` (es secuencia, no anidación), y
+una función definida dentro del `if` (unidad cognitiva aparte). El propio
+código de este plugin se aplanó con retorno anticipado al activar la regla —
+cinco casos, todos quedaron más legibles.
+
 ### `skapxd/no-default-export`
 
 Prohíbe `export default` (incluida la forma `export { x as default }`). Con
@@ -1085,6 +1127,53 @@ const label = match(status)
   .exhaustive();
 ```
 
+### `skapxd/prefer-abort-signal`
+
+Dentro de un `useEffect`/`useLayoutEffect`, los listeners se limpian con
+`AbortController`, no con `removeEventListener` manual:
+
+```ts
+// ❌ registro y limpieza espejados a mano
+useEffect(() => {
+  const media = window.matchMedia("(prefers-color-scheme: dark)");
+  media.addEventListener("change", onSystemChange);
+  return () => media.removeEventListener("change", onSystemChange);
+}, [settings]);
+
+// ✅ un AbortController por efecto
+useEffect(() => {
+  const controller = new AbortController();
+  const media = window.matchMedia("(prefers-color-scheme: dark)");
+  media.addEventListener("change", onSystemChange, { signal: controller.signal });
+  return () => controller.abort();
+}, [settings]);
+```
+
+Por qué: un solo `abort()` limpia **todos** los listeners del efecto (no hay
+que espejar cada `add` con su `remove`), y elimina el bug clásico de pasar una
+referencia distinta a `removeEventListener` (un `.bind()` o una arrow nueva)
+que deja el listener vivo para siempre.
+
+Reporta dos cosas dentro del callback del efecto (incluidas sus funciones
+anidadas y el cleanup): `addEventListener` sin `signal` en las options, y
+cualquier `removeEventListener`. Fuera de un efecto la regla no opina.
+
+Cuando las options no son un objeto literal, la verificación resuelve en
+capas:
+
+1. **Por scope**: `addEventListener("x", fn, opts)` sigue `opts` hasta su
+   `const opts = {...}` y lo inspecciona — sin necesitar type-checking.
+2. **Por tipo** (con `projectService`): si no hay inicializador visible (un
+   parámetro, un import), pregunta al checker si el **tipo** declara `signal`;
+   si ni el tipo la tiene, es imposible que llegue y se reporta.
+3. Sin inicializador ni tipos: beneficio de la duda.
+
+El boolean de capture (`addEventListener("x", fn, true)`) se reporta siempre:
+no puede traer `signal`.
+
+`effectNames` permite cubrir wrappers propios (`["useEffect",
+"useLayoutEffect", "useIsomorphicEffect"]`).
+
 ### `skapxd/no-jsx-ternary-null`
 
 Cuando renderizas JSX condicional y una rama del ternario es `null`, prefiere la

package/dist/astro/index.d.mts

@@ -14,6 +14,7 @@ declare function createAstroConfigs(pluginReference: unknown): ({
         "skapxd/no-deep-relative-imports": string;
         "skapxd/no-default-export": string;
         "skapxd/no-emoji": string;
+        "skapxd/no-nested-if": string;
         "skapxd/no-promise-chain": string;
         "skapxd/no-try-catch": string;
         "skapxd/one-root-function-per-file": string;
@@ -31,6 +32,7 @@ declare function createAstroConfigs(pluginReference: unknown): ({
         "skapxd/no-deep-relative-imports": string;
         "skapxd/no-default-export": string;
         "skapxd/no-emoji": string;
+        "skapxd/no-nested-if": string;
         "skapxd/no-promise-chain": string;
         "skapxd/no-try-catch": string;
         "skapxd/one-root-function-per-file": string;

package/dist/astro/index.d.ts

@@ -14,6 +14,7 @@ declare function createAstroConfigs(pluginReference: unknown): ({
         "skapxd/no-deep-relative-imports": string;
         "skapxd/no-default-export": string;
         "skapxd/no-emoji": string;
+        "skapxd/no-nested-if": string;
         "skapxd/no-promise-chain": string;
         "skapxd/no-try-catch": string;
         "skapxd/one-root-function-per-file": string;
@@ -31,6 +32,7 @@ declare function createAstroConfigs(pluginReference: unknown): ({
         "skapxd/no-deep-relative-imports": string;
         "skapxd/no-default-export": string;
         "skapxd/no-emoji": string;
+        "skapxd/no-nested-if": string;
         "skapxd/no-promise-chain": string;
         "skapxd/no-try-catch": string;
         "skapxd/one-root-function-per-file": string;

package/dist/astro/index.js

@@ -40,6 +40,7 @@ var baseRules = {
   "skapxd/no-deep-relative-imports": "error",
   "skapxd/no-default-export": "error",
   "skapxd/no-emoji": "error",
+  "skapxd/no-nested-if": "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-default-export\": \"error\",\n  \"skapxd/no-emoji\": \"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,mBAAmB;AAAA,EACnB,2BAA2B;AAAA,EAC3B,uBAAuB;AAAA,EACvB,qCAAqC;AAAA,EACrC,4BAA4B;AAAA,EAC5B,sCAAsC;AACxC;;;ACVA,+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-emoji\": \"error\",\n  \"skapxd/no-nested-if\": \"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,mBAAmB;AAAA,EACnB,uBAAuB;AAAA,EACvB,2BAA2B;AAAA,EAC3B,uBAAuB;AAAA,EACvB,qCAAqC;AAAA,EACrC,4BAA4B;AAAA,EAC5B,sCAAsC;AACxC;;;ACXA,+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-5P6OHVFD.mjs";
-import "../chunk-EGNXI5HL.mjs";
+} from "../chunk-3NM7FEIN.mjs";
+import "../chunk-J472YWOD.mjs";
 export {
   createAstroConfigs
 };

package/dist/{chunk-5P6OHVFD.mjs → chunk-3NM7FEIN.mjs}

@@ -2,7 +2,7 @@ import {
   baseRules,
   createBaseLanguageOptions,
   createTypedLanguageOptions
-} from "./chunk-EGNXI5HL.mjs";
+} from "./chunk-J472YWOD.mjs";
 
 // src/astro/configs.ts
 function createAstroConfigs(pluginReference) {
@@ -40,4 +40,4 @@ function createAstroConfigs(pluginReference) {
 export {
   createAstroConfigs
 };
-//# sourceMappingURL=chunk-5P6OHVFD.mjs.map
+//# sourceMappingURL=chunk-3NM7FEIN.mjs.map

package/dist/{chunk-O4RTJGEU.mjs → chunk-EXMF54EM.mjs}

@@ -644,14 +644,16 @@ var asyncFunctionsReturnResult = {
         return;
       }
       const returnType = node.returnType?.typeAnnotation;
+      const missingReturnTypeIsReportable = options.checkMissingReturnType || containsCallNamed(node.body, options.checkMissingReturnTypeWhenCallNames);
+      if (!returnType && missingReturnTypeIsReportable) {
+        context.report({
+          data: { name: functionName },
+          messageId: "missingReturnType",
+          node: reportNode
+        });
+        return;
+      }
       if (!returnType) {
-        if (options.checkMissingReturnType || containsCallNamed(node.body, options.checkMissingReturnTypeWhenCallNames)) {
-          context.report({
-            data: { name: functionName },
-            messageId: "missingReturnType",
-            node: reportNode
-          });
-        }
         return;
       }
       if (isSkapxdResultReturnType(returnType)) {
@@ -813,14 +815,13 @@ function getAwaitScopeName(node) {
 function getEnclosingTrySafeCall(node, trySafeCallNames) {
   let currentNode = node.parent;
   while (currentNode) {
-    if (isFunctionNode(currentNode)) {
-      const parent = currentNode.parent;
-      if (parent?.type === "CallExpression" && parent.arguments.includes(currentNode) && isCalleeNamed(parent.callee, trySafeCallNames)) {
-        return parent;
-      }
-      return null;
+    if (!isFunctionNode(currentNode)) {
+      currentNode = currentNode.parent;
+      continue;
     }
-    currentNode = currentNode.parent;
+    const parent = currentNode.parent;
+    const isTrySafeArgument = parent?.type === "CallExpression" && parent.arguments.includes(currentNode) && isCalleeNamed(parent.callee, trySafeCallNames);
+    return isTrySafeArgument ? parent : null;
   }
   return null;
 }
@@ -954,6 +955,18 @@ var awaitRequiresResult = {
   }
 };
 
+// src/utils/get-error-member-object.ts
+function getErrorMemberObject(node) {
+  const unwrappedNode = unwrapExpression(node);
+  if (unwrappedNode.type !== "MemberExpression" || unwrappedNode.object.type !== "Identifier" || !isMemberPropertyNamed(unwrappedNode, "error")) {
+    return null;
+  }
+  return {
+    name: unwrappedNode.object.name,
+    node: unwrappedNode.object
+  };
+}
+
 // src/utils/get-ok-member-object.ts
 function getOkMemberObject(node) {
   const unwrappedNode = unwrapExpression(node);
@@ -1002,6 +1015,9 @@ function getResultCheckArgument(node, methodName) {
 // src/utils/get-failed-result-guard.ts
 function getFailedResultGuard(node) {
   const unwrappedNode = unwrapExpression(node);
+  if (unwrappedNode.type === "MemberExpression") {
+    return getErrorMemberObject(unwrappedNode);
+  }
   if (unwrappedNode.type === "UnaryExpression" && unwrappedNode.operator === "!") {
     return getOkMemberObject(unwrappedNode.argument) ?? getResultCheckArgument(unwrappedNode.argument, "isOk");
   }
@@ -1119,10 +1135,7 @@ var resultErrorRequiresCause = {
           if (!isSkapxdResultErrCall(resultErrCall, typeContext)) {
             continue;
           }
-          if (resultErrCall.arguments.length === 0) {
-            continue;
-          }
-          if (resultErrPreservesCause(resultErrCall.arguments[0], resultGuard.name)) {
+          if (resultErrCall.arguments.length > 0 && resultErrPreservesCause(resultErrCall.arguments[0], resultGuard.name)) {
             continue;
           }
           context.report({
@@ -1697,6 +1710,134 @@ var noTryCatch = {
   }
 };
 
+// src/utils/get-prefer-abort-signal-options.ts
+function getPreferAbortSignalOptions(options = {}) {
+  return {
+    allowFilePatterns: options.allowFilePatterns ?? [],
+    effectNames: options.effectNames ?? ["useEffect", "useLayoutEffect"]
+  };
+}
+
+// src/utils/get-variable-initializer.ts
+function getVariableInitializer(identifier, scope) {
+  let current = scope;
+  while (current) {
+    const variable = current.variables.find(
+      (candidate) => candidate.name === identifier.name
+    );
+    if (variable) {
+      const definition = variable.defs[0];
+      return definition?.node?.type === "VariableDeclarator" ? definition.node.init : null;
+    }
+    current = current.upper;
+  }
+  return null;
+}
+
+// src/utils/object-expression-has-signal.ts
+function objectExpressionHasSignal(objectExpression) {
+  return objectExpression.properties.some(
+    (property) => property.type === "SpreadElement" || isPropertyKeyNamed(property, "signal")
+  );
+}
+
+// src/utils/has-abort-signal-option.ts
+function hasAbortSignalOption(callExpression, sourceCode, typeContext) {
+  const options = callExpression.arguments[2];
+  if (!options) {
+    return false;
+  }
+  if (options.type === "Literal") {
+    return false;
+  }
+  if (options.type === "ObjectExpression") {
+    return objectExpressionHasSignal(options);
+  }
+  const initializer = options.type === "Identifier" ? getVariableInitializer(options, sourceCode.getScope(options)) : null;
+  if (initializer?.type === "ObjectExpression") {
+    return objectExpressionHasSignal(initializer);
+  }
+  if (typeContext) {
+    const type = typeContext.services.getTypeAtLocation(options);
+    return Boolean(typeContext.checker.getPropertyOfType(type, "signal"));
+  }
+  return true;
+}
+
+// src/utils/is-inside-effect-callback.ts
+function isInsideEffectCallback(node, effectNames) {
+  let current = node.parent;
+  while (current) {
+    const call = isFunctionNode(current) ? current.parent : null;
+    if (call?.type === "CallExpression" && call.arguments[0] === current && isCalleeNamed(call.callee, effectNames)) {
+      return true;
+    }
+    current = current.parent;
+  }
+  return false;
+}
+
+// src/rules/prefer-abort-signal.ts
+var preferAbortSignal = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "En efectos de React, los listeners se limpian con AbortController, no con removeEventListener."
+    },
+    messages: {
+      addWithoutSignal: "Este addEventListener vive en un efecto sin `signal`. Crea `const controller = new AbortController()`, pasa `{ signal: controller.signal }` como tercer argumento y limpia con `return () => controller.abort()`: un solo abort cubre todos los listeners del efecto.",
+      removeInsteadOfAbort: "No quites listeners a mano en el cleanup: registra con `{ signal: controller.signal }` y reemplaza este removeEventListener por `return () => controller.abort()`. Evita el bug clasico de pasar una referencia distinta al remover."
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowFilePatterns: {
+            items: { type: "string" },
+            type: "array"
+          },
+          effectNames: {
+            items: { type: "string" },
+            type: "array"
+          }
+        },
+        type: "object"
+      }
+    ]
+  },
+  create(context) {
+    const options = getPreferAbortSignalOptions(context.options[0]);
+    const filename = context.filename ?? context.getFilename();
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    const typeContext = getTypeContext(context);
+    if (matchesAnyGlob(filename, options.allowFilePatterns)) {
+      return {};
+    }
+    return {
+      CallExpression(node) {
+        if (node.callee?.type !== "MemberExpression") {
+          return;
+        }
+        const isAdd = isMemberPropertyNamed(node.callee, "addEventListener");
+        const isRemove = isMemberPropertyNamed(node.callee, "removeEventListener");
+        if (!isAdd && !isRemove) {
+          return;
+        }
+        if (!isInsideEffectCallback(node, options.effectNames)) {
+          return;
+        }
+        if (isRemove) {
+          context.report({ messageId: "removeInsteadOfAbort", node });
+          return;
+        }
+        if (!hasAbortSignalOption(node, sourceCode, typeContext)) {
+          context.report({ messageId: "addWithoutSignal", node });
+        }
+      }
+    };
+  }
+};
+
 // src/rules/prefer-ts-pattern.ts
 var preferTsPattern = {
   meta: {
@@ -1768,6 +1909,67 @@ var noJsxTernaryNull = {
   }
 };
 
+// src/utils/get-no-nested-if-options.ts
+function getNoNestedIfOptions(options = {}) {
+  return {
+    allowFilePatterns: options.allowFilePatterns ?? []
+  };
+}
+
+// src/utils/is-nested-if-statement.ts
+function isNestedIfStatement(node) {
+  if (node.parent?.type === "IfStatement" && node.parent.alternate === node) {
+    return false;
+  }
+  let current = node.parent;
+  while (current && !isFunctionNode(current)) {
+    if (current.type === "IfStatement") {
+      return true;
+    }
+    current = current.parent;
+  }
+  return false;
+}
+
+// src/rules/no-nested-if.ts
+var noNestedIf = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Prohibe if anidados; usa retorno anticipado (guard clauses) o match() de ts-pattern."
+    },
+    messages: {
+      noNestedIf: "No anides un if dentro de otro: cada nivel suma carga cognitiva y crea puntos ciegos para las demas reglas. Aplana con retorno anticipado (`if (!x) return ...;` y sigue el camino feliz) o decide con `match()` de ts-pattern si son variantes de un mismo valor."
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowFilePatterns: {
+            items: { type: "string" },
+            type: "array"
+          }
+        },
+        type: "object"
+      }
+    ]
+  },
+  create(context) {
+    const options = getNoNestedIfOptions(context.options[0]);
+    const filename = context.filename ?? context.getFilename();
+    if (matchesAnyGlob(filename, options.allowFilePatterns)) {
+      return {};
+    }
+    return {
+      IfStatement(node) {
+        if (isNestedIfStatement(node)) {
+          context.report({ messageId: "noNestedIf", node });
+        }
+      }
+    };
+  }
+};
+
 // src/utils/is-promise-type.ts
 function isPromiseType(type, typeContext) {
   return typeContext.checker.getPromisedTypeOfPromise(type) !== void 0;
@@ -1810,11 +2012,11 @@ var noPromiseChain = {
         if (!method) {
           return;
         }
-        if (typeContext) {
-          const type = typeContext.services.getTypeAtLocation(callee.object);
-          if (!isPromiseType(type, typeContext)) {
-            return;
-          }
+        if (typeContext && !isPromiseType(
+          typeContext.services.getTypeAtLocation(callee.object),
+          typeContext
+        )) {
+          return;
         }
         context.report({
           data: { method },
@@ -1850,12 +2052,14 @@ var rules = {
   "no-tunnel-props": noTunnelProps,
   "no-functions-inside-components": noFunctionsInsideComponents,
   "no-try-catch": noTryCatch,
+  "prefer-abort-signal": preferAbortSignal,
   "prefer-ts-pattern": preferTsPattern,
   "no-jsx-ternary-null": noJsxTernaryNull,
+  "no-nested-if": noNestedIf,
   "no-promise-chain": noPromiseChain
 };
 
 export {
   rules
 };
-//# sourceMappingURL=chunk-O4RTJGEU.mjs.map
+//# sourceMappingURL=chunk-EXMF54EM.mjs.map