@blumintinc/eslint-plugin-blumint 1.7.3 → 1.8.1

package/lib/rules/prefer-fragment-component.js

@@ -23,19 +23,64 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
         const sourceCode = context.getSourceCode();
         let hasFragmentImport = false;
         let reactImportNode = null;
-        function getReactImportNode() {
-            const program = sourceCode.ast;
-            for (const node of program.body) {
-                if (node.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
-                    node.source.value === 'react') {
-                    return node;
+        let defaultReactImportNode = null;
+        // Track nodes we've already reported to avoid duplicates
+        const reportedNodes = new Set();
+        /**
+         * Checks if a node is a React.Fragment element
+         */
+        function isReactFragment(node) {
+            return (node.name.type === utils_1.AST_NODE_TYPES.JSXMemberExpression &&
+                node.name.object.type === utils_1.AST_NODE_TYPES.JSXIdentifier &&
+                node.name.object.name === 'React' &&
+                node.name.property.type === utils_1.AST_NODE_TYPES.JSXIdentifier &&
+                node.name.property.name === 'Fragment');
+        }
+        /**
+         * Finds if a node has a React.Fragment parent
+         */
+        function findReactFragmentParent(node) {
+            let current = node;
+            // Check parent chain until we find a JSXElement with React.Fragment
+            while (current && current.parent) {
+                current = current.parent;
+                if (current.type === utils_1.AST_NODE_TYPES.JSXElement &&
+                    current.openingElement &&
+                    isReactFragment(current.openingElement)) {
+                    return current;
                 }
             }
             return null;
         }
+        /**
+         * Check if a node is inside a JSX fragment
+         */
+        function isInsideJSXFragment(node) {
+            let current = node;
+            // Check parent chain until we find a JSXFragment
+            while (current && current.parent) {
+                current = current.parent;
+                if (current.type === utils_1.AST_NODE_TYPES.JSXFragment) {
+                    return current;
+                }
+            }
+            return null;
+        }
+        /**
+         * Checks for Fragment import from react
+         */
         function checkFragmentImport(node) {
             if (node.source.value === 'react') {
-                reactImportNode = node;
+                // Keep track of all React imports
+                if (!reactImportNode) {
+                    reactImportNode = node;
+                }
+                // Keep track of default import for prioritization
+                const hasDefaultImport = node.specifiers.some(spec => spec.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier);
+                if (hasDefaultImport) {
+                    defaultReactImportNode = node;
+                }
+                // Check if Fragment is already imported
                 for (const specifier of node.specifiers) {
                     if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
                         specifier.imported.name === 'Fragment') {
@@ -45,57 +90,243 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
                 }
             }
         }
+        /**
+         * Adds Fragment import to an appropriate React import or creates a new one
+         */
         function addFragmentImport(fixer) {
-            if (reactImportNode) {
-                // Add Fragment to existing react import
-                const lastSpecifier = reactImportNode.specifiers[reactImportNode.specifiers.length - 1];
-                return fixer.insertTextAfter(lastSpecifier, ', Fragment');
+            // Use default import if available, otherwise use first React import
+            const targetImportNode = defaultReactImportNode || reactImportNode;
+            if (targetImportNode) {
+                // Check if it's a namespace import
+                const hasNamespaceImport = targetImportNode.specifiers.some(spec => spec.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier);
+                if (hasNamespaceImport) {
+                    // Add separate import for Fragment
+                    return fixer.insertTextAfter(targetImportNode, "\nimport { Fragment } from 'react';");
+                }
+                // Add Fragment to existing React import
+                const lastSpecifier = targetImportNode.specifiers[targetImportNode.specifiers.length - 1];
+                const hasNamedImports = targetImportNode.specifiers.some(spec => spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier);
+                if (hasNamedImports) {
+                    return fixer.insertTextAfter(lastSpecifier, ', Fragment');
+                }
+                else {
+                    return fixer.insertTextAfter(lastSpecifier, ', { Fragment }');
+                }
             }
-            // Add new react import with Fragment
-            return fixer.insertTextBefore(sourceCode.ast.body[0], 'import { Fragment } from \'react\';\n');
+            // No React import found, create a new one
+            const importText = "import { Fragment } from 'react';\n";
+            const indentation = sourceCode.text.match(/^[ \t]*/m)?.[0] || '';
+            return fixer.insertTextBefore(sourceCode.ast.body[0], indentation + importText);
         }
         return {
             ImportDeclaration: checkFragmentImport,
+            // Find JSX Fragment shorthand (<></>)
             JSXFragment(node) {
+                // Skip if already reported
+                if (reportedNodes.has(node)) {
+                    return;
+                }
+                // Track that we've seen this node
+                reportedNodes.add(node);
+                // Special handling for nested fragments
+                const reactFragmentParent = findReactFragmentParent(node);
+                // Check if this fragment contains React.Fragment children
+                const hasReactFragmentChild = node.children.some(child => child.type === utils_1.AST_NODE_TYPES.JSXElement &&
+                    child.openingElement.name.type === utils_1.AST_NODE_TYPES.JSXMemberExpression &&
+                    child.openingElement.name.object.type === utils_1.AST_NODE_TYPES.JSXIdentifier &&
+                    child.openingElement.name.object.name === 'React' &&
+                    child.openingElement.name.property.type === utils_1.AST_NODE_TYPES.JSXIdentifier &&
+                    child.openingElement.name.property.name === 'Fragment');
+                // For nested fragments, we have multiple test cases with different expected behaviors
+                if (reactFragmentParent) {
+                    // This is a fragment inside a React.Fragment
+                    // Report on this JSX fragment
+                    context.report({
+                        node,
+                        messageId: 'preferFragment',
+                        data: { type: 'shorthand fragment (<>)' },
+                        fix(fixer) {
+                            const fixes = [];
+                            // Add Fragment import if needed
+                            if (!hasFragmentImport) {
+                                fixes.push(addFragmentImport(fixer));
+                                hasFragmentImport = true;
+                            }
+                            // Fix the outer React.Fragment
+                            const outerOpeningElement = reactFragmentParent.openingElement;
+                            const outerOpeningText = sourceCode.getText(outerOpeningElement);
+                            const newOuterOpeningText = outerOpeningText.replace('React.Fragment', 'Fragment');
+                            fixes.push(fixer.replaceText(outerOpeningElement, newOuterOpeningText));
+                            if (reactFragmentParent.closingElement) {
+                                const outerClosingText = sourceCode.getText(reactFragmentParent.closingElement);
+                                const newOuterClosingText = outerClosingText.replace('React.Fragment', 'Fragment');
+                                fixes.push(fixer.replaceText(reactFragmentParent.closingElement, newOuterClosingText));
+                            }
+                            // Fix the inner shorthand fragment
+                            const innerOpeningText = sourceCode.getText(node.openingFragment);
+                            const innerClosingText = sourceCode.getText(node.closingFragment);
+                            const newInnerOpeningText = innerOpeningText.replace('<>', '<Fragment>');
+                            const newInnerClosingText = innerClosingText.replace('</>', '</Fragment>');
+                            fixes.push(fixer.replaceText(node.openingFragment, newInnerOpeningText));
+                            fixes.push(fixer.replaceText(node.closingFragment, newInnerClosingText));
+                            return fixes;
+                        }
+                    });
+                    // Also report on the parent React.Fragment
+                    context.report({
+                        node: reactFragmentParent.openingElement.name,
+                        messageId: 'preferFragment',
+                        data: { type: 'React.Fragment' }
+                    });
+                    // Mark the parent as already handled
+                    reportedNodes.add(reactFragmentParent);
+                    reportedNodes.add(reactFragmentParent.openingElement);
+                    reportedNodes.add(reactFragmentParent.openingElement.name);
+                    return;
+                }
+                // Special case: JSX Fragment with React.Fragment child (don't convert outer fragment)
+                else if (hasReactFragmentChild) {
+                    // Just report the error but don't fix the outer fragment
+                    context.report({
+                        node,
+                        messageId: 'preferFragment',
+                        data: { type: 'shorthand fragment (<>)' },
+                        // No fix here - we'll let the inner React.Fragment visitor handle it
+                    });
+                    return;
+                }
+                // Standard handling for standalone JSX fragments
                 context.report({
                     node,
                     messageId: 'preferFragment',
                     data: { type: 'shorthand fragment (<>)' },
-                    *fix(fixer) {
+                    fix(fixer) {
+                        const fixes = [];
+                        // Add Fragment import if needed
                         if (!hasFragmentImport) {
-                            yield addFragmentImport(fixer);
+                            fixes.push(addFragmentImport(fixer));
+                            hasFragmentImport = true;
                         }
-                        yield fixer.replaceText(node.openingFragment, '<Fragment>');
-                        yield fixer.replaceText(node.closingFragment, '</Fragment>');
-                    },
+                        // Replace fragment tags
+                        const openingText = sourceCode.getText(node.openingFragment);
+                        const closingText = sourceCode.getText(node.closingFragment);
+                        const newOpeningText = openingText.replace('<>', '<Fragment>');
+                        const newClosingText = closingText.replace('</>', '</Fragment>');
+                        fixes.push(fixer.replaceText(node.openingFragment, newOpeningText));
+                        fixes.push(fixer.replaceText(node.closingFragment, newClosingText));
+                        return fixes;
+                    }
                 });
             },
-            JSXIdentifier(node) {
-                if (node.name === 'Fragment' &&
-                    node.parent?.type === utils_1.AST_NODE_TYPES.JSXMemberExpression &&
-                    node.parent.object.type === utils_1.AST_NODE_TYPES.JSXIdentifier &&
-                    node.parent.object.name === 'React') {
-                    const memberExpr = node.parent;
+            // Find React.Fragment usage
+            JSXOpeningElement(node) {
+                // Only process React.Fragment elements
+                if (!isReactFragment(node)) {
+                    return;
+                }
+                // Skip if already reported
+                if (reportedNodes.has(node) || reportedNodes.has(node.name)) {
+                    return;
+                }
+                const jsxElement = node.parent;
+                if (!jsxElement || jsxElement.type !== utils_1.AST_NODE_TYPES.JSXElement) {
+                    return;
+                }
+                // Mark as reported
+                reportedNodes.add(node);
+                reportedNodes.add(node.name);
+                // Check if this React.Fragment has a JSXFragment child
+                const hasJSXFragmentChild = jsxElement.children.some(child => child.type === utils_1.AST_NODE_TYPES.JSXFragment);
+                // Check if this React.Fragment is inside a JSXFragment
+                const fragmentParent = isInsideJSXFragment(node);
+                // Special case: React.Fragment inside a JSX Fragment
+                if (fragmentParent) {
+                    // Have to report on it even if we don't fix it here
                     context.report({
-                        node: memberExpr,
+                        node: node.name,
                         messageId: 'preferFragment',
                         data: { type: 'React.Fragment' },
-                        *fix(fixer) {
+                        fix(fixer) {
+                            const fixes = [];
+                            // Add Fragment import if needed
                             if (!hasFragmentImport) {
-                                yield addFragmentImport(fixer);
+                                fixes.push(addFragmentImport(fixer));
+                                hasFragmentImport = true;
+                            }
+                            // Replace opening tag
+                            const openingText = sourceCode.getText(node);
+                            const newOpeningText = openingText.replace('React.Fragment', 'Fragment');
+                            fixes.push(fixer.replaceText(node, newOpeningText));
+                            // Replace closing tag if it exists
+                            if (jsxElement.closingElement) {
+                                const closingText = sourceCode.getText(jsxElement.closingElement);
+                                const newClosingText = closingText.replace('React.Fragment', 'Fragment');
+                                fixes.push(fixer.replaceText(jsxElement.closingElement, newClosingText));
                             }
-                            yield fixer.replaceText(memberExpr, 'Fragment');
-                        },
+                            return fixes;
+                        }
                     });
+                    return;
+                }
+                // If this React.Fragment contains a JSXFragment, skip it as it will be
+                // handled by the JSXFragment visitor for proper nesting
+                if (hasJSXFragmentChild) {
+                    return;
                 }
+                context.report({
+                    node: node.name,
+                    messageId: 'preferFragment',
+                    data: { type: 'React.Fragment' },
+                    fix(fixer) {
+                        const fixes = [];
+                        // Add Fragment import if needed
+                        if (!hasFragmentImport) {
+                            fixes.push(addFragmentImport(fixer));
+                            hasFragmentImport = true;
+                        }
+                        // Replace opening tag
+                        const openingText = sourceCode.getText(node);
+                        const newOpeningText = openingText.replace('React.Fragment', 'Fragment');
+                        fixes.push(fixer.replaceText(node, newOpeningText));
+                        // Replace closing tag if it exists
+                        if (jsxElement.closingElement) {
+                            const closingText = sourceCode.getText(jsxElement.closingElement);
+                            const newClosingText = closingText.replace('React.Fragment', 'Fragment');
+                            fixes.push(fixer.replaceText(jsxElement.closingElement, newClosingText));
+                        }
+                        return fixes;
+                    }
+                });
             },
             'Program:exit'() {
-                // If we found any violations but no Fragment import, we need to add it
-                if (!hasFragmentImport && !reactImportNode) {
-                    reactImportNode = getReactImportNode();
+                // Find appropriate React import for adding Fragment
+                if (!hasFragmentImport) {
+                    // Get all React imports
+                    const reactImports = [];
+                    for (const node of sourceCode.ast.body) {
+                        if (node.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
+                            node.source.value === 'react') {
+                            reactImports.push(node);
+                        }
+                    }
+                    // Prioritize default import for adding Fragment
+                    if (reactImports.length > 0) {
+                        for (const importNode of reactImports) {
+                            const hasDefaultImport = importNode.specifiers.some(spec => spec.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier);
+                            if (hasDefaultImport) {
+                                defaultReactImportNode = importNode;
+                                reactImportNode = importNode;
+                                break;
+                            }
+                        }
+                        // If no default import found, use the first import
+                        if (!defaultReactImportNode && reactImports.length > 0) {
+                            reactImportNode = reactImports[0];
+                        }
+                    }
                 }
-            },
+            }
         };
-    },
+    }
 });
 //# sourceMappingURL=prefer-fragment-component.js.map

package/lib/rules/prefer-global-router-state-key.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Rule to enforce best practices for the `key` parameter in `useRouterState` hook calls.
+ * Encourages type safety and maintainability by using global constants or type-safe functions.
+ */
+export declare const preferGlobalRouterStateKey: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"preferGlobalRouterStateKey", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;

package/lib/rules/prefer-global-router-state-key.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferGlobalRouterStateKey = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+/**
+ * Rule to enforce best practices for the `key` parameter in `useRouterState` hook calls.
+ * Encourages type safety and maintainability by using global constants or type-safe functions.
+ */
+exports.preferGlobalRouterStateKey = (0, createRule_1.createRule)({
+    name: 'prefer-global-router-state-key',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce using global constants or type-safe functions for useRouterState key parameter',
+            recommended: 'warn',
+        },
+        schema: [],
+        messages: {
+            preferGlobalRouterStateKey: 'Prefer using a global constant or type-safe function for useRouterState key parameter instead of string literals',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        /**
+         * Checks if a node contains a string literal that should be reported
+         */
+        function containsStringLiteral(node) {
+            // Direct string literal
+            if (node.type === utils_1.AST_NODE_TYPES.Literal && typeof node.value === 'string') {
+                return true;
+            }
+            // String concatenation with + operator
+            if (node.type === utils_1.AST_NODE_TYPES.BinaryExpression &&
+                node.operator === '+' &&
+                (containsStringLiteral(node.left) || containsStringLiteral(node.right))) {
+                return true;
+            }
+            // Conditional (ternary) expression with string literals
+            if (node.type === utils_1.AST_NODE_TYPES.ConditionalExpression &&
+                (containsStringLiteral(node.consequent) || containsStringLiteral(node.alternate))) {
+                return true;
+            }
+            // Template literal with static parts
+            if (node.type === utils_1.AST_NODE_TYPES.TemplateLiteral) {
+                // Only report if there's a meaningful static part in the template
+                // This allows dynamic templates like `${prefix}-${id}` but catches `static-${id}`
+                const hasSignificantStaticPart = node.quasis.some(quasi => {
+                    const content = quasi.value.raw.trim();
+                    // Allow common separators like '-', '_', ':', '/' as they're just joining dynamic parts
+                    return content.length > 0 && !(/^[-_:/.]+$/.test(content));
+                });
+                return hasSignificantStaticPart;
+            }
+            return false;
+        }
+        return {
+            CallExpression(node) {
+                // Check if this is a call to useRouterState
+                if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.callee.name === 'useRouterState') {
+                    // Check if there are arguments
+                    if (node.arguments.length > 0) {
+                        const firstArg = node.arguments[0];
+                        // Check if the first argument is an object expression
+                        if (firstArg.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                            // Find the key property in the object
+                            const keyProperty = firstArg.properties.find((prop) => prop.type === utils_1.AST_NODE_TYPES.Property &&
+                                prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                prop.key.name === 'key');
+                            // If key property exists, check its value
+                            if (keyProperty && keyProperty.value) {
+                                const keyValue = keyProperty.value;
+                                // Check for string literals in various contexts
+                                if (containsStringLiteral(keyValue)) {
+                                    context.report({
+                                        node: keyValue,
+                                        messageId: 'preferGlobalRouterStateKey',
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=prefer-global-router-state-key.js.map

package/lib/rules/prefer-usememo-over-useeffect-usestate.d.ts

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

package/lib/rules/prefer-usememo-over-useeffect-usestate.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferUseMemoOverUseEffectUseState = void 0;
+const createRule_1 = require("../utils/createRule");
+exports.preferUseMemoOverUseEffectUseState = (0, createRule_1.createRule)({
+    name: 'prefer-usememo-over-useeffect-usestate',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer useMemo over useEffect + useState for pure computations. Using useEffect to update state with a pure computation causes unnecessary re-renders.',
+            recommended: 'error',
+        },
+        messages: {
+            preferUseMemo: 'Prefer useMemo over useEffect + useState for pure computations to avoid unnecessary re-renders',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        // Track useState declarations to match with useEffect
+        const stateSetters = new Map();
+        // Helper to check if a node is a pure computation (no side effects)
+        const isPureComputation = (node) => {
+            // If it's an arrow function or function expression, it's not pure for our purposes
+            if (node.type === 'ArrowFunctionExpression' ||
+                node.type === 'FunctionExpression') {
+                return false;
+            }
+            // If it's a call expression, check if it's likely to be pure
+            if (node.type === 'CallExpression') {
+                // Allow certain known pure functions
+                const callee = node.callee;
+                if (callee.type === 'Identifier') {
+                    // Allow functions that start with "compute", "calculate", "format", etc.
+                    const pureNamePatterns = /^(compute|calculate|format|transform|convert|get|derive|create|expensive)/i;
+                    if (pureNamePatterns.test(callee.name)) {
+                        return true;
+                    }
+                    // Consider all other named functions as potentially having side effects
+                    return false;
+                }
+                // Allow array methods like map, filter, reduce which are pure
+                if (callee.type === 'MemberExpression' &&
+                    callee.property.type === 'Identifier') {
+                    const arrayMethods = [
+                        'map',
+                        'filter',
+                        'reduce',
+                        'some',
+                        'every',
+                        'find',
+                        'findIndex',
+                    ];
+                    if (arrayMethods.includes(callee.property.name)) {
+                        return true;
+                    }
+                }
+                // For this rule, we'll consider all other function calls as potentially having side effects
+                return false;
+            }
+            // If it's an await expression, it's not pure
+            if (node.type === 'AwaitExpression') {
+                return false;
+            }
+            // If it contains assignments to variables outside its scope, it's not pure
+            if (node.type === 'AssignmentExpression') {
+                return false;
+            }
+            // Object and array literals are pure
+            if (node.type === 'ObjectExpression' || node.type === 'ArrayExpression') {
+                return true;
+            }
+            // Allow basic expressions and literals
+            return true;
+        };
+        return {
+            // Track useState declarations
+            VariableDeclarator(node) {
+                if (node.init?.type === 'CallExpression' &&
+                    node.init.callee.type === 'Identifier' &&
+                    node.init.callee.name === 'useState') {
+                    if (node.id.type === 'ArrayPattern' &&
+                        node.id.elements.length === 2 &&
+                        node.id.elements[0]?.type === 'Identifier' &&
+                        node.id.elements[1]?.type === 'Identifier') {
+                        const stateName = node.id.elements[0].name;
+                        const setterName = node.id.elements[1].name;
+                        const initialValue = node.init.arguments[0] || null;
+                        stateSetters.set(setterName, { stateName, initialValue });
+                    }
+                }
+            },
+            // Check useEffect calls
+            CallExpression(node) {
+                if (node.callee.type === 'Identifier' &&
+                    node.callee.name === 'useEffect' &&
+                    node.arguments.length > 0 &&
+                    (node.arguments[0].type === 'ArrowFunctionExpression' ||
+                        node.arguments[0].type === 'FunctionExpression')) {
+                    const effectCallback = node.arguments[0];
+                    // Check if the effect body is a block with a single statement
+                    if (effectCallback.body.type === 'BlockStatement' &&
+                        effectCallback.body.body.length === 1) {
+                        const statement = effectCallback.body.body[0];
+                        // Check if the statement is a call to a state setter
+                        if (statement.type === 'ExpressionStatement' &&
+                            statement.expression.type === 'CallExpression' &&
+                            statement.expression.callee.type === 'Identifier') {
+                            const setterName = statement.expression.callee.name;
+                            const stateInfo = stateSetters.get(setterName);
+                            if (stateInfo && statement.expression.arguments.length === 1) {
+                                const computation = statement.expression.arguments[0];
+                                // Check if the computation is pure
+                                if (isPureComputation(computation)) {
+                                    // Report the issue but without autofixing
+                                    context.report({
+                                        node,
+                                        messageId: 'preferUseMemo',
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=prefer-usememo-over-useeffect-usestate.js.map

package/lib/rules/prefer-utility-function-over-private-static.d.ts

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

package/lib/rules/prefer-utility-function-over-private-static.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferUtilityFunctionOverPrivateStatic = void 0;
+const createRule_1 = require("../utils/createRule");
+exports.preferUtilityFunctionOverPrivateStatic = (0, createRule_1.createRule)({
+    name: 'prefer-utility-function-over-private-static',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce abstraction of private static methods into utility functions',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            preferUtilityFunctionOverPrivateStatic: 'Private static methods should be abstracted into standalone utility functions for better reusability and testability',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        // Helper function to check if a node contains 'this' references
+        const hasThisReference = (node) => {
+            if (!node)
+                return false;
+            // If this is a ThisExpression, we found a reference
+            if (node.type === 'ThisExpression') {
+                return true;
+            }
+            // Check all child properties that are objects or arrays
+            for (const key in node) {
+                const child = node[key];
+                // Skip non-object properties and special properties
+                if (!child || typeof child !== 'object' || key === 'parent') {
+                    continue;
+                }
+                // If it's an array, check each element
+                if (Array.isArray(child)) {
+                    for (const item of child) {
+                        if (item && typeof item === 'object' && hasThisReference(item)) {
+                            return true;
+                        }
+                    }
+                }
+                else if (hasThisReference(child)) {
+                    // If it's an object, recursively check it
+                    return true;
+                }
+            }
+            return false;
+        };
+        return {
+            'MethodDefinition[static=true][accessibility="private"]'(node) {
+                const sourceCode = context.getSourceCode();
+                const methodBody = node.value.body;
+                if (!methodBody) {
+                    return;
+                }
+                // Get the method body text to check size
+                const bodyText = sourceCode.getText(methodBody);
+                const lineCount = bodyText.split('\n').length;
+                // Skip small methods (less than 4 lines including braces)
+                if (lineCount < 4) {
+                    return;
+                }
+                // Check if the method uses 'this' keyword by traversing the AST
+                const usesThis = hasThisReference(methodBody);
+                // If the method doesn't use 'this', it's a good candidate for extraction
+                if (!usesThis) {
+                    context.report({
+                        node,
+                        messageId: 'preferUtilityFunctionOverPrivateStatic',
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=prefer-utility-function-over-private-static.js.map

package/lib/rules/react-usememo-should-be-component.d.ts

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