@liveblocks/client 0.13.2 → 0.14.0-beta.1

package/lib/esm/utils.js

@@ -1,4 +1,4 @@
-import { CrdtType, } from "./live";
+import { CrdtType, OpType, } from "./live";
 import { LiveList } from "./LiveList";
 import { LiveMap } from "./LiveMap";
 import { LiveObject } from "./LiveObject";
@@ -64,3 +64,77 @@ export function selfOrRegister(obj) {
         return new LiveRegister(obj);
     }
 }
+export function getTreesDiffOperations(currentItems, newItems) {
+    const ops = [];
+    currentItems.forEach((_, id) => {
+        if (!newItems.get(id)) {
+            // Delete crdt
+            ops.push({
+                type: OpType.DeleteCrdt,
+                id: id,
+            });
+        }
+    });
+    newItems.forEach((crdt, id) => {
+        const currentCrdt = currentItems.get(id);
+        if (currentCrdt) {
+            if (crdt.type === CrdtType.Object) {
+                if (JSON.stringify(crdt.data) !==
+                    JSON.stringify(currentCrdt.data)) {
+                    ops.push({
+                        type: OpType.UpdateObject,
+                        id: id,
+                        data: crdt.data,
+                    });
+                }
+            }
+            if (crdt.parentKey !== currentCrdt.parentKey) {
+                ops.push({
+                    type: OpType.SetParentKey,
+                    id: id,
+                    parentKey: crdt.parentKey,
+                });
+            }
+        }
+        else {
+            // new Crdt
+            switch (crdt.type) {
+                case CrdtType.Register:
+                    ops.push({
+                        type: OpType.CreateRegister,
+                        id: id,
+                        parentId: crdt.parentId,
+                        parentKey: crdt.parentKey,
+                        data: crdt.data,
+                    });
+                    break;
+                case CrdtType.List:
+                    ops.push({
+                        type: OpType.CreateList,
+                        id: id,
+                        parentId: crdt.parentId,
+                        parentKey: crdt.parentKey,
+                    });
+                    break;
+                case CrdtType.Object:
+                    ops.push({
+                        type: OpType.CreateObject,
+                        id: id,
+                        parentId: crdt.parentId,
+                        parentKey: crdt.parentKey,
+                        data: crdt.data,
+                    });
+                    break;
+                case CrdtType.Map:
+                    ops.push({
+                        type: OpType.CreateMap,
+                        id: id,
+                        parentId: crdt.parentId,
+                        parentKey: crdt.parentKey,
+                    });
+                    break;
+            }
+        }
+    });
+    return ops;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liveblocks/client",
-  "version": "0.13.2",
+  "version": "0.14.0-beta.1",
   "description": "",
   "main": "./lib/cjs/index.js",
   "module": "./lib/esm/index.js",
@@ -38,4 +38,4 @@
     "url": "https://github.com/liveblocks/liveblocks.git",
     "directory": "packages/liveblocks"
   }
-}
+}

package/lib/cjs/immutable/index.d.ts

@@ -1,7 +0,0 @@
-import { LiveList } from "../LiveList";
-import { LiveObject } from "../LiveObject";
-import { StorageUpdate } from "../types";
-export declare function liveObjectToJson(liveObject: LiveObject<any>): any;
-export declare function patchLiveList<T>(liveList: LiveList<T>, prev: Array<T>, next: Array<T>): void;
-export declare function patchLiveObject<T extends Record<string, any>>(root: LiveObject<T>, prev: T, next: T): void;
-export declare function patchImmutableObject<T>(state: T, updates: StorageUpdate[]): T;

package/lib/cjs/immutable/index.js

@@ -1,214 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.patchImmutableObject = exports.patchLiveObject = exports.patchLiveList = exports.liveObjectToJson = void 0;
-const LiveList_1 = require("../LiveList");
-const LiveMap_1 = require("../LiveMap");
-const LiveObject_1 = require("../LiveObject");
-function liveObjectToJson(liveObject) {
-    const result = {};
-    const obj = liveObject.toObject();
-    for (const key in obj) {
-        result[key] = liveNodeToJson(obj[key]);
-    }
-    return result;
-}
-exports.liveObjectToJson = liveObjectToJson;
-function liveMapToJson(map) {
-    const result = {};
-    const obj = Object.fromEntries(map);
-    for (const key in obj) {
-        result[key] = liveNodeToJson(obj[key]);
-    }
-    return result;
-}
-function liveListToJson(value) {
-    return value.toArray().map(liveNodeToJson);
-}
-function liveNodeToJson(value) {
-    if (value instanceof LiveObject_1.LiveObject) {
-        return liveObjectToJson(value);
-    }
-    else if (value instanceof LiveList_1.LiveList) {
-        return liveListToJson(value);
-    }
-    else if (value instanceof LiveMap_1.LiveMap) {
-        return liveMapToJson(value);
-    }
-    return value;
-}
-function isPlainObject(obj) {
-    return Object.prototype.toString.call(obj) === "[object Object]";
-}
-function anyToCrdt(obj) {
-    if (obj == null) {
-        return obj;
-    }
-    if (Array.isArray(obj)) {
-        return new LiveList_1.LiveList(obj.map(anyToCrdt));
-    }
-    if (isPlainObject(obj)) {
-        const init = {};
-        for (const key in obj) {
-            init[key] = anyToCrdt(obj[key]);
-        }
-        return new LiveObject_1.LiveObject(init);
-    }
-    return obj;
-}
-function patchLiveList(liveList, prev, next) {
-    let i = 0;
-    let prevEnd = prev.length - 1;
-    let nextEnd = next.length - 1;
-    let prevNode = prev[0];
-    let nextNode = next[0];
-    /**
-     * For A,B,C => A,B,C,D
-     * i = 3, prevEnd = 2, nextEnd = 3
-     *
-     * For A,B,C => B,C
-     * i = 2, prevEnd = 2, nextEnd = 1
-     *
-     * For B,C => A,B,C
-     * i = 0, pre
-     */
-    outer: {
-        while (prevNode === nextNode) {
-            ++i;
-            if (i > prevEnd || i > nextEnd) {
-                break outer;
-            }
-            prevNode = prev[i];
-            nextNode = next[i];
-        }
-        prevNode = prev[prevEnd];
-        nextNode = next[nextEnd];
-        while (prevNode === nextNode) {
-            prevEnd--;
-            nextEnd--;
-            if (i > prevEnd || i > nextEnd) {
-                break outer;
-            }
-            prevNode = prev[prevEnd];
-            nextNode = next[nextEnd];
-        }
-    }
-    if (i > prevEnd) {
-        if (i <= nextEnd) {
-            while (i <= nextEnd) {
-                liveList.insert(anyToCrdt(next[i]), i);
-                i++;
-            }
-        }
-    }
-    else if (i > nextEnd) {
-        while (i <= prevEnd) {
-            liveList.delete(i++);
-        }
-    }
-    else {
-        while (i <= prevEnd && i <= nextEnd) {
-            prevNode = prev[i];
-            nextNode = next[i];
-            const liveListNode = liveList.get(i);
-            if (liveListNode instanceof LiveObject_1.LiveObject &&
-                isPlainObject(prevNode) &&
-                isPlainObject(nextNode)) {
-                patchLiveObject(liveListNode, prevNode, nextNode);
-            }
-            else {
-                liveList.delete(i);
-                liveList.insert(anyToCrdt(nextNode), i);
-            }
-            i++;
-        }
-        while (i <= nextEnd) {
-            liveList.insert(anyToCrdt(next[i]), i);
-            i++;
-        }
-        while (i <= prevEnd) {
-            liveList.delete(i);
-            i++;
-        }
-    }
-}
-exports.patchLiveList = patchLiveList;
-function patchLiveObject(root, prev, next) {
-    const updates = {};
-    for (const key in next) {
-        if (prev[key] === next[key]) {
-            continue;
-        }
-        else if (Array.isArray(prev[key]) && Array.isArray(next[key])) {
-            patchLiveList(root.get(key), prev[key], next[key]);
-        }
-        else if (isPlainObject(prev[key]) && isPlainObject(next[key])) {
-            patchLiveObject(root.get(key), prev[key], next[key]);
-        }
-        else {
-            updates[key] = anyToCrdt(next[key]);
-        }
-    }
-    for (const key in prev) {
-        if (next[key] === undefined) {
-            root.delete(key);
-        }
-    }
-    if (Object.keys(updates).length > 0) {
-        root.update(updates);
-    }
-}
-exports.patchLiveObject = patchLiveObject;
-function getParentsPath(node) {
-    const path = [];
-    while (node._parentKey != null && node._parent != null) {
-        if (node._parent instanceof LiveList_1.LiveList) {
-            path.push(node._parent._indexOfPosition(node._parentKey));
-        }
-        else {
-            path.push(node._parentKey);
-        }
-        node = node._parent;
-    }
-    return path;
-}
-function patchImmutableObject(state, updates) {
-    return updates.reduce((state, update) => patchImmutableObjectWithUpdate(state, update), state);
-}
-exports.patchImmutableObject = patchImmutableObject;
-function patchImmutableObjectWithUpdate(state, update) {
-    const path = getParentsPath(update.node);
-    return patchImmutableNode(state, path, update);
-}
-function patchImmutableNode(state, path, update) {
-    const pathItem = path.pop();
-    if (pathItem === undefined) {
-        switch (update.type) {
-            case "LiveObject": {
-                if (typeof state !== "object") {
-                    throw new Error("Internal: received update on LiveObject but state was not an object");
-                }
-                return liveObjectToJson(update.node);
-            }
-            case "LiveList": {
-                if (Array.isArray(state) === false) {
-                    throw new Error("Internal: received update on LiveList but state was not an array");
-                }
-                return liveListToJson(update.node);
-            }
-            case "LiveMap": {
-                if (typeof state !== "object") {
-                    throw new Error("Internal: received update on LiveMap but state was not an object");
-                }
-                return liveMapToJson(update.node);
-            }
-        }
-    }
-    if (Array.isArray(state)) {
-        const newArray = [...state];
-        newArray[pathItem] = patchImmutableNode(state[pathItem], path, update);
-        return newArray;
-    }
-    else {
-        return Object.assign(Object.assign({}, state), { [pathItem]: patchImmutableNode(state[pathItem], path, update) });
-    }
-}

package/lib/esm/immutable/index.d.ts

@@ -1,7 +0,0 @@
-import { LiveList } from "../LiveList";
-import { LiveObject } from "../LiveObject";
-import { StorageUpdate } from "../types";
-export declare function liveObjectToJson(liveObject: LiveObject<any>): any;
-export declare function patchLiveList<T>(liveList: LiveList<T>, prev: Array<T>, next: Array<T>): void;
-export declare function patchLiveObject<T extends Record<string, any>>(root: LiveObject<T>, prev: T, next: T): void;
-export declare function patchImmutableObject<T>(state: T, updates: StorageUpdate[]): T;

package/lib/esm/immutable/index.js

@@ -1,207 +0,0 @@
-import { LiveList } from "../LiveList";
-import { LiveMap } from "../LiveMap";
-import { LiveObject } from "../LiveObject";
-export function liveObjectToJson(liveObject) {
-    const result = {};
-    const obj = liveObject.toObject();
-    for (const key in obj) {
-        result[key] = liveNodeToJson(obj[key]);
-    }
-    return result;
-}
-function liveMapToJson(map) {
-    const result = {};
-    const obj = Object.fromEntries(map);
-    for (const key in obj) {
-        result[key] = liveNodeToJson(obj[key]);
-    }
-    return result;
-}
-function liveListToJson(value) {
-    return value.toArray().map(liveNodeToJson);
-}
-function liveNodeToJson(value) {
-    if (value instanceof LiveObject) {
-        return liveObjectToJson(value);
-    }
-    else if (value instanceof LiveList) {
-        return liveListToJson(value);
-    }
-    else if (value instanceof LiveMap) {
-        return liveMapToJson(value);
-    }
-    return value;
-}
-function isPlainObject(obj) {
-    return Object.prototype.toString.call(obj) === "[object Object]";
-}
-function anyToCrdt(obj) {
-    if (obj == null) {
-        return obj;
-    }
-    if (Array.isArray(obj)) {
-        return new LiveList(obj.map(anyToCrdt));
-    }
-    if (isPlainObject(obj)) {
-        const init = {};
-        for (const key in obj) {
-            init[key] = anyToCrdt(obj[key]);
-        }
-        return new LiveObject(init);
-    }
-    return obj;
-}
-export function patchLiveList(liveList, prev, next) {
-    let i = 0;
-    let prevEnd = prev.length - 1;
-    let nextEnd = next.length - 1;
-    let prevNode = prev[0];
-    let nextNode = next[0];
-    /**
-     * For A,B,C => A,B,C,D
-     * i = 3, prevEnd = 2, nextEnd = 3
-     *
-     * For A,B,C => B,C
-     * i = 2, prevEnd = 2, nextEnd = 1
-     *
-     * For B,C => A,B,C
-     * i = 0, pre
-     */
-    outer: {
-        while (prevNode === nextNode) {
-            ++i;
-            if (i > prevEnd || i > nextEnd) {
-                break outer;
-            }
-            prevNode = prev[i];
-            nextNode = next[i];
-        }
-        prevNode = prev[prevEnd];
-        nextNode = next[nextEnd];
-        while (prevNode === nextNode) {
-            prevEnd--;
-            nextEnd--;
-            if (i > prevEnd || i > nextEnd) {
-                break outer;
-            }
-            prevNode = prev[prevEnd];
-            nextNode = next[nextEnd];
-        }
-    }
-    if (i > prevEnd) {
-        if (i <= nextEnd) {
-            while (i <= nextEnd) {
-                liveList.insert(anyToCrdt(next[i]), i);
-                i++;
-            }
-        }
-    }
-    else if (i > nextEnd) {
-        while (i <= prevEnd) {
-            liveList.delete(i++);
-        }
-    }
-    else {
-        while (i <= prevEnd && i <= nextEnd) {
-            prevNode = prev[i];
-            nextNode = next[i];
-            const liveListNode = liveList.get(i);
-            if (liveListNode instanceof LiveObject &&
-                isPlainObject(prevNode) &&
-                isPlainObject(nextNode)) {
-                patchLiveObject(liveListNode, prevNode, nextNode);
-            }
-            else {
-                liveList.delete(i);
-                liveList.insert(anyToCrdt(nextNode), i);
-            }
-            i++;
-        }
-        while (i <= nextEnd) {
-            liveList.insert(anyToCrdt(next[i]), i);
-            i++;
-        }
-        while (i <= prevEnd) {
-            liveList.delete(i);
-            i++;
-        }
-    }
-}
-export function patchLiveObject(root, prev, next) {
-    const updates = {};
-    for (const key in next) {
-        if (prev[key] === next[key]) {
-            continue;
-        }
-        else if (Array.isArray(prev[key]) && Array.isArray(next[key])) {
-            patchLiveList(root.get(key), prev[key], next[key]);
-        }
-        else if (isPlainObject(prev[key]) && isPlainObject(next[key])) {
-            patchLiveObject(root.get(key), prev[key], next[key]);
-        }
-        else {
-            updates[key] = anyToCrdt(next[key]);
-        }
-    }
-    for (const key in prev) {
-        if (next[key] === undefined) {
-            root.delete(key);
-        }
-    }
-    if (Object.keys(updates).length > 0) {
-        root.update(updates);
-    }
-}
-function getParentsPath(node) {
-    const path = [];
-    while (node._parentKey != null && node._parent != null) {
-        if (node._parent instanceof LiveList) {
-            path.push(node._parent._indexOfPosition(node._parentKey));
-        }
-        else {
-            path.push(node._parentKey);
-        }
-        node = node._parent;
-    }
-    return path;
-}
-export function patchImmutableObject(state, updates) {
-    return updates.reduce((state, update) => patchImmutableObjectWithUpdate(state, update), state);
-}
-function patchImmutableObjectWithUpdate(state, update) {
-    const path = getParentsPath(update.node);
-    return patchImmutableNode(state, path, update);
-}
-function patchImmutableNode(state, path, update) {
-    const pathItem = path.pop();
-    if (pathItem === undefined) {
-        switch (update.type) {
-            case "LiveObject": {
-                if (typeof state !== "object") {
-                    throw new Error("Internal: received update on LiveObject but state was not an object");
-                }
-                return liveObjectToJson(update.node);
-            }
-            case "LiveList": {
-                if (Array.isArray(state) === false) {
-                    throw new Error("Internal: received update on LiveList but state was not an array");
-                }
-                return liveListToJson(update.node);
-            }
-            case "LiveMap": {
-                if (typeof state !== "object") {
-                    throw new Error("Internal: received update on LiveMap but state was not an object");
-                }
-                return liveMapToJson(update.node);
-            }
-        }
-    }
-    if (Array.isArray(state)) {
-        const newArray = [...state];
-        newArray[pathItem] = patchImmutableNode(state[pathItem], path, update);
-        return newArray;
-    }
-    else {
-        return Object.assign(Object.assign({}, state), { [pathItem]: patchImmutableNode(state[pathItem], path, update) });
-    }
-}