@blumintinc/eslint-plugin-blumint 1.20.169 → 1.20.170

package/lib/index.js

@@ -223,7 +223,7 @@ function noFrontendImportsFromFunctionsPatterns(pattern) {
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.20.169',
+        version: '1.20.170',
     },
     parseOptions: {
         ecmaVersion: 2020,

package/lib/rules/prefer-map-over-conditional-dispatch.js

@@ -28,8 +28,9 @@ const utils_1 = require("@typescript-eslint/utils");
 const ts = __importStar(require("typescript"));
 const createRule_1 = require("../utils/createRule");
 /**
- * Node types whose presence anywhere in a branch value means the value is NOT
- * safe to eager-evaluate inside a `Record` (all entries construct at once).
+ * Node types whose presence in a branch value — outside any function the value
+ * itself carries — means the value is NOT safe to eager-evaluate inside a
+ * `Record` (all entries construct at once).
  */
 const EAGER_UNSAFE_NODES = new Set([
     utils_1.AST_NODE_TYPES.CallExpression,
@@ -959,7 +960,28 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
             }
             return null;
         }
-        /** True when any node in the subtree is unsafe to eager-evaluate. */
+        /**
+         * True when any node in the subtree is unsafe to eager-evaluate.
+         *
+         * The walk stops at a function boundary, because what the `Record` literal
+         * evaluates per entry is the branch value itself, not what that value does
+         * when it is later invoked. A branch value that IS a function is already
+         * the thunk the report-only message asks for: its body runs on invocation,
+         * after the lookup, so a call inside it can no more fire per entry than a
+         * call inside any other uninvoked function. Scanning through the boundary
+         * declined every function-valued dispatch whose body did anything but
+         * arithmetic, and told the author to write the very shape they had (#2062).
+         *
+         * The boundary answers `await` too, and answers it correctly in both
+         * directions: an `await` is eager exactly when it is evaluated where the
+         * literal is built, so a top-level one still blocks, while one inside an
+         * `async` branch value — the only place it can legally appear inside a
+         * function — is suspended until that value is called.
+         *
+         * A class expression is deliberately not a boundary: its static
+         * initializers, static blocks and computed member names all run when the
+         * class definition is evaluated, which is per entry.
+         */
         function containsEagerUnsafe(node) {
             let found = false;
             const visit = (n) => {
@@ -974,6 +996,19 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
                     found = true;
                     return;
                 }
+                if (FUNCTION_TYPES.has(anyNode.type)) {
+                    // A parameter decorator is the one position inside a function that
+                    // does not wait for a call: it is evaluated with the enclosing class
+                    // definition, which the `Record` literal performs for every entry.
+                    for (const param of anyNode.params ?? []) {
+                        const decorators = param
+                            ?.decorators;
+                        for (const decorator of decorators ?? []) {
+                            visit(decorator);
+                        }
+                    }
+                    return;
+                }
                 for (const key of Object.keys(anyNode)) {
                     if (key === 'parent') {
                         continue;
@@ -1410,15 +1445,98 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
             }
         }
         /**
-         * The ternary's replacement, taking the host's line break with it when the
-         * shortened host fits on one line; null when only the expression itself
-         * should be replaced.
+         * The opening parenthesis the PARENT's own syntax puts in front of `node` —
+         * an `if`/`while`/`switch`/`with` head, a lone call or `new` argument, a
+         * `do…while` test, `import(...)`. Such a pair delimits the parent rather
+         * than grouping the expression, and dropping it does not parse.
+         *
+         * A call with more than one argument needs no entry: the token on one side
+         * of any argument is then a comma, so no pair is seen around it at all.
+         */
+        function parentSyntaxParen(node, parent) {
+            const parenAfter = (preceding) => sourceCode.getTokenAfter(preceding, {
+                filter: (token) => token.value === '(',
+            });
+            switch (parent.type) {
+                case utils_1.AST_NODE_TYPES.CallExpression:
+                case utils_1.AST_NODE_TYPES.NewExpression:
+                    return parent.arguments.length === 1 && parent.arguments[0] === node
+                        ? parenAfter(parent.callee)
+                        : null;
+                case utils_1.AST_NODE_TYPES.DoWhileStatement:
+                    return parent.test === node ? parenAfter(parent.body) : null;
+                case utils_1.AST_NODE_TYPES.IfStatement:
+                case utils_1.AST_NODE_TYPES.WhileStatement:
+                    return parent.test === node
+                        ? sourceCode.getFirstToken(parent, 1)
+                        : null;
+                case utils_1.AST_NODE_TYPES.SwitchStatement:
+                    return parent.discriminant === node
+                        ? sourceCode.getFirstToken(parent, 1)
+                        : null;
+                case utils_1.AST_NODE_TYPES.WithStatement:
+                    return parent.object === node
+                        ? sourceCode.getFirstToken(parent, 1)
+                        : null;
+                case utils_1.AST_NODE_TYPES.ImportExpression:
+                    return parent.source === node
+                        ? sourceCode.getFirstToken(parent, 1)
+                        : null;
+                default:
+                    return null;
+            }
+        }
+        /**
+         * The parentheses standing around `node` that the emitted lookup does not
+         * need — the outermost such pair, so a nested grouping goes with it.
+         *
+         * Precedence is a property of the REPLACEMENT text, not of the expression
+         * being replaced: a computed member access is the tightest-binding
+         * production there is, so no enclosing operator can require a pair around
+         * one. Parentheses a ternary genuinely needed (`(k === 'a' ? 1 : 2) > 0`
+         * parses differently without them) are therefore redundant the moment the
+         * lookup takes its place, and keeping them ships
+         * `if ((RESULT_BY_KIND[kind]) > 0)` — text the next `prettier --write`
+         * strips, so the fix is not a fixed point (#2063).
+         *
+         * Two pairs are not the expression's own grouping and stay: one the
+         * parent's syntax requires, and one a decorator requires, whose grammar
+         * admits no computed access at all (`@(cond)` cannot become `@X[k]`).
+         */
+        function redundantParens(node) {
+            const parent = node.parent;
+            if (!parent || parent.type === utils_1.AST_NODE_TYPES.Decorator) {
+                return null;
+            }
+            const syntaxParen = parentSyntaxParen(node, parent);
+            let pair = null;
+            let open = sourceCode.getTokenBefore(node);
+            let close = sourceCode.getTokenAfter(node);
+            while (open !== null &&
+                close !== null &&
+                open !== syntaxParen &&
+                open.type === utils_1.AST_TOKEN_TYPES.Punctuator &&
+                open.value === '(' &&
+                close.type === utils_1.AST_TOKEN_TYPES.Punctuator &&
+                close.value === ')') {
+                pair = { open, close };
+                open = sourceCode.getTokenBefore(open);
+                close = sourceCode.getTokenAfter(close);
+            }
+            return pair;
+        }
+        /**
+         * The ternary's replacement, widened over text the lookup makes redundant —
+         * the parentheses that used to bind the conditional, and the host's line
+         * break when the shortened host fits on one line; null when only the
+         * expression itself should be replaced.
          *
          * The break exists only because the ternary used to be wide; a lookup is
          * short, and Prettier answers the shortened host by joining it back onto one
          * line (#2060). This is the mirror of measuring an inserted head: the fixer
          * SHORTENS, so every line it writes is well inside the width and nothing
-         * about the emitted text reveals the stale wrap.
+         * about the emitted text reveals the stale wrap — which is equally true of
+         * the stale parentheses (#2063).
          *
          * Measure, do not always-join: a host that is over-width for a reason the
          * ternary never caused — a long binding name, a wide type annotation —
@@ -1429,9 +1547,28 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
             if (!parent) {
                 return null;
             }
-            const edit = absorbedOperatorWrap(node, parent, lookupText) ??
-                absorbedArgumentWrap(node, parent, lookupText);
-            return edit !== null && absorbsComment(node, edit) ? null : edit;
+            const parens = redundantParens(node);
+            const span = {
+                node,
+                left: parens?.open ?? node,
+                right: parens?.close ?? node,
+            };
+            const parenEdit = parens === null
+                ? null
+                : {
+                    range: [parens.open.range[0], parens.close.range[1]],
+                    text: lookupText,
+                };
+            // Widest first: a host join is measured from the parentheses' outer
+            // edges, so where one applies it already carries the paren widening. A
+            // candidate whose span would delete a comment steps down to the next,
+            // narrower one rather than withholding the conversion.
+            const candidates = [
+                absorbedOperatorWrap(span, parent, lookupText),
+                absorbedArgumentWrap(span, parent, lookupText),
+                parenEdit,
+            ];
+            return (candidates.find((edit) => edit !== null && !absorbsComment(node, edit)) ?? null);
         }
         /**
          * Whether the margins an absorbing edit adds around `node` hold a comment.
@@ -1447,6 +1584,11 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
          * declining there would cost the join and save nothing. The join is a layout
          * optimization, so dropping it and replacing the expression in place keeps
          * both the conversion and the comment.
+         *
+         * Measured against the reported node whatever the edit spans, this is the
+         * single gate for every widening: the parenthesis absorption (#2063) adds
+         * exactly such a margin, and a comment written between a parenthesis and the
+         * expression it groups sits in it.
          */
         function absorbsComment(node, edit) {
             return sourceCode
@@ -1457,35 +1599,39 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
                     comment.range[0] < edit.range[1]));
         }
         /** The join for a host that broke after `=` / `:` (see `absorbedLookupEdit`). */
-        function absorbedOperatorWrap(node, parent, lookupText) {
+        function absorbedOperatorWrap(span, parent, lookupText) {
             if (!WRAP_ABSORBING_PARENTS.has(parent.type) ||
-                !isWrapAbsorbingPosition(node, parent)) {
+                !isWrapAbsorbingPosition(span.node, parent)) {
                 return null;
             }
-            const prevToken = sourceCode.getTokenBefore(node);
-            if (!prevToken || prevToken.loc.end.line === node.loc.start.line) {
+            const prevToken = sourceCode.getTokenBefore(span.left);
+            if (!prevToken || prevToken.loc.end.line === span.left.loc.start.line) {
                 return null;
             }
             // Joining across a comment would pull the lookup onto a `//` line, which
             // comments the value out.
-            if (sourceCode.getCommentsBefore(node).length > 0) {
+            if (sourceCode.getCommentsBefore(span.left).length > 0) {
                 return null;
             }
             const headLine = sourceCode.lines[prevToken.loc.end.line - 1] ?? '';
             if (headLine.slice(prevToken.loc.end.column).trim() !== '') {
                 return null;
             }
-            const tailLine = sourceCode.lines[node.loc.end.line - 1] ?? '';
-            const tail = tailLine.slice(node.loc.end.column).trimEnd();
-            // Anything after the expression beyond its own terminator (a closing
-            // paren, a trailing comment) means joining does not produce one line.
+            const tailLine = sourceCode.lines[span.right.loc.end.line - 1] ?? '';
+            const tail = tailLine.slice(span.right.loc.end.column).trimEnd();
+            // Anything after the span beyond its own terminator (a closing paren the
+            // span does not own, a trailing comment) means joining does not produce
+            // one line.
             if (!/^[,;]?$/.test(tail)) {
                 return null;
             }
             const head = headLine.slice(0, prevToken.loc.end.column);
             const joined = `${head} ${lookupText}${tail}`;
             return joined.length <= printWidth
-                ? { range: [prevToken.range[1], node.range[1]], text: ` ${lookupText}` }
+                ? {
+                    range: [prevToken.range[1], span.right.range[1]],
+                    text: ` ${lookupText}`,
+                }
                 : null;
         }
         /**
@@ -1494,14 +1640,14 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
          * them — is what makes the shortened call a fixed point; keeping the comma
          * would leave `render(RESULT[x],);`, which Prettier rewrites again.
          */
-        function absorbedArgumentWrap(node, parent, lookupText) {
+        function absorbedArgumentWrap(span, parent, lookupText) {
             if ((parent.type !== utils_1.AST_NODE_TYPES.CallExpression &&
                 parent.type !== utils_1.AST_NODE_TYPES.NewExpression) ||
                 parent.arguments.length !== 1 ||
-                parent.arguments[0] !== node) {
+                parent.arguments[0] !== span.node) {
                 return null;
             }
-            const openParen = sourceCode.getTokenBefore(node);
+            const openParen = sourceCode.getTokenBefore(span.left);
             const closeParen = sourceCode.getLastToken(parent);
             if (!openParen ||
                 !closeParen ||
@@ -1510,18 +1656,18 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
                 openParen.loc.end.line === closeParen.loc.start.line) {
                 return null;
             }
-            // The argument's own parentheses would otherwise be swallowed: the token
-            // trail from the expression to the call's closer must hold nothing but
-            // Prettier's dangling comma.
-            const afterNode = sourceCode.getTokenAfter(node);
+            // Parentheses the span does not own would otherwise be swallowed: the
+            // token trail from the span's right edge to the call's closer must hold
+            // nothing but Prettier's dangling comma.
+            const afterNode = sourceCode.getTokenAfter(span.right);
             const afterComma = afterNode && afterNode.value === ','
                 ? sourceCode.getTokenAfter(afterNode)
                 : afterNode;
             if (afterComma !== closeParen) {
                 return null;
             }
-            if (sourceCode.getCommentsBefore(node).length > 0 ||
-                sourceCode.getCommentsAfter(node).length > 0) {
+            if (sourceCode.getCommentsBefore(span.left).length > 0 ||
+                sourceCode.getCommentsAfter(span.right).length > 0) {
                 return null;
             }
             const headLine = sourceCode.lines[openParen.loc.end.line - 1] ?? '';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "1.20.169",
+  "version": "1.20.170",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",

package/release-manifest.json

@@ -1,4 +1,19 @@
 [
+  {
+    "version": "1.20.170",
+    "date": "2026-08-19T23:48:20.873Z",
+    "rules": [
+      {
+        "name": "prefer-map-over-conditional-dispatch",
+        "changeType": "fix",
+        "issues": [
+          2062,
+          2063
+        ],
+        "summary": "drop the parentheses the replaced ternary needed (closes #2063); stop the eager-call scan at function boundaries (closes #2062)"
+      }
+    ]
+  },
   {
     "version": "1.20.169",
     "date": "2026-08-19T20:16:38.161Z",