@blumintinc/eslint-plugin-blumint 1.0.5 → 1.1.1

package/lib/rules/require-image-overlayed.js

@@ -0,0 +1,80 @@
+"use strict";
+const createRule_1 = require("../utils/createRule");
+module.exports = (0, createRule_1.createRule)({
+    name: 'require-image-overlayed',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce using ImageOverlayed component instead of next/image or img tags',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    componentPath: {
+                        type: 'string',
+                        default: 'src/components/ImageOverlayed',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            useImageOverlayed: 'Use ImageOverlayed component from {{ componentPath }} instead of {{ component }}',
+        },
+    },
+    defaultOptions: [{ componentPath: 'src/components/ImageOverlayed' }],
+    create(context) {
+        const options = context.options[0] || {
+            componentPath: 'src/components/ImageOverlayed',
+        };
+        const sourceCode = context.getSourceCode();
+        return {
+            // Handle JSX img elements
+            JSXElement(node) {
+                if (node.openingElement.name.name === 'img') {
+                    context.report({
+                        node,
+                        messageId: 'useImageOverlayed',
+                        data: {
+                            componentPath: options.componentPath,
+                            component: 'img tag',
+                        },
+                        fix(fixer) {
+                            const attributes = node.openingElement.attributes
+                                .map((attr) => sourceCode.getText(attr))
+                                .join(' ');
+                            return fixer.replaceText(node, `<ImageOverlayed ${attributes} />`);
+                        },
+                    });
+                }
+            },
+            // Handle next/image imports and usage
+            ImportDeclaration(node) {
+                if (node.source.value === 'next/image' && node.specifiers.length > 0) {
+                    const imageSpecifier = node.specifiers.find((spec) => (spec.type === 'ImportDefaultSpecifier' ||
+                        spec.type === 'ImportSpecifier') &&
+                        (spec.local.name === 'Image' || spec.imported?.name === 'Image'));
+                    if (imageSpecifier) {
+                        const localName = imageSpecifier.local.name;
+                        // Report the import
+                        context.report({
+                            node,
+                            messageId: 'useImageOverlayed',
+                            data: {
+                                componentPath: options.componentPath,
+                                component: 'next/image',
+                            },
+                            fix(fixer) {
+                                return fixer.replaceText(node, `import ${localName} from '${options.componentPath}';`);
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=require-image-overlayed.js.map

package/lib/rules/require-memo.js

@@ -45,7 +45,7 @@ const isUnmemoizedExportedFunctionComponent = (parentNode, node) => {
 };
 function isMemoImport(importPath) {
     // Match both absolute and relative paths ending with util/memo
-    return /(?:^|\/)util\/memo$/.test(importPath);
+    return /(?:^|\/|\\)util\/memo$/.test(importPath);
 }
 function checkFunction(context, node) {
     const fileName = context.getFilename();
@@ -137,7 +137,7 @@ function calculateImportPath(currentFilePath) {
     // Calculate relative path based on current file depth from src
     // Subtract 1 from depth to exclude the filename itself
     const depth = parts.length - (srcIndex + 1) - 1;
-    return '../'.repeat(depth) + 'util/memo';
+    return depth > 0 ? '../'.repeat(depth) + 'util/memo' : './util/memo';
 }
 exports.requireMemo = {
     create: (context) => ({
@@ -158,7 +158,7 @@ exports.requireMemo = {
             recommended: 'error',
         },
         messages: {
-            requireMemo: 'Component definition not wrapped in React.memo()',
+            requireMemo: 'Component definition not wrapped in memo()',
         },
         schema: [],
         fixable: 'code',

package/lib/rules/require-usememo-object-literals.d.ts

@@ -0,0 +1,4 @@
+import { TSESTree } from '@typescript-eslint/utils';
+export declare const requireUseMemoObjectLiterals: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"requireUseMemo", never[], {
+    JSXAttribute(node: TSESTree.JSXAttribute): void;
+}>;

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

@@ -0,0 +1,58 @@
+"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;
+                }
+                // Skip if the prop name is 'sx' or ends with 'Sx'
+                const propName = node.name.name;
+                if (typeof propName === 'string' && (propName === 'sx' || propName.endsWith('Sx'))) {
+                    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

@@ -75,6 +75,9 @@ class ASTHelpers {
                 }
                 return (this.declarationIncludesIdentifier(node.object) ||
                     this.declarationIncludesIdentifier(node.property));
+            case 'ImportExpression':
+                // Dynamic imports should be considered as having dependencies
+                return true;
             case 'CallExpression':
             case 'NewExpression':
                 // For function and constructor calls, we care about both the callee and the arguments.
@@ -84,6 +87,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.1",
   "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",