@blumintinc/eslint-plugin-blumint 1.18.14 → 1.18.16

package/lib/index.js

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

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

@@ -92,11 +92,39 @@ const isHookCall = (callee) => {
     }
     return null;
 };
+/**
+ * Recognizes a callee named exactly `name`, whether a bare identifier (`memo`)
+ * or a non-computed member access (`X.memo`), regardless of import source.
+ *
+ * memo/forwardRef are commonly re-exported from project-local wrapper modules
+ * (e.g. `import { memo } from 'src/util/memo'`, which the sibling
+ * `use-custom-memo` rule actively enforces). Resolving these purely against
+ * react's import table would miss the wrapper form and misclassify an HOC
+ * factory as a render body. By-name recognition is safe here because callers
+ * are already gated by PascalCase naming and the surrounding factory analysis.
+ *
+ * Note: this deliberately does NOT apply to `createElement`, which must stay
+ * bound to a react import so unrelated factories (e.g. `Factory.createElement`)
+ * are not misread as element creation.
+ */
+const calleeMatchesName = (callee, name) => {
+    if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return callee.name === name;
+    }
+    if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        !callee.computed &&
+        callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return callee.property.name === name;
+    }
+    return false;
+};
 const isForwardRefCall = (node, reactImports) => {
-    return calleeMatchesReactMember(node.callee, reactImports, 'forwardRef');
+    return (calleeMatchesReactMember(node.callee, reactImports, 'forwardRef') ||
+        calleeMatchesName(node.callee, 'forwardRef'));
 };
 const isMemoCall = (node, reactImports) => {
-    return calleeMatchesReactMember(node.callee, reactImports, 'memo');
+    return (calleeMatchesReactMember(node.callee, reactImports, 'memo') ||
+        calleeMatchesName(node.callee, 'memo'));
 };
 const filterPresentResults = (results) => {
     return results.filter((result) => Boolean(result));

package/lib/rules/no-hungarian.js

@@ -298,6 +298,15 @@ function isDomainNumberCompound(name) {
     const lastSegment = segments[segments.length - 1];
     return (!!lastSegment && DOMAIN_NUMBER_HEAD_NOUNS.has(lastSegment.toLowerCase()));
 }
+// Rebuild a SCREAMING_SNAKE_CASE identifier's segments into a PascalCase compound
+// (["MATCH","NUMBER"] -> "MatchNumber") so the snake-case branch can reuse the
+// camelCase isDomainNumberCompound / DOMAIN_NUMBER_HEAD_NOUNS exemption verbatim,
+// keeping MATCH_NUMBER and matchNumber on a single code path (#1294).
+function screamingSnakePartsToPascalCase(parts) {
+    return parts
+        .map((part) => part.charAt(0) + part.slice(1).toLowerCase())
+        .join('');
+}
 exports.noHungarian = (0, createRule_1.createRule)({
     name: 'no-hungarian',
     meta: {
@@ -387,12 +396,31 @@ exports.noHungarian = (0, createRule_1.createRule)({
                         if (isAbbreviation) {
                             return true;
                         }
-                        // A FULL type word tags the entity's type only at the start (prefix),
-                        // the end (suffix), or directly before the final noun
-                        // (..._STRING_NAME). Buried deeper (EDITABLE_WRAPPER_NUMBER_PROPS_…)
-                        // it qualifies an intermediate segment — a descriptive variant, not a
-                        // type tag.
-                        return (index === 0 || index === lastIndex || index === lastIndex - 1);
+                        // A FULL type word tags the entity's runtime type only as a genuine
+                        // leading prefix (index 0) or trailing head-noun (last segment).
+                        // Mirror the camelCase/PascalCase branch, which never flags a
+                        // full-type-word in a MIDDLE segment: an interior NUMBER/STRING is a
+                        // domain modifier describing a variant (CADENCE_NUMBER_EDITORS —
+                        // "editors of a numeric cadence"), not a redundant type tag. The
+                        // previous `index === lastIndex - 1` allowance produced a casing
+                        // asymmetry — CadenceNumberEditor was exempt (#1250) but
+                        // CADENCE_NUMBER_EDITORS fired (#1294).
+                        if (index !== 0 && index !== lastIndex) {
+                            return false;
+                        }
+                        // A trailing "..._NUMBER" whose preceding head noun is a domain
+                        // entity (MATCH_NUMBER, ISSUE_NUMBER, CURRENT_LINE_NUMBER) is a
+                        // domain compound, not a Hungarian type tag — route through the same
+                        // isDomainNumberCompound carve-out used for camelCase matchNumber
+                        // (#1277), so numeric-quantity heads (COUNT_NUMBER, MAX_RETRY_NUMBER)
+                        // still fire because those heads are absent from
+                        // DOMAIN_NUMBER_HEAD_NOUNS.
+                        if (normalizedMarker === 'number' &&
+                            index === lastIndex &&
+                            isDomainNumberCompound(screamingSnakePartsToPascalCase(parts))) {
+                            return false;
+                        }
+                        return true;
                     });
                 });
             }

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

package/release-manifest.json

@@ -1,4 +1,40 @@
 [
+  {
+    "version": "1.18.16",
+    "date": "2026-07-13T17:31:09.661Z",
+    "rules": [
+      {
+        "name": "memo-nested-react-components",
+        "changeType": "fix",
+        "issues": [
+          1293
+        ],
+        "summary": "recognize project-local memo/forwardRef re-exports in HOC-factory escape hatch (closes #1293)"
+      },
+      {
+        "name": "no-hungarian",
+        "changeType": "fix",
+        "issues": [
+          1294
+        ],
+        "summary": "exempt interior type-word segments in SCREAMING_SNAKE_CASE constants (closes #1294)"
+      }
+    ]
+  },
+  {
+    "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",