@blumintinc/eslint-plugin-blumint 1.3.2 → 1.5.0

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.3.2",
+  "version": "1.5.0",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",
@@ -71,7 +71,7 @@
     "dotenv-cli": "5.0.0",
     "eslint": "8.57.0",
     "eslint-config-prettier": "8.5.0",
-    "eslint-doc-generator": "1.0.0",
+    "eslint-doc-generator": "1.7.1",
     "eslint-import-resolver-typescript": "3.5.5",
     "eslint-plugin-eslint-plugin": "5.0.0",
     "eslint-plugin-import": "2.26.0",