Making Multi type

Author: Josema

src/const.js

@@ -1,7 +1,7 @@
 export const ESCAPE_KEY = '$escape'
-export const DELETE_KEY = '$d'
 export const FUNCTION_KEY = '$f'
+export const DELETE_KEY = '$d'
 export const REPLACE_KEY = '$r'
 export const SPLICE_KEY = '$s'
-export const INNER_KEY = '$i'
 export const SWAP_KEY = '$w'
+export const MULTI_KEY = '$m'

src/index.js

@@ -6,12 +6,13 @@ import createNodeFactory from './api/createNodeFactory'
 import createStoreFactory from './api/createStoreFactory'
 import applyPatchFactory from './api/applyPatchFactory'
 
+import Function from './types/Function'
 import Primitives from './types/Primitives'
 import Delete from './types/Delete'
 import Replace from './types/Replace'
 import Splice from './types/Splice'
 import Swap from './types/Swap'
-import Function from './types/Function'
+import Multi from './types/Multi'
 
 function factory() {
     const patchers = []
@@ -30,12 +31,13 @@ function factory() {
         if (isFunction(decode)) decoders.push(decode)
     }
 
+    addType(Function)
     addType(Primitives)
     addType(Delete)
     addType(Replace)
     addType(Splice)
     addType(Swap)
-    addType(Function)
+    addType(Multi)
 
     return {
         version,
@@ -52,6 +54,7 @@ function factory() {
             Replace,
             Splice,
             Swap,
+            Multi,
         },
     }
 }

src/types/Multi.js

@@ -0,0 +1,49 @@
+import { ESCAPE_KEY, MULTI_KEY } from '../const'
+import { isValidToEscape } from '../util/isValid'
+import { getUniqueKey } from '../util/get'
+import { isArray } from '../util/is'
+
+export default function Multi(...values) {
+    if (!(this instanceof Multi)) {
+        return new Multi(...values)
+    }
+    this.values = values
+}
+
+Multi.patch = function ({ patch, target, prop, old_value, applyPatch }) {
+    const patch_value = patch[prop]
+    if (patch_value instanceof Multi) {
+        target[prop] = old_value
+        const unpatch = patch_value.values.map((value) => {
+            const { unpatch } = applyPatch(target, { [prop]: value })
+            return unpatch[prop]
+        })
+        return Multi.apply(null, unpatch.reverse())
+    }
+    return old_value
+}
+
+Multi.encode = function ({ value, encode }) {
+    if (value instanceof Multi) {
+        return { [MULTI_KEY]: encode(value.values) }
+    } else if (isValidToDecodeMulti({ value })) {
+        return { [ESCAPE_KEY]: value }
+    }
+    return value
+}
+
+Multi.decode = function ({ value, decode }) {
+    if (isValidToDecodeMulti({ value })) {
+        return Multi.apply(null, decode(value[MULTI_KEY]))
+    } else if (
+        isValidToEscape({ value }) &&
+        isValidToDecodeMulti({ value: value[ESCAPE_KEY] })
+    ) {
+        return value[ESCAPE_KEY]
+    }
+    return value
+}
+
+function isValidToDecodeMulti({ value }) {
+    return getUniqueKey(value) === MULTI_KEY && isArray(value[MULTI_KEY])
+}

test/type_multi.js

@@ -0,0 +1,65 @@
+import test from 'ava'
+import { applyPatch } from '../'
+import { TYPE } from '../'
+import { testEncodeDecode, testPatchUnpatch } from './utils'
+
+test('Valid type', function (t) {
+    const patch = { convert: TYPE.Multi(0, 1) }
+    const expected = { convert: { $m: [0, 1] } }
+    testEncodeDecode(t, patch, expected)
+})
+
+test('Inner encode', function (t) {
+    const patch = { convert: TYPE.Multi(0, 1, TYPE.Delete()) }
+    const expected = { convert: { $m: [0, 1, { $d: 0 }] } }
+    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('Ignore', function (t) {
+//     const patch = { ignore: { $w: { a: 2 } } }
+//     const expected = { ignore: { $w: { 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('Deleting', function (t) {
+    const target = { array: false }
+    const patch = { array: TYPE.Multi(TYPE.Delete()) }
+    const expected = {}
+    testPatchUnpatch(t, target, patch, expected)
+})
+
+test('Adding array and swaping', function (t) {
+    const target = { array: 1234 }
+    const patch = { array: TYPE.Multi([1, 2], TYPE.Swap(0, 1)) }
+    const expected = { array: [2, 1] }
+    testPatchUnpatch(t, target, patch, expected)
+})
+
+test('Undefined  before applying Multi', function (t) {
+    const target = {}
+    const patch = { array: TYPE.Multi(true) }
+    const expected = { array: true }
+    testPatchUnpatch(t, target, patch, expected)
+})

test/utils.js

@@ -31,15 +31,26 @@ function testEncodeDecode(
     const encoded = serializeDeserialize(encode(patch), serialize)
     t.deepEqual(expected, encoded)
     t.not(patch, encoded)
+    const decoded = decode(serializeDeserialize(encoded, serialize))
     if (reverse) {
-        const decoded = decode(serializeDeserialize(encoded, serialize))
         t.deepEqual(patch, decoded)
         t.not(encoded, decoded)
     }
+    return { encoded, decoded }
 }
 
-function testPatchUnpatch(t, target, patch, expected, reverse = true) {
+function testPatchUnpatch(
+    t,
+    target,
+    patch,
+    expected,
+    reverse = true,
+    serialize = true
+) {
     const cloned = getNewPlain(target)
+
+    // patch = decode(serializeDeserialize(encode(patch), serialize))
+
     const output = applyPatch(target, patch)
     const { unpatch, mutations, result } = output
     if (isPlainObject(result) && isPlainObject(target)) {