@blumintinc/eslint-plugin-blumint 1.0.5 → 1.1.0

package/lib/rules/require-usememo-object-literals.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireUseMemoObjectLiterals = void 0;
+const createRule_1 = require("../utils/createRule");
+exports.requireUseMemoObjectLiterals = (0, createRule_1.createRule)({
+    name: 'require-usememo-object-literals',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce using useMemo for inline object literals passed as props to JSX components',
+            recommended: 'error',
+        },
+        messages: {
+            requireUseMemo: 'Inline object/array literals in JSX props should be wrapped in useMemo to prevent unnecessary re-renders',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            JSXAttribute(node) {
+                // Skip if the value is not an expression
+                if (!node.value || node.value.type !== 'JSXExpressionContainer') {
+                    return;
+                }
+                const { expression } = node.value;
+                // Check if the expression is an object or array literal
+                if ((expression.type === 'ObjectExpression' ||
+                    expression.type === 'ArrayExpression') &&
+                    // Ensure we're in a function component context
+                    context
+                        .getAncestors()
+                        .some((ancestor) => ancestor.type === 'FunctionDeclaration' ||
+                        ancestor.type === 'ArrowFunctionExpression' ||
+                        ancestor.type === 'FunctionExpression')) {
+                    // Check if the parent component name starts with an uppercase letter
+                    // to ensure it's a React component
+                    const jsxElement = node.parent;
+                    const elementName = jsxElement.name.type === 'JSXIdentifier'
+                        ? jsxElement.name.name
+                        : '';
+                    if (elementName && /^[A-Z]/.test(elementName)) {
+                        context.report({
+                            node: expression,
+                            messageId: 'requireUseMemo',
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=require-usememo-object-literals.js.map

package/lib/rules/use-custom-link.d.ts

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

package/lib/rules/use-custom-link.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCustomLink = void 0;
+const createRule_1 = require("../utils/createRule");
+exports.useCustomLink = (0, createRule_1.createRule)({
+    name: 'use-custom-link',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce using src/components/Link instead of next/link',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            useCustomLink: 'Import Link from src/components/Link instead of next/link',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            ImportDeclaration(node) {
+                if (node.source.value === 'next/link') {
+                    const importSpecifiers = node.specifiers;
+                    // Handle different import types (default, named, namespace)
+                    const defaultSpecifier = importSpecifiers.find((specifier) => specifier.type === 'ImportDefaultSpecifier');
+                    const defaultAsSpecifier = importSpecifiers.find((specifier) => specifier.type === 'ImportSpecifier' &&
+                        specifier.imported.name === 'default');
+                    if (defaultSpecifier || defaultAsSpecifier) {
+                        context.report({
+                            node,
+                            messageId: 'useCustomLink',
+                            fix(fixer) {
+                                // Get the local name of the imported Link component
+                                const localName = defaultSpecifier?.local?.name ||
+                                    defaultAsSpecifier?.local?.name ||
+                                    'Link';
+                                // Create the new import statement
+                                const newImport = `import ${localName} from 'src/components/Link';`;
+                                return fixer.replaceText(node, newImport);
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=use-custom-link.js.map

package/lib/rules/use-custom-router.d.ts

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

package/lib/rules/use-custom-router.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCustomRouter = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.useCustomRouter = (0, createRule_1.createRule)({
+    name: 'use-custom-router',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce using src/hooks/routing/useRouter instead of next/router',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            useCustomRouter: 'Import useRouter from src/hooks/routing/useRouter instead of next/router',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            ImportDeclaration(node) {
+                if (node.source.value === 'next/router') {
+                    const specifiers = node.specifiers.filter((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                        specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        specifier.imported.name === 'useRouter');
+                    if (specifiers.length > 0) {
+                        context.report({
+                            node,
+                            messageId: 'useCustomRouter',
+                            fix(fixer) {
+                                // If there are other imports from next/router, keep them
+                                const otherSpecifiers = node.specifiers.filter((specifier) => specifier.type !== utils_1.AST_NODE_TYPES.ImportSpecifier ||
+                                    (specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                        specifier.imported.name !== 'useRouter'));
+                                if (otherSpecifiers.length === 0) {
+                                    // If useRouter is the only import, replace the entire import
+                                    return fixer.replaceText(node, `import { ${specifiers
+                                        .map((s) => s.local.name !== s.imported.name
+                                        ? `useRouter as ${s.local.name}`
+                                        : 'useRouter')
+                                        .join(', ')} } from 'src/hooks/routing/useRouter';`);
+                                }
+                                else {
+                                    // Create a new import for useRouter and keep other imports
+                                    const useRouterImport = `import { ${specifiers
+                                        .map((s) => s.local.name !== s.imported.name
+                                        ? `useRouter as ${s.local.name}`
+                                        : 'useRouter')
+                                        .join(', ')} } from 'src/hooks/routing/useRouter';\n`;
+                                    const otherImports = `import { ${otherSpecifiers
+                                        .map((s) => s.local.name)
+                                        .join(', ')} } from 'next/router';`;
+                                    return fixer.replaceText(node, useRouterImport + otherImports);
+                                }
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=use-custom-router.js.map

package/lib/utils/ASTHelpers.js

@@ -84,6 +84,8 @@ class ASTHelpers {
                 return (this.declarationIncludesIdentifier(node.test) ||
                     this.declarationIncludesIdentifier(node.consequent) ||
                     this.declarationIncludesIdentifier(node.alternate));
+            case 'TemplateLiteral':
+                return node.expressions.some((expr) => this.declarationIncludesIdentifier(expr));
             case 'TSAsExpression':
                 return this.declarationIncludesIdentifier(node.expression);
             default:

package/lib/utils/graph/ClassGraphBuilder.js

@@ -65,6 +65,10 @@ class ClassGraphBuilder {
     addDependencies(node, methodName) {
         const newDependencies = ASTHelpers_1.ASTHelpers.classMethodDependenciesOf(node, this.graph, this.className).filter((name) => !!this.graph[name] && name !== methodName);
         if (this.graph[methodName]) {
+            // Ensure dependencies is initialized as an array
+            if (!Array.isArray(this.graph[methodName].dependencies)) {
+                this.graph[methodName].dependencies = [];
+            }
             this.graph[methodName].dependencies.push(...newDependencies);
         }
     }

package/lib/utils/graph/ClassGraphSorterReadability.js

@@ -66,13 +66,18 @@ class ClassGraphSorterReadability extends ClassGraphSorter_1.ClassGraphSorter {
         const visited = new Set();
         const dfsSortedNodes = [];
         const dfs = (node) => {
-            if (visited.has(node.name) || !node) {
+            if (!node || visited.has(node.name)) {
                 return;
             }
             visited.add(node.name);
             dfsSortedNodes.push(node);
-            for (const dep of node.dependencies) {
-                dfs(this.graph[String(dep)]);
+            // Ensure node.dependencies exists and is an array before iterating
+            const dependencies = Array.isArray(node.dependencies) ? node.dependencies : [];
+            for (const dep of dependencies) {
+                const depNode = this.graph[String(dep)];
+                if (depNode) {
+                    dfs(depNode);
+                }
             }
         };
         searchNodes.forEach((node) => dfs(node));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "1.0.5",
+  "version": "1.1.0",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",
@@ -63,7 +63,7 @@
     "cz-conventional-changelog": "3.3.0",
     "del-cli": "4.0.1",
     "dotenv-cli": "5.0.0",
-    "eslint": "8.11.0",
+    "eslint": "8.57.0",
     "eslint-config-prettier": "8.5.0",
     "eslint-doc-generator": "1.0.0",
     "eslint-import-resolver-typescript": "3.5.5",