@blumintinc/eslint-plugin-blumint 1.20.120 → 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.120',
+        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/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-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/package.json

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

package/release-manifest.json

@@ -1,4 +1,58 @@
 [
+  {
+    "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",