stream-chat 9.21.0 → 9.22.1

package/src/channel_state.ts

@@ -31,6 +31,38 @@ type ChannelReadStatus = Record<
   }
 >;
 
+const messageSetBounds = (
+  a: LocalMessage[] | MessageResponse[],
+  b: LocalMessage[] | MessageResponse[],
+) => ({
+  newestMessageA: new Date(a[0]?.created_at ?? 0),
+  oldestMessageA: new Date(a.slice(-1)[0]?.created_at ?? 0),
+  newestMessageB: new Date(b[0]?.created_at ?? 0),
+  oldestMessageB: new Date(b.slice(-1)[0]?.created_at ?? 0),
+});
+
+const aContainsOrEqualsB = (a: LocalMessage[], b: LocalMessage[]) => {
+  const { newestMessageA, newestMessageB, oldestMessageA, oldestMessageB } =
+    messageSetBounds(a, b);
+  return newestMessageA >= newestMessageB && oldestMessageB >= oldestMessageA;
+};
+
+const aOverlapsB = (a: LocalMessage[], b: LocalMessage[]) => {
+  const { newestMessageA, newestMessageB, oldestMessageA, oldestMessageB } =
+    messageSetBounds(a, b);
+  return (
+    oldestMessageA < oldestMessageB &&
+    oldestMessageB < newestMessageA &&
+    newestMessageA < newestMessageB
+  );
+};
+
+const messageSetsOverlapByTimestamp = (a: LocalMessage[], b: LocalMessage[]) =>
+  aContainsOrEqualsB(a, b) ||
+  aContainsOrEqualsB(b, a) ||
+  aOverlapsB(a, b) ||
+  aOverlapsB(b, a);
+
 /**
  * ChannelState - A container class for the channel state.
  */
@@ -867,6 +899,41 @@ export class ChannelState {
     return this.messageSets[messageSetIndex].messages.find((m) => m.id === messageId);
   }
 
+  findMessageByTimestamp(
+    timestampMs: number,
+    parentMessageId?: string,
+    exactTsMatch: boolean = false,
+  ): LocalMessage | null {
+    if (
+      (parentMessageId && !this.threads[parentMessageId]) ||
+      this.messageSets.length === 0
+    )
+      return null;
+    const setIndex = this.findMessageSetByOldestTimestamp(timestampMs);
+    const targetMsgSet = this.messageSets[setIndex]?.messages;
+    if (!targetMsgSet?.length) return null;
+    const firstMsgTimestamp = targetMsgSet[0].created_at.getTime();
+    const lastMsgTimestamp = targetMsgSet.slice(-1)[0].created_at.getTime();
+    const isOutOfBound =
+      timestampMs < firstMsgTimestamp || lastMsgTimestamp < timestampMs;
+    if (isOutOfBound && exactTsMatch) return null;
+
+    let msgIndex = 0,
+      hi = targetMsgSet.length - 1;
+    while (msgIndex < hi) {
+      const mid = (msgIndex + hi) >>> 1;
+      if (timestampMs <= targetMsgSet[mid].created_at.getTime()) hi = mid;
+      else msgIndex = mid + 1;
+    }
+
+    const foundMessage = targetMsgSet[msgIndex];
+    return !exactTsMatch
+      ? foundMessage
+      : foundMessage.created_at.getTime() === timestampMs
+        ? foundMessage
+        : null;
+  }
+
   private switchToMessageSet(index: number) {
     const currentMessages = this.messageSets.find((s) => s.isCurrent);
     if (!currentMessages) {
@@ -889,6 +956,26 @@ export class ChannelState {
     );
   }
 
+  /**
+   * Identifies the set index into which a message set would pertain if its first item's creation date corresponded to oldestTimestampMs.
+   * @param oldestTimestampMs
+   */
+  private findMessageSetByOldestTimestamp = (oldestTimestampMs: number): number => {
+    let lo = 0,
+      hi = this.messageSets.length;
+    while (lo < hi) {
+      const mid = (lo + hi) >>> 1;
+      const msgSet = this.messageSets[mid];
+      // should not happen
+      if (msgSet.messages.length === 0) return -1;
+
+      const oldestMessageTimestampInSet = msgSet.messages[0].created_at.getTime();
+      if (oldestMessageTimestampInSet <= oldestTimestampMs) hi = mid;
+      else lo = mid + 1;
+    }
+    return lo;
+  };
+
   private findTargetMessageSet(
     newMessages: (MessageResponse | LocalMessage)[],
     addIfDoesNotExist = true,
@@ -896,39 +983,85 @@ export class ChannelState {
   ) {
     let messagesToAdd: (MessageResponse | LocalMessage)[] = newMessages;
     let targetMessageSetIndex!: number;
+    if (newMessages.length === 0)
+      return { targetMessageSetIndex: 0, messagesToAdd: newMessages };
     if (addIfDoesNotExist) {
-      const overlappingMessageSetIndices = this.messageSets
+      const overlappingMessageSetIndicesByMsgIds = this.messageSets
         .map((_, i) => i)
         .filter((i) =>
           this.areMessageSetsOverlap(this.messageSets[i].messages, newMessages),
         );
+      const overlappingMessageSetIndicesByTimestamp = this.messageSets
+        .map((_, i) => i)
+        .filter((i) =>
+          messageSetsOverlapByTimestamp(
+            this.messageSets[i].messages,
+            newMessages.map(formatMessage),
+          ),
+        );
       switch (messageSetToAddToIfDoesNotExist) {
         case 'new':
-          if (overlappingMessageSetIndices.length > 0) {
-            targetMessageSetIndex = overlappingMessageSetIndices[0];
+          if (overlappingMessageSetIndicesByMsgIds.length > 0) {
+            targetMessageSetIndex = overlappingMessageSetIndicesByMsgIds[0];
+          } else if (overlappingMessageSetIndicesByTimestamp.length > 0) {
+            targetMessageSetIndex = overlappingMessageSetIndicesByTimestamp[0];
             // No new message set is created if newMessages only contains thread replies
           } else if (newMessages.some((m) => !m.parent_id)) {
-            this.messageSets.push({
-              messages: [],
-              isCurrent: false,
-              isLatest: false,
-              pagination: DEFAULT_MESSAGE_SET_PAGINATION,
-            });
-            targetMessageSetIndex = this.messageSets.length - 1;
+            // find the index to insert the set
+            const setIngestIndex = this.findMessageSetByOldestTimestamp(
+              // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+              new Date(newMessages[0].created_at!).getTime(),
+            );
+            if (setIngestIndex === -1) {
+              this.messageSets.push({
+                messages: [],
+                isCurrent: false,
+                isLatest: false,
+                pagination: DEFAULT_MESSAGE_SET_PAGINATION,
+              });
+              targetMessageSetIndex = this.messageSets.length - 1;
+            } else {
+              const isLatest = setIngestIndex === 0;
+              this.messageSets.splice(setIngestIndex, 0, {
+                messages: [],
+                isCurrent: false,
+                isLatest,
+                pagination: DEFAULT_MESSAGE_SET_PAGINATION, // fixme: it is problematic decide about pagination without having data
+              });
+              if (isLatest) {
+                this.messageSets.slice(1).forEach((set) => {
+                  set.isLatest = false;
+                });
+              }
+              targetMessageSetIndex = setIngestIndex;
+            }
           }
           break;
         case 'current':
-          targetMessageSetIndex = this.messageSets.findIndex((s) => s.isCurrent);
+          // determine if there is another set to which it would match taken into consideration the timestamp
+          if (overlappingMessageSetIndicesByTimestamp.length > 0) {
+            targetMessageSetIndex = overlappingMessageSetIndicesByTimestamp[0];
+          } else {
+            targetMessageSetIndex = this.messageSets.findIndex((s) => s.isCurrent);
+          }
           break;
         case 'latest':
-          targetMessageSetIndex = this.messageSets.findIndex((s) => s.isLatest);
+          // determine if there is another set to which it would match taken into consideration the timestamp
+          if (overlappingMessageSetIndicesByTimestamp.length > 0) {
+            targetMessageSetIndex = overlappingMessageSetIndicesByTimestamp[0];
+          } else {
+            targetMessageSetIndex = this.messageSets.findIndex((s) => s.isLatest);
+          }
           break;
         default:
           targetMessageSetIndex = -1;
       }
       // when merging the target set will be the first one from the overlapping message sets
-      const mergeTargetMessageSetIndex = overlappingMessageSetIndices.splice(0, 1)[0];
-      const mergeSourceMessageSetIndices = [...overlappingMessageSetIndices];
+      const mergeTargetMessageSetIndex = overlappingMessageSetIndicesByMsgIds.splice(
+        0,
+        1,
+      )[0];
+      const mergeSourceMessageSetIndices = [...overlappingMessageSetIndicesByMsgIds];
       if (
         mergeTargetMessageSetIndex !== undefined &&
         mergeTargetMessageSetIndex !== targetMessageSetIndex

package/src/client.ts

@@ -80,6 +80,7 @@ import type {
   DeactivateUsersOptions,
   DeleteChannelsResponse,
   DeleteCommandResponse,
+  DeleteMessageOptions,
   DeleteUserOptions,
   Device,
   DeviceIdentifier,
@@ -240,6 +241,7 @@ import type {
   QueryChannelsRequestType,
 } from './channel_manager';
 import { ChannelManager } from './channel_manager';
+import { MessageDeliveryReporter } from './messageDelivery';
 import { NotificationManager } from './notifications';
 import { ReminderManager } from './reminders';
 import { StateStore } from './store';
@@ -272,7 +274,7 @@ export type MessageComposerSetupState = {
 
 export class StreamChat {
   private static _instance?: unknown | StreamChat; // type is undefined|StreamChat, unknown is due to TS limitations with statics
-
+  messageDeliveryReporter: MessageDeliveryReporter;
   _user?: OwnUserResponse | UserResponse;
   appSettingsPromise?: Promise<AppSettingsAPIResponse>;
   activeChannels: {
@@ -503,6 +505,7 @@ export class StreamChat {
     this.threads = new ThreadManager({ client: this });
     this.polls = new PollManager({ client: this });
     this.reminders = new ReminderManager({ client: this });
+    this.messageDeliveryReporter = new MessageDeliveryReporter({ client: this });
   }
 
   /**
@@ -2010,7 +2013,7 @@ export class StreamChat {
 
       channels.push(c);
     }
-
+    this.syncDeliveredCandidates(channels);
     return channels;
   }
 
@@ -3103,10 +3106,30 @@ export class StreamChat {
     );
   }
 
-  async deleteMessage(messageID: string, hardDelete?: boolean) {
+  /**
+   * deleteMessage - Delete a message
+   *
+   * @param {string} messageID The id of the message to delete
+   * @param {boolean | DeleteMessageOptions | undefined} [optionsOrHardDelete]
+   * @return {Promise<APIResponse & { message: MessageResponse }>} The API response
+   */
+  // fixme: remove the signature with optionsOrHardDelete boolean with the next major release
+  async deleteMessage(
+    messageID: string,
+    optionsOrHardDelete?: DeleteMessageOptions | boolean,
+  ): Promise<APIResponse & { message: MessageResponse }> {
+    let options: DeleteMessageOptions = {};
+    if (typeof optionsOrHardDelete === 'boolean') {
+      options = optionsOrHardDelete ? { hardDelete: true } : {};
+    } else if (optionsOrHardDelete?.deleteForMe) {
+      options = { deleteForMe: true };
+    } else if (optionsOrHardDelete?.hardDelete) {
+      options = { hardDelete: true };
+    }
+
     try {
       if (this.offlineDb) {
-        if (hardDelete) {
+        if (options.hardDelete) {
           await this.offlineDb.hardDeleteMessage({ id: messageID });
         } else {
           await this.offlineDb.softDeleteMessage({ id: messageID });
@@ -3115,7 +3138,7 @@ export class StreamChat {
           {
             task: {
               messageId: messageID,
-              payload: [messageID, hardDelete],
+              payload: [messageID, options],
               type: 'delete-message',
             },
           },
@@ -3128,18 +3151,40 @@ export class StreamChat {
       });
     }
 
-    return this._deleteMessage(messageID, hardDelete);
+    return this._deleteMessage(messageID, options);
   }
 
-  async _deleteMessage(messageID: string, hardDelete?: boolean) {
+  // fixme: remove the signature with optionsOrHardDelete boolean with the next major release
+  async _deleteMessage(
+    messageID: string,
+    optionsOrHardDelete?: DeleteMessageOptions | boolean,
+  ): Promise<APIResponse & { message: MessageResponse }> {
+    // this is a API call method, we do not route hardDelete: true and deleteForMe: true to deleteForMe: true
+    // and expect to receive error response from the server
+    const { deleteForMe, hardDelete } = (
+      typeof optionsOrHardDelete === 'boolean'
+        ? { hardDelete: optionsOrHardDelete }
+        : (optionsOrHardDelete ?? {})
+    ) as DeleteMessageOptions;
+
     let params = {};
     if (hardDelete) {
       params = { hard: true };
     }
-    return await this.delete<APIResponse & { message: MessageResponse }>(
+    if (deleteForMe) {
+      params = { ...params, delete_for_me: true };
+    }
+    const result = await this.delete<APIResponse & { message: MessageResponse }>(
       this.baseURL + `/messages/${encodeURIComponent(messageID)}`,
       params,
     );
+
+    // necessary to populate the below values as the server does not return the message in the response as deleted
+    if (deleteForMe) {
+      result.message.deleted_for_me = true;
+      result.message.type = 'deleted';
+    }
+    return result;
   }
 
   /**
@@ -4701,19 +4746,20 @@ export class StreamChat {
   }
 
   /**
-   * Send the mark delivered event for this user, only works if the `delivery_receipts` setting is enabled
+   * Send the mark delivered event for this user
    *
    * @param {MarkDeliveredOptions} data
    * @return {Promise<EventAPIResponse | void>} Description
    */
-  async markChannelsDelivered(data?: MarkDeliveredOptions) {
-    const deliveryReceiptsEnabled =
-      this.user?.privacy_settings?.delivery_receipts?.enabled;
-    if (!deliveryReceiptsEnabled) return;
-
+  async markChannelsDelivered(data: MarkDeliveredOptions) {
+    if (!data?.latest_delivered_messages?.length) return;
     return await this.post<EventAPIResponse>(
       this.baseURL + '/channels/delivered',
       data ?? {},
     );
   }
+
+  syncDeliveredCandidates(collections: Channel[]) {
+    this.messageDeliveryReporter.syncDeliveredCandidates(collections);
+  }
 }

package/src/events.ts

@@ -31,6 +31,7 @@ export const EVENT_MAP = {
   'notification.mark_unread': true,
   'notification.message_new': true,
   'notification.mutes_updated': true,
+  'notification.reminder_due': true,
   'notification.removed_from_channel': true,
   'notification.thread_message_new': true,
   'poll.closed': true,
@@ -41,6 +42,9 @@ export const EVENT_MAP = {
   'reaction.deleted': true,
   'reaction.new': true,
   'reaction.updated': true,
+  'reminder.created': true,
+  'reminder.deleted': true,
+  'reminder.updated': true,
   'thread.updated': true,
   'typing.start': true,
   'typing.stop': true,
@@ -67,10 +71,4 @@ export const EVENT_MAP = {
   'capabilities.changed': true,
   'live_location_sharing.started': true,
   'live_location_sharing.stopped': true,
-
-  // Reminder events
-  'reminder.created': true,
-  'reminder.updated': true,
-  'reminder.deleted': true,
-  'notification.reminder_due': true,
 };

package/src/index.ts

@@ -8,6 +8,7 @@ export * from './connection';
 export * from './events';
 export * from './insights';
 export * from './messageComposer';
+export * from './messageDelivery';
 export * from './middleware';
 export * from './moderation';
 export * from './notifications';

package/src/messageDelivery/MessageDeliveryReporter.ts

@@ -0,0 +1,259 @@
+import type { StreamChat } from '../client';
+import { Channel } from '../channel';
+import type { ThreadUserReadState } from '../thread';
+import { Thread } from '../thread';
+import type {
+  EventAPIResponse,
+  LocalMessage,
+  MarkDeliveredOptions,
+  MarkReadOptions,
+} from '../types';
+import { throttle } from '../utils';
+
+const MAX_DELIVERED_MESSAGE_COUNT_IN_PAYLOAD = 100 as const;
+const MARK_AS_DELIVERED_BUFFER_TIMEOUT = 1000 as const;
+const MARK_AS_READ_THROTTLE_TIMEOUT = 1000 as const;
+
+const isChannel = (item: Channel | Thread): item is Channel => item instanceof Channel;
+const isThread = (item: Channel | Thread): item is Thread => item instanceof Thread;
+
+type MessageId = string;
+type ChannelThreadCompositeId = string;
+
+export type AnnounceDeliveryOptions = Omit<
+  MarkDeliveredOptions,
+  'latest_delivered_messages'
+>;
+
+export type MessageDeliveryReporterOptions = {
+  client: StreamChat;
+};
+
+export class MessageDeliveryReporter {
+  protected client: StreamChat;
+
+  protected deliveryReportCandidates: Map<ChannelThreadCompositeId, MessageId> =
+    new Map();
+  protected nextDeliveryReportCandidates: Map<ChannelThreadCompositeId, MessageId> =
+    new Map();
+
+  protected markDeliveredRequestPromise: Promise<EventAPIResponse | void> | null = null;
+  protected markDeliveredTimeout: ReturnType<typeof setTimeout> | null = null;
+
+  constructor({ client }: MessageDeliveryReporterOptions) {
+    this.client = client;
+  }
+
+  private get markDeliveredRequestInFlight() {
+    return this.markDeliveredRequestPromise !== null;
+  }
+  private get hasTimer() {
+    return this.markDeliveredTimeout !== null;
+  }
+  private get hasDeliveryCandidates() {
+    return this.deliveryReportCandidates.size > 0;
+  }
+
+  /**
+   * Build latest_delivered_messages payload from an arbitrary buffer (deliveryReportCandidates / nextDeliveryReportCandidates)
+   */
+  private confirmationsFrom(map: Map<ChannelThreadCompositeId, MessageId>) {
+    return Array.from(map.entries()).map(([key, messageId]) => {
+      const [type, id, parent_id] = key.split(':');
+      return parent_id
+        ? { cid: `${type}:${id}`, id: messageId, parent_id }
+        : { cid: key, id: messageId };
+    });
+  }
+
+  private confirmationsFromDeliveryReportCandidates() {
+    const entries = Array.from(this.deliveryReportCandidates);
+    const sendBuffer = new Map(entries.slice(0, MAX_DELIVERED_MESSAGE_COUNT_IN_PAYLOAD));
+    this.deliveryReportCandidates = new Map(
+      entries.slice(MAX_DELIVERED_MESSAGE_COUNT_IN_PAYLOAD),
+    );
+
+    return { latest_delivered_messages: this.confirmationsFrom(sendBuffer), sendBuffer };
+  }
+
+  /**
+   * Generate candidate key for storing in the candidates buffer
+   * @param collection
+   * @private
+   */
+  private candidateKeyFor(
+    collection: Channel | Thread,
+  ): ChannelThreadCompositeId | undefined {
+    if (isChannel(collection)) return collection.cid;
+    if (isThread(collection)) return `${collection.channel.cid}:${collection.id}`;
+  }
+
+  /**
+   * Retrieve the reference to the latest message in the state that is nor read neither reported as delivered
+   * @param collection
+   */
+  private getNextDeliveryReportCandidate = (
+    collection: Channel | Thread,
+  ): { key: ChannelThreadCompositeId; id: MessageId | null } | undefined => {
+    const ownUserId = this.client.user?.id;
+    if (!ownUserId) return;
+
+    let latestMessages: LocalMessage[] = [];
+    let lastDeliveredAt: Date | undefined;
+    let lastReadAt: Date | undefined;
+    let key: string | undefined = undefined;
+
+    if (isChannel(collection)) {
+      latestMessages = collection.state.latestMessages;
+      const ownReadState = collection.state.read[ownUserId] ?? {};
+      lastReadAt = ownReadState?.last_read;
+      lastDeliveredAt = ownReadState?.last_delivered_at;
+      key = collection.cid;
+    } else if (isThread(collection)) {
+      latestMessages = collection.state.getLatestValue().replies;
+      const ownReadState =
+        collection.state.getLatestValue().read[ownUserId] ?? ({} as ThreadUserReadState);
+      lastReadAt = ownReadState?.lastReadAt;
+      // @ts-expect-error lastDeliveredAt is not defined yet on ThreadUserReadState
+      lastDeliveredAt = ownReadState?.lastDeliveredAt;
+      key = `${collection.channel.cid}:${collection.id}`;
+      // todo: remove return statement once marking messages as delivered in thread is supported
+      return;
+    } else {
+      return;
+    }
+
+    if (!key) return;
+
+    const [latestMessage] = latestMessages.slice(-1);
+
+    const wholeCollectionIsRead =
+      !latestMessage || lastReadAt >= latestMessage.created_at;
+    if (wholeCollectionIsRead) return { key, id: null };
+    const wholeCollectionIsMarkedDelivered =
+      !latestMessage || (lastDeliveredAt ?? 0) >= latestMessage.created_at;
+    if (wholeCollectionIsMarkedDelivered) return { key, id: null };
+
+    return { key, id: latestMessage.id || null };
+  };
+
+  /**
+   * Updates the delivery candidates buffer with the latest delivery candidates
+   * @param collection
+   */
+  private trackDeliveredCandidate(collection: Channel | Thread) {
+    if (isChannel(collection) && !collection.getConfig()?.read_events) return;
+    if (isThread(collection) && !collection.channel.getConfig()?.read_events) return;
+    const candidate = this.getNextDeliveryReportCandidate(collection);
+    if (!candidate?.key) return;
+    const buffer = this.markDeliveredRequestInFlight
+      ? this.nextDeliveryReportCandidates
+      : this.deliveryReportCandidates;
+    if (candidate.id === null) buffer.delete(candidate.key);
+    else buffer.set(candidate.key, candidate.id);
+  }
+
+  /**
+   * Removes candidate from the delivery report buffer
+   * @param collection
+   * @private
+   */
+  private removeCandidateFor(collection: Channel | Thread) {
+    const candidateKey = this.candidateKeyFor(collection);
+    if (!candidateKey) return;
+    this.deliveryReportCandidates.delete(candidateKey);
+    this.nextDeliveryReportCandidates.delete(candidateKey);
+  }
+
+  /**
+   * Records the latest message delivered for Channel or Thread instances and schedules the next report
+   * if not already scheduled and candidates exist.
+   * Should be used for WS handling (message.new) as well as for ingesting HTTP channel query results.
+   * @param collections
+   */
+  public syncDeliveredCandidates(collections: (Channel | Thread)[]) {
+    if (this.client.user?.privacy_settings?.delivery_receipts?.enabled === false) return;
+    for (const c of collections) this.trackDeliveredCandidate(c);
+    this.announceDeliveryBuffered();
+  }
+
+  /**
+   * Fires delivery announcement request followed by immediate delivery candidate buffer reset.
+   * @param options
+   */
+  public announceDelivery = (options?: AnnounceDeliveryOptions) => {
+    if (this.markDeliveredRequestInFlight || !this.hasDeliveryCandidates) return;
+
+    const { latest_delivered_messages, sendBuffer } =
+      this.confirmationsFromDeliveryReportCandidates();
+    if (!latest_delivered_messages.length) return;
+
+    const payload = { ...options, latest_delivered_messages };
+
+    const postFlightReconcile = () => {
+      this.markDeliveredRequestPromise = null;
+
+      // promote anything that arrived during request
+      for (const [k, v] of this.nextDeliveryReportCandidates.entries()) {
+        this.deliveryReportCandidates.set(k, v);
+      }
+      this.nextDeliveryReportCandidates = new Map();
+
+      // checks internally whether there are candidates to announce
+      this.announceDeliveryBuffered(options);
+    };
+
+    const handleError = () => {
+      // repopulate relevant candidates for the next report
+      for (const [k, v] of Object.entries(sendBuffer)) {
+        if (!this.deliveryReportCandidates.has(k)) {
+          this.deliveryReportCandidates.set(k, v);
+        }
+      }
+      postFlightReconcile();
+    };
+
+    this.markDeliveredRequestPromise = this.client
+      .markChannelsDelivered(payload)
+      .then(postFlightReconcile, handleError);
+  };
+
+  public announceDeliveryBuffered = (options?: AnnounceDeliveryOptions) => {
+    if (this.hasTimer || this.markDeliveredRequestInFlight || !this.hasDeliveryCandidates)
+      return;
+    this.markDeliveredTimeout = setTimeout(() => {
+      this.markDeliveredTimeout = null;
+      this.announceDelivery(options);
+    }, MARK_AS_DELIVERED_BUFFER_TIMEOUT);
+  };
+
+  /**
+   * Delegates the mark-read call to the Channel or Thread instance
+   * @param collection
+   * @param options
+   */
+  public markRead = async (collection: Channel | Thread, options?: MarkReadOptions) => {
+    let result: EventAPIResponse | null = null;
+    if (isChannel(collection)) {
+      result = await collection.markAsReadRequest(options);
+    } else if (isThread(collection)) {
+      result = await collection.channel.markAsReadRequest({
+        ...options,
+        thread_id: collection.id,
+      });
+    }
+
+    this.removeCandidateFor(collection);
+    return result;
+  };
+
+  /**
+   * Throttles the MessageDeliveryReporter.markRead call
+   * @param collection
+   * @param options
+   */
+  public throttledMarkRead = throttle(this.markRead, MARK_AS_READ_THROTTLE_TIMEOUT, {
+    leading: false,
+    trailing: true,
+  });
+}