@liveblocks/client 0.12.2 → 0.13.1

package/lib/esm/LiveList.d.ts

@@ -0,0 +1,133 @@
+import { AbstractCrdt, Doc, ApplyResult } from "./AbstractCrdt";
+import { SerializedList, SerializedCrdtWithId, Op } from "./live";
+/**
+ * The LiveList class represents an ordered collection of items that is synchorinized across clients.
+ */
+export declare class LiveList<T> extends AbstractCrdt {
+    #private;
+    constructor(items?: T[]);
+    /**
+     * INTERNAL
+     */
+    static _deserialize([id, item]: [id: string, item: SerializedList], parentToChildren: Map<string, SerializedCrdtWithId[]>, doc: Doc): LiveList<never>;
+    /**
+     * INTERNAL
+     */
+    _serialize(parentId?: string, parentKey?: string): Op[];
+    /**
+     * INTERNAL
+     */
+    _attach(id: string, doc: Doc): void;
+    /**
+     * INTERNAL
+     */
+    _detach(): void;
+    /**
+     * INTERNAL
+     */
+    _attachChild(id: string, key: string, child: AbstractCrdt): ApplyResult;
+    /**
+     * INTERNAL
+     */
+    _detachChild(child: AbstractCrdt): void;
+    /**
+     * INTERNAL
+     */
+    _setChildKey(key: string, child: AbstractCrdt): void;
+    /**
+     * INTERNAL
+     */
+    _apply(op: Op): ApplyResult;
+    /**
+     * Returns the number of elements.
+     */
+    get length(): number;
+    /**
+     * Adds one element to the end of the LiveList.
+     * @param element The element to add to the end of the LiveList.
+     */
+    push(element: T): void;
+    /**
+     * 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: T, index: number): void;
+    /**
+     * 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: number, targetIndex: number): void;
+    /**
+     * Deletes an element at the specified index
+     * @param index The index of the element to delete
+     */
+    delete(index: number): void;
+    /**
+     * Returns an Array of all the elements in the LiveList.
+     */
+    toArray(): T[];
+    /**
+     * 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: (value: T, index: number) => unknown): boolean;
+    /**
+     * 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: (value: T, index: number) => unknown): T[];
+    /**
+     * 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: (value: T, index: number) => unknown): T | undefined;
+    /**
+     * 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: (value: T, index: number) => unknown): number;
+    /**
+     * Executes a provided function once for each element.
+     * @param callbackfn Function to execute on each element.
+     */
+    forEach(callbackfn: (value: T, index: number) => void): void;
+    /**
+     * 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: number): T | undefined;
+    /**
+     * 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: T, fromIndex?: number): number;
+    /**
+     * 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: T, fromIndex?: number): number;
+    /**
+     * 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<U>(callback: (value: T, index: number) => U): U[];
+    /**
+     * 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: (value: T, index: number) => unknown): boolean;
+    [Symbol.iterator](): IterableIterator<T>;
+}

package/lib/esm/LiveList.js

@@ -0,0 +1,370 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    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 __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _LiveList_items, _LiveListIterator_innerIterator;
+import { AbstractCrdt } from "./AbstractCrdt";
+import { deserialize, selfOrRegister, selfOrRegisterValue } from "./utils";
+import { OpType, } from "./live";
+import { makePosition, compare } from "./position";
+/**
+ * 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. Maybe an Order statistics tree?
+        _LiveList_items.set(this, []);
+        let position = undefined;
+        for (let i = 0; i < items.length; i++) {
+            const newPosition = makePosition(position);
+            const item = selfOrRegister(items[i]);
+            __classPrivateFieldGet(this, _LiveList_items, "f").push([item, newPosition]);
+            position = newPosition;
+        }
+    }
+    /**
+     * INTERNAL
+     */
+    static _deserialize([id, item], parentToChildren, doc) {
+        const list = new LiveList([]);
+        list._attach(id, doc);
+        const children = parentToChildren.get(id);
+        if (children == null) {
+            return list;
+        }
+        for (const entry of children) {
+            const child = deserialize(entry, parentToChildren, doc);
+            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(itemA[1], itemB[1]));
+        }
+        return list;
+    }
+    /**
+     * INTERNAL
+     */
+    _serialize(parentId, parentKey) {
+        if (this._id == null) {
+            throw new Error("Cannot serialize item is not attached");
+        }
+        if (parentId == null || parentKey == null) {
+            throw new Error("Cannot serialize list if parentId or parentKey is undefined");
+        }
+        const ops = [];
+        const op = {
+            id: this._id,
+            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));
+        }
+        return ops;
+    }
+    /**
+     * INTERNAL
+     */
+    _attach(id, doc) {
+        super._attach(id, doc);
+        for (const [item, position] of __classPrivateFieldGet(this, _LiveList_items, "f")) {
+            item._attach(doc.generateId(), doc);
+        }
+    }
+    /**
+     * INTERNAL
+     */
+    _detach() {
+        super._detach();
+        for (const [value] of __classPrivateFieldGet(this, _LiveList_items, "f")) {
+            value._detach();
+        }
+    }
+    /**
+     * 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._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(itemA[1], itemB[1]));
+        return { reverse: [{ type: OpType.DeleteCrdt, id }], modified: this };
+    }
+    /**
+     * 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) {
+            child._detach();
+        }
+    }
+    /**
+     * 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(itemA[1], itemB[1]));
+    }
+    /**
+     * 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);
+    }
+    /**
+     * 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(element);
+        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]));
+        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]);
+        }
+    }
+    /**
+     * 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");
+        }
+        if (targetIndex >= __classPrivateFieldGet(this, _LiveList_items, "f").length) {
+            throw new Error("targetIndex cannot be greater or equal than the list length");
+        }
+        if (index < 0) {
+            throw new Error("index cannot be less than 0");
+        }
+        if (index >= __classPrivateFieldGet(this, _LiveList_items, "f").length) {
+            throw new Error("index cannot be greater or equal than the list length");
+        }
+        let beforePosition = null;
+        let afterPosition = null;
+        if (index < targetIndex) {
+            afterPosition =
+                targetIndex === __classPrivateFieldGet(this, _LiveList_items, "f").length - 1
+                    ? undefined
+                    : __classPrivateFieldGet(this, _LiveList_items, "f")[targetIndex + 1][1];
+            beforePosition = __classPrivateFieldGet(this, _LiveList_items, "f")[targetIndex][1];
+        }
+        else {
+            afterPosition = __classPrivateFieldGet(this, _LiveList_items, "f")[targetIndex][1];
+            beforePosition =
+                targetIndex === 0 ? undefined : __classPrivateFieldGet(this, _LiveList_items, "f")[targetIndex - 1][1];
+        }
+        const position = makePosition(beforePosition, afterPosition);
+        const item = __classPrivateFieldGet(this, _LiveList_items, "f")[index];
+        const previousPosition = item[1];
+        item[1] = position;
+        item[0]._setParentLink(this, position);
+        __classPrivateFieldGet(this, _LiveList_items, "f").sort((itemA, itemB) => compare(itemA[1], itemB[1]));
+        if (this._doc && this._id) {
+            this._doc.dispatch([
+                {
+                    type: OpType.SetParentKey,
+                    id: item[0]._id,
+                    parentKey: position,
+                },
+            ], [
+                {
+                    type: OpType.SetParentKey,
+                    id: item[0]._id,
+                    parentKey: previousPosition,
+                },
+            ], [this]);
+        }
+    }
+    /**
+     * 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}`);
+        }
+        const item = __classPrivateFieldGet(this, _LiveList_items, "f")[index];
+        item[0]._detach();
+        __classPrivateFieldGet(this, _LiveList_items, "f").splice(index, 1);
+        if (this._doc) {
+            const childRecordId = item[0]._id;
+            if (childRecordId) {
+                this._doc.dispatch([
+                    {
+                        id: childRecordId,
+                        type: OpType.DeleteCrdt,
+                    },
+                ], item[0]._serialize(this._id, item[1]), [this]);
+            }
+        }
+    }
+    /**
+     * 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);
+    }
+    [(_LiveList_items = new WeakMap(), Symbol.iterator)]() {
+        return new LiveListIterator(__classPrivateFieldGet(this, _LiveList_items, "f"));
+    }
+}
+class LiveListIterator {
+    constructor(items) {
+        _LiveListIterator_innerIterator.set(this, void 0);
+        __classPrivateFieldSet(this, _LiveListIterator_innerIterator, items[Symbol.iterator](), "f");
+    }
+    [(_LiveListIterator_innerIterator = new WeakMap(), Symbol.iterator)]() {
+        return this;
+    }
+    next() {
+        const result = __classPrivateFieldGet(this, _LiveListIterator_innerIterator, "f").next();
+        if (result.done) {
+            return {
+                done: true,
+                value: undefined,
+            };
+        }
+        return {
+            value: selfOrRegisterValue(result.value[0]),
+        };
+    }
+}

package/lib/esm/LiveMap.d.ts

@@ -0,0 +1,83 @@
+import { AbstractCrdt, Doc, ApplyResult } from "./AbstractCrdt";
+import { Op, SerializedCrdtWithId } 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.
+ * If multiple clients update the same property simultaneously, the last modification received by the Liveblocks servers is the winner.
+ */
+export declare class LiveMap<TKey extends string, TValue> extends AbstractCrdt {
+    #private;
+    constructor(entries?: readonly (readonly [TKey, TValue])[] | null | undefined);
+    /**
+     * INTERNAL
+     */
+    _serialize(parentId?: string, parentKey?: string): Op[];
+    /**
+     * INTERNAL
+     */
+    static _deserialize([id, item]: SerializedCrdtWithId, parentToChildren: Map<string, SerializedCrdtWithId[]>, doc: Doc): LiveMap<string, unknown>;
+    /**
+     * INTERNAL
+     */
+    _attach(id: string, doc: Doc): void;
+    /**
+     * INTERNAL
+     */
+    _attachChild(id: string, key: TKey, child: AbstractCrdt): ApplyResult;
+    /**
+     * INTERNAL
+     */
+    _detach(): void;
+    /**
+     * INTERNAL
+     */
+    _detachChild(child: AbstractCrdt): void;
+    /**
+     * 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: TKey): TValue | undefined;
+    /**
+     * 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: TKey, value: TValue): void;
+    /**
+     * Returns the number of elements in the LiveMap.
+     */
+    get size(): number;
+    /**
+     * 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: TKey): boolean;
+    /**
+     * 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: TKey): boolean;
+    /**
+     * Returns a new Iterator object that contains the [key, value] pairs for each element.
+     */
+    entries(): IterableIterator<[string, TValue]>;
+    /**
+     * Same function object as the initial value of the entries method.
+     */
+    [Symbol.iterator](): IterableIterator<[string, TValue]>;
+    /**
+     * Returns a new Iterator object that contains the keys for each element.
+     */
+    keys(): IterableIterator<TKey>;
+    /**
+     * Returns a new Iterator object that contains the values for each element.
+     */
+    values(): IterableIterator<TValue>;
+    /**
+     * 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: (value: TValue, key: TKey, map: LiveMap<TKey, TValue>) => void): void;
+}