@blumintinc/eslint-plugin-blumint 1.20.10 → 1.20.11

package/lib/index.js

@@ -223,7 +223,7 @@ function noFrontendImportsFromFunctionsPatterns(pattern) {
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.20.10',
+        version: '1.20.11',
     },
     parseOptions: {
         ecmaVersion: 2020,

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

@@ -43,63 +43,6 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
     create(context) {
         // Track processed nodes to avoid duplicate reports
         const processedNodes = new Set();
-        function hasNestedSpread(node) {
-            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;
-                    }
-                }
-                else if (node.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
-                    node.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') ||
-                    // 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')) {
-                    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));
-                }
-                else if (node.type === utils_1.AST_NODE_TYPES.Property) {
-                    visit(node.value, depth + 1);
-                }
-                else if (node.type === utils_1.AST_NODE_TYPES.SpreadElement) {
-                    visit(node.argument, depth);
-                }
-            }
-            visit(node);
-            return (hasSpread &&
-                hasNestedSpread &&
-                hasNestedObject &&
-                !hasFunction &&
-                !hasSymbol);
-        }
         const sourceCode = context.sourceCode;
         function normalizedTextOf(node) {
             return sourceCode.getText(node).replace(/\s+/g, '');
@@ -142,6 +85,100 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
             }
             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;
+            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 (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
+                (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
+                    (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 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 (current.type === utils_1.AST_NODE_TYPES.Property) {
+                    visit(current.value, depth + 1);
+                }
+                else if (current.type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                    visit(current.argument, depth);
+                }
+            }
+            visit(node);
+            // 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;
+        }
+        /**
+         * 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;
+            }
+            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)}]`;
@@ -270,7 +307,7 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
             const visit = (current) => {
                 if (current !== node &&
                     startsWithSpread(current) &&
-                    hasNestedSpread(current)) {
+                    isPartialDeepCopy(current)) {
                     targets.push(current);
                     return;
                 }
@@ -331,7 +368,7 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
             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
@@ -339,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;
                     }
                 }
@@ -354,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) {

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,18 @@
 [
+  {
+    "version": "1.20.11",
+    "date": "2026-07-28T20:40:15.882Z",
+    "rules": [
+      {
+        "name": "prefer-clone-deep",
+        "changeType": "fix",
+        "issues": [
+          1371
+        ],
+        "summary": "flag only partial deep copies of the same base (closes #1371)"
+      }
+    ]
+  },
   {
     "version": "1.20.10",
     "date": "2026-07-28T19:39:55.260Z",