@talkjs/core 1.1.0 → 1.2.0

package/dist/talkSession.d.ts

@@ -381,6 +381,19 @@ export declare interface ConversationRef {
      * The snapshot is null if you are not a participant in the conversation (including when the conversation doesn't exist)
      */
     subscribeMessages(onSnapshot?: (snapshot: MessageSnapshot[] | null, loadedAll: boolean) => void): MessageSubscription;
+    /**
+     * Subscribes to the participants in the conversation.
+     *
+     * @remarks
+     * Initially, you will be subscribed to the 10 participants who joined most recently, and any new participants.
+     * Call `loadMore` to load additional older participants.
+     *
+     * Whenever `Subscription.state.type` is "active" and a participant is created, edited, deleted, or you load more participants, `onSnapshot` will fire and `Subscription.state.latestSnapshot` will be updated.
+     * `loadedAll` is true when the snapshot contains all the participants in the conversation.
+     *
+     * The snapshot is null if you are not a participant in the conversation (including when the conversation doesn't exist)
+     */
+    subscribeParticipants(onSnapshot?: (snapshot: ParticipantSnapshot[] | null, loadedAll: boolean) => void): ParticipantSubscription;
     /**
      * Subscribes to the conversation.
      *
@@ -494,9 +507,25 @@ export declare interface ConversationSnapshot {
      */
     unreadMessageCount: number;
     /**
-     * Timestamp of when the current user read a message
+     * The most recent date that the current user read the conversation.
+     *
+     * @remarks
+     * This value is updated whenever you read a message in a chat UI, open an email notification, or mark the conversation as read using an API like {@link ConversationRef.markAsRead}.
+     *
+     * Any messages sent after this timestamp are unread messages.
      */
     readUntil: number;
+    /**
+     * Everyone in the conversation has read any messages sent on or before this date.
+     *
+     * @remarks
+     * This is the minimum of all the participants' `readUntil` values.
+     * Any messages sent on or before this timestamp should show a "read" indicator in the UI.
+     *
+     * This value will rarely change in very large conversations.
+     * If just one person stops checking their messages, `everyoneReadUntil` will never update.
+     */
+    everyoneReadUntil: number;
     /**
      * Whether the conversation should be considered unread.
      *
@@ -1229,7 +1258,7 @@ export declare interface MessageSnapshot {
  * Get a MessageSubscription by calling {@link ConversationRef.subscribeMessages}
  *
  * The subscription is 'windowed'. It includes all messages since a certain point in time.
- * By default, you subscribe to the 30 most recent messages, and any new messages are sent after you subscribe.
+ * By default, you subscribe to the 30 most recent messages, and any new messages that are sent after you subscribe.
  *
  * You can expand this window by calling {@link MessageSubscription.loadMore}, which extends the window further into the past.
  *
@@ -1275,7 +1304,7 @@ export declare interface MessageSubscription {
      * @remarks
      * Calling `loadMore` multiple times in parallel will still only load one page of messages.
      *
-     * @param count - The number of additional messages to load. Must be between 1 and 100
+     * @param count - The number of additional messages to load. Must be between 1 and 100. Default 30.
      * @returns A promise that resolves once the additional messages have loaded
      */
     loadMore(count?: number): Promise<void>;
@@ -1288,6 +1317,24 @@ export declare interface MessageSubscription {
     unsubscribe(): void;
 }
 
+/**
+ * The state of a participants subscription when it is actively listening for changes
+ *
+ * @public
+ */
+export declare interface ParticipantActiveState {
+    type: "active";
+    /**
+     * The most recently received snapshot for the participants, or `null` if you are not a participant in that conversation.
+     */
+    latestSnapshot: ParticipantSnapshot[] | null;
+    /**
+     * True if `latestSnapshot` contains all participants in the conversation.
+     * Use {@link ParticipantSubscription.loadMore} to load more.
+     */
+    loadedAll: boolean;
+}
+
 /**
  * References a given user's participation in a conversation.
  *
@@ -1397,6 +1444,72 @@ export declare interface ParticipantSnapshot {
     joinedAt: number;
 }
 
+/**
+ * A subscription to the participants in a specific conversation.
+ *
+ * @remarks
+ * Get a ParticipantSubscription by calling {@link ConversationRef.subscribeParticipants}
+ *
+ * The subscription is 'windowed'. It includes everyone who joined since a certain point in time.
+ * By default, you subscribe to the 10 most recent participants, and any participants who joined after you subscribe.
+ *
+ * You can expand this window by calling {@link ParticipantSubscription.loadMore}, which extends the window further into the past.
+ *
+ * @public
+ */
+export declare interface ParticipantSubscription {
+    /**
+     * The current state of the subscription
+     *
+     * @remarks
+     * An object with the following fields:
+     *
+     * `type` is one of "pending", "active", "unsubscribed", or "error".
+     *
+     * When `type` is "active", includes `latestSnapshot` and `loadedAll`.
+     *
+     * - `latestSnapshot: ParticipantSnapshot[] | null` the current state of the participants in the window, or null if you're not a participant in the conversation
+     *
+     * - `loadedAll: boolean` true when `latestSnapshot` contains all the participants in the conversation
+     *
+     * When `type` is "error", includes the `error` field. It is a JS `Error` object explaining what caused the subscription to be terminated.
+     */
+    state: PendingState | ParticipantActiveState | UnsubscribedState | ErrorState;
+    /**
+     * Resolves when the subscription starts receiving updates from the server.
+     *
+     * @remarks
+     * Wait for this promise if you want to perform some action as soon as the subscription is active.
+     *
+     * The promise rejects if the subscription is terminated before it connects.
+     */
+    connected: Promise<ParticipantActiveState>;
+    /**
+     * Resolves when the subscription permanently stops receiving updates from the server.
+     *
+     * @remarks
+     * This is either because you unsubscribed or because the subscription encountered an unrecoverable error.
+     */
+    terminated: Promise<UnsubscribedState | ErrorState>;
+    /**
+     * Expand the window to include older participants
+     *
+     * @remarks
+     * Calling `loadMore` multiple times in parallel will still only load one page of participants.
+     *
+     * @param count - The number of additional participants to load. Must be between 1 and 50. Default 10.
+     * @returns A promise that resolves once the additional participants have loaded
+     */
+    loadMore(count?: number): Promise<void>;
+    /**
+     * Unsubscribe from this resource and stop receiving updates.
+     *
+     * @remarks
+     * If the subscription is already in the "unsubscribed" or "error" state, this is a no-op.
+     */
+    unsubscribe(): void;
+}
+
 /**
  * The state of a subscription before it has connected to the server
  *