fix(util): preserve source when removing nested values in set (react-component/util#807)

- copy the parent object / array before deleting with removeIfUndefined
- skip deletion when the parent is missing or a primitive
- add set tests for source immutability and primitive parents

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: aibayanyu20

packages/util/src/utils/set.ts

@@ -22,10 +22,18 @@ function internalSet<Entity = any, Output = Entity, Value = any>(
     clone = ({ ...entity } as unknown) as Output
 
   // Delete prop if `removeIfUndefined` and value is undefined
-  if (removeIfUndefined && value === undefined && restPath.length === 1)
-    delete (clone as any)[path][restPath[0]]
-  else
+  if (removeIfUndefined && value === undefined && restPath.length === 1) {
+    // Copy the parent before deleting so the source entity is never mutated
+    const origin = (clone as any)[path]
+    if (origin && typeof origin === 'object') {
+      const child = Array.isArray(origin) ? [...origin] : { ...origin }
+      delete child[restPath[0] as any]
+      ;(clone as any)[path] = child
+    }
+  }
+  else {
     (clone as any)[path] = internalSet((clone as any)[path], restPath, value, removeIfUndefined)
+  }
 
   return clone
 }

packages/util/tests/set.spec.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest'
+import set from '../src/utils/set'
+
+describe('set', () => {
+  it('remove if undefined', () => {
+    // Skip not exist path
+    expect(set({}, ['notExist'], undefined, true)).toEqual({})
+
+    // Delete value
+    const source = { keep: { light: 2333, bamboo: 1 } }
+    const target = set(source, ['keep', 'light'], undefined, true)
+    expect(target).toEqual({ keep: { bamboo: 1 } })
+    expect('light' in target.keep).toBeFalsy()
+    expect(source).toEqual({ keep: { light: 2333, bamboo: 1 } })
+    expect(target.keep).not.toBe(source.keep)
+
+    // Delete array item without touching the source array
+    const listSource = { list: [0, 1, 2] }
+    const listTarget = set(listSource, ['list', 1], undefined, true)
+    expect(1 in listTarget.list).toBeFalsy()
+    expect(listSource.list).toEqual([0, 1, 2])
+
+    // Mid path not exist
+    const midTgt = set({ lv1: { lv2: {} } }, ['lv1', 'lv2', 'lv3'], undefined, true)
+    expect(midTgt).toEqual({ lv1: { lv2: {} } })
+    expect('lv3' in midTgt.lv1.lv2).toBeFalsy()
+
+    // Long path not exist
+    const longNotExistTgt = set({ lv1: { lv2: {} } }, ['lv1', 'lv2', 'lv3', 'lv4'], undefined, true)
+    expect(longNotExistTgt).toEqual({ lv1: { lv2: {} } })
+    expect('lv3' in longNotExistTgt.lv1.lv2).toBeFalsy()
+
+    // Long path remove
+    const longTgt = set(
+      { lv1: { lv2: { lv3: { lv4: { lv: 5 } } } } },
+      ['lv1', 'lv2', 'lv3', 'lv4'],
+      undefined,
+      true,
+    )
+    expect(longTgt).toEqual({ lv1: { lv2: { lv3: {} } } })
+    expect('lv4' in longTgt.lv1.lv2.lv3).toBeFalsy()
+  })
+
+  it.each(['str', 123, true, Symbol('value'), BigInt(1)])(
+    'preserves a primitive parent when removing a missing property: %s',
+    (value) => {
+      const source = { keep: value }
+      const target = set(source, ['keep', 'light'], undefined, true)
+      expect(target.keep).toBe(value)
+      expect(source.keep).toBe(value)
+    },
+  )
+})