@liveblocks/client 0.12.2 → 0.13.1

package/lib/cjs/LiveObject.js

@@ -0,0 +1,368 @@
+"use strict";
+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 __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 _LiveObject_instances, _LiveObject_map, _LiveObject_propToLastUpdate, _LiveObject_applyUpdate, _LiveObject_applyDeleteObjectKey;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveObject = void 0;
+const AbstractCrdt_1 = require("./AbstractCrdt");
+const utils_1 = require("./utils");
+const live_1 = require("./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.
+ * If multiple clients update the same property simultaneously, the last modification received by the Liveblocks servers is the winner.
+ */
+class LiveObject extends AbstractCrdt_1.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_1.AbstractCrdt) {
+                value._setParentLink(this, key);
+            }
+        }
+        __classPrivateFieldSet(this, _LiveObject_map, new Map(Object.entries(object)), "f");
+    }
+    /**
+     * INTERNAL
+     */
+    _serialize(parentId, parentKey) {
+        if (this._id == null) {
+            throw new Error("Cannot serialize item is not attached");
+        }
+        const ops = [];
+        const op = {
+            id: this._id,
+            type: live_1.OpType.CreateObject,
+            parentId,
+            parentKey,
+            data: {},
+        };
+        ops.push(op);
+        for (const [key, value] of __classPrivateFieldGet(this, _LiveObject_map, "f")) {
+            if (value instanceof AbstractCrdt_1.AbstractCrdt) {
+                ops.push(...value._serialize(this._id, key));
+            }
+            else {
+                op.data[key] = value;
+            }
+        }
+        return ops;
+    }
+    /**
+     * INTERNAL
+     */
+    static _deserialize([id, item], parentToChildren, doc) {
+        if (item.type !== live_1.CrdtType.Object) {
+            throw new Error(`Tried to deserialize a record but item type is "${item.type}"`);
+        }
+        const object = new LiveObject(item.data);
+        object._attach(id, doc);
+        const children = parentToChildren.get(id);
+        if (children == null) {
+            return object;
+        }
+        for (const entry of children) {
+            const crdt = entry[1];
+            if (crdt.parentKey == null) {
+                throw new Error("Tried to deserialize a crdt but it does not have a parentKey and is not the root");
+            }
+            const child = (0, utils_1.deserialize)(entry, parentToChildren, doc);
+            child._setParentLink(object, crdt.parentKey);
+            __classPrivateFieldGet(object, _LiveObject_map, "f").set(crdt.parentKey, child);
+        }
+        return object;
+    }
+    /**
+     * INTERNAL
+     */
+    _attach(id, doc) {
+        super._attach(id, doc);
+        for (const [key, value] of __classPrivateFieldGet(this, _LiveObject_map, "f")) {
+            if (value instanceof AbstractCrdt_1.AbstractCrdt) {
+                value._attach(doc.generateId(), doc);
+            }
+        }
+    }
+    /**
+     * INTERNAL
+     */
+    _attachChild(id, key, child) {
+        if (this._doc == null) {
+            throw new Error("Can't attach child if doc is not present");
+        }
+        const previousValue = __classPrivateFieldGet(this, _LiveObject_map, "f").get(key);
+        let reverse;
+        if ((0, utils_1.isCrdt)(previousValue)) {
+            reverse = previousValue._serialize(this._id, key);
+            previousValue._detach();
+        }
+        else if (previousValue === undefined) {
+            reverse = [
+                { type: live_1.OpType.DeleteObjectKey, id: this._id, key: key },
+            ];
+        }
+        else {
+            reverse = [
+                {
+                    type: live_1.OpType.UpdateObject,
+                    id: this._id,
+                    data: { [key]: previousValue },
+                },
+            ];
+        }
+        __classPrivateFieldGet(this, _LiveObject_map, "f").set(key, child);
+        child._setParentLink(this, key);
+        child._attach(id, this._doc);
+        return { reverse, modified: this };
+    }
+    /**
+     * INTERNAL
+     */
+    _detachChild(child) {
+        for (const [key, value] of __classPrivateFieldGet(this, _LiveObject_map, "f")) {
+            if (value === child) {
+                __classPrivateFieldGet(this, _LiveObject_map, "f").delete(key);
+            }
+        }
+        if (child) {
+            child._detach();
+        }
+    }
+    /**
+     * INTERNAL
+     */
+    _detach() {
+        super._detach();
+        for (const value of __classPrivateFieldGet(this, _LiveObject_map, "f").values()) {
+            if ((0, utils_1.isCrdt)(value)) {
+                value._detach();
+            }
+        }
+    }
+    /**
+     * INTERNAL
+     */
+    _apply(op) {
+        if (op.type === live_1.OpType.UpdateObject) {
+            return __classPrivateFieldGet(this, _LiveObject_instances, "m", _LiveObject_applyUpdate).call(this, op);
+        }
+        else if (op.type === live_1.OpType.DeleteObjectKey) {
+            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);
+    }
+    /**
+     * Deletes a key from the LiveObject
+     * @param key The key of the property to delete
+     */
+    delete(key) {
+        const keyAsString = key;
+        const oldValue = __classPrivateFieldGet(this, _LiveObject_map, "f").get(keyAsString);
+        if (oldValue === undefined) {
+            return;
+        }
+        if (this._doc == null || this._id == null) {
+            if (oldValue instanceof AbstractCrdt_1.AbstractCrdt) {
+                oldValue._detach();
+            }
+            __classPrivateFieldGet(this, _LiveObject_map, "f").delete(keyAsString);
+            return;
+        }
+        let reverse;
+        if (oldValue instanceof AbstractCrdt_1.AbstractCrdt) {
+            oldValue._detach();
+            reverse = oldValue._serialize(this._id, keyAsString);
+        }
+        else {
+            reverse = [
+                {
+                    type: live_1.OpType.UpdateObject,
+                    data: { [keyAsString]: oldValue },
+                    id: this._id,
+                },
+            ];
+        }
+        __classPrivateFieldGet(this, _LiveObject_map, "f").delete(keyAsString);
+        this._doc.dispatch([{ type: live_1.OpType.DeleteObjectKey, key: keyAsString, id: this._id }], reverse, [this]);
+    }
+    /**
+     * Adds or updates multiple properties at once with an object.
+     * @param overrides The object used to overrides properties
+     */
+    update(overrides) {
+        if (this._doc == null || this._id == null) {
+            for (const key in overrides) {
+                const oldValue = __classPrivateFieldGet(this, _LiveObject_map, "f").get(key);
+                if (oldValue instanceof AbstractCrdt_1.AbstractCrdt) {
+                    oldValue._detach();
+                }
+                const newValue = overrides[key];
+                if (newValue instanceof AbstractCrdt_1.AbstractCrdt) {
+                    newValue._setParentLink(this, key);
+                }
+                __classPrivateFieldGet(this, _LiveObject_map, "f").set(key, newValue);
+            }
+            return;
+        }
+        const ops = [];
+        const reverseOps = [];
+        const opId = this._doc.generateOpId();
+        const updatedProps = {};
+        const reverseUpdateOp = {
+            id: this._id,
+            type: live_1.OpType.UpdateObject,
+            data: {},
+        };
+        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_1.AbstractCrdt) {
+                reverseOps.push(...oldValue._serialize(this._id, key));
+                oldValue._detach();
+            }
+            else if (oldValue === undefined) {
+                reverseOps.push({ type: live_1.OpType.DeleteObjectKey, id: this._id, key });
+            }
+            else {
+                reverseUpdateOp.data[key] = oldValue;
+            }
+            const newValue = overrides[key];
+            if (newValue instanceof AbstractCrdt_1.AbstractCrdt) {
+                newValue._setParentLink(this, key);
+                newValue._attach(this._doc.generateId(), this._doc);
+                ops.push(...newValue._serialize(this._id, key));
+            }
+            else {
+                updatedProps[key] = newValue;
+            }
+            __classPrivateFieldGet(this, _LiveObject_map, "f").set(key, newValue);
+        }
+        if (Object.keys(reverseUpdateOp.data).length !== 0) {
+            reverseOps.unshift(reverseUpdateOp);
+        }
+        if (Object.keys(updatedProps).length !== 0) {
+            ops.unshift({
+                opId,
+                id: this._id,
+                type: live_1.OpType.UpdateObject,
+                data: updatedProps,
+            });
+        }
+        this._doc.dispatch(ops, reverseOps, [this]);
+    }
+}
+exports.LiveObject = LiveObject;
+_LiveObject_map = new WeakMap(), _LiveObject_propToLastUpdate = new WeakMap(), _LiveObject_instances = new WeakSet(), _LiveObject_applyUpdate = function _LiveObject_applyUpdate(op) {
+    let isModified = false;
+    const reverse = [];
+    const reverseUpdate = {
+        type: live_1.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 instanceof AbstractCrdt_1.AbstractCrdt) {
+            reverse.push(...oldValue._serialize(this._id, key));
+            oldValue._detach();
+        }
+        else if (oldValue !== undefined) {
+            reverseUpdate.data[key] = oldValue;
+        }
+        else if (oldValue === undefined) {
+            reverse.push({ type: live_1.OpType.DeleteObjectKey, id: this._id, key });
+        }
+    }
+    let isLocal = false;
+    if (op.opId == null) {
+        isLocal = true;
+        op.opId = this._doc.generateOpId();
+    }
+    for (const key in op.data) {
+        if (isLocal) {
+            __classPrivateFieldGet(this, _LiveObject_propToLastUpdate, "f").set(key, op.opId);
+        }
+        else if (__classPrivateFieldGet(this, _LiveObject_propToLastUpdate, "f").get(key) == null) {
+            // Not modified localy so we apply update
+            isModified = true;
+        }
+        else if (__classPrivateFieldGet(this, _LiveObject_propToLastUpdate, "f").get(key) === op.opId) {
+            // Acknowlegment from local operation
+            __classPrivateFieldGet(this, _LiveObject_propToLastUpdate, "f").delete(key);
+            continue;
+        }
+        else {
+            // Conflict, ignore remote operation
+            continue;
+        }
+        const oldValue = __classPrivateFieldGet(this, _LiveObject_map, "f").get(key);
+        if ((0, utils_1.isCrdt)(oldValue)) {
+            oldValue._detach();
+        }
+        isModified = true;
+        __classPrivateFieldGet(this, _LiveObject_map, "f").set(key, op.data[key]);
+    }
+    if (Object.keys(reverseUpdate.data).length !== 0) {
+        reverse.unshift(reverseUpdate);
+    }
+    return isModified ? { modified: this, reverse } : { modified: false };
+}, _LiveObject_applyDeleteObjectKey = function _LiveObject_applyDeleteObjectKey(op) {
+    const key = op.key;
+    // If property does not exist, exit without notifying
+    if (__classPrivateFieldGet(this, _LiveObject_map, "f").has(key) === false) {
+        return { modified: false };
+    }
+    const oldValue = __classPrivateFieldGet(this, _LiveObject_map, "f").get(key);
+    let reverse = [];
+    if ((0, utils_1.isCrdt)(oldValue)) {
+        reverse = oldValue._serialize(this._id, op.key);
+        oldValue._detach();
+    }
+    else if (oldValue !== undefined) {
+        reverse = [
+            {
+                type: live_1.OpType.UpdateObject,
+                id: this._id,
+                data: { [key]: oldValue },
+            },
+        ];
+    }
+    __classPrivateFieldGet(this, _LiveObject_map, "f").delete(key);
+    return { modified: this, reverse };
+};

package/lib/cjs/LiveRegister.d.ts

@@ -0,0 +1,21 @@
+import { AbstractCrdt, Doc, ApplyResult } from "./AbstractCrdt";
+import { SerializedCrdtWithId, Op } from "./live";
+/**
+ * INTERNAL
+ */
+export declare class LiveRegister<TValue = any> extends AbstractCrdt {
+    #private;
+    constructor(data: TValue);
+    get data(): TValue;
+    /**
+     * INTERNAL
+     */
+    static _deserialize([id, item]: SerializedCrdtWithId, parentToChildren: Map<string, SerializedCrdtWithId[]>, doc: Doc): LiveRegister<any>;
+    /**
+     * INTERNAL
+     */
+    _serialize(parentId: string, parentKey: string): Op[];
+    _attachChild(id: string, key: string, crdt: AbstractCrdt): ApplyResult;
+    _detachChild(crdt: AbstractCrdt): void;
+    _apply(op: Op): ApplyResult;
+}

package/lib/cjs/LiveRegister.js

@@ -0,0 +1,69 @@
+"use strict";
+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 __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 _LiveRegister_data;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveRegister = void 0;
+const AbstractCrdt_1 = require("./AbstractCrdt");
+const live_1 = require("./live");
+/**
+ * INTERNAL
+ */
+class LiveRegister extends AbstractCrdt_1.AbstractCrdt {
+    constructor(data) {
+        super();
+        _LiveRegister_data.set(this, void 0);
+        __classPrivateFieldSet(this, _LiveRegister_data, data, "f");
+    }
+    get data() {
+        return __classPrivateFieldGet(this, _LiveRegister_data, "f");
+    }
+    /**
+     * INTERNAL
+     */
+    static _deserialize([id, item], parentToChildren, doc) {
+        if (item.type !== live_1.CrdtType.Register) {
+            throw new Error(`Tried to deserialize a map but item type is "${item.type}"`);
+        }
+        const register = new LiveRegister(item.data);
+        register._attach(id, doc);
+        return register;
+    }
+    /**
+     * INTERNAL
+     */
+    _serialize(parentId, parentKey) {
+        if (this._id == null || parentId == null || parentKey == null) {
+            throw new Error("Cannot serialize register if parentId or parentKey is undefined");
+        }
+        return [
+            {
+                type: live_1.OpType.CreateRegister,
+                id: this._id,
+                parentId,
+                parentKey,
+                data: this.data,
+            },
+        ];
+    }
+    _attachChild(id, key, crdt) {
+        throw new Error("Method not implemented.");
+    }
+    _detachChild(crdt) {
+        throw new Error("Method not implemented.");
+    }
+    _apply(op) {
+        return super._apply(op);
+    }
+}
+exports.LiveRegister = LiveRegister;
+_LiveRegister_data = new WeakMap();

package/lib/cjs/index.d.ts

@@ -1,3 +1,5 @@
-export { LiveObject, LiveList, LiveMap } from "./doc";
+export { LiveObject } from "./LiveObject";
+export { LiveMap } from "./LiveMap";
+export { LiveList } from "./LiveList";
 export type { Others, Presence, Room, Client, User } from "./types";
 export { createClient } from "./client";

package/lib/cjs/index.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createClient = exports.LiveMap = exports.LiveList = exports.LiveObject = void 0;
-var doc_1 = require("./doc");
-Object.defineProperty(exports, "LiveObject", { enumerable: true, get: function () { return doc_1.LiveObject; } });
-Object.defineProperty(exports, "LiveList", { enumerable: true, get: function () { return doc_1.LiveList; } });
-Object.defineProperty(exports, "LiveMap", { enumerable: true, get: function () { return doc_1.LiveMap; } });
+exports.createClient = exports.LiveList = exports.LiveMap = exports.LiveObject = void 0;
+var LiveObject_1 = require("./LiveObject");
+Object.defineProperty(exports, "LiveObject", { enumerable: true, get: function () { return LiveObject_1.LiveObject; } });
+var LiveMap_1 = require("./LiveMap");
+Object.defineProperty(exports, "LiveMap", { enumerable: true, get: function () { return LiveMap_1.LiveMap; } });
+var LiveList_1 = require("./LiveList");
+Object.defineProperty(exports, "LiveList", { enumerable: true, get: function () { return LiveList_1.LiveList; } });
 var client_1 = require("./client");
 Object.defineProperty(exports, "createClient", { enumerable: true, get: function () { return client_1.createClient; } });

package/lib/cjs/room.d.ts

@@ -1,11 +1,19 @@
-import { Others, Presence, ClientOptions, Room, MyPresenceCallback, OthersEventCallback, AuthEndpoint, EventCallback, User, Connection, ErrorCallback, AuthenticationToken, ConnectionCallback } from "./types";
+import { Others, Presence, ClientOptions, Room, MyPresenceCallback, OthersEventCallback, AuthEndpoint, EventCallback, User, Connection, ErrorCallback, AuthenticationToken, ConnectionCallback, StorageCallback, StorageUpdate } from "./types";
 import { ClientMessage, Op } from "./live";
+import { LiveMap } from "./LiveMap";
+import { LiveObject } from "./LiveObject";
+import { LiveList } from "./LiveList";
+import { AbstractCrdt } from "./AbstractCrdt";
+declare type HistoryItem = Array<Op | {
+    type: "presence";
+    data: Presence;
+}>;
 declare type IdFactory = () => string;
 export declare type State = {
     connection: Connection;
     socket: WebSocket | null;
     lastFlushTime: number;
-    flushData: {
+    buffer: {
         presence: Presence | null;
         messages: ClientMessage[];
         storageOperations: Op[];
@@ -24,6 +32,7 @@ export declare type State = {
         "my-presence": MyPresenceCallback[];
         error: ErrorCallback[];
         connection: ConnectionCallback[];
+        storage: StorageCallback[];
     };
     me: Presence;
     others: Others;
@@ -35,6 +44,24 @@ export declare type State = {
     defaultStorageRoot?: {
         [key: string]: any;
     };
+    clock: number;
+    opClock: number;
+    items: Map<string, AbstractCrdt>;
+    root: LiveObject | undefined;
+    undoStack: HistoryItem[];
+    redoStack: HistoryItem[];
+    isHistoryPaused: boolean;
+    pausedHistory: HistoryItem;
+    isBatching: boolean;
+    batch: {
+        ops: Op[];
+        reverseOps: HistoryItem;
+        updates: {
+            others: [];
+            presence: boolean;
+            nodes: Set<AbstractCrdt>;
+        };
+    };
 };
 export declare type Effects = {
     authenticate(): void;
@@ -63,14 +90,23 @@ export declare function makeStateMachine(state: State, context: Context, mockedE
     heartbeat: () => void;
     onNavigatorOnline: () => void;
     onVisibilityChange: (visibilityState: VisibilityState) => void;
+    getUndoStack: () => HistoryItem[];
+    getItemsCount: () => number;
     connect: () => null | undefined;
     disconnect: () => void;
     subscribe: {
-        <T extends Presence>(type: "my-presence", listener: MyPresenceCallback<T>): void;
-        <T_1 extends Presence>(type: "others", listener: OthersEventCallback<T_1>): void;
-        (type: "event", listener: EventCallback): void;
-        (type: "error", listener: ErrorCallback): void;
-        (type: "connection", listener: ConnectionCallback): void;
+        (callback: (updates: StorageUpdate) => void): () => void;
+        <TKey extends string, TValue>(liveMap: LiveMap<TKey, TValue>, callback: (liveMap: LiveMap<TKey, TValue>) => void): () => void;
+        <TData>(liveObject: LiveObject<TData>, callback: (liveObject: LiveObject<TData>) => void): () => void;
+        <TItem>(liveList: LiveList<TItem>, callback: (liveList: LiveList<TItem>) => void): () => void;
+        <TItem_1 extends AbstractCrdt>(node: TItem_1, callback: (updates: StorageUpdate[]) => void, options: {
+            isDeep: true;
+        }): () => void;
+        <T extends Presence>(type: "my-presence", listener: MyPresenceCallback<T>): () => void;
+        <T_1 extends Presence>(type: "others", listener: OthersEventCallback<T_1>): () => void;
+        (type: "event", listener: EventCallback): () => void;
+        (type: "error", listener: ErrorCallback): () => void;
+        (type: "connection", listener: ConnectionCallback): () => void;
     };
     unsubscribe: {
         <T_2 extends Presence>(type: "my-presence", listener: MyPresenceCallback<T_2>): void;
@@ -79,12 +115,17 @@ export declare function makeStateMachine(state: State, context: Context, mockedE
         (type: "error", listener: ErrorCallback): void;
         (type: "connection", listener: ConnectionCallback): void;
     };
-    updatePresence: <T_4 extends Presence>(overrides: Partial<T_4>) => void;
+    updatePresence: <T_4 extends Presence>(overrides: Partial<T_4>, options?: {
+        addToHistory: boolean;
+    } | undefined) => void;
     broadcastEvent: (event: any) => void;
+    batch: (callback: () => void) => void;
     undo: () => void;
     redo: () => void;
+    pauseHistory: () => void;
+    resumeHistory: () => void;
     getStorage: <TRoot>() => Promise<{
-        root: import("./doc").LiveObject<TRoot>;
+        root: LiveObject<TRoot>;
     }>;
     selectors: {
         getConnectionState: () => "failed" | "closed" | "connecting" | "open" | "authenticating" | "unavailable";