stream-chat 9.50.2 → 10.0.0-rc.1

package/dist/types/thread.d.ts

@@ -1,18 +1,12 @@
 import { StateStore } from './store';
-import type { AscDesc, LocalMessage, MessagePaginationOptions, MessageResponse, ThreadResponse, UserResponse } from './types';
-import type { Channel } from './channel';
+import type { DraftResponse, EventAPIResponse, LocalMessage, MarkReadRequest, MessageResponse, ThreadStateResponse, UserResponse } from './types';
+import type { Channel, DeleteMessageWithStateUpdateParams, SendMessageWithStateUpdateParams, UpdateMessageWithStateUpdateParams } from './channel';
 import type { StreamChat } from './client';
 import type { CustomThreadData } from './custom_types';
 import { MessageComposer } from './messageComposer';
+import { MessageOperations } from './messageOperations';
 import { WithSubscriptions } from './utils/WithSubscriptions';
-type QueryRepliesOptions = {
-    sort?: {
-        created_at: AscDesc;
-    }[];
-} & MessagePaginationOptions & {
-    user?: UserResponse;
-    user_id?: string;
-};
+import { MessagePaginator } from './pagination';
 export type ThreadState = {
     /**
      * Determines if the thread is currently opened and on-screen. When the thread is active,
@@ -25,25 +19,17 @@ export type ThreadState = {
     deletedAt: Date | null;
     isLoading: boolean;
     isStateStale: boolean;
-    pagination: ThreadRepliesPagination;
     /**
      * Thread is identified by and has a one-to-one relation with its parent message.
      * We use parent message id as a thread id.
      */
     parentMessage: LocalMessage;
-    participants: ThreadResponse['thread_participants'];
+    participants: ThreadStateResponse['thread_participants'];
     read: ThreadReadState;
-    replies: Array<LocalMessage>;
     replyCount: number;
     title: string;
     updatedAt: Date | null;
 };
-export type ThreadRepliesPagination = {
-    isLoadingNext: boolean;
-    isLoadingPrev: boolean;
-    nextCursor: string | null;
-    prevCursor: string | null;
-};
 export type ThreadUserReadState = {
     lastReadAt: Date;
     unreadMessageCount: number;
@@ -52,16 +38,30 @@ export type ThreadUserReadState = {
     firstUnreadMessageId?: string;
 };
 export type ThreadReadState = Record<string, ThreadUserReadState | undefined>;
-export declare const THREAD_RESPONSE_RESERVED_KEYS: Record<keyof ThreadResponse, true>;
+export type CustomThreadMarkReadRequestFn = (params: {
+    thread: Thread;
+    options?: MarkReadRequest;
+}) => Promise<EventAPIResponse | null> | void;
+export type ThreadInstanceConfig = {
+    requestHandlers?: {
+        markReadRequest?: CustomThreadMarkReadRequestFn;
+    };
+};
 export declare class Thread extends WithSubscriptions {
+    readonly configState: StateStore<ThreadInstanceConfig>;
     readonly state: StateStore<ThreadState>;
     readonly id: string;
     readonly messageComposer: MessageComposer;
+    readonly messagePaginator: MessagePaginator;
+    readonly messageOperations: MessageOperations;
     private client;
     private failedRepliesMap;
-    constructor({ client, threadData, }: {
+    constructor({ client, threadData, channel, parentMessage, draft, }: {
         client: StreamChat;
-        threadData: ThreadResponse;
+        threadData?: ThreadStateResponse;
+        channel?: Channel;
+        parentMessage?: MessageResponse | LocalMessage;
+        draft?: DraftResponse;
     });
     get channel(): Channel;
     get hasStaleState(): boolean;
@@ -77,14 +77,16 @@ export declare class Thread extends WithSubscriptions {
     private subscribeMarkThreadStale;
     private subscribeRepliesUnread;
     private subscribeNewReplies;
+    private incrementReplyCountLocally;
     private subscribeRepliesRead;
     private subscribeMessageDeleted;
     private subscribeMessageUpdated;
+    private subscribeUserMessagesDeleted;
     unregisterSubscriptions: () => symbol;
     deleteReplyLocally: ({ message }: {
         message: MessageResponse;
     }) => void;
-    upsertReplyLocally: ({ message, timestampChanged, }: {
+    upsertReplyLocally: ({ message, }: {
         message: MessageResponse | LocalMessage;
         timestampChanged?: boolean;
     }) => void;
@@ -92,17 +94,32 @@ export declare class Thread extends WithSubscriptions {
         message: MessageResponse;
     }) => void;
     updateParentMessageOrReplyLocally: (message: MessageResponse) => void;
+    /**
+     * Sends a message with optimistic local state update.
+     */
+    sendMessageWithLocalUpdate({ localMessage, message, options, sendMessageRequestFn, }: SendMessageWithStateUpdateParams): Promise<void>;
+    /**
+     * Retry sending a failed message.
+     */
+    retrySendMessageWithLocalUpdate(params: Omit<SendMessageWithStateUpdateParams, 'message'>): Promise<void>;
+    /**
+     * Updates a message with optimistic local state update.
+     *
+     * The update flows through `messagePaginator`, which is the sole reply source.
+     */
+    updateMessageWithLocalUpdate(params: UpdateMessageWithStateUpdateParams): Promise<void>;
+    /**
+     * Deletes a message with local state update.
+     */
+    deleteMessageWithLocalUpdate(params: DeleteMessageWithStateUpdateParams): Promise<void>;
+    markRead: ({ force }?: {
+        force?: boolean;
+    }) => Promise<EventAPIResponse | import("./types").StreamResponse<import(".").MarkReadResponse> | null>;
+    private throttledMarkRead;
+    /**
+     * @deprecated Use `thread.markRead` instead.
+     */
     markAsRead: ({ force }?: {
         force?: boolean;
-    }) => Promise<import("./types").EventAPIResponse | null>;
-    private throttledMarkAsRead;
-    queryReplies: ({ limit, sort, ...otherOptions }?: QueryRepliesOptions) => Promise<import("./types").GetRepliesAPIResponse>;
-    loadNextPage: ({ limit }?: {
-        limit?: number;
-    }) => Promise<void>;
-    loadPrevPage: ({ limit }?: {
-        limit?: number;
-    }) => Promise<void>;
-    private loadPage;
+    }) => Promise<EventAPIResponse | import("./types").StreamResponse<import(".").MarkReadResponse> | null>;
 }
-export {};

package/dist/types/thread_manager.d.ts

@@ -1,7 +1,7 @@
 import { StateStore } from './store';
 import type { StreamChat } from './client';
 import type { Thread } from './thread';
-import type { QueryThreadsOptions } from './types';
+import type { QueryThreadsRequest } from './types';
 import { WithSubscriptions } from './utils/WithSubscriptions';
 export declare const THREAD_MANAGER_INITIAL_STATE: {
     active: boolean;
@@ -65,9 +65,9 @@ export declare class ThreadManager extends WithSubscriptions {
     reload: ({ force }?: {
         force?: boolean | undefined;
     }) => Promise<void>;
-    queryThreads: (options?: QueryThreadsOptions) => Promise<{
+    queryThreads: (options?: QueryThreadsRequest) => Promise<{
         threads: Thread[];
         next: string | undefined;
     }>;
-    loadNextPage: (options?: Omit<QueryThreadsOptions, "next">) => Promise<void>;
+    loadNextPage: (options?: Omit<QueryThreadsRequest, "next">) => Promise<void>;
 }

package/dist/types/token_manager.d.ts

@@ -1,5 +1,9 @@
 import type jwt from 'jsonwebtoken';
-import type { TokenOrProvider, UserResponse } from './types';
+import type { TokenOrProvider } from './types';
+export type TokenManagerMinimalUser = {
+    id: string;
+    anon?: boolean;
+};
 /**
  * TokenManager
  *
@@ -11,27 +15,28 @@ export declare class TokenManager {
     secret?: jwt.Secret;
     token?: string;
     tokenProvider?: TokenOrProvider;
-    user?: UserResponse;
+    user?: TokenManagerMinimalUser;
     /**
-     * Constructor
+     * Initializes the token manager, optionally with a server-side API secret used to mint tokens
+     * locally.
      *
-     * @param {Secret} secret
+     * @param secret - Optional API secret. When provided, the manager will sign server tokens locally.
      */
     constructor(secret?: jwt.Secret);
     /**
-     * Set the static string token or token provider.
-     * Token provider should return a token string or a promise which resolves to string token.
+     * Sets the static string token or token provider. A token provider should return a token string
+     * or a promise that resolves to a token string.
      *
-     * @param {TokenOrProvider} tokenOrProvider
-     * @param {UserResponse} user
+     * @param tokenOrProvider - A token string or an async provider that returns one.
+     * @param user - The user the token belongs to.
      */
-    setTokenOrProvider: (tokenOrProvider: TokenOrProvider, user: UserResponse) => Promise<void>;
+    setTokenOrProvider: (tokenOrProvider: TokenOrProvider, user: TokenManagerMinimalUser) => Promise<void>;
     /**
      * Resets the token manager.
      * Useful for client disconnection or switching user.
      */
     reset: () => void;
-    validateToken: (tokenOrProvider: TokenOrProvider, user: UserResponse) => void;
+    validateToken: (tokenOrProvider: TokenOrProvider, user: TokenManagerMinimalUser) => void;
     tokenReady: () => Promise<string> | null;
     loadToken: () => Promise<string>;
     getToken: () => string | undefined;