feat: set support merge (#441)

Author: zombieJ

src/utils/set.ts

@@ -1,8 +1,10 @@
 import get from './get';
 
+export type Path = (string | number)[];
+
 function internalSet<Entity = any, Output = Entity, Value = any>(
   entity: Entity,
-  paths: (string | number)[],
+  paths: Path,
   value: Value,
   removeIfUndefined: boolean,
 ): Output {
@@ -49,3 +51,52 @@ export default function set<Entity = any, Output = Entity, Value = any>(
 
   return internalSet(entity, paths, value, removeIfUndefined);
 }
+
+function isObject(obj: any) {
+  return (
+    typeof obj === 'object' &&
+    obj !== null &&
+    Object.getPrototypeOf(obj) === Object.prototype
+  );
+}
+
+function createEmpty<T>(source: T) {
+  return (Array.isArray(source) ? [] : {}) as T;
+}
+
+/**
+ * Merge objects which will create
+ */
+export function merge<T extends object>(...sources: T[]) {
+  let clone = createEmpty(sources[0]);
+
+  const loopSet = new Set<object>();
+
+  sources.forEach(src => {
+    function internalMerge(path: Path) {
+      const value = get(src, path);
+
+      if (isObject(value) || Array.isArray(value)) {
+        // Only add not loop obj
+        if (!loopSet.has(value)) {
+          loopSet.add(value);
+
+          // Init container if not exist
+          if (!get(clone, path)) {
+            clone = set(clone, path, createEmpty(value));
+          }
+
+          Object.keys(value).forEach(key => {
+            internalMerge([...path, key]);
+          });
+        }
+      } else {
+        clone = set(clone, path, value);
+      }
+    }
+
+    internalMerge([]);
+  });
+
+  return clone;
+}

tests/utils.test.js

@@ -1,6 +1,6 @@
-import get from '../src/utils/get';
-import set from '../src/utils/set';
 import pickAttrs from '../src/pickAttrs';
+import get from '../src/utils/get';
+import set, { merge } from '../src/utils/set';
 
 describe('utils', () => {
   it('get', () => {
@@ -96,6 +96,90 @@ describe('utils', () => {
       expect(longTgt).toEqual({ lv1: { lv2: { lv3: {} } } });
       expect('lv4' in longTgt.lv1.lv2.lv3).toBeFalsy();
     });
+
+    describe('merge', () => {
+      it('basic', () => {
+        const merged = merge({}, { a: 1 }, { b: 2 });
+
+        expect(merged).toEqual({
+          a: 1,
+          b: 2,
+        });
+      });
+
+      it('array', () => {
+        const merged = merge([], [{ a: 1 }], [{ b: 2 }]);
+
+        expect(merged).toEqual([
+          {
+            a: 1,
+            b: 2,
+          },
+        ]);
+      });
+
+      it('not cover', () => {
+        const merged = merge(
+          [],
+          [{ a: { e: 8 }, b: 2 }],
+          [{ a: { f: 9 }, c: 3 }],
+        );
+
+        expect(merged).toEqual([
+          {
+            a: {
+              e: 8,
+              f: 9,
+            },
+            b: 2,
+            c: 3,
+          },
+        ]);
+      });
+
+      it('DayObject', () => {
+        const now = new Date();
+
+        const merged = merge(
+          { a: 123 },
+          { b: 234 },
+          {
+            now,
+          },
+        );
+
+        expect(merged).toEqual({
+          a: 123,
+          b: 234,
+          now,
+        });
+
+        expect(merged.now).toBe(now);
+      });
+
+      it('empty object', () => {
+        const merged = merge({}, { a: {} });
+        expect(merged).toEqual({ a: {} });
+      });
+
+      it('no dead-loop', () => {
+        const looper = {
+          a: 1,
+          b: {
+            c: 3,
+          },
+        };
+        looper.b.looper = looper;
+
+        const merged = merge(looper);
+        expect(merged).toEqual({
+          a: 1,
+          b: {
+            c: 3,
+          },
+        });
+      });
+    });
   });
 
   describe('pickAttrs', () => {