@blumintinc/eslint-plugin-blumint 1.20.9 → 1.20.11

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

@@ -3,6 +3,28 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.preferCloneDeep = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const CLONE_DEEP_NAME = 'cloneDeep';
+const CLONE_DEEP_MODULE = 'functions/src/util/cloneDeep';
+const INDENT_STEP = '  ';
+/**
+ * Only BluMint's own `cloneDeep` accepts an overrides argument, so an existing
+ * binding coming from anywhere else (notably `lodash`) must not be reused by the
+ * fix. Relative/aliased paths are accepted because the helper is imported by
+ * path, never as a package.
+ */
+function isCloneDeepModule(source) {
+    if (source === CLONE_DEEP_MODULE) {
+        return true;
+    }
+    if (!/(^|\/)cloneDeep$/.test(source)) {
+        return false;
+    }
+    return (source.startsWith('.') ||
+        source.startsWith('/') ||
+        source.startsWith('~') ||
+        source.startsWith('@/') ||
+        source.endsWith('util/cloneDeep'));
+}
 exports.preferCloneDeep = (0, createRule_1.createRule)({
     name: 'prefer-clone-deep',
     meta: {
@@ -21,278 +43,332 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
     create(context) {
         // Track processed nodes to avoid duplicate reports
         const processedNodes = new Set();
-        function hasNestedSpread(node) {
+        const sourceCode = context.sourceCode;
+        function normalizedTextOf(node) {
+            return sourceCode.getText(node).replace(/\s+/g, '');
+        }
+        /**
+         * `...(base.a ?? {})`, `...(base?.a)` and `...base.a!` are defensive
+         * spellings of `...base.a`; unwrapping them lets the mirror check below
+         * recognize the underlying member path.
+         */
+        function unwrapSpreadArgument(node) {
+            if (node.type === utils_1.AST_NODE_TYPES.ChainExpression) {
+                return unwrapSpreadArgument(node.expression);
+            }
+            if (node.type === utils_1.AST_NODE_TYPES.TSNonNullExpression) {
+                return unwrapSpreadArgument(node.expression);
+            }
+            if (node.type === utils_1.AST_NODE_TYPES.LogicalExpression &&
+                (node.operator === '??' || node.operator === '||') &&
+                node.right.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
+                node.right.properties.length === 0) {
+                return unwrapSpreadArgument(node.left);
+            }
+            return node;
+        }
+        /**
+         * Canonical, whitespace-insensitive spelling of a member path so that a
+         * nested spread can be compared against the path cloneDeep already copies.
+         */
+        function accessPathOf(node) {
+            const unwrapped = unwrapSpreadArgument(node);
+            if (unwrapped.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                const objectPath = accessPathOf(unwrapped.object);
+                if (unwrapped.computed) {
+                    return `${objectPath}[${normalizedTextOf(unwrapped.property)}]`;
+                }
+                if (unwrapped.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    return `${objectPath}.${unwrapped.property.name}`;
+                }
+                return `${objectPath}.${normalizedTextOf(unwrapped.property)}`;
+            }
+            return normalizedTextOf(unwrapped);
+        }
+        const partialDeepCopyCache = new WeakMap();
+        /**
+         * The hazard this rule describes is a hand-written PARTIAL deep copy: a
+         * literal that spreads a base AND separately spreads one of that same
+         * base's sub-paths, as in `{ ...base, a: { ...base.a, x: 1 } }`. Only the
+         * sub-objects spelled out that way get their own copy; every OTHER
+         * sub-object of `base` keeps aliasing the original, so a later mutation
+         * leaks back.
+         *
+         * Merging unrelated sources copies nothing twice and is safe, which is why
+         * shapes such as `{ ...a, nested: { ...b } }`, MUI `sx` style maps and
+         * static config maps must not be flagged (#1371). A spread of the exact
+         * same path (`{ ...a, x: { ...a } }`) is deliberately excluded as well: it
+         * is a redundant copy rather than a partial one, and this repo prefers
+         * false negatives over false positives.
+         */
+        function isPartialDeepCopy(node) {
+            const cached = partialDeepCopyCache.get(node);
+            if (cached !== undefined) {
+                return cached;
+            }
             let hasFunction = false;
             let hasSymbol = false;
-            let hasSpread = false;
-            let hasNestedSpread = false;
-            let hasNestedObject = false;
-            function visit(node, depth = 0) {
-                if (node.type === utils_1.AST_NODE_TYPES.SpreadElement) {
-                    hasSpread = true;
-                    if (depth > 0) {
-                        hasNestedSpread = true;
+            const basePaths = new Set();
+            const nestedPaths = [];
+            function visit(current, depth = 0) {
+                if (current.type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                    const path = accessPathOf(current.argument);
+                    if (depth === 0) {
+                        basePaths.add(path);
+                    }
+                    else {
+                        nestedPaths.push(path);
                     }
                 }
-                else if (node.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
-                    node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                else if (current.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+                    current.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
                     hasFunction = true;
                 }
                 else if (
                 // Check for Symbol usage in computed properties
-                (node.type === utils_1.AST_NODE_TYPES.Property &&
-                    node.computed &&
-                    node.key.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    node.key.name === 'Symbol') ||
+                (current.type === utils_1.AST_NODE_TYPES.Property &&
+                    current.computed &&
+                    current.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    current.key.name === 'Symbol') ||
                     // Check for direct Symbol constructor calls
-                    (node.type === utils_1.AST_NODE_TYPES.Property &&
-                        node.computed &&
-                        node.key.type === utils_1.AST_NODE_TYPES.CallExpression &&
-                        node.key.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        node.key.callee.name === 'Symbol')) {
+                    (current.type === utils_1.AST_NODE_TYPES.Property &&
+                        current.computed &&
+                        current.key.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                        current.key.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        current.key.callee.name === 'Symbol')) {
                     hasSymbol = true;
                 }
                 // Visit child nodes without traversing parent references. Depth tracks
                 // object-nesting level: an object's OWN direct properties stay at the
                 // object's depth, and only descending into a property's value (a
-                // genuinely nested child) increments it. This keeps the top-level
-                // object's own `...spread` at depth 0 so it is never miscounted as a
-                // nested spread.
-                if (node.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
-                    if (depth > 0) {
-                        hasNestedObject = true;
-                    }
-                    node.properties.forEach((prop) => visit(prop, depth));
+                // genuinely nested child) increments it. This keeps the literal's own
+                // `...spread` at depth 0, where it names a base rather than a
+                // hand-copied sub-path.
+                if (current.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                    current.properties.forEach((prop) => visit(prop, depth));
                 }
-                else if (node.type === utils_1.AST_NODE_TYPES.Property) {
-                    visit(node.value, depth + 1);
+                else if (current.type === utils_1.AST_NODE_TYPES.Property) {
+                    visit(current.value, depth + 1);
                 }
-                else if (node.type === utils_1.AST_NODE_TYPES.SpreadElement) {
-                    visit(node.argument, depth);
+                else if (current.type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                    visit(current.argument, depth);
                 }
             }
             visit(node);
-            return (hasSpread &&
-                hasNestedSpread &&
-                hasNestedObject &&
-                !hasFunction &&
-                !hasSymbol);
+            // cloneDeep cannot faithfully reproduce functions or symbol keys, so
+            // their presence suppresses the report regardless of the copy shape.
+            const result = !hasFunction &&
+                !hasSymbol &&
+                nestedPaths.some((nested) => 
+                // The separators guard against a sibling whose name merely starts
+                // with a base's name (`abc.x` is not a sub-path of `ab`).
+                [...basePaths].some((base) => nested.startsWith(`${base}.`) || nested.startsWith(`${base}[`)));
+            partialDeepCopyCache.set(node, result);
+            return result;
         }
-        function generateCloneDeepFix(node) {
-            const sourceCode = context.sourceCode;
-            // Find the base object (first spread element)
-            let baseObj = null;
-            // Extract the base object from the first spread element
-            for (const prop of node.properties) {
-                if (prop.type === utils_1.AST_NODE_TYPES.SpreadElement) {
-                    baseObj = sourceCode.getText(prop.argument);
-                    break;
-                }
+        /**
+         * A literal that merely wraps a partial deep copy (the #365 membership
+         * shape) is still the site the report belongs on, so the predicate reaches
+         * through property values into descendant literals.
+         */
+        function containsPartialDeepCopy(node) {
+            if (isPartialDeepCopy(node)) {
+                return true;
             }
-            // 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 &&
-                    !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) {
-                    // Find the first spread in the membership object
-                    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
-                        return `{
-          sender: 'unchanged',
-          receiver: 'unchanged',
-          membership: cloneDeep(membershipIncomplete, {
-            sender: {
-              request: {
-                status: 'accepted',
-              },
-            },
-            receiver: {
-              request: {
-                status: 'accepted',
-              },
-            },
-          } as const),
-        }`;
-                    }
-                }
-            }
-            // Process the object normally
-            if (baseObj) {
-                // For simplicity, let's just use the expected output format for each test case
-                // 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 &&
-                        p.computed &&
-                        p.key.type === utils_1.AST_NODE_TYPES.TemplateLiteral);
-                    if (hasTemplateLiteral) {
-                        return `cloneDeep(baseObj, {
-          [\`\${prefix}Config\`]: {
-            nested: {
-              value: 42
+            return node.properties.some((prop) => prop.type === utils_1.AST_NODE_TYPES.Property &&
+                prop.value.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
+                containsPartialDeepCopy(prop.value));
+        }
+        function accessorForKey(prop) {
+            if (prop.computed) {
+                return `[${normalizedTextOf(prop.key)}]`;
             }
-          }
-        } as const)`;
-                    }
-                    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, {
-          settings: {
-            ...(condition ? {
-              advanced: {
-                enabled: true
-              }
-            } : {}),
-            basic: {
-              value: 42
+            if (prop.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                return `.${prop.key.name}`;
             }
-          }
-        } as const)`;
-                    }
-                    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')) {
-                        return `cloneDeep(baseObj, {
-          [key]: {
-            nested: {
-              ['dynamic' + key]: {
-                value: 42
-              }
+            if (prop.key.type === utils_1.AST_NODE_TYPES.Literal) {
+                return `[${normalizedTextOf(prop.key)}]`;
             }
-          }
-        } as const)`;
-                    }
-                    else {
-                        return `cloneDeep(baseObj, {
-          data: {
-            nested: {
-              value: 42
-            }
-          }
-        } as const)`;
-                    }
+            return null;
+        }
+        function keyTextOf(prop) {
+            return prop.computed
+                ? `[${sourceCode.getText(prop.key)}]`
+                : sourceCode.getText(prop.key);
+        }
+        function indentOf(node) {
+            const text = sourceCode.getText();
+            const lineStart = text.lastIndexOf('\n', node.range[0] - 1) + 1;
+            const prefix = text.slice(lineStart, node.range[0]);
+            return /^[ \t]*/.exec(prefix)?.[0] ?? '';
+        }
+        function startsWithSpread(node) {
+            return node.properties[0]?.type === utils_1.AST_NODE_TYPES.SpreadElement;
+        }
+        /**
+         * `SourceCode#getScope` supersedes the deprecated `context.getScope`; the
+         * fallback keeps the rule working on ESLint versions that predate it.
+         */
+        function scopeOf(node) {
+            const scoped = sourceCode;
+            return typeof scoped.getScope === 'function'
+                ? scoped.getScope(node)
+                : context.getScope();
+        }
+        /**
+         * Rebuilds the properties of one object as cloneDeep overrides. Returns null
+         * whenever a property cannot be reproduced without changing runtime
+         * behavior, which makes the caller decline the fix instead of emitting code
+         * that silently drops data (#1364).
+         */
+        function buildOverrideEntries(properties, basePath, indent) {
+            const entries = [];
+            for (const prop of properties) {
+                // Any spread other than a leading copy of the path cloneDeep already
+                // clones would have to be dropped, deleting whatever it contributed.
+                if (prop.type !== utils_1.AST_NODE_TYPES.Property) {
+                    return null;
                 }
-                else if (baseObj === 'baseConfig') {
-                    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 &&
-                            sp.key.type === utils_1.AST_NODE_TYPES.Identifier &&
-                            sp.key.name === 'items'))) {
-                        return `cloneDeep(baseConfig, {
-          features: {
-            items: [
-              ...baseConfig.features.items,
-              {
-                settings: {
-                  enabled: true
+                // Getters, setters and shorthand methods degrade into plain data
+                // properties when reprinted as overrides.
+                if (prop.kind !== 'init' || prop.method) {
+                    return null;
                 }
-              }
-            ]
-          }
-        } as const)`;
+                let valueText;
+                if (prop.value.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                    const accessor = accessorForKey(prop);
+                    if (accessor === null) {
+                        return null;
                     }
-                    else {
-                        return `cloneDeep(baseConfig, {
-          features: {
-            advanced: {
-              enabled: true
-            }
-          }
-        } as const)`;
+                    const nested = buildOverrideObject(prop.value, `${basePath}${accessor}`, `${indent}${INDENT_STEP}`);
+                    if (nested === null) {
+                        return null;
                     }
+                    valueText = nested;
                 }
-                else if (baseObj === 'prevState') {
-                    return `cloneDeep(prevState, {
-          ui: {
-            modal: {
-              content: {
-                form: {
-                  values: {
-                    submitted: true
-                  }
+                else {
+                    // Arrays, calls, conditionals and primitives are copied verbatim, so
+                    // whatever they contain survives the fix untouched.
+                    valueText = sourceCode.getText(prop.value);
                 }
-              }
+                entries.push(`${indent}${keyTextOf(prop)}: ${valueText}`);
             }
-          }
-        } as const)`;
+            return entries.join(',\n');
+        }
+        /**
+         * `indent` is the indentation of the rebuilt object's entries; its closing
+         * brace lines up one step to the left.
+         */
+        function buildOverrideObject(node, basePath, indent) {
+            let properties = [...node.properties];
+            const [first] = properties;
+            if (first && first.type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                // A leading spread of this exact path is redundant: cloneDeep already
+                // copies it from the base. Any other spread carries data that the
+                // overrides object cannot express.
+                if (accessPathOf(first.argument) !== basePath) {
+                    return null;
                 }
-                // Default case - extract overrides
-                const overrides = extractNestedOverrides(node);
-                return `cloneDeep(${baseObj}, {
-          ${overrides}
-        } as const)`;
+                properties = properties.slice(1);
             }
-            else {
-                // Fallback to the original implementation if no base object is found
-                const parts = [];
-                for (const prop of node.properties) {
-                    if (prop.type === utils_1.AST_NODE_TYPES.SpreadElement) {
-                        const spreadArg = sourceCode.getText(prop.argument);
-                        parts.push(`...${spreadArg}`);
-                    }
-                    else if (prop.type === utils_1.AST_NODE_TYPES.Property) {
-                        const key = prop.computed
-                            ? `[${sourceCode.getText(prop.key)}]`
-                            : sourceCode.getText(prop.key);
-                        const value = sourceCode.getText(prop.value);
-                        parts.push(`${key}: ${value}`);
-                    }
-                }
-                return `cloneDeep({ ${parts.join(', ')} }, {} as const)`;
+            const body = buildOverrideEntries(properties, basePath, indent);
+            if (body === null) {
+                return null;
             }
+            if (body === '') {
+                return '{}';
+            }
+            const closingIndent = indent.slice(0, indent.length - INDENT_STEP.length);
+            return `{\n${body}\n${closingIndent}}`;
         }
-        // Helper function to extract nested overrides without spread elements
-        function extractNestedOverrides(node) {
-            const sourceCode = context.sourceCode;
-            const overrides = [];
-            for (const prop of node.properties) {
-                if (prop.type === utils_1.AST_NODE_TYPES.Property) {
-                    const key = prop.computed
-                        ? `[${sourceCode.getText(prop.key)}]`
-                        : sourceCode.getText(prop.key);
-                    let value;
-                    if (prop.value.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
-                        // For nested objects, recursively extract overrides
-                        const nestedOverrides = extractNestedOverrides(prop.value);
-                        if (nestedOverrides.trim()) {
-                            value = `{\n            ${nestedOverrides}\n          }`;
-                        }
-                        else {
-                            // If there are no nested overrides, use an empty object
-                            value = '{}';
-                        }
-                    }
-                    else if (prop.value.type === utils_1.AST_NODE_TYPES.ArrayExpression) {
-                        // For arrays, keep the original array
-                        value = sourceCode.getText(prop.value);
-                    }
-                    else {
-                        // For primitive values, use the original value
-                        value = sourceCode.getText(prop.value);
+        function buildCloneDeepCall(node) {
+            const [first, ...rest] = node.properties;
+            if (!first || first.type !== utils_1.AST_NODE_TYPES.SpreadElement) {
+                return null;
+            }
+            const baseText = sourceCode.getText(first.argument);
+            const basePath = accessPathOf(first.argument);
+            const baseIndent = indentOf(node);
+            const body = buildOverrideEntries(rest, basePath, `${baseIndent}${INDENT_STEP}`);
+            if (body === null) {
+                return null;
+            }
+            const overrides = body === '' ? '{}' : `{\n${body}\n${baseIndent}}`;
+            return `cloneDeep(${baseText}, ${overrides} as const)`;
+        }
+        /**
+         * When the reported object has no spread of its own (the #365 membership
+         * shape), the object that actually shallow-copies a base lives one or more
+         * levels down; rewriting only those children leaves the rest of the literal
+         * untouched.
+         */
+        function collectCloneTargets(node) {
+            const targets = [];
+            const visit = (current) => {
+                if (current !== node &&
+                    startsWithSpread(current) &&
+                    isPartialDeepCopy(current)) {
+                    targets.push(current);
+                    return;
+                }
+                for (const prop of current.properties) {
+                    if (prop.type === utils_1.AST_NODE_TYPES.Property &&
+                        prop.value.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                        visit(prop.value);
                     }
-                    overrides.push(`${key}: ${value}`);
                 }
-                else if (prop.type === utils_1.AST_NODE_TYPES.SpreadElement &&
-                    prop.argument.type === utils_1.AST_NODE_TYPES.ConditionalExpression) {
-                    // Handle conditional spread elements (like ...(condition ? {...} : {}))
-                    const text = sourceCode.getText(prop);
-                    overrides.push(text);
+            };
+            visit(node);
+            return targets;
+        }
+        /**
+         * Returns the fixes required for `cloneDeep` to resolve, an empty list when
+         * it already does, or null when a conflicting binding of that name exists —
+         * shadowing it would silently call something else.
+         */
+        function buildImportFixes(fixer, scope) {
+            const existing = utils_1.ASTUtils.findVariable(scope, CLONE_DEEP_NAME);
+            if (existing) {
+                const [definition] = existing.defs;
+                if (!definition) {
+                    return null;
+                }
+                const definitionNode = definition.node;
+                if (definitionNode.type !== utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                    definitionNode.type !== utils_1.AST_NODE_TYPES.ImportDefaultSpecifier) {
+                    return null;
+                }
+                if (definitionNode.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                    definitionNode.importKind === 'type') {
+                    return null;
                 }
+                const declaration = definitionNode.parent;
+                if (!declaration ||
+                    declaration.type !== utils_1.AST_NODE_TYPES.ImportDeclaration ||
+                    declaration.importKind === 'type' ||
+                    !isCloneDeepModule(String(declaration.source.value))) {
+                    return null;
+                }
+                return [];
+            }
+            const importDeclarations = sourceCode.ast.body.filter((statement) => statement.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
+            const reusable = importDeclarations.find((declaration) => declaration.importKind !== 'type' &&
+                isCloneDeepModule(String(declaration.source.value)) &&
+                declaration.specifiers.some((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier));
+            if (reusable) {
+                const namedSpecifiers = reusable.specifiers.filter((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier);
+                const lastSpecifier = namedSpecifiers[namedSpecifiers.length - 1];
+                return [fixer.insertTextAfter(lastSpecifier, `, ${CLONE_DEEP_NAME}`)];
             }
-            return overrides.join(',\n            ');
+            const importText = `import { ${CLONE_DEEP_NAME} } from '${CLONE_DEEP_MODULE}';\n`;
+            const [firstImport] = importDeclarations;
+            if (firstImport) {
+                return [fixer.insertTextBefore(firstImport, importText)];
+            }
+            return [fixer.insertTextBeforeRange([0, 0], importText)];
         }
         // Find the outermost object expression that needs cloneDeep
-        function findOutermostObjectWithNestedSpread(node) {
+        function findOutermostPartialDeepCopy(node) {
             let current = node.parent;
             let result = node;
             // Walk up the tree to find the outermost object expression
@@ -300,8 +376,9 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
                 if (current.type === utils_1.AST_NODE_TYPES.Property &&
                     current.parent &&
                     current.parent.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
-                    // If this is a property of an object expression, check if that object has nested spreads
-                    if (hasNestedSpread(current.parent)) {
+                    // Reporting on the enclosing literal keeps sibling copies under a
+                    // single error, so one fix pass rewrites them all together.
+                    if (containsPartialDeepCopy(current.parent)) {
                         result = current.parent;
                     }
                 }
@@ -315,9 +392,9 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
                 if (processedNodes.has(node)) {
                     return;
                 }
-                if (hasNestedSpread(node)) {
+                if (containsPartialDeepCopy(node)) {
                     // Find the outermost object that should use cloneDeep
-                    const outermostNode = findOutermostObjectWithNestedSpread(node);
+                    const outermostNode = findOutermostPartialDeepCopy(node);
                     // Mark all nested object expressions as processed
                     const markProcessed = (n) => {
                         if (n.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
@@ -338,11 +415,30 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
                     markProcessed(outermostNode);
                     // Only report on the outermost node
                     if (outermostNode === node) {
+                        const scope = scopeOf(node);
                         context.report({
                             node,
                             messageId: 'preferCloneDeep',
                             fix(fixer) {
-                                return fixer.replaceText(node, generateCloneDeepFix(node));
+                                const rewrites = [];
+                                const targets = startsWithSpread(node)
+                                    ? [node]
+                                    : collectCloneTargets(node);
+                                if (targets.length === 0) {
+                                    return null;
+                                }
+                                for (const target of targets) {
+                                    const call = buildCloneDeepCall(target);
+                                    if (call === null) {
+                                        return null;
+                                    }
+                                    rewrites.push(fixer.replaceText(target, call));
+                                }
+                                const importFixes = buildImportFixes(fixer, scope);
+                                if (importFixes === null) {
+                                    return null;
+                                }
+                                return [...importFixes, ...rewrites];
                             },
                         });
                     }