@liveblocks/client 0.13.2 → 0.14.1

package/lib/cjs/room.js

@@ -1,23 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -30,7 +11,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRoom = exports.defaultState = exports.makeStateMachine = void 0;
 const utils_1 = require("./utils");
-const authentication_1 = __importStar(require("./authentication"));
 const live_1 = require("./live");
 const LiveMap_1 = require("./LiveMap");
 const LiveObject_1 = require("./LiveObject");
@@ -58,6 +38,9 @@ function makeOthers(presenceMap) {
         get count() {
             return array.length;
         },
+        [Symbol.iterator]() {
+            return array[Symbol.iterator]();
+        },
         map(callback) {
             return array.map(callback);
         },
@@ -72,16 +55,12 @@ function log(...params) {
 }
 function makeStateMachine(state, context, mockedEffects) {
     const effects = mockedEffects || {
-        authenticate() {
+        authenticate(auth, createWebSocket) {
             return __awaiter(this, void 0, void 0, function* () {
                 try {
-                    const token = yield (0, authentication_1.default)(context.authEndpoint, context.room, context.publicApiKey);
-                    const parsedToken = (0, authentication_1.parseToken)(token);
-                    const socket = new WebSocket(`${context.liveblocksServer}/?token=${token}`);
-                    socket.addEventListener("message", onMessage);
-                    socket.addEventListener("open", onOpen);
-                    socket.addEventListener("close", onClose);
-                    socket.addEventListener("error", onError);
+                    const { token } = yield auth(context.room);
+                    const parsedToken = parseToken(token);
+                    const socket = createWebSocket(token);
                     authenticationSuccess(parsedToken, socket);
                 }
                 catch (er) {
@@ -129,18 +108,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 +145,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 +250,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 +261,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 +288,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 +301,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 +313,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 +341,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 };
@@ -398,15 +409,14 @@ See v0.13 release notes for more information.
             : null;
     }
     function connect() {
-        if (typeof window === "undefined") {
-            return;
-        }
         if (state.connection.state !== "closed" &&
             state.connection.state !== "unavailable") {
             return null;
         }
+        const auth = prepareAuthEndpoint(context.authentication, context.fetchPolyfill);
+        const createWebSocket = prepareCreateWebSocket(context.liveblocksServer, context.WebSocketPolyfill);
         updateConnection({ state: "authenticating" });
-        effects.authenticate();
+        effects.authenticate(auth, createWebSocket);
     }
     function updatePresence(overrides, options) {
         const oldValues = {};
@@ -433,6 +443,10 @@ See v0.13 release notes for more information.
         }
     }
     function authenticationSuccess(token, socket) {
+        socket.addEventListener("message", onMessage);
+        socket.addEventListener("open", onOpen);
+        socket.addEventListener("close", onClose);
+        socket.addEventListener("error", onError);
         updateConnection({
             state: "connecting",
             id: token.actor,
@@ -443,7 +457,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 +587,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,14 +626,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) {
-                console.error(`Liveblocks WebSocket connection closed. Reason: ${error.message} (code: ${error.code})`);
+                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" });
@@ -640,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 {
@@ -653,7 +680,7 @@ See v0.13 release notes for more information.
         }
         clearTimeout(state.timeoutHandles.pongTimeout);
         state.timeoutHandles.pongTimeout = effects.schedulePongTimeout();
-        if (state.socket.readyState === WebSocket.OPEN) {
+        if (state.socket.readyState === state.socket.OPEN) {
             state.socket.send("ping");
         }
     }
@@ -679,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 !== state.socket.OPEN) {
+            state.buffer.storageOperations = [];
             return;
         }
         const now = Date.now();
@@ -758,8 +803,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({
@@ -801,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) {
@@ -820,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) {
@@ -872,14 +919,26 @@ 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,
         onClose,
         onMessage,
         authenticationSuccess,
         heartbeat,
         onNavigatorOnline,
+        // Internal dev tools
+        simulateSocketClose,
+        simulateSendCloseEvent,
         // onWakeUp,
         onVisibilityChange,
         getUndoStack: () => state.undoStack,
@@ -912,6 +971,7 @@ exports.makeStateMachine = makeStateMachine;
 function defaultState(me, defaultStorageRoot) {
     return {
         connection: { state: "closed" },
+        lastConnectionId: null,
         socket: null,
         listeners: {
             event: [],
@@ -956,29 +1016,13 @@ function defaultState(me, defaultStorageRoot) {
             updates: { nodes: new Set(), presence: false, others: [] },
             reverseOps: [],
         },
+        offlineOperations: new Map(),
     };
 }
 exports.defaultState = defaultState;
-function createRoom(name, options) {
-    const throttleDelay = options.throttle || 100;
-    const liveblocksServer = options.liveblocksServer || "wss://liveblocks.net/v5";
-    let authEndpoint;
-    if (options.authEndpoint) {
-        authEndpoint = options.authEndpoint;
-    }
-    else {
-        const publicAuthorizeEndpoint = options.publicAuthorizeEndpoint ||
-            "https://liveblocks.io/api/public/authorize";
-        authEndpoint = publicAuthorizeEndpoint;
-    }
+function createRoom(options, context) {
     const state = defaultState(options.defaultPresence, options.defaultStorageRoot);
-    const machine = makeStateMachine(state, {
-        throttleDelay,
-        liveblocksServer,
-        authEndpoint,
-        room: name,
-        publicApiKey: options.publicApiKey,
-    });
+    const machine = makeStateMachine(state, context);
     const room = {
         /////////////
         // Core    //
@@ -1002,6 +1046,11 @@ function createRoom(name, options) {
             pause: machine.pauseHistory,
             resume: machine.resumeHistory,
         },
+        // @ts-ignore
+        internalDevTools: {
+            closeWebsocket: machine.simulateSocketClose,
+            sendCloseEvent: machine.simulateSendCloseEvent,
+        },
     };
     return {
         connect: machine.connect,
@@ -1018,3 +1067,76 @@ class LiveblocksError extends Error {
         this.code = code;
     }
 }
+function parseToken(token) {
+    const tokenParts = token.split(".");
+    if (tokenParts.length !== 3) {
+        throw new Error(`Authentication error. Liveblocks could not parse the response of your authentication endpoint`);
+    }
+    const data = JSON.parse(atob(tokenParts[1]));
+    if (typeof data.actor !== "number") {
+        throw new Error(`Authentication error. Liveblocks could not parse the response of your authentication endpoint`);
+    }
+    return data;
+}
+function prepareCreateWebSocket(liveblocksServer, WebSocketPolyfill) {
+    if (typeof window === "undefined" && WebSocketPolyfill == null) {
+        throw new Error("To use Liveblocks client in a non-dom environment, you need to provide a WebSocket polyfill.");
+    }
+    const ws = WebSocketPolyfill || WebSocket;
+    return (token) => {
+        return new ws(`${liveblocksServer}/?token=${token}`);
+    };
+}
+function prepareAuthEndpoint(authentication, fetchPolyfill) {
+    if (authentication.type === "public") {
+        if (typeof window === "undefined" && fetchPolyfill == null) {
+            throw new Error("To use Liveblocks client in a non-dom environment with a publicApiKey, you need to provide a fetch polyfill.");
+        }
+        return (room) => fetchAuthEndpoint(fetchPolyfill || fetch, authentication.url, {
+            room,
+            publicApiKey: authentication.publicApiKey,
+        });
+    }
+    if (authentication.type === "private") {
+        if (typeof window === "undefined" && fetchPolyfill == null) {
+            throw new Error("To use Liveblocks client in a non-dom environment with a url as auth endpoint, you need to provide a fetch polyfill.");
+        }
+        return (room) => fetchAuthEndpoint(fetchPolyfill || fetch, authentication.url, {
+            room,
+        });
+    }
+    if (authentication.type === "custom") {
+        return authentication.callback;
+    }
+    throw new Error("Internal error. Unexpected authentication type");
+}
+function fetchAuthEndpoint(fetch, endpoint, body) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const res = yield fetch(endpoint, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            throw new AuthenticationError(`Authentication error. Liveblocks could not parse the response of your authentication "${endpoint}"`);
+        }
+        let authResponse = null;
+        try {
+            authResponse = yield res.json();
+        }
+        catch (er) {
+            throw new AuthenticationError(`Authentication error. Liveblocks could not parse the response of your authentication "${endpoint}"`);
+        }
+        if (typeof authResponse.token !== "string") {
+            throw new AuthenticationError(`Authentication error. Liveblocks could not parse the response of your authentication "${endpoint}"`);
+        }
+        return authResponse;
+    });
+}
+class AuthenticationError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}

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.
      */
@@ -109,6 +121,8 @@ export declare type AuthEndpoint = string | AuthEndpointCallback;
  */
 export declare type ClientOptions = {
     throttle?: number;
+    fetchPolyfill?: any;
+    WebSocketPolyfill?: any;
 } & ({
     publicApiKey: string;
     authEndpoint?: never;
@@ -119,6 +133,17 @@ export declare type ClientOptions = {
 export declare type AuthorizeResponse = {
     token: string;
 };
+export declare type Authentication = {
+    type: "public";
+    publicApiKey: string;
+    url: string;
+} | {
+    type: "private";
+    url: string;
+} | {
+    type: "custom";
+    callback: (room: string) => Promise<AuthorizeResponse>;
+};
 declare type ConnectionState = "closed" | "authenticating" | "unavailable" | "failed" | "open" | "connecting";
 export declare type Connection = {
     state: "closed" | "authenticating" | "unavailable" | "failed";
@@ -423,7 +448,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;