compat/merge behavior differs from lodash-es when object contains Date object

[imonmandal]

Reproduction

Code:

import { merge as esMerge } from "es-toolkit/compat";
import { merge as ldMerge } from "lodash-es";

const target = { a: 1, b: { x: 1, y: 2 }, c: new Date("2025-01-01") };
const source = { b: { y: 3, z: 4 }, c: new Date("2000-01-01") };

const resultEs = esMerge({}, target, source);
const resultLd = ldMerge({}, target, source);

console.log("es-toolkit/compat", resultEs);
console.log("lodash-es", resultLd);

Output:
es-toolkit/compat { a: 1, b: { x: 1, y: 3, z: 4 }, c: 2025-01-01T00:00:00.000Z }
lodash-es { a: 1, b: { x: 1, y: 3, z: 4 }, c: 2000-01-01T00:00:00.000Z }

Actual Result: Date object from the source is not merged into target object
Expected Result: Date object from the source is merged into target object

[oshosh]

I’ve taken a closer look at the behavior, and here’s a compact summary of what seems to be happening.

Root Cause

merge(...) currently treats any non-null object (Date, RegExp, Map, Set, etc.) as deep-mergeable because the condition relies on:

• https://github.com/toss/es-toolkit/blob/main/src/compat/object/mergeWith.ts#L318

isObjectLike(targetValue) && isObjectLike(sourceValue)

isObjectLike returns true for Date, so Date instances go through the recursive merge path.
Since Date objects have no enumerable properties, the merge produces no effect — which means the existing target date stays intact and the source date is silently ignored.

This differs from Lodash’s merge semantics:
Lodash only deep merges plain objects and arrays, and always replaces special object types (like Date) with the source value.

As a reference, here’s the relevant internal logic inside Lodash (baseMergeDeep), where only arrays, buffers, typed arrays, plain objects, and arguments are considered mergeable. Everything else simply becomes newValue = srcValue:

• https://github.com/lodash/lodash/blob/4.17.21/lodash.js#L13540

function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
  var objValue = safeGet(object, key);
  var srcValue = safeGet(source, key);

  var newValue = customizer ? customizer(objValue, srcValue, key + "", object, source, stack) : undefined;
  var isCommon = newValue === undefined;

  if (isCommon) {
    var isArr   = isArray(srcValue);
    var isBuff  = !isArr && isBuffer(srcValue);
    var isTyped = !isArr && !isBuff && isTypedArray(srcValue);

    newValue = srcValue;

    if (isArr || isBuff || isTyped) {
      // deep-merge for array-like values
    }
    else if (isPlainObject(srcValue) || isArguments(srcValue)) {
      // deep-merge only for JSON-like structures
    }
    // Date, RegExp, Map, Set, etc.
    // → none of these hit the above branches
    // → newValue stays as srcValue (simple replace)
  }

  assignMergeValue(object, key, newValue);
}

Proposed Fix

Restricting the deep-merge condition to isPlainObject aligns perfectly with Lodash behavior:

- isObjectLike(targetValue) && isObjectLike(sourceValue)
+ isPlainObject(targetValue) && isPlainObject(sourceValue)

This still preserves all existing deep merge behavior.

If you agree with this direction, I’d be happy to open a PR with:

• the change
• unit tests
• short documentation note

Let me know what you think!

[imonmandal]

@oshosh I am okay with it