@liveblocks/client 0.15.0-alpha.2 → 0.15.0-alpha.3

package/lib/cjs/AbstractCrdt.d.ts

@@ -9,6 +9,7 @@ export declare type ApplyResult = {
 export interface Doc {
     generateId: () => string;
     generateOpId: () => string;
+    getItem: (id: string) => AbstractCrdt | undefined;
     addItem: (id: string, item: AbstractCrdt) => void;
     deleteItem: (id: string) => void;
     dispatch: (ops: Op[], reverseOps: Op[], storageUpdates: Map<string, StorageUpdate>) => void;
@@ -46,7 +47,7 @@ export declare abstract class AbstractCrdt {
     /**
      * INTERNAL
      */
-    abstract _attachChild(id: string, key: string, crdt: AbstractCrdt, isLocal: boolean): ApplyResult;
+    abstract _attachChild(id: string, key: string, crdt: AbstractCrdt, opId: string, isLocal: boolean): ApplyResult;
     /**
      * INTERNAL
      */

package/lib/cjs/LiveList.d.ts

@@ -26,7 +26,7 @@ export declare class LiveList<T> extends AbstractCrdt {
     /**
      * INTERNAL
      */
-    _attachChild(id: string, key: string, child: AbstractCrdt, isLocal: boolean): ApplyResult;
+    _attachChild(id: string, key: string, child: AbstractCrdt, opId: string, isLocal: boolean): ApplyResult;
     /**
      * INTERNAL
      */

package/lib/cjs/LiveList.js

@@ -100,11 +100,14 @@ class LiveList extends AbstractCrdt_1.AbstractCrdt {
     /**
      * INTERNAL
      */
-    _attachChild(id, key, child, isLocal) {
+    _attachChild(id, key, child, opId, isLocal) {
         var _a;
         if (this._doc == null) {
             throw new Error("Can't attach child if doc is not present");
         }
+        if (this._doc.getItem(id) !== undefined) {
+            return { modified: false };
+        }
         child._attach(id, this._doc);
         child._setParentLink(this, key);
         const index = __classPrivateFieldGet(this, _LiveList_items, "f").findIndex((entry) => entry[1] === key);

package/lib/cjs/LiveMap.d.ts

@@ -23,7 +23,7 @@ export declare class LiveMap<TKey extends string, TValue> extends AbstractCrdt {
     /**
      * INTERNAL
      */
-    _attachChild(id: string, key: TKey, child: AbstractCrdt, isLocal: boolean): ApplyResult;
+    _attachChild(id: string, key: TKey, child: AbstractCrdt, opId: string, isLocal: boolean): ApplyResult;
     /**
      * INTERNAL
      */

package/lib/cjs/LiveMap.js

@@ -100,10 +100,13 @@ class LiveMap extends AbstractCrdt_1.AbstractCrdt {
     /**
      * INTERNAL
      */
-    _attachChild(id, key, child, isLocal) {
+    _attachChild(id, key, child, opId, isLocal) {
         if (this._doc == null) {
             throw new Error("Can't attach child if doc is not present");
         }
+        if (this._doc.getItem(id) !== undefined) {
+            return { modified: false };
+        }
         const previousValue = __classPrivateFieldGet(this, _LiveMap_map, "f").get(key);
         let reverse;
         if (previousValue) {

package/lib/cjs/LiveObject.d.ts

@@ -27,7 +27,7 @@ export declare class LiveObject<T extends Record<string, any> = Record<string, a
     /**
      * INTERNAL
      */
-    _attachChild(id: string, key: keyof T, child: AbstractCrdt, isLocal: boolean): ApplyResult;
+    _attachChild(id: string, key: keyof T, child: AbstractCrdt, opId: string, isLocal: boolean): ApplyResult;
     /**
      * INTERNAL
      */

package/lib/cjs/LiveObject.js

@@ -106,10 +106,32 @@ class LiveObject extends AbstractCrdt_1.AbstractCrdt {
     /**
      * INTERNAL
      */
-    _attachChild(id, key, child, isLocal) {
+    _attachChild(id, key, child, opId, isLocal) {
         if (this._doc == null) {
             throw new Error("Can't attach child if doc is not present");
         }
+        if (this._doc.getItem(id) !== undefined) {
+            if (__classPrivateFieldGet(this, _LiveObject_propToLastUpdate, "f").get(key) === opId) {
+                // Acknowlegment from local operation
+                __classPrivateFieldGet(this, _LiveObject_propToLastUpdate, "f").delete(key);
+            }
+            return { modified: false };
+        }
+        if (isLocal) {
+            __classPrivateFieldGet(this, _LiveObject_propToLastUpdate, "f").set(key, opId);
+        }
+        else if (__classPrivateFieldGet(this, _LiveObject_propToLastUpdate, "f").get(key) === undefined) {
+            // Remote operation with no local change => apply operation
+        }
+        else if (__classPrivateFieldGet(this, _LiveObject_propToLastUpdate, "f").get(key) === opId) {
+            // Acknowlegment from local operation
+            __classPrivateFieldGet(this, _LiveObject_propToLastUpdate, "f").delete(key);
+            return { modified: false };
+        }
+        else {
+            // Conflict, ignore remote operation
+            return { modified: false };
+        }
         const previousValue = __classPrivateFieldGet(this, _LiveObject_map, "f").get(key);
         let reverse;
         if ((0, utils_1.isCrdt)(previousValue)) {
@@ -314,7 +336,6 @@ class LiveObject extends AbstractCrdt_1.AbstractCrdt {
         };
         const updateDelta = {};
         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));
@@ -330,10 +351,16 @@ class LiveObject extends AbstractCrdt_1.AbstractCrdt {
             if (newValue instanceof AbstractCrdt_1.AbstractCrdt) {
                 newValue._setParentLink(this, key);
                 newValue._attach(this._doc.generateId(), this._doc);
-                ops.push(...newValue._serialize(this._id, key, this._doc));
+                const newAttachChildOps = newValue._serialize(this._id, key, this._doc);
+                const createCrdtOp = newAttachChildOps.find((op) => op.parentId === this._id);
+                if (createCrdtOp) {
+                    __classPrivateFieldGet(this, _LiveObject_propToLastUpdate, "f").set(key, createCrdtOp.opId);
+                }
+                ops.push(...newAttachChildOps);
             }
             else {
                 updatedProps[key] = newValue;
+                __classPrivateFieldGet(this, _LiveObject_propToLastUpdate, "f").set(key, opId);
             }
             __classPrivateFieldGet(this, _LiveObject_map, "f").set(key, newValue);
             updateDelta[key] = { type: "update" };
@@ -426,6 +453,11 @@ _LiveObject_map = new WeakMap(), _LiveObject_propToLastUpdate = new WeakMap(), _
     if (__classPrivateFieldGet(this, _LiveObject_map, "f").has(key) === false) {
         return { modified: false };
     }
+    // If a local operation exists on the same key
+    // prevent flickering by not applying delete op.
+    if (__classPrivateFieldGet(this, _LiveObject_propToLastUpdate, "f").get(key) !== undefined) {
+        return { modified: false };
+    }
     const oldValue = __classPrivateFieldGet(this, _LiveObject_map, "f").get(key);
     let reverse = [];
     if ((0, utils_1.isCrdt)(oldValue)) {

package/lib/cjs/LiveRegister.d.ts

@@ -19,7 +19,7 @@ export declare class LiveRegister<TValue = any> extends AbstractCrdt {
      * INTERNAL
      */
     _toSerializedCrdt(): SerializedCrdt;
-    _attachChild(id: string, key: string, crdt: AbstractCrdt, isLocal: boolean): ApplyResult;
+    _attachChild(id: string, key: string, crdt: AbstractCrdt, opId: string, isLocal: boolean): ApplyResult;
     _detachChild(crdt: AbstractCrdt): ApplyResult;
     _apply(op: Op, isLocal: boolean): ApplyResult;
     /**

package/lib/cjs/LiveRegister.js

@@ -68,7 +68,7 @@ class LiveRegister extends AbstractCrdt_1.AbstractCrdt {
             data: this.data,
         };
     }
-    _attachChild(id, key, crdt, isLocal) {
+    _attachChild(id, key, crdt, opId, isLocal) {
         throw new Error("Method not implemented.");
     }
     _detachChild(crdt) {

package/lib/cjs/client.js

@@ -29,11 +29,7 @@ const room_1 = require("./room");
  */
 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);
@@ -44,9 +40,21 @@ function createClient(options) {
         if (internalRoom) {
             return internalRoom.room;
         }
-        internalRoom = (0, room_1.createRoom)(roomId, Object.assign(Object.assign({}, clientOptions), options));
+        internalRoom = (0, room_1.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) {
@@ -78,3 +86,38 @@ function createClient(options) {
     };
 }
 exports.createClient = createClient;
+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/cjs/immutable.js

@@ -5,6 +5,7 @@ const LiveList_1 = require("./LiveList");
 const LiveMap_1 = require("./LiveMap");
 const LiveObject_1 = require("./LiveObject");
 const LiveRegister_1 = require("./LiveRegister");
+const utils_1 = require("./utils");
 function liveObjectToJson(liveObject) {
     const result = {};
     const obj = liveObject.toObject();
@@ -140,6 +141,13 @@ function patchLiveList(liveList, prev, next) {
 }
 exports.patchLiveList = patchLiveList;
 function patchLiveObjectKey(liveObject, key, prev, next) {
+    if (process.env.NODE_ENV !== "production") {
+        const nonSerializableValue = (0, utils_1.findNonSerializableValue)(next);
+        if (nonSerializableValue) {
+            console.error(`New state path: '${nonSerializableValue.path}' value: '${nonSerializableValue.value}' is not serializable.\nOnly serializable value can be synced with Liveblocks.`);
+            return;
+        }
+    }
     const value = liveObject.get(key);
     if (next === undefined) {
         liveObject.delete(key);

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, BroadcastOptions } 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";
@@ -66,7 +66,7 @@ export declare type State = {
     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;
@@ -75,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;
@@ -152,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 {};

package/lib/cjs/room.js

@@ -1,23 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -30,7 +11,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRoom = exports.defaultState = exports.makeStateMachine = void 0;
 const utils_1 = require("./utils");
-const authentication_1 = __importStar(require("./authentication"));
 const live_1 = require("./live");
 const LiveMap_1 = require("./LiveMap");
 const LiveObject_1 = require("./LiveObject");
@@ -75,16 +55,12 @@ function log(...params) {
 }
 function makeStateMachine(state, context, mockedEffects) {
     const effects = mockedEffects || {
-        authenticate() {
+        authenticate(auth, createWebSocket) {
             return __awaiter(this, void 0, void 0, function* () {
                 try {
-                    const token = yield (0, authentication_1.default)(context.authEndpoint, context.room, context.publicApiKey);
-                    const parsedToken = (0, authentication_1.parseToken)(token);
-                    const socket = new WebSocket(`${context.liveblocksServer}/?token=${token}`);
-                    socket.addEventListener("message", onMessage);
-                    socket.addEventListener("open", onOpen);
-                    socket.addEventListener("close", onClose);
-                    socket.addEventListener("error", onError);
+                    const { token } = yield auth(context.room);
+                    const parsedToken = parseToken(token);
+                    const socket = createWebSocket(token);
                     authenticationSuccess(parsedToken, socket);
                 }
                 catch (er) {
@@ -187,6 +163,7 @@ function makeStateMachine(state, context, mockedEffects) {
     function load(items) {
         const [root, parentToChildren] = buildRootAndParentToChildren(items);
         return LiveObject_1.LiveObject._deserialize(root, parentToChildren, {
+            getItem,
             addItem,
             deleteItem,
             generateId,
@@ -341,31 +318,31 @@ function makeStateMachine(state, context, mockedEffects) {
             }
             case live_1.OpType.CreateObject: {
                 const parent = state.items.get(op.parentId);
-                if (parent == null || getItem(op.id) != null) {
+                if (parent == null) {
                     return { modified: false };
                 }
-                return parent._attachChild(op.id, op.parentKey, new LiveObject_1.LiveObject(op.data), isLocal);
+                return parent._attachChild(op.id, op.parentKey, new LiveObject_1.LiveObject(op.data), op.opId, isLocal);
             }
             case live_1.OpType.CreateList: {
                 const parent = state.items.get(op.parentId);
-                if (parent == null || getItem(op.id) != null) {
+                if (parent == null) {
                     return { modified: false };
                 }
-                return parent._attachChild(op.id, op.parentKey, new LiveList_1.LiveList(), isLocal);
+                return parent._attachChild(op.id, op.parentKey, new LiveList_1.LiveList(), op.opId, isLocal);
             }
             case live_1.OpType.CreateRegister: {
                 const parent = state.items.get(op.parentId);
-                if (parent == null || getItem(op.id) != null) {
+                if (parent == null) {
                     return { modified: false };
                 }
-                return parent._attachChild(op.id, op.parentKey, new LiveRegister_1.LiveRegister(op.data), isLocal);
+                return parent._attachChild(op.id, op.parentKey, new LiveRegister_1.LiveRegister(op.data), op.opId, isLocal);
             }
             case live_1.OpType.CreateMap: {
                 const parent = state.items.get(op.parentId);
-                if (parent == null || getItem(op.id) != null) {
+                if (parent == null) {
                     return { modified: false };
                 }
-                return parent._attachChild(op.id, op.parentKey, new LiveMap_1.LiveMap(), isLocal);
+                return parent._attachChild(op.id, op.parentKey, new LiveMap_1.LiveMap(), op.opId, isLocal);
             }
         }
         return { modified: false };
@@ -412,15 +389,14 @@ See v0.13 release notes for more information.
             : null;
     }
     function connect() {
-        if (typeof window === "undefined") {
-            return;
-        }
         if (state.connection.state !== "closed" &&
             state.connection.state !== "unavailable") {
             return null;
         }
+        const auth = prepareAuthEndpoint(context.authentication, context.fetchPolyfill);
+        const createWebSocket = prepareCreateWebSocket(context.liveblocksServer, context.WebSocketPolyfill);
         updateConnection({ state: "authenticating" });
-        effects.authenticate();
+        effects.authenticate(auth, createWebSocket);
     }
     function updatePresence(overrides, options) {
         const oldValues = {};
@@ -447,6 +423,10 @@ See v0.13 release notes for more information.
         }
     }
     function authenticationSuccess(token, socket) {
+        socket.addEventListener("message", onMessage);
+        socket.addEventListener("open", onOpen);
+        socket.addEventListener("close", onClose);
+        socket.addEventListener("error", onError);
         updateConnection({
             state: "connecting",
             id: token.actor,
@@ -680,7 +660,7 @@ See v0.13 release notes for more information.
         }
         clearTimeout(state.timeoutHandles.pongTimeout);
         state.timeoutHandles.pongTimeout = effects.schedulePongTimeout();
-        if (state.socket.readyState === WebSocket.OPEN) {
+        if (state.socket.readyState === state.socket.OPEN) {
             state.socket.send("ping");
         }
     }
@@ -727,7 +707,7 @@ See v0.13 release notes for more information.
                 state.offlineOperations.set(op.opId, op);
             });
         }
-        if (state.socket == null || state.socket.readyState !== WebSocket.OPEN) {
+        if (state.socket == null || state.socket.readyState !== state.socket.OPEN) {
             state.buffer.storageOperations = [];
             return;
         }
@@ -934,7 +914,6 @@ See v0.13 release notes for more information.
     }
     return {
         // Internal
-        onOpen,
         onClose,
         onMessage,
         authenticationSuccess,
@@ -1028,26 +1007,9 @@ function defaultState(me, defaultStorageRoot) {
     };
 }
 exports.defaultState = defaultState;
-function createRoom(name, options) {
-    const throttleDelay = options.throttle || 100;
-    const liveblocksServer = options.liveblocksServer || "wss://liveblocks.net/v5";
-    let authEndpoint;
-    if (options.authEndpoint) {
-        authEndpoint = options.authEndpoint;
-    }
-    else {
-        const publicAuthorizeEndpoint = options.publicAuthorizeEndpoint ||
-            "https://liveblocks.io/api/public/authorize";
-        authEndpoint = publicAuthorizeEndpoint;
-    }
+function createRoom(options, context) {
     const state = defaultState(options.defaultPresence, options.defaultStorageRoot);
-    const machine = makeStateMachine(state, {
-        throttleDelay,
-        liveblocksServer,
-        authEndpoint,
-        room: name,
-        publicApiKey: options.publicApiKey,
-    });
+    const machine = makeStateMachine(state, context);
     const room = {
         /////////////
         // Core    //
@@ -1092,3 +1054,76 @@ class LiveblocksError extends Error {
         this.code = code;
     }
 }
+function parseToken(token) {
+    const tokenParts = token.split(".");
+    if (tokenParts.length !== 3) {
+        throw new Error(`Authentication error. Liveblocks could not parse the response of your authentication endpoint`);
+    }
+    const data = JSON.parse(atob(tokenParts[1]));
+    if (typeof data.actor !== "number") {
+        throw new Error(`Authentication error. Liveblocks could not parse the response of your authentication endpoint`);
+    }
+    return data;
+}
+function prepareCreateWebSocket(liveblocksServer, WebSocketPolyfill) {
+    if (typeof window === "undefined" && WebSocketPolyfill == null) {
+        throw new Error("To use Liveblocks client in a non-dom environment, you need to provide a WebSocket polyfill.");
+    }
+    const ws = WebSocketPolyfill || WebSocket;
+    return (token) => {
+        return new ws(`${liveblocksServer}/?token=${token}`);
+    };
+}
+function prepareAuthEndpoint(authentication, fetchPolyfill) {
+    if (authentication.type === "public") {
+        if (typeof window === "undefined" && fetchPolyfill == null) {
+            throw new Error("To use Liveblocks client in a non-dom environment with a publicApiKey, you need to provide a fetch polyfill.");
+        }
+        return (room) => fetchAuthEndpoint(fetchPolyfill || fetch, authentication.url, {
+            room,
+            publicApiKey: authentication.publicApiKey,
+        });
+    }
+    if (authentication.type === "private") {
+        if (typeof window === "undefined" && fetchPolyfill == null) {
+            throw new Error("To use Liveblocks client in a non-dom environment with a url as auth endpoint, you need to provide a fetch polyfill.");
+        }
+        return (room) => fetchAuthEndpoint(fetchPolyfill || fetch, authentication.url, {
+            room,
+        });
+    }
+    if (authentication.type === "custom") {
+        return authentication.callback;
+    }
+    throw new Error("Internal error. Unexpected authentication type");
+}
+function fetchAuthEndpoint(fetch, endpoint, body) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const res = yield fetch(endpoint, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            throw new AuthenticationError(`Authentication error. Liveblocks could not parse the response of your authentication "${endpoint}"`);
+        }
+        let authResponse = null;
+        try {
+            authResponse = yield res.json();
+        }
+        catch (er) {
+            throw new AuthenticationError(`Authentication error. Liveblocks could not parse the response of your authentication "${endpoint}"`);
+        }
+        if (typeof authResponse.token !== "string") {
+            throw new AuthenticationError(`Authentication error. Liveblocks could not parse the response of your authentication "${endpoint}"`);
+        }
+        return authResponse;
+    });
+}
+class AuthenticationError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}

package/lib/cjs/types.d.ts

@@ -146,6 +146,8 @@ export declare type AuthEndpoint = string | AuthEndpointCallback;
  */
 export declare type ClientOptions = {
     throttle?: number;
+    fetchPolyfill?: any;
+    WebSocketPolyfill?: any;
 } & ({
     publicApiKey: string;
     authEndpoint?: never;
@@ -156,6 +158,17 @@ export declare type ClientOptions = {
 export declare type AuthorizeResponse = {
     token: string;
 };
+export declare type Authentication = {
+    type: "public";
+    publicApiKey: string;
+    url: string;
+} | {
+    type: "private";
+    url: string;
+} | {
+    type: "custom";
+    callback: (room: string) => Promise<AuthorizeResponse>;
+};
 declare type ConnectionState = "closed" | "authenticating" | "unavailable" | "failed" | "open" | "connecting";
 export declare type Connection = {
     state: "closed" | "authenticating" | "unavailable" | "failed";

package/lib/cjs/utils.d.ts

@@ -9,3 +9,7 @@ export declare function selfOrRegisterValue(obj: AbstractCrdt): any;
 export declare function selfOrRegister(obj: any): AbstractCrdt;
 export declare function getTreesDiffOperations(currentItems: Map<string, SerializedCrdt>, newItems: Map<string, SerializedCrdt>): Op[];
 export declare function mergeStorageUpdates(first: StorageUpdate | undefined, second: StorageUpdate): StorageUpdate;
+export declare function findNonSerializableValue(value: any, path?: string): {
+    path: string;
+    value: any;
+} | false;