@blumintinc/eslint-plugin-blumint 1.1.4 → 1.1.6

package/lib/index.js

@@ -34,10 +34,12 @@ const require_image_overlayed_1 = __importDefault(require("./rules/require-image
 const require_usememo_object_literals_1 = require("./rules/require-usememo-object-literals");
 const enforce_safe_stringify_1 = require("./rules/enforce-safe-stringify");
 const avoid_utils_directory_1 = require("./rules/avoid-utils-directory");
+const no_entire_object_hook_deps_1 = require("./rules/no-entire-object-hook-deps");
+const enforce_firestore_path_utils_1 = require("./rules/enforce-firestore-path-utils");
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.1.4',
+        version: '1.1.6',
     },
     parseOptions: {
         ecmaVersion: 2020,
@@ -47,6 +49,7 @@ module.exports = {
             plugins: ['@blumintinc/blumint'],
             rules: {
                 '@blumintinc/blumint/avoid-utils-directory': 'error',
+                '@blumintinc/blumint/enforce-firestore-path-utils': 'error',
                 '@blumintinc/blumint/no-jsx-whitespace-literal': 'error',
                 '@blumintinc/blumint/array-methods-this-context': 'warn',
                 '@blumintinc/blumint/class-methods-read-top-to-bottom': 'warn',
@@ -77,6 +80,7 @@ module.exports = {
                 '@blumintinc/blumint/require-image-overlayed': 'error',
                 '@blumintinc/blumint/require-usememo-object-literals': 'error',
                 '@blumintinc/blumint/enforce-safe-stringify': 'error',
+                '@blumintinc/blumint/no-entire-object-hook-deps': 'error',
             },
         },
     },
@@ -112,6 +116,8 @@ module.exports = {
         'require-usememo-object-literals': require_usememo_object_literals_1.requireUseMemoObjectLiterals,
         'enforce-safe-stringify': enforce_safe_stringify_1.enforceStableStringify,
         'avoid-utils-directory': avoid_utils_directory_1.avoidUtilsDirectory,
+        'no-entire-object-hook-deps': no_entire_object_hook_deps_1.noEntireObjectHookDeps,
+        'enforce-firestore-path-utils': enforce_firestore_path_utils_1.enforceFirestorePathUtils,
     },
 };
 //# sourceMappingURL=index.js.map

package/lib/rules/consistent-callback-naming.js

@@ -56,19 +56,31 @@ module.exports = (0, createRule_1.createRule)({
             // Check if type is a React component type
             const isComponent = symbol.declarations?.some((decl) => {
                 const declaration = decl;
-                if (ts.isClassDeclaration(declaration) ||
-                    ts.isInterfaceDeclaration(declaration)) {
+                // Check for JSX element types
+                if (ts.isTypeAliasDeclaration(declaration)) {
+                    const typeText = declaration.type.getText();
+                    return typeText.includes('JSX.Element') || typeText.includes('ReactElement');
+                }
+                // Check for class/interface component patterns
+                if (ts.isClassDeclaration(declaration) || ts.isInterfaceDeclaration(declaration)) {
                     const name = declaration.name?.text ?? '';
-                    return (
-                    // Check for common React component patterns
-                    name.includes('Component') ||
+                    return (name.includes('Component') ||
                         name.includes('Element') ||
                         name.includes('FC') ||
                         name.includes('FunctionComponent'));
                 }
                 return false;
             });
-            return isComponent || false;
+            // Check if the type itself is a component or element type
+            const typeString = checker.typeToString(type);
+            const isComponentType = (typeString.includes('JSX.Element') ||
+                typeString.includes('ReactElement') ||
+                typeString.includes('Component') ||
+                typeString.includes('FC'));
+            return isComponent || isComponentType;
+        }
+        function isPascalCase(str) {
+            return /^[A-Z][a-zA-Z0-9]*$/.test(str);
         }
         function isFunctionType(node) {
             const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
@@ -85,6 +97,38 @@ module.exports = (0, createRule_1.createRule)({
                     if (propName?.match(/^on[A-Z]/)) {
                         return;
                     }
+                    // Skip PascalCase props as they typically represent components or component-related props
+                    if (propName && isPascalCase(propName)) {
+                        return;
+                    }
+                    // Skip common non-callback props
+                    const commonNonCallbackProps = new Set([
+                        'theme',
+                        'style',
+                        'className',
+                        'ref',
+                        'key',
+                        'component',
+                        'as',
+                        'sx',
+                        'css', // Emotion css prop
+                    ]);
+                    if (propName && commonNonCallbackProps.has(propName)) {
+                        return;
+                    }
+                    // Skip props on components that commonly use function props that aren't callbacks
+                    const parentName = node.parent?.name;
+                    const componentName = parentName?.type === 'JSXIdentifier' ? parentName.name : undefined;
+                    const componentsWithFunctionProps = new Set([
+                        'ThemeProvider',
+                        'Transition',
+                        'CSSTransition',
+                        'TransitionGroup',
+                        'SwitchTransition', // React Transition Group
+                    ]);
+                    if (componentName && componentsWithFunctionProps.has(componentName)) {
+                        return;
+                    }
                     // Check if the value is a function type and not a React component
                     if (isFunctionType(node.value.expression) &&
                         propName &&

package/lib/rules/enforce-firestore-path-utils.d.ts

@@ -0,0 +1 @@
+export declare const enforceFirestorePathUtils: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"requirePathUtil", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;

package/lib/rules/enforce-firestore-path-utils.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceFirestorePathUtils = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const FIRESTORE_METHODS = new Set(['doc', 'collection']);
+exports.enforceFirestorePathUtils = (0, createRule_1.createRule)({
+    name: 'enforce-firestore-path-utils',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce usage of utility functions for Firestore paths',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            requirePathUtil: 'Use a utility function (e.g., toUserPath, toCollectionPath) for Firestore paths instead of string literals',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        function isFirestoreCall(node) {
+            if (node.callee.type !== utils_1.AST_NODE_TYPES.MemberExpression) {
+                return false;
+            }
+            const property = node.callee.property;
+            if (property.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                return false;
+            }
+            return FIRESTORE_METHODS.has(property.name);
+        }
+        function isStringLiteralOrTemplate(node) {
+            return (node.type === utils_1.AST_NODE_TYPES.Literal && typeof node.value === 'string' ||
+                node.type === utils_1.AST_NODE_TYPES.TemplateLiteral);
+        }
+        function isUtilityFunction(node) {
+            if (node.type !== utils_1.AST_NODE_TYPES.CallExpression) {
+                return false;
+            }
+            const callee = node.callee;
+            if (callee.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                return false;
+            }
+            // Match functions starting with 'to' and ending with 'Path'
+            return /^to.*Path$/.test(callee.name);
+        }
+        return {
+            CallExpression(node) {
+                if (!isFirestoreCall(node)) {
+                    return;
+                }
+                // Check first argument of doc() or collection() call
+                const pathArg = node.arguments[0];
+                if (!pathArg) {
+                    return;
+                }
+                // Skip if it's already using a utility function
+                if (isUtilityFunction(pathArg)) {
+                    return;
+                }
+                // Skip if it's a variable or other non-literal expression
+                if (!isStringLiteralOrTemplate(pathArg)) {
+                    return;
+                }
+                // Skip test files
+                const filename = context.getFilename();
+                if (filename.includes('__tests__') || filename.includes('.test.') || filename.includes('.spec.')) {
+                    return;
+                }
+                context.report({
+                    node: pathArg,
+                    messageId: 'requirePathUtil',
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-firestore-path-utils.js.map

package/lib/rules/enforce-realtimedb-path-utils.d.ts

@@ -0,0 +1 @@
+export declare const enforceRealtimedbPathUtils: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"requirePathUtil", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;

package/lib/rules/enforce-realtimedb-path-utils.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceRealtimedbPathUtils = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const RTDB_METHODS = new Set(['ref', 'child']);
+exports.enforceRealtimedbPathUtils = (0, createRule_1.createRule)({
+    name: 'enforce-realtimedb-path-utils',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce usage of utility functions for Realtime Database paths',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            requirePathUtil: 'Use a utility function (e.g., toUserPath, toItemPath) for Realtime Database paths instead of string literals',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        function isRTDBCall(node) {
+            if (node.callee.type !== utils_1.AST_NODE_TYPES.MemberExpression) {
+                return false;
+            }
+            const property = node.callee.property;
+            if (property.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                return false;
+            }
+            // Check for both frontend and backend SDK patterns
+            if (!RTDB_METHODS.has(property.name)) {
+                return false;
+            }
+            // Check if it's a Firebase RTDB call by looking at the chain
+            let current = node.callee.object;
+            while (current) {
+                if (current.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                    if (current.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                        const method = current.callee.property;
+                        if (method.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            method.name === 'database') {
+                            return true;
+                        }
+                    }
+                    current = current.callee;
+                }
+                else if (current.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                    // Handle chained calls like ref().child()
+                    current = current.object;
+                }
+                else {
+                    break;
+                }
+            }
+            return false;
+        }
+        function isStringLiteralOrTemplate(node) {
+            return ((node.type === utils_1.AST_NODE_TYPES.Literal && typeof node.value === 'string') ||
+                node.type === utils_1.AST_NODE_TYPES.TemplateLiteral);
+        }
+        function isUtilityFunction(node) {
+            if (node.type !== utils_1.AST_NODE_TYPES.CallExpression) {
+                return false;
+            }
+            const callee = node.callee;
+            if (callee.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                return false;
+            }
+            // Match functions starting with 'to' and ending with 'Path'
+            return /^to.*Path$/.test(callee.name);
+        }
+        return {
+            CallExpression(node) {
+                if (!isRTDBCall(node)) {
+                    return;
+                }
+                // Check first argument of ref() or child() call
+                const pathArg = node.arguments[0];
+                if (!pathArg) {
+                    return;
+                }
+                // Skip if it's already using a utility function
+                if (isUtilityFunction(pathArg)) {
+                    return;
+                }
+                // Skip if it's a variable or other non-literal expression
+                if (!isStringLiteralOrTemplate(pathArg)) {
+                    return;
+                }
+                // Skip test files
+                const filename = context.getFilename();
+                if (filename.includes('__tests__') ||
+                    filename.includes('.test.') ||
+                    filename.includes('.spec.') ||
+                    filename.includes('mocks')) {
+                    return;
+                }
+                context.report({
+                    node: pathArg,
+                    messageId: 'requirePathUtil',
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-realtimedb-path-utils.js.map

package/lib/rules/no-entire-object-hook-deps.d.ts

@@ -0,0 +1 @@
+export declare const noEntireObjectHookDeps: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"avoidEntireObject", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;

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

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noEntireObjectHookDeps = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const HOOK_NAMES = new Set(['useEffect', 'useCallback', 'useMemo']);
+function isHookCall(node) {
+    const callee = node.callee;
+    return (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+        HOOK_NAMES.has(callee.name));
+}
+function getObjectUsagesInHook(hookBody, objectName) {
+    const usages = new Set();
+    const visited = new Set();
+    function buildAccessPath(node) {
+        const parts = [];
+        let current = node;
+        while (current.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+            if (current.computed) {
+                return null; // Skip computed properties
+            }
+            if (current.property.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                return null;
+            }
+            parts.unshift(current.property.name);
+            current = current.object;
+        }
+        if (current.type === utils_1.AST_NODE_TYPES.Identifier && current.name === objectName) {
+            parts.unshift(objectName);
+            return parts.join('.');
+        }
+        return null;
+    }
+    function visit(node) {
+        if (visited.has(node)) {
+            return;
+        }
+        visited.add(node);
+        if (node.type === utils_1.AST_NODE_TYPES.MemberExpression && !node.computed) {
+            const accessPath = buildAccessPath(node);
+            if (accessPath) {
+                usages.add(accessPath);
+            }
+        }
+        // Visit children
+        switch (node.type) {
+            case utils_1.AST_NODE_TYPES.BlockStatement:
+            case utils_1.AST_NODE_TYPES.Program:
+                node.body.forEach(child => visit(child));
+                break;
+            case utils_1.AST_NODE_TYPES.ExpressionStatement:
+                visit(node.expression);
+                break;
+            case utils_1.AST_NODE_TYPES.CallExpression:
+                visit(node.callee);
+                node.arguments.forEach(arg => visit(arg));
+                break;
+            case utils_1.AST_NODE_TYPES.MemberExpression:
+                visit(node.object);
+                if (!node.computed) {
+                    visit(node.property);
+                }
+                break;
+            case utils_1.AST_NODE_TYPES.ArrowFunctionExpression:
+            case utils_1.AST_NODE_TYPES.FunctionExpression:
+                if (node.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+                    visit(node.body);
+                }
+                else {
+                    visit(node.body);
+                }
+                break;
+            case utils_1.AST_NODE_TYPES.ReturnStatement:
+                if (node.argument) {
+                    visit(node.argument);
+                }
+                break;
+            case utils_1.AST_NODE_TYPES.ConditionalExpression:
+                visit(node.test);
+                visit(node.consequent);
+                visit(node.alternate);
+                break;
+            case utils_1.AST_NODE_TYPES.LogicalExpression:
+            case utils_1.AST_NODE_TYPES.BinaryExpression:
+                visit(node.left);
+                visit(node.right);
+                break;
+            case utils_1.AST_NODE_TYPES.TemplateLiteral:
+                node.expressions.forEach(expr => visit(expr));
+                break;
+        }
+    }
+    visit(hookBody);
+    // Filter out intermediate paths
+    const paths = Array.from(usages);
+    const filteredPaths = paths.filter(path => !paths.some(otherPath => otherPath !== path && otherPath.startsWith(path + '.')));
+    return new Set(filteredPaths);
+}
+exports.noEntireObjectHookDeps = (0, createRule_1.createRule)({
+    name: 'no-entire-object-hook-deps',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Avoid using entire objects in React hook dependency arrays when only specific fields are used',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            avoidEntireObject: 'Avoid using entire object "{{objectName}}" in dependency array. Use specific fields: {{fields}}',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (!isHookCall(node)) {
+                    return;
+                }
+                // Get the dependency array argument
+                const depsArg = node.arguments[node.arguments.length - 1];
+                if (!depsArg ||
+                    depsArg.type !== utils_1.AST_NODE_TYPES.ArrayExpression) {
+                    return;
+                }
+                // Get the hook callback function
+                const callbackArg = node.arguments[0];
+                if (!callbackArg ||
+                    (callbackArg.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+                        callbackArg.type !== utils_1.AST_NODE_TYPES.FunctionExpression)) {
+                    return;
+                }
+                // Check each dependency in the array
+                depsArg.elements.forEach(element => {
+                    if (element &&
+                        element.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        const objectName = element.name;
+                        const usages = getObjectUsagesInHook(callbackArg.body, objectName);
+                        // If we found specific field usages and the entire object is in deps
+                        if (usages.size > 0) {
+                            const fields = Array.from(usages).join(', ');
+                            context.report({
+                                node: element,
+                                messageId: 'avoidEntireObject',
+                                data: {
+                                    objectName,
+                                    fields,
+                                },
+                                fix(fixer) {
+                                    // Only provide fix if we have specific fields to suggest
+                                    if (usages.size > 0) {
+                                        return fixer.replaceText(element, Array.from(usages).join(', '));
+                                    }
+                                    return null;
+                                },
+                            });
+                        }
+                    }
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-entire-object-hook-deps.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",
@@ -36,23 +36,28 @@
     "docs": "./scripts/make-docs.sh && npm run update:eslint-docs",
     "update:eslint-docs": "eslint-doc-generator",
     "build": "tsc",
-    "prepare": "npm run build",
+    "prepare": "husky install && npm run build",
     "version": "git add -A src",
     "postversion": "git push && git push --tags",
     "remove-hooks": "del-cli ./.husky/",
     "release:dry-run": "semantic-release --dry-run --no-ci",
-    "test:release": "node scripts/test-release.js"
+    "test:release": "node scripts/test-release.js",
+    "commitlint": "commitlint --edit"
   },
   "dependencies": {
     "requireindex": "1.2.0"
   },
   "devDependencies": {
+    "@commitlint/cli": "19.6.1",
+    "@commitlint/config-conventional": "19.6.0",
     "@semantic-release/changelog": "6.0.1",
     "@semantic-release/commit-analyzer": "9.0.2",
+    "@semantic-release/exec": "6.0.3",
     "@semantic-release/git": "10.0.1",
     "@semantic-release/npm": "9.0.1",
     "@semantic-release/release-notes-generator": "10.0.3",
     "@types/eslint": "8.37.0",
+    "@types/jest": "29.5.14",
     "@types/node": "18.7.13",
     "@typescript-eslint/eslint-plugin": "5.34.0",
     "@typescript-eslint/parser": "5.48.0",
@@ -69,11 +74,12 @@
     "eslint-import-resolver-typescript": "3.5.5",
     "eslint-plugin-eslint-plugin": "5.0.0",
     "eslint-plugin-import": "2.26.0",
-    "eslint-plugin-node": "11.1.0",
     "eslint-plugin-jsdoc": "44.0.0",
+    "eslint-plugin-node": "11.1.0",
     "eslint-plugin-prettier": "4.2.1",
     "eslint-plugin-security": "1.5.0",
     "fs": "0.0.1-security",
+    "husky": "9.1.7",
     "jest": "29.3.1",
     "jest-junit": "14.0.0",
     "jsonc-eslint-parser": "2.3.0",
@@ -85,9 +91,7 @@
     "semantic-release": "19.0.3",
     "ts-jest": "29.0.5",
     "ts-node": "10.9.1",
-    "typescript": "4.9.5",
-    "@types/jest": "^29.3.1",
-    "@semantic-release/exec": "^6.0.3"
+    "typescript": "4.9.5"
   },
   "peerDependencies": {
     "eslint": ">=7"