@blumintinc/eslint-plugin-blumint 1.4.0 → 1.5.1

package/lib/rules/require-hooks-default-params.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireHooksDefaultParams = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
+    name: 'require-hooks-default-params',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce React hooks with optional parameters to default to an empty object',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            requireDefaultParams: 'React hooks with all optional parameters should default to an empty object',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        function isHookName(name) {
+            return name.startsWith('use') && name[3]?.toUpperCase() === name[3];
+        }
+        function hasAllOptionalProperties(typeNode) {
+            // Handle type literals directly
+            if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
+                return typeNode.members.every(member => {
+                    if (member.type !== utils_1.AST_NODE_TYPES.TSPropertySignature) {
+                        return false;
+                    }
+                    return member.optional === true;
+                });
+            }
+            // Handle type references
+            if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
+                const typeName = typeNode.typeName;
+                if (typeName.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                    return false;
+                }
+                const scope = context.getScope();
+                const variable = scope.variables.find(v => v.name === typeName.name);
+                if (!variable || !variable.defs[0]?.node) {
+                    // If we can't find the type definition, assume it's a type with all optional properties
+                    // This handles cases where the type is imported from another module
+                    return true;
+                }
+                const def = variable.defs[0].node;
+                if (def.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+                    return hasAllOptionalProperties(def.typeAnnotation);
+                }
+                else if (def.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
+                    return def.body.body.every(member => {
+                        if (member.type !== utils_1.AST_NODE_TYPES.TSPropertySignature) {
+                            return false;
+                        }
+                        return member.optional === true;
+                    });
+                }
+                // If we found the type definition but it's not a type alias or interface declaration,
+                // assume it's a type with all optional properties
+                // This handles cases where the type is imported from another module
+                return true;
+            }
+            // Handle type alias declarations
+            if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+                return hasAllOptionalProperties(typeNode.typeAnnotation);
+            }
+            // Handle interface declarations
+            if (typeNode.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
+                return typeNode.body.body.every(member => {
+                    if (member.type !== utils_1.AST_NODE_TYPES.TSPropertySignature) {
+                        return false;
+                    }
+                    return member.optional === true;
+                });
+            }
+            return false;
+        }
+        function checkHookParam(param) {
+            // If it's already an assignment pattern, check if the left side is an object pattern
+            if (param.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
+                if (param.left.type === utils_1.AST_NODE_TYPES.ObjectPattern && param.left.typeAnnotation) {
+                    if (hasAllOptionalProperties(param.left.typeAnnotation.typeAnnotation)) {
+                        return; // Already has a default value and is correctly typed
+                    }
+                }
+                return;
+            }
+            // If it's an object pattern, check if it needs a default value
+            if (param.type === utils_1.AST_NODE_TYPES.ObjectPattern && param.typeAnnotation) {
+                const typeAnnotation = param.typeAnnotation.typeAnnotation;
+                if (typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
+                    const typeName = typeAnnotation.typeName;
+                    if (typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        const scope = context.getScope();
+                        const variable = scope.variables.find(v => v.name === typeName.name);
+                        if (!variable || !variable.defs[0]?.node) {
+                            // If we can't find the type definition, assume it's a type with all optional properties
+                            // This handles cases where the type is imported from another module
+                            context.report({
+                                node: param,
+                                messageId: 'requireDefaultParams',
+                                fix(fixer) {
+                                    const paramText = context.getSourceCode().getText(param);
+                                    return fixer.replaceText(param, `${paramText} = {}`);
+                                },
+                            });
+                            return;
+                        }
+                        const def = variable.defs[0].node;
+                        if (def.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+                            if (hasAllOptionalProperties(def.typeAnnotation)) {
+                                context.report({
+                                    node: param,
+                                    messageId: 'requireDefaultParams',
+                                    fix(fixer) {
+                                        const paramText = context.getSourceCode().getText(param);
+                                        return fixer.replaceText(param, `${paramText} = {}`);
+                                    },
+                                });
+                            }
+                        }
+                        else if (def.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
+                            if (def.body.body.every(member => {
+                                if (member.type !== utils_1.AST_NODE_TYPES.TSPropertySignature) {
+                                    return false;
+                                }
+                                return member.optional === true;
+                            })) {
+                                context.report({
+                                    node: param,
+                                    messageId: 'requireDefaultParams',
+                                    fix(fixer) {
+                                        const paramText = context.getSourceCode().getText(param);
+                                        return fixer.replaceText(param, `${paramText} = {}`);
+                                    },
+                                });
+                            }
+                        }
+                        else {
+                            // If we found the type definition but it's not a type alias or interface declaration,
+                            // assume it's a type with all optional properties
+                            // This handles cases where the type is imported from another module
+                            context.report({
+                                node: param,
+                                messageId: 'requireDefaultParams',
+                                fix(fixer) {
+                                    const paramText = context.getSourceCode().getText(param);
+                                    return fixer.replaceText(param, `${paramText} = {}`);
+                                },
+                            });
+                        }
+                    }
+                }
+                else if (hasAllOptionalProperties(typeAnnotation)) {
+                    context.report({
+                        node: param,
+                        messageId: 'requireDefaultParams',
+                        fix(fixer) {
+                            const paramText = context.getSourceCode().getText(param);
+                            return fixer.replaceText(param, `${paramText} = {}`);
+                        },
+                    });
+                }
+            }
+        }
+        return {
+            FunctionDeclaration(node) {
+                if (!node.id || !isHookName(node.id.name)) {
+                    return;
+                }
+                if (node.params.length !== 1) {
+                    return;
+                }
+                checkHookParam(node.params[0]);
+            },
+            ArrowFunctionExpression(node) {
+                const parent = node.parent;
+                if (!parent ||
+                    parent.type !== utils_1.AST_NODE_TYPES.VariableDeclarator ||
+                    !parent.id ||
+                    parent.id.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                    !isHookName(parent.id.name)) {
+                    return;
+                }
+                if (node.params.length !== 1) {
+                    return;
+                }
+                checkHookParam(node.params[0]);
+            },
+        };
+    },
+});
+//# sourceMappingURL=require-hooks-default-params.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.1",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",