@blumintinc/eslint-plugin-blumint 1.20.42 → 1.20.43

package/lib/index.js

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

package/lib/rules/enforce-callback-memo.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const createRule_1 = require("../utils/createRule");
 const utils_1 = require("@typescript-eslint/utils");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 exports.default = (0, createRule_1.createRule)({
     name: 'enforce-callback-memo',
     meta: {
@@ -194,6 +195,14 @@ exports.default = (0, createRule_1.createRule)({
                 node.value.type !== utils_1.AST_NODE_TYPES.JSXExpressionContainer) {
                 return;
             }
+            // The only remediation this rule offers is a hook call, which is legal
+            // solely inside a component or a hook. Module-scope JSX, a plain helper
+            // that happens to build JSX, and JSX rendered from a test body are all
+            // outside any render path, so wrapping there would throw
+            // "Invalid hook call" while saving no re-render.
+            if (!ASTHelpers_1.ASTHelpers.isInsideComponentOrHook(node, context)) {
+                return;
+            }
             // Props of JSX built inside a useMemo factory inherit the memo's stability
             if (isInsideUseMemoFactory(node)) {
                 return;

package/lib/utils/ASTHelpers.d.ts

@@ -61,6 +61,47 @@ export declare class ASTHelpers {
      * parenthesized expressions to get to the underlying expression.
      */
     static unwrapTSAssertions(node: TSESTree.Node): TSESTree.Node;
+    /**
+     * Calls that wrap a component/hook definition without renaming it, so the
+     * binding they are assigned to still names the wrapped function
+     * (`const Component = memo(() => ...)`).
+     */
+    private static readonly TRANSPARENT_WRAPPER_CALLEES;
+    private static isFunctionNode;
+    private static isTransparentWrapperCall;
+    private static staticPropertyName;
+    /**
+     * Resolves the name a function is known by: its own identifier, or the
+     * binding it is assigned to (variable, object property, class field,
+     * assignment target). Returns null only when the function is truly
+     * anonymous, e.g. an inline callback argument such as `items.map(() => ...)`.
+     */
+    static inferFunctionName(node: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression | TSESTree.FunctionDeclaration): string | null;
+    /**
+     * React's universal convention: only PascalCase-initial identifiers are
+     * components, and only `use`-prefixed ones are hooks. A camelCase name is a
+     * plain helper or a render-prop callback.
+     */
+    private static isComponentOrHookName;
+    /**
+     * Reports whether a node sits anywhere inside a React component or hook, so a
+     * rule whose remediation is a hook call (useCallback/useMemo/useState) can
+     * stay silent where that call would be a Rules-of-Hooks violation: module
+     * scope, a plain helper function, or a test body such as `it(() => ...)`.
+     *
+     * The whole enclosing-function ancestry is consulted, not just the nearest
+     * function: a `.map()` render callback inside a component is still a render
+     * path and must stay reportable.
+     *
+     * Classification is name-first. A function the developer named is judged by
+     * that name alone — `buildTree` is not a component even though it returns
+     * JSX, because the name is an explicit signal about its role. Only a truly
+     * anonymous function falls back to "does it return JSX", which is what makes
+     * `memo(() => <div />)` a component. That fallback is suppressed when some
+     * enclosing function carries a non-component name, since a callback nested in
+     * a plain helper is no more of a render path than the helper itself.
+     */
+    static isInsideComponentOrHook(node: TSESTree.Node, context?: Readonly<TSESLint.RuleContext<string, readonly unknown[]>>): boolean;
     /**
      * Helper to get ancestors of a node in a way that is compatible with both ESLint v8 and v9.
      * In ESLint v9, context.getAncestors() is deprecated and moved to context.sourceCode.getAncestors(node).

package/lib/utils/ASTHelpers.js

@@ -661,6 +661,140 @@ class ASTHelpers {
         }
         return inner;
     }
+    static isFunctionNode(node) {
+        return (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+            node.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+            node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration);
+    }
+    static isTransparentWrapperCall(node) {
+        const { callee } = node;
+        if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+            return this.TRANSPARENT_WRAPPER_CALLEES.has(callee.name);
+        }
+        return (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+            !callee.computed &&
+            callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+            this.TRANSPARENT_WRAPPER_CALLEES.has(callee.property.name));
+    }
+    static staticPropertyName(key, computed) {
+        if (computed) {
+            return null;
+        }
+        if (key.type === utils_1.AST_NODE_TYPES.Identifier) {
+            return key.name;
+        }
+        if (key.type === utils_1.AST_NODE_TYPES.Literal && typeof key.value === 'string') {
+            return key.value;
+        }
+        return null;
+    }
+    /**
+     * Resolves the name a function is known by: its own identifier, or the
+     * binding it is assigned to (variable, object property, class field,
+     * assignment target). Returns null only when the function is truly
+     * anonymous, e.g. an inline callback argument such as `items.map(() => ...)`.
+     */
+    static inferFunctionName(node) {
+        if (node.id?.name) {
+            return node.id.name;
+        }
+        let child = node;
+        let parent = node.parent;
+        while (parent) {
+            switch (parent.type) {
+                case utils_1.AST_NODE_TYPES.VariableDeclarator:
+                    return parent.id.type === utils_1.AST_NODE_TYPES.Identifier
+                        ? parent.id.name
+                        : null;
+                case utils_1.AST_NODE_TYPES.Property:
+                    return this.staticPropertyName(parent.key, parent.computed);
+                case utils_1.AST_NODE_TYPES.PropertyDefinition:
+                case utils_1.AST_NODE_TYPES.MethodDefinition:
+                    return this.staticPropertyName(parent.key, parent.computed);
+                case utils_1.AST_NODE_TYPES.AssignmentExpression: {
+                    const { left } = parent;
+                    if (left.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        return left.name;
+                    }
+                    if (left.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                        return this.staticPropertyName(left.property, left.computed);
+                    }
+                    return null;
+                }
+                case utils_1.AST_NODE_TYPES.TSAsExpression:
+                case utils_1.AST_NODE_TYPES.TSSatisfiesExpression:
+                case utils_1.AST_NODE_TYPES.TSNonNullExpression:
+                case utils_1.AST_NODE_TYPES.TSTypeAssertion:
+                    child = parent;
+                    parent = parent.parent;
+                    continue;
+                case utils_1.AST_NODE_TYPES.CallExpression:
+                    // Only step through wrappers that preserve identity; an arbitrary
+                    // callback argument (`items.map(fn)`) is not named by whatever the
+                    // call's result is assigned to.
+                    if (parent.arguments.includes(child) &&
+                        this.isTransparentWrapperCall(parent)) {
+                        child = parent;
+                        parent = parent.parent;
+                        continue;
+                    }
+                    return null;
+                default:
+                    return null;
+            }
+        }
+        return null;
+    }
+    /**
+     * React's universal convention: only PascalCase-initial identifiers are
+     * components, and only `use`-prefixed ones are hooks. A camelCase name is a
+     * plain helper or a render-prop callback.
+     */
+    static isComponentOrHookName(name) {
+        return /^[A-Z]/.test(name) || /^use[A-Z0-9_]/.test(name);
+    }
+    /**
+     * Reports whether a node sits anywhere inside a React component or hook, so a
+     * rule whose remediation is a hook call (useCallback/useMemo/useState) can
+     * stay silent where that call would be a Rules-of-Hooks violation: module
+     * scope, a plain helper function, or a test body such as `it(() => ...)`.
+     *
+     * The whole enclosing-function ancestry is consulted, not just the nearest
+     * function: a `.map()` render callback inside a component is still a render
+     * path and must stay reportable.
+     *
+     * Classification is name-first. A function the developer named is judged by
+     * that name alone — `buildTree` is not a component even though it returns
+     * JSX, because the name is an explicit signal about its role. Only a truly
+     * anonymous function falls back to "does it return JSX", which is what makes
+     * `memo(() => <div />)` a component. That fallback is suppressed when some
+     * enclosing function carries a non-component name, since a callback nested in
+     * a plain helper is no more of a render path than the helper itself.
+     */
+    static isInsideComponentOrHook(node, context) {
+        const anonymousFunctions = [];
+        let hasNamedNonComponent = false;
+        let current = node.parent;
+        while (current) {
+            if (this.isFunctionNode(current)) {
+                const name = this.inferFunctionName(current);
+                if (name === null) {
+                    anonymousFunctions.push(current);
+                }
+                else if (this.isComponentOrHookName(name)) {
+                    return true;
+                }
+                else {
+                    hasNamedNonComponent = true;
+                }
+            }
+            current = current.parent;
+        }
+        if (hasNamedNonComponent) {
+            return false;
+        }
+        return anonymousFunctions.some((fn) => this.returnsJSX(fn, context));
+    }
     /**
      * Helper to get ancestors of a node in a way that is compatible with both ESLint v8 and v9.
      * In ESLint v9, context.getAncestors() is deprecated and moved to context.sourceCode.getAncestors(node).
@@ -671,5 +805,17 @@ class ASTHelpers {
             (context.getAncestors ? context.getAncestors() : []));
     }
 }
+/**
+ * Calls that wrap a component/hook definition without renaming it, so the
+ * binding they are assigned to still names the wrapped function
+ * (`const Component = memo(() => ...)`).
+ */
+ASTHelpers.TRANSPARENT_WRAPPER_CALLEES = new Set([
+    'forwardRef',
+    'memo',
+    'observer',
+    'useCallback',
+    'useMemo',
+]);
 exports.ASTHelpers = ASTHelpers;
 //# sourceMappingURL=ASTHelpers.js.map

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,18 @@
 [
+  {
+    "version": "1.20.43",
+    "date": "2026-07-31T04:38:54.532Z",
+    "rules": [
+      {
+        "name": "enforce-callback-memo",
+        "changeType": "fix",
+        "issues": [
+          1496
+        ],
+        "summary": "only report inside a component or hook (closes #1496)"
+      }
+    ]
+  },
   {
     "version": "1.20.42",
     "date": "2026-07-31T04:16:11.179Z",