@blumintinc/eslint-plugin-blumint 1.20.174 → 1.20.175

package/lib/index.js

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

package/lib/rules/enforce-firestore-set-merge.js

@@ -647,9 +647,9 @@ exports.enforceFirestoreSetMerge = (0, createRule_1.createRule)({
          * inline there emits text the formatter immediately re-breaks, so the fix
          * is never a fixed point of the consumer's own formatting pass (#2097).
          *
-         * A list written across lines answers the first half outright: this fixer
-         * never rewrites an argument's own text, so the flat layout is not among
-         * the shapes it could emit at all.
+         * A list written across lines answers the first half outright and is
+         * handled before this is asked: the caller keeps it broken, except for
+         * the block-comment tail {@link flattenedListFixes} claims (#2142).
          *
          * The width half is answered only where the formatter's own answer is
          * modelled end to end. A trailing options object gets hugged against the
@@ -683,17 +683,93 @@ exports.enforceFirestoreSetMerge = (0, createRule_1.createRule)({
             const widest = Math.max(...spans.map((span) => span.end - span.start), ...appended.map((argument) => argument.length));
             return body + widest + ','.length <= PRINT_WIDTH;
         }
+        /**
+         * The width the call prints at with its argument list riding one line:
+         * everything on the opening line through the parenthesis, each span
+         * joined by `, `, the tail comments a written comma strands outside the
+         * last span, the appended arguments, and whatever follows the closing
+         * parenthesis on its own line.
+         */
+        function flatListWidth(layout, appended, nameDelta, gapComments) {
+            const { openParen, closeParen, spans } = layout;
+            const lastSpanEnd = spans[spans.length - 1].end;
+            const suffix = (sourceCode.lines[closeParen.loc.start.line - 1] ?? '')
+                .slice(closeParen.loc.start.column)
+                .trimEnd();
+            return (openParen.loc.end.column +
+                nameDelta +
+                spans.reduce((width, span) => width + (span.end - span.start), 0) +
+                (spans.length - 1) * ', '.length +
+                gapComments
+                    .filter((comment) => comment.range[0] >= lastSpanEnd)
+                    .reduce((width, comment) => width + ' '.length + (comment.range[1] - comment.range[0]), 0) +
+                appended.reduce((width, argument) => width + ', '.length + argument.length, 0) +
+                suffix.length);
+        }
+        /**
+         * The edits that print an authored-broken list flat, with `appended` on
+         * its tail — or `null` where the flat layout is out of reach or out of
+         * scope.
+         *
+         * A list written across lines usually stays broken: a multi-line argument
+         * cannot be inlined without rewriting its text, and a line comment pins
+         * its break outright. A break held up by nothing but a BLOCK comment
+         * trailing the last argument is neither — a block comment is no line
+         * terminator, so the consumer's formatter collapses the whole call as
+         * soon as it fits the print width, and no broken emission is a fixed
+         * point of its formatting pass there (#2142). Only that annotated tail
+         * claims the flat layout; elsewhere the author's breaks are kept — a
+         * choice the formatter may fold, but one this fix did not create.
+         */
+        function flattenedListFixes(fixer, node, layout, appended, nameDelta, beforeClose, gapComments, ownLineComments) {
+            const { openParen, closeParen, spans } = layout;
+            if (gapComments.length === 0 ||
+                ownLineComments.length > 0 ||
+                gapComments.some(replacementSegments_1.requiresOwnLine) ||
+                calleeBreaksFirst(node.callee) ||
+                spans.some((span) => sourceCode.text.slice(span.start, span.end).includes('\n')) ||
+                flatListWidth(layout, appended, nameDelta, gapComments) > PRINT_WIDTH) {
+                return null;
+            }
+            const fixes = [
+                fixer.replaceTextRange([openParen.range[1], spans[0].start], ''),
+            ];
+            for (let index = 1; index < spans.length; index++) {
+                fixes.push(fixer.replaceTextRange([spans[index - 1].end, spans[index].start], ', '));
+            }
+            const lastSpanEnd = spans[spans.length - 1].end;
+            const flatTail = appended.map((argument) => `, ${argument}`).join('');
+            if (beforeClose.value !== ',') {
+                // With no written comma the tail comments sit inside the last span,
+                // so everything between the span and the parenthesis is whitespace.
+                fixes.push(fixer.replaceTextRange([lastSpanEnd, closeParen.range[0]], flatTail));
+                return fixes;
+            }
+            const pastComma = gapComments.filter((comment) => comment.range[0] >= beforeClose.range[1]);
+            if (pastComma.length === 0) {
+                // The written comma already trails the annotation; it is the
+                // separator the appended arguments ride on.
+                fixes.push(fixer.replaceTextRange([beforeClose.range[1], closeParen.range[0]], ` ${appended.join(', ')}`));
+                return fixes;
+            }
+            // The written comma moves past the comments it precedes: prettier
+            // prints a block comment on a list element BEFORE the separator.
+            fixes.push(fixer.removeRange(beforeClose.range));
+            fixes.push(fixer.replaceTextRange([pastComma[pastComma.length - 1].range[1], closeParen.range[0]], flatTail));
+            return fixes;
+        }
         /**
          * The edits that add `appended` to the end of a call's argument list, laid
          * out the way the consumer's formatter prints the result — or `null` for
          * the one tail no edit can extend without retargeting a directive.
          *
-         * Neither layout re-emits an argument from its text. The broken one
-         * rewrites the SEPARATORS between the arguments and shifts the indentation
-         * of the ones that span lines, so everything between them — comments
-         * included, and a dropped `eslint-disable` silently re-enables the rule it
-         * was suppressing (#1877) — stays where it was written, attached to the
-         * argument it belongs to.
+         * No layout re-emits an argument from its text. The broken one rewrites
+         * the SEPARATORS between the arguments and shifts the indentation of the
+         * ones that span lines, and the flat one rewrites the separators alone,
+         * so everything between them — comments included, and a dropped
+         * `eslint-disable` silently re-enables the rule it was suppressing
+         * (#1877) — stays where it was written, attached to the argument it
+         * belongs to.
          *
          * `nameDelta` is how much the caller's own rename widens the call, since
          * the two edits land on the same line and the width answer is about the
@@ -705,10 +781,17 @@ exports.enforceFirestoreSetMerge = (0, createRule_1.createRule)({
                 fixer.insertTextAfter(args[args.length - 1], appended.map((argument) => `, ${argument}`).join('')),
             ];
             const layout = callLayout(node);
-            if (!layout || !requiresBrokenList(node, layout, appended, nameDelta)) {
+            if (!layout) {
                 return inline();
             }
             const { openParen, closeParen, spans } = layout;
+            const listSpansLines = sourceCode.text
+                .slice(openParen.range[1], closeParen.range[0])
+                .includes('\n');
+            if (!listSpansLines &&
+                !requiresBrokenList(node, layout, appended, nameDelta)) {
+                return inline();
+            }
             // Between the last argument's own last token and the closing parenthesis
             // sit the trailing comma, if one was written, and any comment. The tail
             // SPAN absorbs such a comment whenever no comma follows it, so the span's
@@ -739,6 +822,12 @@ exports.enforceFirestoreSetMerge = (0, createRule_1.createRule)({
             if (sameLineComments.some(isPositionalDirective)) {
                 return null;
             }
+            if (listSpansLines) {
+                const flattened = flattenedListFixes(fixer, node, layout, appended, nameDelta, beforeClose, gapComments, ownLineComments);
+                if (flattened) {
+                    return flattened;
+                }
+            }
             // A broken list is indented one step past the line its parenthesis opens
             // on, whatever depth that line sits at, and closes at that line's own
             // column. A constant indent is right for exactly one call site.
@@ -769,18 +858,34 @@ exports.enforceFirestoreSetMerge = (0, createRule_1.createRule)({
             }
             const separatorPresent = beforeClose.value === ',';
             const lastSameLine = sameLineComments[sameLineComments.length - 1];
+            // WHERE the separator sits among the trailing comments is the
+            // formatter's call, not a constant: prettier prints a line comment on a
+            // list element after the comma and a block comment before it (#2142).
+            // The comma therefore lands past the leading run of block comments — at
+            // the argument's own last token when that run is empty — and a comma
+            // the author wrote on the wrong side of the run is moved rather than
+            // doubled. Everything else in the annotation is left byte for byte as
+            // written.
+            let blockRunEnd = lastArgumentToken.range[1];
+            for (const comment of sameLineComments) {
+                if ((0, replacementSegments_1.requiresLineBreakAfter)(comment)) {
+                    break;
+                }
+                blockRunEnd = comment.range[1];
+            }
+            const commaMisplaced = separatorPresent && beforeClose.range[1] < blockRunEnd;
+            const needsComma = !separatorPresent || commaMisplaced;
+            if (commaMisplaced) {
+                fixes.push(fixer.removeRange(beforeClose.range));
+            }
             if (ownLineComments.length === 0) {
                 // The comment trails the argument it annotates, so it keeps that line
-                // and the option opens the next one. The separator has to sit between
-                // the argument and the comment — after a line comment it is comment
-                // text — so one is inserted at the argument's own last token unless
-                // the author already wrote it, and everything through the end of the
-                // annotation is left byte for byte as written.
-                if (!separatorPresent) {
-                    fixes.push(fixer.insertTextAfter(lastArgumentToken, ','));
-                }
+                // and the option opens the next one.
                 const annotationEnd = Math.max(lastSameLine.range[1], beforeClose.range[1]);
-                fixes.push(fixer.replaceTextRange([annotationEnd, closeParen.range[0]], `${appended
+                if (needsComma && blockRunEnd < annotationEnd) {
+                    fixes.push(fixer.insertTextAfterRange([blockRunEnd, blockRunEnd], ','));
+                }
+                fixes.push(fixer.replaceTextRange([annotationEnd, closeParen.range[0]], `${needsComma && blockRunEnd >= annotationEnd ? ',' : ''}${appended
                     .map((argument) => `\n${body}${argument},`)
                     .join('')}\n${indent}`));
                 return fixes;
@@ -792,16 +897,20 @@ exports.enforceFirestoreSetMerge = (0, createRule_1.createRule)({
             const appendedText = appended
                 .map((argument) => `\n${body}${argument},`)
                 .join('');
-            const anchor = Math.max(separatorPresent ? beforeClose.range[1] : lastArgumentToken.range[1], lastSameLine ? lastSameLine.range[1] : 0);
-            if (separatorPresent || lastSameLine) {
-                if (!separatorPresent) {
-                    fixes.push(fixer.insertTextAfter(lastArgumentToken, ','));
-                }
+            const anchor = Math.max(separatorPresent && !commaMisplaced
+                ? beforeClose.range[1]
+                : lastArgumentToken.range[1], lastSameLine ? lastSameLine.range[1] : 0);
+            if (!needsComma) {
+                fixes.push(fixer.insertTextAfterRange([anchor, anchor], appendedText));
+                return fixes;
+            }
+            if (blockRunEnd < anchor) {
+                fixes.push(fixer.insertTextAfterRange([blockRunEnd, blockRunEnd], ','));
                 fixes.push(fixer.insertTextAfterRange([anchor, anchor], appendedText));
                 return fixes;
             }
-            // With neither a comma nor a trailing comment, the separator and the
-            // option travel as one insertion, since both land at the same offset.
+            // With the separator due at the annotation's own end, it and the option
+            // travel as one insertion, since both land at the same offset.
             fixes.push(fixer.insertTextAfterRange([anchor, anchor], `,${appendedText}`));
             return fixes;
         }

package/lib/rules/prefer-nullish-coalescing-boolean-props.js

@@ -883,14 +883,19 @@ function chainComments(node, sourceCode, operands) {
  * inside an operand's own brackets — a line comment in an object literal passed
  * to a call — belongs to that operand's layout and leaves the chain's own layout
  * alone, which is how prettier prints it.
+ *
+ * `absorbed` holds the comments the rewrite carries out past the statement's
+ * closing punctuator: those sit in no gap of the emitted chain, so counting one
+ * as a break would split a group that ends up holding no comment at all
+ * (#2141).
  */
-function chainBreaksLine(node, sourceCode) {
+function chainBreaksLine(node, sourceCode, absorbed) {
     if (node.type !== utils_1.AST_NODE_TYPES.LogicalExpression) {
         return false;
     }
-    return (strandedComments(node, sourceCode).some(replacementSegments_1.requiresLineBreakAfter) ||
-        chainBreaksLine(node.left, sourceCode) ||
-        chainBreaksLine(node.right, sourceCode));
+    return (strandedComments(node, sourceCode).some((comment) => !absorbed.has(comment) && (0, replacementSegments_1.requiresLineBreakAfter)(comment)) ||
+        chainBreaksLine(node.left, sourceCode, absorbed) ||
+        chainBreaksLine(node.right, sourceCode, absorbed));
 }
 /**
  * Whether the chain a link belongs to breaks the line, asked of the whole chain
@@ -902,12 +907,16 @@ function chainBreaksLine(node, sourceCode) {
  * broken packs two operands onto a line the formatter then splits (#2106).
  *
  * A comment trailing the chain, or leading it, is outside every gap: prettier
- * prints it on the line the chain already occupies and moves no operand.
+ * prints it on the line the chain already occupies and moves no operand. The
+ * same goes for a comment in `absorbed` — one the fix carries out past the
+ * statement's closing punctuator: wherever the INPUT held it, the emission
+ * holds it behind the statement, outside every gap (#2141).
  */
-function chainBreaksAtAGap(chain, sourceCode) {
+function chainBreaksAtAGap(chain, sourceCode, absorbed) {
     const operands = chainOperands(chain);
     const { gaps } = chainComments(chain, sourceCode, operands);
-    return (gaps.some((gap) => [...gap.beforeOperator, ...gap.afterOperator].some(replacementSegments_1.requiresLineBreakAfter)) || operands.some((operand) => chainBreaksLine(operand, sourceCode)));
+    return (gaps.some((gap) => [...gap.beforeOperator, ...gap.afterOperator].some((comment) => !absorbed.has(comment) && (0, replacementSegments_1.requiresLineBreakAfter)(comment))) ||
+        operands.some((operand) => chainBreaksLine(operand, sourceCode, absorbed)));
 }
 /**
  * The depths the rebuilt expression lands at.
@@ -1196,6 +1205,36 @@ exports.preferNullishCoalescingBooleanProps = (0, createRule_1.createRule)({
                                     });
                                 });
                                 segments.push(...comments.trailing.map(toSegment));
+                                // A comment trailing the whole expression rides out past the
+                                // punctuator that closes the statement the chain stands in,
+                                // where one is available to take over. Kept inside the
+                                // replacement, the line break such a comment demands strands
+                                // that punctuator on a line of its own — layout a formatter
+                                // folds straight back, and the fold moves an
+                                // `eslint-disable-next-line` written on the comment's line
+                                // onto a different subject, so the pipeline's formatting order
+                                // decides which violations are enforced (#2139). The span this
+                                // fix replaces can end PAST the node, at a redundant paren the
+                                // widening claims, so the lookup anchors on that paren where
+                                // the widening applies: asked of the node, it answers with the
+                                // paren — a token inside the span — instead of the punctuator
+                                // behind it. The landing widening reaches BACKWARD from the
+                                // node and never past its end, so everywhere else the span
+                                // ends at the node's own last token. The parenthesized
+                                // (selfParens) replacement keeps every comment inside the
+                                // emitted parens, where no punctuator can be stranded.
+                                const spanEndToken = redundantParens(node, sourceCode)
+                                    ? sourceCode.getTokenAfter(node)
+                                    : sourceCode.getLastToken(node);
+                                const closingPunctuator = !selfParens && comments.trailing.length > 0 && spanEndToken
+                                    ? (0, replacementSegments_1.absorbableClosingPunctuator)(sourceCode, spanEndToken, comments.trailing)
+                                    : null;
+                                // The absorption is decided BEFORE the break decision because
+                                // a comment carried past the punctuator sits in no gap of the
+                                // emitted chain: counted as a break it would put every operand
+                                // on a line of its own for a comment that no longer sits
+                                // between any of them (#2141).
+                                const absorbed = new Set(closingPunctuator ? comments.trailing : []);
                                 // Prettier prints a logical chain as ONE group: once anything
                                 // inside it breaks the line, EVERY operand takes a line of its
                                 // own. So a chain broken by a comment anywhere gets a break in
@@ -1204,7 +1243,7 @@ exports.preferNullishCoalescingBooleanProps = (0, createRule_1.createRule)({
                                 // The break rides on the last thing in the gap so a carried
                                 // comment keeps the line it was written on, and a gap already
                                 // holding a break needs no second separator.
-                                const chainBreaks = chainBreaksAtAGap(chainRootOf(node), sourceCode);
+                                const chainBreaks = chainBreaksAtAGap(chainRootOf(node), sourceCode, absorbed);
                                 if (chainBreaks) {
                                     for (const { start, end } of gapSpans) {
                                         const separated = segments
@@ -1236,26 +1275,6 @@ exports.preferNullishCoalescingBooleanProps = (0, createRule_1.createRule)({
                                     : null;
                                 const leading = landing ? `\n${bodyIndent}` : '';
                                 const range = replacementRange(node, sourceCode, landing);
-                                // A comment trailing the whole expression rides out past the
-                                // punctuator that closes the statement the chain stands in,
-                                // where one is available to take over. Kept inside the
-                                // replacement, the line break such a comment demands strands
-                                // that punctuator on a line of its own — layout a formatter
-                                // folds straight back, and the fold moves an
-                                // `eslint-disable-next-line` written on the comment's line
-                                // onto a different subject, so the pipeline's formatting order
-                                // decides which violations are enforced (#2139). The span this
-                                // fix replaces can end PAST the node, at a redundant paren the
-                                // widening claims, so the lookup anchors on the span's own
-                                // last token: asked of the node, it answers with that paren —
-                                // a token inside the span — instead of the punctuator behind
-                                // it.
-                                const spanEndToken = range[1] > node.range[1]
-                                    ? sourceCode.getTokenAfter(node)
-                                    : sourceCode.getLastToken(node);
-                                const closingPunctuator = comments.trailing.length > 0 && spanEndToken
-                                    ? (0, replacementSegments_1.absorbableClosingPunctuator)(sourceCode, spanEndToken, comments.trailing)
-                                    : null;
                                 const bodySegments = closingPunctuator
                                     ? segments.slice(0, segments.length - comments.trailing.length)
                                     : segments;

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,26 @@
 [
+  {
+    "version": "1.20.175",
+    "date": "2026-08-26T06:19:14.998Z",
+    "rules": [
+      {
+        "name": "enforce-firestore-set-merge",
+        "changeType": "fix",
+        "issues": [
+          2142
+        ],
+        "summary": "place a block comment before the separator and fold a list that fits (closes #2142)"
+      },
+      {
+        "name": "prefer-nullish-coalescing-boolean-props",
+        "changeType": "fix",
+        "issues": [
+          2141
+        ],
+        "summary": "discount an absorbed comment from the chain-break decision (closes #2141)"
+      }
+    ]
+  },
   {
     "version": "1.20.174",
     "date": "2026-08-26T04:47:21.242Z",