@blumintinc/eslint-plugin-blumint 1.12.6 → 1.14.0

package/lib/rules/memo-nested-react-components.d.ts

@@ -0,0 +1,8 @@
+import { TSESLint } from '@typescript-eslint/utils';
+type Options = [
+    {
+        ignorePatterns?: string[];
+    }
+];
+export declare const memoNestedReactComponents: TSESLint.RuleModule<"memoizeNestedComponent", Options, TSESLint.RuleListener>;
+export {};

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

@@ -0,0 +1,410 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoNestedReactComponents = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const minimatch_1 = require("minimatch");
+const createRule_1 = require("../utils/createRule");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
+const CALLBACK_HOOKS = new Set(['useCallback', 'useDeepCompareCallback']);
+const HOOK_REPLACEMENT = {
+    useCallback: 'useMemo',
+    useDeepCompareCallback: 'useDeepCompareMemo',
+};
+const collectReactImports = (sourceCode) => {
+    const reactImports = { namespace: null, named: {} };
+    for (const statement of sourceCode.ast.body) {
+        if (statement.type !== utils_1.AST_NODE_TYPES.ImportDeclaration)
+            continue;
+        if (statement.source.value !== 'react')
+            continue;
+        for (const specifier of statement.specifiers) {
+            if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier) {
+                const importedName = specifier.imported.name;
+                if (importedName === 'createElement' ||
+                    importedName === 'memo' ||
+                    importedName === 'forwardRef') {
+                    reactImports.named[importedName] = specifier.local.name;
+                }
+            }
+            if (specifier.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier ||
+                specifier.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+                reactImports.namespace = specifier.local.name;
+            }
+        }
+    }
+    return reactImports;
+};
+const calleeMatchesReactMember = (callee, reactImports, member) => {
+    if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return reactImports.named[member] === callee.name;
+    }
+    if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        !callee.computed &&
+        callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+        callee.property.name === member &&
+        callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+        reactImports.namespace === callee.object.name) {
+        return true;
+    }
+    return false;
+};
+const isFunctionExpression = (node) => {
+    return (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+        node.type === utils_1.AST_NODE_TYPES.FunctionExpression);
+};
+const unwrapExpression = (expression) => {
+    if (expression.type === utils_1.AST_NODE_TYPES.TSAsExpression) {
+        return unwrapExpression(expression.expression);
+    }
+    if (expression.type === utils_1.AST_NODE_TYPES.TSSatisfiesExpression) {
+        return unwrapExpression(expression.expression);
+    }
+    if (expression.type === utils_1.AST_NODE_TYPES.TSNonNullExpression) {
+        return unwrapExpression(expression.expression);
+    }
+    /**
+     * ParenthesizedExpression appears in the parsed AST even though the type
+     * is missing from AST_NODE_TYPES. This assertion safely unwraps to keep
+     * traversal consistent.
+     */
+    if (expression.type ===
+        'ParenthesizedExpression') {
+        return unwrapExpression(expression.expression);
+    }
+    return expression;
+};
+const isReactCreateElementCall = (node, reactImports) => {
+    return calleeMatchesReactMember(node.callee, reactImports, 'createElement');
+};
+const isHookCall = (callee) => {
+    if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+        if (CALLBACK_HOOKS.has(callee.name)) {
+            return { name: callee.name };
+        }
+        return null;
+    }
+    if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        !callee.computed &&
+        callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+        CALLBACK_HOOKS.has(callee.property.name)) {
+        return { name: callee.property.name };
+    }
+    return null;
+};
+const isForwardRefCall = (node, reactImports) => {
+    return calleeMatchesReactMember(node.callee, reactImports, 'forwardRef');
+};
+const isMemoCall = (node, reactImports) => {
+    return calleeMatchesReactMember(node.callee, reactImports, 'memo');
+};
+const filterPresentResults = (results) => {
+    return results.filter((result) => Boolean(result));
+};
+const areAllComponentsCallbacks = (components) => {
+    return components.every((result) => result.componentIsCallback);
+};
+const createMergedResult = (components) => {
+    return {
+        found: true,
+        // Auto-fix wraps the callback in memo() and swaps the hook. That is only valid when
+        // every branch is itself a component callback (returns JSX/createElement directly).
+        // If any branch yields a component factory, the transformation changes behavior.
+        componentIsCallback: areAllComponentsCallbacks(components),
+    };
+};
+const mergeComponentResults = (...results) => {
+    const present = filterPresentResults(results);
+    if (!present.length) {
+        return null;
+    }
+    return createMergedResult(present);
+};
+const expressionCreatesComponent = (expression, reactImports) => {
+    if (!expression) {
+        return null;
+    }
+    const unwrapped = unwrapExpression(expression);
+    if (unwrapped.type === utils_1.AST_NODE_TYPES.JSXElement ||
+        unwrapped.type === utils_1.AST_NODE_TYPES.JSXFragment) {
+        return { found: true, componentIsCallback: true };
+    }
+    if (unwrapped.type === utils_1.AST_NODE_TYPES.CallExpression &&
+        isReactCreateElementCall(unwrapped, reactImports)) {
+        return { found: true, componentIsCallback: true };
+    }
+    switch (unwrapped.type) {
+        case utils_1.AST_NODE_TYPES.ArrowFunctionExpression:
+        case utils_1.AST_NODE_TYPES.FunctionExpression: {
+            const inner = functionCreatesComponent(unwrapped, reactImports);
+            return inner ? { found: true, componentIsCallback: false } : null;
+        }
+        case utils_1.AST_NODE_TYPES.CallExpression: {
+            if (isForwardRefCall(unwrapped, reactImports) ||
+                isMemoCall(unwrapped, reactImports)) {
+                const firstArg = unwrapped.arguments[0];
+                if (firstArg && isFunctionExpression(firstArg)) {
+                    const inner = functionCreatesComponent(firstArg, reactImports);
+                    if (inner) {
+                        return { found: true, componentIsCallback: false };
+                    }
+                }
+            }
+            return null;
+        }
+        case utils_1.AST_NODE_TYPES.ConditionalExpression: {
+            const cons = expressionCreatesComponent(unwrapped.consequent, reactImports);
+            const alt = expressionCreatesComponent(unwrapped.alternate, reactImports);
+            return mergeComponentResults(cons, alt);
+        }
+        case utils_1.AST_NODE_TYPES.LogicalExpression: {
+            const left = expressionCreatesComponent(unwrapped.left, reactImports);
+            const right = expressionCreatesComponent(unwrapped.right, reactImports);
+            return mergeComponentResults(left, right);
+        }
+        case utils_1.AST_NODE_TYPES.SequenceExpression: {
+            const last = unwrapped.expressions[unwrapped.expressions.length - 1];
+            return expressionCreatesComponent(last || null, reactImports);
+        }
+        case utils_1.AST_NODE_TYPES.ArrayExpression: {
+            const matches = unwrapped.elements
+                .map((element) => element && element.type !== utils_1.AST_NODE_TYPES.SpreadElement
+                ? expressionCreatesComponent(element, reactImports)
+                : null)
+                .filter(Boolean);
+            return mergeComponentResults(...matches);
+        }
+        default:
+            return null;
+    }
+};
+const statementCreatesComponent = (node, reactImports) => {
+    switch (node.type) {
+        case utils_1.AST_NODE_TYPES.ReturnStatement:
+            return expressionCreatesComponent(node.argument, reactImports);
+        case utils_1.AST_NODE_TYPES.IfStatement: {
+            const cons = node.consequent.type === utils_1.AST_NODE_TYPES.BlockStatement
+                ? blockCreatesComponent(node.consequent, reactImports)
+                : statementCreatesComponent(node.consequent, reactImports);
+            const alt = node.alternate
+                ? node.alternate.type === utils_1.AST_NODE_TYPES.BlockStatement
+                    ? blockCreatesComponent(node.alternate, reactImports)
+                    : statementCreatesComponent(node.alternate, reactImports)
+                : null;
+            return mergeComponentResults(cons, alt);
+        }
+        case utils_1.AST_NODE_TYPES.SwitchStatement: {
+            const matches = [];
+            for (const switchCase of node.cases) {
+                for (const consequent of switchCase.consequent) {
+                    matches.push(statementCreatesComponent(consequent, reactImports));
+                }
+            }
+            return mergeComponentResults(...matches);
+        }
+        case utils_1.AST_NODE_TYPES.BlockStatement:
+            return blockCreatesComponent(node, reactImports);
+        case utils_1.AST_NODE_TYPES.ForStatement:
+        case utils_1.AST_NODE_TYPES.ForInStatement:
+        case utils_1.AST_NODE_TYPES.ForOfStatement:
+        case utils_1.AST_NODE_TYPES.WhileStatement:
+        case utils_1.AST_NODE_TYPES.DoWhileStatement: {
+            if (node.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+                return blockCreatesComponent(node.body, reactImports);
+            }
+            return statementCreatesComponent(node.body, reactImports);
+        }
+        case utils_1.AST_NODE_TYPES.TryStatement: {
+            const blockMatch = blockCreatesComponent(node.block, reactImports);
+            const handlerMatch = node.handler?.body
+                ? blockCreatesComponent(node.handler.body, reactImports)
+                : null;
+            const finalizerMatch = node.finalizer
+                ? blockCreatesComponent(node.finalizer, reactImports)
+                : null;
+            return mergeComponentResults(blockMatch, handlerMatch, finalizerMatch);
+        }
+        default:
+            return null;
+    }
+};
+const blockCreatesComponent = (block, reactImports) => {
+    const matches = [];
+    for (const statement of block.body) {
+        matches.push(statementCreatesComponent(statement, reactImports));
+    }
+    return mergeComponentResults(...matches);
+};
+const functionCreatesComponent = (node, reactImports) => {
+    if (node.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+        return blockCreatesComponent(node.body, reactImports);
+    }
+    return expressionCreatesComponent(node.body, reactImports);
+};
+const shouldIgnoreFile = (filename, patterns) => {
+    return patterns.some((pattern) => (0, minimatch_1.minimatch)(filename, pattern));
+};
+const getVariableName = (node) => {
+    if (node.parent &&
+        node.parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+        node.parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return node.parent.id.name;
+    }
+    return null;
+};
+const findMemoReference = (reactImports) => {
+    if (reactImports.namespace) {
+        return `${reactImports.namespace}.memo`;
+    }
+    return reactImports.named.memo ?? null;
+};
+const hasIdentifierInScope = (identifierName, scope) => {
+    return !!ASTHelpers_1.ASTHelpers.findVariableInScope(scope, identifierName);
+};
+exports.memoNestedReactComponents = (0, createRule_1.createRule)({
+    name: 'memo-nested-react-components',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow React components defined in useCallback/useDeepCompareCallback',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    ignorePatterns: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        default: [],
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            memoizeNestedComponent: `What's wrong: React component "{{componentName}}" is created inside {{hookName}}.
+Why it matters: Components defined inside callbacks get new identities when the callback changes, causing React to remount them and drop their state and effects.
+How to fix: Create the component via {{replacementHook}} and wrap it in memo() so its identity stays stable across renders.`,
+        },
+    },
+    defaultOptions: [{}],
+    create(context, [options]) {
+        const ignorePatterns = options?.ignorePatterns ?? [];
+        const filename = context.filename ?? context.getFilename();
+        if (ignorePatterns.length && shouldIgnoreFile(filename, ignorePatterns)) {
+            return {};
+        }
+        const sourceCode = context.sourceCode ?? context.getSourceCode();
+        const reactImports = collectReactImports(sourceCode);
+        const memoReference = findMemoReference(reactImports);
+        return {
+            CallExpression(node) {
+                const hook = isHookCall(node.callee);
+                if (!hook)
+                    return;
+                const callback = node.arguments[0];
+                if (!callback || callback.type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                    return;
+                }
+                const componentMatch = isFunctionExpression(callback)
+                    ? functionCreatesComponent(callback, reactImports)
+                    : expressionCreatesComponent(callback, reactImports);
+                if (!componentMatch) {
+                    return;
+                }
+                const componentName = getVariableName(node) ??
+                    (isFunctionExpression(callback) &&
+                        callback.id?.type === utils_1.AST_NODE_TYPES.Identifier
+                        ? callback.id.name
+                        : 'component');
+                const replacementHook = HOOK_REPLACEMENT[hook.name];
+                context.report({
+                    node,
+                    messageId: 'memoizeNestedComponent',
+                    data: {
+                        componentName,
+                        hookName: `${hook.name}()`,
+                        replacementHook: `${replacementHook}()`,
+                    },
+                    fix: (fixer) => {
+                        if (!memoReference) {
+                            return null;
+                        }
+                        const memoNamespace = memoReference.endsWith('.memo')
+                            ? memoReference.slice(0, -'.memo'.length)
+                            : null;
+                        // Prefer SourceCode#getScope when available; fall back to RuleContext#getScope for ESLint compatibility.
+                        const sourceCodeWithScope = sourceCode;
+                        const scope = typeof sourceCodeWithScope.getScope === 'function'
+                            ? sourceCodeWithScope.getScope(node)
+                            : context.getScope();
+                        const replacementIdentifierAvailable = hook.name === 'useCallback'
+                            ? hasIdentifierInScope(HOOK_REPLACEMENT.useCallback, scope)
+                            : hasIdentifierInScope(HOOK_REPLACEMENT.useDeepCompareCallback, scope);
+                        if (!replacementIdentifierAvailable) {
+                            // When the standalone replacement hook (useMemo/useDeepCompareMemo) is not imported,
+                            // we can only fix member expressions that use the React namespace.
+                            if (node.callee.type !== utils_1.AST_NODE_TYPES.MemberExpression ||
+                                node.callee.object.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                                return null;
+                            }
+                            // Ensure memo's namespace matches the hook's namespace (e.g., React.useCallback → React.useMemo + React.memo).
+                            if (memoReference &&
+                                memoReference.includes('.') &&
+                                memoReference !== `${node.callee.object.name}.memo`) {
+                                return null;
+                            }
+                        }
+                        // Component factories (functions returning functions that return JSX) require manual refactoring.
+                        if (!componentMatch.componentIsCallback) {
+                            return null;
+                        }
+                        // Ensure callback is a function expression before attempting to wrap it.
+                        if (!isFunctionExpression(callback)) {
+                            return null;
+                        }
+                        // React.memo() expects a synchronous component function. Wrapping async functions or
+                        // generators would produce a Promise/yielding component, which is not renderable.
+                        if (callback.async ||
+                            (callback.type === utils_1.AST_NODE_TYPES.FunctionExpression &&
+                                callback.generator)) {
+                            return null;
+                        }
+                        // Avoid rewriting non-React namespaces (e.g., Hooks.useCallback → Hooks.useMemo),
+                        // even when useMemo/memo are available as named imports.
+                        if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                            if (node.callee.object.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                                !reactImports.namespace ||
+                                node.callee.object.name !== reactImports.namespace) {
+                                return null;
+                            }
+                        }
+                        // Prevent mixing namespaces: don't apply fix when hook and memo use different React imports.
+                        if (memoNamespace &&
+                            node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                            node.callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            node.callee.object.name !== memoNamespace) {
+                            return null;
+                        }
+                        const callbackText = sourceCode.getText(callback);
+                        const callbackReplacement = `() => ${memoReference}(${callbackText})`;
+                        const fixes = [
+                            fixer.replaceText(callback, callbackReplacement),
+                        ];
+                        if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                            fixes.push(fixer.replaceText(node.callee, HOOK_REPLACEMENT[node.callee.name]));
+                        }
+                        else if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                            node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                            fixes.push(fixer.replaceText(node.callee.property, HOOK_REPLACEMENT[node.callee.property.name]));
+                        }
+                        return fixes;
+                    },
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=memo-nested-react-components.js.map

package/lib/rules/memoize-root-level-hocs.d.ts

@@ -0,0 +1,7 @@
+type Options = [
+    {
+        additionalHocNames?: string[];
+    }
+];
+export declare const memoizeRootLevelHocs: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"wrapHocInUseMemo", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};

package/lib/rules/memoize-root-level-hocs.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoizeRootLevelHocs = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const defaultOptions = [{ additionalHocNames: [] }];
+const isFunctionNode = (node) => node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+    node.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+    node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression;
+const isHookName = (name) => /^use[A-Z]/.test(name);
+const isComponentName = (name) => /^[A-Z]/.test(name);
+const forEachChildNode = (node, callback) => {
+    for (const key of Object.keys(node)) {
+        if (key === 'parent')
+            continue;
+        const value = node[key];
+        if (!value)
+            continue;
+        if (Array.isArray(value)) {
+            for (const child of value) {
+                if (child && typeof child.type === 'string') {
+                    if (callback(child)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        else if (value && typeof value.type === 'string') {
+            if (callback(value)) {
+                return true;
+            }
+        }
+    }
+    return false;
+};
+const getFunctionName = (node) => {
+    if (node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration && node.id) {
+        return node.id.name;
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+        node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+        const parent = node.parent;
+        if (parent &&
+            parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+            parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+            return parent.id.name;
+        }
+        if (parent &&
+            parent.type === utils_1.AST_NODE_TYPES.Property &&
+            parent.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+            return parent.key.name;
+        }
+    }
+    return null;
+};
+const containsJsx = (node, options) => {
+    if (!node)
+        return false;
+    if (node.type === utils_1.AST_NODE_TYPES.JSXElement ||
+        node.type === utils_1.AST_NODE_TYPES.JSXFragment) {
+        return true;
+    }
+    return forEachChildNode(node, (child) => {
+        if (options?.skipFunctionBodies && isFunctionNode(child)) {
+            return false;
+        }
+        return containsJsx(child, options);
+    });
+};
+const hasFunctionParent = (node) => {
+    let current = node.parent;
+    while (current) {
+        if (isFunctionNode(current)) {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+};
+const getBodyNodeForJsxCheck = (node) => {
+    if (node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+        node.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+        return node.body;
+    }
+    if (node.body && node.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+        return node.body;
+    }
+    return node.body;
+};
+const isComponentOrHook = (node) => {
+    const name = getFunctionName(node);
+    const hook = name ? isHookName(name) : false;
+    const component = name ? isComponentName(name) : false;
+    const nestedFunction = hasFunctionParent(node);
+    const jsxBody = containsJsx(getBodyNodeForJsxCheck(node), {
+        skipFunctionBodies: !hook && !component,
+    });
+    if (!hook && !component && nestedFunction) {
+        return null;
+    }
+    if (!hook && !component && !jsxBody) {
+        return null;
+    }
+    if (hook) {
+        return { contextLabel: `hook${name ? ` ${name}` : ''}` };
+    }
+    return { contextLabel: `component${name ? ` ${name}` : ''}` };
+};
+const getCallableIdentifierName = (callee) => {
+    const maybeChain = callee;
+    if (maybeChain.type === utils_1.AST_NODE_TYPES.ChainExpression) {
+        return getCallableIdentifierName(maybeChain.expression);
+    }
+    if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return callee.name;
+    }
+    if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        !callee.computed &&
+        callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return callee.property.name;
+    }
+    return null;
+};
+const isHocIdentifier = (name, additionalHocs) => {
+    if (additionalHocs.has(name)) {
+        return true;
+    }
+    if (!name.startsWith('with')) {
+        return false;
+    }
+    const suffix = name.charAt(4);
+    return Boolean(suffix) && /^[A-Z]$/.test(suffix);
+};
+const findHocName = (node, additionalHocs) => {
+    const identifier = getCallableIdentifierName(node.callee);
+    if (identifier && isHocIdentifier(identifier, additionalHocs)) {
+        return identifier;
+    }
+    if (node.callee.type === utils_1.AST_NODE_TYPES.CallExpression) {
+        return findHocName(node.callee, additionalHocs);
+    }
+    return null;
+};
+/**
+ * Detects chained HOC calls where an inner call is immediately invoked by
+ * another call (for example, withHoc(Component)()). We only treat calls as
+ * part of the same chain when the current CallExpression is the callee of its
+ * parent and both resolve to the same HOC name, which prevents duplicate
+ * reports for patterns like withHoc(Component)(props).
+ */
+const getParentCallExpression = (callExpr) => callExpr.parent &&
+    callExpr.parent.type === utils_1.AST_NODE_TYPES.CallExpression &&
+    callExpr.parent.callee === callExpr
+    ? callExpr.parent
+    : null;
+const isPartOfHocChain = (hocName, parentHocName) => Boolean(parentHocName && parentHocName === hocName);
+exports.memoizeRootLevelHocs = (0, createRule_1.createRule)({
+    name: 'memoize-root-level-hocs',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Prevent creating Higher-Order Components at the root level of React components/hooks without wrapping them in useMemo to keep wrapped component identities stable across renders.',
+            recommended: 'error',
+        },
+        fixable: undefined,
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    additionalHocNames: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        default: [],
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            wrapHocInUseMemo: 'HOC "{{hocName}}" is created inside {{contextLabel}} during render, so every render creates a brand-new wrapped component reference. React treats that as a different component, unmounting/remounting it (resetting internal state) and forcing children to re-render even when props stay the same. Wrap the HOC creation in useMemo with the correct dependencies or hoist it outside the {{contextLabel}} so the wrapped component identity stays stable.',
+        },
+    },
+    defaultOptions,
+    create(context, [options]) {
+        const additionalHocs = new Set(options?.additionalHocNames ?? []);
+        const reportUnmemoizedHoc = (node, hocName, contextInfo) => {
+            context.report({
+                node,
+                messageId: 'wrapHocInUseMemo',
+                data: {
+                    hocName,
+                    contextLabel: contextInfo.contextLabel,
+                },
+            });
+        };
+        const checkHocCall = (callExpr, contextInfo) => {
+            const hocName = findHocName(callExpr, additionalHocs);
+            const parentCall = getParentCallExpression(callExpr);
+            const parentHocName = parentCall && findHocName(parentCall, additionalHocs);
+            if (hocName && !isPartOfHocChain(hocName, parentHocName)) {
+                reportUnmemoizedHoc(callExpr, hocName, contextInfo);
+            }
+        };
+        const traverseFunctionBody = (node, contextInfo) => {
+            const visitNode = (current) => {
+                if (isFunctionNode(current) && current !== node) {
+                    return;
+                }
+                if (current.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                    checkHocCall(current, contextInfo);
+                }
+                forEachChildNode(current, (child) => {
+                    visitNode(child);
+                    return false;
+                });
+            };
+            if (!node.body) {
+                return;
+            }
+            if (node.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+                for (const statement of node.body.body) {
+                    visitNode(statement);
+                }
+                return;
+            }
+            visitNode(node.body);
+        };
+        const analyzeFunction = (node) => {
+            const contextInfo = isComponentOrHook(node);
+            if (!contextInfo) {
+                return;
+            }
+            traverseFunctionBody(node, contextInfo);
+        };
+        return {
+            FunctionDeclaration: analyzeFunction,
+            FunctionExpression: analyzeFunction,
+            ArrowFunctionExpression: analyzeFunction,
+        };
+    },
+});
+//# sourceMappingURL=memoize-root-level-hocs.js.map

package/lib/rules/no-always-true-false-conditions.d.ts

@@ -1,3 +1,4 @@
+import type { TSESLint } from '@typescript-eslint/utils';
 type MessageIds = 'alwaysTrueCondition' | 'alwaysFalseCondition';
-export declare const noAlwaysTrueFalseConditions: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export declare const noAlwaysTrueFalseConditions: TSESLint.RuleModule<MessageIds, [], TSESLint.RuleListener>;
 export {};