733 lines
31 KiB
TypeScript
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",
|
|
};
|