@liveblocks/client 0.14.4 → 0.15.0-alpha.3

package/lib/esm/AbstractCrdt.d.ts

@@ -1,7 +1,8 @@
 import { Op, SerializedCrdt } from "./live";
+import { StorageUpdate } from "./types";
 export declare type ApplyResult = {
     reverse: Op[];
-    modified: AbstractCrdt;
+    modified: StorageUpdate;
 } | {
     modified: false;
 };
@@ -11,7 +12,7 @@ export interface Doc {
     getItem: (id: string) => AbstractCrdt | undefined;
     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;
@@ -54,7 +55,7 @@ export declare abstract class AbstractCrdt {
     /**
      * INTERNAL
      */
-    abstract _detachChild(crdt: AbstractCrdt): void;
+    abstract _detachChild(crdt: AbstractCrdt): ApplyResult;
     /**
      * INTERNAL
      */
@@ -63,4 +64,5 @@ export declare abstract class AbstractCrdt {
      * INTERNAL
      */
     abstract _toSerializedCrdt(): SerializedCrdt;
+    abstract _getType(): string;
 }

package/lib/esm/AbstractCrdt.js

@@ -49,10 +49,7 @@ export class AbstractCrdt {
         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, __classPrivateFieldGet(this, _AbstractCrdt_doc, "f"));
-                    this._parent._detachChild(this);
-                    return { modified: parent, reverse };
+                    return this._parent._detachChild(this);
                 }
                 return { modified: false };
             }

package/lib/esm/LiveList.d.ts

@@ -14,6 +14,7 @@ export declare class LiveList<T> extends AbstractCrdt {
      * INTERNAL
      */
     _serialize(parentId?: string, parentKey?: string, doc?: Doc): Op[];
+    _indexOfPosition(position: string): number;
     /**
      * INTERNAL
      */
@@ -29,15 +30,19 @@ export declare class LiveList<T> extends AbstractCrdt {
     /**
      * INTERNAL
      */
-    _detachChild(child: AbstractCrdt): void;
+    _detachChild(child: AbstractCrdt): ApplyResult;
     /**
      * INTERNAL
      */
-    _setChildKey(key: string, child: AbstractCrdt): void;
+    _setChildKey(key: string, child: AbstractCrdt, previousKey: string): ApplyResult;
     /**
      * INTERNAL
      */
     _apply(op: Op, isLocal: boolean): ApplyResult;
+    /**
+     * INTERNAL
+     */
+    _getType(): string;
     /**
      * INTERNAL
      */
@@ -73,6 +78,7 @@ export declare class LiveList<T> extends AbstractCrdt {
      * Returns an Array of all the elements in the LiveList.
      */
     toArray(): T[];
+    toCrdtArray(): AbstractCrdt[];
     /**
      * Tests whether all elements pass the test implemented by the provided function.
      * @param predicate Function to test for each element, taking two arguments (the element and its index).

package/lib/esm/LiveList.js

@@ -14,6 +14,7 @@ import { AbstractCrdt } from "./AbstractCrdt";
 import { deserialize, selfOrRegister, selfOrRegisterValue } from "./utils";
 import { OpType, CrdtType, } from "./live";
 import { makePosition, compare } from "./position";
+import { LiveRegister } from "./LiveRegister";
 /**
  * The LiveList class represents an ordered collection of items that is synchorinized across clients.
  */
@@ -72,6 +73,9 @@ export class LiveList extends AbstractCrdt {
         }
         return ops;
     }
+    _indexOfPosition(position) {
+        return __classPrivateFieldGet(this, _LiveList_items, "f").findIndex((item) => item[1] === position);
+    }
     /**
      * INTERNAL
      */
@@ -123,24 +127,47 @@ export class LiveList extends AbstractCrdt {
         }
         __classPrivateFieldGet(this, _LiveList_items, "f").push([child, newKey]);
         __classPrivateFieldGet(this, _LiveList_items, "f").sort((itemA, itemB) => compare(itemA[1], itemB[1]));
-        return { reverse: [{ type: OpType.DeleteCrdt, id }], modified: this };
+        const newIndex = __classPrivateFieldGet(this, _LiveList_items, "f").findIndex((entry) => entry[1] === newKey);
+        return {
+            reverse: [{ type: OpType.DeleteCrdt, id }],
+            modified: {
+                node: this,
+                type: "LiveList",
+                updates: [
+                    {
+                        index: newIndex,
+                        type: "insert",
+                        item: child instanceof LiveRegister ? child.data : child,
+                    },
+                ],
+            },
+        };
     }
     /**
      * INTERNAL
      */
     _detachChild(child) {
-        const indexToDelete = __classPrivateFieldGet(this, _LiveList_items, "f").findIndex((item) => item[0] === child);
-        __classPrivateFieldGet(this, _LiveList_items, "f").splice(indexToDelete, 1);
         if (child) {
+            const reverse = child._serialize(this._id, child._parentKey, this._doc);
+            const indexToDelete = __classPrivateFieldGet(this, _LiveList_items, "f").findIndex((item) => item[0] === child);
+            __classPrivateFieldGet(this, _LiveList_items, "f").splice(indexToDelete, 1);
             child._detach();
+            const storageUpdate = {
+                node: this,
+                type: "LiveList",
+                updates: [{ index: indexToDelete, type: "delete" }],
+            };
+            return { modified: storageUpdate, reverse };
         }
+        return { modified: false };
     }
     /**
      * INTERNAL
      */
-    _setChildKey(key, child) {
+    _setChildKey(key, child, previousKey) {
         var _a;
         child._setParentLink(this, key);
+        const previousIndex = __classPrivateFieldGet(this, _LiveList_items, "f").findIndex((entry) => entry[0]._id === child._id);
         const index = __classPrivateFieldGet(this, _LiveList_items, "f").findIndex((entry) => entry[1] === key);
         // Assign a temporary position until we get the fix from the backend
         if (index !== -1) {
@@ -151,6 +178,31 @@ export class LiveList extends AbstractCrdt {
             item[1] = key;
         }
         __classPrivateFieldGet(this, _LiveList_items, "f").sort((itemA, itemB) => compare(itemA[1], itemB[1]));
+        const newIndex = __classPrivateFieldGet(this, _LiveList_items, "f").findIndex((entry) => entry[0]._id === child._id);
+        const updatesDelta = newIndex === previousIndex
+            ? []
+            : [
+                {
+                    index: newIndex,
+                    item: child instanceof LiveRegister ? child.data : child,
+                    previousIndex: previousIndex,
+                    type: "move",
+                },
+            ];
+        return {
+            modified: {
+                node: this,
+                type: "LiveList",
+                updates: updatesDelta,
+            },
+            reverse: [
+                {
+                    type: OpType.SetParentKey,
+                    id: item === null || item === void 0 ? void 0 : item[0]._id,
+                    parentKey: previousKey,
+                },
+            ],
+        };
     }
     /**
      * INTERNAL
@@ -158,6 +210,12 @@ export class LiveList extends AbstractCrdt {
     _apply(op, isLocal) {
         return super._apply(op, isLocal);
     }
+    /**
+     * INTERNAL
+     */
+    _getType() {
+        return "LiveList";
+    }
     /**
      * INTERNAL
      */
@@ -189,7 +247,7 @@ export class LiveList extends AbstractCrdt {
      */
     insert(element, index) {
         if (index < 0 || index > __classPrivateFieldGet(this, _LiveList_items, "f").length) {
-            throw new Error(`Cannot delete list item at index "${index}". index should be between 0 and ${__classPrivateFieldGet(this, _LiveList_items, "f").length}`);
+            throw new Error(`Cannot insert list item at index "${index}". index should be between 0 and ${__classPrivateFieldGet(this, _LiveList_items, "f").length}`);
         }
         let before = __classPrivateFieldGet(this, _LiveList_items, "f")[index - 1] ? __classPrivateFieldGet(this, _LiveList_items, "f")[index - 1][1] : undefined;
         let after = __classPrivateFieldGet(this, _LiveList_items, "f")[index] ? __classPrivateFieldGet(this, _LiveList_items, "f")[index][1] : undefined;
@@ -198,10 +256,23 @@ export class LiveList extends AbstractCrdt {
         value._setParentLink(this, position);
         __classPrivateFieldGet(this, _LiveList_items, "f").push([value, position]);
         __classPrivateFieldGet(this, _LiveList_items, "f").sort((itemA, itemB) => compare(itemA[1], itemB[1]));
+        const newIndex = __classPrivateFieldGet(this, _LiveList_items, "f").findIndex((entry) => entry[1] === position);
         if (this._doc && this._id) {
             const id = this._doc.generateId();
             value._attach(id, this._doc);
-            this._doc.dispatch(value._serialize(this._id, position, this._doc), [{ type: OpType.DeleteCrdt, id }], [this]);
+            const storageUpdates = new Map();
+            storageUpdates.set(this._id, {
+                node: this,
+                type: "LiveList",
+                updates: [
+                    {
+                        index: newIndex,
+                        item: value instanceof LiveRegister ? value.data : value,
+                        type: "insert",
+                    },
+                ],
+            });
+            this._doc.dispatch(value._serialize(this._id, position, this._doc), [{ type: OpType.DeleteCrdt, id }], storageUpdates);
         }
     }
     /**
@@ -242,7 +313,21 @@ export class LiveList extends AbstractCrdt {
         item[1] = position;
         item[0]._setParentLink(this, position);
         __classPrivateFieldGet(this, _LiveList_items, "f").sort((itemA, itemB) => compare(itemA[1], itemB[1]));
+        const newIndex = __classPrivateFieldGet(this, _LiveList_items, "f").findIndex((entry) => entry[1] === position);
         if (this._doc && this._id) {
+            const storageUpdates = new Map();
+            storageUpdates.set(this._id, {
+                node: this,
+                type: "LiveList",
+                updates: [
+                    {
+                        index: newIndex,
+                        previousIndex: index,
+                        item: item[0],
+                        type: "move",
+                    },
+                ],
+            });
             this._doc.dispatch([
                 {
                     type: OpType.SetParentKey,
@@ -256,7 +341,7 @@ export class LiveList extends AbstractCrdt {
                     id: item[0]._id,
                     parentKey: previousPosition,
                 },
-            ], [this]);
+            ], storageUpdates);
         }
     }
     /**
@@ -273,13 +358,19 @@ export class LiveList extends AbstractCrdt {
         if (this._doc) {
             const childRecordId = item[0]._id;
             if (childRecordId) {
+                const storageUpdates = new Map();
+                storageUpdates.set(this._id, {
+                    node: this,
+                    type: "LiveList",
+                    updates: [{ index: index, type: "delete" }],
+                });
                 this._doc.dispatch([
                     {
                         id: childRecordId,
                         opId: this._doc.generateOpId(),
                         type: OpType.DeleteCrdt,
                     },
-                ], item[0]._serialize(this._id, item[1]), [this]);
+                ], item[0]._serialize(this._id, item[1]), storageUpdates);
             }
         }
     }
@@ -287,16 +378,26 @@ export class LiveList extends AbstractCrdt {
         if (this._doc) {
             let ops = [];
             let reverseOps = [];
+            let updateDelta = [];
+            let i = 0;
             for (const item of __classPrivateFieldGet(this, _LiveList_items, "f")) {
                 item[0]._detach();
                 const childId = item[0]._id;
                 if (childId) {
                     ops.push({ id: childId, type: OpType.DeleteCrdt });
                     reverseOps.push(...item[0]._serialize(this._id, item[1]));
+                    updateDelta.push({ index: i, type: "delete" });
                 }
+                i++;
             }
             __classPrivateFieldSet(this, _LiveList_items, [], "f");
-            this._doc.dispatch(ops, reverseOps, [this]);
+            const storageUpdates = new Map();
+            storageUpdates.set(this._id, {
+                node: this,
+                type: "LiveList",
+                updates: updateDelta,
+            });
+            this._doc.dispatch(ops, reverseOps, storageUpdates);
         }
         else {
             for (const item of __classPrivateFieldGet(this, _LiveList_items, "f")) {
@@ -311,6 +412,9 @@ export class LiveList extends AbstractCrdt {
     toArray() {
         return __classPrivateFieldGet(this, _LiveList_items, "f").map((entry) => selfOrRegisterValue(entry[0]));
     }
+    toCrdtArray() {
+        return __classPrivateFieldGet(this, _LiveList_items, "f").map((entry) => entry[0]);
+    }
     /**
      * Tests whether all elements pass the test implemented by the provided function.
      * @param predicate Function to test for each element, taking two arguments (the element and its index).

package/lib/esm/LiveMap.d.ts

@@ -31,7 +31,11 @@ export declare class LiveMap<TKey extends string, TValue> extends AbstractCrdt {
     /**
      * INTERNAL
      */
-    _detachChild(child: AbstractCrdt): void;
+    _detachChild(child: AbstractCrdt): ApplyResult;
+    /**
+     * INTERNAL
+     */
+    _getType(): string;
     /**
      * INTERNAL
      */

package/lib/esm/LiveMap.js

@@ -116,7 +116,14 @@ export class LiveMap extends AbstractCrdt {
         child._setParentLink(this, key);
         child._attach(id, this._doc);
         __classPrivateFieldGet(this, _LiveMap_map, "f").set(key, child);
-        return { modified: this, reverse };
+        return {
+            modified: {
+                node: this,
+                type: "LiveMap",
+                updates: { [key]: { type: "update" } },
+            },
+            reverse,
+        };
     }
     /**
      * INTERNAL
@@ -131,12 +138,25 @@ export class LiveMap extends AbstractCrdt {
      * INTERNAL
      */
     _detachChild(child) {
+        const reverse = child._serialize(this._id, child._parentKey, this._doc);
         for (const [key, value] of __classPrivateFieldGet(this, _LiveMap_map, "f")) {
             if (value === child) {
                 __classPrivateFieldGet(this, _LiveMap_map, "f").delete(key);
             }
         }
         child._detach();
+        const storageUpdate = {
+            node: this,
+            type: "LiveMap",
+            updates: { [child._parentKey]: { type: "delete" } },
+        };
+        return { modified: storageUpdate, reverse };
+    }
+    /**
+     * INTERNAL
+     */
+    _getType() {
+        return "LiveMap";
     }
     /**
      * INTERNAL
@@ -177,9 +197,15 @@ export class LiveMap extends AbstractCrdt {
         if (this._doc && this._id) {
             const id = this._doc.generateId();
             item._attach(id, this._doc);
+            const storageUpdates = new Map();
+            storageUpdates.set(this._id, {
+                node: this,
+                type: "LiveMap",
+                updates: { [key]: { type: "update" } },
+            });
             this._doc.dispatch(item._serialize(this._id, key, this._doc), oldValue
                 ? oldValue._serialize(this._id, key)
-                : [{ type: OpType.DeleteCrdt, id }], [this]);
+                : [{ type: OpType.DeleteCrdt, id }], storageUpdates);
         }
     }
     /**
@@ -207,13 +233,19 @@ export class LiveMap extends AbstractCrdt {
         }
         item._detach();
         if (this._doc && item._id) {
+            const storageUpdates = new Map();
+            storageUpdates.set(this._id, {
+                node: this,
+                type: "LiveMap",
+                updates: { [key]: { type: "delete" } },
+            });
             this._doc.dispatch([
                 {
                     type: OpType.DeleteCrdt,
                     id: item._id,
                     opId: this._doc.generateOpId(),
                 },
-            ], item._serialize(this._id, key), [this]);
+            ], item._serialize(this._id, key), storageUpdates);
         }
         __classPrivateFieldGet(this, _LiveMap_map, "f").delete(key);
         return true;

package/lib/esm/LiveObject.d.ts

@@ -31,7 +31,7 @@ export declare class LiveObject<T extends Record<string, any> = Record<string, a
     /**
      * INTERNAL
      */
-    _detachChild(child: AbstractCrdt): void;
+    _detachChild(child: AbstractCrdt): ApplyResult;
     /**
      * INTERNAL
      */
@@ -48,6 +48,10 @@ export declare class LiveObject<T extends Record<string, any> = Record<string, a
      * INTERNAL
      */
     _toSerializedCrdt(): SerializedCrdt;
+    /**
+     * INTERNAL
+     */
+    _getType(): string;
     /**
      * Transform the LiveObject into a javascript object
      */

package/lib/esm/LiveObject.js

@@ -152,20 +152,37 @@ export class LiveObject extends AbstractCrdt {
         __classPrivateFieldGet(this, _LiveObject_map, "f").set(key, child);
         child._setParentLink(this, key);
         child._attach(id, this._doc);
-        return { reverse, modified: this };
+        return {
+            reverse,
+            modified: {
+                node: this,
+                type: "LiveObject",
+                updates: { [key]: { type: "update" } },
+            },
+        };
     }
     /**
      * INTERNAL
      */
     _detachChild(child) {
-        for (const [key, value] of __classPrivateFieldGet(this, _LiveObject_map, "f")) {
-            if (value === child) {
-                __classPrivateFieldGet(this, _LiveObject_map, "f").delete(key);
-            }
-        }
         if (child) {
+            const reverse = child._serialize(this._id, child._parentKey, this._doc);
+            for (const [key, value] of __classPrivateFieldGet(this, _LiveObject_map, "f")) {
+                if (value === child) {
+                    __classPrivateFieldGet(this, _LiveObject_map, "f").delete(key);
+                }
+            }
             child._detach();
+            const storageUpdate = {
+                node: this,
+                type: "LiveObject",
+                updates: {
+                    [child._parentKey]: { type: "delete" },
+                },
+            };
+            return { modified: storageUpdate, reverse };
         }
+        return { modified: false };
     }
     /**
      * INTERNAL
@@ -211,6 +228,12 @@ export class LiveObject extends AbstractCrdt {
             data: this.toObject(),
         };
     }
+    /**
+     * INTERNAL
+     */
+    _getType() {
+        return "LiveObject";
+    }
     /**
      * Transform the LiveObject into a javascript object
      */
@@ -265,6 +288,12 @@ export class LiveObject extends AbstractCrdt {
             ];
         }
         __classPrivateFieldGet(this, _LiveObject_map, "f").delete(keyAsString);
+        const storageUpdates = new Map();
+        storageUpdates.set(this._id, {
+            node: this,
+            type: "LiveObject",
+            updates: { [key]: { type: "delete" } },
+        });
         this._doc.dispatch([
             {
                 type: OpType.DeleteObjectKey,
@@ -272,7 +301,7 @@ export class LiveObject extends AbstractCrdt {
                 id: this._id,
                 opId: this._doc.generateOpId(),
             },
-        ], reverse, [this]);
+        ], reverse, storageUpdates);
     }
     /**
      * Adds or updates multiple properties at once with an object.
@@ -302,6 +331,7 @@ export class LiveObject extends AbstractCrdt {
             type: OpType.UpdateObject,
             data: {},
         };
+        const updateDelta = {};
         for (const key in overrides) {
             const oldValue = __classPrivateFieldGet(this, _LiveObject_map, "f").get(key);
             if (oldValue instanceof AbstractCrdt) {
@@ -330,6 +360,7 @@ export class LiveObject extends AbstractCrdt {
                 __classPrivateFieldGet(this, _LiveObject_propToLastUpdate, "f").set(key, opId);
             }
             __classPrivateFieldGet(this, _LiveObject_map, "f").set(key, newValue);
+            updateDelta[key] = { type: "update" };
         }
         if (Object.keys(reverseUpdateOp.data).length !== 0) {
             reverseOps.unshift(reverseUpdateOp);
@@ -342,7 +373,13 @@ export class LiveObject extends AbstractCrdt {
                 data: updatedProps,
             });
         }
-        this._doc.dispatch(ops, reverseOps, [this]);
+        const storageUpdates = new Map();
+        storageUpdates.set(this._id, {
+            node: this,
+            type: "LiveObject",
+            updates: updateDelta,
+        });
+        this._doc.dispatch(ops, reverseOps, storageUpdates);
     }
 }
 _LiveObject_map = new WeakMap(), _LiveObject_propToLastUpdate = new WeakMap(), _LiveObject_instances = new WeakSet(), _LiveObject_applyUpdate = function _LiveObject_applyUpdate(op, isLocal) {
@@ -367,6 +404,7 @@ _LiveObject_map = new WeakMap(), _LiveObject_propToLastUpdate = new WeakMap(), _
             reverse.push({ type: OpType.DeleteObjectKey, id: this._id, key });
         }
     }
+    let updateDelta = {};
     for (const key in op.data) {
         if (isLocal) {
             __classPrivateFieldGet(this, _LiveObject_propToLastUpdate, "f").set(key, op.opId);
@@ -389,12 +427,22 @@ _LiveObject_map = new WeakMap(), _LiveObject_propToLastUpdate = new WeakMap(), _
             oldValue._detach();
         }
         isModified = true;
+        updateDelta[key] = { type: "update" };
         __classPrivateFieldGet(this, _LiveObject_map, "f").set(key, op.data[key]);
     }
     if (Object.keys(reverseUpdate.data).length !== 0) {
         reverse.unshift(reverseUpdate);
     }
-    return isModified ? { modified: this, reverse } : { modified: false };
+    return isModified
+        ? {
+            modified: {
+                node: this,
+                type: "LiveObject",
+                updates: updateDelta,
+            },
+            reverse,
+        }
+        : { modified: false };
 }, _LiveObject_applyDeleteObjectKey = function _LiveObject_applyDeleteObjectKey(op) {
     const key = op.key;
     // If property does not exist, exit without notifying
@@ -422,5 +470,12 @@ _LiveObject_map = new WeakMap(), _LiveObject_propToLastUpdate = new WeakMap(), _
         ];
     }
     __classPrivateFieldGet(this, _LiveObject_map, "f").delete(key);
-    return { modified: this, reverse };
+    return {
+        modified: {
+            node: this,
+            type: "LiveObject",
+            updates: { [op.key]: { type: "delete" } },
+        },
+        reverse,
+    };
 };

package/lib/esm/LiveRegister.d.ts

@@ -20,6 +20,10 @@ export declare class LiveRegister<TValue = any> extends AbstractCrdt {
      */
     _toSerializedCrdt(): SerializedCrdt;
     _attachChild(id: string, key: string, crdt: AbstractCrdt, opId: string, isLocal: boolean): ApplyResult;
-    _detachChild(crdt: AbstractCrdt): void;
+    _detachChild(crdt: AbstractCrdt): ApplyResult;
     _apply(op: Op, isLocal: boolean): ApplyResult;
+    /**
+     * INTERNAL
+     */
+    _getType(): string;
 }

package/lib/esm/LiveRegister.js

@@ -74,5 +74,11 @@ export class LiveRegister extends AbstractCrdt {
     _apply(op, isLocal) {
         return super._apply(op, isLocal);
     }
+    /**
+     * INTERNAL
+     */
+    _getType() {
+        return "LiveRegister";
+    }
 }
 _LiveRegister_data = new WeakMap();

package/lib/esm/immutable.d.ts

@@ -0,0 +1,9 @@
+import { LiveList } from "./LiveList";
+import { LiveObject } from "./LiveObject";
+import { StorageUpdate } from "./types";
+export declare function liveObjectToJson(liveObject: LiveObject<any>): any;
+export declare function liveNodeToJson(value: any): any;
+export declare function patchLiveList<T>(liveList: LiveList<T>, prev: Array<T>, next: Array<T>): void;
+export declare function patchLiveObjectKey<T>(liveObject: LiveObject<T>, key: keyof T, prev: any, next: any): 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;