@blumintinc/eslint-plugin-blumint 1.12.5 → 1.13.0

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

@@ -14,7 +14,7 @@ exports.useCustomRouter = (0, createRule_1.createRule)({
         fixable: 'code',
         schema: [],
         messages: {
-            useCustomRouter: 'Import useRouter from src/hooks/routing/useRouter instead of next/router',
+            useCustomRouter: 'useRouter import "{{imports}}" comes from next/router, which bypasses the app-specific hook that applies auth checks, analytics, and redirect helpers. Import it from src/hooks/routing/useRouter so routing code stays consistent with the rest of the app.',
         },
     },
     defaultOptions: [],
@@ -29,6 +29,11 @@ exports.useCustomRouter = (0, createRule_1.createRule)({
                         context.report({
                             node,
                             messageId: 'useCustomRouter',
+                            data: {
+                                imports: specifiers
+                                    .map((specifier) => specifier.local.name)
+                                    .join(', '),
+                            },
                             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 ||

package/lib/rules/use-latest-callback.d.ts

@@ -0,0 +1,3 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+export declare const useLatestCallback: TSESLint.RuleModule<"useLatestCallback", [], TSESLint.RuleListener>;
+export default useLatestCallback;

package/lib/rules/use-latest-callback.js

@@ -0,0 +1,270 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLatestCallback = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.useLatestCallback = (0, createRule_1.createRule)({
+    name: 'use-latest-callback',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce using useLatestCallback from use-latest-callback instead of React useCallback',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            useLatestCallback: 'Replace {{currentHook}} with {{recommendedHook}} from "use-latest-callback" so the callback keeps a stable reference while still reading the latest props/state. useCallback recreates functions whenever dependencies change, which can trigger needless renders and stale closures. Drop the dependency array when switching to {{recommendedHook}}.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const filename = context.getFilename();
+        if (filename.includes('/node_modules/')) {
+            return {};
+        }
+        // Track if the file already has a useLatestCallback import
+        let hasUseLatestCallbackImport = false;
+        let useLatestCallbackImportName = 'useLatestCallback';
+        // Track if any useCallback calls should be replaced
+        let hasNonJsxUseCallbacks = false;
+        let useCallbackLocalNames = new Set();
+        const reactNamespaceNames = new Set();
+        const reactDefaultLikeNames = new Set();
+        let hasReactMemberUseCallback = false;
+        const isJSXLikeReturn = (node) => {
+            if (!node)
+                return false;
+            if (node.type === utils_1.AST_NODE_TYPES.JSXElement ||
+                node.type === utils_1.AST_NODE_TYPES.JSXFragment ||
+                node.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer) {
+                return true;
+            }
+            if (node.type === 'ParenthesizedExpression') {
+                return isJSXLikeReturn(node.expression);
+            }
+            if (node.type === utils_1.AST_NODE_TYPES.SequenceExpression) {
+                return isJSXLikeReturn(node.expressions[node.expressions.length - 1]);
+            }
+            if (node.type === utils_1.AST_NODE_TYPES.ArrayExpression) {
+                return node.elements.some((el) => isJSXLikeReturn(el && el.type === utils_1.AST_NODE_TYPES.SpreadElement
+                    ? el.argument
+                    : el));
+            }
+            if (node.type === utils_1.AST_NODE_TYPES.ConditionalExpression) {
+                return (isJSXLikeReturn(node.consequent) || isJSXLikeReturn(node.alternate));
+            }
+            if (node.type === utils_1.AST_NODE_TYPES.LogicalExpression) {
+                return (isJSXLikeReturn(node.left) || isJSXLikeReturn(node.right));
+            }
+            if (node.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                    node.callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    reactNamespaceNames.has(node.callee.object.name) &&
+                    node.callee.property.name === 'createElement') {
+                    return true;
+                }
+            }
+            return false;
+        };
+        return {
+            // First pass: check imports
+            ImportDeclaration(node) {
+                if (node.importKind && node.importKind !== 'value')
+                    return;
+                if (node.source.value === 'use-latest-callback') {
+                    // Check if useLatestCallback is imported
+                    const specifiers = node.specifiers.filter((specifier) => {
+                        if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier) {
+                            return (specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                specifier.imported.name === 'useLatestCallback');
+                        }
+                        return (specifier.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier ||
+                            specifier.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier);
+                    });
+                    if (specifiers.length > 0) {
+                        hasUseLatestCallbackImport = true;
+                        // Get the local name of the import (in case it's renamed)
+                        if (specifiers[0].type === utils_1.AST_NODE_TYPES.ImportSpecifier) {
+                            useLatestCallbackImportName = specifiers[0].local.name;
+                        }
+                        else if (specifiers[0].type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier) {
+                            useLatestCallbackImportName = specifiers[0].local.name;
+                        }
+                        else if (specifiers[0].type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+                            useLatestCallbackImportName = `${specifiers[0].local.name}.useLatestCallback`;
+                        }
+                    }
+                }
+                else if (node.source.value === 'react') {
+                    // Check if useCallback is imported from React
+                    const useCallbackSpecifiers = node.specifiers.filter((specifier) => {
+                        return (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                            specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            specifier.imported.name === 'useCallback');
+                    });
+                    node.specifiers.forEach((specifier) => {
+                        if (specifier.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier ||
+                            specifier.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+                            reactNamespaceNames.add(specifier.local.name);
+                            reactDefaultLikeNames.add(specifier.local.name);
+                        }
+                    });
+                    if (useCallbackSpecifiers.length > 0) {
+                        useCallbackSpecifiers.forEach((spec) => {
+                            useCallbackLocalNames.add(spec.local.name);
+                        });
+                    }
+                }
+            },
+            // Check for useCallback usage and identify JSX-returning callbacks
+            CallExpression(node) {
+                const isUseCallbackIdentifierCall = node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    useCallbackLocalNames.has(node.callee.name);
+                const isUseCallbackMemberCall = node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                    node.callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    reactDefaultLikeNames.has(node.callee.object.name) &&
+                    node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.callee.property.name === 'useCallback';
+                if ((isUseCallbackIdentifierCall || isUseCallbackMemberCall) && node.arguments.length >= 1) {
+                    if (isUseCallbackMemberCall) {
+                        hasReactMemberUseCallback = true;
+                    }
+                    // Check if this is a JSX-returning callback (edge case where we shouldn't replace)
+                    const callback = node.arguments[0];
+                    let isJsxReturning = false;
+                    if ((callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                        callback.type === utils_1.AST_NODE_TYPES.FunctionExpression) &&
+                        callback.body) {
+                        // For arrow functions with implicit return
+                        if (callback.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+                            if (isJSXLikeReturn(callback.body)) {
+                                isJsxReturning = true;
+                            }
+                        }
+                        // For functions with block body - check all return statements
+                        else if (callback.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+                            const returnStatements = callback.body.body.filter((statement) => statement.type === utils_1.AST_NODE_TYPES.ReturnStatement);
+                            // If there are return statements, check if any return JSX
+                            if (returnStatements.length > 0) {
+                                isJsxReturning = returnStatements.some((returnStatement) => returnStatement.argument &&
+                                    isJSXLikeReturn(returnStatement.argument));
+                            }
+                        }
+                    }
+                    if (!isJsxReturning) {
+                        hasNonJsxUseCallbacks = true;
+                        const currentCallbackName = node.callee.type === utils_1.AST_NODE_TYPES.Identifier
+                            ? node.callee.name
+                            : node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                                node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier
+                                ? node.callee.property.name
+                                : 'useCallback';
+                        const replacementName = hasUseLatestCallbackImport
+                            ? useLatestCallbackImportName
+                            : currentCallbackName === 'useCallback'
+                                ? 'useLatestCallback'
+                                : currentCallbackName;
+                        // Report the useCallback call for replacement
+                        context.report({
+                            node,
+                            messageId: 'useLatestCallback',
+                            data: {
+                                currentHook: currentCallbackName,
+                                recommendedHook: replacementName,
+                            },
+                            fix(fixer) {
+                                const sourceCode = context.getSourceCode();
+                                const callbackText = sourceCode.getText(node.arguments[0]);
+                                const typeParams = node.typeParameters
+                                    ? sourceCode.getText(node.typeParameters)
+                                    : '';
+                                // Replace useCallback with useLatestCallback and remove the dependency array
+                                return fixer.replaceText(node, `${replacementName}${typeParams}(${callbackText})`);
+                            },
+                        });
+                    }
+                }
+            },
+            // Final pass: check for useCallback import from react (only if there are non-JSX callbacks)
+            'Program:exit'() {
+                if (!hasNonJsxUseCallbacks) {
+                    return; // Don't modify imports if all useCallback calls return JSX
+                }
+                const sourceCode = context.getSourceCode();
+                const program = sourceCode.ast;
+                for (const statement of program.body) {
+                    if (statement.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
+                        statement.source.value === 'react') {
+                        if (statement.importKind && statement.importKind !== 'value') {
+                            continue;
+                        }
+                        const specifiers = statement.specifiers.filter((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                            specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            specifier.imported.name === 'useCallback');
+                        if (specifiers.length > 0 || hasReactMemberUseCallback) {
+                            const useCallbackLocalName = specifiers[0]?.local.name ?? 'useCallback';
+                            const recommendedHook = hasUseLatestCallbackImport
+                                ? useLatestCallbackImportName
+                                : useCallbackLocalName === 'useCallback'
+                                    ? 'useLatestCallback'
+                                    : useCallbackLocalName;
+                            context.report({
+                                node: statement,
+                                messageId: 'useLatestCallback',
+                                data: {
+                                    currentHook: useCallbackLocalName,
+                                    recommendedHook,
+                                },
+                                fix(fixer) {
+                                    const importText = `import ${useCallbackLocalName === 'useCallback'
+                                        ? 'useLatestCallback'
+                                        : useCallbackLocalName} from 'use-latest-callback';`;
+                                    if (specifiers.length === 0) {
+                                        if (hasUseLatestCallbackImport)
+                                            return null;
+                                        return fixer.insertTextBefore(statement, `${importText}\n`);
+                                    }
+                                    const defaultOrNamespace = statement.specifiers.find((s) => s.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier ||
+                                        s.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier);
+                                    const remainingNamed = statement.specifiers.filter((s) => s.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                                        s.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                        s.imported.name !== 'useCallback');
+                                    const prefix = statement.importKind && statement.importKind !== 'value'
+                                        ? 'import type'
+                                        : 'import';
+                                    if (remainingNamed.length === 0 && !defaultOrNamespace) {
+                                        if (!hasUseLatestCallbackImport) {
+                                            return fixer.replaceText(statement, importText);
+                                        }
+                                        return fixer.remove(statement);
+                                    }
+                                    const parts = [];
+                                    if (defaultOrNamespace) {
+                                        parts.push(sourceCode.getText(defaultOrNamespace));
+                                    }
+                                    if (remainingNamed.length > 0) {
+                                        parts.push(`{ ${remainingNamed
+                                            .map((s) => sourceCode.getText(s))
+                                            .join(', ')} }`);
+                                    }
+                                    const replacement = `${prefix} ${parts.join(', ')} from 'react';`;
+                                    const fixes = [];
+                                    if (!hasUseLatestCallbackImport) {
+                                        fixes.push(fixer.insertTextBefore(statement, `${importText}\n`));
+                                    }
+                                    fixes.push(fixer.replaceText(statement, replacement));
+                                    return fixes;
+                                },
+                            });
+                        }
+                        break;
+                    }
+                }
+            },
+        };
+    },
+});
+exports.default = exports.useLatestCallback;
+//# sourceMappingURL=use-latest-callback.js.map

package/lib/utils/ASTHelpers.js

@@ -14,9 +14,15 @@ class ASTHelpers {
         if (!node) {
             return false;
         }
+        // Gracefully handle ParenthesizedExpression without widening AST node types
+        if (node.type === 'ParenthesizedExpression') {
+            return this.declarationIncludesIdentifier(node.expression);
+        }
         switch (node.type) {
             case 'TSNonNullExpression':
                 return this.declarationIncludesIdentifier(node.expression);
+            case 'TSSatisfiesExpression':
+                return this.declarationIncludesIdentifier(node.expression);
             case 'ArrayPattern':
                 return node.elements.some((element) => ASTHelpers.declarationIncludesIdentifier(element));
             case 'ObjectPattern':
@@ -114,6 +120,10 @@ class ASTHelpers {
         if (!node) {
             return dependencies;
         }
+        // Gracefully handle ParenthesizedExpression without widening AST node types
+        if (node.type === 'ParenthesizedExpression') {
+            return ASTHelpers.classMethodDependenciesOf(node.expression, graph, className);
+        }
         switch (node.type) {
             case 'MethodDefinition':
                 const functionBody = node.value.body;

package/lib/utils/createRule.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRule = void 0;
 const utils_1 = require("@typescript-eslint/utils");
-exports.createRule = utils_1.ESLintUtils.RuleCreator((name) => `https://github.com/BluMintInc/eslint-custom-rules/plugin/docs/rules/${name}.md`);
+exports.createRule = utils_1.ESLintUtils.RuleCreator((name) => `https://github.com/BluMintInc/eslint-custom-rules/docs/rules/${name}.md`);
 //# sourceMappingURL=createRule.js.map

package/lib/utils/graph/ClassGraphSorterReadability.js

@@ -86,7 +86,6 @@ class ClassGraphSorterReadability extends ClassGraphSorter_1.ClassGraphSorter {
         return dfsSortedNodes;
     }
 }
-exports.ClassGraphSorterReadability = ClassGraphSorterReadability;
 ClassGraphSorterReadability.MODIFIER_PRIORITY_MAP = {
     isStatic: [true, false],
     accessibility: ['public', undefined, 'private'],
@@ -98,4 +97,5 @@ ClassGraphSorterReadability.SEARCH_NODE_PRIORITY_FUNCTIONS = [
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     (method, _methods) => method.dependencies.length === 0,
 ];
+exports.ClassGraphSorterReadability = ClassGraphSorterReadability;
 //# sourceMappingURL=ClassGraphSorterReadability.js.map

package/lib/utils/ruleTester.d.ts

@@ -3,3 +3,4 @@ import { RuleTester } from 'eslint';
 export declare const ruleTesterTs: ESLintUtils.RuleTester;
 export declare const ruleTesterJsx: ESLintUtils.RuleTester;
 export declare const ruleTesterJson: RuleTester;
+export declare const ruleTesterMarkdown: RuleTester;

package/lib/utils/ruleTester.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ruleTesterJson = exports.ruleTesterJsx = exports.ruleTesterTs = void 0;
+exports.ruleTesterMarkdown = exports.ruleTesterJson = exports.ruleTesterJsx = exports.ruleTesterTs = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const eslint_1 = require("eslint");
 exports.ruleTesterTs = new utils_1.ESLintUtils.RuleTester({
@@ -20,4 +20,7 @@ exports.ruleTesterJson = new eslint_1.RuleTester({
         ecmaVersion: 2020,
     },
 });
+exports.ruleTesterMarkdown = new eslint_1.RuleTester({
+    parser: require.resolve('markdown-eslint-parser'),
+});
 //# sourceMappingURL=ruleTester.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "1.12.5",
+  "version": "1.13.0",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",
@@ -13,12 +13,12 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/BluMintInc/custom-eslint-rules.git"
+    "url": "git+https://github.com/BluMintInc/eslint-custom-rules.git"
   },
   "bugs": {
-    "url": "https://github.com/BluMintInc/custom-eslint-rules/issues"
+    "url": "https://github.com/BluMintInc/eslint-custom-rules/issues"
   },
-  "homepage": "https://github.com/BluMintInc/custom-eslint-rules#readme",
+  "homepage": "https://github.com/BluMintInc/eslint-custom-rules#readme",
   "keywords": [
     "eslint",
     "eslintplugin",
@@ -29,10 +29,15 @@
     "lint": "npm-run-all \"lint:*\"",
     "lint:eslint-docs": "npm-run-all \"update:eslint-docs -- --check\"",
     "lint:js": "eslint ./src",
-    "lint:shell": "shellcheck .devcontainer/git-flow-completion.bash",
     "lint:fix": "tsc && eslint \"./src/**/*\" --quiet --fix",
     "test": "jest --passWithNoTests --reporters=default --reporters=jest-junit",
     "test:ci": "jest --ci --passWithNoTests --reporters=default --reporters=jest-junit",
+    "address-review": "tsx ./.github/scripts/address-review.ts",
+    "merge-review": "tsx ./.github/scripts/merge-review.ts",
+    "fetch-unresolved-comments": "./scripts/pr-check-comments.sh",
+    "fetch-unresolved-bot-comments": "./scripts/pr-check-bot-comments.sh",
+    "resolve-comments": "./scripts/pr-resolve-comments.sh",
+    "apply-comment-decisions": "./scripts/pr-apply-comment-decisions.sh",
     "docs": "./scripts/make-docs.sh && npm run update:eslint-docs",
     "update:eslint-docs": "eslint-doc-generator --init-rule-docs",
     "build": "tsc",
@@ -54,12 +59,12 @@
   "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/changelog": "6.0.3",
+    "@semantic-release/commit-analyzer": "13.0.1",
+    "@semantic-release/exec": "7.1.0",
     "@semantic-release/git": "10.0.1",
-    "@semantic-release/npm": "9.0.1",
-    "@semantic-release/release-notes-generator": "10.0.3",
+    "@semantic-release/npm": "13.1.2",
+    "@semantic-release/release-notes-generator": "14.1.0",
     "@types/eslint": "8.37.0",
     "@types/jest": "29.5.14",
     "@types/node": "18.7.13",
@@ -72,9 +77,9 @@
     "cz-conventional-changelog": "3.3.0",
     "del-cli": "4.0.1",
     "dotenv-cli": "5.0.0",
-    "eslint": "8.57.0",
+    "eslint": "8.57.1",
     "eslint-config-prettier": "8.5.0",
-    "eslint-doc-generator": "1.7.1",
+    "eslint-doc-generator": "2.2.0",
     "eslint-import-resolver-typescript": "3.5.5",
     "eslint-plugin-eslint-plugin": "5.0.0",
     "eslint-plugin-import": "2.26.0",
@@ -87,15 +92,17 @@
     "jest": "29.7.0",
     "jest-junit": "14.0.0",
     "jsonc-eslint-parser": "2.3.0",
+    "markdown-eslint-parser": "1.2.1",
     "npm-run-all": "4.1.5",
     "prettier": "2.7.1",
     "remark-cli": "10.0.1",
     "remark-lint": "9.1.1",
     "remark-preset-lint-recommended": "6.1.2",
-    "semantic-release": "19.0.3",
+    "semantic-release": "25.0.2",
     "ts-jest": "29.2.6",
     "ts-node": "10.9.1",
-    "typescript": "4.9.5"
+    "tsx": "4.19.4",
+    "typescript": "5.0.3"
   },
   "peerDependencies": {
     "eslint": ">=7"

package/lib/rules/enforce-assertSafe-object-key.d.ts

@@ -1,2 +0,0 @@
-import { TSESLint } from '@typescript-eslint/utils';
-export declare const enforceAssertSafeObjectKey: TSESLint.RuleModule<"useAssertSafe", [], TSESLint.RuleListener>;

package/lib/rules/no-restricted-imports-dynamic.d.ts

@@ -1,25 +0,0 @@
-export declare const RULE_NAME = "no-restricted-imports-dynamic";
-type Options = [
-    {
-        paths?: (string | {
-            name: string;
-            message?: string;
-            allowTypeImports?: boolean;
-            allowDynamicImports?: boolean;
-        })[];
-        patterns?: (string | {
-            group: string[];
-            message?: string;
-            caseSensitive?: boolean;
-            allowTypeImports?: boolean;
-            allowDynamicImports?: boolean;
-        })[];
-    } | (string | {
-        name: string;
-        message?: string;
-        allowTypeImports?: boolean;
-        allowDynamicImports?: boolean;
-    })[]
-];
-declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"restrictedImport" | "restrictedImportPattern", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
-export default _default;