Refactor forEachObject

Author: Josema

src/api/applyPatchFactory.js

@@ -12,6 +12,7 @@ export default function applyPatchFactory(patchers) {
 
         forEachObject(
             patch_root,
+            target_root,
             ({ origin, destiny, prop, path }) => {
                 const origin_value = origin[prop]
                 const destiny_value = destiny[prop]
@@ -24,7 +25,7 @@ export default function applyPatchFactory(patchers) {
                             isPlainObject(destiny_value)
                         ))
                 ) {
-                    let oldValue = destiny[prop]
+                    let oldValue = destiny_value
 
                     destiny[prop] = isPlainObject(origin_value) // immutable
                         ? applyPatch({}, origin_value).result
@@ -44,6 +45,7 @@ export default function applyPatchFactory(patchers) {
                             }),
                         oldValue
                     )
+
                     setDeep(unpatch_root, path.slice(0), oldValue)
                     mutations.push({
                         oldValue,
@@ -54,8 +56,7 @@ export default function applyPatchFactory(patchers) {
 
                     return false // we dont go deeper
                 }
-            },
-            target_root
+            }
         )
 
         return {

src/util/converter.js

@@ -4,28 +4,24 @@ import { isArray } from '../util/is'
 
 export default function converter(origin, converters) {
     const destiny = isArray(origin) ? [] : {}
-    forEachObject(
-        origin,
-        ({ origin, prop, destiny, path }) => {
-            const value = converters.reduce(
-                (value, converter) =>
-                    converter({
-                        value,
-                        origin,
-                        destiny,
-                        prop,
-                        path
-                    }),
-                origin[prop]
-            )
-            if (origin[prop] !== value) {
-                destiny[prop] = value
-                return false // we don't go deeper
-            } else {
-                return mergeMutator({ origin, destiny, prop })
-            }
-        },
-        destiny
-    )
+    forEachObject(origin, destiny, ({ origin, prop, destiny, path }) => {
+        const value = converters.reduce(
+            (value, converter) =>
+                converter({
+                    value,
+                    origin,
+                    destiny,
+                    prop,
+                    path
+                }),
+            origin[prop]
+        )
+        if (origin[prop] !== value) {
+            destiny[prop] = value
+            return false // we don't go deeper
+        } else {
+            return mergeMutator({ origin, destiny, prop })
+        }
+    })
     return destiny
 }

src/util/forEachObject.js

@@ -3,45 +3,17 @@ import forEach from './forEach'
 
 // https://jsperf.com/dop-foreachobject
 // https://2ality.com/2019/10/shared-mutable-state.html
-export default function forEachObject(origin, callback, destiny) {
-    const circular = new Set()
-    const path = []
-    const has_destiny = isObject(destiny)
-    forEachObjectLoop(origin, destiny, callback, path, has_destiny, circular)
+export default function forEachObject(origin, destiny, mutator) {
+    forEachObjectLoop(origin, destiny, mutator, [])
 }
 
-function forEachObjectLoop(
-    origin,
-    destiny,
-    callback,
-    path,
-    has_destiny,
-    circular
-) {
+function forEachObjectLoop(origin, destiny, mutator, path) {
     forEach(origin, (value_origin, prop) => {
         path.push(prop)
-
-        const go_deep = callback({ origin, destiny, prop, path })
-
-        if (
-            isObject(value_origin) &&
-            go_deep !== false &&
-            value_origin !== origin &&
-            // (!has_destiny ||
-            //     (has_destiny && destiny[prop] !== undefined)) &&
-            !circular.has(value_origin)
-        ) {
-            circular.add(value_origin)
-            forEachObjectLoop(
-                value_origin,
-                has_destiny ? destiny[prop] : undefined,
-                callback,
-                path,
-                has_destiny,
-                circular
-            )
+        const shallWeGoDown = mutator({ origin, destiny, prop, path })
+        if (shallWeGoDown !== false && isObject(value_origin)) {
+            forEachObjectLoop(value_origin, destiny[prop], mutator, path)
         }
-
         path.pop()
     })
 }

src/util/merge.js

@@ -17,7 +17,7 @@ export default function merge(destiny, origin) {
     } else if (origin === destiny) {
         return destiny
     } else {
-        forEachObject(origin, mergeMutator, destiny)
+        forEachObject(origin, destiny, mergeMutator)
         return destiny
     }
 }