@liveblocks/client 0.12.0-beta.8 → 0.12.2

package/lib/esm/doc.js

@@ -9,19 +9,23 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _Doc_instances, _Doc_clock, _Doc_items, _Doc_root, _Doc_actor, _Doc_dispatch, _Doc_applyCreateRegister, _Doc_applyDeleteRecordKey, _Doc_applyUpdateRecord, _Doc_applyCreateMap, _Doc_applyCreateList, _Doc_applyCreateObject, _Doc_applyDeleteRecord, _Doc_applySetParentKey, _AbstractCrdt_listeners, _AbstractCrdt_deepListeners, _AbstractCrdt_parent, _AbstractCrdt_doc, _AbstractCrdt_id, _LiveObject_map, _LiveMap_map, _LiveRegister_data, _LiveList_items, _LiveListIterator_innerIterator;
+var _Doc_instances, _Doc_clock, _Doc_opClock, _Doc_items, _Doc_root, _Doc_actor, _Doc_dispatch, _Doc_undoStack, _Doc_redoStack, _Doc_applyOp, _AbstractCrdt_instances, _AbstractCrdt_listeners, _AbstractCrdt_deepListeners, _AbstractCrdt_parent, _AbstractCrdt_doc, _AbstractCrdt_id, _AbstractCrdt_parentKey, _AbstractCrdt_applySetParentKey, _AbstractCrdt_applyRegister, _AbstractCrdt_applyCreateObject, _AbstractCrdt_applyCreateMap, _AbstractCrdt_applyCreateList, _LiveObject_instances, _LiveObject_map, _LiveObject_propToLastUpdate, _LiveObject_applyDeleteObjectKey, _LiveMap_map, _LiveRegister_data, _LiveList_items, _LiveListIterator_innerIterator;
 import { remove } from "./utils";
 import { CrdtType, OpType, } from "./live";
 import { compare, makePosition } from "./position";
 function noOp() { }
+const MAX_UNDO_STACK = 50;
 export class Doc {
     constructor(root, actor = 0, dispatch = noOp) {
         _Doc_instances.add(this);
         _Doc_clock.set(this, 0);
+        _Doc_opClock.set(this, 0);
         _Doc_items.set(this, new Map());
         _Doc_root.set(this, void 0);
         _Doc_actor.set(this, void 0);
         _Doc_dispatch.set(this, void 0);
+        _Doc_undoStack.set(this, []);
+        _Doc_redoStack.set(this, []);
         __classPrivateFieldSet(this, _Doc_root, root, "f");
         __classPrivateFieldSet(this, _Doc_actor, actor, "f");
         __classPrivateFieldSet(this, _Doc_dispatch, dispatch, "f");
@@ -62,6 +66,7 @@ export class Doc {
         return doc;
     }
     dispatch(ops) {
+        __classPrivateFieldSet(this, _Doc_redoStack, [], "f");
         __classPrivateFieldGet(this, _Doc_dispatch, "f").call(this, ops);
     }
     addItem(id, item) {
@@ -73,45 +78,38 @@ export class Doc {
     getItem(id) {
         return __classPrivateFieldGet(this, _Doc_items, "f").get(id);
     }
-    apply(op) {
-        switch (op.type) {
-            case OpType.UpdateObject: {
-                __classPrivateFieldGet(this, _Doc_instances, "m", _Doc_applyUpdateRecord).call(this, op);
-                break;
-            }
-            case OpType.CreateObject: {
-                __classPrivateFieldGet(this, _Doc_instances, "m", _Doc_applyCreateObject).call(this, op);
-                break;
-            }
-            case OpType.CreateMap: {
-                __classPrivateFieldGet(this, _Doc_instances, "m", _Doc_applyCreateMap).call(this, op);
-                break;
-            }
-            case OpType.CreateList: {
-                __classPrivateFieldGet(this, _Doc_instances, "m", _Doc_applyCreateList).call(this, op);
-                break;
-            }
-            case OpType.DeleteCrdt: {
-                __classPrivateFieldGet(this, _Doc_instances, "m", _Doc_applyDeleteRecord).call(this, op);
-                break;
-            }
-            case OpType.SetParentKey: {
-                __classPrivateFieldGet(this, _Doc_instances, "m", _Doc_applySetParentKey).call(this, op);
-                break;
-            }
-            case OpType.DeleteObjectKey: {
-                __classPrivateFieldGet(this, _Doc_instances, "m", _Doc_applyDeleteRecordKey).call(this, op);
-                break;
-            }
-            case OpType.CreateRegister: {
-                __classPrivateFieldGet(this, _Doc_instances, "m", _Doc_applyCreateRegister).call(this, op);
-                break;
-            }
+    apply(ops) {
+        const reverse = [];
+        for (const op of ops) {
+            reverse.push(...__classPrivateFieldGet(this, _Doc_instances, "m", _Doc_applyOp).call(this, op));
         }
+        return reverse;
     }
     get root() {
         return __classPrivateFieldGet(this, _Doc_root, "f");
     }
+    addToUndoStack(ops) {
+        if (__classPrivateFieldGet(this, _Doc_undoStack, "f").length >= MAX_UNDO_STACK) {
+            __classPrivateFieldGet(this, _Doc_undoStack, "f").shift();
+        }
+        __classPrivateFieldGet(this, _Doc_undoStack, "f").push(ops);
+    }
+    undo() {
+        const ops = __classPrivateFieldGet(this, _Doc_undoStack, "f").pop();
+        if (ops == null) {
+            return;
+        }
+        __classPrivateFieldGet(this, _Doc_redoStack, "f").push(this.apply(ops));
+        __classPrivateFieldGet(this, _Doc_dispatch, "f").call(this, ops);
+    }
+    redo() {
+        const ops = __classPrivateFieldGet(this, _Doc_redoStack, "f").pop();
+        if (ops == null) {
+            return;
+        }
+        __classPrivateFieldGet(this, _Doc_undoStack, "f").push(this.apply(ops));
+        __classPrivateFieldGet(this, _Doc_dispatch, "f").call(this, ops);
+    }
     count() {
         return __classPrivateFieldGet(this, _Doc_items, "f").size;
     }
@@ -119,81 +117,47 @@ export class Doc {
         var _a, _b;
         return `${__classPrivateFieldGet(this, _Doc_actor, "f")}:${__classPrivateFieldSet(this, _Doc_clock, (_b = __classPrivateFieldGet(this, _Doc_clock, "f"), _a = _b++, _b), "f"), _a}`;
     }
+    generateOpId() {
+        var _a, _b;
+        return `${__classPrivateFieldGet(this, _Doc_actor, "f")}:${__classPrivateFieldSet(this, _Doc_opClock, (_b = __classPrivateFieldGet(this, _Doc_opClock, "f"), _a = _b++, _b), "f"), _a}`;
+    }
 }
-_Doc_clock = new WeakMap(), _Doc_items = new WeakMap(), _Doc_root = new WeakMap(), _Doc_actor = new WeakMap(), _Doc_dispatch = new WeakMap(), _Doc_instances = new WeakSet(), _Doc_applyCreateRegister = function _Doc_applyCreateRegister(op) {
-    const parent = __classPrivateFieldGet(this, _Doc_items, "f").get(op.parentId);
-    if (parent == null) {
-        return;
-    }
-    if (!(parent instanceof LiveMap) && !(parent instanceof LiveList)) {
-        throw new Error("LiveRegister can only be attached to a LiveMap or LiveList");
-    }
-    const newRegister = new LiveRegister(op.data);
-    parent._attachChild(op.id, op.parentKey, newRegister);
-}, _Doc_applyDeleteRecordKey = function _Doc_applyDeleteRecordKey(op) {
-    const item = __classPrivateFieldGet(this, _Doc_items, "f").get(op.id);
-    if (item && item instanceof LiveObject) {
-        item._apply(op);
-    }
-}, _Doc_applyUpdateRecord = function _Doc_applyUpdateRecord(op) {
-    const item = __classPrivateFieldGet(this, _Doc_items, "f").get(op.id);
-    if (item && item instanceof LiveObject) {
-        item._apply(op);
-    }
-}, _Doc_applyCreateMap = function _Doc_applyCreateMap(op) {
-    const parent = __classPrivateFieldGet(this, _Doc_items, "f").get(op.parentId);
-    if (parent == null) {
-        return;
-    }
-    const newMap = new LiveMap();
-    parent._attachChild(op.id, op.parentKey, newMap);
-}, _Doc_applyCreateList = function _Doc_applyCreateList(op) {
-    const parent = __classPrivateFieldGet(this, _Doc_items, "f").get(op.parentId);
-    if (parent == null) {
-        return;
-    }
-    const list = new LiveList();
-    parent._attachChild(op.id, op.parentKey, list);
-}, _Doc_applyCreateObject = function _Doc_applyCreateObject(op) {
-    if (op.parentId && op.parentKey) {
-        const parent = __classPrivateFieldGet(this, _Doc_items, "f").get(op.parentId);
-        if (parent == null) {
-            return;
+_Doc_clock = new WeakMap(), _Doc_opClock = new WeakMap(), _Doc_items = new WeakMap(), _Doc_root = new WeakMap(), _Doc_actor = new WeakMap(), _Doc_dispatch = new WeakMap(), _Doc_undoStack = new WeakMap(), _Doc_redoStack = new WeakMap(), _Doc_instances = new WeakSet(), _Doc_applyOp = function _Doc_applyOp(op) {
+    switch (op.type) {
+        case OpType.DeleteObjectKey:
+        case OpType.UpdateObject:
+        case OpType.DeleteCrdt:
+        case OpType.SetParentKey: {
+            const item = __classPrivateFieldGet(this, _Doc_items, "f").get(op.id);
+            if (item == null) {
+                return [];
+            }
+            return item._apply(op);
+            break;
+        }
+        case OpType.CreateList:
+        case OpType.CreateObject:
+        case OpType.CreateMap:
+        case OpType.CreateRegister: {
+            const parent = __classPrivateFieldGet(this, _Doc_items, "f").get(op.parentId);
+            if (parent == null) {
+                return [];
+            }
+            return parent._apply(op);
+            break;
         }
-        const newObj = new LiveObject(op.data);
-        parent._attachChild(op.id, op.parentKey, newObj);
-    }
-}, _Doc_applyDeleteRecord = function _Doc_applyDeleteRecord(op) {
-    const item = __classPrivateFieldGet(this, _Doc_items, "f").get(op.id);
-    if (item == null) {
-        return;
-    }
-    const parent = item._parent;
-    if (parent == null) {
-        return;
-    }
-    if (parent) {
-        parent._detachChild(item);
-    }
-}, _Doc_applySetParentKey = function _Doc_applySetParentKey(op) {
-    const item = __classPrivateFieldGet(this, _Doc_items, "f").get(op.id);
-    if (item == null) {
-        return;
-    }
-    if (item._parent == null) {
-        return;
-    }
-    if (item._parent instanceof LiveList) {
-        item._parent._setChildKey(op.parentKey, item);
     }
+    return [];
 };
 class AbstractCrdt {
     constructor() {
+        _AbstractCrdt_instances.add(this);
         _AbstractCrdt_listeners.set(this, []);
         _AbstractCrdt_deepListeners.set(this, []);
         _AbstractCrdt_parent.set(this, void 0);
         _AbstractCrdt_doc.set(this, void 0);
         _AbstractCrdt_id.set(this, void 0);
+        _AbstractCrdt_parentKey.set(this, void 0);
     }
     /**
      * INTERNAL
@@ -216,10 +180,45 @@ class AbstractCrdt {
     /**
      * INTERNAL
      */
-    _setParent(parent) {
-        if (__classPrivateFieldGet(this, _AbstractCrdt_parent, "f")) {
+    get _parentKey() {
+        return __classPrivateFieldGet(this, _AbstractCrdt_parentKey, "f");
+    }
+    _apply(op) {
+        switch (op.type) {
+            case OpType.DeleteCrdt: {
+                if (this._parent != null && this._parentKey != null) {
+                    const reverse = this._serialize(this._parent._id, this._parentKey);
+                    this._parent._detachChild(this);
+                    return reverse;
+                }
+                return [];
+            }
+            case OpType.CreateObject: {
+                return __classPrivateFieldGet(this, _AbstractCrdt_instances, "m", _AbstractCrdt_applyCreateObject).call(this, op);
+            }
+            case OpType.CreateMap: {
+                return __classPrivateFieldGet(this, _AbstractCrdt_instances, "m", _AbstractCrdt_applyCreateMap).call(this, op);
+            }
+            case OpType.CreateRegister: {
+                return __classPrivateFieldGet(this, _AbstractCrdt_instances, "m", _AbstractCrdt_applyRegister).call(this, op);
+            }
+            case OpType.CreateList: {
+                return __classPrivateFieldGet(this, _AbstractCrdt_instances, "m", _AbstractCrdt_applyCreateList).call(this, op);
+            }
+            case OpType.SetParentKey: {
+                return __classPrivateFieldGet(this, _AbstractCrdt_instances, "m", _AbstractCrdt_applySetParentKey).call(this, op);
+            }
+        }
+        return [];
+    }
+    /**
+     * INTERNAL
+     */
+    _setParentLink(parent, key) {
+        if (__classPrivateFieldGet(this, _AbstractCrdt_parent, "f") != null && __classPrivateFieldGet(this, _AbstractCrdt_parent, "f") !== parent) {
             throw new Error("Cannot attach parent if it already exist");
         }
+        __classPrivateFieldSet(this, _AbstractCrdt_parentKey, key, "f");
         __classPrivateFieldSet(this, _AbstractCrdt_parent, parent, "f");
     }
     /**
@@ -243,19 +242,34 @@ class AbstractCrdt {
         __classPrivateFieldSet(this, _AbstractCrdt_parent, undefined, "f");
         __classPrivateFieldSet(this, _AbstractCrdt_doc, undefined, "f");
     }
+    /**
+     * Subscribes to updates.
+     */
     subscribe(listener) {
         __classPrivateFieldGet(this, _AbstractCrdt_listeners, "f").push(listener);
     }
+    /**
+     * Subscribes to updates and children updates.
+     */
     subscribeDeep(listener) {
         __classPrivateFieldGet(this, _AbstractCrdt_deepListeners, "f").push(listener);
     }
+    /**
+     * Unsubscribes to updates.
+     */
     unsubscribe(listener) {
         remove(__classPrivateFieldGet(this, _AbstractCrdt_listeners, "f"), listener);
     }
+    /**
+     * Unsubscribes to updates and children updates.
+     */
     unsubscribeDeep(listener) {
         remove(__classPrivateFieldGet(this, _AbstractCrdt_deepListeners, "f"), listener);
     }
-    notify(onlyDeep = false) {
+    /**
+     * INTERNAL
+     */
+    _notify(onlyDeep = false) {
         if (onlyDeep === false) {
             for (const listener of __classPrivateFieldGet(this, _AbstractCrdt_listeners, "f")) {
                 listener();
@@ -265,19 +279,70 @@ class AbstractCrdt {
             listener();
         }
         if (this._parent) {
-            this._parent.notify(true);
+            this._parent._notify(true);
         }
     }
 }
-_AbstractCrdt_listeners = new WeakMap(), _AbstractCrdt_deepListeners = new WeakMap(), _AbstractCrdt_parent = new WeakMap(), _AbstractCrdt_doc = new WeakMap(), _AbstractCrdt_id = new WeakMap();
+_AbstractCrdt_listeners = new WeakMap(), _AbstractCrdt_deepListeners = new WeakMap(), _AbstractCrdt_parent = new WeakMap(), _AbstractCrdt_doc = new WeakMap(), _AbstractCrdt_id = new WeakMap(), _AbstractCrdt_parentKey = new WeakMap(), _AbstractCrdt_instances = new WeakSet(), _AbstractCrdt_applySetParentKey = function _AbstractCrdt_applySetParentKey(op) {
+    if (this._parent == null) {
+        return [];
+    }
+    if (this._parent instanceof LiveList) {
+        const previousKey = this._parentKey;
+        this._parent._setChildKey(op.parentKey, this);
+        return [
+            { type: OpType.SetParentKey, id: this._id, parentKey: previousKey },
+        ];
+    }
+    return [];
+}, _AbstractCrdt_applyRegister = function _AbstractCrdt_applyRegister(op) {
+    if (this._doc == null) {
+        throw new Error("Internal: doc should exist");
+    }
+    if (this._doc.getItem(op.id) != null) {
+        return [];
+    }
+    return this._attachChild(op.id, op.parentKey, new LiveRegister(op.data));
+}, _AbstractCrdt_applyCreateObject = function _AbstractCrdt_applyCreateObject(op) {
+    if (this._doc == null) {
+        throw new Error("Internal: doc should exist");
+    }
+    if (this._doc.getItem(op.id) != null) {
+        return [];
+    }
+    return this._attachChild(op.id, op.parentKey, new LiveObject(op.data));
+}, _AbstractCrdt_applyCreateMap = function _AbstractCrdt_applyCreateMap(op) {
+    if (this._doc == null) {
+        throw new Error("Internal: doc should exist");
+    }
+    if (this._doc.getItem(op.id) != null) {
+        return [];
+    }
+    return this._attachChild(op.id, op.parentKey, new LiveMap());
+}, _AbstractCrdt_applyCreateList = function _AbstractCrdt_applyCreateList(op) {
+    if (this._doc == null) {
+        throw new Error("Internal: doc should exist");
+    }
+    if (this._doc.getItem(op.id) != null) {
+        return [];
+    }
+    return this._attachChild(op.id, op.parentKey, new LiveList());
+};
+/**
+ * The LiveObject class is similar to a JavaScript object that is synchronized on all clients.
+ * Keys should be a string, and values should be serializable to JSON.
+ * If multiple clients update the same property simultaneously, the last modification received by the Liveblocks servers is the winner.
+ */
 export class LiveObject extends AbstractCrdt {
     constructor(object = {}) {
         super();
+        _LiveObject_instances.add(this);
         _LiveObject_map.set(this, void 0);
+        _LiveObject_propToLastUpdate.set(this, new Map());
         for (const key in object) {
             const value = object[key];
             if (value instanceof AbstractCrdt) {
-                value._setParent(this);
+                value._setParentLink(this, key);
             }
         }
         __classPrivateFieldSet(this, _LiveObject_map, new Map(Object.entries(object)), "f");
@@ -295,7 +360,7 @@ export class LiveObject extends AbstractCrdt {
             type: OpType.CreateObject,
             parentId,
             parentKey,
-            data: {}
+            data: {},
         };
         ops.push(op);
         for (const [key, value] of __classPrivateFieldGet(this, _LiveObject_map, "f")) {
@@ -327,7 +392,7 @@ export class LiveObject extends AbstractCrdt {
                 throw new Error("Tried to deserialize a crdt but it does not have a parentKey and is not the root");
             }
             const child = deserialize(entry, parentToChildren, doc);
-            child._setParent(object);
+            child._setParentLink(object, crdt.parentKey);
             __classPrivateFieldGet(object, _LiveObject_map, "f").set(crdt.parentKey, child);
         }
         return object;
@@ -351,13 +416,30 @@ export class LiveObject extends AbstractCrdt {
             throw new Error("Can't attach child if doc is not present");
         }
         const previousValue = __classPrivateFieldGet(this, _LiveObject_map, "f").get(key);
+        let result;
         if (isCrdt(previousValue)) {
+            result = previousValue._serialize(this._id, key);
             previousValue._detach();
         }
+        else if (previousValue === undefined) {
+            result = [
+                { type: OpType.DeleteObjectKey, id: this._id, key: key },
+            ];
+        }
+        else {
+            result = [
+                {
+                    type: OpType.UpdateObject,
+                    id: this._id,
+                    data: { [key]: previousValue },
+                },
+            ];
+        }
         __classPrivateFieldGet(this, _LiveObject_map, "f").set(key, child);
-        child._setParent(this);
+        child._setParentLink(this, key);
         child._attach(id, this._doc);
-        this.notify();
+        this._notify();
+        return result;
     }
     /**
      * INTERNAL
@@ -371,7 +453,7 @@ export class LiveObject extends AbstractCrdt {
         if (child) {
             child._detach();
         }
-        this.notify();
+        this._notify();
     }
     /**
      * INTERNAL
@@ -388,8 +470,36 @@ export class LiveObject extends AbstractCrdt {
      * INTERNAL
      */
     _apply(op) {
+        var _a;
         if (op.type === OpType.UpdateObject) {
+            const reverse = [];
+            const reverseUpdate = {
+                type: OpType.UpdateObject,
+                id: this._id,
+                data: {},
+            };
+            reverse.push(reverseUpdate);
+            for (const key in op.data) {
+                const oldValue = __classPrivateFieldGet(this, _LiveObject_map, "f").get(key);
+                if (oldValue !== undefined) {
+                    reverseUpdate.data[key] = oldValue;
+                }
+                else if (oldValue === undefined) {
+                    reverse.push({ type: OpType.DeleteObjectKey, id: this._id, key });
+                }
+            }
             for (const key in op.data) {
+                if (op.opId == null) {
+                    op.opId = (_a = this._doc) === null || _a === void 0 ? void 0 : _a.generateOpId();
+                }
+                const lastOpId = __classPrivateFieldGet(this, _LiveObject_propToLastUpdate, "f").get(key);
+                if (lastOpId === op.opId) {
+                    __classPrivateFieldGet(this, _LiveObject_propToLastUpdate, "f").delete(key);
+                    continue;
+                }
+                else if (lastOpId != null) {
+                    continue;
+                }
                 const oldValue = __classPrivateFieldGet(this, _LiveObject_map, "f").get(key);
                 if (isCrdt(oldValue)) {
                     oldValue._detach();
@@ -397,85 +507,127 @@ export class LiveObject extends AbstractCrdt {
                 const value = op.data[key];
                 __classPrivateFieldGet(this, _LiveObject_map, "f").set(key, value);
             }
-            this.notify();
+            this._notify();
+            return reverse;
         }
         else if (op.type === OpType.DeleteObjectKey) {
-            const key = op.key;
-            const oldValue = __classPrivateFieldGet(this, _LiveObject_map, "f").get(key);
-            if (isCrdt(oldValue)) {
-                oldValue._detach();
-            }
-            __classPrivateFieldGet(this, _LiveObject_map, "f").delete(key);
-            this.notify();
+            return __classPrivateFieldGet(this, _LiveObject_instances, "m", _LiveObject_applyDeleteObjectKey).call(this, op);
         }
+        return super._apply(op);
     }
+    /**
+     * Transform the LiveObject into a javascript object
+     */
     toObject() {
         return Object.fromEntries(__classPrivateFieldGet(this, _LiveObject_map, "f"));
     }
+    /**
+     * Adds or updates a property with a specified key and a value.
+     * @param key The key of the property to add
+     * @param value The value of the property to add
+     */
     set(key, value) {
         // TODO: Find out why typescript complains
         this.update({ [key]: value });
     }
+    /**
+     * Returns a specified property from the LiveObject.
+     * @param key The key of the property to get
+     */
     get(key) {
         return __classPrivateFieldGet(this, _LiveObject_map, "f").get(key);
     }
-    // delete<TKey extends keyof T>(key: TKey) {
-    //   if (this.doc && this.id) {
-    //     const item = this._map.get(key as string);
-    //     if (isCrdt(item)) {
-    //       item.detach();
-    //     }
-    //     this.doc.dispatch([
-    //       { type: OpType.DeleteObjectKey, id: this.id, key: key as string },
-    //     ]);
-    //   }
-    //   this._map.delete(key as string);
-    //   this.notify();
-    // }
+    /**
+     * Adds or updates multiple properties at once with an object.
+     * @param overrides The object used to overrides properties
+     */
     update(overrides) {
-        if (this._doc && this._id) {
-            const ops = [];
-            const updateOp = {
-                id: this._id,
-                type: OpType.UpdateObject,
-                data: {}
-            };
-            ops.push(updateOp);
+        if (this._doc == null || this._id == null) {
             for (const key in overrides) {
                 const oldValue = __classPrivateFieldGet(this, _LiveObject_map, "f").get(key);
-                if (oldValue instanceof LiveObject) {
+                if (oldValue instanceof AbstractCrdt) {
                     oldValue._detach();
                 }
                 const newValue = overrides[key];
                 if (newValue instanceof AbstractCrdt) {
-                    newValue._setParent(this);
-                    newValue._attach(this._doc.generateId(), this._doc);
-                    ops.push(...newValue._serialize(this._id, key));
-                }
-                else {
-                    updateOp.data[key] = newValue;
+                    newValue._setParentLink(this, key);
                 }
                 __classPrivateFieldGet(this, _LiveObject_map, "f").set(key, newValue);
             }
-            this._doc.dispatch(ops);
-            this.notify();
+            this._notify();
             return;
         }
+        const ops = [];
+        const reverseOps = [];
+        const opId = this._doc.generateOpId();
+        const updateOp = {
+            opId,
+            id: this._id,
+            type: OpType.UpdateObject,
+            data: {},
+        };
+        ops.push(updateOp);
+        const reverseUpdateOp = {
+            id: this._id,
+            type: OpType.UpdateObject,
+            data: {},
+        };
+        reverseOps.push(reverseUpdateOp);
         for (const key in overrides) {
+            __classPrivateFieldGet(this, _LiveObject_propToLastUpdate, "f").set(key, opId);
             const oldValue = __classPrivateFieldGet(this, _LiveObject_map, "f").get(key);
             if (oldValue instanceof AbstractCrdt) {
+                reverseOps.push(...oldValue._serialize(this._id, key));
                 oldValue._detach();
             }
+            else if (oldValue === undefined) {
+                reverseOps.push({ type: OpType.DeleteObjectKey, id: this._id, key });
+            }
+            else {
+                reverseUpdateOp.data[key] = oldValue;
+            }
             const newValue = overrides[key];
             if (newValue instanceof AbstractCrdt) {
-                newValue._setParent(this);
+                newValue._setParentLink(this, key);
+                newValue._attach(this._doc.generateId(), this._doc);
+                ops.push(...newValue._serialize(this._id, key));
+            }
+            else {
+                updateOp.data[key] = newValue;
             }
             __classPrivateFieldGet(this, _LiveObject_map, "f").set(key, newValue);
         }
-        this.notify();
+        this._doc.addToUndoStack(reverseOps);
+        this._doc.dispatch(ops);
+        this._notify();
     }
 }
-_LiveObject_map = new WeakMap();
+_LiveObject_map = new WeakMap(), _LiveObject_propToLastUpdate = new WeakMap(), _LiveObject_instances = new WeakSet(), _LiveObject_applyDeleteObjectKey = function _LiveObject_applyDeleteObjectKey(op) {
+    const key = op.key;
+    const oldValue = __classPrivateFieldGet(this, _LiveObject_map, "f").get(key);
+    let result = [];
+    if (isCrdt(oldValue)) {
+        result = oldValue._serialize(this._id, op.key);
+        oldValue._detach();
+    }
+    else if (oldValue !== undefined) {
+        result = [
+            {
+                type: OpType.UpdateObject,
+                id: this._id,
+                data: { [key]: oldValue },
+            },
+        ];
+    }
+    __classPrivateFieldGet(this, _LiveObject_map, "f").delete(key);
+    this._notify();
+    return result;
+};
+/**
+ * The LiveMap class is similar to a JavaScript Map that is synchronized on all clients.
+ * Keys should be a string, and values should be serializable to JSON.
+ * If multiple clients update the same property simultaneously, the last modification received by the Liveblocks servers is the winner.
+ */
 export class LiveMap extends AbstractCrdt {
     constructor(entries) {
         super();
@@ -484,7 +636,7 @@ export class LiveMap extends AbstractCrdt {
             const mappedEntries = [];
             for (const entry of entries) {
                 const value = selfOrRegister(entry[1]);
-                value._setParent(this);
+                value._setParentLink(this, entry[0]);
                 mappedEntries.push([entry[0], value]);
             }
             __classPrivateFieldSet(this, _LiveMap_map, new Map(mappedEntries), "f");
@@ -535,7 +687,7 @@ export class LiveMap extends AbstractCrdt {
                 throw new Error("Tried to deserialize a crdt but it does not have a parentKey and is not the root");
             }
             const child = deserialize(entry, parentToChildren, doc);
-            child._setParent(map);
+            child._setParentLink(map, crdt.parentKey);
             __classPrivateFieldGet(map, _LiveMap_map, "f").set(crdt.parentKey, child);
         }
         return map;
@@ -559,13 +711,19 @@ export class LiveMap extends AbstractCrdt {
             throw new Error("Can't attach child if doc is not present");
         }
         const previousValue = __classPrivateFieldGet(this, _LiveMap_map, "f").get(key);
+        let result;
         if (previousValue) {
+            result = previousValue._serialize(this._id, key);
             previousValue._detach();
         }
-        child._setParent(this);
+        else {
+            result = [{ type: OpType.DeleteCrdt, id }];
+        }
+        child._setParentLink(this, key);
         child._attach(id, this._doc);
         __classPrivateFieldGet(this, _LiveMap_map, "f").set(key, child);
-        this.notify();
+        this._notify();
+        return result;
     }
     /**
      * INTERNAL
@@ -586,8 +744,13 @@ export class LiveMap extends AbstractCrdt {
             }
         }
         child._detach();
-        this.notify();
+        this._notify();
     }
+    /**
+     * Returns a specified element from the LiveMap.
+     * @param key The key of the element to return.
+     * @returns The element associated with the specified key, or undefined if the key can't be found in the LiveMap.
+     */
     get(key) {
         const value = __classPrivateFieldGet(this, _LiveMap_map, "f").get(key);
         if (value == undefined) {
@@ -595,27 +758,47 @@ export class LiveMap extends AbstractCrdt {
         }
         return selfOrRegisterValue(value);
     }
+    /**
+     * Adds or updates an element with a specified key and a value.
+     * @param key The key of the element to add. Should be a string.
+     * @param value The value of the element to add. Should be serializable to JSON.
+     */
     set(key, value) {
         const oldValue = __classPrivateFieldGet(this, _LiveMap_map, "f").get(key);
         if (oldValue) {
             oldValue._detach();
         }
         const item = selfOrRegister(value);
-        item._setParent(this);
+        item._setParentLink(this, key);
         __classPrivateFieldGet(this, _LiveMap_map, "f").set(key, item);
         if (this._doc && this._id) {
-            item._attach(this._doc.generateId(), this._doc);
-            const ops = item._serialize(this._id, key);
-            this._doc.dispatch(ops);
+            const id = this._doc.generateId();
+            item._attach(id, this._doc);
+            this._doc.addToUndoStack(oldValue
+                ? oldValue._serialize(this._id, key)
+                : [{ type: OpType.DeleteCrdt, id }]);
+            this._doc.dispatch(item._serialize(this._id, key));
         }
-        this.notify();
+        this._notify();
     }
+    /**
+     * Returns the number of elements in the LiveMap.
+     */
     get size() {
         return __classPrivateFieldGet(this, _LiveMap_map, "f").size;
     }
+    /**
+     * Returns a boolean indicating whether an element with the specified key exists or not.
+     * @param key The key of the element to test for presence.
+     */
     has(key) {
         return __classPrivateFieldGet(this, _LiveMap_map, "f").has(key);
     }
+    /**
+     * Removes the specified element by key.
+     * @param key The key of the element to remove.
+     * @returns true if an element existed and has been removed, or false if the element does not exist.
+     */
     delete(key) {
         const item = __classPrivateFieldGet(this, _LiveMap_map, "f").get(key);
         if (item == null) {
@@ -623,12 +806,16 @@ export class LiveMap extends AbstractCrdt {
         }
         item._detach();
         if (this._doc && item._id) {
+            this._doc.addToUndoStack(item._serialize(this._id, key));
             this._doc.dispatch([{ type: OpType.DeleteCrdt, id: item._id }]);
         }
         __classPrivateFieldGet(this, _LiveMap_map, "f").delete(key);
-        this.notify();
+        this._notify();
         return true;
     }
+    /**
+     * Returns a new Iterator object that contains the [key, value] pairs for each element.
+     */
     entries() {
         const innerIterator = __classPrivateFieldGet(this, _LiveMap_map, "f").entries();
         return {
@@ -650,12 +837,21 @@ export class LiveMap extends AbstractCrdt {
             },
         };
     }
+    /**
+     * Same function object as the initial value of the entries method.
+     */
     [(_LiveMap_map = new WeakMap(), Symbol.iterator)]() {
         return this.entries();
     }
+    /**
+     * Returns a new Iterator object that contains the keys for each element.
+     */
     keys() {
         return __classPrivateFieldGet(this, _LiveMap_map, "f").keys();
     }
+    /**
+     * Returns a new Iterator object that contains the values for each element.
+     */
     values() {
         const innerIterator = __classPrivateFieldGet(this, _LiveMap_map, "f").values();
         return {
@@ -676,12 +872,19 @@ export class LiveMap extends AbstractCrdt {
             },
         };
     }
+    /**
+     * Executes a provided function once per each key/value pair in the Map object, in insertion order.
+     * @param callback Function to execute for each entry in the map.
+     */
     forEach(callback) {
         for (const entry of this) {
             callback(entry[1], entry[0], this);
         }
     }
 }
+/**
+ * INTERNAL
+ */
 class LiveRegister extends AbstractCrdt {
     constructor(data) {
         super();
@@ -709,13 +912,15 @@ class LiveRegister extends AbstractCrdt {
         if (this._id == null || parentId == null || parentKey == null) {
             throw new Error("Cannot serialize register if parentId or parentKey is undefined");
         }
-        return [{
+        return [
+            {
                 type: OpType.CreateRegister,
                 id: this._id,
                 parentId,
                 parentKey,
-                data: this.data
-            }];
+                data: this.data,
+            },
+        ];
     }
     _attachChild(id, key, crdt) {
         throw new Error("Method not implemented.");
@@ -723,12 +928,18 @@ class LiveRegister extends AbstractCrdt {
     _detachChild(crdt) {
         throw new Error("Method not implemented.");
     }
+    _apply(op) {
+        return super._apply(op);
+    }
 }
 _LiveRegister_data = new WeakMap();
+/**
+ * The LiveList class represents an ordered collection of items that is synchorinized across clients.
+ */
 export class LiveList extends AbstractCrdt {
     constructor(items = []) {
         super();
-        // TODO: Naive array at first, find a better data structure
+        // TODO: Naive array at first, find a better data structure. Maybe an Order statistics tree?
         _LiveList_items.set(this, []);
         let position = undefined;
         for (let i = 0; i < items.length; i++) {
@@ -750,9 +961,9 @@ export class LiveList extends AbstractCrdt {
         }
         for (const entry of children) {
             const child = deserialize(entry, parentToChildren, doc);
-            child._setParent(list);
+            child._setParentLink(list, entry[1].parentKey);
             __classPrivateFieldGet(list, _LiveList_items, "f").push([child, entry[1].parentKey]);
-            __classPrivateFieldGet(list, _LiveList_items, "f").sort((itemA, itemB) => compare({ position: itemA[1] }, { position: itemB[1] }));
+            __classPrivateFieldGet(list, _LiveList_items, "f").sort((itemA, itemB) => compare(itemA[1], itemB[1]));
         }
         return list;
     }
@@ -801,15 +1012,21 @@ export class LiveList extends AbstractCrdt {
      * INTERNAL
      */
     _attachChild(id, key, child) {
+        var _a;
         if (this._doc == null) {
             throw new Error("Can't attach child if doc is not present");
         }
         child._attach(id, this._doc);
-        child._setParent(this);
-        // TODO: Handle list conflict
+        child._setParentLink(this, key);
+        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) {
+            __classPrivateFieldGet(this, _LiveList_items, "f")[index][1] = makePosition(key, (_a = __classPrivateFieldGet(this, _LiveList_items, "f")[index + 1]) === null || _a === void 0 ? void 0 : _a[1]);
+        }
         __classPrivateFieldGet(this, _LiveList_items, "f").push([child, key]);
-        __classPrivateFieldGet(this, _LiveList_items, "f").sort((itemA, itemB) => compare({ position: itemA[1] }, { position: itemB[1] }));
-        this.notify();
+        __classPrivateFieldGet(this, _LiveList_items, "f").sort((itemA, itemB) => compare(itemA[1], itemB[1]));
+        this._notify();
+        return [{ type: OpType.DeleteCrdt, id }];
     }
     /**
      * INTERNAL
@@ -820,49 +1037,74 @@ export class LiveList extends AbstractCrdt {
         if (child) {
             child._detach();
         }
-        this.notify();
+        this._notify();
     }
     /**
      * INTERNAL
      */
     _setChildKey(key, child) {
+        var _a;
+        child._setParentLink(this, key);
+        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) {
+            __classPrivateFieldGet(this, _LiveList_items, "f")[index][1] = makePosition(key, (_a = __classPrivateFieldGet(this, _LiveList_items, "f")[index + 1]) === null || _a === void 0 ? void 0 : _a[1]);
+        }
         const item = __classPrivateFieldGet(this, _LiveList_items, "f").find((item) => item[0] === child);
         if (item) {
             item[1] = key;
         }
-        __classPrivateFieldGet(this, _LiveList_items, "f").sort((itemA, itemB) => compare({ position: itemA[1] }, { position: itemB[1] }));
-        this.notify();
+        __classPrivateFieldGet(this, _LiveList_items, "f").sort((itemA, itemB) => compare(itemA[1], itemB[1]));
+        this._notify();
     }
-    push(item) {
-        const position = __classPrivateFieldGet(this, _LiveList_items, "f").length === 0
-            ? makePosition()
-            : makePosition(__classPrivateFieldGet(this, _LiveList_items, "f")[__classPrivateFieldGet(this, _LiveList_items, "f").length - 1][1]);
-        const value = selfOrRegister(item);
-        value._setParent(this);
-        __classPrivateFieldGet(this, _LiveList_items, "f").push([value, position]);
-        this.notify();
-        if (this._doc && this._id) {
-            value._attach(this._doc.generateId(), this._doc);
-            this._doc.dispatch(value._serialize(this._id, position));
-        }
+    /**
+     * INTERNAL
+     */
+    _apply(op) {
+        return super._apply(op);
+    }
+    /**
+     * Returns the number of elements.
+     */
+    get length() {
+        return __classPrivateFieldGet(this, _LiveList_items, "f").length;
+    }
+    /**
+     * Adds one element to the end of the LiveList.
+     * @param element The element to add to the end of the LiveList.
+     */
+    push(element) {
+        return this.insert(element, this.length);
     }
-    insert(item, index) {
+    /**
+     * Inserts one element at a specified index.
+     * @param element The element to insert.
+     * @param index The index at which you want to insert the element.
+     */
+    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}`);
         }
         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;
         const position = makePosition(before, after);
-        const value = selfOrRegister(item);
-        value._setParent(this);
+        const value = selfOrRegister(element);
+        value._setParentLink(this, position);
         __classPrivateFieldGet(this, _LiveList_items, "f").push([value, position]);
-        __classPrivateFieldGet(this, _LiveList_items, "f").sort((itemA, itemB) => compare({ position: itemA[1] }, { position: itemB[1] }));
-        this.notify();
+        __classPrivateFieldGet(this, _LiveList_items, "f").sort((itemA, itemB) => compare(itemA[1], itemB[1]));
+        this._notify();
         if (this._doc && this._id) {
-            value._attach(this._doc.generateId(), this._doc);
+            const id = this._doc.generateId();
+            value._attach(id, this._doc);
+            this._doc.addToUndoStack([{ type: OpType.DeleteCrdt, id }]);
             this._doc.dispatch(value._serialize(this._id, position));
         }
     }
+    /**
+     * Move one element from one index to another.
+     * @param index The index of the element to move
+     * @param targetIndex The index where the element should be after moving.
+     */
     move(index, targetIndex) {
         if (targetIndex < 0) {
             throw new Error("targetIndex cannot be less than 0");
@@ -892,17 +1134,32 @@ export class LiveList extends AbstractCrdt {
         }
         const position = makePosition(beforePosition, afterPosition);
         const item = __classPrivateFieldGet(this, _LiveList_items, "f")[index];
+        const previousPosition = item[1];
         item[1] = position;
-        __classPrivateFieldGet(this, _LiveList_items, "f").sort((itemA, itemB) => compare({ position: itemA[1] }, { position: itemB[1] }));
-        this.notify();
+        item[0]._setParentLink(this, position);
+        __classPrivateFieldGet(this, _LiveList_items, "f").sort((itemA, itemB) => compare(itemA[1], itemB[1]));
+        this._notify();
         if (this._doc && this._id) {
-            this._doc.dispatch([{
+            this._doc.addToUndoStack([
+                {
+                    type: OpType.SetParentKey,
+                    id: item[0]._id,
+                    parentKey: previousPosition,
+                },
+            ]);
+            this._doc.dispatch([
+                {
                     type: OpType.SetParentKey,
                     id: item[0]._id,
                     parentKey: position,
-                },]);
+                },
+            ]);
         }
     }
+    /**
+     * Deletes an element at the specified index
+     * @param index The index of the element to delete
+     */
     delete(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 - 1}`);
@@ -913,6 +1170,7 @@ export class LiveList extends AbstractCrdt {
         if (this._doc) {
             const childRecordId = item[0]._id;
             if (childRecordId) {
+                this._doc.addToUndoStack(item[0]._serialize(this._id, item[1]));
                 this._doc.dispatch([
                     {
                         id: childRecordId,
@@ -921,38 +1179,95 @@ export class LiveList extends AbstractCrdt {
                 ]);
             }
         }
-        this.notify();
+        this._notify();
     }
+    /**
+     * Returns an Array of all the elements in the LiveList.
+     */
     toArray() {
         return __classPrivateFieldGet(this, _LiveList_items, "f").map((entry) => selfOrRegisterValue(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).
+     * @returns true if the predicate function returns a truthy value for every element. Otherwise, false.
+     */
     every(predicate) {
         return this.toArray().every(predicate);
     }
+    /**
+     * Creates an array with all elements that pass the test implemented by the provided function.
+     * @param predicate Function to test each element of the LiveList. Return a value that coerces to true to keep the element, or to false otherwise.
+     * @returns An array with the elements that pass the test.
+     */
     filter(predicate) {
         return this.toArray().filter(predicate);
     }
+    /**
+     * Returns the first element that satisfies the provided testing function.
+     * @param predicate Function to execute on each value.
+     * @returns The value of the first element in the LiveList that satisfies the provided testing function. Otherwise, undefined is returned.
+     */
     find(predicate) {
         return this.toArray().find(predicate);
     }
+    /**
+     * Returns the index of the first element in the LiveList that satisfies the provided testing function.
+     * @param predicate Function to execute on each value until the function returns true, indicating that the satisfying element was found.
+     * @returns The index of the first element in the LiveList that passes the test. Otherwise, -1.
+     */
     findIndex(predicate) {
         return this.toArray().findIndex(predicate);
     }
+    /**
+     * Executes a provided function once for each element.
+     * @param callbackfn Function to execute on each element.
+     */
     forEach(callbackfn) {
         return this.toArray().forEach(callbackfn);
     }
+    /**
+     * Get the element at the specified index.
+     * @param index The index on the element to get.
+     * @returns The element at the specified index or undefined.
+     */
     get(index) {
+        if (index < 0 || index >= __classPrivateFieldGet(this, _LiveList_items, "f").length) {
+            return undefined;
+        }
         return selfOrRegisterValue(__classPrivateFieldGet(this, _LiveList_items, "f")[index][0]);
     }
+    /**
+     * Returns the first index at which a given element can be found in the LiveList, or -1 if it is not present.
+     * @param searchElement Element to locate.
+     * @param fromIndex The index to start the search at.
+     * @returns The first index of the element in the LiveList; -1 if not found.
+     */
     indexOf(searchElement, fromIndex) {
         return this.toArray().indexOf(searchElement, fromIndex);
     }
+    /**
+     * Returns the last index at which a given element can be found in the LiveList, or -1 if it is not present. The LiveLsit is searched backwards, starting at fromIndex.
+     * @param searchElement Element to locate.
+     * @param fromIndex The index at which to start searching backwards.
+     * @returns
+     */
     lastIndexOf(searchElement, fromIndex) {
         return this.toArray().lastIndexOf(searchElement, fromIndex);
     }
+    /**
+     * Creates an array populated with the results of calling a provided function on every element.
+     * @param callback Function that is called for every element.
+     * @returns An array with each element being the result of the callback function.
+     */
     map(callback) {
         return __classPrivateFieldGet(this, _LiveList_items, "f").map((entry, i) => callback(selfOrRegisterValue(entry[0]), i));
     }
+    /**
+     * Tests whether at least one element in the LiveList passes the test implemented by the provided function.
+     * @param predicate Function to test for each element.
+     * @returns true if the callback function returns a truthy value for at least one element. Otherwise, false.
+     */
     some(predicate) {
         return this.toArray().some(predicate);
     }