@blumintinc/eslint-plugin-blumint 1.20.174 → 1.20.176

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.176',
     },
     parseOptions: {
         ecmaVersion: 2020,

package/lib/rules/enforce-assert-safe-object-key.js

@@ -1302,11 +1302,18 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
          * position the author wrote it, and hands assertSafe what it produces — the
          * rewrite adds a validation, it does not move a dereference.
          *
-         * A key written without a wrapper keeps the narrower argument the fix has
-         * always emitted: `String(id)` and `` `${id}` `` collapse to `id`, whose
-         * conversion assertSafe subsumes.
+         * A coercion the author wrote is part of the key, so it is wrapped rather
+         * than replaced: `assertSafe(String(id))` and ``assertSafe(`${id}`)``, not
+         * `assertSafe(id)`. assertSafe VALIDATES a key, it does not coerce one —
+         * it throws on any argument whose `typeof` is neither `string` nor
+         * `number` — so dropping the `String()` call or the template hands it the
+         * raw operand and changes what the key evaluates to. A boolean operand
+         * turns a working `` record[`${flag}`] `` lookup into a throw (#2144).
+         * Wrapping the key exactly as written is also what makes the sole
+         * substitution behave like every other template: `` `${a}${b}` `` has
+         * always been wrapped whole.
          */
-        const reportWrittenKey = (written, unwrapped, innerText) => reportUseAssertSafe(written, written === unwrapped ? innerText : context.sourceCode.getText(written));
+        const reportWrittenKey = (written) => reportUseAssertSafe(written, context.sourceCode.getText(written));
         /**
          * Returns true when the identifier was initialized directly from an
          * assertSafe(...) call, e.g. `const safeKey = assertSafe(rawKey)`.
@@ -1830,9 +1837,7 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                     if (key.type === utils_1.AST_NODE_TYPES.CallExpression &&
                         key.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
                         key.callee.name === 'String') {
-                        const arg = key.arguments[0];
-                        const argText = context.sourceCode.getText(arg);
-                        reportWrittenKey(written, key, argText);
+                        reportWrittenKey(written);
                     }
                     // Check for template literals like `${id}`
                     if (key.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
@@ -1840,9 +1845,7 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                         key.quasis.length === 2 &&
                         key.quasis[0].value.raw === '' &&
                         key.quasis[1].value.raw === '') {
-                        const expr = key.expressions[0];
-                        const exprText = context.sourceCode.getText(expr);
-                        reportWrittenKey(written, key, exprText);
+                        reportWrittenKey(written);
                     }
                 }
             },
@@ -1855,9 +1858,7 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                     if (left.type === utils_1.AST_NODE_TYPES.CallExpression &&
                         left.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
                         left.callee.name === 'String') {
-                        const arg = left.arguments[0];
-                        const argText = context.sourceCode.getText(arg);
-                        reportWrittenKey(written, left, argText);
+                        reportWrittenKey(written);
                     }
                     // Check for template literals like `${id}`
                     if (left.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
@@ -1865,9 +1866,7 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                         left.quasis.length === 2 &&
                         left.quasis[0].value.raw === '' &&
                         left.quasis[1].value.raw === '') {
-                        const expr = left.expressions[0];
-                        const exprText = context.sourceCode.getText(expr);
-                        reportWrittenKey(written, left, exprText);
+                        reportWrittenKey(written);
                     }
                 }
             },
@@ -1909,9 +1908,7 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                     if (property.type === utils_1.AST_NODE_TYPES.CallExpression &&
                         property.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
                         property.callee.name === 'String') {
-                        const arg = property.arguments[0];
-                        const argText = context.sourceCode.getText(arg);
-                        reportWrittenKey(written, property, argText);
+                        reportWrittenKey(written);
                         return;
                     }
                     // Check for template literals
@@ -1935,19 +1932,14 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                         if (!reachesPrototype) {
                             return;
                         }
-                        // `${id}` alone is the whole key, so the remedy names the inner
-                        // expression and the fix wraps it directly. A template carrying
-                        // fixed text has no such inner key — the string it builds is the
-                        // key — so that whole template is what gets wrapped, which is the
-                        // shape the docs show for `assertSafe(`${id}_suffix`)`.
-                        const isSimpleVarInterpolation = property.expressions.length === 1 &&
-                            property.quasis.length === 2 &&
-                            property.quasis[0].value.raw === '' &&
-                            property.quasis[1].value.raw === '';
-                        const unwrapped = isSimpleVarInterpolation
-                            ? property.expressions[0]
-                            : property;
-                        reportWrittenKey(written, property, context.sourceCode.getText(unwrapped));
+                        // The string the template builds is the key, whether it carries
+                        // fixed text or is a lone substitution, so the whole template is
+                        // what gets wrapped — the shape the docs show for
+                        // `assertSafe(`${id}_suffix`)`. Reaching inside for `${id}` would
+                        // hand assertSafe the operand instead of the string the operand
+                        // widens to, and assertSafe throws on anything that is not already
+                        // a string or a number (#2144).
+                        reportWrittenKey(written);
                         return;
                     }
                     // Check for direct variable usage (identifiers)
@@ -1971,8 +1963,7 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                         if (isCompilerBoundedLookup(node, property)) {
                             return;
                         }
-                        const propText = context.sourceCode.getText(property);
-                        reportWrittenKey(written, property, propText);
+                        reportWrittenKey(written);
                         return;
                     }
                     // Check for binary expressions (like index + 1)
@@ -1981,8 +1972,7 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                         if (isLikelyArray) {
                             return;
                         }
-                        const propText = context.sourceCode.getText(property);
-                        reportWrittenKey(written, property, propText);
+                        reportWrittenKey(written);
                         return;
                     }
                     // Check for boolean expressions and other literals
@@ -1993,8 +1983,7 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                         if (isLikelyArray) {
                             return;
                         }
-                        const propText = context.sourceCode.getText(property);
-                        reportWrittenKey(written, property, propText);
+                        reportWrittenKey(written);
                         return;
                     }
                     // Check for function calls (anything that isn't handled above)
@@ -2006,8 +1995,7 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                         if (isLikelyArray) {
                             return;
                         }
-                        const propText = context.sourceCode.getText(property);
-                        reportWrittenKey(written, property, propText);
+                        reportWrittenKey(written);
                         return;
                     }
                 }

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/enforce-singular-type-names.js

@@ -41,6 +41,141 @@ const NON_PLURALIZABLE_SUFFIXES = [
  * the reference itself as a container.
  */
 const ARRAY_GENERIC_NAMES = new Set(['Array', 'ReadonlyArray']);
+/**
+ * Word-final suffixes that are singular by shape. No English plural ends in
+ * `-sis` or `-ss`, so both classes are exempt wholesale rather than enumerated:
+ * every `-sis` noun (`Analysis`, `Basis`, `Thesis`, `Diagnosis`, `Synopsis`,
+ * `Chassis`) and every `-ss` noun (`Address`, `Progress`, `Class`, `Success`)
+ * is covered, including ones no list would anticipate.
+ *
+ * The neighbouring `-is`/`-us`/`-os` classes get no such blanket rule, because
+ * genuine plurals do end that way — `Emojis`, `Minis`, `Menus`, `Plateaus`,
+ * `Taxis`. Exempting those by shape would silence the rule on real collection
+ * names, so they are enumerated in SINGULAR_NOUNS_ENDING_IN_S instead.
+ */
+const SINGULAR_WORD_SUFFIXES = ['sis', 'ss'];
+/**
+ * Singular nouns that end in `s` and that `pluralize` mistakes for plurals.
+ * Stripping the trailing `s` yields a non-word — `Axis` → `Axi`, `Lens` →
+ * `Len`, `Chaos` → `Chao` — which is the tell that the identifier was singular
+ * all along. Enumeration is the only safe discriminator here: `Axis` and
+ * `Minis` share a shape, so nothing but the noun itself separates a Latin/Greek
+ * singular from an ordinary plural.
+ *
+ * Entries `pluralize` already classifies correctly (`Status`, `Corpus`) are
+ * listed too, so a change in that library's heuristics cannot quietly
+ * reintroduce the false positive.
+ */
+const SINGULAR_NOUNS_ENDING_IN_S = new Set([
+    // Latin/Greek `-is` singulars outside the `-sis` family above.
+    'axis',
+    'praxis',
+    'prophylaxis',
+    'aegis',
+    'cannabis',
+    'chrysalis',
+    'clematis',
+    'dais',
+    'dermis',
+    'epidermis',
+    'epiglottis',
+    'glottis',
+    'hubris',
+    'ibis',
+    'iris',
+    'mantis',
+    'marquis',
+    'megalopolis',
+    'metropolis',
+    'pelvis',
+    'portcullis',
+    'proboscis',
+    'tennis',
+    'trellis',
+    // `-us` singulars.
+    'alumnus',
+    'apparatus',
+    'bonus',
+    'bus',
+    'cactus',
+    'campus',
+    'census',
+    'chorus',
+    'consensus',
+    'corpus',
+    'exodus',
+    'focus',
+    'fungus',
+    'genus',
+    'hiatus',
+    'impetus',
+    'locus',
+    'minus',
+    'modulus',
+    'nexus',
+    'nucleus',
+    'octopus',
+    'opus',
+    'plus',
+    'prospectus',
+    'radius',
+    'sinus',
+    'status',
+    'stimulus',
+    'surplus',
+    'syllabus',
+    'terminus',
+    'thesaurus',
+    'versus',
+    'virus',
+    // Remaining singular nouns ending in `s`.
+    'alias',
+    'apropos',
+    'asbestos',
+    'atlas',
+    'bias',
+    'canvas',
+    'chaos',
+    'cosmos',
+    'ethos',
+    'fracas',
+    'gas',
+    'kudos',
+    'lens',
+    'news',
+    'pancreas',
+    'pathos',
+    'rhinoceros',
+    'series',
+    'species',
+    'thermos',
+]);
+/**
+ * Splits a PascalCase/camelCase identifier into its words, keeping an
+ * all-caps run together: `DeferAxis` → `Defer`/`Axis`, `HTTPStatus` →
+ * `HTTP`/`Status`.
+ */
+const IDENTIFIER_WORD_PATTERN = /[A-Z]+(?![a-z])|[A-Z]?[a-z0-9]+/g;
+/**
+ * The exemption keys on the identifier's FINAL word rather than the whole
+ * identifier so it composes with any prefix: `Axis`, `DeferAxis` and
+ * `ChartRenderAxis` all resolve to `axis`. Whole-identifier matching would
+ * exempt only the bare noun and keep reporting every compound built on it.
+ */
+function trailingWordOf(name) {
+    const words = name.match(IDENTIFIER_WORD_PATTERN);
+    return (words?.[words.length - 1] ?? name).toLowerCase();
+}
+/**
+ * True when the identifier's final word is a singular noun that merely ends in
+ * `s`. Checked before `pluralize`, whose naive trailing-`s` strip is what
+ * misreads these nouns in the first place.
+ */
+function endsWithSingularNoun(name) {
+    const trailingWord = trailingWordOf(name);
+    return (SINGULAR_NOUNS_ENDING_IN_S.has(trailingWord) ||
+        SINGULAR_WORD_SUFFIXES.some((suffix) => trailingWord.endsWith(suffix)));
+}
 /**
  * Union members that only express absence. Stripping them keeps a nullable
  * container recognisable as a container: `T[]` and `T[] | null` describe the
@@ -137,6 +272,11 @@ exports.enforceSingularTypeNames = (0, createRule_1.createRule)({
             // Skip checking if name ends with 'Props', 'Params', 'Data', etc.
             if (NON_PLURALIZABLE_SUFFIXES.some((suffix) => name.toLowerCase().endsWith(suffix.toLowerCase())))
                 return false;
+            // Singular nouns that end in `s` must be settled BEFORE pluralize sees
+            // them: its trailing-`s` strip turns `DeferAxis` into the non-word
+            // `DeferAxi` and reports a rename to it.
+            if (endsWithSingularNoun(name))
+                return false;
             // Skip checking if name is already singular according to pluralize
             if (pluralize.isSingular(name))
                 return false;

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.176",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",

package/release-manifest.json

@@ -1,4 +1,48 @@
 [
+  {
+    "version": "1.20.176",
+    "date": "2026-08-26T11:56:32.903Z",
+    "rules": [
+      {
+        "name": "enforce-assert-safe-object-key",
+        "changeType": "fix",
+        "issues": [
+          2144
+        ],
+        "summary": "wrap a coerced key instead of replacing it (closes #2144)"
+      },
+      {
+        "name": "enforce-singular-type-names",
+        "changeType": "fix",
+        "issues": [
+          2143
+        ],
+        "summary": "exempt singular nouns that merely end in s (closes #2143)"
+      }
+    ]
+  },
+  {
+    "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",