stream-chat 9.52.1 → 9.53.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 }
     });
   }
 };
@@ -14587,6 +14583,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 +14630,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 +14739,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 +14816,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 +15090,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 +15210,7 @@ var StreamChat = class _StreamChat {
         return this.userAgent;
       }
       if (!this.cachedUserAgent) {
-        const version = "9.52.1";
+        const version = "9.53.0";
         const { name: sdkName, version: sdkVersion } = this.sdkIdentifier ?? {};
         const { name: appName, version: appVersion } = this.appIdentifier ?? {};
         const { os, model: deviceModel } = this.deviceIdentifier ?? {};
@@ -18404,6 +18452,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
    */