@blumintinc/eslint-plugin-blumint 1.20.95 → 1.20.96

package/README.md

@@ -101,7 +101,7 @@ full closed loop is documented in agora's `.claude/skills/eslint-autonomy/SKILL.
 | [enforce-dynamic-imports](docs/rules/enforce-dynamic-imports.md)                                             | Enforce dynamic imports for external libraries by default to optimize bundle size, unless explicitly ignored                                                                                                                                                                                                                                                                                     | ✅  |    |    |    |    |
 | [enforce-early-destructuring](docs/rules/enforce-early-destructuring.md)                                     | Hoist object destructuring out of React hooks so dependency arrays track the fields in use instead of the entire object.                                                                                                                                                                                                                                                                         | ✅  |    | 🔧 |    |    |
 | [enforce-empty-object-check](docs/rules/enforce-empty-object-check.md)                                       | Ensure object existence checks also guard against empty objects so that empty payloads are treated like missing data.                                                                                                                                                                                                                                                                            | ✅  |    | 🔧 |    |    |
-| [enforce-exported-function-types](docs/rules/enforce-exported-function-types.md)                             | Enforce exporting types for function props and return values                                                                                                                                                                                                                                                                                                                                     | ✅  |    |    |    |    |
+| [enforce-exported-function-types](docs/rules/enforce-exported-function-types.md)                             | Enforce exporting types for function props and return values                                                                                                                                                                                                                                                                                                                                     | ✅  |    | 🔧 |    |    |
 | [enforce-f-extension-for-entry-points](docs/rules/enforce-f-extension-for-entry-points.md)                   | Enforce .f.ts extension for entry points                                                                                                                                                                                                                                                                                                                                                         | ✅  |    |    |    |    |
 | [enforce-fieldpath-syntax-in-docsetter](docs/rules/enforce-fieldpath-syntax-in-docsetter.md)                 | Enforce the use of Firestore FieldPath syntax when passing documentData into DocSetter. Instead of using nested object syntax, developers should use dot notation for deeply nested fields.                                                                                                                                                                                                      | ✅  |    | 🔧 |    |    |
 | [enforce-firestore-doc-ref-generic](docs/rules/enforce-firestore-doc-ref-generic.md)                         | Enforce generic argument for Firestore DocumentReference, CollectionReference and CollectionGroup                                                                                                                                                                                                                                                                                                | ✅  |    |    |    | 💭 |

package/lib/index.js

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

package/lib/rules/enforce-css-media-queries.d.ts

@@ -1,5 +1,6 @@
+import { TSESLint } from '@typescript-eslint/utils';
 /**
  * This rule enforces the use of CSS media queries instead of JavaScript-based breakpoints
  * in React components for better performance and separation of concerns.
  */
-export declare const enforceCssMediaQueries: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"enforceCssMediaQueries", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export declare const enforceCssMediaQueries: TSESLint.RuleModule<"enforceCssMediaQueries", [], TSESLint.RuleListener>;

package/lib/rules/enforce-css-media-queries.js

@@ -2,7 +2,158 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceCssMediaQueries = void 0;
 const utils_1 = require("@typescript-eslint/utils");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 const createRule_1 = require("../utils/createRule");
+/** Hooks whose calls perform JavaScript media detection. */
+const MEDIA_HOOKS = new Set(['useMediaQuery', 'useMobile']);
+/**
+ * Features that describe the viewport's geometry. A stylesheet evaluates these
+ * itself, so asking JavaScript for the answer duplicates a CSS breakpoint and
+ * the rule's remedy — move the breakpoint into `@media` — applies.
+ */
+const LAYOUT_FEATURES = new Set([
+    'width',
+    'min-width',
+    'max-width',
+    'height',
+    'min-height',
+    'max-height',
+    'aspect-ratio',
+    'min-aspect-ratio',
+    'max-aspect-ratio',
+    'resolution',
+    'min-resolution',
+    'max-resolution',
+    'device-width',
+    'min-device-width',
+    'max-device-width',
+    'device-height',
+    'min-device-height',
+    'max-device-height',
+    'device-aspect-ratio',
+    'min-device-aspect-ratio',
+    'max-device-aspect-ratio',
+]);
+/**
+ * Features that describe the device's capabilities or the user's preferences.
+ * These gate JavaScript behaviour — whether a component mounts, which animation
+ * duration a prop carries, which branch a hook takes — and no class name can
+ * express that decision, so the rule's remedy is unreachable and the query is
+ * exempt.
+ */
+const NON_LAYOUT_FEATURES = new Set([
+    'hover',
+    'any-hover',
+    'pointer',
+    'any-pointer',
+    'orientation',
+    'display-mode',
+    'forced-colors',
+    'inverted-colors',
+    'update',
+    'scripting',
+]);
+/** Every `prefers-*` feature is a user preference, never a layout measurement. */
+const PREFERENCE_FEATURE_PREFIX = 'prefers-';
+/**
+ * Guards the text a query carries outside its feature groups — media types and
+ * combinators such as `screen`, `and`, `not`. A layout name appearing there
+ * means the query is shaped in a way the group scanner does not read, so the
+ * rule keeps reporting it rather than guessing.
+ */
+const LAYOUT_NAME = new RegExp([...LAYOUT_FEATURES].join('|'));
+const FEATURE_GROUP = /\(([^()]*)\)/g;
+/** Follows at most this many indirections while resolving a query argument. */
+const MAX_RESOLUTION_DEPTH = 4;
+/**
+ * The feature a parenthesized query group tests, or `null` when the group's
+ * shape leaves it ambiguous (range syntax such as `(width >= 600px)`, a nested
+ * `calc()`, an empty group).
+ */
+function featureNameOf(group) {
+    const separator = group.indexOf(':');
+    const name = (separator === -1 ? group : group.slice(0, separator))
+        .trim()
+        .toLowerCase();
+    if (name === '' || /[^a-z-]/.test(name)) {
+        return null;
+    }
+    return name;
+}
+function isNonLayoutFeature(name) {
+    return (NON_LAYOUT_FEATURES.has(name) || name.startsWith(PREFERENCE_FEATURE_PREFIX));
+}
+/**
+ * Whether every feature the query tests is a capability or preference. An
+ * unrecognized feature, a mixed query (`(hover: hover) and (min-width: 600px)`)
+ * or a query naming no feature at all is not exempt: the rule reports whenever
+ * it cannot prove the query is free of layout.
+ */
+function testsOnlyNonLayoutFeatures(query) {
+    const normalized = query.toLowerCase();
+    const groups = new RegExp(FEATURE_GROUP.source, FEATURE_GROUP.flags);
+    let match;
+    let sawFeature = false;
+    while ((match = groups.exec(normalized)) !== null) {
+        const name = featureNameOf(match[1]);
+        // A layout feature and an unrecognized one both keep the query reportable:
+        // the exemption exists only where the query is provably free of layout.
+        if (name === null || !isNonLayoutFeature(name)) {
+            return false;
+        }
+        sawFeature = true;
+    }
+    const outsideGroups = normalized.replace(new RegExp(FEATURE_GROUP.source, FEATURE_GROUP.flags), ' ');
+    return sawFeature && !LAYOUT_NAME.test(outsideGroups);
+}
+/**
+ * The query string an argument carries, or `null` when the rule cannot see it.
+ * A `theme.breakpoints.*` expression, an imported constant, a template with
+ * interpolations and a reassignable binding all resolve to `null`, which keeps
+ * them reportable.
+ */
+function resolveQuery(node, scope, depth = 0) {
+    if (depth > MAX_RESOLUTION_DEPTH) {
+        return null;
+    }
+    switch (node.type) {
+        case utils_1.AST_NODE_TYPES.Literal:
+            return typeof node.value === 'string' ? node.value : null;
+        case utils_1.AST_NODE_TYPES.TemplateLiteral:
+            return node.expressions.length === 0
+                ? node.quasis[0]?.value.cooked ?? null
+                : null;
+        // `as const`, `satisfies` and angle-bracket assertions only annotate the
+        // string they wrap, so the query survives them unchanged.
+        case utils_1.AST_NODE_TYPES.TSAsExpression:
+        case utils_1.AST_NODE_TYPES.TSSatisfiesExpression:
+        case utils_1.AST_NODE_TYPES.TSTypeAssertion:
+        case utils_1.AST_NODE_TYPES.TSNonNullExpression:
+            return resolveQuery(node.expression, scope, depth + 1);
+        case utils_1.AST_NODE_TYPES.Identifier:
+            return resolveBinding(node, scope, depth);
+        default:
+            return null;
+    }
+}
+function resolveBinding(node, scope, depth) {
+    const variable = ASTHelpers_1.ASTHelpers.findVariableInScope(scope, node.name);
+    if (!variable || variable.defs.length !== 1) {
+        return null;
+    }
+    const definition = variable.defs[0];
+    if (definition.type !== 'Variable' || !definition.node.init) {
+        return null;
+    }
+    // Only a `const` proves the query the call receives is the one declared here;
+    // a `let` may hold a width query by the time the hook runs.
+    const declaration = definition.parent;
+    if (declaration?.type !== utils_1.AST_NODE_TYPES.VariableDeclaration ||
+        declaration.kind !== 'const') {
+        return null;
+    }
+    return resolveQuery(definition.node.init, scope, depth + 1);
+}
 /**
  * This rule enforces the use of CSS media queries instead of JavaScript-based breakpoints
  * in React components for better performance and separation of concerns.
@@ -22,11 +173,28 @@ exports.enforceCssMediaQueries = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
-        const reportUsage = (node, source) => context.report({
+        /**
+         * Import reports are held back until traversal ends: an import whose hook is
+         * called in the same file is the same single usage as the call, and one
+         * usage earns one report (and therefore one disable comment).
+         */
+        const pendingImports = [];
+        const calledHooks = new Set();
+        const reportableCalls = [];
+        const reportUsage = ({ node, source }) => context.report({
             node,
             messageId: 'enforceCssMediaQueries',
             data: { source },
         });
+        const localNamesOf = (node) => node.specifiers.map((specifier) => specifier.local.name);
+        const isExemptCall = (node) => {
+            const [argument] = node.arguments;
+            if (!argument) {
+                return false;
+            }
+            const query = resolveQuery(argument, ASTHelpers_1.ASTHelpers.getScope(context, node));
+            return query !== null && testsOnlyNonLayoutFeatures(query);
+        };
         return {
             // Only react-responsive is handled at the declaration level to avoid duplicates.
             ImportDeclaration(node) {
@@ -34,7 +202,11 @@ exports.enforceCssMediaQueries = (0, createRule_1.createRule)({
                     !node.source.value.includes('react-responsive/')) {
                     return;
                 }
-                reportUsage(node, `react-responsive import "${String(node.source.value)}"`);
+                pendingImports.push({
+                    node,
+                    source: `react-responsive import "${String(node.source.value)}"`,
+                    localNames: localNamesOf(node),
+                });
             },
             // Handle specific specifiers to avoid duplicate diagnostics.
             ImportSpecifier(node) {
@@ -42,22 +214,45 @@ exports.enforceCssMediaQueries = (0, createRule_1.createRule)({
                     node.imported.type === utils_1.AST_NODE_TYPES.Identifier) {
                     if (node.parent.source.value === '@mui/material' &&
                         node.imported.name === 'useMediaQuery') {
-                        reportUsage(node, 'useMediaQuery import from @mui/material');
+                        pendingImports.push({
+                            node,
+                            source: 'useMediaQuery import from @mui/material',
+                            localNames: [node.local.name],
+                        });
                         return;
                     }
                     if (node.imported.name === 'useMobile') {
-                        reportUsage(node, `useMobile import from ${String(node.parent.source.value)}`);
+                        pendingImports.push({
+                            node,
+                            source: `useMobile import from ${String(node.parent.source.value)}`,
+                            localNames: [node.local.name],
+                        });
                         return;
                     }
                 }
             },
             // Check for useMediaQuery and useMobile calls
             CallExpression(node) {
-                if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    (node.callee.name === 'useMediaQuery' ||
-                        node.callee.name === 'useMobile')) {
-                    reportUsage(node, `${node.callee.name} call`);
+                if (node.callee.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                    !MEDIA_HOOKS.has(node.callee.name)) {
+                    return;
+                }
+                calledHooks.add(node.callee.name);
+                if (isExemptCall(node)) {
+                    return;
                 }
+                reportableCalls.push({ node, source: `${node.callee.name} call` });
+            },
+            'Program:exit'() {
+                reportableCalls.forEach(reportUsage);
+                pendingImports
+                    // An import the file also calls is covered by the call: reported
+                    // through it when the query is a breakpoint, and exempt with it when
+                    // every query is a capability or preference probe. An import with no
+                    // call — unused, re-exported, passed around as a value — has no call
+                    // to carry the report, so it keeps its own.
+                    .filter(({ localNames }) => !localNames.some((n) => calledHooks.has(n)))
+                    .forEach(reportUsage);
             },
         };
     },

package/lib/rules/enforce-exported-function-types.js

@@ -4,6 +4,67 @@ exports.enforceExportedFunctionTypes = void 0;
 /* eslint-disable @typescript-eslint/no-empty-function */
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+/**
+ * `require-memo` rewrites `export function Banner(props: P)` into
+ * `export const Banner = memo(function BannerUnmemoized(props: P) {...})`, so
+ * every wrapper it can emit has to be unwrapped here or the config's own
+ * autofix hides the component from this rule.
+ */
+const COMPONENT_WRAPPERS = new Set(['memo', 'forwardRef']);
+function isComponentName(name) {
+    return /^[A-Z]/.test(name);
+}
+function isComponentWrapperCallee(callee) {
+    if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return COMPONENT_WRAPPERS.has(callee.name);
+    }
+    if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        !callee.computed &&
+        callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return COMPONENT_WRAPPERS.has(callee.property.name);
+    }
+    return false;
+}
+/**
+ * Resolves the function that actually receives the props, peeling any nesting
+ * of component wrappers (`memo(forwardRef(fn))`) along the way.
+ *
+ * `seen` records the binding names already followed, so mutually aliased
+ * declarations (`const A = memo(B); const B = memo(A);`) terminate instead of
+ * recursing forever.
+ */
+function unwrapComponentFunction(node, resolveComponent, isWrapped = false, seen = new Set()) {
+    if (!node)
+        return undefined;
+    if (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+        node.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+        node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) {
+        return { fn: node, isWrapped };
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.CallExpression &&
+        isComponentWrapperCallee(node.callee)) {
+        const [firstArgument] = node.arguments;
+        if (!firstArgument || firstArgument.type === utils_1.AST_NODE_TYPES.SpreadElement) {
+            return undefined;
+        }
+        return unwrapComponentFunction(firstArgument, resolveComponent, true, seen);
+    }
+    // `export const Banner = memo(BannerUnmemoized)` is the shape `require-memo`
+    // leaves behind most often, and the props it wraps live one hop away on the
+    // named declaration. Resolution is confined to wrapper arguments: a bare
+    // `export const Banner = Other` re-exports a value rather than declaring a
+    // component here.
+    if (isWrapped && node.type === utils_1.AST_NODE_TYPES.Identifier) {
+        if (seen.has(node.name))
+            return undefined;
+        seen.add(node.name);
+        const component = unwrapComponentFunction(resolveComponent(node.name), resolveComponent, true, seen);
+        if (!component)
+            return undefined;
+        return { ...component, resolvedName: component.resolvedName ?? node.name };
+    }
+    return undefined;
+}
 exports.enforceExportedFunctionTypes = (0, createRule_1.createRule)({
     name: 'enforce-exported-function-types',
     meta: {
@@ -12,6 +73,7 @@ exports.enforceExportedFunctionTypes = (0, createRule_1.createRule)({
             description: 'Enforce exporting types for function props and return values',
             recommended: 'error',
         },
+        fixable: 'code',
         schema: [],
         messages: {
             missingExportedType: 'Type "{{typeName}}" is used in a parameter of an exported function but is not exported. Callers cannot import the parameter contract, which forces duplicate or ad-hoc types and makes the API drift. Export the type (e.g., `export type {{typeName}} = ...`) or reuse an already exported type.',
@@ -373,8 +435,26 @@ exports.enforceExportedFunctionTypes = (0, createRule_1.createRule)({
             ]);
             return builtInTypes.has(typeName);
         }
-        function checkAndReportType(node, parentNode, messageId) {
-            const typeNames = getTypeNames(node);
+        /**
+         * Locates the module-scope declaration of a type so the report can offer to
+         * export it. Only a bare declaration in `Program.body` qualifies: anything
+         * already carrying `export` is an `ExportNamedDeclaration` (and never
+         * reported), while a declaration nested in a namespace or a function body
+         * cannot be exported by inserting a single keyword.
+         *
+         * Merged declarations (repeated `interface Props`) are left alone: TypeScript
+         * requires every declaration of a merged name to be exported or none of
+         * them, so exporting one of several would trade a lint report for a compile
+         * error.
+         */
+        function findExportableTypeDeclaration(typeName) {
+            const declarations = context.sourceCode.ast.body.filter((statement) => (statement.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration ||
+                statement.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) &&
+                statement.id.name === typeName);
+            return declarations.length === 1 ? declarations[0] : undefined;
+        }
+        function checkAndReportType(node, parentNode, messageId, typeParams) {
+            const typeNames = getTypeNames(node, typeParams);
             for (const typeName of typeNames) {
                 if (typeName !== 'AnonymousType' &&
                     !isBuiltInType(typeName) &&
@@ -383,18 +463,102 @@ exports.enforceExportedFunctionTypes = (0, createRule_1.createRule)({
                     const key = `${typeName}-${parentNode.loc?.start.line}-${parentNode.loc?.start.column}`;
                     if (!reportedTypes.has(key)) {
                         reportedTypes.add(key);
+                        // The props contract is the shape consumers compose against, so its
+                        // remedy — exporting the local declaration — is offered as a fix.
+                        const declaration = messageId === 'missingExportedPropsType'
+                            ? findExportableTypeDeclaration(typeName)
+                            : undefined;
                         context.report({
                             node: parentNode,
                             messageId,
                             data: { typeName },
+                            fix: declaration
+                                ? (fixer) => fixer.insertTextBefore(declaration, 'export ')
+                                : undefined,
                         });
                     }
                 }
             }
         }
-        function checkAndReportParameterType(param, messageId) {
+        /**
+         * Applies the props check every exported component shape shares, reusing
+         * the parameter walk the `export function Banner(props: P)` visitor
+         * performs so the widened shapes cannot drift from it.
+         *
+         * Only the first parameter carries props. `forwardRef` hands the second one
+         * a ref, whose type (`Ref<HTMLDivElement>`) is no part of the contract a
+         * consumer composes against, so reporting it would be noise.
+         */
+        function checkComponentProps(fn) {
+            const [props] = fn.params;
+            if (!props)
+                return;
+            const typeParams = componentTypeParameters(fn);
+            // Destructuring the props changes nothing about the contract a consumer
+            // composes against, so `({ message }: BannerProps)` is read exactly like
+            // `(props: BannerProps)`. The widening stays on the props path: the
+            // parameter helper the other messageIds share keeps reading named
+            // parameters only.
+            if (props.type === utils_1.AST_NODE_TYPES.ObjectPattern && props.typeAnnotation) {
+                checkAndReportType(props.typeAnnotation.typeAnnotation, props.typeAnnotation, 'missingExportedPropsType', typeParams);
+                return;
+            }
+            checkAndReportParameterType(props, 'missingExportedPropsType', typeParams);
+        }
+        /**
+         * Collects the generic parameters a component may legitimately name in its
+         * props annotation (`memo(function ListUnmemoized<T>(props: ListProps<T>))`),
+         * which are contracts the module cannot export.
+         *
+         * Reading them off the function itself is what keeps the check correct for
+         * the shapes it reaches indirectly: `parent` links exist only for nodes
+         * ESLint has already traversed, so a component resolved through
+         * `memo(ListUnmemoized)` above its declaration has no ancestor chain to walk
+         * yet, and a function expression is no part of the ancestor walk to begin
+         * with. The ancestors are still unioned in for a component nested inside a
+         * generic function.
+         */
+        function componentTypeParameters(fn) {
+            const typeParams = findTypeParameters(fn);
+            for (const param of fn.typeParameters?.params ?? []) {
+                if (param.type === utils_1.AST_NODE_TYPES.TSTypeParameter) {
+                    typeParams.add(param.name.name);
+                }
+            }
+            return typeParams;
+        }
+        /**
+         * Resolves a module-scope binding to the declaration or initializer it
+         * names, which is what turns `memo(BannerUnmemoized)` into the function
+         * carrying the props.
+         *
+         * A name with no module-scope declaration belongs to another module. Its
+         * props type is declared there and cannot be exported by editing this file,
+         * so an unresolved name leaves the component unchecked rather than guessing.
+         */
+        function findModuleScopeDeclaration(name) {
+            for (const statement of context.sourceCode.ast.body) {
+                const declaration = statement.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration &&
+                    statement.declaration
+                    ? statement.declaration
+                    : statement;
+                if (declaration.type === utils_1.AST_NODE_TYPES.FunctionDeclaration &&
+                    declaration.id?.name === name) {
+                    return declaration;
+                }
+                if (declaration.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
+                    const declarator = declaration.declarations.find((candidate) => candidate.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        candidate.id.name === name);
+                    if (declarator?.init) {
+                        return declarator.init;
+                    }
+                }
+            }
+            return undefined;
+        }
+        function checkAndReportParameterType(param, messageId, typeParams) {
             if (param.type === utils_1.AST_NODE_TYPES.Identifier && param.typeAnnotation) {
-                checkAndReportType(param.typeAnnotation.typeAnnotation, param.typeAnnotation, messageId);
+                checkAndReportType(param.typeAnnotation.typeAnnotation, param.typeAnnotation, messageId, typeParams);
             }
         }
         function isTypeExported(typeName) {
@@ -507,9 +671,14 @@ exports.enforceExportedFunctionTypes = (0, createRule_1.createRule)({
             FunctionDeclaration(node) {
                 if (!isExported(node))
                     return;
-                // Skip React components
-                if (node.id?.name && /^[A-Z]/.test(node.id.name))
+                // A component declaration takes the props path, which reads the first
+                // parameter however it is spelled. Routing it through the same helper
+                // as the expression and wrapper shapes is what keeps a destructured
+                // parameter from being visible in one shape and invisible in another.
+                if (node.id?.name && isComponentName(node.id.name)) {
+                    checkComponentProps(node);
                     return;
+                }
                 // Check return type
                 if (node.returnType?.typeAnnotation) {
                     checkAndReportType(node.returnType.typeAnnotation, node.returnType, 'missingExportedReturnType');
@@ -545,6 +714,40 @@ exports.enforceExportedFunctionTypes = (0, createRule_1.createRule)({
                     checkAndReportType(node.typeAnnotation.typeAnnotation, node.typeAnnotation, 'missingExportedPropsType');
                 }
             },
+            // Handle exported components written as an expression:
+            // `export const Banner = (props: P) => ...`,
+            // `export const Banner = function (props: P) {...}`, any
+            // `memo`/`forwardRef` nesting around either form, and the wrappers whose
+            // argument names a same-file function (`memo(BannerUnmemoized)`).
+            VariableDeclarator(node) {
+                if (node.id.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                    !isComponentName(node.id.name) ||
+                    !isExported(node.parent)) {
+                    return;
+                }
+                const component = unwrapComponentFunction(node.init, findModuleScopeDeclaration);
+                if (!component)
+                    return;
+                checkComponentProps(component.fn);
+            },
+            // `export default memo(function Banner(props: P) {...})` mirrors the
+            // `export default function Banner(props: P)` form the declaration
+            // visitors already cover.
+            ExportDefaultDeclaration(node) {
+                const component = unwrapComponentFunction(node.declaration, findModuleScopeDeclaration);
+                if (!component)
+                    return;
+                // The binding a wrapper argument named outranks the inner function's
+                // own name: `export default memo(BannerUnmemoized)` is the component
+                // consumers see, whatever the resolved expression calls itself.
+                const name = component.resolvedName ?? component.fn.id?.name;
+                // An anonymous default export is only recognizable as a component
+                // through its wrapper, since there is no name to inspect.
+                const isComponent = name === undefined ? component.isWrapped : isComponentName(name);
+                if (!isComponent)
+                    return;
+                checkComponentProps(component.fn);
+            },
             // Skip type checking for React components since we handle them separately
             'FunctionDeclaration[id.name=/^[A-Z]/] > TSTypeAnnotation'() { },
             'FunctionDeclaration[id.name=/^[A-Z]/] > TSTypeAnnotation > TSTypeReference'() { },

package/lib/rules/enforce-firestore-doc-ref-generic.js

@@ -55,13 +55,7 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
                     if (!node.members || node.members.length === 0) {
                         return true;
                     }
-                    return node.members.some((member) => {
-                        if (member.type === utils_1.AST_NODE_TYPES.TSPropertySignature &&
-                            member.typeAnnotation) {
-                            return hasInvalidType(member.typeAnnotation.typeAnnotation);
-                        }
-                        return false;
-                    });
+                    return membersHaveInvalidType(node.members);
                 case utils_1.AST_NODE_TYPES.TSTypeReference:
                     if (node.typeParameters) {
                         return node.typeParameters.params.some(hasInvalidType);
@@ -74,17 +68,9 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
                         }
                         // Prevent infinite recursion
                         typeCache.set(typeName, false);
-                        const program = context.sourceCode.ast;
-                        const interfaceDecl = program.body.find((n) => n.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration &&
-                            n.id.name === typeName);
-                        if (interfaceDecl) {
-                            const result = interfaceDecl.body.body.some((member) => {
-                                if (member.type === utils_1.AST_NODE_TYPES.TSPropertySignature &&
-                                    member.typeAnnotation) {
-                                    return hasInvalidType(member.typeAnnotation.typeAnnotation);
-                                }
-                                return false;
-                            });
+                        const members = declaredMembersOf(typeName);
+                        if (members) {
+                            const result = membersHaveInvalidType(members);
                             typeCache.set(typeName, result);
                             return result;
                         }
@@ -120,6 +106,73 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
                     return false;
             }
         }
+        function membersHaveInvalidType(members) {
+            return members.some((member) => {
+                if (member.type === utils_1.AST_NODE_TYPES.TSPropertySignature &&
+                    member.typeAnnotation) {
+                    return hasInvalidType(member.typeAnnotation.typeAnnotation);
+                }
+                return false;
+            });
+        }
+        /**
+         * Wrappers an alias may place around its type literal without changing the
+         * fields the document declares. `Readonly<{...}>` written inline at the
+         * reference is already looked through by the type-argument recursion in
+         * `hasInvalidType`, so reading it here keeps the two spellings in agreement.
+         * A wrapper that drops fields, such as `Omit`, is excluded: its members are
+         * not the document's members, and checking them invents reports.
+         */
+        const FIELD_PRESERVING_WRAPPERS = new Set(['Readonly']);
+        /**
+         * Reads the type literal an alias declares, looking through at most one
+         * field-preserving wrapper. Anything else — a union, an intersection, a
+         * mapped type, a reference to another named or imported type — has no
+         * members this rule can read syntactically, and guessing at them is how
+         * false positives arrive, so it stays unresolved.
+         */
+        function aliasedTypeLiteral(typeNode) {
+            if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
+                return typeNode;
+            }
+            if (typeNode.type !== utils_1.AST_NODE_TYPES.TSTypeReference ||
+                typeNode.typeName.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                !FIELD_PRESERVING_WRAPPERS.has(typeNode.typeName.name)) {
+                return undefined;
+            }
+            const wrapperArguments = typeNode.typeParameters?.params;
+            if (!wrapperArguments || wrapperArguments.length !== 1) {
+                return undefined;
+            }
+            const [wrapped] = wrapperArguments;
+            return wrapped.type === utils_1.AST_NODE_TYPES.TSTypeLiteral
+                ? wrapped
+                : undefined;
+        }
+        /**
+         * Resolves a named generic to the members its declaration lists, reading an
+         * interface and a type alias alike.
+         *
+         * The alias spelling is not an extra convenience: `prefer-type-over-interface`
+         * ships in the same recommended config and is fixable, so a single
+         * `eslint --fix` pass rewrites every interface into a type alias. A lookup
+         * that reads interfaces alone therefore resolves nothing on a codebase that
+         * has run the config, and a nested `any` in a document schema goes
+         * unreported.
+         */
+        function declaredMembersOf(typeName) {
+            for (const statement of context.sourceCode.ast.body) {
+                if (statement.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration &&
+                    statement.id.name === typeName) {
+                    return statement.body.body;
+                }
+                if (statement.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration &&
+                    statement.id.name === typeName) {
+                    return aliasedTypeLiteral(statement.typeAnnotation)?.members;
+                }
+            }
+            return undefined;
+        }
         function hasTypeAnnotation(node) {
             if (nodeCache.has(node)) {
                 return nodeCache.get(node);