@trackunit/eslint-plugin-trackunit 0.0.2

package/src/lib/rules/prefer-event-specific-callback-naming/strategies/type-based.js

@@ -0,0 +1,196 @@
+"use strict";
+/**
+ * Type-based detection strategy for prefer-event-specific-callback-naming rule.
+ *
+ * Uses TypeScript's type checker to detect when a callback with problematic naming
+ * is passed to a prop typed as a mouse event handler (MouseEventHandler, MouseEvent, etc.).
+ *
+ * This catches cases where custom components use non-standard prop names for click handlers:
+ * - <MobileButton onTap={onClose} /> where onTap is typed as MouseEventHandler
+ * - <PressableArea onPress={onCancel} /> where onPress accepts MouseEvent
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkTypeBased = exports.typeBasedMessages = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const utils_2 = require("../utils");
+exports.typeBasedMessages = {
+    preferOnClickNamingTyped: "Callback '{{current}}' passed to {{event}} should use '{{expectedPrefix}}*' naming (e.g., '{{suggested}}'). " +
+        "Reported because {{event}} is typed as a MouseEventHandler. Rename it at its definition.",
+    preferOnClickNamingTypedWrapped: "Callback '{{current}}' called in {{event}} should use '{{expectedPrefix}}*' naming (e.g., '{{suggested}}'). " +
+        "Reported because {{event}} is typed as a MouseEventHandler. Rename it at its definition.",
+    suggestRenameAllTyped: "Rename '{{current}}' to '{{suggested}}' (definition and all usages in this file)",
+    suggestRenameLocalTyped: "Rename to '{{suggested}}' (this reference only - definition is in another file)",
+};
+/**
+ * Extracts the expected naming prefix from a suggested name.
+ * This is used to show the correct expected pattern in error messages.
+ *
+ * @example
+ * getExpectedPrefix("onClickPrimary") // "onClick"
+ * getExpectedPrefix("onMouseDownClose") // "onMouseDown"
+ */
+const getExpectedPrefix = (suggestedName) => {
+    // Find where the capitalized suffix starts (after the event prefix)
+    // e.g., "onClickPrimary" -> find "Primary" -> prefix is "onClick"
+    const match = suggestedName.match(/^(on[A-Z][a-z]*)/);
+    return match?.[1] ?? suggestedName;
+};
+/**
+ * Checks if a type represents a mouse event handler.
+ * Looks for:
+ * - MouseEventHandler<T>
+ * - React.MouseEventHandler<T>
+ * - Function types with MouseEvent as first parameter
+ */
+const isMouseEventHandlerType = (type, checker) => {
+    const typeString = checker.typeToString(type);
+    // Quick check for common patterns in the type string
+    if (typeString.includes("MouseEventHandler") ||
+        typeString.includes("MouseEvent<") ||
+        typeString.includes("MouseEvent)")) {
+        return true;
+    }
+    // Check call signatures for MouseEvent parameter
+    const signatures = type.getCallSignatures();
+    for (const signature of signatures) {
+        const params = signature.getParameters();
+        if (params.length > 0) {
+            const firstParam = params[0];
+            if (firstParam) {
+                const paramType = checker.getTypeOfSymbol(firstParam);
+                const paramTypeString = checker.typeToString(paramType);
+                if (paramTypeString.includes("MouseEvent")) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+};
+/**
+ * Checks a JSX attribute for type-based mouse event handler naming issues.
+ *
+ * Only runs when "onClick" is in the events list (since this check only detects
+ * MouseEventHandler types, which are click events).
+ *
+ * Skips props already in the events list (those are handled by the name-based strategy).
+ *
+ * @param node - The JSX attribute node to check
+ * @param context - The ESLint rule context
+ * @param allowedNames - Callback names to exempt from this rule
+ * @param events - Configured event names (used to skip already-covered props)
+ */
+const checkTypeBased = (node, context, allowedNames, events) => {
+    // Only run if "onClick" is in the events list, since this check only detects
+    // MouseEventHandler types (which are click events)
+    if (!events.includes("onClick")) {
+        return;
+    }
+    // Extract prop name - must be a JSXIdentifier
+    if (node.name.type !== utils_1.AST_NODE_TYPES.JSXIdentifier) {
+        return;
+    }
+    const propName = node.name.name;
+    // Skip props already in the events list - those are handled by the name-based strategy
+    if (events.includes(propName)) {
+        return;
+    }
+    // Must have a value that's an expression container
+    if (!node.value || node.value.type !== utils_1.AST_NODE_TYPES.JSXExpressionContainer) {
+        return;
+    }
+    const { expression } = node.value;
+    if (expression.type === utils_1.AST_NODE_TYPES.JSXEmptyExpression) {
+        return;
+    }
+    // Extract callback identifier (without checking hardcoded onClick pattern)
+    const result = (0, utils_2.extractCallbackIdentifier)(expression);
+    if (!result) {
+        return;
+    }
+    // Check if this name is in the allowed list
+    if (allowedNames.includes(result.callbackName)) {
+        return;
+    }
+    // Skip if callback name already matches or starts with the prop name
+    // e.g., onMouseEnter={onMouseEnter} or onMouseEnter={onMouseEnterSomething}
+    if (result.callbackName === propName || result.callbackName.startsWith(propName)) {
+        return;
+    }
+    // Skip if callback doesn't start with "on" - we only care about on* callbacks
+    // that might be confused with lifecycle/event callbacks
+    if (!result.callbackName.startsWith("on")) {
+        return;
+    }
+    // Now check if the prop is typed as a mouse event handler
+    try {
+        const services = utils_1.ESLintUtils.getParserServices(context);
+        const checker = services.program.getTypeChecker();
+        // Get the TypeScript node for the expression (already validated above)
+        const tsExpressionNode = services.esTreeNodeToTSNodeMap.get(expression);
+        // Get the contextual type (what type is expected at this position)
+        // The ESTree to TS node map returns a generic node, but getContextualType
+        // expects an Expression. This assertion is necessary for TypeScript API interop.
+        // eslint-disable-next-line @trackunit/no-typescript-assertion
+        const contextualType = checker.getContextualType(tsExpressionNode);
+        if (!contextualType) {
+            return;
+        }
+        if (!isMouseEventHandlerType(contextualType, checker)) {
+            return;
+        }
+        // Calculate suggested name using the actual prop name (e.g., onMouseDown -> onMouseDownClose)
+        const suggestedName = (0, utils_2.getSuggestedNameForEvent)(result.callbackName, propName);
+        // Select the appropriate messageId based on whether the callback is wrapped
+        const messageId = result.isWrapped
+            ? "preferOnClickNamingTypedWrapped"
+            : "preferOnClickNamingTyped";
+        // Build suggestions based on whether the definition is in the same file
+        const suggestions = [];
+        const localInfo = (0, utils_2.findLocalDefinitionInfo)(result.identifierNode, context);
+        if (localInfo) {
+            // Definition is in this file - offer to rename all occurrences
+            suggestions.push({
+                messageId: "suggestRenameAllTyped",
+                data: {
+                    current: result.callbackName,
+                    suggested: suggestedName,
+                },
+                fix: fixer => {
+                    return localInfo.allNodesToRename.map(nodeToRename => fixer.replaceText(nodeToRename, suggestedName));
+                },
+            });
+        }
+        else {
+            // Definition is external - only offer to rename this reference
+            suggestions.push({
+                messageId: "suggestRenameLocalTyped",
+                data: {
+                    current: result.callbackName,
+                    suggested: suggestedName,
+                },
+                fix: fixer => {
+                    return fixer.replaceText(result.identifierNode, suggestedName);
+                },
+            });
+        }
+        context.report({
+            node: result.node,
+            messageId,
+            data: {
+                current: result.callbackName,
+                suggested: suggestedName,
+                event: propName,
+                expectedPrefix: getExpectedPrefix(suggestedName),
+            },
+            suggest: suggestions,
+        });
+    }
+    catch {
+        // Type checking failed - silently skip this check
+        // This can happen if TypeScript services are not available
+        return;
+    }
+};
+exports.checkTypeBased = checkTypeBased;
+//# sourceMappingURL=type-based.js.map

package/src/lib/rules/prefer-event-specific-callback-naming/strategies/type-based.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-based.js","sourceRoot":"","sources":["../../../../../../../../../libs/eslint/plugin-trackunit/src/lib/rules/prefer-event-specific-callback-naming/strategies/type-based.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Type-based detection strategy for prefer-event-specific-callback-naming rule.\n *\n * Uses TypeScript's type checker to detect when a callback with problematic naming\n * is passed to a prop typed as a mouse event handler (MouseEventHandler, MouseEvent, etc.).\n *\n * This catches cases where custom components use non-standard prop names for click handlers:\n * - <MobileButton onTap={onClose} /> where onTap is typed as MouseEventHandler\n * - <PressableArea onPress={onCancel} /> where onPress accepts MouseEvent\n */\n\nimport { AST_NODE_TYPES, ESLintUtils, TSESLint, TSESTree } from \"@typescript-eslint/utils\";\nimport * as ts from \"typescript\";\n\nimport { extractCallbackIdentifier, findLocalDefinitionInfo, getSuggestedNameForEvent } from \"../utils\";\n\nexport type TypeBasedMessageIds =\n  | \"preferOnClickNamingTyped\"\n  | \"preferOnClickNamingTypedWrapped\"\n  | \"suggestRenameAllTyped\"\n  | \"suggestRenameLocalTyped\";\n\nexport const typeBasedMessages: Record<TypeBasedMessageIds, string> = {\n  preferOnClickNamingTyped:\n    \"Callback '{{current}}' passed to {{event}} should use '{{expectedPrefix}}*' naming (e.g., '{{suggested}}'). \" +\n    \"Reported because {{event}} is typed as a MouseEventHandler. Rename it at its definition.\",\n  preferOnClickNamingTypedWrapped:\n    \"Callback '{{current}}' called in {{event}} should use '{{expectedPrefix}}*' naming (e.g., '{{suggested}}'). \" +\n    \"Reported because {{event}} is typed as a MouseEventHandler. Rename it at its definition.\",\n  suggestRenameAllTyped: \"Rename '{{current}}' to '{{suggested}}' (definition and all usages in this file)\",\n  suggestRenameLocalTyped: \"Rename to '{{suggested}}' (this reference only - definition is in another file)\",\n};\n\n/**\n * Extracts the expected naming prefix from a suggested name.\n * This is used to show the correct expected pattern in error messages.\n *\n * @example\n * getExpectedPrefix(\"onClickPrimary\") // \"onClick\"\n * getExpectedPrefix(\"onMouseDownClose\") // \"onMouseDown\"\n */\nconst getExpectedPrefix = (suggestedName: string): string => {\n  // Find where the capitalized suffix starts (after the event prefix)\n  // e.g., \"onClickPrimary\" -> find \"Primary\" -> prefix is \"onClick\"\n  const match = suggestedName.match(/^(on[A-Z][a-z]*)/);\n  return match?.[1] ?? suggestedName;\n};\n\ntype SuggestionDescriptor = {\n  messageId: TypeBasedMessageIds;\n  data: { current: string; suggested: string };\n  fix: (fixer: TSESLint.RuleFixer) => TSESLint.RuleFix | ReadonlyArray<TSESLint.RuleFix>;\n};\n\n/**\n * Checks if a type represents a mouse event handler.\n * Looks for:\n * - MouseEventHandler<T>\n * - React.MouseEventHandler<T>\n * - Function types with MouseEvent as first parameter\n */\nconst isMouseEventHandlerType = (type: ts.Type, checker: ts.TypeChecker): boolean => {\n  const typeString = checker.typeToString(type);\n\n  // Quick check for common patterns in the type string\n  if (\n    typeString.includes(\"MouseEventHandler\") ||\n    typeString.includes(\"MouseEvent<\") ||\n    typeString.includes(\"MouseEvent)\")\n  ) {\n    return true;\n  }\n\n  // Check call signatures for MouseEvent parameter\n  const signatures = type.getCallSignatures();\n  for (const signature of signatures) {\n    const params = signature.getParameters();\n    if (params.length > 0) {\n      const firstParam = params[0];\n      if (firstParam) {\n        const paramType = checker.getTypeOfSymbol(firstParam);\n        const paramTypeString = checker.typeToString(paramType);\n\n        if (paramTypeString.includes(\"MouseEvent\")) {\n          return true;\n        }\n      }\n    }\n  }\n\n  return false;\n};\n\n/**\n * Checks a JSX attribute for type-based mouse event handler naming issues.\n *\n * Only runs when \"onClick\" is in the events list (since this check only detects\n * MouseEventHandler types, which are click events).\n *\n * Skips props already in the events list (those are handled by the name-based strategy).\n *\n * @param node - The JSX attribute node to check\n * @param context - The ESLint rule context\n * @param allowedNames - Callback names to exempt from this rule\n * @param events - Configured event names (used to skip already-covered props)\n */\nexport const checkTypeBased = (\n  node: TSESTree.JSXAttribute,\n  context: TSESLint.RuleContext<TypeBasedMessageIds, ReadonlyArray<unknown>>,\n  allowedNames: ReadonlyArray<string>,\n  events: ReadonlyArray<string>\n): void => {\n  // Only run if \"onClick\" is in the events list, since this check only detects\n  // MouseEventHandler types (which are click events)\n  if (!events.includes(\"onClick\")) {\n    return;\n  }\n\n  // Extract prop name - must be a JSXIdentifier\n  if (node.name.type !== AST_NODE_TYPES.JSXIdentifier) {\n    return;\n  }\n\n  const propName = node.name.name;\n\n  // Skip props already in the events list - those are handled by the name-based strategy\n  if (events.includes(propName)) {\n    return;\n  }\n\n  // Must have a value that's an expression container\n  if (!node.value || node.value.type !== AST_NODE_TYPES.JSXExpressionContainer) {\n    return;\n  }\n\n  const { expression } = node.value;\n  if (expression.type === AST_NODE_TYPES.JSXEmptyExpression) {\n    return;\n  }\n\n  // Extract callback identifier (without checking hardcoded onClick pattern)\n  const result = extractCallbackIdentifier(expression);\n\n  if (!result) {\n    return;\n  }\n\n  // Check if this name is in the allowed list\n  if (allowedNames.includes(result.callbackName)) {\n    return;\n  }\n\n  // Skip if callback name already matches or starts with the prop name\n  // e.g., onMouseEnter={onMouseEnter} or onMouseEnter={onMouseEnterSomething}\n  if (result.callbackName === propName || result.callbackName.startsWith(propName)) {\n    return;\n  }\n\n  // Skip if callback doesn't start with \"on\" - we only care about on* callbacks\n  // that might be confused with lifecycle/event callbacks\n  if (!result.callbackName.startsWith(\"on\")) {\n    return;\n  }\n\n  // Now check if the prop is typed as a mouse event handler\n  try {\n    const services = ESLintUtils.getParserServices(context);\n    const checker = services.program.getTypeChecker();\n\n    // Get the TypeScript node for the expression (already validated above)\n    const tsExpressionNode = services.esTreeNodeToTSNodeMap.get(expression);\n\n    // Get the contextual type (what type is expected at this position)\n    // The ESTree to TS node map returns a generic node, but getContextualType\n    // expects an Expression. This assertion is necessary for TypeScript API interop.\n    // eslint-disable-next-line @trackunit/no-typescript-assertion\n    const contextualType = checker.getContextualType(tsExpressionNode as ts.Expression);\n\n    if (!contextualType) {\n      return;\n    }\n\n    if (!isMouseEventHandlerType(contextualType, checker)) {\n      return;\n    }\n\n    // Calculate suggested name using the actual prop name (e.g., onMouseDown -> onMouseDownClose)\n    const suggestedName = getSuggestedNameForEvent(result.callbackName, propName);\n\n    // Select the appropriate messageId based on whether the callback is wrapped\n    const messageId: TypeBasedMessageIds = result.isWrapped\n      ? \"preferOnClickNamingTypedWrapped\"\n      : \"preferOnClickNamingTyped\";\n\n    // Build suggestions based on whether the definition is in the same file\n    const suggestions: Array<SuggestionDescriptor> = [];\n    const localInfo = findLocalDefinitionInfo(result.identifierNode, context);\n\n    if (localInfo) {\n      // Definition is in this file - offer to rename all occurrences\n      suggestions.push({\n        messageId: \"suggestRenameAllTyped\",\n        data: {\n          current: result.callbackName,\n          suggested: suggestedName,\n        },\n        fix: fixer => {\n          return localInfo.allNodesToRename.map(nodeToRename => fixer.replaceText(nodeToRename, suggestedName));\n        },\n      });\n    } else {\n      // Definition is external - only offer to rename this reference\n      suggestions.push({\n        messageId: \"suggestRenameLocalTyped\",\n        data: {\n          current: result.callbackName,\n          suggested: suggestedName,\n        },\n        fix: fixer => {\n          return fixer.replaceText(result.identifierNode, suggestedName);\n        },\n      });\n    }\n\n    context.report({\n      node: result.node,\n      messageId,\n      data: {\n        current: result.callbackName,\n        suggested: suggestedName,\n        event: propName,\n        expectedPrefix: getExpectedPrefix(suggestedName),\n      },\n      suggest: suggestions,\n    });\n  } catch {\n    // Type checking failed - silently skip this check\n    // This can happen if TypeScript services are not available\n    return;\n  }\n};\n"]}

package/src/lib/rules/prefer-event-specific-callback-naming/utils.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Shared utilities for the prefer-event-specific-callback-naming rule.
+ * These functions handle the naming convention logic and callback extraction
+ * used by both string-based and type-based detection strategies.
+ */
+import { TSESLint, TSESTree } from "@typescript-eslint/utils";
+/**
+ * Result of extracting callback information from an expression.
+ * Does not include messageId - each strategy adds its own.
+ */
+export type CallbackExtractionResult = {
+    callbackName: string;
+    suggestedName: string;
+    node: TSESTree.Node;
+    /** The identifier node for the callback - used for fix ranges */
+    identifierNode: TSESTree.Identifier;
+    /** Whether the callback is wrapped in an arrow function */
+    isWrapped: boolean;
+} | null;
+/**
+ * Information about a locally defined variable, including its definition
+ * and all references within the same file.
+ */
+export type LocalDefinitionInfo = {
+    /** The identifier node where the variable is defined */
+    definitionNode: TSESTree.Identifier;
+    /** All nodes that need to be renamed (variable references + type property definitions) */
+    allNodesToRename: ReadonlyArray<TSESTree.Identifier>;
+};
+/**
+ * Finds the local definition and all references of a variable in the current file.
+ * Also finds TypeScript interface/type property definitions with the same name
+ * (for React component props that need to be renamed in both the type and usage).
+ * Returns null if the variable is not defined in the current file (e.g., imported).
+ *
+ * @param identifier - The identifier node to look up
+ * @param context - The ESLint rule context
+ * @returns LocalDefinitionInfo if defined locally, null if defined externally
+ */
+export declare const findLocalDefinitionInfo: (identifier: TSESTree.Identifier, context: TSESLint.RuleContext<string, ReadonlyArray<unknown>>) => LocalDefinitionInfo | null;
+/**
+ * Result of extracting a callback identifier from an expression.
+ * Unlike CallbackExtractionResult, this doesn't include suggested names
+ * since those depend on the specific event handler being used.
+ */
+export type CallbackIdentifierResult = {
+    callbackName: string;
+    node: TSESTree.Node;
+    /** The identifier node for the callback - used for fix ranges */
+    identifierNode: TSESTree.Identifier;
+    /** Whether the callback is wrapped in an arrow function */
+    isWrapped: boolean;
+} | null;
+/**
+ * Extracts the callback identifier from an expression without checking naming patterns.
+ * Used by strict prop events check which has its own naming criteria.
+ *
+ * @returns Callback identifier info, or null if not a simple identifier/single-call arrow
+ */
+export declare const extractCallbackIdentifier: (expression: TSESTree.Expression) => CallbackIdentifierResult;
+/**
+ * Generates the suggested name for a callback based on the event handler it's passed to.
+ *
+ * Uses a strategy-based approach to handle different naming patterns appropriately.
+ * See `name-suggestion-strategies.ts` for the individual strategies.
+ *
+ * @param currentName - The current callback name (e.g., "secondaryAction", "close")
+ * @param eventName - The event handler name (e.g., "onClick", "onSubmit", "primaryAction")
+ * @returns The suggested name (e.g., "onClickSecondaryAction", "onSubmitClose", "onClickPrimary")
+ * @example
+ * getSuggestedNameForEvent("close", "onClick") // "onClickClose"
+ * getSuggestedNameForEvent("onCancel", "onClick") // "onClickCancel"
+ * getSuggestedNameForEvent("onPrimary", "primaryAction") // "onClickPrimary"
+ * getSuggestedNameForEvent("onClose", "onClickClose") // "onClickClose"
+ */
+export declare const getSuggestedNameForEvent: (currentName: string, eventName: string) => string;

package/src/lib/rules/prefer-event-specific-callback-naming/utils.js

@@ -0,0 +1,245 @@
+"use strict";
+/**
+ * Shared utilities for the prefer-event-specific-callback-naming rule.
+ * These functions handle the naming convention logic and callback extraction
+ * used by both string-based and type-based detection strategies.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSuggestedNameForEvent = exports.extractCallbackIdentifier = exports.findLocalDefinitionInfo = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const name_suggestion_strategies_1 = require("./name-suggestion-strategies");
+/**
+ * Recursively finds all TSPropertySignature nodes in the AST with the given name.
+ * This finds interface/type property definitions that need to be renamed along with the variable.
+ */
+const findTypePropertyDefinitions = (ast, propertyName) => {
+    const results = [];
+    const visit = (node) => {
+        // Find interface/type property signatures with matching name
+        if (node.type === utils_1.AST_NODE_TYPES.TSPropertySignature &&
+            node.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+            node.key.name === propertyName) {
+            results.push(node.key);
+        }
+        // Recursively visit all child nodes
+        // Use Object.entries to iterate without needing type assertions
+        for (const [key, value] of Object.entries(node)) {
+            if (key === "parent")
+                continue; // Skip parent to avoid cycles
+            if (value !== null && typeof value === "object") {
+                if (Array.isArray(value)) {
+                    for (const item of value) {
+                        if (item !== null && typeof item === "object" && "type" in item) {
+                            visit(item);
+                        }
+                    }
+                }
+                else if ("type" in value) {
+                    visit(value);
+                }
+            }
+        }
+    };
+    visit(ast);
+    return results;
+};
+/**
+ * Finds the local definition and all references of a variable in the current file.
+ * Also finds TypeScript interface/type property definitions with the same name
+ * (for React component props that need to be renamed in both the type and usage).
+ * Returns null if the variable is not defined in the current file (e.g., imported).
+ *
+ * @param identifier - The identifier node to look up
+ * @param context - The ESLint rule context
+ * @returns LocalDefinitionInfo if defined locally, null if defined externally
+ */
+const findLocalDefinitionInfo = (identifier, context) => {
+    const scope = context.sourceCode.getScope(identifier);
+    const variable = scope.references.find(ref => ref.identifier === identifier)?.resolved;
+    if (!variable) {
+        return null;
+    }
+    // Check if the variable has definition nodes in this file
+    const definitions = variable.defs;
+    if (definitions.length === 0) {
+        // No definitions found - likely a global or imported variable
+        return null;
+    }
+    // Get the first definition (typically there's only one)
+    const definition = definitions[0];
+    if (!definition) {
+        return null;
+    }
+    // The definition's name node is where the variable is defined
+    // It could be an Identifier, ArrayPattern, or ObjectPattern
+    // We only handle simple Identifier definitions
+    const definitionName = definition.name;
+    if (definitionName.type !== utils_1.AST_NODE_TYPES.Identifier) {
+        return null;
+    }
+    // Collect all variable references (identifiers that refer to this variable)
+    const variableReferences = variable.references
+        .map(ref => ref.identifier)
+        .filter((node) => node.type === utils_1.AST_NODE_TYPES.Identifier);
+    // Also find TypeScript type property definitions with the same name
+    // This handles the case where a callback is destructured from props:
+    // interface Props { onCancel: () => void }  <-- need to rename this too
+    // const { onCancel } = props;               <-- the variable reference
+    const ast = context.sourceCode.ast;
+    const typePropertyDefinitions = findTypePropertyDefinitions(ast, identifier.name);
+    // Combine definition, variable references, and type property definitions
+    // Use a Set based on node range to deduplicate (needed because shorthand properties
+    // may share node ranges between definition and reference)
+    const seenRanges = new Set();
+    const allNodesToRename = [];
+    for (const node of [definitionName, ...variableReferences, ...typePropertyDefinitions]) {
+        const rangeKey = `${node.range[0]}-${node.range[1]}`;
+        if (!seenRanges.has(rangeKey)) {
+            seenRanges.add(rangeKey);
+            allNodesToRename.push(node);
+        }
+    }
+    return {
+        definitionNode: definitionName,
+        allNodesToRename,
+    };
+};
+exports.findLocalDefinitionInfo = findLocalDefinitionInfo;
+/**
+ * Checks if a callback name is problematic when used with click handlers.
+ * A name is problematic if it starts with "on" but not "onClick".
+ *
+ * @example
+ * isProblematicName("onClose") // true - should be onClickClose
+ * isProblematicName("onClickClose") // false - already correct
+ * isProblematicName("handleClose") // false - different convention
+ * isProblematicName("close") // false - doesn't start with "on"
+ */
+const isProblematicName = (name) => {
+    return name.startsWith("on") && !name.startsWith("onClick");
+};
+/**
+ * Converts a problematic callback name to the suggested onClick* format.
+ *
+ * @example
+ * getSuggestedName("onClose") // "onClickClose"
+ * getSuggestedName("onCancel") // "onClickCancel"
+ */
+const getSuggestedName = (name) => {
+    // Remove "on" prefix and add "onClick" prefix
+    return `onClick${name.slice(2)}`;
+};
+/**
+ * Extracts callback info from a direct identifier pattern: onClick={onClose}
+ */
+const extractFromDirectIdentifier = (expression) => {
+    if (expression.type !== utils_1.AST_NODE_TYPES.Identifier) {
+        return null;
+    }
+    const callbackName = expression.name;
+    if (!isProblematicName(callbackName)) {
+        return null;
+    }
+    return {
+        callbackName,
+        suggestedName: getSuggestedName(callbackName),
+        node: expression,
+        identifierNode: expression,
+        isWrapped: false,
+    };
+};
+/**
+ * Extracts callback info from a single-call arrow function: onClick={() => onClose()}
+ */
+const extractFromSingleCallArrow = (expression) => {
+    if (expression.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+        return null;
+    }
+    const { body } = expression;
+    // Only check if body is a single call expression (not a block statement)
+    if (body.type !== utils_1.AST_NODE_TYPES.CallExpression) {
+        return null;
+    }
+    // Only check if the callee is a simple identifier
+    if (body.callee.type !== utils_1.AST_NODE_TYPES.Identifier) {
+        return null;
+    }
+    const callbackName = body.callee.name;
+    if (!isProblematicName(callbackName)) {
+        return null;
+    }
+    return {
+        callbackName,
+        suggestedName: getSuggestedName(callbackName),
+        node: body.callee,
+        identifierNode: body.callee,
+        isWrapped: true,
+    };
+};
+/**
+ * Extracts callback information from an expression.
+ * Handles both direct identifiers (onClick={onClose}) and
+ * single-call arrow functions (onClick={() => onClose()}).
+ *
+ * @returns Callback extraction result without messageId, or null if no problematic callback found
+ */
+const extractCallbackInfo = (expression) => {
+    return extractFromDirectIdentifier(expression) ?? extractFromSingleCallArrow(expression);
+};
+/**
+ * Extracts the callback identifier from an expression without checking naming patterns.
+ * Used by strict prop events check which has its own naming criteria.
+ *
+ * @returns Callback identifier info, or null if not a simple identifier/single-call arrow
+ */
+const extractCallbackIdentifier = (expression) => {
+    // Direct identifier: onClick={onClose}
+    if (expression.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return {
+            callbackName: expression.name,
+            node: expression,
+            identifierNode: expression,
+            isWrapped: false,
+        };
+    }
+    // Single-call arrow function: onClick={() => onClose()}
+    if (expression.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+        const { body } = expression;
+        // Only check if body is a single call expression (not a block statement)
+        if (body.type !== utils_1.AST_NODE_TYPES.CallExpression) {
+            return null;
+        }
+        // Only check if the callee is a simple identifier
+        if (body.callee.type !== utils_1.AST_NODE_TYPES.Identifier) {
+            return null;
+        }
+        return {
+            callbackName: body.callee.name,
+            node: body.callee,
+            identifierNode: body.callee,
+            isWrapped: true,
+        };
+    }
+    return null;
+};
+exports.extractCallbackIdentifier = extractCallbackIdentifier;
+/**
+ * Generates the suggested name for a callback based on the event handler it's passed to.
+ *
+ * Uses a strategy-based approach to handle different naming patterns appropriately.
+ * See `name-suggestion-strategies.ts` for the individual strategies.
+ *
+ * @param currentName - The current callback name (e.g., "secondaryAction", "close")
+ * @param eventName - The event handler name (e.g., "onClick", "onSubmit", "primaryAction")
+ * @returns The suggested name (e.g., "onClickSecondaryAction", "onSubmitClose", "onClickPrimary")
+ * @example
+ * getSuggestedNameForEvent("close", "onClick") // "onClickClose"
+ * getSuggestedNameForEvent("onCancel", "onClick") // "onClickCancel"
+ * getSuggestedNameForEvent("onPrimary", "primaryAction") // "onClickPrimary"
+ * getSuggestedNameForEvent("onClose", "onClickClose") // "onClickClose"
+ */
+const getSuggestedNameForEvent = (currentName, eventName) => {
+    return (0, name_suggestion_strategies_1.getSuggestedName)({ callbackName: currentName, eventName });
+};
+exports.getSuggestedNameForEvent = getSuggestedNameForEvent;
+//# sourceMappingURL=utils.js.map

package/src/lib/rules/prefer-event-specific-callback-naming/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../../../../libs/eslint/plugin-trackunit/src/lib/rules/prefer-event-specific-callback-naming/utils.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH,oDAA8E;AAE9E,6EAA4F;AA2B5F;;;GAGG;AACH,MAAM,2BAA2B,GAAG,CAAC,GAAqB,EAAE,YAAoB,EAA8B,EAAE;IAC9G,MAAM,OAAO,GAA+B,EAAE,CAAC;IAE/C,MAAM,KAAK,GAAG,CAAC,IAAmB,EAAQ,EAAE;QAC1C,6DAA6D;QAC7D,IACE,IAAI,CAAC,IAAI,KAAK,sBAAc,CAAC,mBAAmB;YAChD,IAAI,CAAC,GAAG,CAAC,IAAI,KAAK,sBAAc,CAAC,UAAU;YAC3C,IAAI,CAAC,GAAG,CAAC,IAAI,KAAK,YAAY,EAC9B,CAAC;YACD,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACzB,CAAC;QAED,oCAAoC;QACpC,gEAAgE;QAChE,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;YAChD,IAAI,GAAG,KAAK,QAAQ;gBAAE,SAAS,CAAC,8BAA8B;YAE9D,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;gBAChD,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;oBACzB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;wBACzB,IAAI,IAAI,KAAK,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,MAAM,IAAI,IAAI,EAAE,CAAC;4BAChE,KAAK,CAAC,IAAI,CAAC,CAAC;wBACd,CAAC;oBACH,CAAC;gBACH,CAAC;qBAAM,IAAI,MAAM,IAAI,KAAK,EAAE,CAAC;oBAC3B,KAAK,CAAC,KAAK,CAAC,CAAC;gBACf,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC,CAAC;IAEF,KAAK,CAAC,GAAG,CAAC,CAAC;IACX,OAAO,OAAO,CAAC;AACjB,CAAC,CAAC;AAEF;;;;;;;;;GASG;AACI,MAAM,uBAAuB,GAAG,CACrC,UAA+B,EAC/B,OAA6D,EACjC,EAAE;IAC9B,MAAM,KAAK,GAAG,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;IACtD,MAAM,QAAQ,GAAG,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,UAAU,KAAK,UAAU,CAAC,EAAE,QAAQ,CAAC;IAEvF,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,OAAO,IAAI,CAAC;IACd,CAAC;IAED,0DAA0D;IAC1D,MAAM,WAAW,GAAG,QAAQ,CAAC,IAAI,CAAC;IAClC,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC7B,8DAA8D;QAC9D,OAAO,IAAI,CAAC;IACd,CAAC;IAED,wDAAwD;IACxD,MAAM,UAAU,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC;IAClC,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,8DAA8D;IAC9D,4DAA4D;IAC5D,+CAA+C;IAC/C,MAAM,cAAc,GAAG,UAAU,CAAC,IAAI,CAAC;IACvC,IAAI,cAAc,CAAC,IAAI,KAAK,sBAAc,CAAC,UAAU,EAAE,CAAC;QACtD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,4EAA4E;IAC5E,MAAM,kBAAkB,GAAG,QAAQ,CAAC,UAAU;SAC3C,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,UAAU,CAAC;SAC1B,MAAM,CAAC,CAAC,IAAI,EAA+B,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,sBAAc,CAAC,UAAU,CAAC,CAAC;IAE1F,oEAAoE;IACpE,qEAAqE;IACrE,wEAAwE;IACxE,uEAAuE;IACvE,MAAM,GAAG,GAAG,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC;IACnC,MAAM,uBAAuB,GAAG,2BAA2B,CAAC,GAAG,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC;IAElF,yEAAyE;IACzE,oFAAoF;IACpF,0DAA0D;IAC1D,MAAM,UAAU,GAAG,IAAI,GAAG,EAAU,CAAC;IACrC,MAAM,gBAAgB,GAA+B,EAAE,CAAC;IAExD,KAAK,MAAM,IAAI,IAAI,CAAC,cAAc,EAAE,GAAG,kBAAkB,EAAE,GAAG,uBAAuB,CAAC,EAAE,CAAC;QACvF,MAAM,QAAQ,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;QACrD,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC9B,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;YACzB,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC9B,CAAC;IACH,CAAC;IAED,OAAO;QACL,cAAc,EAAE,cAAc;QAC9B,gBAAgB;KACjB,CAAC;AACJ,CAAC,CAAC;AA9DW,QAAA,uBAAuB,2BA8DlC;AAEF;;;;;;;;;GASG;AACH,MAAM,iBAAiB,GAAG,CAAC,IAAY,EAAW,EAAE;IAClD,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;AAC9D,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,gBAAgB,GAAG,CAAC,IAAY,EAAU,EAAE;IAChD,8CAA8C;IAC9C,OAAO,UAAU,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;AACnC,CAAC,CAAC;AAEF;;GAEG;AACH,MAAM,2BAA2B,GAAG,CAAC,UAA+B,EAA4B,EAAE;IAChG,IAAI,UAAU,CAAC,IAAI,KAAK,sBAAc,CAAC,UAAU,EAAE,CAAC;QAClD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,YAAY,GAAG,UAAU,CAAC,IAAI,CAAC;IACrC,IAAI,CAAC,iBAAiB,CAAC,YAAY,CAAC,EAAE,CAAC;QACrC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO;QACL,YAAY;QACZ,aAAa,EAAE,gBAAgB,CAAC,YAAY,CAAC;QAC7C,IAAI,EAAE,UAAU;QAChB,cAAc,EAAE,UAAU;QAC1B,SAAS,EAAE,KAAK;KACjB,CAAC;AACJ,CAAC,CAAC;AAEF;;GAEG;AACH,MAAM,0BAA0B,GAAG,CAAC,UAA+B,EAA4B,EAAE;IAC/F,IAAI,UAAU,CAAC,IAAI,KAAK,sBAAc,CAAC,uBAAuB,EAAE,CAAC;QAC/D,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,EAAE,IAAI,EAAE,GAAG,UAAU,CAAC;IAE5B,yEAAyE;IACzE,IAAI,IAAI,CAAC,IAAI,KAAK,sBAAc,CAAC,cAAc,EAAE,CAAC;QAChD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,kDAAkD;IAClD,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,sBAAc,CAAC,UAAU,EAAE,CAAC;QACnD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,YAAY,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;IACtC,IAAI,CAAC,iBAAiB,CAAC,YAAY,CAAC,EAAE,CAAC;QACrC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO;QACL,YAAY;QACZ,aAAa,EAAE,gBAAgB,CAAC,YAAY,CAAC;QAC7C,IAAI,EAAE,IAAI,CAAC,MAAM;QACjB,cAAc,EAAE,IAAI,CAAC,MAAM;QAC3B,SAAS,EAAE,IAAI;KAChB,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,mBAAmB,GAAG,CAAC,UAA+B,EAA4B,EAAE;IACxF,OAAO,2BAA2B,CAAC,UAAU,CAAC,IAAI,0BAA0B,CAAC,UAAU,CAAC,CAAC;AAC3F,CAAC,CAAC;AAgBF;;;;;GAKG;AACI,MAAM,yBAAyB,GAAG,CAAC,UAA+B,EAA4B,EAAE;IACrG,uCAAuC;IACvC,IAAI,UAAU,CAAC,IAAI,KAAK,sBAAc,CAAC,UAAU,EAAE,CAAC;QAClD,OAAO;YACL,YAAY,EAAE,UAAU,CAAC,IAAI;YAC7B,IAAI,EAAE,UAAU;YAChB,cAAc,EAAE,UAAU;YAC1B,SAAS,EAAE,KAAK;SACjB,CAAC;IACJ,CAAC;IAED,wDAAwD;IACxD,IAAI,UAAU,CAAC,IAAI,KAAK,sBAAc,CAAC,uBAAuB,EAAE,CAAC;QAC/D,MAAM,EAAE,IAAI,EAAE,GAAG,UAAU,CAAC;QAE5B,yEAAyE;QACzE,IAAI,IAAI,CAAC,IAAI,KAAK,sBAAc,CAAC,cAAc,EAAE,CAAC;YAChD,OAAO,IAAI,CAAC;QACd,CAAC;QAED,kDAAkD;QAClD,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,sBAAc,CAAC,UAAU,EAAE,CAAC;YACnD,OAAO,IAAI,CAAC;QACd,CAAC;QAED,OAAO;YACL,YAAY,EAAE,IAAI,CAAC,MAAM,CAAC,IAAI;YAC9B,IAAI,EAAE,IAAI,CAAC,MAAM;YACjB,cAAc,EAAE,IAAI,CAAC,MAAM;YAC3B,SAAS,EAAE,IAAI;SAChB,CAAC;IACJ,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC,CAAC;AAlCW,QAAA,yBAAyB,6BAkCpC;AAEF;;;;;;;;;;;;;;GAcG;AACI,MAAM,wBAAwB,GAAG,CAAC,WAAmB,EAAE,SAAiB,EAAU,EAAE;IACzF,OAAO,IAAA,6CAAwB,EAAC,EAAE,YAAY,EAAE,WAAW,EAAE,SAAS,EAAE,CAAC,CAAC;AAC5E,CAAC,CAAC;AAFW,QAAA,wBAAwB,4BAEnC","sourcesContent":["/**\n * Shared utilities for the prefer-event-specific-callback-naming rule.\n * These functions handle the naming convention logic and callback extraction\n * used by both string-based and type-based detection strategies.\n */\n\nimport { AST_NODE_TYPES, TSESLint, TSESTree } from \"@typescript-eslint/utils\";\n\nimport { getSuggestedName as getStrategySuggestedName } from \"./name-suggestion-strategies\";\n\n/**\n * Result of extracting callback information from an expression.\n * Does not include messageId - each strategy adds its own.\n */\nexport type CallbackExtractionResult = {\n  callbackName: string;\n  suggestedName: string;\n  node: TSESTree.Node;\n  /** The identifier node for the callback - used for fix ranges */\n  identifierNode: TSESTree.Identifier;\n  /** Whether the callback is wrapped in an arrow function */\n  isWrapped: boolean;\n} | null;\n\n/**\n * Information about a locally defined variable, including its definition\n * and all references within the same file.\n */\nexport type LocalDefinitionInfo = {\n  /** The identifier node where the variable is defined */\n  definitionNode: TSESTree.Identifier;\n  /** All nodes that need to be renamed (variable references + type property definitions) */\n  allNodesToRename: ReadonlyArray<TSESTree.Identifier>;\n};\n\n/**\n * Recursively finds all TSPropertySignature nodes in the AST with the given name.\n * This finds interface/type property definitions that need to be renamed along with the variable.\n */\nconst findTypePropertyDefinitions = (ast: TSESTree.Program, propertyName: string): Array<TSESTree.Identifier> => {\n  const results: Array<TSESTree.Identifier> = [];\n\n  const visit = (node: TSESTree.Node): void => {\n    // Find interface/type property signatures with matching name\n    if (\n      node.type === AST_NODE_TYPES.TSPropertySignature &&\n      node.key.type === AST_NODE_TYPES.Identifier &&\n      node.key.name === propertyName\n    ) {\n      results.push(node.key);\n    }\n\n    // Recursively visit all child nodes\n    // Use Object.entries to iterate without needing type assertions\n    for (const [key, value] of Object.entries(node)) {\n      if (key === \"parent\") continue; // Skip parent to avoid cycles\n\n      if (value !== null && typeof value === \"object\") {\n        if (Array.isArray(value)) {\n          for (const item of value) {\n            if (item !== null && typeof item === \"object\" && \"type\" in item) {\n              visit(item);\n            }\n          }\n        } else if (\"type\" in value) {\n          visit(value);\n        }\n      }\n    }\n  };\n\n  visit(ast);\n  return results;\n};\n\n/**\n * Finds the local definition and all references of a variable in the current file.\n * Also finds TypeScript interface/type property definitions with the same name\n * (for React component props that need to be renamed in both the type and usage).\n * Returns null if the variable is not defined in the current file (e.g., imported).\n *\n * @param identifier - The identifier node to look up\n * @param context - The ESLint rule context\n * @returns LocalDefinitionInfo if defined locally, null if defined externally\n */\nexport const findLocalDefinitionInfo = (\n  identifier: TSESTree.Identifier,\n  context: TSESLint.RuleContext<string, ReadonlyArray<unknown>>\n): LocalDefinitionInfo | null => {\n  const scope = context.sourceCode.getScope(identifier);\n  const variable = scope.references.find(ref => ref.identifier === identifier)?.resolved;\n\n  if (!variable) {\n    return null;\n  }\n\n  // Check if the variable has definition nodes in this file\n  const definitions = variable.defs;\n  if (definitions.length === 0) {\n    // No definitions found - likely a global or imported variable\n    return null;\n  }\n\n  // Get the first definition (typically there's only one)\n  const definition = definitions[0];\n  if (!definition) {\n    return null;\n  }\n\n  // The definition's name node is where the variable is defined\n  // It could be an Identifier, ArrayPattern, or ObjectPattern\n  // We only handle simple Identifier definitions\n  const definitionName = definition.name;\n  if (definitionName.type !== AST_NODE_TYPES.Identifier) {\n    return null;\n  }\n\n  // Collect all variable references (identifiers that refer to this variable)\n  const variableReferences = variable.references\n    .map(ref => ref.identifier)\n    .filter((node): node is TSESTree.Identifier => node.type === AST_NODE_TYPES.Identifier);\n\n  // Also find TypeScript type property definitions with the same name\n  // This handles the case where a callback is destructured from props:\n  // interface Props { onCancel: () => void }  <-- need to rename this too\n  // const { onCancel } = props;               <-- the variable reference\n  const ast = context.sourceCode.ast;\n  const typePropertyDefinitions = findTypePropertyDefinitions(ast, identifier.name);\n\n  // Combine definition, variable references, and type property definitions\n  // Use a Set based on node range to deduplicate (needed because shorthand properties\n  // may share node ranges between definition and reference)\n  const seenRanges = new Set<string>();\n  const allNodesToRename: Array<TSESTree.Identifier> = [];\n\n  for (const node of [definitionName, ...variableReferences, ...typePropertyDefinitions]) {\n    const rangeKey = `${node.range[0]}-${node.range[1]}`;\n    if (!seenRanges.has(rangeKey)) {\n      seenRanges.add(rangeKey);\n      allNodesToRename.push(node);\n    }\n  }\n\n  return {\n    definitionNode: definitionName,\n    allNodesToRename,\n  };\n};\n\n/**\n * Checks if a callback name is problematic when used with click handlers.\n * A name is problematic if it starts with \"on\" but not \"onClick\".\n *\n * @example\n * isProblematicName(\"onClose\") // true - should be onClickClose\n * isProblematicName(\"onClickClose\") // false - already correct\n * isProblematicName(\"handleClose\") // false - different convention\n * isProblematicName(\"close\") // false - doesn't start with \"on\"\n */\nconst isProblematicName = (name: string): boolean => {\n  return name.startsWith(\"on\") && !name.startsWith(\"onClick\");\n};\n\n/**\n * Converts a problematic callback name to the suggested onClick* format.\n *\n * @example\n * getSuggestedName(\"onClose\") // \"onClickClose\"\n * getSuggestedName(\"onCancel\") // \"onClickCancel\"\n */\nconst getSuggestedName = (name: string): string => {\n  // Remove \"on\" prefix and add \"onClick\" prefix\n  return `onClick${name.slice(2)}`;\n};\n\n/**\n * Extracts callback info from a direct identifier pattern: onClick={onClose}\n */\nconst extractFromDirectIdentifier = (expression: TSESTree.Expression): CallbackExtractionResult => {\n  if (expression.type !== AST_NODE_TYPES.Identifier) {\n    return null;\n  }\n\n  const callbackName = expression.name;\n  if (!isProblematicName(callbackName)) {\n    return null;\n  }\n\n  return {\n    callbackName,\n    suggestedName: getSuggestedName(callbackName),\n    node: expression,\n    identifierNode: expression,\n    isWrapped: false,\n  };\n};\n\n/**\n * Extracts callback info from a single-call arrow function: onClick={() => onClose()}\n */\nconst extractFromSingleCallArrow = (expression: TSESTree.Expression): CallbackExtractionResult => {\n  if (expression.type !== AST_NODE_TYPES.ArrowFunctionExpression) {\n    return null;\n  }\n\n  const { body } = expression;\n\n  // Only check if body is a single call expression (not a block statement)\n  if (body.type !== AST_NODE_TYPES.CallExpression) {\n    return null;\n  }\n\n  // Only check if the callee is a simple identifier\n  if (body.callee.type !== AST_NODE_TYPES.Identifier) {\n    return null;\n  }\n\n  const callbackName = body.callee.name;\n  if (!isProblematicName(callbackName)) {\n    return null;\n  }\n\n  return {\n    callbackName,\n    suggestedName: getSuggestedName(callbackName),\n    node: body.callee,\n    identifierNode: body.callee,\n    isWrapped: true,\n  };\n};\n\n/**\n * Extracts callback information from an expression.\n * Handles both direct identifiers (onClick={onClose}) and\n * single-call arrow functions (onClick={() => onClose()}).\n *\n * @returns Callback extraction result without messageId, or null if no problematic callback found\n */\nconst extractCallbackInfo = (expression: TSESTree.Expression): CallbackExtractionResult => {\n  return extractFromDirectIdentifier(expression) ?? extractFromSingleCallArrow(expression);\n};\n\n/**\n * Result of extracting a callback identifier from an expression.\n * Unlike CallbackExtractionResult, this doesn't include suggested names\n * since those depend on the specific event handler being used.\n */\nexport type CallbackIdentifierResult = {\n  callbackName: string;\n  node: TSESTree.Node;\n  /** The identifier node for the callback - used for fix ranges */\n  identifierNode: TSESTree.Identifier;\n  /** Whether the callback is wrapped in an arrow function */\n  isWrapped: boolean;\n} | null;\n\n/**\n * Extracts the callback identifier from an expression without checking naming patterns.\n * Used by strict prop events check which has its own naming criteria.\n *\n * @returns Callback identifier info, or null if not a simple identifier/single-call arrow\n */\nexport const extractCallbackIdentifier = (expression: TSESTree.Expression): CallbackIdentifierResult => {\n  // Direct identifier: onClick={onClose}\n  if (expression.type === AST_NODE_TYPES.Identifier) {\n    return {\n      callbackName: expression.name,\n      node: expression,\n      identifierNode: expression,\n      isWrapped: false,\n    };\n  }\n\n  // Single-call arrow function: onClick={() => onClose()}\n  if (expression.type === AST_NODE_TYPES.ArrowFunctionExpression) {\n    const { body } = expression;\n\n    // Only check if body is a single call expression (not a block statement)\n    if (body.type !== AST_NODE_TYPES.CallExpression) {\n      return null;\n    }\n\n    // Only check if the callee is a simple identifier\n    if (body.callee.type !== AST_NODE_TYPES.Identifier) {\n      return null;\n    }\n\n    return {\n      callbackName: body.callee.name,\n      node: body.callee,\n      identifierNode: body.callee,\n      isWrapped: true,\n    };\n  }\n\n  return null;\n};\n\n/**\n * Generates the suggested name for a callback based on the event handler it's passed to.\n *\n * Uses a strategy-based approach to handle different naming patterns appropriately.\n * See `name-suggestion-strategies.ts` for the individual strategies.\n *\n * @param currentName - The current callback name (e.g., \"secondaryAction\", \"close\")\n * @param eventName - The event handler name (e.g., \"onClick\", \"onSubmit\", \"primaryAction\")\n * @returns The suggested name (e.g., \"onClickSecondaryAction\", \"onSubmitClose\", \"onClickPrimary\")\n * @example\n * getSuggestedNameForEvent(\"close\", \"onClick\") // \"onClickClose\"\n * getSuggestedNameForEvent(\"onCancel\", \"onClick\") // \"onClickCancel\"\n * getSuggestedNameForEvent(\"onPrimary\", \"primaryAction\") // \"onClickPrimary\"\n * getSuggestedNameForEvent(\"onClose\", \"onClickClose\") // \"onClickClose\"\n */\nexport const getSuggestedNameForEvent = (currentName: string, eventName: string): string => {\n  return getStrategySuggestedName({ callbackName: currentName, eventName });\n};\n"]}

package/src/lib/rules/prefer-field-components/prefer-field-components.d.ts

@@ -0,0 +1,4 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+export declare const preferFieldComponents: ESLintUtils.RuleModule<"preferFieldComponent", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};