@sarj/eslint-plugin 19.10.0 → 19.14.0

package/dist/catalog.js

@@ -2,7 +2,7 @@ import {
   publicDocumentation,
   ruleSpec,
   src_default
-} from "./chunk-ZWOGM4CV.js";
+} from "./chunk-YWEV6GQM.js";
 
 // src/docs/directive-disable-enable-pair.ts
 var DIRECTIVE_DISABLE_ENABLE_PAIR_DOCUMENTATION = {
@@ -4163,9 +4163,9 @@ var PREFER_CODED_ERROR_RESULT_DOCUMENTATION = {
     "Checks source-resolved local unions with required literal ok/success booleans, or status/state/kind/type/tag values ok/success versus err/error/failure/failed (case insensitive). Conflicting outcome tags abstain. A shared outcome tag does not also count as a domain error code. Named and namespace neverthrow Result/ResultAsync imports establish their generic error position.",
     "Presence-selected unions require an error property on every failure branch and the same single required non-control value property on every success branch. Optional error/value fields, multiple value keys, loading states and error branches carrying the success value abstain. Required errorMessage and Error-suffixed failure channels are also reviewed; multiple custom channels abstain and a primary error payload retains precedence.",
     "Broad string and unknown error channels, unshadowed native Error-family types and open string/unknown code fields receive review. Explicit Any stays with the existing no-explicit-any rule. Finite literal codes need no invented payload. Imported domain errors, validation-library errors, generic error parameters, ordinary formatters, legitimate absence and redacted failure states remain valid.",
-    "Local aliases, unmerged interfaces without inheritance and generic substitutions are bounded to 16 resolution levels, 64 union members and 256 traversal steps. Imported local declarations, conditional/intersection/mapped types and unresolved contracts abstain. Optional discriminants, independent success/error payloads and partial-data failures are excluded.",
+    "Local aliases, unmerged interfaces without inheritance and generic substitutions are bounded to 16 resolution levels, 64 union members and 256 traversal steps. Transparent aliases retain the proven neverthrow Result/ResultAsync error position, including renamed/namespace imports, generic defaults and unshadowed native Promise/PromiseLike wrappers. Imported local declarations, conditional/intersection/mapped types and unresolved contracts abstain. Optional discriminants, independent success/error payloads and partial-data failures are excluded.",
     "Required code/kind/type/tag fields of unresolved or imported type defer to the type checker; a finite code does not prove that its cases or payloads are useful. Generic error parameters are retained rather than guessed. Ordinary string formatters, absence, validation-library errors and redacted failure states without a string payload are not flagged.",
-    "A directly returned failure object, neverthrow err/errAsync call or new Err with an interpolated template or proven string concatenation receives review. Without a code, the diagnostic asks for a domain contract; with a literal code, it asks for consumer formatting. Literal-only compositions, including earlier stable local constants, remain valid codes. Nested plain error objects, expression-bodied arrows and one direct await are supported. Import identity and value-space shadowing are checked; arbitrary aliases, spreads, accessors, computed keys, helper formatting calls and nonliteral codes abstain. This proves formatting ownership, not which context the domain must expose; presentation adapters remain a reviewed exception.",
+    "A directly returned failure object, neverthrow err/errAsync call or new Err with an interpolated template or proven string concatenation receives review. Without a code, the diagnostic asks for a domain contract; with a literal code, it asks for consumer formatting. Literal-only compositions, including earlier stable local constants, remain valid codes. Nested plain error objects, expression-bodied arrows and awaited returns are supported. Returned conditional branches are followed without visiting their conditions, call arguments or containers; logical/sequence expressions and arbitrary aliases abstain. The entire return expression abstains beyond 16 levels, 64 leaves or 256 traversal steps. Import identity and value-space shadowing are checked; spreads, accessors, computed keys, helper formatting calls and nonliteral codes abstain. This proves formatting ownership, not which context the domain must expose; presentation adapters remain a reviewed exception.",
     "This warning requests domain review: an infrastructure adapter may intentionally retain unknown/Error, and a final presentation boundary may accept every failure and render one message. Neither proves a recoverable domain rejection. No fix invents error codes, fields, handlers or changes serialization, exception unwinding, transactions, retries or logging."
   ],
   references: [
@@ -4173,6 +4173,66 @@ var PREFER_CODED_ERROR_RESULT_DOCUMENTATION = {
     "https://github.com/supermacro/neverthrow"
   ],
   examples: [
+    {
+      id: "conditional-message-failure",
+      scenarioId: "conditional-result-producer",
+      title: "A conditional return still needs a useful error contract",
+      outcome: "match",
+      files: [
+        {
+          path: "app/result.ts",
+          source: "import { err, ok } from 'neverthrow'; export const save = (name: string, allowed: boolean) => allowed ? ok(name) : err(`Denied ${name}`);"
+        }
+      ],
+      focusPath: "app/result.ts",
+      expectedCount: 1,
+      public: true
+    },
+    {
+      id: "conditional-coded-failure",
+      scenarioId: "conditional-result-producer",
+      title: "Preserve the code and context and let the consumer format",
+      outcome: "no-match",
+      files: [
+        {
+          path: "app/result.ts",
+          source: "import { err, ok, type Result } from 'neverthrow'; type Denied = { code: 'denied'; name: string }; export function save(name: string, allowed: boolean): Result<string, Denied> { return allowed ? ok(name) : err({ code: 'denied', name }); } export function format(error: Denied): string { return `Denied ${error.name}`; }"
+        }
+      ],
+      focusPath: "app/result.ts",
+      expectedCount: 0,
+      public: true
+    },
+    {
+      id: "aliased-library-message",
+      scenarioId: "aliased-library-error",
+      title: "A transparent alias must preserve the library error contract",
+      outcome: "match",
+      files: [
+        {
+          path: "app/result.ts",
+          source: "import type { Result as NativeResult } from 'neverthrow'; type Saved<T, E> = Promise<NativeResult<T, E>>; export type Output = Saved<number, string>;"
+        }
+      ],
+      focusPath: "app/result.ts",
+      expectedCount: 1,
+      public: true
+    },
+    {
+      id: "aliased-library-domain-error",
+      scenarioId: "aliased-library-error",
+      title: "Keep a finite error code and only the context its consumer needs",
+      outcome: "no-match",
+      files: [
+        {
+          path: "app/result.ts",
+          source: "import type { Result as NativeResult } from 'neverthrow'; type Saved<T, E> = Promise<NativeResult<T, E>>; export type Output = Saved<number, { code: 'duplicate'; name: string } | { code: 'denied' }>;"
+        }
+      ],
+      focusPath: "app/result.ts",
+      expectedCount: 0,
+      public: true
+    },
     {
       id: "presence-selected-message",
       scenarioId: "presence-selected-result",

package/dist/{chunk-ZWOGM4CV.js → chunk-YWEV6GQM.js}

@@ -21588,14 +21588,15 @@ function resolve2(value, source, depth = 0) {
   if (depth >= MAX_DEPTH) return null;
   const node = value.node;
   if (node.type !== "TSTypeReference") return value;
-  if (node.typeName.type !== "Identifier") return null;
+  if (node.typeName.type !== "Identifier")
+    return libraryResult(node, source) ? value : null;
   const variable = typeBinding(source, node.typeName);
   if (variable === null || variable.defs.length === 0) return value;
   const bound = value.bindings.get(variable);
   if (bound !== void 0) return resolve2(bound, source, depth + 1);
   const declaration = variable.defs.length === 1 ? variable.defs[0]?.node : void 0;
   if (declaration?.type !== "TSTypeAliasDeclaration" && declaration?.type !== "TSInterfaceDeclaration")
-    return null;
+    return libraryResult(node, source) ? value : null;
   if (declaration.type === "TSInterfaceDeclaration" && declaration.extends.length !== 0)
     return null;
   const bindings = bindArguments(declaration, node, value, source);
@@ -21761,6 +21762,26 @@ function openStringField(fields2, owner, source, names, budget) {
   }
   return null;
 }
+function outcomeFailures(value, source, depth = 0, budget = { remaining: MAX_TYPE_STEPS }) {
+  if (depth >= MAX_DEPTH || --budget.remaining < 0) return [];
+  const resolved = resolve2(value, source);
+  if (resolved === null) return [];
+  const structural = failureMessages(resolved, source);
+  if (structural.length !== 0) return structural;
+  const library = libraryError(resolved, source);
+  if (library !== null) return [library];
+  const node = resolved.node;
+  if (node.type !== "TSTypeReference") return [];
+  if (node.typeName.type !== "Identifier" || !["Promise", "PromiseLike"].includes(node.typeName.name) || (typeBinding(source, node.typeName)?.defs.length ?? 0) !== 0 || node.typeArguments?.params.length !== 1)
+    return [];
+  const argument = node.typeArguments.params[0];
+  return argument === void 0 ? [] : outcomeFailures(
+    { ...resolved, node: argument, origin: argument },
+    source,
+    depth + 1,
+    budget
+  );
+}
 function failureMessages(value, source) {
   const members2 = variants(value, source);
   if (members2 === null || members2.length < 2) return [];
@@ -21853,14 +21874,18 @@ function variants(value, source, depth = 0, budget = { remaining: MAX_TYPE_STEPS
   }
   return result;
 }
-function libraryError(reference, source) {
-  if (reference.typeArguments?.params.length !== 2) return null;
-  if (!["Result", "ResultAsync"].includes(
-    libraryName(reference.typeName, source, true) ?? ""
-  ))
+function libraryError(value, source) {
+  const reference = value.node;
+  if (reference.type !== "TSTypeReference" || !libraryResult(reference, source))
     return null;
+  if (reference.typeArguments?.params.length !== 2) return null;
   const error = reference.typeArguments.params[1];
-  return error === void 0 ? null : weakError(view(error), source);
+  return error === void 0 ? null : weakError({ ...value, node: error, origin: error }, source);
+}
+function libraryResult(reference, source) {
+  return ["Result", "ResultAsync"].includes(
+    libraryName(reference.typeName, source, true) ?? ""
+  );
 }
 function libraryName(node, source, typeSpace) {
   const reference = libraryReference(node);
@@ -21886,15 +21911,18 @@ function libraryReference(node) {
     return { root: node.object, member: node.property.name };
   return null;
 }
-function weakAnnotation(node, source, depth = 0, budget = { remaining: MAX_TYPE_STEPS }) {
-  if (depth >= MAX_DEPTH || --budget.remaining < 0) return false;
-  if (failureMessages(view(node), source).length !== 0) return true;
-  if (node.type !== "TSTypeReference") return false;
-  if (libraryError(node, source) !== null) return true;
-  if (node.typeName.type !== "Identifier" || !["Promise", "PromiseLike"].includes(node.typeName.name) || typeBinding(source, node.typeName) !== null || node.typeArguments?.params.length !== 1)
-    return false;
-  const argument = node.typeArguments.params[0];
-  return argument !== void 0 && weakAnnotation(argument, source, depth + 1, budget);
+function returnedValues(node, depth = 0, budget = { remaining: MAX_TYPE_STEPS }) {
+  if (depth >= MAX_DEPTH || --budget.remaining < 0) return null;
+  const value = unwrapExpression(node);
+  if (value.type === "AwaitExpression")
+    return returnedValues(value.argument, depth + 1, budget);
+  if (value.type !== "ConditionalExpression") return [value];
+  const consequent = returnedValues(value.consequent, depth + 1, budget);
+  if (consequent === null) return null;
+  const alternate = returnedValues(value.alternate, depth + 1, budget);
+  if (alternate === null || consequent.length + alternate.length > MAX_VARIANTS)
+    return null;
+  return [...consequent, ...alternate];
 }
 function renderedFailure(node, source) {
   let value = unwrapExpression(node);
@@ -22017,9 +22045,7 @@ var prefer_coded_error_result_default = defineRule({
   createOnce(context) {
     const reported = /* @__PURE__ */ new Set();
     function check(node) {
-      const candidates2 = failureMessages(view(node), context.sourceCode);
-      const library = node.type === "TSTypeReference" ? libraryError(node, context.sourceCode) : null;
-      for (const candidate2 of library === null ? candidates2 : [...candidates2, library]) {
+      for (const candidate2 of outcomeFailures(view(node), context.sourceCode)) {
         if (reported.has(candidate2)) continue;
         reported.add(candidate2);
         context.report({
@@ -22030,13 +22056,19 @@ var prefer_coded_error_result_default = defineRule({
     }
     function checkProducer(owner, value) {
       if (owner === null) return;
-      const rendered = renderedFailure(value, context.sourceCode);
-      if (rendered === null || reported.has(rendered.node)) return;
+      const issues = (returnedValues(value) ?? []).flatMap((leaf) => {
+        const issue = renderedFailure(leaf, context.sourceCode);
+        return issue === null ? [] : [issue];
+      });
+      if (issues.length === 0) return;
       const contract = owner.returnType?.typeAnnotation;
-      if (contract !== void 0 && weakAnnotation(contract, context.sourceCode))
+      if (contract !== void 0 && outcomeFailures(view(contract), context.sourceCode).length !== 0)
         return;
-      reported.add(rendered.node);
-      context.report(rendered);
+      for (const issue of issues) {
+        if (reported.has(issue.node)) continue;
+        reported.add(issue.node);
+        context.report(issue);
+      }
     }
     return {
       before() {

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   src_default
-} from "./chunk-ZWOGM4CV.js";
+} from "./chunk-YWEV6GQM.js";
 export {
   src_default as default
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sarj/eslint-plugin",
-  "version": "19.10.0",
+  "version": "19.14.0",
   "packageManager": "npm@12.2.1",
   "description": "Custom Oxlint rules for hypermodern TypeScript / React / Next.js projects",
   "type": "module",