stream-chat 10.0.0-rc.13 → 10.0.0-rc.15

package/dist/cjs/index.browser.js

@@ -137,6 +137,7 @@ __export(src_exports, {
   WS_NETWORK_RECOVERY_RETRY_MS: () => WS_NETWORK_RECOVERY_RETRY_MS,
   ZERO_PAGE_CURSOR: () => ZERO_PAGE_CURSOR,
   accentsMap: () => accentsMap,
+  asTimestampNS: () => asTimestampNS,
   browserNetworkStatusReporter: () => browserNetworkStatusReporter,
   calculateLevenshtein: () => calculateLevenshtein,
   chatCodes: () => chatCodes,
@@ -407,8 +408,9 @@ var chatLoggerSystem = scopedLogger.createLoggerSystem();
 
 // src/utils/time.ts
 var NS_PER_MS = 1e6;
+var asTimestampNS = (ns) => ns;
 var nsToMs = (ns) => Math.floor(ns / NS_PER_MS);
-var msToNs = (ms) => ms * NS_PER_MS;
+var msToNs = (ms) => asTimestampNS(ms * NS_PER_MS);
 var nowNs = () => msToNs(Date.now());
 var nsToDate = (ns) => new Date(nsToMs(ns));
 var nsToRfc3339 = (ns) => {
@@ -550,7 +552,7 @@ 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 channelTracksReadLocally = (channel) => !channelHasReadEvents(channel) && !!channel?.config.readEvents.localUnreadCountEnabled;
 function retryInterval(numberOfFailures) {
   const max = Math.min(500 + numberOfFailures * 2e3, 25e3);
   const min = Math.min(Math.max(250, (numberOfFailures - 1) * 2e3), 25e3);
@@ -8663,7 +8665,7 @@ var MessagePaginator = class extends MessageIntervalPaginator {
     const { lastMessage, seededLastMessageAt } = this.aggregateState.getLatestValue();
     const fromMessage = getMessageCreatedAtTimestamp(lastMessage);
     if (fromMessage !== null && seededLastMessageAt !== null) {
-      return Math.max(fromMessage, seededLastMessageAt);
+      return asTimestampNS(Math.max(fromMessage, seededLastMessageAt));
     }
     return fromMessage ?? seededLastMessageAt;
   }
@@ -14476,11 +14478,12 @@ var MessageDeliveryReporter = class _MessageDeliveryReporter {
       }, this.requestTimeoutMs);
     };
     /**
-     * Delegates the mark-read call to the Channel or Thread instance.
+     * Delegates the mark-read call to the Channel or Thread instance. A channel whose read events are
+     * disabled is marked read locally instead, when the client opted into counting unread itself.
      *
      * @param collection - The channel or thread to mark as read.
      * @param options - Flags forwarded to the underlying `markRead` call (optional).
-     * @returns The server response, or `null` when the collection is unsupported.
+     * @returns The server response, or `null` when no request went out.
      */
     this.markRead = async (collection, options) => {
       const isThreadCollection = isThread(collection);
@@ -14494,8 +14497,15 @@ var MessageDeliveryReporter = class _MessageDeliveryReporter {
           thread: collection
         }) ?? null : await channel.markRead(requestOptions);
       } else {
-        const markReadRequestHandler = channel.configState.getLatestValue().requestHandlers?.markReadRequest;
-        result = markReadRequestHandler ? await markReadRequestHandler({ channel, options: requestOptions }) ?? null : await channel.markRead(requestOptions);
+        const { readEvents, requestHandlers } = channel.configState.getLatestValue();
+        const markReadRequestHandler = requestHandlers?.markReadRequest;
+        if (markReadRequestHandler) {
+          result = await markReadRequestHandler({ channel, options: requestOptions }) ?? null;
+        } else if (!readEvents.enabled && readEvents.localUnreadCountEnabled) {
+          channel.markReadLocally();
+        } else {
+          result = await channel.markRead(requestOptions);
+        }
       }
       if (result) this.removeCandidateFor(collection);
       return result;
@@ -14669,7 +14679,10 @@ var MessageDeliveryReporter = class _MessageDeliveryReporter {
 
 // src/messageDelivery/MessageReceiptsTracker.ts
 var import_state_store20 = require("@stream-io/state-store");
-var MIN_REF = { timestamp: Number.NEGATIVE_INFINITY, msgId: "" };
+var MIN_REF = {
+  timestamp: asTimestampNS(Number.NEGATIVE_INFINITY),
+  msgId: ""
+};
 var isValidReadState = (readState) => !!readState?.user && Number.isFinite(readState.last_read);
 var compareRefsAsc = (a, b) => a.timestamp !== b.timestamp ? a.timestamp - b.timestamp : 0;
 var findIndex = (arr, target, keyOf) => {
@@ -15446,7 +15459,7 @@ var ownDeclarativeConfig = (slice) => {
 var DEFAULT_CHANNEL_CONFIG = deepFreezeConfig({
   availableCommands: [],
   deliveryEvents: { enabled: true },
-  readEvents: { enabled: true },
+  readEvents: { enabled: true, localUnreadCountEnabled: false },
   replies: { enabled: true },
   typingEvents: { enabled: true },
   userMessageReminders: { enabled: true }
@@ -16200,7 +16213,7 @@ var Channel = class extends WithMessageOperations(ChannelApi) {
   /**
    * Returns the mute status for the current channel.
    *
-   * @returns An object of the form `{ muted: true | false, createdAt: number | null, expiresAt: number | null }`,
+   * @returns An object of the form `{ muted: true | false, createdAt: TimestampNS | null, expiresAt: TimestampNS | null }`,
    *   where the timestamps are unix nanoseconds as the API sends them.
    */
   muteStatus() {
@@ -16473,7 +16486,7 @@ var Channel = class extends WithMessageOperations(ChannelApi) {
   /**
    * 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
+   * `readEvents.localUnreadCountEnabled` configuration. 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
@@ -16635,7 +16648,7 @@ var Channel = class extends WithMessageOperations(ChannelApi) {
     if (message.user?.id === this.getClient().userId) return false;
     if (message.user?.id && this.getClient().userMuteStatus(message.user.id))
       return false;
-    if (!this.getClient().options.isLocalUnreadCountEnabled && !channelHasReadEvents(this)) {
+    if (!this.config.readEvents.localUnreadCountEnabled && !channelHasReadEvents(this)) {
       return false;
     }
     if (this.muteStatus().muted) return false;
@@ -17153,7 +17166,7 @@ var Channel = class extends WithMessageOperations(ChannelApi) {
                 }
                 if (ownUserId && countsAsOwnUnread && !currentReadState[ownUserId]) {
                   nextReadState[ownUserId] = {
-                    last_read: 0,
+                    last_read: asTimestampNS(0),
                     unread_messages: 1,
                     user: client.user ?? { id: ownUserId }
                   };
@@ -17769,8 +17782,9 @@ var ApiClient = class {
     if (limit) rateLimit.rate_limit = parseInt(limit, 10);
     const remaining = headers["x-ratelimit-remaining"];
     if (remaining) rateLimit.rate_limit_remaining = parseInt(remaining, 10);
-    const reset = headers["x-ratelimit-reset"];
-    if (reset) rateLimit.rate_limit_reset = new Date(reset);
+    const reset = Number(headers["x-ratelimit-reset"]);
+    if (Number.isFinite(reset) && reset > 0)
+      rateLimit.rate_limit_reset = new Date(reset * 1e3);
     return {
       response_headers: headers,
       rate_limit: rateLimit,
@@ -17971,6 +17985,7 @@ var ModerationApi = class {
       appeal_reason: request?.appeal_reason,
       entity_id: request?.entity_id,
       entity_type: request?.entity_type,
+      channel_cid: request?.channel_cid,
       review_queue_item_id: request?.review_queue_item_id,
       attachments: request?.attachments
     };
@@ -23317,6 +23332,7 @@ var ChatApi = class {
       id: request?.id,
       is_closed: request?.is_closed,
       max_votes_allowed: request?.max_votes_allowed,
+      team: request?.team,
       voting_visibility: request?.voting_visibility,
       options: request?.options,
       custom: request?.custom
@@ -24404,7 +24420,7 @@ var StreamChat = class _StreamChat extends ChatApi {
         return this.userAgent;
       }
       if (!this.cachedUserAgent) {
-        const version = "10.0.0-rc.13";
+        const version = "10.0.0-rc.15";
         const { name: sdkName, version: sdkVersion } = this.sdkIdentifier ?? {};
         const { name: appName, version: appVersion } = this.appIdentifier ?? {};
         const { os, model: deviceModel } = this.deviceIdentifier ?? {};
@@ -24460,10 +24476,7 @@ var StreamChat = class _StreamChat extends ChatApi {
     this.uploadManager = new UploadManager(this);
     this.browser = options.browser ?? typeof window !== "undefined";
     this.node = !this.browser;
-    this.options = {
-      isLocalUnreadCountEnabled: false,
-      ...options
-    };
+    this.options = { ...options };
     this.axiosInstance = import_axios4.default.create({
       timeout: 3e3,
       withCredentials: false,
@@ -25222,6 +25235,10 @@ var StreamChat = class _StreamChat extends ChatApi {
   /**
    * Pins the message.
    *
+   * A `number` is a relative offset in SECONDS, so a server-sent timestamp (`message.pinned_at`,
+   * `message.pin_expires`) is rejected at compile time rather than read as ~1.79e18 seconds from now.
+   * Hand one back as a date with `nsToDate(timestamp)`.
+   *
    * @param messageOrMessageId - MessageRequest object or message ID.
    * @param timeoutOrExpirationDate - Expiration date or timeout. Use `number` to set the timeout
    *   in seconds, `string` or `Date` to set the exact expiration date (optional).
@@ -25949,6 +25966,11 @@ var CHANNEL_FIELDS = {
         description: 'Allows marking the channel read or unread. The server must also allow it per channel type (`read_events`), and a server "no" wins.',
         kind: "value",
         type: "boolean"
+      },
+      localUnreadCountEnabled: {
+        description: "Counts unread messages client-side when `enabled` is false, reset by `channel.markReadLocally()` instead of a request. Not subject to server authority.",
+        kind: "value",
+        type: "boolean"
       }
     },
     kind: "group"
@@ -26675,13 +26697,13 @@ var AbstractOfflineDB = class {
       execute = true
     }) => {
       const {
-        received_at: last_read = nowNs(),
         last_read_message_id,
         // @ts-expect-error property missing
         unread_messages = 0,
         user,
         cid
       } = event;
+      const last_read = (event.type === "notification.mark_unread" ? event.last_read_at : void 0) ?? event.created_at ?? event.received_at ?? nowNs();
       const overriddenUnreadMessages = unreadMessages ?? unread_messages;
       if (user?.id && cid) {
         return await this.queriesWithChannelGuard(