@liveblocks/client 0.13.2 → 0.15.0-alpha.1

package/lib/esm/AbstractCrdt.d.ts

@@ -1,7 +1,8 @@
-import { Op } from "./live";
+import { Op, SerializedCrdt } from "./live";
+import { StorageUpdate } from "./types";
 export declare type ApplyResult = {
     reverse: Op[];
-    modified: AbstractCrdt;
+    modified: StorageUpdate;
 } | {
     modified: false;
 };
@@ -10,7 +11,7 @@ export interface Doc {
     generateOpId: () => string;
     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;
@@ -33,7 +34,7 @@ export declare abstract class AbstractCrdt {
     /**
      * INTERNAL
      */
-    _apply(op: Op): ApplyResult;
+    _apply(op: Op, isLocal: boolean): ApplyResult;
     /**
      * INTERNAL
      */
@@ -45,7 +46,7 @@ export declare abstract class AbstractCrdt {
     /**
      * INTERNAL
      */
-    abstract _attachChild(id: string, key: string, crdt: AbstractCrdt): ApplyResult;
+    abstract _attachChild(id: string, key: string, crdt: AbstractCrdt, isLocal: boolean): ApplyResult;
     /**
      * INTERNAL
      */
@@ -53,9 +54,14 @@ export declare abstract class AbstractCrdt {
     /**
      * INTERNAL
      */
-    abstract _detachChild(crdt: AbstractCrdt): void;
+    abstract _detachChild(crdt: AbstractCrdt): ApplyResult;
     /**
      * INTERNAL
      */
-    abstract _serialize(parentId: string, parentKey: string): Op[];
+    abstract _serialize(parentId: string, parentKey: string, doc?: Doc): Op[];
+    /**
+     * INTERNAL
+     */
+    abstract _toSerializedCrdt(): SerializedCrdt;
+    abstract _getType(): string;
 }

package/lib/esm/AbstractCrdt.js

@@ -45,14 +45,11 @@ export class AbstractCrdt {
     /**
      * INTERNAL
      */
-    _apply(op) {
+    _apply(op, isLocal) {
         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);
-                    this._parent._detachChild(this);
-                    return { modified: parent, reverse };
+                    return this._parent._detachChild(this);
                 }
                 return { modified: false };
             }

package/lib/esm/LiveList.d.ts

@@ -1,5 +1,5 @@
 import { AbstractCrdt, Doc, ApplyResult } from "./AbstractCrdt";
-import { SerializedList, SerializedCrdtWithId, Op } from "./live";
+import { SerializedList, SerializedCrdtWithId, Op, SerializedCrdt } from "./live";
 /**
  * The LiveList class represents an ordered collection of items that is synchorinized across clients.
  */
@@ -13,7 +13,8 @@ export declare class LiveList<T> extends AbstractCrdt {
     /**
      * INTERNAL
      */
-    _serialize(parentId?: string, parentKey?: string): Op[];
+    _serialize(parentId?: string, parentKey?: string, doc?: Doc): Op[];
+    _indexOfPosition(position: string): number;
     /**
      * INTERNAL
      */
@@ -25,19 +26,27 @@ export declare class LiveList<T> extends AbstractCrdt {
     /**
      * INTERNAL
      */
-    _attachChild(id: string, key: string, child: AbstractCrdt): ApplyResult;
+    _attachChild(id: string, key: string, child: AbstractCrdt, isLocal: boolean): ApplyResult;
     /**
      * 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): ApplyResult;
+    _apply(op: Op, isLocal: boolean): ApplyResult;
+    /**
+     * INTERNAL
+     */
+    _getType(): string;
+    /**
+     * INTERNAL
+     */
+    _toSerializedCrdt(): SerializedCrdt;
     /**
      * Returns the number of elements.
      */
@@ -64,10 +73,12 @@ export declare class LiveList<T> extends AbstractCrdt {
      * @param index The index of the element to delete
      */
     delete(index: number): void;
+    clear(): void;
     /**
      * 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

@@ -12,7 +12,7 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
 var _LiveList_items, _LiveListIterator_innerIterator;
 import { AbstractCrdt } from "./AbstractCrdt";
 import { deserialize, selfOrRegister, selfOrRegisterValue } from "./utils";
-import { OpType, } from "./live";
+import { OpType, CrdtType, } from "./live";
 import { makePosition, compare } from "./position";
 /**
  * The LiveList class represents an ordered collection of items that is synchorinized across clients.
@@ -51,7 +51,7 @@ export class LiveList extends AbstractCrdt {
     /**
      * INTERNAL
      */
-    _serialize(parentId, parentKey) {
+    _serialize(parentId, parentKey, doc) {
         if (this._id == null) {
             throw new Error("Cannot serialize item is not attached");
         }
@@ -61,16 +61,20 @@ export class LiveList extends AbstractCrdt {
         const ops = [];
         const op = {
             id: this._id,
+            opId: doc === null || doc === void 0 ? void 0 : doc.generateOpId(),
             type: OpType.CreateList,
             parentId,
             parentKey,
         };
         ops.push(op);
         for (const [value, key] of __classPrivateFieldGet(this, _LiveList_items, "f")) {
-            ops.push(...value._serialize(this._id, key));
+            ops.push(...value._serialize(this._id, key, doc));
         }
         return ops;
     }
+    _indexOfPosition(position) {
+        return __classPrivateFieldGet(this, _LiveList_items, "f").findIndex((item) => item[1] === position);
+    }
     /**
      * INTERNAL
      */
@@ -92,7 +96,7 @@ export class LiveList extends AbstractCrdt {
     /**
      * INTERNAL
      */
-    _attachChild(id, key, child) {
+    _attachChild(id, key, child, isLocal) {
         var _a;
         if (this._doc == null) {
             throw new Error("Can't attach child if doc is not present");
@@ -100,28 +104,57 @@ export class LiveList extends AbstractCrdt {
         child._attach(id, this._doc);
         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
+        let newKey = key;
+        // If there is a conflict
         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]);
+            if (isLocal) {
+                // If change is local => assign a temporary position to newly attached child
+                let before = __classPrivateFieldGet(this, _LiveList_items, "f")[index] ? __classPrivateFieldGet(this, _LiveList_items, "f")[index][1] : undefined;
+                let after = __classPrivateFieldGet(this, _LiveList_items, "f")[index + 1]
+                    ? __classPrivateFieldGet(this, _LiveList_items, "f")[index + 1][1]
+                    : undefined;
+                newKey = makePosition(before, after);
+                child._setParentLink(this, newKey);
+            }
+            else {
+                // If change is remote => assign a temporary position to existing child until we get the fix from the backend
+                __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").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);
@@ -134,12 +167,44 @@ 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
+     */
+    _apply(op, isLocal) {
+        return super._apply(op, isLocal);
+    }
+    /**
+     * INTERNAL
+     */
+    _getType() {
+        return "LiveList";
     }
     /**
      * INTERNAL
      */
-    _apply(op) {
-        return super._apply(op);
+    _toSerializedCrdt() {
+        var _a;
+        return {
+            type: CrdtType.List,
+            parentId: (_a = this._parent) === null || _a === void 0 ? void 0 : _a._id,
+            parentKey: this._parentKey,
+        };
     }
     /**
      * Returns the number of elements.
@@ -170,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), [{ 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);
         }
     }
     /**
@@ -214,11 +286,22 @@ 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,
                     id: item[0]._id,
+                    opId: this._doc.generateOpId(),
                     parentKey: position,
                 },
             ], [
@@ -227,7 +310,7 @@ export class LiveList extends AbstractCrdt {
                     id: item[0]._id,
                     parentKey: previousPosition,
                 },
-            ], [this]);
+            ], storageUpdates);
         }
     }
     /**
@@ -244,21 +327,63 @@ 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);
             }
         }
     }
+    clear() {
+        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");
+            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")) {
+                item[0]._detach();
+            }
+            __classPrivateFieldSet(this, _LiveList_items, [], "f");
+        }
+    }
     /**
      * Returns an Array of all the elements in the LiveList.
      */
     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

@@ -1,5 +1,5 @@
 import { AbstractCrdt, Doc, ApplyResult } from "./AbstractCrdt";
-import { Op, SerializedCrdtWithId } from "./live";
+import { Op, SerializedCrdtWithId, SerializedCrdt } from "./live";
 /**
  * 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.
@@ -11,7 +11,7 @@ export declare class LiveMap<TKey extends string, TValue> extends AbstractCrdt {
     /**
      * INTERNAL
      */
-    _serialize(parentId?: string, parentKey?: string): Op[];
+    _serialize(parentId?: string, parentKey?: string, doc?: Doc): Op[];
     /**
      * INTERNAL
      */
@@ -23,7 +23,7 @@ export declare class LiveMap<TKey extends string, TValue> extends AbstractCrdt {
     /**
      * INTERNAL
      */
-    _attachChild(id: string, key: TKey, child: AbstractCrdt): ApplyResult;
+    _attachChild(id: string, key: TKey, child: AbstractCrdt, isLocal: boolean): ApplyResult;
     /**
      * INTERNAL
      */
@@ -31,7 +31,15 @@ export declare class LiveMap<TKey extends string, TValue> extends AbstractCrdt {
     /**
      * INTERNAL
      */
-    _detachChild(child: AbstractCrdt): void;
+    _detachChild(child: AbstractCrdt): ApplyResult;
+    /**
+     * INTERNAL
+     */
+    _getType(): string;
+    /**
+     * INTERNAL
+     */
+    _toSerializedCrdt(): SerializedCrdt;
     /**
      * Returns a specified element from the LiveMap.
      * @param key The key of the element to return.

package/lib/esm/LiveMap.js

@@ -38,7 +38,7 @@ export class LiveMap extends AbstractCrdt {
     /**
      * INTERNAL
      */
-    _serialize(parentId, parentKey) {
+    _serialize(parentId, parentKey, doc) {
         if (this._id == null) {
             throw new Error("Cannot serialize item is not attached");
         }
@@ -48,13 +48,14 @@ export class LiveMap extends AbstractCrdt {
         const ops = [];
         const op = {
             id: this._id,
+            opId: doc === null || doc === void 0 ? void 0 : doc.generateOpId(),
             type: OpType.CreateMap,
             parentId,
             parentKey,
         };
         ops.push(op);
         for (const [key, value] of __classPrivateFieldGet(this, _LiveMap_map, "f")) {
-            ops.push(...value._serialize(this._id, key));
+            ops.push(...value._serialize(this._id, key, doc));
         }
         return ops;
     }
@@ -96,7 +97,7 @@ export class LiveMap extends AbstractCrdt {
     /**
      * INTERNAL
      */
-    _attachChild(id, key, child) {
+    _attachChild(id, key, child, isLocal) {
         if (this._doc == null) {
             throw new Error("Can't attach child if doc is not present");
         }
@@ -112,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
@@ -127,12 +135,36 @@ 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
+     */
+    _toSerializedCrdt() {
+        var _a;
+        return {
+            type: CrdtType.Map,
+            parentId: (_a = this._parent) === null || _a === void 0 ? void 0 : _a._id,
+            parentKey: this._parentKey,
+        };
     }
     /**
      * Returns a specified element from the LiveMap.
@@ -162,9 +194,15 @@ export class LiveMap extends AbstractCrdt {
         if (this._doc && this._id) {
             const id = this._doc.generateId();
             item._attach(id, this._doc);
-            this._doc.dispatch(item._serialize(this._id, key), oldValue
+            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);
         }
     }
     /**
@@ -192,7 +230,19 @@ export class LiveMap extends AbstractCrdt {
         }
         item._detach();
         if (this._doc && item._id) {
-            this._doc.dispatch([{ type: OpType.DeleteCrdt, id: item._id }], item._serialize(this._id, key), [this]);
+            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), storageUpdates);
         }
         __classPrivateFieldGet(this, _LiveMap_map, "f").delete(key);
         return true;

package/lib/esm/LiveObject.d.ts

@@ -1,5 +1,5 @@
 import { AbstractCrdt, Doc, ApplyResult } from "./AbstractCrdt";
-import { Op, SerializedCrdtWithId } from "./live";
+import { Op, SerializedCrdt, SerializedCrdtWithId } from "./live";
 /**
  * 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.
@@ -11,13 +11,15 @@ export declare class LiveObject<T extends Record<string, any> = Record<string, a
     /**
      * INTERNAL
      */
-    _serialize(parentId?: string, parentKey?: string): Op[];
+    _serialize(parentId?: string, parentKey?: string, doc?: Doc): Op[];
     /**
      * INTERNAL
      */
-    static _deserialize([id, item]: SerializedCrdtWithId, parentToChildren: Map<string, SerializedCrdtWithId[]>, doc: Doc): LiveObject<{
-        [key: string]: any;
-    }>;
+    static _deserialize([id, item]: SerializedCrdtWithId, parentToChildren: Map<string, SerializedCrdtWithId[]>, doc: Doc): LiveObject<Record<string, any>>;
+    /**
+     * INTERNAL
+     */
+    static _deserializeChildren(object: LiveObject, parentToChildren: Map<string, SerializedCrdtWithId[]>, doc: Doc): LiveObject<Record<string, any>>;
     /**
      * INTERNAL
      */
@@ -25,11 +27,15 @@ export declare class LiveObject<T extends Record<string, any> = Record<string, a
     /**
      * INTERNAL
      */
-    _attachChild(id: string, key: keyof T, child: AbstractCrdt): ApplyResult;
+    _attachChild(id: string, key: keyof T, child: AbstractCrdt, isLocal: boolean): ApplyResult;
+    /**
+     * INTERNAL
+     */
+    _detachChild(child: AbstractCrdt): ApplyResult;
     /**
      * INTERNAL
      */
-    _detachChild(child: AbstractCrdt): void;
+    _detachChildren(): void;
     /**
      * INTERNAL
      */
@@ -37,7 +43,15 @@ export declare class LiveObject<T extends Record<string, any> = Record<string, a
     /**
      * INTERNAL
      */
-    _apply(op: Op): ApplyResult;
+    _apply(op: Op, isLocal: boolean): ApplyResult;
+    /**
+     * INTERNAL
+     */
+    _toSerializedCrdt(): SerializedCrdt;
+    /**
+     * INTERNAL
+     */
+    _getType(): string;
     /**
      * Transform the LiveObject into a javascript object
      */