@blumintinc/eslint-plugin-blumint 1.1.5 → 1.1.7

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.5',
+        version: '1.1.7',
     },
     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/class-methods-read-top-to-bottom.js

@@ -49,10 +49,12 @@ exports.classMethodsReadTopToBottom = (0, createRule_1.createRule)({
                             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                             const memberNode = node.body.find((member) => getMemberName(member) === n);
                             const comments = sourceCode.getCommentsBefore(memberNode);
-                            memberNode.range = [
-                                Math.min(memberNode.range[0], Math.min(...comments.map((comment) => comment.range[0]))),
-                                Math.max(memberNode.range[1], Math.max(...comments.map((comment) => comment.range[1]))),
-                            ];
+                            memberNode.range = comments.length
+                                ? [
+                                    Math.min(memberNode.range[0], Math.min(...comments.map((comment) => comment.range[0]))),
+                                    Math.max(memberNode.range[1], Math.max(...comments.map((comment) => comment.range[1]))),
+                                ]
+                                : memberNode.range;
                             return sourceCode.getText(memberNode);
                         })
                             .join('\n');

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

@@ -23,6 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 const createRule_1 = require("../utils/createRule");
+const utils_1 = require("@typescript-eslint/utils");
 const ts = __importStar(require("typescript"));
 module.exports = (0, createRule_1.createRule)({
     name: 'consistent-callback-naming',
@@ -101,6 +102,34 @@ module.exports = (0, createRule_1.createRule)({
                     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 &&
@@ -122,14 +151,84 @@ module.exports = (0, createRule_1.createRule)({
             'FunctionDeclaration, VariableDeclarator'(node) {
                 const functionName = node.id?.type === 'Identifier' ? node.id.name : undefined;
                 if (functionName && functionName.startsWith('handle') && node.id) {
+                    // Skip autofixing for "handler" and "handlers"
+                    if (functionName === 'handler' || functionName === 'handlers') {
+                        context.report({
+                            node,
+                            messageId: 'callbackFunctionPrefix',
+                        });
+                        return;
+                    }
+                    // Skip autofixing for class parameters and getters
+                    const parent = node.parent;
+                    if (parent?.type === utils_1.AST_NODE_TYPES.PropertyDefinition || parent?.type === utils_1.AST_NODE_TYPES.MethodDefinition) {
+                        context.report({
+                            node,
+                            messageId: 'callbackFunctionPrefix',
+                        });
+                        return;
+                    }
+                    // Get all references to this variable
+                    const scope = context.getScope();
+                    const variable = scope.variables.find(v => v.name === functionName);
+                    const references = new Set(variable?.references ?? []);
+                    // Get references from all scopes
+                    const allScopes = [scope];
+                    let currentScope = scope;
+                    while (currentScope.upper) {
+                        currentScope = currentScope.upper;
+                        allScopes.push(currentScope);
+                    }
+                    // Get references from all scopes and their children
+                    for (const s of allScopes) {
+                        // Get references from current scope
+                        const currentVar = s.variables.find(v => v.name === functionName);
+                        if (currentVar) {
+                            currentVar.references.forEach(ref => references.add(ref));
+                        }
+                        // Get references from child scopes
+                        const childScopes = s.childScopes;
+                        for (const childScope of childScopes) {
+                            const childVar = childScope.variables.find(v => v.name === functionName);
+                            if (childVar) {
+                                childVar.references.forEach(ref => references.add(ref));
+                            }
+                        }
+                    }
+                    // Get references from sibling scopes
+                    const siblingScopes = scope.upper?.childScopes ?? [];
+                    for (const siblingScope of siblingScopes) {
+                        if (siblingScope !== scope) {
+                            const siblingVar = siblingScope.variables.find(v => v.name === functionName);
+                            if (siblingVar) {
+                                siblingVar.references.forEach(ref => references.add(ref));
+                            }
+                        }
+                    }
+                    // Get references from global scope
+                    const sourceCode = context.getSourceCode();
+                    if (sourceCode.scopeManager?.globalScope) {
+                        const globalVar = sourceCode.scopeManager.globalScope.variables.find(v => v.name === functionName);
+                        if (globalVar) {
+                            globalVar.references.forEach(ref => references.add(ref));
+                        }
+                    }
                     context.report({
                         node,
                         messageId: 'callbackFunctionPrefix',
-                        fix(fixer) {
+                        *fix(fixer) {
                             // Remove 'handle' prefix and convert first character to lowercase
                             const newName = functionName.slice(6).charAt(0).toLowerCase() +
                                 functionName.slice(7);
-                            return fixer.replaceText(node.id, newName);
+                            // Fix the declaration and all references
+                            const fixes = [];
+                            fixes.push(fixer.replaceText(node.id, newName));
+                            for (const ref of references) {
+                                if (ref.identifier !== node.id) {
+                                    fixes.push(fixer.replaceText(ref.identifier, newName));
+                                }
+                            }
+                            return fixes;
                         },
                     });
                 }
@@ -140,6 +239,22 @@ module.exports = (0, createRule_1.createRule)({
                     node.key.name &&
                     node.key.name.startsWith('handle')) {
                     const name = node.key.name;
+                    // Skip autofixing for "handler" and "handlers"
+                    if (name === 'handler' || name === 'handlers') {
+                        context.report({
+                            node: node.key,
+                            messageId: 'callbackFunctionPrefix',
+                        });
+                        return;
+                    }
+                    // Skip autofixing for class parameters and getters
+                    if (node.type === 'MethodDefinition' && node.kind === 'get') {
+                        context.report({
+                            node: node.key,
+                            messageId: 'callbackFunctionPrefix',
+                        });
+                        return;
+                    }
                     context.report({
                         node: node.key,
                         messageId: 'callbackFunctionPrefix',
@@ -151,6 +266,16 @@ module.exports = (0, createRule_1.createRule)({
                     });
                 }
             },
+            // Check constructor parameters
+            'TSParameterProperty'(node) {
+                if (node.parameter.type === 'Identifier' &&
+                    node.parameter.name.startsWith('handle')) {
+                    context.report({
+                        node,
+                        messageId: 'callbackFunctionPrefix',
+                    });
+                }
+            },
         };
     },
 });

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.5",
+  "version": "1.1.7",
   "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"