@blumintinc/eslint-plugin-blumint 1.14.0 → 1.15.0

package/lib/rules/enforce-f-extension-for-entry-points.js

@@ -0,0 +1,283 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceFExtensionForEntryPoints = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const path_1 = __importDefault(require("path"));
+const ASTHelpers_1 = require("../utils/ASTHelpers");
+const DEFAULT_ENTRY_POINTS = [
+    'onCall',
+    'onCallVaripotent',
+    'onRequest',
+    'onQueueTask',
+    'onWebhook',
+    'sequentialDocumentWritten',
+    'onDocumentWritten',
+    'onDocumentCreated',
+    'onDocumentDeleted',
+    'onDocumentUpdated',
+    'onSchedule',
+    'onValueWritten',
+    'onValueCreated',
+    'onValueUpdated',
+    'onValueDeleted',
+    'sequentialValueWritten',
+    'sequentialValueCreated',
+    'sequentialValueUpdated',
+    'sequentialValueDeleted',
+];
+/**
+ * Entry points must be defined at the top level because Firebase deployment
+ * discovers and registers them by evaluating the module scope. Nested definitions
+ * inside functions or classes won't be discovered during the deployment process.
+ */
+function isTopLevel(node) {
+    let current = node.parent;
+    while (current) {
+        if (current.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+            current.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+            current.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+            current.type === utils_1.AST_NODE_TYPES.ClassDeclaration ||
+            current.type === utils_1.AST_NODE_TYPES.ClassExpression ||
+            current.type === utils_1.AST_NODE_TYPES.MethodDefinition) {
+            return false;
+        }
+        current = current.parent;
+    }
+    return true;
+}
+/**
+ * Checks if a node directly defines an entry point as a function or variable declaration.
+ * This exempts wrapper implementation files (e.g., functions/src/v2/) but intentionally
+ * does not exempt re-export files (e.g., `const myCall = onCall; export { myCall }`).
+ * Re-export files that also invoke entry points must still follow the .f.ts naming convention
+ * and will be flagged by the CallExpression handler.
+ *
+ * This function specifically checks AST node types FunctionDeclaration and
+ * VariableDeclaration but does not catch ExportSpecifiers used in re-exports.
+ */
+function isNodeDefiningEntryPoint(node, entryPoints) {
+    // Handle function declaration: export function onCall() {}
+    if (node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration &&
+        node.id &&
+        entryPoints.has(node.id.name)) {
+        return true;
+    }
+    // Handle variable declaration: export const onCall = ...
+    if (node.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
+        return node.declarations.some((decl) => decl.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+            entryPoints.has(decl.id.name));
+    }
+    return false;
+}
+/**
+ * Obtains the scope for a node in an ESLint 9+ compatible way.
+ *
+ * Note: In ESLint 8, falls back to context.getScope() which returns the scope
+ * of the currently visited node—only call this from within visitor handlers
+ * for the target node.
+ */
+function getScopeForNode(context, node) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    if (isEslint9OrLater(sourceCode)) {
+        return getEslint9Scope(sourceCode, node);
+    }
+    return context.getScope();
+}
+/**
+ * Checks if the current environment is ESLint 9 or later.
+ */
+function isEslint9OrLater(sourceCode) {
+    return typeof sourceCode.getScope === 'function';
+}
+/**
+ * Gets the scope for a node using the ESLint 9+ SourceCode.getScope() method.
+ */
+function getEslint9Scope(sourceCode, node) {
+    return sourceCode.getScope(node);
+}
+/**
+ * Gets the import definition for a given name in the current scope.
+ */
+function getImportDef(context, calleeName, node) {
+    const scope = getScopeForNode(context, node);
+    const variable = ASTHelpers_1.ASTHelpers.findVariableInScope(scope, calleeName);
+    if (!variable) {
+        return null;
+    }
+    return variable.defs.find((def) => def.type === 'ImportBinding') ?? null;
+}
+/**
+ * Checks if the import comes from an allowed Firebase or internal wrapper source.
+ */
+function isFromAllowedSource(importDef) {
+    if (!importDef || !importDef.parent) {
+        return false;
+    }
+    const importDeclaration = importDef.parent;
+    if (importDeclaration.type !== utils_1.AST_NODE_TYPES.ImportDeclaration) {
+        return false;
+    }
+    const source = importDeclaration.source.value;
+    return (source.startsWith('firebase-functions') ||
+        /(^|\/)v2(\/|$)/.test(source) ||
+        /(^|\/)util\/webhook(\/|$)/.test(source));
+}
+/**
+ * Helper function to extract name from import specifier.
+ */
+function getNameFromImportSpecifier(node) {
+    const { imported } = node;
+    if (imported.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return imported.name;
+    }
+    // Handle Literal imports (string-named imports in ESLint 8+)
+    const importedNode = imported;
+    if (importedNode.type === utils_1.AST_NODE_TYPES.Literal &&
+        typeof importedNode.value === 'string') {
+        return importedNode.value;
+    }
+    return undefined;
+}
+/**
+ * Helper function to extract name from module path.
+ */
+function getNameFromModulePath(importDeclaration, entryPoints) {
+    const modulePath = importDeclaration.source.value;
+    // Extract the module name from the path.
+    // Example: '../../v2/https/onCall' -> 'onCall'
+    const match = modulePath.match(/[/\\]([^/\\]+)$/);
+    const segment = (match ? match[1] : modulePath).replace(/\.[jt]sx?$/, '');
+    return entryPoints.has(segment) ? segment : undefined;
+}
+/**
+ * Resolves the original name of the imported function, handling aliases and default imports.
+ */
+function getOriginalName(importDef, calleeName, entryPoints) {
+    if (!importDef || !importDef.node) {
+        return calleeName;
+    }
+    // Handle named imports: import { onCall as myCall } from ...
+    if (importDef.node.type === utils_1.AST_NODE_TYPES.ImportSpecifier) {
+        return getNameFromImportSpecifier(importDef.node) ?? calleeName;
+    }
+    // Handle default imports: import onCall from '../../v2/https/onCall'
+    // or namespace imports: import * as onCall from '../../v2/https/onCall'
+    if (importDef.node.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier ||
+        importDef.node.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+        return (getNameFromModulePath(importDef.parent, entryPoints) ?? calleeName);
+    }
+    return calleeName;
+}
+exports.enforceFExtensionForEntryPoints = (0, createRule_1.createRule)({
+    name: 'enforce-f-extension-for-entry-points',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce .f.ts extension for entry points',
+            recommended: 'error',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    entryPoints: {
+                        type: 'array',
+                        items: { type: 'string' },
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            requireFExtension: 'File "{{fileName}}" contains a Firebase Cloud Function entry point "{{entryPoint}}" but lacks the ".f.ts" extension. ' +
+                'Entry points must use ".f.ts" to clearly mark the public function surface to avoid accidental export/name collisions, ' +
+                'unintended exposure of internal implementation during deployment, confusion during imports/tests, and maintenance bugs. ' +
+                'Rename this file to "{{suggestedName}}" to mark it as a public entry point.',
+        },
+    },
+    defaultOptions: [{ entryPoints: DEFAULT_ENTRY_POINTS }],
+    create(context, [options]) {
+        const filePath = context.filename ??
+            context.getFilename();
+        const fileName = path_1.default.basename(filePath);
+        const entryPoints = new Set(options.entryPoints?.length ? options.entryPoints : DEFAULT_ENTRY_POINTS);
+        // Only apply to files under functions/src/
+        const normalizedPath = filePath.replace(/\\/g, '/');
+        if (!normalizedPath.includes('/functions/src/') &&
+            !normalizedPath.startsWith('functions/src/')) {
+            return {};
+        }
+        // Exclude test files and declaration files
+        if (/\.(test|spec)\.tsx?$|\.d\.ts$/.test(fileName)) {
+            return {};
+        }
+        // Only apply to .ts and .tsx files, but not files already using .f.ts or .f.tsx
+        const isTsOrTsx = /\.tsx?$/.test(fileName);
+        const isFExtension = /\.f\.tsx?$/.test(fileName);
+        if (!isTsOrTsx || isFExtension) {
+            return {};
+        }
+        let isDefiningEntryPoint = false;
+        let reported = false;
+        return {
+            ExportNamedDeclaration(node) {
+                if (isDefiningEntryPoint || !node.declaration) {
+                    return;
+                }
+                if (isNodeDefiningEntryPoint(node.declaration, entryPoints)) {
+                    isDefiningEntryPoint = true;
+                }
+            },
+            ExportDefaultDeclaration(node) {
+                if (isDefiningEntryPoint) {
+                    return;
+                }
+                if (isNodeDefiningEntryPoint(node.declaration, entryPoints)) {
+                    isDefiningEntryPoint = true;
+                }
+            },
+            CallExpression(node) {
+                if (reported || isDefiningEntryPoint) {
+                    return;
+                }
+                // We only care about simple identifier calls (e.g., onCall())
+                if (node.callee.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                    return;
+                }
+                const calleeName = node.callee.name;
+                // Optimization: Early return if it's not a top-level call
+                if (!isTopLevel(node)) {
+                    return;
+                }
+                // Variable lookup logic and import source validation
+                const importDef = getImportDef(context, calleeName, node);
+                if (!importDef || !isFromAllowedSource(importDef)) {
+                    return;
+                }
+                // Entry point checking
+                const originalName = getOriginalName(importDef, calleeName, entryPoints);
+                if (!entryPoints.has(originalName)) {
+                    return;
+                }
+                reported = true;
+                const suggestedName = fileName.replace(/\.tsx?$/, '.f$&');
+                context.report({
+                    node,
+                    messageId: 'requireFExtension',
+                    data: {
+                        fileName,
+                        entryPoint: calleeName === originalName
+                            ? calleeName
+                            : `${calleeName} (${originalName})`,
+                        suggestedName,
+                    },
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-f-extension-for-entry-points.js.map

package/lib/rules/enforce-global-constants.js

@@ -9,14 +9,14 @@ exports.enforceGlobalConstants = (0, createRule_1.createRule)({
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Enforce using global static constants instead of useMemo with empty dependency arrays for object literals, and extract inline destructuring defaults in React components/hooks to global constants',
+            description: 'Enforce global static constants for React components/hooks',
             recommended: 'error',
         },
         fixable: 'code',
         schema: [],
         messages: {
-            useGlobalConstant: 'Use a global static constant instead of useMemo with an empty dependency array for object literals',
-            extractDefaultToGlobalConstant: 'Extract inline default value to a module-level constant for stable reference',
+            useGlobalConstant: 'Object literal returned from useMemo with empty dependencies creates a new reference every render without providing memoization benefits → this wastes memory and misleads readers into thinking the value is computed → move the object to a module-level constant (e.g., const OPTIONS = { ... } as const;).',
+            extractDefaultToGlobalConstant: 'Inline default value in destructuring creates a new reference on every render → this causes unnecessary re-renders in child components due to unstable identity → extract the default to a module-level constant (e.g., const DEFAULT_OPTIONS = { ... } as const;).',
         },
     },
     defaultOptions: [],

package/lib/rules/enforce-id-capitalization.js

@@ -19,7 +19,7 @@ exports.enforceIdCapitalization = (0, createRule_1.createRule)({
         fixable: 'code',
         schema: [],
         messages: {
-            enforceIdCapitalization: 'Use "ID" instead of "id" in user-facing text for better readability',
+            enforceIdCapitalization: 'Found lowercase "id" in user-facing text → "ID" (capitalized) is the standard abbreviation for "identifier" and improves readability in UI labels and messages → replace lowercase "id" with uppercase "ID" in displayed labels and messages.',
         },
     },
     defaultOptions: [],

package/lib/rules/enforce-memoize-async.js

@@ -3,7 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceMemoizeAsync = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
-const MEMOIZE_MODULE = 'typescript-memoize';
+const MEMOIZE_MODULE = '@blumintinc/typescript-memoize';
+const ALLOWED_MEMOIZE_MODULES = new Set([
+    MEMOIZE_MODULE,
+    'typescript-memoize',
+]);
 /**
  * Matches a memoize decorator in supported syntaxes:
  * - @Alias()
@@ -38,33 +42,34 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Enforce @Memoize() decorator on async methods with 0-1 parameters to cache results and prevent redundant API calls or expensive computations. This improves performance by reusing previous results when the same parameters are provided, particularly useful for data fetching methods.',
+            description: 'Enforce @Memoize() decorator on async methods with 0-1 parameters to cache results and prevent redundant API calls or expensive computations. Without memoization, repeated calls trigger redundant requests or expensive computations, increasing latency. @Memoize() caches results by parameter, ensuring subsequent calls with identical inputs return immediately.',
             recommended: 'error',
         },
         fixable: 'code',
         schema: [],
         messages: {
-            requireMemoize: 'Async methods with 0-1 parameters should be decorated with @Memoize() to cache results and improve performance. Instead of `async getData(id?: string)`, use `@Memoize()\nasync getData(id?: string)`. Import Memoize from "typescript-memoize".',
+            requireMemoize: 'Async methods with 0-1 parameters should be decorated with @Memoize(). Without memoization, repeated calls trigger redundant network requests or expensive computations, increasing latency and risk of rate-limiting. @Memoize() caches results by parameter, ensuring subsequent calls with identical inputs return immediately. Fix: add @Memoize() above the method and import Memoize from "@blumintinc/typescript-memoize".',
         },
     },
     defaultOptions: [],
     create(context) {
         let hasMemoizeImport = false;
-        let memoizeAlias = 'Memoize';
-        let memoizeNamespace = null;
+        const memoizeAliases = new Map(); // alias -> source module
+        const memoizeNamespaces = new Map(); // namespace -> source module
         let scheduledImportFix = false;
         return {
             ImportDeclaration(node) {
-                if (node.source.value === MEMOIZE_MODULE) {
+                if (ALLOWED_MEMOIZE_MODULES.has(String(node.source.value))) {
                     node.specifiers.forEach((spec) => {
                         if (spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                            spec.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
                             spec.imported.name === 'Memoize') {
                             hasMemoizeImport = true;
-                            memoizeAlias = spec.local?.name ?? memoizeAlias;
+                            memoizeAliases.set(spec.local.name, String(node.source.value));
                         }
                         else if (spec.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
                             hasMemoizeImport = true;
-                            memoizeNamespace = spec.local.name;
+                            memoizeNamespaces.set(spec.local.name, String(node.source.value));
                         }
                     });
                 }
@@ -81,7 +86,39 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
                     return;
                 }
                 // Check if method already has @Memoize or @Memoize() decorator
-                const hasDecorator = node.decorators?.some((decorator) => isMemoizeDecorator(decorator, memoizeAlias));
+                const hasDecorator = node.decorators?.some((decorator) => {
+                    // If no named imports were found, we assume 'Memoize' is the intended name (for legacy/global support)
+                    const aliasesToCheck = memoizeAliases.size === 0
+                        ? ['Memoize']
+                        : Array.from(memoizeAliases.keys());
+                    // Check against all known aliases
+                    for (const alias of aliasesToCheck) {
+                        if (isMemoizeDecorator(decorator, alias)) {
+                            return true;
+                        }
+                    }
+                    // Also check against namespaces
+                    const expression = decorator.expression;
+                    if (expression.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                        !expression.computed &&
+                        expression.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        expression.property.name === 'Memoize' &&
+                        expression.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        memoizeNamespaces.has(expression.object.name)) {
+                        return true;
+                    }
+                    // Handle namespace call: @ns.Memoize()
+                    if (expression.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                        expression.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                        !expression.callee.computed &&
+                        expression.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        expression.callee.property.name === 'Memoize' &&
+                        expression.callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        memoizeNamespaces.has(expression.callee.object.name)) {
+                        return true;
+                    }
+                    return false;
+                });
                 if (hasDecorator) {
                     return;
                 }
@@ -91,15 +128,32 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
                     fix(fixer) {
                         const fixes = [];
                         const sourceCode = context.sourceCode;
-                        const decoratorIdent = memoizeNamespace
-                            ? `${memoizeNamespace}.Memoize`
-                            : memoizeAlias;
+                        // Determine which identifier to use for the decorator
+                        let decoratorIdent = 'Memoize';
+                        if (hasMemoizeImport) {
+                            // Prefer 'Memoize' from the new package if available
+                            if (memoizeAliases.has('Memoize') &&
+                                memoizeAliases.get('Memoize') === MEMOIZE_MODULE) {
+                                decoratorIdent = 'Memoize';
+                            }
+                            else if (memoizeAliases.size > 0) {
+                                // Find first alias from new package, fallback to any alias
+                                const newPackageAlias = Array.from(memoizeAliases.entries()).find(([_, pkg]) => pkg === MEMOIZE_MODULE)?.[0];
+                                decoratorIdent =
+                                    newPackageAlias || Array.from(memoizeAliases.keys())[0];
+                            }
+                            else if (memoizeNamespaces.size > 0) {
+                                // Prefer namespace from the new package if available
+                                const newPackageNs = Array.from(memoizeNamespaces.entries()).find(([_, pkg]) => pkg === MEMOIZE_MODULE)?.[0];
+                                const selectedNs = newPackageNs || Array.from(memoizeNamespaces.keys())[0];
+                                decoratorIdent = `${selectedNs}.Memoize`;
+                            }
+                        }
                         const importStatement = `import { Memoize } from '${MEMOIZE_MODULE}';`;
                         // Add import if it's not already present; ensure we only add once per file
                         if (!hasMemoizeImport &&
-                            !memoizeNamespace &&
-                            !scheduledImportFix &&
-                            !sourceCode.text.includes(importStatement)) {
+                            memoizeNamespaces.size === 0 &&
+                            !scheduledImportFix) {
                             const programBody = sourceCode.ast.body;
                             const firstImport = programBody.find((n) => n.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
                             const anchorNode = (firstImport ?? programBody[0]);

package/lib/rules/enforce-props-argument-name.js

@@ -34,14 +34,48 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
         function endsWithProps(typeName) {
             return typeName.endsWith('Props');
         }
+        // Get all parameters that have a "Props" type
+        function getPropsParams(params) {
+            return params
+                .map((param) => {
+                const id = getIdFromParam(param);
+                if (id && id.typeAnnotation && id.typeAnnotation.typeAnnotation) {
+                    const paramTypeName = getTypeName(id.typeAnnotation.typeAnnotation);
+                    if (paramTypeName && endsWithProps(paramTypeName)) {
+                        return { id, typeName: paramTypeName };
+                    }
+                }
+                return null;
+            })
+                .filter((p) => !!p);
+        }
         // Generate suggested parameter name for Props types
-        function getSuggestedParameterName(typeName, allParams, currentParam) {
+        function getSuggestedParameterName(typeName, allParams, currentParam, propsParams) {
             const currentId = getIdFromParam(currentParam);
             const currentName = currentId?.name;
             const existingNames = new Set(allParams
                 .map((p) => getIdFromParam(p))
                 .filter((id) => !!id && id.name !== currentName)
                 .map((id) => id.name));
+            // If multiple parameters have the exact same Props type, allow the current names.
+            // This handles cases like (prevProps: TProps, nextProps: TProps) where
+            // forcing a single name based on the type would cause a collision or
+            // break descriptive naming.
+            const sameTypeParams = propsParams.filter((p) => p.typeName === typeName);
+            if (sameTypeParams.length > 1) {
+                // Keep the current name when multiple params share the same Props type.
+                // This preserves descriptive names like prevProps/nextProps.
+                if (!currentName) {
+                    // Fallback should not occur since destructured params are filtered upstream.
+                    let candidate = 'props';
+                    let suffix = 2;
+                    while (existingNames.has(candidate)) {
+                        candidate = `props${suffix++}`;
+                    }
+                    return candidate;
+                }
+                return currentName;
+            }
             if (typeName === 'Props') {
                 let candidate = 'props';
                 let suffix = 2;
@@ -50,17 +84,7 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
                 }
                 return candidate;
             }
-            // Count how many parameters have Props types
-            const propsParams = allParams.filter((param) => {
-                if (param.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    param.typeAnnotation &&
-                    param.typeAnnotation.typeAnnotation) {
-                    const paramTypeName = getTypeName(param.typeAnnotation.typeAnnotation);
-                    return paramTypeName && endsWithProps(paramTypeName);
-                }
-                return false;
-            });
-            // If there's only one Props parameter, suggest "props"
+            // If there's only one Props parameter (regardless of type name), suggest "props"
             if (propsParams.length <= 1) {
                 let candidate = 'props';
                 let suffix = 2;
@@ -69,8 +93,8 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
                 }
                 return candidate;
             }
-            // If there are multiple Props parameters, use prefixed names
-            // For types like "UserProps", suggest "userProps"
+            // If there are multiple Props parameters with different types, use prefixed names.
+            // For types like "UserProps", suggest "userProps".
             const baseName = typeName.slice(0, -5); // Remove "Props"
             const camelCaseBase = baseName.charAt(0).toLowerCase() + baseName.slice(1);
             let candidate = `${camelCaseBase}Props`;
@@ -138,6 +162,7 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
                 return;
             }
             const sourceCode = context.sourceCode;
+            const propsParams = getPropsParams(node.params);
             node.params.forEach((param) => {
                 if (isDestructuredParameter(param)) {
                     return;
@@ -146,7 +171,7 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
                 if (id && id.typeAnnotation && id.typeAnnotation.typeAnnotation) {
                     const typeName = getTypeName(id.typeAnnotation.typeAnnotation);
                     if (typeName && endsWithProps(typeName)) {
-                        const suggestedName = getSuggestedParameterName(typeName, node.params, param);
+                        const suggestedName = getSuggestedParameterName(typeName, node.params, param, propsParams);
                         if (id.name !== suggestedName) {
                             const messageId = suggestedName === 'props'
                                 ? 'usePropsParameterName'
@@ -174,6 +199,7 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
         function checkClassMethod(node) {
             const method = node.value;
             const sourceCode = context.sourceCode;
+            const propsParams = getPropsParams(method.params);
             method.params.forEach((param) => {
                 if (isDestructuredParameter(param)) {
                     return;
@@ -182,7 +208,7 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
                 if (id && id.typeAnnotation && id.typeAnnotation.typeAnnotation) {
                     const typeName = getTypeName(id.typeAnnotation.typeAnnotation);
                     if (typeName && endsWithProps(typeName)) {
-                        const suggestedName = getSuggestedParameterName(typeName, method.params, param);
+                        const suggestedName = getSuggestedParameterName(typeName, method.params, param, propsParams);
                         if (id.name !== suggestedName) {
                             const messageId = suggestedName === 'props'
                                 ? 'usePropsParameterName'

package/lib/rules/enforce-stable-hash-spread-props.js

@@ -31,12 +31,12 @@ function getFunctionName(node) {
     }
     return null;
 }
-function isProbablyComponent(node) {
+function isProbablyComponent(node, context) {
     const name = getFunctionName(node);
     if (name && /^[A-Z]/.test(name)) {
         return true;
     }
-    if (ASTHelpers_1.ASTHelpers.returnsJSX(node.body)) {
+    if (ASTHelpers_1.ASTHelpers.returnsJSX(node.body, context)) {
         return true;
     }
     return false;
@@ -236,7 +236,7 @@ exports.enforceStableHashSpreadProps = (0, createRule_1.createRule)({
                 }
                 functionStack.push({
                     node,
-                    isComponent: isProbablyComponent(node),
+                    isComponent: isProbablyComponent(node, context),
                     restNames,
                     propsIdentifiers,
                 });

package/lib/rules/enforce-transform-memoization.js

@@ -8,7 +8,7 @@ exports.enforceTransformMemoization = (0, createRule_1.createRule)({
     meta: {
         type: 'problem',
         docs: {
-            description: 'Enforce memoization of adaptValue transformValue/transformOnChange so the adapted component receives stable handlers and avoids unnecessary re-renders.',
+            description: 'Enforce memoization of transformValue and transformOnChange in adaptValue',
             recommended: 'error',
         },
         schema: [],