import { useEffect, useMemo, useRef, useState } from "react"; import { type ActionFunctionArgs, type LoaderFunctionArgs, type MetaFunction, useFetcher, useLoaderData, useNavigate, useRevalidator } from "react-router"; import { CatalogError } from "@hivegrid/foundation"; import { extractChatMentions, findChatMentionQuery, insertChatMention, type ChatMentionQuery, type ChatMentionType } from "@hivegrid/realtime"; import { chatMessageIdentityKey, type ChatMentionAutocompleteVM, type ChatMentionSuggestionVM, type ChatChannelDetailVM, type ChatMessageVM, type ChatResolvedMentionVM, type ChatResolvedAuthorVM, } from "@hivegrid/view-models"; import { ChatChannelDetailPage } from "~/components/screens/chat/ChatChannelDetailPage"; import ServerError from "~/components/ui/errors/ServerError"; import { useTranslation } from "react-i18next"; import { getTranslations } from "~/locale/i18next.server"; import { overlayChatChannelDetailRealtime } from "~/modules/chat/client/chatRealtimeViewModel"; import { beginChatFeatureMutation, chatFeatureErrorsByMessageId, failedChatFeatureMutationForMessage, overlayChatChannelFeatureMutations, reconcileChatChannelFeatureMutations, retryChatFeatureMutation, settleChatFeatureMutation, type ChatOptimisticFeatureMutation, type ChatOptimisticFeatureMutationInput, } from "~/modules/chat/client/ChatFeatureOptimistic"; import { overlayChatAttachmentSendAttempt, type ChatAttachmentSendAttempt } from "~/modules/chat/client/chatAttachmentOptimistic"; import { useChatAttachmentUploads } from "~/modules/chat/client/useChatAttachmentUploads"; import { useChatChannelRealtime } from "~/modules/chat/client/useChatChannelRealtime"; import { beginChatMessageMutation, chatMessageMutationErrors, failedChatMessageMutationForMessage, overlayChatMessageMutations, reconcileChatMessageMutations, retryChatMessageMutation, settleChatMessageMutation, type ChatOptimisticMessageMutation, type ChatOptimisticMessageMutationInput, } from "~/modules/chat/client/chatMessageMutationOptimistic"; import { useChatDraft } from "~/modules/chat/client/useChatDraft"; import { loadChatContext } from "~/modules/chat/routes/chatAccess.server"; import { CHAT_MODULE_KEY, chatChannelPath, chatIndexPath, chatThreadPath } from "~/modules/chat/routes/chatRoutePaths"; import { loadMemberChatChannel, sendMemberChatMessage } from "~/modules/chat/services/ChatService.server"; import { changeChatMessagePin, changeChatReaction } from "~/modules/chat/services/ChatMessageFeaturesService.server"; import { markChatMessageAsTask } from "~/modules/chat/services/ChatMessageTaskService.server"; import { editMemberChatMessage, removeMemberChatMessage } from "~/modules/chat/services/ChatMessageMutationsService.server"; import { useRootData } from "~/utils/data/useRootData"; import { loadTasksContext, requireTasksPermission } from "~/utils/integrations/taskAccess.server"; import { validateCSRFToken } from "~/utils/session.server"; type LoaderData = { readonly title: string; readonly tenantSlug: string; readonly currentUserId: string; readonly chatId: string; readonly vm: ChatChannelDetailVM; readonly eventCursor: string; readonly authors: readonly ChatResolvedAuthorVM[]; readonly focusMessageId: string | null; }; type ActionIntent = "reaction" | "pin" | "send_attachment_message" | "mark_task" | "edit_message" | "delete_message"; type ActionData = { readonly ok: boolean; readonly intent: ActionIntent | "invalid"; readonly requestId: string; readonly errorKey: string | null; readonly messageId: string | null; readonly taskId: string | null; readonly replayed: boolean | null; }; type MentionLoaderData = { readonly query: string; readonly type: ChatMentionType | null; readonly vm: ChatMentionAutocompleteVM; }; export const loader = async ({ request, params }: LoaderFunctionArgs) => { const [{ t }, context] = await Promise.all([getTranslations(request), loadChatContext({ request, params })]); const tenantSlug = params.tenant ?? ""; const chatId = params.id ?? ""; const url = new URL(request.url); const beforeMessageCursor = url.searchParams.get("before") ?? undefined; const focusMessageId = beforeMessageCursor ? null : url.searchParams.get("message")?.trim() || null; const result = await loadMemberChatChannel({ context, tenantSlug, chatId, ...(beforeMessageCursor ? { beforeMessageCursor } : {}), ...(focusMessageId ? { focusMessageId } : {}), labels: { directMessage: t("chat.channel.fallback.directMessage"), unnamedGroup: t("chat.channel.fallback.group"), unnamedProject: t("chat.channel.fallback.project"), unknownUser: t("chat.participant.unknown"), unknownMention: t("chat.mention.unknown"), }, }); const channelTitle = result.vm.status === "ready" ? result.vm.data.header.title : t("chat.titleFallback"); return Response.json({ title: `${channelTitle} | ${process.env.APP_NAME}`, tenantSlug, currentUserId: context.userId, chatId, focusMessageId, ...result, } satisfies LoaderData); }; export async function action({ request, params }: ActionFunctionArgs): Promise { const context = await loadChatContext({ request, params }); const formData = await request.formData(); await validateCSRFToken(request, { formData }); const intent = formData.get("intent")?.toString() ?? ""; const chatId = params.id ?? ""; const requestId = formData.get("requestId")?.toString() ?? ""; try { let messageId: string | null = null; let taskId: string | null = null; let replayed: boolean | null = null; if (intent === "reaction") { await changeChatReaction({ context, chatId, requestId, messageId: formData.get("messageId")?.toString() ?? "", emoji: formData.get("emoji")?.toString() ?? "", active: formData.get("active")?.toString() === "true", }); } else if (intent === "pin") { await changeChatMessagePin({ context, chatId, requestId, messageId: formData.get("messageId")?.toString() ?? "", pinned: formData.get("pinned")?.toString() === "true", }); } else if (intent === "send_attachment_message") { const attachmentFileIds = parseAttachmentFileIds(formData.get("attachmentFileIds")); const clientMessageId = formData.get("clientMessageId")?.toString().trim() ?? ""; if (!requestId || !clientMessageId || attachmentFileIds === null || attachmentFileIds.length === 0) { return actionResponse({ ok: false, intent: "send_attachment_message", requestId, errorKey: "chat.errors.invalidInput" }, 400); } const result = await sendMemberChatMessage({ context, chatId, requestId, clientMessageId, body: formData.get("body")?.toString() ?? "", attachmentFileIds, }); messageId = result.message.id; } else if (intent === "mark_task") { const messageToMarkId = formData.get("messageId")?.toString().trim() ?? ""; if (!requestId || !messageToMarkId) { return actionResponse({ ok: false, intent: "mark_task", requestId, errorKey: "chat.errors.invalidInput" }, 400); } const [{ t }, taskContext] = await Promise.all([getTranslations(request), loadTasksContext({ request, params, requireModule: true })]); requireTasksPermission(taskContext, "tasks.write"); const result = await markChatMessageAsTask({ chatContext: context, taskContext, chatId, messageId: messageToMarkId, requestId, tenantSlug: params.tenant ?? "", fallbackTitle: t("chat.task.fallbackTitle"), }); taskId = result.taskId; replayed = result.replayed; } else if (intent === "edit_message") { const result = await editMemberChatMessage({ context, chatId, requestId, messageId: formData.get("messageId")?.toString() ?? "", body: formData.get("body")?.toString() ?? "", }); messageId = result.message.id; replayed = result.replayed; } else if (intent === "delete_message") { const result = await removeMemberChatMessage({ context, chatId, requestId, messageId: formData.get("messageId")?.toString() ?? "", }); messageId = result.messageId; replayed = result.replayed; } else { return actionResponse({ ok: false, intent: "invalid", requestId, errorKey: "chat.errors.invalidInput" }, 400); } return actionResponse({ ok: true, intent: intent as ActionIntent, requestId, errorKey: null, messageId, taskId, replayed }); } catch (error) { if (error instanceof CatalogError) { return actionResponse({ ok: false, intent: isActionIntent(intent) ? intent : "invalid", requestId, errorKey: error.i18nKey }, error.status); } throw error; } } function actionResponse( input: Pick & Partial>, status = 200 ): Response { return Response.json( { ...input, messageId: input.messageId ?? null, taskId: input.taskId ?? null, replayed: input.replayed ?? null, } satisfies ActionData, { status } ); } function isActionIntent(value: string): value is ActionIntent { return ( value === "reaction" || value === "pin" || value === "send_attachment_message" || value === "mark_task" || value === "edit_message" || value === "delete_message" ); } export function parseAttachmentFileIds(value: FormDataEntryValue | null): readonly string[] | null { if (typeof value !== "string") return null; try { const parsed: unknown = JSON.parse(value); if (!Array.isArray(parsed) || parsed.length > 20) return null; const ids = parsed.map((id) => (typeof id === "string" ? id.trim() : "")); if (ids.some((id) => id.length === 0) || new Set(ids).size !== ids.length) return null; return ids; } catch { return null; } } export const meta: MetaFunction = ({ data }) => [{ title: (data as LoaderData | undefined)?.title }]; export default function ChatChannelDetailRoute(): React.JSX.Element { const loaderData = useLoaderData(); return ; } function ChatChannelDetailController({ loaderData }: { readonly loaderData: LoaderData }): React.JSX.Element { const { t } = useTranslation(); const rootData = useRootData(); const navigate = useNavigate(); const revalidator = useRevalidator(); const olderFetcher = useFetcher(); const featureFetcher = useFetcher(); const mutationFetcher = useFetcher(); const mentionFetcher = useFetcher(); const attachmentFetcher = useFetcher(); const taskFetcher = useFetcher(); const readyData = loaderData.vm.status === "ready" ? loaderData.vm.data : null; const [hydratedMessages, setHydratedMessages] = useState(() => readyData?.messages ?? []); const [olderHistory, setOlderHistory] = useState["history"] | null>(null); const [featureMutations, setFeatureMutations] = useState([]); const [messageMutations, setMessageMutations] = useState([]); const [composerCaret, setComposerCaret] = useState(0); const [mentionQuery, setMentionQuery] = useState(null); const [mentionActiveIndex, setMentionActiveIndex] = useState(0); const [selectedMentionLabels, setSelectedMentionLabels] = useState>(new Map()); const [markingTaskMessageId, setMarkingTaskMessageId] = useState(null); const [attachmentSendAttempt, setAttachmentSendAttempt] = useState(null); const attachmentAttemptRef = useRef(null); const handledAttachmentRequestRef = useRef(null); const handledTaskRequestRef = useRef(null); const authorById = useMemo(() => new Map(loaderData.authors.map((author) => [author.userId, author])), [loaderData.authors]); const currentUser = authorById.get(loaderData.currentUserId) ?? fallbackCurrentUser(loaderData.currentUserId, t("chat.participant.unknown")); const attachmentUploads = useChatAttachmentUploads({ tenantSlug: loaderData.tenantSlug, enabled: readyData?.composer.canAttachFiles === true, }); useEffect(() => { if (!readyData) return; setHydratedMessages((current) => mergeHydratedMessages(current, readyData.messages)); }, [readyData]); useEffect(() => { const fetched = olderFetcher.data; const page = fetched?.vm; if (!fetched || !page || page.status !== "ready" || fetched.chatId !== loaderData.chatId) return; setHydratedMessages((current) => mergeHydratedMessages(page.data.messages, current)); setOlderHistory(page.data.history); }, [loaderData.chatId, olderFetcher.data]); const initialMessages = useMemo(() => (readyData ? mergeHydratedMessages(hydratedMessages, readyData.messages) : []), [hydratedMessages, readyData]); const realtime = useChatChannelRealtime({ enabled: readyData !== null, tenantSlug: loaderData.tenantSlug, chatId: loaderData.chatId, initialCursor: loaderData.eventCursor, csrfToken: rootData.csrf ?? null, routing: rootData.routing, initialMessages, currentUser, unknownAuthorLabel: t("chat.participant.unknown"), resolveAuthor: (userId) => authorById.get(userId), revalidate: () => revalidator.revalidate(), }); const draftDeliveries = useMemo( () => realtime.messages.map((message) => ({ clientMessageId: message.clientMessageId, isCurrentUser: message.author?.isCurrentUser ?? false, deliveryState: message.deliveryState, failureReasonKey: message.failureReasonKey, retryable: message.retryable, })), [realtime.messages] ); const chatDraft = useChatDraft({ storageKey: readyData?.composer.draftStorageKey ?? null, deliveries: draftDeliveries, sendMessage: (body, clientMessageId, requestId) => realtime.sendMessage( body, resolvedMentionsForBody(body).map((mention) => ({ type: mention.kind, id: mention.id, label: mention.label })), clientMessageId, requestId ), restoreFailedMessage: realtime.restoreFailedMessage, retryMessage: realtime.retryMessage, updateTyping: realtime.updateTyping, }); const controlledDraft = chatDraft.loaded ? chatDraft.draft : ""; const mentionResponseMatches = mentionQuery !== null && mentionFetcher.data?.query === mentionQuery.query && mentionFetcher.data.type === mentionQuery.kind; const mentionVm = mentionResponseMatches ? (mentionFetcher.data?.vm ?? null) : null; const mentionItems = mentionVm?.groups.flatMap((group) => group.items) ?? []; useEffect(() => { if (readyData?.composer.canMention !== true) { setMentionQuery(null); setMentionActiveIndex(0); return; } const query = findChatMentionQuery(controlledDraft, composerCaret); setMentionQuery(query); setMentionActiveIndex(0); if (!query) return; const timer = window.setTimeout(() => { const search = new URLSearchParams({ q: query.query }); if (query.kind) search.set("type", query.kind); void mentionFetcher.load(`/${encodeURIComponent(loaderData.tenantSlug)}/chat/${encodeURIComponent(loaderData.chatId)}/mentions?${search.toString()}`); }, 200); return () => window.clearTimeout(timer); }, [composerCaret, controlledDraft, loaderData.chatId, loaderData.tenantSlug, readyData?.composer.canMention]); useEffect(() => { const result = attachmentFetcher.data; if ( attachmentFetcher.state !== "idle" || !result || result.intent !== "send_attachment_message" || handledAttachmentRequestRef.current === result.requestId ) { return; } handledAttachmentRequestRef.current = result.requestId; const attempt = attachmentAttemptRef.current; if (!attempt || attempt.requestId !== result.requestId) return; if (!result.ok) { updateAttachmentAttempt({ ...attempt, deliveryState: "failed", errorKey: result.errorKey ?? "chat.message.sendFailed" }); return; } attachmentUploads.clearReady(attempt.fileIds); chatDraft.updateDraft(""); updateAttachmentAttempt(null); revalidator.revalidate(); }, [attachmentFetcher.data, attachmentFetcher.state, attachmentUploads.clearReady, chatDraft.updateDraft, revalidator]); useEffect(() => { const result = taskFetcher.data; if (taskFetcher.state !== "idle" || !result || result.intent !== "mark_task" || handledTaskRequestRef.current === result.requestId) return; handledTaskRequestRef.current = result.requestId; setMarkingTaskMessageId(null); }, [taskFetcher.data, taskFetcher.state]); const loaderVmWithHistory = withOlderHistory(loaderData.vm, olderHistory); const authoritativeVm = overlayChatChannelDetailRealtime(loaderVmWithHistory, { ...realtime, presence: realtime.presence.filter((entry) => entry.userId !== loaderData.currentUserId), }); const vm = overlayChatMessageMutations( overlayChatChannelFeatureMutations(overlayChatAttachmentSendAttempt(authoritativeVm, attachmentSendAttempt, currentUser), featureMutations), messageMutations ); useEffect(() => { setFeatureMutations((current) => reconcileChatChannelFeatureMutations(current, authoritativeVm)); setMessageMutations((current) => reconcileChatMessageMutations(current, authoritativeVm)); }, [authoritativeVm]); useEffect(() => { if (featureFetcher.state !== "idle" || !featureFetcher.data) return; setFeatureMutations((current) => settleChatFeatureMutation(current, featureFetcher.data!.requestId, featureFetcher.data!)); }, [featureFetcher.data, featureFetcher.state]); useEffect(() => { if (mutationFetcher.state !== "idle" || !mutationFetcher.data) return; setMessageMutations((current) => settleChatMessageMutation(current, mutationFetcher.data!)); }, [mutationFetcher.data, mutationFetcher.state]); function submitFeatureMutation(mutation: ChatOptimisticFeatureMutationInput): void { if (featureFetcher.state !== "idle") return; setFeatureMutations((current) => beginChatFeatureMutation(current, mutation)); const formData = new FormData(); formData.set("csrf", rootData.csrf ?? ""); formData.set("intent", mutation.kind); formData.set("requestId", mutation.requestId); formData.set("messageId", mutation.messageId); if (mutation.kind === "reaction") { formData.set("emoji", mutation.emoji); formData.set("active", String(mutation.active)); } else { formData.set("pinned", String(mutation.pinned)); } void featureFetcher.submit(formData, { method: "post" }); } function beginFeatureMutation( input: | { readonly kind: "reaction"; readonly messageId: string; readonly emoji: string; readonly active: boolean } | { readonly kind: "pin"; readonly messageId: string; readonly pinned: boolean } ): void { submitFeatureMutation({ ...input, requestId: crypto.randomUUID(), actorLabel: currentUser.displayName, startedAtIso: new Date().toISOString(), } as ChatOptimisticFeatureMutationInput); } function retryFeatureMutation(messageId: string): void { const messageMutation = failedChatMessageMutationForMessage(messageMutations, messageId); if (messageMutation) { if (mutationFetcher.state !== "idle") return; setMessageMutations((current) => retryChatMessageMutation(current, messageMutation.requestId)); submitMessageMutationForm(messageMutation); return; } if (featureFetcher.state !== "idle") return; const mutation = failedChatFeatureMutationForMessage(featureMutations, messageId); if (!mutation) return; setFeatureMutations((current) => retryChatFeatureMutation(current, mutation.requestId)); submitFeatureMutation(mutation); } function submitMessageMutationForm(mutation: ChatOptimisticMessageMutation): void { const formData = new FormData(); formData.set("csrf", rootData.csrf ?? ""); formData.set("intent", mutation.kind); formData.set("requestId", mutation.requestId); formData.set("messageId", mutation.messageId); if (mutation.kind === "edit_message") formData.set("body", mutation.bodyMarkdown); void mutationFetcher.submit(formData, { method: "post" }); } function submitMessageMutation(mutation: ChatOptimisticMessageMutationInput): void { if (mutationFetcher.state !== "idle") return; setMessageMutations((current) => beginChatMessageMutation(current, mutation)); submitMessageMutationForm({ ...mutation, state: "pending", errorKey: null } as ChatOptimisticMessageMutation); } function resolvedMentionsForBody(body: string): readonly ChatResolvedMentionVM[] { const available = new Map(selectedMentionLabels); if (vm.status === "ready") { for (const message of vm.data.messages) { for (const mention of message.mentions) available.set(`${mention.kind}\u0000${mention.id}`, mention); } } try { return extractChatMentions(body).flatMap((mention) => { const resolved = available.get(`${mention.type}\u0000${mention.id}`); return resolved ? [resolved] : []; }); } catch { return []; } } function selectMention(suggestion: ChatMentionSuggestionVM): number | null { if (!mentionQuery) return null; const inserted = insertChatMention(controlledDraft, mentionQuery, { type: suggestion.kind, id: suggestion.id }); setSelectedMentionLabels((current) => { const next = new Map(current); next.set(`${suggestion.kind}\u0000${suggestion.id}`, { kind: suggestion.kind, id: suggestion.id, label: suggestion.label, href: suggestion.href, }); return next; }); chatDraft.updateDraft(inserted.body); setComposerCaret(inserted.caret); setMentionQuery(null); return inserted.caret; } function handleMentionKeyDown(key: "ArrowDown" | "ArrowUp" | "Enter" | "Escape"): boolean { if (!mentionQuery) return false; if (key === "Escape") { setMentionQuery(null); return true; } if (key === "ArrowDown" || key === "ArrowUp") { if (mentionItems.length === 0) return false; setMentionActiveIndex((current) => key === "ArrowDown" ? (current + 1) % mentionItems.length : (current - 1 + mentionItems.length) % mentionItems.length ); return true; } const selected = mentionItems[mentionActiveIndex]; if (!selected) return false; selectMention(selected); return true; } function updateAttachmentAttempt(attempt: ChatAttachmentSendAttempt | null): void { attachmentAttemptRef.current = attempt; setAttachmentSendAttempt(attempt); } function submitAttachmentAttempt(attempt: ChatAttachmentSendAttempt): void { if (attachmentFetcher.state !== "idle") return; handledAttachmentRequestRef.current = null; const sendingAttempt = { ...attempt, deliveryState: "sending" as const, errorKey: null }; updateAttachmentAttempt(sendingAttempt); const formData = new FormData(); formData.set("csrf", rootData.csrf ?? ""); formData.set("intent", "send_attachment_message"); formData.set("requestId", sendingAttempt.requestId); formData.set("clientMessageId", sendingAttempt.clientMessageId); formData.set("body", sendingAttempt.body); formData.set("attachmentFileIds", JSON.stringify(sendingAttempt.fileIds)); void attachmentFetcher.submit(formData, { method: "post" }); } function sendDraftOrAttachments(bodyMarkdown: string): boolean | void { const readyFileIds = attachmentUploads.attachments.flatMap((attachment) => (attachment.status === "ready" && attachment.fileId ? [attachment.fileId] : [])); if (readyFileIds.length === 0) return chatDraft.sendDraft(bodyMarkdown); if (attachmentFetcher.state !== "idle" || attachmentUploads.attachments.some((attachment) => attachment.status !== "ready")) return false; const body = bodyMarkdown.trim(); const payloadKey = JSON.stringify([body, readyFileIds]); const previous = attachmentAttemptRef.current; const attempt = previous?.payloadKey === payloadKey ? previous : { payloadKey, requestId: crypto.randomUUID(), clientMessageId: crypto.randomUUID(), fileIds: readyFileIds, body, attachments: attachmentUploads.attachments.filter((attachment) => attachment.status === "ready" && attachment.fileId !== null), createdAtIso: new Date().toISOString(), deliveryState: "sending" as const, errorKey: null, }; submitAttachmentAttempt(attempt); return true; } function markMessageAsTask(messageId: string): void { if (taskFetcher.state !== "idle") return; const formData = new FormData(); formData.set("csrf", rootData.csrf ?? ""); formData.set("intent", "mark_task"); formData.set("requestId", crypto.randomUUID()); formData.set("messageId", messageId); setMarkingTaskMessageId(messageId); void taskFetcher.submit(formData, { method: "post" }); } return ( navigateBackToChatList(navigate, chatIndexPath(loaderData.tenantSlug)), onOpenSettings: () => { if (readyData?.header.settingsHref) void navigate(readyData.header.settingsHref); }, onOpenPinned: () => { if (readyData?.header.pinnedHref) void navigate(readyData.header.pinnedHref); }, onOpenThread: (messageId, href) => void navigate(href ?? chatThreadPath(loaderData.tenantSlug, loaderData.chatId, messageId)), onToggleReaction: (messageId, emoji, active) => beginFeatureMutation({ kind: "reaction", messageId, emoji, active }), onTogglePin: (messageId, pinned) => beginFeatureMutation({ kind: "pin", messageId, pinned }), onRetryFeature: retryFeatureMutation, onEditMessage: (messageId, body) => submitMessageMutation({ kind: "edit_message", messageId, bodyMarkdown: body, mentions: resolvedMentionsForBody(body), requestId: crypto.randomUUID(), startedAtIso: new Date().toISOString(), }), onDeleteMessage: (messageId) => submitMessageMutation({ kind: "delete_message", messageId, requestId: crypto.randomUUID(), startedAtIso: new Date().toISOString(), }), onMentionActiveIndexChange: setMentionActiveIndex, onMentionSelect: selectMention, onMentionKeyDown: handleMentionKeyDown, onAddFiles: (files) => attachmentUploads.addFiles(files), onAddPhotos: (files) => attachmentUploads.addFiles(files), onStartRecording: attachmentUploads.startRecording, onStopRecording: attachmentUploads.stopRecording, onCancelRecording: attachmentUploads.cancelRecording, onRetryAttachment: attachmentUploads.retry, onRemoveAttachment: attachmentUploads.remove, onMarkAsTask: markMessageAsTask, onDraftChange: (body, _storageKey, caret) => { chatDraft.updateDraft(body); setComposerCaret(caret); }, onSend: sendDraftOrAttachments, onRetryMessage: (clientMessageId) => { const attachmentAttempt = attachmentAttemptRef.current; if (attachmentAttempt?.clientMessageId === clientMessageId && attachmentAttempt.deliveryState === "failed") { submitAttachmentAttempt(attachmentAttempt); return; } realtime.retryMessage(clientMessageId); }, onDiscardMessage: (clientMessageId) => { if (attachmentAttemptRef.current?.clientMessageId === clientMessageId) { updateAttachmentAttempt(null); return; } chatDraft.discardPendingDraft(clientMessageId); realtime.discardMessage(clientMessageId); }, onMessageVisibilityChange: (messageId, createdAtIso, visible) => { if (messageId.startsWith("local:")) return; if (visible) realtime.beginMessageVisible(messageId, createdAtIso); else realtime.endMessageVisible(messageId); }, onRetryConnection: () => realtime.retryConnection(), onLoadOlder: (cursor) => { const href = `${chatChannelPath(loaderData.tenantSlug, loaderData.chatId)}?before=${encodeURIComponent(cursor)}`; void olderFetcher.load(href); }, }} pendingAttachments={attachmentUploads.attachments} isStartingRecording={attachmentUploads.isStartingRecording} isRecording={attachmentUploads.isRecording} recordingDurationSeconds={attachmentUploads.recordingDurationSeconds} scrollStorageKey={`team-chat:scroll:v1:${loaderData.tenantSlug}:${loaderData.currentUserId}:${loaderData.chatId}`} sending={attachmentFetcher.state !== "idle"} markingTaskMessageId={markingTaskMessageId} actionErrorKey={attachmentUploads.errorKey ?? (taskFetcher.data?.intent === "mark_task" && !taskFetcher.data.ok ? taskFetcher.data.errorKey : null)} actionSuccessKey={taskFetcher.data?.intent === "mark_task" && taskFetcher.data.ok ? "chat.task.created" : null} featureErrorKeys={{ ...chatFeatureErrorsByMessageId(featureMutations), ...chatMessageMutationErrors(messageMutations) }} /> ); } function navigateBackToChatList(navigate: ReturnType, fallbackHref: string): void { const historyIndex = typeof window === "undefined" ? 0 : (window.history.state as { readonly idx?: unknown } | null)?.idx; if (typeof historyIndex === "number" && historyIndex > 0) { navigate(-1); return; } void navigate(fallbackHref); } function withOlderHistory(vm: ChatChannelDetailVM, olderHistory: NonNullable["history"] | null): ChatChannelDetailVM { if (vm.status !== "ready" || olderHistory === null) return vm; return { ...vm, data: { ...vm.data, history: olderHistory, }, }; } function mergeHydratedMessages(older: readonly ChatMessageVM[], newer: readonly ChatMessageVM[]): readonly ChatMessageVM[] { const byKey = new Map(); for (const message of [...older, ...newer]) { byKey.set(chatMessageIdentityKey(message), message); } return [...byKey.values()].sort((left, right) => left.createdAtIso.localeCompare(right.createdAtIso)); } function fallbackCurrentUser(userId: string, label: string): ChatResolvedAuthorVM { return { userId, displayName: label, avatar: { imageUrl: null, fallbackLabel: label.slice(0, 1).toLocaleUpperCase() || "?" }, isCurrentUser: true, }; } export function ErrorBoundary(): React.JSX.Element { return ; } export const handle = { moduleKey: CHAT_MODULE_KEY, breadcrumbKey: "chat.channel.detailTitle", };