@liveblocks/client 0.13.2 → 0.14.1

package/lib/esm/client.js

@@ -26,11 +26,7 @@ import { createRoom } from "./room";
  */
 export function createClient(options) {
     const clientOptions = options;
-    if (typeof clientOptions.throttle === "number") {
-        if (clientOptions.throttle < 80 || clientOptions.throttle > 1000) {
-            throw new Error("Liveblocks client throttle should be between 80 and 1000 ms");
-        }
-    }
+    const throttleDelay = getThrottleDelayFromOptions(options);
     const rooms = new Map();
     function getRoom(roomId) {
         const internalRoom = rooms.get(roomId);
@@ -41,9 +37,21 @@ export function createClient(options) {
         if (internalRoom) {
             return internalRoom.room;
         }
-        internalRoom = createRoom(roomId, Object.assign(Object.assign({}, clientOptions), options));
+        internalRoom = createRoom({
+            defaultPresence: options.defaultPresence,
+            defaultStorageRoot: options.defaultStorageRoot,
+        }, {
+            room: roomId,
+            throttleDelay,
+            WebSocketPolyfill: clientOptions.WebSocketPolyfill,
+            fetchPolyfill: clientOptions.fetchPolyfill,
+            liveblocksServer: clientOptions.liveblocksServer || "wss://liveblocks.net/v5",
+            authentication: prepareAuthentication(clientOptions),
+        });
         rooms.set(roomId, internalRoom);
-        internalRoom.connect();
+        if (!options.DO_NOT_USE_withoutConnecting) {
+            internalRoom.connect();
+        }
         return internalRoom.room;
     }
     function leave(roomId) {
@@ -74,3 +82,38 @@ export function createClient(options) {
         leave,
     };
 }
+function getThrottleDelayFromOptions(options) {
+    if (options.throttle === undefined) {
+        return 100;
+    }
+    if (typeof options.throttle !== "number" ||
+        options.throttle < 80 ||
+        options.throttle > 1000) {
+        throw new Error("throttle should be a number between 80 and 1000.");
+    }
+    return options.throttle;
+}
+function prepareAuthentication(clientOptions) {
+    // TODO: throw descriptive errors for invalid options
+    if (typeof clientOptions.publicApiKey === "string") {
+        return {
+            type: "public",
+            publicApiKey: clientOptions.publicApiKey,
+            url: clientOptions.publicAuthorizeEndpoint ||
+                "https://liveblocks.io/api/public/authorize",
+        };
+    }
+    else if (typeof clientOptions.authEndpoint === "string") {
+        return {
+            type: "private",
+            url: clientOptions.authEndpoint,
+        };
+    }
+    else if (typeof clientOptions.authEndpoint === "function") {
+        return {
+            type: "custom",
+            callback: clientOptions.authEndpoint,
+        };
+    }
+    throw new Error("Invalid Liveblocks client options. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClient");
+}

package/lib/esm/{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/esm/{immutable/index.js → immutable.js}

@@ -1,6 +1,7 @@
-import { LiveList } from "../LiveList";
-import { LiveMap } from "../LiveMap";
-import { LiveObject } from "../LiveObject";
+import { LiveList } from "./LiveList";
+import { LiveMap } from "./LiveMap";
+import { LiveObject } from "./LiveObject";
+import { LiveRegister } from "./LiveRegister";
 export function liveObjectToJson(liveObject) {
     const result = {};
     const obj = liveObject.toObject();
@@ -20,7 +21,7 @@ function liveMapToJson(map) {
 function liveListToJson(value) {
     return value.toArray().map(liveNodeToJson);
 }
-function liveNodeToJson(value) {
+export function liveNodeToJson(value) {
     if (value instanceof LiveObject) {
         return liveObjectToJson(value);
     }
@@ -30,6 +31,9 @@ function liveNodeToJson(value) {
     else if (value instanceof LiveMap) {
         return liveMapToJson(value);
     }
+    else if (value instanceof LiveRegister) {
+        return value.data;
+    }
     return value;
 }
 function isPlainObject(obj) {
@@ -97,8 +101,10 @@ export 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 {
@@ -127,21 +133,35 @@ export function patchLiveList(liveList, prev, next) {
         }
     }
 }
+export 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 &&
+        Array.isArray(prev) &&
+        Array.isArray(next)) {
+        patchLiveList(value, prev, next);
+    }
+    else if (value instanceof LiveObject &&
+        isPlainObject(prev) &&
+        isPlainObject(next)) {
+        patchLiveObject(value, prev, next);
+    }
+    else {
+        liveObject.set(key, anyToCrdt(next));
+    }
+}
 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]);
-        }
+        patchLiveObjectKey(root, key, prev[key], next[key]);
     }
     for (const key in prev) {
         if (next[key] === undefined) {
@@ -173,6 +193,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) {
@@ -180,19 +201,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/esm/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/esm/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/esm/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 {};