@blumintinc/eslint-plugin-blumint 1.20.119 → 1.20.121

package/lib/index.js

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

package/lib/rules/enforce-dynamic-firebase-imports.js

@@ -6,8 +6,8 @@ const isFunctionNode = (node) => node.type === utils_1.AST_NODE_TYPES.ArrowFunct
     node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
     node.type === utils_1.AST_NODE_TYPES.FunctionExpression;
 /**
- * Walks outward from a reference to the innermost `async` function whose block
- * body contains it.
+ * Walks outward from a reference to the innermost `async` function whose body
+ * both contains it and satisfies `hostsDeclaration`.
  *
  * A reference sitting in a *synchronous* callback nested inside an async
  * function still resolves once the declaration heads the async body, because
@@ -19,12 +19,12 @@ const isFunctionNode = (node) => node.type === utils_1.AST_NODE_TYPES.ArrowFunct
  * before the body runs, so a declaration at the top of the body would come too
  * late for it.
  */
-const enclosingAsyncBodyOf = (identifier) => {
+const enclosingAsyncFunctionOf = (identifier, hostsDeclaration) => {
     let current = identifier.parent;
     while (current) {
         if (isFunctionNode(current) &&
             current.async &&
-            current.body.type === utils_1.AST_NODE_TYPES.BlockStatement &&
+            hostsDeclaration(current) &&
             identifier.range[0] >= current.body.range[0] &&
             identifier.range[1] <= current.body.range[1]) {
             return current;
@@ -33,6 +33,16 @@ const enclosingAsyncBodyOf = (identifier) => {
     }
     return undefined;
 };
+const enclosingAsyncBodyOf = (identifier) => enclosingAsyncFunctionOf(identifier, (fn) => fn.body.type === utils_1.AST_NODE_TYPES.BlockStatement);
+/**
+ * The innermost `async` arrow whose *concise* body holds the reference.
+ *
+ * A concise body is a single expression with no statement list to head, so the
+ * declaration only becomes expressible once the arrow gains a block. That is a
+ * larger edit than heading an existing body, which is why this search runs only
+ * for references no async block encloses — an enclosing block always wins.
+ */
+const enclosingConciseAsyncArrowOf = (identifier) => enclosingAsyncFunctionOf(identifier, (fn) => fn.body.type !== utils_1.AST_NODE_TYPES.BlockStatement);
 const THIRD_PARTY_DIRECTORY = /(^|\/)node_modules(\/|$)/;
 // Anchored at the end of the path so multi-part suffixes such as
 // `useStartMatch.integration.test.ts` are recognized while production modules
@@ -174,7 +184,8 @@ const enforceFirebaseImports = (0, createRule_1.createRule)({
                     }
                     let target;
                     for (const reference of references) {
-                        const enclosing = enclosingAsyncBodyOf(reference.identifier);
+                        const enclosing = enclosingAsyncBodyOf(reference.identifier) ??
+                            enclosingConciseAsyncArrowOf(reference.identifier);
                         if (!enclosing || (target && target !== enclosing)) {
                             return undefined;
                         }
@@ -205,12 +216,50 @@ const enforceFirebaseImports = (0, createRule_1.createRule)({
                     }
                     return cursor;
                 };
+                /**
+                 * Gives a concise-bodied arrow the block its declaration needs, turning
+                 * the returned expression into an explicit `return`.
+                 *
+                 * The expression is spliced verbatim out of the source rather than
+                 * reprinted from the AST: the parentheses around an object literal are
+                 * not part of its node, and a comment sitting between `=>` and the
+                 * expression belongs to neither, so both survive only by copying the
+                 * text the arrow already owns.
+                 */
+                const blockifyConciseBody = (fixer, arrow, statements) => {
+                    const arrowToken = sourceCode.getTokenBefore(arrow.body, {
+                        filter: (token) => token.type === utils_1.AST_TOKEN_TYPES.Punctuator && token.value === '=>',
+                    });
+                    if (!arrowToken) {
+                        return null;
+                    }
+                    const expression = sourceCode
+                        .getText()
+                        .slice(arrowToken.range[1], arrow.range[1])
+                        .trim();
+                    const indent = indentationAt(arrow.loc.start.line);
+                    const bodyIndent = `${indent}  `;
+                    const lines = [...statements, `return ${expression};`]
+                        .map((statement) => `\n${bodyIndent}${statement}`)
+                        .join('');
+                    return fixer.replaceTextRange([arrowToken.range[1], arrow.range[1]], ` {${lines}\n${indent}}`);
+                };
                 const buildFix = (fixer) => {
                     const target = findRelocationTarget();
                     const statements = buildValueStatements();
                     if (!target || statements.length === 0) {
                         return null;
                     }
+                    // Type-only specifiers are erased at compile time, so they stay where
+                    // they are instead of riding along into the function body.
+                    const importEdit = typeOnlySpecifiers.length > 0
+                        ? fixer.replaceText(node, `import type { ${buildTypeNames()} } from '${importPath}';`)
+                        : fixer.removeRange([node.range[0], removalEnd()]);
+                    if (target.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+                        target.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+                        const blockified = blockifyConciseBody(fixer, target, statements);
+                        return blockified ? [importEdit, blockified] : null;
+                    }
                     const body = target.body;
                     // A directive stops being a directive the moment a declaration
                     // precedes it, so `'use server'` on a server action would silently
@@ -239,11 +288,7 @@ const enforceFirebaseImports = (0, createRule_1.createRule)({
                         })
                             .join('');
                     return [
-                        // Type-only specifiers are erased at compile time, so they stay
-                        // where they are instead of riding along into the function body.
-                        typeOnlySpecifiers.length > 0
-                            ? fixer.replaceText(node, `import type { ${buildTypeNames()} } from '${importPath}';`)
-                            : fixer.removeRange([node.range[0], removalEnd()]),
+                        importEdit,
                         lastDirective
                             ? fixer.insertTextAfter(lastDirective, insertion)
                             : fixer.insertTextAfterRange([body.range[0], body.range[0] + 1], insertion),

package/lib/rules/enforce-microdiff.js

@@ -37,6 +37,58 @@ const DIFF_FUNCTION_NAMES = new Set([
     'detailedDiff',
     // 'fastDeepEqual' and 'isEqual' stay out: they are allowed alternatives.
 ]);
+/**
+ * The names a hand-rolled comparison function is conventionally given. One
+ * shared set answers for both spellings of such a function — a `function`
+ * declaration and an arrow bound to a `const` — so neither can drift into
+ * recognising a name the other misses.
+ */
+const COMPARISON_FUNCTION_NAMES = new Set([
+    'detectChanges',
+    'hasConfigChanged',
+    'compareObjects',
+    'compareArrays',
+    'findChanges',
+    'detectDifferences',
+    'hasStateChanged',
+    'stateHasUpdated',
+    'arrayHasChanged',
+    'settingsChanged',
+]);
+/**
+ * The comparison function whose body the fix rewrites. A name alone does not
+ * fix what such a function returns — a boolean, the changed keys, the changes
+ * themselves — and a change list swapped in for the wrong one of those
+ * compiles, so the rest of the set is reported and left to its authors.
+ */
+const REWRITABLE_COMPARISON_NAME = 'hasConfigChanged';
+/**
+ * The markers that make a body look like a hand-rolled comparison. Text is
+ * enough to raise the report because the report says only that the body should
+ * be using microdiff; nothing is rewritten off these.
+ */
+function hasComparisonMarkers(bodyText) {
+    return (bodyText.includes('JSON.stringify') ||
+        bodyText.includes('Object.keys') ||
+        bodyText.includes('for (') ||
+        bodyText.includes('.some(') ||
+        bodyText.includes('.every('));
+}
+/**
+ * Whether a comparison function is one whose body the fix attempts. The gate is
+ * a text-level pre-filter over the name and the body: `collectStringifyComparisons`
+ * reads the AST afterwards and has the last word on whether a rewrite exists,
+ * so a body that clears this gate is still routinely left alone.
+ *
+ * The `!==` marker keeps the rewrite to bodies that phrase the question the way
+ * the name does — "has it changed?" — while an all-`===` body is reported and
+ * left for its author in either spelling.
+ */
+function isRewritableComparison(name, bodyText) {
+    return (name === REWRITABLE_COMPARISON_NAME &&
+        bodyText.includes('JSON.stringify') &&
+        bodyText.includes('!=='));
+}
 /**
  * The exports of a competing library whose call sites this rule rewrites,
  * whatever local name the import binds them to.
@@ -457,6 +509,62 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
             const emptiness = comparison.isEqual ? '.length === 0' : '.length > 0';
             return `${DIFF_NAME}(${left}, ${right})${emptiness}`;
         }
+        /**
+         * The rewrite of a comparison function's body, or null when the body offers
+         * no single expression to replace or the emitted `diff` would not reach
+         * microdiff at `fn`.
+         *
+         * Exactly one comparison is the condition for a fix. With none there is no
+         * expression to rewrite, and with several the rule cannot tell which one the
+         * function's answer turns on, so the report stands on its own.
+         *
+         * Only the comparison's own range is rewritten. The signature keeps its type
+         * annotations, its modifiers and any `export` in front of it, and the body
+         * keeps everything the comparison shares it with: side effects, guard
+         * clauses, locals, and the comments around them. Re-emitting the body as a
+         * single return drops all of that silently — the fix compiles, so nothing
+         * downstream flags the loss.
+         *
+         * Replacing the comparison rather than the statement holding it is also what
+         * lets one implementation serve every spelling of the function: an arrow's
+         * concise expression body takes no `return` and no semicolon, and it needs
+         * none, because the text around the comparison is never part of the range.
+         */
+        function buildComparisonBodyFix(fixer, fn, body) {
+            const comparisons = collectStringifyComparisons(body);
+            if (comparisons.length !== 1 || !canEmitDiffAt(fn)) {
+                return null;
+            }
+            const bodyFix = fixer.replaceText(comparisons[0].node, buildDiffComparison(comparisons[0]));
+            const importFix = buildMicrodiffImportFix(fixer);
+            return importFix ? [importFix, bodyFix] : bodyFix;
+        }
+        /**
+         * Reports a hand-rolled comparison function, carrying the rewrite whenever
+         * its body offers one. Both spellings route through here so an identical
+         * violation is auto-remediable however it is written: a report with a fix in
+         * one spelling and without it in the other leaves the same code manual to
+         * resolve for no reason the author can see.
+         */
+        function reportComparisonFunction(node, name, body) {
+            const bodyText = sourceCode.getText(body);
+            if (isRewritableComparison(name, bodyText)) {
+                reportedNodes.add(node);
+                context.report({
+                    node,
+                    messageId: 'enforceMicrodiff',
+                    fix: (fixer) => buildComparisonBodyFix(fixer, node, body),
+                });
+                return;
+            }
+            if (hasComparisonMarkers(bodyText)) {
+                reportedNodes.add(node);
+                context.report({
+                    node,
+                    messageId: 'enforceMicrodiff',
+                });
+            }
+        }
         // Add a specific set to track which import names are used
         const usedImportNames = new Set();
         // Check if a node is an object or array type
@@ -692,71 +800,14 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                 if (reportedNodes.has(node)) {
                     return;
                 }
-                // Look for functions that might be implementing diff logic
-                if (node.id &&
-                    [
-                        'detectChanges',
-                        'hasConfigChanged',
-                        'compareObjects',
-                        'compareArrays',
-                        'findChanges',
-                        'detectDifferences',
-                        'hasStateChanged',
-                        'stateHasUpdated',
-                        'arrayHasChanged',
-                        'settingsChanged',
-                    ].includes(node.id.name)) {
-                    // Check if function has two parameters that might be objects/arrays
-                    if (node.params.length >= 2) {
-                        const body = node.body;
-                        const bodyText = sourceCode.getText(body);
-                        // Check if the function body contains a JSON.stringify comparison
-                        if (node.id.name === 'hasConfigChanged' &&
-                            bodyText.includes('JSON.stringify') &&
-                            bodyText.includes('!==')) {
-                            reportedNodes.add(node);
-                            // Exactly one comparison is the condition for a fix. With none
-                            // there is no expression to rewrite, and with several the rule
-                            // cannot tell which one the function's answer turns on, so the
-                            // report stands on its own.
-                            const comparisons = collectStringifyComparisons(body);
-                            const comparison = comparisons.length === 1 ? comparisons[0] : null;
-                            context.report({
-                                node,
-                                messageId: 'enforceMicrodiff',
-                                fix(fixer) {
-                                    if (!comparison || !canEmitDiffAt(node)) {
-                                        return null;
-                                    }
-                                    // Only the comparison's own range is rewritten. The signature
-                                    // keeps its type annotations, its modifiers and any `export`
-                                    // in front of it, and the body keeps everything the
-                                    // comparison shares it with: side effects, guard clauses,
-                                    // locals, and the comments around them. Re-emitting the body
-                                    // as a single return drops all of that silently — the fix
-                                    // compiles, so nothing downstream flags the loss.
-                                    const bodyFix = fixer.replaceText(comparison.node, buildDiffComparison(comparison));
-                                    const importFix = buildMicrodiffImportFix(fixer);
-                                    return importFix ? [importFix, bodyFix] : bodyFix;
-                                },
-                            });
-                            return;
-                        }
-                        // Look for patterns that suggest object/array comparison
-                        const hasComparisonLogic = bodyText.includes('JSON.stringify') ||
-                            bodyText.includes('Object.keys') ||
-                            bodyText.includes('for (') ||
-                            bodyText.includes('.some(') ||
-                            bodyText.includes('.every(');
-                        if (hasComparisonLogic) {
-                            reportedNodes.add(node);
-                            context.report({
-                                node,
-                                messageId: 'enforceMicrodiff',
-                            });
-                        }
-                    }
+                // Two parameters are what a comparison function needs, and what the
+                // `diff(a, b)` it is rewritten to needs as well.
+                if (!node.id ||
+                    !COMPARISON_FUNCTION_NAMES.has(node.id.name) ||
+                    node.params.length < 2) {
+                    return;
                 }
+                reportComparisonFunction(node, node.id.name, node.body);
             },
             // Check for custom deep comparison in arrow functions
             ArrowFunctionExpression(node) {
@@ -764,42 +815,17 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                 if (reportedNodes.has(node)) {
                     return;
                 }
-                // Only check arrow functions assigned to variables with comparison-like names
+                // The name an arrow answers to is the one its declarator binds, so an
+                // arrow passed straight to a call names nothing and is left alone.
                 const parent = node.parent;
-                if (parent &&
-                    parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
-                    parent.id.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    [
-                        'detectChanges',
-                        'hasConfigChanged',
-                        'compareObjects',
-                        'compareArrays',
-                        'findChanges',
-                        'detectDifferences',
-                        'hasStateChanged',
-                        'stateHasUpdated',
-                        'arrayHasChanged',
-                        'settingsChanged',
-                    ].includes(parent.id.name)) {
-                    // Check if function has two parameters that might be objects/arrays
-                    if (node.params.length >= 2) {
-                        const body = node.body;
-                        // Look for patterns that suggest object/array comparison
-                        const bodyText = sourceCode.getText(body);
-                        const hasComparisonLogic = bodyText.includes('JSON.stringify') ||
-                            bodyText.includes('Object.keys') ||
-                            bodyText.includes('for (') ||
-                            bodyText.includes('.some(') ||
-                            bodyText.includes('.every(');
-                        if (hasComparisonLogic) {
-                            reportedNodes.add(node);
-                            context.report({
-                                node,
-                                messageId: 'enforceMicrodiff',
-                            });
-                        }
-                    }
+                if (!parent ||
+                    parent.type !== utils_1.AST_NODE_TYPES.VariableDeclarator ||
+                    parent.id.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                    !COMPARISON_FUNCTION_NAMES.has(parent.id.name) ||
+                    node.params.length < 2) {
+                    return;
                 }
+                reportComparisonFunction(node, parent.id.name, node.body);
             },
         };
     },

package/lib/rules/no-jsx-in-hooks.js

@@ -227,6 +227,22 @@ exports.noJsxInHooks = (0, createRule_1.createRule)({
                                 data: { hookName: parent.id.name },
                             });
                         }
+                        return;
+                    }
+                    /**
+                     * A concise body that is a call expression returns whatever the call
+                     * yields, so `() => useMemo(() => <div />, [])` is the same violation
+                     * as its block-bodied spelling. Without this branch the block scanner
+                     * — the only place the useMemo unwrapper is reached from — never runs
+                     * for it, and rewriting a hook to a concise arrow silences the rule.
+                     */
+                    if (node.body.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                        containsJsxInUseMemo(node.body)) {
+                        context.report({
+                            node: parent.id,
+                            messageId: 'noJsxInHooks',
+                            data: { hookName: parent.id.name },
+                        });
                     }
                 }
             },

package/lib/rules/no-redundant-usecallback-wrapper.js

@@ -442,9 +442,16 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
                                         : first.expression;
                                     if (expr && expr.type === utils_1.AST_NODE_TYPES.CallExpression) {
                                         const callee = unwrapChainExpression(expr.callee);
+                                        // A bare identifier is a memoized callback whether the hook
+                                        // handed it back directly (`const signIn = useThing()`) or
+                                        // through a destructuring pattern, so both sets answer here.
+                                        // The arrow-body spelling is not part of the question: a
+                                        // block body delegating to the same callback is the same
+                                        // redundant wrapper the concise spelling is.
                                         const isHookProp = callee &&
                                             callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                                            (hookReturnProps.has(callee.name) ||
+                                            (hookReturnObjects.has(callee.name) ||
+                                                hookReturnProps.has(callee.name) ||
                                                 isLocallyMemoizedCallback(callee, node));
                                         const isHookObjMember = callee &&
                                             callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&

package/lib/rules/no-undefined-null-passthrough.js

@@ -82,6 +82,21 @@ function checkFunctionBody(body, param, context) {
     }
     if (!paramName)
         return;
+    // A block whose only statement is `return <expr>;` makes exactly the claim
+    // the implicit-return spelling of that same expression makes, so it is
+    // answered by the same predicate. A block that does other work first is a
+    // different claim and stays out of scope.
+    const soleStatement = body.body.length === 1 ? body.body[0] : null;
+    if (soleStatement?.type === 'ReturnStatement' &&
+        soleStatement.argument &&
+        isNullishPassthroughExpression(soleStatement.argument, paramName)) {
+        context.report({
+            node: soleStatement,
+            messageId: 'unexpected',
+            data: { paramName },
+        });
+        return;
+    }
     // Look for early returns based on parameter being null/undefined
     for (const statement of body.body) {
         if (statement.type === 'IfStatement') {
@@ -209,6 +224,32 @@ function containsParameterTransformation(node, paramName) {
     // are NOT considered transformations for the purpose of this rule
     return false;
 }
+/**
+ * Recognizes the expressions that hand a nullish parameter straight back to the
+ * caller: `param && ...` and `param ? ... : null/undefined`.
+ *
+ * A function states this shape either as an implicit return or as a block whose
+ * sole statement returns it; both spellings mean the same thing, so they share
+ * this predicate rather than each carrying a copy that can drift.
+ *
+ * The bare-identifier passthrough (`(param) => param`) is deliberately absent.
+ * Its boundary is unsettled — inline callback arguments such as
+ * `items.filter((x) => x)` reach that shape without the prescribed remedy
+ * applying — so it stays confined to the implicit-return path instead of being
+ * duplicated into a second spelling that would have to be narrowed twice.
+ */
+function isNullishPassthroughExpression(node, paramName) {
+    // (param) => param ? param.value : null
+    if (node.type === 'ConditionalExpression') {
+        return (isParameterReference(node.test, paramName) &&
+            isNullOrUndefinedLiteral(node.alternate));
+    }
+    // (param) => param && doSomething(param)
+    if (node.type === 'LogicalExpression') {
+        return node.operator === '&&' && isParameterReference(node.left, paramName);
+    }
+    return false;
+}
 /**
  * Check arrow functions with expression bodies (implicit returns)
  */
@@ -224,28 +265,12 @@ function checkImplicitReturn(node, context) {
     }
     if (!paramName)
         return;
-    // Check for patterns like: (param) => param ? param.value : null
-    if (node.body.type === 'ConditionalExpression') {
-        const test = node.body.test;
-        if (isParameterReference(test, paramName) &&
-            isNullOrUndefinedLiteral(node.body.alternate)) {
-            context.report({
-                node,
-                messageId: 'unexpected',
-                data: { paramName },
-            });
-        }
-    }
-    else if (node.body.type === 'LogicalExpression') {
-        // Check for (param) => param && doSomething(param)
-        if (node.body.operator === '&&' &&
-            isParameterReference(node.body.left, paramName)) {
-            context.report({
-                node,
-                messageId: 'unexpected',
-                data: { paramName },
-            });
-        }
+    if (isNullishPassthroughExpression(node.body, paramName)) {
+        context.report({
+            node,
+            messageId: 'unexpected',
+            data: { paramName },
+        });
     }
     else if (node.body.type === 'Identifier' && node.body.name === paramName) {
         // Check for (param) => param

package/lib/rules/prefer-use-base62-id.js

@@ -131,6 +131,30 @@ function hasEmptyDepsArray(callNode) {
     const deps = callNode.arguments[1];
     return (deps.type === utils_1.AST_NODE_TYPES.ArrayExpression && deps.elements.length === 0);
 }
+/**
+ * Wrappers that exist purely at the type level: they leave the wrapped
+ * expression's runtime value untouched, so a value wrapped in them is still the
+ * value the enclosing declarator binds.
+ */
+const TYPE_ONLY_WRAPPERS = new Set([
+    utils_1.AST_NODE_TYPES.TSAsExpression,
+    utils_1.AST_NODE_TYPES.TSSatisfiesExpression,
+    utils_1.AST_NODE_TYPES.TSNonNullExpression,
+    utils_1.AST_NODE_TYPES.TSTypeAssertion,
+]);
+/**
+ * Returns the nearest ancestor that carries runtime meaning, skipping the
+ * type-only wrappers that may sit between an expression and its binding site.
+ * A double assertion (`as unknown as T`) nests two of them, so the climb loops
+ * rather than peeling a single layer.
+ */
+function getRuntimeParent(node) {
+    let current = node.parent;
+    while (current && TYPE_ONLY_WRAPPERS.has(current.type)) {
+        current = current.parent;
+    }
+    return current;
+}
 /**
  * Checks whether the given identifier (the ref variable name) has its
  * `.current` property assigned anywhere in the enclosing function body.
@@ -398,8 +422,13 @@ exports.preferUseBase62Id = (0, createRule_1.createRule)({
                         return;
                     if (!useRefArgContainsUuid(node, trackedUuidNames))
                         return;
-                    // Find the variable name assigned to the ref
-                    const parent = node.parent;
+                    // Find the variable name assigned to the ref. A type assertion
+                    // between the call and its declarator is semantically neutral, so the
+                    // name stays knowable through it and the `.current`-reassignment
+                    // exemption still applies. Genuinely nameless shapes — a destructure,
+                    // a discarded call, a returned ref — leave `refName` null and keep
+                    // the conservative report.
+                    const parent = getRuntimeParent(node);
                     let refName = null;
                     if (parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
                         parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {

package/lib/rules/prefer-usememo-over-useeffect-usestate.js

@@ -77,6 +77,26 @@ exports.preferUseMemoOverUseEffectUseState = (0, createRule_1.createRule)({
         const isIdentifierReference = (node) => {
             return node.type === 'Identifier';
         };
+        // The expression a lazy useState initializer produces, if it produces one.
+        // A concise arrow body and a single `return` statement declare the same
+        // initializer, so both spellings must resolve to the same expression rather
+        // than the exemption below recognizing only one of them. A block with any
+        // other shape does work beyond producing a value, which is outside what the
+        // exemption covers.
+        const lazyInitializerResult = (node) => {
+            if (node.type !== 'ArrowFunctionExpression' &&
+                node.type !== 'FunctionExpression') {
+                return null;
+            }
+            if (node.body.type !== 'BlockStatement') {
+                return node.body;
+            }
+            if (node.body.body.length !== 1) {
+                return null;
+            }
+            const statement = node.body.body[0];
+            return statement.type === 'ReturnStatement' ? statement.argument : null;
+        };
         // Helper to check if this is a state synchronization pattern
         const isStateSynchronization = (initialValue, setterArgument) => {
             // If the initial value is a reference to a prop/variable and the setter argument
@@ -88,13 +108,13 @@ exports.preferUseMemoOverUseEffectUseState = (0, createRule_1.createRule)({
                     setterArgument.name) {
                 return true;
             }
-            // If the initial value is a function that references a prop and the setter argument
-            // is that same prop, this is likely state synchronization
-            if (initialValue &&
-                initialValue.type === 'ArrowFunctionExpression' &&
-                initialValue.body.type === 'Identifier' &&
+            // If the initial value is a lazy initializer producing a prop and the
+            // setter argument is that same prop, this is likely state synchronization
+            const lazyResult = initialValue && lazyInitializerResult(initialValue);
+            if (lazyResult &&
+                lazyResult.type === 'Identifier' &&
                 isIdentifierReference(setterArgument) &&
-                initialValue.body.name === setterArgument.name) {
+                lazyResult.name === setterArgument.name) {
                 return true;
             }
             return false;

package/lib/rules/require-memo.js

@@ -239,6 +239,143 @@ function buildImportExtensionFix(fixer, program) {
     }
     return null;
 }
+/**
+ * An `async` or generator function cannot be a React component — React renders
+ * neither a promise nor an iterator — so memoizing one would enshrine a shape
+ * that never renders. The report stands, the edit is withheld.
+ */
+const isRewritableFunction = (node) => !node.async && !node.generator;
+/**
+ * Whether the emitted `memo(...)` call can reach the helper, and the import edit
+ * that makes it so (null when the helper is already imported).
+ *
+ * `available: false` withholds the whole rewrite. `memo` is resolved through the
+ * scope chain at the rewritten component because a binding that is not the
+ * helper import breaks the edit two ways: the inserted import collides with the
+ * existing declaration (TS2440, or TS2300 when that declaration is itself an
+ * import), and a binding visible at the fix site captures the emitted call with
+ * no compile error at all. Declining leaves the report standing so the author
+ * resolves the clash deliberately. `React.memo` is a member access on the
+ * default import rather than a `memo` binding, so it never reaches this path.
+ */
+function planMemoBinding(context, fixer, node) {
+    const existingMemo = ASTHelpers_1.ASTHelpers.findVariableInScope(ASTHelpers_1.ASTHelpers.getScope(context, node), MEMO_NAME);
+    if (existingMemo && !bindsMemoHelper(existingMemo)) {
+        return { available: false, importFix: null };
+    }
+    const sourceCode = context.sourceCode;
+    const program = sourceCode.ast;
+    if (importsMemo(program)) {
+        return { available: true, importFix: null };
+    }
+    const extensionFix = buildImportExtensionFix(fixer, program);
+    if (extensionFix) {
+        return { available: true, importFix: extensionFix };
+    }
+    const importPath = calculateImportPath(context.getFilename());
+    const importStatement = `import { memo } from '${importPath}';`;
+    const firstImport = program.body.find((statement) => statement.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
+    // An existing import hosts the helper import directly after it, keeping the
+    // module's imports contiguous. With none to follow, the shared anchor keeps
+    // the file's prologue in place: a `'use client'` directive only counts as one
+    // while it is the first statement, and a `#!` shebang only parses at
+    // character 0.
+    return {
+        available: true,
+        importFix: firstImport
+            ? fixer.insertTextAfter(firstImport, `\n${importStatement}`)
+            : (0, importInsertion_1.insertAtImportAnchor)(sourceCode, fixer, (0, importInsertion_1.importInsertionAnchor)(sourceCode), `${importStatement}\n`),
+    };
+}
+/**
+ * Whether `memo(...)` can be wrapped around the initializer of `declarator`
+ * without changing what the binding means.
+ *
+ * A type annotation on the binding is the decisive exclusion: the wrapper's
+ * return type is the memo helper's, which need not be assignable to the
+ * declared type (`const Row: FC<Props> = ...`), so the edit would trade a
+ * lint report for a type error. A lone `const` declarator is the shape whose
+ * initializer is the binding's only definition — `let`/`var` can be reassigned
+ * afterwards, leaving the name bound to an unmemoized value that the edit only
+ * appears to have fixed, and a shared declaration's other declarators may carry
+ * reports of their own whose edits then compete for the same import anchor.
+ */
+function isWrappableInitializer(declarator) {
+    if (declarator.id.type !== utils_1.AST_NODE_TYPES.Identifier ||
+        declarator.id.typeAnnotation) {
+        return false;
+    }
+    const declaration = declarator.parent;
+    return (declaration?.type === utils_1.AST_NODE_TYPES.VariableDeclaration &&
+        declaration.kind === 'const' &&
+        declaration.declarations.length === 1);
+}
+/**
+ * Rewrites a function declaration into a memoized `const`, renaming the function
+ * itself to `<Name>Unmemoized` so the wrapped component keeps a display name.
+ */
+function memoizeDeclaration(context, node) {
+    return function fix(fixer) {
+        if (!isRewritableFunction(node)) {
+            return null;
+        }
+        const { available, importFix } = planMemoBinding(context, fixer, node);
+        if (!available) {
+            return null;
+        }
+        const functionKeywordRange = [
+            node.range[0],
+            node.range[0] + 'function'.length,
+        ];
+        const functionKeywordReplacement = `const ${node.id.name} = memo(`;
+        const functionNameReplacement = `function ${node.id.name}Unmemoized`;
+        // `export default const X = memo(...)` is a syntax error, so a
+        // default-exported declaration becomes a memoized const plus a trailing
+        // `export default X;`. The local binding is preserved because other
+        // statements in the module may reference it.
+        const defaultExport = node.parent.type === utils_1.AST_NODE_TYPES.ExportDefaultDeclaration
+            ? node.parent
+            : null;
+        const fixes = [
+            fixer.replaceTextRange(functionKeywordRange, functionKeywordReplacement),
+            fixer.insertTextAfterRange([node.range[1], node.range[1]], defaultExport ? `);\nexport default ${node.id.name};` : ');'),
+            fixer.replaceTextRange([node.id.range[0] - 1, node.id.range[1]], functionNameReplacement),
+        ];
+        if (defaultExport) {
+            fixes.push(fixer.removeRange([defaultExport.range[0], node.range[0]]));
+        }
+        if (importFix) {
+            fixes.push(importFix);
+        }
+        return fixes;
+    };
+}
+/**
+ * Wraps a `const X = <function>` initializer in `memo(...)` where it stands.
+ *
+ * The binding, its name and the function's own text are left untouched, so
+ * every reference to the component keeps resolving to the same name and an
+ * anonymous initializer is not forced into a spelling it did not have.
+ */
+function memoizeInitializer(context, node) {
+    return function fix(fixer) {
+        if (!isRewritableFunction(node)) {
+            return null;
+        }
+        const { available, importFix } = planMemoBinding(context, fixer, node);
+        if (!available) {
+            return null;
+        }
+        const fixes = [
+            fixer.insertTextBefore(node, `${MEMO_NAME}(`),
+            fixer.insertTextAfter(node, ')'),
+        ];
+        if (importFix) {
+            fixes.push(importFix);
+        }
+        return fixes;
+    };
+}
 function checkFunction(context, node) {
     const fileName = context.getFilename();
     if (!fileName.endsWith('.tsx')) {
@@ -261,83 +398,24 @@ function checkFunction(context, node) {
                     parentNode.id.type === 'Identifier' &&
                     parentNode.id.name) ||
                 'component';
+            // Both spellings of a component carry the same remedy, so both carry an
+            // edit: the declaration one becomes a memoized const, and an initializer
+            // is wrapped in place.
+            const fixDeclaration = isDeclarationComponent && canHostConstDeclaration(parentNode);
+            const fixInitializer = isArrowComponent &&
+                parentNode.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                isWrappableInitializer(parentNode);
             context.report({
                 node,
                 messageId: 'requireMemo',
                 data: {
                     name: componentName,
                 },
-                fix: isDeclarationComponent && canHostConstDeclaration(parentNode)
-                    ? function fix(fixer) {
-                        if (node.async || node.generator) {
-                            return null;
-                        }
-                        const sourceCode = context.sourceCode;
-                        const program = sourceCode.ast;
-                        // Resolve `memo` through the scope chain at the fixed node. A
-                        // binding that is not the helper import breaks the edit two
-                        // ways: the inserted import collides with the existing
-                        // declaration (TS2440, or TS2300 when that declaration is
-                        // itself an import), and a binding visible at the fix site
-                        // captures the emitted call with no compile error at all.
-                        // Declining leaves the report standing so the author resolves
-                        // the clash deliberately. `React.memo` is a member access on
-                        // the default import rather than a `memo` binding, so it never
-                        // reaches this path.
-                        const existingMemo = ASTHelpers_1.ASTHelpers.findVariableInScope(ASTHelpers_1.ASTHelpers.getScope(context, node), MEMO_NAME);
-                        if (existingMemo && !bindsMemoHelper(existingMemo)) {
-                            return null;
-                        }
-                        let importFix = null;
-                        if (!importsMemo(program)) {
-                            importFix = buildImportExtensionFix(fixer, program);
-                            if (!importFix) {
-                                // Calculate relative path based on current file location
-                                const currentFilePath = context.getFilename();
-                                const importPath = calculateImportPath(currentFilePath);
-                                const importStatement = `import { memo } from '${importPath}';`;
-                                const firstImport = program.body.find((statement) => statement.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
-                                // An existing import hosts the helper import directly after
-                                // it, keeping the module's imports contiguous. With none to
-                                // follow, the shared anchor keeps the file's prologue in
-                                // place: a `'use client'` directive only counts as one while
-                                // it is the first statement, and a `#!` shebang only parses
-                                // at character 0.
-                                importFix = firstImport
-                                    ? fixer.insertTextAfter(firstImport, `\n${importStatement}`)
-                                    : (0, importInsertion_1.insertAtImportAnchor)(sourceCode, fixer, (0, importInsertion_1.importInsertionAnchor)(sourceCode), `${importStatement}\n`);
-                            }
-                        }
-                        const functionKeywordRange = [
-                            node.range[0],
-                            node.range[0] + 'function'.length,
-                        ];
-                        const functionKeywordReplacement = `const ${node.id.name} = memo(`;
-                        // Step 3: Rename function
-                        const functionNameReplacement = `function ${node.id.name}Unmemoized`;
-                        // `export default const X = memo(...)` is a syntax error, so a
-                        // default-exported declaration becomes a memoized const plus a
-                        // trailing `export default X;`. The local binding is preserved
-                        // because other statements in the module may reference it.
-                        const defaultExport = parentNode.type === utils_1.AST_NODE_TYPES.ExportDefaultDeclaration
-                            ? parentNode
-                            : null;
-                        const fixes = [
-                            fixer.replaceTextRange(functionKeywordRange, functionKeywordReplacement),
-                            fixer.insertTextAfterRange([node.range[1], node.range[1]], defaultExport
-                                ? `);\nexport default ${node.id.name};`
-                                : ');'),
-                            fixer.replaceTextRange([node.id.range[0] - 1, node.id.range[1]], functionNameReplacement),
-                        ];
-                        if (defaultExport) {
-                            fixes.push(fixer.removeRange([defaultExport.range[0], node.range[0]]));
-                        }
-                        if (importFix) {
-                            fixes.push(importFix);
-                        }
-                        return fixes;
-                    }
-                    : undefined,
+                fix: fixDeclaration
+                    ? memoizeDeclaration(context, node)
+                    : fixInitializer
+                        ? memoizeInitializer(context, node)
+                        : undefined,
             });
         }
     }

package/lib/utils/fixtureCorpus.d.ts

@@ -72,9 +72,8 @@ export declare const ruleNameByIdentity: Map<unknown, string>;
  *
  * `RuleTester` passes `undefined` in that situation, which ESLint renders as
  * `<input>` — a name with no extension, under which every path-gated rule is
- * silent and contributes nothing. A bare `file.ts`/`react.tsx` is the smallest
- * departure that keeps those rules reachable, and it matches the extension the
- * fixture's own tester implies.
+ * silent and contributes nothing. A bare `file`/`react` basename is the smallest
+ * departure that keeps those rules reachable.
  */
 export declare const defaultFilenameFor: (testCase: FixtureCase) => string;
 /**

package/lib/utils/fixtureCorpus.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.harvestFixtureCorpus = exports.severityWithOptions = exports.suggestionEditsOf = exports.suggestionRuleNames = exports.parserOptionsFor = exports.FALLBACK_FILENAMES = exports.defaultFilenameFor = exports.ruleNameByIdentity = exports.typeAwareRuleNames = exports.TS_TESTERS = exports.harvestOnce = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const typescript_estree_1 = require("@typescript-eslint/typescript-estree");
 const harvestRuleTesterCases_1 = require("./harvestRuleTesterCases");
 /**
  * The fixture corpus every fixer guard probes, keyed by RULE NAME.
@@ -98,17 +99,65 @@ exports.typeAwareRuleNames = new Set(fs_1.default
  * suites and `../index` resolve to the same module instance under jest.
  */
 exports.ruleNameByIdentity = new Map(Object.entries(plugin.rules).map(([name, rule]) => [rule, name]));
+const parsesWithJsx = (code, jsx) => {
+    try {
+        // `range`/`loc` are not optional in practice: without them any comment in
+        // the snippet throws, which reads as an unparsable fixture.
+        (0, typescript_estree_1.parse)(code, { jsx, range: true, loc: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+/** Decided once per snippet+preference; the corpus reprobes the same code. */
+const extensionByCode = new Map();
+/**
+ * `.ts` and `.tsx` are not ordered by permissiveness, so neither one can be the
+ * blanket default: only `.ts` accepts the angle-bracket assertion `<T>expr`, and
+ * only `.tsx` accepts JSX. The tester supplies a PREFERENCE, and the snippet
+ * overrides it only when that preference cannot parse the snippet at all.
+ *
+ * Taking the tester's word for it instead makes a JSX fixture in a `ruleTesterTs`
+ * suite a FATAL parse. Every consumer filters messages by `ruleId`, so the fatal
+ * is indistinguishable from the rule staying silent — a false clean over 168
+ * cases, four fifths of some rules' corpora. The converse costs one case: an
+ * angle-bracket assertion declared in a `ruleTesterJsx` suite.
+ *
+ * Correcting only on a fatal is what keeps this from churning: a snippet legal
+ * both ways stays on the extension it has always been probed under, so no
+ * path-gated rule silently changes which fixtures reach it.
+ */
+const extensionFor = (code, preferred) => {
+    const key = `${preferred}\u0000${code}`;
+    const cached = extensionByCode.get(key);
+    if (cached)
+        return cached;
+    const alternate = preferred === '.tsx' ? '.ts' : '.tsx';
+    // Only a `<` can make the two disagree, so the common case never parses.
+    const extension = !code.includes('<') || parsesWithJsx(code, preferred === '.tsx')
+        ? preferred
+        : parsesWithJsx(code, alternate === '.tsx')
+            ? alternate
+            : preferred;
+    extensionByCode.set(key, extension);
+    return extension;
+};
 /**
  * The filename a case is probed under when it declares none.
  *
  * `RuleTester` passes `undefined` in that situation, which ESLint renders as
  * `<input>` — a name with no extension, under which every path-gated rule is
- * silent and contributes nothing. A bare `file.ts`/`react.tsx` is the smallest
- * departure that keeps those rules reachable, and it matches the extension the
- * fixture's own tester implies.
+ * silent and contributes nothing. A bare `file`/`react` basename is the smallest
+ * departure that keeps those rules reachable.
  */
-const defaultFilenameFor = (testCase) => testCase.filename ??
-    (testCase.tester === 'ruleTesterJsx' ? 'react.tsx' : 'file.ts');
+const defaultFilenameFor = (testCase) => {
+    if (testCase.filename)
+        return testCase.filename;
+    const jsxTester = testCase.tester === 'ruleTesterJsx';
+    const basename = jsxTester ? 'react' : 'file';
+    return `${basename}${extensionFor(testCase.code, jsxTester ? '.tsx' : '.ts')}`;
+};
 exports.defaultFilenameFor = defaultFilenameFor;
 /**
  * Second-chance filenames, used ONLY for a rule that produced no probe at all

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,80 @@
 [
+  {
+    "version": "1.20.121",
+    "date": "2026-08-06T10:37:08.150Z",
+    "rules": [
+      {
+        "name": "enforce-dynamic-firebase-imports",
+        "changeType": "fix",
+        "issues": [
+          1790
+        ],
+        "summary": "remediate a concise-bodied async arrow (closes #1790)"
+      },
+      {
+        "name": "no-jsx-in-hooks",
+        "changeType": "fix",
+        "issues": [
+          1792
+        ],
+        "summary": "report a concise arrow body that is itself a memoized JSX call (closes #1792)"
+      },
+      {
+        "name": "no-redundant-usecallback-wrapper",
+        "changeType": "fix",
+        "issues": [
+          1793
+        ],
+        "summary": "consult hookReturnObjects from the block-body arm (closes #1793)"
+      },
+      {
+        "name": "no-undefined-null-passthrough",
+        "changeType": "fix",
+        "issues": [
+          1794
+        ],
+        "summary": "detect the guard shapes in a block-bodied arrow (closes #1794)"
+      },
+      {
+        "name": "prefer-usememo-over-useeffect-usestate",
+        "changeType": "fix",
+        "issues": [
+          1791
+        ],
+        "summary": "recognise a block-bodied lazy initializer as state synchronization (closes #1791)"
+      },
+      {
+        "name": "require-memo",
+        "changeType": "fix",
+        "issues": [
+          1789
+        ],
+        "summary": "wrap arrow and function-expression components in memo (closes #1789)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.120",
+    "date": "2026-08-06T05:46:26.078Z",
+    "rules": [
+      {
+        "name": "enforce-microdiff",
+        "changeType": "fix",
+        "issues": [
+          1784
+        ],
+        "summary": "give the arrow spelling the rewrite its declaration twin carries (closes #1784)"
+      },
+      {
+        "name": "prefer-use-base62-id",
+        "changeType": "fix",
+        "issues": [
+          1782
+        ],
+        "summary": "look through type-only wrappers to the ref name (closes #1782)"
+      }
+    ]
+  },
   {
     "version": "1.20.119",
     "date": "2026-08-06T04:34:04.981Z",