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

package/dist/components/messages/MessageList.vue.d.ts

@@ -0,0 +1,42 @@
+import { ChatMessageItem } from '../../chat/types';
+import { ChatTarget } from '../../composables/useChatEventBus';
+import { ChatConversationItem } from '../..';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    /** Which target this list instance represents. Determines which context slice to use. */
+    target: ChatTarget;
+    /** Optional override to show/hide the list header for this pane. */
+    showHeader?: boolean;
+    /** Optional class applied to action-message rows rendered by MessageItem. */
+    actionMessageClass?: string;
+    /** Optional class applied to the inner action message pill/content row. */
+    actionMessageRowClass?: string;
+    /** Optional flag to hide the group actions for this pane. */
+    hideGroupActions?: boolean;
+};
+declare var __VLS_1: {
+    conversation: ChatConversationItem | null;
+    parentMessage: ChatMessageItem | null;
+    target: ChatTarget;
+    title: string;
+    subtitle: string;
+    memberCount: number;
+}, __VLS_39: {};
+type __VLS_Slots = {} & {
+    header?: (props: typeof __VLS_1) => any;
+} & {
+    composer?: (props: typeof __VLS_39) => any;
+};
+declare const __VLS_base: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    anchorclick: (event: MouseEvent, url: string) => any;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onAnchorclick?: ((event: MouseEvent, url: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/messages/MessageListHeader.vue.d.ts

@@ -0,0 +1,9 @@
+import { ChatConversationItem, ChatMessageItem } from '../../chat/types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    conversation: ChatConversationItem | null;
+    parentMessage?: ChatMessageItem | null;
+};
+declare const __VLS_export: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/messages/MessagePinnedLabel.vue.d.ts

@@ -0,0 +1,4 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare const __VLS_export: DefineComponent<{}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/messages/MessagePollContent.vue.d.ts

@@ -0,0 +1,14 @@
+import { ChatMessageItem } from '../../chat/types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    message: ChatMessageItem;
+    currentUserId?: string;
+    pendingOptionKey?: string | null;
+};
+declare const __VLS_export: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    vote: (optionId: string) => any;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onVote?: ((optionId: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/messages/MessageReactionList.vue.d.ts

@@ -0,0 +1,14 @@
+import { ChatMessageItem } from '../../chat/types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    message: ChatMessageItem;
+    disabled: boolean;
+    compact?: boolean;
+};
+declare const __VLS_export: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    toggle: (emoji: string) => any;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onToggle?: ((emoji: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/messages/MessageReplyQuote.vue.d.ts

@@ -0,0 +1,12 @@
+import { ChatMessageItem } from '../../chat/types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    message: ChatMessageItem;
+};
+declare const __VLS_export: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    open: () => any;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onOpen?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/messages/MessageTextContent.vue.d.ts

@@ -0,0 +1,12 @@
+import { ChatMessageItem } from '../../chat/types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    message: ChatMessageItem;
+};
+declare const __VLS_export: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    anchorclick: (event: MouseEvent, url: string) => any;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onAnchorclick?: ((event: MouseEvent, url: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/messages/PinnedMessagesBar.vue.d.ts

@@ -0,0 +1,4 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare const __VLS_export: DefineComponent<{}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/overlays/ForwardMessageDialog.vue.d.ts

@@ -0,0 +1,16 @@
+import { ChatConversationItem, ForwardMessageTarget } from '../../chat/types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    open: boolean;
+    chats: ChatConversationItem[];
+    sending?: boolean;
+};
+declare const __VLS_export: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    close: () => any;
+    select: (target: ForwardMessageTarget) => any;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+    onSelect?: ((target: ForwardMessageTarget) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/overlays/FullscreenDialog.vue.d.ts

@@ -0,0 +1,34 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    open: boolean;
+    title?: string;
+    subtitle?: string;
+    closeLabel?: string;
+    closeAriaLabel?: string;
+};
+declare var __VLS_19: {}, __VLS_21: {}, __VLS_23: {};
+type __VLS_Slots = {} & {
+    actions?: (props: typeof __VLS_19) => any;
+} & {
+    default?: (props: typeof __VLS_21) => any;
+} & {
+    footer?: (props: typeof __VLS_23) => any;
+};
+declare const __VLS_base: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    close: () => any;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {
+    title: string;
+    subtitle: string;
+    closeLabel: string;
+    closeAriaLabel: string;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/overlays/MediaViewerDialog.vue.d.ts

@@ -0,0 +1,12 @@
+import { ChatAttachmentItem } from '../../chat/types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    attachment: ChatAttachmentItem | null;
+};
+declare const __VLS_export: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    close: () => any;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/overlays/MessageInfoDialog.vue.d.ts

@@ -0,0 +1,16 @@
+import { ChatMessageItem, ChatMessageReceiptItem } from '../../chat/types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    open: boolean;
+    message: ChatMessageItem | null;
+    receipts: ChatMessageReceiptItem[];
+    loading: boolean;
+    error?: string | null;
+};
+declare const __VLS_export: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    close: () => any;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/overlays/PinnedMessagesDialog.vue.d.ts

@@ -0,0 +1,20 @@
+import { ChatMessageItem } from '../../chat/types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    open: boolean;
+    messages: ChatMessageItem[];
+    canUnpin?: boolean;
+    mentionNameByUid?: Record<string, string>;
+    conversationTitle?: string;
+};
+declare const __VLS_export: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    close: () => any;
+    unpin: (messageId: string) => any;
+    jump: (messageId: string) => any;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+    onUnpin?: ((messageId: string) => any) | undefined;
+    onJump?: ((messageId: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/overlays/ReceiptSection.vue.d.ts

@@ -0,0 +1,13 @@
+import { ChatMessageReceiptItem } from '../../chat/types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    title: string;
+    receipts: ChatMessageReceiptItem[];
+    formatDateTime: (date?: Date) => string;
+    showHeader?: boolean;
+};
+declare const __VLS_export: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    showHeader: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/overlays/ScheduledMessagesDialog.vue.d.ts

@@ -0,0 +1,37 @@
+import { ChatMessageItem } from '../../chat/types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    open: boolean;
+    loading: boolean;
+    messages: ChatMessageItem[];
+    conversationTitle?: string;
+};
+declare const __VLS_export: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    close: () => any;
+    remove: (message: ChatMessageItem) => any;
+    reschedule: (payload: {
+        messageId: number;
+        muid: string;
+        originalChatUid: string;
+        scheduleDate: string;
+    }) => any;
+    editText: (payload: {
+        message: ChatMessageItem;
+        nextText: string;
+    }) => any;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+    onRemove?: ((message: ChatMessageItem) => any) | undefined;
+    onReschedule?: ((payload: {
+        messageId: number;
+        muid: string;
+        originalChatUid: string;
+        scheduleDate: string;
+    }) => any) | undefined;
+    onEditText?: ((payload: {
+        message: ChatMessageItem;
+        nextText: string;
+    }) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/shared/PersonAvatar.vue.d.ts

@@ -0,0 +1,8 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    image?: string;
+    name: string;
+};
+declare const __VLS_export: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/composables/chat/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Barrel export for the four focused chat subcontexts.
+ *
+ * @remarks
+ * Each subcontext owns a single domain of the chat component tree's shared
+ * state: conversation identity/permissions, message lists, composer drafts, and
+ * dialog overlays. Consumer components inject only the subcontexts they need,
+ * keeping coupling tight and surfaces small.
+ */
+export { createConversationContext, provideConversationContext, useConversationContext, type ConversationContext, type CreateConversationContextOptions, } from './useConversationContext';
+export { createMessagesContext, provideMessagesContext, useMessagesContext, type MessagesContext, type CreateMessagesContextOptions, } from './useMessagesContext';
+export { createComposerContext, provideComposerContext, useComposerContext, type ComposerContext, type ComposerHandle, type CreateComposerContextOptions, } from './useComposerContext';
+export { createDialogsContext, provideDialogsContext, useDialogsContext, type DialogsContext, type CreateDialogsContextOptions, } from './useDialogsContext';

package/dist/composables/chat/useComposerContext.d.ts

@@ -0,0 +1,44 @@
+import { ComputedRef, Ref, TemplateRef } from 'vue';
+import { AttachmentUploadInput, ChatClient, ChatMessageItem, MessageSendOptions, PollComposerInput, ScheduleMessageInput } from '../../chat/types';
+/** Minimal public interface exposed by a composer component via defineExpose. */
+export interface ComposerHandle {
+    focusEditor: () => Promise<void>;
+}
+export interface ComposerContext {
+    readonly draft: Ref<string>;
+    readonly threadDraft: Ref<string>;
+    readonly composerResetSignal: Ref<number>;
+    readonly threadComposerResetSignal: Ref<number>;
+    readonly messageBeingRepliedTo: ComputedRef<ChatMessageItem | null>;
+    readonly messageBeingEdited: ComputedRef<ChatMessageItem | null>;
+    readonly offlineMode: ComputedRef<boolean>;
+    readonly pendingQueueCount: ComputedRef<number>;
+    readonly isSendingMessage: ComputedRef<boolean>;
+    readonly isSchedulingMessage: ComputedRef<boolean>;
+    resetMainComposer(): void;
+    resetThreadComposer(): void;
+    focusMainComposer(): void;
+    focusThreadComposer(): void;
+    shouldFocusThreadComposer(message: ChatMessageItem): boolean;
+    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 interface CreateComposerContextOptions {
+    chatClient: ComputedRef<ChatClient | null>;
+    sendOptions: ComputedRef<MessageSendOptions | undefined>;
+    mentionNameByUid: ComputedRef<Record<string, string>>;
+    /** Called after a message has been scheduled. */
+    afterSchedule: () => Promise<void>;
+    mainComposerRef?: TemplateRef<ComposerHandle | null>;
+    threadComposerRef?: TemplateRef<ComposerHandle | null>;
+}
+export declare function createComposerContext(options: CreateComposerContextOptions): ComposerContext;
+export declare function provideComposerContext(ctx: ComposerContext): void;
+export declare function useComposerContext(): ComposerContext;

package/dist/composables/chat/useConversationContext.d.ts

@@ -0,0 +1,36 @@
+import { ComputedRef } from 'vue';
+import { MentionCandidate } from '../../chat/mentions';
+import { ChatClient, ChatConversationItem, MessageSendOptions, ParticipantInfo } from '../../chat/types';
+export interface ConversationContext {
+    /** The resolved ChatClient (from BccChat prop or global singleton). */
+    readonly client: ComputedRef<ChatClient | null>;
+    /** The currently active conversation. */
+    readonly conversation: ComputedRef<ChatConversationItem | null>;
+    /** UID of the authenticated user. */
+    readonly currentUserId: ComputedRef<string | undefined>;
+    readonly canUseMessageActions: ComputedRef<boolean>;
+    readonly canReact: ComputedRef<boolean>;
+    readonly canReply: ComputedRef<boolean>;
+    readonly canOpenThread: ComputedRef<boolean>;
+    readonly canPin: ComputedRef<boolean>;
+    readonly isReadOnly: ComputedRef<boolean>;
+    readonly isChannel: ComputedRef<boolean>;
+    readonly sendOptions: ComputedRef<MessageSendOptions | undefined>;
+    readonly mentionCandidates: ComputedRef<MentionCandidate[]>;
+    readonly mentionNameByUid: ComputedRef<Record<string, string>>;
+}
+export interface CreateConversationContextOptions {
+    chatClient: ComputedRef<ChatClient | null>;
+    selectedConversation: ComputedRef<ChatConversationItem | null>;
+    /** Returns prop-supplied read-only flag, or undefined to auto-detect. */
+    getPropIsReadOnly: () => boolean | undefined;
+    /** Returns prop-supplied send options, or undefined to auto-detect. */
+    getPropSendOptions: () => MessageSendOptions | undefined;
+    /** Display name override for the sender. */
+    getSenderDisplayName: () => string | undefined;
+    /** Live group members used for @mention suggestions. */
+    getMentionCandidates: () => ReadonlyArray<ParticipantInfo>;
+}
+export declare function createConversationContext(options: CreateConversationContextOptions): ConversationContext;
+export declare function provideConversationContext(ctx: ConversationContext): void;
+export declare function useConversationContext(): ConversationContext;

package/dist/composables/chat/useDialogsContext.d.ts

@@ -0,0 +1,43 @@
+import { ComputedRef, Ref } from 'vue';
+import { ChatClient, ChatConversationItem, ChatMessageItem, ChatMessageReceiptItem, ChatReactionDetailItem, ForwardMessageTarget } from '../../chat/types';
+export interface DialogsContext {
+    readonly infoMessage: Ref<ChatMessageItem | null>;
+    readonly infoMessageReceipts: Ref<ChatMessageReceiptItem[]>;
+    readonly loadingMessageReceipts: Ref<boolean>;
+    readonly messageReceiptsError: Ref<string | null>;
+    readonly messageReceiptsByMessageId: Ref<Record<string, ChatMessageReceiptItem[]>>;
+    readonly loadingMessageReceiptIds: Ref<Record<string, boolean>>;
+    getMessageReceipts(message: ChatMessageItem): Promise<ChatMessageReceiptItem[]>;
+    openMessageInfo(message: ChatMessageItem): Promise<void>;
+    closeMessageInfo(): void;
+    readonly messageReactionsByMessageId: Ref<Record<string, ChatReactionDetailItem[]>>;
+    readonly loadingMessageReactionIds: Ref<Record<string, boolean>>;
+    getMessageReactions(message: ChatMessageItem): Promise<ChatReactionDetailItem[]>;
+    readonly hasScheduledMessages: ComputedRef<boolean>;
+    readonly showScheduledMessages: Ref<boolean>;
+    readonly loadingScheduledMessages: ComputedRef<boolean>;
+    readonly scheduledMessages: ComputedRef<ChatMessageItem[]>;
+    openScheduledMessages(): Promise<void>;
+    refreshScheduledMessages(): Promise<void>;
+    readonly showPinnedMessages: Ref<boolean>;
+    openPinnedMessages(): void;
+    closePinnedMessages(): void;
+    readonly forwardMessageSource: Ref<ChatMessageItem | null>;
+    readonly sendingForwardMessage: Ref<boolean>;
+    openForwardMessage(message: ChatMessageItem): void;
+    closeForwardMessage(): void;
+    sendForwardedMessage(target: ForwardMessageTarget): Promise<void>;
+}
+export interface CreateDialogsContextOptions {
+    chatClient: ComputedRef<ChatClient | null>;
+    selectedConversation: ComputedRef<ChatConversationItem | null>;
+    /** Whether the current user can send and schedule messages in the selected conversation. */
+    canScheduleMessages: () => boolean;
+    /** Whether the initial scheduled-messages dialog should be open. */
+    getInitialScheduledMessagesOpen: () => boolean;
+    /** Fallback error string shown when receipt fetch fails. */
+    fetchErrorFallback: string;
+}
+export declare function createDialogsContext(options: CreateDialogsContextOptions): DialogsContext;
+export declare function provideDialogsContext(ctx: DialogsContext): void;
+export declare function useDialogsContext(): DialogsContext;

package/dist/composables/chat/useMessagesContext.d.ts

@@ -0,0 +1,42 @@
+import { ComputedRef, Ref } from 'vue';
+import { ChatClient, ChatConversationItem, ChatMessageItem } from '../../chat/types';
+export interface MessagesContext {
+    readonly messages: ComputedRef<ChatMessageItem[]>;
+    readonly loadingMessages: ComputedRef<boolean>;
+    readonly hasOlderMessages: ComputedRef<boolean>;
+    readonly loadingOlderMessages: ComputedRef<boolean>;
+    readonly threadMessages: ComputedRef<ChatMessageItem[]>;
+    readonly loadingThreadMessages: ComputedRef<boolean>;
+    readonly activeThreadParentMessage: ComputedRef<ChatMessageItem | null>;
+    readonly hasOlderThreadMessages: ComputedRef<boolean>;
+    readonly loadingOlderThreadMessages: ComputedRef<boolean>;
+    /** Pins of the active conversation, most recently pinned first. */
+    readonly pinnedMessages: ComputedRef<ChatMessageItem[]>;
+    /** Whether the message with this id is pinned. */
+    isMessagePinned(messageId: string): boolean;
+    /** True while the conversation is at the server-owned pin cap. */
+    readonly pinnedMessagesLimitReached: ComputedRef<boolean>;
+    readonly showDefaultEmptyState: ComputedRef<boolean>;
+    readonly isChatEmpty: ComputedRef<boolean>;
+}
+export interface CreateMessagesContextOptions {
+    chatClient: ComputedRef<ChatClient | null>;
+    selectedConversation: ComputedRef<ChatConversationItem | null>;
+    usesPublicContract: ComputedRef<boolean>;
+    loadingChat: Ref<boolean>;
+    /** Returns prop-supplied messages, or undefined to fall back to client. */
+    getPropMessages: () => ChatMessageItem[] | undefined;
+    /** Returns prop-supplied thread messages, or undefined to fall back. */
+    getPropThreadMessages: () => ChatMessageItem[] | undefined;
+    /** Returns prop-supplied loading flag, or undefined to fall back. */
+    getPropLoadingMessages: () => boolean | undefined;
+    /** Returns prop-supplied thread loading flag, or undefined to fall back. */
+    getPropLoadingThreadMessages: () => boolean | undefined;
+    /** Returns prop-supplied empty-state flag, or undefined for auto. */
+    getPropShowDefaultEmptyState: () => boolean | undefined;
+    /** Whether to filter out deleted messages. */
+    getHideDeletedMessages: () => boolean;
+}
+export declare function createMessagesContext(options: CreateMessagesContextOptions): MessagesContext;
+export declare function provideMessagesContext(ctx: MessagesContext): void;
+export declare function useMessagesContext(): MessagesContext;

package/dist/composables/useAudioPlayer.d.ts

@@ -0,0 +1,18 @@
+import { Ref } from 'vue';
+export interface UseAudioPlayerOptions {
+    /** Ref to the underlying `<audio>` element. */
+    audioRef: Ref<HTMLAudioElement | null>;
+}
+/**
+ * Composable that owns playback state and exposes the handlers required by a
+ * custom audio player (play/pause toggle plus a draggable seek bar).
+ */
+export declare function useAudioPlayer(options: UseAudioPlayerOptions): {
+    isPlaying: Ref<boolean, boolean>;
+    currentTime: Ref<number, number>;
+    duration: Ref<number, number>;
+    togglePlay: () => void;
+    startSeek: () => void;
+    seek: (time: number) => void;
+    endSeek: () => void;
+};

package/dist/composables/useChatActions.d.ts

@@ -0,0 +1,21 @@
+import { ComposerContext } from './chat/useComposerContext';
+import { ConversationContext } from './chat/useConversationContext';
+import { DialogsContext } from './chat/useDialogsContext';
+import { ChatEventBus } from './useChatEventBus';
+export interface UseChatActionsOptions {
+    /** Conversation identity and permissions. */
+    conversation: ConversationContext;
+    /** Composer draft/send state. */
+    composer: ComposerContext;
+    /** Dialog overlay state. */
+    dialogs: DialogsContext;
+    /** The event bus to subscribe to. */
+    bus: ChatEventBus;
+}
+/**
+ * Subscribes to all bus events and wires them to the appropriate business
+ * logic. Returns a teardown function (also registered via `onUnmounted`).
+ */
+export declare function useChatActions({ conversation, composer, dialogs, bus }: UseChatActionsOptions): {
+    teardown: () => void;
+};

package/dist/composables/useChatEventBus.d.ts

@@ -0,0 +1,108 @@
+import { AttachmentUploadInput, ChatMessageItem, PollComposerInput, ScheduleMessageInput } from '../chat/types';
+/** Target identifier used to distinguish main-conversation from thread actions. */
+export type ChatTarget = "main" | "thread";
+/** All events that can flow through the chat event bus. */
+export interface ChatBusEventMap {
+    /** User wants to reply to a message. */
+    "message:reply": ChatMessageItem;
+    /** User wants to edit a message. */
+    "message:edit": ChatMessageItem;
+    /** User wants to delete a message. */
+    "message:delete": ChatMessageItem;
+    /** User wants to view message delivery info. */
+    "message:info": ChatMessageItem;
+    /** User wants to open a thread for a message. */
+    "message:openThread": ChatMessageItem;
+    /** User wants to toggle a reaction on a message. */
+    "message:toggleReaction": {
+        message: ChatMessageItem;
+        emoji: string;
+    };
+    /** User wants to translate a message. */
+    "message:translate": ChatMessageItem;
+    /** User wants to vote on a poll option. */
+    "message:votePoll": {
+        message: ChatMessageItem;
+        optionId: string;
+    };
+    /** User wants to navigate to a referenced message. */
+    "message:openReference": string;
+    /** User wants to forward a message to another conversation. */
+    "message:forward": ChatMessageItem;
+    /** User wants to pin or unpin a message. */
+    "message:togglePin": ChatMessageItem;
+    /** User wants to unpin the message with this id. */
+    "message:unpin": string;
+    /** User pressed send (text or attachment). */
+    "composer:send": {
+        target: ChatTarget;
+    };
+    /** User attached a file and pressed send. */
+    "composer:sendAttachment": {
+        target: ChatTarget;
+        input: AttachmentUploadInput;
+    };
+    /** User composed and submitted a poll. */
+    "composer:sendPoll": {
+        target: ChatTarget;
+        input: PollComposerInput;
+    };
+    /** User scheduled a message. */
+    "composer:schedule": {
+        target: ChatTarget;
+        input: ScheduleMessageInput;
+    };
+    /** User cancelled a reply. */
+    "composer:cancelReply": undefined;
+    /** User cancelled an edit. */
+    "composer:cancelEdit": undefined;
+    /** User requested older messages. */
+    "list:loadOlder": {
+        target: ChatTarget;
+    };
+    /** Open the scheduled-messages dialog. */
+    "ui:openScheduled": undefined;
+    /** Open the pinned-messages dialog. */
+    "ui:openPinned": undefined;
+    /** Close any open composer actions popover. */
+    "ui:closeComposerActions": undefined;
+    /** Close the thread dialog. */
+    "ui:closeThread": undefined;
+    /** Reschedule a scheduled message. */
+    "ui:reschedule": {
+        messageId: number;
+        muid: string;
+        originalChatUid: string;
+        scheduleDate: string;
+    };
+    /** Remove (cancel) a scheduled message before it is sent. */
+    "ui:removeScheduled": ChatMessageItem;
+    /** Edit the text/caption of a scheduled message. */
+    "ui:editScheduledText": {
+        message: ChatMessageItem;
+        nextText: string;
+    };
+}
+/** Handler type that correctly handles both void and payload events. */
+type EventHandler<T> = T extends undefined ? () => void : (payload: T) => void;
+/** A typed event bus instance. */
+export interface ChatEventBus {
+    /** Emit an event with an optional payload. */
+    emit<K extends keyof ChatBusEventMap>(event: K, ...args: ChatBusEventMap[K] extends undefined ? [] : [ChatBusEventMap[K]]): void;
+    /** Subscribe to an event. Returns an unsubscribe function. */
+    on<K extends keyof ChatBusEventMap>(event: K, handler: EventHandler<ChatBusEventMap[K]>): () => void;
+    /** Unsubscribe from an event. */
+    off<K extends keyof ChatBusEventMap>(event: K, handler: EventHandler<ChatBusEventMap[K]>): void;
+}
+/** Creates a new ChatEventBus instance. Called once by BccChat. */
+export declare function createChatEventBus(): ChatEventBus;
+/** Provides the event bus to descendant components. */
+export declare function provideChatEventBus(bus: ChatEventBus): void;
+/** Injects the event bus from an ancestor BccChat component. */
+export declare function useChatBus(): ChatEventBus;
+/**
+ * Convenience helper: subscribes to a bus event and auto-unsubscribes when the
+ * calling component is unmounted.
+ */
+export declare function useBusListener<K extends keyof ChatBusEventMap>(bus: ChatEventBus, event: K, handler: EventHandler<ChatBusEventMap[K]>): void;
+export {};