@blumintinc/eslint-plugin-blumint 1.9.1 → 1.11.0

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

@@ -22,6 +22,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
 const createRule_1 = require("../utils/createRule");
 const utils_1 = require("@typescript-eslint/utils");
 const ts = __importStar(require("typescript"));
@@ -60,10 +61,12 @@ module.exports = (0, createRule_1.createRule)({
                 // Check for JSX element types
                 if (ts.isTypeAliasDeclaration(declaration)) {
                     const typeText = declaration.type.getText();
-                    return typeText.includes('JSX.Element') || typeText.includes('ReactElement');
+                    return (typeText.includes('JSX.Element') ||
+                        typeText.includes('ReactElement'));
                 }
                 // Check for class/interface component patterns
-                if (ts.isClassDeclaration(declaration) || ts.isInterfaceDeclaration(declaration)) {
+                if (ts.isClassDeclaration(declaration) ||
+                    ts.isInterfaceDeclaration(declaration)) {
                     const name = declaration.name?.text ?? '';
                     return (name.includes('Component') ||
                         name.includes('Element') ||
@@ -74,10 +77,10 @@ module.exports = (0, createRule_1.createRule)({
             });
             // Check if the type itself is a component or element type
             const typeString = checker.typeToString(type);
-            const isComponentType = (typeString.includes('JSX.Element') ||
+            const isComponentType = typeString.includes('JSX.Element') ||
                 typeString.includes('ReactElement') ||
                 typeString.includes('Component') ||
-                typeString.includes('FC'));
+                typeString.includes('FC');
             return isComponent || isComponentType;
         }
         function isPascalCase(str) {
@@ -161,7 +164,8 @@ module.exports = (0, createRule_1.createRule)({
                     }
                     // Skip autofixing for class parameters and getters
                     const parent = node.parent;
-                    if (parent?.type === utils_1.AST_NODE_TYPES.PropertyDefinition || parent?.type === utils_1.AST_NODE_TYPES.MethodDefinition) {
+                    if (parent?.type === utils_1.AST_NODE_TYPES.PropertyDefinition ||
+                        parent?.type === utils_1.AST_NODE_TYPES.MethodDefinition) {
                         context.report({
                             node,
                             messageId: 'callbackFunctionPrefix',
@@ -170,7 +174,7 @@ module.exports = (0, createRule_1.createRule)({
                     }
                     // Get all references to this variable
                     const scope = context.getScope();
-                    const variable = scope.variables.find(v => v.name === functionName);
+                    const variable = scope.variables.find((v) => v.name === functionName);
                     const references = new Set(variable?.references ?? []);
                     // Get references from all scopes
                     const allScopes = [scope];
@@ -182,16 +186,16 @@ module.exports = (0, createRule_1.createRule)({
                     // Get references from all scopes and their children
                     for (const s of allScopes) {
                         // Get references from current scope
-                        const currentVar = s.variables.find(v => v.name === functionName);
+                        const currentVar = s.variables.find((v) => v.name === functionName);
                         if (currentVar) {
-                            currentVar.references.forEach(ref => references.add(ref));
+                            currentVar.references.forEach((ref) => references.add(ref));
                         }
                         // Get references from child scopes
                         const childScopes = s.childScopes;
                         for (const childScope of childScopes) {
-                            const childVar = childScope.variables.find(v => v.name === functionName);
+                            const childVar = childScope.variables.find((v) => v.name === functionName);
                             if (childVar) {
-                                childVar.references.forEach(ref => references.add(ref));
+                                childVar.references.forEach((ref) => references.add(ref));
                             }
                         }
                     }
@@ -199,24 +203,24 @@ module.exports = (0, createRule_1.createRule)({
                     const siblingScopes = scope.upper?.childScopes ?? [];
                     for (const siblingScope of siblingScopes) {
                         if (siblingScope !== scope) {
-                            const siblingVar = siblingScope.variables.find(v => v.name === functionName);
+                            const siblingVar = siblingScope.variables.find((v) => v.name === functionName);
                             if (siblingVar) {
-                                siblingVar.references.forEach(ref => references.add(ref));
+                                siblingVar.references.forEach((ref) => references.add(ref));
                             }
                         }
                     }
                     // Get references from global scope
                     const sourceCode = context.getSourceCode();
                     if (sourceCode.scopeManager?.globalScope) {
-                        const globalVar = sourceCode.scopeManager.globalScope.variables.find(v => v.name === functionName);
+                        const globalVar = sourceCode.scopeManager.globalScope.variables.find((v) => v.name === functionName);
                         if (globalVar) {
-                            globalVar.references.forEach(ref => references.add(ref));
+                            globalVar.references.forEach((ref) => references.add(ref));
                         }
                     }
                     context.report({
                         node,
                         messageId: 'callbackFunctionPrefix',
-                        *fix(fixer) {
+                        fix(fixer) {
                             // Remove 'handle' prefix and convert first character to lowercase
                             const newName = functionName.slice(6).charAt(0).toLowerCase() +
                                 functionName.slice(7);
@@ -267,7 +271,7 @@ module.exports = (0, createRule_1.createRule)({
                 }
             },
             // Check constructor parameters
-            'TSParameterProperty'(node) {
+            TSParameterProperty(node) {
                 if (node.parameter.type === 'Identifier' &&
                     node.parameter.name.startsWith('handle')) {
                     context.report({

package/lib/rules/enforce-assert-throws.js

@@ -107,7 +107,7 @@ exports.enforceAssertThrows = (0, createRule_1.createRule)({
                 }
                 // Handle BlockStatement specially
                 if (node.type === utils_1.AST_NODE_TYPES.BlockStatement) {
-                    node.body.forEach(stmt => walk(stmt));
+                    node.body.forEach((stmt) => walk(stmt));
                     return;
                 }
                 // Handle IfStatement specially
@@ -122,13 +122,15 @@ exports.enforceAssertThrows = (0, createRule_1.createRule)({
                 for (const key of Object.keys(node)) {
                     const value = node[key];
                     if (Array.isArray(value)) {
-                        value.forEach(item => {
+                        value.forEach((item) => {
                             if (item && typeof item === 'object' && !('parent' in item)) {
                                 walk(item);
                             }
                         });
                     }
-                    else if (value && typeof value === 'object' && !('parent' in value)) {
+                    else if (value &&
+                        typeof value === 'object' &&
+                        !('parent' in value)) {
                         walk(value);
                     }
                 }
@@ -140,7 +142,8 @@ exports.enforceAssertThrows = (0, createRule_1.createRule)({
         function checkFunction(node) {
             let functionName = '';
             if (node.type === utils_1.AST_NODE_TYPES.MethodDefinition) {
-                functionName = node.key.type === utils_1.AST_NODE_TYPES.Identifier ? node.key.name : '';
+                functionName =
+                    node.key.type === utils_1.AST_NODE_TYPES.Identifier ? node.key.name : '';
             }
             else if (node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration && node.id) {
                 functionName = node.id.name;
@@ -156,7 +159,9 @@ exports.enforceAssertThrows = (0, createRule_1.createRule)({
             }
             if (functionName.toLowerCase().startsWith('assert')) {
                 currentFunction = node;
-                const functionBody = node.type === utils_1.AST_NODE_TYPES.MethodDefinition ? node.value.body : node.body;
+                const functionBody = node.type === utils_1.AST_NODE_TYPES.MethodDefinition
+                    ? node.value.body
+                    : node.body;
                 if (functionBody && !hasThrowStatement(functionBody)) {
                     context.report({
                         node,

package/lib/rules/enforce-boolean-naming-prefixes.d.ts

@@ -0,0 +1,7 @@
+type Options = [
+    {
+        prefixes?: string[];
+    }
+];
+export declare const enforceBooleanNamingPrefixes: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"missingBooleanPrefix", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};

package/lib/rules/enforce-boolean-naming-prefixes.js

@@ -0,0 +1,462 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceBooleanNamingPrefixes = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+// Default approved boolean prefixes
+const DEFAULT_BOOLEAN_PREFIXES = [
+    'is',
+    'has',
+    'does',
+    'can',
+    'should',
+    'will',
+    'was',
+    'had',
+    'did',
+    'would',
+    'must',
+    'allows',
+    'supports',
+    'needs',
+    'asserts',
+];
+exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
+    name: 'enforce-boolean-naming-prefixes',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce consistent naming conventions for boolean values by requiring approved prefixes',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    prefixes: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            missingBooleanPrefix: 'Boolean {{type}} "{{name}}" should start with an approved prefix: {{prefixes}}',
+        },
+    },
+    defaultOptions: [{ prefixes: DEFAULT_BOOLEAN_PREFIXES }],
+    create(context, [options]) {
+        const approvedPrefixes = options.prefixes || DEFAULT_BOOLEAN_PREFIXES;
+        /**
+         * Check if a name starts with any of the approved prefixes
+         */
+        function hasApprovedPrefix(name) {
+            return approvedPrefixes.some((prefix) => name.toLowerCase().startsWith(prefix.toLowerCase()));
+        }
+        /**
+         * Format the list of approved prefixes for error messages
+         */
+        function formatPrefixes() {
+            return approvedPrefixes.join(', ');
+        }
+        /**
+         * Check if a node is a TypeScript type predicate
+         */
+        function isTypePredicate(node) {
+            if (node.parent?.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation &&
+                node.parent.parent?.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.parent.parent.parent?.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) {
+                const typeAnnotation = node.parent;
+                return (typeAnnotation.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypePredicate);
+            }
+            return false;
+        }
+        /**
+         * Check if a node has a boolean type annotation
+         */
+        function hasBooleanTypeAnnotation(node) {
+            if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
+                // Check for explicit boolean type annotation
+                if (node.typeAnnotation?.typeAnnotation.type ===
+                    utils_1.AST_NODE_TYPES.TSBooleanKeyword) {
+                    return true;
+                }
+                // Check if it's a parameter in a function with a boolean type
+                if (node.parent?.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+                    node.parent?.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+                    node.parent?.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                    if (node.typeAnnotation?.typeAnnotation &&
+                        node.typeAnnotation.typeAnnotation.type ===
+                            utils_1.AST_NODE_TYPES.TSBooleanKeyword) {
+                        return true;
+                    }
+                }
+            }
+            // Check for property signature with boolean type
+            if (node.type === utils_1.AST_NODE_TYPES.TSPropertySignature &&
+                node.typeAnnotation?.typeAnnotation.type ===
+                    utils_1.AST_NODE_TYPES.TSBooleanKeyword) {
+                return true;
+            }
+            return false;
+        }
+        /**
+         * Check if a node is initialized with a boolean value
+         */
+        function hasInitialBooleanValue(node) {
+            if (node.type === utils_1.AST_NODE_TYPES.VariableDeclarator && node.init) {
+                // Check for direct boolean literal initialization
+                if (node.init.type === utils_1.AST_NODE_TYPES.Literal &&
+                    typeof node.init.value === 'boolean') {
+                    return true;
+                }
+                // Check for logical expressions that typically return boolean
+                if (node.init.type === utils_1.AST_NODE_TYPES.BinaryExpression &&
+                    ['===', '!==', '==', '!=', '>', '<', '>=', '<='].includes(node.init.operator)) {
+                    return true;
+                }
+                // Check for logical expressions (&&, ||)
+                if (node.init.type === utils_1.AST_NODE_TYPES.LogicalExpression &&
+                    ['&&', '||'].includes(node.init.operator)) {
+                    return true;
+                }
+                // Check for unary expressions with ! operator
+                if (node.init.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
+                    node.init.operator === '!') {
+                    return true;
+                }
+                // Check for function calls that might return boolean
+                if (node.init.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                    node.init.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    const calleeName = node.init.callee.name;
+                    // Check if the function name suggests it returns a boolean
+                    return approvedPrefixes.some((prefix) => calleeName.toLowerCase().startsWith(prefix.toLowerCase()));
+                }
+            }
+            return false;
+        }
+        /**
+         * Check if a function returns a boolean value
+         */
+        function returnsBooleanValue(node) {
+            // Check for explicit boolean return type annotation
+            if (node.returnType?.typeAnnotation &&
+                node.returnType.typeAnnotation.type ===
+                    utils_1.AST_NODE_TYPES.TSBooleanKeyword) {
+                return true;
+            }
+            // For arrow functions with expression bodies, check if the expression is boolean-like
+            if (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+                node.expression &&
+                node.body) {
+                if (node.body.type === utils_1.AST_NODE_TYPES.Literal &&
+                    typeof node.body.value === 'boolean') {
+                    return true;
+                }
+                if (node.body.type === utils_1.AST_NODE_TYPES.BinaryExpression &&
+                    ['===', '!==', '==', '!=', '>', '<', '>=', '<='].includes(node.body.operator)) {
+                    return true;
+                }
+                if (node.body.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
+                    node.body.operator === '!') {
+                    return true;
+                }
+            }
+            // Check for arrow function with boolean return type
+            if (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                const variableDeclarator = node.parent;
+                if (variableDeclarator?.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                    variableDeclarator.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    // Check if the arrow function has a boolean return type annotation
+                    if (node.returnType?.typeAnnotation &&
+                        node.returnType.typeAnnotation.type ===
+                            utils_1.AST_NODE_TYPES.TSBooleanKeyword) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+        /**
+         * Check variable declarations for boolean naming
+         */
+        function checkVariableDeclaration(node) {
+            if (node.id.type !== utils_1.AST_NODE_TYPES.Identifier)
+                return;
+            const variableName = node.id.name;
+            // Skip checking if it's a type predicate
+            if (isTypePredicate(node.id))
+                return;
+            // Check if it's a boolean variable
+            let isBooleanVar = hasBooleanTypeAnnotation(node.id) || hasInitialBooleanValue(node);
+            // Check if it's an arrow function with boolean return type
+            if (node.init?.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+                node.init.returnType?.typeAnnotation &&
+                node.init.returnType.typeAnnotation.type ===
+                    utils_1.AST_NODE_TYPES.TSBooleanKeyword) {
+                isBooleanVar = true;
+            }
+            if (isBooleanVar && !hasApprovedPrefix(variableName)) {
+                context.report({
+                    node: node.id,
+                    messageId: 'missingBooleanPrefix',
+                    data: {
+                        type: 'variable',
+                        name: variableName,
+                        prefixes: formatPrefixes(),
+                    },
+                });
+            }
+        }
+        /**
+         * Check function declarations for boolean return values
+         */
+        function checkFunctionDeclaration(node) {
+            // Skip anonymous functions
+            if (!node.id && node.parent?.type !== utils_1.AST_NODE_TYPES.VariableDeclarator) {
+                return;
+            }
+            // Get function name
+            let functionName = '';
+            if (node.id) {
+                functionName = node.id.name;
+            }
+            else if (node.parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                node.parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+                functionName = node.parent.id.name;
+            }
+            else if (node.parent?.type === utils_1.AST_NODE_TYPES.Property &&
+                node.parent.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                functionName = node.parent.key.name;
+            }
+            else if (node.parent?.type === utils_1.AST_NODE_TYPES.MethodDefinition &&
+                node.parent.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                functionName = node.parent.key.name;
+            }
+            if (!functionName)
+                return;
+            // Skip checking if it's a type predicate (these are allowed to use 'is' prefix regardless)
+            if (node.returnType?.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypePredicate) {
+                return;
+            }
+            // Check if it returns a boolean
+            if (returnsBooleanValue(node) && !hasApprovedPrefix(functionName)) {
+                context.report({
+                    node: node.id || node,
+                    messageId: 'missingBooleanPrefix',
+                    data: {
+                        type: 'function',
+                        name: functionName,
+                        prefixes: formatPrefixes(),
+                    },
+                });
+            }
+        }
+        /**
+         * Check method definitions for boolean return values
+         */
+        function checkMethodDefinition(node) {
+            if (node.key.type !== utils_1.AST_NODE_TYPES.Identifier)
+                return;
+            const methodName = node.key.name;
+            // Skip checking if it's a type predicate
+            if (node.value.returnType?.typeAnnotation &&
+                node.value.returnType.typeAnnotation.type ===
+                    utils_1.AST_NODE_TYPES.TSTypePredicate) {
+                return;
+            }
+            // Check if it returns a boolean
+            if (node.value.returnType?.typeAnnotation &&
+                node.value.returnType.typeAnnotation.type ===
+                    utils_1.AST_NODE_TYPES.TSBooleanKeyword &&
+                !hasApprovedPrefix(methodName)) {
+                context.report({
+                    node: node.key,
+                    messageId: 'missingBooleanPrefix',
+                    data: {
+                        type: 'method',
+                        name: methodName,
+                        prefixes: formatPrefixes(),
+                    },
+                });
+            }
+        }
+        /**
+         * Check class property definitions for boolean values
+         */
+        function checkClassProperty(node) {
+            if (node.key.type !== utils_1.AST_NODE_TYPES.Identifier)
+                return;
+            const propertyName = node.key.name;
+            // Check if it's a boolean property
+            let isBooleanProperty = false;
+            // Check if it has a boolean type annotation
+            if (node.typeAnnotation?.typeAnnotation &&
+                node.typeAnnotation.typeAnnotation.type ===
+                    utils_1.AST_NODE_TYPES.TSBooleanKeyword) {
+                isBooleanProperty = true;
+            }
+            // Check if it's initialized with a boolean value
+            if (node.value?.type === utils_1.AST_NODE_TYPES.Literal &&
+                typeof node.value.value === 'boolean') {
+                isBooleanProperty = true;
+            }
+            if (isBooleanProperty && !hasApprovedPrefix(propertyName)) {
+                context.report({
+                    node: node.key,
+                    messageId: 'missingBooleanPrefix',
+                    data: {
+                        type: 'property',
+                        name: propertyName,
+                        prefixes: formatPrefixes(),
+                    },
+                });
+            }
+        }
+        /**
+         * Check class property declarations for boolean values
+         */
+        function checkClassPropertyDeclaration(node) {
+            if (node.key.type !== utils_1.AST_NODE_TYPES.Identifier)
+                return;
+            const propertyName = node.key.name;
+            // Check if it's a boolean property
+            let isBooleanProperty = false;
+            // Check if it has a boolean type annotation
+            if (node.typeAnnotation?.typeAnnotation &&
+                node.typeAnnotation.typeAnnotation.type ===
+                    utils_1.AST_NODE_TYPES.TSBooleanKeyword) {
+                isBooleanProperty = true;
+            }
+            // Check if it's initialized with a boolean value
+            if (node.value?.type === utils_1.AST_NODE_TYPES.Literal &&
+                typeof node.value.value === 'boolean') {
+                isBooleanProperty = true;
+            }
+            if (isBooleanProperty && !hasApprovedPrefix(propertyName)) {
+                context.report({
+                    node: node.key,
+                    messageId: 'missingBooleanPrefix',
+                    data: {
+                        type: 'property',
+                        name: propertyName,
+                        prefixes: formatPrefixes(),
+                    },
+                });
+            }
+        }
+        /**
+         * Check property definitions for boolean values
+         */
+        function checkProperty(node) {
+            if (node.key.type !== utils_1.AST_NODE_TYPES.Identifier)
+                return;
+            const propertyName = node.key.name;
+            // Check if it's a boolean property
+            let isBooleanProperty = false;
+            // Check if it's initialized with a boolean value
+            if (node.value.type === utils_1.AST_NODE_TYPES.Literal &&
+                typeof node.value.value === 'boolean') {
+                isBooleanProperty = true;
+            }
+            // Check if it's a method that returns a boolean
+            if ((node.value.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+                node.value.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) &&
+                node.value.returnType?.typeAnnotation.type ===
+                    utils_1.AST_NODE_TYPES.TSBooleanKeyword) {
+                isBooleanProperty = true;
+            }
+            if (isBooleanProperty && !hasApprovedPrefix(propertyName)) {
+                context.report({
+                    node: node.key,
+                    messageId: 'missingBooleanPrefix',
+                    data: {
+                        type: 'property',
+                        name: propertyName,
+                        prefixes: formatPrefixes(),
+                    },
+                });
+            }
+        }
+        /**
+         * Check property signatures in interfaces/types for boolean types
+         */
+        function checkPropertySignature(node) {
+            if (node.key.type !== utils_1.AST_NODE_TYPES.Identifier)
+                return;
+            const propertyName = node.key.name;
+            // Check if it has a boolean type
+            if (node.typeAnnotation?.typeAnnotation &&
+                node.typeAnnotation.typeAnnotation.type ===
+                    utils_1.AST_NODE_TYPES.TSBooleanKeyword &&
+                !hasApprovedPrefix(propertyName)) {
+                context.report({
+                    node: node.key,
+                    messageId: 'missingBooleanPrefix',
+                    data: {
+                        type: 'property',
+                        name: propertyName,
+                        prefixes: formatPrefixes(),
+                    },
+                });
+            }
+        }
+        /**
+         * Check parameters for boolean types
+         */
+        function checkParameter(node) {
+            if (node.type !== utils_1.AST_NODE_TYPES.Identifier)
+                return;
+            const paramName = node.name;
+            // Check if it has a boolean type annotation
+            if (node.typeAnnotation?.typeAnnotation &&
+                node.typeAnnotation.typeAnnotation.type ===
+                    utils_1.AST_NODE_TYPES.TSBooleanKeyword &&
+                !hasApprovedPrefix(paramName)) {
+                context.report({
+                    node,
+                    messageId: 'missingBooleanPrefix',
+                    data: {
+                        type: 'parameter',
+                        name: paramName,
+                        prefixes: formatPrefixes(),
+                    },
+                });
+            }
+        }
+        return {
+            VariableDeclarator: checkVariableDeclaration,
+            FunctionDeclaration: checkFunctionDeclaration,
+            FunctionExpression(node) {
+                if (node.parent?.type !== utils_1.AST_NODE_TYPES.VariableDeclarator) {
+                    checkFunctionDeclaration(node);
+                }
+            },
+            ArrowFunctionExpression(node) {
+                if (node.parent?.type !== utils_1.AST_NODE_TYPES.VariableDeclarator) {
+                    checkFunctionDeclaration(node);
+                }
+            },
+            MethodDefinition: checkMethodDefinition,
+            Property: checkProperty,
+            ClassProperty: checkClassProperty,
+            PropertyDefinition: checkClassPropertyDeclaration,
+            TSPropertySignature: checkPropertySignature,
+            Identifier(node) {
+                // Check parameter names in function declarations
+                if (node.parent &&
+                    (node.parent.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+                        node.parent.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+                        node.parent.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) &&
+                    node.parent.params.includes(node)) {
+                    checkParameter(node);
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-boolean-naming-prefixes.js.map

package/lib/rules/enforce-callable-types.d.ts

@@ -1,3 +1,3 @@
-type MessageIds = 'missingParamsType' | 'missingResponseType' | 'unusedParamsType' | 'unusedResponseType';
+type MessageIds = 'missingPropsType' | 'missingResponseType' | 'unusedPropsType' | 'unusedResponseType';
 export declare const enforceCallableTypes: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
 export {};