@liveblocks/client 0.14.0 → 0.15.0-alpha.1

package/lib/esm/LiveList.js

@@ -72,6 +72,9 @@ export class LiveList extends AbstractCrdt {
         }
         return ops;
     }
+    _indexOfPosition(position) {
+        return __classPrivateFieldGet(this, _LiveList_items, "f").findIndex((item) => item[1] === position);
+    }
     /**
      * INTERNAL
      */
@@ -120,22 +123,38 @@ 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" }],
+            },
+        };
     }
     /**
      * 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 = this._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 index = __classPrivateFieldGet(this, _LiveList_items, "f").findIndex((entry) => entry[1] === key);
@@ -148,6 +167,21 @@ export class LiveList extends AbstractCrdt {
             item[1] = key;
         }
         __classPrivateFieldGet(this, _LiveList_items, "f").sort((itemA, itemB) => compare(itemA[1], itemB[1]));
+        const newIndex = this._indexOfPosition(key);
+        return {
+            modified: {
+                node: this,
+                type: "LiveList",
+                updates: [{ index: newIndex, type: "insert" }],
+            },
+            reverse: [
+                {
+                    type: OpType.SetParentKey,
+                    id: item === null || item === void 0 ? void 0 : item[0]._id,
+                    parentKey: previousKey,
+                },
+            ],
+        };
     }
     /**
      * INTERNAL
@@ -155,6 +189,12 @@ export class LiveList extends AbstractCrdt {
     _apply(op, isLocal) {
         return super._apply(op, isLocal);
     }
+    /**
+     * INTERNAL
+     */
+    _getType() {
+        return "LiveList";
+    }
     /**
      * INTERNAL
      */
@@ -195,10 +235,17 @@ 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, type: "insert" }],
+            });
+            this._doc.dispatch(value._serialize(this._id, position, this._doc), [{ type: OpType.DeleteCrdt, id }], storageUpdates);
         }
     }
     /**
@@ -239,7 +286,17 @@ 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: index, type: "delete" },
+                    { index: newIndex, type: "insert" },
+                ],
+            });
             this._doc.dispatch([
                 {
                     type: OpType.SetParentKey,
@@ -253,7 +310,7 @@ export class LiveList extends AbstractCrdt {
                     id: item[0]._id,
                     parentKey: previousPosition,
                 },
-            ], [this]);
+            ], storageUpdates);
         }
     }
     /**
@@ -270,13 +327,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);
             }
         }
     }
@@ -284,16 +347,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")) {
@@ -308,6 +381,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

@@ -113,7 +113,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
@@ -128,12 +135,25 @@ export class LiveMap extends AbstractCrdt {
      * INTERNAL
      */
     _detachChild(child) {
+        const reverse = this._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
@@ -174,9 +194,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);
         }
     }
     /**
@@ -204,13 +230,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

@@ -130,20 +130,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 = this._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
@@ -189,6 +206,12 @@ export class LiveObject extends AbstractCrdt {
             data: this.toObject(),
         };
     }
+    /**
+     * INTERNAL
+     */
+    _getType() {
+        return "LiveObject";
+    }
     /**
      * Transform the LiveObject into a javascript object
      */
@@ -243,6 +266,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,
@@ -250,7 +279,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.
@@ -280,6 +309,7 @@ export class LiveObject extends AbstractCrdt {
             type: OpType.UpdateObject,
             data: {},
         };
+        const updateDelta = {};
         for (const key in overrides) {
             __classPrivateFieldGet(this, _LiveObject_propToLastUpdate, "f").set(key, opId);
             const oldValue = __classPrivateFieldGet(this, _LiveObject_map, "f").get(key);
@@ -303,6 +333,7 @@ export class LiveObject extends AbstractCrdt {
                 updatedProps[key] = newValue;
             }
             __classPrivateFieldGet(this, _LiveObject_map, "f").set(key, newValue);
+            updateDelta[key] = { type: "update" };
         }
         if (Object.keys(reverseUpdateOp.data).length !== 0) {
             reverseOps.unshift(reverseUpdateOp);
@@ -315,7 +346,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) {
@@ -340,6 +377,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);
@@ -362,12 +400,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
@@ -390,5 +438,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, 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;