@bcc-code/vue-bcc-chat-ui 7.3.3 → 7.4.1

package/dist/index.d.ts

@@ -15,11 +15,6 @@ import { User } from '@cometchat/chat-sdk-javascript';
 import { WritableComputedRef } from 'vue';
 
 declare const __VLS_base: DefineComponent<__VLS_Props, {
-    applyComposerFormat: typeof applyComposerFormat;
-    applyComposerLink: typeof applyComposerLink;
-    cancelComposerLink: typeof cancelComposerLink;
-    getComposerSelection: typeof getComposerSelection;
-    requestComposerLink: typeof requestComposerLink;
     initiateDirectMessage: typeof initiateDirectMessage_2;
     scrollToMessage: typeof scrollToMessage_2;
     groupMembers: ComputedRef<{
@@ -32,56 +27,37 @@ declare const __VLS_base: DefineComponent<__VLS_Props, {
     }[]>;
 }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
     chatNotAMember: (chatUid: string) => any;
-    composerSelectionChange: (selection: ChatComposerSelectionState | null) => any;
-    composerLinkRequest: (selection: ChatComposerSelectionState) => any;
     chatMembersFetched: (members: ParticipantInfo[]) => any;
     chatEmpty: () => any;
     linkClicked: (event: MouseEvent, url: string) => any;
 }, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
     onChatNotAMember?: ((chatUid: string) => any) | undefined;
-    onComposerSelectionChange?: ((selection: ChatComposerSelectionState | null) => any) | undefined;
-    onComposerLinkRequest?: ((selection: ChatComposerSelectionState) => any) | undefined;
     onChatMembersFetched?: ((members: ParticipantInfo[]) => any) | undefined;
     onChatEmpty?: (() => any) | undefined;
     onLinkClicked?: ((event: MouseEvent, url: string) => any) | undefined;
 }>, {
     chatUid: string;
+    showHeader: boolean;
     hideGroupActions: boolean;
     client: ChatClient | null;
     isReadOnly: boolean;
     initialScheduledMessagesOpen: boolean;
     hideDeletedMessages: boolean;
-    displayNoMessagesText: boolean;
-    showMessageHeader: boolean;
-    composerFormattingMode: ComposerFormattingMode;
 }, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
 
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 
 declare type __VLS_Props = {
     client?: ChatClient | null;
-    conversation?: ChatConversationItem | null;
-    messages?: ChatMessageItem[];
-    threadMessages?: ChatMessageItem[];
-    loadingMessages?: boolean;
-    loadingThreadMessages?: boolean;
     isReadOnly?: boolean;
-    sendOptions?: MessageSendOptions;
-    showDefaultEmptyState?: boolean;
     initialScheduledMessagesOpen?: boolean;
     chatUid?: string;
-    senderDisplayName?: string;
     hideDeletedMessages?: boolean;
     hideGroupActions?: boolean;
-    chatMessageGetter?: ChatMessagesGetter;
-    displayNoMessagesText?: boolean;
-    language?: Language;
     showHeader?: boolean;
-    showMessageHeader?: boolean;
     containerClass?: string;
     actionMessageClass?: string;
     actionMessageRowClass?: string;
-    composerFormattingMode?: ComposerFormattingMode;
 };
 
 declare type __VLS_Slots = {} & {
@@ -89,9 +65,9 @@ declare type __VLS_Slots = {} & {
 } & {
     'message-header'?: (props: typeof __VLS_23) => any;
 } & {
-    'no-messages'?: (props: typeof __VLS_102) => any;
+    'no-messages'?: (props: typeof __VLS_96) => any;
 } & {
-    'not-a-member'?: (props: typeof __VLS_105) => any;
+    'not-a-member'?: (props: typeof __VLS_99) => any;
 };
 
 declare type __VLS_WithSlots<T, S> = T & {
@@ -100,24 +76,12 @@ declare type __VLS_WithSlots<T, S> = T & {
     };
 };
 
-declare function applyComposerFormat(command: ComposerFormatCommand, target?: ChatComposerTarget): boolean;
-
-declare function applyComposerLink(url: string, target?: ChatComposerTarget): boolean;
-
 export declare interface AttachmentUploadInput {
     file: File;
     caption?: string;
 }
 
-export declare interface BccChatComposerFormattingHandle {
-    applyComposerFormat(command: ComposerFormatCommand, target?: ChatComposerTarget): boolean;
-    requestComposerLink(target?: ChatComposerTarget): boolean;
-    applyComposerLink(url: string, target?: ChatComposerTarget): boolean;
-    cancelComposerLink(target?: ChatComposerTarget): void;
-    getComposerSelection(target?: ChatComposerTarget): ChatComposerSelectionState | null;
-}
-
-export declare interface BccChatExpose extends BccChatComposerFormattingHandle {
+export declare interface BccChatExpose {
     scrollToMessage(messageId: string): Promise<void>;
     initiateDirectMessage(userUid: string): Promise<ChatConversationItem>;
     readonly groupMembers: ParticipantInfo[];
@@ -135,11 +99,23 @@ export declare interface CachedParticipantSettings {
     lastUpdated: number;
 }
 
-declare function cancelComposerLink(target?: ChatComposerTarget): void;
+/** Why the last call session ended for the current user. */
+export declare type CallEndReason = "ended" | "left" | "timed-out" | "failed";
+
+/** Settings for the call UI rendered into the container passed to `chat.calls`. */
+export declare interface CallSessionOptions {
+    /** Hide the recording control. Defaults to `false`. */
+    hideRecordingButton?: boolean;
+    /** Hide the in-call chat panel toggle. Defaults to `false`. */
+    hideChatButton?: boolean;
+    /** How long a participant can be alone in the call before being asked whether to stay, in milliseconds. */
+    idleTimeoutBeforePromptMs?: number;
+    /** How long the stay prompt waits for an answer before the participant is removed, in milliseconds. */
+    idleTimeoutAfterPromptMs?: number;
+}
 
 declare const chat: {
     install: typeof install;
-    setGetChatMessagesCallback: typeof setGetChatMessagesCallback;
     initialized: Ref<boolean, boolean>;
     connected: ComputedRef<boolean>;
     connecting: ComputedRef<boolean>;
@@ -259,7 +235,6 @@ declare const chat: {
     toggleMuteAll: typeof toggleMuteAll;
     toMarkdownHtml: typeof toMarkdownHtml;
     retrieveCcToken: typeof retrieveCcToken;
-    getChatMessages: Ref<ChatMessagesGetter | undefined, ChatMessagesGetter | undefined>;
     scrollToMessageId: Ref<string | undefined, string | undefined>;
     scrollToMessage: typeof scrollToMessage;
     pinnedMessages: ComputedRef<ChatMessageItem[]>;
@@ -298,11 +273,15 @@ declare const chat: {
         incomingCall: ComputedRef< Call | null>;
         incomingCalls: ComputedRef<Map<string, Call>>;
         outgoingCall: ComputedRef< Call | null>;
-        start: (receiverId: string, container: HTMLElement, callType?: "audio" | "video", receiverType?: "user" | "group") => Promise< Call>;
-        accept: (container: HTMLElement, sessionId?: string) => Promise<void>;
+        lastEndReason: ComputedRef<CallEndReason | null>;
+        start: (receiverId: string, container: HTMLElement, callType?: "audio" | "video", receiverType?: "user" | "group", options?: CallSessionOptions) => Promise< Call>;
+        /** Joins the chat's ongoing call, starting one if there is none. Leaving does not end it for the others. */
+        join: (chatUid: string, container: HTMLElement, callType?: "audio" | "video", options?: CallSessionOptions) => Promise<void>;
+        accept: (container: HTMLElement, sessionId?: string, options?: CallSessionOptions) => Promise<void>;
         reject: (sessionId?: string) => Promise<void>;
         end: () => Promise<void>;
-        joinActive: (container: HTMLElement) => Promise<void>;
+        leave: () => void | undefined;
+        joinActive: (container: HTMLElement, options?: CallSessionOptions) => Promise<void>;
     };
 };
 export { chat }
@@ -370,9 +349,11 @@ export declare interface ChatClient {
     forwardMessage: (message: ChatMessageItem, target: ForwardMessageTarget) => Promise<void>;
     fetchScheduledMessages: (originalChatUid?: string) => Promise<void>;
     loadOlderMessages: () => Promise<boolean>;
+    /** Drops older loaded messages once the user is back at the newest ones. */
+    trimOlderMessages?: () => void;
     loadOlderThreadMessages: () => Promise<boolean>;
     ensureMessageLoaded: (messageId: string) => Promise<boolean>;
-    scheduleMessage: (input: ScheduleMessageInput, options?: MessageSendOptions) => Promise<void>;
+    scheduleMessage: (input: ScheduleMessageInput, options?: MessageSendOptions) => Promise<ScheduleMessageResult>;
     rescheduleMessage: (input: RescheduleMessageInput) => Promise<void>;
     removeScheduledMessage: (message: ChatMessageItem) => Promise<void>;
     editScheduledMessage: (message: ChatMessageItem, nextText: string) => Promise<void>;
@@ -399,25 +380,22 @@ export declare interface ChatClient {
         uid: string;
         displayName: string;
     }>) => void;
-    initiateCall: (receiverId: string, container: HTMLElement, callType?: "video" | "audio", receiverType?: "user" | "group") => Promise<InstanceType<typeof CometChat_2.Call>>;
-    acceptIncomingCall: (container: HTMLElement, sessionId?: string) => Promise<void>;
+    initiateCall: (receiverId: string, container: HTMLElement, callType?: "video" | "audio", receiverType?: "user" | "group", options?: CallSessionOptions) => Promise<InstanceType<typeof CometChat_2.Call>>;
+    joinChatCall: (chatUid: string, container: HTMLElement, callType?: "video" | "audio", options?: CallSessionOptions) => Promise<void>;
+    acceptIncomingCall: (container: HTMLElement, sessionId?: string, options?: CallSessionOptions) => Promise<void>;
     rejectIncomingCall: (sessionId?: string) => Promise<void>;
     endActiveCall: () => Promise<void>;
-    joinOutgoingCallSession: (container: HTMLElement) => Promise<void>;
+    leaveActiveCall: () => void;
+    joinOutgoingCallSession: (container: HTMLElement, options?: CallSessionOptions) => Promise<void>;
     incomingCall: Ref<InstanceType<typeof CometChat_2.Call> | null>;
     incomingCalls: Ref<Map<string, InstanceType<typeof CometChat_2.Call>>>;
     outgoingCall: Ref<InstanceType<typeof CometChat_2.Call> | null>;
     activeCallSessionId: Ref<string | null>;
     activeCallType: Ref<"audio" | "video">;
     callState: Ref<"idle" | "outgoing" | "incoming" | "connecting" | "in-call">;
+    lastCallEndReason: Ref<CallEndReason | null>;
 }
 
-export declare interface ChatComposerSelectionState extends ComposerSelectionState {
-    target: ChatComposerTarget;
-}
-
-export declare type ChatComposerTarget = "main" | "thread";
-
 export declare interface ChatConversationItem {
     id: string;
     targetId: string;
@@ -534,23 +512,6 @@ export declare interface ChatMessageReceiptSummary {
     readByMeAt?: Date;
 }
 
-export declare type ChatMessagesGetter = (guid: string, query: string) => Promise<ChatMessagesGetterResult>;
-
-export declare interface ChatMessagesGetterPagination {
-    total_pages?: number;
-    current_page?: number;
-    [key: string]: unknown;
-}
-
-export declare interface ChatMessagesGetterResult<TMessage = Record<string, unknown>> {
-    data: TMessage[];
-    meta?: {
-        pagination?: ChatMessagesGetterPagination;
-        [key: string]: unknown;
-    };
-    [key: string]: unknown;
-}
-
 export declare interface ChatPollData {
     id?: string;
     question: string;
@@ -604,23 +565,9 @@ declare function clearChatCount(chatUid: string): Promise<void>;
 
 export declare type ComposerFormatCommand = "bold" | "italic" | "underline";
 
-export declare type ComposerFormattingMode = "default" | "external";
-
-export declare interface ComposerSelectionRect {
-    x: number;
-    y: number;
-    top: number;
-    right: number;
-    bottom: number;
-    left: number;
-    width: number;
-    height: number;
-}
-
 export declare interface ComposerSelectionState {
     text: string;
     href?: string;
-    rect: ComposerSelectionRect;
 }
 
 declare function connect(connectionName?: string): Promise<void>;
@@ -665,8 +612,6 @@ declare function getChatMembersInfo(chatUid: string): Promise<ParticipantInfo[]>
 
 declare function getChatOnlineCount(chatUid: string): Promise<number>;
 
-declare function getComposerSelection(target?: ChatComposerTarget): ChatComposerSelectionState | null;
-
 declare function getCurrentEnvironment(): ChatEnvironmentConfig;
 
 declare function getGroup(groupUid: string, throwErrors?: boolean): Promise<Group | null | undefined>;
@@ -804,8 +749,6 @@ export declare type PresenceStatus = "online" | "offline";
 
 declare function proxyImage(imageUrl: string): string;
 
-declare function requestComposerLink(target?: ChatComposerTarget): boolean;
-
 export declare interface RescheduleMessageInput {
     messageId: number;
     muid: string;
@@ -816,12 +759,32 @@ export declare interface RescheduleMessageInput {
 declare function retrieveCcToken(): StoredCometChatToken | null;
 
 export declare interface ScheduleMessageInput {
+    /** Primary (earliest) send time, kept for single-time callers. */
     scheduleDate: string;
+    /**
+     * Every send time the message should be delivered at, including `scheduleDate`.
+     * When set, one scheduled message is created per time so the same draft is sent repeatedly.
+     */
+    scheduleDates?: string[];
     text?: string;
     file?: File;
     caption?: string;
 }
 
+/** Per-occurrence outcome of a `scheduleMessage` call, so callers can tell exactly which send times landed. */
+export declare interface ScheduleMessageResult {
+    occurrences: ScheduleOccurrenceResult[];
+}
+
+/** Outcome of scheduling a single occurrence within a (possibly multi-time) schedule request. */
+export declare interface ScheduleOccurrenceResult {
+    /** The ISO send time this occurrence was scheduled for. */
+    scheduleDate: string;
+    success: boolean;
+    /** Present when `success` is false. */
+    error?: string;
+}
+
 declare function scrollToMessage(messageId: string): void;
 
 declare function scrollToMessage_2(messageId: string): Promise<void>;
@@ -841,8 +804,6 @@ declare function setAccessToken(token: string): Promise<void>;
 
 declare function setEnvironment(environment: Environment): void;
 
-declare function setGetChatMessagesCallback(chatMessageGetter: ChatMessagesGetter | undefined): void;
-
 declare function setLanguage(language: Language): void;
 
 declare function setMuteAll(mute: boolean): Promise<boolean>;