@blumintinc/eslint-plugin-blumint 1.20.87 → 1.20.88

package/lib/index.js

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

package/lib/rules/use-latest-callback.js

@@ -263,6 +263,55 @@ const brokenOpenCallText = (sourceCode, call, callback, head, indentUnit) => {
     const comma = wantsTrailingComma(sourceCode, call) ? ',' : '';
     return `${head}(\n${calleeIndent}${moved}${comma}\n${callIndent})`;
 };
+/** Whether a range sits wholly inside one of the ranges a fix deletes. */
+const fallsInside = (ranges, range) => ranges.some(([start, end]) => start <= range[0] && range[1] <= end);
+/**
+ * Whether the binding belongs to a function rather than to the module. A
+ * module-scope binding is left alone because this file cannot settle whether it
+ * is dead: it may be exported, re-exported, or declared for a side effect,
+ * whereas a binding declared inside a component or hook is reachable only from
+ * the references this file spells out.
+ */
+const isFunctionLocal = (variable) => {
+    for (let scope = variable.scope; scope; scope = scope.upper) {
+        if (scope.type === 'function') {
+            return true;
+        }
+    }
+    return false;
+};
+/** The bindings a reference inside one of the deleted ranges resolves to. */
+const variablesReferencedIn = (root, deletedRanges) => {
+    const referenced = new Set();
+    const walk = (scope) => {
+        for (const reference of scope.references) {
+            if (reference.resolved &&
+                fallsInside(deletedRanges, reference.identifier.range)) {
+                referenced.add(reference.resolved);
+            }
+        }
+        scope.childScopes.forEach(walk);
+    };
+    walk(root);
+    return referenced;
+};
+/**
+ * Whether deleting the given ranges would strip the last read of a binding
+ * declared inside a function, leaving a declaration — and whatever imports feed
+ * it — that nothing uses.
+ *
+ * A dependency array can hold the sole reference to a value computed for it
+ * alone, which is precisely what `no-array-length-in-deps` produces when it
+ * hoists `const listHash = useMemo(() => stableHash(list), [list])` and points
+ * the dependency at it. Dropping the array then strands that statement, turning
+ * a clean file into one `no-unused-vars` rejects with a violation this plugin
+ * cannot itself fix (issue #1652). Only a write left behind counts as no use at
+ * all, matching how an unused-variable check reads the result.
+ */
+const orphansLocalBinding = (root, deletedRanges) => [...variablesReferencedIn(root, deletedRanges)]
+    .filter((variable) => variable.defs.length > 0 && isFunctionLocal(variable))
+    .some((variable) => variable.references.every((reference) => !reference.isRead() ||
+    fallsInside(deletedRanges, reference.identifier.range)));
 exports.useLatestCallback = (0, createRule_1.createRule)({
     name: 'use-latest-callback',
     meta: {
@@ -676,6 +725,14 @@ exports.useLatestCallback = (0, createRule_1.createRule)({
                     }
                     return texts;
                 };
+                // Everything a rewritten call carries past its callback argument — the
+                // dependency array, and any further argument — is absent from the
+                // replacement text, so those ranges are what the fix deletes.
+                const droppedRanges = batchedConversions.map((conversion) => [
+                    conversion.node.arguments[0].range[1],
+                    conversion.node.range[1],
+                ]);
+                const programScope = ASTHelpers_1.ASTHelpers.getScope(context, program);
                 // Every call-site conversion and the import rewrite ride on ONE fix
                 // from ONE report. ESLint discards a multi-part fix wholesale when any
                 // part conflicts with another rule's fix and retries it on the next
@@ -700,6 +757,14 @@ exports.useLatestCallback = (0, createRule_1.createRule)({
                         if (!batchedConversions.every(reachesHook)) {
                             return null;
                         }
+                        // Deleting the dependency arrays must not strand a binding that
+                        // exists only to be listed in one. The batch is atomic, so a single
+                        // orphaned binding withholds all of it, and the violation still
+                        // stands as a report: the author drops the dead declaration
+                        // together with the array.
+                        if (orphansLocalBinding(programScope, droppedRanges)) {
+                            return null;
+                        }
                         const texts = conversionTexts();
                         return [
                             ...batchedConversions.map((conversion) => fixer.replaceText(conversion.node, texts.get(conversion.node))),

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,18 @@
 [
+  {
+    "version": "1.20.88",
+    "date": "2026-08-03T09:05:50.265Z",
+    "rules": [
+      {
+        "name": "use-latest-callback",
+        "changeType": "fix",
+        "issues": [
+          1652
+        ],
+        "summary": "decline the fix when dropping the deps array orphans a local binding (closes #1652)"
+      }
+    ]
+  },
   {
     "version": "1.20.87",
     "date": "2026-08-03T08:16:33.082Z",