stream-chat 9.48.0 → 9.50.0

package/dist/cjs/index.browser.js

@@ -621,6 +621,12 @@ function isOwnUserBaseProperty(property) {
   };
   return ownUserBaseProperties[property];
 }
+var channelHasReadEvents = (channel) => {
+  const ownCapabilities = channel?.data?.own_capabilities;
+  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 import_form_data.default();
   if (isReadableStream(uri) || isBuffer(uri) || isFileWebAPI(uri) || isBlobWebAPI(uri)) {
@@ -8782,6 +8788,7 @@ 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);
@@ -10126,6 +10133,33 @@ var Channel = class {
       ...data
     });
   }
+  /**
+   * markReadLocally - Resets this user's unread count locally, without any backend call. Intended for
+   * channels that have read events disabled (e.g. livestreams) when the client is created with the
+   * `isLocalUnreadCountEnabled` option. Dispatches a dedicated, client-only `message.read_locally` event
+   * that runs through the same `_handleChannelEvent` read logic as a real `message.read` (minus the
+   * delivery-report network sync), so the read-state update lives in one place. When offline support
+   * is enabled, the offline DB persists the reset for read-events-disabled channels, so the local
+   * count stays consistent across app restarts.
+   *
+   * @return {Event | undefined} The dispatched `message.read_locally` event, or `undefined` if there is no connected user.
+   */
+  markReadLocally() {
+    const client = this.getClient();
+    if (!client.userID) return;
+    const event = {
+      channel_id: this.id,
+      channel_type: this.type,
+      cid: this.cid,
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      last_read_message_id: this.lastMessage()?.id,
+      team: this.data?.team,
+      type: "message.read_locally",
+      user: client.user
+    };
+    client.dispatchEvent(event);
+    return event;
+  }
   /**
    * clean - Cleans the channel state and fires stop typing if needed
    */
@@ -10281,7 +10315,7 @@ var Channel = class {
     if (message.user?.id === this.getClient().userID) return false;
     if (message.user?.id && this.getClient().userMuteStatus(message.user.id))
       return false;
-    if (Array.isArray(this.data?.own_capabilities) && !this.data?.own_capabilities.includes("read-events")) {
+    if (!this.getClient().options.isLocalUnreadCountEnabled && !channelHasReadEvents(this)) {
       return false;
     }
     if (this.getClient()._muteStatus(this.cid).muted) return false;
@@ -10692,6 +10726,11 @@ var Channel = class {
           delete channelState.typing[event.user.id];
         }
         break;
+      // `message.read_locally` is the client-only event dispatched by `markReadLocally()` when read
+      // events are disabled (e.g. livestreams with `isLocalUnreadCountEnabled`). It reuses the exact
+      // `message.read` state logic so the read-state update lives in one place — only the
+      // delivery-report network sync below is skipped for it.
+      case "message.read_locally":
       case "message.read":
         if (event.user?.id && event.created_at) {
           const previousReadState = channelState.read[event.user.id];
@@ -10712,7 +10751,9 @@ var Channel = class {
           const isOwnEvent = event.user?.id === client.user?.id;
           if (isOwnEvent) {
             channelState.unreadCount = 0;
-            client.syncDeliveredCandidates([this]);
+            if (event.type === "message.read") {
+              client.syncDeliveredCandidates([this]);
+            }
           }
         }
         break;
@@ -14827,6 +14868,31 @@ var StreamChat = class _StreamChat {
      * @return {Promise<APIResponse>}
      */
     this.markAllRead = this.markChannelsRead;
+    this.getUserAgent = () => {
+      if (this.userAgent) {
+        return this.userAgent;
+      }
+      if (!this.cachedUserAgent) {
+        const version = "9.50.0";
+        const { name: sdkName, version: sdkVersion } = this.sdkIdentifier ?? {};
+        const { name: appName, version: appVersion } = this.appIdentifier ?? {};
+        const { os, model: deviceModel } = this.deviceIdentifier ?? {};
+        const head = sdkName ? `stream-chat-${sdkName}-v${sdkVersion}-llc-v${version}` : `stream-chat-js-v${version}-${this.node ? "node" : "browser"}`;
+        this.cachedUserAgent = [
+          head,
+          // reports the host app, the device OS, the device model, and the picked
+          // exports bundle, each only when a value is present
+          ...Object.entries({
+            app: appName,
+            app_version: appVersion,
+            os,
+            device_model: deviceModel,
+            client_bundle: "browser-cjs"
+          }).filter(([, value]) => value && value.length > 0).map(([key, value]) => `${key}=${value}`)
+        ].join("|");
+      }
+      return this.cachedUserAgent;
+    };
     /**
      * _isUsingServerAuth - Returns true if we're using server side auth
      */
@@ -14865,6 +14931,7 @@ var StreamChat = class _StreamChat {
       warmUp: false,
       recoverStateOnReconnect: true,
       disableCache: false,
+      isLocalUnreadCountEnabled: false,
       wsUrlParams: new URLSearchParams({}),
       ...inputOptions
     };
@@ -15279,6 +15346,13 @@ var StreamChat = class _StreamChat {
         delete this.activeChannels[cid];
       });
     }
+    if (event.type === "notification.removed_from_channel" && event.cid) {
+      const { cid } = event;
+      this.activeChannels[cid]?._disconnect();
+      postListenerCallbacks.push(() => {
+        delete this.activeChannels[cid];
+      });
+    }
     return postListenerCallbacks;
   }
   _muteStatus(cid) {
@@ -16770,31 +16844,6 @@ var StreamChat = class _StreamChat {
       partialThreadObject
     );
   }
-  getUserAgent() {
-    if (this.userAgent) {
-      return this.userAgent;
-    }
-    const version = "9.48.0";
-    const clientBundle = "browser-cjs";
-    let userAgentString = "";
-    if (this.sdkIdentifier) {
-      userAgentString = `stream-chat-${this.sdkIdentifier.name}-v${this.sdkIdentifier.version}-llc-v${version}`;
-    } else {
-      userAgentString = `stream-chat-js-v${version}-${this.node ? "node" : "browser"}`;
-    }
-    const { os, model } = this.deviceIdentifier ?? {};
-    return [
-      // reports the device OS, if provided
-      ["os", os],
-      // reports the device model, if provided
-      ["device_model", model],
-      // reports which bundle is being picked from the exports
-      ["client_bundle", clientBundle]
-    ].reduce(
-      (withArguments, [key, value]) => value && value.length > 0 ? withArguments.concat(`|${key}=${value}`) : withArguments,
-      userAgentString
-    );
-  }
   /**
    * @deprecated use sdkIdentifier instead
    * @param userAgent
@@ -18236,6 +18285,7 @@ var EVENT_MAP = {
   "ai_indicator.stop": true,
   "ai_indicator.clear": true,
   // local events
+  "message.read_locally": true,
   "channels.queried": true,
   "offline_reactions.queried": true,
   "connection.changed": true,
@@ -18619,7 +18669,8 @@ var AbstractOfflineDB = class {
           if (cid && client.user && client.user.id !== user?.id) {
             const userId = client.user.id;
             const channel = client.activeChannels[cid];
-            if (channel) {
+            const tracksReadLocally = channelTracksReadLocally(channel);
+            if (channel && (channelHasReadEvents(channel) || tracksReadLocally)) {
               const ownReads = channel.state.read[userId];
               const unreadCount = channel.countUnread();
               const upsertReadsQueries = await this.upsertReads({
@@ -18627,8 +18678,8 @@ var AbstractOfflineDB = class {
                 execute: false,
                 reads: [
                   {
-                    last_read: ownReads.last_read.toISOString(),
-                    last_read_message_id: ownReads.last_read_message_id,
+                    last_read: (ownReads?.last_read ?? /* @__PURE__ */ new Date(0)).toISOString(),
+                    last_read_message_id: ownReads?.last_read_message_id,
                     unread_messages: unreadCount,
                     user: client.user
                   }
@@ -18827,27 +18878,30 @@ var AbstractOfflineDB = class {
           truncated_at,
           execute: false
         });
+        let finalQueries = [...truncateQueries];
         const userId = ownUser.id;
         const activeChannel = this.client.activeChannels[cid];
-        const ownReads = activeChannel.state.read[userId];
-        let unreadCount = 0;
-        if (truncated_at) {
-          const truncatedAt = new Date(truncated_at);
-          unreadCount = activeChannel.countUnread(truncatedAt);
+        const tracksReadLocally = channelTracksReadLocally(activeChannel);
+        if (activeChannel && (channelHasReadEvents(activeChannel) || tracksReadLocally)) {
+          const ownReads = activeChannel.state.read[userId];
+          let unreadCount = 0;
+          if (truncated_at) {
+            unreadCount = activeChannel.countUnread(new Date(truncated_at));
+          }
+          const upsertReadQueries = await this.upsertReads({
+            cid,
+            execute: false,
+            reads: [
+              {
+                last_read: (ownReads?.last_read ?? /* @__PURE__ */ new Date(0)).toString(),
+                last_read_message_id: ownReads?.last_read_message_id,
+                unread_messages: unreadCount,
+                user: ownUser
+              }
+            ]
+          });
+          finalQueries = [...finalQueries, ...upsertReadQueries];
         }
-        const upsertReadQueries = await this.upsertReads({
-          cid,
-          execute: false,
-          reads: [
-            {
-              last_read: ownReads.last_read.toString(),
-              last_read_message_id: ownReads.last_read_message_id,
-              unread_messages: unreadCount,
-              user: ownUser
-            }
-          ]
-        });
-        const finalQueries = [...truncateQueries, ...upsertReadQueries];
         if (execute) {
           await this.executeSqlBatch(finalQueries);
         }
@@ -18948,6 +19002,13 @@ var AbstractOfflineDB = class {
       if (type === "message.read" || type === "notification.mark_read") {
         return this.handleRead({ event, unreadMessages: 0, execute });
       }
+      if (type === "message.read_locally") {
+        const localChannel = event.cid ? this.client.activeChannels[event.cid] : void 0;
+        if (channelTracksReadLocally(localChannel)) {
+          return this.handleRead({ event, unreadMessages: 0, execute });
+        }
+        return [];
+      }
       if (type === "notification.mark_unread") {
         return this.handleRead({ event, execute });
       }