@liveblocks/client 0.13.1 → 0.14.0

package/lib/cjs/room.d.ts

@@ -1,4 +1,4 @@
-import { Others, Presence, ClientOptions, Room, MyPresenceCallback, OthersEventCallback, AuthEndpoint, EventCallback, User, Connection, ErrorCallback, AuthenticationToken, ConnectionCallback, StorageCallback, StorageUpdate } from "./types";
+import { Others, Presence, ClientOptions, Room, MyPresenceCallback, OthersEventCallback, AuthEndpoint, EventCallback, User, Connection, ErrorCallback, AuthenticationToken, ConnectionCallback, StorageCallback, StorageUpdate, BroadcastOptions } from "./types";
 import { ClientMessage, Op } from "./live";
 import { LiveMap } from "./LiveMap";
 import { LiveObject } from "./LiveObject";
@@ -11,6 +11,7 @@ declare type HistoryItem = Array<Op | {
 declare type IdFactory = () => string;
 export declare type State = {
     connection: Connection;
+    lastConnectionId: number | null;
     socket: WebSocket | null;
     lastFlushTime: number;
     buffer: {
@@ -62,6 +63,7 @@ export declare type State = {
             nodes: Set<AbstractCrdt>;
         };
     };
+    offlineOperations: Map<string, Op>;
 };
 export declare type Effects = {
     authenticate(): void;
@@ -89,6 +91,12 @@ export declare function makeStateMachine(state: State, context: Context, mockedE
     authenticationSuccess: (token: AuthenticationToken, socket: WebSocket) => void;
     heartbeat: () => void;
     onNavigatorOnline: () => void;
+    simulateSocketClose: () => void;
+    simulateSendCloseEvent: (event: {
+        code: number;
+        wasClean: boolean;
+        reason: any;
+    }) => void;
     onVisibilityChange: (visibilityState: VisibilityState) => void;
     getUndoStack: () => HistoryItem[];
     getItemsCount: () => number;
@@ -118,7 +126,7 @@ export declare function makeStateMachine(state: State, context: Context, mockedE
     updatePresence: <T_4 extends Presence>(overrides: Partial<T_4>, options?: {
         addToHistory: boolean;
     } | undefined) => void;
-    broadcastEvent: (event: any) => void;
+    broadcastEvent: (event: any, options?: BroadcastOptions) => void;
     batch: (callback: () => void) => void;
     undo: () => void;
     redo: () => void;

package/lib/cjs/room.js

@@ -58,6 +58,9 @@ function makeOthers(presenceMap) {
         get count() {
             return array.length;
         },
+        [Symbol.iterator]() {
+            return array[Symbol.iterator]();
+        },
         map(callback) {
             return array.map(callback);
         },
@@ -129,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) {
@@ -161,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,
@@ -249,7 +274,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++}`;
@@ -257,7 +285,7 @@ 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 },
@@ -284,7 +312,11 @@ 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.reverse.unshift(...applyOpResult.reverse);
@@ -293,7 +325,10 @@ function makeStateMachine(state, context, mockedEffects) {
         }
         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:
@@ -302,7 +337,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);
@@ -330,28 +365,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 };
@@ -443,7 +478,9 @@ See v0.13 release notes for more information.
         state.socket = socket;
     }
     function authenticationFailure(error) {
-        console.error(error);
+        if (process.env.NODE_ENV !== "production") {
+            console.error("Call to authentication endpoint failed", error);
+        }
         updateConnection({ state: "unavailable" });
         state.numberOfRetry++;
         state.timeoutHandles.reconnect = effects.scheduleReconnect(getRetryDelay());
@@ -571,12 +608,13 @@ 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);
+                    const applyResult = apply(subMessage.ops, false);
                     for (const node of applyResult.updates.nodes) {
                         updates.nodes.add(node);
                     }
@@ -609,13 +647,20 @@ See v0.13 release notes for more information.
             updateConnection({ state: "failed" });
             const error = new LiveblocksError(event.reason, event.code);
             for (const listener of state.listeners.error) {
+                if (process.env.NODE_ENV !== "production") {
+                    console.error(`Connection to Liveblocks websocket server closed. Reason: ${error.message} (code: ${error.code})`);
+                }
                 listener(error);
             }
         }
         else if (event.wasClean === false) {
-            updateConnection({ state: "unavailable" });
             state.numberOfRetry++;
-            state.timeoutHandles.reconnect = effects.scheduleReconnect(getRetryDelay());
+            const delay = getRetryDelay();
+            if (process.env.NODE_ENV !== "production") {
+                console.warn(`Connection to Liveblocks websocket server closed (code: ${event.code}). Retrying in ${delay}ms.`);
+            }
+            updateConnection({ state: "unavailable" });
+            state.timeoutHandles.reconnect = effects.scheduleReconnect(delay);
         }
         else {
             updateConnection({ state: "closed" });
@@ -639,6 +684,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 {
@@ -678,11 +727,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();
@@ -757,8 +824,10 @@ See v0.13 release notes for more information.
     function getOthers() {
         return state.others;
     }
-    function broadcastEvent(event) {
-        if (state.socket == null) {
+    function broadcastEvent(event, options = {
+        shouldQueueEventIfNotReady: false,
+    }) {
+        if (state.socket == null && options.shouldQueueEventIfNotReady == false) {
             return;
         }
         state.buffer.messages.push({
@@ -800,7 +869,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) {
@@ -819,7 +888,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) {
@@ -871,6 +940,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,
@@ -879,6 +958,9 @@ See v0.13 release notes for more information.
         authenticationSuccess,
         heartbeat,
         onNavigatorOnline,
+        // Internal dev tools
+        simulateSocketClose,
+        simulateSendCloseEvent,
         // onWakeUp,
         onVisibilityChange,
         getUndoStack: () => state.undoStack,
@@ -911,6 +993,7 @@ exports.makeStateMachine = makeStateMachine;
 function defaultState(me, defaultStorageRoot) {
     return {
         connection: { state: "closed" },
+        lastConnectionId: null,
         socket: null,
         listeners: {
             event: [],
@@ -955,6 +1038,7 @@ function defaultState(me, defaultStorageRoot) {
             updates: { nodes: new Set(), presence: false, others: [] },
             reverseOps: [],
         },
+        offlineOperations: new Map(),
     };
 }
 exports.defaultState = defaultState;
@@ -1001,6 +1085,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

@@ -28,6 +28,14 @@ export declare type LiveListUpdates<TItem = any> = {
     type: "LiveList";
     node: LiveList<TItem>;
 };
+export declare type BroadcastOptions = {
+    /**
+     * Whether or not event is queued if the connection is currently closed.
+     *
+     * ❗ We are not sure if we want to support this option in the future so it might be deprecated to be replaced by something else
+     */
+    shouldQueueEventIfNotReady: boolean;
+};
 export declare type StorageUpdate = LiveMapUpdates | LiveObjectUpdates | LiveListUpdates;
 export declare type StorageCallback = (updates: StorageUpdate[]) => void;
 export declare type Client = {
@@ -65,6 +73,10 @@ export interface Others<TPresence extends Presence = Presence> {
      * Number of other users in the room.
      */
     readonly count: number;
+    /**
+     * Returns a new Iterator object that contains the users.
+     */
+    [Symbol.iterator](): IterableIterator<User<TPresence>>;
     /**
      * Returns the array of connected users in room.
      */
@@ -423,7 +435,7 @@ export declare type Room = {
      *   }
      * });
      */
-    broadcastEvent: (event: any) => void;
+    broadcastEvent: (event: any, options?: BroadcastOptions) => void;
     /**
      * Get the room's storage asynchronously.
      * The storage's root is a {@link LiveObject}.

package/lib/cjs/utils.d.ts

@@ -1,8 +1,9 @@
 import { AbstractCrdt, Doc } from "./AbstractCrdt";
-import { SerializedCrdtWithId } from "./live";
+import { SerializedCrdtWithId, Op, SerializedCrdt } from "./live";
 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[];

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.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,78 @@ 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;

package/lib/esm/AbstractCrdt.d.ts

@@ -1,4 +1,4 @@
-import { Op } from "./live";
+import { Op, SerializedCrdt } from "./live";
 export declare type ApplyResult = {
     reverse: Op[];
     modified: AbstractCrdt;
@@ -33,7 +33,7 @@ export declare abstract class AbstractCrdt {
     /**
      * INTERNAL
      */
-    _apply(op: Op): ApplyResult;
+    _apply(op: Op, isLocal: boolean): ApplyResult;
     /**
      * INTERNAL
      */
@@ -45,7 +45,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
      */
@@ -57,5 +57,9 @@ export declare abstract class AbstractCrdt {
     /**
      * INTERNAL
      */
-    abstract _serialize(parentId: string, parentKey: string): Op[];
+    abstract _serialize(parentId: string, parentKey: string, doc?: Doc): Op[];
+    /**
+     * INTERNAL
+     */
+    abstract _toSerializedCrdt(): SerializedCrdt;
 }

package/lib/esm/AbstractCrdt.js

@@ -45,12 +45,12 @@ 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);
+                    const reverse = this._serialize(this._parent._id, this._parentKey, __classPrivateFieldGet(this, _AbstractCrdt_doc, "f"));
                     this._parent._detachChild(this);
                     return { modified: parent, reverse };
                 }

package/lib/esm/LiveList.d.ts

@@ -1,5 +1,5 @@
 import { AbstractCrdt, Doc, ApplyResult } from "./AbstractCrdt";
-import { SerializedList, SerializedCrdtWithId, Op } from "./live";
+import { SerializedList, SerializedCrdtWithId, Op, SerializedCrdt } from "./live";
 /**
  * The LiveList class represents an ordered collection of items that is synchorinized across clients.
  */
@@ -13,7 +13,7 @@ export declare class LiveList<T> extends AbstractCrdt {
     /**
      * INTERNAL
      */
-    _serialize(parentId?: string, parentKey?: string): Op[];
+    _serialize(parentId?: string, parentKey?: string, doc?: Doc): Op[];
     /**
      * INTERNAL
      */
@@ -25,7 +25,7 @@ export declare class LiveList<T> extends AbstractCrdt {
     /**
      * INTERNAL
      */
-    _attachChild(id: string, key: string, child: AbstractCrdt): ApplyResult;
+    _attachChild(id: string, key: string, child: AbstractCrdt, isLocal: boolean): ApplyResult;
     /**
      * INTERNAL
      */
@@ -37,7 +37,11 @@ export declare class LiveList<T> extends AbstractCrdt {
     /**
      * INTERNAL
      */
-    _apply(op: Op): ApplyResult;
+    _apply(op: Op, isLocal: boolean): ApplyResult;
+    /**
+     * INTERNAL
+     */
+    _toSerializedCrdt(): SerializedCrdt;
     /**
      * Returns the number of elements.
      */
@@ -64,6 +68,7 @@ export declare class LiveList<T> extends AbstractCrdt {
      * @param index The index of the element to delete
      */
     delete(index: number): void;
+    clear(): void;
     /**
      * Returns an Array of all the elements in the LiveList.
      */