stream-chat 9.52.0 → 9.53.0

package/dist/esm/index.mjs

@@ -159,6 +159,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;
@@ -297,19 +298,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 }
     });
   }
 };
@@ -364,6 +360,22 @@ function logChatPromiseExecution(promise, name) {
     console.warn(`failed to do ${name}, ran into error: `, error);
   });
 }
+var noopLogger = () => null;
+var logError = (logger, error, event) => {
+  const message = "Unhandled error in event listener";
+  logger("error", message, { error, event });
+  if (logger === noopLogger) console.error(message, error, event);
+};
+var invokeEventListener = (listener, event, logger) => {
+  try {
+    const result = listener(event);
+    if (result && typeof result.then === "function") {
+      Promise.resolve(result).catch((error) => logError(logger, error, event));
+    }
+  } catch (error) {
+    logError(logger, error, event);
+  }
+};
 var sleep = (m) => new Promise((r) => setTimeout(r, m));
 function isFunction(value) {
   return typeof value === "function" || value instanceof Function || Object.prototype.toString.call(value) === "[object Function]";
@@ -411,7 +423,6 @@ var channelHasReadEvents = (channel) => {
   return !(Array.isArray(ownCapabilities) && !ownCapabilities.includes("read-events"));
 };
 var channelTracksReadLocally = (channel) => !channelHasReadEvents(channel) && !!channel?.getClient().options.isLocalUnreadCountEnabled;
-var userHasReadReceipts = (client) => client.user?.privacy_settings?.read_receipts?.enabled ?? true;
 function addFileToFormData(uri, name, contentType) {
   const data = new FormData();
   if (isReadableStream(uri) || isBuffer(uri) || isFileWebAPI(uri) || isBlobWebAPI(uri)) {
@@ -8964,7 +8975,6 @@ var MessageDeliveryReporter = class _MessageDeliveryReporter {
      * @param options
      */
     this.markRead = async (collection, options) => {
-      if (!userHasReadReceipts(this.client)) return null;
       let result = null;
       if (isChannel(collection)) {
         result = await collection.markAsReadRequest(options);
@@ -8974,7 +8984,7 @@ var MessageDeliveryReporter = class _MessageDeliveryReporter {
           thread_id: collection.id
         });
       }
-      this.removeCandidateFor(collection);
+      if (result) this.removeCandidateFor(collection);
       return result;
     };
     /**
@@ -9359,18 +9369,14 @@ var Channel = class {
       return await this.query(defaultOptions, "latest");
     };
     this._callChannelListeners = (event) => {
-      const channel = this;
-      const listeners = [];
-      if (channel.listeners.all) {
-        listeners.push(...channel.listeners.all);
-      }
-      if (channel.listeners[event.type]) {
-        listeners.push(...channel.listeners[event.type]);
-      }
+      const listeners = [
+        ...this.listeners.all ?? [],
+        ...this.listeners[event.type] ?? []
+      ];
+      const { logger } = this._client;
       for (const listener of listeners) {
-        if (typeof listener !== "string") {
-          listener(event);
-        }
+        if (typeof listener === "string") continue;
+        invokeEventListener(listener, event, logger);
       }
     };
     /**
@@ -10284,14 +10290,15 @@ var Channel = class {
     return await this.getClient().messageDeliveryReporter.markRead(this, data);
   }
   /**
-   * markReadRequest - Send the mark read event for this user, only works if the `read_events` setting is enabled
+   * markReadRequest - Send the mark read event for this user, only works if the `read_events` setting is
+   * enabled and the user holds the `read-events` capability on this channel
    *
    * @param {MarkReadOptions} data
    * @return {Promise<EventAPIResponse | null>} Description
    */
   async markAsReadRequest(data = {}) {
     this._checkInitialized();
-    if (!this.getConfig()?.read_events && !this.getClient()._isUsingServerAuth()) {
+    if (!this.getClient()._isUsingServerAuth() && (!this.getConfig()?.read_events || !channelHasReadEvents(this))) {
       return null;
     }
     return await this.getClient().post(this._channelURL() + "/read", {
@@ -10299,14 +10306,15 @@ var Channel = class {
     });
   }
   /**
-   * markUnread - Mark the channel as unread from messageID, only works if the `read_events` setting is enabled
+   * markUnread - Mark the channel as unread from messageID, only works if the `read_events` setting is
+   * enabled and the user holds the `read-events` capability on this channel
    *
    * @param {MarkUnreadOptions} data
    * @return {APIResponse} An API response
    */
   async markUnread(data) {
     this._checkInitialized();
-    if (!this.getConfig()?.read_events && !this.getClient()._isUsingServerAuth()) {
+    if (!this.getClient()._isUsingServerAuth() && (!this.getConfig()?.read_events || !channelHasReadEvents(this))) {
       return Promise.resolve(null);
     }
     return await this.getClient().post(this._channelURL() + "/unread", {
@@ -14352,6 +14360,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
@@ -14397,17 +14407,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;
       }
@@ -14503,9 +14516,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.
@@ -14539,6 +14593,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();
@@ -14768,16 +14826,12 @@ var StreamChat = class _StreamChat {
       }
     };
     this._callClientListeners = (event) => {
-      const client = this;
-      const listeners = [];
-      if (client.listeners.all) {
-        listeners.push(...client.listeners.all);
-      }
-      if (client.listeners[event.type]) {
-        listeners.push(...client.listeners[event.type]);
-      }
+      const listeners = [
+        ...this.listeners.all ?? [],
+        ...this.listeners[event.type] ?? []
+      ];
       for (const listener of listeners) {
-        listener(event);
+        invokeEventListener(listener, event, this.logger);
       }
     };
     this.recoverState = async () => {
@@ -14813,7 +14867,9 @@ var StreamChat = class _StreamChat {
           type: "connection.recovered"
         });
       }
-      this.wsPromise = Promise.resolve();
+      if (this._wsPromiseSettled) {
+        this.wsPromise = Promise.resolve();
+      }
       this.setUserPromise = Promise.resolve();
     };
     /**
@@ -14931,7 +14987,7 @@ var StreamChat = class _StreamChat {
         return this.userAgent;
       }
       if (!this.cachedUserAgent) {
-        const version = "9.52.0";
+        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 ?? {};
@@ -15020,7 +15076,7 @@ var StreamChat = class _StreamChat {
     this.defaultWSTimeoutWithFallback = 6 * 1e3;
     this.defaultWSTimeout = 15 * 1e3;
     this.axiosInstance.defaults.paramsSerializer = axiosParamsSerializer;
-    this.logger = isFunction(inputOptions.logger) ? inputOptions.logger : () => null;
+    this.logger = isFunction(inputOptions.logger) ? inputOptions.logger : noopLogger;
     this.recoverStateOnReconnect = this.options.recoverStateOnReconnect;
     this.threads = new ThreadManager({ client: this });
     this.polls = new PollManager({ client: this });
@@ -18173,6 +18229,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
    */