@tim-code/my-util 0.2.5 → 0.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tim-code/my-util",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "description": "",
   "type": "module",
   "author": "",

package/src/object.js

@@ -55,3 +55,37 @@ export function like(template) {
     return true
   }
 }
+
+/**
+ * Deeply merges one or more source objects into a target object.
+ * If the property values are objects, they are merged recursively.
+ * Non-object properties (including arrays) are directly assigned to the target.
+ * @param {Object} target The target object that will receive the merged properties.
+ * @param {...Object} sources The source objects whose properties will be merged into the target.
+ * @returns {Object} The target object with the merged properties from all source objects.
+ */
+export function deepMerge(target, ...sources) {
+  for (const source of sources) {
+    const keys = Object.keys(source)
+    for (const key of keys) {
+      if (!Object.hasOwn(source, key)) {
+        continue
+      }
+      const targetValue = target[key]
+      const sourceValue = source[key]
+      if (Array.isArray(sourceValue)) {
+        target[key] = sourceValue
+      } else if (
+        targetValue &&
+        typeof targetValue === "object" &&
+        sourceValue &&
+        typeof sourceValue === "object"
+      ) {
+        deepMerge(targetValue, sourceValue)
+      } else {
+        target[key] = sourceValue
+      }
+    }
+  }
+  return target
+}

package/src/object.test.js

@@ -1,6 +1,6 @@
 /* eslint-disable no-restricted-syntax */
 import { jest } from "@jest/globals"
-import { deleteUndefinedValues, like, mutateValues, via } from "./object.js"
+import { deepMerge, deleteUndefinedValues, like, mutateValues, via } from "./object.js"
 
 describe("mutateValues", () => {
   it("mutates values in the object using the callback", () => {
@@ -159,3 +159,101 @@ describe("contains", () => {
     expect(fn(obj)).toBe(false)
   })
 })
+
+describe("deepMerge", () => {
+  it("merges flat objects", () => {
+    const target = { a: 1, b: 2 }
+    const source = { b: 3, c: 4 }
+    expect(deepMerge(target, source)).toEqual({ a: 1, b: 3, c: 4 })
+    expect(target).toEqual({ a: 1, b: 3, c: 4 })
+  })
+
+  it("deeply merges nested objects", () => {
+    const target = { a: { x: 1, y: 2 }, b: 2 }
+    const source = { a: { y: 3, z: 4 }, b: 5 }
+    expect(deepMerge(target, source)).toEqual({ a: { x: 1, y: 3, z: 4 }, b: 5 })
+    expect(target).toEqual({ a: { x: 1, y: 3, z: 4 }, b: 5 })
+  })
+
+  it("overwrites arrays instead of merging them", () => {
+    const target = { arr: [1, 2], a: 1 }
+    const source = { arr: [3, 4] }
+    expect(deepMerge(target, source)).toEqual({ arr: [3, 4], a: 1 })
+  })
+
+  it("merges multiple sources left-to-right", () => {
+    const target = { a: 1 }
+    const s1 = { b: 2 }
+    const s2 = { a: 3, c: 4 }
+    expect(deepMerge(target, s1, s2)).toEqual({ a: 3, b: 2, c: 4 })
+  })
+
+  it("does not merge non-object values, just assigns", () => {
+    const target = { a: { x: 1 } }
+    const source = { a: 2 }
+    expect(deepMerge(target, source)).toEqual({ a: 2 })
+  })
+
+  it("handles empty sources", () => {
+    const target = { a: 1 }
+    expect(deepMerge(target)).toEqual({ a: 1 })
+    expect(deepMerge(target, {})).toEqual({ a: 1 })
+  })
+
+  it("handles empty target", () => {
+    const target = {}
+    const source = { a: 1 }
+    expect(deepMerge(target, source)).toEqual({ a: 1 })
+  })
+
+  it("does not merge inherited properties from sources", () => {
+    const proto = { x: 1 }
+    const source = Object.create(proto)
+    source.a = 2
+    const target = {}
+    expect(deepMerge(target, source)).toEqual({ a: 2 })
+    expect("x" in target).toBe(false)
+  })
+
+  it("merges deeply with multiple sources", () => {
+    const target = { a: { x: 1 } }
+    const s1 = { a: { y: 2 } }
+    const s2 = { a: { z: 3 } }
+    expect(deepMerge(target, s1, s2)).toEqual({ a: { x: 1, y: 2, z: 3 } })
+  })
+
+  it("does not merge if source value is null", () => {
+    const target = { a: { x: 1 } }
+    const source = { a: null }
+    expect(deepMerge(target, source)).toEqual({ a: null })
+  })
+
+  it("does not merge if target value is null", () => {
+    const target = { a: null }
+    const source = { a: { x: 1 } }
+    expect(deepMerge(target, source)).toEqual({ a: { x: 1 } })
+  })
+
+  it("does not merge arrays deeply", () => {
+    const target = { a: [1, 2, 3] }
+    const source = { a: [4, 5] }
+    expect(deepMerge(target, source)).toEqual({ a: [4, 5] })
+  })
+
+  it("does not merge non-enumerable properties from source", () => {
+    const target = {}
+    const source = {}
+    Object.defineProperty(source, "hidden", {
+      value: 123,
+      enumerable: false,
+    })
+    expect(deepMerge(target, source)).toEqual({})
+    expect("hidden" in target).toBe(false)
+  })
+
+  it("returns the target object", () => {
+    const target = { a: 1 }
+    const result = deepMerge(target, { b: 2 })
+    expect(result).toBe(target)
+  })
+})