Added combine()

Author: luca-vogels

package.json

@@ -1,6 +1,6 @@
 {
   "name": "lup-utils",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "NodeJS library providing utility functions.",
   "main": "./lib/index",
   "types": "./lib/index.d.ts",

src/__tests__/object.test.ts

@@ -1,38 +1,38 @@
-import { combineObjects, deepEqual, difference } from '../object';
+import { combine, deepEqual, difference } from '../object';
 
-test('combineObjects()', async () => {
-  expect(combineObjects(undefined, undefined)).toBeUndefined();
-  expect(combineObjects(undefined, 5)).toBe(5);
-  expect(combineObjects(5, undefined)).toBeUndefined();
-  expect(combineObjects(5, undefined, { ignoreUndefined: true })).toBe(5);
-  expect(combineObjects(5, 10)).toBe(10);
-  expect(combineObjects(5, 0, { ignoreUndefined: true })).toBe(0);
+test('combine()', async () => {
+  expect(combine(undefined, undefined)).toBeUndefined();
+  expect(combine(undefined, 5)).toBe(5);
+  expect(combine(5, undefined)).toBeUndefined();
+  expect(combine(5, undefined, { ignoreUndefined: true })).toBe(5);
+  expect(combine(5, 10)).toBe(10);
+  expect(combine(5, 0, { ignoreUndefined: true })).toBe(0);
 
-  expect(combineObjects([1, 2], [3, 4])).toEqual([3, 4]);
-  expect(combineObjects([1, 2], [3, 4], { mergeArrays: true })).toEqual([1, 2, 3, 4]);
+  expect(combine([1, 2], [3, 4])).toEqual([3, 4]);
+  expect(combine([1, 2], [3, 4], { mergeArrays: true })).toEqual([1, 2, 3, 4]);
 
-  expect(combineObjects({ a: 1, b: 2 }, { b: 3, c: 4 })).toEqual({ a: 1, b: 3, c: 4 });
-  expect(combineObjects({ a: 1, b: 2 }, { b: undefined, c: 4 }, { ignoreUndefined: false })).toEqual({
+  expect(combine({ a: 1, b: 2 }, { b: 3, c: 4 })).toEqual({ a: 1, b: 3, c: 4 });
+  expect(combine({ a: 1, b: 2 }, { b: undefined, c: 4 }, { ignoreUndefined: false })).toEqual({
     a: 1,
     b: undefined,
     c: 4,
   });
-  expect(combineObjects({ a: 1, b: 2 }, { b: undefined, c: 4 }, { ignoreUndefined: true })).toEqual({
+  expect(combine({ a: 1, b: 2 }, { b: undefined, c: 4 }, { ignoreUndefined: true })).toEqual({
     a: 1,
     b: 2,
     c: 4,
   });
 
-  expect(combineObjects({ a: 1, b: { c: 5, d: 6 } }, { b: { e: 7 } }, { recursive: false })).toEqual({
+  expect(combine({ a: 1, b: { c: 5, d: 6 } }, { b: { e: 7 } }, { recursive: false })).toEqual({
     a: 1,
     b: { e: 7 },
   });
-  expect(combineObjects({ a: 1, b: { c: 5, d: 6 } }, { b: { e: 7 } }, { recursive: true })).toEqual({
+  expect(combine({ a: 1, b: { c: 5, d: 6 } }, { b: { e: 7 } }, { recursive: true })).toEqual({
     a: 1,
     b: { c: 5, d: 6, e: 7 },
   });
 
-  expect(combineObjects({ a: [1, 2], b: 2 }, { a: [3, 4] }, { mergeArrays: true })).toEqual({ a: [1, 2, 3, 4], b: 2 });
+  expect(combine({ a: [1, 2], b: 2 }, { a: [3, 4] }, { mergeArrays: true })).toEqual({ a: [1, 2, 3, 4], b: 2 });
 });
 
 test('deepEqual()', async () => {

src/object.ts

@@ -1,4 +1,11 @@
-export function combineObjects<O, N>(
+/**
+ * Combines two objects into one, with options for handling undefined values, merging arrays, and deep merging.
+ * @param oldObj The original object.
+ * @param newObj The object to merge into the original.
+ * @param options Options for merging behavior.
+ * @returns A new object that combines the properties of both input objects.
+ */
+export function combine<O, N>(
   oldObj: O,
   newObj: N,
   options?: {
@@ -49,7 +56,7 @@ export function combineObjects<O, N>(
       typeof newValue === 'object' &&
       newValue !== null
     ) {
-      result[key] = combineObjects(oldValue, newValue, options);
+      result[key] = combine(oldValue, newValue, options);
       continue;
     }