@liveblocks/client 0.13.3 → 0.15.0-alpha.2

package/lib/cjs/room.js

@@ -132,18 +132,23 @@ function makeStateMachine(state, context, mockedEffects) {
         };
         return genericSubscribe(cb);
     }
-    function createRootFromMessage(message) {
-        state.root = load(message.items);
+    function createOrUpdateRootFromMessage(message) {
+        if (message.items.length === 0) {
+            throw new Error("Internal error: cannot load storage without items");
+        }
+        if (state.root) {
+            updateRoot(message.items);
+        }
+        else {
+            state.root = load(message.items);
+        }
         for (const key in state.defaultStorageRoot) {
             if (state.root.get(key) == null) {
                 state.root.set(key, state.defaultStorageRoot[key]);
             }
         }
     }
-    function load(items) {
-        if (items.length === 0) {
-            throw new Error("Internal error: cannot load storage without items");
-        }
+    function buildRootAndParentToChildren(items) {
         const parentToChildren = new Map();
         let root = null;
         for (const tuple of items) {
@@ -164,6 +169,23 @@ function makeStateMachine(state, context, mockedEffects) {
         if (root == null) {
             throw new Error("Root can't be null");
         }
+        return [root, parentToChildren];
+    }
+    function updateRoot(items) {
+        if (!state.root) {
+            return;
+        }
+        const currentItems = new Map();
+        state.items.forEach((liveCrdt, id) => {
+            currentItems.set(id, liveCrdt._toSerializedCrdt());
+        });
+        // Get operations that represent the diff between 2 states.
+        const ops = (0, utils_1.getTreesDiffOperations)(currentItems, new Map(items));
+        const result = apply(ops, false);
+        notify(result.updates);
+    }
+    function load(items) {
+        const [root, parentToChildren] = buildRootAndParentToChildren(items);
         return LiveObject_1.LiveObject._deserialize(root, parentToChildren, {
             addItem,
             deleteItem,
@@ -193,22 +215,22 @@ function makeStateMachine(state, context, mockedEffects) {
             state.undoStack.push(historyItem);
         }
     }
-    function storageDispatch(ops, reverse, modified) {
+    function storageDispatch(ops, reverse, storageUpdates) {
         if (state.isBatching) {
             state.batch.ops.push(...ops);
-            for (const item of modified) {
-                state.batch.updates.nodes.add(item);
-            }
+            storageUpdates.forEach((value, key) => {
+                state.batch.updates.storageUpdates.set(key, (0, utils_1.mergeStorageUpdates)(state.batch.updates.storageUpdates.get(key), value));
+            });
             state.batch.reverseOps.push(...reverse);
         }
         else {
             addToUndoStack(reverse);
             state.redoStack = [];
             dispatch(ops);
-            notify({ nodes: new Set(modified) });
+            notify({ storageUpdates: storageUpdates });
         }
     }
-    function notify({ nodes = new Set(), presence = false, others = [], }) {
+    function notify({ storageUpdates = new Map(), presence = false, others = [], }) {
         if (others.length > 0) {
             state.others = makeOthers(state.users);
             for (const event of others) {
@@ -222,28 +244,9 @@ function makeStateMachine(state, context, mockedEffects) {
                 listener(state.me);
             }
         }
-        if (nodes.size > 0) {
+        if (storageUpdates.size > 0) {
             for (const subscriber of state.listeners.storage) {
-                subscriber(Array.from(nodes).map((m) => {
-                    if (m instanceof LiveObject_1.LiveObject) {
-                        return {
-                            type: "LiveObject",
-                            node: m,
-                        };
-                    }
-                    else if (m instanceof LiveList_1.LiveList) {
-                        return {
-                            type: "LiveList",
-                            node: m,
-                        };
-                    }
-                    else {
-                        return {
-                            type: "LiveMap",
-                            node: m,
-                        };
-                    }
-                }));
+                subscriber(Array.from(storageUpdates.values()));
             }
         }
     }
@@ -252,7 +255,10 @@ function makeStateMachine(state, context, mockedEffects) {
             state.connection.state === "connecting") {
             return state.connection.id;
         }
-        throw new Error("Internal. Tried to get connection id but connection is not open");
+        else if (state.lastConnectionId !== null) {
+            return state.lastConnectionId;
+        }
+        throw new Error("Internal. Tried to get connection id but connection was never open");
     }
     function generateId() {
         return `${getConnectionId()}:${state.clock++}`;
@@ -260,10 +266,13 @@ function makeStateMachine(state, context, mockedEffects) {
     function generateOpId() {
         return `${getConnectionId()}:${state.opClock++}`;
     }
-    function apply(item) {
+    function apply(item, isLocal) {
         const result = {
             reverse: [],
-            updates: { nodes: new Set(), presence: false },
+            updates: {
+                storageUpdates: new Map(),
+                presence: false,
+            },
         };
         for (const op of item) {
             if (op.type === "presence") {
@@ -287,16 +296,23 @@ function makeStateMachine(state, context, mockedEffects) {
                 result.updates.presence = true;
             }
             else {
-                const applyOpResult = applyOp(op);
+                // Ops applied after undo/redo don't have an opId.
+                if (isLocal && !op.opId) {
+                    op.opId = generateOpId();
+                }
+                const applyOpResult = applyOp(op, isLocal);
                 if (applyOpResult.modified) {
-                    result.updates.nodes.add(applyOpResult.modified);
+                    result.updates.storageUpdates.set(applyOpResult.modified.node._id, (0, utils_1.mergeStorageUpdates)(result.updates.storageUpdates.get(applyOpResult.modified.node._id), applyOpResult.modified));
                     result.reverse.unshift(...applyOpResult.reverse);
                 }
             }
         }
         return result;
     }
-    function applyOp(op) {
+    function applyOp(op, isLocal) {
+        if (op.opId) {
+            state.offlineOperations.delete(op.opId);
+        }
         switch (op.type) {
             case live_1.OpType.DeleteObjectKey:
             case live_1.OpType.UpdateObject:
@@ -305,7 +321,7 @@ function makeStateMachine(state, context, mockedEffects) {
                 if (item == null) {
                     return { modified: false };
                 }
-                return item._apply(op);
+                return item._apply(op, isLocal);
             }
             case live_1.OpType.SetParentKey: {
                 const item = state.items.get(op.id);
@@ -314,17 +330,12 @@ function makeStateMachine(state, context, mockedEffects) {
                 }
                 if (item._parent instanceof LiveList_1.LiveList) {
                     const previousKey = item._parentKey;
-                    item._parent._setChildKey(op.parentKey, item);
-                    return {
-                        reverse: [
-                            {
-                                type: live_1.OpType.SetParentKey,
-                                id: item._id,
-                                parentKey: previousKey,
-                            },
-                        ],
-                        modified: item._parent,
-                    };
+                    if (previousKey === op.parentKey) {
+                        return { modified: false };
+                    }
+                    else {
+                        return item._parent._setChildKey(op.parentKey, item, previousKey);
+                    }
                 }
                 return { modified: false };
             }
@@ -333,28 +344,28 @@ function makeStateMachine(state, context, mockedEffects) {
                 if (parent == null || getItem(op.id) != null) {
                     return { modified: false };
                 }
-                return parent._attachChild(op.id, op.parentKey, new LiveObject_1.LiveObject(op.data));
+                return parent._attachChild(op.id, op.parentKey, new LiveObject_1.LiveObject(op.data), isLocal);
             }
             case live_1.OpType.CreateList: {
                 const parent = state.items.get(op.parentId);
                 if (parent == null || getItem(op.id) != null) {
                     return { modified: false };
                 }
-                return parent._attachChild(op.id, op.parentKey, new LiveList_1.LiveList());
+                return parent._attachChild(op.id, op.parentKey, new LiveList_1.LiveList(), isLocal);
             }
             case live_1.OpType.CreateRegister: {
                 const parent = state.items.get(op.parentId);
                 if (parent == null || getItem(op.id) != null) {
                     return { modified: false };
                 }
-                return parent._attachChild(op.id, op.parentKey, new LiveRegister_1.LiveRegister(op.data));
+                return parent._attachChild(op.id, op.parentKey, new LiveRegister_1.LiveRegister(op.data), isLocal);
             }
             case live_1.OpType.CreateMap: {
                 const parent = state.items.get(op.parentId);
                 if (parent == null || getItem(op.id) != null) {
                     return { modified: false };
                 }
-                return parent._attachChild(op.id, op.parentKey, new LiveMap_1.LiveMap());
+                return parent._attachChild(op.id, op.parentKey, new LiveMap_1.LiveMap(), isLocal);
             }
         }
         return { modified: false };
@@ -547,7 +558,7 @@ See v0.13 release notes for more information.
             subMessages.push(message);
         }
         const updates = {
-            nodes: new Set(),
+            storageUpdates: new Map(),
             others: [],
         };
         for (const subMessage of subMessages) {
@@ -576,15 +587,16 @@ See v0.13 release notes for more information.
                     break;
                 }
                 case live_1.ServerMessageType.InitialStorageState: {
-                    createRootFromMessage(subMessage);
+                    createOrUpdateRootFromMessage(subMessage);
+                    applyAndSendOfflineOps();
                     _getInitialStateResolver === null || _getInitialStateResolver === void 0 ? void 0 : _getInitialStateResolver();
                     break;
                 }
                 case live_1.ServerMessageType.UpdateStorage: {
-                    const applyResult = apply(subMessage.ops);
-                    for (const node of applyResult.updates.nodes) {
-                        updates.nodes.add(node);
-                    }
+                    const applyResult = apply(subMessage.ops, false);
+                    applyResult.updates.storageUpdates.forEach((value, key) => {
+                        updates.storageUpdates.set(key, (0, utils_1.mergeStorageUpdates)(updates.storageUpdates.get(key), value));
+                    });
                     break;
                 }
             }
@@ -651,6 +663,10 @@ See v0.13 release notes for more information.
         if (state.connection.state === "connecting") {
             updateConnection(Object.assign(Object.assign({}, state.connection), { state: "open" }));
             state.numberOfRetry = 0;
+            state.lastConnectionId = state.connection.id;
+            if (state.root) {
+                state.buffer.messages.push({ type: live_1.ClientMessageType.FetchStorage });
+            }
             tryFlushing();
         }
         else {
@@ -690,11 +706,29 @@ See v0.13 release notes for more information.
         clearInterval(state.intervalHandles.heartbeat);
         connect();
     }
-    function tryFlushing() {
-        if (state.socket == null) {
+    function applyAndSendOfflineOps() {
+        if (state.offlineOperations.size === 0) {
             return;
         }
-        if (state.socket.readyState !== WebSocket.OPEN) {
+        const messages = [];
+        const ops = Array.from(state.offlineOperations.values());
+        const result = apply(ops, true);
+        messages.push({
+            type: live_1.ClientMessageType.UpdateStorage,
+            ops: ops,
+        });
+        notify(result.updates);
+        effects.send(messages);
+    }
+    function tryFlushing() {
+        const storageOps = state.buffer.storageOperations;
+        if (storageOps.length > 0) {
+            storageOps.forEach((op) => {
+                state.offlineOperations.set(op.opId, op);
+            });
+        }
+        if (state.socket == null || state.socket.readyState !== WebSocket.OPEN) {
+            state.buffer.storageOperations = [];
             return;
         }
         const now = Date.now();
@@ -814,7 +848,7 @@ See v0.13 release notes for more information.
             return;
         }
         state.isHistoryPaused = false;
-        const result = apply(historyItem);
+        const result = apply(historyItem, true);
         notify(result.updates);
         state.redoStack.push(result.reverse);
         for (const op of historyItem) {
@@ -833,7 +867,7 @@ See v0.13 release notes for more information.
             return;
         }
         state.isHistoryPaused = false;
-        const result = apply(historyItem);
+        const result = apply(historyItem, true);
         notify(result.updates);
         state.undoStack.push(result.reverse);
         for (const op of historyItem) {
@@ -856,8 +890,11 @@ See v0.13 release notes for more information.
             if (state.batch.reverseOps.length > 0) {
                 addToUndoStack(state.batch.reverseOps);
             }
-            // Clear the redo stack because batch is always called from a local operation
-            state.redoStack = [];
+            if (state.batch.ops.length > 0) {
+                // Only clear the redo stack if something has changed during a batch
+                // Clear the redo stack because batch is always called from a local operation
+                state.redoStack = [];
+            }
             if (state.batch.ops.length > 0) {
                 dispatch(state.batch.ops);
             }
@@ -867,7 +904,7 @@ See v0.13 release notes for more information.
                 reverseOps: [],
                 updates: {
                     others: [],
-                    nodes: new Set(),
+                    storageUpdates: new Map(),
                     presence: false,
                 },
             };
@@ -885,6 +922,16 @@ See v0.13 release notes for more information.
         }
         state.pausedHistory = [];
     }
+    function simulateSocketClose() {
+        if (state.socket) {
+            state.socket.close();
+        }
+    }
+    function simulateSendCloseEvent(event) {
+        if (state.socket) {
+            onClose(event);
+        }
+    }
     return {
         // Internal
         onOpen,
@@ -893,6 +940,9 @@ See v0.13 release notes for more information.
         authenticationSuccess,
         heartbeat,
         onNavigatorOnline,
+        // Internal dev tools
+        simulateSocketClose,
+        simulateSendCloseEvent,
         // onWakeUp,
         onVisibilityChange,
         getUndoStack: () => state.undoStack,
@@ -925,6 +975,7 @@ exports.makeStateMachine = makeStateMachine;
 function defaultState(me, defaultStorageRoot) {
     return {
         connection: { state: "closed" },
+        lastConnectionId: null,
         socket: null,
         listeners: {
             event: [],
@@ -966,9 +1017,14 @@ function defaultState(me, defaultStorageRoot) {
         isBatching: false,
         batch: {
             ops: [],
-            updates: { nodes: new Set(), presence: false, others: [] },
+            updates: {
+                storageUpdates: new Map(),
+                presence: false,
+                others: [],
+            },
             reverseOps: [],
         },
+        offlineOperations: new Map(),
     };
 }
 exports.defaultState = defaultState;
@@ -1015,6 +1071,11 @@ function createRoom(name, options) {
             pause: machine.pauseHistory,
             resume: machine.resumeHistory,
         },
+        // @ts-ignore
+        internalDevTools: {
+            closeWebsocket: machine.simulateSocketClose,
+            sendCloseEvent: machine.simulateSendCloseEvent,
+        },
     };
     return {
         connect: machine.connect,

package/lib/cjs/types.d.ts

@@ -1,3 +1,4 @@
+import { AbstractCrdt } from "./AbstractCrdt";
 import type { LiveList } from "./LiveList";
 import type { LiveMap } from "./LiveMap";
 import type { LiveObject } from "./LiveObject";
@@ -16,17 +17,41 @@ export declare type RoomEventCallbackMap = {
     error: ErrorCallback;
     connection: ConnectionCallback;
 };
+export declare type UpdateDelta = {
+    type: "update";
+} | {
+    type: "delete";
+};
 export declare type LiveMapUpdates<TKey extends string = string, TValue = any> = {
     type: "LiveMap";
     node: LiveMap<TKey, TValue>;
+    updates: Record<TKey, UpdateDelta>;
 };
+export declare type LiveObjectUpdateDelta<T> = Partial<{
+    [Property in keyof T]: UpdateDelta;
+}>;
 export declare type LiveObjectUpdates<TData = any> = {
     type: "LiveObject";
     node: LiveObject<TData>;
+    updates: LiveObjectUpdateDelta<TData>;
+};
+export declare type LiveListUpdateDelta = {
+    index: number;
+    item: AbstractCrdt;
+    type: "insert";
+} | {
+    index: number;
+    type: "delete";
+} | {
+    index: number;
+    previousIndex: number;
+    item: AbstractCrdt;
+    type: "move";
 };
 export declare type LiveListUpdates<TItem = any> = {
     type: "LiveList";
     node: LiveList<TItem>;
+    updates: LiveListUpdateDelta[];
 };
 export declare type BroadcastOptions = {
     /**

package/lib/cjs/utils.d.ts

@@ -1,8 +1,11 @@
 import { AbstractCrdt, Doc } from "./AbstractCrdt";
-import { SerializedCrdtWithId } from "./live";
+import { SerializedCrdtWithId, Op, SerializedCrdt } from "./live";
+import { StorageUpdate } from "./types";
 export declare function remove<T>(array: T[], item: T): void;
 export declare function isSameNodeOrChildOf(node: AbstractCrdt, parent: AbstractCrdt): boolean;
 export declare function deserialize(entry: SerializedCrdtWithId, parentToChildren: Map<string, SerializedCrdtWithId[]>, doc: Doc): AbstractCrdt;
 export declare function isCrdt(obj: any): obj is AbstractCrdt;
 export declare function selfOrRegisterValue(obj: AbstractCrdt): any;
 export declare function selfOrRegister(obj: any): AbstractCrdt;
+export declare function getTreesDiffOperations(currentItems: Map<string, SerializedCrdt>, newItems: Map<string, SerializedCrdt>): Op[];
+export declare function mergeStorageUpdates(first: StorageUpdate | undefined, second: StorageUpdate): StorageUpdate;

package/lib/cjs/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.selfOrRegister = exports.selfOrRegisterValue = exports.isCrdt = exports.deserialize = exports.isSameNodeOrChildOf = exports.remove = void 0;
+exports.mergeStorageUpdates = exports.getTreesDiffOperations = exports.selfOrRegister = exports.selfOrRegisterValue = exports.isCrdt = exports.deserialize = exports.isSameNodeOrChildOf = exports.remove = void 0;
 const live_1 = require("./live");
 const LiveList_1 = require("./LiveList");
 const LiveMap_1 = require("./LiveMap");
@@ -73,3 +73,103 @@ function selfOrRegister(obj) {
     }
 }
 exports.selfOrRegister = selfOrRegister;
+function getTreesDiffOperations(currentItems, newItems) {
+    const ops = [];
+    currentItems.forEach((_, id) => {
+        if (!newItems.get(id)) {
+            // Delete crdt
+            ops.push({
+                type: live_1.OpType.DeleteCrdt,
+                id: id,
+            });
+        }
+    });
+    newItems.forEach((crdt, id) => {
+        const currentCrdt = currentItems.get(id);
+        if (currentCrdt) {
+            if (crdt.type === live_1.CrdtType.Object) {
+                if (JSON.stringify(crdt.data) !==
+                    JSON.stringify(currentCrdt.data)) {
+                    ops.push({
+                        type: live_1.OpType.UpdateObject,
+                        id: id,
+                        data: crdt.data,
+                    });
+                }
+            }
+            if (crdt.parentKey !== currentCrdt.parentKey) {
+                ops.push({
+                    type: live_1.OpType.SetParentKey,
+                    id: id,
+                    parentKey: crdt.parentKey,
+                });
+            }
+        }
+        else {
+            // new Crdt
+            switch (crdt.type) {
+                case live_1.CrdtType.Register:
+                    ops.push({
+                        type: live_1.OpType.CreateRegister,
+                        id: id,
+                        parentId: crdt.parentId,
+                        parentKey: crdt.parentKey,
+                        data: crdt.data,
+                    });
+                    break;
+                case live_1.CrdtType.List:
+                    ops.push({
+                        type: live_1.OpType.CreateList,
+                        id: id,
+                        parentId: crdt.parentId,
+                        parentKey: crdt.parentKey,
+                    });
+                    break;
+                case live_1.CrdtType.Object:
+                    ops.push({
+                        type: live_1.OpType.CreateObject,
+                        id: id,
+                        parentId: crdt.parentId,
+                        parentKey: crdt.parentKey,
+                        data: crdt.data,
+                    });
+                    break;
+                case live_1.CrdtType.Map:
+                    ops.push({
+                        type: live_1.OpType.CreateMap,
+                        id: id,
+                        parentId: crdt.parentId,
+                        parentKey: crdt.parentKey,
+                    });
+                    break;
+            }
+        }
+    });
+    return ops;
+}
+exports.getTreesDiffOperations = getTreesDiffOperations;
+function mergeStorageUpdates(first, second) {
+    if (!first) {
+        return second;
+    }
+    if (second.type === "LiveObject") {
+        const updates = first.updates;
+        for (const [key, value] of Object.entries(second.updates)) {
+            updates[key] = value;
+        }
+        return Object.assign(Object.assign({}, second), { updates: updates });
+    }
+    else if (second.type === "LiveMap") {
+        const updates = first.updates;
+        for (const [key, value] of Object.entries(second.updates)) {
+            updates[key] = value;
+        }
+        return Object.assign(Object.assign({}, second), { updates: updates });
+    }
+    else if (second.type === "LiveList") {
+        const updates = first.updates;
+        return Object.assign(Object.assign({}, second), { updates: updates.concat(second.updates) });
+    }
+    return second;
+}
+exports.mergeStorageUpdates = mergeStorageUpdates;

package/lib/esm/AbstractCrdt.d.ts

@@ -1,7 +1,8 @@
-import { Op } from "./live";
+import { Op, SerializedCrdt } from "./live";
+import { StorageUpdate } from "./types";
 export declare type ApplyResult = {
     reverse: Op[];
-    modified: AbstractCrdt;
+    modified: StorageUpdate;
 } | {
     modified: false;
 };
@@ -10,7 +11,7 @@ export interface Doc {
     generateOpId: () => string;
     addItem: (id: string, item: AbstractCrdt) => void;
     deleteItem: (id: string) => void;
-    dispatch: (ops: Op[], reverseOps: Op[], modified: AbstractCrdt[]) => void;
+    dispatch: (ops: Op[], reverseOps: Op[], storageUpdates: Map<string, StorageUpdate>) => void;
 }
 export declare abstract class AbstractCrdt {
     #private;
@@ -33,7 +34,7 @@ export declare abstract class AbstractCrdt {
     /**
      * INTERNAL
      */
-    _apply(op: Op): ApplyResult;
+    _apply(op: Op, isLocal: boolean): ApplyResult;
     /**
      * INTERNAL
      */
@@ -45,7 +46,7 @@ export declare abstract class AbstractCrdt {
     /**
      * INTERNAL
      */
-    abstract _attachChild(id: string, key: string, crdt: AbstractCrdt): ApplyResult;
+    abstract _attachChild(id: string, key: string, crdt: AbstractCrdt, isLocal: boolean): ApplyResult;
     /**
      * INTERNAL
      */
@@ -53,9 +54,14 @@ export declare abstract class AbstractCrdt {
     /**
      * INTERNAL
      */
-    abstract _detachChild(crdt: AbstractCrdt): void;
+    abstract _detachChild(crdt: AbstractCrdt): ApplyResult;
     /**
      * INTERNAL
      */
-    abstract _serialize(parentId: string, parentKey: string): Op[];
+    abstract _serialize(parentId: string, parentKey: string, doc?: Doc): Op[];
+    /**
+     * INTERNAL
+     */
+    abstract _toSerializedCrdt(): SerializedCrdt;
+    abstract _getType(): string;
 }

package/lib/esm/AbstractCrdt.js

@@ -45,14 +45,11 @@ export class AbstractCrdt {
     /**
      * INTERNAL
      */
-    _apply(op) {
+    _apply(op, isLocal) {
         switch (op.type) {
             case OpType.DeleteCrdt: {
                 if (this._parent != null && this._parentKey != null) {
-                    const parent = this._parent;
-                    const reverse = this._serialize(this._parent._id, this._parentKey);
-                    this._parent._detachChild(this);
-                    return { modified: parent, reverse };
+                    return this._parent._detachChild(this);
                 }
                 return { modified: false };
             }