Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/routes/app.$tenant/chat.$id.tsx
T

733 lines
31 KiB
TypeScript

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<Response> {
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<ActionData, "ok" | "intent" | "requestId" | "errorKey"> & Partial<Pick<ActionData, "messageId" | "taskId" | "replayed">>,
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<LoaderData>();
return <ChatChannelDetailController key={`${loaderData.tenantSlug}\u0000${loaderData.currentUserId}\u0000${loaderData.chatId}`} loaderData={loaderData} />;
}
function ChatChannelDetailController({ loaderData }: { readonly loaderData: LoaderData }): React.JSX.Element {
const { t } = useTranslation();
const rootData = useRootData();
const navigate = useNavigate();
const revalidator = useRevalidator();
const olderFetcher = useFetcher<LoaderData>();
const featureFetcher = useFetcher<ActionData>();
const mutationFetcher = useFetcher<ActionData>();
const mentionFetcher = useFetcher<MentionLoaderData>();
const attachmentFetcher = useFetcher<ActionData>();
const taskFetcher = useFetcher<ActionData>();
const readyData = loaderData.vm.status === "ready" ? loaderData.vm.data : null;
const [hydratedMessages, setHydratedMessages] = useState<readonly ChatMessageVM[]>(() => readyData?.messages ?? []);
const [olderHistory, setOlderHistory] = useState<NonNullable<ChatChannelDetailVM["data"]>["history"] | null>(null);
const [featureMutations, setFeatureMutations] = useState<readonly ChatOptimisticFeatureMutation[]>([]);
const [messageMutations, setMessageMutations] = useState<readonly ChatOptimisticMessageMutation[]>([]);
const [composerCaret, setComposerCaret] = useState(0);
const [mentionQuery, setMentionQuery] = useState<ChatMentionQuery | null>(null);
const [mentionActiveIndex, setMentionActiveIndex] = useState(0);
const [selectedMentionLabels, setSelectedMentionLabels] = useState<ReadonlyMap<string, ChatResolvedMentionVM>>(new Map());
const [markingTaskMessageId, setMarkingTaskMessageId] = useState<string | null>(null);
const [attachmentSendAttempt, setAttachmentSendAttempt] = useState<ChatAttachmentSendAttempt | null>(null);
const attachmentAttemptRef = useRef<ChatAttachmentSendAttempt | null>(null);
const handledAttachmentRequestRef = useRef<string | null>(null);
const handledTaskRequestRef = useRef<string | null>(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 (
<ChatChannelDetailPage
vm={vm}
draft={controlledDraft}
focusedMessageId={loaderData.focusMessageId}
mentionAutocomplete={{
vm: mentionVm,
open: mentionQuery !== null,
loading: mentionQuery !== null && (!mentionResponseMatches || mentionFetcher.state !== "idle"),
activeIndex: Math.min(mentionActiveIndex, Math.max(0, mentionItems.length - 1)),
listboxId: "chat-channel-mention-listbox",
}}
actions={{
onBack: () => 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<typeof useNavigate>, 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<ChatChannelDetailVM["data"]>["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<string, ChatMessageVM>();
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 <ServerError />;
}
export const handle = {
moduleKey: CHAT_MODULE_KEY,
breadcrumbKey: "chat.channel.detailTitle",
};