@trackunit/eslint-plugin-trackunit 0.0.2

package/src/lib/rules/prefer-event-specific-callback-naming/name-suggestion-strategies.js

@@ -0,0 +1,225 @@
+"use strict";
+/**
+ * Strategy-based name suggestion system for the prefer-event-specific-callback-naming rule.
+ *
+ * This module provides a structured, extensible approach to generating suggested names
+ * for callback functions based on different naming patterns. Each strategy handles a
+ * specific type of problematic name and knows how to transform it correctly.
+ *
+ * Strategies are evaluated in order - the first matching strategy wins.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testableStrategies = exports.getSuggestedName = void 0;
+// =============================================================================
+// Helper Functions
+// =============================================================================
+/**
+ * Capitalizes the first letter of a string.
+ *
+ * @example capitalize("primary") // "Primary"
+ */
+const capitalize = (str) => {
+    if (str.length === 0)
+        return str;
+    return str.charAt(0).toUpperCase() + str.slice(1);
+};
+// =============================================================================
+// Strategy Implementations
+// =============================================================================
+/**
+ * Strategy: Handle `*Action` suffix event names.
+ *
+ * When the event prop ends with "Action" (e.g., "primaryAction", "secondaryAction"),
+ * the prop itself is poorly named for a click handler. We extract the prefix and
+ * construct a proper onClick* name.
+ *
+ * @example
+ * - eventName: "primaryAction", callbackName: "onPrimary" → "onClickPrimary"
+ * - eventName: "secondaryAction", callbackName: "action" → "onClickSecondary"
+ * - eventName: "primaryAction", callbackName: "foo" → "onClickPrimary"
+ */
+const actionSuffixEventStrategy = {
+    name: "actionSuffixEventStrategy",
+    matches: (ctx) => {
+        // Matches when the event name ends with "Action" (case-sensitive)
+        return ctx.eventName.endsWith("Action");
+    },
+    suggest: (ctx) => {
+        // Extract the prefix before "Action" (e.g., "primary" from "primaryAction")
+        const prefix = ctx.eventName.slice(0, -"Action".length);
+        // If the callback starts with "on", extract its semantic part
+        // e.g., "onPrimary" → "Primary", "onConfirm" → "Confirm"
+        if (ctx.callbackName.startsWith("on") && ctx.callbackName.length > 2) {
+            const callbackSuffix = ctx.callbackName.slice(2);
+            // If the callback suffix matches the event prefix (case-insensitive),
+            // use the callback's casing for consistency
+            // e.g., eventName: "primaryAction", callbackName: "onPrimary" → "onClickPrimary"
+            if (callbackSuffix.toLowerCase() === prefix.toLowerCase()) {
+                return `onClick${callbackSuffix}`;
+            }
+            // Otherwise, combine both for clarity
+            // e.g., eventName: "primaryAction", callbackName: "onConfirm" → "onClickPrimaryConfirm"
+            return `onClick${capitalize(prefix)}${callbackSuffix}`;
+        }
+        // For non-"on" prefixed callbacks, just use the event prefix
+        // e.g., eventName: "primaryAction", callbackName: "foo" → "onClickPrimary"
+        return `onClick${capitalize(prefix)}`;
+    },
+};
+/**
+ * Strategy: Handle `*Handler` suffix event names.
+ *
+ * When the event prop ends with "Handler" (e.g., "clickHandler", "submitHandler"),
+ * the prop itself is poorly named. We extract the prefix and construct a proper onClick* name.
+ *
+ * @example
+ * - eventName: "clickHandler", callbackName: "onClose" → "onClickClose"
+ * - eventName: "submitHandler", callbackName: "foo" → "onClickSubmit"
+ */
+const handlerSuffixEventStrategy = {
+    name: "handlerSuffixEventStrategy",
+    matches: (ctx) => {
+        // Matches when the event name ends with "Handler" (case-sensitive)
+        return ctx.eventName.endsWith("Handler");
+    },
+    suggest: (ctx) => {
+        // Extract the prefix before "Handler" (e.g., "click" from "clickHandler")
+        const prefix = ctx.eventName.slice(0, -"Handler".length);
+        // If the callback starts with "on", extract its semantic part
+        if (ctx.callbackName.startsWith("on") && ctx.callbackName.length > 2) {
+            const callbackSuffix = ctx.callbackName.slice(2);
+            return `onClick${capitalize(prefix)}${callbackSuffix}`;
+        }
+        // For non-"on" prefixed callbacks
+        return `onClick${capitalize(prefix)}`;
+    },
+};
+/**
+ * Strategy: Handle `on*` callback → `onClick` event.
+ *
+ * When a callback starts with "on" (but not "onClick") and is passed to an onClick handler,
+ * we replace the "on" prefix with "onClick".
+ *
+ * @example
+ * - eventName: "onClick", callbackName: "onClose" → "onClickClose"
+ * - eventName: "onClick", callbackName: "onCancel" → "onClickCancel"
+ */
+const onPrefixCallbackToClickEventStrategy = {
+    name: "onPrefixCallbackToClickEventStrategy",
+    matches: (ctx) => {
+        return ctx.eventName === "onClick" && ctx.callbackName.startsWith("on") && !ctx.callbackName.startsWith("onClick");
+    },
+    suggest: (ctx) => {
+        // Replace "on" with "onClick"
+        // e.g., "onClose" → "onClickClose"
+        const suffix = ctx.callbackName.slice(2);
+        return `onClick${suffix}`;
+    },
+};
+/**
+ * Strategy: Handle `on*` callback → generic `on*` event (not onClick).
+ *
+ * When a callback starts with "on" and is passed to a different on* event handler
+ * (like onMouseDown, onSubmit, etc.), we replace the "on" prefix with the event name.
+ *
+ * @example
+ * - eventName: "onMouseDown", callbackName: "onClose" → "onMouseDownClose"
+ * - eventName: "onSubmit", callbackName: "onConfirm" → "onSubmitConfirm"
+ */
+const onPrefixCallbackToGenericEventStrategy = {
+    name: "onPrefixCallbackToGenericEventStrategy",
+    matches: (ctx) => {
+        return (ctx.eventName.startsWith("on") &&
+            ctx.eventName !== "onClick" &&
+            ctx.callbackName.startsWith("on") &&
+            !ctx.callbackName.startsWith(ctx.eventName));
+    },
+    suggest: (ctx) => {
+        const callbackSuffix = ctx.callbackName.slice(2);
+        // Avoid duplication: if event name already ends with the suffix, just use the event name
+        // e.g., eventName: "onClickClose", callbackName: "onClose" → "onClickClose"
+        if (ctx.eventName.toLowerCase().endsWith(callbackSuffix.toLowerCase())) {
+            return ctx.eventName;
+        }
+        return `${ctx.eventName}${callbackSuffix}`;
+    },
+};
+/**
+ * Strategy: Default fallback.
+ *
+ * For any callback that doesn't match other patterns, capitalize and prepend
+ * the event name.
+ *
+ * @example
+ * - eventName: "onClick", callbackName: "myCallback" → "onClickMyCallback"
+ * - eventName: "onClick", callbackName: "close" → "onClickClose"
+ */
+const defaultCapitalizeStrategy = {
+    name: "defaultCapitalizeStrategy",
+    matches: () => {
+        // Always matches as a fallback
+        return true;
+    },
+    suggest: (ctx) => {
+        const capitalizedName = capitalize(ctx.callbackName);
+        return `${ctx.eventName}${capitalizedName}`;
+    },
+};
+// =============================================================================
+// Strategy Registry
+// =============================================================================
+/**
+ * Ordered list of strategies. First matching strategy wins.
+ *
+ * Order matters:
+ * 1. Specific patterns (Action suffix, Handler suffix) first
+ * 2. General patterns (on* prefix) next
+ * 3. Default fallback last
+ */
+const strategies = [
+    actionSuffixEventStrategy,
+    handlerSuffixEventStrategy,
+    onPrefixCallbackToClickEventStrategy,
+    onPrefixCallbackToGenericEventStrategy,
+    defaultCapitalizeStrategy,
+];
+// =============================================================================
+// Public API
+// =============================================================================
+/**
+ * Generates a suggested name for a callback based on the event it's passed to.
+ *
+ * Uses a strategy pattern to handle different naming conventions appropriately.
+ * The first matching strategy determines the suggested name.
+ *
+ * @param ctx - The naming context with callback and event names
+ * @returns The suggested name for the callback
+ * @example
+ * getSuggestedName({ callbackName: "onClose", eventName: "onClick" })
+ * // Returns: "onClickClose"
+ *
+ * getSuggestedName({ callbackName: "onPrimary", eventName: "primaryAction" })
+ * // Returns: "onClickPrimary"
+ */
+const getSuggestedName = (ctx) => {
+    for (const strategy of strategies) {
+        if (strategy.matches(ctx)) {
+            return strategy.suggest(ctx);
+        }
+    }
+    // Should never reach here since defaultCapitalizeStrategy always matches,
+    // but TypeScript doesn't know that
+    return defaultCapitalizeStrategy.suggest(ctx);
+};
+exports.getSuggestedName = getSuggestedName;
+/**
+ * Exported for testing purposes - allows testing individual strategies.
+ */
+exports.testableStrategies = {
+    actionSuffixEventStrategy,
+    handlerSuffixEventStrategy,
+    onPrefixCallbackToClickEventStrategy,
+    onPrefixCallbackToGenericEventStrategy,
+    defaultCapitalizeStrategy,
+};
+//# sourceMappingURL=name-suggestion-strategies.js.map

package/src/lib/rules/prefer-event-specific-callback-naming/name-suggestion-strategies.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"name-suggestion-strategies.js","sourceRoot":"","sources":["../../../../../../../../libs/eslint/plugin-trackunit/src/lib/rules/prefer-event-specific-callback-naming/name-suggestion-strategies.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Strategy-based name suggestion system for the prefer-event-specific-callback-naming rule.\n *\n * This module provides a structured, extensible approach to generating suggested names\n * for callback functions based on different naming patterns. Each strategy handles a\n * specific type of problematic name and knows how to transform it correctly.\n *\n * Strategies are evaluated in order - the first matching strategy wins.\n */\n\n/**\n * Context passed to name suggestion strategies.\n */\nexport type NameSuggestionContext = {\n  /** The current callback name (e.g., \"onPrimary\", \"onClose\", \"handleClick\") */\n  callbackName: string;\n  /** The event handler prop name (e.g., \"onClick\", \"primaryAction\", \"onSubmit\") */\n  eventName: string;\n};\n\n/**\n * A strategy for suggesting renamed callback names.\n * Each strategy handles a specific pattern of problematic naming.\n */\nexport type NameSuggestionStrategy = {\n  /** Human-readable name for debugging and logging */\n  name: string;\n  /** Returns true if this strategy should handle the given context */\n  matches: (ctx: NameSuggestionContext) => boolean;\n  /** Returns the suggested name for the callback */\n  suggest: (ctx: NameSuggestionContext) => string;\n};\n\n// =============================================================================\n// Helper Functions\n// =============================================================================\n\n/**\n * Capitalizes the first letter of a string.\n *\n * @example capitalize(\"primary\") // \"Primary\"\n */\nconst capitalize = (str: string): string => {\n  if (str.length === 0) return str;\n  return str.charAt(0).toUpperCase() + str.slice(1);\n};\n\n// =============================================================================\n// Strategy Implementations\n// =============================================================================\n\n/**\n * Strategy: Handle `*Action` suffix event names.\n *\n * When the event prop ends with \"Action\" (e.g., \"primaryAction\", \"secondaryAction\"),\n * the prop itself is poorly named for a click handler. We extract the prefix and\n * construct a proper onClick* name.\n *\n * @example\n * - eventName: \"primaryAction\", callbackName: \"onPrimary\" → \"onClickPrimary\"\n * - eventName: \"secondaryAction\", callbackName: \"action\" → \"onClickSecondary\"\n * - eventName: \"primaryAction\", callbackName: \"foo\" → \"onClickPrimary\"\n */\nconst actionSuffixEventStrategy: NameSuggestionStrategy = {\n  name: \"actionSuffixEventStrategy\",\n\n  matches: (ctx: NameSuggestionContext): boolean => {\n    // Matches when the event name ends with \"Action\" (case-sensitive)\n    return ctx.eventName.endsWith(\"Action\");\n  },\n\n  suggest: (ctx: NameSuggestionContext): string => {\n    // Extract the prefix before \"Action\" (e.g., \"primary\" from \"primaryAction\")\n    const prefix = ctx.eventName.slice(0, -\"Action\".length);\n\n    // If the callback starts with \"on\", extract its semantic part\n    // e.g., \"onPrimary\" → \"Primary\", \"onConfirm\" → \"Confirm\"\n    if (ctx.callbackName.startsWith(\"on\") && ctx.callbackName.length > 2) {\n      const callbackSuffix = ctx.callbackName.slice(2);\n\n      // If the callback suffix matches the event prefix (case-insensitive),\n      // use the callback's casing for consistency\n      // e.g., eventName: \"primaryAction\", callbackName: \"onPrimary\" → \"onClickPrimary\"\n      if (callbackSuffix.toLowerCase() === prefix.toLowerCase()) {\n        return `onClick${callbackSuffix}`;\n      }\n\n      // Otherwise, combine both for clarity\n      // e.g., eventName: \"primaryAction\", callbackName: \"onConfirm\" → \"onClickPrimaryConfirm\"\n      return `onClick${capitalize(prefix)}${callbackSuffix}`;\n    }\n\n    // For non-\"on\" prefixed callbacks, just use the event prefix\n    // e.g., eventName: \"primaryAction\", callbackName: \"foo\" → \"onClickPrimary\"\n    return `onClick${capitalize(prefix)}`;\n  },\n};\n\n/**\n * Strategy: Handle `*Handler` suffix event names.\n *\n * When the event prop ends with \"Handler\" (e.g., \"clickHandler\", \"submitHandler\"),\n * the prop itself is poorly named. We extract the prefix and construct a proper onClick* name.\n *\n * @example\n * - eventName: \"clickHandler\", callbackName: \"onClose\" → \"onClickClose\"\n * - eventName: \"submitHandler\", callbackName: \"foo\" → \"onClickSubmit\"\n */\nconst handlerSuffixEventStrategy: NameSuggestionStrategy = {\n  name: \"handlerSuffixEventStrategy\",\n\n  matches: (ctx: NameSuggestionContext): boolean => {\n    // Matches when the event name ends with \"Handler\" (case-sensitive)\n    return ctx.eventName.endsWith(\"Handler\");\n  },\n\n  suggest: (ctx: NameSuggestionContext): string => {\n    // Extract the prefix before \"Handler\" (e.g., \"click\" from \"clickHandler\")\n    const prefix = ctx.eventName.slice(0, -\"Handler\".length);\n\n    // If the callback starts with \"on\", extract its semantic part\n    if (ctx.callbackName.startsWith(\"on\") && ctx.callbackName.length > 2) {\n      const callbackSuffix = ctx.callbackName.slice(2);\n      return `onClick${capitalize(prefix)}${callbackSuffix}`;\n    }\n\n    // For non-\"on\" prefixed callbacks\n    return `onClick${capitalize(prefix)}`;\n  },\n};\n\n/**\n * Strategy: Handle `on*` callback → `onClick` event.\n *\n * When a callback starts with \"on\" (but not \"onClick\") and is passed to an onClick handler,\n * we replace the \"on\" prefix with \"onClick\".\n *\n * @example\n * - eventName: \"onClick\", callbackName: \"onClose\" → \"onClickClose\"\n * - eventName: \"onClick\", callbackName: \"onCancel\" → \"onClickCancel\"\n */\nconst onPrefixCallbackToClickEventStrategy: NameSuggestionStrategy = {\n  name: \"onPrefixCallbackToClickEventStrategy\",\n\n  matches: (ctx: NameSuggestionContext): boolean => {\n    return ctx.eventName === \"onClick\" && ctx.callbackName.startsWith(\"on\") && !ctx.callbackName.startsWith(\"onClick\");\n  },\n\n  suggest: (ctx: NameSuggestionContext): string => {\n    // Replace \"on\" with \"onClick\"\n    // e.g., \"onClose\" → \"onClickClose\"\n    const suffix = ctx.callbackName.slice(2);\n    return `onClick${suffix}`;\n  },\n};\n\n/**\n * Strategy: Handle `on*` callback → generic `on*` event (not onClick).\n *\n * When a callback starts with \"on\" and is passed to a different on* event handler\n * (like onMouseDown, onSubmit, etc.), we replace the \"on\" prefix with the event name.\n *\n * @example\n * - eventName: \"onMouseDown\", callbackName: \"onClose\" → \"onMouseDownClose\"\n * - eventName: \"onSubmit\", callbackName: \"onConfirm\" → \"onSubmitConfirm\"\n */\nconst onPrefixCallbackToGenericEventStrategy: NameSuggestionStrategy = {\n  name: \"onPrefixCallbackToGenericEventStrategy\",\n\n  matches: (ctx: NameSuggestionContext): boolean => {\n    return (\n      ctx.eventName.startsWith(\"on\") &&\n      ctx.eventName !== \"onClick\" &&\n      ctx.callbackName.startsWith(\"on\") &&\n      !ctx.callbackName.startsWith(ctx.eventName)\n    );\n  },\n\n  suggest: (ctx: NameSuggestionContext): string => {\n    const callbackSuffix = ctx.callbackName.slice(2);\n\n    // Avoid duplication: if event name already ends with the suffix, just use the event name\n    // e.g., eventName: \"onClickClose\", callbackName: \"onClose\" → \"onClickClose\"\n    if (ctx.eventName.toLowerCase().endsWith(callbackSuffix.toLowerCase())) {\n      return ctx.eventName;\n    }\n\n    return `${ctx.eventName}${callbackSuffix}`;\n  },\n};\n\n/**\n * Strategy: Default fallback.\n *\n * For any callback that doesn't match other patterns, capitalize and prepend\n * the event name.\n *\n * @example\n * - eventName: \"onClick\", callbackName: \"myCallback\" → \"onClickMyCallback\"\n * - eventName: \"onClick\", callbackName: \"close\" → \"onClickClose\"\n */\nconst defaultCapitalizeStrategy: NameSuggestionStrategy = {\n  name: \"defaultCapitalizeStrategy\",\n\n  matches: (): boolean => {\n    // Always matches as a fallback\n    return true;\n  },\n\n  suggest: (ctx: NameSuggestionContext): string => {\n    const capitalizedName = capitalize(ctx.callbackName);\n    return `${ctx.eventName}${capitalizedName}`;\n  },\n};\n\n// =============================================================================\n// Strategy Registry\n// =============================================================================\n\n/**\n * Ordered list of strategies. First matching strategy wins.\n *\n * Order matters:\n * 1. Specific patterns (Action suffix, Handler suffix) first\n * 2. General patterns (on* prefix) next\n * 3. Default fallback last\n */\nconst strategies: ReadonlyArray<NameSuggestionStrategy> = [\n  actionSuffixEventStrategy,\n  handlerSuffixEventStrategy,\n  onPrefixCallbackToClickEventStrategy,\n  onPrefixCallbackToGenericEventStrategy,\n  defaultCapitalizeStrategy,\n];\n\n// =============================================================================\n// Public API\n// =============================================================================\n\n/**\n * Generates a suggested name for a callback based on the event it's passed to.\n *\n * Uses a strategy pattern to handle different naming conventions appropriately.\n * The first matching strategy determines the suggested name.\n *\n * @param ctx - The naming context with callback and event names\n * @returns The suggested name for the callback\n * @example\n * getSuggestedName({ callbackName: \"onClose\", eventName: \"onClick\" })\n * // Returns: \"onClickClose\"\n *\n * getSuggestedName({ callbackName: \"onPrimary\", eventName: \"primaryAction\" })\n * // Returns: \"onClickPrimary\"\n */\nexport const getSuggestedName = (ctx: NameSuggestionContext): string => {\n  for (const strategy of strategies) {\n    if (strategy.matches(ctx)) {\n      return strategy.suggest(ctx);\n    }\n  }\n\n  // Should never reach here since defaultCapitalizeStrategy always matches,\n  // but TypeScript doesn't know that\n  return defaultCapitalizeStrategy.suggest(ctx);\n};\n\n/**\n * Exported for testing purposes - allows testing individual strategies.\n */\nexport const testableStrategies = {\n  actionSuffixEventStrategy,\n  handlerSuffixEventStrategy,\n  onPrefixCallbackToClickEventStrategy,\n  onPrefixCallbackToGenericEventStrategy,\n  defaultCapitalizeStrategy,\n};\n"]}

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

@@ -0,0 +1,49 @@
+/**
+ * ESLint rule: prefer-event-specific-callback-naming
+ *
+ * Enforces that callbacks passed to event handler attributes use matching
+ * event-specific naming (e.g., onClick* for onClick, onSubmit* for onSubmit).
+ *
+ * This prevents confusing names like `onClose` (sounds like "when close happens")
+ * when the callback is actually triggered by a click event.
+ *
+ * Uses two detection strategies:
+ * 1. Name-based: Checks configured event attributes for mismatched callback names
+ * 2. Type-based: Detects any prop typed as MouseEventHandler with problematic naming
+ *    (only active when "onClick" is in the events list)
+ *
+ * Configuration via the `events` option controls which event handler attributes
+ * are checked by both strategies.
+ */
+import { ESLintUtils } from "@typescript-eslint/utils";
+import { NameBasedMessageIds } from "./strategies/string-based";
+import { TypeBasedMessageIds } from "./strategies/type-based";
+type Options = [
+    {
+        /**
+         * Callback names to exempt from this rule.
+         *
+         * @example ["onToggle", "onTrigger"]
+         */
+        allowedNames?: ReadonlyArray<string>;
+        /**
+         * Event handler attributes to check for matching callback naming.
+         *
+         * For each event in this list, callbacks passed to that attribute must use
+         * matching naming (e.g., `onClick*` for `onClick`, `onSubmit*` for `onSubmit`).
+         *
+         * - `on*` callbacks that don't match the event prefix are always flagged
+         * - Other callbacks (`handle*`, `close`, etc.) are only flagged when they come from props
+         * - When "onClick" is included, type-based MouseEventHandler detection is also enabled
+         *
+         * @default ["onClick"]
+         * @example ["onClick", "onSubmit", "onDoubleClick"]
+         */
+        events?: ReadonlyArray<string>;
+    }
+];
+type MessageIds = NameBasedMessageIds | TypeBasedMessageIds;
+export declare const preferEventSpecificCallbackNaming: ESLintUtils.RuleModule<MessageIds, Options, unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export {};

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

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * ESLint rule: prefer-event-specific-callback-naming
+ *
+ * Enforces that callbacks passed to event handler attributes use matching
+ * event-specific naming (e.g., onClick* for onClick, onSubmit* for onSubmit).
+ *
+ * This prevents confusing names like `onClose` (sounds like "when close happens")
+ * when the callback is actually triggered by a click event.
+ *
+ * Uses two detection strategies:
+ * 1. Name-based: Checks configured event attributes for mismatched callback names
+ * 2. Type-based: Detects any prop typed as MouseEventHandler with problematic naming
+ *    (only active when "onClick" is in the events list)
+ *
+ * Configuration via the `events` option controls which event handler attributes
+ * are checked by both strategies.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferEventSpecificCallbackNaming = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const string_based_1 = require("./strategies/string-based");
+const type_based_1 = require("./strategies/type-based");
+const createRule = utils_1.ESLintUtils.RuleCreator(name => `https://github.com/trackunit/manager/blob/main/libs/eslint/plugin-trackunit/src/lib/rules/${name}/${name}.ts`);
+exports.preferEventSpecificCallbackNaming = createRule({
+    name: "prefer-event-specific-callback-naming",
+    meta: {
+        type: "suggestion",
+        hasSuggestions: true,
+        docs: {
+            description: "Enforce using event-specific naming for callbacks passed to event handlers. " +
+                "Names like onClose are confusing because they sound like lifecycle events rather than click handlers.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    allowedNames: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Callback names to exempt from this rule",
+                    },
+                    events: {
+                        type: "array",
+                        items: { type: "string", pattern: "^on[A-Z]" },
+                        description: "Event handler attributes to check (e.g., ['onClick', 'onSubmit']). " +
+                            "Callbacks passed to these handlers must use matching on[Event]* naming.",
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            ...string_based_1.nameBasedMessages,
+            ...type_based_1.typeBasedMessages,
+        },
+    },
+    defaultOptions: [
+        {
+            allowedNames: [],
+            events: ["onClick"],
+        },
+    ],
+    create(context, [options]) {
+        const allowedNames = options.allowedNames ?? [];
+        const events = options.events ?? ["onClick"];
+        return {
+            JSXAttribute(node) {
+                (0, string_based_1.checkNameBased)(node, context, allowedNames, events);
+                (0, type_based_1.checkTypeBased)(node, context, allowedNames, events);
+            },
+        };
+    },
+});
+//# sourceMappingURL=prefer-event-specific-callback-naming.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-event-specific-callback-naming.js","sourceRoot":"","sources":["../../../../../../../../libs/eslint/plugin-trackunit/src/lib/rules/prefer-event-specific-callback-naming/prefer-event-specific-callback-naming.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;GAgBG;;;AAEH,oDAAiE;AAEjE,4DAAmG;AACnG,wDAAiG;AAEjG,MAAM,UAAU,GAAG,mBAAW,CAAC,WAAW,CACxC,IAAI,CAAC,EAAE,CAAC,6FAA6F,IAAI,IAAI,IAAI,KAAK,CACvH,CAAC;AA8BW,QAAA,iCAAiC,GAAG,UAAU,CAAsB;IAC/E,IAAI,EAAE,uCAAuC;IAC7C,IAAI,EAAE;QACJ,IAAI,EAAE,YAAY;QAClB,cAAc,EAAE,IAAI;QACpB,IAAI,EAAE;YACJ,WAAW,EACT,8EAA8E;gBAC9E,uGAAuG;SAC1G;QACD,MAAM,EAAE;YACN;gBACE,IAAI,EAAE,QAAQ;gBACd,UAAU,EAAE;oBACV,YAAY,EAAE;wBACZ,IAAI,EAAE,OAAO;wBACb,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;wBACzB,WAAW,EAAE,yCAAyC;qBACvD;oBACD,MAAM,EAAE;wBACN,IAAI,EAAE,OAAO;wBACb,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,EAAE;wBAC9C,WAAW,EACT,qEAAqE;4BACrE,yEAAyE;qBAC5E;iBACF;gBACD,oBAAoB,EAAE,KAAK;aAC5B;SACF;QACD,QAAQ,EAAE;YACR,GAAG,gCAAiB;YACpB,GAAG,8BAAiB;SACrB;KACF;IACD,cAAc,EAAE;QACd;YACE,YAAY,EAAE,EAAE;YAChB,MAAM,EAAE,CAAC,SAAS,CAAC;SACpB;KACF;IACD,MAAM,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC;QACvB,MAAM,YAAY,GAAG,OAAO,CAAC,YAAY,IAAI,EAAE,CAAC;QAChD,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,CAAC,SAAS,CAAC,CAAC;QAE7C,OAAO;YACL,YAAY,CAAC,IAA2B;gBACtC,IAAA,6BAAc,EAAC,IAAI,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,CAAC,CAAC;gBACpD,IAAA,2BAAc,EAAC,IAAI,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,CAAC,CAAC;YACtD,CAAC;SACF,CAAC;IACJ,CAAC;CACF,CAAC,CAAC","sourcesContent":["/**\n * ESLint rule: prefer-event-specific-callback-naming\n *\n * Enforces that callbacks passed to event handler attributes use matching\n * event-specific naming (e.g., onClick* for onClick, onSubmit* for onSubmit).\n *\n * This prevents confusing names like `onClose` (sounds like \"when close happens\")\n * when the callback is actually triggered by a click event.\n *\n * Uses two detection strategies:\n * 1. Name-based: Checks configured event attributes for mismatched callback names\n * 2. Type-based: Detects any prop typed as MouseEventHandler with problematic naming\n *    (only active when \"onClick\" is in the events list)\n *\n * Configuration via the `events` option controls which event handler attributes\n * are checked by both strategies.\n */\n\nimport { ESLintUtils, TSESTree } from \"@typescript-eslint/utils\";\n\nimport { checkNameBased, NameBasedMessageIds, nameBasedMessages } from \"./strategies/string-based\";\nimport { checkTypeBased, TypeBasedMessageIds, typeBasedMessages } from \"./strategies/type-based\";\n\nconst createRule = ESLintUtils.RuleCreator(\n  name => `https://github.com/trackunit/manager/blob/main/libs/eslint/plugin-trackunit/src/lib/rules/${name}/${name}.ts`\n);\n\ntype Options = [\n  {\n    /**\n     * Callback names to exempt from this rule.\n     *\n     * @example [\"onToggle\", \"onTrigger\"]\n     */\n    allowedNames?: ReadonlyArray<string>;\n\n    /**\n     * Event handler attributes to check for matching callback naming.\n     *\n     * For each event in this list, callbacks passed to that attribute must use\n     * matching naming (e.g., `onClick*` for `onClick`, `onSubmit*` for `onSubmit`).\n     *\n     * - `on*` callbacks that don't match the event prefix are always flagged\n     * - Other callbacks (`handle*`, `close`, etc.) are only flagged when they come from props\n     * - When \"onClick\" is included, type-based MouseEventHandler detection is also enabled\n     *\n     * @default [\"onClick\"]\n     * @example [\"onClick\", \"onSubmit\", \"onDoubleClick\"]\n     */\n    events?: ReadonlyArray<string>;\n  },\n];\n\ntype MessageIds = NameBasedMessageIds | TypeBasedMessageIds;\n\nexport const preferEventSpecificCallbackNaming = createRule<Options, MessageIds>({\n  name: \"prefer-event-specific-callback-naming\",\n  meta: {\n    type: \"suggestion\",\n    hasSuggestions: true,\n    docs: {\n      description:\n        \"Enforce using event-specific naming for callbacks passed to event handlers. \" +\n        \"Names like onClose are confusing because they sound like lifecycle events rather than click handlers.\",\n    },\n    schema: [\n      {\n        type: \"object\",\n        properties: {\n          allowedNames: {\n            type: \"array\",\n            items: { type: \"string\" },\n            description: \"Callback names to exempt from this rule\",\n          },\n          events: {\n            type: \"array\",\n            items: { type: \"string\", pattern: \"^on[A-Z]\" },\n            description:\n              \"Event handler attributes to check (e.g., ['onClick', 'onSubmit']). \" +\n              \"Callbacks passed to these handlers must use matching on[Event]* naming.\",\n          },\n        },\n        additionalProperties: false,\n      },\n    ],\n    messages: {\n      ...nameBasedMessages,\n      ...typeBasedMessages,\n    },\n  },\n  defaultOptions: [\n    {\n      allowedNames: [],\n      events: [\"onClick\"],\n    },\n  ],\n  create(context, [options]) {\n    const allowedNames = options.allowedNames ?? [];\n    const events = options.events ?? [\"onClick\"];\n\n    return {\n      JSXAttribute(node: TSESTree.JSXAttribute) {\n        checkNameBased(node, context, allowedNames, events);\n        checkTypeBased(node, context, allowedNames, events);\n      },\n    };\n  },\n});\n"]}

package/src/lib/rules/prefer-event-specific-callback-naming/strategies/string-based.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Name-based detection strategy for prefer-event-specific-callback-naming rule.
+ *
+ * Checks JSX attributes whose names appear in the configured `events` list
+ * and flags callbacks that don't use matching event prefix naming.
+ *
+ * Two levels of strictness:
+ * - Callbacks starting with `on*` that don't match the event prefix are always flagged
+ *   (e.g., onClick={onClose} - regardless of source)
+ * - Other callbacks (handle*, close, etc.) are only flagged when they come from props
+ *   (not internal functions or hook results)
+ */
+import { TSESLint, TSESTree } from "@typescript-eslint/utils";
+export type NameBasedMessageIds = "nameBasedEventNaming" | "nameBasedEventNamingWrapped" | "suggestRenameAllNameBased" | "suggestRenameLocalNameBased";
+export declare const nameBasedMessages: Record<NameBasedMessageIds, string>;
+/**
+ * Unified name-based check for event handler callback naming.
+ *
+ * Checks whether a callback passed to a configured event attribute uses the correct
+ * naming convention. The check applies two levels of strictness:
+ *
+ * 1. `on*` callbacks that don't match the event prefix are always flagged
+ *    (e.g., `onClick={onClose}` - should be `onClickClose`)
+ * 2. Other callbacks (`handle*`, `close`, etc.) are only flagged when they come from
+ *    component props (not internal functions, hook results, or render prop callbacks)
+ *
+ * @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 - Event handler attribute names to check (e.g., ["onClick", "onSubmit"])
+ */
+export declare const checkNameBased: (node: TSESTree.JSXAttribute, context: TSESLint.RuleContext<NameBasedMessageIds, ReadonlyArray<unknown>>, allowedNames: ReadonlyArray<string>, events: ReadonlyArray<string>) => void;

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

@@ -0,0 +1,143 @@
+"use strict";
+/**
+ * Name-based detection strategy for prefer-event-specific-callback-naming rule.
+ *
+ * Checks JSX attributes whose names appear in the configured `events` list
+ * and flags callbacks that don't use matching event prefix naming.
+ *
+ * Two levels of strictness:
+ * - Callbacks starting with `on*` that don't match the event prefix are always flagged
+ *   (e.g., onClick={onClose} - regardless of source)
+ * - Other callbacks (handle*, close, etc.) are only flagged when they come from props
+ *   (not internal functions or hook results)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkNameBased = exports.nameBasedMessages = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const ast_utils_1 = require("../../../utils/ast-utils");
+const utils_2 = require("../utils");
+exports.nameBasedMessages = {
+    nameBasedEventNaming: "Callback '{{current}}' passed to {{event}} should use '{{expectedPrefix}}*' naming (e.g., '{{suggested}}'). " +
+        "Reported because {{event}} is an explicitly monitored event handler name (see rule 'events' option). Rename it at its definition.",
+    nameBasedEventNamingWrapped: "Callback '{{current}}' called in {{event}} should use '{{expectedPrefix}}*' naming (e.g., '{{suggested}}'). " +
+        "Reported because {{event}} is an explicitly monitored event handler name (see rule 'events' option). Rename it at its definition.",
+    suggestRenameAllNameBased: "Rename '{{current}}' to '{{suggested}}' (definition and all usages in this file)",
+    suggestRenameLocalNameBased: "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) => {
+    const match = suggestedName.match(/^(on[A-Z][a-z]*)/);
+    return match?.[1] ?? suggestedName;
+};
+/**
+ * Unified name-based check for event handler callback naming.
+ *
+ * Checks whether a callback passed to a configured event attribute uses the correct
+ * naming convention. The check applies two levels of strictness:
+ *
+ * 1. `on*` callbacks that don't match the event prefix are always flagged
+ *    (e.g., `onClick={onClose}` - should be `onClickClose`)
+ * 2. Other callbacks (`handle*`, `close`, etc.) are only flagged when they come from
+ *    component props (not internal functions, hook results, or render prop callbacks)
+ *
+ * @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 - Event handler attribute names to check (e.g., ["onClick", "onSubmit"])
+ */
+const checkNameBased = (node, context, allowedNames, events) => {
+    // Must be a JSX identifier attribute
+    if (node.name.type !== utils_1.AST_NODE_TYPES.JSXIdentifier) {
+        return;
+    }
+    const eventName = node.name.name;
+    // Only check attributes in the events list
+    if (!events.includes(eventName)) {
+        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 specific naming patterns)
+    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;
+    }
+    // Check if the name already matches the event pattern (e.g., onClick* for onClick)
+    if (result.callbackName.startsWith(eventName)) {
+        return;
+    }
+    // Determine if this is an on* callback that doesn't match the event prefix
+    const isOnPrefixMismatch = result.callbackName.startsWith("on") && !result.callbackName.startsWith(eventName);
+    if (!isOnPrefixMismatch) {
+        // For non-on* callbacks (handle*, close, etc.), only flag if they come from props
+        // but NOT from render prop callbacks (e.g., {close => <MenuItem onClick={close} />})
+        if (!(0, ast_utils_1.isIdentifierFromParameter)(result.identifierNode, context)) {
+            return;
+        }
+        if ((0, ast_utils_1.isIdentifierFromRenderPropCallback)(result.identifierNode, context)) {
+            return;
+        }
+    }
+    const suggestedName = (0, utils_2.getSuggestedNameForEvent)(result.callbackName, eventName);
+    // Select the appropriate messageId based on whether the callback is wrapped
+    const messageId = result.isWrapped ? "nameBasedEventNamingWrapped" : "nameBasedEventNaming";
+    // 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: "suggestRenameAllNameBased",
+            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: "suggestRenameLocalNameBased",
+            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: eventName,
+            expectedPrefix: getExpectedPrefix(suggestedName),
+        },
+        suggest: suggestions,
+    });
+};
+exports.checkNameBased = checkNameBased;
+//# sourceMappingURL=string-based.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"string-based.js","sourceRoot":"","sources":["../../../../../../../../../libs/eslint/plugin-trackunit/src/lib/rules/prefer-event-specific-callback-naming/strategies/string-based.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Name-based detection strategy for prefer-event-specific-callback-naming rule.\n *\n * Checks JSX attributes whose names appear in the configured `events` list\n * and flags callbacks that don't use matching event prefix naming.\n *\n * Two levels of strictness:\n * - Callbacks starting with `on*` that don't match the event prefix are always flagged\n *   (e.g., onClick={onClose} - regardless of source)\n * - Other callbacks (handle*, close, etc.) are only flagged when they come from props\n *   (not internal functions or hook results)\n */\n\nimport { AST_NODE_TYPES, TSESLint, TSESTree } from \"@typescript-eslint/utils\";\n\nimport { isIdentifierFromParameter, isIdentifierFromRenderPropCallback } from \"../../../utils/ast-utils\";\nimport { extractCallbackIdentifier, findLocalDefinitionInfo, getSuggestedNameForEvent } from \"../utils\";\n\nexport type NameBasedMessageIds =\n  | \"nameBasedEventNaming\"\n  | \"nameBasedEventNamingWrapped\"\n  | \"suggestRenameAllNameBased\"\n  | \"suggestRenameLocalNameBased\";\n\nexport const nameBasedMessages: Record<NameBasedMessageIds, string> = {\n  nameBasedEventNaming:\n    \"Callback '{{current}}' passed to {{event}} should use '{{expectedPrefix}}*' naming (e.g., '{{suggested}}'). \" +\n    \"Reported because {{event}} is an explicitly monitored event handler name (see rule 'events' option). Rename it at its definition.\",\n  nameBasedEventNamingWrapped:\n    \"Callback '{{current}}' called in {{event}} should use '{{expectedPrefix}}*' naming (e.g., '{{suggested}}'). \" +\n    \"Reported because {{event}} is an explicitly monitored event handler name (see rule 'events' option). Rename it at its definition.\",\n  suggestRenameAllNameBased: \"Rename '{{current}}' to '{{suggested}}' (definition and all usages in this file)\",\n  suggestRenameLocalNameBased: \"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  const match = suggestedName.match(/^(on[A-Z][a-z]*)/);\n  return match?.[1] ?? suggestedName;\n};\n\ntype SuggestionDescriptor = {\n  messageId: NameBasedMessageIds;\n  data: { current: string; suggested: string };\n  fix: (fixer: TSESLint.RuleFixer) => TSESLint.RuleFix | ReadonlyArray<TSESLint.RuleFix>;\n};\n\n/**\n * Unified name-based check for event handler callback naming.\n *\n * Checks whether a callback passed to a configured event attribute uses the correct\n * naming convention. The check applies two levels of strictness:\n *\n * 1. `on*` callbacks that don't match the event prefix are always flagged\n *    (e.g., `onClick={onClose}` - should be `onClickClose`)\n * 2. Other callbacks (`handle*`, `close`, etc.) are only flagged when they come from\n *    component props (not internal functions, hook results, or render prop callbacks)\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 - Event handler attribute names to check (e.g., [\"onClick\", \"onSubmit\"])\n */\nexport const checkNameBased = (\n  node: TSESTree.JSXAttribute,\n  context: TSESLint.RuleContext<NameBasedMessageIds, ReadonlyArray<unknown>>,\n  allowedNames: ReadonlyArray<string>,\n  events: ReadonlyArray<string>\n): void => {\n  // Must be a JSX identifier attribute\n  if (node.name.type !== AST_NODE_TYPES.JSXIdentifier) {\n    return;\n  }\n\n  const eventName = node.name.name;\n\n  // Only check attributes in the events list\n  if (!events.includes(eventName)) {\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 specific naming patterns)\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  // Check if the name already matches the event pattern (e.g., onClick* for onClick)\n  if (result.callbackName.startsWith(eventName)) {\n    return;\n  }\n\n  // Determine if this is an on* callback that doesn't match the event prefix\n  const isOnPrefixMismatch = result.callbackName.startsWith(\"on\") && !result.callbackName.startsWith(eventName);\n\n  if (!isOnPrefixMismatch) {\n    // For non-on* callbacks (handle*, close, etc.), only flag if they come from props\n    // but NOT from render prop callbacks (e.g., {close => <MenuItem onClick={close} />})\n    if (!isIdentifierFromParameter(result.identifierNode, context)) {\n      return;\n    }\n    if (isIdentifierFromRenderPropCallback(result.identifierNode, context)) {\n      return;\n    }\n  }\n\n  const suggestedName = getSuggestedNameForEvent(result.callbackName, eventName);\n\n  // Select the appropriate messageId based on whether the callback is wrapped\n  const messageId: NameBasedMessageIds = result.isWrapped ? \"nameBasedEventNamingWrapped\" : \"nameBasedEventNaming\";\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: \"suggestRenameAllNameBased\",\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: \"suggestRenameLocalNameBased\",\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: eventName,\n      expectedPrefix: getExpectedPrefix(suggestedName),\n    },\n    suggest: suggestions,\n  });\n};\n"]}

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

@@ -0,0 +1,27 @@
+/**
+ * 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
+ */
+import { TSESLint, TSESTree } from "@typescript-eslint/utils";
+export type TypeBasedMessageIds = "preferOnClickNamingTyped" | "preferOnClickNamingTypedWrapped" | "suggestRenameAllTyped" | "suggestRenameLocalTyped";
+export declare const typeBasedMessages: Record<TypeBasedMessageIds, string>;
+/**
+ * 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)
+ */
+export declare const checkTypeBased: (node: TSESTree.JSXAttribute, context: TSESLint.RuleContext<TypeBasedMessageIds, ReadonlyArray<unknown>>, allowedNames: ReadonlyArray<string>, events: ReadonlyArray<string>) => void;