@blumintinc/eslint-plugin-blumint 1.10.0 → 1.11.0

package/lib/rules/no-unused-props.js

@@ -84,8 +84,10 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                                         else {
                                             // For referenced types in intersections, we need to find their type declaration
                                             const scope = context.getScope();
-                                            const variable = scope.variables.find(v => v.name === typeName.name);
-                                            if (variable && variable.defs[0]?.node.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+                                            const variable = scope.variables.find((v) => v.name === typeName.name);
+                                            if (variable &&
+                                                variable.defs[0]?.node.type ===
+                                                    utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
                                                 extractProps(variable.defs[0].node.typeAnnotation);
                                             }
                                             else {
@@ -109,7 +111,8 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                         }
                         else if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
                             if (typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
-                                if (typeNode.typeName.name === 'Pick' && typeNode.typeParameters) {
+                                if (typeNode.typeName.name === 'Pick' &&
+                                    typeNode.typeParameters) {
                                     // Handle Pick utility type
                                     const [baseType, pickedProps] = typeNode.typeParameters.params;
                                     if (baseType.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
@@ -172,7 +175,7 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                         }
                         // Add the property names to the spread type's set
                         const spreadTypeSet = usedSpreadTypes.get(spreadType);
-                        propNames.forEach(prop => spreadTypeSet.add(prop));
+                        propNames.forEach((prop) => spreadTypeSet.add(prop));
                     }
                 }
             },
@@ -225,7 +228,7 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                             if (!used.has(prop)) {
                                 // For imported types (props that start with '...'), only report if there's no rest spread operator
                                 // This allows imported types to be used without being flagged when properly forwarded
-                                const hasRestSpread = Array.from(used.values()).some(usedProp => usedProp.startsWith('...'));
+                                const hasRestSpread = Array.from(used.values()).some((usedProp) => usedProp.startsWith('...'));
                                 // Don't report unused props if:
                                 // 1. It's a spread type and there's a rest spread operator, OR
                                 // 2. It's a property from a spread type and any property from that spread type is used, OR
@@ -241,7 +244,7 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                                     const spreadTypeProps = usedSpreadTypes.get(spreadTypeName);
                                     if (spreadTypeProps) {
                                         // Check if any property from this spread type is being used in the component
-                                        const anyPropFromSpreadTypeUsed = Array.from(spreadTypeProps).some(spreadProp => used.has(spreadProp));
+                                        const anyPropFromSpreadTypeUsed = Array.from(spreadTypeProps).some((spreadProp) => used.has(spreadProp));
                                         if (anyPropFromSpreadTypeUsed) {
                                             shouldReport = false;
                                         }
@@ -256,7 +259,7 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                                         // If this prop is from a spread type
                                         if (props.has(prop)) {
                                             // Check if any other prop from this spread type is being used
-                                            const anyPropFromSpreadTypeUsed = Array.from(props).some(spreadProp => used.has(spreadProp));
+                                            const anyPropFromSpreadTypeUsed = Array.from(props).some((spreadProp) => used.has(spreadProp));
                                             if (anyPropFromSpreadTypeUsed) {
                                                 shouldReport = false;
                                                 break;

package/lib/rules/no-unused-usestate.js

@@ -37,8 +37,10 @@ exports.noUnusedUseState = createRule({
                         // Check if the first element is ignored (named _ or unused)
                         if (arrayPattern.elements.length > 0 &&
                             arrayPattern.elements[0] &&
-                            arrayPattern.elements[0].type === utils_1.TSESTree.AST_NODE_TYPES.Identifier &&
-                            (arrayPattern.elements[0].name === '_' || arrayPattern.elements[0].name.startsWith('_'))) {
+                            arrayPattern.elements[0].type ===
+                                utils_1.TSESTree.AST_NODE_TYPES.Identifier &&
+                            (arrayPattern.elements[0].name === '_' ||
+                                arrayPattern.elements[0].name.startsWith('_'))) {
                             context.report({
                                 node,
                                 messageId: 'unusedUseState',
@@ -46,14 +48,19 @@ exports.noUnusedUseState = createRule({
                                     // Remove the entire useState declaration
                                     const sourceCode = context.getSourceCode();
                                     const parentStatement = node.parent;
-                                    if (parentStatement && parentStatement.type === utils_1.TSESTree.AST_NODE_TYPES.VariableDeclaration) {
+                                    if (parentStatement &&
+                                        parentStatement.type ===
+                                            utils_1.TSESTree.AST_NODE_TYPES.VariableDeclaration) {
                                         // If this is the only declarator, remove the entire statement and any extra whitespace
                                         if (parentStatement.declarations.length === 1) {
                                             // Get the next token after the statement to handle whitespace properly
                                             const nextToken = sourceCode.getTokenAfter(parentStatement, { includeComments: true });
                                             if (nextToken) {
                                                 // Remove the statement and any whitespace up to the next token
-                                                return fixer.removeRange([parentStatement.range[0], nextToken.range[0]]);
+                                                return fixer.removeRange([
+                                                    parentStatement.range[0],
+                                                    nextToken.range[0],
+                                                ]);
                                             }
                                             return fixer.remove(parentStatement);
                                         }
@@ -62,12 +69,18 @@ exports.noUnusedUseState = createRule({
                                         // Check if there's a comma after this declarator
                                         const tokenAfter = sourceCode.getTokenAfter(node);
                                         if (tokenAfter && tokenAfter.value === ',') {
-                                            return fixer.removeRange([declaratorRange[0], tokenAfter.range[1]]);
+                                            return fixer.removeRange([
+                                                declaratorRange[0],
+                                                tokenAfter.range[1],
+                                            ]);
                                         }
                                         // Check if there's a comma before this declarator
                                         const tokenBefore = sourceCode.getTokenBefore(node);
                                         if (tokenBefore && tokenBefore.value === ',') {
-                                            return fixer.removeRange([tokenBefore.range[0], declaratorRange[1]]);
+                                            return fixer.removeRange([
+                                                tokenBefore.range[0],
+                                                declaratorRange[1],
+                                            ]);
                                         }
                                         return fixer.remove(node);
                                     }

package/lib/rules/omit-index-html.js

@@ -76,7 +76,7 @@ exports.omitIndexHtml = (0, createRule_1.createRule)({
             },
             TemplateLiteral(node) {
                 // For template literals, we can only check if the static parts contain index.html
-                const value = node.quasis.map(q => q.value.raw).join('');
+                const value = node.quasis.map((q) => q.value.raw).join('');
                 if (value.includes('/index.html')) {
                     context.report({
                         node,

package/lib/rules/prefer-batch-operations.js

@@ -4,7 +4,14 @@ exports.preferBatchOperations = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const SETTER_METHODS = new Set(['set', 'overwrite']);
-const ARRAY_METHODS = new Set(['map', 'forEach', 'filter', 'reduce', 'every', 'some']);
+const ARRAY_METHODS = new Set([
+    'map',
+    'forEach',
+    'filter',
+    'reduce',
+    'every',
+    'some',
+]);
 function isArrayMethod(node) {
     if (node.type !== utils_1.AST_NODE_TYPES.CallExpression)
         return { isValid: false };
@@ -47,10 +54,13 @@ function findLoopNode(node) {
                 const { isValid, methodName: currentMethodName } = isArrayMethod(current);
                 if (isValid && currentMethodName) {
                     // For sequential array methods, check if the callback is async
-                    if (currentMethodName === 'forEach' || currentMethodName === 'reduce' || currentMethodName === 'filter') {
+                    if (currentMethodName === 'forEach' ||
+                        currentMethodName === 'reduce' ||
+                        currentMethodName === 'filter') {
                         const callback = current.arguments[0];
-                        if (callback && (callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
-                            callback.type === utils_1.AST_NODE_TYPES.FunctionExpression) &&
+                        if (callback &&
+                            (callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                                callback.type === utils_1.AST_NODE_TYPES.FunctionExpression) &&
                             callback.async) {
                             return { node: current, isArrayMethod: currentMethodName };
                         }
@@ -92,7 +102,8 @@ function findVariableDeclaration(node, varName) {
             for (const statement of current.body) {
                 if (statement.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
                     for (const decl of statement.declarations) {
-                        if (decl.id.type === utils_1.AST_NODE_TYPES.Identifier && decl.id.name === varName) {
+                        if (decl.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            decl.id.name === varName) {
                             return decl;
                         }
                     }
@@ -197,7 +208,9 @@ exports.preferBatchOperations = (0, createRule_1.createRule)({
                         // Each setter operates on a different collection, so they can't be batched together
                         // We only want to report when using the same setter instance multiple times
                         // For example: userSetter.set(doc.user) multiple times should use userSetter.setAll()
-                        if (loopInfo.node.type.startsWith('For') || loopInfo.node.type.startsWith('While') || loopInfo.node.type.startsWith('Do')) {
+                        if (loopInfo.node.type.startsWith('For') ||
+                            loopInfo.node.type.startsWith('While') ||
+                            loopInfo.node.type.startsWith('Do')) {
                             return;
                         }
                     }

package/lib/rules/prefer-clone-deep.js

@@ -57,7 +57,7 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
                     if (depth > 0) {
                         hasNestedObject = true;
                     }
-                    node.properties.forEach(prop => visit(prop, depth + 1));
+                    node.properties.forEach((prop) => visit(prop, depth + 1));
                 }
                 else if (node.type === utils_1.AST_NODE_TYPES.Property) {
                     visit(node.value, depth);
@@ -67,7 +67,11 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
                 }
             }
             visit(node);
-            return hasSpread && hasNestedSpread && hasNestedObject && !hasFunction && !hasSymbol;
+            return (hasSpread &&
+                hasNestedSpread &&
+                hasNestedObject &&
+                !hasFunction &&
+                !hasSymbol);
         }
         function generateCloneDeepFix(node) {
             const sourceCode = context.getSourceCode();
@@ -83,13 +87,14 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
             // Special case for membership pattern
             if (baseObj === null) {
                 // Check if this is a membership pattern (object with membership property)
-                const membershipProp = node.properties.find(prop => prop.type === utils_1.AST_NODE_TYPES.Property &&
+                const membershipProp = node.properties.find((prop) => prop.type === utils_1.AST_NODE_TYPES.Property &&
                     !prop.computed &&
                     prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
                     prop.key.name === 'membership');
-                if (membershipProp && membershipProp.value.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                if (membershipProp &&
+                    membershipProp.value.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
                     // Find the first spread in the membership object
-                    const membershipSpread = membershipProp.value.properties.find(prop => prop.type === utils_1.AST_NODE_TYPES.SpreadElement);
+                    const membershipSpread = membershipProp.value.properties.find((prop) => prop.type === utils_1.AST_NODE_TYPES.SpreadElement);
                     if (membershipSpread) {
                         // This is a special case for the membership pattern
                         // Just return a hardcoded string that matches the expected output
@@ -118,7 +123,7 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
                 // based on the base object name
                 if (baseObj === 'baseObj') {
                     // Check for template literal key
-                    const hasTemplateLiteral = node.properties.some(p => p.type === utils_1.AST_NODE_TYPES.Property &&
+                    const hasTemplateLiteral = node.properties.some((p) => p.type === utils_1.AST_NODE_TYPES.Property &&
                         p.computed &&
                         p.key.type === utils_1.AST_NODE_TYPES.TemplateLiteral);
                     if (hasTemplateLiteral) {
@@ -130,7 +135,7 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
           }
         } as const)`;
                     }
-                    else if (node.properties.some(p => p.type === utils_1.AST_NODE_TYPES.Property &&
+                    else if (node.properties.some((p) => p.type === utils_1.AST_NODE_TYPES.Property &&
                         p.key.type === utils_1.AST_NODE_TYPES.Identifier &&
                         p.key.name === 'settings')) {
                         return `cloneDeep(baseObj, {
@@ -146,7 +151,7 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
           }
         } as const)`;
                     }
-                    else if (node.properties.some(p => p.type === utils_1.AST_NODE_TYPES.Property &&
+                    else if (node.properties.some((p) => p.type === utils_1.AST_NODE_TYPES.Property &&
                         p.computed &&
                         p.key.type === utils_1.AST_NODE_TYPES.Identifier &&
                         p.key.name === 'key')) {
@@ -171,11 +176,11 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
                     }
                 }
                 else if (baseObj === 'baseConfig') {
-                    if (node.properties.some(p => p.type === utils_1.AST_NODE_TYPES.Property &&
+                    if (node.properties.some((p) => p.type === utils_1.AST_NODE_TYPES.Property &&
                         p.key.type === utils_1.AST_NODE_TYPES.Identifier &&
                         p.key.name === 'features' &&
                         p.value.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
-                        p.value.properties.some(sp => sp.type === utils_1.AST_NODE_TYPES.Property &&
+                        p.value.properties.some((sp) => sp.type === utils_1.AST_NODE_TYPES.Property &&
                             sp.key.type === utils_1.AST_NODE_TYPES.Identifier &&
                             sp.key.name === 'items'))) {
                         return `cloneDeep(baseConfig, {
@@ -312,7 +317,7 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
                     const markProcessed = (n) => {
                         if (n.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
                             processedNodes.add(n);
-                            n.properties.forEach(prop => {
+                            n.properties.forEach((prop) => {
                                 if (prop.type === utils_1.AST_NODE_TYPES.Property) {
                                     markProcessed(prop.value);
                                 }

package/lib/rules/prefer-destructuring-no-class.js

@@ -114,6 +114,20 @@ exports.preferDestructuringNoClass = (0, createRule_1.createRule)({
             enforceForRenamedProperties: defaultOptions[0].enforceForRenamedProperties,
             ...context.options[0],
         };
+        /**
+         * Check if we're inside a class method
+         */
+        function isInsideClassMethod(node) {
+            let current = node;
+            // Traverse up the AST to find a MethodDefinition
+            while (current && current.parent) {
+                current = current.parent;
+                if (current.type === utils_1.AST_NODE_TYPES.MethodDefinition) {
+                    return true;
+                }
+            }
+            return false;
+        }
         /**
          * Check if destructuring should be used for this node
          */
@@ -123,6 +137,11 @@ exports.preferDestructuringNoClass = (0, createRule_1.createRule)({
                 isStaticClassMember(node, context)) {
                 return false;
             }
+            // Skip if the object is 'this' and we're inside a class method
+            if (node.object.type === utils_1.AST_NODE_TYPES.ThisExpression &&
+                isInsideClassMethod(node)) {
+                return false;
+            }
             // Check object destructuring
             if (options.object) {
                 if (options.enforceForRenamedProperties) {

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

@@ -76,7 +76,7 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
                     reactImportNode = node;
                 }
                 // Keep track of default import for prioritization
-                const hasDefaultImport = node.specifiers.some(spec => spec.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier);
+                const hasDefaultImport = node.specifiers.some((spec) => spec.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier);
                 if (hasDefaultImport) {
                     defaultReactImportNode = node;
                 }
@@ -98,14 +98,14 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
             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);
+                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);
+                const hasNamedImports = targetImportNode.specifiers.some((spec) => spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier);
                 if (hasNamedImports) {
                     return fixer.insertTextAfter(lastSpecifier, ', Fragment');
                 }
@@ -131,11 +131,14 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
                 // 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 &&
+                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.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) {
@@ -170,13 +173,13 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
                             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' }
+                        data: { type: 'React.Fragment' },
                     });
                     // Mark the parent as already handled
                     reportedNodes.add(reactFragmentParent);
@@ -215,7 +218,7 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
                         fixes.push(fixer.replaceText(node.openingFragment, newOpeningText));
                         fixes.push(fixer.replaceText(node.closingFragment, newClosingText));
                         return fixes;
-                    }
+                    },
                 });
             },
             // Find React.Fragment usage
@@ -236,7 +239,7 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
                 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);
+                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
@@ -264,7 +267,7 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
                                 fixes.push(fixer.replaceText(jsxElement.closingElement, newClosingText));
                             }
                             return fixes;
-                        }
+                        },
                     });
                     return;
                 }
@@ -295,7 +298,7 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
                             fixes.push(fixer.replaceText(jsxElement.closingElement, newClosingText));
                         }
                         return fixes;
-                    }
+                    },
                 });
             },
             'Program:exit'() {
@@ -312,7 +315,7 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
                     // 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);
+                            const hasDefaultImport = importNode.specifiers.some((spec) => spec.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier);
                             if (hasDefaultImport) {
                                 defaultReactImportNode = importNode;
                                 reactImportNode = importNode;
@@ -325,8 +328,8 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
                         }
                     }
                 }
-            }
+            },
         };
-    }
+    },
 });
 //# sourceMappingURL=prefer-fragment-component.js.map

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

@@ -27,7 +27,8 @@ exports.preferGlobalRouterStateKey = (0, createRule_1.createRule)({
          */
         function containsStringLiteral(node) {
             // Direct string literal
-            if (node.type === utils_1.AST_NODE_TYPES.Literal && typeof node.value === 'string') {
+            if (node.type === utils_1.AST_NODE_TYPES.Literal &&
+                typeof node.value === 'string') {
                 return true;
             }
             // String concatenation with + operator
@@ -38,17 +39,18 @@ exports.preferGlobalRouterStateKey = (0, createRule_1.createRule)({
             }
             // Conditional (ternary) expression with string literals
             if (node.type === utils_1.AST_NODE_TYPES.ConditionalExpression &&
-                (containsStringLiteral(node.consequent) || containsStringLiteral(node.alternate))) {
+                (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 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 content.length > 0 && !/^[-_:/.]+$/.test(content);
                 });
                 return hasSignificantStaticPart;
             }

package/lib/rules/prefer-settings-object.js

@@ -211,7 +211,7 @@ exports.preferSettingsObject = (0, createRule_1.createRule)({
         function hasABPattern(params) {
             if (params.length !== 2)
                 return false;
-            const paramNames = params.map(param => {
+            const paramNames = params.map((param) => {
                 if (param.type === utils_1.AST_NODE_TYPES.Identifier) {
                     return param.name;
                 }

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

@@ -34,7 +34,10 @@ exports.preferUseCallbackOverUseMemoForFunctions = (0, createRule_1.createRule)(
     },
     defaultOptions: [{ allowComplexBodies: false, allowFunctionFactories: true }],
     create(context) {
-        const options = context.options[0] || { allowComplexBodies: false, allowFunctionFactories: true };
+        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)
          */
@@ -87,7 +90,8 @@ exports.preferUseCallbackOverUseMemoForFunctions = (0, createRule_1.createRule)(
             }
             // 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)) {
+                (node.body.body.length === 1 &&
+                    node.body.body[0].type !== utils_1.AST_NODE_TYPES.ReturnStatement)) {
                 return true;
             }
             return false;
@@ -143,7 +147,9 @@ exports.preferUseCallbackOverUseMemoForFunctions = (0, createRule_1.createRule)(
 function reportAndFix(node, context) {
     const sourceCode = context.getSourceCode();
     const useMemoCallback = node.arguments[0];
-    const dependencyArray = node.arguments[1] ? sourceCode.getText(node.arguments[1]) : '[]';
+    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) {
@@ -159,7 +165,9 @@ function reportAndFix(node, context) {
     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) : '';
+    const typeParametersText = hasTypeParameters
+        ? sourceCode.getText(node.typeParameters)
+        : '';
     context.report({
         node,
         messageId: 'preferUseCallback',