@blumintinc/eslint-plugin-blumint 1.20.140 → 1.20.142

package/lib/index.js

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

package/lib/rules/enforce-centralized-mock-firestore.js

@@ -218,19 +218,14 @@ function editOffset(anchor) {
  *
  * Widening to the anchor's line start is what lets the emitted
  * `${indent}import …\n` leave the displaced statement on the indentation it
- * already had, but that is sound only while whitespace is all that precedes
- * the anchor: a `'use client';` sharing the anchor's line would be demoted by
- * an insertion at column 0. When the resulting position still falls inside a
- * retirement — the anchor statement is itself the declaration being retired,
- * and the retirement claims the indentation ahead of it — the insertion moves
- * to that edit's start, since ESLint rejects a fix nested inside another.
+ * already had; `importAnchorLineStartIfOwned` restricts that to the anchors it
+ * is sound for. When the resulting position still falls inside a retirement —
+ * the anchor statement is itself the declaration being retired, and the
+ * retirement claims the indentation ahead of it — the insertion moves to that
+ * edit's start, since ESLint rejects a fix nested inside another.
  */
 function importPlacement(sourceCode, anchor, edits) {
-    const anchorStart = editOffset(anchor);
-    const lineStart = sourceCode.text.lastIndexOf('\n', anchorStart - 1) + 1;
-    const placement = /^[ \t]*$/.test(sourceCode.text.slice(lineStart, anchorStart))
-        ? (0, importInsertion_1.importAnchorLineStart)(sourceCode, anchor)
-        : anchor;
+    const placement = (0, importInsertion_1.importAnchorLineStartIfOwned)(sourceCode, anchor);
     const offset = editOffset(placement);
     const enclosing = edits.find((edit) => edit.start < offset && offset < edit.end);
     return enclosing ? { kind: 'index', index: enclosing.start } : placement;

package/lib/rules/enforce-early-destructuring.js

@@ -894,7 +894,7 @@ function generateHoistingFixes(groups, callback, depsArray, depTexts, insertionS
     for (const group of groups.values()) {
         const sortedProps = Array.from(group.properties.values()).sort((a, b) => a.order - b.order);
         const pattern = `{ ${sortedProps.map((p) => p.text).join(', ')} }`;
-        hoistedLines.push(`${indent}const ${pattern} = ${nullishSourceText(group.objectText, group.inits[0])} ?? {};`);
+        hoistedLines.push(`const ${pattern} = ${nullishSourceText(group.objectText, group.inits[0])} ?? {};`);
     }
     reservedNamesByScope.set(scope, updatedReservedNames);
     const newDepSet = new Set(newDepTexts);
@@ -904,9 +904,18 @@ function generateHoistingFixes(groups, callback, depsArray, depTexts, insertionS
             newDepSet.add(name);
         }
     }
-    const insertAt = sourceCode.getText().lastIndexOf('\n', insertionStatement.range[0]) + 1;
+    // Anchoring to the start of the statement's LINE is the same offset as the
+    // statement itself only while the statement opens that line. When it does not
+    // — a body collapsed onto one line, or a sibling declared ahead of it — that
+    // offset sits outside the enclosing function, so a declaration reading the
+    // function's own parameters would be hoisted out of the scope that binds them.
+    const text = sourceCode.getText();
+    const lineStart = text.lastIndexOf('\n', insertionStatement.range[0]) + 1;
+    const ownsItsLine = /^[\t ]*$/.test(text.slice(lineStart, insertionStatement.range[0]));
     const fixes = [
-        fixer.insertTextBeforeRange([insertAt, insertAt], `${hoistedLines.join('\n')}\n`),
+        ownsItsLine
+            ? fixer.insertTextBeforeRange([lineStart, lineStart], `${hoistedLines.map((line) => `${indent}${line}`).join('\n')}\n`)
+            : fixer.insertTextBefore(insertionStatement, `${hoistedLines.join(' ')} `),
         fixer.replaceText(depsArray, `[${newDepTexts.join(', ')}]`),
     ];
     for (const decl of declarationsToRemove) {

package/lib/rules/enforce-memoize-async.js

@@ -459,7 +459,7 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
                             // a header comment — while still placing it above the first
                             // existing import.
                             const anchor = (0, importInsertion_1.importInsertionAnchor)(sourceCode);
-                            fixes.push((0, importInsertion_1.insertAtImportAnchor)(sourceCode, fixer, (0, importInsertion_1.importAnchorLineStart)(sourceCode, anchor), `${(0, importInsertion_1.importAnchorIndent)(sourceCode, anchor)}${importStatement}\n`));
+                            fixes.push((0, importInsertion_1.insertAtImportAnchor)(sourceCode, fixer, (0, importInsertion_1.importAnchorLineStartIfOwned)(sourceCode, anchor), `${(0, importInsertion_1.importAnchorIndent)(sourceCode, anchor)}${importStatement}\n`));
                             scheduledImportFix = true;
                         }
                         // Anchor the decorator on the method — its first token, so ahead of

package/lib/rules/enforce-memoize-getters.js

@@ -507,7 +507,7 @@ exports.enforceMemoizeGetters = (0, createRule_1.createRule)({
                             // with the statement it displaces; widening to the line start
                             // then leaves that statement's indentation intact.
                             const indent = (0, importInsertion_1.importAnchorIndent)(sourceCode, anchor);
-                            fixes.push((0, importInsertion_1.insertAtImportAnchor)(sourceCode, fixer, (0, importInsertion_1.importAnchorLineStart)(sourceCode, anchor), `${indent}import { Memoize } from '${MEMOIZE_PREFERRED_MODULE}';\n`));
+                            fixes.push((0, importInsertion_1.insertAtImportAnchor)(sourceCode, fixer, (0, importInsertion_1.importAnchorLineStartIfOwned)(sourceCode, anchor), `${indent}import { Memoize } from '${MEMOIZE_PREFERRED_MODULE}';\n`));
                             scheduledImportFix = true;
                         }
                         // Anchor the decorator on the member — its first token, so ahead of

package/lib/rules/no-explicit-return-type.js

@@ -846,6 +846,115 @@ function carriedText(source, range) {
             : ' ';
     return `${lead}${body}${trail}`;
 }
+/** Every character the syntactic grammar counts as a LineTerminator. */
+const LINE_TERMINATOR = /[\n\r\u2028\u2029]/;
+const textOf = (source, range) => source.text.slice(range[0], range[1]);
+/**
+ * The span an arrow's return annotation occupies between the parameter list and
+ * the `=>`, together with that arrow token.
+ *
+ * The span holds the annotation, whitespace and comments and nothing else,
+ * which is what makes it safe to rewrite wholesale: no binding reference can
+ * hide in it beyond the ones the annotation itself names.
+ */
+function arrowAnnotationGap(source, returnType) {
+    const parametersEnd = source.getTokenBefore(returnType);
+    const arrow = source.getTokenAfter(returnType, {
+        filter: (token) => token.value === '=>',
+    });
+    if (!parametersEnd || !arrow)
+        return null;
+    const gap = [parametersEnd.range[1], arrow.range[0]];
+    return containsRange(gap, returnType.range) ? { gap, arrow } : null;
+}
+/**
+ * Re-emits `comments` on the far side of the arrow, where a line terminator is
+ * inert, consuming the horizontal whitespace the arrow already had after it so
+ * the body keeps a single separator.
+ */
+function hoistPastArrow(source, arrow, comments) {
+    const indent = indentAt(source, arrow.range[0]);
+    const trailingText = source.text.slice(arrow.range[1]);
+    const [spacing] = /^[ \t]*/.exec(trailingText) ?? [''];
+    const body = (0, replacementSegments_1.joinSegmentBody)(comments.map((comment) => ({
+        text: textOf(source, comment.range),
+        breakAfter: true,
+    })), indent);
+    const rest = trailingText.slice(spacing.length);
+    const separator = LINE_TERMINATOR.test(rest.charAt(0))
+        ? ''
+        : (0, replacementSegments_1.requiresLineBreakAfter)(comments[comments.length - 1])
+            ? `\n${indent}`
+            : ' ';
+    return {
+        range: [arrow.range[1], arrow.range[1] + spacing.length],
+        text: ` ${body}${separator}`,
+    };
+}
+/**
+ * The edits that strip one annotation, carrying every comment the strip
+ * strands rather than deleting it (#1877). `null` withholds the fix, for a
+ * comment whose meaning is its position and which cannot stay where it is.
+ *
+ * An arrow is the one subject whose annotation sits inside a restricted
+ * production: `ArrowParameters [no LineTerminator here] =>` forbids a line
+ * terminator between the parameter list and the arrow, and a block comment
+ * carrying a line terminator IS one to the grammar. A comment left there — or
+ * carried there from inside the annotation — therefore turns the output into a
+ * hard SyntaxError that only V8 reports, since `@typescript-eslint/parser`
+ * accepts it (#1964). Such a comment is re-emitted past the `=>` instead, the
+ * nearest position outside the restricted gap that cannot itself begin one;
+ * hoisting it above the enclosing line would anchor an insertion at a column
+ * zero that may sit inside a template literal or JSX text, where the comment
+ * would become content rather than code.
+ *
+ * Every other subject ends its parameter list at a body or a semicolon, so its
+ * stranded comments stay where they were written.
+ */
+function planAnnotationEdits(source, entry) {
+    const range = entry.returnType.range;
+    if (entry.node.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+        const carried = carriedText(source, range);
+        return carried === null ? null : [{ range, text: carried }];
+    }
+    const gapInfo = arrowAnnotationGap(source, entry.returnType);
+    if (!gapInfo)
+        return null;
+    const { gap, arrow } = gapInfo;
+    const comments = source
+        .getAllComments()
+        .filter((comment) => containsRange(gap, comment.range));
+    const stranded = comments.filter((comment) => containsRange(range, comment.range));
+    // What the plain deletion would leave between the parameters and the arrow.
+    // A comment left there contributes its own text, so a line comment or a
+    // multi-line block comment shows up here as the line terminator it is.
+    const residue = `${textOf(source, [gap[0], range[0]])}${textOf(source, [
+        range[1],
+        gap[1],
+    ])}`;
+    // The plain deletion is kept wherever it already lands a legal gap and
+    // strands nothing, so no output that survives today moves by a byte.
+    if (stranded.length === 0 && !LINE_TERMINATOR.test(residue)) {
+        return [{ range, text: '' }];
+    }
+    // Rewriting the gap collapses the lines it spanned, which moves the line a
+    // directive inside it points at, so the whole fix is withheld rather than
+    // retargeting one. The gap a directive can share with nothing else is left
+    // untouched by the branch above.
+    if (comments.some(isPositionalDirective))
+        return null;
+    const hoisted = comments.filter(replacementSegments_1.requiresOwnLine);
+    const inline = comments
+        .filter((comment) => !(0, replacementSegments_1.requiresOwnLine)(comment))
+        .map((comment) => textOf(source, comment.range));
+    const edits = [
+        { range: gap, text: inline.length === 0 ? ' ' : ` ${inline.join(' ')} ` },
+    ];
+    if (hoisted.length > 0) {
+        edits.push(hoistPastArrow(source, arrow, hoisted));
+    }
+    return edits;
+}
 /**
  * ESLint applies a fix whole or not at all, and rejects one whose edits
  * overlap. Two spans planned independently — an annotation and the declaration
@@ -866,14 +975,23 @@ function isDisjoint(edits) {
  * outright. The planner computes spans that reach across separators, so a
  * comment among the specifiers sits inside one; declining on that comment is no
  * remedy, since it lets a comment decide whether the annotations are stripped at
- * all, which is a comment changing the transform just the same (#1877).
+ * all, which is a comment changing the transform just the same (#1877). The
+ * annotation spans are carried the same way by {@link planAnnotationEdits},
+ * which additionally answers for the arrow whose annotation sits inside a
+ * restricted production.
  */
 function planRemoval(source, removalSource, batch) {
     const annotations = batch.map((entry) => entry.returnType.range);
     const cleanups = (0, importRemoval_1.planOrphanedBindingRemoval)(removalSource, annotations, (variables, planned) => (0, typeDeclarationRemoval_1.planTypeDeclarationRemoval)(removalSource, variables, planned));
     if (!cleanups)
         return null;
-    const edits = annotations.map((range) => ({ range, text: '' }));
+    const edits = [];
+    for (const entry of batch) {
+        const planned = planAnnotationEdits(source, entry);
+        if (planned === null)
+            return null;
+        edits.push(...planned);
+    }
     for (const range of cleanups) {
         if (removesWholeStatement(source, range)) {
             edits.push({ range, text: '' });

package/lib/rules/no-usememo-for-pass-by-value.js

@@ -551,11 +551,13 @@ exports.noUsememoForPassByValue = (0, createRule_1.createRule)({
                     // line is hoisted onto a full line of its own ABOVE the line the
                     // call starts on. That insertion can never split a token pair, and
                     // it lands a `-next-line` directive exactly one line above the
-                    // statement that now hosts its subject. Everything else stays
-                    // inline: a block comment beside the expression, and a trailing
-                    // line-bound comment followed by a line break, which is safe after
-                    // the expression has begun.
-                    const hoistedComments = leadingComments.filter(replacementSegments_1.requiresLineBreakAfter);
+                    // statement that now hosts its subject. A block comment carrying a
+                    // line terminator demands a line the same way, because the grammar
+                    // reads it AS a line terminator (#1963). Everything else stays
+                    // inline: a single-line block comment beside the expression, and a
+                    // trailing line-bound comment followed by a line break, which is
+                    // safe after the expression has begun.
+                    const hoistedComments = leadingComments.filter(replacementSegments_1.requiresOwnLine);
                     if (hoistedComments.length > 0) {
                         const lineStartIndex = sourceCode.getIndexFromLoc({
                             line: node.loc.start.line,
@@ -571,7 +573,7 @@ exports.noUsememoForPassByValue = (0, createRule_1.createRule)({
                     }
                     const segments = [
                         ...leadingComments
-                            .filter((comment) => !(0, replacementSegments_1.requiresLineBreakAfter)(comment))
+                            .filter((comment) => !(0, replacementSegments_1.requiresOwnLine)(comment))
                             .map(toSegment),
                         { text: replacementText, breakAfter: false },
                         ...trailingComments.map(toSegment),

package/lib/rules/prefer-use-deep-compare-memo.js

@@ -258,10 +258,13 @@ function ensureDeepCompareImportFixes(context, fixer) {
     const anchor = (0, importInsertion_1.importInsertionAnchor)(sourceCode);
     const indent = (0, importInsertion_1.importAnchorIndent)(sourceCode, anchor);
     const importText = `${indent}import { ${DEEP_COMPARE_HOOK} } from '${DEEP_COMPARE_MODULE}';\n`;
-    // Widened to the anchor's line start because the emitted statement carries
-    // its own indentation, leaving the displaced anchor sitting on the original.
+    // Widened to the anchor's line start where the anchor opens it, because the
+    // emitted statement carries its own indentation and so leaves the displaced
+    // anchor sitting on the original. Where the anchor shares its line the
+    // widening is declined: the offset would otherwise fall ahead of the prologue
+    // this anchor was chosen to sit below.
     return [
-        (0, importInsertion_1.insertAtImportAnchor)(sourceCode, fixer, (0, importInsertion_1.importAnchorLineStart)(sourceCode, anchor), importText),
+        (0, importInsertion_1.insertAtImportAnchor)(sourceCode, fixer, (0, importInsertion_1.importAnchorLineStartIfOwned)(sourceCode, anchor), importText),
     ];
 }
 function isImportedIdentifier(context, name) {

package/lib/utils/harvestRuleTesterCases.js

@@ -43,7 +43,30 @@ const TESTS_DIR = path.join(__dirname, '..', 'tests');
  * (`const jsx = ruleTesterJsx`) before calling `run`, so a call-site pattern
  * drops it.
  */
-exports.IMPORTS_SHARED_TESTER = /from\s+'\.\.\/utils\/ruleTester'/;
+exports.IMPORTS_SHARED_TESTER = /from\s+'(?:\.\.\/)+utils\/ruleTester'/;
+/**
+ * Every suite file under the tests root, as a path relative to it.
+ *
+ * The enumeration is recursive because a suite in a subdirectory is still a
+ * suite: `src/tests/rules/` holds three that jest runs and that every
+ * harvest-based gate used to miss, while their rules' top-level namesakes kept
+ * the per-rule closure green — so the gap read as coverage from every angle
+ * that was checked.
+ *
+ * Paths stay relative rather than collapsing to a basename so that two suites
+ * with the same name (`no-circular-references.test.ts` exists at both depths)
+ * remain distinguishable, which is what keeps a per-file baseline or a dedupe
+ * key from silently merging them.
+ */
+function suiteFilesUnder(root) {
+    const walk = (dir) => fs.readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory())
+            return walk(full);
+        return entry.name.endsWith('.test.ts') ? [path.relative(root, full)] : [];
+    });
+    return walk(root).sort();
+}
 /**
  * Jest registers a test for every `describe`/`it` a loaded module calls, so
  * loading 271 suites inside a suite would graft their entire test list onto
@@ -156,10 +179,7 @@ function harvestRuleTesterCases() {
     const realCwd = process.cwd();
     process.chdir(scratchRoot);
     try {
-        const files = fs
-            .readdirSync(TESTS_DIR)
-            .filter((file) => file.endsWith('.test.ts'))
-            .sort();
+        const files = suiteFilesUnder(TESTS_DIR);
         for (const file of files) {
             const fullPath = path.join(TESTS_DIR, file);
             if (!exports.IMPORTS_SHARED_TESTER.test(fs.readFileSync(fullPath, 'utf8'))) {

package/lib/utils/importInsertion.d.ts

@@ -40,11 +40,25 @@ export declare function importInsertionAnchor(sourceCode: ImportInsertionSource)
  */
 export declare function insertAtImportAnchor(sourceCode: ImportInsertionSource, fixer: TSESLint.RuleFixer, anchor: ImportInsertionAnchor, text: string): TSESLint.RuleFix;
 /**
- * Widens `anchor` to the start of its line, for rules that emit
- * `${indent}import …\n` so the displaced anchor keeps its own indentation.
+ * Widens `anchor` to the start of its line only where whitespace is all that
+ * precedes it there, and leaves it alone otherwise.
+ *
  * Raw-offset anchors pass through: they never sit inside an indented line.
+ *
+ * The widening buys one thing — an emitted `${indent}import …\n` leaves the
+ * displaced anchor on the indentation it already had — and that reasoning holds
+ * only while the anchor opens its line. When something else opens that line the
+ * widened offset sits ahead of it, and the anchor resolves past the prologue
+ * precisely because the prologue is what precedes it: a `'use client'` is a
+ * directive only while it is the first statement, so an import spliced above it
+ * demotes it to an inert expression statement that no bundler reads. Nothing
+ * downstream reports that — the output re-lints clean and the demoted directive
+ * is still valid TypeScript.
+ *
+ * Declining to widen costs the displaced anchor its indentation and keeps the
+ * file's meaning, which is the safe direction of that trade.
  */
-export declare function importAnchorLineStart(sourceCode: ImportInsertionSource, anchor: ImportInsertionAnchor): ImportInsertionAnchor;
+export declare function importAnchorLineStartIfOwned(sourceCode: ImportInsertionSource, anchor: ImportInsertionAnchor): ImportInsertionAnchor;
 /**
  * The whitespace prefix of the anchor's line, for fixers that replicate the
  * anchor's indentation on the inserted import.

package/lib/utils/importInsertion.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.importAnchorIndent = exports.importAnchorLineStart = exports.insertAtImportAnchor = exports.importInsertionAnchor = void 0;
+exports.importAnchorIndent = exports.importAnchorLineStartIfOwned = exports.insertAtImportAnchor = exports.importInsertionAnchor = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const disableDirectives_1 = require("./disableDirectives");
 /**
@@ -95,18 +95,35 @@ function insertAtImportAnchor(sourceCode, fixer, anchor, text) {
 }
 exports.insertAtImportAnchor = insertAtImportAnchor;
 /**
- * Widens `anchor` to the start of its line, for rules that emit
- * `${indent}import …\n` so the displaced anchor keeps its own indentation.
+ * Widens `anchor` to the start of its line only where whitespace is all that
+ * precedes it there, and leaves it alone otherwise.
+ *
  * Raw-offset anchors pass through: they never sit inside an indented line.
+ *
+ * The widening buys one thing — an emitted `${indent}import …\n` leaves the
+ * displaced anchor on the indentation it already had — and that reasoning holds
+ * only while the anchor opens its line. When something else opens that line the
+ * widened offset sits ahead of it, and the anchor resolves past the prologue
+ * precisely because the prologue is what precedes it: a `'use client'` is a
+ * directive only while it is the first statement, so an import spliced above it
+ * demotes it to an inert expression statement that no bundler reads. Nothing
+ * downstream reports that — the output re-lints clean and the demoted directive
+ * is still valid TypeScript.
+ *
+ * Declining to widen costs the displaced anchor its indentation and keeps the
+ * file's meaning, which is the safe direction of that trade.
  */
-function importAnchorLineStart(sourceCode, anchor) {
+function importAnchorLineStartIfOwned(sourceCode, anchor) {
     if (anchor.kind === 'index') {
         return anchor;
     }
-    const lineStart = sourceCode.text.lastIndexOf('\n', anchor.target.range[0] - 1) + 1;
-    return { kind: 'index', index: lineStart };
+    const start = anchor.target.range[0];
+    const lineStart = sourceCode.text.lastIndexOf('\n', start - 1) + 1;
+    return /^[\t ]*$/.test(sourceCode.text.slice(lineStart, start))
+        ? { kind: 'index', index: lineStart }
+        : anchor;
 }
-exports.importAnchorLineStart = importAnchorLineStart;
+exports.importAnchorLineStartIfOwned = importAnchorLineStartIfOwned;
 /**
  * The whitespace prefix of the anchor's line, for fixers that replicate the
  * anchor's indentation on the inserted import.

package/lib/utils/replacementSegments.d.ts

@@ -16,6 +16,25 @@ import { TSESTree } from '@typescript-eslint/utils';
  * silently retarget one line past its subject.
  */
 export declare function requiresLineBreakAfter(comment: TSESTree.Comment): boolean;
+/**
+ * A comment that cannot be folded onto the code that follows it, so a fixer
+ * placing it ahead of an expression must give it a line of its own.
+ *
+ * Two kinds qualify. One is the line-bound comment {@link requiresLineBreakAfter}
+ * describes, whose meaning is tied to the line it occupies. The other is a block
+ * comment containing a line terminator: the syntactic grammar treats such a
+ * comment as a LineTerminator in its own right, so it triggers every restricted
+ * production a raw newline would. Measured with `node --check`, a block comment
+ * on one line between arrow parameters and their arrow parses, while the same
+ * comment broken across two lines is a SyntaxError; ahead of a `return`
+ * argument, the multi-line form is worse still — it parses, and ASI silently
+ * replaces the returned value with `undefined` (#1963).
+ *
+ * Only fixers emitting text where a newline is meaningful need this;
+ * a replacement wrapped in parentheses can never trip a restricted production
+ * and can keep such a comment inline.
+ */
+export declare function requiresOwnLine(comment: TSESTree.Comment): boolean;
 export type ReplacementSegment = {
     text: string;
     breakAfter: boolean;

package/lib/utils/replacementSegments.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.joinSegments = exports.joinSegmentBody = exports.requiresLineBreakAfter = void 0;
+exports.joinSegments = exports.joinSegmentBody = exports.requiresOwnLine = exports.requiresLineBreakAfter = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const disableDirectives_1 = require("./disableDirectives");
 /**
@@ -26,6 +26,35 @@ function requiresLineBreakAfter(comment) {
     return (0, disableDirectives_1.parseDisableDirectives)([comment]).some((directive) => directive.kind === 'disable-next-line');
 }
 exports.requiresLineBreakAfter = requiresLineBreakAfter;
+/**
+ * Whether a comment's own text carries a line terminator, which only a block
+ * comment can do.
+ */
+function spansMultipleLines(comment) {
+    return comment.loc.start.line !== comment.loc.end.line;
+}
+/**
+ * A comment that cannot be folded onto the code that follows it, so a fixer
+ * placing it ahead of an expression must give it a line of its own.
+ *
+ * Two kinds qualify. One is the line-bound comment {@link requiresLineBreakAfter}
+ * describes, whose meaning is tied to the line it occupies. The other is a block
+ * comment containing a line terminator: the syntactic grammar treats such a
+ * comment as a LineTerminator in its own right, so it triggers every restricted
+ * production a raw newline would. Measured with `node --check`, a block comment
+ * on one line between arrow parameters and their arrow parses, while the same
+ * comment broken across two lines is a SyntaxError; ahead of a `return`
+ * argument, the multi-line form is worse still — it parses, and ASI silently
+ * replaces the returned value with `undefined` (#1963).
+ *
+ * Only fixers emitting text where a newline is meaningful need this;
+ * a replacement wrapped in parentheses can never trip a restricted production
+ * and can keep such a comment inline.
+ */
+function requiresOwnLine(comment) {
+    return requiresLineBreakAfter(comment) || spansMultipleLines(comment);
+}
+exports.requiresOwnLine = requiresOwnLine;
 /**
  * Joins the inlined expression and its carried comments into one run of text,
  * keeping each comment on the side of the expression it was written on and

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,64 @@
 [
+  {
+    "version": "1.20.142",
+    "date": "2026-08-12T07:04:58.677Z",
+    "rules": [
+      {
+        "name": "no-explicit-return-type",
+        "changeType": "fix",
+        "issues": [
+          1964
+        ],
+        "summary": "keep the annotation's comments clear of the arrow gap (closes #1964)"
+      },
+      {
+        "name": "no-usememo-for-pass-by-value",
+        "changeType": "fix",
+        "issues": [
+          1963
+        ],
+        "summary": "hoist a carried multi-line comment clear of the return (closes #1963)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.141",
+    "date": "2026-08-12T00:57:09.340Z",
+    "rules": [
+      {
+        "name": "enforce-early-destructuring",
+        "changeType": "fix",
+        "issues": [
+          1956
+        ],
+        "summary": "anchor the hoist to the hook call, not to its line (closes #1956)"
+      },
+      {
+        "name": "enforce-memoize-async",
+        "changeType": "fix",
+        "issues": [
+          1957
+        ],
+        "summary": "keep the injected import below a shared-line directive (closes #1957)"
+      },
+      {
+        "name": "enforce-memoize-getters",
+        "changeType": "fix",
+        "issues": [
+          1958
+        ],
+        "summary": "keep the injected import below a shared-line directive (closes #1958)"
+      },
+      {
+        "name": "prefer-use-deep-compare-memo",
+        "changeType": "fix",
+        "issues": [
+          1959
+        ],
+        "summary": "keep the injected import below a shared-line directive (closes #1959)"
+      }
+    ]
+  },
   {
     "version": "1.20.140",
     "date": "2026-08-11T22:49:18.139Z",