@blumintinc/eslint-plugin-blumint 1.20.140 → 1.20.141

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.141',
     },
     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/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/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/package.json

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

package/release-manifest.json

@@ -1,4 +1,42 @@
 [
+  {
+    "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",