@blumintinc/eslint-plugin-blumint 1.5.3 → 1.5.5

package/lib/index.js

@@ -59,7 +59,7 @@ const no_jsx_in_hooks_1 = require("./rules/no-jsx-in-hooks");
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.5.3',
+        version: '1.5.5',
     },
     parseOptions: {
         ecmaVersion: 2020,

package/lib/rules/enforce-verb-noun-naming.js

@@ -4581,29 +4581,77 @@ exports.enforceVerbNounNaming = (0, createRule_1.createRule)({
             }
             return isVerb;
         }
+        function isPascalCase(name) {
+            return /^[A-Z][a-zA-Z0-9]*$/.test(name);
+        }
+        function hasPropsParameter(node) {
+            if (!node.params.length)
+                return false;
+            const firstParam = node.params[0];
+            if (firstParam.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+                return true; // Destructured props
+            }
+            if (firstParam.type === utils_1.AST_NODE_TYPES.Identifier) {
+                const paramName = firstParam.name.toLowerCase();
+                return paramName === 'props';
+            }
+            return false;
+        }
+        function hasJsxReturn(node) {
+            const sourceCode = context.getSourceCode();
+            const text = sourceCode.getText(node);
+            // Check for direct JSX returns
+            if (text.includes('return <') || text.includes('=> <')) {
+                return true;
+            }
+            // Check for JSX assigned to variables then returned
+            if (text.includes('const ') && text.includes('<') && text.includes('return')) {
+                return true;
+            }
+            return false;
+        }
         function isReactComponent(node) {
             if (node.type !== utils_1.AST_NODE_TYPES.FunctionDeclaration &&
                 node.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
                 node.type !== utils_1.AST_NODE_TYPES.FunctionExpression) {
                 return false;
             }
-            // Check if function has React component type annotation
-            if (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+            // Get the function name
+            let functionName = '';
+            if (node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration && node.id) {
+                functionName = node.id.name;
+            }
+            else if (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression || node.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
                 const parent = node.parent;
-                if (parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
-                    const id = parent.id;
-                    if (id.type === utils_1.AST_NODE_TYPES.Identifier && id.typeAnnotation?.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation) {
-                        const typeText = context.getSourceCode().getText(id.typeAnnotation.typeAnnotation);
-                        if (typeText.includes('React.') || typeText.includes('FC') || typeText.includes('FunctionComponent')) {
-                            return true;
-                        }
-                    }
+                if (parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator && parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    functionName = parent.id.name;
                 }
             }
-            // Check if function returns JSX
-            const sourceCode = context.getSourceCode();
-            const text = sourceCode.getText(node);
-            return text.includes('return <') || text.includes('=> <');
+            // Check for React component indicators
+            const indicators = [
+                // 1. PascalCase naming
+                functionName && isPascalCase(functionName),
+                // 2. Props parameter
+                hasPropsParameter(node),
+                // 3. JSX return
+                hasJsxReturn(node),
+                // 4. React type annotations
+                (() => {
+                    if (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                        const parent = node.parent;
+                        if (parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
+                            const id = parent.id;
+                            if (id.type === utils_1.AST_NODE_TYPES.Identifier && id.typeAnnotation?.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation) {
+                                const typeText = context.getSourceCode().getText(id.typeAnnotation.typeAnnotation);
+                                return typeText.includes('React.') || typeText.includes('FC') || typeText.includes('FunctionComponent');
+                            }
+                        }
+                    }
+                    return false;
+                })()
+            ];
+            // Consider it a React component if it matches at least 2 indicators
+            return indicators.filter(Boolean).length >= 2;
         }
         return {
             FunctionDeclaration(node) {

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

@@ -87,12 +87,23 @@ function isInterfaceOrAbstractMethodSignature(node) {
     }
     return false;
 }
+function isTypeGuardFunction(node) {
+    if (!('returnType' in node) || !node.returnType)
+        return false;
+    const returnType = node.returnType;
+    if (returnType.type !== utils_1.AST_NODE_TYPES.TSTypeAnnotation)
+        return false;
+    const typeAnnotation = returnType.typeAnnotation;
+    if (typeAnnotation.type !== utils_1.AST_NODE_TYPES.TSTypePredicate)
+        return false;
+    return true;
+}
 exports.noExplicitReturnType = (0, createRule_1.createRule)({
     name: 'no-explicit-return-type',
     meta: {
         type: 'suggestion',
         docs: {
-            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.',
+            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 type guard functions (using the `is` keyword), recursive functions, overloaded functions, interface methods, and abstract methods where explicit types improve clarity.',
             recommended: 'error',
             requiresTypeChecking: false,
             extendsBaseRule: false,
@@ -136,8 +147,8 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
             FunctionDeclaration(node) {
                 if (!node.returnType)
                     return;
-                if (mergedOptions.allowRecursiveFunctions &&
-                    isRecursiveFunction(node)) {
+                if (isTypeGuardFunction(node) ||
+                    (mergedOptions.allowRecursiveFunctions && isRecursiveFunction(node))) {
                     return;
                 }
                 context.report({
@@ -149,8 +160,8 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
             FunctionExpression(node) {
                 if (!node.returnType)
                     return;
-                if (mergedOptions.allowRecursiveFunctions &&
-                    isRecursiveFunction(node)) {
+                if (isTypeGuardFunction(node) ||
+                    (mergedOptions.allowRecursiveFunctions && isRecursiveFunction(node))) {
                     return;
                 }
                 context.report({
@@ -162,6 +173,9 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
             ArrowFunctionExpression(node) {
                 if (!node.returnType)
                     return;
+                if (isTypeGuardFunction(node)) {
+                    return;
+                }
                 context.report({
                     node: node.returnType,
                     messageId: 'noExplicitReturnType',

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

@@ -39,9 +39,35 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                             typeNode.types.forEach(extractProps);
                         }
                         else if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
-                            // For referenced types like FormControlLabelProps, we need to track that these props should be forwarded
                             if (typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
-                                props[`...${typeNode.typeName.name}`] = typeNode.typeName;
+                                if (typeNode.typeName.name === 'Pick' && typeNode.typeParameters) {
+                                    // Handle Pick utility type
+                                    const [baseType, pickedProps] = typeNode.typeParameters.params;
+                                    if (baseType.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                                        baseType.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                        // Extract the picked properties from the union type
+                                        if (pickedProps.type === utils_1.AST_NODE_TYPES.TSUnionType) {
+                                            pickedProps.types.forEach((type) => {
+                                                if (type.type === utils_1.AST_NODE_TYPES.TSLiteralType &&
+                                                    type.literal.type === utils_1.AST_NODE_TYPES.Literal &&
+                                                    typeof type.literal.value === 'string') {
+                                                    // Add each picked property as a regular prop
+                                                    props[type.literal.value] = type.literal;
+                                                }
+                                            });
+                                        }
+                                        else if (pickedProps.type === utils_1.AST_NODE_TYPES.TSLiteralType &&
+                                            pickedProps.literal.type === utils_1.AST_NODE_TYPES.Literal &&
+                                            typeof pickedProps.literal.value === 'string') {
+                                            // Single property pick
+                                            props[pickedProps.literal.value] = pickedProps.literal;
+                                        }
+                                    }
+                                }
+                                else {
+                                    // For referenced types like FormControlLabelProps, we need to track that these props should be forwarded
+                                    props[`...${typeNode.typeName.name}`] = typeNode.typeName;
+                                }
                             }
                         }
                     }

package/package.json

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