@liveblocks/client 0.16.4-beta2 → 0.16.4

package/internal.js

@@ -4,33 +4,364 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var LiveObject = require('./shared.js');
 
+function lsonObjectToJson(obj) {
+  var result = {};
 
+  for (var _key in obj) {
+    var val = obj[_key];
+
+    if (val !== undefined) {
+      result[_key] = lsonToJson(val);
+    }
+  }
+
+  return result;
+}
+
+function liveObjectToJson(liveObject) {
+  return lsonObjectToJson(liveObject.toObject());
+}
+
+function liveMapToJson(map) {
+  var result = {};
+
+  for (var _iterator = LiveObject._createForOfIteratorHelperLoose(map.entries()), _step; !(_step = _iterator()).done;) {
+    var _step$value = _step.value,
+        _key2 = _step$value[0],
+        value = _step$value[1];
+    result[_key2] = lsonToJson(value);
+  }
+
+  return result;
+}
+
+function lsonListToJson(value) {
+  return value.map(lsonToJson);
+}
+
+function liveListToJson(value) {
+  return lsonListToJson(value.toArray());
+}
+
+function lsonToJson(value) {
+  if (value instanceof LiveObject.LiveObject) {
+    return liveObjectToJson(value);
+  } else if (value instanceof LiveObject.LiveList) {
+    return liveListToJson(value);
+  } else if (value instanceof LiveObject.LiveMap) {
+    return liveMapToJson(value);
+  } else if (value instanceof LiveObject.LiveRegister) {
+    return value.data;
+  } else if (value instanceof LiveObject.AbstractCrdt) {
+    throw new Error("Unhandled subclass of AbstractCrdt encountered");
+  }
+
+  if (Array.isArray(value)) {
+    return lsonListToJson(value);
+  } else if (isPlainObject(value)) {
+    return lsonObjectToJson(value);
+  }
+
+  return value;
+}
+
+function isPlainObject(obj) {
+  return obj !== null && Object.prototype.toString.call(obj) === "[object Object]";
+}
+
+function anyToCrdt(obj) {
+  if (obj == null) {
+    return obj;
+  }
+
+  if (Array.isArray(obj)) {
+    return new LiveObject.LiveList(obj.map(anyToCrdt));
+  }
+
+  if (isPlainObject(obj)) {
+    var init = {};
+
+    for (var _key3 in obj) {
+      init[_key3] = anyToCrdt(obj[_key3]);
+    }
+
+    return new LiveObject.LiveObject(init);
+  }
+
+  return obj;
+}
+
+function patchLiveList(liveList, prev, next) {
+  var i = 0;
+  var prevEnd = prev.length - 1;
+  var nextEnd = next.length - 1;
+  var prevNode = prev[0];
+  var nextNode = next[0];
+
+  outer: {
+    while (prevNode === nextNode) {
+      ++i;
+
+      if (i > prevEnd || i > nextEnd) {
+        break outer;
+      }
+
+      prevNode = prev[i];
+      nextNode = next[i];
+    }
+
+    prevNode = prev[prevEnd];
+    nextNode = next[nextEnd];
+
+    while (prevNode === nextNode) {
+      prevEnd--;
+      nextEnd--;
+
+      if (i > prevEnd || i > nextEnd) {
+        break outer;
+      }
+
+      prevNode = prev[prevEnd];
+      nextNode = next[nextEnd];
+    }
+  }
+
+  if (i > prevEnd) {
+    if (i <= nextEnd) {
+      while (i <= nextEnd) {
+        liveList.insert(anyToCrdt(next[i]), i);
+        i++;
+      }
+    }
+  } else if (i > nextEnd) {
+    var localI = i;
+
+    while (localI <= prevEnd) {
+      liveList.delete(i);
+      localI++;
+    }
+  } else {
+    while (i <= prevEnd && i <= nextEnd) {
+      prevNode = prev[i];
+      nextNode = next[i];
+      var liveListNode = liveList.get(i);
+
+      if (liveListNode instanceof LiveObject.LiveObject && isPlainObject(prevNode) && isPlainObject(nextNode)) {
+        patchLiveObject(liveListNode, prevNode, nextNode);
+      } else {
+        liveList.set(i, anyToCrdt(nextNode));
+      }
+
+      i++;
+    }
+
+    while (i <= nextEnd) {
+      liveList.insert(anyToCrdt(next[i]), i);
+      i++;
+    }
+
+    var _localI = i;
+
+    while (_localI <= prevEnd) {
+      liveList.delete(i);
+      _localI++;
+    }
+  }
+}
+function patchLiveObjectKey(liveObject, key, prev, next) {
+  if (process.env.NODE_ENV !== "production") {
+    var nonSerializableValue = LiveObject.findNonSerializableValue(next);
+
+    if (nonSerializableValue) {
+      console.error("New state path: '" + nonSerializableValue.path + "' value: '" + nonSerializableValue.value + "' is not serializable.\nOnly serializable value can be synced with Liveblocks.");
+      return;
+    }
+  }
+
+  var value = liveObject.get(key);
+
+  if (next === undefined) {
+    liveObject.delete(key);
+  } else if (value === undefined) {
+    liveObject.set(key, anyToCrdt(next));
+  } else if (prev === next) {
+    return;
+  } else if (value instanceof LiveObject.LiveList && Array.isArray(prev) && Array.isArray(next)) {
+    patchLiveList(value, prev, next);
+  } else if (value instanceof LiveObject.LiveObject && isPlainObject(prev) && isPlainObject(next)) {
+    patchLiveObject(value, prev, next);
+  } else {
+    liveObject.set(key, anyToCrdt(next));
+  }
+}
+function patchLiveObject(root, prev, next) {
+  var updates = {};
+
+  for (var _key4 in next) {
+    patchLiveObjectKey(root, _key4, prev[_key4], next[_key4]);
+  }
+
+  for (var _key5 in prev) {
+    if (next[_key5] === undefined) {
+      root.delete(_key5);
+    }
+  }
+
+  if (Object.keys(updates).length > 0) {
+    root.update(updates);
+  }
+}
+
+function getParentsPath(node) {
+  var path = [];
+
+  while (node._parentKey != null && node._parent != null) {
+    if (node._parent instanceof LiveObject.LiveList) {
+      path.push(node._parent._indexOfPosition(node._parentKey));
+    } else {
+      path.push(node._parentKey);
+    }
+
+    node = node._parent;
+  }
+
+  return path;
+}
+
+function patchImmutableObject(state, updates) {
+  return updates.reduce(function (state, update) {
+    return patchImmutableObjectWithUpdate(state, update);
+  }, state);
+}
+
+function patchImmutableObjectWithUpdate(state, update) {
+  var path = getParentsPath(update.node);
+  return patchImmutableNode(state, path, update);
+}
+
+function patchImmutableNode(state, path, update) {
+  var pathItem = path.pop();
+
+  if (pathItem === undefined) {
+    switch (update.type) {
+      case "LiveObject":
+        {
+          if (typeof state !== "object") {
+            throw new Error("Internal: received update on LiveObject but state was not an object");
+          }
+
+          var newState = Object.assign({}, state);
+
+          for (var _key6 in update.updates) {
+            var _update$updates$_key, _update$updates$_key2;
+
+            if (((_update$updates$_key = update.updates[_key6]) == null ? void 0 : _update$updates$_key.type) === "update") {
+              var val = update.node.get(_key6);
+
+              if (val !== undefined) {
+                newState[_key6] = lsonToJson(val);
+              }
+            } else if (((_update$updates$_key2 = update.updates[_key6]) == null ? void 0 : _update$updates$_key2.type) === "delete") {
+              delete newState[_key6];
+            }
+          }
+
+          return newState;
+        }
+
+      case "LiveList":
+        {
+          if (Array.isArray(state) === false) {
+            throw new Error("Internal: received update on LiveList but state was not an array");
+          }
+
+          var _newState = state.map(function (x) {
+            return x;
+          });
+
+          var _loop = function _loop() {
+            var listUpdate = _step2.value;
+
+            if (listUpdate.type === "set") {
+              _newState = _newState.map(function (item, index) {
+                return index === listUpdate.index ? listUpdate.item : item;
+              });
+            } else if (listUpdate.type === "insert") {
+              if (listUpdate.index === _newState.length) {
+                _newState.push(lsonToJson(listUpdate.item));
+              } else {
+                _newState = [].concat(_newState.slice(0, listUpdate.index), [lsonToJson(listUpdate.item)], _newState.slice(listUpdate.index));
+              }
+            } else if (listUpdate.type === "delete") {
+              _newState.splice(listUpdate.index, 1);
+            } else if (listUpdate.type === "move") {
+              if (listUpdate.previousIndex > listUpdate.index) {
+                _newState = [].concat(_newState.slice(0, listUpdate.index), [lsonToJson(listUpdate.item)], _newState.slice(listUpdate.index, listUpdate.previousIndex), _newState.slice(listUpdate.previousIndex + 1));
+              } else {
+                _newState = [].concat(_newState.slice(0, listUpdate.previousIndex), _newState.slice(listUpdate.previousIndex + 1, listUpdate.index + 1), [lsonToJson(listUpdate.item)], _newState.slice(listUpdate.index + 1));
+              }
+            }
+          };
+
+          for (var _iterator2 = LiveObject._createForOfIteratorHelperLoose(update.updates), _step2; !(_step2 = _iterator2()).done;) {
+            _loop();
+          }
+
+          return _newState;
+        }
+
+      case "LiveMap":
+        {
+          if (typeof state !== "object") {
+            throw new Error("Internal: received update on LiveMap but state was not an object");
+          }
+
+          var _newState2 = Object.assign({}, state);
+
+          for (var _key7 in update.updates) {
+            var _update$updates$_key3, _update$updates$_key4;
+
+            if (((_update$updates$_key3 = update.updates[_key7]) == null ? void 0 : _update$updates$_key3.type) === "update") {
+              _newState2[_key7] = lsonToJson(update.node.get(_key7));
+            } else if (((_update$updates$_key4 = update.updates[_key7]) == null ? void 0 : _update$updates$_key4.type) === "delete") {
+              delete _newState2[_key7];
+            }
+          }
+
+          return _newState2;
+        }
+    }
+  }
+
+  if (Array.isArray(state)) {
+    var newArray = [].concat(state);
+    newArray[pathItem] = patchImmutableNode(state[pathItem], path, update);
+    return newArray;
+  } else {
+    var _extends2;
+
+    return LiveObject._extends({}, state, (_extends2 = {}, _extends2[pathItem] = patchImmutableNode(state[pathItem], path, update), _extends2));
+  }
+}
 
 Object.defineProperty(exports, 'ClientMessageType', {
-	enumerable: true,
-	get: function () { return LiveObject.ClientMessageType; }
+  enumerable: true,
+  get: function () { return LiveObject.ClientMessageType; }
 });
 Object.defineProperty(exports, 'CrdtType', {
-	enumerable: true,
-	get: function () { return LiveObject.CrdtType; }
+  enumerable: true,
+  get: function () { return LiveObject.CrdtType; }
 });
 Object.defineProperty(exports, 'OpType', {
-	enumerable: true,
-	get: function () { return LiveObject.OpType; }
+  enumerable: true,
+  get: function () { return LiveObject.OpType; }
 });
 Object.defineProperty(exports, 'ServerMessageType', {
-	enumerable: true,
-	get: function () { return LiveObject.ServerMessageType; }
-});
-Object.defineProperty(exports, 'WebsocketCloseCodes', {
-	enumerable: true,
-	get: function () { return LiveObject.WebsocketCloseCodes; }
+  enumerable: true,
+  get: function () { return LiveObject.ServerMessageType; }
 });
-exports.compare = LiveObject.compare;
 exports.deprecate = LiveObject.deprecate;
 exports.deprecateIf = LiveObject.deprecateIf;
-exports.makePosition = LiveObject.makePosition;
-exports.max = LiveObject.max;
-exports.min = LiveObject.min;
-exports.pos = LiveObject.pos;
-exports.posCodes = LiveObject.posCodes;
+exports.lsonToJson = lsonToJson;
+exports.patchImmutableObject = patchImmutableObject;
+exports.patchLiveObjectKey = patchLiveObjectKey;

package/internal.mjs

@@ -1 +1,320 @@
-export { C as ClientMessageType, n as CrdtType, O as OpType, S as ServerMessageType, W as WebsocketCloseCodes, v as compare, k as deprecate, l as deprecateIf, s as makePosition, q as max, o as min, u as pos, t as posCodes } from './shared.mjs';
+import { L as LiveObject, b as LiveList, h as LiveMap, j as LiveRegister, A as AbstractCrdt, k as findNonSerializableValue } from './shared.mjs';
+export { C as ClientMessageType, l as CrdtType, O as OpType, S as ServerMessageType, n as deprecate, f as deprecateIf } from './shared.mjs';
+
+function lsonObjectToJson(obj) {
+    const result = {};
+    for (const key in obj) {
+        const val = obj[key];
+        if (val !== undefined) {
+            result[key] = lsonToJson(val);
+        }
+    }
+    return result;
+}
+function liveObjectToJson(liveObject) {
+    return lsonObjectToJson(liveObject.toObject());
+}
+function liveMapToJson(map) {
+    const result = {};
+    for (const [key, value] of map.entries()) {
+        result[key] = lsonToJson(value);
+    }
+    return result;
+}
+function lsonListToJson(value) {
+    return value.map(lsonToJson);
+}
+function liveListToJson(value) {
+    return lsonListToJson(value.toArray());
+}
+function lsonToJson(value) {
+    //                                     ^^^^^^^^^^^^
+    //                                     FIXME: Remove me later. This requires the
+    //                                     addition of a concrete LiveStructure type first.
+    // Check for LiveStructure datastructures first
+    if (value instanceof LiveObject) {
+        return liveObjectToJson(value);
+    }
+    else if (value instanceof LiveList) {
+        return liveListToJson(value);
+    }
+    else if (value instanceof LiveMap) {
+        return liveMapToJson(value);
+    }
+    else if (value instanceof LiveRegister) {
+        return value.data;
+    }
+    else if (value instanceof AbstractCrdt) {
+        // This code path should never be taken
+        throw new Error("Unhandled subclass of AbstractCrdt encountered");
+    }
+    // Then for composite Lson values
+    if (Array.isArray(value)) {
+        return lsonListToJson(value);
+    }
+    else if (isPlainObject(value)) {
+        return lsonObjectToJson(value);
+    }
+    // Finally, if value is an LsonScalar, then it's also a valid JsonScalar
+    return value;
+}
+function isPlainObject(obj) {
+    return (obj !== null && Object.prototype.toString.call(obj) === "[object Object]");
+}
+function anyToCrdt(obj) {
+    //                              ^^^ AbstractCrdt?
+    if (obj == null) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return new LiveList(obj.map(anyToCrdt));
+    }
+    if (isPlainObject(obj)) {
+        const init = {};
+        for (const key in obj) {
+            init[key] = anyToCrdt(obj[key]);
+        }
+        return new LiveObject(init);
+    }
+    return obj;
+}
+function patchLiveList(liveList, prev, next) {
+    let i = 0;
+    let prevEnd = prev.length - 1;
+    let nextEnd = next.length - 1;
+    let prevNode = prev[0];
+    let nextNode = next[0];
+    /**
+     * For A,B,C => A,B,C,D
+     * i = 3, prevEnd = 2, nextEnd = 3
+     *
+     * For A,B,C => B,C
+     * i = 2, prevEnd = 2, nextEnd = 1
+     *
+     * For B,C => A,B,C
+     * i = 0, pre
+     */
+    outer: {
+        while (prevNode === nextNode) {
+            ++i;
+            if (i > prevEnd || i > nextEnd) {
+                break outer;
+            }
+            prevNode = prev[i];
+            nextNode = next[i];
+        }
+        prevNode = prev[prevEnd];
+        nextNode = next[nextEnd];
+        while (prevNode === nextNode) {
+            prevEnd--;
+            nextEnd--;
+            if (i > prevEnd || i > nextEnd) {
+                break outer;
+            }
+            prevNode = prev[prevEnd];
+            nextNode = next[nextEnd];
+        }
+    }
+    if (i > prevEnd) {
+        if (i <= nextEnd) {
+            while (i <= nextEnd) {
+                liveList.insert(anyToCrdt(next[i]), i);
+                i++;
+            }
+        }
+    }
+    else if (i > nextEnd) {
+        let localI = i;
+        while (localI <= prevEnd) {
+            liveList.delete(i);
+            localI++;
+        }
+    }
+    else {
+        while (i <= prevEnd && i <= nextEnd) {
+            prevNode = prev[i];
+            nextNode = next[i];
+            const liveListNode = liveList.get(i);
+            if (liveListNode instanceof LiveObject &&
+                isPlainObject(prevNode) &&
+                isPlainObject(nextNode)) {
+                patchLiveObject(liveListNode, prevNode, nextNode);
+            }
+            else {
+                liveList.set(i, anyToCrdt(nextNode));
+            }
+            i++;
+        }
+        while (i <= nextEnd) {
+            liveList.insert(anyToCrdt(next[i]), i);
+            i++;
+        }
+        let localI = i;
+        while (localI <= prevEnd) {
+            liveList.delete(i);
+            localI++;
+        }
+    }
+}
+function patchLiveObjectKey(liveObject, key, prev, next) {
+    if (process.env.NODE_ENV !== "production") {
+        const nonSerializableValue = findNonSerializableValue(next);
+        if (nonSerializableValue) {
+            console.error(`New state path: '${nonSerializableValue.path}' value: '${nonSerializableValue.value}' is not serializable.\nOnly serializable value can be synced with Liveblocks.`);
+            return;
+        }
+    }
+    const value = liveObject.get(key);
+    if (next === undefined) {
+        liveObject.delete(key);
+    }
+    else if (value === undefined) {
+        liveObject.set(key, anyToCrdt(next));
+    }
+    else if (prev === next) {
+        return;
+    }
+    else if (value instanceof LiveList &&
+        Array.isArray(prev) &&
+        Array.isArray(next)) {
+        patchLiveList(value, prev, next);
+    }
+    else if (value instanceof LiveObject &&
+        isPlainObject(prev) &&
+        isPlainObject(next)) {
+        patchLiveObject(value, prev, next);
+    }
+    else {
+        liveObject.set(key, anyToCrdt(next));
+    }
+}
+function patchLiveObject(root, prev, next) {
+    const updates = {};
+    for (const key in next) {
+        patchLiveObjectKey(root, key, prev[key], next[key]);
+    }
+    for (const key in prev) {
+        if (next[key] === undefined) {
+            root.delete(key);
+        }
+    }
+    if (Object.keys(updates).length > 0) {
+        root.update(updates);
+    }
+}
+function getParentsPath(node) {
+    const path = [];
+    while (node._parentKey != null && node._parent != null) {
+        if (node._parent instanceof LiveList) {
+            path.push(node._parent._indexOfPosition(node._parentKey));
+        }
+        else {
+            path.push(node._parentKey);
+        }
+        node = node._parent;
+    }
+    return path;
+}
+function patchImmutableObject(state, updates) {
+    return updates.reduce((state, update) => patchImmutableObjectWithUpdate(state, update), state);
+}
+function patchImmutableObjectWithUpdate(state, update) {
+    const path = getParentsPath(update.node);
+    return patchImmutableNode(state, path, update);
+}
+function patchImmutableNode(state, path, update) {
+    var _a, _b, _c, _d;
+    const pathItem = path.pop();
+    if (pathItem === undefined) {
+        switch (update.type) {
+            case "LiveObject": {
+                if (typeof state !== "object") {
+                    throw new Error("Internal: received update on LiveObject but state was not an object");
+                }
+                const newState = Object.assign({}, state);
+                for (const key in update.updates) {
+                    if (((_a = update.updates[key]) === null || _a === void 0 ? void 0 : _a.type) === "update") {
+                        const val = update.node.get(key);
+                        if (val !== undefined) {
+                            newState[key] = lsonToJson(val);
+                        }
+                    }
+                    else if (((_b = update.updates[key]) === null || _b === void 0 ? void 0 : _b.type) === "delete") {
+                        delete newState[key];
+                    }
+                }
+                return newState;
+            }
+            case "LiveList": {
+                if (Array.isArray(state) === false) {
+                    throw new Error("Internal: received update on LiveList but state was not an array");
+                }
+                let newState = state.map((x) => x);
+                for (const listUpdate of update.updates) {
+                    if (listUpdate.type === "set") {
+                        newState = newState.map((item, index) => index === listUpdate.index ? listUpdate.item : item);
+                    }
+                    else if (listUpdate.type === "insert") {
+                        if (listUpdate.index === newState.length) {
+                            newState.push(lsonToJson(listUpdate.item));
+                        }
+                        else {
+                            newState = [
+                                ...newState.slice(0, listUpdate.index),
+                                lsonToJson(listUpdate.item),
+                                ...newState.slice(listUpdate.index),
+                            ];
+                        }
+                    }
+                    else if (listUpdate.type === "delete") {
+                        newState.splice(listUpdate.index, 1);
+                    }
+                    else if (listUpdate.type === "move") {
+                        if (listUpdate.previousIndex > listUpdate.index) {
+                            newState = [
+                                ...newState.slice(0, listUpdate.index),
+                                lsonToJson(listUpdate.item),
+                                ...newState.slice(listUpdate.index, listUpdate.previousIndex),
+                                ...newState.slice(listUpdate.previousIndex + 1),
+                            ];
+                        }
+                        else {
+                            newState = [
+                                ...newState.slice(0, listUpdate.previousIndex),
+                                ...newState.slice(listUpdate.previousIndex + 1, listUpdate.index + 1),
+                                lsonToJson(listUpdate.item),
+                                ...newState.slice(listUpdate.index + 1),
+                            ];
+                        }
+                    }
+                }
+                return newState;
+            }
+            case "LiveMap": {
+                if (typeof state !== "object") {
+                    throw new Error("Internal: received update on LiveMap but state was not an object");
+                }
+                const newState = Object.assign({}, state);
+                for (const key in update.updates) {
+                    if (((_c = update.updates[key]) === null || _c === void 0 ? void 0 : _c.type) === "update") {
+                        newState[key] = lsonToJson(update.node.get(key));
+                    }
+                    else if (((_d = update.updates[key]) === null || _d === void 0 ? void 0 : _d.type) === "delete") {
+                        delete newState[key];
+                    }
+                }
+                return newState;
+            }
+        }
+    }
+    if (Array.isArray(state)) {
+        const newArray = [...state];
+        newArray[pathItem] = patchImmutableNode(state[pathItem], path, update);
+        return newArray;
+    }
+    else {
+        return Object.assign(Object.assign({}, state), { [pathItem]: patchImmutableNode(state[pathItem], path, update) });
+    }
+}
+
+export { lsonToJson, patchImmutableObject, patchLiveObjectKey };