@blumintinc/eslint-plugin-blumint 1.5.2 → 1.5.4

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.2',
+        version: '1.5.4',
     },
     parseOptions: {
         ecmaVersion: 2020,

package/lib/rules/enforce-exported-function-types.js

@@ -137,15 +137,16 @@ exports.enforceExportedFunctionTypes = (0, createRule_1.createRule)({
         function isTypeExported(typeName) {
             const sourceCode = context.getSourceCode();
             const program = sourceCode.ast;
-            // Check for imported types
-            const importedTypes = program.body.filter((node) => {
+            // Check for imported types first - if found, return true immediately
+            // since imported types are already available to consumers
+            const hasImportedType = program.body.some((node) => {
                 if (node.type === utils_1.AST_NODE_TYPES.ImportDeclaration) {
                     return node.specifiers.some((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
                         specifier.local.name === typeName);
                 }
                 return false;
             });
-            if (importedTypes.length > 0) {
+            if (hasImportedType) {
                 return true;
             }
             // Check for exported type declarations

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

@@ -4581,22 +4581,83 @@ exports.enforceVerbNounNaming = (0, createRule_1.createRule)({
             }
             return isVerb;
         }
-        function isJsxReturnFunction(node) {
+        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 returns JSX
-            const sourceCode = context.getSourceCode();
-            const text = sourceCode.getText(node);
-            return text.includes('return <') || text.includes('=> <');
+            // 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 && parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    functionName = parent.id.name;
+                }
+            }
+            // 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) {
                 if (!node.id)
                     return;
-                if (isJsxReturnFunction(node)) {
+                if (isReactComponent(node)) {
                     return;
                 }
                 if (!isVerbPhrase(node.id.name)) {
@@ -4612,7 +4673,7 @@ exports.enforceVerbNounNaming = (0, createRule_1.createRule)({
                 // Only check if it's a function
                 if (node.init?.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
                     node.init?.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
-                    if (isJsxReturnFunction(node.init)) {
+                    if (isReactComponent(node.init)) {
                         return;
                     }
                     if (!isVerbPhrase(node.id.name)) {

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

@@ -89,6 +89,18 @@ function getObjectUsagesInHook(hookBody, objectName) {
                 }
             });
         }
+        else if (node.type === utils_1.AST_NODE_TYPES.JSXElement || node.type === utils_1.AST_NODE_TYPES.JSXFragment) {
+            // If we find a JSX element, check its attributes for spread operator
+            if (node.type === utils_1.AST_NODE_TYPES.JSXElement) {
+                node.openingElement.attributes.forEach((attr) => {
+                    if (attr.type === utils_1.AST_NODE_TYPES.JSXSpreadAttribute &&
+                        attr.argument.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        attr.argument.name === objectName) {
+                        needsEntireObject = true;
+                    }
+                });
+            }
+        }
         else if (node.type === utils_1.AST_NODE_TYPES.SpreadElement) {
             // If we find a spread operator with our target object, consider it as accessing all properties
             if (node.argument.type === utils_1.AST_NODE_TYPES.Identifier &&

package/lib/rules/prefer-settings-object.js

@@ -48,6 +48,9 @@ exports.preferSettingsObject = (0, createRule_1.createRule)({
     create(context, [options]) {
         const finalOptions = { ...defaultOptions, ...options };
         function getParameterType(param) {
+            if (param.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
+                return getParameterType(param.left);
+            }
             if (param.type === utils_1.AST_NODE_TYPES.Identifier && param.typeAnnotation) {
                 const typeNode = param.typeAnnotation.typeAnnotation;
                 if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
@@ -55,6 +58,12 @@ exports.preferSettingsObject = (0, createRule_1.createRule)({
                         ? typeNode.typeName.name
                         : 'unknown';
                 }
+                if (typeNode.type === utils_1.AST_NODE_TYPES.TSStringKeyword)
+                    return 'string';
+                if (typeNode.type === utils_1.AST_NODE_TYPES.TSNumberKeyword)
+                    return 'number';
+                if (typeNode.type === utils_1.AST_NODE_TYPES.TSBooleanKeyword)
+                    return 'boolean';
                 return typeNode.type;
             }
             return 'unknown';
@@ -95,7 +104,7 @@ exports.preferSettingsObject = (0, createRule_1.createRule)({
             if (shouldIgnoreNode(node))
                 return;
             const params = node.params;
-            // Check for too many parameters
+            // Check for too many parameters first
             const minParams = finalOptions.minimumParameters !== undefined
                 ? finalOptions.minimumParameters
                 : defaultOptions.minimumParameters;
@@ -107,7 +116,7 @@ exports.preferSettingsObject = (0, createRule_1.createRule)({
                 });
                 return;
             }
-            // Check for same type parameters if enabled
+            // Then check for same type parameters if enabled
             if (finalOptions.checkSameTypeParameters && params.length >= 2) {
                 if (hasSameTypeParameters(params)) {
                     context.report({

package/package.json

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