stream-chat 9.49.0 → 9.50.1

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;
@@ -12597,6 +12638,7 @@ var DEFAULT_CONNECTION_RECOVERY_THROTTLE_DURATION = 1e3;
 var MAX_QUERY_THREADS_LIMIT = 25;
 var THREAD_MANAGER_INITIAL_STATE = {
   active: false,
+  wasActivatedAtLeastOnce: false,
   isThreadOrderStale: false,
   threads: [],
   unreadThreadCount: 0,
@@ -12619,7 +12661,7 @@ var ThreadManager = class extends WithSubscriptions {
       this.state.next(THREAD_MANAGER_INITIAL_STATE);
     };
     this.activate = () => {
-      this.state.partialNext({ active: true });
+      this.state.partialNext({ active: true, wasActivatedAtLeastOnce: true });
     };
     this.deactivate = () => {
       this.state.partialNext({ active: false });
@@ -12699,8 +12741,8 @@ var ThreadManager = class extends WithSubscriptions {
       }).unsubscribe;
       const throttledHandleConnectionRecovered = throttle(
         () => {
-          const { lastConnectionDropAt } = this.state.getLatestValue();
-          if (!lastConnectionDropAt) return;
+          const { lastConnectionDropAt, wasActivatedAtLeastOnce } = this.state.getLatestValue();
+          if (!lastConnectionDropAt || !wasActivatedAtLeastOnce) return;
           this.reload({ force: true });
         },
         DEFAULT_CONNECTION_RECOVERY_THROTTLE_DURATION,
@@ -14832,7 +14874,7 @@ var StreamChat = class _StreamChat {
         return this.userAgent;
       }
       if (!this.cachedUserAgent) {
-        const version = "9.49.0";
+        const version = "9.50.1";
         const { name: sdkName, version: sdkVersion } = this.sdkIdentifier ?? {};
         const { name: appName, version: appVersion } = this.appIdentifier ?? {};
         const { os, model: deviceModel } = this.deviceIdentifier ?? {};
@@ -14890,6 +14932,7 @@ var StreamChat = class _StreamChat {
       warmUp: false,
       recoverStateOnReconnect: true,
       disableCache: false,
+      isLocalUnreadCountEnabled: false,
       wsUrlParams: new URLSearchParams({}),
       ...inputOptions
     };
@@ -18243,6 +18286,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,
@@ -18626,7 +18670,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({
@@ -18634,8 +18679,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
                   }
@@ -18834,27 +18879,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);
         }
@@ -18955,6 +19003,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 });
       }