es-toolkit
Version:
A state-of-the-art, high-performance JavaScript utility library with a small bundle size and strong type annotations.
112 lines (111 loc) • 5.48 kB
JavaScript
import { isPrimitive } from "../../predicate/isPrimitive.mjs";
import { clone } from "../../object/clone.mjs";
import { getSymbols } from "../_internal/getSymbols.mjs";
import { isBuffer } from "../../predicate/isBuffer.mjs";
import { isUnsafeProperty } from "../../_internal/isUnsafeProperty.mjs";
import { isPlainObject } from "../predicate/isPlainObject.mjs";
import { cloneDeep } from "./cloneDeep.mjs";
import { isArguments } from "../predicate/isArguments.mjs";
import { isObjectLike } from "../predicate/isObjectLike.mjs";
import { isArrayLikeObject } from "../predicate/isArrayLikeObject.mjs";
import { isTypedArray } from "../predicate/isTypedArray.mjs";
//#region src/compat/object/mergeWith.ts
/**
* Merges the properties of one or more source objects into the target object using a customizer function.
*
* This function performs a deep merge, recursively merging nested objects and arrays.
* If a property in the source object is an array or object and the corresponding property in the target object is also an array or object, they will be merged.
* If a property in the source object is `undefined`, it will not overwrite a defined property in the target object.
*
* You can provide a custom `merge` function to control how properties are merged. The `merge` function is called for each property that is being merged and receives the following arguments:
*
* - `targetValue`: The current value of the property in the target object.
* - `sourceValue`: The value of the property in the source object.
* - `key`: The key of the property being merged.
* - `target`: The target object.
* - `source`: The source object.
* - `stack`: A `Map` used to keep track of objects that have already been processed to handle circular references.
*
* The `merge` function should return the value to be set in the target object. If it returns `undefined`, a default deep merge will be applied for arrays and objects.
*
* The function can handle multiple source objects and will merge them all into the target object.
*
* @param object - The target object into which the source object properties will be merged. This object is modified in place.
* @param otherArgs - Additional source objects to merge into the target object, including the custom `merge` function.
* @returns The updated target object with properties from the source object(s) merged in.
*
* @example
* const target = { a: 1, b: 2 };
* const source = { b: 3, c: 4 };
*
* mergeWith(target, source, (targetValue, sourceValue) => {
* if (typeof targetValue === 'number' && typeof sourceValue === 'number') {
* return targetValue + sourceValue;
* }
* });
* // Returns { a: 1, b: 5, c: 4 }
* @example
* const target = { a: [1], b: [2] };
* const source = { a: [3], b: [4] };
*
* const result = mergeWith(target, source, (objValue, srcValue) => {
* if (Array.isArray(objValue)) {
* return objValue.concat(srcValue);
* }
* });
*
* expect(result).toEqual({ a: [1, 3], b: [2, 4] });
*/
function mergeWith(object, ...otherArgs) {
const sources = otherArgs.slice(0, -1);
const merge = otherArgs[otherArgs.length - 1];
let result = object;
for (let i = 0; i < sources.length; i++) {
const source = sources[i];
result = mergeWithDeep(result, source, merge, /* @__PURE__ */ new Map());
}
return result;
}
function mergeWithDeep(target, source, merge, stack) {
if (isPrimitive(target)) target = Object(target);
if (source == null || typeof source !== "object") return target;
if (stack.has(source)) return clone(stack.get(source));
stack.set(source, target);
if (Array.isArray(source)) {
source = source.slice();
for (let i = 0; i < source.length; i++) source[i] = source[i] ?? void 0;
}
const sourceKeys = [...Object.keys(source), ...getSymbols(source)];
for (let i = 0; i < sourceKeys.length; i++) {
const key = sourceKeys[i];
if (isUnsafeProperty(key)) continue;
let sourceValue = source[key];
let targetValue = target[key];
if (isArguments(sourceValue)) sourceValue = { ...sourceValue };
if (isArguments(targetValue)) targetValue = { ...targetValue };
if (isBuffer(sourceValue)) sourceValue = cloneDeep(sourceValue);
if (Array.isArray(sourceValue)) if (Array.isArray(targetValue)) {
const cloned = [];
const targetKeys = Reflect.ownKeys(targetValue);
for (let i = 0; i < targetKeys.length; i++) {
const targetKey = targetKeys[i];
cloned[targetKey] = targetValue[targetKey];
}
targetValue = cloned;
} else if (isArrayLikeObject(targetValue)) {
const cloned = [];
for (let i = 0; i < targetValue.length; i++) cloned[i] = targetValue[i];
targetValue = cloned;
} else targetValue = [];
const merged = merge(targetValue, sourceValue, key, target, source, stack);
if (merged !== void 0) target[key] = merged;
else if (Array.isArray(sourceValue)) target[key] = mergeWithDeep(targetValue, sourceValue, merge, stack);
else if (isObjectLike(targetValue) && isObjectLike(sourceValue) && (isPlainObject(targetValue) || isPlainObject(sourceValue) || isTypedArray(targetValue) || isTypedArray(sourceValue))) target[key] = mergeWithDeep(targetValue, sourceValue, merge, stack);
else if (targetValue == null && isPlainObject(sourceValue)) target[key] = mergeWithDeep({}, sourceValue, merge, stack);
else if (targetValue == null && isTypedArray(sourceValue)) target[key] = cloneDeep(sourceValue);
else if (targetValue === void 0 || sourceValue !== void 0) target[key] = sourceValue;
}
return target;
}
//#endregion
export { mergeWith };