@blumintinc/eslint-plugin-blumint 1.9.1 → 1.10.0

package/README.md

@@ -70,6 +70,7 @@ Or use the recommended config:
 | [enforce-callback-memo](docs/rules/enforce-callback-memo.md)                                             | Enforce useCallback for inline functions and useMemo for objects/arrays containing functions in JSX props to prevent unnecessary re-renders. This improves React component performance by ensuring stable function references across renders and memoizing complex objects.                                                                                                                                 | ✅  |    |    |    |
 | [enforce-centralized-mock-firestore](docs/rules/enforce-centralized-mock-firestore.md)                   | Enforce usage of centralized mockFirestore from predefined location                                                                                                                                                                                                                                                                                                                                         | ✅  |    | 🔧 |    |
 | [enforce-dynamic-firebase-imports](docs/rules/enforce-dynamic-firebase-imports.md)                       | Enforce dynamic importing for modules within the firebaseCloud directory to optimize initial bundle size. This ensures Firebase-related code is only loaded when needed, improving application startup time and reducing the main bundle size.                                                                                                                                                              | ✅  |    |    |    |
+| [enforce-dynamic-file-naming](docs/rules/enforce-dynamic-file-naming.md)                               | Enforce .dynamic.ts(x) file naming when @blumintinc/blumint/enforce-dynamic-imports rule is disabled. This improves code clarity and helps enforce consistent naming conventions across the codebase.                                                                                                                                                                                                    | ✅  |    |    |    |
 | [enforce-exported-function-types](docs/rules/enforce-exported-function-types.md)                         | Enforce exporting types for function props and return values                                                                                                                                                                                                                                                                                                                                                | ✅  |    |    |    |
 | [enforce-firestore-doc-ref-generic](docs/rules/enforce-firestore-doc-ref-generic.md)                     | Enforce generic argument for Firestore DocumentReference, CollectionReference and CollectionGroup                                                                                                                                                                                                                                                                                                           | ✅  |    |    | 💭 |
 | [enforce-firestore-facade](docs/rules/enforce-firestore-facade.md)                                       | Enforce usage of Firestore facades instead of direct Firestore methods                                                                                                                                                                                                                                                                                                                                      | ✅  |    |    |    |

package/lib/index.js

@@ -97,10 +97,13 @@ const omit_index_html_1 = require("./rules/omit-index-html");
 const enforce_id_capitalization_1 = require("./rules/enforce-id-capitalization");
 const no_unused_usestate_1 = require("./rules/no-unused-usestate");
 const no_uuidv4_base62_as_key_1 = require("./rules/no-uuidv4-base62-as-key");
+const enforce_dynamic_file_naming_1 = __importDefault(require("./rules/enforce-dynamic-file-naming"));
+const prefer_usecallback_over_usememo_for_functions_1 = __importDefault(require("./rules/prefer-usecallback-over-usememo-for-functions"));
+const no_margin_properties_1 = require("./rules/no-margin-properties");
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.9.1',
+        version: '1.10.0',
     },
     parseOptions: {
         ecmaVersion: 2020,
@@ -209,6 +212,9 @@ module.exports = {
                 '@blumintinc/blumint/omit-index-html': 'error',
                 '@blumintinc/blumint/enforce-id-capitalization': 'error',
                 '@blumintinc/blumint/no-unused-usestate': 'error',
+                '@blumintinc/blumint/enforce-dynamic-file-naming': 'error',
+                '@blumintinc/blumint/prefer-usecallback-over-usememo-for-functions': 'error',
+                '@blumintinc/blumint/no-margin-properties': 'error',
             },
         },
     },
@@ -238,6 +244,7 @@ module.exports = {
         'no-unused-props': no_unused_props_1.noUnusedProps,
         'no-useless-fragment': no_useless_fragment_1.noUselessFragment,
         'no-uuidv4-base62-as-key': no_uuidv4_base62_as_key_1.noUuidv4Base62AsKey,
+        'enforce-dynamic-file-naming': enforce_dynamic_file_naming_1.default,
         'prefer-fragment-shorthand': prefer_fragment_shorthand_1.preferFragmentShorthand,
         'prefer-type-over-interface': prefer_type_over_interface_1.preferTypeOverInterface,
         'require-memo': require_memo_1.requireMemo,
@@ -307,6 +314,8 @@ module.exports = {
         'omit-index-html': omit_index_html_1.omitIndexHtml,
         'enforce-id-capitalization': enforce_id_capitalization_1.enforceIdCapitalization,
         'no-unused-usestate': no_unused_usestate_1.noUnusedUseState,
+        'prefer-usecallback-over-usememo-for-functions': prefer_usecallback_over_usememo_for_functions_1.default,
+        'no-margin-properties': no_margin_properties_1.noMarginProperties,
     },
 };
 //# sourceMappingURL=index.js.map

package/lib/rules/enforce-callable-types.d.ts

@@ -1,3 +1,3 @@
-type MessageIds = 'missingParamsType' | 'missingResponseType' | 'unusedParamsType' | 'unusedResponseType';
+type MessageIds = 'missingParamsPropsType' | 'missingResponseType' | 'unusedParamsPropsType' | 'unusedResponseType';
 export declare const enforceCallableTypes: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
 export {};

package/lib/rules/enforce-callable-types.js

@@ -8,14 +8,14 @@ exports.enforceCallableTypes = (0, createRule_1.createRule)({
     meta: {
         type: 'problem',
         docs: {
-            description: 'Enforce Params and Response type exports in callable functions',
+            description: 'Enforce Props/Params and Response type exports in callable functions',
             recommended: 'error',
         },
         schema: [],
         messages: {
-            missingParamsType: 'Missing Params type export in callable function file',
+            missingParamsPropsType: 'Missing Props or Params type export in callable function file',
             missingResponseType: 'Missing Response type export in callable function file',
-            unusedParamsType: 'Params type is exported but not used in the callable function',
+            unusedParamsPropsType: 'Props or Params type is exported but not used in the callable function',
             unusedResponseType: 'Response type is exported but not used in the callable function',
         },
     },
@@ -28,18 +28,18 @@ exports.enforceCallableTypes = (0, createRule_1.createRule)({
             filename.includes('/callable/scripts/')) {
             return {};
         }
-        let hasParamsExport = false;
+        let hasParamsOrPropsExport = false;
         let hasResponseExport = false;
         let hasCallableFunction = false;
-        let paramsTypeUsed = false;
+        let paramsOrPropsTypeUsed = false;
         let responseTypeUsed = false;
         return {
             // Check for type exports
             ExportNamedDeclaration(node) {
                 if (node.declaration?.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
                     const typeName = node.declaration.id.name;
-                    if (typeName === 'Params') {
-                        hasParamsExport = true;
+                    if (typeName === 'Params' || typeName === 'Props') {
+                        hasParamsOrPropsExport = true;
                     }
                     else if (typeName === 'Response') {
                         hasResponseExport = true;
@@ -56,8 +56,8 @@ exports.enforceCallableTypes = (0, createRule_1.createRule)({
             // Check for type usage in function parameters and return types
             TSTypeReference(node) {
                 if (node.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
-                    if (node.typeName.name === 'Params') {
-                        paramsTypeUsed = true;
+                    if (node.typeName.name === 'Params' || node.typeName.name === 'Props') {
+                        paramsOrPropsTypeUsed = true;
                     }
                     else if (node.typeName.name === 'Response') {
                         responseTypeUsed = true;
@@ -68,16 +68,16 @@ exports.enforceCallableTypes = (0, createRule_1.createRule)({
                 if (!hasCallableFunction) {
                     return;
                 }
-                if (!hasParamsExport) {
+                if (!hasParamsOrPropsExport) {
                     context.report({
                         loc: { line: 1, column: 0 },
-                        messageId: 'missingParamsType',
+                        messageId: 'missingParamsPropsType',
                     });
                 }
-                else if (!paramsTypeUsed) {
+                else if (!paramsOrPropsTypeUsed) {
                     context.report({
                         loc: { line: 1, column: 0 },
-                        messageId: 'unusedParamsType',
+                        messageId: 'unusedParamsPropsType',
                     });
                 }
                 if (!hasResponseExport) {

package/lib/rules/enforce-dynamic-file-naming.d.ts

@@ -0,0 +1,3 @@
+export declare const RULE_NAME = "enforce-dynamic-file-naming";
+declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"requireDynamicExtension" | "requireDisableDirective", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export default _default;

package/lib/rules/enforce-dynamic-file-naming.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_NAME = void 0;
+const createRule_1 = require("../utils/createRule");
+const path_1 = __importDefault(require("path"));
+exports.RULE_NAME = 'enforce-dynamic-file-naming';
+exports.default = (0, createRule_1.createRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce .dynamic.ts(x) file naming when @blumintinc/blumint/enforce-dynamic-imports rule is disabled',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            requireDynamicExtension: 'Files with disabled @blumintinc/blumint/enforce-dynamic-imports rule must use .dynamic.ts(x) extension',
+            requireDisableDirective: 'Files with .dynamic.ts(x) extension must have at least one @blumintinc/blumint/enforce-dynamic-imports disable directive',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        // Get the file path and name
+        const filePath = context.getFilename();
+        const fileName = path_1.default.basename(filePath);
+        // Check if the file is a TypeScript file (ends with .ts or .tsx)
+        // Ignore files with other extensions like .test.ts, .deprecated.ts, etc.
+        const isTypeScriptFile = /^[^.]+\.tsx?$/.test(fileName);
+        // Check if the file has .dynamic.ts or .dynamic.tsx extension
+        const hasDynamicExtension = /\.dynamic\.tsx?$/.test(fileName);
+        // Skip if not a TypeScript file or has other extensions
+        if (!isTypeScriptFile && !hasDynamicExtension) {
+            return {};
+        }
+        // Track if we found a disable directive for enforce-dynamic-imports
+        let foundDisableDirective = false;
+        return {
+            Program() {
+                // Get the source code
+                const sourceCode = context.getSourceCode();
+                const comments = sourceCode.getAllComments();
+                // Check all comments for disable directives
+                for (const comment of comments) {
+                    const commentText = comment.value.trim();
+                    // Check for inline disable directive
+                    if ((commentText.includes('eslint-disable-next-line') ||
+                        commentText.includes('ednl')) &&
+                        commentText.includes('@blumintinc/blumint/enforce-dynamic-imports')) {
+                        foundDisableDirective = true;
+                        break;
+                    }
+                    // Check for block disable directive
+                    if (commentText.includes('eslint-disable ') &&
+                        commentText.includes('@blumintinc/blumint/enforce-dynamic-imports')) {
+                        foundDisableDirective = true;
+                        break;
+                    }
+                }
+                // If we found a disable directive but the file doesn't have .dynamic extension
+                if (foundDisableDirective && !hasDynamicExtension) {
+                    context.report({
+                        loc: { line: 1, column: 0 },
+                        messageId: 'requireDynamicExtension',
+                    });
+                }
+                // If the file has .dynamic extension but no disable directive
+                if (hasDynamicExtension && !foundDisableDirective) {
+                    context.report({
+                        loc: { line: 1, column: 0 },
+                        messageId: 'requireDisableDirective',
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-dynamic-file-naming.js.map

package/lib/rules/enforce-id-capitalization.js

@@ -61,6 +61,47 @@ exports.enforceIdCapitalization = (0, createRule_1.createRule)({
                 node.parent.id === node) {
                 return true;
             }
+            // Check if the node is in an object property context
+            if (node.parent &&
+                node.parent.type === utils_1.AST_NODE_TYPES.Property &&
+                node.parent.value === node) {
+                // Check if this is a property in an object pattern (destructuring)
+                let currentNode = node.parent;
+                while (currentNode.parent) {
+                    if (currentNode.parent.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+                        return true;
+                    }
+                    currentNode = currentNode.parent;
+                }
+            }
+            // Check if the node is in a property assignment context
+            if (node.parent &&
+                node.parent.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                return true;
+            }
+            // Check if the node is in a property access context
+            if (node.parent &&
+                node.parent.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                return true;
+            }
+            // Check if the node is a string literal in a type definition context
+            // This handles cases like Pick<Type, 'id' | 'name'>
+            if (node.type === utils_1.AST_NODE_TYPES.Literal && typeof node.value === 'string') {
+                let currentNode = node;
+                while (currentNode.parent) {
+                    // Check for TypeScript type contexts
+                    if (currentNode.parent.type === utils_1.AST_NODE_TYPES.TSTypeReference ||
+                        currentNode.parent.type === utils_1.AST_NODE_TYPES.TSTypeParameterInstantiation ||
+                        currentNode.parent.type === utils_1.AST_NODE_TYPES.TSUnionType ||
+                        currentNode.parent.type === utils_1.AST_NODE_TYPES.TSIntersectionType ||
+                        currentNode.parent.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration ||
+                        currentNode.parent.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration ||
+                        currentNode.parent.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
+                        return true;
+                    }
+                    currentNode = currentNode.parent;
+                }
+            }
             return false;
         }
         /**

package/lib/rules/no-always-true-false-conditions.js

@@ -276,6 +276,92 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
                 node.typeAnnotation.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
                 node.typeAnnotation.typeName.name === 'const');
         }
+        /**
+         * Check if a logical expression is being used for default value assignment
+         * This includes patterns like:
+         * - variable || defaultValue
+         * - variable ?? defaultValue
+         * - variable && expression
+         */
+        function isDefaultValueAssignment(node) {
+            // Check if this is a nullish coalescing operator (always used for defaults)
+            if (node.operator === '??') {
+                return true;
+            }
+            // Check if this is in a JSX attribute
+            if (node.parent &&
+                (node.parent.type === utils_1.AST_NODE_TYPES.JSXAttribute ||
+                    node.parent.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer)) {
+                return true;
+            }
+            // Check if this is a variable assignment with a default value
+            if (node.parent &&
+                (node.parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator ||
+                    node.parent.type === utils_1.AST_NODE_TYPES.AssignmentExpression)) {
+                return true;
+            }
+            // Check if this is a function parameter default value
+            if (node.parent &&
+                node.parent.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
+                return true;
+            }
+            // Check if this is a return statement with a default value
+            if (node.parent &&
+                node.parent.type === utils_1.AST_NODE_TYPES.ReturnStatement) {
+                return true;
+            }
+            // Check if this is a function argument (common for default values)
+            if (node.parent &&
+                (node.parent.type === utils_1.AST_NODE_TYPES.CallExpression ||
+                    node.parent.type === utils_1.AST_NODE_TYPES.NewExpression)) {
+                return true;
+            }
+            // Check if this is part of an object or array expression (common for default values)
+            if (node.parent &&
+                (node.parent.type === utils_1.AST_NODE_TYPES.ObjectExpression ||
+                    node.parent.type === utils_1.AST_NODE_TYPES.ArrayExpression)) {
+                return true;
+            }
+            // Check if this is inside a property assignment in an object
+            if (node.parent &&
+                node.parent.type === utils_1.AST_NODE_TYPES.Property) {
+                return true;
+            }
+            // Check if this is inside a template literal expression
+            if (node.parent &&
+                node.parent.type === utils_1.AST_NODE_TYPES.TemplateLiteral) {
+                return true;
+            }
+            // Check if this is inside a template element
+            if (node.parent &&
+                node.parent.type === utils_1.AST_NODE_TYPES.TemplateElement) {
+                return true;
+            }
+            // Check if this is inside a spread element
+            if (node.parent &&
+                node.parent.type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                return true;
+            }
+            // Check if this is inside an array method callback (map, filter, etc.)
+            if (node.parent &&
+                node.parent.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+                node.parent.parent &&
+                node.parent.parent.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                node.parent.parent.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                const methodName = node.parent.parent.callee.property.type === utils_1.AST_NODE_TYPES.Identifier
+                    ? node.parent.parent.callee.property.name
+                    : '';
+                if (['map', 'filter', 'find', 'findIndex', 'some', 'every', 'forEach'].includes(methodName)) {
+                    return true;
+                }
+            }
+            // Check if this is inside an arrow function body
+            if (node.parent &&
+                node.parent.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                return true;
+            }
+            return false;
+        }
         /**
          * Check logical expressions (&&, ||)
          */
@@ -285,6 +371,12 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
             // Add children to evaluated list to prevent duplicate evaluations
             evaluatedParentNodes.add(node.left);
             evaluatedParentNodes.add(node.right);
+            // Check if this is a default value assignment pattern
+            const isDefaultValuePattern = isDefaultValueAssignment(node);
+            if (isDefaultValuePattern) {
+                // Don't flag default value assignments as always true/false conditions
+                return {};
+            }
             // For &&: if either side is always falsy, the whole expression is falsy
             if (node.operator === '&&') {
                 if (leftResult.isFalsy) {
@@ -724,6 +816,16 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
             }
             // Template literals
             if (node.type === utils_1.AST_NODE_TYPES.TemplateLiteral) {
+                // Skip template literals that are likely used for string interpolation
+                // rather than conditions
+                if (node.parent &&
+                    (node.parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator ||
+                        node.parent.type === utils_1.AST_NODE_TYPES.AssignmentExpression ||
+                        node.parent.type === utils_1.AST_NODE_TYPES.ReturnStatement ||
+                        node.parent.type === utils_1.AST_NODE_TYPES.Property ||
+                        node.parent.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer)) {
+                    return {};
+                }
                 return checkTemplateLiteral(node);
             }
             // Type checking (typeof x === 'string')
@@ -1092,11 +1194,59 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
         /**
          * Check if a condition is always truthy or falsy and report it
          */
+        /**
+         * Check if a ternary expression is being used for default value assignment
+         * This includes patterns like:
+         * - variable ? variable : defaultValue
+         */
+        function isDefaultValueTernary(node) {
+            // Check if the condition and the consequent are the same variable
+            // This is a common pattern for default values: status ? status : 'offline'
+            if (node.test.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.consequent.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.test.name === node.consequent.name) {
+                return true;
+            }
+            // Check if this is in a JSX attribute
+            if (node.parent &&
+                (node.parent.type === utils_1.AST_NODE_TYPES.JSXAttribute ||
+                    node.parent.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer)) {
+                return true;
+            }
+            // Check if this is a variable assignment with a default value
+            if (node.parent &&
+                (node.parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator ||
+                    node.parent.type === utils_1.AST_NODE_TYPES.AssignmentExpression)) {
+                // Only if the condition and consequent are the same variable
+                if (node.test.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.consequent.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.test.name === node.consequent.name) {
+                    return true;
+                }
+            }
+            // Check if this is a return statement with a default value
+            if (node.parent &&
+                node.parent.type === utils_1.AST_NODE_TYPES.ReturnStatement) {
+                // Only if the condition and consequent are the same variable
+                if (node.test.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.consequent.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.test.name === node.consequent.name) {
+                    return true;
+                }
+            }
+            return false;
+        }
         function checkCondition(node) {
             // Skip if already reported or if it's a part of a larger expression that's been reported
             if (reportedNodes.has(node) || evaluatedParentNodes.has(node)) {
                 return;
             }
+            // Check if this is a ternary expression used for default values
+            if (node.type === utils_1.AST_NODE_TYPES.ConditionalExpression &&
+                isDefaultValueTernary(node)) {
+                // Skip checking ternaries used for default values
+                return;
+            }
             // We should NOT clear evaluatedParentNodes here as that can lead to duplicate evaluations
             // and miss detection of conditions in nested expressions
             // Check for nested expressions to avoid multiple errors

package/lib/rules/no-complex-cloud-params.js

@@ -244,8 +244,10 @@ exports.noComplexCloudParams = (0, createRule_1.createRule)({
                         ['WeakMap', 'WeakSet', 'Promise', 'Error'].includes(node.object.name)) {
                         return true;
                     }
-                    // Check for circular references in member expressions
-                    return isComplexValue(node.object) || isComplexValue(node.property);
+                    // For property access expressions, we only need to check if the object itself is complex
+                    // We don't need to check the property, as accessing a property will result in a primitive value
+                    // or another object that we'll check separately
+                    return isComplexValue(node.object);
                 }
                 // Check for Symbols
                 if (node.type === utils_1.AST_NODE_TYPES.Identifier && node.name === 'Symbol') {

package/lib/rules/no-hungarian.js

@@ -34,6 +34,17 @@ const TYPE_MARKERS = [
     'Type',
     'Enum',
 ];
+// Allowed descriptive suffixes that should not be flagged as Hungarian notation
+const ALLOWED_SUFFIXES = [
+    'Formatted',
+    'Parsed',
+    'Processed',
+    'Transformed',
+    'Converted',
+    'Rendered',
+    'Display',
+    'Displayed',
+];
 // Common built-in JavaScript prototype methods
 const BUILT_IN_METHODS = new Set([
     // String methods
@@ -197,6 +208,12 @@ exports.noHungarian = (0, createRule_1.createRule)({
         const checkedIdentifiers = new Set();
         // Check if a variable name contains a type marker with proper word boundaries
         function hasTypeMarker(variableName) {
+            // Check if the variable name ends with one of the allowed descriptive suffixes
+            if (ALLOWED_SUFFIXES.some(suffix => variableName.endsWith(suffix) &&
+                variableName.length > suffix.length &&
+                /[a-z]/.test(variableName[variableName.length - suffix.length - 1]))) {
+                return false;
+            }
             const normalizedVarName = variableName.toLowerCase();
             // Handle SCREAMING_SNAKE_CASE separately
             if (variableName === variableName.toUpperCase() &&

package/lib/rules/no-margin-properties.d.ts

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

package/lib/rules/no-margin-properties.js

@@ -0,0 +1,307 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noMarginProperties = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+// Convert camelCase to kebab-case
+function toKebabCase(str) {
+    return str.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+}
+// Normalize property name to kebab-case for consistent lookup
+function normalizePropertyName(name) {
+    // If already contains hyphens, assume it's kebab-case
+    if (name.includes('-'))
+        return name.toLowerCase();
+    // Convert camelCase to kebab-case
+    return toKebabCase(name).toLowerCase();
+}
+// List of margin properties to flag
+const MARGIN_PROPERTIES = new Set([
+    'margin',
+    'margin-left',
+    'margin-right',
+    'margin-top',
+    'margin-bottom',
+    'marginleft',
+    'marginright',
+    'margintop',
+    'marginbottom',
+    'mx',
+    'my',
+    'mt',
+    'mr',
+    'mb',
+    'ml',
+    'm',
+]);
+exports.noMarginProperties = (0, createRule_1.createRule)({
+    name: 'no-margin-properties',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Discourage using margin properties (margin, marginLeft, marginRight, marginTop, marginBottom, mx, my, etc.) for spacing in MUI components. Instead, prefer defining spacing with padding, gap, or the spacing prop for more predictable layouts.',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            noMarginProperties: 'Avoid using {{property}} for spacing in MUI components. Use padding, gap, or the spacing prop instead for more predictable layouts. See https://www.youtube.com/watch?v=KVQMoEFUee8 for more details.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const seenNodes = new WeakSet();
+        function checkProperty(propertyName) {
+            const normalizedName = normalizePropertyName(propertyName);
+            return MARGIN_PROPERTIES.has(normalizedName);
+        }
+        // Check if a node is within an sx prop context or theme override context
+        function isMuiStylingContext(node) {
+            let current = node;
+            while (current?.parent) {
+                // Check for JSX sx attribute (MUI specific)
+                if (current.parent.type === utils_1.AST_NODE_TYPES.JSXAttribute &&
+                    current.parent.name.type === utils_1.AST_NODE_TYPES.JSXIdentifier &&
+                    current.parent.name.name === 'sx') {
+                    return true;
+                }
+                // Check for sx prop in object spread
+                if (current.parent.type === utils_1.AST_NODE_TYPES.Property &&
+                    current.parent.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    current.parent.key.name === 'sx') {
+                    return true;
+                }
+                // Check for theme overrides (MUI's createTheme)
+                if (current.parent.type === utils_1.AST_NODE_TYPES.Property &&
+                    current.parent.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    (current.parent.key.name === 'styleOverrides' ||
+                        current.parent.key.name === 'components')) {
+                    return true;
+                }
+                // Check for MUI's css function
+                if (current.parent.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                    current.parent.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    current.parent.callee.name === 'css') {
+                    return true;
+                }
+                // Skip if we're in a TypeScript type definition
+                if (current.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration ||
+                    current.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration ||
+                    current.type === utils_1.AST_NODE_TYPES.TSPropertySignature) {
+                    return false;
+                }
+                current = current.parent;
+            }
+            return false;
+        }
+        function checkNode(node) {
+            // Skip if we've already processed this node
+            if (seenNodes.has(node))
+                return;
+            seenNodes.add(node);
+            let propertyName = '';
+            // Get property name
+            if (node.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                propertyName = node.key.name;
+            }
+            else if (node.key.type === utils_1.AST_NODE_TYPES.Literal) {
+                propertyName = String(node.key.value);
+            }
+            else if (node.computed && node.key.type === utils_1.AST_NODE_TYPES.TemplateLiteral) {
+                // Handle template literals like [`${prop}Top`]
+                const quasis = node.key.quasis.map(q => q.value.raw).join('');
+                const expressions = node.key.expressions.map(exp => {
+                    if (exp.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        return exp.name;
+                    }
+                    return '';
+                }).join('');
+                propertyName = quasis + expressions;
+            }
+            if (propertyName && checkProperty(propertyName)) {
+                // Check if in MUI styling context
+                if (isMuiStylingContext(node)) {
+                    context.report({
+                        node,
+                        messageId: 'noMarginProperties',
+                        data: {
+                            property: propertyName,
+                        },
+                    });
+                }
+            }
+        }
+        // Check object expression for margin properties
+        function checkObjectExpression(objExp) {
+            objExp.properties.forEach(prop => {
+                if (prop.type === utils_1.AST_NODE_TYPES.Property) {
+                    checkNode(prop);
+                }
+                else if (prop.type === utils_1.AST_NODE_TYPES.SpreadElement &&
+                    prop.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    // Handle spread elements by looking up the variable
+                    const variableName = prop.argument.name;
+                    const scope = context.getScope();
+                    const variable = scope.variables.find(v => v.name === variableName);
+                    if (variable && variable.defs.length > 0) {
+                        const def = variable.defs[0];
+                        if (def.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                            def.node.init?.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                            checkObjectExpression(def.node.init);
+                        }
+                    }
+                }
+            });
+        }
+        return {
+            // Handle object literal properties (inline styles)
+            Property(node) {
+                if (node.parent?.type !== utils_1.AST_NODE_TYPES.ObjectExpression)
+                    return;
+                checkNode(node);
+            },
+            // Handle JSX sx attributes with object expressions
+            JSXAttribute(node) {
+                if (node.name.type !== utils_1.AST_NODE_TYPES.JSXIdentifier ||
+                    node.name.name !== 'sx')
+                    return;
+                if (node.value?.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer &&
+                    node.value.expression.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                    checkObjectExpression(node.value.expression);
+                }
+                else if (node.value?.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer &&
+                    node.value.expression.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    // Handle variable reference in sx prop
+                    const variableName = node.value.expression.name;
+                    const scope = context.getScope();
+                    const variable = scope.variables.find(v => v.name === variableName);
+                    if (variable && variable.defs.length > 0) {
+                        const def = variable.defs[0];
+                        if (def.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                            def.node.init?.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                            checkObjectExpression(def.node.init);
+                        }
+                    }
+                }
+                else if (node.value?.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer &&
+                    node.value.expression.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                    // Handle function-based sx props
+                    if (node.value.expression.body.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                        // Arrow function with object expression body
+                        checkObjectExpression(node.value.expression.body);
+                    }
+                    else if (node.value.expression.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+                        // Arrow function with block body
+                        const returnStatements = node.value.expression.body.body.filter(stmt => stmt.type === utils_1.AST_NODE_TYPES.ReturnStatement);
+                        returnStatements.forEach(returnStmt => {
+                            if (returnStmt.argument?.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                                checkObjectExpression(returnStmt.argument);
+                            }
+                        });
+                    }
+                }
+                else if (node.value?.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer &&
+                    node.value.expression.type === utils_1.AST_NODE_TYPES.ConditionalExpression) {
+                    // Handle conditional expressions in sx props
+                    if (node.value.expression.consequent.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                        checkObjectExpression(node.value.expression.consequent);
+                    }
+                    if (node.value.expression.alternate.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                        checkObjectExpression(node.value.expression.alternate);
+                    }
+                }
+            },
+            // Handle variable declarations that might be used in sx props
+            VariableDeclarator(node) {
+                if (node.init?.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
+                    node.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    const variableName = node.id.name;
+                    const sourceCode = context.getSourceCode().getText();
+                    // Check for margin properties in the object
+                    node.init.properties.forEach(prop => {
+                        if (prop.type === utils_1.AST_NODE_TYPES.Property) {
+                            let propertyName = '';
+                            if (prop.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                propertyName = prop.key.name;
+                            }
+                            else if (prop.key.type === utils_1.AST_NODE_TYPES.Literal) {
+                                propertyName = String(prop.key.value);
+                            }
+                            if (propertyName && checkProperty(propertyName)) {
+                                // Check if this variable is used in an sx prop
+                                if (sourceCode.includes(`sx={${variableName}}`) ||
+                                    sourceCode.includes(`sx={{ ...${variableName}`) ||
+                                    sourceCode.includes(`sx={Object.assign({}, ${variableName}`)) {
+                                    context.report({
+                                        node: prop,
+                                        messageId: 'noMarginProperties',
+                                        data: {
+                                            property: propertyName,
+                                        },
+                                    });
+                                }
+                            }
+                        }
+                    });
+                }
+            },
+            // Handle direct margin props on MUI components
+            JSXOpeningElement(node) {
+                node.attributes.forEach(attr => {
+                    if (attr.type === utils_1.AST_NODE_TYPES.JSXAttribute &&
+                        attr.name.type === utils_1.AST_NODE_TYPES.JSXIdentifier) {
+                        const attrName = attr.name.name;
+                        if (checkProperty(attrName)) {
+                            context.report({
+                                node: attr,
+                                messageId: 'noMarginProperties',
+                                data: {
+                                    property: attrName,
+                                },
+                            });
+                        }
+                    }
+                });
+            },
+            // Handle MUI's css function
+            CallExpression(node) {
+                if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.callee.name === 'css' &&
+                    node.arguments.length > 0) {
+                    const arg = node.arguments[0];
+                    if (arg.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                        checkObjectExpression(arg);
+                    }
+                }
+                // Handle createTheme for MUI theme overrides
+                if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.callee.name === 'createTheme' &&
+                    node.arguments.length > 0 &&
+                    node.arguments[0].type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                    const themeObj = node.arguments[0];
+                    // Find components property in theme object
+                    const componentsProperty = themeObj.properties.find(prop => prop.type === utils_1.AST_NODE_TYPES.Property &&
+                        prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        prop.key.name === 'components' &&
+                        prop.value.type === utils_1.AST_NODE_TYPES.ObjectExpression);
+                    if (componentsProperty && componentsProperty.value.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                        // Check each component override
+                        componentsProperty.value.properties.forEach(componentProp => {
+                            if (componentProp.type === utils_1.AST_NODE_TYPES.Property &&
+                                componentProp.value.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                                // Find styleOverrides property
+                                const styleOverrides = componentProp.value.properties.find(prop => prop.type === utils_1.AST_NODE_TYPES.Property &&
+                                    prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                    prop.key.name === 'styleOverrides' &&
+                                    prop.value.type === utils_1.AST_NODE_TYPES.ObjectExpression);
+                                if (styleOverrides && styleOverrides.value.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                                    checkObjectExpression(styleOverrides.value);
+                                }
+                            }
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-margin-properties.js.map

package/lib/rules/no-type-assertion-returns.js

@@ -98,6 +98,24 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
     defaultOptions: [defaultOptions],
     create(context, [options]) {
         const mergedOptions = { ...defaultOptions, ...options };
+        /**
+         * Checks if a node is inside a JSX attribute or object property (which could be JSX props)
+         */
+        function isInsideJSXAttributeOrObjectProperty(node) {
+            let current = node;
+            while (current?.parent) {
+                // Direct JSX attribute
+                if (current.parent.type === utils_1.AST_NODE_TYPES.JSXAttribute) {
+                    return true;
+                }
+                // Object property (which could be JSX props)
+                if (current.parent.type === utils_1.AST_NODE_TYPES.Property) {
+                    return true;
+                }
+                current = current.parent;
+            }
+            return false;
+        }
         /**
          * Common function to check if a type assertion should be allowed
          */
@@ -136,13 +154,31 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
                 return true;
             }
             // Allow type assertions within conditional expressions, but only if they're not part of a return statement
-            if (node.parent?.type === utils_1.AST_NODE_TYPES.ConditionalExpression && !isInsideReturnStatement(node)) {
+            if (node.parent?.type === utils_1.AST_NODE_TYPES.ConditionalExpression &&
+                !isInsideReturnStatement(node)) {
                 return true;
             }
             // Allow type assertions used to access properties in conditional contexts
             if (isPropertyAccess(node) && isInsideConditionalStatement(node)) {
                 return true;
             }
+            // Allow type assertions in object instantiations (as constructor arguments)
+            if (node.parent?.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
+                node.parent.parent?.type === utils_1.AST_NODE_TYPES.NewExpression) {
+                return true;
+            }
+            // Allow type assertions as arguments to constructors
+            if (node.parent?.type === utils_1.AST_NODE_TYPES.NewExpression) {
+                return true;
+            }
+            // Allow type assertions in JSX attributes/props or object properties
+            if (isInsideJSXAttributeOrObjectProperty(node)) {
+                return true;
+            }
+            // Only flag type assertions in return statements
+            if (!isInsideReturnStatement(node)) {
+                return true;
+            }
             return false;
         }
         /**
@@ -152,11 +188,13 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
             if (!node.returnType)
                 return;
             // Allow type predicates if configured
-            if (mergedOptions.allowTypePredicates && isTypePredicate(node.returnType)) {
+            if (mergedOptions.allowTypePredicates &&
+                isTypePredicate(node.returnType)) {
                 return;
             }
             // If type predicates are not allowed, report them
-            if (!mergedOptions.allowTypePredicates && isTypePredicate(node.returnType)) {
+            if (!mergedOptions.allowTypePredicates &&
+                isTypePredicate(node.returnType)) {
                 context.report({
                     node: node.returnType,
                     messageId: 'useExplicitVariable',
@@ -166,7 +204,8 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
             // Check if the function has a return statement with a direct value (not a variable)
             if (node.body && node.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
                 for (const statement of node.body.body) {
-                    if (statement.type === utils_1.AST_NODE_TYPES.ReturnStatement && statement.argument) {
+                    if (statement.type === utils_1.AST_NODE_TYPES.ReturnStatement &&
+                        statement.argument) {
                         // If returning a variable reference, that's fine
                         if (statement.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
                             continue;
@@ -233,11 +272,13 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
                     // Check for explicit return type
                     if (node.returnType) {
                         // Allow type predicates if configured
-                        if (mergedOptions.allowTypePredicates && isTypePredicate(node.returnType)) {
+                        if (mergedOptions.allowTypePredicates &&
+                            isTypePredicate(node.returnType)) {
                             return;
                         }
                         // If type predicates are not allowed, report them
-                        if (!mergedOptions.allowTypePredicates && isTypePredicate(node.returnType)) {
+                        if (!mergedOptions.allowTypePredicates &&
+                            isTypePredicate(node.returnType)) {
                             context.report({
                                 node: node.returnType,
                                 messageId: 'useExplicitVariable',

package/lib/rules/prefer-usecallback-over-usememo-for-functions.d.ts

@@ -0,0 +1,8 @@
+type Options = [
+    {
+        allowComplexBodies?: boolean;
+        allowFunctionFactories?: boolean;
+    }
+];
+export declare const preferUseCallbackOverUseMemoForFunctions: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"preferUseCallback", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export default preferUseCallbackOverUseMemoForFunctions;

package/lib/rules/prefer-usecallback-over-usememo-for-functions.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferUseCallbackOverUseMemoForFunctions = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.preferUseCallbackOverUseMemoForFunctions = (0, createRule_1.createRule)({
+    name: 'prefer-usecallback-over-usememo-for-functions',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce using useCallback instead of useMemo for memoizing functions',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allowComplexBodies: {
+                        type: 'boolean',
+                        default: true,
+                    },
+                    allowFunctionFactories: {
+                        type: 'boolean',
+                        default: true,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            preferUseCallback: 'Use useCallback instead of useMemo for memoizing functions',
+        },
+    },
+    defaultOptions: [{ allowComplexBodies: false, allowFunctionFactories: true }],
+    create(context) {
+        const options = context.options[0] || { allowComplexBodies: false, allowFunctionFactories: true };
+        /**
+         * Checks if a node is a function factory (returns an object with functions or a function that generates functions)
+         */
+        function isFunctionFactory(node) {
+            // If we're not checking for function factories, return false
+            if (!options.allowFunctionFactories) {
+                return false;
+            }
+            // For arrow functions with implicit return
+            if (node.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+                // Check if it's returning an object literal
+                if (node.body.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                    // Check if any property in the object is a function
+                    return node.body.properties.some((prop) => {
+                        if (prop.type === utils_1.AST_NODE_TYPES.Property) {
+                            const value = prop.value;
+                            return (value.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                                value.type === utils_1.AST_NODE_TYPES.FunctionExpression);
+                        }
+                        return false;
+                    });
+                }
+                return false;
+            }
+            // For arrow functions with block body
+            if (node.body.body.length === 1 &&
+                node.body.body[0].type === utils_1.AST_NODE_TYPES.ReturnStatement &&
+                node.body.body[0].argument) {
+                const returnValue = node.body.body[0].argument;
+                // Check if returning an object literal with functions
+                if (returnValue.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                    return returnValue.properties.some((prop) => {
+                        if (prop.type === utils_1.AST_NODE_TYPES.Property) {
+                            const value = prop.value;
+                            return (value.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                                value.type === utils_1.AST_NODE_TYPES.FunctionExpression);
+                        }
+                        return false;
+                    });
+                }
+            }
+            return false;
+        }
+        /**
+         * Checks if a function body is complex (more than one statement before returning)
+         */
+        function hasComplexBody(node) {
+            if (node.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+                return false;
+            }
+            // If there's more than one statement, or the single statement isn't a return
+            if (node.body.body.length > 1 ||
+                (node.body.body.length === 1 && node.body.body[0].type !== utils_1.AST_NODE_TYPES.ReturnStatement)) {
+                return true;
+            }
+            return false;
+        }
+        /**
+         * Checks if a node returns a function
+         */
+        function returnsFunction(node) {
+            // For arrow functions with implicit return
+            if (node.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+                return (node.body.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                    node.body.type === utils_1.AST_NODE_TYPES.FunctionExpression);
+            }
+            // For arrow functions with block body
+            if (node.body.body.length === 1 &&
+                node.body.body[0].type === utils_1.AST_NODE_TYPES.ReturnStatement &&
+                node.body.body[0].argument) {
+                const returnValue = node.body.body[0].argument;
+                return (returnValue.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                    returnValue.type === utils_1.AST_NODE_TYPES.FunctionExpression);
+            }
+            return false;
+        }
+        return {
+            CallExpression(node) {
+                // Check if the call is to useMemo
+                if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.callee.name === 'useMemo' &&
+                    node.arguments.length > 0) {
+                    const callback = node.arguments[0];
+                    // Check if the callback is an arrow function or function expression
+                    if ((callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                        callback.type === utils_1.AST_NODE_TYPES.FunctionExpression) &&
+                        callback.body) {
+                        // Skip if it's a function factory and we're allowing those
+                        if (isFunctionFactory(callback)) {
+                            return;
+                        }
+                        // Skip if it has a complex body and we're allowing those
+                        if (hasComplexBody(callback) && options.allowComplexBodies) {
+                            return;
+                        }
+                        // Check if it returns a function
+                        if (returnsFunction(callback)) {
+                            reportAndFix(node, context);
+                        }
+                    }
+                }
+            },
+        };
+    },
+});
+function reportAndFix(node, context) {
+    const sourceCode = context.getSourceCode();
+    const useMemoCallback = node.arguments[0];
+    const dependencyArray = node.arguments[1] ? sourceCode.getText(node.arguments[1]) : '[]';
+    // Get the returned function from useMemo
+    let returnedFunction;
+    if (useMemoCallback.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+        // For block body arrow functions or function expressions
+        const returnStatement = useMemoCallback.body.body[0];
+        returnedFunction = returnStatement.argument;
+    }
+    else {
+        // For implicit return arrow functions
+        returnedFunction = useMemoCallback.body;
+    }
+    // Create the useCallback replacement
+    const returnedFunctionText = sourceCode.getText(returnedFunction);
+    // Check if useMemo has TypeScript generic type parameters
+    const hasTypeParameters = node.typeParameters !== undefined;
+    const typeParametersText = hasTypeParameters ? sourceCode.getText(node.typeParameters) : '';
+    context.report({
+        node,
+        messageId: 'preferUseCallback',
+        fix: (fixer) => {
+            return fixer.replaceText(node, `useCallback${typeParametersText}(${returnedFunctionText}, ${dependencyArray})`);
+        },
+    });
+}
+exports.default = exports.preferUseCallbackOverUseMemoForFunctions;
+//# sourceMappingURL=prefer-usecallback-over-usememo-for-functions.js.map

package/lib/rules/react-usememo-should-be-component.js

@@ -15,6 +15,71 @@ const isJsxElement = (node) => {
     return (node.type === utils_1.AST_NODE_TYPES.JSXElement ||
         node.type === utils_1.AST_NODE_TYPES.JSXFragment);
 };
+/**
+ * Checks if a variable is used multiple times in a component
+ */
+const isUsedMultipleTimes = (variableName, node) => {
+    // Find the function component that contains this node
+    let currentNode = node;
+    let functionNode;
+    // Walk up the AST to find the function component
+    while (currentNode.parent) {
+        currentNode = currentNode.parent;
+        if (currentNode.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+            currentNode.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+            currentNode.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+            functionNode = currentNode;
+            break;
+        }
+    }
+    if (!functionNode) {
+        return false;
+    }
+    // Count occurrences of the variable in the function body
+    let count = 0;
+    // Function to recursively search for references to the variable
+    const findReferences = (searchNode) => {
+        if (!searchNode)
+            return;
+        // Check if this node is a reference to our variable
+        if (searchNode.type === utils_1.AST_NODE_TYPES.Identifier &&
+            searchNode.name === variableName &&
+            // Exclude the declaration itself
+            !(searchNode.parent &&
+                searchNode.parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                searchNode.parent.id === searchNode)) {
+            count++;
+        }
+        // Recursively check all properties of the node
+        for (const key in searchNode) {
+            if (key === 'parent')
+                continue; // Skip parent to avoid circular references
+            const child = searchNode[key];
+            if (child && typeof child === 'object') {
+                if (Array.isArray(child)) {
+                    child.forEach(item => {
+                        if (item && typeof item === 'object') {
+                            findReferences(item);
+                        }
+                    });
+                }
+                else {
+                    findReferences(child);
+                }
+            }
+        }
+    };
+    // Start the search from the function body
+    if (functionNode.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+        findReferences(functionNode.body);
+    }
+    else if (functionNode.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+        functionNode.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+        findReferences(functionNode.body);
+    }
+    // Return true if the variable is referenced more than once
+    return count > 1;
+};
 /**
  * Checks if an object contains JSX elements in its properties
  */
@@ -338,6 +403,17 @@ exports.reactUseMemoShouldBeComponent = (0, createRule_1.createRule)({
         return {
             CallExpression(node) {
                 if (containsJsxInUseMemo(node)) {
+                    // Check if this is a variable declaration
+                    if (node.parent &&
+                        node.parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                        node.parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        const variableName = node.parent.id.name;
+                        // Check if the variable is used multiple times in the component
+                        if (isUsedMultipleTimes(variableName, node)) {
+                            // If the variable is used multiple times, allow it
+                            return;
+                        }
+                    }
                     context.report({
                         node,
                         messageId: 'useMemoShouldBeComponent',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "1.9.1",
+  "version": "1.10.0",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",