@blumintinc/eslint-plugin-blumint 1.20.55 → 1.20.56

package/lib/index.js

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

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

@@ -5,10 +5,25 @@ const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const typescript_1 = require("typescript");
 const HOOK_NAMES = new Set(['useEffect', 'useCallback', 'useMemo']);
+/**
+ * Hooks that run for their side effects rather than producing a value. An
+ * unread dependency means something different here than in useMemo/useCallback
+ * — see `callsCorrespondingSetter`.
+ */
+const EFFECT_HOOK_NAMES = new Set(['useEffect']);
 function isHookCall(node) {
     const callee = node.callee;
     return (callee.type === utils_1.AST_NODE_TYPES.Identifier && HOOK_NAMES.has(callee.name));
 }
+function isEffectHookCall(node) {
+    const callee = node.callee;
+    return (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+        EFFECT_HOOK_NAMES.has(callee.name));
+}
+/** `channelGroupActive` -> `setChannelGroupActive`, `a` -> `setA`. */
+function toSetterName(dependencyName) {
+    return `set${dependencyName.charAt(0).toUpperCase()}${dependencyName.slice(1)}`;
+}
 function isArrayOrPrimitive(checker, esTreeNode, nodeMap) {
     try {
         const tsNode = nodeMap.get(esTreeNode);
@@ -80,6 +95,55 @@ function unwrapExpression(expr) {
     }
     return current;
 }
+/**
+ * Whether the hook body anywhere calls the state setter that corresponds to
+ * `dependencyName` (dep `count` -> `setCount(...)`).
+ *
+ * why: for an effect, an unread dependency is React's reset-on-scope-change
+ * idiom — a deliberate re-run trigger. The one shape where an unread dependency
+ * is genuinely wrong is the circular dependency, where the effect writes the
+ * very value it depends on and so re-triggers itself. The setter call is that
+ * signature. It can sit arbitrarily deep (inside an inner async function, a
+ * `startTransition` callback, a `.then()`), so the whole body is searched.
+ */
+function callsCorrespondingSetter(hookBody, dependencyName) {
+    const setterName = toSetterName(dependencyName);
+    const visited = new Set();
+    function visit(node) {
+        if (!node || visited.has(node))
+            return false;
+        visited.add(node);
+        if (node.type === utils_1.AST_NODE_TYPES.CallExpression) {
+            const callee = unwrapExpression(node.callee);
+            if (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                callee.name === setterName) {
+                return true;
+            }
+        }
+        for (const key in node) {
+            if (key === 'parent')
+                continue; // Skip parent references to avoid cycles
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const child = node[key];
+            if (!child || typeof child !== 'object')
+                continue;
+            if (Array.isArray(child)) {
+                for (const item of child) {
+                    if (item && typeof item === 'object' && 'type' in item) {
+                        if (visit(item))
+                            return true;
+                    }
+                }
+            }
+            else if ('type' in child) {
+                if (visit(child))
+                    return true;
+            }
+        }
+        return false;
+    }
+    return visit(hookBody);
+}
 function getObjectUsagesInHook(hookBody, objectName) {
     const usages = new Map(); // Track usage and its position
     // why: derived dependency paths (first-optional intermediate, array base)
@@ -562,6 +626,8 @@ exports.noEntireObjectHookDeps = (0, createRule_1.createRule)({
                         callbackArg.type !== utils_1.AST_NODE_TYPES.FunctionExpression)) {
                     return;
                 }
+                const callbackBody = callbackArg.body;
+                const isEffect = isEffectHookCall(node);
                 // Check each dependency in the array
                 depsArg.elements.forEach((element) => {
                     const unwrappedElement = element ? unwrapExpression(element) : null;
@@ -579,9 +645,20 @@ exports.noEntireObjectHookDeps = (0, createRule_1.createRule)({
                             }
                         }
                         // For testing without TypeScript services, we'll assume all identifiers are objects
-                        const result = getObjectUsagesInHook(callbackArg.body, objectName);
+                        const result = getObjectUsagesInHook(callbackBody, objectName);
                         // If the object is not used at all, suggest removing it
                         if (result.notUsed) {
+                            // why: an effect reruns for its side effects, so a dependency the
+                            // body never reads is normally a deliberate re-run trigger
+                            // (React's reset-on-scope-change idiom) — deleting it silently
+                            // stops the effect from rerunning. Only when the body also writes
+                            // that value (setX for dep x) is the dependency a circular one
+                            // worth removing. Value-producing hooks (useMemo/useCallback)
+                            // gain nothing from an unread dependency, so they still report.
+                            if (isEffect &&
+                                !callsCorrespondingSetter(callbackBody, objectName)) {
+                                return;
+                            }
                             context.report({
                                 node: element,
                                 messageId: 'removeUnusedDependency',

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,18 @@
 [
+  {
+    "version": "1.20.56",
+    "date": "2026-08-01T03:08:15.343Z",
+    "rules": [
+      {
+        "name": "no-entire-object-hook-deps",
+        "changeType": "fix",
+        "issues": [
+          1546
+        ],
+        "summary": "treat unread useEffect deps as re-run triggers unless the effect sets them (closes #1546)"
+      }
+    ]
+  },
   {
     "version": "1.20.55",
     "date": "2026-08-01T02:47:13.295Z",