@liveblocks/client 0.16.4-beta1 → 0.16.5

package/internal.d.ts

@@ -1,10 +1,10 @@
-import { J as Json, P as Presence, d as JsonObject } from './shared';
-export { g as Resolve } from './shared';
+import { d as JsonObject, J as Json, 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.
  */
-declare type ServerMessage = UpdatePresenceMessage | UserJoinMessage | UserLeftMessage | EventMessage | RoomStateMessage | InitialDocumentStateMessage | UpdateStorageMessage;
+declare type ServerMessage<TPresence extends JsonObject> = UpdatePresenceMessage<TPresence> | UserJoinMessage | UserLeftMessage | EventMessage | RoomStateMessage | InitialDocumentStateMessage | UpdateStorageMessage;
 declare enum ServerMessageType {
     UpdatePresence = 100,
     UserJoined = 101,
@@ -39,7 +39,7 @@ declare type RoomStateMessage = {
  * those cases, the `targetActor` field indicates the newly connected client,
  * so all other existing clients can ignore this broadcasted message.
  */
-declare type UpdatePresenceMessage = {
+declare type UpdatePresenceMessage<TPresence extends JsonObject> = {
     type: ServerMessageType.UpdatePresence;
     /**
      * The User whose Presence has changed.
@@ -50,7 +50,7 @@ declare type UpdatePresenceMessage = {
      * this will be the full Presence, otherwise it only contain the fields that
      * have changed since the last broadcast.
      */
-    data: Presence;
+    data: TPresence;
     /**
      * If this message was sent in response to a newly joined user, this field
      * indicates which client this message is for. Other existing clients may
@@ -121,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,
@@ -192,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;
@@ -250,24 +229,12 @@ 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;
 
+/**
+ * Tools to help with the controlled deprecation of public APIs.
+ *
+ * First warn, then error, then remove eventually.
+ */
 /**
  * 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.
@@ -279,5 +246,23 @@ declare function deprecate(message: string, key?: string): void;
  * only once per message/key. In production, this is a no-op.
  */
 declare function deprecateIf(condition: unknown, message: string, key?: string): void;
+/**
+ * Throws a deprecation error in the dev console.
+ *
+ * Only triggers in dev mode. In production, this is a no-op.
+ */
+declare function throwUsageError(message: string): void;
+/**
+ * Conditionally throws a usage error in the dev console if the first argument
+ * is truthy. Use this to "escalate" usage patterns that in previous versions
+ * we already warned about with deprecation warnings.
+ *
+ * Only has effect in dev mode. In production, this is a no-op.
+ */
+declare function errorIf(condition: unknown, message: 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, deprecate, deprecateIf, makePosition, max, min, pos, posCodes };
+export { ClientMessageType, CrdtType, OpType, RoomStateMessage, SerializedCrdtWithId, ServerMessage, ServerMessageType, deprecate, deprecateIf, errorIf, lsonToJson, patchImmutableObject, patchLiveObjectKey, throwUsageError };

package/internal.js

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

package/internal.mjs

@@ -1 +1,148 @@
-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, o as errorIf, t as throwUsageError } from "./shared.mjs";
+
+function lsonObjectToJson(obj) {
+ const result = {};
+ for (const key in obj) {
+  const val = obj[key];
+  void 0 !== val && (result[key] = lsonToJson(val));
+ }
+ return result;
+}
+
+function lsonListToJson(value) {
+ return value.map(lsonToJson);
+}
+
+function lsonToJson(value) {
+ if (value instanceof LiveObject) return lsonObjectToJson(value.toObject());
+ if (value instanceof LiveList) return function(value) {
+  return lsonListToJson(value.toArray());
+ }(value);
+ if (value instanceof LiveMap) return function(map) {
+  const result = {};
+  for (const [key, value] of map.entries()) result[key] = lsonToJson(value);
+  return result;
+ }(value);
+ if (value instanceof LiveRegister) return value.data;
+ if (value instanceof AbstractCrdt) throw new Error("Unhandled subclass of AbstractCrdt encountered");
+ return Array.isArray(value) ? lsonListToJson(value) : isPlainObject(value) ? lsonObjectToJson(value) : value;
+}
+
+function isPlainObject(obj) {
+ return null !== obj && "[object Object]" === Object.prototype.toString.call(obj);
+}
+
+function anyToCrdt(obj) {
+ if (null == obj) 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 patchLiveObjectKey(liveObject, key, prev, next) {
+ if ("production" !== process.env.NODE_ENV) {
+  const nonSerializableValue = findNonSerializableValue(next);
+  if (nonSerializableValue) return void console.error(`New state path: '${nonSerializableValue.path}' value: '${nonSerializableValue.value}' is not serializable.\nOnly serializable value can be synced with Liveblocks.`);
+ }
+ const value = liveObject.get(key);
+ if (void 0 === next) liveObject.delete(key); else if (void 0 === value) liveObject.set(key, anyToCrdt(next)); else {
+  if (prev === next) return;
+  value instanceof LiveList && Array.isArray(prev) && Array.isArray(next) ? function(liveList, prev, next) {
+   let i = 0, prevEnd = prev.length - 1, nextEnd = next.length - 1, prevNode = prev[0], nextNode = next[0];
+   outer: {
+    for (;prevNode === nextNode; ) {
+     if (++i, i > prevEnd || i > nextEnd) break outer;
+     prevNode = prev[i], nextNode = next[i];
+    }
+    for (prevNode = prev[prevEnd], nextNode = next[nextEnd]; prevNode === nextNode; ) {
+     if (prevEnd--, nextEnd--, i > prevEnd || i > nextEnd) break outer;
+     prevNode = prev[prevEnd], nextNode = next[nextEnd];
+    }
+   }
+   if (i > prevEnd) {
+    if (i <= nextEnd) for (;i <= nextEnd; ) liveList.insert(anyToCrdt(next[i]), i), 
+    i++;
+   } else if (i > nextEnd) {
+    let localI = i;
+    for (;localI <= prevEnd; ) liveList.delete(i), localI++;
+   } else {
+    for (;i <= prevEnd && i <= nextEnd; ) {
+     prevNode = prev[i], nextNode = next[i];
+     const liveListNode = liveList.get(i);
+     liveListNode instanceof LiveObject && isPlainObject(prevNode) && isPlainObject(nextNode) ? patchLiveObject(liveListNode, prevNode, nextNode) : liveList.set(i, anyToCrdt(nextNode)), 
+     i++;
+    }
+    for (;i <= nextEnd; ) liveList.insert(anyToCrdt(next[i]), i), i++;
+    let localI = i;
+    for (;localI <= prevEnd; ) liveList.delete(i), localI++;
+   }
+  }(value, prev, next) : value instanceof LiveObject && isPlainObject(prev) && isPlainObject(next) ? patchLiveObject(value, prev, next) : 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) void 0 === next[key] && root.delete(key);
+ Object.keys(updates).length > 0 && root.update(updates);
+}
+
+function patchImmutableObject(state, updates) {
+ return updates.reduce(((state, update) => function(state, update) {
+  const path = function(node) {
+   const path = [];
+   for (;null != node._parentKey && null != node._parent; ) node._parent instanceof LiveList ? path.push(node._parent._indexOfPosition(node._parentKey)) : path.push(node._parentKey), 
+   node = node._parent;
+   return path;
+  }(update.node);
+  return patchImmutableNode(state, path, update);
+ }(state, update)), state);
+}
+
+function patchImmutableNode(state, path, update) {
+ var _a, _b, _c, _d;
+ const pathItem = path.pop();
+ if (void 0 === pathItem) switch (update.type) {
+ case "LiveObject":
+  {
+   if ("object" != typeof state) 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 ("update" === (null === (_a = update.updates[key]) || void 0 === _a ? void 0 : _a.type)) {
+    const val = update.node.get(key);
+    void 0 !== val && (newState[key] = lsonToJson(val));
+   } else "delete" === (null === (_b = update.updates[key]) || void 0 === _b ? void 0 : _b.type) && delete newState[key];
+   return newState;
+  }
+
+ case "LiveList":
+  {
+   if (!1 === Array.isArray(state)) 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) "set" === listUpdate.type ? newState = newState.map(((item, index) => index === listUpdate.index ? listUpdate.item : item)) : "insert" === listUpdate.type ? listUpdate.index === newState.length ? newState.push(lsonToJson(listUpdate.item)) : newState = [ ...newState.slice(0, listUpdate.index), lsonToJson(listUpdate.item), ...newState.slice(listUpdate.index) ] : "delete" === listUpdate.type ? newState.splice(listUpdate.index, 1) : "move" === listUpdate.type && (newState = listUpdate.previousIndex > listUpdate.index ? [ ...newState.slice(0, listUpdate.index), lsonToJson(listUpdate.item), ...newState.slice(listUpdate.index, listUpdate.previousIndex), ...newState.slice(listUpdate.previousIndex + 1) ] : [ ...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 ("object" != typeof state) 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) "update" === (null === (_c = update.updates[key]) || void 0 === _c ? void 0 : _c.type) ? newState[key] = lsonToJson(update.node.get(key)) : "delete" === (null === (_d = update.updates[key]) || void 0 === _d ? void 0 : _d.type) && delete newState[key];
+   return newState;
+  }
+ }
+ if (Array.isArray(state)) {
+  const newArray = [ ...state ];
+  return newArray[pathItem] = patchImmutableNode(state[pathItem], path, update), newArray;
+ }
+ return Object.assign(Object.assign({}, state), {
+  [pathItem]: patchImmutableNode(state[pathItem], path, update)
+ });
+}
+
+export { lsonToJson, patchImmutableObject, patchLiveObjectKey };

package/package.json

@@ -1,10 +1,22 @@
 {
   "name": "@liveblocks/client",
-  "version": "0.16.4-beta1",
+  "version": "0.16.5",
   "description": "A client that lets you interact with Liveblocks servers.",
   "main": "./index.js",
   "module": "./index.mjs",
   "types": "./index.d.ts",
+  "exports": {
+    "./internal": {
+      "types": "./internal.d.ts",
+      "require": "./internal.js",
+      "import": "./internal.mjs"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "require": "./index.js",
+      "import": "./index.mjs"
+    }
+  },
   "files": [
     "**"
   ],
@@ -19,17 +31,16 @@
   },
   "scripts": {
     "build": "rollup -c && cp ./package.json ./README.md ./lib",
+    "format": "eslint --fix src/ test/ && prettier --write src/ test/",
     "lint": "eslint src/ test/",
     "test": "jest --watch",
     "test-ci": "jest"
   },
   "license": "Apache-2.0",
   "devDependencies": {
-    "@babel/core": "^7.12.16",
-    "@babel/plugin-proposal-class-properties": "^7.16.7",
-    "@babel/plugin-proposal-private-methods": "^7.16.11",
-    "@babel/preset-env": "^7.12.16",
-    "@babel/preset-typescript": "^7.12.16",
+    "@babel/core": "^7.17.10",
+    "@babel/preset-env": "^7.17.10",
+    "@babel/preset-typescript": "^7.16.7",
     "@rollup/plugin-babel": "^5.3.1",
     "@rollup/plugin-node-resolve": "^13.1.3",
     "@rollup/plugin-replace": "^4.0.0",
@@ -39,8 +50,9 @@
     "@types/ws": "^8.2.2",
     "@typescript-eslint/eslint-plugin": "^5.17.0",
     "@typescript-eslint/parser": "^5.17.0",
-    "babel-jest": "^26.6.3",
     "eslint": "^8.12.0",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-simple-import-sort": "^7.0.0",
     "jest": "^26.6.3",
     "jest-each": "^27.5.1",
     "msw": "^0.39.1",
@@ -48,6 +60,7 @@
     "rollup": "^2.68.0",
     "rollup-plugin-command": "^1.1.3",
     "rollup-plugin-dts": "^4.1.0",
+    "rollup-plugin-terser": "^7.0.2",
     "typescript": "^4.4.0",
     "whatwg-fetch": "^3.6.2",
     "ws": "^8.5.0"

package/shared.d.ts

@@ -22,7 +22,11 @@ declare type JsonObject = {
  */
 declare class LiveMap<TKey extends string = string, TValue extends Lson = Lson> extends AbstractCrdt {
     private _map;
-    constructor(entries?: readonly (readonly [TKey, TValue])[] | null | undefined);
+    constructor(entries?: readonly (readonly [TKey, TValue])[] | undefined);
+    /**
+     * @deprecated Please call as `new LiveMap()` or `new LiveMap([])` instead.
+     */
+    constructor(entries: null);
     /**
      * Returns a specified element from the LiveMap.
      * @param key The key of the element to return.
@@ -291,6 +295,27 @@ declare type BroadcastOptions = {
  * in-client.
  */
 declare type StorageUpdate = LiveMapUpdates<string, Lson> | LiveObjectUpdates<LsonObject> | LiveListUpdates<Lson>;
+declare type RoomInitializers<TPresence, TStorage> = Resolve<{
+    /**
+     * The initial Presence to use and announce when you enter the Room. The
+     * Presence is available on all users in the Room (me & others).
+     */
+    initialPresence?: TPresence | ((roomId: string) => TPresence);
+    /**
+     * The initial Storage to use when entering a new Room.
+     */
+    initialStorage?: TStorage | ((roomId: string) => TStorage);
+    /**
+     * @deprecated Please use `initialPresence` instead. This property is
+     * scheduled for removal in 0.18.
+     */
+    defaultPresence?: () => TPresence;
+    /**
+     * @deprecated Please use `initialStorage` instead. This property is
+     * scheduled for removal in 0.18.
+     */
+    defaultStorageRoot?: TStorage;
+}>;
 declare type Client = {
     /**
      * Gets a room. Returns null if {@link Client.enter} has not been called previously.
@@ -301,12 +326,9 @@ declare type Client = {
     /**
      * Enters a room and returns it.
      * @param roomId The id of the room
-     * @param defaultPresence Optional. Should be serializable to JSON. If omitted, an empty object will be used.
+     * @param options Optional. You can provide initializers for the Presence or Storage when entering the Room.
      */
-    enter<TStorage extends Record<string, any> = Record<string, any>>(roomId: string, options?: {
-        defaultPresence?: Presence;
-        defaultStorageRoot?: TStorage;
-    }): Room;
+    enter<TStorage extends Record<string, any> = Record<string, any>>(roomId: string, options?: RoomInitializers<Presence, TStorage>): Room;
     /**
      * Leaves a room.
      * @param roomId The id of the room
@@ -376,7 +398,15 @@ declare type ClientOptions = {
     publicApiKey?: never;
     authEndpoint: AuthEndpoint;
 });
-declare type ConnectionState = "closed" | "authenticating" | "unavailable" | "failed" | "open" | "connecting";
+declare type Connection = {
+    state: "closed" | "authenticating" | "unavailable" | "failed";
+} | {
+    state: "open" | "connecting";
+    id: number;
+    userId?: string;
+    userInfo?: any;
+};
+declare type ConnectionState = Connection["state"];
 declare type OthersEvent<T extends Presence = Presence> = {
     type: "leave";
     user: User<T>;
@@ -720,7 +750,7 @@ declare abstract class AbstractCrdt {
 declare class LiveObject<O extends LsonObject = LsonObject> extends AbstractCrdt {
     private _map;
     private _propToLastUpdate;
-    constructor(object?: O);
+    constructor(obj?: O);
     private _applyUpdate;
     private _applyDeleteObjectKey;
     /**
@@ -750,4 +780,4 @@ declare class LiveObject<O extends LsonObject = LsonObject> extends AbstractCrdt
     update(overrides: Partial<O>): void;
 }
 
-export { BroadcastOptions as B, ClientOptions as C, History as H, Json as J, LiveObject as L, Others as O, Presence as P, Room as R, StorageUpdate as S, User as U, Client as a, LiveMap as b, LiveList as c, JsonObject as d, Lson as e, LsonObject as f, Resolve as g };
+export { AbstractCrdt as A, BroadcastOptions as B, ClientOptions as C, History as H, Json as J, LiveObject as L, Others as O, Presence as P, Room as R, StorageUpdate as S, User as U, Client as a, LiveMap as b, LiveList as c, JsonObject as d, Lson as e, LsonObject as f, Resolve as g, RoomInitializers as h };