@liveblocks/client 0.12.3 → 0.13.2

package/lib/esm/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/esm/LiveRegister.js

@@ -0,0 +1,65 @@
+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;
+import { AbstractCrdt } from "./AbstractCrdt";
+import { CrdtType, OpType } from "./live";
+/**
+ * INTERNAL
+ */
+export class LiveRegister extends 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 !== 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: 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);
+    }
+}
+_LiveRegister_data = new WeakMap();

package/lib/esm/immutable/index.d.ts

@@ -0,0 +1,7 @@
+import { LiveList } from "../LiveList";
+import { LiveObject } from "../LiveObject";
+import { StorageUpdate } from "../types";
+export declare function liveObjectToJson(liveObject: LiveObject<any>): any;
+export declare function patchLiveList<T>(liveList: LiveList<T>, prev: Array<T>, next: Array<T>): void;
+export declare function patchLiveObject<T extends Record<string, any>>(root: LiveObject<T>, prev: T, next: T): void;
+export declare function patchImmutableObject<T>(state: T, updates: StorageUpdate[]): T;

package/lib/esm/immutable/index.js

@@ -0,0 +1,207 @@
+import { LiveList } from "../LiveList";
+import { LiveMap } from "../LiveMap";
+import { LiveObject } from "../LiveObject";
+export function liveObjectToJson(liveObject) {
+    const result = {};
+    const obj = liveObject.toObject();
+    for (const key in obj) {
+        result[key] = liveNodeToJson(obj[key]);
+    }
+    return result;
+}
+function liveMapToJson(map) {
+    const result = {};
+    const obj = Object.fromEntries(map);
+    for (const key in obj) {
+        result[key] = liveNodeToJson(obj[key]);
+    }
+    return result;
+}
+function liveListToJson(value) {
+    return value.toArray().map(liveNodeToJson);
+}
+function liveNodeToJson(value) {
+    if (value instanceof LiveObject) {
+        return liveObjectToJson(value);
+    }
+    else if (value instanceof LiveList) {
+        return liveListToJson(value);
+    }
+    else if (value instanceof LiveMap) {
+        return liveMapToJson(value);
+    }
+    return value;
+}
+function isPlainObject(obj) {
+    return Object.prototype.toString.call(obj) === "[object Object]";
+}
+function anyToCrdt(obj) {
+    if (obj == null) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return new LiveList(obj.map(anyToCrdt));
+    }
+    if (isPlainObject(obj)) {
+        const init = {};
+        for (const key in obj) {
+            init[key] = anyToCrdt(obj[key]);
+        }
+        return new LiveObject(init);
+    }
+    return obj;
+}
+export function patchLiveList(liveList, prev, next) {
+    let i = 0;
+    let prevEnd = prev.length - 1;
+    let nextEnd = next.length - 1;
+    let prevNode = prev[0];
+    let nextNode = next[0];
+    /**
+     * For A,B,C => A,B,C,D
+     * i = 3, prevEnd = 2, nextEnd = 3
+     *
+     * For A,B,C => B,C
+     * i = 2, prevEnd = 2, nextEnd = 1
+     *
+     * For B,C => A,B,C
+     * i = 0, pre
+     */
+    outer: {
+        while (prevNode === nextNode) {
+            ++i;
+            if (i > prevEnd || i > nextEnd) {
+                break outer;
+            }
+            prevNode = prev[i];
+            nextNode = next[i];
+        }
+        prevNode = prev[prevEnd];
+        nextNode = next[nextEnd];
+        while (prevNode === nextNode) {
+            prevEnd--;
+            nextEnd--;
+            if (i > prevEnd || i > nextEnd) {
+                break outer;
+            }
+            prevNode = prev[prevEnd];
+            nextNode = next[nextEnd];
+        }
+    }
+    if (i > prevEnd) {
+        if (i <= nextEnd) {
+            while (i <= nextEnd) {
+                liveList.insert(anyToCrdt(next[i]), i);
+                i++;
+            }
+        }
+    }
+    else if (i > nextEnd) {
+        while (i <= prevEnd) {
+            liveList.delete(i++);
+        }
+    }
+    else {
+        while (i <= prevEnd && i <= nextEnd) {
+            prevNode = prev[i];
+            nextNode = next[i];
+            const liveListNode = liveList.get(i);
+            if (liveListNode instanceof LiveObject &&
+                isPlainObject(prevNode) &&
+                isPlainObject(nextNode)) {
+                patchLiveObject(liveListNode, prevNode, nextNode);
+            }
+            else {
+                liveList.delete(i);
+                liveList.insert(anyToCrdt(nextNode), i);
+            }
+            i++;
+        }
+        while (i <= nextEnd) {
+            liveList.insert(anyToCrdt(next[i]), i);
+            i++;
+        }
+        while (i <= prevEnd) {
+            liveList.delete(i);
+            i++;
+        }
+    }
+}
+export function patchLiveObject(root, prev, next) {
+    const updates = {};
+    for (const key in next) {
+        if (prev[key] === next[key]) {
+            continue;
+        }
+        else if (Array.isArray(prev[key]) && Array.isArray(next[key])) {
+            patchLiveList(root.get(key), prev[key], next[key]);
+        }
+        else if (isPlainObject(prev[key]) && isPlainObject(next[key])) {
+            patchLiveObject(root.get(key), prev[key], next[key]);
+        }
+        else {
+            updates[key] = anyToCrdt(next[key]);
+        }
+    }
+    for (const key in prev) {
+        if (next[key] === undefined) {
+            root.delete(key);
+        }
+    }
+    if (Object.keys(updates).length > 0) {
+        root.update(updates);
+    }
+}
+function getParentsPath(node) {
+    const path = [];
+    while (node._parentKey != null && node._parent != null) {
+        if (node._parent instanceof LiveList) {
+            path.push(node._parent._indexOfPosition(node._parentKey));
+        }
+        else {
+            path.push(node._parentKey);
+        }
+        node = node._parent;
+    }
+    return path;
+}
+export function patchImmutableObject(state, updates) {
+    return updates.reduce((state, update) => patchImmutableObjectWithUpdate(state, update), state);
+}
+function patchImmutableObjectWithUpdate(state, update) {
+    const path = getParentsPath(update.node);
+    return patchImmutableNode(state, path, update);
+}
+function patchImmutableNode(state, path, update) {
+    const pathItem = path.pop();
+    if (pathItem === undefined) {
+        switch (update.type) {
+            case "LiveObject": {
+                if (typeof state !== "object") {
+                    throw new Error("Internal: received update on LiveObject but state was not an object");
+                }
+                return liveObjectToJson(update.node);
+            }
+            case "LiveList": {
+                if (Array.isArray(state) === false) {
+                    throw new Error("Internal: received update on LiveList but state was not an array");
+                }
+                return liveListToJson(update.node);
+            }
+            case "LiveMap": {
+                if (typeof state !== "object") {
+                    throw new Error("Internal: received update on LiveMap but state was not an object");
+                }
+                return liveMapToJson(update.node);
+            }
+        }
+    }
+    if (Array.isArray(state)) {
+        const newArray = [...state];
+        newArray[pathItem] = patchImmutableNode(state[pathItem], path, update);
+        return newArray;
+    }
+    else {
+        return Object.assign(Object.assign({}, state), { [pathItem]: patchImmutableNode(state[pathItem], path, update) });
+    }
+}

package/lib/esm/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/esm/index.js

@@ -1,2 +1,4 @@
-export { LiveObject, LiveList, LiveMap } from "./doc";
+export { LiveObject } from "./LiveObject";
+export { LiveMap } from "./LiveMap";
+export { LiveList } from "./LiveList";
 export { createClient } from "./client";

package/lib/esm/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";