Implementing TYPE.Splice

Author: Josema

src/const.js

@@ -1,4 +1,5 @@
 export const DELETE_KEY = '$d'
 export const FUNCTION_KEY = '$f'
 export const REPLACE_KEY = '$r'
+export const SPLICE_KEY = '$s'
 export const ESCAPE_KEY = '$escape'

src/index.js

@@ -5,10 +5,11 @@ import createStoreFactory from './api/createStoreFactory'
 import applyPatchFactory from './api/applyPatchFactory'
 import Delete from './types/Delete'
 import Replace from './types/Replace'
+import Splice from './types/Splice'
 
 function factory() {
- const TYPE = { Delete, Replace }
- const patchers = [Delete.patch, Replace.patch]
+ const TYPE = { Delete, Replace, Splice }
+ const patchers = [Delete.patch, Replace.patch, Splice.patch]
  const encoders = [Delete.encode, Replace.encode]
  const decoders = [Delete.decode, Replace.decode]
  const encode = (object, list = encoders) => converter(object, list)

src/types/Delete.js

@@ -7,8 +7,8 @@ export default function Delete() {
  }
 }
 
-Delete.patch = function({ destiny, prop, oldValue, had_prop }) {
- if (destiny[prop] instanceof Delete) {
+Delete.patch = function({ origin, destiny, prop, oldValue, had_prop }) {
+ if (origin[prop] instanceof Delete || origin[prop] === Delete) {
  delete destiny[prop]
  }
  if (!had_prop) {

src/types/Replace.js

@@ -8,8 +8,8 @@ export default function Replace(value) {
  this.value = value
 }
 
-Replace.patch = function({ destiny, prop, oldValue }) {
- if (destiny[prop] instanceof Replace) {
+Replace.patch = function({ origin, destiny, prop, oldValue }) {
+ if (origin[prop] instanceof Replace) {
  destiny[prop] = destiny[prop].value
  }
  return oldValue

src/types/Splice.js

@@ -0,0 +1,53 @@
+import { isArray } from '../util/is'
+import { ESCAPE_KEY, SPLICE_KEY } from '../const'
+import { getUniqueKey } from '../util/get'
+
+export default function Splice(...args) {
+ if (!(this instanceof Splice)) {
+ return new Splice(...args)
+ }
+ this.args = args
+}
+
+Splice.patch = function({ origin, destiny, prop, oldValue }) {
+ const origin_value = origin[prop]
+ if (isArray(oldValue) && origin_value instanceof Splice) {
+ destiny[prop] = oldValue
+ const { args } = origin_value
+ const spliced = oldValue.splice.apply(oldValue, args)
+ const inverted = [args[0], args.length - 2].concat(spliced)
+ return Splice.apply(null, inverted)
+ }
+ return oldValue
+}
+
+Splice.encode = function({ value }) {
+ if (value instanceof Splice) {
+ return { [SPLICE_KEY]: value.args }
+ } else if (isValidToDecode({ value })) {
+ return { [ESCAPE_KEY]: value }
+ }
+ return value
+}
+
+Splice.decode = function({ value }) {
+ if (isValidToDecode({ value })) {
+ return new Splice(value[SPLICE_KEY])
+ } else if (
+ isValidToEscape({ value }) &&
+ isValidToDecode({ value: value[ESCAPE_KEY] })
+ ) {
+ return value[ESCAPE_KEY]
+ }
+ return value
+}
+
+function isValidToDecode({ value }) {
+ return (
+ getUniqueKey(value) === SPLICE_KEY && value.hasOwnProperty(SPLICE_KEY)
+ )
+}
+
+function isValidToEscape({ value }) {
+ return getUniqueKey(value) === ESCAPE_KEY
+}

src/util/createRequest.js

@@ -1,29 +1,29 @@
-export default function createRequest() {
- let resolve
- let reject
- const promise = new Promise((res, rej) => {
- resolve = res
- reject = rej
- })
- promise.resolve = resolve
- promise.reject = reject
- return promise
-}
-
-// function Request(executor) {
-// let resolve
-// let reject
-// const promise = new Promise((res, rej) => {
-// resolve = res
-// reject = rej
-// // return executor(res, rej)
-// })
-
-// promise.__proto__ = Request.prototype
-// promise.resolve = resolve
-// promise.reject = reject
-// return promise
-// }
-
-// Request.__proto__ = Promise
-// Request.prototype.__proto__ = Promise.prototype
+export default function createRequest() {
+ let resolve
+ let reject
+ const promise = new Promise((res, rej) => {
+ resolve = res
+ reject = rej
+ })
+ promise.resolve = resolve
+ promise.reject = reject
+ return promise
+}
+
+// function Request(executor) {
+// let resolve
+// let reject
+// const promise = new Promise((res, rej) => {
+// resolve = res
+// reject = rej
+// // return executor(res, rej)
+// })
+
+// promise.__proto__ = Request.prototype
+// promise.resolve = resolve
+// promise.reject = reject
+// return promise
+// }
+
+// Request.__proto__ = Promise
+// Request.prototype.__proto__ = Promise.prototype

test/type_splice.js

@@ -0,0 +1,37 @@
+import test from 'ava'
+import { applyPatch, encode, decode, TYPE } from '../'
+import { getNewPlain } from '../src/util/get'
+import { isPlainObject } from '../src/util/is'
+
+function testBasic(t, patch, expected, recursive = true) {
+ const encoded = encode(patch)
+ const decoded = decode(encoded)
+ t.deepEqual(expected, encoded)
+ t.deepEqual(patch, decoded)
+ t.not(patch, encoded)
+ t.not(encoded, decoded)
+}
+
+function testUnpatch(t, target, patch, expected, reverse = true) {
+ const cloned = getNewPlain(target)
+ const output = applyPatch(target, patch)
+ const { unpatch, mutations, result } = output
+ console.log({ result, cloned })
+ if (isPlainObject(result)) {
+ t.is(target, result)
+ }
+ target = result
+ t.deepEqual(target, expected)
+ if (reverse) {
+ const output2 = applyPatch(target, unpatch)
+ t.deepEqual(output2.result, cloned)
+ }
+ return { unpatch, mutations }
+}
+
+test('patch', function(t) {
+ const target = { array: ['a', 'b', 'c'] }
+ const patch = { array: TYPE.Splice(0, 1, 'd') }
+ const expected = { array: ['d', 'b', 'c'] }
+ testUnpatch(t, target, patch, expected)
+})