@hypersolid-dev/eslint-config 3.0.0 → 5.0.0

package/dist/plugins/rules/boolean-guard.js

@@ -0,0 +1,143 @@
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+import ts, { TypeFlags } from "typescript";
+import createRule from "../utils/create-rule.js";
+import { isSameAsBangBang, undefinedComparison } from "../utils/types.js";
+/** React draws these; every other falsy value renders as nothing. */
+const RENDERS_WHEN_FALSY = TypeFlags.NumberLike | TypeFlags.StringLike | TypeFlags.BigIntLike;
+/** `any` and `unknown` could be anything, so they are treated as leaking. */
+const UNKNOWABLE = TypeFlags.Any | TypeFlags.Unknown;
+const WHITESPACE_PATTERN = /\s+/gu;
+/**
+ * An intersection carries its own flags, never its parts', so a branded
+ * primitive (`string & { brand }`) is walked like a union: leaking if any part
+ * leaks. A literal is exactly its value, so `"a" | "b"` and `1 | 2` never leak.
+ */
+const canLeak = (type) => {
+    if (type.isUnion() || type.isIntersection())
+        return type.types.some(canLeak);
+    if (type.isStringLiteral())
+        return type.value === "";
+    if (type.isNumberLiteral())
+        return type.value === 0;
+    if (type.flags & TypeFlags.BigIntLiteral) {
+        return type.value.base10Value === "0";
+    }
+    return Boolean(type.flags & (RENDERS_WHEN_FALSY | UNKNOWABLE));
+};
+const isRenderable = (node) => node.type === AST_NODE_TYPES.JSXElement || node.type === AST_NODE_TYPES.JSXFragment;
+/** React skips all three, so each means "draw nothing" in the alternate slot. */
+const isNothing = (node) => (node.type === AST_NODE_TYPES.Literal && (node.value === null || node.value === false)) ||
+    (node.type === AST_NODE_TYPES.Identifier && node.name === "undefined");
+/**
+ * Whether this expression's value ends up drawn as a child, directly or through
+ * array literals, the right side of `&&` and the branches of a ternary.
+ */
+const isInRenderPosition = (node) => {
+    let current = node;
+    let { parent } = current;
+    while (parent) {
+        if (parent.type === AST_NODE_TYPES.JSXExpressionContainer) {
+            return parent.parent.type === AST_NODE_TYPES.JSXElement || parent.parent.type === AST_NODE_TYPES.JSXFragment;
+        }
+        const isPassThrough = parent.type === AST_NODE_TYPES.ArrayExpression ||
+            (parent.type === AST_NODE_TYPES.LogicalExpression && parent.right === current) ||
+            (parent.type === AST_NODE_TYPES.ConditionalExpression && (parent.consequent === current || parent.alternate === current));
+        if (!isPassThrough)
+            return false;
+        current = parent;
+        parent = parent.parent;
+    }
+    return false;
+};
+/** The declarator a conditional is the whole value of, when it binds a plain name. */
+const heldBy = (node) => node.parent?.type === AST_NODE_TYPES.VariableDeclarator && node.parent.init === node && node.parent.id.type === AST_NODE_TYPES.Identifier
+    ? node.parent
+    : undefined;
+const booleanGuard = createRule({
+    name: "boolean-guard",
+    meta: {
+        defaultOptions: [],
+        type: "problem",
+        docs: {
+            description: "Require a rendered child to be guarded with `&&`, coercing a condition that can render as 0 or an empty string.",
+        },
+        schema: [],
+        messages: {
+            preferLogical: "A rendered child guarded by a ternary is a plain `&&`. Write `{{condition}} && …` instead of `… : null`.",
+            preferLogicalCoerced: "A rendered child guarded by a ternary is a plain `&&`, and this condition can render as 0 or an empty string. Write `!!{{condition}} && …`.",
+            coerce: "`{{condition}}` can be 0 or an empty string, which React renders — outside a `<Text>` that throws. Coerce it with `!!`.",
+            preferBangBang: "`!== undefined` is `!!` for this type. Write `!!{{condition}} && …`.",
+        },
+    },
+    create(context) {
+        const services = ESLintUtils.getParserServices(context, true);
+        if (!services.program)
+            return {};
+        const checker = services.program.getTypeChecker();
+        const isLeaking = (node) => canLeak(services.getTypeAtLocation(node));
+        const bangBangSubject = (test, isPresentWanted) => {
+            const compared = undefinedComparison(test);
+            if (compared?.isPresent !== isPresentWanted)
+                return undefined;
+            return isSameAsBangBang(services.getTypeAtLocation(compared.value), checker) ? compared.value : undefined;
+        };
+        /** The message is the fix, so anything that is not a isSingle term is parenthesised. */
+        const nameOf = (node) => {
+            const text = context.sourceCode.getText(node).replaceAll(WHITESPACE_PATTERN, " ");
+            const isSingle = node.type === AST_NODE_TYPES.Identifier ||
+                node.type === AST_NODE_TYPES.Literal ||
+                node.type === AST_NODE_TYPES.MemberExpression ||
+                node.type === AST_NODE_TYPES.CallExpression;
+            return isSingle ? text : `(${text})`;
+        };
+        /** Whether a name holding a guard is read, and every read is drawn. */
+        const isOnlyRendered = (declarator) => {
+            const [variable] = context.sourceCode.getDeclaredVariables(declarator);
+            const reads = variable.references.filter((reference) => reference.isRead());
+            if (reads.length === 0)
+                return false;
+            return reads.every((reference) => isInRenderPosition(reference.identifier));
+        };
+        return {
+            ConditionalExpression(node) {
+                // The shape is what proves a `const` holding this is a guard.
+                const isConsequentGuarded = isRenderable(node.consequent) && isNothing(node.alternate);
+                const isAlternateGuarded = isRenderable(node.alternate) && isNothing(node.consequent);
+                if (!isConsequentGuarded && !isAlternateGuarded)
+                    return;
+                if (!isInRenderPosition(node)) {
+                    const declarator = heldBy(node);
+                    if (!declarator || !isOnlyRendered(declarator))
+                        return;
+                }
+                const subject = bangBangSubject(node.test, isConsequentGuarded);
+                if (subject) {
+                    context.report({ node, messageId: "preferBangBang", data: { condition: nameOf(subject) } });
+                    return;
+                }
+                context.report({
+                    node,
+                    // A negated test is already a boolean, so only the consequent guard can leak.
+                    messageId: isConsequentGuarded && isLeaking(node.test) ? "preferLogicalCoerced" : "preferLogical",
+                    data: { condition: isAlternateGuarded ? `!${nameOf(node.test)}` : nameOf(node.test) },
+                });
+            },
+            LogicalExpression(node) {
+                if (node.operator !== "&&")
+                    return;
+                if (!isInRenderPosition(node))
+                    return;
+                const subject = bangBangSubject(node.left, true);
+                if (subject) {
+                    context.report({ node: node.left, messageId: "preferBangBang", data: { condition: nameOf(subject) } });
+                    return;
+                }
+                // The rightmost operand is the guard: `a && b && <X />` leaks only on `b`.
+                if (!isLeaking(node.left))
+                    return;
+                context.report({ node: node.left, messageId: "coerce", data: { condition: nameOf(node.left) } });
+            },
+        };
+    },
+});
+export default booleanGuard;

package/dist/plugins/rules/comment-style.d.ts

@@ -0,0 +1,26 @@
+import { type TSESLint } from "@typescript-eslint/utils";
+type Options = [{
+    maxLength?: number;
+}?];
+type MessageIds = "lineRun" | "blockRun" | "jsxRun" | "jsxBlock" | "tooLong";
+/**
+ * Keep `//` and `/* *\/` to one row, so a caption stays a caption; a paragraph belongs in a `/** *\/` JSDoc block.
+ *
+ * Reported: a run of own-row `//` lines, or of one-row `/* *\/` blocks on
+ * consecutive own rows (a run is one comment in disguise); a `/* *\/` block,
+ * including `{/* *\/}` in JSX, spanning rows; and with `maxLength`, any row
+ * longer than it. Unset, only the row count is checked.
+ *
+ * Accepted: a JSDoc block of any number of rows; a one-row `//` or `/* *\/`; a
+ * run of nothing but directives, which each bind to the line beneath.
+ *
+ * Directives are the tool's text, so only the reason after ` -- ` is measured.
+ * A run holding any prose is still a run. A URL is exempt from the length cap.
+ *
+ * Limits: a row is judged by its text, not by whether it explains anything; a
+ * `/* *\/` block hugging code on its row is trailing and never joins a run.
+ */
+declare const _default: TSESLint.RuleModule<MessageIds, Options, unknown, TSESLint.RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/plugins/rules/comment-style.js

@@ -0,0 +1,158 @@
+import { AST_NODE_TYPES, AST_TOKEN_TYPES } from "@typescript-eslint/utils";
+import createRule from "../utils/create-rule.js";
+import { DIRECTIVE_PATTERN, isJsdoc, isRowStart } from "../utils/comments.js";
+const REASON_PATTERN = /\s--\s([\s\S]*)$/;
+const LINK_PATTERN = /\S*https?:\/\/\S*/g;
+const JSDOC_ROW_PATTERN = /^\s*\*?\s?/;
+/**
+ * A JSX comment is `{ / * … * / }`, a block comment alone inside an expression container.
+ *
+ * Braces either side are not enough: an empty object literal, function body or
+ * `catch` look identical from the tokens. A container holding nothing but
+ * comments parses as a JSXEmptyExpression, which exists nowhere else.
+ */
+const isJsxComment = (sourceCode, comment) => {
+    const before = sourceCode.getTokenBefore(comment, { includeComments: false });
+    const after = sourceCode.getTokenAfter(comment, { includeComments: false });
+    if (before?.value !== "{" || after?.value !== "}")
+        return false;
+    return sourceCode.getNodeByRangeIndex(comment.range[0])?.type === AST_NODE_TYPES.JSXEmptyExpression;
+};
+/** A directive's payload is the tool's; only the reason after `--` is the author's, and none means nothing to cap. */
+const measurable = (text) => {
+    const reason = REASON_PATTERN.exec(text);
+    if (reason)
+        return reason[1];
+    return DIRECTIVE_PATTERN.test(text) ? "" : text;
+};
+/** A URL cannot be wrapped, so it is left out of the measured row; the rest of the row still counts. */
+const withoutLinks = (line) => line.replaceAll(LINK_PATTERN, "");
+const lineLength = (comment) => {
+    const lines = isJsdoc(comment)
+        ? comment.value.split("\n").map((line) => line.replace(JSDOC_ROW_PATTERN, "").trimEnd())
+        : comment.value.split("\n");
+    const measured = DIRECTIVE_PATTERN.test(comment.value) ? lines.map(measurable) : lines;
+    return Math.max(0, ...measured.map((line) => withoutLinks(line).trim().length));
+};
+/**
+ * Keep `//` and `/* *\/` to one row, so a caption stays a caption; a paragraph belongs in a `/** *\/` JSDoc block.
+ *
+ * Reported: a run of own-row `//` lines, or of one-row `/* *\/` blocks on
+ * consecutive own rows (a run is one comment in disguise); a `/* *\/` block,
+ * including `{/* *\/}` in JSX, spanning rows; and with `maxLength`, any row
+ * longer than it. Unset, only the row count is checked.
+ *
+ * Accepted: a JSDoc block of any number of rows; a one-row `//` or `/* *\/`; a
+ * run of nothing but directives, which each bind to the line beneath.
+ *
+ * Directives are the tool's text, so only the reason after ` -- ` is measured.
+ * A run holding any prose is still a run. A URL is exempt from the length cap.
+ *
+ * Limits: a row is judged by its text, not by whether it explains anything; a
+ * `/* *\/` block hugging code on its row is trailing and never joins a run.
+ */
+export default createRule({
+    name: "comment-style",
+    meta: {
+        defaultOptions: [{}],
+        type: "layout",
+        docs: {
+            description: "Keep `//` and `/* */` to one row; a longer explanation is a `/** */` JSDoc block.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: { maxLength: { type: "integer", minimum: 1 } },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            lineRun: "This comment runs to {{rows}} rows. Say it in one `//` or `/* */` line, or move the explanation to a `/** */` JSDoc block.",
+            blockRun: "This comment runs to {{rows}} rows. Say it in one `//` or `/* */` line, or move the explanation to a `/** */` JSDoc block.",
+            jsxRun: "These JSX comments run to {{rows}} rows. Say it in one `{/* */}` line, or move the explanation to a JSDoc block above the component.",
+            jsxBlock: "This JSX comment runs to {{rows}} rows. Say it in one line, or move the explanation to a JSDoc block above the component.",
+            tooLong: "This comment line is {{length}} characters. Keep it to {{max}}.",
+        },
+    },
+    create(context) {
+        const { sourceCode } = context;
+        const maxLength = context.options[0]?.maxLength;
+        const isTooLong = (comment) => Boolean(maxLength) && lineLength(comment) > (maxLength ?? 0);
+        const reportTooLong = (comment) => {
+            context.report({
+                loc: comment.loc,
+                messageId: "tooLong",
+                data: { length: String(lineLength(comment)), max: String(maxLength) },
+            });
+        };
+        return {
+            "Program:exit"() {
+                let run = [];
+                const doesContinue = (comment) => {
+                    const last = run.at(-1);
+                    return Boolean(last) && comment.loc.start.line === (last?.loc.end.line ?? 0) + 1;
+                };
+                const flush = () => {
+                    const [first] = run;
+                    const last = run.at(-1);
+                    if (last && run.length > 1 && run.some((entry) => !DIRECTIVE_PATTERN.test(entry.value))) {
+                        context.report({
+                            loc: { start: first.loc.start, end: last.loc.end },
+                            // `//` cannot be written inside JSX, so advising it there would be unfollowable.
+                            messageId: run.some((entry) => isJsxComment(sourceCode, entry)) ? "jsxRun" : "lineRun",
+                            data: { rows: String(run.length) },
+                        });
+                    }
+                    else if (run.length === 1 && isTooLong(first)) {
+                        reportTooLong(first);
+                    }
+                    run = [];
+                };
+                for (const comment of sourceCode.getAllComments()) {
+                    if (comment.type === AST_TOKEN_TYPES.Block) {
+                        const rows = comment.loc.end.line - comment.loc.start.line + 1;
+                        // A JSX comment's `{` is syntax, so a row holding only `{/* … */}` starts its row.
+                        const isOwnRow = isRowStart(sourceCode, comment) ||
+                            (isJsxComment(sourceCode, comment) &&
+                                !sourceCode.lines[comment.loc.start.line - 1]
+                                    ?.slice(0, Math.max(0, comment.loc.start.column - 1))
+                                    .trim());
+                        if (!isJsdoc(comment) && rows === 1 && isOwnRow) {
+                            if (!doesContinue(comment))
+                                flush();
+                            run.push(comment);
+                            continue;
+                        }
+                        flush();
+                        if (isJsdoc(comment)) {
+                            if (isTooLong(comment))
+                                reportTooLong(comment);
+                            continue;
+                        }
+                        if (rows > 1) {
+                            context.report({
+                                loc: comment.loc,
+                                messageId: isJsxComment(sourceCode, comment) ? "jsxBlock" : "blockRun",
+                                data: { rows: String(rows) },
+                            });
+                        }
+                        else if (isTooLong(comment)) {
+                            reportTooLong(comment);
+                        }
+                        continue;
+                    }
+                    if (!doesContinue(comment))
+                        flush();
+                    if (!isRowStart(sourceCode, comment)) {
+                        flush();
+                        if (isTooLong(comment))
+                            reportTooLong(comment);
+                        continue;
+                    }
+                    run.push(comment);
+                }
+                flush();
+            },
+        };
+    },
+});

package/dist/plugins/rules/effect-takes-callback.d.ts

@@ -0,0 +1,20 @@
+/**
+ * A hook named `use<Something>Effect` takes the callback it runs as its first
+ * parameter, like `useEffect`, `useLayoutEffect` and `useFocusEffect`.
+ *
+ * Reports a function declaration, or a `const` bound to an arrow or function
+ * expression, named `use` + a capitalised word + `Effect` whose first parameter
+ * is missing or is not a function. A parameter counts as a function when it is
+ * annotated with a function type, `EffectCallback` or a union of those with
+ * `undefined`, has a function default, or, with type information, when its
+ * type has a call signature (through an alias or a generic bound). `any` is
+ * given the benefit of the doubt.
+ *
+ * Limits: without type information only the annotation is read. A hook ending
+ * in `Effect` for another reason (`useSoundEffect(name)`) is reported; rename
+ * it or disable the rule on that line. A hook assigned from a call is not seen.
+ */
+declare const effectTakesCallback: import("@typescript-eslint/utils/ts-eslint").RuleModule<"callbackFirst", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default effectTakesCallback;

package/dist/plugins/rules/effect-takes-callback.js

@@ -0,0 +1,106 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import ts, { TypeFlags } from "typescript";
+import createRule from "../utils/create-rule.js";
+const EFFECT_HOOK_PATTERN = /^use[A-Z]\w*Effect$/;
+const NOTHING = TypeFlags.Undefined | TypeFlags.Null | TypeFlags.Void;
+const ABSENT = new Set(["TSUndefinedKeyword", "TSNullKeyword", "TSVoidKeyword"]);
+/** A function type, `EffectCallback`, or a union of those with `undefined`/`null`. */
+const isCallbackAnnotation = (type) => {
+    if (type?.type === AST_NODE_TYPES.TSUnionType) {
+        const rest = type.types.filter((part) => !ABSENT.has(part.type));
+        return rest.length > 0 && rest.every(isCallbackAnnotation);
+    }
+    if (type?.type === AST_NODE_TYPES.TSFunctionType)
+        return true;
+    if (type?.type !== AST_NODE_TYPES.TSTypeReference)
+        return false;
+    const { typeName } = type;
+    if (typeName.type === AST_NODE_TYPES.Identifier)
+        return typeName.name === "EffectCallback";
+    return typeName.type === AST_NODE_TYPES.TSQualifiedName && typeName.right.name === "EffectCallback";
+};
+/**
+ * A hook named `use<Something>Effect` takes the callback it runs as its first
+ * parameter, like `useEffect`, `useLayoutEffect` and `useFocusEffect`.
+ *
+ * Reports a function declaration, or a `const` bound to an arrow or function
+ * expression, named `use` + a capitalised word + `Effect` whose first parameter
+ * is missing or is not a function. A parameter counts as a function when it is
+ * annotated with a function type, `EffectCallback` or a union of those with
+ * `undefined`, has a function default, or, with type information, when its
+ * type has a call signature (through an alias or a generic bound). `any` is
+ * given the benefit of the doubt.
+ *
+ * Limits: without type information only the annotation is read. A hook ending
+ * in `Effect` for another reason (`useSoundEffect(name)`) is reported; rename
+ * it or disable the rule on that line. A hook assigned from a call is not seen.
+ */
+const effectTakesCallback = createRule({
+    name: "effect-takes-callback",
+    meta: {
+        defaultOptions: [],
+        type: "suggestion",
+        docs: {
+            description: "A use*Effect hook takes the callback it runs as its first parameter, like useEffect and useFocusEffect.",
+        },
+        schema: [],
+        messages: {
+            callbackFirst: "`{{name}}` ends in Effect but its first parameter is not a callback. Take the callback first, or drop the Effect suffix.",
+        },
+    },
+    create(context) {
+        const services = context.sourceCode.parserServices;
+        const checker = services?.program ? services.program.getTypeChecker() : undefined;
+        /** Whether a value of this type can be called, once `undefined` is set aside. */
+        const isCallable = (type) => {
+            if (type.flags & TypeFlags.Any)
+                return true;
+            if (type.isUnion()) {
+                const rest = type.types.filter((part) => !(part.flags & NOTHING));
+                return rest.length > 0 && rest.every(isCallable);
+            }
+            if (type.getCallSignatures().length > 0)
+                return true;
+            if (checker && type.flags & TypeFlags.TypeParameter) {
+                const constraint = checker.getBaseConstraintOfType(type);
+                return Boolean(constraint) && isCallable(constraint);
+            }
+            return false;
+        };
+        const isCallback = (parameter) => {
+            if (!parameter)
+                return false;
+            if (parameter.type === AST_NODE_TYPES.AssignmentPattern && (parameter.right.type === AST_NODE_TYPES.ArrowFunctionExpression ||
+                parameter.right.type === AST_NODE_TYPES.FunctionExpression)) {
+                return true;
+            }
+            const node = parameter.type === AST_NODE_TYPES.AssignmentPattern ? parameter.left : parameter;
+            const annotation = "typeAnnotation" in node ? node.typeAnnotation : undefined;
+            if (isCallbackAnnotation(annotation?.typeAnnotation))
+                return true;
+            if (!checker || !services?.esTreeNodeToTSNodeMap)
+                return false;
+            const tsNode = services.esTreeNodeToTSNodeMap.get(node);
+            return isCallable(checker.getTypeAtLocation(tsNode));
+        };
+        const check = (id, fn) => {
+            if (id?.type !== AST_NODE_TYPES.Identifier || !EFFECT_HOOK_PATTERN.test(id.name))
+                return;
+            if (!isCallback(fn.params[0])) {
+                context.report({ node: id, messageId: "callbackFirst", data: { name: id.name } });
+            }
+        };
+        return {
+            FunctionDeclaration: (node) => {
+                check(node.id, node);
+            },
+            VariableDeclarator: (node) => {
+                if (node.init?.type === AST_NODE_TYPES.ArrowFunctionExpression ||
+                    node.init?.type === AST_NODE_TYPES.FunctionExpression) {
+                    check(node.id, node.init);
+                }
+            },
+        };
+    },
+});
+export default effectTakesCallback;

package/dist/plugins/rules/jsdoc-for-props.d.ts

@@ -0,0 +1,18 @@
+/**
+ * A comment on a type member is a JSDoc block, the only form an editor shows when the member is hovered elsewhere.
+ *
+ * Reported: a `//` line comment or a plain `/* *\/` block directly above a
+ * property or method signature of a type literal or an interface.
+ *
+ * Accepted: a JSDoc block of any number of rows; no comment; a comment trailing
+ * code on its row; a comment separated from the member by a blank line. A
+ * directive is skipped: it binds to the line beneath it, so it neither
+ * documents the member nor hides the comment above itself.
+ *
+ * Limits: only the nearest comment above the member is judged. Class members,
+ * object-literal properties, enum members and call signatures are not checked.
+ */
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"form", never[], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/plugins/rules/jsdoc-for-props.js

@@ -0,0 +1,57 @@
+import { AST_TOKEN_TYPES } from "@typescript-eslint/utils";
+import createRule from "../utils/create-rule.js";
+import { DIRECTIVE_PATTERN, isJsdoc, isRowStart } from "../utils/comments.js";
+/**
+ * A comment on a type member is a JSDoc block, the only form an editor shows when the member is hovered elsewhere.
+ *
+ * Reported: a `//` line comment or a plain `/* *\/` block directly above a
+ * property or method signature of a type literal or an interface.
+ *
+ * Accepted: a JSDoc block of any number of rows; no comment; a comment trailing
+ * code on its row; a comment separated from the member by a blank line. A
+ * directive is skipped: it binds to the line beneath it, so it neither
+ * documents the member nor hides the comment above itself.
+ *
+ * Limits: only the nearest comment above the member is judged. Class members,
+ * object-literal properties, enum members and call signatures are not checked.
+ */
+export default createRule({
+    name: "jsdoc-for-props",
+    meta: {
+        defaultOptions: [],
+        type: "suggestion",
+        docs: {
+            description: "A comment above a type member is a JSDoc block, so an editor shows it at the call site.",
+        },
+        schema: [],
+        messages: {
+            form: "Write this as a JSDoc block, not `{{ form }}`. A member's comment is what an editor shows when someone hovers it elsewhere, and only JSDoc reaches there.",
+        },
+    },
+    create(context) {
+        const { sourceCode } = context;
+        const check = (node) => {
+            // A directive neither documents the member nor separates it from the comment above.
+            let floor = node.loc.start.line;
+            let comment;
+            for (const entry of sourceCode.getCommentsBefore(node).toReversed()) {
+                if (!isRowStart(sourceCode, entry))
+                    continue;
+                if (DIRECTIVE_PATTERN.test(entry.value)) {
+                    floor = entry.loc.start.line;
+                    continue;
+                }
+                comment = entry;
+                break;
+            }
+            if (!comment || comment.loc.end.line !== floor - 1 || isJsdoc(comment))
+                return;
+            context.report({
+                node: comment,
+                messageId: "form",
+                data: { form: comment.type === AST_TOKEN_TYPES.Line ? "a line comment" : "a plain block" },
+            });
+        };
+        return { TSPropertySignature: check, TSMethodSignature: check };
+    },
+});

package/dist/plugins/rules/no-callback-payload.d.ts

@@ -0,0 +1,21 @@
+import { type TSESLint } from "@typescript-eslint/utils";
+/**
+ * A component forwards an event; the caller builds the payload.
+ *
+ * Reports, in an exported component (a function whose name starts with a
+ * capital, also inside `memo`/`forwardRef`), a call of one of its own `on*`
+ * props when every argument is built only from its props and literals and at
+ * least one prop is handed straight back (`onPress(teamId)`,
+ * `onPlay({ mediaId })`). Left alone: a value the component produced itself
+ * (an index it tracks, input text, `!isOn`), a callback called with different
+ * arguments in different places (the argument says which control was
+ * pressed), and components the file does not export.
+ *
+ * Props are the first parameter's bindings, resolved through scope, so a local
+ * that shadows a prop's name is the component's own value. Limits: a value
+ * derived into a local first (`const id = item.id`) is not followed.
+ */
+declare const noCallbackPayload: TSESLint.RuleModule<"payload", [], unknown, TSESLint.RuleListener> & {
+    name: string;
+};
+export default noCallbackPayload;