Dirty inner array solution

Author: Josema

src/api/applyPatchFactory.js

@@ -9,6 +9,17 @@ export default function applyPatchFactory(patchers) {
         const patch_root = { '': patch } // a trick to allow top level patches
         const unpatch_root = { '': {} }
 
+        function registerMutation(path, object, prop, old_value) {
+            // console.log(path, object, prop, old_value)
+            setDeep(unpatch_root, path.slice(0), old_value)
+            mutations.push({
+                old_value,
+                object,
+                prop,
+                path: path.slice(1),
+            })
+        }
+
         forEachObject(
             patch_root,
             target_root,
@@ -19,13 +30,8 @@ export default function applyPatchFactory(patchers) {
                 if (
                     !had_prop ||
                     (patch_value !== target_value &&
-                        !(
-                            isPlainObject(patch_value) &&
-                            isPlainObject(target_value)
-                        ))
+                        !(isPlainObject(patch_value) && isPlain(target_value)))
                 ) {
-                    target[prop] = patch_value
-
                     // Applying patches
                     const old_value = patchers.reduce(
                         (old_value, p) =>
@@ -36,20 +42,16 @@ export default function applyPatchFactory(patchers) {
                                 path,
                                 old_value,
                                 had_prop,
+                                unpatch_root,
                                 applyPatch,
+                                registerMutation,
                             }),
                         target_value
                     )
 
                     // We register the mutation if old_value is different to the new value
                     if (target[prop] !== old_value) {
-                        setDeep(unpatch_root, path.slice(0), old_value)
-                        mutations.push({
-                            old_value,
-                            object: target,
-                            prop,
-                            path: path.slice(1),
-                        })
+                        registerMutation(path, target, prop, old_value)
                     }
 
                     return false // we don't go deeper

src/index.js

@@ -7,10 +7,9 @@ import createStoreFactory from './api/createStoreFactory'
 import applyPatchFactory from './api/applyPatchFactory'
 
 import Function from './types/Function'
-import Plain from './types/Plain'
+import Primitives from './types/Primitives'
 import Delete from './types/Delete'
 import Replace from './types/Replace'
-import Inner from './types/Inner'
 import Splice from './types/Splice'
 import Swap from './types/Swap'
 
@@ -32,10 +31,9 @@ function factory() {
     }
 
     addType(Function)
-    addType(Plain)
+    addType(Primitives)
     addType(Delete)
     addType(Replace)
-    addType(Inner)
     addType(Splice)
     addType(Swap)
 
@@ -52,7 +50,6 @@ function factory() {
         TYPE: {
             Delete,
             Replace,
-            Inner,
             Splice,
             Swap,
         },

src/types/Delete.js

@@ -12,9 +12,6 @@ Delete.patch = function ({ patch, target, prop, old_value, had_prop }) {
     if (patch[prop] instanceof Delete || patch[prop] === Delete) {
         delete target[prop]
     }
-    if (!had_prop) {
-        old_value = new Delete()
-    }
     return old_value
 }
 

src/types/Inner.js

@@ -0,0 +1,62 @@
+import { isArray, isPlainObject } from '../util/is'
+import merge from '../util/merge'
+import Replace from './Replace'
+import Delete from './Delete'
+
+export default function Primitives() {}
+
+Primitives.patch = function ({
+    patch,
+    target,
+    prop,
+    old_value,
+    path,
+    had_prop,
+    unpatch_root,
+    applyPatch,
+    registerMutation,
+}) {
+    const patch_value = patch[prop]
+
+    if (!had_prop) {
+        if (isArray(target)) {
+            const path_length = path.slice(0, path.length - 1).concat('length')
+            // console.log(
+            //     path_length.join('.'),
+            //     unpatch_root,
+            //     getDeep(unpatch_root, path_length.slice(0))
+            // )
+            if (!getDeep(unpatch_root, path_length.slice(0))) {
+                registerMutation(path_length, target, 'length', target.length)
+            }
+        } else {
+            old_value = new Delete()
+        }
+    }
+
+    if (isPlainObject(patch_value)) {
+        // console.log({ path, had_prop, target })
+        target[prop] = applyPatch({}, patch_value).result
+    }
+
+    // New array
+    else if (isArray(patch_value)) {
+        target[prop] = merge([], patch_value)
+        return isPlainObject(old_value) ? Replace(old_value) : old_value
+    }
+
+    // Any other
+    else {
+        target[prop] = patch_value
+    }
+
+    return old_value
+}
+
+function getDeep(object, path) {
+    if (path.length === 0) {
+        return true
+    }
+    const prop = path.shift()
+    return object.hasOwnProperty(prop) ? getDeep(object[prop], path) : false
+}