@medipha/chat 1.0.14

package/dist/features/message-list/overlays/message-details/message-details-modal.d.ts

@@ -0,0 +1,16 @@
+import { ChatMessage, ChatUser, ConversationMember } from '../../../../utils/chat';
+interface MessageDetailsModalProps {
+    message: ChatMessage;
+    isGroup: boolean;
+    members: ConversationMember[] | undefined;
+    otherMember: ConversationMember | undefined;
+    currentUserId: string | null;
+    authUser: ChatUser | null;
+    /** Members (besides the sender) who've read up to this message; `null` means the group
+     *  is over MAX_DETAILED_SEEN_MEMBERS and details aren't computed at all. */
+    seenBy: ConversationMember[] | null;
+    onClose: () => void;
+}
+/** "Thông tin tin nhắn" dialog — sender/content/time preview plus a seen-by list. */
+export declare function MessageDetailsModal({ message, isGroup, members, otherMember, currentUserId, authUser, seenBy, onClose, }: MessageDetailsModalProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/message-list/overlays/message-details/use-message-details-modal.d.ts

@@ -0,0 +1,14 @@
+import { ChatMessage, ConversationMember } from '../../../../utils/chat';
+/**
+ * Tracks which message's "thông tin tin nhắn" (details) modal is open, and derives its
+ * "seen by" member list. Returns `null` for the seen-by list (as opposed to an empty
+ * array) when the group is too large to compute cheaply, so the modal can render a
+ * "too many members" message instead of an empty one.
+ */
+export declare function useMessageDetailsModal(conversationMembers: ConversationMember[] | undefined, isGroup: boolean, groupMemberCount: number): {
+    detailsMessage: ChatMessage | null;
+    detailsSeenBy: ConversationMember[] | null;
+    openDetails: (message: ChatMessage) => void;
+    closeDetails: () => void;
+    clearIfTarget: (messageId: string) => void;
+};

package/dist/features/message-list/overlays/message-menu/use-message-menu.d.ts

@@ -0,0 +1,21 @@
+import { RefObject } from 'react';
+export interface MessageMenuPosition {
+    top?: number;
+    bottom?: number;
+    left: number;
+}
+/**
+ * Tracks which message's options menu ("...") is open and its fixed-position pixel
+ * coordinates, clamped inside the message timeline's own bounds (not the browser
+ * window, since the chat module is embedded in a host page and may not fill the
+ * viewport) so it never overhangs any edge at any container size. Closes on outside
+ * click, on timeline scroll, or when its target message is removed.
+ */
+export declare function useMessageMenu(messageTimelineRef: RefObject<HTMLElement | null>): {
+    openMessageMenuId: string | null;
+    messageMenuPosition: MessageMenuPosition | null;
+    openMenu: (messageId: string, triggerRect: DOMRect) => void;
+    closeMenu: () => void;
+    clearIfTarget: (messageId: string) => void;
+    setOpenId: (messageId: string | null) => void;
+};

package/dist/features/message-list/overlays/reaction/reaction-modal.d.ts

@@ -0,0 +1,22 @@
+import { ReactionType, ReactionUserItem } from '@medipha/chat-core';
+import { ChatMessage, ConversationMember } from '../../../../utils/chat';
+interface ReactionModalProps {
+    message: ChatMessage;
+    filter: ReactionType | null;
+    items: ReactionUserItem[];
+    isLoading: boolean;
+    error: string;
+    hasMore: boolean;
+    onFilterChange: (filter: ReactionType | null) => void;
+    onLoadMore: () => void;
+    onRetry: () => void;
+    onClose: () => void;
+    /** So each row can show the same "Phòng ban · Chức vụ" subtitle other member lists
+     *  show — the reaction detail endpoint itself only returns name/avatar. */
+    members: ConversationMember[] | undefined;
+    /** Opens the shared account-info modal for a reactor. */
+    onOpenProfile: (userId: string) => void;
+}
+/** Shows detail users fetched on demand; message history never supplies these rows. */
+export declare function ReactionModal({ message, filter, items, isLoading, error, hasMore, onFilterChange, onLoadMore, onRetry, onClose, members, onOpenProfile, }: ReactionModalProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/message-list/overlays/reaction/use-reaction-modal.d.ts

@@ -0,0 +1,23 @@
+import { ReactionType, ReactionUserItem } from '@medipha/chat-core';
+interface ReactionCursor {
+    updatedAt: string | null;
+    userId: string | null;
+}
+/** Backs the "who reacted" modal (ReactionModal): which message/filter is showing, its
+ *  paginated list of reactors, and the API calls that load/refresh/page through it. */
+export declare function useReactionModal(): {
+    messageId: string | null;
+    filter: ReactionType | null;
+    items: ReactionUserItem[];
+    cursor: ReactionCursor;
+    hasMore: boolean;
+    isLoading: boolean;
+    error: string;
+    open: (targetMessageId: string, targetFilter: ReactionType | null) => void;
+    changeFilter: (targetFilter: ReactionType | null) => void;
+    loadMore: () => void;
+    close: () => void;
+    retry: () => void;
+    clearIfTarget: (targetMessageId: string) => void;
+};
+export {};

package/dist/features/message-list/overlays/reaction/use-reaction-picker.d.ts

@@ -0,0 +1,8 @@
+/** Tracks which message's inline emoji reaction picker is open (one at a time). */
+export declare function useReactionPicker(): {
+    reactionPickerMessageId: string | null;
+    openPicker: (messageId: string | null) => void;
+    closePicker: () => void;
+    toggle: (messageId: string) => void;
+    clearIfTarget: (messageId: string) => void;
+};

package/dist/features/message-list/overlays/system-members/system-members-modal.d.ts

@@ -0,0 +1,22 @@
+import { MessageSystemMemberItem } from '@medipha/chat-core';
+import { ConversationMember } from '../../../../utils/chat';
+interface SystemMembersModalProps {
+    totalCount: number;
+    /** The verb from the notice itself ("đã thêm" / "đã xóa"), so one modal titles both. */
+    actionLabel: string;
+    items: MessageSystemMemberItem[];
+    isLoading: boolean;
+    error: string;
+    hasMore: boolean;
+    onLoadMore: () => void;
+    onRetry: () => void;
+    onClose: () => void;
+    /** Lets each row show the same "Phòng ban · Chức vụ" subtitle other member lists show — the
+     *  endpoint itself only returns name/avatar. */
+    members: ConversationMember[] | undefined;
+    onOpenProfile: (userId: string) => void;
+}
+/** The people a batch "đã thêm" notice named. Same shape as the reaction detail modal: rows
+ *  are fetched a page at a time, because this list can run to the whole company. */
+export declare function SystemMembersModal({ totalCount, actionLabel, items, isLoading, error, hasMore, onLoadMore, onRetry, onClose, members, onOpenProfile, }: SystemMembersModalProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/message-list/overlays/system-members/use-system-members-modal.d.ts

@@ -0,0 +1,18 @@
+import { MessageSystemMemberItem } from '@medipha/chat-core';
+/** Backs the "N người khác" list on a batch member-add notice: which message is showing, its
+ *  paginated people, and the calls that load and page through them. The list is never part of
+ *  the message payload — a 500-member batch would ride along with every history fetch — so it
+ *  is fetched here the first time someone opens it. */
+export declare function useSystemMembersModal(): {
+    messageId: string | null;
+    totalCount: number;
+    actionLabel: string;
+    items: MessageSystemMemberItem[];
+    hasMore: boolean;
+    isLoading: boolean;
+    error: string;
+    open: (targetMessageId: string, knownCount: number, label: string) => void;
+    loadMore: () => void;
+    retry: () => void;
+    close: () => void;
+};

package/dist/features/message-list/use-message-removal.d.ts

@@ -0,0 +1,12 @@
+import { ChatMessage } from '../../utils/chat';
+import { MessageRemovedPayload } from '@medipha/chat-core';
+/**
+ * Owns the "thu hồi/gỡ tin nhắn" (remove message) confirm flow: which messages currently
+ * have a removal request in flight, and the confirm-dialog-then-API-call sequence itself.
+ * Only changes local content after the server confirms via `onRemoved`, which the caller
+ * uses to update every UI projection that could still expose the removed message's data.
+ */
+export declare function useMessageRemoval(conversationId: string | undefined, currentUserId: string | null, canModerateMessages: boolean, onRemoved: (removal: MessageRemovedPayload) => void, onConfirmRemoving?: (message: ChatMessage) => void): {
+    removalInFlightIds: Set<string>;
+    requestRemoval: (message: ChatMessage) => void;
+};

package/dist/features/message-list/use-message-timeline-scroll.d.ts

@@ -0,0 +1,25 @@
+import { VirtuosoHandle } from 'react-virtuoso';
+import { ChatMessage } from '../../utils/chat';
+/**
+ * Owns the Virtuoso scroll plumbing for the message timeline: sticky-to-latest pinning
+ * across async layout shifts (e.g. images growing after they load), the auto-hiding
+ * scrollbar, the floating day-label pill, and the "near bottom" signal used to hide the
+ * scroll-to-bottom button a little early. `onScrollStart` is an escape hatch for closing
+ * an unrelated popover (the message options menu) that scrolling used to close as a
+ * side effect — it isn't this hook's own concern.
+ */
+export declare function useMessageTimelineScroll(messages: ChatMessage[], firstItemIndex: number, onScrollStart?: () => void): {
+    virtuosoRef: import('react').RefObject<VirtuosoHandle>;
+    timelineScrollerRef: import('react').MutableRefObject<HTMLElement | null>;
+    stickToLatestRef: import('react').MutableRefObject<boolean>;
+    visibleDayLabel: string | null;
+    isNearBottomOfList: boolean;
+    scrollToLatest: (behavior?: "auto" | "smooth") => void;
+    stickToLatest: () => void;
+    handleTimelineScrolling: (scrolling: boolean) => void;
+    handleVisibleRangeChanged: (range: {
+        startIndex: number;
+        endIndex: number;
+    }) => void;
+    setScrollerRef: (element: unknown) => void;
+};

package/dist/features/message-window/use-message-window.d.ts

@@ -0,0 +1,46 @@
+import { ChatMessage, ReactionSummary } from '../../utils/chat';
+import { MessageRemovedPayload } from '@medipha/chat-core';
+type WindowMode = 'latest' | 'around';
+interface WindowMeta {
+    oldestSequence: string | null;
+    newestSequence: string | null;
+    hasOlderMessages: boolean;
+    hasNewerMessages: boolean;
+}
+/**
+ * Owns the paginated message window for one conversation: latest/around loading,
+ * older/newer cursor pages, realtime merges, and gap reconciliation.
+ */
+export declare function useMessageWindow(conversationId: string | undefined): {
+    clearFocusedMessage: () => void;
+    applyMessageRemoved: (removal: MessageRemovedPayload) => void;
+    completeAroundFocus: () => void;
+    error: string;
+    firstItemIndex: number;
+    focusedMessageId: string | null;
+    focusedMessageIndex: number | null;
+    timelineRevision: number;
+    handleRealtimeMessage: (incomingMessage: unknown) => void;
+    hasUnseenMessages: boolean;
+    isAtBottom: boolean;
+    isFollowingLatest: () => boolean;
+    isRemovedMessageId: (messageId: string) => boolean;
+    isLoadingAround: boolean;
+    isLoadingLatest: boolean;
+    isLoadingNewer: boolean;
+    isLoadingOlder: boolean;
+    loadAround: (messageId: string) => Promise<boolean>;
+    loadLatest: () => Promise<boolean>;
+    loadNewer: () => Promise<boolean>;
+    loadOlder: () => Promise<boolean>;
+    mergeOutgoingMessage: (message: ChatMessage) => void;
+    removeOutgoingMessage: (clientMessageId: string) => void;
+    messages: ChatMessage[];
+    mode: WindowMode;
+    reconcile: (afterSequence?: string | null) => Promise<boolean>;
+    updateAtBottom: (nextIsAtBottom: boolean) => void;
+    updateMessageReactionSummary: (messageId: string, nextReactionSummary: ReactionSummary | ((currentSummary: ReactionSummary) => ReactionSummary)) => void;
+    windowMeta: WindowMeta;
+};
+export type MessageWindow = ReturnType<typeof useMessageWindow>;
+export {};

package/dist/features/pinned-messages/pinned-messages-bar.d.ts

@@ -0,0 +1,18 @@
+import { RefObject } from 'react';
+interface PinnedMessagesBarProps {
+    conversationId: string | undefined;
+    canManagePins: boolean;
+    onJump: (messageId: string) => void;
+    /** The message-list viewport — the dropdown/scrim portal into it so only the message
+     * area dims, leaving the header and composer untouched. */
+    timelineRef: RefObject<HTMLElement | null>;
+}
+/**
+ * Zalo-style pinned bar: a compact strip showing the most recent pin. Expanding it opens
+ * a floating dropdown over the conversation (not pushing it down) with the full list.
+ * Reads the pinned list straight from the shared pin store (via `usePinnedMessages`) —
+ * the same store each message bubble's own pin icon reads, so a pin/unpin from either
+ * place shows up in both immediately.
+ */
+export declare function PinnedMessagesBar({ conversationId, canManagePins, onJump: _onJump, timelineRef, }: PinnedMessagesBarProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/features/pinned-messages/use-pinned-messages.d.ts

@@ -0,0 +1,21 @@
+import { ChatMessage } from '../../utils/chat';
+/**
+ * Owns the pinned-messages list for a conversation: fetching it, applying single-message
+ * pin/unpin updates (from either the socket ACK or a `message:pinned` broadcast), and
+ * emitting the pin toggle itself. `onBeforeToggle` runs before the socket emit — used by
+ * the caller to close any unrelated popover (e.g. the reaction picker) that toggling pin
+ * used to close as a side effect.
+ *
+ * Backed by the shared `pinnedMessagesStore` (not local state) — every place that calls
+ * this hook for the same conversation (the pinned bar, each message bubble) reads and
+ * writes the same list, so a pin/unpin from any of them is reflected everywhere at once.
+ */
+export declare function usePinnedMessages(conversationId: string | undefined, onBeforeToggle?: () => void): {
+    pinnedMessages: ChatMessage[];
+    pinnedIds: Set<string>;
+    applyPinnedUpdate: (message: ChatMessage) => void;
+    refreshPinned: () => Promise<void>;
+    togglePin: (message: ChatMessage, nextPinned: boolean) => void;
+    reset: () => void;
+    clearIfTarget: (messageId: string) => void;
+};

package/dist/features/typing/use-typing-indicator.d.ts

@@ -0,0 +1,12 @@
+import { ChatUser, ConversationMember } from '../../utils/chat';
+/**
+ * Tracks up to TYPING_INDICATOR_CAP most-recently-active typers for a conversation (most
+ * recent first) and auto-clears one if its typing:stop event never arrives. Eviction past
+ * the cap is a local display-cap only — it does not emit typing:stop for the evicted user.
+ */
+export declare function useTypingIndicator(isGroup: boolean, otherMember: ConversationMember | undefined, mentionMembers: ChatUser[]): {
+    typingNames: string[];
+    markUserTyping: (userId: string) => void;
+    markUserStoppedTyping: (userId: string) => void;
+    resetAll: () => void;
+};