@blumintinc/eslint-plugin-blumint 1.20.54 → 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.54',
+        version: '1.20.56',
     },
     parseOptions: {
         ecmaVersion: 2020,

package/lib/rules/enforce-boolean-naming-prefixes.js

@@ -1219,40 +1219,12 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
             }
         }
         /**
-         * Check class property definitions for boolean values
-         */
-        function checkClassProperty(node) {
-            if (node.key.type !== utils_1.AST_NODE_TYPES.Identifier)
-                return;
-            const propertyName = node.key.name;
-            // Check if it's a boolean property
-            let isBooleanProperty = false;
-            // Check if it has a boolean type annotation
-            if (node.typeAnnotation?.typeAnnotation &&
-                node.typeAnnotation.typeAnnotation.type ===
-                    utils_1.AST_NODE_TYPES.TSBooleanKeyword) {
-                isBooleanProperty = true;
-            }
-            // Check if it's initialized with a boolean value
-            if (node.value?.type === utils_1.AST_NODE_TYPES.Literal &&
-                typeof node.value.value === 'boolean') {
-                isBooleanProperty = true;
-            }
-            if (isBooleanProperty && !hasApprovedPrefix(propertyName)) {
-                context.report({
-                    node: node.key,
-                    messageId: 'missingBooleanPrefix',
-                    data: {
-                        type: 'property',
-                        name: propertyName,
-                        capitalizedName: capitalizeFirst(propertyName),
-                        prefixes: formatPrefixes(),
-                    },
-                });
-            }
-        }
-        /**
-         * Check class property declarations for boolean values
+         * Check class property declarations for boolean values.
+         *
+         * Handles both concrete (`PropertyDefinition`) and abstract
+         * (`TSAbstractPropertyDefinition`) fields: an abstract field is a
+         * declaration the author owns and every implementer inherits the name from,
+         * so it carries the same naming obligation as a concrete one.
          */
         function checkClassPropertyDeclaration(node) {
             if (node.key.type !== utils_1.AST_NODE_TYPES.Identifier)
@@ -1383,6 +1355,43 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                 }
             }
         }
+        /**
+         * Check constructor parameter properties (`constructor(private enabled: boolean) {}`)
+         * for boolean values.
+         *
+         * An access modifier turns a constructor parameter into a declared class
+         * field, so it is reported as a `property` rather than a `parameter`. The
+         * generic parameter visitor never sees these names — `TSParameterProperty`
+         * wraps the identifier — so this is the single report site for them.
+         */
+        function checkParameterProperty(node) {
+            // A default value wraps the identifier again: `private enabled = true`
+            // parses as an AssignmentPattern whose left holds the name and annotation.
+            const { parameter } = node;
+            const isDefaulted = parameter.type === utils_1.AST_NODE_TYPES.AssignmentPattern;
+            const target = isDefaulted ? parameter.left : parameter;
+            if (target.type !== utils_1.AST_NODE_TYPES.Identifier)
+                return;
+            const propertyName = target.name;
+            const hasBooleanAnnotation = target.typeAnnotation?.typeAnnotation.type ===
+                utils_1.AST_NODE_TYPES.TSBooleanKeyword;
+            const initializer = isDefaulted ? parameter.right : undefined;
+            const hasBooleanInitializer = initializer?.type === utils_1.AST_NODE_TYPES.Literal &&
+                typeof initializer.value === 'boolean';
+            if ((hasBooleanAnnotation || hasBooleanInitializer) &&
+                !hasApprovedPrefix(propertyName)) {
+                context.report({
+                    node: target,
+                    messageId: 'missingBooleanPrefix',
+                    data: {
+                        type: 'property',
+                        name: propertyName,
+                        capitalizedName: capitalizeFirst(propertyName),
+                        prefixes: formatPrefixes(),
+                    },
+                });
+            }
+        }
         return {
             VariableDeclarator: checkVariableDeclaration,
             FunctionDeclaration: checkFunctionDeclaration,
@@ -1398,8 +1407,9 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
             },
             MethodDefinition: checkMethodDefinition,
             TSAbstractMethodDefinition: checkMethodDefinition,
-            ClassProperty: checkClassProperty,
             PropertyDefinition: checkClassPropertyDeclaration,
+            TSAbstractPropertyDefinition: checkClassPropertyDeclaration,
+            TSParameterProperty: checkParameterProperty,
             TSPropertySignature: checkPropertySignature,
             Identifier(node) {
                 // Check parameter names in function declarations

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.54",
+  "version": "1.20.56",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",

package/release-manifest.json

@@ -1,4 +1,32 @@
 [
+  {
+    "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",
+    "rules": [
+      {
+        "name": "enforce-boolean-naming-prefixes",
+        "changeType": "fix",
+        "issues": [
+          1545
+        ],
+        "summary": "check abstract properties and constructor parameter properties (closes #1545)"
+      }
+    ]
+  },
   {
     "version": "1.20.54",
     "date": "2026-08-01T01:37:34.774Z",