@liveblocks/client 0.16.3 → 0.16.4

package/internal.d.ts

@@ -1,21 +1,5 @@
-/**
- * Represents an indefinitely deep arbitrary JSON data structure. There are
- * four types that make up the Json family:
- *
- * - Json         any legal JSON value
- * - JsonScalar   any legal JSON leaf value (no lists or objects)
- * - JsonArray    a JSON value whose outer type is an array
- * - JsonObject   a JSON value whose outer type is an object
- *
- */
-declare type Json = JsonScalar | JsonArray | JsonObject;
-declare type JsonScalar = string | number | boolean | null;
-declare type JsonArray = Json[];
-declare type JsonObject = {
-    [key: string]: Json | undefined;
-};
-
-declare type Presence = Record<string, unknown>;
+import { J as Json, P as Presence, d as JsonObject, e as Lson, A as AbstractCrdt, f as LsonObject, L as LiveObject, S as StorageUpdate } from './shared';
+export { g as Resolve, h as RoomInitializers } from './shared';
 
 /**
  * Messages that can be sent from the server to the client.
@@ -137,32 +121,12 @@ declare type UpdateStorageMessage = {
     type: ServerMessageType.UpdateStorage;
     ops: Op[];
 };
-/**
- * Messages that can be sent from the client to the server.
- */
-declare type ClientMessage = ClientEventMessage | UpdatePresenceClientMessage | UpdateStorageClientMessage | FetchStorageClientMessage;
 declare enum ClientMessageType {
     UpdatePresence = 100,
     ClientEvent = 103,
     FetchStorage = 200,
     UpdateStorage = 201
 }
-declare type ClientEventMessage = {
-    type: ClientMessageType.ClientEvent;
-    event: Json;
-};
-declare type UpdatePresenceClientMessage = {
-    type: ClientMessageType.UpdatePresence;
-    data: Presence;
-    targetActor?: number;
-};
-declare type UpdateStorageClientMessage = {
-    type: ClientMessageType.UpdateStorage;
-    ops: Op[];
-};
-declare type FetchStorageClientMessage = {
-    type: ClientMessageType.FetchStorage;
-};
 declare enum CrdtType {
     Object = 0,
     List = 1,
@@ -208,7 +172,6 @@ declare enum OpType {
  * only.
  */
 declare type Op = CreateObjectOp | UpdateObjectOp | DeleteCrdtOp | CreateListOp | SetParentKeyOp | DeleteObjectKeyOp | CreateMapOp | CreateRegisterOp;
-declare type CreateOp = CreateObjectOp | CreateRegisterOp | CreateMapOp | CreateListOp;
 declare type UpdateObjectOp = {
     opId?: string;
     id: string;
@@ -266,22 +229,21 @@ declare type DeleteObjectKeyOp = {
     type: OpType.DeleteObjectKey;
     key: string;
 };
-declare enum WebsocketCloseCodes {
-    CLOSE_ABNORMAL = 1006,
-    INVALID_MESSAGE_FORMAT = 4000,
-    NOT_ALLOWED = 4001,
-    MAX_NUMBER_OF_MESSAGES_PER_SECONDS = 4002,
-    MAX_NUMBER_OF_CONCURRENT_CONNECTIONS = 4003,
-    MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP = 4004,
-    MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM = 4005,
-    CLOSE_WITHOUT_RETRY = 4999
-}
 
-declare const min = 32;
-declare const max = 126;
-declare function makePosition(before?: string, after?: string): string;
-declare function posCodes(str: string): number[];
-declare function pos(codes: number[]): string;
-declare function compare(posA: string, posB: string): number;
+/**
+ * Displays a deprecation warning in the dev console. Only in dev mode, and
+ * only once per message/key. In production, this is a no-op.
+ */
+declare function deprecate(message: string, key?: string): void;
+/**
+ * Conditionally displays a deprecation warning in the dev
+ * console if the first argument is truthy. Only in dev mode, and
+ * only once per message/key. In production, this is a no-op.
+ */
+declare function deprecateIf(condition: unknown, message: string, key?: string): void;
+
+declare function lsonToJson(value: Lson | AbstractCrdt): Json;
+declare function patchLiveObjectKey<O extends LsonObject>(liveObject: LiveObject<O>, key: keyof O, prev: unknown, next: unknown): void;
+declare function patchImmutableObject<T>(state: T, updates: StorageUpdate[]): T;
 
-export { ClientEventMessage, ClientMessage, ClientMessageType, CrdtType, CreateListOp, CreateMapOp, CreateObjectOp, CreateOp, CreateRegisterOp, DeleteCrdtOp, DeleteObjectKeyOp, EventMessage, FetchStorageClientMessage, InitialDocumentStateMessage, Op, OpType, RoomStateMessage, SerializedCrdt, SerializedCrdtWithId, SerializedList, SerializedMap, SerializedObject, SerializedRegister, ServerMessage, ServerMessageType, SetParentKeyOp, UpdateObjectOp, UpdatePresenceClientMessage, UpdatePresenceMessage, UpdateStorageClientMessage, UpdateStorageMessage, UserJoinMessage, UserLeftMessage, WebsocketCloseCodes, compare, makePosition, max, min, pos, posCodes };
+export { ClientMessageType, CrdtType, OpType, SerializedCrdtWithId, ServerMessage, ServerMessageType, deprecate, deprecateIf, lsonToJson, patchImmutableObject, patchLiveObjectKey };

package/internal.js

@@ -2,193 +2,366 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-exports.ServerMessageType = void 0;
-
-(function (ServerMessageType) {
-  ServerMessageType[ServerMessageType["UpdatePresence"] = 100] = "UpdatePresence";
-  ServerMessageType[ServerMessageType["UserJoined"] = 101] = "UserJoined";
-  ServerMessageType[ServerMessageType["UserLeft"] = 102] = "UserLeft";
-  ServerMessageType[ServerMessageType["Event"] = 103] = "Event";
-  ServerMessageType[ServerMessageType["RoomState"] = 104] = "RoomState";
-  ServerMessageType[ServerMessageType["InitialStorageState"] = 200] = "InitialStorageState";
-  ServerMessageType[ServerMessageType["UpdateStorage"] = 201] = "UpdateStorage";
-})(exports.ServerMessageType || (exports.ServerMessageType = {}));
-
-exports.ClientMessageType = void 0;
-
-(function (ClientMessageType) {
-  ClientMessageType[ClientMessageType["UpdatePresence"] = 100] = "UpdatePresence";
-  ClientMessageType[ClientMessageType["ClientEvent"] = 103] = "ClientEvent";
-  ClientMessageType[ClientMessageType["FetchStorage"] = 200] = "FetchStorage";
-  ClientMessageType[ClientMessageType["UpdateStorage"] = 201] = "UpdateStorage";
-})(exports.ClientMessageType || (exports.ClientMessageType = {}));
-
-exports.CrdtType = void 0;
-
-(function (CrdtType) {
-  CrdtType[CrdtType["Object"] = 0] = "Object";
-  CrdtType[CrdtType["List"] = 1] = "List";
-  CrdtType[CrdtType["Map"] = 2] = "Map";
-  CrdtType[CrdtType["Register"] = 3] = "Register";
-})(exports.CrdtType || (exports.CrdtType = {}));
-
-exports.OpType = void 0;
-
-(function (OpType) {
-  OpType[OpType["Init"] = 0] = "Init";
-  OpType[OpType["SetParentKey"] = 1] = "SetParentKey";
-  OpType[OpType["CreateList"] = 2] = "CreateList";
-  OpType[OpType["UpdateObject"] = 3] = "UpdateObject";
-  OpType[OpType["CreateObject"] = 4] = "CreateObject";
-  OpType[OpType["DeleteCrdt"] = 5] = "DeleteCrdt";
-  OpType[OpType["DeleteObjectKey"] = 6] = "DeleteObjectKey";
-  OpType[OpType["CreateMap"] = 7] = "CreateMap";
-  OpType[OpType["CreateRegister"] = 8] = "CreateRegister";
-})(exports.OpType || (exports.OpType = {}));
-
-exports.WebsocketCloseCodes = void 0;
-
-(function (WebsocketCloseCodes) {
-  WebsocketCloseCodes[WebsocketCloseCodes["CLOSE_ABNORMAL"] = 1006] = "CLOSE_ABNORMAL";
-  WebsocketCloseCodes[WebsocketCloseCodes["INVALID_MESSAGE_FORMAT"] = 4000] = "INVALID_MESSAGE_FORMAT";
-  WebsocketCloseCodes[WebsocketCloseCodes["NOT_ALLOWED"] = 4001] = "NOT_ALLOWED";
-  WebsocketCloseCodes[WebsocketCloseCodes["MAX_NUMBER_OF_MESSAGES_PER_SECONDS"] = 4002] = "MAX_NUMBER_OF_MESSAGES_PER_SECONDS";
-  WebsocketCloseCodes[WebsocketCloseCodes["MAX_NUMBER_OF_CONCURRENT_CONNECTIONS"] = 4003] = "MAX_NUMBER_OF_CONCURRENT_CONNECTIONS";
-  WebsocketCloseCodes[WebsocketCloseCodes["MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP"] = 4004] = "MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP";
-  WebsocketCloseCodes[WebsocketCloseCodes["MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM"] = 4005] = "MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM";
-  WebsocketCloseCodes[WebsocketCloseCodes["CLOSE_WITHOUT_RETRY"] = 4999] = "CLOSE_WITHOUT_RETRY";
-})(exports.WebsocketCloseCodes || (exports.WebsocketCloseCodes = {}));
-
-var min = 32;
-var max = 126;
-function makePosition(before, after) {
-  if (before == null && after == null) {
-    return pos([min + 1]);
-  }
-
-  if (before != null && after == null) {
-    return getNextPosition(before);
-  }
-
-  if (before == null && after != null) {
-    return getPreviousPosition(after);
-  }
-
-  return pos(makePositionFromCodes(posCodes(before), posCodes(after)));
+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 getPreviousPosition(after) {
-  var result = [];
-  var afterCodes = posCodes(after);
+function liveObjectToJson(liveObject) {
+  return lsonObjectToJson(liveObject.toObject());
+}
 
-  for (var i = 0; i < afterCodes.length; i++) {
-    var code = afterCodes[i];
+function liveMapToJson(map) {
+  var result = {};
 
-    if (code <= min + 1) {
-      result.push(min);
+  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);
+  }
 
-      if (afterCodes.length - 1 === i) {
-        result.push(max);
-        break;
-      }
-    } else {
-      result.push(code - 1);
-      break;
+  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 pos(result);
+  return obj;
 }
 
-function getNextPosition(before) {
-  var result = [];
-  var beforeCodes = posCodes(before);
+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];
 
-  for (var i = 0; i < beforeCodes.length; i++) {
-    var code = beforeCodes[i];
+  outer: {
+    while (prevNode === nextNode) {
+      ++i;
 
-    if (code === max) {
-      result.push(code);
+      if (i > prevEnd || i > nextEnd) {
+        break outer;
+      }
 
-      if (beforeCodes.length - 1 === i) {
-        result.push(min + 1);
-        break;
+      prevNode = prev[i];
+      nextNode = next[i];
+    }
+
+    prevNode = prev[prevEnd];
+    nextNode = next[nextEnd];
+
+    while (prevNode === nextNode) {
+      prevEnd--;
+      nextEnd--;
+
+      if (i > prevEnd || i > nextEnd) {
+        break outer;
       }
-    } else {
-      result.push(code + 1);
-      break;
+
+      prevNode = prev[prevEnd];
+      nextNode = next[nextEnd];
     }
   }
 
-  return pos(result);
-}
+  if (i > prevEnd) {
+    if (i <= nextEnd) {
+      while (i <= nextEnd) {
+        liveList.insert(anyToCrdt(next[i]), i);
+        i++;
+      }
+    }
+  } else if (i > nextEnd) {
+    var localI = i;
 
-function makePositionFromCodes(before, after) {
-  var index = 0;
-  var result = [];
+    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));
+      }
 
-  while (true) {
-    var beforeDigit = before[index] || min;
-    var afterDigit = after[index] || max;
+      i++;
+    }
 
-    if (beforeDigit > afterDigit) {
-      throw new Error("Impossible to generate position between " + before + " and " + after);
+    while (i <= nextEnd) {
+      liveList.insert(anyToCrdt(next[i]), i);
+      i++;
     }
 
-    if (beforeDigit === afterDigit) {
-      result.push(beforeDigit);
-      index++;
-      continue;
+    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 (afterDigit - beforeDigit === 1) {
-      result.push(beforeDigit);
-      result.push.apply(result, makePositionFromCodes(before.slice(index + 1), []));
-      break;
+    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 mid = afterDigit + beforeDigit >> 1;
-    result.push(mid);
-    break;
+  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 = {};
 
-  return result;
+  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 posCodes(str) {
-  var codes = [];
+function getParentsPath(node) {
+  var path = [];
 
-  for (var i = 0; i < str.length; i++) {
-    codes.push(str.charCodeAt(i));
+  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 codes;
+  return path;
 }
-function pos(codes) {
-  return String.fromCharCode.apply(String, codes);
+
+function patchImmutableObject(state, updates) {
+  return updates.reduce(function (state, update) {
+    return patchImmutableObjectWithUpdate(state, update);
+  }, state);
 }
-function compare(posA, posB) {
-  var aCodes = posCodes(posA);
-  var bCodes = posCodes(posB);
-  var maxLength = Math.max(aCodes.length, bCodes.length);
 
-  for (var i = 0; i < maxLength; i++) {
-    var a = aCodes[i] == null ? min : aCodes[i];
-    var b = bCodes[i] == null ? min : bCodes[i];
+function patchImmutableObjectWithUpdate(state, update) {
+  var path = getParentsPath(update.node);
+  return patchImmutableNode(state, path, update);
+}
 
-    if (a === b) {
-      continue;
-    } else {
-      return a - b;
+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;
+        }
     }
   }
 
-  throw new Error("Impossible to compare similar position \"" + posA + "\" and \"" + posB + "\"");
+  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));
+  }
 }
 
-exports.compare = compare;
-exports.makePosition = makePosition;
-exports.max = max;
-exports.min = min;
-exports.pos = pos;
-exports.posCodes = posCodes;
+Object.defineProperty(exports, 'ClientMessageType', {
+  enumerable: true,
+  get: function () { return LiveObject.ClientMessageType; }
+});
+Object.defineProperty(exports, 'CrdtType', {
+  enumerable: true,
+  get: function () { return LiveObject.CrdtType; }
+});
+Object.defineProperty(exports, 'OpType', {
+  enumerable: true,
+  get: function () { return LiveObject.OpType; }
+});
+Object.defineProperty(exports, 'ServerMessageType', {
+  enumerable: true,
+  get: function () { return LiveObject.ServerMessageType; }
+});
+exports.deprecate = LiveObject.deprecate;
+exports.deprecateIf = LiveObject.deprecateIf;
+exports.lsonToJson = lsonToJson;
+exports.patchImmutableObject = patchImmutableObject;
+exports.patchLiveObjectKey = patchLiveObjectKey;