@blumintinc/eslint-plugin-blumint 1.9.1 → 1.11.0

package/lib/rules/no-mixed-firestore-transactions.js

@@ -38,7 +38,8 @@ exports.noMixedFirestoreTransactions = (0, createRule_1.createRule)({
             if (callee.type !== utils_1.AST_NODE_TYPES.MemberExpression)
                 return false;
             const property = callee.property;
-            return property.type === utils_1.AST_NODE_TYPES.Identifier && property.name === 'runTransaction';
+            return (property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                property.name === 'runTransaction');
         }
         function isNonTransactionalClass(node) {
             const callee = node.callee;
@@ -50,7 +51,8 @@ exports.noMixedFirestoreTransactions = (0, createRule_1.createRule)({
             if (param.type !== utils_1.AST_NODE_TYPES.Identifier)
                 return false;
             const typeAnnotation = param.typeAnnotation;
-            if (!typeAnnotation || typeAnnotation.type !== utils_1.AST_NODE_TYPES.TSTypeAnnotation)
+            if (!typeAnnotation ||
+                typeAnnotation.type !== utils_1.AST_NODE_TYPES.TSTypeAnnotation)
                 return false;
             const type = typeAnnotation.typeAnnotation;
             if (type.type !== utils_1.AST_NODE_TYPES.TSTypeReference)
@@ -58,8 +60,10 @@ exports.noMixedFirestoreTransactions = (0, createRule_1.createRule)({
             const typeName = type.typeName;
             if (typeName.type !== utils_1.AST_NODE_TYPES.TSQualifiedName)
                 return false;
-            return typeName.left.type === utils_1.AST_NODE_TYPES.Identifier && typeName.left.name === 'FirebaseFirestore' &&
-                typeName.right.type === utils_1.AST_NODE_TYPES.Identifier && typeName.right.name === 'Transaction';
+            return (typeName.left.type === utils_1.AST_NODE_TYPES.Identifier &&
+                typeName.left.name === 'FirebaseFirestore' &&
+                typeName.right.type === utils_1.AST_NODE_TYPES.Identifier &&
+                typeName.right.name === 'Transaction');
         }
         function isInTransactionScope(node) {
             let current = node;

package/lib/rules/no-mock-firebase-admin.js

@@ -48,7 +48,12 @@ exports.noMockFirebaseAdmin = (0, createRule_1.createRule)({
                     else if (node.arguments[0].type === utils_1.AST_NODE_TYPES.Literal) {
                         mockPath = String(node.arguments[0].value);
                     }
-                    const isFirebaseAdminMock = FIREBASE_ADMIN_PATHS.some(path => mockPath.endsWith(path) && !mockPath.endsWith('Helper') && !mockPath.endsWith('utils') && !mockPath.endsWith('test') && !mockPath.endsWith('mock') && !mockPath.endsWith('jest-mock'));
+                    const isFirebaseAdminMock = FIREBASE_ADMIN_PATHS.some((path) => mockPath.endsWith(path) &&
+                        !mockPath.endsWith('Helper') &&
+                        !mockPath.endsWith('utils') &&
+                        !mockPath.endsWith('test') &&
+                        !mockPath.endsWith('mock') &&
+                        !mockPath.endsWith('jest-mock'));
                     if (isFirebaseAdminMock) {
                         context.report({
                             node,

package/lib/rules/no-object-values-on-strings.js

@@ -43,16 +43,17 @@ exports.noObjectValuesOnStrings = (0, createRule_1.createRule)({
          */
         function isOrContainsStringType(type) {
             // Check if it's a string type
-            if (type.flags & ts.TypeFlags.String || type.flags & ts.TypeFlags.StringLiteral) {
+            if (type.flags & ts.TypeFlags.String ||
+                type.flags & ts.TypeFlags.StringLiteral) {
                 return true;
             }
             // Check if it's a union type that contains string
             if (type.isUnion()) {
-                return type.types.some(t => isOrContainsStringType(t));
+                return type.types.some((t) => isOrContainsStringType(t));
             }
             // Check if it's an intersection type that contains string
             if (type.isIntersection()) {
-                return type.types.some(t => isOrContainsStringType(t));
+                return type.types.some((t) => isOrContainsStringType(t));
             }
             return false;
         }
@@ -71,7 +72,8 @@ exports.noObjectValuesOnStrings = (0, createRule_1.createRule)({
          * Checks if a node is a string literal or template literal
          */
         function isStringLiteral(node) {
-            return ((node.type === utils_1.AST_NODE_TYPES.Literal && typeof node.value === 'string') ||
+            return ((node.type === utils_1.AST_NODE_TYPES.Literal &&
+                typeof node.value === 'string') ||
                 node.type === utils_1.AST_NODE_TYPES.TemplateLiteral);
         }
         /**
@@ -90,7 +92,20 @@ exports.noObjectValuesOnStrings = (0, createRule_1.createRule)({
                 (isStringLiteral(node.callee.object) ||
                     (node.callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
                         node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        ['toString', 'toUpperCase', 'toLowerCase', 'trim', 'substring', 'slice', 'charAt', 'concat', 'replace', 'replaceAll', 'padStart', 'padEnd'].includes(node.callee.property.name)))) {
+                        [
+                            'toString',
+                            'toUpperCase',
+                            'toLowerCase',
+                            'trim',
+                            'substring',
+                            'slice',
+                            'charAt',
+                            'concat',
+                            'replace',
+                            'replaceAll',
+                            'padStart',
+                            'padEnd',
+                        ].includes(node.callee.property.name)))) {
                 return true;
             }
             // Check for common string-producing functions
@@ -152,7 +167,8 @@ exports.noObjectValuesOnStrings = (0, createRule_1.createRule)({
                 // Handle object pattern parameters
                 if (param.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
                     for (const property of param.properties) {
-                        if (property.type === utils_1.AST_NODE_TYPES.Property && property.value.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        if (property.type === utils_1.AST_NODE_TYPES.Property &&
+                            property.value.type === utils_1.AST_NODE_TYPES.Identifier) {
                             try {
                                 const tsNode = parserServices.esTreeNodeToTSNodeMap.get(property.value);
                                 const type = checker.getTypeAtLocation(tsNode);
@@ -213,7 +229,8 @@ exports.noObjectValuesOnStrings = (0, createRule_1.createRule)({
                         if (argument.type === utils_1.AST_NODE_TYPES.ConditionalExpression) {
                             const consequentType = checker.getTypeAtLocation(parserServices.esTreeNodeToTSNodeMap.get(argument.consequent));
                             const alternateType = checker.getTypeAtLocation(parserServices.esTreeNodeToTSNodeMap.get(argument.alternate));
-                            if (couldBeString(consequentType) || couldBeString(alternateType)) {
+                            if (couldBeString(consequentType) ||
+                                couldBeString(alternateType)) {
                                 context.report({
                                     node,
                                     messageId: 'unexpected',
@@ -251,7 +268,8 @@ exports.noObjectValuesOnStrings = (0, createRule_1.createRule)({
                     });
                 }
                 // For arrow functions with expression bodies
-                else if (node.body && node.body.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                else if (node.body &&
+                    node.body.type === utils_1.AST_NODE_TYPES.CallExpression &&
                     isObjectValuesCall(node.body)) {
                     objectValuesCalls.push(node.body);
                 }
@@ -263,8 +281,8 @@ exports.noObjectValuesOnStrings = (0, createRule_1.createRule)({
                         if (argument.type === utils_1.AST_NODE_TYPES.Identifier) {
                             // Check if this identifier is one of the function parameters
                             const paramNames = node.params
-                                .filter(p => p.type === utils_1.AST_NODE_TYPES.Identifier)
-                                .map(p => p.name);
+                                .filter((p) => p.type === utils_1.AST_NODE_TYPES.Identifier)
+                                .map((p) => p.name);
                             if (paramNames.includes(argument.name)) {
                                 context.report({
                                     node: call,

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/no-unnecessary-destructuring.js

@@ -62,7 +62,7 @@ exports.noUnnecessaryDestructuring = (0, createRule_1.createRule)({
                         },
                     });
                 }
-            }
+            },
         };
     },
 });

package/lib/rules/no-unnecessary-verb-suffix.js

@@ -14,23 +14,6 @@ const COMMON_PREPOSITION_SUFFIXES = new Set([
     'On',
     'At',
     'Of',
-    // Directional prepositions
-    'Above',
-    'Below',
-    'Over',
-    'Under',
-    'Up',
-    'Down',
-    'Into',
-    'Onto',
-    'Out',
-    'Off',
-    'Through',
-    'Throughout',
-    'Across',
-    'Along',
-    'Around',
-    'Past',
     // Temporal prepositions
     'After',
     'Before',
@@ -49,22 +32,8 @@ const COMMON_PREPOSITION_SUFFIXES = new Set([
     'Vs',
     // Comparative prepositions
     'Than',
-    'Like',
     'As',
-    // Compound prepositions
-    'According',
-    'Ahead',
-    'Apart',
-    'Aside',
-    'Away',
-    'Back',
-    'Forward',
-    'Backward',
-    'Inside',
-    'Outside',
-    'Together',
     // Phrasal prepositions (common endings)
-    'About',
     'Against',
     'Among',
     'Amongst',

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) {