uapp-communication-sdk 1.0.0-dev.54

package/types/features/chat/presentation/tick-state.d.ts

@@ -0,0 +1,23 @@
+import type { ChatMessage } from '../domain';
+import type { ConversationReceipts } from '../store';
+/** The delivery state of one of OUR sent messages, derived from per-member receipt cursors. */
+export type TickState = 'sent' | 'delivered' | 'read';
+/** What `tickState` needs to resolve a message's ticks: who the recipients are + their cursors. */
+export interface TickContext {
+    /** The DM peer's userId; null for a group (then `otherMemberIds` is consulted instead). */
+    readonly peerUserId: string | null;
+    /** Every member's userId except the viewer (used for the group all-members rule). */
+    readonly otherMemberIds: readonly string[];
+    /** Per-member delivered/read cursors for the conversation, keyed by userId. */
+    readonly receipts: ConversationReceipts;
+}
+/**
+ * Resolve a sent message's tick state from per-member receipt cursors. Pure.
+ *
+ * Only meaningful for the viewer's own settled text messages (the caller gates that). For a DM the
+ * peer's own cursors decide it exactly. For a group it is "read"/"delivered" only when ALL other
+ * members have reached the message's sequence (a member with no cursor counts as 0); with no other
+ * members it stays "sent".
+ */
+export declare const tickState: (message: ChatMessage, ctx: TickContext) => TickState;
+//# sourceMappingURL=tick-state.d.ts.map

package/types/features/chat/presentation/tick-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tick-state.d.ts","sourceRoot":"","sources":["../../../../../../src/features/chat/presentation/tick-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAErD,+FAA+F;AAC/F,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,CAAC;AAEtD,mGAAmG;AACnG,MAAM,WAAW,WAAW;IAC1B,2FAA2F;IAC3F,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,qFAAqF;IACrF,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,+EAA+E;IAC/E,QAAQ,CAAC,QAAQ,EAAE,oBAAoB,CAAC;CACzC;AA2CD;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,GAAI,SAAS,WAAW,EAAE,KAAK,WAAW,KAAG,SAKlE,CAAC"}

package/types/features/chat/presentation/unread-chat-count.d.ts

@@ -0,0 +1,14 @@
+import type { Conversation } from '../domain';
+/**
+ * Total unread messages across active (non-archived) conversations. Pure, unit-testable helper kept for
+ * reuse where a full conversation list is on hand; the shell badge now reads the server count directly.
+ */
+export declare const sumUnread: (conversations: readonly Conversation[]) => number;
+/**
+ * Single source of truth for the "unread chats" badge shared by the top bar and the sidebar — the number
+ * of conversations with unread messages, read from the SERVER's exact count (accurate regardless of how
+ * many list pages are loaded). Resilient by design: while loading / errored it returns 0, so the badge
+ * simply stays hidden and never crashes the shell.
+ */
+export declare const useUnreadChatCount: () => number;
+//# sourceMappingURL=unread-chat-count.d.ts.map

package/types/features/chat/presentation/unread-chat-count.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unread-chat-count.d.ts","sourceRoot":"","sources":["../../../../../../src/features/chat/presentation/unread-chat-count.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAG9C;;;GAGG;AACH,eAAO,MAAM,SAAS,GAAI,eAAe,SAAS,YAAY,EAAE,KAAG,MAKhE,CAAC;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,QAAO,MAGrC,CAAC"}

package/types/features/chat/presentation/use-active-conversation.d.ts

@@ -0,0 +1,32 @@
+import type { ChatMessage, MessageReplyPreview } from '../domain';
+import { useMessages } from './use-chat';
+import { useSendMessage } from './use-send-message';
+import { useSendMediaMessage } from './use-send-media';
+export interface ActiveEditingMessage {
+    readonly id: string;
+    readonly text: string;
+}
+export interface ActiveConversation {
+    readonly messages: ReturnType<typeof useMessages>;
+    readonly send: ReturnType<typeof useSendMessage>;
+    readonly media: ReturnType<typeof useSendMediaMessage>;
+    readonly text: string;
+    readonly setText: (value: string) => void;
+    readonly replyTo: MessageReplyPreview | null;
+    readonly setReplyTo: (preview: MessageReplyPreview | null) => void;
+    readonly editingMessage: ActiveEditingMessage | null;
+    readonly startEdit: (message: ChatMessage) => void;
+    readonly clearEditing: () => void;
+    readonly onReact: (messageId: string, emoji: string) => void;
+    readonly onEdit: (messageId: string, text: string) => void;
+    readonly onDelete: (messageId: string) => void;
+    readonly onDeleteForMe: (messageId: string) => void;
+    readonly submit: () => void;
+    /** Send one or more attachments at once (WhatsApp-style); the caption rides with the first. */
+    readonly onSendMedia: (files: readonly File[], caption: string) => void;
+    readonly onTyping: () => void;
+    /** A send (text or media) is in flight — used to disable the composer's send affordance. */
+    readonly isSending: boolean;
+}
+export declare const useActiveConversation: (conversationId: string) => ActiveConversation;
+//# sourceMappingURL=use-active-conversation.d.ts.map

package/types/features/chat/presentation/use-active-conversation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-active-conversation.d.ts","sourceRoot":"","sources":["../../../../../../src/features/chat/presentation/use-active-conversation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAClE,OAAO,EAIL,WAAW,EAEZ,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAKvD,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,QAAQ,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;IAClD,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;IACjD,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC;IACvD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAC1C,QAAQ,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAC7C,QAAQ,CAAC,UAAU,EAAE,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI,KAAK,IAAI,CAAC;IACnE,QAAQ,CAAC,cAAc,EAAE,oBAAoB,GAAG,IAAI,CAAC;IACrD,QAAQ,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,IAAI,CAAC;IACnD,QAAQ,CAAC,YAAY,EAAE,MAAM,IAAI,CAAC;IAClC,QAAQ,CAAC,OAAO,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7D,QAAQ,CAAC,MAAM,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3D,QAAQ,CAAC,QAAQ,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/C,QAAQ,CAAC,aAAa,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IACpD,QAAQ,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC;IAC5B,+FAA+F;IAC/F,QAAQ,CAAC,WAAW,EAAE,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACxE,QAAQ,CAAC,QAAQ,EAAE,MAAM,IAAI,CAAC;IAC9B,4FAA4F;IAC5F,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC7B;AA2DD,eAAO,MAAM,qBAAqB,GAAI,gBAAgB,MAAM,KAAG,kBAkF9D,CAAC"}

package/types/features/chat/presentation/use-chat-actions.d.ts

@@ -0,0 +1,17 @@
+import type { Conversation } from '../domain';
+/** Conversation-level actions shared by the list rows and the conversation header kebab. */
+export interface ChatActions {
+    readonly toggleFavourite: (conversation: Conversation) => void;
+    readonly togglePin: (conversation: Conversation) => void;
+    readonly toggleArchive: (conversation: Conversation) => void;
+    readonly remove: (id: string) => void;
+    /** Self-service leave a group (the confirmation lives at the call site, like delete). */
+    readonly leave: (conversation: Conversation) => void;
+    readonly refresh: (conversation: Conversation) => void;
+}
+/**
+ * Bundles the conversation mutations with their success toasts so the list and the header issue
+ * identical, consistent feedback. Delete is performed here; its confirmation lives at the call site.
+ */
+export declare const useChatActions: () => ChatActions;
+//# sourceMappingURL=use-chat-actions.d.ts.map

package/types/features/chat/presentation/use-chat-actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-chat-actions.d.ts","sourceRoot":"","sources":["../../../../../../src/features/chat/presentation/use-chat-actions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAU9C,4FAA4F;AAC5F,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,eAAe,EAAE,CAAC,YAAY,EAAE,YAAY,KAAK,IAAI,CAAC;IAC/D,QAAQ,CAAC,SAAS,EAAE,CAAC,YAAY,EAAE,YAAY,KAAK,IAAI,CAAC;IACzD,QAAQ,CAAC,aAAa,EAAE,CAAC,YAAY,EAAE,YAAY,KAAK,IAAI,CAAC;IAC7D,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IACtC,yFAAyF;IACzF,QAAQ,CAAC,KAAK,EAAE,CAAC,YAAY,EAAE,YAAY,KAAK,IAAI,CAAC;IACrD,QAAQ,CAAC,OAAO,EAAE,CAAC,YAAY,EAAE,YAAY,KAAK,IAAI,CAAC;CACxD;AAED;;;GAGG;AACH,eAAO,MAAM,cAAc,QAAO,WA+DjC,CAAC"}

package/types/features/chat/presentation/use-chat-media-src.d.ts

@@ -0,0 +1,15 @@
+export interface ChatMediaSrc {
+    /** A renderable image src, or null while it is still loading. */
+    readonly src: string | null;
+    readonly isLoading: boolean;
+    readonly isError: boolean;
+    /** Fired when the browser cannot decode the resolved src (revoked blob, corrupt bytes, etc.). */
+    readonly onImageError: () => void;
+}
+/**
+ * Resolve a renderable `<img>` src for a media message. An optimistic local `blob:` URL is used as-is;
+ * a server path is fetched through the authenticated gateway (plain `<img src>` cannot send the bearer
+ * token) and exposed as an object URL that is revoked on unmount.
+ */
+export declare const useChatMediaSrc: (mediaUrl: string | null) => ChatMediaSrc;
+//# sourceMappingURL=use-chat-media-src.d.ts.map

package/types/features/chat/presentation/use-chat-media-src.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-chat-media-src.d.ts","sourceRoot":"","sources":["../../../../../../src/features/chat/presentation/use-chat-media-src.ts"],"names":[],"mappings":"AAQA,MAAM,WAAW,YAAY;IAC3B,iEAAiE;IACjE,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,iGAAiG;IACjG,QAAQ,CAAC,YAAY,EAAE,MAAM,IAAI,CAAC;CACnC;AASD;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAAI,UAAU,MAAM,GAAG,IAAI,KAAG,YAwDzD,CAAC"}

package/types/features/chat/presentation/use-chat-module.d.ts

@@ -0,0 +1,4 @@
+import type { ChatModule } from '../chat-module';
+/** Resolve the injected chat use cases. Throws if used outside the provider. */
+export declare const useChatModule: () => ChatModule;
+//# sourceMappingURL=use-chat-module.d.ts.map

package/types/features/chat/presentation/use-chat-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-chat-module.d.ts","sourceRoot":"","sources":["../../../../../../src/features/chat/presentation/use-chat-module.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAGjD,gFAAgF;AAChF,eAAO,MAAM,aAAa,QAAO,UAMhC,CAAC"}

package/types/features/chat/presentation/use-chat-page-state.d.ts

@@ -0,0 +1,24 @@
+import type { Conversation, ConversationScopeCounts } from '../domain';
+import type { ChatTab } from './chat-tabs';
+import { type UseConversationsResult } from './use-chat';
+export interface ChatPageState {
+    /** The scoped, searched, paged conversation list query (loading/error + scroll controls). */
+    readonly conversations: UseConversationsResult;
+    /** Exact per-tab counts for the badges. */
+    readonly counts: ConversationScopeCounts | undefined;
+    /** The current page's conversations (flattened). */
+    readonly list: readonly Conversation[];
+    /** The open conversation id (URL selection, else the first in the list). */
+    readonly activeId: string | null;
+    /** The open conversation — resolved by id (tab-independent), falling back to the list entry. */
+    readonly active: Conversation | undefined;
+    /** True when an explicitly-opened chat can't be loaded (removed / deleted). */
+    readonly lostAccess: boolean;
+}
+/**
+ * Orchestrates the chat page's server state: the scoped+searched conversation page, the exact tab counts,
+ * and the OPEN conversation resolved independently by id (so a chat that isn't on the current tab's first
+ * page — or a deep-link — still opens). Also seeds per-member receipts from the loaded page.
+ */
+export declare const useChatPageState: (tab: ChatTab, search: string, selectedId: string | null) => ChatPageState;
+//# sourceMappingURL=use-chat-page-state.d.ts.map

package/types/features/chat/presentation/use-chat-page-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-chat-page-state.d.ts","sourceRoot":"","sources":["../../../../../../src/features/chat/presentation/use-chat-page-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AACvE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EACL,KAAK,sBAAsB,EAI5B,MAAM,YAAY,CAAC;AAKpB,MAAM,WAAW,aAAa;IAC5B,6FAA6F;IAC7F,QAAQ,CAAC,aAAa,EAAE,sBAAsB,CAAC;IAC/C,2CAA2C;IAC3C,QAAQ,CAAC,MAAM,EAAE,uBAAuB,GAAG,SAAS,CAAC;IACrD,oDAAoD;IACpD,QAAQ,CAAC,IAAI,EAAE,SAAS,YAAY,EAAE,CAAC;IACvC,4EAA4E;IAC5E,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,gGAAgG;IAChG,QAAQ,CAAC,MAAM,EAAE,YAAY,GAAG,SAAS,CAAC;IAC1C,+EAA+E;IAC/E,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;CAC9B;AAED;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAC3B,KAAK,OAAO,EACZ,QAAQ,MAAM,EACd,YAAY,MAAM,GAAG,IAAI,KACxB,aAsBF,CAAC"}

package/types/features/chat/presentation/use-chat.d.ts

@@ -0,0 +1,86 @@
+import { type UseMutationResult, type UseQueryResult } from '@tanstack/react-query';
+import type { ChatMessage, ChatViewer, Conversation, ConversationMember } from '../domain';
+export * from './use-conversations';
+/**
+ * Which roster a picker queries: the full staff directory (DM start), or the viewer's group member
+ * pool (group create / add members — hierarchy-scoped server-side when the feature is on).
+ */
+export type StaffSource = 'directory' | 'groupPool';
+/** Keyed by source + search term so each roster/typeahead query is cached independently. */
+export declare const staffQueryKey: (search?: string, source?: StaffSource) => readonly unknown[];
+export declare const viewerQueryKey: readonly ["chat", "viewer"];
+export declare const messagesQueryKey: (conversationId: string) => readonly unknown[];
+/** The picker roster for `source`; `search` runs a server-side typeahead over name + role. */
+export declare const useChatStaff: (search?: string, source?: StaffSource) => UseQueryResult<readonly ConversationMember[]>;
+export declare const useChatViewer: () => UseQueryResult<ChatViewer>;
+export declare const useMessages: (conversationId: string | null) => UseQueryResult<readonly ChatMessage[]>;
+/** `{ id, value }` for the boolean conversation toggles (favourite / archive / pin). */
+export interface ToggleVars {
+    readonly id: string;
+    readonly value: boolean;
+}
+export declare const useSetFavourite: () => UseMutationResult<void, Error, ToggleVars>;
+export declare const useSetArchived: () => UseMutationResult<void, Error, ToggleVars>;
+export declare const useSetPinned: () => UseMutationResult<void, Error, ToggleVars>;
+export declare const useDeleteConversation: () => UseMutationResult<void, Error, string>;
+/** Self-service leave a group → refresh the list (the viewer is no longer a member, so it drops off). */
+export declare const useLeaveConversation: () => UseMutationResult<void, Error, string>;
+export declare const useRefreshPortal: () => UseMutationResult<void, Error, string>;
+export interface SaveMembersVars {
+    readonly members: readonly ConversationMember[];
+    readonly adminIds: readonly string[];
+}
+/** Save a group's members/admins → refresh the list AND the open thread (system messages land there). */
+export declare const useSaveMembers: (conversationId: string) => UseMutationResult<void, Error, SaveMembersVars>;
+export { useMarkRead } from './use-mark-read';
+/**
+ * Start (or find) a DM with another staff member. On success the conversation list is refreshed so
+ * the new/existing conversation appears; the returned `Conversation` lets the caller open it.
+ */
+export declare const useStartDirect: () => UseMutationResult<Conversation, Error, string>;
+/** `{ title, memberIds }` for creating a group conversation. */
+export interface CreateGroupVars {
+    readonly title: string;
+    readonly memberIds: readonly string[];
+}
+/**
+ * Create a group conversation. On success the conversation list is refreshed; the returned
+ * `Conversation` lets the caller open the new group.
+ */
+export declare const useCreateGroup: () => UseMutationResult<Conversation, Error, CreateGroupVars>;
+/**
+ * Reaction picker on a message. Applies the toggle OPTIMISTICALLY to the cached thread (the actor's
+ * own client is the source of truth for their reaction — the realtime `ReactionToggled` echo skips the
+ * actor to avoid double-counting). A thread `invalidateQueries` is deliberately NOT used: the thread is
+ * a flat "latest N + scrolled-older" array, so a refetch would discard every older page the user loaded.
+ */
+export declare const useReactToMessage: (conversationId: string) => UseMutationResult<void, Error, {
+    readonly messageId: string;
+    readonly emoji: string;
+}, {
+    readonly previous: readonly ChatMessage[] | undefined;
+}>;
+/**
+ * Edit a message. The use case RETURNS the updated message, so the thread is patched in place with
+ * `setQueryData` (mirroring the realtime `MessageEdited` handler). No thread refetch — it would collapse
+ * the loaded pagination history back to the latest page.
+ */
+export declare const useEditMessage: (conversationId: string) => UseMutationResult<ChatMessage, Error, {
+    readonly messageId: string;
+    readonly text: string;
+}>;
+/**
+ * Delete a message for everyone. The single cached entry is replaced with its tombstone via
+ * `setQueryData` (other clients get the same via the realtime `MessageDeleted` handler). No thread
+ * refetch — it would truncate the loaded history.
+ */
+export declare const useDeleteMessage: (conversationId: string) => UseMutationResult<void, Error, string>;
+/**
+ * "Delete for me": persists the hide server-side (cross-device). The instant, in-session removal is
+ * handled entirely by the local hidden-messages store ([[use-hidden-messages]]), which overlays the
+ * cached thread — so no thread refetch is needed (and one would truncate the loaded history). The
+ * server-side filter takes effect on the next natural full load. Best-effort — a failure leaves the
+ * local hide in place.
+ */
+export declare const useDeleteMessageForMe: (conversationId: string) => UseMutationResult<void, Error, string>;
+//# sourceMappingURL=use-chat.d.ts.map

package/types/features/chat/presentation/use-chat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-chat.d.ts","sourceRoot":"","sources":["../../../../../../src/features/chat/presentation/use-chat.ts"],"names":[],"mappings":"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"}

package/types/features/chat/presentation/use-conversation-confirm.d.ts

@@ -0,0 +1,19 @@
+import type { NavigateFunction } from 'react-router-dom';
+import type { Conversation } from '../domain';
+import type { ChatActions } from './use-chat-actions';
+export interface ConversationConfirm {
+    readonly pendingDelete: Conversation | null;
+    readonly pendingLeave: Conversation | null;
+    readonly requestDelete: (conversation: Conversation) => void;
+    readonly requestLeave: (conversation: Conversation) => void;
+    readonly confirmDelete: () => void;
+    readonly confirmLeave: () => void;
+    readonly cancelDelete: () => void;
+    readonly cancelLeave: () => void;
+}
+/**
+ * Owns the delete-chat / leave-group confirmation state + handlers. On confirm it runs the action and, if
+ * the affected chat was the one open, navigates back to the chats root.
+ */
+export declare const useConversationConfirm: (actions: ChatActions, selectedId: string | null, navigate: NavigateFunction) => ConversationConfirm;
+//# sourceMappingURL=use-conversation-confirm.d.ts.map

package/types/features/chat/presentation/use-conversation-confirm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-conversation-confirm.d.ts","sourceRoot":"","sources":["../../../../../../src/features/chat/presentation/use-conversation-confirm.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAItD,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,aAAa,EAAE,YAAY,GAAG,IAAI,CAAC;IAC5C,QAAQ,CAAC,YAAY,EAAE,YAAY,GAAG,IAAI,CAAC;IAC3C,QAAQ,CAAC,aAAa,EAAE,CAAC,YAAY,EAAE,YAAY,KAAK,IAAI,CAAC;IAC7D,QAAQ,CAAC,YAAY,EAAE,CAAC,YAAY,EAAE,YAAY,KAAK,IAAI,CAAC;IAC5D,QAAQ,CAAC,aAAa,EAAE,MAAM,IAAI,CAAC;IACnC,QAAQ,CAAC,YAAY,EAAE,MAAM,IAAI,CAAC;IAClC,QAAQ,CAAC,YAAY,EAAE,MAAM,IAAI,CAAC;IAClC,QAAQ,CAAC,WAAW,EAAE,MAAM,IAAI,CAAC;CAClC;AAED;;;GAGG;AACH,eAAO,MAAM,sBAAsB,GACjC,SAAS,WAAW,EACpB,YAAY,MAAM,GAAG,IAAI,EACzB,UAAU,gBAAgB,KACzB,mBA8BF,CAAC"}

package/types/features/chat/presentation/use-conversations.d.ts

@@ -0,0 +1,69 @@
+import { type QueryClient, type UseQueryResult } from '@tanstack/react-query';
+import type { Conversation, ConversationScope, ConversationScopeCounts } from '../domain';
+/** Prefix for every conversation-LIST query (all scope/search variants) — used to invalidate them all. */
+export declare const conversationsQueryKey: readonly ["chat", "conversations"];
+/** The exact per-tab badge counts. */
+export declare const conversationCountsQueryKey: readonly ["chat", "conversation-counts"];
+/** A single conversation by id (the open pane / deep-link). */
+export declare const conversationQueryKey: (conversationId: string) => readonly unknown[];
+/**
+ * The conversation list, filtered (tab + search) and paged SERVER-SIDE for WhatsApp/Facebook-style
+ * infinite scroll. `data` is the flattened list across every loaded page; `fetchNextPage` pulls the next
+ * slice when the viewer nears the bottom (and `hasNextPage` says more remain on the server).
+ */
+export interface UseConversationsResult {
+    readonly data: readonly Conversation[] | undefined;
+    readonly isPending: boolean;
+    readonly isSuccess: boolean;
+    readonly error: Error | null;
+    readonly hasNextPage: boolean;
+    readonly isFetchingNextPage: boolean;
+    readonly fetchNextPage: () => void;
+}
+export declare const useConversations: (scope: ConversationScope, search: string) => UseConversationsResult;
+/** Exact per-tab conversation counts for the chat badges (server-computed). */
+export declare const useConversationCounts: () => UseQueryResult<ConversationScopeCounts>;
+/**
+ * A single conversation by id for the OPEN pane — resolved independently of the current tab/page so a chat
+ * that isn't on this tab's first page (or a deep-link) still opens. On error (removed / deleted) the query
+ * fails fast (no retry) so the UI can show "you no longer have access".
+ *
+ * The list already returns fully-hydrated conversations, so opening one that is visible in the list seeds
+ * this query from the list cache via `initialData` (carrying the list's fetch time). While that seed is
+ * still fresh (staleTime), the pane paints instantly and issues NO extra request; the network fetch is
+ * reserved for the off-page / deep-link case, or for revalidation once the seed goes stale.
+ */
+export declare const useConversation: (conversationId: string | null) => UseQueryResult<Conversation>;
+/**
+ * Refresh the conversation-LIST-derived views: the scoped lists (all tab/search variants) and the exact tab
+ * badges. Use this on the hot paths — an inbound/sent message or a receipt only changes a conversation's
+ * last-message preview and unread count, both of which live on the list + counts. It deliberately does NOT
+ * touch the single-conversation entity queries, so a busy thread does not fan a refetch out across every
+ * open pane.
+ */
+export declare const invalidateConversationLists: (queryClient: QueryClient) => void;
+/**
+ * Refresh every conversation-derived view, including the single-conversation entity queries. Reserved for
+ * STRUCTURAL changes — members saved, portal refreshed, conversation started/created/left/deleted — where
+ * the conversation entity itself (not just its last message) changed.
+ */
+export declare const invalidateConversationViews: (queryClient: QueryClient) => void;
+/**
+ * Refresh conversation lists and single-entity queries for ACTOR-INITIATED structural changes
+ * (e.g. saving group members) WITHOUT invalidating the counts query.
+ *
+ * When the signed-in viewer is the one making a structural change (adding/removing members, etc.)
+ * the system message that lands in the thread is immediately acknowledged by `useMarkReadOnView`.
+ * Invalidating the counts query before that acknowledgement fires causes a brief badge flash
+ * (counts refetches → returns 1 unread → markRead fires → back to 0). Skipping the counts
+ * invalidation here removes that flash entirely, while the list and entity queries still update
+ * correctly so member changes are reflected immediately in the UI.
+ */
+export declare const invalidateConversationStructure: (queryClient: QueryClient) => void;
+/**
+ * Update a conversation's properties directly in all cached conversation lists (all tabs/searches).
+ * This provides instant UI updates for simple toggles (like favourite, pinned, archived) without waiting
+ * for network refetches.
+ */
+export declare const updateConversationInCache: (queryClient: QueryClient, conversationId: string, update: (conversation: Conversation) => Conversation) => void;
+//# sourceMappingURL=use-conversations.d.ts.map

package/types/features/chat/presentation/use-conversations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-conversations.d.ts","sourceRoot":"","sources":["../../../../../../src/features/chat/presentation/use-conversations.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,WAAW,EAChB,KAAK,cAAc,EACpB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,KAAK,EACV,YAAY,EAEZ,iBAAiB,EACjB,uBAAuB,EACxB,MAAM,WAAW,CAAC;AAGnB,0GAA0G;AAC1G,eAAO,MAAM,qBAAqB,oCAAqC,CAAC;AAExE,sCAAsC;AACtC,eAAO,MAAM,0BAA0B,0CAA2C,CAAC;AAEnF,+DAA+D;AAC/D,eAAO,MAAM,oBAAoB,GAAI,gBAAgB,MAAM,KAAG,SAAS,OAAO,EAI7E,CAAC;AAKF;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,IAAI,EAAE,SAAS,YAAY,EAAE,GAAG,SAAS,CAAC;IACnD,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,kBAAkB,EAAE,OAAO,CAAC;IACrC,QAAQ,CAAC,aAAa,EAAE,MAAM,IAAI,CAAC;CACpC;AAED,eAAO,MAAM,gBAAgB,GAC3B,OAAO,iBAAiB,EACxB,QAAQ,MAAM,KACb,sBAgCF,CAAC;AAEF,+EAA+E;AAC/E,eAAO,MAAM,qBAAqB,QAAO,cAAc,CAAC,uBAAuB,CAM9E,CAAC;AAyBF;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,GAC1B,gBAAgB,MAAM,GAAG,IAAI,KAC5B,cAAc,CAAC,YAAY,CAkB7B,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,GAAI,aAAa,WAAW,KAAG,IAMtE,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,GAAI,aAAa,WAAW,KAAG,IAGtE,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,+BAA+B,GAAI,aAAa,WAAW,KAAG,IAM1E,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,GACpC,aAAa,WAAW,EACxB,gBAAgB,MAAM,EACtB,QAAQ,CAAC,YAAY,EAAE,YAAY,KAAK,YAAY,KACnD,IAmBF,CAAC"}

package/types/features/chat/presentation/use-debounced-value.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns `value` delayed by `delayMs`, collapsing rapid changes into the last one. Used to throttle a
+ * search box so a server-side typeahead fires once the user pauses, not on every keystroke.
+ */
+export declare const useDebouncedValue: <T>(value: T, delayMs: number) => T;
+//# sourceMappingURL=use-debounced-value.d.ts.map

package/types/features/chat/presentation/use-debounced-value.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-debounced-value.d.ts","sourceRoot":"","sources":["../../../../../../src/features/chat/presentation/use-debounced-value.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAAI,CAAC,EAAE,OAAO,CAAC,EAAE,SAAS,MAAM,KAAG,CAahE,CAAC"}

package/types/features/chat/presentation/use-hidden-messages.d.ts

@@ -0,0 +1,14 @@
+interface HiddenMessagesState {
+    /** Message ids the viewer has "deleted for me" — hidden locally, persisted per browser. */
+    readonly hidden: ReadonlySet<string>;
+    readonly hideForMe: (messageId: string) => void;
+}
+/**
+ * Per-browser "delete for me" state. WhatsApp's delete-for-me removes a message only on the viewer's
+ * side; with no backend per-user delete, we persist the hidden ids in localStorage and filter them
+ * out of the thread. (Cross-device sync would need a backend "hidden messages" store — see
+ * `delete-message`.) "Delete for everyone" still goes through the gateway.
+ */
+export declare const useHiddenMessages: import("zustand").UseBoundStore<import("zustand").StoreApi<HiddenMessagesState>>;
+export {};
+//# sourceMappingURL=use-hidden-messages.d.ts.map

package/types/features/chat/presentation/use-hidden-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-hidden-messages.d.ts","sourceRoot":"","sources":["../../../../../../src/features/chat/presentation/use-hidden-messages.ts"],"names":[],"mappings":"AAGA,UAAU,mBAAmB;IAC3B,2FAA2F;IAC3F,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACrC,QAAQ,CAAC,SAAS,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;CACjD;AAED;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,kFAW3B,CAAC"}

package/types/features/chat/presentation/use-infinite-scroll.d.ts

@@ -0,0 +1,19 @@
+import { type RefObject } from 'react';
+export interface InfiniteScrollOptions {
+    readonly hasNextPage: boolean;
+    readonly isFetchingNextPage: boolean;
+    readonly onLoadMore: () => void;
+}
+export interface InfiniteScrollRefs {
+    /** Attach to the scroll container (the intersection root). */
+    readonly rootRef: RefObject<HTMLDivElement>;
+    /** Attach to a small element rendered just past the last row. */
+    readonly sentinelRef: RefObject<HTMLDivElement>;
+}
+/**
+ * WhatsApp/Facebook-style infinite scroll: loads the next page as soon as a sentinel near the bottom of
+ * the scroll container comes into view. Also auto-fills a short list — if the sentinel is still visible
+ * after a page lands, the next effect run loads again until it scrolls out or the server runs dry.
+ */
+export declare const useInfiniteScroll: ({ hasNextPage, isFetchingNextPage, onLoadMore, }: InfiniteScrollOptions) => InfiniteScrollRefs;
+//# sourceMappingURL=use-infinite-scroll.d.ts.map

package/types/features/chat/presentation/use-infinite-scroll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-infinite-scroll.d.ts","sourceRoot":"","sources":["../../../../../../src/features/chat/presentation/use-infinite-scroll.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAqB,MAAM,OAAO,CAAC;AAE1D,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,kBAAkB,EAAE,OAAO,CAAC;IACrC,QAAQ,CAAC,UAAU,EAAE,MAAM,IAAI,CAAC;CACjC;AAED,MAAM,WAAW,kBAAkB;IACjC,8DAA8D;IAC9D,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC,cAAc,CAAC,CAAC;IAC5C,iEAAiE;IACjE,QAAQ,CAAC,WAAW,EAAE,SAAS,CAAC,cAAc,CAAC,CAAC;CACjD;AAED;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,kDAI/B,qBAAqB,KAAG,kBA0B1B,CAAC"}

package/types/features/chat/presentation/use-load-older-messages.d.ts

@@ -0,0 +1,17 @@
+/** What the message thread needs to drive its "load older" affordance. */
+export interface LoadOlderController {
+    /** Fetch the next older page and prepend it to the thread cache. Safe to call repeatedly. */
+    readonly loadOlder: () => void;
+    /** False once a page returns fewer than `PAGE_SIZE` rows (the start of history is reached). */
+    readonly hasMore: boolean;
+    /** True while a page is in flight (drives the spinner/disabled state on the trigger). */
+    readonly isLoadingOlder: boolean;
+}
+/**
+ * Backward pagination for one conversation. Reads the cached thread's lowest sequence as the cursor,
+ * fetches the page before it, and prepends the (ascending) result via `prependOlderMessages`. Tracks
+ * `hasMore`/`isLoadingOlder` locally and resets both when the conversation changes. The component is
+ * responsible for preserving scroll position around the prepend.
+ */
+export declare const useLoadOlderMessages: (conversationId: string | null) => LoadOlderController;
+//# sourceMappingURL=use-load-older-messages.d.ts.map

package/types/features/chat/presentation/use-load-older-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-load-older-messages.d.ts","sourceRoot":"","sources":["../../../../../../src/features/chat/presentation/use-load-older-messages.ts"],"names":[],"mappings":"AAYA,0EAA0E;AAC1E,MAAM,WAAW,mBAAmB;IAClC,6FAA6F;IAC7F,QAAQ,CAAC,SAAS,EAAE,MAAM,IAAI,CAAC;IAC/B,+FAA+F;IAC/F,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,yFAAyF;IACzF,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;CAClC;AAED;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAC/B,gBAAgB,MAAM,GAAG,IAAI,KAC5B,mBA6CF,CAAC"}

package/types/features/chat/presentation/use-mark-read-on-view.d.ts

@@ -0,0 +1,13 @@
+import type { ChatMessage } from '../domain';
+/**
+ * Fire OUR read receipt for the active conversation as its thread grows. Guarded so it only sends when
+ * the highest seen sequence actually increases (per conversation), which covers both opening a thread
+ * and each new inbound message while it is open. Best-effort — the conversation id resets the cursor so
+ * switching chats re-acknowledges the new thread.
+ *
+ * Only <c>mark-read</c> is called (not a parallel <c>mark-delivered</c>): on the server,
+ * <c>MarkRead</c> also drags the delivered pointer forward, and firing both at once raced on the same
+ * conversation <c>ConcurrencyStamp</c> → HTTP 409.
+ */
+export declare const useMarkReadOnView: (conversationId: string | null, messages: readonly ChatMessage[] | undefined) => void;
+//# sourceMappingURL=use-mark-read-on-view.d.ts.map

package/types/features/chat/presentation/use-mark-read-on-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-mark-read-on-view.d.ts","sourceRoot":"","sources":["../../../../../../src/features/chat/presentation/use-mark-read-on-view.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAI7C;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,GAC5B,gBAAgB,MAAM,GAAG,IAAI,EAC7B,UAAU,SAAS,WAAW,EAAE,GAAG,SAAS,KAC3C,IA4BF,CAAC"}

package/types/features/chat/presentation/use-mark-read.d.ts

@@ -0,0 +1,13 @@
+import { type UseMutationResult } from '@tanstack/react-query';
+interface MarkReadVars {
+    readonly conversationId: string;
+    readonly uptoSequence: number;
+}
+/**
+ * Fire OUR read receipt for a conversation up to a sequence cursor (fans out to others over the hub
+ * backend). Performs production-grade optimistic updates to clear unread counts immediately in the
+ * cache, rolling back on error and refetching on settle.
+ */
+export declare const useMarkRead: () => UseMutationResult<void, Error, MarkReadVars>;
+export {};
+//# sourceMappingURL=use-mark-read.d.ts.map

package/types/features/chat/presentation/use-mark-read.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-mark-read.d.ts","sourceRoot":"","sources":["../../../../../../src/features/chat/presentation/use-mark-read.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,iBAAiB,EAGvB,MAAM,uBAAuB,CAAC;AA2C/B,UAAU,YAAY;IACpB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAqJD;;;;GAIG;AACH,eAAO,MAAM,WAAW,QAAO,iBAAiB,CAAC,IAAI,EAAE,KAAK,EAAE,YAAY,CAoBzE,CAAC"}

package/types/features/chat/presentation/use-media-viewer.d.ts

@@ -0,0 +1,20 @@
+interface MediaViewerState {
+    /** Whether the full-screen image preview is open. */
+    readonly open: boolean;
+    /** The image paths the viewer pages through (a single image, or an album sent together). */
+    readonly urls: readonly string[];
+    /** The index within `urls` currently shown. */
+    readonly index: number;
+    readonly openViewer: (urls: readonly string[], index: number) => void;
+    readonly close: () => void;
+    readonly next: () => void;
+    readonly prev: () => void;
+}
+/**
+ * Client-only state for the chat image lightbox: which album is open and the active index. A single
+ * module store (like the "delete for me" store) lets a deeply-nested thumbnail open the preview without
+ * prop-drilling a handler up through the album → bubble → thread tree.
+ */
+export declare const useMediaViewer: import("zustand").UseBoundStore<import("zustand").StoreApi<MediaViewerState>>;
+export {};
+//# sourceMappingURL=use-media-viewer.d.ts.map

package/types/features/chat/presentation/use-media-viewer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-media-viewer.d.ts","sourceRoot":"","sources":["../../../../../../src/features/chat/presentation/use-media-viewer.ts"],"names":[],"mappings":"AAEA,UAAU,gBAAgB;IACxB,qDAAqD;IACrD,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,4FAA4F;IAC5F,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,+CAA+C;IAC/C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACtE,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,IAAI,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,IAAI,CAAC;CAC3B;AAED;;;;GAIG;AACH,eAAO,MAAM,cAAc,+EAmBxB,CAAC"}

package/types/features/chat/presentation/use-member-draft.d.ts

@@ -0,0 +1,18 @@
+import type { Conversation, ConversationMember } from '../domain';
+import { type MemberDiff } from './manage-members';
+export interface MemberDraft {
+    readonly members: readonly ConversationMember[];
+    readonly adminIds: readonly string[];
+    readonly adding: boolean;
+    readonly diff: MemberDiff;
+    readonly adminCount: number;
+    readonly setAdding: (value: boolean) => void;
+    readonly addMember: (member: ConversationMember) => void;
+    readonly removeMember: (id: string) => void;
+    readonly makeAdmin: (id: string) => void;
+    readonly removeAdmin: (id: string) => void;
+    readonly undoRemove: (member: ConversationMember) => void;
+}
+/** Local, uncommitted member/admin draft for the Manage-members modal (reset whenever it opens). */
+export declare const useMemberDraft: (conversation: Conversation, open: boolean) => MemberDraft;
+//# sourceMappingURL=use-member-draft.d.ts.map

package/types/features/chat/presentation/use-member-draft.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-member-draft.d.ts","sourceRoot":"","sources":["../../../../../../src/features/chat/presentation/use-member-draft.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAClE,OAAO,EAAE,KAAK,UAAU,EAAc,MAAM,kBAAkB,CAAC;AAE/D,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,OAAO,EAAE,SAAS,kBAAkB,EAAE,CAAC;IAChD,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IAC7C,QAAQ,CAAC,SAAS,EAAE,CAAC,MAAM,EAAE,kBAAkB,KAAK,IAAI,CAAC;IACzD,QAAQ,CAAC,YAAY,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5C,QAAQ,CAAC,SAAS,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IACzC,QAAQ,CAAC,WAAW,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3C,QAAQ,CAAC,UAAU,EAAE,CAAC,MAAM,EAAE,kBAAkB,KAAK,IAAI,CAAC;CAC3D;AAED,oGAAoG;AACpG,eAAO,MAAM,cAAc,GACzB,cAAc,YAAY,EAC1B,MAAM,OAAO,KACZ,WA2CF,CAAC"}

package/types/features/chat/presentation/use-message-delete.d.ts

@@ -0,0 +1,17 @@
+import type { Clock } from '@core/time';
+import type { ChatMessage } from '../domain';
+import type { DeleteMessageDialogProps } from './DeleteMessageDialog';
+export interface MessageDelete {
+    /** Open the delete dialog for a message (call from the thread's delete affordance). */
+    readonly requestDelete: (messageId: string) => void;
+    /** Spread onto `<DeleteMessageDialog />`. */
+    readonly dialogProps: DeleteMessageDialogProps;
+}
+/**
+ * Owns the WhatsApp-style delete flow: clicking delete opens a dialog rather than deleting outright.
+ * "Delete for everyone" (gateway soft-delete, only while inside the message's window) and "delete for
+ * me" (per-user hide) are supplied as callbacks. Extracted from the pane so the component stays small
+ * and the time-window policy is testable.
+ */
+export declare const useMessageDelete: (messages: readonly ChatMessage[], deleteForEveryone: (messageId: string) => void, deleteForMe: (messageId: string) => void, clock: Clock) => MessageDelete;
+//# sourceMappingURL=use-message-delete.d.ts.map

package/types/features/chat/presentation/use-message-delete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-message-delete.d.ts","sourceRoot":"","sources":["../../../../../../src/features/chat/presentation/use-message-delete.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE,MAAM,WAAW,aAAa;IAC5B,uFAAuF;IACvF,QAAQ,CAAC,aAAa,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IACpD,6CAA6C;IAC7C,QAAQ,CAAC,WAAW,EAAE,wBAAwB,CAAC;CAChD;AAED;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAC3B,UAAU,SAAS,WAAW,EAAE,EAChC,mBAAmB,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,EAC9C,aAAa,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,EACxC,OAAO,KAAK,KACX,aA6BF,CAAC"}

package/types/features/chat/presentation/use-pending-attachments.d.ts

@@ -0,0 +1,20 @@
+/** One queued attachment + its image preview URL (null for non-images, shown as a file chip). */
+export interface PendingAttachment {
+    readonly id: string;
+    readonly file: File;
+    readonly previewUrl: string | null;
+}
+export interface PendingAttachments {
+    readonly items: readonly PendingAttachment[];
+    readonly add: (files: FileList) => void;
+    readonly remove: (id: string) => void;
+    readonly clear: () => void;
+}
+/**
+ * Holds the files queued in the composer's preview tray: validates size + count (toasting what was
+ * dropped via the pure {@link pickAttachableFiles}), builds object-URL thumbnails for images, and
+ * revokes them on remove / clear / unmount so nothing leaks. UI-only state — the bytes are uploaded
+ * by the send pipeline, not held here.
+ */
+export declare const usePendingAttachments: () => PendingAttachments;
+//# sourceMappingURL=use-pending-attachments.d.ts.map

package/types/features/chat/presentation/use-pending-attachments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-pending-attachments.d.ts","sourceRoot":"","sources":["../../../../../../src/features/chat/presentation/use-pending-attachments.ts"],"names":[],"mappings":"AASA,iGAAiG;AACjG,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CACpC;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,KAAK,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAC7C,QAAQ,CAAC,GAAG,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IACtC,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAC;CAC5B;AAED;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,QAAO,kBAoExC,CAAC"}

package/types/features/chat/presentation/use-seed-receipts.d.ts

@@ -0,0 +1,8 @@
+import type { Conversation } from '../domain';
+/**
+ * Seed the realtime store's per-member receipt cursors from each conversation's load-time snapshot.
+ * The seed is a MAX-merge (it never lowers a value), so it is safe to re-run whenever the conversation
+ * list changes — a late snapshot can't clobber a newer live `MessageDelivered`/`MessageRead` event.
+ */
+export declare const useSeedReceipts: (conversations: readonly Conversation[]) => void;
+//# sourceMappingURL=use-seed-receipts.d.ts.map

package/types/features/chat/presentation/use-seed-receipts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-seed-receipts.d.ts","sourceRoot":"","sources":["../../../../../../src/features/chat/presentation/use-seed-receipts.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAG9C;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAAI,eAAe,SAAS,YAAY,EAAE,KAAG,IAQxE,CAAC"}

package/types/features/chat/presentation/use-send-media.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Send a media file with the SAME optimistic UX as a text message: the bubble (the local image +
+ * caption) appears instantly with a sending spinner, then the server echo reconciles it by
+ * `clientMessageId` (swapping the local preview for the stored URL). A failed upload drops the bubble
+ * and toasts (binaries aren't kept for the text-style retry). Multiple files each get their own bubble.
+ */
+export declare const useSendMediaMessage: (conversationId: string) => {
+    readonly sendMedia: (file: File, caption?: string, replyToMessageId?: string | null) => void;
+    readonly isSending: boolean;
+};
+//# sourceMappingURL=use-send-media.d.ts.map