@liveblocks/client 0.13.2 → 0.14.1

package/lib/cjs/{immutable/index.d.ts → immutable.d.ts}

@@ -1,7 +1,9 @@
-import { LiveList } from "../LiveList";
-import { LiveObject } from "../LiveObject";
-import { StorageUpdate } from "../types";
+import { LiveList } from "./LiveList";
+import { LiveObject } from "./LiveObject";
+import { StorageUpdate } from "./types";
 export declare function liveObjectToJson(liveObject: LiveObject<any>): any;
+export declare function liveNodeToJson(value: any): any;
 export declare function patchLiveList<T>(liveList: LiveList<T>, prev: Array<T>, next: Array<T>): void;
+export declare function patchLiveObjectKey<T>(liveObject: LiveObject<T>, key: keyof T, prev: any, next: any): 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/cjs/{immutable/index.js → immutable.js}

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.patchImmutableObject = exports.patchLiveObject = exports.patchLiveList = exports.liveObjectToJson = void 0;
-const LiveList_1 = require("../LiveList");
-const LiveMap_1 = require("../LiveMap");
-const LiveObject_1 = require("../LiveObject");
+exports.patchImmutableObject = exports.patchLiveObject = exports.patchLiveObjectKey = exports.patchLiveList = exports.liveNodeToJson = exports.liveObjectToJson = void 0;
+const LiveList_1 = require("./LiveList");
+const LiveMap_1 = require("./LiveMap");
+const LiveObject_1 = require("./LiveObject");
+const LiveRegister_1 = require("./LiveRegister");
 function liveObjectToJson(liveObject) {
     const result = {};
     const obj = liveObject.toObject();
@@ -34,8 +35,12 @@ function liveNodeToJson(value) {
     else if (value instanceof LiveMap_1.LiveMap) {
         return liveMapToJson(value);
     }
+    else if (value instanceof LiveRegister_1.LiveRegister) {
+        return value.data;
+    }
     return value;
 }
+exports.liveNodeToJson = liveNodeToJson;
 function isPlainObject(obj) {
     return Object.prototype.toString.call(obj) === "[object Object]";
 }
@@ -101,8 +106,10 @@ function patchLiveList(liveList, prev, next) {
         }
     }
     else if (i > nextEnd) {
-        while (i <= prevEnd) {
-            liveList.delete(i++);
+        let localI = i;
+        while (localI <= prevEnd) {
+            liveList.delete(i);
+            localI++;
         }
     }
     else {
@@ -132,21 +139,36 @@ function patchLiveList(liveList, prev, next) {
     }
 }
 exports.patchLiveList = patchLiveList;
+function patchLiveObjectKey(liveObject, key, prev, next) {
+    const value = liveObject.get(key);
+    if (next === undefined) {
+        liveObject.delete(key);
+    }
+    else if (value === undefined) {
+        liveObject.set(key, anyToCrdt(next));
+    }
+    else if (prev === next) {
+        return;
+    }
+    else if (value instanceof LiveList_1.LiveList &&
+        Array.isArray(prev) &&
+        Array.isArray(next)) {
+        patchLiveList(value, prev, next);
+    }
+    else if (value instanceof LiveObject_1.LiveObject &&
+        isPlainObject(prev) &&
+        isPlainObject(next)) {
+        patchLiveObject(value, prev, next);
+    }
+    else {
+        liveObject.set(key, anyToCrdt(next));
+    }
+}
+exports.patchLiveObjectKey = patchLiveObjectKey;
 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]);
-        }
+        patchLiveObjectKey(root, key, prev[key], next[key]);
     }
     for (const key in prev) {
         if (next[key] === undefined) {
@@ -180,6 +202,7 @@ function patchImmutableObjectWithUpdate(state, update) {
     return patchImmutableNode(state, path, update);
 }
 function patchImmutableNode(state, path, update) {
+    var _a, _b, _c, _d;
     const pathItem = path.pop();
     if (pathItem === undefined) {
         switch (update.type) {
@@ -187,19 +210,73 @@ function patchImmutableNode(state, path, update) {
                 if (typeof state !== "object") {
                     throw new Error("Internal: received update on LiveObject but state was not an object");
                 }
-                return liveObjectToJson(update.node);
+                let newState = Object.assign({}, state);
+                for (const key in update.updates) {
+                    if (((_a = update.updates[key]) === null || _a === void 0 ? void 0 : _a.type) === "update") {
+                        newState[key] = liveNodeToJson(update.node.get(key));
+                    }
+                    else if (((_b = update.updates[key]) === null || _b === void 0 ? void 0 : _b.type) === "delete") {
+                        delete newState[key];
+                    }
+                }
+                return newState;
             }
             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);
+                let newState = state.map((x) => x);
+                for (const listUpdate of update.updates) {
+                    if (listUpdate.type === "insert") {
+                        if (listUpdate.index === newState.length) {
+                            newState.push(liveNodeToJson(listUpdate.item));
+                        }
+                        else {
+                            newState = [
+                                ...newState.slice(0, listUpdate.index),
+                                liveNodeToJson(listUpdate.item),
+                                ...newState.slice(listUpdate.index),
+                            ];
+                        }
+                    }
+                    else if (listUpdate.type === "delete") {
+                        newState.splice(listUpdate.index, 1);
+                    }
+                    else if (listUpdate.type === "move") {
+                        if (listUpdate.previousIndex > listUpdate.index) {
+                            newState = [
+                                ...newState.slice(0, listUpdate.index),
+                                liveNodeToJson(listUpdate.item),
+                                ...newState.slice(listUpdate.index, listUpdate.previousIndex),
+                                ...newState.slice(listUpdate.previousIndex + 1),
+                            ];
+                        }
+                        else {
+                            newState = [
+                                ...newState.slice(0, listUpdate.previousIndex),
+                                ...newState.slice(listUpdate.previousIndex + 1, listUpdate.index + 1),
+                                liveNodeToJson(listUpdate.item),
+                                ...newState.slice(listUpdate.index + 1),
+                            ];
+                        }
+                    }
+                }
+                return newState;
             }
             case "LiveMap": {
                 if (typeof state !== "object") {
                     throw new Error("Internal: received update on LiveMap but state was not an object");
                 }
-                return liveMapToJson(update.node);
+                let newState = Object.assign({}, state);
+                for (const key in update.updates) {
+                    if (((_c = update.updates[key]) === null || _c === void 0 ? void 0 : _c.type) === "update") {
+                        newState[key] = liveNodeToJson(update.node.get(key));
+                    }
+                    else if (((_d = update.updates[key]) === null || _d === void 0 ? void 0 : _d.type) === "delete") {
+                        delete newState[key];
+                    }
+                }
+                return newState;
             }
         }
     }

package/lib/cjs/index.d.ts

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

package/lib/cjs/live.d.ts

@@ -122,6 +122,7 @@ export declare type UpdateObjectOp = {
     };
 };
 export declare type CreateObjectOp = {
+    opId?: string;
     id: string;
     type: OpType.CreateObject;
     parentId?: string;
@@ -131,18 +132,21 @@ export declare type CreateObjectOp = {
     };
 };
 export declare type CreateListOp = {
+    opId?: string;
     id: string;
     type: OpType.CreateList;
     parentId: string;
     parentKey: string;
 };
 export declare type CreateMapOp = {
+    opId?: string;
     id: string;
     type: OpType.CreateMap;
     parentId: string;
     parentKey: string;
 };
 export declare type CreateRegisterOp = {
+    opId?: string;
     id: string;
     type: OpType.CreateRegister;
     parentId: string;
@@ -150,15 +154,18 @@ export declare type CreateRegisterOp = {
     data: any;
 };
 export declare type DeleteCrdtOp = {
+    opId?: string;
     id: string;
     type: OpType.DeleteCrdt;
 };
 export declare type SetParentKeyOp = {
+    opId?: string;
     id: string;
     type: OpType.SetParentKey;
     parentKey: string;
 };
 export declare type DeleteObjectKeyOp = {
+    opId?: string;
     id: string;
     type: OpType.DeleteObjectKey;
     key: string;

package/lib/cjs/room.d.ts

@@ -1,4 +1,4 @@
-import { Others, Presence, ClientOptions, Room, MyPresenceCallback, OthersEventCallback, AuthEndpoint, EventCallback, User, Connection, ErrorCallback, AuthenticationToken, ConnectionCallback, StorageCallback, StorageUpdate } from "./types";
+import { Others, Presence, Room, MyPresenceCallback, OthersEventCallback, EventCallback, User, Connection, ErrorCallback, AuthenticationToken, ConnectionCallback, StorageCallback, StorageUpdate, BroadcastOptions, AuthorizeResponse, Authentication } from "./types";
 import { ClientMessage, Op } from "./live";
 import { LiveMap } from "./LiveMap";
 import { LiveObject } from "./LiveObject";
@@ -11,6 +11,7 @@ declare type HistoryItem = Array<Op | {
 declare type IdFactory = () => string;
 export declare type State = {
     connection: Connection;
+    lastConnectionId: number | null;
     socket: WebSocket | null;
     lastFlushTime: number;
     buffer: {
@@ -62,9 +63,10 @@ export declare type State = {
             nodes: Set<AbstractCrdt>;
         };
     };
+    offlineOperations: Map<string, Op>;
 };
 export declare type Effects = {
-    authenticate(): void;
+    authenticate(auth: (room: string) => Promise<AuthorizeResponse>, createWebSocket: (token: string) => WebSocket): void;
     send(messages: ClientMessage[]): void;
     delayFlush(delay: number): number;
     startHeartbeatInterval(): number;
@@ -73,13 +75,13 @@ export declare type Effects = {
 };
 declare type Context = {
     room: string;
-    authEndpoint: AuthEndpoint;
-    liveblocksServer: string;
     throttleDelay: number;
-    publicApiKey?: string;
+    fetchPolyfill?: typeof fetch;
+    WebSocketPolyfill?: typeof WebSocket;
+    authentication: Authentication;
+    liveblocksServer: string;
 };
 export declare function makeStateMachine(state: State, context: Context, mockedEffects?: Effects): {
-    onOpen: () => void;
     onClose: (event: {
         code: number;
         wasClean: boolean;
@@ -89,6 +91,12 @@ export declare function makeStateMachine(state: State, context: Context, mockedE
     authenticationSuccess: (token: AuthenticationToken, socket: WebSocket) => void;
     heartbeat: () => void;
     onNavigatorOnline: () => void;
+    simulateSocketClose: () => void;
+    simulateSendCloseEvent: (event: {
+        code: number;
+        wasClean: boolean;
+        reason: any;
+    }) => void;
     onVisibilityChange: (visibilityState: VisibilityState) => void;
     getUndoStack: () => HistoryItem[];
     getItemsCount: () => number;
@@ -118,7 +126,7 @@ export declare function makeStateMachine(state: State, context: Context, mockedE
     updatePresence: <T_4 extends Presence>(overrides: Partial<T_4>, options?: {
         addToHistory: boolean;
     } | undefined) => void;
-    broadcastEvent: (event: any) => void;
+    broadcastEvent: (event: any, options?: BroadcastOptions) => void;
     batch: (callback: () => void) => void;
     undo: () => void;
     redo: () => void;
@@ -144,8 +152,8 @@ export declare type InternalRoom = {
     onNavigatorOnline: () => void;
     onVisibilityChange: (visibilityState: VisibilityState) => void;
 };
-export declare function createRoom(name: string, options: ClientOptions & {
+export declare function createRoom(options: {
     defaultPresence?: Presence;
     defaultStorageRoot?: Record<string, any>;
-}): InternalRoom;
+}, context: Context): InternalRoom;
 export {};