@blumintinc/eslint-plugin-blumint 1.19.27 → 1.19.29

package/lib/index.js

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

package/lib/rules/enforce-id-capitalization.js

@@ -27,6 +27,21 @@ exports.enforceIdCapitalization = (0, createRule_1.createRule)({
         // Regular expression to match standalone "id" surrounded by whitespace or punctuation
         // This ensures we only match "id" as a word, not as part of another word
         const idRegex = /(^|\s|[.,;:!?'"()\[\]{}])id(\s|$|[.,;:!?'"()\[\]{}])/g;
+        // DOM / Testing-Library APIs whose first argument is an attribute NAME
+        // (code), not user-facing text. A literal like 'id' passed here is a DOM
+        // attribute name; flagging or rewriting it to 'ID' breaks the call.
+        const ATTRIBUTE_NAME_METHODS = new Set([
+            'getAttribute',
+            'setAttribute',
+            'hasAttribute',
+            'removeAttribute',
+            'getAttributeNode',
+            'getAttributeNS',
+            'setAttributeNS',
+            'hasAttributeNS',
+            'removeAttributeNS',
+            'toHaveAttribute',
+        ]);
         /**
          * Check if a node is in a context that should be excluded from the rule
          * (e.g., parameter names, property names, type definitions)
@@ -82,6 +97,24 @@ exports.enforceIdCapitalization = (0, createRule_1.createRule)({
             if (node.parent && node.parent.type === utils_1.AST_NODE_TYPES.MemberExpression) {
                 return true;
             }
+            // Check if the node is the attribute-name argument of a DOM / jest-dom
+            // attribute API call, e.g. element.getAttribute('id') or
+            // expect(el).toHaveAttribute('id', ...). The attribute name is code, not
+            // user-facing text. For the *NS variants the name is the second argument
+            // (the first is the namespace URI); otherwise it is the first argument.
+            if (node.parent &&
+                node.parent.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                node.parent.callee &&
+                node.parent.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                node.parent.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                ATTRIBUTE_NAME_METHODS.has(node.parent.callee.property.name)) {
+                const nameArgIndex = node.parent.callee.property.name.endsWith('NS')
+                    ? 1
+                    : 0;
+                if (node.parent.arguments[nameArgIndex] === node) {
+                    return true;
+                }
+            }
             // Check if the node is a string literal used for property access
             // This handles cases like obj['id'] or OverwolfGame['id']
             if (node.parent &&

package/lib/rules/memo-nested-react-components.js

@@ -339,6 +339,35 @@ const returnExpressionIsJsx = (expression) => {
     return (unwrapped.type === utils_1.AST_NODE_TYPES.JSXElement ||
         unwrapped.type === utils_1.AST_NODE_TYPES.JSXFragment);
 };
+/**
+ * True when the expression is a `memo(...)` / `forwardRef(...)` call. Returned
+ * from a useMemo/useDeepCompareMemo callback, this is the complete, sanctioned
+ * stabilization pattern: the memo hook stabilizes the component *identity*
+ * across re-renders (a new identity only on a deps change), so the inner
+ * component never remounts on an ordinary re-render—the exact harm this rule
+ * exists to prevent does not occur.
+ */
+const returnExpressionIsMemoOrForwardRefCall = (expression, reactImports) => {
+    if (!expression) {
+        return false;
+    }
+    const unwrapped = unwrapExpression(expression);
+    return (unwrapped.type === utils_1.AST_NODE_TYPES.CallExpression &&
+        (isMemoCall(unwrapped, reactImports) ||
+            isForwardRefCall(unwrapped, reactImports)));
+};
+/**
+ * True when a useMemo/useDeepCompareMemo callback directly returns a
+ * memo()/forwardRef()-wrapped component. The memo hook stabilizes the returned
+ * component's identity, so such a binding does not remount on re-render and
+ * must not be flagged.
+ */
+const memoCallbackReturnsMemoizedComponent = (callback, reactImports) => {
+    if (!isFunctionExpression(callback)) {
+        return false;
+    }
+    return collectDirectReturnExpressions(callback).some((expression) => returnExpressionIsMemoOrForwardRefCall(expression, reactImports));
+};
 /**
  * Direct return-statement arguments of a function, traversing control flow
  * (if/switch/try/loops) but NOT descending into nested function definitions—
@@ -486,6 +515,12 @@ See: https://react.dev/learn/your-first-component#nesting-and-organizing-compone
                         // Returns JSX directly, so it's an element, not a component
                         return;
                     }
+                    // A memo()/forwardRef()-wrapped return is identity-stabilized by the
+                    // memo hook, so it does not remount on re-render and must not be
+                    // flagged (see #1336). Bare inner components stay flagged.
+                    if (memoCallbackReturnsMemoizedComponent(callback, reactImports)) {
+                        return;
+                    }
                 }
                 const variableName = getVariableName(node);
                 // A non-PascalCase binding (e.g. renderHit) is a render callback used

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,32 @@
 [
+  {
+    "version": "1.19.29",
+    "date": "2026-07-23T21:23:38.334Z",
+    "rules": [
+      {
+        "name": "enforce-id-capitalization",
+        "changeType": "fix",
+        "issues": [
+          1337
+        ],
+        "summary": "exempt DOM attribute-name arguments (closes #1337)"
+      }
+    ]
+  },
+  {
+    "version": "1.19.28",
+    "date": "2026-07-23T17:25:39.744Z",
+    "rules": [
+      {
+        "name": "memo-nested-react-components",
+        "changeType": "fix",
+        "issues": [
+          1336
+        ],
+        "summary": "exempt memo/forwardRef components returned from useMemo/useDeepCompareMemo callbacks (closes #1336)"
+      }
+    ]
+  },
   {
     "version": "1.19.27",
     "date": "2026-07-23T04:26:05.419Z",