@blumintinc/eslint-plugin-blumint 1.13.0 → 1.14.0

package/lib/rules/no-uuidv4-base62-as-key.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.noUuidv4Base62AsKey = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 exports.noUuidv4Base62AsKey = (0, createRule_1.createRule)({
     name: 'no-uuidv4-base62-as-key',
     meta: {
@@ -13,13 +14,13 @@ exports.noUuidv4Base62AsKey = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            noUuidv4Base62AsKey: 'Do not use uuidv4Base62() to generate keys for elements in a list or loop. ' +
-                'These keys are not stable across renders and can cause performance issues. ' +
-                'Use a stable identifier from your data instead.',
+            noUuidv4Base62AsKey: 'Key "{{keyExpression}}" comes from uuidv4Base62(), which regenerates on every render so React cannot reconcile list items and may remount components, drop local state, or reorder DOM nodes. ' +
+                'Use a stable identifier from your data (for example a database id, slug, or memoized array of ids) instead of generating a new UUID inside render.',
         },
     },
     defaultOptions: [],
     create(context) {
+        const sourceCode = context.sourceCode;
         // Track imported uuidv4Base62 identifiers
         const importedUuidv4Base62 = new Set();
         // Track elements that we've already reported to avoid duplicate reports
@@ -31,14 +32,18 @@ exports.noUuidv4Base62AsKey = (0, createRule_1.createRule)({
         // Flag to indicate we've seen the itemKeys pattern
         let hasPreGeneratedKeys = false;
         // Helper function to report a rule violation while avoiding duplicates
-        function reportViolation(node, messageId = 'noUuidv4Base62AsKey') {
+        function reportViolation(node, keyExpression, messageId = 'noUuidv4Base62AsKey') {
             // Skip if we've already reported this element
             if (reportedElements.has(node))
                 return;
             reportedElements.add(node);
+            const keyExpressionText = keyExpression
+                ? sourceCode.getText(keyExpression).trim()
+                : 'uuidv4Base62()';
             context.report({
                 node,
                 messageId,
+                data: { keyExpression: keyExpressionText },
             });
         }
         // Helper to check if a node is a call to uuidv4Base62()
@@ -117,7 +122,7 @@ exports.noUuidv4Base62AsKey = (0, createRule_1.createRule)({
                     const { expression } = attr.value;
                     // Direct uuidv4Base62() call in key
                     if (containsUuidV4Base62Call(expression)) {
-                        reportViolation(jsxElement);
+                        reportViolation(jsxElement, expression);
                         return;
                     }
                     // Check for member expressions (item.key pattern)
@@ -128,12 +133,12 @@ exports.noUuidv4Base62AsKey = (0, createRule_1.createRule)({
                         const objName = expression.object.name;
                         // Check if this variable has been marked as containing keys with uuidv4Base62
                         if (variablesWithUuidv4Base62Keys.has(objName)) {
-                            reportViolation(jsxElement);
+                            reportViolation(jsxElement, expression);
                             return;
                         }
                         // Special case for the failing 'itemKeys' test
                         if (hasPreGeneratedKeys) {
-                            const ancestors = context.getAncestors();
+                            const ancestors = ASTHelpers_1.ASTHelpers.getAncestors(context, jsxElement);
                             // Check if we're inside a map callback
                             for (let i = ancestors.length - 1; i >= 0; i--) {
                                 const ancestor = ancestors[i];
@@ -144,7 +149,7 @@ exports.noUuidv4Base62AsKey = (0, createRule_1.createRule)({
                                     ancestor.callee.object.type === utils_1.AST_NODE_TYPES.Identifier) {
                                     // If we're mapping over a variable with pre-generated keys
                                     if (variablesWithUuidv4Base62Keys.has(ancestor.callee.object.name)) {
-                                        reportViolation(jsxElement);
+                                        reportViolation(jsxElement, expression);
                                         return;
                                     }
                                 }
@@ -155,8 +160,8 @@ exports.noUuidv4Base62AsKey = (0, createRule_1.createRule)({
             }
         }
         // Helper to check for react mapping functions
-        function isInsideMapCallback() {
-            const ancestors = context.getAncestors();
+        function isInsideMapCallback(node) {
+            const ancestors = ASTHelpers_1.ASTHelpers.getAncestors(context, node);
             for (let i = ancestors.length - 1; i >= 0; i--) {
                 const ancestor = ancestors[i];
                 if (ancestor.type === utils_1.AST_NODE_TYPES.CallExpression &&
@@ -276,7 +281,7 @@ exports.noUuidv4Base62AsKey = (0, createRule_1.createRule)({
             },
             // Check JSX elements for uuidv4Base62 keys
             JSXElement(node) {
-                if (!isInsideMapCallback())
+                if (!isInsideMapCallback(node))
                     return;
                 if (node.openingElement.attributes) {
                     checkJSXAttributesForUuidv4Base62(node.openingElement.attributes, node);
@@ -284,7 +289,7 @@ exports.noUuidv4Base62AsKey = (0, createRule_1.createRule)({
             },
             // Check JSX fragments for children with uuidv4Base62 keys
             JSXFragment(node) {
-                if (!isInsideMapCallback())
+                if (!isInsideMapCallback(node))
                     return;
                 for (const child of node.children) {
                     if (child.type === utils_1.AST_NODE_TYPES.JSXElement &&
@@ -336,7 +341,7 @@ exports.noUuidv4Base62AsKey = (0, createRule_1.createRule)({
                                         utils_1.AST_NODE_TYPES.Identifier &&
                                     attr.value.expression.property.name === 'key') {
                                     // The test case - directly report this element
-                                    reportViolation(returnExpr);
+                                    reportViolation(returnExpr, attr.value.expression);
                                     break;
                                 }
                             }

package/lib/rules/omit-index-html.d.ts

@@ -1,7 +1,8 @@
+import { TSESLint } from '@typescript-eslint/utils';
 type Options = [
     {
         allowWithQueryOrHash?: boolean;
     }
 ];
-export declare const omitIndexHtml: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"omitIndexHtml", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export declare const omitIndexHtml: TSESLint.RuleModule<"omitIndexHtml", Options, TSESLint.RuleListener>;
 export {};

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

@@ -25,8 +25,26 @@ function hasQueryOrHash(url) {
  * Removes 'index.html' from a URL and ensures proper trailing slash
  */
 function fixUrl(url) {
-    // Replace /index.html with /
-    return url.replace(/\/index\.html($|[?#])/, '/$1');
+    // Replace /index.html/ with / and /index.html with / at the end or before ?/#/${
+    return url
+        .replace(/\/index\.html\//g, '/')
+        .replace(/\/index\.html(?=(?:$|[?#]|\$\{))/g, '/');
+}
+/**
+ * Reconstructs a template literal using cooked values so static checks and
+ * reporting align with what runtime sees (escape sequences are resolved).
+ */
+function describeTemplateLiteral(node, sourceCode) {
+    const parts = [];
+    node.quasis.forEach((quasi, index) => {
+        const text = quasi.value.cooked ?? quasi.value.raw;
+        parts.push(text);
+        const expression = node.expressions[index];
+        if (expression) {
+            parts.push(`\${${sourceCode.getText(expression)}}`);
+        }
+    });
+    return parts.join('');
 }
 exports.omitIndexHtml = (0, createRule_1.createRule)({
     name: 'omit-index-html',
@@ -49,11 +67,12 @@ exports.omitIndexHtml = (0, createRule_1.createRule)({
             },
         ],
         messages: {
-            omitIndexHtml: 'Avoid using "index.html" in URLs. Many web servers automatically resolve directory requests to index.html.',
+            omitIndexHtml: 'URL "{{url}}" includes "index.html", which servers already serve implicitly for directory paths. Keeping the file name creates duplicate URLs, breaks canonical links, and can make caches treat the same page as different assets. {{fixHint}}',
         },
     },
     defaultOptions: [{ allowWithQueryOrHash: true }],
     create(context, [options]) {
+        const sourceCode = context.getSourceCode();
         const allowWithQueryOrHash = options.allowWithQueryOrHash !== false;
         return {
             Literal(node) {
@@ -65,22 +84,58 @@ exports.omitIndexHtml = (0, createRule_1.createRule)({
                     // Skip if it has query parameters or hash fragments and we're allowing those
                     if (allowWithQueryOrHash && hasQueryOrHash(value))
                         return;
+                    const suggestedUrl = fixUrl(value);
+                    const fixHint = `Replace it with the directory path (e.g., "${suggestedUrl}").`;
                     context.report({
                         node,
                         messageId: 'omitIndexHtml',
+                        data: {
+                            url: value,
+                            suggestedUrl,
+                            fixHint,
+                        },
                         fix: (fixer) => {
-                            return fixer.replaceText(node, `"${fixUrl(value)}"`);
+                            const quote = sourceCode.getText(node).startsWith("'")
+                                ? "'"
+                                : '"';
+                            const escapedUrl = suggestedUrl.split(quote).join(`\\${quote}`);
+                            return fixer.replaceText(node, `${quote}${escapedUrl}${quote}`);
                         },
                     });
                 }
             },
             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('');
-                if (value.includes('/index.html')) {
+                const hasIndexHtmlInStatic = node.quasis.some((quasi) => {
+                    const text = quasi.value.cooked ?? quasi.value.raw;
+                    return text.includes('/index.html');
+                });
+                if (!hasIndexHtmlInStatic) {
+                    return;
+                }
+                const value = describeTemplateLiteral(node, sourceCode);
+                // Check if it's a URL and contains index.html
+                if (isLikelyUrl(value) && value.includes('/index.html')) {
+                    // Skip if it has query parameters or hash fragments and we're allowing those
+                    if (allowWithQueryOrHash && hasQueryOrHash(value))
+                        return;
+                    const hasDynamicParts = node.expressions.length > 0;
+                    const suggestedUrlRaw = fixUrl(value);
+                    const suggestedUrl = hasDynamicParts
+                        ? `\`${suggestedUrlRaw
+                            .replace(/\\/g, '\\\\')
+                            .replace(/`/g, '\\`')}\``
+                        : suggestedUrlRaw;
+                    const fixHint = hasDynamicParts
+                        ? `Remove "index.html" from the static portion of the template so it resolves to the directory path (e.g., ${suggestedUrl}).`
+                        : `Replace it with the directory path (e.g., "${suggestedUrl}").`;
                     context.report({
                         node,
                         messageId: 'omitIndexHtml',
+                        data: {
+                            url: value,
+                            suggestedUrl,
+                            fixHint,
+                        },
                         // No automatic fix for template literals as they may contain dynamic parts
                     });
                 }

package/lib/rules/optimize-object-boolean-conditions.js

@@ -6,7 +6,8 @@ const createRule_1 = require("../utils/createRule");
 const HOOK_NAMES = new Set(['useEffect', 'useCallback', 'useMemo']);
 function isHookCall(node) {
     const callee = node.callee;
-    return ((callee.type === utils_1.AST_NODE_TYPES.Identifier && HOOK_NAMES.has(callee.name)) ||
+    return ((callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+        HOOK_NAMES.has(callee.name)) ||
         (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
             !callee.computed &&
             callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
@@ -32,7 +33,8 @@ function isObjectExistenceCheck(node) {
     // Check for patterns like !obj
     if (node.type === utils_1.AST_NODE_TYPES.UnaryExpression) {
         // !obj
-        if (node.operator === '!' && node.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
+        if (node.operator === '!' &&
+            node.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
             return true;
         }
         // !!obj
@@ -111,7 +113,7 @@ function extractObjectName(node) {
     return null;
 }
 function analyzeBooleanCondition(node, context) {
-    const sourceCode = context.getSourceCode();
+    const sourceCode = context.sourceCode;
     const expression = sourceCode.getText(node);
     if (isObjectExistenceCheck(node)) {
         const objectName = extractObjectName(node);
@@ -195,7 +197,7 @@ exports.optimizeObjectBooleanConditions = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            extractBooleanCondition: 'Extract boolean condition "{{expression}}" into a separate variable "{{suggestedName}}" to optimize hook re-runs. The condition depends on object "{{objectName}}" which may change frequently, but the boolean result changes less often.',
+            extractBooleanCondition: 'Dependency array includes boolean condition "{{expression}}" derived from object "{{objectName}}". Hook re-runs every time the object reference changes even when the boolean outcome stays the same, leading to wasted renders and unstable memoization. Extract the condition into a stable boolean like "{{suggestedName}}" and depend on that variable instead.',
         },
     },
     defaultOptions: [],

package/lib/rules/parallelize-async-operations.js

@@ -44,12 +44,12 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
             },
         ],
         messages: {
-            parallelizeAsyncOperations: 'Multiple sequential awaits detected. Consider using Promise.all() to parallelize independent async operations for better performance.',
+            parallelizeAsyncOperations: 'Awaiting {{awaitCount}} independent async operations sequentially makes their network and I/O latency add up, which slows responses and wastes compute. These awaits have no data dependency or per-call error handling, so run them together with Promise.all([...]) and destructure the results when you need individual values.',
         },
     },
     defaultOptions,
     create(context, [options]) {
-        const sourceCode = context.getSourceCode();
+        const sourceCode = context.sourceCode;
         const sideEffectMatchers = (options?.sideEffectPatterns ?? []).map((pattern) => typeof pattern === 'string' ? new RegExp(pattern, 'i') : pattern);
         const reportedRanges = new Set();
         /**
@@ -269,8 +269,13 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
         }
         /**
          * Generates a fix for sequential awaits
+         *
+         * Returns null when the sequential awaits cannot be safely rewritten as a Promise.all.
          */
         function generateFix(fixer, awaitNodes) {
+            if (awaitNodes.length < 2) {
+                return null;
+            }
             // Extract the await expressions
             const awaitExpressions = awaitNodes
                 .map((node) => getAwaitExpression(node))
@@ -312,11 +317,19 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
                 promiseAllText = `await Promise.all([\n  ${awaitArguments.join(',\n  ')}\n]);`;
             }
             // Find the start position, accounting for leading comments
-            let startPos = awaitNodes[0].range[0];
+            const startPos = awaitNodes[0].range[0];
             // Replace the range from the start of the first await to the end of the last await
             const endPos = awaitNodes[awaitNodes.length - 1].range[1];
             return fixer.replaceTextRange([startPos, endPos], promiseAllText);
         }
+        /**
+         * Generates a deduplication key from await nodes' range metadata.
+         */
+        function getDeduplicationKey(awaitNodes) {
+            const rangeStart = awaitNodes[0].range[0];
+            const rangeEnd = awaitNodes[awaitNodes.length - 1].range[1];
+            return `${rangeStart}-${rangeEnd}`;
+        }
         const processStatementList = (statements) => {
             const awaitNodes = [];
             for (const statement of statements) {
@@ -329,12 +342,15 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
                     if (!hasDependencies(awaitNodes, variableNames, sideEffectMatchers) &&
                         !areInTryCatchBlocks(awaitNodes) &&
                         !areInLoop(awaitNodes)) {
-                        const key = `${awaitNodes[0].range?.[0]}-${awaitNodes[awaitNodes.length - 1].range?.[1]}`;
+                        const key = getDeduplicationKey(awaitNodes);
                         if (!reportedRanges.has(key)) {
                             reportedRanges.add(key);
                             context.report({
                                 node: awaitNodes[0],
                                 messageId: 'parallelizeAsyncOperations',
+                                data: {
+                                    awaitCount: awaitNodes.length.toString(),
+                                },
                                 fix: (fixer) => generateFix(fixer, awaitNodes),
                             });
                         }
@@ -350,12 +366,15 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
                 if (!hasDependencies(awaitNodes, variableNames, sideEffectMatchers) &&
                     !areInTryCatchBlocks(awaitNodes) &&
                     !areInLoop(awaitNodes)) {
-                    const key = `${awaitNodes[0].range?.[0]}-${awaitNodes[awaitNodes.length - 1].range?.[1]}`;
+                    const key = getDeduplicationKey(awaitNodes);
                     if (!reportedRanges.has(key)) {
                         reportedRanges.add(key);
                         context.report({
                             node: awaitNodes[0],
                             messageId: 'parallelizeAsyncOperations',
+                            data: {
+                                awaitCount: awaitNodes.length.toString(),
+                            },
                             fix: (fixer) => generateFix(fixer, awaitNodes),
                         });
                     }

package/lib/rules/prefer-batch-operations.d.ts

@@ -1,3 +1 @@
-type MessageIds = 'preferSetAll' | 'preferOverwriteAll';
-export declare const preferBatchOperations: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
-export {};
+export declare const preferBatchOperations: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"preferBatch", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;

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

@@ -224,6 +224,27 @@ function findLoopNode(node) {
     }
     return undefined;
 }
+function describeLoopContext(loopInfo) {
+    if (loopInfo.isPromiseAll)
+        return 'Promise.all()';
+    if (loopInfo.isArrayMethod) {
+        return `${loopInfo.isArrayMethod}() callback`;
+    }
+    switch (loopInfo.node.type) {
+        case utils_1.AST_NODE_TYPES.ForStatement:
+            return 'for loop';
+        case utils_1.AST_NODE_TYPES.ForInStatement:
+            return 'for...in loop';
+        case utils_1.AST_NODE_TYPES.ForOfStatement:
+            return 'for...of loop';
+        case utils_1.AST_NODE_TYPES.WhileStatement:
+            return 'while loop';
+        case utils_1.AST_NODE_TYPES.DoWhileStatement:
+            return 'do...while loop';
+        default:
+            return 'this control flow';
+    }
+}
 function isFirestoreSetterInstance(node) {
     // Check if it's a DocSetter instance
     if (node.type === utils_1.AST_NODE_TYPES.NewExpression) {
@@ -301,8 +322,7 @@ exports.preferBatchOperations = (0, createRule_1.createRule)({
         fixable: 'code',
         schema: [],
         messages: {
-            preferSetAll: 'Use setAll() instead of multiple set() calls for better performance',
-            preferOverwriteAll: 'Use overwriteAll() instead of multiple overwrite() calls for better performance',
+            preferBatch: 'DocSetter.{{setterMethod}} is invoked repeatedly inside {{contextDescription}}, which issues separate Firestore writes per document and can leave partial updates when later calls fail. Batch the documents with DocSetter.{{batchMethod}} so the writes stay grouped and latency stays predictable.',
         },
     },
     defaultOptions: [],
@@ -321,6 +341,13 @@ exports.preferBatchOperations = (0, createRule_1.createRule)({
                 const loopInfo = findLoopNode(node);
                 if (!loopInfo)
                     return;
+                const batchMethod = methodName === 'set' ? 'setAll()' : 'overwriteAll()';
+                const messageData = {
+                    setterMethod: `${methodName}()`,
+                    batchMethod,
+                    contextDescription: describeLoopContext(loopInfo),
+                };
+                const messageId = 'preferBatch';
                 // Get or create the setter calls map for this loop
                 let setterCalls = loopSetterCalls.get(loopInfo.node);
                 if (!setterCalls) {
@@ -348,10 +375,10 @@ exports.preferBatchOperations = (0, createRule_1.createRule)({
                         existing.count === 2 &&
                         !reportedLoops.has(loopInfo.node)) {
                         reportedLoops.add(loopInfo.node);
-                        const messageId = methodName === 'set' ? 'preferSetAll' : 'preferOverwriteAll';
                         context.report({
                             node: existing.firstNode,
                             messageId,
+                            data: messageData,
                             fix: () => null, // We can't provide a fix because we don't know the array structure
                         });
                     }
@@ -371,10 +398,10 @@ exports.preferBatchOperations = (0, createRule_1.createRule)({
                         // For traditional loops, report on the first occurrence since we know it's in a loop
                         if (!reportedLoops.has(loopInfo.node)) {
                             reportedLoops.add(loopInfo.node);
-                            const messageId = methodName === 'set' ? 'preferSetAll' : 'preferOverwriteAll';
                             context.report({
                                 node,
                                 messageId,
+                                data: messageData,
                                 fix: () => null, // We can't provide a fix because we don't know the array structure
                             });
                         }
@@ -383,10 +410,10 @@ exports.preferBatchOperations = (0, createRule_1.createRule)({
                     else if (loopInfo.isArrayMethod) {
                         if (!reportedLoops.has(loopInfo.node)) {
                             reportedLoops.add(loopInfo.node);
-                            const messageId = methodName === 'set' ? 'preferSetAll' : 'preferOverwriteAll';
                             context.report({
                                 node,
                                 messageId,
+                                data: messageData,
                                 fix: () => null, // We can't provide a fix because we don't know the array structure
                             });
                         }

package/lib/rules/prefer-block-comments-for-declarations.js

@@ -65,17 +65,22 @@ exports.preferBlockCommentsForDeclarations = (0, createRule_1.createRule)({
             if (isInsideFunctionBody(node)) {
                 return;
             }
-            const sourceCode = context.getSourceCode();
+            const sourceCode = context.sourceCode;
             const comments = sourceCode.getCommentsBefore(node);
             // Find the closest comment to the node
             const lastComment = comments[comments.length - 1];
             if (lastComment && isLineCommentBeforeDeclaration(lastComment, node)) {
+                const commentText = lastComment.value.trim();
+                const commentLabel = commentText || 'declaration comment';
                 context.report({
                     loc: lastComment.loc,
                     messageId: 'preferBlockComment',
+                    data: { commentText: commentLabel },
                     fix: (fixer) => {
-                        const commentText = lastComment.value.trim();
-                        return fixer.replaceText(lastComment, `/** ${commentText} */`);
+                        if (commentLabel.includes('*/')) {
+                            return null;
+                        }
+                        return fixer.replaceText(lastComment, `/** ${commentLabel} */`);
                     },
                 });
             }
@@ -129,7 +134,7 @@ exports.preferBlockCommentsForDeclarations = (0, createRule_1.createRule)({
         fixable: 'code',
         schema: [],
         messages: {
-            preferBlockComment: 'Use block comments (/** */) instead of line comments (//) for declarations to improve IDE support.',
+            preferBlockComment: 'Line comment "{{commentText}}" sits on a declaration, and IDE hovers and TypeScript docs ignore it as documentation. Rewrite it as a block comment (/** ... */) so the text stays attached to the declaration and tooling surfaces it.',
         },
     },
     defaultOptions: [],

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

@@ -14,7 +14,7 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
         fixable: 'code',
         schema: [],
         messages: {
-            preferCloneDeep: 'Use cloneDeep from functions/src/util/cloneDeep.ts instead of nested spread operators for deep object copying',
+            preferCloneDeep: 'Nested spread copies only clone one level, so inner objects still point at the original and later mutations leak back. Use cloneDeep from functions/src/util/cloneDeep.ts and pass overrides as the second argument so the base object is deeply cloned before applying updates.',
         },
     },
     defaultOptions: [],
@@ -74,7 +74,7 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
                 !hasSymbol);
         }
         function generateCloneDeepFix(node) {
-            const sourceCode = context.getSourceCode();
+            const sourceCode = context.sourceCode;
             // Find the base object (first spread element)
             let baseObj = null;
             // Extract the base object from the first spread element
@@ -248,7 +248,7 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
         }
         // Helper function to extract nested overrides without spread elements
         function extractNestedOverrides(node) {
-            const sourceCode = context.getSourceCode();
+            const sourceCode = context.sourceCode;
             const overrides = [];
             for (const prop of node.properties) {
                 if (prop.type === utils_1.AST_NODE_TYPES.Property) {

package/lib/rules/prefer-destructuring-no-class.d.ts

@@ -1,8 +1,9 @@
+import { TSESLint } from '@typescript-eslint/utils';
 type Options = [
     {
         object?: boolean;
         enforceForRenamedProperties?: boolean;
     }
 ];
-export declare const preferDestructuringNoClass: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"preferDestructuring", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export declare const preferDestructuringNoClass: TSESLint.RuleModule<"preferDestructuring", Options, TSESLint.RuleListener>;
 export {};