@bcc-code/vue-bcc-chat-ui 7.2.3 → 7.2.7

package/dist/composables/useComposerDrafts.d.ts

@@ -0,0 +1,47 @@
+import { TemplateRef, Ref } from 'vue';
+import { AttachmentUploadInput, ChatClient, ChatMessageItem, MessageSendOptions, PollComposerInput, ScheduleMessageInput } from '../chat/types';
+/** Minimal public interface exposed by MessageComposer via `defineExpose`. */
+interface ComposerHandle {
+    focusEditor: () => Promise<void>;
+}
+export interface UseComposerDraftsOptions {
+    /** Returns the active chat client, or null when unavailable. */
+    getClient: () => ChatClient | null;
+    /** Returns the resolved send options for the current conversation. */
+    getSendOptions: () => MessageSendOptions | undefined;
+    /** Maps mention uids to display names for editable drafts. */
+    getMentionNameByUid: () => Record<string, string>;
+    /**
+     * Called after a message has been scheduled so the parent can refresh the
+     * scheduled-messages overlay.
+     */
+    afterSchedule: () => Promise<void>;
+    mainComposerRef?: TemplateRef<ComposerHandle | null>;
+    threadComposerRef?: TemplateRef<ComposerHandle | null>;
+}
+/**
+ * Composable that owns all state for the main + thread dual-composer drafts, including
+ * draft text, reset signals, focus helpers, and delegated send actions.
+ */
+export declare function useComposerDrafts(options: UseComposerDraftsOptions): {
+    draft: Ref<string, string>;
+    threadDraft: Ref<string, string>;
+    composerResetSignal: Ref<number, number>;
+    threadComposerResetSignal: Ref<number, number>;
+    resetMainComposer: () => void;
+    resetThreadComposer: () => void;
+    focusMainComposer: () => void;
+    focusThreadComposer: () => void;
+    shouldFocusThreadComposer: (message: ChatMessageItem) => boolean;
+    getEditableMessageText: (message: ChatMessageItem) => string;
+    loadMainDraft: (message: ChatMessageItem) => void;
+    loadThreadDraft: (message: ChatMessageItem) => void;
+    sendMessage: () => Promise<void>;
+    sendAttachment: (input: AttachmentUploadInput) => Promise<void>;
+    sendPoll: (input: PollComposerInput) => Promise<void>;
+    scheduleMessage: (input: ScheduleMessageInput) => Promise<void>;
+    sendThreadMessage: () => Promise<void>;
+    sendThreadAttachment: (input: AttachmentUploadInput) => Promise<void>;
+    sendThreadPoll: (input: PollComposerInput) => Promise<void>;
+};
+export {};

package/dist/composables/useComposerTriggers.d.ts

@@ -0,0 +1,63 @@
+import { Ref, ComputedRef } from 'vue';
+import { MentionCandidate } from '../chat/mentions';
+export interface ComposerTriggerCandidate {
+    id: string;
+    label: string;
+    subtitle?: string;
+    avatar?: string;
+}
+export interface ComposerTriggerDefinition {
+    id: string;
+    triggerChar: string;
+    enabled: () => boolean;
+    getCandidates: (query: string) => ComposerTriggerCandidate[];
+    apply: (candidate: ComposerTriggerCandidate, triggerRange: Range) => void;
+    maxSuggestions?: number;
+}
+interface UseComposerTriggersOptions {
+    editorRef: Ref<HTMLDivElement | null>;
+    getTriggers: () => ComposerTriggerDefinition[];
+    onChange?: () => void;
+}
+export declare function createMentionTriggerDefinition(options: {
+    enabled: () => boolean;
+    getMentionCandidates: () => ReadonlyArray<MentionCandidate>;
+    insertMention: (candidate: MentionCandidate, triggerRange: Range) => void;
+    maxSuggestions?: number;
+}): ComposerTriggerDefinition;
+export declare function useComposerTriggers(options: UseComposerTriggersOptions): {
+    activeTriggerId: () => string | null;
+    triggerCandidates: Ref<{
+        id: string;
+        label: string;
+        subtitle?: string | undefined;
+        avatar?: string | undefined;
+    }[], ComposerTriggerCandidate[] | {
+        id: string;
+        label: string;
+        subtitle?: string | undefined;
+        avatar?: string | undefined;
+    }[]>;
+    triggerMenuPosition: Ref<{
+        x: number;
+        y: number;
+        placement: "above" | "below";
+    }, {
+        x: number;
+        y: number;
+        placement: "above" | "below";
+    } | {
+        x: number;
+        y: number;
+        placement: "above" | "below";
+    }>;
+    highlightedTriggerIndex: Ref<number, number>;
+    showTriggerMenu: ComputedRef<boolean>;
+    hideTriggerMenu: () => void;
+    handleInput: () => void;
+    handleKeydown: (event: KeyboardEvent) => boolean;
+    selectTriggerCandidate: (candidate: ComposerTriggerCandidate) => void;
+    refreshActiveTrigger: () => void;
+};
+export declare function insertMentionAtRange(range: Range, candidate: MentionCandidate): void;
+export {};

package/dist/composables/useConversationComposer.d.ts

@@ -0,0 +1,16 @@
+import { AttachmentUploadInput, ChatClient, ChatMessageItem, MessageSendOptions, PollComposerInput, ScheduleMessageInput } from '../chat/types';
+import { Ref } from 'vue';
+export declare function useConversationComposer(options: {
+    client: ChatClient;
+    getSendOptions: () => MessageSendOptions | undefined;
+    afterSchedule?: () => Promise<void> | void;
+}): {
+    draft: Ref<string, string>;
+    loadMessageDraft: (message: ChatMessageItem) => void;
+    reset: () => void;
+    resetSignal: Ref<number, number>;
+    scheduleMessage: (input: ScheduleMessageInput) => Promise<void>;
+    sendAttachment: (input: AttachmentUploadInput) => Promise<void>;
+    sendPoll: (input: PollComposerInput) => Promise<void>;
+    sendText: () => Promise<void>;
+};

package/dist/composables/useGroupMemberTracking.d.ts

@@ -0,0 +1,33 @@
+import { ParticipantInfo } from '../chat/types';
+import { Ref } from 'vue';
+export interface UseGroupMemberTrackingOptions {
+    /** Returns the CometChat GUID of the currently active conversation, or undefined when none is selected. */
+    getConversationTargetId: () => string | undefined;
+    /** Returns true when the active conversation is a broadcast channel (members are not tracked). */
+    isChannel: () => boolean;
+    /** Returns true when the current user has joined the active group. */
+    hasJoined: () => boolean;
+    /** Called whenever the member list changes with the new complete list. */
+    onMembersChanged: (members: ParticipantInfo[]) => void;
+}
+/**
+ * Composable that keeps a live `groupMembers` ref in sync with CometChat
+ * membership events and exposes a manual `fetchGroupMembers` loader for the
+ * initial page-load.
+ */
+export declare function useGroupMemberTracking(options: UseGroupMemberTrackingOptions): {
+    groupMembers: Ref<{
+        uid: string;
+        displayName: string;
+        avatar: string;
+        role: string;
+        lastSeen?: Date | undefined;
+    }[], ParticipantInfo[] | {
+        uid: string;
+        displayName: string;
+        avatar: string;
+        role: string;
+        lastSeen?: Date | undefined;
+    }[]>;
+    fetchGroupMembers: (groupUid: string) => Promise<void>;
+};

package/dist/composables/useImageZoom.d.ts

@@ -0,0 +1,26 @@
+import { Ref } from 'vue';
+export interface UseImageZoomOptions {
+    /** Ref to the scrollable viewport wrapper element. */
+    viewportRef: Ref<HTMLElement | null>;
+    /** Ref to the `<img>` element whose natural dimensions guide clamping. */
+    imageRef: Ref<HTMLImageElement | null>;
+    /** Returns true when the current attachment is an image (non-image = zoom disabled). */
+    isImage: () => boolean;
+}
+/**
+ * Composable that owns scale, translateX, and translateY state and exposes
+ * all pointer event handlers required by the media-viewer image stage.
+ */
+export declare function useImageZoom(options: UseImageZoomOptions): {
+    scale: Ref<number, number>;
+    translateX: Ref<number, number>;
+    translateY: Ref<number, number>;
+    isDragging: Ref<boolean, boolean>;
+    resetTransform: () => void;
+    handlePointerDown: (event: PointerEvent) => void;
+    handlePointerMove: (event: PointerEvent) => void;
+    handlePointerUp: (event: PointerEvent) => void;
+    handlePointerCancel: (event: PointerEvent) => void;
+    handleWheel: (event: WheelEvent) => void;
+    handleDoubleClick: () => void;
+};

package/dist/composables/useIsTouchUi.d.ts

@@ -0,0 +1,4 @@
+import { ComputedRef } from 'vue';
+export declare function useIsTouchUi(): {
+    isTouchUI: ComputedRef<boolean>;
+};

package/dist/composables/useMessageActionMenu.d.ts

@@ -0,0 +1,257 @@
+import { Component, TemplateRef, ShallowRef, Ref, ComputedRef } from 'vue';
+import { TranslationParams } from '../chat/i18n/types';
+import { TranslationKey } from '../chat/localization';
+import { ChatMessageItem, ChatMessageReceiptItem, ChatPollData, ChatReactionDetailItem } from '../chat/types';
+import { ChatMessageKind, ChatDeliveryState } from '..';
+/** Minimal public interface of the custom MessageItemMenu component. */
+interface ActionMenuHandle {
+    show: (event: Event, fallbackPosition?: {
+        x: number;
+        y: number;
+    }, element?: HTMLElement) => void;
+    hide: () => void;
+}
+export interface UseMessageActionMenuOptions {
+    /** Returns true when message actions are enabled for this view. */
+    canUseMessageActions: () => boolean;
+    /** Returns true when reactions are allowed. */
+    canReact: () => boolean;
+    /** Returns true when replying is allowed. */
+    canReply: () => boolean;
+    /** Returns true when opening a thread is allowed. */
+    canOpenThread: () => boolean;
+    /** Returns true when pinning messages is allowed for this view. */
+    canPin: () => boolean;
+    /** Returns true when the supplied message is currently pinned. */
+    isPinned: (message: ChatMessageItem) => boolean;
+    /** Returns true when the conversation is at its server-owned pin cap. Absent means no cap is known. */
+    pinLimitReached?: () => boolean;
+    /** Returns true when the list is rendering a thread view (disables thread action). */
+    isInThread: () => boolean;
+    /** Translation helper forwarded from the parent component. */
+    t: (key: TranslationKey, params?: TranslationParams) => string;
+    emit: {
+        reply: (message: ChatMessageItem) => void;
+        edit: (message: ChatMessageItem) => void;
+        openThread: (message: ChatMessageItem) => void;
+        delete: (message: ChatMessageItem) => void;
+        translate: (message: ChatMessageItem) => void;
+        toggleReaction: (message: ChatMessageItem, emoji: string) => void;
+        forward: (message: ChatMessageItem) => void;
+        togglePin: (message: ChatMessageItem) => void;
+    };
+    /** Optional callback fired right before opening the message actions menu. */
+    onMenuOpen?: () => void;
+    /** Returns cached message receipts for the context-menu receipt summary. */
+    getCachedMessageReceipts?: (message: ChatMessageItem) => ChatMessageReceiptItem[] | undefined;
+    /** Loads message receipts for the context-menu receipt summary. */
+    loadMessageReceipts?: (message: ChatMessageItem) => Promise<ChatMessageReceiptItem[]>;
+    /** Returns true while receipts are being loaded for the supplied message. */
+    isLoadingMessageReceipts?: (message: ChatMessageItem) => boolean;
+    /** Returns cached reaction detail (who reacted with which emoji) for the supplied message. */
+    getCachedMessageReactions?: (message: ChatMessageItem) => ChatReactionDetailItem[] | undefined;
+    /** Loads reaction detail for the supplied message. Only called when the user opens the reactions view. */
+    loadMessageReactions?: (message: ChatMessageItem) => Promise<ChatReactionDetailItem[]>;
+    /** Returns true while reaction detail is being loaded for the supplied message. */
+    isLoadingMessageReactions?: (message: ChatMessageItem) => boolean;
+    actionMenuRef: TemplateRef<ActionMenuHandle>;
+}
+export interface MessageReceiptSummaryAction {
+    label: string;
+    receipts: ChatMessageReceiptItem[];
+    loading: boolean;
+}
+export interface MessagePollVotersSummaryAction {
+    label: string;
+    poll: ChatPollData;
+}
+export interface MessageReactionsSummaryAction {
+    label: string;
+    /** Reaction detail once loaded; null while not yet requested or still loading. */
+    details: ChatReactionDetailItem[] | null;
+    loading: boolean;
+}
+/**
+ * Composable that owns all state for the per-message action popover, reaction
+ * expansion, inline reaction toggles, and message copying.
+ */
+export declare function useMessageActionMenu(options: UseMessageActionMenuOptions): {
+    actionMenuRef: Readonly< ShallowRef<ActionMenuHandle | null>>;
+    activeActionMessage: Ref<{
+        id: string;
+        muid?: string | undefined;
+        conversationId: string;
+        senderId: string;
+        senderName: string;
+        text: string;
+        kind: ChatMessageKind;
+        sentAt: Date;
+        category: string;
+        type: string;
+        senderAvatar?: string | undefined;
+        isOwn: boolean;
+        isDeleted: boolean;
+        isEdited: boolean;
+        attachments: {
+            kind: Extract< ChatMessageKind, "image" | "video" | "audio" | "file">;
+            name: string;
+            url?: string | undefined;
+            mimeType?: string | undefined;
+            extension?: string | undefined;
+            size?: number | undefined;
+            width?: number | undefined;
+            height?: number | undefined;
+        }[];
+        poll?: {
+            id?: string | undefined;
+            question: string;
+            options: {
+                id: string;
+                text: string;
+                voteCount: number;
+                voters: {
+                    uid: string;
+                    name: string;
+                    avatar?: string | undefined;
+                    status?: string | undefined;
+                    lastSeen?: Date | undefined;
+                }[];
+            }[];
+            totalVotes: number;
+            allowsMultipleAnswers: boolean;
+        } | undefined;
+        scheduled?: {
+            scheduleDate?: Date | undefined;
+            originalChatUid?: string | undefined;
+            muid?: string | undefined;
+            messageId?: number | undefined;
+        } | undefined;
+        translatedText?: string | undefined;
+        replyTo?: {
+            messageId: string;
+            senderName: string;
+            text: string;
+            kind: ChatMessageKind;
+        } | undefined;
+        forwardedFrom?: {
+            senderName: string;
+        } | undefined;
+        parentMessageId?: string | undefined;
+        replyCount: number;
+        reactions: {
+            emoji: string;
+            count: number;
+            reactedByMe: boolean;
+        }[];
+        receipts: {
+            deliveredAt?: Date | undefined;
+            deliveredToMeAt?: Date | undefined;
+            readAt?: Date | undefined;
+            readByMeAt?: Date | undefined;
+        };
+        pinnedAt?: Date | undefined;
+        pinnedBy?: string | undefined;
+        deliveryState: ChatDeliveryState;
+        metadata?: Record<string, unknown> | undefined;
+        source: any;
+    } | null, ChatMessageItem | {
+        id: string;
+        muid?: string | undefined;
+        conversationId: string;
+        senderId: string;
+        senderName: string;
+        text: string;
+        kind: ChatMessageKind;
+        sentAt: Date;
+        category: string;
+        type: string;
+        senderAvatar?: string | undefined;
+        isOwn: boolean;
+        isDeleted: boolean;
+        isEdited: boolean;
+        attachments: {
+            kind: Extract< ChatMessageKind, "image" | "video" | "audio" | "file">;
+            name: string;
+            url?: string | undefined;
+            mimeType?: string | undefined;
+            extension?: string | undefined;
+            size?: number | undefined;
+            width?: number | undefined;
+            height?: number | undefined;
+        }[];
+        poll?: {
+            id?: string | undefined;
+            question: string;
+            options: {
+                id: string;
+                text: string;
+                voteCount: number;
+                voters: {
+                    uid: string;
+                    name: string;
+                    avatar?: string | undefined;
+                    status?: string | undefined;
+                    lastSeen?: Date | undefined;
+                }[];
+            }[];
+            totalVotes: number;
+            allowsMultipleAnswers: boolean;
+        } | undefined;
+        scheduled?: {
+            scheduleDate?: Date | undefined;
+            originalChatUid?: string | undefined;
+            muid?: string | undefined;
+            messageId?: number | undefined;
+        } | undefined;
+        translatedText?: string | undefined;
+        replyTo?: {
+            messageId: string;
+            senderName: string;
+            text: string;
+            kind: ChatMessageKind;
+        } | undefined;
+        forwardedFrom?: {
+            senderName: string;
+        } | undefined;
+        parentMessageId?: string | undefined;
+        replyCount: number;
+        reactions: {
+            emoji: string;
+            count: number;
+            reactedByMe: boolean;
+        }[];
+        receipts: {
+            deliveredAt?: Date | undefined;
+            deliveredToMeAt?: Date | undefined;
+            readAt?: Date | undefined;
+            readByMeAt?: Date | undefined;
+        };
+        pinnedAt?: Date | undefined;
+        pinnedBy?: string | undefined;
+        deliveryState: ChatDeliveryState;
+        metadata?: Record<string, unknown> | undefined;
+        source: any;
+    } | null>;
+    copiedMessageId: Ref<string | null, string | null>;
+    isTouchUI: ComputedRef<boolean>;
+    handleMessageContextMenu: (message: ChatMessageItem, event: MouseEvent) => void;
+    handleMessageTap: (message: ChatMessageItem, event: MouseEvent) => void;
+    closeActionMenu: () => void;
+    resetActionMenuState: () => void;
+    reactToMessage: (message: ChatMessageItem, emoji: string) => void;
+    toggleInlineReaction: (message: ChatMessageItem, emoji: string) => void;
+    loadReceiptPreview: (message: ChatMessageItem) => Promise<void>;
+    getReceiptSummaryAction: (message: ChatMessageItem) => MessageReceiptSummaryAction | null;
+    getPollVotersSummaryAction: (message: ChatMessageItem) => MessagePollVotersSummaryAction | null;
+    loadReactionDetails: (message: ChatMessageItem) => Promise<void>;
+    getReactionsSummaryAction: (message: ChatMessageItem) => MessageReactionsSummaryAction | null;
+    getActionItems: (message: ChatMessageItem) => {
+        key: string;
+        label: string;
+        icon: Component;
+        visible: boolean;
+        command: () => void;
+    }[];
+    togglePinnedMessage: (message: ChatMessageItem) => void;
+};
+export {};

package/dist/composables/useMessageInfoDialog.d.ts

@@ -0,0 +1,201 @@
+import { ChatClient, ChatMessageItem, ChatMessageReceiptItem, ChatReactionDetailItem } from '../chat/types';
+import { Ref } from 'vue';
+import { ChatMessageKind, ChatDeliveryState, ChatMessageReceiptKind } from '..';
+export interface UseMessageInfoDialogOptions {
+    /** Returns the active chat client, or null when none is available. */
+    getClient: () => ChatClient | null;
+    /** Fallback error string shown when the receipt fetch fails without a message. */
+    fetchErrorFallback: string;
+}
+/**
+ * Composable that owns the reactive state required to display the per-message
+ * info overlay and handles the asynchronous receipt-loading lifecycle.
+ */
+export declare function useMessageInfoDialog(options: UseMessageInfoDialogOptions): {
+    infoMessage: Ref<{
+        id: string;
+        muid?: string | undefined;
+        conversationId: string;
+        senderId: string;
+        senderName: string;
+        text: string;
+        kind: ChatMessageKind;
+        sentAt: Date;
+        category: string;
+        type: string;
+        senderAvatar?: string | undefined;
+        isOwn: boolean;
+        isDeleted: boolean;
+        isEdited: boolean;
+        attachments: {
+            kind: Extract< ChatMessageKind, "image" | "video" | "audio" | "file">;
+            name: string;
+            url?: string | undefined;
+            mimeType?: string | undefined;
+            extension?: string | undefined;
+            size?: number | undefined;
+            width?: number | undefined;
+            height?: number | undefined;
+        }[];
+        poll?: {
+            id?: string | undefined;
+            question: string;
+            options: {
+                id: string;
+                text: string;
+                voteCount: number;
+                voters: {
+                    uid: string;
+                    name: string;
+                    avatar?: string | undefined;
+                    status?: string | undefined;
+                    lastSeen?: Date | undefined;
+                }[];
+            }[];
+            totalVotes: number;
+            allowsMultipleAnswers: boolean;
+        } | undefined;
+        scheduled?: {
+            scheduleDate?: Date | undefined;
+            originalChatUid?: string | undefined;
+            muid?: string | undefined;
+            messageId?: number | undefined;
+        } | undefined;
+        translatedText?: string | undefined;
+        replyTo?: {
+            messageId: string;
+            senderName: string;
+            text: string;
+            kind: ChatMessageKind;
+        } | undefined;
+        forwardedFrom?: {
+            senderName: string;
+        } | undefined;
+        parentMessageId?: string | undefined;
+        replyCount: number;
+        reactions: {
+            emoji: string;
+            count: number;
+            reactedByMe: boolean;
+        }[];
+        receipts: {
+            deliveredAt?: Date | undefined;
+            deliveredToMeAt?: Date | undefined;
+            readAt?: Date | undefined;
+            readByMeAt?: Date | undefined;
+        };
+        pinnedAt?: Date | undefined;
+        pinnedBy?: string | undefined;
+        deliveryState: ChatDeliveryState;
+        metadata?: Record<string, unknown> | undefined;
+        source: any;
+    } | null, ChatMessageItem | {
+        id: string;
+        muid?: string | undefined;
+        conversationId: string;
+        senderId: string;
+        senderName: string;
+        text: string;
+        kind: ChatMessageKind;
+        sentAt: Date;
+        category: string;
+        type: string;
+        senderAvatar?: string | undefined;
+        isOwn: boolean;
+        isDeleted: boolean;
+        isEdited: boolean;
+        attachments: {
+            kind: Extract< ChatMessageKind, "image" | "video" | "audio" | "file">;
+            name: string;
+            url?: string | undefined;
+            mimeType?: string | undefined;
+            extension?: string | undefined;
+            size?: number | undefined;
+            width?: number | undefined;
+            height?: number | undefined;
+        }[];
+        poll?: {
+            id?: string | undefined;
+            question: string;
+            options: {
+                id: string;
+                text: string;
+                voteCount: number;
+                voters: {
+                    uid: string;
+                    name: string;
+                    avatar?: string | undefined;
+                    status?: string | undefined;
+                    lastSeen?: Date | undefined;
+                }[];
+            }[];
+            totalVotes: number;
+            allowsMultipleAnswers: boolean;
+        } | undefined;
+        scheduled?: {
+            scheduleDate?: Date | undefined;
+            originalChatUid?: string | undefined;
+            muid?: string | undefined;
+            messageId?: number | undefined;
+        } | undefined;
+        translatedText?: string | undefined;
+        replyTo?: {
+            messageId: string;
+            senderName: string;
+            text: string;
+            kind: ChatMessageKind;
+        } | undefined;
+        forwardedFrom?: {
+            senderName: string;
+        } | undefined;
+        parentMessageId?: string | undefined;
+        replyCount: number;
+        reactions: {
+            emoji: string;
+            count: number;
+            reactedByMe: boolean;
+        }[];
+        receipts: {
+            deliveredAt?: Date | undefined;
+            deliveredToMeAt?: Date | undefined;
+            readAt?: Date | undefined;
+            readByMeAt?: Date | undefined;
+        };
+        pinnedAt?: Date | undefined;
+        pinnedBy?: string | undefined;
+        deliveryState: ChatDeliveryState;
+        metadata?: Record<string, unknown> | undefined;
+        source: any;
+    } | null>;
+    infoMessageReceipts: Ref<{
+        kind: ChatMessageReceiptKind;
+        user: {
+            uid: string;
+            name: string;
+            avatar?: string | undefined;
+            status?: string | undefined;
+            lastSeen?: Date | undefined;
+        };
+        timestamp?: Date | undefined;
+    }[], ChatMessageReceiptItem[] | {
+        kind: ChatMessageReceiptKind;
+        user: {
+            uid: string;
+            name: string;
+            avatar?: string | undefined;
+            status?: string | undefined;
+            lastSeen?: Date | undefined;
+        };
+        timestamp?: Date | undefined;
+    }[]>;
+    loadingMessageReceipts: Ref<boolean, boolean>;
+    messageReceiptsError: Ref<string | null, string | null>;
+    messageReceiptsByMessageId: Ref<Record<string, ChatMessageReceiptItem[]>, Record<string, ChatMessageReceiptItem[]>>;
+    loadingMessageReceiptIds: Ref<Record<string, boolean>, Record<string, boolean>>;
+    getMessageReceipts: (message: ChatMessageItem) => Promise<ChatMessageReceiptItem[]>;
+    messageReactionsByMessageId: Ref<Record<string, ChatReactionDetailItem[]>, Record<string, ChatReactionDetailItem[]>>;
+    loadingMessageReactionIds: Ref<Record<string, boolean>, Record<string, boolean>>;
+    getMessageReactions: (message: ChatMessageItem) => Promise<ChatReactionDetailItem[]>;
+    openMessageInfo: (message: ChatMessageItem) => Promise<void>;
+    closeMessageInfo: () => void;
+};

package/dist/composables/useMessageListScroll.d.ts

@@ -0,0 +1,15 @@
+import { TemplateRef } from 'vue';
+import { ChatConversationItem, ChatMessageItem } from '../chat/types';
+export interface UseMessageListScrollOptions {
+    getConversation: () => ChatConversationItem | null | undefined;
+    getParentMessage: () => ChatMessageItem | null | undefined;
+    getMessages: () => ChatMessageItem[];
+    isLoading: () => boolean;
+    isLoadingOlder: () => boolean;
+    canLoadOlder: () => boolean;
+    onLoadOlder: () => void;
+    threadRef: TemplateRef<HTMLElement | null>;
+}
+export declare function useMessageListScroll(options: UseMessageListScrollOptions): {
+    handleThreadScroll: () => void;
+};

package/dist/composables/useMessageNavigation.d.ts

@@ -0,0 +1,16 @@
+import { Ref } from 'vue';
+import { ChatClient } from '../chat/types';
+export interface UseMessageNavigationOptions {
+    /** Ref to the root chat wrapper element used as the querySelector scope. */
+    chatRootRef: Ref<HTMLElement | null>;
+    /** Returns the currently resolved chat client, or null. */
+    getClient: () => ChatClient | null;
+}
+/**
+ * Composable that scrolls the chat root to a requested message ID coming from
+ * either the `loadMessageId` prop or the global `chat` navigation refs.
+ */
+export declare function useMessageNavigation(options: UseMessageNavigationOptions): {
+    scrollToRequestedMessage: (messageId?: string) => Promise<void>;
+    handleOpenReferencedMessage: (messageId: string) => void;
+};