@blumintinc/eslint-plugin-blumint 1.20.187 → 1.20.189

package/lib/index.js

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

package/lib/rules/no-entire-object-hook-deps.d.ts

@@ -1,3 +1,4 @@
+import { TSESLint } from '@typescript-eslint/utils';
 type MessageIds = 'avoidEntireObject' | 'removeUnusedDependency';
-export declare const noEntireObjectHookDeps: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export declare const noEntireObjectHookDeps: TSESLint.RuleModule<MessageIds, [], TSESLint.RuleListener>;
 export {};

package/lib/rules/no-entire-object-hook-deps.js

@@ -1167,6 +1167,48 @@ function getObjectUsagesInHook(hookBody, objectName, typeInfo, bodyIsDeferred =
         notUsed,
     };
 }
+/** The run of spaces/tabs opening the line that `offset` sits on. */
+function indentAt(text, offset) {
+    const lineStart = text.lastIndexOf('\n', offset - 1) + 1;
+    return /^[ \t]*/.exec(text.slice(lineStart, offset))?.[0] ?? '';
+}
+/**
+ * Drop `span`, but re-emit any comment standing inside it.
+ *
+ * Removing a dependency means removing its separator too, so the span reaches
+ * to a NEIGHBOURING element and therefore covers the margin between the two.
+ * That margin is not the fixer's to delete: it can hold an
+ * `eslint-disable-next-line` protecting the dependency that survives, and
+ * dropping that directive silently re-enables another rule (#2208). Declining
+ * the fix instead would only trade the lost comment for a transform that a
+ * comment decides (#1877), so the comment is carried rather than obeyed.
+ *
+ * Each carried comment is re-emitted on a line of its own: a `//` comment
+ * swallows whatever follows it on the same line, so folding one inline would
+ * comment out the dependency that was meant to survive.
+ */
+function removeCarryingComments(fixer, sourceCode, span, anchor) {
+    const carried = sourceCode
+        .getAllComments()
+        .filter((comment) => comment.range[0] >= span[0] && comment.range[1] <= span[1]);
+    // With nothing to preserve the span is pure separator and whitespace, so the
+    // plain removal keeps the comment-free output exactly as it has always been.
+    if (carried.length === 0) {
+        return fixer.removeRange(span);
+    }
+    const text = sourceCode.getText();
+    // Anchor the indentation on the end the surviving code sits against.
+    const indent = indentAt(text, anchor === 'toNextElement' ? span[1] : carried[0].range[0]);
+    const body = carried
+        .map((comment) => text.slice(comment.range[0], comment.range[1]))
+        .join(`\n${indent}`);
+    // Both spellings close on a fresh line: whatever the span abutted — the next
+    // dependency, or the separator trailing the last one — would otherwise land
+    // on the final carried comment's line and be commented out.
+    return fixer.replaceTextRange(span, anchor === 'toNextElement'
+        ? `${body}\n${indent}`
+        : `\n${indent}${body}\n${indent}`);
+}
 exports.noEntireObjectHookDeps = (0, createRule_1.createRule)({
     name: 'no-entire-object-hook-deps',
     meta: {
@@ -1339,21 +1381,19 @@ exports.noEntireObjectHookDeps = (0, createRule_1.createRule)({
                                     if (elementIndex === depsArg.elements.length - 1) {
                                         const prevElement = depsArg.elements[elementIndex - 1];
                                         if (prevElement) {
-                                            const range = [
+                                            return removeCarryingComments(fixer, sourceCode, [
                                                 prevElement.range[1],
                                                 element.range[1],
-                                            ];
-                                            return fixer.removeRange(range);
+                                            ], 'fromPrevElement');
                                         }
                                     }
                                     // Otherwise, remove the element and the following comma
                                     const nextElement = depsArg.elements[elementIndex + 1];
                                     if (nextElement) {
-                                        const range = [
+                                        return removeCarryingComments(fixer, sourceCode, [
                                             element.range[0],
                                             nextElement.range[0],
-                                        ];
-                                        return fixer.removeRange(range);
+                                        ], 'toNextElement');
                                     }
                                     // Fallback to just removing the element
                                     return fixer.remove(element);

package/lib/rules/require-memo.js

@@ -838,7 +838,18 @@ function calculateImportPath(currentFilePath) {
         return 'src/util/memo';
     // Split the current file path into parts and normalize
     const parts = currentFilePath.split(/[\\/]/); // Handle both Unix and Windows paths
-    const srcIndex = parts.indexOf('src');
+    /**
+     * The source root is the `src` NEAREST the file, not the first one in the
+     * path. `context.getFilename()` is always absolute under every real ESLint
+     * entry point, so the absolute prefix is part of the path being searched: a
+     * checkout under a directory named `src` (`~/src/proj/src/components/Foo.tsx`)
+     * would otherwise anchor on that outer segment and emit a specifier that walks
+     * out of the project entirely.
+     *
+     * Directory segments only — a file that is itself named `src` names no
+     * directory the import could be relative to.
+     */
+    const srcIndex = parts.slice(0, -1).lastIndexOf('src');
     if (srcIndex === -1) {
         // If we're not in a src directory, use absolute path
         return 'src/util/memo';

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,32 @@
 [
+  {
+    "version": "1.20.189",
+    "date": "2026-08-29T11:57:05.586Z",
+    "rules": [
+      {
+        "name": "no-entire-object-hook-deps",
+        "changeType": "fix",
+        "issues": [
+          2208
+        ],
+        "summary": "carry comments in the removed dep's margin (closes #2208)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.188",
+    "date": "2026-08-29T07:11:55.294Z",
+    "rules": [
+      {
+        "name": "require-memo",
+        "changeType": "fix",
+        "issues": [
+          2207
+        ],
+        "summary": "anchor the memo import on the nearest src, not the first (closes #2207)"
+      }
+    ]
+  },
   {
     "version": "1.20.187",
     "date": "2026-08-28T10:18:26.589Z",