stream-chat 9.52.1 → 9.54.0

package/dist/cjs/index.browser.js

@@ -382,6 +382,7 @@ var Campaign = class {
 };
 
 // src/channel_batch_updater.ts
+var isChannelBatchDataUpdateOptions = (update) => "data" in update || "custom_set" in update || "custom_unset" in update;
 var ChannelBatchUpdater = class {
   constructor(client) {
     this.client = client;
@@ -520,19 +521,14 @@ var ChannelBatchUpdater = class {
       filter
     });
   }
-  // Data operations
-  /**
-   * updateData - Update data on channels matching the filter
-   *
-   * @param {UpdateChannelsBatchFilters} filter Filter to select channels
-   * @param {BatchChannelDataUpdate} data Data to update
-   * @return {Promise<APIResponse & UpdateChannelsBatchResponse>} The server response
-   */
-  async updateData(filter, data) {
+  async updateData(filter, update) {
+    const { data, custom_set, custom_unset } = isChannelBatchDataUpdateOptions(update) ? update : { data: update };
     return await this.client.updateChannelsBatch({
       operation: "updateData",
       filter,
-      data
+      ...data && { data },
+      ...custom_set && { custom_set },
+      ...custom_unset && { custom_unset }
     });
   }
 };
@@ -5914,10 +5910,11 @@ var createLinkPreviewsCompositionMiddleware = (composer) => ({
       const linkPreviews = linkPreviewsManager.loadingPreviews.length > 0 ? [] : linkPreviewsManager.loadedPreviews.map(
         (preview) => LinkPreviewsManager.getPreviewData(preview)
       );
-      const attachments = (state.message.attachments ?? []).concat(
+      const messageAttachments = (state.message.attachments ?? []).concat(
         linkPreviews
       );
-      if (!attachments.length) return forward();
+      const localAttachments = (state.localMessage.attachments ?? []).concat(linkPreviews);
+      if (!messageAttachments.length && !localAttachments.length) return forward();
       const sendOptions = { ...state.sendOptions };
       const skip_enrich_url = !someLinkPreviewsLoading && linkPreviews.length > 0 || someLinkPreviewsDismissed;
       if (skip_enrich_url) {
@@ -5925,14 +5922,14 @@ var createLinkPreviewsCompositionMiddleware = (composer) => ({
       }
       return next({
         ...state,
-        message: {
+        message: messageAttachments.length ? {
           ...state.message,
-          attachments
-        },
-        localMessage: {
+          attachments: messageAttachments
+        } : state.message,
+        localMessage: localAttachments.length ? {
           ...state.localMessage,
-          attachments
-        },
+          attachments: localAttachments
+        } : state.localMessage,
         sendOptions
       });
     }
@@ -13161,6 +13158,242 @@ var ThreadManager = class extends WithSubscriptions {
   }
 };
 
+// src/poll_optimistic_votes.ts
+var CATCH_UP_TIMEOUT_MS = 3e3;
+var OptimisticPollVotes = class {
+  constructor({ client, poll }) {
+    // Own vote changes not confirmed by a WS event yet
+    this.pendingCount = 0;
+    // Own vote changes whose requests succeeded since the server's vote state was last shown
+    this.succeededChanges = [];
+    // Vote requests with this tag are sent one after another. A symbol, so it is unique per instance.
+    this.requestTag = /* @__PURE__ */ Symbol("poll-votes");
+    this.withServerVotes = (pollState) => ({
+      ...pollState,
+      ...this.serverVoteState
+    });
+    /**
+     * Casts a vote for an option, shown right away through a placeholder vote. In polls with unique
+     * votes, it replaces the existing own votes.
+     */
+    this.castVote = (optionId, messageId) => {
+      const sendRequest = () => this.client.castPollVote(messageId, this.poll.id, { option_id: optionId });
+      const state = this.poll.data;
+      if (state.ownVotesByOptionId[optionId]) return this.send(sendRequest);
+      const replacedVotes = state.enforce_unique_vote ? Object.values(state.ownVotesByOptionId) : [];
+      this.poll.state.partialNext(
+        applyOwnVoteDelta(state, {
+          add: [this.createPlaceholderVote(optionId)],
+          remove: replacedVotes
+        })
+      );
+      return this.track(sendRequest, (response) => ({
+        optionId,
+        vote: response.vote
+      }));
+    };
+    // Removes a vote, right away.
+    this.removeVote = (voteId, messageId) => {
+      const sendRequest = (id) => this.client.removePollVote(messageId, this.poll.id, id);
+      const state = this.poll.data;
+      const vote = Object.values(state.ownVotesByOptionId).find(({ id }) => id === voteId);
+      if (!vote?.option_id) return this.send(() => sendRequest(voteId));
+      const optionId = vote.option_id;
+      this.poll.state.partialNext(applyOwnVoteDelta(state, { remove: [vote] }));
+      return this.track(
+        // runs when the removal's turn comes, so a preceding cast of the vote has finished
+        () => {
+          const serverVoteId = this.getServerVoteId(vote);
+          return serverVoteId ? sendRequest(serverVoteId) : Promise.resolve(void 0);
+        },
+        () => ({ optionId })
+      );
+    };
+    // Sends a vote request once the previous one has finished, whether it succeeded or not.
+    this.send = async (sendRequest) => {
+      try {
+        return await withoutConcurrency(this.requestTag, sendRequest);
+      } finally {
+        if (!hasPending(this.requestTag)) this.scheduleCatchUp();
+      }
+    };
+    // Stores the vote state of a WS vote event and returns the vote fields to show, if any.
+    this.handleVoteEvent = (poll, {
+      confirmsOwnVote,
+      ownVotesByOptionId
+    }) => {
+      this.serverVoteState = {
+        latest_votes_by_option: poll.latest_votes_by_option,
+        ownVotesByOptionId,
+        vote_count: poll.vote_count,
+        vote_counts_by_option: poll.vote_counts_by_option
+      };
+      if (confirmsOwnVote) this.pendingCount = Math.max(this.pendingCount - 1, 0);
+      return this.pendingCount > 0 ? {} : this.takeServerVoteState();
+    };
+    // Fresh server state (e.g. a refetch) replaces everything, pending changes are dropped.
+    this.reset = (pollState) => {
+      this.serverVoteState = pickVoteState(pollState);
+      this.pendingCount = 0;
+      this.succeededChanges = [];
+      clearTimeout(this.catchUpTimeout);
+    };
+    // Tracks an own vote change until its request settles. `sendRequest` resolves to undefined
+    // when no request was needed.
+    this.track = async (sendRequest, toChange) => {
+      this.pendingCount += 1;
+      clearTimeout(this.catchUpTimeout);
+      let response;
+      try {
+        response = await this.send(async () => {
+          const result = await sendRequest();
+          if (result !== void 0) this.succeededChanges.push(toChange(result));
+          return result;
+        });
+      } catch (error) {
+        this.settleWithoutEvent();
+        throw error;
+      }
+      if (response === void 0) this.settleWithoutEvent();
+      return response;
+    };
+    // A failed or skipped request gets no WS event, so it counts as confirmed right away.
+    this.settleWithoutEvent = () => {
+      this.pendingCount = Math.max(this.pendingCount - 1, 0);
+      if (this.pendingCount === 0) this.poll.state.partialNext(this.takeServerVoteState());
+    };
+    // The vote shown for a cast until the server's vote arrives
+    this.createPlaceholderVote = (optionId) => {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      return {
+        created_at: now,
+        id: `local-${generateUUIDv4()}`,
+        option_id: optionId,
+        poll_id: this.poll.id,
+        updated_at: now,
+        user: this.client.user,
+        user_id: this.client.userID
+      };
+    };
+    /**
+     * The server id of a vote to remove, once everything sent before the removal has finished. Casts
+     * and removals of an option alternate, so the option's last succeeded change tells: a cast is the
+     * vote being removed (e.g. a placeholder), a removal means the cast in between failed. Without
+     * one, the server's own vote of the option is the vote being removed.
+     */
+    this.getServerVoteId = (vote) => {
+      for (let i = this.succeededChanges.length - 1; i >= 0; i--) {
+        const change = this.succeededChanges[i];
+        if (change.optionId === vote.option_id) return change.vote?.id;
+      }
+      return this.serverVoteState.ownVotesByOptionId[vote.option_id]?.id;
+    };
+    this.takeServerVoteState = () => {
+      clearTimeout(this.catchUpTimeout);
+      this.succeededChanges = [];
+      return {
+        ...this.serverVoteState,
+        maxVotedOptionIds: getMaxVotedOptionIds(this.serverVoteState.vote_counts_by_option)
+      };
+    };
+    this.scheduleCatchUp = () => {
+      clearTimeout(this.catchUpTimeout);
+      if (this.pendingCount === 0) return;
+      this.catchUpTimeout = setTimeout(this.applySucceededChanges, CATCH_UP_TIMEOUT_MS);
+    };
+    /**
+     * A WS event of an own vote change got lost, so the server's own votes are stale. All requests
+     * have finished (the timeout starts once nothing is left to send and a new request cancels it),
+     * so applying the succeeded changes in order gives the server's own votes (changes whose events
+     * did arrive end up the same). They are shown with the vote counts of the last WS event, which
+     * contain the other users' votes too.
+     */
+    this.applySucceededChanges = () => {
+      const { enforce_unique_vote } = this.poll.data;
+      let ownVotesByOptionId = { ...this.serverVoteState.ownVotesByOptionId };
+      for (const { optionId, vote } of this.succeededChanges) {
+        if (!vote) {
+          delete ownVotesByOptionId[optionId];
+        } else if (enforce_unique_vote) {
+          ownVotesByOptionId = { [optionId]: vote };
+        } else {
+          ownVotesByOptionId[optionId] = vote;
+        }
+      }
+      this.serverVoteState = { ...this.serverVoteState, ownVotesByOptionId };
+      this.pendingCount = 0;
+      this.poll.state.partialNext(this.takeServerVoteState());
+    };
+    this.client = client;
+    this.poll = poll;
+    this.serverVoteState = pickVoteState(poll.data);
+  }
+  get serverOwnVotes() {
+    return this.serverVoteState.ownVotesByOptionId;
+  }
+};
+function pickVoteState(state) {
+  return {
+    latest_votes_by_option: state.latest_votes_by_option,
+    ownVotesByOptionId: state.ownVotesByOptionId,
+    vote_count: state.vote_count,
+    vote_counts_by_option: state.vote_counts_by_option
+  };
+}
+function applyOwnVoteDelta(state, { add = [], remove = [] }) {
+  const ownVotesByOptionId = { ...state.ownVotesByOptionId };
+  const voteCountsByOption = { ...state.vote_counts_by_option };
+  const latestVotesByOption = state.latest_votes_by_option ? { ...state.latest_votes_by_option } : state.latest_votes_by_option;
+  let voteCount = state.vote_count ?? 0;
+  for (const vote of remove) {
+    const optionId = vote.option_id;
+    if (!optionId) continue;
+    delete ownVotesByOptionId[optionId];
+    const optionVoteCount = (voteCountsByOption[optionId] ?? 0) - 1;
+    if (optionVoteCount > 0) {
+      voteCountsByOption[optionId] = optionVoteCount;
+    } else {
+      delete voteCountsByOption[optionId];
+    }
+    voteCount = Math.max(voteCount - 1, 0);
+    if (latestVotesByOption?.[optionId]) {
+      latestVotesByOption[optionId] = latestVotesByOption[optionId].filter(
+        (latestVote) => latestVote.id !== vote.id
+      );
+    }
+  }
+  for (const vote of add) {
+    const optionId = vote.option_id;
+    if (!optionId) continue;
+    ownVotesByOptionId[optionId] = vote;
+    voteCountsByOption[optionId] = (voteCountsByOption[optionId] ?? 0) + 1;
+    voteCount += 1;
+    if (latestVotesByOption && state.voting_visibility !== "anonymous") {
+      latestVotesByOption[optionId] = [vote, ...latestVotesByOption[optionId] ?? []];
+    }
+  }
+  return {
+    latest_votes_by_option: latestVotesByOption,
+    maxVotedOptionIds: getMaxVotedOptionIds(voteCountsByOption),
+    ownVotesByOptionId,
+    vote_count: voteCount,
+    vote_counts_by_option: voteCountsByOption
+  };
+}
+function getMaxVotedOptionIds(voteCountsByOption) {
+  let maxVotes = 0;
+  let winningOptions = [];
+  for (const [id, count] of Object.entries(voteCountsByOption ?? {})) {
+    if (count > maxVotes) {
+      winningOptions = [id];
+      maxVotes = count;
+    } else if (count === maxVotes) {
+      winningOptions.push(id);
+    }
+  }
+  return winningOptions;
+}
+
 // src/poll.ts
 var isPollUpdatedEvent = (e) => e.type === "poll.updated";
 var isPollClosedEventEvent = (e) => e.type === "poll.closed";
@@ -13170,6 +13403,9 @@ var isPollVoteRemovedEvent = (e) => e.type === "poll.vote_removed";
 var isVoteAnswer = (vote) => !!vote?.answer_text;
 var Poll = class {
   constructor({ client, poll }) {
+    // Set whenever server data (WS event or rehydration) confirms that the poll is closed,
+    // so that a failed optimistic close does not reopen a poll that is actually closed.
+    this.closeConfirmed = false;
     this.getInitialStateFromPollResponse = (poll) => {
       const { own_votes, id, ...pollResponseForState } = poll;
       const { ownAnswer, ownVotes } = own_votes?.reduce(
@@ -13193,25 +13429,47 @@ var Poll = class {
         ownVotesByOptionId: getOwnVotesByOptionId(ownVotes)
       };
     };
+    // persists only the server's votes, never the optimistic ones
     this.upsertOfflineDb = () => {
+      const serverState = this.optimisticVotes.withServerVotes(this.data);
       this.client.offlineDb?.executeQuerySafely(
-        (db) => db.upsertPoll({ poll: mapPollStateToResponse(this) }),
+        (db) => db.upsertPoll({ poll: mapPollStateToResponse(this, serverState) }),
         { method: "upsertPoll" }
       );
     };
     this.reinitializeState = (poll) => {
-      this.state.partialNext(this.getInitialStateFromPollResponse(poll));
+      if (poll.is_closed) this.closeConfirmed = true;
+      const initialState = this.getInitialStateFromPollResponse(poll);
+      this.optimisticVotes.reset(initialState);
+      this.state.partialNext(initialState);
+    };
+    // Hands the vote state of a WS vote event to the optimistic votes, which decide whether to show it.
+    this.updateFromVoteEvent = (event, ownVotesByOptionId, answerState) => {
+      const isOwnVote = event.poll_vote.user_id === this.client.userID;
+      const shownVoteState = this.optimisticVotes.handleVoteEvent(event.poll, {
+        confirmsOwnVote: isOwnVote && !isVoteAnswer(event.poll_vote) && !!event.poll_vote.option_id,
+        ownVotesByOptionId
+      });
+      this.state.partialNext({
+        ...answerState,
+        answers_count: event.poll.answers_count,
+        lastActivityAt: new Date(event.created_at),
+        ...shownVoteState
+      });
+      this.upsertOfflineDb();
     };
     this.handlePollUpdated = (event) => {
       if (event.poll?.id && event.poll.id !== this.id) return;
       if (!isPollUpdatedEvent(event)) return;
       const { id, ...pollData } = extractPollData(event.poll);
+      if (pollData.is_closed) this.closeConfirmed = true;
       this.state.partialNext({ ...pollData, lastActivityAt: new Date(event.created_at) });
       this.upsertOfflineDb();
     };
     this.handlePollClosed = (event) => {
       if (event.poll?.id && event.poll.id !== this.id) return;
       if (!isPollClosedEventEvent(event)) return;
+      this.closeConfirmed = true;
       this.state.partialNext({
         is_closed: true,
         lastActivityAt: new Date(event.created_at)
@@ -13225,8 +13483,7 @@ var Poll = class {
       const isOwnVote = event.poll_vote.user_id === this.client.userID;
       let latestAnswers = [...currentState.latest_answers];
       let ownAnswer = currentState.ownAnswer;
-      const ownVotesByOptionId = currentState.ownVotesByOptionId;
-      let maxVotedOptionIds = currentState.maxVotedOptionIds;
+      const ownVotesByOptionId = { ...this.optimisticVotes.serverOwnVotes };
       if (isOwnVote) {
         if (isVoteAnswer(event.poll_vote)) {
           ownAnswer = event.poll_vote;
@@ -13236,19 +13493,11 @@ var Poll = class {
       }
       if (isVoteAnswer(event.poll_vote)) {
         latestAnswers = [event.poll_vote, ...latestAnswers];
-      } else {
-        maxVotedOptionIds = getMaxVotedOptionIds(event.poll.vote_counts_by_option);
       }
-      const pollEnrichData = extractPollEnrichedData(event.poll);
-      this.state.partialNext({
-        ...pollEnrichData,
+      this.updateFromVoteEvent(event, ownVotesByOptionId, {
         latest_answers: latestAnswers,
-        lastActivityAt: new Date(event.created_at),
-        ownAnswer,
-        ownVotesByOptionId,
-        maxVotedOptionIds
+        ownAnswer
       });
-      this.upsertOfflineDb();
     };
     this.handleVoteChanged = (event) => {
       if (event.poll?.id && event.poll.id !== this.id) return;
@@ -13257,8 +13506,7 @@ var Poll = class {
       const isOwnVote = event.poll_vote.user_id === this.client.userID;
       let latestAnswers = [...currentState.latest_answers];
       let ownAnswer = currentState.ownAnswer;
-      let ownVotesByOptionId = currentState.ownVotesByOptionId;
-      let maxVotedOptionIds = currentState.maxVotedOptionIds;
+      let ownVotesByOptionId = this.optimisticVotes.serverOwnVotes;
       if (isOwnVote) {
         if (isVoteAnswer(event.poll_vote)) {
           latestAnswers = [
@@ -13282,23 +13530,14 @@ var Poll = class {
           if (ownAnswer?.id === event.poll_vote.id) {
             ownAnswer = void 0;
           }
-          maxVotedOptionIds = getMaxVotedOptionIds(event.poll.vote_counts_by_option);
         }
       } else if (isVoteAnswer(event.poll_vote)) {
         latestAnswers = [event.poll_vote, ...latestAnswers];
-      } else {
-        maxVotedOptionIds = getMaxVotedOptionIds(event.poll.vote_counts_by_option);
       }
-      const pollEnrichData = extractPollEnrichedData(event.poll);
-      this.state.partialNext({
-        ...pollEnrichData,
+      this.updateFromVoteEvent(event, ownVotesByOptionId, {
         latest_answers: latestAnswers,
-        lastActivityAt: new Date(event.created_at),
-        ownAnswer,
-        ownVotesByOptionId,
-        maxVotedOptionIds
+        ownAnswer
       });
-      this.upsertOfflineDb();
     };
     this.handleVoteRemoved = (event) => {
       if (event.poll?.id && event.poll.id !== this.id) return;
@@ -13307,29 +13546,19 @@ var Poll = class {
       const isOwnVote = event.poll_vote.user_id === this.client.userID;
       let latestAnswers = [...currentState.latest_answers];
       let ownAnswer = currentState.ownAnswer;
-      const ownVotesByOptionId = { ...currentState.ownVotesByOptionId };
-      let maxVotedOptionIds = currentState.maxVotedOptionIds;
+      const ownVotesByOptionId = { ...this.optimisticVotes.serverOwnVotes };
       if (isVoteAnswer(event.poll_vote)) {
         latestAnswers = latestAnswers.filter((answer) => answer.id !== event.poll_vote.id);
         if (isOwnVote) {
           ownAnswer = void 0;
         }
-      } else {
-        maxVotedOptionIds = getMaxVotedOptionIds(event.poll.vote_counts_by_option);
-        if (isOwnVote && event.poll_vote.option_id) {
-          delete ownVotesByOptionId[event.poll_vote.option_id];
-        }
+      } else if (isOwnVote && event.poll_vote.option_id) {
+        delete ownVotesByOptionId[event.poll_vote.option_id];
       }
-      const pollEnrichData = extractPollEnrichedData(event.poll);
-      this.state.partialNext({
-        ...pollEnrichData,
+      this.updateFromVoteEvent(event, ownVotesByOptionId, {
         latest_answers: latestAnswers,
-        lastActivityAt: new Date(event.created_at),
-        ownAnswer,
-        ownVotesByOptionId,
-        maxVotedOptionIds
+        ownAnswer
       });
-      this.upsertOfflineDb();
     };
     this.query = async (id) => {
       const { poll } = await this.client.getPoll(id);
@@ -13338,11 +13567,33 @@ var Poll = class {
     };
     this.update = async (data) => await this.client.updatePoll({ ...data, id: this.id });
     this.partialUpdate = async (partialPollObject) => await this.client.partialUpdatePoll(this.id, partialPollObject);
-    this.close = async () => await this.client.closePoll(this.id);
+    /**
+     * Closes the poll. The poll is marked as closed optimistically and the change is
+     * reverted if the request fails, unless the server confirmed the close meanwhile.
+     * Does nothing if the poll is already closed.
+     */
+    this.close = async () => {
+      if (this.data.is_closed) return;
+      this.closeConfirmed = false;
+      this.state.partialNext({ is_closed: true });
+      try {
+        return await this.client.closePoll(this.id);
+      } catch (error) {
+        if (!this.closeConfirmed) {
+          this.state.partialNext({ is_closed: false });
+        }
+        throw error;
+      }
+    };
     this.delete = async () => await this.client.deletePoll(this.id);
     this.createOption = async (option) => await this.client.createPollOption(this.id, option);
     this.updateOption = async (option) => await this.client.updatePollOption(this.id, option);
     this.deleteOption = async (optionId) => await this.client.deletePollOption(this.id, optionId);
+    /**
+     * Casts a vote for an option. The vote is shown right away through a local placeholder vote,
+     * which the server's vote replaces once the WS events of all pending vote changes arrived.
+     * If the request fails, the change is reverted.
+     */
     this.castVote = async (optionId, messageId) => {
       const { max_votes_allowed, ownVotesByOptionId } = this.data;
       const reachedVoteLimit = max_votes_allowed && max_votes_allowed === Object.keys(ownVotesByOptionId).length;
@@ -13359,11 +13610,14 @@ var Poll = class {
         });
         return;
       }
-      return await this.client.castPollVote(messageId, this.id, {
-        option_id: optionId
-      });
+      return await this.optimisticVotes.castVote(optionId, messageId);
     };
-    this.removeVote = async (voteId, messageId) => await this.client.removePollVote(messageId, this.id, voteId);
+    /**
+     * Removes a vote. The vote is removed right away and restored if the request fails. Vote
+     * requests are sent in order, so removing a vote whose cast is not confirmed yet uses the vote
+     * id from the cast's response; if that cast failed, there is nothing to remove.
+     */
+    this.removeVote = async (voteId, messageId) => await this.optimisticVotes.removeVote(voteId, messageId);
     this.addAnswer = async (answerText, messageId) => await this.client.addPollAnswer(messageId, this.id, answerText);
     this.removeAnswer = async (answerId, messageId) => await this.client.removePollVote(messageId, this.id, answerId);
     this.queryAnswers = async (params) => await this.client.queryPollAnswers(
@@ -13381,24 +13635,12 @@ var Poll = class {
     this.client = client;
     this.id = poll.id;
     this.state = new StateStore(this.getInitialStateFromPollResponse(poll));
+    this.optimisticVotes = new OptimisticPollVotes({ client: this.client, poll: this });
   }
   get data() {
     return this.state.getLatestValue();
   }
 };
-function getMaxVotedOptionIds(voteCountsByOption) {
-  let maxVotes = 0;
-  let winningOptions = [];
-  for (const [id, count] of Object.entries(voteCountsByOption ?? {})) {
-    if (count > maxVotes) {
-      winningOptions = [id];
-      maxVotes = count;
-    } else if (count === maxVotes) {
-      winningOptions.push(id);
-    }
-  }
-  return winningOptions;
-}
 function getOwnVotesByOptionId(ownVotes) {
   return !ownVotes ? {} : ownVotes.reduce((acc, vote) => {
     if (isVoteAnswer(vote) || !vote.option_id) return acc;
@@ -13420,7 +13662,7 @@ function extractPollData(pollResponse) {
     voting_visibility: pollResponse.voting_visibility
   };
 }
-function mapPollStateToResponse(poll) {
+function mapPollStateToResponse(poll, state = poll.data) {
   const {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     lastActivityAt,
@@ -13429,7 +13671,7 @@ function mapPollStateToResponse(poll) {
     ownVotesByOptionId,
     ownAnswer,
     ...restState
-  } = poll.data;
+  } = state;
   const ownVotes = [
     ...Object.values(ownVotesByOptionId),
     ...ownAnswer ? [ownAnswer] : []
@@ -14587,6 +14829,8 @@ var StreamChat = class _StreamChat {
      * The main use case for SDKs who do independent state recovery for channels.
      */
     this.preventThreadCleanup = false;
+    this._wsPromiseSettled = true;
+    this._wsConnectId = 0;
     this.nextRequestAbortController = null;
     /**
      * @private
@@ -14632,17 +14876,20 @@ var StreamChat = class _StreamChat {
       const setTokenPromise = this._setToken(user, userTokenOrProvider);
       this._setUser(user);
       const wsPromise = this.openConnection();
-      this.setUserPromise = Promise.all([setTokenPromise, wsPromise]).then(
+      const setUserPromise = Promise.all([setTokenPromise, wsPromise]).then(
         (result) => result[1]
         // We only return connection promise;
       );
+      this.setUserPromise = setUserPromise;
       try {
-        return await this.setUserPromise;
+        return await setUserPromise;
       } catch (err) {
-        if (this.persistUserOnConnectionFailure) {
-          this.closeConnection();
-        } else {
-          this.disconnectUser();
+        if (this.setUserPromise === setUserPromise && this.userID === user.id) {
+          if (this.persistUserOnConnectionFailure) {
+            this.closeConnection();
+          } else {
+            this.disconnectUser();
+          }
         }
         throw err;
       }
@@ -14738,9 +14985,50 @@ var StreamChat = class _StreamChat {
         return;
       }
       this.clientID = `${this.userID}--${randomId()}`;
-      this.wsPromise = this.connect();
+      const wsPromise = this._bindWsPromise(this.connect());
       this._startCleaning();
-      return this.wsPromise;
+      return wsPromise;
+    };
+    /**
+     * Rejects the shared `wsPromise`, invalidates any in-flight connect attempt
+     */
+    this._rejectPendingWsPromise = (reason) => {
+      if (!this._wsPromiseSettled) {
+        this._wsConnectId += 1;
+        this._wsPromiseSettled = true;
+        this.wsPromise?.catch(() => {
+        });
+        this._rejectWsPromise?.(reason);
+      }
+    };
+    /**
+     * Keep a single pending `wsPromise` across close/reopen so callers that already
+     * `await this.wsPromise` are not stranded when `openConnection` starts a new connect.
+     */
+    this._bindWsPromise = (connectPromise) => {
+      const connectId = ++this._wsConnectId;
+      let pending = this.wsPromise;
+      if (this._wsPromiseSettled || !pending) {
+        this._wsPromiseSettled = false;
+        pending = new Promise((resolve, reject) => {
+          this._resolveWsPromise = resolve;
+          this._rejectWsPromise = reject;
+        });
+        this.wsPromise = pending;
+      }
+      connectPromise.then(
+        (value) => {
+          if (connectId !== this._wsConnectId) return;
+          this._wsPromiseSettled = true;
+          this._resolveWsPromise?.(value);
+        },
+        (error) => {
+          if (connectId !== this._wsConnectId) return;
+          this._wsPromiseSettled = true;
+          this._rejectWsPromise?.(error);
+        }
+      );
+      return pending;
     };
     /**
      * @deprecated Please use client.openConnction instead.
@@ -14774,6 +15062,10 @@ var StreamChat = class _StreamChat {
       delete this._user;
       delete this.userID;
       this.anonymous = false;
+      this._rejectPendingWsPromise(
+        new Error("Connection was closed because disconnectUser() was called")
+      );
+      this.wsPromise = null;
       const closePromise = this.closeConnection(timeout);
       for (const channel of Object.values(this.activeChannels)) {
         channel._disconnect();
@@ -15044,7 +15336,9 @@ var StreamChat = class _StreamChat {
           type: "connection.recovered"
         });
       }
-      this.wsPromise = Promise.resolve();
+      if (this._wsPromiseSettled) {
+        this.wsPromise = Promise.resolve();
+      }
       this.setUserPromise = Promise.resolve();
     };
     /**
@@ -15162,7 +15456,7 @@ var StreamChat = class _StreamChat {
         return this.userAgent;
       }
       if (!this.cachedUserAgent) {
-        const version = "9.52.1";
+        const version = "9.54.0";
         const { name: sdkName, version: sdkVersion } = this.sdkIdentifier ?? {};
         const { name: appName, version: appVersion } = this.appIdentifier ?? {};
         const { os, model: deviceModel } = this.deviceIdentifier ?? {};
@@ -18404,6 +18698,10 @@ var StreamChat = class _StreamChat {
   /**
    *  Update Channels Batch
    *
+   *  For the `updateData` operation, `data.custom` replaces the channel's whole
+   *  custom object, while the root-level `custom_set` / `custom_unset` patch
+   *  individual keys and leave the rest untouched.
+   *
    *  @param {UpdateChannelsBatchOptions} payload for updating channels in batch
    *  @return {Promise<APIResponse & UpdateChannelsBatchResponse>} The server response
    */