@liveblocks/core 0.19.1 → 0.19.2

package/dist/index.d.ts

@@ -37,73 +37,73 @@ declare type Op = CreateOp | UpdateObjectOp | DeleteCrdtOp | SetParentKeyOp | De
 declare type CreateOp = CreateRootObjectOp | CreateChildOp;
 declare type CreateChildOp = CreateObjectOp | CreateRegisterOp | CreateMapOp | CreateListOp;
 declare type UpdateObjectOp = {
-    opId?: string;
-    id: string;
-    type: OpCode.UPDATE_OBJECT;
-    data: Partial<JsonObject>;
+    readonly opId?: string;
+    readonly id: string;
+    readonly type: OpCode.UPDATE_OBJECT;
+    readonly data: Partial<JsonObject>;
 };
 declare type CreateObjectOp = {
-    opId?: string;
-    id: string;
-    intent?: "set";
-    deletedId?: string;
-    type: OpCode.CREATE_OBJECT;
-    parentId: string;
-    parentKey: string;
-    data: JsonObject;
+    readonly opId?: string;
+    readonly id: string;
+    readonly intent?: "set";
+    readonly deletedId?: string;
+    readonly type: OpCode.CREATE_OBJECT;
+    readonly parentId: string;
+    readonly parentKey: string;
+    readonly data: JsonObject;
 };
 declare type CreateRootObjectOp = {
-    opId?: string;
-    id: string;
-    type: OpCode.CREATE_OBJECT;
-    data: JsonObject;
-    parentId?: never;
-    parentKey?: never;
+    readonly opId?: string;
+    readonly id: string;
+    readonly type: OpCode.CREATE_OBJECT;
+    readonly data: JsonObject;
+    readonly parentId?: never;
+    readonly parentKey?: never;
 };
 declare type CreateListOp = {
-    opId?: string;
-    id: string;
-    intent?: "set";
-    deletedId?: string;
-    type: OpCode.CREATE_LIST;
-    parentId: string;
-    parentKey: string;
+    readonly opId?: string;
+    readonly id: string;
+    readonly intent?: "set";
+    readonly deletedId?: string;
+    readonly type: OpCode.CREATE_LIST;
+    readonly parentId: string;
+    readonly parentKey: string;
 };
 declare type CreateMapOp = {
-    opId?: string;
-    id: string;
-    intent?: "set";
-    deletedId?: string;
-    type: OpCode.CREATE_MAP;
-    parentId: string;
-    parentKey: string;
+    readonly opId?: string;
+    readonly id: string;
+    readonly intent?: "set";
+    readonly deletedId?: string;
+    readonly type: OpCode.CREATE_MAP;
+    readonly parentId: string;
+    readonly parentKey: string;
 };
 declare type CreateRegisterOp = {
-    opId?: string;
-    id: string;
-    intent?: "set";
-    deletedId?: string;
-    type: OpCode.CREATE_REGISTER;
-    parentId: string;
-    parentKey: string;
-    data: Json;
+    readonly opId?: string;
+    readonly id: string;
+    readonly intent?: "set";
+    readonly deletedId?: string;
+    readonly type: OpCode.CREATE_REGISTER;
+    readonly parentId: string;
+    readonly parentKey: string;
+    readonly data: Json;
 };
 declare type DeleteCrdtOp = {
-    opId?: string;
-    id: string;
-    type: OpCode.DELETE_CRDT;
+    readonly opId?: string;
+    readonly id: string;
+    readonly type: OpCode.DELETE_CRDT;
 };
 declare type SetParentKeyOp = {
-    opId?: string;
-    id: string;
-    type: OpCode.SET_PARENT_KEY;
-    parentKey: string;
+    readonly opId?: string;
+    readonly id: string;
+    readonly type: OpCode.SET_PARENT_KEY;
+    readonly parentKey: string;
 };
 declare type DeleteObjectKeyOp = {
-    opId?: string;
-    id: string;
-    type: OpCode.DELETE_OBJECT_KEY;
-    key: string;
+    readonly opId?: string;
+    readonly id: string;
+    readonly type: OpCode.DELETE_OBJECT_KEY;
+    readonly key: string;
 };
 
 /**
@@ -537,7 +537,7 @@ declare type BroadcastEventClientMsg<TRoomEvent extends Json> = {
     event: TRoomEvent;
 };
 declare type UpdatePresenceClientMsg<TPresence extends JsonObject> = {
-    type: ClientMsgCode.UPDATE_PRESENCE;
+    readonly type: ClientMsgCode.UPDATE_PRESENCE;
     /**
      * Set this to any number to signify that this is a Full Presence™
      * update, not a patch.
@@ -551,23 +551,23 @@ declare type UpdatePresenceClientMsg<TPresence extends JsonObject> = {
      * is a backward-compatible way of expressing that the `data` contains
      * all presence fields, and isn't a partial "patch".
      */
-    targetActor: number;
-    data: TPresence;
+    readonly targetActor: number;
+    readonly data: TPresence;
 } | {
-    type: ClientMsgCode.UPDATE_PRESENCE;
+    readonly type: ClientMsgCode.UPDATE_PRESENCE;
     /**
      * Absence of the `targetActor` field signifies that this is a Partial
      * Presence™ "patch".
      */
-    targetActor?: undefined;
-    data: Partial<TPresence>;
+    readonly targetActor?: undefined;
+    readonly data: Partial<TPresence>;
 };
 declare type UpdateStorageClientMsg = {
-    type: ClientMsgCode.UPDATE_STORAGE;
-    ops: Op[];
+    readonly type: ClientMsgCode.UPDATE_STORAGE;
+    readonly ops: Op[];
 };
 declare type FetchStorageClientMsg = {
-    type: ClientMsgCode.FETCH_STORAGE;
+    readonly type: ClientMsgCode.FETCH_STORAGE;
 };
 
 declare type ReadonlyArrayWithLegacyMethods<T> = readonly T[] & {
@@ -1167,32 +1167,32 @@ declare enum CrdtType {
 declare type SerializedCrdt = SerializedRootObject | SerializedChild;
 declare type SerializedChild = SerializedObject | SerializedList | SerializedMap | SerializedRegister;
 declare type SerializedRootObject = {
-    type: CrdtType.OBJECT;
-    data: JsonObject;
-    parentId?: never;
-    parentKey?: never;
+    readonly type: CrdtType.OBJECT;
+    readonly data: JsonObject;
+    readonly parentId?: never;
+    readonly parentKey?: never;
 };
 declare type SerializedObject = {
-    type: CrdtType.OBJECT;
-    parentId: string;
-    parentKey: string;
-    data: JsonObject;
+    readonly type: CrdtType.OBJECT;
+    readonly parentId: string;
+    readonly parentKey: string;
+    readonly data: JsonObject;
 };
 declare type SerializedList = {
-    type: CrdtType.LIST;
-    parentId: string;
-    parentKey: string;
+    readonly type: CrdtType.LIST;
+    readonly parentId: string;
+    readonly parentKey: string;
 };
 declare type SerializedMap = {
-    type: CrdtType.MAP;
-    parentId: string;
-    parentKey: string;
+    readonly type: CrdtType.MAP;
+    readonly parentId: string;
+    readonly parentKey: string;
 };
 declare type SerializedRegister = {
-    type: CrdtType.REGISTER;
-    parentId: string;
-    parentKey: string;
-    data: Json;
+    readonly type: CrdtType.REGISTER;
+    readonly parentId: string;
+    readonly parentKey: string;
+    readonly data: Json;
 };
 declare function isRootCrdt(crdt: SerializedCrdt): crdt is SerializedRootObject;
 declare function isChildCrdt(crdt: SerializedCrdt): crdt is SerializedChild;
@@ -1222,11 +1222,11 @@ declare type ServerMsg<TPresence extends JsonObject, TUserMeta extends BaseUserM
  * so all other existing clients can ignore this broadcasted message.
  */
 declare type UpdatePresenceServerMsg<TPresence extends JsonObject> = {
-    type: ServerMsgCode.UPDATE_PRESENCE;
+    readonly type: ServerMsgCode.UPDATE_PRESENCE;
     /**
      * The User whose Presence has changed.
      */
-    actor: number;
+    readonly actor: number;
     /**
      * When set, signifies that this is a Full Presence™ update, not a patch.
      *
@@ -1239,74 +1239,74 @@ declare type UpdatePresenceServerMsg<TPresence extends JsonObject> = {
      * is a backward-compatible way of expressing that the `data` contains
      * all presence fields, and isn't a partial "patch".
      */
-    targetActor: number;
+    readonly targetActor: number;
     /**
      * The partial or full Presence of a User. If the `targetActor` field is set,
      * this will be the full Presence, otherwise it only contain the fields that
      * have changed since the last broadcast.
      */
-    data: TPresence;
+    readonly data: TPresence;
 } | {
-    type: ServerMsgCode.UPDATE_PRESENCE;
+    readonly type: ServerMsgCode.UPDATE_PRESENCE;
     /**
      * The User whose Presence has changed.
      */
-    actor: number;
+    readonly actor: number;
     /**
      * Not set for partial presence updates.
      */
-    targetActor?: undefined;
+    readonly targetActor?: undefined;
     /**
      * A partial Presence patch to apply to the User. It will only contain the
      * fields that have changed since the last broadcast.
      */
-    data: Partial<TPresence>;
+    readonly data: Partial<TPresence>;
 };
 /**
  * Sent by the WebSocket server and broadcasted to all clients to announce that
  * a new User has joined the Room.
  */
 declare type UserJoinServerMsg<TUserMeta extends BaseUserMeta> = {
-    type: ServerMsgCode.USER_JOINED;
-    actor: number;
+    readonly type: ServerMsgCode.USER_JOINED;
+    readonly actor: number;
     /**
      * The id of the User that has been set in the authentication endpoint.
      * Useful to get additional information about the connected user.
      */
-    id: TUserMeta["id"];
+    readonly id: TUserMeta["id"];
     /**
      * Additional user information that has been set in the authentication
      * endpoint.
      */
-    info: TUserMeta["info"];
+    readonly info: TUserMeta["info"];
     /**
      * Permissions that the user has in the Room.
      */
-    scopes: string[];
+    readonly scopes: string[];
 };
 /**
  * Sent by the WebSocket server and broadcasted to all clients to announce that
  * a new User has left the Room.
  */
 declare type UserLeftServerMsg = {
-    type: ServerMsgCode.USER_LEFT;
-    actor: number;
+    readonly type: ServerMsgCode.USER_LEFT;
+    readonly actor: number;
 };
 /**
  * Sent by the WebSocket server and broadcasted to all clients to announce that
  * a User broadcasted an Event to everyone in the Room.
  */
 declare type BroadcastedEventServerMsg<TRoomEvent extends Json> = {
-    type: ServerMsgCode.BROADCASTED_EVENT;
+    readonly type: ServerMsgCode.BROADCASTED_EVENT;
     /**
      * The User who broadcasted the Event.
      */
-    actor: number;
+    readonly actor: number;
     /**
      * The arbitrary payload of the Event. This can be any JSON value. Clients
      * will have to manually verify/decode this event.
      */
-    event: TRoomEvent;
+    readonly event: TRoomEvent;
 };
 /**
  * Sent by the WebSocket server to a single client in response to the client
@@ -1314,9 +1314,9 @@ declare type BroadcastedEventServerMsg<TRoomEvent extends Json> = {
  * includes a list of all other Users that already are in the Room.
  */
 declare type RoomStateServerMsg<TUserMeta extends BaseUserMeta> = {
-    type: ServerMsgCode.ROOM_STATE;
-    users: {
-        [actor: number]: TUserMeta & {
+    readonly type: ServerMsgCode.ROOM_STATE;
+    readonly users: {
+        readonly [actor: number]: TUserMeta & {
             scopes: string[];
         };
     };
@@ -1327,8 +1327,8 @@ declare type RoomStateServerMsg<TUserMeta extends BaseUserMeta> = {
  * payload includes the entire Storage document.
  */
 declare type InitialDocumentStateServerMsg = {
-    type: ServerMsgCode.INITIAL_STORAGE_STATE;
-    items: IdTuple<SerializedCrdt>[];
+    readonly type: ServerMsgCode.INITIAL_STORAGE_STATE;
+    readonly items: IdTuple<SerializedCrdt>[];
 };
 /**
  * Sent by the WebSocket server and broadcasted to all clients to announce that
@@ -1338,8 +1338,8 @@ declare type InitialDocumentStateServerMsg = {
  * mutations to make to the initially loaded document).
  */
 declare type UpdateStorageServerMsg = {
-    type: ServerMsgCode.UPDATE_STORAGE;
-    ops: Op[];
+    readonly type: ServerMsgCode.UPDATE_STORAGE;
+    readonly ops: Op[];
 };
 
 /**

package/dist/index.js

@@ -825,8 +825,10 @@ var LiveList = class extends AbstractCrdt {
       const existingItem = this._items[indexOfItemWithSameKey];
       existingItem._detach();
       this._items[indexOfItemWithSameKey] = child;
-      const reverse = existingItem._toOps(nn(this._id), key, this._pool);
-      addIntentAndDeletedIdToOperation(reverse, op.id);
+      const reverse = HACK_addIntentAndDeletedIdToOperation(
+        existingItem._toOps(nn(this._id), key, this._pool),
+        op.id
+      );
       const delta = [setDelta(indexOfItemWithSameKey, child)];
       const deletedDelta = this._detachItemAssociatedToSetOperation(
         op.deletedId
@@ -1239,11 +1241,15 @@ var LiveList = class extends AbstractCrdt {
       value._attach(id, this._pool);
       const storageUpdates = /* @__PURE__ */ new Map();
       storageUpdates.set(this._id, makeUpdate(this, [setDelta(index, value)]));
-      const ops = value._toOps(this._id, position, this._pool);
-      addIntentAndDeletedIdToOperation(ops, existingId);
+      const ops = HACK_addIntentAndDeletedIdToOperation(
+        value._toOps(this._id, position, this._pool),
+        existingId
+      );
       this._unacknowledgedSets.set(position, nn(ops[0].opId));
-      const reverseOps = existingItem._toOps(this._id, position, void 0);
-      addIntentAndDeletedIdToOperation(reverseOps, id);
+      const reverseOps = HACK_addIntentAndDeletedIdToOperation(
+        existingItem._toOps(this._id, position, void 0),
+        id
+      );
       this._pool.dispatch(ops, reverseOps, storageUpdates);
     }
   }
@@ -1371,15 +1377,18 @@ function moveDelta(previousIndex, index, item) {
     item: item instanceof LiveRegister ? item.data : item
   };
 }
-function addIntentAndDeletedIdToOperation(ops, deletedId) {
-  if (ops.length === 0) {
-    throw new Error(
-      "Internal error. Serialized LiveStructure should have at least 1 operation"
-    );
-  }
-  const firstOp = ops[0];
-  firstOp.intent = "set";
-  firstOp.deletedId = deletedId;
+function HACK_addIntentAndDeletedIdToOperation(ops, deletedId) {
+  return ops.map((op, index) => {
+    if (index === 0) {
+      const firstOp = op;
+      return __spreadProps(__spreadValues({}, firstOp), {
+        intent: "set",
+        deletedId
+      });
+    } else {
+      return op;
+    }
+  });
 }
 
 // src/lib/freeze.ts
@@ -2817,7 +2826,7 @@ function makeStateMachine(state, config, mockedEffects) {
       currentItems.set(id, node._serialize());
     });
     const ops = getTreesDiffOperations(currentItems, new Map(items));
-    const result = apply(ops, false);
+    const result = applyOps(ops, false);
     notify(result.updates, batchedUpdatesWrapper);
   }
   function load(items) {
@@ -2870,15 +2879,20 @@ function makeStateMachine(state, config, mockedEffects) {
       "Internal. Tried to get connection id but connection was never open"
     );
   }
-  function apply(ops, isLocal) {
-    const result = {
+  function applyOps(rawOps, isLocal) {
+    const output = {
       reverse: [],
-      updates: {
-        storageUpdates: /* @__PURE__ */ new Map(),
-        presence: false
-      }
+      storageUpdates: /* @__PURE__ */ new Map(),
+      presence: false
     };
     const createdNodeIds = /* @__PURE__ */ new Set();
+    const ops = rawOps.map((op) => {
+      if (op.type !== "presence" && !op.opId) {
+        return __spreadProps(__spreadValues({}, op), { opId: pool.generateOpId() });
+      } else {
+        return op;
+      }
+    });
     for (const op of ops) {
       if (op.type === "presence") {
         const reverse = {
@@ -2896,13 +2910,10 @@ function makeStateMachine(state, config, mockedEffects) {
             state.buffer.me.data[key] = op.data[key];
           }
         }
-        result.reverse.unshift(reverse);
-        result.updates.presence = true;
+        output.reverse.unshift(reverse);
+        output.presence = true;
       } else {
         let source;
-        if (!op.opId) {
-          op.opId = pool.generateOpId();
-        }
         if (isLocal) {
           source = 0 /* UNDOREDO_RECONNECT */;
         } else {
@@ -2916,16 +2927,16 @@ function makeStateMachine(state, config, mockedEffects) {
             "Expected parent node to have an ID"
           ) : void 0;
           if (!parentId || !createdNodeIds.has(parentId)) {
-            result.updates.storageUpdates.set(
+            output.storageUpdates.set(
               nn(applyOpResult.modified.node._id),
               mergeStorageUpdates(
-                result.updates.storageUpdates.get(
+                output.storageUpdates.get(
                   nn(applyOpResult.modified.node._id)
                 ),
                 applyOpResult.modified
               )
             );
-            result.reverse.unshift(...applyOpResult.reverse);
+            output.reverse.unshift(...applyOpResult.reverse);
           }
           if (op.type === 2 /* CREATE_LIST */ || op.type === 7 /* CREATE_MAP */ || op.type === 4 /* CREATE_OBJECT */) {
             createdNodeIds.add(nn(applyOpResult.modified.node._id));
@@ -2933,7 +2944,14 @@ function makeStateMachine(state, config, mockedEffects) {
         }
       }
     }
-    return result;
+    return {
+      ops,
+      reverse: output.reverse,
+      updates: {
+        storageUpdates: output.storageUpdates,
+        presence: output.presence
+      }
+    };
   }
   function applyOp(op, source) {
     switch (op.type) {
@@ -3283,7 +3301,7 @@ function makeStateMachine(state, config, mockedEffects) {
             break;
           }
           case 201 /* UPDATE_STORAGE */: {
-            const applyResult = apply(message.ops, false);
+            const applyResult = applyOps(message.ops, false);
             applyResult.updates.storageUpdates.forEach((value, key) => {
               updates.storageUpdates.set(
                 key,
@@ -3415,10 +3433,10 @@ function makeStateMachine(state, config, mockedEffects) {
     }
     const messages = [];
     const ops = Array.from(offlineOps.values());
-    const result = apply(ops, true);
+    const result = applyOps(ops, true);
     messages.push({
       type: 201 /* UPDATE_STORAGE */,
-      ops
+      ops: result.ops
     });
     notify(result.updates, batchedUpdatesWrapper);
     effects.send(messages);
@@ -3569,13 +3587,13 @@ function makeStateMachine(state, config, mockedEffects) {
       return;
     }
     state.pausedHistory = null;
-    const result = apply(historyOps, true);
+    const result = applyOps(historyOps, true);
     batchUpdates(() => {
       notify(result.updates, doNotBatchUpdates);
       state.redoStack.push(result.reverse);
       onHistoryChange(doNotBatchUpdates);
     });
-    for (const op of historyOps) {
+    for (const op of result.ops) {
       if (op.type !== "presence") {
         state.buffer.storageOperations.push(op);
       }
@@ -3594,13 +3612,13 @@ function makeStateMachine(state, config, mockedEffects) {
       return;
     }
     state.pausedHistory = null;
-    const result = apply(historyOps, true);
+    const result = applyOps(historyOps, true);
     batchUpdates(() => {
       notify(result.updates, doNotBatchUpdates);
       state.undoStack.push(result.reverse);
       onHistoryChange(doNotBatchUpdates);
     });
-    for (const op of historyOps) {
+    for (const op of result.ops) {
       if (op.type !== "presence") {
         state.buffer.storageOperations.push(op);
       }
@@ -3806,7 +3824,7 @@ function prepareCreateWebSocket(liveblocksServer, WebSocketPolyfill) {
   const ws = WebSocketPolyfill || WebSocket;
   return (token) => {
     return new ws(
-      `${liveblocksServer}/?token=${token}&version=${true ? "0.19.1" : "dev"}`
+      `${liveblocksServer}/?token=${token}&version=${true ? "0.19.2" : "dev"}`
     );
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liveblocks/core",
-  "version": "0.19.1",
+  "version": "0.19.2",
   "description": "Shared code and foundational internals for Liveblocks",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",