@liveblocks/client 0.17.11-debug1 → 0.17.11-debug2

package/index.mjs

@@ -1,7 +1,1364 @@
-import mod from "./index.js";
+import {
+  LiveList,
+  LiveMap,
+  LiveObject,
+  compact,
+  errorIf,
+  getTreesDiffOperations,
+  isJsonArray,
+  isJsonObject,
+  isLiveList,
+  isLiveNode,
+  isPlainObject,
+  isRoomEventName,
+  isRootCrdt,
+  isSameNodeOrChildOf,
+  isTokenExpired,
+  mergeStorageUpdates,
+  nn,
+  parseRoomAuthToken,
+  remove,
+  tryParseJson
+} from "./chunk-ATVOU6HF.mjs";
 
-export default mod;
-export const LiveList = mod.LiveList;
-export const LiveMap = mod.LiveMap;
-export const LiveObject = mod.LiveObject;
-export const createClient = mod.createClient;
+// src/room.ts
+var BACKOFF_RETRY_DELAYS = [250, 500, 1e3, 2e3, 4e3, 8e3, 1e4];
+var BACKOFF_RETRY_DELAYS_SLOW = [2e3, 3e4, 6e4, 3e5];
+var HEARTBEAT_INTERVAL = 3e4;
+var PONG_TIMEOUT = 2e3;
+function makeIdFactory(connectionId) {
+  let count = 0;
+  return () => `${connectionId}:${count++}`;
+}
+function makeOthers(userMap) {
+  const users = Object.values(userMap).map((user) => {
+    const { _hasReceivedInitialPresence, ...publicKeys } = user;
+    return publicKeys;
+  });
+  return {
+    get count() {
+      return users.length;
+    },
+    [Symbol.iterator]() {
+      return users[Symbol.iterator]();
+    },
+    map(callback) {
+      return users.map(callback);
+    },
+    toArray() {
+      return users;
+    }
+  };
+}
+function log(..._params) {
+  return;
+}
+function makeStateMachine(state, context, mockedEffects) {
+  const effects = mockedEffects || {
+    authenticate(auth, createWebSocket) {
+      const rawToken = state.token;
+      const parsedToken = rawToken !== null && parseRoomAuthToken(rawToken);
+      if (parsedToken && !isTokenExpired(parsedToken)) {
+        const socket = createWebSocket(rawToken);
+        authenticationSuccess(parsedToken, socket);
+      } else {
+        return auth(context.roomId).then(({ token }) => {
+          if (state.connection.state !== "authenticating") {
+            return;
+          }
+          const parsedToken2 = parseRoomAuthToken(token);
+          const socket = createWebSocket(token);
+          authenticationSuccess(parsedToken2, socket);
+          state.token = token;
+        }).catch(
+          (er) => authenticationFailure(
+            er instanceof Error ? er : new Error(String(er))
+          )
+        );
+      }
+    },
+    send(messageOrMessages) {
+      if (state.socket == null) {
+        throw new Error("Can't send message if socket is null");
+      }
+      state.socket.send(JSON.stringify(messageOrMessages));
+    },
+    delayFlush(delay) {
+      return setTimeout(tryFlushing, delay);
+    },
+    startHeartbeatInterval() {
+      return setInterval(heartbeat, HEARTBEAT_INTERVAL);
+    },
+    schedulePongTimeout() {
+      return setTimeout(pongTimeout, PONG_TIMEOUT);
+    },
+    scheduleReconnect(delay) {
+      return setTimeout(connect, delay);
+    }
+  };
+  function genericSubscribe(callback) {
+    state.listeners.storage.push(callback);
+    return () => remove(state.listeners.storage, callback);
+  }
+  function subscribeToLiveStructureDeeply(node, callback) {
+    return genericSubscribe((updates) => {
+      const relatedUpdates = updates.filter(
+        (update) => isSameNodeOrChildOf(update.node, node)
+      );
+      if (relatedUpdates.length > 0) {
+        callback(relatedUpdates);
+      }
+    });
+  }
+  function subscribeToLiveStructureShallowly(node, callback) {
+    return genericSubscribe((updates) => {
+      for (const update of updates) {
+        if (update.node._id === node._id) {
+          callback(update.node);
+        }
+      }
+    });
+  }
+  function createOrUpdateRootFromMessage(message) {
+    if (message.items.length === 0) {
+      throw new Error("Internal error: cannot load storage without items");
+    }
+    if (state.root) {
+      updateRoot(message.items);
+    } else {
+      state.root = load(message.items);
+    }
+    for (const key in state.defaultStorageRoot) {
+      if (state.root.get(key) == null) {
+        state.root.set(key, state.defaultStorageRoot[key]);
+      }
+    }
+  }
+  function buildRootAndParentToChildren(items) {
+    const parentToChildren = /* @__PURE__ */ new Map();
+    let root = null;
+    for (const [id, crdt] of items) {
+      if (isRootCrdt(crdt)) {
+        root = [id, crdt];
+      } else {
+        const tuple = [id, crdt];
+        const children = parentToChildren.get(crdt.parentId);
+        if (children != null) {
+          children.push(tuple);
+        } else {
+          parentToChildren.set(crdt.parentId, [tuple]);
+        }
+      }
+    }
+    if (root == null) {
+      throw new Error("Root can't be null");
+    }
+    return [root, parentToChildren];
+  }
+  function updateRoot(items) {
+    if (!state.root) {
+      return;
+    }
+    const currentItems = /* @__PURE__ */ new Map();
+    state.items.forEach((liveCrdt, id) => {
+      currentItems.set(id, liveCrdt._toSerializedCrdt());
+    });
+    const ops = getTreesDiffOperations(currentItems, new Map(items));
+    const result = apply(ops, false);
+    notify(result.updates);
+  }
+  function load(items) {
+    const [root, parentToChildren] = buildRootAndParentToChildren(items);
+    return LiveObject._deserialize(root, parentToChildren, {
+      getItem,
+      addItem,
+      deleteItem,
+      generateId,
+      generateOpId,
+      dispatch: storageDispatch,
+      roomId: context.roomId
+    });
+  }
+  function addItem(id, liveItem) {
+    state.items.set(id, liveItem);
+  }
+  function deleteItem(id) {
+    state.items.delete(id);
+  }
+  function getItem(id) {
+    return state.items.get(id);
+  }
+  function addToUndoStack(historyItem) {
+    if (state.undoStack.length >= 50) {
+      state.undoStack.shift();
+    }
+    if (state.isHistoryPaused) {
+      state.pausedHistory.unshift(...historyItem);
+    } else {
+      state.undoStack.push(historyItem);
+      onHistoryChange();
+    }
+  }
+  function storageDispatch(ops, reverse, storageUpdates) {
+    if (state.isBatching) {
+      state.batch.ops.push(...ops);
+      storageUpdates.forEach((value, key) => {
+        state.batch.updates.storageUpdates.set(
+          key,
+          mergeStorageUpdates(
+            state.batch.updates.storageUpdates.get(key),
+            value
+          )
+        );
+      });
+      state.batch.reverseOps.push(...reverse);
+    } else {
+      addToUndoStack(reverse);
+      state.redoStack = [];
+      dispatch(ops);
+      notify({ storageUpdates });
+    }
+  }
+  function notify({
+    storageUpdates = /* @__PURE__ */ new Map(),
+    presence = false,
+    others: otherEvents = []
+  }) {
+    if (otherEvents.length > 0) {
+      state.others = makeOthers(state.users);
+      for (const event of otherEvents) {
+        for (const listener of state.listeners.others) {
+          listener(state.others, event);
+        }
+      }
+    }
+    if (presence) {
+      for (const listener of state.listeners["my-presence"]) {
+        listener(state.me);
+      }
+    }
+    if (storageUpdates.size > 0) {
+      for (const subscriber of state.listeners.storage) {
+        subscriber(Array.from(storageUpdates.values()));
+      }
+    }
+  }
+  function getConnectionId() {
+    if (state.connection.state === "open" || state.connection.state === "connecting") {
+      return state.connection.id;
+    } else if (state.lastConnectionId !== null) {
+      return state.lastConnectionId;
+    }
+    throw new Error(
+      "Internal. Tried to get connection id but connection was never open"
+    );
+  }
+  function generateId() {
+    return `${getConnectionId()}:${state.clock++}`;
+  }
+  function generateOpId() {
+    return `${getConnectionId()}:${state.opClock++}`;
+  }
+  function apply(item, isLocal) {
+    const result = {
+      reverse: [],
+      updates: {
+        storageUpdates: /* @__PURE__ */ new Map(),
+        presence: false
+      }
+    };
+    const createdNodeIds = /* @__PURE__ */ new Set();
+    for (const op of item) {
+      if (op.type === "presence") {
+        const reverse = {
+          type: "presence",
+          data: {}
+        };
+        for (const key in op.data) {
+          reverse.data[key] = state.me[key];
+        }
+        state.me = { ...state.me, ...op.data };
+        if (state.buffer.presence == null) {
+          state.buffer.presence = { type: "partial", data: op.data };
+        } else {
+          for (const key in op.data) {
+            state.buffer.presence.data[key] = op.data[key];
+          }
+        }
+        result.reverse.unshift(reverse);
+        result.updates.presence = true;
+      } else {
+        let source;
+        if (!op.opId) {
+          op.opId = generateOpId();
+        }
+        if (isLocal) {
+          source = 0 /* UNDOREDO_RECONNECT */;
+        } else {
+          const deleted = state.offlineOperations.delete(nn(op.opId));
+          source = deleted ? 2 /* ACK */ : 1 /* REMOTE */;
+        }
+        const applyOpResult = applyOp(op, source);
+        if (applyOpResult.modified) {
+          const parentId = applyOpResult.modified.node.parent.type === "HasParent" ? nn(
+            applyOpResult.modified.node.parent.node._id,
+            "Expected parent node to have an ID"
+          ) : void 0;
+          if (!parentId || !createdNodeIds.has(parentId)) {
+            result.updates.storageUpdates.set(
+              nn(applyOpResult.modified.node._id),
+              mergeStorageUpdates(
+                result.updates.storageUpdates.get(
+                  nn(applyOpResult.modified.node._id)
+                ),
+                applyOpResult.modified
+              )
+            );
+            result.reverse.unshift(...applyOpResult.reverse);
+          }
+          if (op.type === 2 /* CREATE_LIST */ || op.type === 7 /* CREATE_MAP */ || op.type === 4 /* CREATE_OBJECT */) {
+            createdNodeIds.add(nn(applyOpResult.modified.node._id));
+          }
+        }
+      }
+    }
+    return result;
+  }
+  function applyOp(op, source) {
+    switch (op.type) {
+      case 6 /* DELETE_OBJECT_KEY */:
+      case 3 /* UPDATE_OBJECT */:
+      case 5 /* DELETE_CRDT */: {
+        const item = state.items.get(op.id);
+        if (item == null) {
+          return { modified: false };
+        }
+        return item._apply(op, source === 0 /* UNDOREDO_RECONNECT */);
+      }
+      case 1 /* SET_PARENT_KEY */: {
+        const item = state.items.get(op.id);
+        if (item == null) {
+          return { modified: false };
+        }
+        if (item.parent.type === "HasParent" && isLiveList(item.parent.node)) {
+          return item.parent.node._setChildKey(op.parentKey, item, source);
+        }
+        return { modified: false };
+      }
+      case 4 /* CREATE_OBJECT */:
+      case 2 /* CREATE_LIST */:
+      case 7 /* CREATE_MAP */:
+      case 8 /* CREATE_REGISTER */: {
+        if (op.parentId === void 0) {
+          return { modified: false };
+        }
+        const parent = state.items.get(op.parentId);
+        if (parent == null) {
+          return { modified: false };
+        }
+        return parent._attachChild(op, source);
+      }
+    }
+  }
+  function subscribe(first, second, options) {
+    if (second === void 0 || typeof first === "function") {
+      if (typeof first === "function") {
+        const storageCallback = first;
+        return genericSubscribe(storageCallback);
+      } else {
+        throw new Error("Please specify a listener callback");
+      }
+    }
+    if (isLiveNode(first)) {
+      const node = first;
+      if (options?.isDeep) {
+        const storageCallback = second;
+        return subscribeToLiveStructureDeeply(node, storageCallback);
+      } else {
+        const nodeCallback = second;
+        return subscribeToLiveStructureShallowly(node, nodeCallback);
+      }
+    }
+    if (!isRoomEventName(first)) {
+      throw new Error(`"${first}" is not a valid event name`);
+    }
+    const eventName = first;
+    const eventListener = second;
+    state.listeners[eventName].push(eventListener);
+    return () => {
+      const callbacks = state.listeners[eventName];
+      remove(callbacks, eventListener);
+    };
+  }
+  function getConnectionState() {
+    return state.connection.state;
+  }
+  function getSelf() {
+    return state.connection.state === "open" || state.connection.state === "connecting" ? {
+      connectionId: state.connection.id,
+      id: state.connection.userId,
+      info: state.connection.userInfo,
+      presence: getPresence()
+    } : null;
+  }
+  function connect() {
+    if (state.connection.state !== "closed" && state.connection.state !== "unavailable") {
+      return null;
+    }
+    const auth = prepareAuthEndpoint(
+      context.authentication,
+      context.polyfills?.fetch ?? context.fetchPolyfill
+    );
+    const createWebSocket = prepareCreateWebSocket(
+      context.liveblocksServer,
+      context.polyfills?.WebSocket ?? context.WebSocketPolyfill
+    );
+    updateConnection({ state: "authenticating" });
+    effects.authenticate(auth, createWebSocket);
+  }
+  function updatePresence(overrides, options) {
+    const oldValues = {};
+    if (state.buffer.presence == null) {
+      state.buffer.presence = {
+        type: "partial",
+        data: {}
+      };
+    }
+    for (const key in overrides) {
+      const overrideValue = overrides[key];
+      if (overrideValue === void 0) {
+        continue;
+      }
+      state.buffer.presence.data[key] = overrideValue;
+      oldValues[key] = state.me[key];
+    }
+    state.me = { ...state.me, ...overrides };
+    if (state.isBatching) {
+      if (options?.addToHistory) {
+        state.batch.reverseOps.push({ type: "presence", data: oldValues });
+      }
+      state.batch.updates.presence = true;
+    } else {
+      tryFlushing();
+      if (options?.addToHistory) {
+        addToUndoStack([{ type: "presence", data: oldValues }]);
+      }
+      notify({ presence: true });
+    }
+  }
+  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,
+      userInfo: token.info,
+      userId: token.id
+    });
+    state.idFactory = makeIdFactory(token.actor);
+    state.socket = socket;
+  }
+  function authenticationFailure(error) {
+    if (process.env.NODE_ENV !== "production") {
+      console.error("Call to authentication endpoint failed", error);
+    }
+    state.token = null;
+    updateConnection({ state: "unavailable" });
+    state.numberOfRetry++;
+    state.timeoutHandles.reconnect = effects.scheduleReconnect(getRetryDelay());
+  }
+  function onVisibilityChange(visibilityState) {
+    if (visibilityState === "visible" && state.connection.state === "open") {
+      log("Heartbeat after visibility change");
+      heartbeat();
+    }
+  }
+  function onUpdatePresenceMessage(message) {
+    const user = state.users[message.actor];
+    if (message.targetActor === void 0 && user != null && !user._hasReceivedInitialPresence) {
+      return void 0;
+    }
+    if (user == null) {
+      state.users[message.actor] = {
+        connectionId: message.actor,
+        presence: message.data,
+        id: void 0,
+        info: void 0,
+        _hasReceivedInitialPresence: true
+      };
+    } else {
+      state.users[message.actor] = {
+        id: user.id,
+        info: user.info,
+        connectionId: message.actor,
+        presence: {
+          ...user.presence,
+          ...message.data
+        },
+        _hasReceivedInitialPresence: true
+      };
+    }
+    return {
+      type: "update",
+      updates: message.data,
+      user: state.users[message.actor]
+    };
+  }
+  function onUserLeftMessage(message) {
+    const userLeftMessage = message;
+    const user = state.users[userLeftMessage.actor];
+    if (user) {
+      delete state.users[userLeftMessage.actor];
+      return { type: "leave", user };
+    }
+    return null;
+  }
+  function onRoomStateMessage(message) {
+    const newUsers = {};
+    for (const key in message.users) {
+      const connectionId = Number.parseInt(key);
+      const user = message.users[key];
+      newUsers[connectionId] = {
+        connectionId,
+        info: user.info,
+        id: user.id
+      };
+    }
+    state.users = newUsers;
+    return { type: "reset" };
+  }
+  function onNavigatorOnline() {
+    if (state.connection.state === "unavailable") {
+      log("Try to reconnect after connectivity change");
+      reconnect();
+    }
+  }
+  function onEvent(message) {
+    for (const listener of state.listeners.event) {
+      listener({ connectionId: message.actor, event: message.event });
+    }
+  }
+  function onHistoryChange() {
+    for (const listener of state.listeners.history) {
+      listener({ canUndo: canUndo(), canRedo: canRedo() });
+    }
+  }
+  function onUserJoinedMessage(message) {
+    state.users[message.actor] = {
+      connectionId: message.actor,
+      info: message.info,
+      id: message.id,
+      _hasReceivedInitialPresence: true
+    };
+    if (state.me) {
+      state.buffer.messages.push({
+        type: 100 /* UPDATE_PRESENCE */,
+        data: state.me,
+        targetActor: message.actor
+      });
+      tryFlushing();
+    }
+    return { type: "enter", user: state.users[message.actor] };
+  }
+  function parseServerMessage(data) {
+    if (!isJsonObject(data)) {
+      return null;
+    }
+    return data;
+  }
+  function parseServerMessages(text) {
+    const data = tryParseJson(text);
+    if (data === void 0) {
+      return null;
+    } else if (isJsonArray(data)) {
+      return compact(data.map((item) => parseServerMessage(item)));
+    } else {
+      return compact([parseServerMessage(data)]);
+    }
+  }
+  function onMessage(event) {
+    if (event.data === "pong") {
+      clearTimeout(state.timeoutHandles.pongTimeout);
+      return;
+    }
+    const messages = parseServerMessages(event.data);
+    if (messages === null || messages.length === 0) {
+      return;
+    }
+    const updates = {
+      storageUpdates: /* @__PURE__ */ new Map(),
+      others: []
+    };
+    for (const message of messages) {
+      switch (message.type) {
+        case 101 /* USER_JOINED */: {
+          updates.others.push(onUserJoinedMessage(message));
+          break;
+        }
+        case 100 /* UPDATE_PRESENCE */: {
+          const othersPresenceUpdate = onUpdatePresenceMessage(message);
+          if (othersPresenceUpdate) {
+            updates.others.push(othersPresenceUpdate);
+          }
+          break;
+        }
+        case 103 /* BROADCASTED_EVENT */: {
+          onEvent(message);
+          break;
+        }
+        case 102 /* USER_LEFT */: {
+          const event2 = onUserLeftMessage(message);
+          if (event2) {
+            updates.others.push(event2);
+          }
+          break;
+        }
+        case 104 /* ROOM_STATE */: {
+          updates.others.push(onRoomStateMessage(message));
+          break;
+        }
+        case 200 /* INITIAL_STORAGE_STATE */: {
+          const offlineOps = new Map(state.offlineOperations);
+          createOrUpdateRootFromMessage(message);
+          applyAndSendOfflineOps(offlineOps);
+          _getInitialStateResolver?.();
+          break;
+        }
+        case 201 /* UPDATE_STORAGE */: {
+          const applyResult = apply(message.ops, false);
+          applyResult.updates.storageUpdates.forEach((value, key) => {
+            updates.storageUpdates.set(
+              key,
+              mergeStorageUpdates(
+                updates.storageUpdates.get(key),
+                value
+              )
+            );
+          });
+          break;
+        }
+      }
+    }
+    notify(updates);
+  }
+  function onClose(event) {
+    state.socket = null;
+    clearTimeout(state.timeoutHandles.pongTimeout);
+    clearInterval(state.intervalHandles.heartbeat);
+    if (state.timeoutHandles.flush) {
+      clearTimeout(state.timeoutHandles.flush);
+    }
+    clearTimeout(state.timeoutHandles.reconnect);
+    state.users = {};
+    notify({ others: [{ type: "reset" }] });
+    if (event.code >= 4e3 && event.code <= 4100) {
+      updateConnection({ state: "failed" });
+      const error = new LiveblocksError(event.reason, event.code);
+      for (const listener of state.listeners.error) {
+        listener(error);
+      }
+      const delay = getRetryDelay(true);
+      state.numberOfRetry++;
+      if (process.env.NODE_ENV !== "production") {
+        console.error(
+          `Connection to Liveblocks websocket server closed. Reason: ${error.message} (code: ${error.code}). Retrying in ${delay}ms.`
+        );
+      }
+      updateConnection({ state: "unavailable" });
+      state.timeoutHandles.reconnect = effects.scheduleReconnect(delay);
+    } else if (event.code === 4999 /* CLOSE_WITHOUT_RETRY */) {
+      updateConnection({ state: "closed" });
+    } else {
+      const delay = getRetryDelay();
+      state.numberOfRetry++;
+      if (process.env.NODE_ENV !== "production") {
+        console.warn(
+          `Connection to Liveblocks websocket server closed (code: ${event.code}). Retrying in ${delay}ms.`
+        );
+      }
+      updateConnection({ state: "unavailable" });
+      state.timeoutHandles.reconnect = effects.scheduleReconnect(delay);
+    }
+  }
+  function updateConnection(connection) {
+    state.connection = connection;
+    for (const listener of state.listeners.connection) {
+      listener(connection.state);
+    }
+  }
+  function getRetryDelay(slow = false) {
+    if (slow) {
+      return BACKOFF_RETRY_DELAYS_SLOW[state.numberOfRetry < BACKOFF_RETRY_DELAYS_SLOW.length ? state.numberOfRetry : BACKOFF_RETRY_DELAYS_SLOW.length - 1];
+    }
+    return BACKOFF_RETRY_DELAYS[state.numberOfRetry < BACKOFF_RETRY_DELAYS.length ? state.numberOfRetry : BACKOFF_RETRY_DELAYS.length - 1];
+  }
+  function onError() {
+  }
+  function onOpen() {
+    clearInterval(state.intervalHandles.heartbeat);
+    state.intervalHandles.heartbeat = effects.startHeartbeatInterval();
+    if (state.connection.state === "connecting") {
+      updateConnection({ ...state.connection, state: "open" });
+      state.numberOfRetry = 0;
+      if (state.lastConnectionId !== void 0) {
+        state.buffer.presence = {
+          type: "full",
+          data: state.me
+        };
+        tryFlushing();
+      }
+      state.lastConnectionId = state.connection.id;
+      if (state.root) {
+        state.buffer.messages.push({ type: 200 /* FETCH_STORAGE */ });
+      }
+      tryFlushing();
+    } else {
+    }
+  }
+  function heartbeat() {
+    if (state.socket == null) {
+      return;
+    }
+    clearTimeout(state.timeoutHandles.pongTimeout);
+    state.timeoutHandles.pongTimeout = effects.schedulePongTimeout();
+    if (state.socket.readyState === state.socket.OPEN) {
+      state.socket.send("ping");
+    }
+  }
+  function pongTimeout() {
+    log("Pong timeout. Trying to reconnect.");
+    reconnect();
+  }
+  function reconnect() {
+    if (state.socket) {
+      state.socket.removeEventListener("open", onOpen);
+      state.socket.removeEventListener("message", onMessage);
+      state.socket.removeEventListener("close", onClose);
+      state.socket.removeEventListener("error", onError);
+      state.socket.close();
+      state.socket = null;
+    }
+    updateConnection({ state: "unavailable" });
+    clearTimeout(state.timeoutHandles.pongTimeout);
+    if (state.timeoutHandles.flush) {
+      clearTimeout(state.timeoutHandles.flush);
+    }
+    clearTimeout(state.timeoutHandles.reconnect);
+    clearInterval(state.intervalHandles.heartbeat);
+    connect();
+  }
+  function applyAndSendOfflineOps(offlineOps) {
+    if (offlineOps.size === 0) {
+      return;
+    }
+    const messages = [];
+    const ops = Array.from(offlineOps.values());
+    const result = apply(ops, true);
+    messages.push({
+      type: 201 /* UPDATE_STORAGE */,
+      ops
+    });
+    notify(result.updates);
+    effects.send(messages);
+  }
+  function tryFlushing() {
+    const storageOps = state.buffer.storageOperations;
+    if (storageOps.length > 0) {
+      storageOps.forEach((op) => {
+        state.offlineOperations.set(nn(op.opId), op);
+      });
+    }
+    if (state.socket == null || state.socket.readyState !== state.socket.OPEN) {
+      state.buffer.storageOperations = [];
+      return;
+    }
+    const now = Date.now();
+    const elapsedTime = now - state.lastFlushTime;
+    if (elapsedTime > context.throttleDelay) {
+      const messages = flushDataToMessages(state);
+      if (messages.length === 0) {
+        return;
+      }
+      effects.send(messages);
+      state.buffer = {
+        messages: [],
+        storageOperations: [],
+        presence: null
+      };
+      state.lastFlushTime = now;
+    } else {
+      if (state.timeoutHandles.flush != null) {
+        clearTimeout(state.timeoutHandles.flush);
+      }
+      state.timeoutHandles.flush = effects.delayFlush(
+        context.throttleDelay - (now - state.lastFlushTime)
+      );
+    }
+  }
+  function flushDataToMessages(state2) {
+    const messages = [];
+    if (state2.buffer.presence) {
+      messages.push(
+        state2.buffer.presence.type === "full" ? {
+          type: 100 /* UPDATE_PRESENCE */,
+          targetActor: -1,
+          data: state2.buffer.presence.data
+        } : {
+          type: 100 /* UPDATE_PRESENCE */,
+          data: state2.buffer.presence.data
+        }
+      );
+    }
+    for (const event of state2.buffer.messages) {
+      messages.push(event);
+    }
+    if (state2.buffer.storageOperations.length > 0) {
+      messages.push({
+        type: 201 /* UPDATE_STORAGE */,
+        ops: state2.buffer.storageOperations
+      });
+    }
+    return messages;
+  }
+  function disconnect() {
+    if (state.socket) {
+      state.socket.removeEventListener("open", onOpen);
+      state.socket.removeEventListener("message", onMessage);
+      state.socket.removeEventListener("close", onClose);
+      state.socket.removeEventListener("error", onError);
+      state.socket.close();
+      state.socket = null;
+    }
+    updateConnection({ state: "closed" });
+    if (state.timeoutHandles.flush) {
+      clearTimeout(state.timeoutHandles.flush);
+    }
+    clearTimeout(state.timeoutHandles.reconnect);
+    clearTimeout(state.timeoutHandles.pongTimeout);
+    clearInterval(state.intervalHandles.heartbeat);
+    state.users = {};
+    notify({ others: [{ type: "reset" }] });
+    clearListeners();
+  }
+  function clearListeners() {
+    for (const key in state.listeners) {
+      state.listeners[key] = [];
+    }
+  }
+  function getPresence() {
+    return state.me;
+  }
+  function getOthers() {
+    return state.others;
+  }
+  function broadcastEvent(event, options = {
+    shouldQueueEventIfNotReady: false
+  }) {
+    if (state.socket == null && options.shouldQueueEventIfNotReady == false) {
+      return;
+    }
+    state.buffer.messages.push({
+      type: 103 /* BROADCAST_EVENT */,
+      event
+    });
+    tryFlushing();
+  }
+  function dispatch(ops) {
+    state.buffer.storageOperations.push(...ops);
+    tryFlushing();
+  }
+  let _getInitialStatePromise = null;
+  let _getInitialStateResolver = null;
+  function getStorage() {
+    if (state.root) {
+      return new Promise(
+        (resolve) => resolve({
+          root: state.root
+        })
+      );
+    }
+    if (_getInitialStatePromise == null) {
+      state.buffer.messages.push({ type: 200 /* FETCH_STORAGE */ });
+      tryFlushing();
+      _getInitialStatePromise = new Promise(
+        (resolve) => _getInitialStateResolver = resolve
+      );
+    }
+    return _getInitialStatePromise.then(() => {
+      return {
+        root: nn(state.root)
+      };
+    });
+  }
+  function undo() {
+    if (state.isBatching) {
+      throw new Error("undo is not allowed during a batch");
+    }
+    const historyItem = state.undoStack.pop();
+    if (historyItem == null) {
+      return;
+    }
+    state.isHistoryPaused = false;
+    const result = apply(historyItem, true);
+    notify(result.updates);
+    state.redoStack.push(result.reverse);
+    onHistoryChange();
+    for (const op of historyItem) {
+      if (op.type !== "presence") {
+        state.buffer.storageOperations.push(op);
+      }
+    }
+    tryFlushing();
+  }
+  function canUndo() {
+    return state.undoStack.length > 0;
+  }
+  function redo() {
+    if (state.isBatching) {
+      throw new Error("redo is not allowed during a batch");
+    }
+    const historyItem = state.redoStack.pop();
+    if (historyItem == null) {
+      return;
+    }
+    state.isHistoryPaused = false;
+    const result = apply(historyItem, true);
+    notify(result.updates);
+    state.undoStack.push(result.reverse);
+    onHistoryChange();
+    for (const op of historyItem) {
+      if (op.type !== "presence") {
+        state.buffer.storageOperations.push(op);
+      }
+    }
+    tryFlushing();
+  }
+  function canRedo() {
+    return state.redoStack.length > 0;
+  }
+  function batch(callback) {
+    if (state.isBatching) {
+      throw new Error("batch should not be called during a batch");
+    }
+    state.isBatching = true;
+    try {
+      callback();
+    } finally {
+      state.isBatching = false;
+      if (state.batch.reverseOps.length > 0) {
+        addToUndoStack(state.batch.reverseOps);
+      }
+      if (state.batch.ops.length > 0) {
+        state.redoStack = [];
+      }
+      if (state.batch.ops.length > 0) {
+        dispatch(state.batch.ops);
+      }
+      notify(state.batch.updates);
+      state.batch = {
+        ops: [],
+        reverseOps: [],
+        updates: {
+          others: [],
+          storageUpdates: /* @__PURE__ */ new Map(),
+          presence: false
+        }
+      };
+      tryFlushing();
+    }
+  }
+  function pauseHistory() {
+    state.pausedHistory = [];
+    state.isHistoryPaused = true;
+  }
+  function resumeHistory() {
+    state.isHistoryPaused = false;
+    if (state.pausedHistory.length > 0) {
+      addToUndoStack(state.pausedHistory);
+    }
+    state.pausedHistory = [];
+  }
+  function simulateSocketClose() {
+    if (state.socket) {
+      state.socket = null;
+    }
+  }
+  function simulateSendCloseEvent(event) {
+    onClose(event);
+  }
+  return {
+    onClose,
+    onMessage,
+    authenticationSuccess,
+    heartbeat,
+    onNavigatorOnline,
+    simulateSocketClose,
+    simulateSendCloseEvent,
+    onVisibilityChange,
+    getUndoStack: () => state.undoStack,
+    getItemsCount: () => state.items.size,
+    connect,
+    disconnect,
+    subscribe,
+    updatePresence,
+    broadcastEvent,
+    batch,
+    undo,
+    redo,
+    canUndo,
+    canRedo,
+    pauseHistory,
+    resumeHistory,
+    getStorage,
+    selectors: {
+      getConnectionState,
+      getSelf,
+      getPresence,
+      getOthers
+    }
+  };
+}
+function defaultState(initialPresence, initialStorage) {
+  return {
+    connection: { state: "closed" },
+    token: null,
+    lastConnectionId: null,
+    socket: null,
+    listeners: {
+      event: [],
+      others: [],
+      "my-presence": [],
+      error: [],
+      connection: [],
+      storage: [],
+      history: []
+    },
+    numberOfRetry: 0,
+    lastFlushTime: 0,
+    timeoutHandles: {
+      flush: null,
+      reconnect: 0,
+      pongTimeout: 0
+    },
+    buffer: {
+      presence: {
+        type: "full",
+        data: initialPresence == null ? {} : initialPresence
+      },
+      messages: [],
+      storageOperations: []
+    },
+    intervalHandles: {
+      heartbeat: 0
+    },
+    me: initialPresence == null ? {} : initialPresence,
+    users: {},
+    others: makeOthers({}),
+    defaultStorageRoot: initialStorage,
+    idFactory: null,
+    clock: 0,
+    opClock: 0,
+    items: /* @__PURE__ */ new Map(),
+    root: void 0,
+    undoStack: [],
+    redoStack: [],
+    isHistoryPaused: false,
+    pausedHistory: [],
+    isBatching: false,
+    batch: {
+      ops: [],
+      updates: {
+        storageUpdates: /* @__PURE__ */ new Map(),
+        presence: false,
+        others: []
+      },
+      reverseOps: []
+    },
+    offlineOperations: /* @__PURE__ */ new Map()
+  };
+}
+function createRoom(options, context) {
+  const initialPresence = options.initialPresence ?? options.defaultPresence;
+  const initialStorage = options.initialStorage ?? options.defaultStorageRoot;
+  const state = defaultState(
+    typeof initialPresence === "function" ? initialPresence(context.roomId) : initialPresence,
+    typeof initialStorage === "function" ? initialStorage(context.roomId) : initialStorage
+  );
+  const machine = makeStateMachine(
+    state,
+    context
+  );
+  const room = {
+    id: context.roomId,
+    getConnectionState: machine.selectors.getConnectionState,
+    getSelf: machine.selectors.getSelf,
+    subscribe: machine.subscribe,
+    getPresence: machine.selectors.getPresence,
+    updatePresence: machine.updatePresence,
+    getOthers: machine.selectors.getOthers,
+    broadcastEvent: machine.broadcastEvent,
+    getStorage: machine.getStorage,
+    batch: machine.batch,
+    history: {
+      undo: machine.undo,
+      redo: machine.redo,
+      canUndo: machine.canUndo,
+      canRedo: machine.canRedo,
+      pause: machine.pauseHistory,
+      resume: machine.resumeHistory
+    },
+    __INTERNAL_DO_NOT_USE: {
+      simulateCloseWebsocket: machine.simulateSocketClose,
+      simulateSendCloseEvent: machine.simulateSendCloseEvent
+    }
+  };
+  return {
+    connect: machine.connect,
+    disconnect: machine.disconnect,
+    onNavigatorOnline: machine.onNavigatorOnline,
+    onVisibilityChange: machine.onVisibilityChange,
+    room
+  };
+}
+var LiveblocksError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+  }
+};
+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}&version=${true ? "0.17.11-debug2" : "dev"}`
+    );
+  };
+}
+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") {
+    const authWithResponseValidation = (room) => {
+      return authentication.callback(room).then((response) => {
+        if (!response || !response.token) {
+          throw new Error(
+            'Authentication error. We expect the authentication callback to return a token, but it does not. Hint: the return value should look like: { token: "..." }'
+          );
+        }
+        return response;
+      });
+    };
+    return authWithResponseValidation;
+  }
+  throw new Error("Internal error. Unexpected authentication type");
+}
+function fetchAuthEndpoint(fetch2, endpoint, body) {
+  return fetch2(endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
+  }).then((res) => {
+    if (!res.ok) {
+      throw new AuthenticationError(
+        `Expected a status 200 but got ${res.status} when doing a POST request on "${endpoint}"`
+      );
+    }
+    return res.json().catch((er) => {
+      throw new AuthenticationError(
+        `Expected a JSON response when doing a POST request on "${endpoint}". ${er}`
+      );
+    });
+  }).then((data) => {
+    if (!isPlainObject(data) || typeof data.token !== "string") {
+      throw new AuthenticationError(
+        `Expected a JSON response of the form \`{ token: "..." }\` when doing a POST request on "${endpoint}", but got ${JSON.stringify(
+          data
+        )}`
+      );
+    }
+    const { token } = data;
+    return { token };
+  });
+}
+var AuthenticationError = class extends Error {
+  constructor(message) {
+    super(message);
+  }
+};
+
+// src/client.ts
+function createClient(options) {
+  const clientOptions = options;
+  const throttleDelay = getThrottleDelayFromOptions(options);
+  const rooms = /* @__PURE__ */ new Map();
+  function getRoom(roomId) {
+    const internalRoom = rooms.get(roomId);
+    return internalRoom ? internalRoom.room : null;
+  }
+  function enter(roomId, options2 = {}) {
+    let internalRoom = rooms.get(roomId);
+    if (internalRoom) {
+      return internalRoom.room;
+    }
+    errorIf(
+      options2.defaultPresence,
+      "Argument `defaultPresence` will be removed in @liveblocks/client 0.18. Please use `initialPresence` instead. For more info, see https://bit.ly/3Niy5aP"
+    );
+    errorIf(
+      options2.defaultStorageRoot,
+      "Argument `defaultStorageRoot` will be removed in @liveblocks/client 0.18. Please use `initialStorage` instead. For more info, see https://bit.ly/3Niy5aP"
+    );
+    internalRoom = createRoom(
+      {
+        initialPresence: options2.initialPresence,
+        initialStorage: options2.initialStorage,
+        defaultPresence: options2.defaultPresence,
+        defaultStorageRoot: options2.defaultStorageRoot
+      },
+      {
+        roomId,
+        throttleDelay,
+        polyfills: clientOptions.polyfills,
+        WebSocketPolyfill: clientOptions.WebSocketPolyfill,
+        fetchPolyfill: clientOptions.fetchPolyfill,
+        liveblocksServer: clientOptions?.liveblocksServer || "wss://api.liveblocks.io/v6",
+        authentication: prepareAuthentication(clientOptions, roomId)
+      }
+    );
+    rooms.set(
+      roomId,
+      internalRoom
+    );
+    if (!options2.DO_NOT_USE_withoutConnecting) {
+      if (typeof atob == "undefined") {
+        if (clientOptions.polyfills?.atob == void 0) {
+          throw new Error(
+            "You need to polyfill atob to use the client in your environment. Please follow the instructions at https://liveblocks.io/docs/errors/liveblocks-client/atob-polyfill"
+          );
+        }
+        global.atob = clientOptions.polyfills.atob;
+      }
+      internalRoom.connect();
+    }
+    return internalRoom.room;
+  }
+  function leave(roomId) {
+    const room = rooms.get(roomId);
+    if (room) {
+      room.disconnect();
+      rooms.delete(roomId);
+    }
+  }
+  if (typeof window !== "undefined" && typeof window.addEventListener !== "undefined") {
+    window.addEventListener("online", () => {
+      for (const [, room] of rooms) {
+        room.onNavigatorOnline();
+      }
+    });
+  }
+  if (typeof document !== "undefined") {
+    document.addEventListener("visibilitychange", () => {
+      for (const [, room] of rooms) {
+        room.onVisibilityChange(document.visibilityState);
+      }
+    });
+  }
+  return {
+    getRoom,
+    enter,
+    leave
+  };
+}
+function getThrottleDelayFromOptions(options) {
+  if (options.throttle === void 0) {
+    return 100;
+  }
+  if (typeof options.throttle !== "number" || options.throttle < 80 || options.throttle > 1e3) {
+    throw new Error("throttle should be a number between 80 and 1000.");
+  }
+  return options.throttle;
+}
+function prepareAuthentication(clientOptions, roomId) {
+  const { publicApiKey, authEndpoint } = clientOptions;
+  if (authEndpoint !== void 0 && publicApiKey !== void 0) {
+    throw new Error(
+      "You cannot use both publicApiKey and authEndpoint. Please use either publicApiKey or authEndpoint, but not both. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClient"
+    );
+  }
+  if (typeof publicApiKey === "string") {
+    if (publicApiKey.startsWith("sk_")) {
+      throw new Error(
+        "Invalid publicApiKey. You are using the secret key which is not supported. Please use the public key instead. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClientPublicKey"
+      );
+    } else if (!publicApiKey.startsWith("pk_")) {
+      throw new Error(
+        "Invalid key. Please use the public key format: pk_<public key>. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClientPublicKey"
+      );
+    }
+    return {
+      type: "public",
+      publicApiKey,
+      url: buildLiveblocksPublicAuthorizeEndpoint(clientOptions, roomId)
+    };
+  }
+  if (typeof authEndpoint === "string") {
+    return {
+      type: "private",
+      url: authEndpoint
+    };
+  } else if (typeof authEndpoint === "function") {
+    return {
+      type: "custom",
+      callback: authEndpoint
+    };
+  } else if (authEndpoint !== void 0) {
+    throw new Error(
+      "authEndpoint must be a string or a function. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClientAuthEndpoint"
+    );
+  }
+  throw new Error(
+    "Invalid Liveblocks client options. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClient"
+  );
+}
+function buildLiveblocksPublicAuthorizeEndpoint(options, roomId) {
+  if (options.publicAuthorizeEndpoint) {
+    return options.publicAuthorizeEndpoint.replace("{roomId}", roomId);
+  }
+  return `https://api.liveblocks.io/v2/rooms/${encodeURIComponent(
+    roomId
+  )}/public/authorize`;
+}
+export {
+  LiveList,
+  LiveMap,
+  LiveObject,
+  createClient
+};