@blumintinc/eslint-plugin-blumint 1.18.13 → 1.18.15

package/lib/index.js

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

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

@@ -65,9 +65,7 @@ function unwrapExpression(expr) {
     }
     return current;
 }
-function getObjectUsagesInHook(hookBody, objectName, 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-context) {
+function getObjectUsagesInHook(hookBody, objectName) {
     const usages = new Map(); // Track usage and its position
     const visited = new Set();
     let needsEntireObject = false;
@@ -133,8 +131,15 @@ context) {
             const memberExpr = current;
             // Handle computed properties (like array indices)
             if (memberExpr.computed) {
-                // For computed properties with variables (like user[key]), we need the entire object
-                if (memberExpr.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                // why: only a *literal* computed key (obj[0], obj['special-key'])
+                // narrows to a single, stable field. EVERY other computed key —
+                // Identifier (obj[i]), CallExpression (obj[assertSafe(i)]),
+                // BinaryExpression (obj[i+1]), MemberExpression (obj[keys[j]]),
+                // TSAsExpression (obj[k as K]), TemplateLiteral (obj[`row-${i}`]), etc.
+                // — is a dynamic access that can read arbitrary elements across an
+                // iteration. There is no single narrowable field, so the whole object
+                // is a legitimate dependency: resolve the base and mark it accordingly.
+                if (memberExpr.property.type !== utils_1.AST_NODE_TYPES.Literal) {
                     // Check if this is accessing our target object
                     let currentBase = unwrapExpression(memberExpr.object);
                     while (currentBase.type === utils_1.AST_NODE_TYPES.MemberExpression) {
@@ -142,35 +147,23 @@ context) {
                     }
                     if (currentBase.type === utils_1.AST_NODE_TYPES.Identifier &&
                         currentBase.name === objectName) {
-                        // This is a computed property access on our target object, so we need the entire object
+                        // This is a dynamic computed property access on our target object,
+                        // so we need the entire object (no narrowable field exists).
                         needsEntireObject = true;
                     }
                     return null;
                 }
                 // For computed properties with literals
-                if (memberExpr.property.type === utils_1.AST_NODE_TYPES.Literal) {
-                    const literalProp = memberExpr.property;
-                    if (typeof literalProp.value === 'number') {
-                        parts.unshift(`[${literalProp.value}]`);
-                    }
-                    else if (typeof literalProp.value === 'string') {
-                        parts.unshift(`[${JSON.stringify(literalProp.value)}]`);
-                    }
-                    else {
-                        // For other computed properties, use a wildcard
-                        parts.unshift('[*]');
-                    }
+                const literalProp = memberExpr.property;
+                if (typeof literalProp.value === 'number') {
+                    parts.unshift(`[${literalProp.value}]`);
+                }
+                else if (typeof literalProp.value === 'string') {
+                    parts.unshift(`[${JSON.stringify(literalProp.value)}]`);
                 }
                 else {
-                    // For other computed properties, use the exact expression
-                    try {
-                        const propertyText = context.sourceCode.getText(memberExpr.property);
-                        parts.unshift(`[${propertyText}]`);
-                    }
-                    catch (e) {
-                        // Fallback to wildcard if we can't get the source text
-                        parts.unshift('[*]');
-                    }
+                    // For other literal computed properties (e.g. boolean/null), wildcard
+                    parts.unshift('[*]');
                 }
             }
             else {
@@ -184,7 +177,7 @@ context) {
                         STRING_METHODS.has(memberExpr.property.name))) {
                     // Check if this is accessing our target object or a property of it
                     let currentBase = unwrapExpression(memberExpr.object);
-                    let pathParts = [];
+                    const pathParts = [];
                     let hasOptionalChainingInMethod = false;
                     // Build the path to the array/string being accessed
                     while (currentBase.type === utils_1.AST_NODE_TYPES.MemberExpression) {
@@ -352,7 +345,8 @@ context) {
                     effectiveParent.type === utils_1.AST_NODE_TYPES.TSNonNullExpression)) {
                 effectiveParent = effectiveParent.parent;
             }
-            const isIntermediate = effectiveParent && effectiveParent.type === utils_1.AST_NODE_TYPES.MemberExpression;
+            const isIntermediate = effectiveParent &&
+                effectiveParent.type === utils_1.AST_NODE_TYPES.MemberExpression;
             if (!isIntermediate) {
                 // Check if this member expression involves our target object
                 let current = memberExpr;
@@ -361,9 +355,12 @@ context) {
                 // Walk up the member expression chain to see if it involves our target object
                 while (current.type === utils_1.AST_NODE_TYPES.MemberExpression) {
                     const currentMember = current;
-                    // Check if this level uses dynamic computed property access
+                    // Check if this level uses dynamic computed property access.
+                    // why: any non-literal computed key reads arbitrary elements, so it
+                    // requires the entire object. Only a literal key (obj[0], obj['k'])
+                    // narrows to a single, stable field.
                     if (currentMember.computed &&
-                        currentMember.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        currentMember.property.type !== utils_1.AST_NODE_TYPES.Literal) {
                         hasDynamicComputed = true;
                     }
                     current = unwrapExpression(currentMember.object);
@@ -582,7 +579,7 @@ exports.noEntireObjectHookDeps = (0, createRule_1.createRule)({
                             }
                         }
                         // For testing without TypeScript services, we'll assume all identifiers are objects
-                        const result = getObjectUsagesInHook(callbackArg.body, objectName, context);
+                        const result = getObjectUsagesInHook(callbackArg.body, objectName);
                         // If the object is not used at all, suggest removing it
                         if (result.notUsed) {
                             context.report({

package/lib/rules/react-memoize-literals.js

@@ -100,11 +100,18 @@ function isHookName(name) {
 }
 /**
  * Detects PascalCase identifiers commonly used for React components.
+ *
+ * SCREAMING_SNAKE_CASE names (`CHANNEL_OPTIONS`, `MAX_COUNT`, `SPACING`) are
+ * constants by convention, not components, so they are excluded even though
+ * they begin with an uppercase letter. Treating them as components would
+ * misclassify a module-scope constant's `.map`/`.filter` callback body as a
+ * render body and flag literals that are only ever built once at import.
  * @param name Candidate identifier name.
- * @returns True when the name begins with an uppercase character.
+ * @returns True when the name is PascalCase (starts uppercase and contains a
+ * lowercase letter), false for all-caps constants.
  */
 function isComponentName(name) {
-    return !!name && /^[A-Z]/.test(name);
+    return !!name && /^[A-Z]/.test(name) && !/^[A-Z][A-Z0-9_]*$/.test(name);
 }
 /**
  * True when `node` is a function literal passed directly as an argument to an

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,32 @@
 [
+  {
+    "version": "1.18.15",
+    "date": "2026-07-13T15:25:03.959Z",
+    "rules": [
+      {
+        "name": "react-memoize-literals",
+        "changeType": "fix",
+        "issues": [
+          1292
+        ],
+        "summary": "exclude SCREAMING_SNAKE_CASE constants from component detection (closes #1292)"
+      }
+    ]
+  },
+  {
+    "version": "1.18.14",
+    "date": "2026-07-13T08:30:23.444Z",
+    "rules": [
+      {
+        "name": "no-entire-object-hook-deps",
+        "changeType": "fix",
+        "issues": [
+          1291
+        ],
+        "summary": "treat non-literal computed keys as whole-object access (closes #1291)"
+      }
+    ]
+  },
   {
     "version": "1.18.13",
     "date": "2026-07-13T01:43:11.918Z",