@blumintinc/eslint-plugin-blumint 1.4.0 → 1.5.0

package/lib/rules/no-class-instance-destructuring.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noClassInstanceDestructuring = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.noClassInstanceDestructuring = (0, createRule_1.createRule)({
+    name: 'no-class-instance-destructuring',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow destructuring of class instances to prevent loss of `this` context',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            noClassInstanceDestructuring: 'Avoid destructuring class instances as it can lead to loss of `this` context. Use direct property access instead.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        function isClassInstance(node) {
+            // Check for new expressions
+            if (node.type === utils_1.AST_NODE_TYPES.NewExpression) {
+                return true;
+            }
+            // Check for identifiers that might be class instances
+            if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
+                const variableDef = context
+                    .getScope()
+                    .variables.find((variableDef) => variableDef.name === node.name);
+                if (variableDef?.defs[0]?.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
+                    const init = variableDef.defs[0].node
+                        .init;
+                    return init?.type === utils_1.AST_NODE_TYPES.NewExpression;
+                }
+            }
+            return false;
+        }
+        return {
+            VariableDeclarator(node) {
+                if (node.id.type === utils_1.AST_NODE_TYPES.ObjectPattern &&
+                    node.init &&
+                    isClassInstance(node.init)) {
+                    const objectPattern = node.id;
+                    context.report({
+                        node,
+                        messageId: 'noClassInstanceDestructuring',
+                        fix(fixer) {
+                            const sourceCode = context.getSourceCode();
+                            const properties = objectPattern.properties;
+                            // Skip if there's no init expression
+                            if (!node.init)
+                                return null;
+                            // For single property, use simple replacement
+                            if (properties.length === 1) {
+                                const prop = properties[0];
+                                if (prop.type === utils_1.AST_NODE_TYPES.Property) {
+                                    const key = prop.key.type === utils_1.AST_NODE_TYPES.Identifier
+                                        ? prop.key.name
+                                        : sourceCode.getText(prop.key);
+                                    const value = prop.value.type === utils_1.AST_NODE_TYPES.Identifier
+                                        ? prop.value.name
+                                        : sourceCode.getText(prop.value);
+                                    const initText = sourceCode.getText(node.init);
+                                    return fixer.replaceText(node, `${value} = ${initText}.${key}`);
+                                }
+                                return null;
+                            }
+                            // For multiple properties, create multiple declarations
+                            const declarations = properties
+                                .filter((prop) => prop.type === utils_1.AST_NODE_TYPES.Property)
+                                .map((prop) => {
+                                const key = prop.key.type === utils_1.AST_NODE_TYPES.Identifier
+                                    ? prop.key.name
+                                    : sourceCode.getText(prop.key);
+                                const value = prop.value.type === utils_1.AST_NODE_TYPES.Identifier
+                                    ? prop.value.name
+                                    : sourceCode.getText(prop.value);
+                                const initText = sourceCode.getText(node.init);
+                                return `${value} = ${initText}.${key}`;
+                            })
+                                .join(';\nconst ');
+                            // Only apply the fix if we have valid declarations
+                            if (!declarations)
+                                return null;
+                            return fixer.replaceText(node, declarations);
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-class-instance-destructuring.js.map

package/lib/rules/no-compositing-layer-props.js

@@ -37,7 +37,7 @@ exports.noCompositingLayerProps = (0, createRule_1.createRule)({
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Warn when using CSS properties that trigger compositing layers',
+            description: 'Warn when using CSS properties that trigger compositing layers, which can impact performance. Properties like transform, opacity, filter, and will-change create new GPU layers. While sometimes beneficial for animations, excessive layer creation can increase memory usage and hurt performance. Consider alternatives or explicitly document intentional layer promotion.',
             recommended: 'error',
         },
         schema: [],

package/lib/rules/no-conditional-literals-in-jsx.js

@@ -14,7 +14,7 @@ exports.noConditionalLiteralsInJsx = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            unexpected: 'Conditional expression is a sibling of raw text and must be wrapped in <div> or <span>',
+            unexpected: 'Conditional text literals must be wrapped in a container element when next to other text. Instead of `<div>text {condition && "more text"}</div>`, use `<div>text <span>{condition && "more text"}</span></div>` to prevent React hydration issues.',
         },
     },
     defaultOptions: [],

package/lib/rules/no-entire-object-hook-deps.js

@@ -136,7 +136,7 @@ exports.noEntireObjectHookDeps = (0, createRule_1.createRule)({
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Avoid using entire objects in React hook dependency arrays when only specific fields are used. Requires TypeScript and `parserOptions.project` to be configured.',
+            description: 'Avoid using entire objects in React hook dependency arrays when only specific fields are used, as this can cause unnecessary re-renders. When a hook only uses obj.name but obj is in the deps array, any change to obj.age will trigger the hook. Use individual fields (obj.name) instead of the entire object. Requires TypeScript and `parserOptions.project` to be configured.',
             recommended: 'error',
             requiresTypeChecking: true,
         },

package/lib/rules/no-explicit-return-type.d.ts

@@ -6,6 +6,7 @@ type Options = [
         allowInterfaceMethodSignatures?: boolean;
         allowAbstractMethodSignatures?: boolean;
         allowDtsFiles?: boolean;
+        allowFirestoreFunctionFiles?: boolean;
     }
 ];
 export declare const noExplicitReturnType: TSESLint.RuleModule<'noExplicitReturnType', Options>;

package/lib/rules/no-explicit-return-type.js

@@ -9,6 +9,7 @@ const defaultOptions = {
     allowInterfaceMethodSignatures: true,
     allowAbstractMethodSignatures: true,
     allowDtsFiles: true,
+    allowFirestoreFunctionFiles: true,
 };
 function isRecursiveFunction(node) {
     const functionName = node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration
@@ -91,7 +92,7 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Disallow explicit return types on functions',
+            description: 'Disallow explicit return type annotations on functions when TypeScript can infer them. This reduces code verbosity and maintenance burden while leveraging TypeScript\'s powerful type inference. Exceptions are made for recursive functions, overloaded functions, interface methods, and abstract methods where explicit types improve clarity.',
             recommended: 'error',
             requiresTypeChecking: false,
             extendsBaseRule: false,
@@ -106,6 +107,7 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
                     allowInterfaceMethodSignatures: { type: 'boolean' },
                     allowAbstractMethodSignatures: { type: 'boolean' },
                     allowDtsFiles: { type: 'boolean' },
+                    allowFirestoreFunctionFiles: { type: 'boolean' },
                 },
                 additionalProperties: false,
             },
@@ -118,7 +120,8 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
     create(context, [options]) {
         const mergedOptions = { ...defaultOptions, ...options };
         const filename = context.getFilename();
-        if (mergedOptions.allowDtsFiles && filename.endsWith('.d.ts')) {
+        if ((mergedOptions.allowDtsFiles && filename.endsWith('.d.ts')) ||
+            (mergedOptions.allowFirestoreFunctionFiles && filename.endsWith('.f.ts'))) {
             return {};
         }
         // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/lib/rules/no-filter-without-return.js

@@ -33,7 +33,7 @@ exports.noFilterWithoutReturn = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            unexpected: 'An array filter callback with a block statement must contain a return statement',
+            unexpected: 'Array.filter callbacks with block statements must contain a return statement. Instead of `array.filter(x => { doSomething(x); })`, use `array.filter(x => { doSomething(x); return someCondition; })` or use implicit return `array.filter(x => someCondition)`.',
         },
     },
     defaultOptions: [],

package/lib/rules/no-misused-switch-case.js

@@ -7,12 +7,12 @@ exports.noMisusedSwitchCase = (0, createRule_1.createRule)({
     meta: {
         type: 'problem',
         docs: {
-            description: 'Prevent misuse of logical OR in switch case statements',
+            description: 'Prevent misuse of logical OR (||) in switch case statements, which can lead to confusing and error-prone code. Instead of using OR operators in case expressions, use multiple case statements in sequence to handle multiple values. This improves code readability and follows the standard switch-case pattern.',
             recommended: 'error',
         },
         schema: [],
         messages: {
-            noMisusedSwitchCase: 'Avoid using logical OR  in switch case. Use cascading cases instead.',
+            noMisusedSwitchCase: 'Avoid using logical OR (||) in switch case statements. Instead of `case x || y:`, use cascading cases like `case x: case y:`.',
         },
     },
     defaultOptions: [],

package/lib/rules/no-redundant-param-types.d.ts

@@ -0,0 +1,2 @@
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const noRedundantParamTypes: TSESLint.RuleModule<"redundantParamType", [], TSESLint.RuleListener>;

package/lib/rules/no-redundant-param-types.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noRedundantParamTypes = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+function isIdentifierWithTypeAnnotation(node) {
+    return (node.type === utils_1.AST_NODE_TYPES.Identifier && node.typeAnnotation !== undefined);
+}
+function isRestElementWithTypeAnnotation(node) {
+    return (node.type === utils_1.AST_NODE_TYPES.RestElement &&
+        node.typeAnnotation !== undefined);
+}
+function isObjectPatternWithTypeAnnotation(node) {
+    return (node.type === utils_1.AST_NODE_TYPES.ObjectPattern &&
+        node.typeAnnotation !== undefined);
+}
+function isArrayPatternWithTypeAnnotation(node) {
+    return (node.type === utils_1.AST_NODE_TYPES.ArrayPattern &&
+        node.typeAnnotation !== undefined);
+}
+function isAssignmentPatternWithTypeAnnotation(node) {
+    return (node.type === utils_1.AST_NODE_TYPES.AssignmentPattern &&
+        node.left.type === utils_1.AST_NODE_TYPES.Identifier &&
+        node.left.typeAnnotation !== undefined);
+}
+function removeTypeAnnotation(fixer, typeAnnotation, sourceCode) {
+    const typeStart = typeAnnotation.range[0];
+    const typeEnd = typeAnnotation.range[1];
+    // Check if there's a question mark before the type annotation
+    const hasQuestionMark = typeStart > 0 && sourceCode.getText().charAt(typeStart - 1) === '?';
+    const startPos = hasQuestionMark ? typeStart - 1 : typeStart;
+    return fixer.removeRange([startPos, typeEnd]);
+}
+function hasRedundantTypeAnnotation(node) {
+    const parent = node.parent;
+    if (!parent)
+        return false;
+    // Check variable declarations
+    if (parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+        parent.id.typeAnnotation?.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation) {
+        return true;
+    }
+    // Check class property assignments
+    if (parent.type === utils_1.AST_NODE_TYPES.PropertyDefinition &&
+        parent.typeAnnotation?.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation) {
+        return true;
+    }
+    // Check assignments
+    if (parent.type === utils_1.AST_NODE_TYPES.AssignmentExpression &&
+        parent.left.type === utils_1.AST_NODE_TYPES.Identifier &&
+        parent.left.typeAnnotation?.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation) {
+        return true;
+    }
+    return false;
+}
+exports.noRedundantParamTypes = (0, createRule_1.createRule)({
+    name: 'no-redundant-param-types',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow redundant parameter type annotations',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            redundantParamType: 'Parameter type annotation is redundant',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            ArrowFunctionExpression(node) {
+                if (!hasRedundantTypeAnnotation(node))
+                    return;
+                const params = node.params;
+                params.forEach((param) => {
+                    if (isIdentifierWithTypeAnnotation(param)) {
+                        context.report({
+                            node: param,
+                            messageId: 'redundantParamType',
+                            fix(fixer) {
+                                return removeTypeAnnotation(fixer, param.typeAnnotation, context.getSourceCode());
+                            },
+                        });
+                    }
+                    else if (isRestElementWithTypeAnnotation(param)) {
+                        context.report({
+                            node: param,
+                            messageId: 'redundantParamType',
+                            fix(fixer) {
+                                return removeTypeAnnotation(fixer, param.typeAnnotation, context.getSourceCode());
+                            },
+                        });
+                    }
+                    else if (isObjectPatternWithTypeAnnotation(param)) {
+                        context.report({
+                            node: param,
+                            messageId: 'redundantParamType',
+                            fix(fixer) {
+                                return removeTypeAnnotation(fixer, param.typeAnnotation, context.getSourceCode());
+                            },
+                        });
+                    }
+                    else if (isArrayPatternWithTypeAnnotation(param)) {
+                        context.report({
+                            node: param,
+                            messageId: 'redundantParamType',
+                            fix(fixer) {
+                                return removeTypeAnnotation(fixer, param.typeAnnotation, context.getSourceCode());
+                            },
+                        });
+                    }
+                    else if (isAssignmentPatternWithTypeAnnotation(param)) {
+                        const { left } = param;
+                        context.report({
+                            node: param,
+                            messageId: 'redundantParamType',
+                            fix(fixer) {
+                                return removeTypeAnnotation(fixer, left.typeAnnotation, context.getSourceCode());
+                            },
+                        });
+                    }
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-redundant-param-types.js.map

package/lib/rules/no-unused-props.js

@@ -13,7 +13,7 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            unusedProp: 'Prop "{{propName}}" is defined in type but not used in component',
+            unusedProp: 'Prop "{{propName}}" is defined in the Props type but not used in the component. Either use the prop in your component or remove it from the Props type. If you need to forward all props, use a rest spread operator: `const MyComponent = ({ usedProp, ...rest }: Props) => ...`',
         },
         fixable: 'code',
     },

package/lib/rules/no-useless-fragment.js

@@ -38,7 +38,7 @@ exports.noUselessFragment = {
             recommended: 'error',
         },
         messages: {
-            noUselessFragment: 'React fragment is unnecessary when wrapping a single child',
+            noUselessFragment: 'React fragment is unnecessary when wrapping a single child. Instead of `<>{"text"}</> or <Fragment>{"text"}</Fragment>`, use just `{"text"}`. Fragments are only needed when returning multiple elements.',
         },
         schema: [],
         fixable: 'code',

package/lib/rules/prefer-destructuring-no-class.d.ts

@@ -0,0 +1,8 @@
+type Options = [
+    {
+        object?: boolean;
+        enforceForRenamedProperties?: boolean;
+    }
+];
+export declare const preferDestructuringNoClass: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"preferDestructuring", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};

package/lib/rules/prefer-destructuring-no-class.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferDestructuringNoClass = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const defaultOptions = [
+    {
+        object: true,
+        enforceForRenamedProperties: false,
+    },
+];
+function isClassInstance(node, context) {
+    // Check if node is a MemberExpression
+    if (node.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+        const object = node.object;
+        // If object is a NewExpression, it's a class instance
+        if (object.type === utils_1.AST_NODE_TYPES.NewExpression) {
+            return true;
+        }
+        // If object is an identifier, check if it refers to a class instance
+        if (object.type === utils_1.AST_NODE_TYPES.Identifier) {
+            const variable = object.name;
+            const scope = context.getScope();
+            const ref = scope.references.find((ref) => ref.identifier.name === variable);
+            if (ref?.resolved?.defs[0]?.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
+                const init = ref.resolved.defs[0].node.init;
+                return init?.type === utils_1.AST_NODE_TYPES.NewExpression;
+            }
+            // Check if the identifier refers to a class (not an instance)
+            if (ref?.resolved?.defs[0]?.node.type === utils_1.AST_NODE_TYPES.ClassDeclaration) {
+                return false;
+            }
+        }
+        // Recursively check if parent object is a class instance
+        if (object.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+            return isClassInstance(object, context);
+        }
+    }
+    return false;
+}
+function isStaticClassMember(node, context) {
+    if (node.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+        const object = node.object;
+        if (object.type === utils_1.AST_NODE_TYPES.Identifier) {
+            const variable = object.name;
+            const scope = context.getScope();
+            const ref = scope.references.find((ref) => ref.identifier.name === variable);
+            return (ref?.resolved?.defs[0]?.node.type === utils_1.AST_NODE_TYPES.ClassDeclaration);
+        }
+    }
+    return false;
+}
+/**
+ * Check if the property name matches the variable name in an assignment
+ */
+function isMatchingPropertyName(propertyNode, variableName) {
+    if (propertyNode.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return propertyNode.name === variableName;
+    }
+    if (propertyNode.type === utils_1.AST_NODE_TYPES.Literal) {
+        return propertyNode.value === variableName;
+    }
+    return false;
+}
+/**
+ * Get the property text for destructuring
+ */
+function getPropertyText(property, computed, sourceCode) {
+    if (computed) {
+        return sourceCode.getText(property);
+    }
+    if (property.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return property.name;
+    }
+    if (property.type === utils_1.AST_NODE_TYPES.Literal) {
+        return String(property.value);
+    }
+    // For any other type, use the source text
+    return sourceCode.getText(property);
+}
+exports.preferDestructuringNoClass = (0, createRule_1.createRule)({
+    name: 'prefer-destructuring-no-class',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce destructuring when accessing object properties, except for class instances',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    object: {
+                        type: 'boolean',
+                        default: true,
+                    },
+                    enforceForRenamedProperties: {
+                        type: 'boolean',
+                        default: false,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            preferDestructuring: 'Use destructuring instead of accessing the property directly.',
+        },
+    },
+    defaultOptions,
+    create(context) {
+        const options = {
+            object: defaultOptions[0].object,
+            enforceForRenamedProperties: defaultOptions[0].enforceForRenamedProperties,
+            ...context.options[0],
+        };
+        /**
+         * Check if destructuring should be used for this node
+         */
+        function shouldUseDestructuring(node, leftNode) {
+            // Skip if this is a class instance or static class member
+            if (isClassInstance(node, context) ||
+                isStaticClassMember(node, context)) {
+                return false;
+            }
+            // Check object destructuring
+            if (options.object) {
+                if (options.enforceForRenamedProperties) {
+                    return true;
+                }
+                // Only suggest destructuring when property name matches variable name
+                if (leftNode.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    return isMatchingPropertyName(node.property, leftNode.name);
+                }
+            }
+            return false;
+        }
+        return {
+            VariableDeclarator(node) {
+                // Skip if variable is declared without assignment or if init is not a MemberExpression
+                if (!node.init)
+                    return;
+                if (node.init.type !== utils_1.AST_NODE_TYPES.MemberExpression)
+                    return;
+                if (shouldUseDestructuring(node.init, node.id)) {
+                    const sourceCode = context.getSourceCode();
+                    const objectText = sourceCode.getText(node.init.object);
+                    const propertyText = getPropertyText(node.init.property, node.init.computed, sourceCode);
+                    context.report({
+                        node,
+                        messageId: 'preferDestructuring',
+                        fix(fixer) {
+                            // Get the variable declaration kind (const, let, var)
+                            const parentNode = node.parent;
+                            if (!parentNode ||
+                                parentNode.type !== utils_1.AST_NODE_TYPES.VariableDeclaration) {
+                                return null;
+                            }
+                            const kind = parentNode.kind;
+                            // Handle renamed properties
+                            if (options.enforceForRenamedProperties &&
+                                node.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                node.init &&
+                                node.init.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                                !isMatchingPropertyName(node.init.property, node.id.name)) {
+                                return fixer.replaceText(parentNode, `${kind} { ${propertyText}: ${node.id.name} } = ${objectText};`);
+                            }
+                            return fixer.replaceText(parentNode, `${kind} { ${propertyText} } = ${objectText};`);
+                        },
+                    });
+                }
+            },
+            AssignmentExpression(node) {
+                if (node.operator === '=' &&
+                    node.right.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                    if (shouldUseDestructuring(node.right, node.left)) {
+                        const sourceCode = context.getSourceCode();
+                        const objectText = sourceCode.getText(node.right.object);
+                        const propertyText = getPropertyText(node.right.property, node.right.computed, sourceCode);
+                        context.report({
+                            node,
+                            messageId: 'preferDestructuring',
+                            fix(fixer) {
+                                // Handle renamed properties
+                                if (options.enforceForRenamedProperties &&
+                                    node.left.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                    node.right.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                                    !isMatchingPropertyName(node.right.property, node.left.name)) {
+                                    return fixer.replaceText(node, `({ ${propertyText}: ${node.left.name} } = ${objectText})`);
+                                }
+                                return fixer.replaceText(node, `({ ${propertyText} } = ${objectText})`);
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=prefer-destructuring-no-class.js.map

package/lib/rules/require-usememo-object-literals.js

@@ -7,7 +7,7 @@ exports.requireUseMemoObjectLiterals = (0, createRule_1.createRule)({
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Enforce using useMemo for inline object literals passed as props to JSX components',
+            description: 'Enforce using useMemo for inline object/array literals passed as props to JSX components to prevent unnecessary re-renders. When object/array literals are defined inline in JSX, they create new references on every render, causing child components to re-render even if the values haven\'t changed. Wrap them in useMemo to maintain referential equality.',
             recommended: 'error',
         },
         messages: {

package/lib/rules/semantic-function-prefixes.js

@@ -27,6 +27,40 @@ exports.semanticFunctionPrefixes = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
+        function checkMethodName(node) {
+            // Skip getters and setters
+            if (node.kind === 'get' || node.kind === 'set') {
+                return;
+            }
+            const methodName = node.key.type === utils_1.AST_NODE_TYPES.Identifier ? node.key.name : '';
+            if (!methodName)
+                return;
+            // Skip if method starts with 'is' (boolean check methods are okay)
+            if (methodName.startsWith('is'))
+                return;
+            // Extract first word from PascalCase/camelCase
+            let firstWord = methodName;
+            for (let i = 1; i < methodName.length; i++) {
+                if (methodName[i] >= 'A' && methodName[i] <= 'Z') {
+                    firstWord = methodName.substring(0, i);
+                    break;
+                }
+            }
+            // Check for disallowed prefixes
+            for (const prefix of DISALLOWED_PREFIXES) {
+                if (firstWord.toLowerCase() === prefix.toLowerCase()) {
+                    context.report({
+                        node: node.key,
+                        messageId: 'avoidGenericPrefix',
+                        data: {
+                            prefix,
+                            alternatives: SUGGESTED_ALTERNATIVES[prefix].join(', '),
+                        },
+                    });
+                    break;
+                }
+            }
+        }
         function checkFunctionName(node) {
             // Skip anonymous functions
             if (!node.id && node.parent?.type !== utils_1.AST_NODE_TYPES.VariableDeclarator) {
@@ -45,13 +79,17 @@ exports.semanticFunctionPrefixes = (0, createRule_1.createRule)({
             // Skip if function starts with 'is' (boolean check functions are okay)
             if (functionName.startsWith('is'))
                 return;
-            // Skip class getters
-            if (node.parent?.type === utils_1.AST_NODE_TYPES.MethodDefinition && node.parent.kind === 'get') {
-                return;
+            // Extract first word from PascalCase/camelCase
+            let firstWord = functionName;
+            for (let i = 1; i < functionName.length; i++) {
+                if (functionName[i] >= 'A' && functionName[i] <= 'Z') {
+                    firstWord = functionName.substring(0, i);
+                    break;
+                }
             }
             // Check for disallowed prefixes
             for (const prefix of DISALLOWED_PREFIXES) {
-                if (functionName.toLowerCase().startsWith(prefix.toLowerCase())) {
+                if (firstWord.toLowerCase() === prefix.toLowerCase()) {
                     context.report({
                         node: node.id || node,
                         messageId: 'avoidGenericPrefix',
@@ -68,6 +106,7 @@ exports.semanticFunctionPrefixes = (0, createRule_1.createRule)({
             FunctionDeclaration: checkFunctionName,
             FunctionExpression: checkFunctionName,
             ArrowFunctionExpression: checkFunctionName,
+            MethodDefinition: checkMethodName,
         };
     },
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",