@blumintinc/eslint-plugin-blumint 1.20.95 → 1.20.97

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.97',
     },
     parseOptions: {
         ecmaVersion: 2020,

package/lib/rules/enforce-boolean-naming-prefixes.js

@@ -113,12 +113,25 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                     return true;
                 }
                 const nextChar = normalizedName.charAt(p.length);
-                // For SCREAMING_SNAKE_CASE or similar all-uppercase names,
-                // we require an underscore boundary.
+                // For SCREAMING_SNAKE_CASE or similar all-uppercase names the prefix must
+                // end at a separator, since case can no longer mark the word boundary
+                // (ISVALID stays unprefixed). Digits fused onto the prefix belong to that
+                // first segment rather than to the next word — ARE2_VALID is the
+                // UPPER_SNAKE spelling of are2Valid, which the camelCase branch below
+                // accepts — so a trailing digit run is consumed before the separator is
+                // examined, and the same separators the camelCase branch honours (`_`,
+                // `$`, end of name) close the segment. Only a digit run directly after
+                // the prefix qualifies: ARENA2_MAP still fails because a letter follows
+                // the prefix, and H2AS_ITEMS never reaches here because the prefix does
+                // not match the segment's start.
                 const isAllUppercase = normalizedName === normalizedName.toUpperCase() &&
                     /[a-z]/i.test(normalizedName);
                 if (isAllUppercase) {
-                    return nextChar === '_';
+                    const afterPrefix = normalizedName
+                        .slice(p.length)
+                        .replace(/^\d+/, '');
+                    const boundaryChar = afterPrefix.charAt(0);
+                    return (boundaryChar === '' || boundaryChar === '_' || boundaryChar === '$');
                 }
                 // For camelCase, the next char must be uppercase, a digit, or $
                 return (nextChar === '_' ||
@@ -710,6 +723,28 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                 expression.name === 'undefined') {
                 return 'nonBoolean';
             }
+            // A returned binding is governed by this very rule: a boolean variable,
+            // parameter or function must carry an approved prefix. So an unprefixed
+            // `id` — or the result of calling an unprefixed `compute(x)` — is not a
+            // boolean under the regime the rule enforces, and the callee's own name
+            // must not override that. Deciding here keeps the exemption in the body
+            // rather than in a return annotation, which `no-explicit-return-type`
+            // deletes (issue #1691).
+            //
+            // Member accesses (`source.flag`, `source.read()`) are deliberately
+            // excluded: property signatures are only enforced under
+            // `enforceForPropertySignatures` and third-party method names are outside
+            // this rule's reach, so an unprefixed member may legitimately yield a
+            // boolean and the callee's name keeps its say.
+            if (expression.type === utils_1.AST_NODE_TYPES.Identifier) {
+                return identifierIsBoolean(expression) ? 'boolean' : 'nonBoolean';
+            }
+            if (expression.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                expression.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                return callExpressionLooksBoolean(expression) === 'boolean'
+                    ? 'boolean'
+                    : 'nonBoolean';
+            }
             if (expression.type === utils_1.AST_NODE_TYPES.UnaryExpression) {
                 if (expression.operator === '!' || expression.operator === 'delete') {
                     return 'boolean';

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'() { },