@skapxd/eslint-opinionated 0.17.0 → 1.0.0

package/README.md

@@ -831,6 +831,7 @@ de cada regla):
 | `nest-validation-pipe-config` | `allowFilePatterns` (globs), `requiredPipeOptions` (default `["transform", "whitelist"]`) |
 | `no-deep-relative-imports` | `maxDepth` |
 | `no-default-export` | `allowFilePatterns` (globs, aditivos a los integrados) |
+| `no-anonymous-condition` | `allowFilePatterns` (globs), `maxMemberDepth` (default `2`), `allowTypePredicates` (default `true`, type-aware) |
 | `no-else` | `allowFilePatterns` (globs) |
 | `no-emoji` | `allowFilePatterns` (globs) |
 | `no-explicit-any` | las de la regla original de typescript-eslint (`fixToUnknown`, ...) |
@@ -879,6 +880,7 @@ matchea en cualquier carpeta). Las 7 reglas restantes no tienen opciones: su
 | `skapxd/nest-no-swagger-in-controllers` | Los controllers no se llenan de decoradores de swagger; el plugin introspecciona los DTOs. Preset `nest`. |
 | `skapxd/nest-requires-swagger-plugin` | `nest-cli.json` debe tener el plugin `@nestjs/swagger`: la premisa de las reglas de swagger, verificada. Preset `nest`. |
 | `skapxd/nest-validation-pipe-config` | Todo `new ValidationPipe` configura `transform` y `whitelist`: la premisa de las reglas de DTOs. Preset `nest`. |
+| `skapxd/no-anonymous-condition` | El `if` solo acepta condiciones ya nombradas; todo cómputo (llamada, comparación, `&&`/`||`) se extrae a una `const` con nombre semántico. **Opt-in: no está en ningún preset.** |
 | `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-else` | Prohíbe `else`/`else if`: el else es el estado sin nombre. Retorno anticipado, ternario simple o `match()`. |
@@ -1197,8 +1199,9 @@ con las mismas cinco formas de guard.
 > }
 > ```
 >
-> (`skapxd/await-requires-try-safe` es el nombre anterior; sigue funcionando
-> como alias deprecado y se eliminará en una versión futura.)
+> (`skapxd/await-requires-try-safe` fue el nombre anterior; el alias se
+> eliminó en la v1.0.0 — si tu config lo menciona, renómbralo a
+> `skapxd/await-requires-result`: mismo comportamiento, mismas opciones.)
 
 Hay dos caminos válidos, y la regla recomienda el primero:
 
@@ -1660,6 +1663,57 @@ por indirección tampoco escapa. Solo aplica a clases con `@Controller`
 (configurable con `controllerDecoratorNames` para decoradores propios); los
 services retornan Result con orgullo — ese es el dominio.
 
+### `skapxd/no-anonymous-condition`
+
+La hermana de `no-else`: esa nombra los **caminos**, esta nombra la
+**pregunta**. Un `if` cuya condición es un cómputo evalúa un valor anónimo
+cuyo significado vive solo en la cabeza de quien lo escribió; la regla exige
+bautizarlo (el refactor "introduce explaining variable" de Fowler, como ley):
+
+```ts
+if (matchesAnyGlob(filename, options.allowFilePatterns)) { ... }   // ❌ ¿qué significa que matchee?
+
+const esArchivoExento = matchesAnyGlob(filename, options.allowFilePatterns);
+if (esArchivoExento) { ... }                                       // ✅ la decisión se lee como prosa
+```
+
+Lo **ya nombrado** no se extrae (la lista blanca — extraerlo sería ceremonia
+sin información):
+
+- Variables y sus negaciones: `isReady`, `!isReady`, `!!isReady`.
+- Accesos a propiedad hasta `maxMemberDepth` saltos (contando puntos desde
+  la base como nivel 0: `result.ok` → 1, `options.rules.flag` → 2; default
+  `2`) y sus negaciones — incluido el encadenamiento opcional (`config?.flag`).
+- Comparaciones contra literal booleano o nullish (`x.ok === false`,
+  `x == null`, `x !== undefined`): la escritura explícita de la
+  afirmación/negación/presencia. Cubre las formas oficiales del guard de
+  Result, que `result-error-requires-cause/handling` necesitan ver intactas.
+- **Type guards demostrados por la firma** (`allowTypePredicates`, default
+  `true`): `if (isFunctionNode(x))` pasa cuando la firma declara
+  `x is FunctionNode` — el type-checker lo demuestra (evidencia, no
+  convención de nombre: una `isX(...)` que devuelve `boolean` a secas sí se
+  extrae). Requiere type info; sin parser services no hay evidencia y toda
+  llamada exige nombre. `Result.isErr(x)` pasa por esta vía: es un type
+  predicate real.
+
+Lo que **sí dispara**: llamadas, comparaciones (`a.length <= b.max`,
+`status === "ready"`), combinaciones `&&`/`||` y aritmética
+(`if (total % 2)`). La extracción directa a `const` conserva el narrowing
+(TS 4.4+, aliased conditions).
+
+**Opt-in deliberado: no está en ningún preset.** La calibración contra 4
+proyectos reales (2026-06-12) midió 473/95/308 hallazgos en tres backends
+NestJS en producción y 44 en un front pequeño — señal genuina en la muestra
+revisada, pero un orden de magnitud más invasiva que cualquier regla de las
+bases. Actívala por proyecto (o por carpeta, estilo ola 3 del playbook de
+adopción):
+
+```js
+rules: {
+  "skapxd/no-anonymous-condition": "error",
+}
+```
+
 ### `skapxd/no-deep-relative-imports`
 
 Limita cuántos niveles puede subir un import relativo. Por defecto **prohíbe

package/dist/{chunk-PD77UDUY.mjs → chunk-S2MDPOWE.mjs}

@@ -2652,6 +2652,157 @@ var noDefaultExport = {
   }
 };
 
+// src/utils/call-has-type-predicate.ts
+function callHasTypePredicate(node, parserServices) {
+  const tsNode = parserServices?.esTreeNodeToTSNodeMap?.get(node);
+  const program = parserServices?.program;
+  if (tsNode === void 0 || program === null || program === void 0) {
+    return false;
+  }
+  const checker = program.getTypeChecker();
+  const signature = checker.getResolvedSignature(
+    tsNode
+  );
+  if (signature === void 0) {
+    return false;
+  }
+  return checker.getTypePredicateOfSignature(signature) !== void 0;
+}
+
+// src/utils/get-member-chain-depth.ts
+function getMemberChainDepth(node) {
+  let current = node.type === "ChainExpression" && node.expression !== void 0 ? node.expression : node;
+  let depth = 0;
+  while (current.type === "MemberExpression") {
+    depth += 1;
+    if (current.object === void 0) {
+      return null;
+    }
+    current = current.object;
+  }
+  if (current.type === "Identifier" || current.type === "ThisExpression") {
+    return depth;
+  }
+  return null;
+}
+
+// src/utils/get-no-anonymous-condition-options.ts
+function getNoAnonymousConditionOptions(options = {}) {
+  return {
+    allowFilePatterns: options.allowFilePatterns ?? [],
+    // Permitir llamadas cuya firma el type-checker demuestra como type
+    // predicate (`x is T`). Sin type info, no hay evidencia y no aplica.
+    allowTypePredicates: options.allowTypePredicates ?? true,
+    // Saltos de propiedad permitidos en la lista blanca, contando desde la
+    // base como nivel 0: `result.ok` → 1, `options.rules.flag` → 2.
+    maxMemberDepth: options.maxMemberDepth ?? 2
+  };
+}
+
+// src/utils/is-guard-literal.ts
+function isGuardLiteral(node) {
+  if (node.type === "Literal") {
+    return typeof node.value === "boolean" || node.value === null;
+  }
+  return node.type === "Identifier" && node.name === "undefined";
+}
+
+// src/utils/is-literal-guard-comparison.ts
+var guardOperators = /* @__PURE__ */ new Set(["===", "!==", "==", "!="]);
+function isLiteralGuardComparison(node, maxMemberDepth) {
+  if (node.type !== "BinaryExpression") {
+    return false;
+  }
+  if (node.operator === void 0 || !guardOperators.has(node.operator)) {
+    return false;
+  }
+  const { left, right } = node;
+  if (left === void 0 || right === void 0) {
+    return false;
+  }
+  const leftIsGuard = isGuardLiteral(left);
+  const rightIsGuard = isGuardLiteral(right);
+  if (!leftIsGuard && !rightIsGuard) {
+    return false;
+  }
+  const namedSide = leftIsGuard ? right : left;
+  const depth = getMemberChainDepth(namedSide);
+  return depth !== null && depth <= maxMemberDepth;
+}
+
+// src/utils/unwrap-negations.ts
+function unwrapNegations(node) {
+  let current = node;
+  while (current.type === "UnaryExpression" && current.operator === "!" && current.argument !== void 0) {
+    current = current.argument;
+  }
+  return current;
+}
+
+// src/rules/no-anonymous-condition.ts
+var noAnonymousCondition = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "La condicion sin nombre: el if solo acepta condiciones ya nombradas (variables, accesos acotados, type guards demostrados); todo computo se extrae a una const con nombre semantico."
+    },
+    messages: {
+      anonymousCondition: "La condicion sin nombre: este if evalua un computo cuyo significado el lector debe deducir. Extraelo a una const con nombre semantico y la decision se lee como prosa: `const esArchivoExento = matchesAnyGlob(archivo, patrones); if (esArchivoExento) ...`. La extraccion directa a const conserva el narrowing (TS 4.4+). Lo ya-nombrado no se extrae: variables (`isReady`), accesos como `result.ok` (hasta {{maxMemberDepth}} saltos), sus negaciones (`!result.ok`), comparaciones con literal booleano o nullish (`x.ok === false`, `x == null`) y type guards que la firma demuestra (`x is T`)."
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowFilePatterns: {
+            items: { type: "string" },
+            type: "array"
+          },
+          allowTypePredicates: {
+            type: "boolean"
+          },
+          maxMemberDepth: {
+            type: "number"
+          }
+        },
+        type: "object"
+      }
+    ]
+  },
+  create(context) {
+    const options = getNoAnonymousConditionOptions(
+      context.options[0]
+    );
+    const filename = context.filename ?? context.getFilename?.() ?? "";
+    if (matchesAnyGlob(filename, options.allowFilePatterns)) {
+      return {};
+    }
+    return {
+      IfStatement(node) {
+        const condition = unwrapNegations(node.test);
+        if (condition.type === "Literal") {
+          return;
+        }
+        const depth = getMemberChainDepth(condition);
+        if (depth !== null && depth <= options.maxMemberDepth) {
+          return;
+        }
+        if (isLiteralGuardComparison(condition, options.maxMemberDepth)) {
+          return;
+        }
+        const isProvenTypeGuard = condition.type === "CallExpression" && options.allowTypePredicates && callHasTypePredicate(condition, context.sourceCode?.parserServices);
+        if (isProvenTypeGuard) {
+          return;
+        }
+        context.report({
+          data: { maxMemberDepth: String(options.maxMemberDepth) },
+          messageId: "anonymousCondition",
+          node: node.test
+        });
+      }
+    };
+  }
+};
+
 // src/utils/get-no-else-options.ts
 function getNoElseOptions(options = {}) {
   return {
@@ -4065,15 +4216,6 @@ var rules = {
   "async-functions-return-result": asyncFunctionsReturnResult,
   "no-ad-hoc-ok-result": noAdHocOkResult,
   "await-requires-result": awaitRequiresResult,
-  // Alias deprecado del nombre anterior; se elimina en una versión futura.
-  "await-requires-try-safe": {
-    ...awaitRequiresResult,
-    meta: {
-      ...awaitRequiresResult.meta,
-      deprecated: true,
-      replacedBy: ["skapxd/await-requires-result"]
-    }
-  },
   "result-error-requires-cause": resultErrorRequiresCause,
   "result-error-requires-handling": resultErrorRequiresHandling,
   "max-hook-size": maxHookSize,
@@ -4086,6 +4228,7 @@ var rules = {
   "nest-no-swagger-in-controllers": nestNoSwaggerInControllers,
   "nest-requires-swagger-plugin": nestRequiresSwaggerPlugin,
   "nest-validation-pipe-config": nestValidationPipeConfig,
+  "no-anonymous-condition": noAnonymousCondition,
   "no-deep-relative-imports": noDeepRelativeImports,
   "no-default-export": noDefaultExport,
   "no-else": noElse,
@@ -4116,4 +4259,4 @@ var rules = {
 export {
   rules
 };
-//# sourceMappingURL=chunk-PD77UDUY.mjs.map
+//# sourceMappingURL=chunk-S2MDPOWE.mjs.map