@liveblocks/client 0.12.2 → 0.13.1

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/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";