Splice and Replace can encode and decode internally

Author: Josema

src/types/Replace.js

@@ -16,18 +16,18 @@ Replace.patch = function ({ patch, target, prop, old_value }) {
     return old_value
 }
 
-Replace.encode = function ({ value }) {
+Replace.encode = function ({ value, encode }) {
     if (value instanceof Replace) {
-        return { [REPLACE_KEY]: value.value }
+        return { [REPLACE_KEY]: encode(value.value) }
     } else if (isValidToDecode({ value, key: REPLACE_KEY })) {
         return { [ESCAPE_KEY]: value }
     }
     return value
 }
 
-Replace.decode = function ({ value }) {
+Replace.decode = function ({ value, decode }) {
     if (isValidToDecode({ value, key: REPLACE_KEY })) {
-        return new Replace(value[REPLACE_KEY])
+        return new Replace(decode(value[REPLACE_KEY]))
     } else if (
         isValidToEscape({ value }) &&
         isValidToDecode({ value: value[ESCAPE_KEY], key: REPLACE_KEY })

src/types/Splice.js

@@ -27,18 +27,18 @@ Splice.patch = function ({ patch, target, prop, old_value }) {
     return old_value
 }
 
-Splice.encode = function ({ value }) {
+Splice.encode = function ({ value, encode }) {
     if (value instanceof Splice) {
-        return { [SPLICE_KEY]: value.args }
+        return { [SPLICE_KEY]: encode(value.args) }
     } else if (isValidToDecode({ value, key: SPLICE_KEY })) {
         return { [ESCAPE_KEY]: value }
     }
     return value
 }
 
-Splice.decode = function ({ value }) {
+Splice.decode = function ({ value, decode }) {
     if (isValidToDecode({ value, key: SPLICE_KEY })) {
-        return Splice.apply(null, value[SPLICE_KEY])
+        return Splice.apply(null, decode(value[SPLICE_KEY]))
     } else if (
         isValidToEscape({ value }) &&
         isValidToDecode({ value: value[ESCAPE_KEY], key: SPLICE_KEY })

test/type_multi.js

@@ -15,33 +15,41 @@ test('Inner encode', function (t) {
     const { encoded, decoded } = testEncodeDecode(t, patch, expected)
 })
 
-// test('Escape', function (t) {
-//     const patch = { escape: { $w: [0, 1] } }
-//     const expected = { escape: { $escape: { $w: [0, 1] } } }
-//     testEncodeDecode(t, patch, expected)
-// })
+test('Escape', function (t) {
+    const patch = { escape: { $m: [0, 1] } }
+    const expected = { escape: { $escape: { $m: [0, 1] } } }
+    testEncodeDecode(t, patch, expected)
+})
 
-// test('Ignore', function (t) {
-//     const patch = { ignore: { $w: { a: 2 } } }
-//     const expected = { ignore: { $w: { a: 2 } } }
-//     testEncodeDecode(t, patch, expected)
-// })
+test('Ignore', function (t) {
+    const patch = { ignore: { $m: { a: 2 } } }
+    const expected = { ignore: { $m: { a: 2 } } }
+    testEncodeDecode(t, patch, expected)
+})
 
-// test('API', function (t) {
-//     const target = { array: ['a', 'b'] }
-//     const patch = { array: TYPE.Swap(0, 1) }
-//     const expected = { array: ['b', 'a'] }
-//     const { unpatch, result, mutations } = testPatchUnpatch(
-//         t,
-//         target,
-//         patch,
-//         expected
-//     )
-//     t.is(mutations.length, 1)
-//     t.is(result.array, target.array)
-//     t.true(unpatch.array instanceof TYPE.Swap)
-//     t.deepEqual(unpatch.array.args, [1, 0])
-// })
+test('API', function (t) {
+    const target = { array: ['a', 'b'] }
+    const array = target.array
+    const patch = {
+        array: TYPE.Multi(
+            TYPE.Splice(0, 0, 'c'),
+            TYPE.Swap(0, 2),
+            TYPE.Swap(1, 2)
+        ),
+    }
+    const expected = { array: ['b', 'c', 'a'] }
+    const { unpatch, result, mutations } = testPatchUnpatch(
+        t,
+        target,
+        patch,
+        expected
+    )
+    t.is(mutations.length, 1)
+    t.is(result.array, target.array)
+    t.is(array, target.array)
+    t.true(unpatch.array instanceof TYPE.Multi)
+    t.is(unpatch.array.values.length, 3)
+})
 
 test('Deleting', function (t) {
     const target = { array: false }
@@ -57,7 +65,7 @@ test('Adding array and swaping', function (t) {
     testPatchUnpatch(t, target, patch, expected)
 })
 
-test('Undefined  before applying Multi', function (t) {
+test('Undefined before applying Multi', function (t) {
     const target = {}
     const patch = { array: TYPE.Multi(true) }
     const expected = { array: true }

test/type_replace.js

@@ -133,3 +133,11 @@ test('same behavior as replace array', function (t) {
 
     testPatchUnpatch(t, target, patch, expected)
 })
+
+test('inner types', function (t) {
+    const target = { value: { a: 1, b: 2 } }
+    const patch = { value: TYPE.Replace({ a: 1, b: TYPE.Swap(1, 2) }) }
+    const expected = { value: { a: 1, b: TYPE.Swap(1, 2) } }
+
+    testPatchUnpatch(t, target, patch, expected, false)
+})

test/type_splice.js

@@ -96,6 +96,14 @@ function testAgainstNative(t, original, params) {
     // console.log({ result: target })
 }
 
+test('inner types', function (t) {
+    const target = { value: [0, 1] }
+    const patch = { value: TYPE.Splice(2, 0, TYPE.Swap(1, 2)) }
+    const expected = { value: [0, 1, TYPE.Swap(1, 2)] }
+
+    testPatchUnpatch(t, target, patch, expected, false)
+})
+
 test('1/ vs Array.splice', function (t) {
     const original = ['angel', 'clown', 'mandarin', 'sturgeon']
     const params = [0, 0]