@fjall/eslint-plugin 2.23.0 → 2.24.0

package/mask-error-message-at-boundary.js

@@ -9,6 +9,13 @@
  *   - `<expr>.error.reason` / `<expr>.error?.reason`
  *   - `<bareErrorBinding>.message` / `.reason` where the binding name is
  *     `err`, `error`, `cause`, or `rejection` (common error-handler param)
+ *   - `<anyBinding>.message` inside a ConditionalExpression branch whose test
+ *     proves error-ness name-independently: the consequent of
+ *     `X instanceof Error ? X.message : …` (RHS: any Identifier matching
+ *     /Error$/ — `Error` itself or a custom ctor), or
+ *     the alternate of `!(X instanceof Error) ? … : X.message`. The
+ *     same-identifier requirement between test and leaf is strict, and the
+ *     check is AST-local (no interprocedural inference).
  *   - `<expr>.reason` (Promise rejection / settled-result shape)
  *   - `<expr>.error` / `<expr>.errorMessage` — server-error envelope reads.
  *     The webapp's JSON failure shape is `{ error: string }` or
@@ -325,6 +332,14 @@ function classifyErrorLeaf(node, context) {
       return { label: `${object.name}.${propName}`, shape: "strict" };
     }
 
+    if (
+      propName === "message" &&
+      object.type === "Identifier" &&
+      isInInstanceofProvenErrorBranch(node, object.name)
+    ) {
+      return { label: `${object.name}.message`, shape: "strict" };
+    }
+
     if (propName === "reason" && object.type === "Identifier") {
       return { label: `${object.name}.reason`, shape: "strict" };
     }
@@ -386,6 +401,62 @@ function classifyErrorLeaf(node, context) {
   return null;
 }
 
+/**
+ * True when `node` (an `X.message` MemberExpression, `X` an Identifier named
+ * `bindingName`) sits in a ConditionalExpression branch whose test proves
+ * `X instanceof Error`: the consequent of `X instanceof Error ? … : …`, or
+ * the alternate of `!(X instanceof Error) ? … : …`. The instanceof test
+ * proves error-ness name-independently, so bindings outside
+ * ERROR_BINDING_NAMES qualify. The identifier match between test and leaf is
+ * strict; the walk is AST-local and stops at function boundaries. A leaf in
+ * a ternary TEST position never qualifies (boolean check, not value flow).
+ */
+function isInInstanceofProvenErrorBranch(node, bindingName) {
+  let child = node;
+  let parent = node.parent;
+  while (parent) {
+    if (
+      parent.type === "FunctionDeclaration" ||
+      parent.type === "FunctionExpression" ||
+      parent.type === "ArrowFunctionExpression" ||
+      parent.type === "Program"
+    ) {
+      return false;
+    }
+    if (parent.type === "ConditionalExpression") {
+      if (parent.test === child) return false;
+      if (
+        parent.consequent === child &&
+        isInstanceofErrorTest(parent.test, bindingName)
+      ) {
+        return true;
+      }
+      if (
+        parent.alternate === child &&
+        parent.test.type === "UnaryExpression" &&
+        parent.test.operator === "!" &&
+        isInstanceofErrorTest(parent.test.argument, bindingName)
+      ) {
+        return true;
+      }
+    }
+    child = parent;
+    parent = parent.parent;
+  }
+  return false;
+}
+
+function isInstanceofErrorTest(test, bindingName) {
+  return (
+    test.type === "BinaryExpression" &&
+    test.operator === "instanceof" &&
+    test.left.type === "Identifier" &&
+    test.left.name === bindingName &&
+    test.right.type === "Identifier" &&
+    CUSTOM_ERROR_CTOR_RE.test(test.right.name)
+  );
+}
+
 /**
  * Returns true when `objectNode` is an Identifier bound from a
  * `<schema>.safeParse(...)` call. `parsed.error` in that shape is a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fjall/eslint-plugin",
-  "version": "2.23.0",
+  "version": "2.24.0",
   "description": "ESLint plugin with Fjall-specific coding standard rules",
   "type": "module",
   "main": "index.js",
@@ -32,5 +32,5 @@
     "vitest": "^4.1.5"
   },
   "license": "SEE LICENSE IN LICENSE",
-  "gitHead": "dadd84e6118f03252877974eec755e812cb5b42f"
+  "gitHead": "616d7af846f0eebfa3409f5f47c98fbee836bad9"
 }