fix(compat/merge): use isArrayLikeObject to match lodash merge behavior

Author: dayongkr

src/compat/object/merge.spec.ts

@@ -370,6 +370,14 @@ describe('merge', () => {
     expect(actual).toEqual({ a: ['x', 'y', 'z'] });
   });
 
+  it('should not preserve object properties when nested object is replaced by array', () => {
+    const actual = merge({ x: { a: 2 } }, { x: ['1'] });
+
+    expect(actual.x).toEqual(['1']);
+    expect(Object.keys(actual.x)).toEqual(['0']);
+    expect((actual.x as any).a).toBeUndefined();
+  });
+
   it('should match the type of lodash', () => {
     expectTypeOf(merge).toEqualTypeOf<typeof mergeLodash>();
   });

src/compat/object/mergeWith.spec.ts

@@ -228,4 +228,12 @@ describe('mergeWith', () => {
     result = mergeWith({ a: 1 }, { a: undefined }, noop);
     expect(result.a).toBe(1);
   });
+
+  it('should not preserve object properties when nested object is replaced by array', () => {
+    const actual = mergeWith({ x: { a: 2 } }, { x: ['1'] }, noop);
+
+    expect(actual.x).toEqual(['1']);
+    expect(Object.keys(actual.x)).toEqual(['0']);
+    expect((actual.x as any).a).toBeUndefined();
+  });
 });

src/compat/object/mergeWith.ts

@@ -4,6 +4,7 @@ import { clone } from '../../object/clone.ts';
 import { isPrimitive } from '../../predicate/isPrimitive.ts';
 import { getSymbols } from '../_internal/getSymbols.ts';
 import { isArguments } from '../predicate/isArguments.ts';
+import { isArrayLikeObject } from '../predicate/isArrayLikeObject.ts';
 import { isObjectLike } from '../predicate/isObjectLike.ts';
 import { isPlainObject } from '../predicate/isPlainObject.ts';
 import { isTypedArray } from '../predicate/isTypedArray.ts';
@@ -292,15 +293,25 @@ function mergeWithDeep(
     }
 
     if (Array.isArray(sourceValue)) {
-      if (typeof targetValue === 'object' && targetValue != null) {
+      if (Array.isArray(targetValue)) {
         const cloned: any = [];
+        // for custom properties on arrays
         const targetKeys = Reflect.ownKeys(targetValue);
 
         for (let i = 0; i < targetKeys.length; i++) {
-          const targetKey = targetKeys[i];
+          const targetKey = targetKeys[i] as keyof typeof targetValue;
           cloned[targetKey] = targetValue[targetKey];
         }
 
+        targetValue = cloned;
+      } else if (isArrayLikeObject(targetValue)) {
+        // array-like object: only copy numeric indices
+        const cloned: any = [];
+
+        for (let i = 0; i < targetValue.length; i++) {
+          cloned[i] = targetValue[i];
+        }
+
         targetValue = cloned;
       } else {
         targetValue = [];