@blumintinc/eslint-plugin-blumint 1.20.139 → 1.20.141

package/lib/index.js

@@ -223,7 +223,7 @@ function noFrontendImportsFromFunctionsPatterns(pattern) {
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.20.139',
+        version: '1.20.141',
     },
     parseOptions: {
         ecmaVersion: 2020,

package/lib/rules/class-methods-read-top-to-bottom.js

@@ -3,15 +3,35 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.classMethodsReadTopToBottom = void 0;
 const createRule_1 = require("../utils/createRule");
 const ClassGraphBuilder_1 = require("../utils/graph/ClassGraphBuilder");
-function getMemberName(member) {
-    if (member.type === 'MethodDefinition' ||
-        member.type === 'PropertyDefinition' ||
-        member.type === 'TSAbstractMethodDefinition' ||
-        member.type === 'TSAbstractPropertyDefinition' ||
-        member.type === 'TSAbstractAccessorProperty') {
-        return member.key.type === 'Identifier' ? member.key.name : null;
-    }
-    return null;
+const ASTHelpers_1 = require("../utils/ASTHelpers");
+// The source order and the sorted graph are matched by name, so both sides must
+// derive names from the same function: any disagreement makes the two arrays
+// differ in length and silently skips the whole class body.
+const getMemberName = ClassGraphBuilder_1.classMemberNameOf;
+/**
+ * Whether the proposed order still declares every field above the initializer
+ * that reads it. Only field-to-field reads constrain the layout: methods (and
+ * private methods) are installed before any initializer runs, so relocating one
+ * is unobservable.
+ */
+function initializerReadsPrecedeDeclarations(node, sortedOrder, graph, className) {
+    const positionOf = new Map(sortedOrder.map((name, index) => [name, index]));
+    return node.body.every((member) => {
+        if (member.type !== 'PropertyDefinition' || !member.value) {
+            return true;
+        }
+        const reader = getMemberName(member);
+        const readerPosition = reader === null ? undefined : positionOf.get(reader);
+        if (readerPosition === undefined) {
+            return true;
+        }
+        return ASTHelpers_1.ASTHelpers.classMemberNamesReadEagerly(member.value, className)
+            .filter((name) => graph[name]?.type === 'property' && name !== reader)
+            .every((name) => {
+            const readPosition = positionOf.get(name);
+            return readPosition === undefined || readPosition < readerPosition;
+        });
+    });
 }
 exports.classMethodsReadTopToBottom = (0, createRule_1.createRule)({
     name: 'class-methods-read-top-to-bottom',
@@ -71,6 +91,14 @@ exports.classMethodsReadTopToBottom = (0, createRule_1.createRule)({
                 if (!allMembersRepresented) {
                     return;
                 }
+                // Field declaration order is observable where method order is not:
+                // methods are installed before any initializer runs, but a field read
+                // before its own declaration evaluates to `undefined` under the
+                // `private` spelling and throws under the ECMA `#` spelling. Bail
+                // rather than emit an order that changes what the class computes.
+                if (!initializerReadsPrecedeDeclarations(node, sortedOrder, graphBuilder.graph, className)) {
+                    return;
+                }
                 for (let i = 0; i < actualOrder.length; i++) {
                     const actualMember = actualOrder[i];
                     const expectedMember = sortedOrder[i];

package/lib/rules/consistent-callback-naming.js

@@ -148,6 +148,100 @@ function isApiSurfaceValue(node) {
     }
     return false;
 }
+/**
+ * Whether `node` is a member of a class that `extends` or `implements`
+ * something.
+ *
+ * Such a member is one end of a contract whose other end this fixer does not
+ * own. Renaming only the implementation leaves the declaration behind and the
+ * class stops satisfying it: `TS2515` when an abstract base declares the member,
+ * `TS2420` when an `implements` clause does (Bug #1944). The heritage itself is
+ * the trigger rather than a matching declaration the rule can find, because the
+ * base is routinely imported — the declaration need not be in this file at all,
+ * and sibling implementors of the same contract certainly need not be. Erring
+ * toward withholding costs an autofix on members that override nothing; it buys
+ * a fixer that cannot turn a compiling file into a broken one. The violation is
+ * still reported, so the author renames both ends deliberately — the same policy
+ * that already withholds the rename for exported bindings and for members of an
+ * exported or returned object literal.
+ */
+function satisfiesDeclaredContract(node) {
+    const classNode = enclosingClass(node);
+    return (!!classNode &&
+        (!!classNode.superClass || (classNode.implements?.length ?? 0) > 0));
+}
+/** The class a member belongs to, when `node` is a class member. */
+function enclosingClass(node) {
+    const body = node.parent;
+    if (body?.type !== utils_1.AST_NODE_TYPES.ClassBody) {
+        return undefined;
+    }
+    const classNode = body.parent;
+    return classNode?.type === utils_1.AST_NODE_TYPES.ClassDeclaration ||
+        classNode?.type === utils_1.AST_NODE_TYPES.ClassExpression
+        ? classNode
+        : undefined;
+}
+/**
+ * What `this` denotes at `node`: `classNode`'s instance, `classNode` itself
+ * (inside a `static` member), or nothing the rule can pin down.
+ *
+ * `this` is only rewritable evidence when it provably names the class whose
+ * member is being renamed. An arrow function inherits `this` lexically, so the
+ * walk passes through it; an ordinary function expression rebinds `this` to
+ * whatever calls it, so `this.handleClick` inside a callback may be some other
+ * object's member entirely and the rename must not touch it.
+ */
+function thisReceiverOf(node, classNode) {
+    const ownedBy = (member) => member.parent?.parent === classNode
+        ? member.static
+            ? 'static'
+            : 'instance'
+        : undefined;
+    let child = node;
+    let current = node.parent;
+    while (current) {
+        // A concise or block-bodied arrow keeps the enclosing `this`.
+        if (current.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+            const owner = current.parent;
+            return (owner?.type === utils_1.AST_NODE_TYPES.MethodDefinition ||
+                owner?.type === utils_1.AST_NODE_TYPES.PropertyDefinition) &&
+                owner.value === current
+                ? ownedBy(owner)
+                : undefined;
+        }
+        if (current.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) {
+            return undefined;
+        }
+        if (current.type === utils_1.AST_NODE_TYPES.PropertyDefinition) {
+            // Reached through arrows alone: a field initializer's `this` is the
+            // instance under construction.
+            return current.value === child ? ownedBy(current) : undefined;
+        }
+        if (current.type === utils_1.AST_NODE_TYPES.StaticBlock) {
+            return current.parent === classNode.body ? 'static' : undefined;
+        }
+        // A computed key, a decorator or a heritage expression evaluates outside
+        // the class body, so `this` there is not the instance.
+        if (current.type === utils_1.AST_NODE_TYPES.ClassBody ||
+            current.type === utils_1.AST_NODE_TYPES.Program) {
+            return undefined;
+        }
+        child = current;
+        current = current.parent;
+    }
+    return undefined;
+}
+/** Whether a class body declares `name` twice — a `get`/`set` pair. */
+function declaresNameTwice(body, name) {
+    const declarations = body.body.filter((member) => {
+        const key = member.key;
+        return (!member.computed &&
+            key?.type === utils_1.AST_NODE_TYPES.Identifier &&
+            key.name === name);
+    });
+    return declarations.length > 1;
+}
 /** The member names already declared alongside `node`, keyed by identifier. */
 function siblingMemberNames(node) {
     const names = new Set();
@@ -179,17 +273,7 @@ function siblingMemberNames(node) {
  */
 function collectMemberReads(program, visitorKeys) {
     const names = new Set();
-    const stack = [program];
-    const push = (value) => {
-        if (Array.isArray(value)) {
-            value.forEach(push);
-        }
-        else if (value && typeof value === 'object' && 'type' in value) {
-            stack.push(value);
-        }
-    };
-    while (stack.length > 0) {
-        const node = stack.pop();
+    walkProgram(program, visitorKeys, (node) => {
         if (node.type === utils_1.AST_NODE_TYPES.MemberExpression) {
             if (!node.computed && node.property.type === utils_1.AST_NODE_TYPES.Identifier) {
                 names.add(node.property.name);
@@ -210,11 +294,75 @@ function collectMemberReads(program, visitorKeys) {
                 }
             }
         }
+    });
+    return names;
+}
+/**
+ * Every node of the file, type nodes included.
+ *
+ * The walk is driven by `visitorKeys` rather than by the rule's own visitors so
+ * that a reference is found wherever it sits — including before the declaration
+ * it refers to, and inside a type position the default traversal would still
+ * reach but a hand-written recursion routinely forgets.
+ */
+function walkProgram(program, visitorKeys, visit) {
+    const stack = [program];
+    const push = (value) => {
+        if (Array.isArray(value)) {
+            value.forEach(push);
+        }
+        else if (value && typeof value === 'object' && 'type' in value) {
+            stack.push(value);
+        }
+    };
+    while (stack.length > 0) {
+        const node = stack.pop();
+        visit(node);
         for (const key of visitorKeys[node.type] ?? []) {
             push(node[key]);
         }
     }
-    return names;
+}
+function collectMemberSites(program, visitorKeys) {
+    const reads = new Map();
+    const opaque = new Set();
+    let dynamicThisAccess = false;
+    walkProgram(program, visitorKeys, (node) => {
+        if (node.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+            if (!node.computed && node.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                const existing = reads.get(node.property.name);
+                if (existing) {
+                    existing.push(node);
+                }
+                else {
+                    reads.set(node.property.name, [node]);
+                }
+            }
+            else if (node.computed &&
+                node.object.type === utils_1.AST_NODE_TYPES.ThisExpression &&
+                !(node.property.type === utils_1.AST_NODE_TYPES.Literal &&
+                    typeof node.property.value === 'string')) {
+                dynamicThisAccess = true;
+            }
+        }
+        if (node.type === utils_1.AST_NODE_TYPES.Literal &&
+            typeof node.value === 'string') {
+            opaque.add(node.value);
+        }
+        if (node.type === utils_1.AST_NODE_TYPES.TSQualifiedName) {
+            opaque.add(node.right.name);
+        }
+        if (node.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+            for (const property of node.properties) {
+                if (property.type === utils_1.AST_NODE_TYPES.Property &&
+                    !property.computed &&
+                    property.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    opaque.add(property.key.name);
+                }
+            }
+        }
+    });
+    return { reads, opaque, dynamicThisAccess };
 }
 module.exports = (0, createRule_1.createRule)({
     name: 'consistent-callback-naming',
@@ -385,6 +533,101 @@ module.exports = (0, createRule_1.createRule)({
             memberReads ??= collectMemberReads(sourceCode.ast, sourceCode.visitorKeys);
             return memberReads.has(name);
         }
+        // Built once per file, and only when a class member is actually a rename
+        // candidate.
+        let memberSites;
+        function fileMemberSites() {
+            const sourceCode = context.getSourceCode();
+            memberSites ??= collectMemberSites(sourceCode.ast, sourceCode.visitorKeys);
+            return memberSites;
+        }
+        /**
+         * Whether the class — and with it every value of its type — stays inside
+         * this file.
+         *
+         * A rename of a member another module can name is the JSX-prop problem in
+         * class clothing: the fixer edits one end of a contract whose readers it
+         * cannot see, and `import { C } from './c'; c.handleClick()` fails with
+         * TS2339 (Bug #1946). Export of the class is the obvious leak; a bare
+         * mention of the class name is the subtler one, since `export const c = new
+         * C()` hands the instance out without exporting the class at all. Neither is
+         * traceable across files, so both withhold.
+         */
+        function classStaysModulePrivate(classNode) {
+            if (isApiSurfaceValue(classNode)) {
+                return false;
+            }
+            const bindings = [...context.getDeclaredVariables(classNode)];
+            if (classNode.type === utils_1.AST_NODE_TYPES.ClassExpression) {
+                const declarator = classNode.parent;
+                if (declarator?.type !== utils_1.AST_NODE_TYPES.VariableDeclarator ||
+                    declarator.init !== classNode ||
+                    declarator.id.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                    // A class expression passed to a call, stored on a property or
+                    // returned is a value whose consumers the fixer cannot follow.
+                    return false;
+                }
+                bindings.push(...context.getDeclaredVariables(declarator));
+            }
+            else if (bindings.length === 0) {
+                // An unnamed declaration is only reachable through an export.
+                return false;
+            }
+            return bindings.every((variable) => !isExportedBinding(variable) &&
+                !variable.references.some((ref) => !variable.identifiers.includes(ref.identifier)));
+        }
+        /**
+         * The reads a class-member rename must rewrite alongside the key, or `null`
+         * when the rename has to be withheld entirely.
+         *
+         * The reads live in this file, so unlike the JSX prop or the exported
+         * binding they are the fixer's to move — and they must move in the SAME fix,
+         * because a rename that reaches the declaration and not `this.handleClick()`
+         * turns a compiling file into TS2339 (Bug #1946). Any read the fixer cannot
+         * prove it owns — a computed access, a `super.` or instance-variable read, a
+         * `this` that some other object binds — collapses the whole rename to
+         * `null`: a partial rename is the very breakage this returns to prevent.
+         *
+         * A field (`handleClick = () => {}`) has exactly the binding sites a method
+         * has — the key, and `this.` reads of it — so it is answered here rather
+         * than on a parallel path that would have to re-derive every one of these
+         * withholdings (Bug #1949).
+         */
+        function classMemberRenameTargets(node, name) {
+            const classNode = enclosingClass(node);
+            if (!classNode || node.computed) {
+                return null;
+            }
+            // A `get`/`set` pair declares the name twice, and this report covers one
+            // half of it: the getter is report-only, so renaming the setter alone
+            // would split the accessor in two and leave `obj.handleResize = x`
+            // assigning to a property that no longer has a setter.
+            if (declaresNameTwice(classNode.body, name)) {
+                return null;
+            }
+            // A `private` member is unnameable outside the class body, so its
+            // references are all in this file however far the class itself travels.
+            if (node.accessibility !== 'private' &&
+                !classStaysModulePrivate(classNode)) {
+                return null;
+            }
+            const sites = fileMemberSites();
+            if (sites.dynamicThisAccess || sites.opaque.has(name)) {
+                return null;
+            }
+            // `this` in a static member is the class object, so a static member's
+            // reads and an instance member's reads are different members entirely.
+            const receiver = node.static ? 'static' : 'instance';
+            const targets = [];
+            for (const read of sites.reads.get(name) ?? []) {
+                if (read.object.type !== utils_1.AST_NODE_TYPES.ThisExpression ||
+                    thisReceiverOf(read, classNode) !== receiver) {
+                    return null;
+                }
+                targets.push(read.property);
+            }
+            return targets;
+        }
         /**
          * The variable a pattern identifier binds. `getDeclaredVariables` is
          * authoritative — it is asked of the declaring ancestor (the
@@ -413,10 +656,35 @@ module.exports = (0, createRule_1.createRule)({
                 variable.identifiers.some(namedByExportSpecifier) ||
                 variable.defs.some((def) => isExportedDeclaration(def.node)));
         }
+        /**
+         * Whether any scope from `from` up to — but NOT including — `until` binds
+         * `newName`.
+         *
+         * `until` is the scope the renamed declaration lives in, so it and
+         * everything above it is already answered by the upward walk in
+         * `isNameTaken`. What this adds is the span BETWEEN a reference and its
+         * declaration, which is where a binding of the new name captures the
+         * rewritten reference without colliding with anything the rename can see.
+         */
+        function bindsNameBelow(from, until, newName) {
+            let scope = from;
+            while (scope && scope !== until) {
+                if (scope.set.has(newName)) {
+                    return true;
+                }
+                scope = scope.upper;
+            }
+            return false;
+        }
         // A rename that collides with a name already visible where the binding (or
         // any of its references) lives silently re-points those references at the
         // other declaration.
-        function isNameTaken(variable, newName) {
+        function isNameTaken(variable, newName, 
+        // The sites the fix will actually rewrite. The function path gathers a
+        // wider set than `variable.references` — a reference resolved through a
+        // sibling or child scope is still a site the fixer emits the new name at,
+        // so it is still a site the new name has to resolve correctly at.
+        references = variable.references) {
             let scope = variable.scope;
             while (scope) {
                 if (scope.set.has(newName)) {
@@ -424,7 +692,22 @@ module.exports = (0, createRule_1.createRule)({
                 }
                 scope = scope.upper;
             }
-            return variable.scope.childScopes.some((child) => child.set.has(newName));
+            if (variable.scope.childScopes.some((child) => child.set.has(newName))) {
+                return true;
+            }
+            /**
+             * The declaration site is not the only place the new name has to mean the
+             * renamed binding: the fix emits it at every reference too, and a scope
+             * BETWEEN a reference and the declaration that binds the new name takes
+             * that reference over (Bug #1948). Nothing else notices — the module scope
+             * still holds one `submit`, so a redeclaration check passes, and the
+             * emitted reference is well-typed against a real binding right up until it
+             * is called (`TS2349`). Withholding the whole rename is the only safe
+             * answer: alpha-renaming the intervening binding instead would mean owning
+             * ITS references as well, and a partial rename is exactly the breakage
+             * this prevents.
+             */
+            return references.some((ref) => bindsNameBelow(ref.from, variable.scope, newName));
         }
         /**
          * A `Property` inside an `ObjectPattern`. Its key names a property of the
@@ -620,16 +903,25 @@ module.exports = (0, createRule_1.createRule)({
                     const leavesModule = declaredVariable
                         ? isExportedBinding(declaredVariable)
                         : isExportedDeclaration(node);
+                    // Remove 'handle' prefix and convert first character to lowercase
+                    const newName = stripHandlePrefix(functionName);
+                    // The rename is emitted at the declaration AND at every reference, so
+                    // it is safe only where the new name resolves to this declaration at
+                    // each of them. A binding of that name between a reference and the
+                    // declaration silently captures the rewritten reference (Bug #1948),
+                    // and without the binding itself there is no scope chain to ask, so
+                    // the fix is withheld rather than guessed. The violation still
+                    // reports; only the rename is withheld.
+                    const capturesReference = !declaredVariable ||
+                        isNameTaken(declaredVariable, newName, [...references]);
                     context.report({
                         node,
                         messageId: 'callbackFunctionPrefix',
                         data: { functionName },
                         fix(fixer) {
-                            if (leavesModule) {
+                            if (leavesModule || capturesReference) {
                                 return null;
                             }
-                            // Remove 'handle' prefix and convert first character to lowercase
-                            const newName = stripHandlePrefix(functionName);
                             // `const handleDelete = fn` would become `const delete = fn`,
                             // which does not parse (Bug #1719).
                             if (!isEmittableName(newName)) {
@@ -648,8 +940,29 @@ module.exports = (0, createRule_1.createRule)({
                     });
                 }
             },
-            // Check class methods and object methods
-            'MethodDefinition, Property'(node) {
+            /**
+             * Class members (methods and fields) and object-literal members.
+             *
+             * A class FIELD is a subject here because it is one of the docs' own
+             * subjects — "a function, method, class property, or parameter" — and
+             * because covering only the method spelling leaves the rule evadable by a
+             * single token: `handleClick() {}` reported while `handleClick = () => {}`
+             * did not, so writing `=` silenced it without changing anything about the
+             * callback (Bug #1949).
+             *
+             * The field is judged on its NAME alone, not on whether it holds a
+             * function — the same question this arm already asks of an object-literal
+             * member, that the abstract-member arm asks of `abstract handleSubmit:
+             * (d: string) => string`, and that the variable arm asks of `const
+             * handleClickCount = 0`. The subject is the `handle<Something>` prefix
+             * itself, which describes no action whatever sits to the right of the
+             * `=`. Gating on a function-typed value would reinstate the same evasion
+             * one level down — `handleClick = makeHandler()` and `handleClick =
+             * deps.click` are the identical name behind a value the rule cannot
+             * always resolve, and a file parsed without type information resolves
+             * none of them.
+             */
+            'MethodDefinition, PropertyDefinition, Property'(node) {
                 const key = node.key;
                 if (key.type !== utils_1.AST_NODE_TYPES.Identifier ||
                     !key.name ||
@@ -657,6 +970,16 @@ module.exports = (0, createRule_1.createRule)({
                     return;
                 }
                 const name = key.name;
+                // A computed key is an expression evaluated where the class is
+                // defined, so the identifier in `[handleClick] = fn` REFERENCES a
+                // binding and the member's own name is whatever that binding holds —
+                // something the rule cannot read. That binding is a subject in its own
+                // right and is reported at its declaration, so reporting the reference
+                // too would name a member that need not exist. The abstract-member arm
+                // skips a computed key for the same reason.
+                if (node.type === utils_1.AST_NODE_TYPES.PropertyDefinition && node.computed) {
+                    return;
+                }
                 // Skip autofixing for class parameters and getters
                 if (node.type === utils_1.AST_NODE_TYPES.MethodDefinition &&
                     node.kind === 'get') {
@@ -677,24 +1000,73 @@ module.exports = (0, createRule_1.createRule)({
                 // the key also replaces the value: `{ handleClick }` becomes
                 // `{ click }`, which both renames the member and re-points it at a
                 // binding that need not exist (Bug #1719).
-                const canFix = isEmittableName(newName) &&
+                const isRenameable = isEmittableName(newName) &&
                     // A sibling already holding the target name turns the rename into a
                     // duplicate member: `{ click: a, handleClick: b }` would collapse to
                     // two `click` keys, silently discarding the first.
                     !siblingMemberNames(node.parent).has(newName) &&
                     !(isProperty && node.shorthand) &&
+                    // A member of a class with heritage may be satisfying a declaration
+                    // the fixer cannot rewrite (Bug #1944).
+                    !satisfiesDeclaredContract(node) &&
+                    // A `declare` field defines nothing: it asserts that a property is
+                    // established somewhere the class body does not show — a base
+                    // constructor, a decorator, a framework assigning by name — so the
+                    // definition the rename must move with is out of the fixer's reach,
+                    // exactly as an abstract declaration's implementors are (Bug #1949).
+                    !(node.type === utils_1.AST_NODE_TYPES.PropertyDefinition && node.declare) &&
                     !(isProperty &&
                         node.parent &&
                         (isApiSurfaceValue(node.parent) || isReadByName(name)));
+                // A class member's readers are `this.handleClick` sites in this same
+                // file, so the rename owns them and rewrites them in one fix; `null`
+                // means at least one reference is beyond its reach (Bug #1946).
+                const referenceTargets = isRenameable && !isProperty
+                    ? classMemberRenameTargets(node, name)
+                    : [];
+                const canFix = isRenameable && referenceTargets !== null;
                 context.report({
                     node: key,
                     messageId: 'callbackFunctionPrefix',
                     data: { functionName: name },
                     fix(fixer) {
-                        return canFix ? fixer.replaceText(key, newName) : null;
+                        if (!canFix || !referenceTargets) {
+                            return null;
+                        }
+                        // One fix carrying every edit: ESLint applies a fix atomically, so
+                        // the declaration and its readers cannot be rewritten apart — a
+                        // partial application would leave the file broken.
+                        return [key, ...referenceTargets].map((target) => fixer.replaceText(target, newName));
                     },
                 });
             },
+            // The declaration half of a class contract: `abstract handleSubmit(): T`
+            // and `abstract handleSubmit: () => T`. The docs scope the subject by what
+            // the member IS — "a function, method, class property, or parameter" — and
+            // an abstract member is a method or a class property, so silence here is
+            // a gap rather than a carve-out (Bug #1944).
+            //
+            // Report-only, and permanently so: the declaration binds every implementor
+            // of the class, and implementors live in files a single-file fixer cannot
+            // see, let alone edit atomically. Interface and type-literal members
+            // (`TSMethodSignature`, `TSPropertySignature`) are deliberately NOT
+            // reported here — a member of a type is a prop declaration, which this
+            // rule governs through `callbackPropPrefix`, whose remedy is the OPPOSITE
+            // one (`onSubmit`, not `submit`). Reporting both on one declaration would
+            // hand the author contradictory instructions.
+            'TSAbstractMethodDefinition, TSAbstractPropertyDefinition'(node) {
+                const key = node.key;
+                if (node.computed ||
+                    key.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                    !hasHandlePrefix(key.name)) {
+                    return;
+                }
+                context.report({
+                    node: key,
+                    messageId: 'callbackFunctionPrefix',
+                    data: { functionName: key.name },
+                });
+            },
             // Check constructor parameters
             TSParameterProperty(node) {
                 if (node.parameter.type === 'Identifier' &&