stream-chat 9.49.0 → 9.50.0

package/dist/esm/index.mjs

@@ -406,6 +406,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 FormData();
   if (isReadableStream(uri) || isBuffer(uri) || isFileWebAPI(uri) || isBlobWebAPI(uri)) {
@@ -8567,6 +8573,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);
@@ -9911,6 +9918,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
    */
@@ -10066,7 +10100,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;
@@ -10477,6 +10511,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];
@@ -10497,7 +10536,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;
@@ -14617,7 +14658,7 @@ var StreamChat = class _StreamChat {
         return this.userAgent;
       }
       if (!this.cachedUserAgent) {
-        const version = "9.49.0";
+        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 ?? {};
@@ -14675,6 +14716,7 @@ var StreamChat = class _StreamChat {
       warmUp: false,
       recoverStateOnReconnect: true,
       disableCache: false,
+      isLocalUnreadCountEnabled: false,
       wsUrlParams: new URLSearchParams({}),
       ...inputOptions
     };
@@ -18028,6 +18070,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,
@@ -18411,7 +18454,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({
@@ -18419,8 +18463,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
                   }
@@ -18619,27 +18663,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);
         }
@@ -18740,6 +18787,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 });
       }