// @refresh reset
import {
useCallback,
useEffect,
useMemo,
useRef,
useState,
type MouseEvent,
type ReactNode,
type RefObject,
} from 'react';
import { useAtom, useAtomValue } from 'jotai';
import { Box, Scroll, Spinner, Text, config } from 'folds';
import { RelationType, Room } from 'matrix-js-sdk';
import { ReactEditor } from 'slate-react';
import { useMatrixClient } from '../../hooks/useMatrixClient';
import { usePowerLevels } from '../../hooks/usePowerLevels';
import { useRoomPermissions } from '../../hooks/useRoomPermissions';
import { useRoomCreators } from '../../hooks/useRoomCreators';
import { useImagePackRooms } from '../../hooks/useImagePackRooms';
import { roomToParentsAtom } from '../../state/room/roomToParents';
import { roomIdToReplyDraftAtomFamily } from '../../state/room/roomInputDrafts';
import { canEditEvent, getEditedEvent } from '../../utils/room';
import { MessageEditor } from '../room/message/MessageEditor';
import { Reactions } from '../room/message';
import { formatForumTimeAgo } from './forumTime';
import { loadPostThread, loadPostThreadLocal } from './forumFeed';
import { countAllReplies } from './forumTopicHelpers';
import type { ForumPost } from './types';
import { ForumAuthorIdentity } from './ForumAuthorIdentity';
import { ForumEventContent } from './ForumEventContent';
import { ForumMessageContextMenu } from './ForumMessageContextMenu';
import { ForumMessageActions } from './ForumMessageActions';
import { ForumReplyComposer } from './ForumReplyComposer';
import { useForumMessageReactions } from './useForumMessageReactions';
import { useForumRoomLiveUpdates } from './useForumRoomLiveUpdates';
import { resetEditor, resetEditorHistory, useEditor } from '../../components/editor';
import { mobileOrTablet } from '../../utils/user-agent';
import * as theme from './forumTheme.css';
function forumBranchKey(eventId: string): string {
return `branch:${eventId}`;
}
function forumMessageSurfaceClass(
baseClass: string,
eventId: string,
replyTargetEventId?: string,
): string {
if (replyTargetEventId && replyTargetEventId === eventId) {
return `${baseClass} ${theme.ForumThreadReplyTarget}`;
}
return baseClass;
}
type ForumThreadBranchProps = {
className: string;
railClassName: string;
collapsed: boolean;
hiddenCount: number;
onToggle: () => void;
children: ReactNode;
};
function morePostsLabel(count: number): string {
return `${count} more ${count === 1 ? 'post' : 'posts'}`;
}
function ForumThreadBranch({
className,
railClassName,
collapsed,
hiddenCount,
onToggle,
children,
}: ForumThreadBranchProps) {
const isRootBranch = className === theme.ForumThread;
const handleToggle = (event: MouseEvent) => {
event.stopPropagation();
onToggle();
};
if (collapsed && hiddenCount > 0) {
return (
);
}
return (
{children}
);
}
type ForumThreadMessageProps = {
post: ForumPost;
room: Room;
roomId: string;
threadRootId: string;
fileDropContainerRef: RefObject;
editEventId?: string;
onEditEventId: (eventId?: string) => void;
onComposerSent: () => void;
onDeleted: () => void;
onReplyTo: (eventId: string) => void;
replyTargetEventId?: string;
collapsedBranches: Set;
onToggleBranch: (branchKey: string) => void;
};
function ForumThreadMessage({
post,
room,
roomId,
threadRootId,
fileDropContainerRef,
editEventId,
onEditEventId,
onComposerSent,
onDeleted,
onReplyTo,
replyTargetEventId,
collapsedBranches,
onToggleBranch,
}: ForumThreadMessageProps) {
const mx = useMatrixClient();
const mEvent = room.findEventById(post.eventId);
const isEditing = editEventId === post.eventId;
const branchKey = forumBranchKey(post.eventId);
const replyCount = countAllReplies(post.replies);
const repliesCollapsed = collapsedBranches.has(branchKey);
const powerLevels = usePowerLevels(room);
const creators = useRoomCreators(room);
const permissions = useRoomPermissions(creators, powerLevels);
const roomToParents = useAtomValue(roomToParentsAtom);
const imagePackRooms = useImagePackRooms(roomId, roomToParents);
const canEdit = mEvent ? canEditEvent(mx, mEvent) : false;
const canDelete = mEvent
? permissions.action('redact', mx.getSafeUserId()) || mEvent.getSender() === mx.getUserId()
: false;
const { canSendReaction, reactionRelations, handleReactionToggle } = useForumMessageReactions(
room,
mEvent,
);
const handleDelete = useCallback(() => {
if (!mEvent) return;
const eventId = mEvent.getId();
if (!eventId) return;
mx.redactEvent(roomId, eventId).then(onDeleted);
}, [mEvent, mx, onDeleted, roomId]);
const handleEditClose = useCallback(() => {
onEditEventId(undefined);
onComposerSent();
}, [onComposerSent, onEditEventId]);
return (
onReplyTo(post.eventId)}
onEdit={() => onEditEventId(post.eventId)}
onDeleted={onDeleted}
className={forumMessageSurfaceClass(
theme.ForumThreadReplyInner,
post.eventId,
replyTargetEventId,
)}
>
{post.replyToDeleted && (
Replying to a deleted message
)}
{isEditing && mEvent ? (
) : (
<>
{reactionRelations && (
)}
>
)}
{!isEditing && (
onReplyTo(post.eventId)}
replyActive={replyTargetEventId === post.eventId}
onEdit={() => onEditEventId(post.eventId)}
canEdit={canEdit}
onDelete={handleDelete}
canDelete={canDelete}
/>
)}
{post.replies.length > 0 && (
onToggleBranch(branchKey)}
>
{!repliesCollapsed &&
post.replies.map((child) => (
))}
)}
);
}
type ForumThreadDetailProps = {
roomId: string;
rootEventId: string;
titleHint?: string;
initialPost?: ForumPost | null;
fileDropContainerRef?: RefObject;
onReplySent?: (reply: ForumPost) => void;
};
type ForumThreadDetailBodyProps = Omit & {
post: ForumPost;
room: Room;
onPostUpdate: (post: ForumPost | null) => void;
};
function ForumThreadDetailBody({
roomId,
rootEventId,
titleHint,
post,
room,
fileDropContainerRef,
onReplySent,
onPostUpdate,
}: ForumThreadDetailBodyProps) {
const mx = useMatrixClient();
const editor = useEditor();
const [editEventId, setEditEventId] = useState();
const [replyToEventId, setReplyToEventId] = useState(rootEventId);
const [replyDraft, setReplyDraft] = useAtom(roomIdToReplyDraftAtomFamily(roomId));
const timelineSet = useMemo(() => room.getUnfilteredTimelineSet(), [room]);
useEffect(
() => () => {
resetEditor(editor);
resetEditorHistory(editor);
},
[editor],
);
useEffect(() => {
setReplyToEventId(rootEventId);
setReplyDraft(undefined);
}, [rootEventId, setReplyDraft]);
useEffect(() => {
if (!replyDraft) {
setReplyToEventId(rootEventId);
}
}, [replyDraft, rootEventId]);
const [collapsedBranches, setCollapsedBranches] = useState>(() => new Set());
const localDropRef = useRef(null);
const dropRef = fileDropContainerRef ?? localDropRef;
const powerLevels = usePowerLevels(room);
const creators = useRoomCreators(room);
const permissions = useRoomPermissions(creators, powerLevels);
const roomToParents = useAtomValue(roomToParentsAtom);
const imagePackRooms = useImagePackRooms(roomId, roomToParents);
const reloadThread = useCallback(async () => {
const local = loadPostThreadLocal(mx, roomId, rootEventId);
if (local) onPostUpdate(local);
const loaded = await loadPostThread(mx, roomId, rootEventId);
onPostUpdate(loaded);
return loaded;
}, [mx, onPostUpdate, roomId, rootEventId]);
const handleComposerSent = useCallback(async () => {
const applyLoaded = (loaded: ForumPost | null) => {
if (!loaded) return;
onReplySent?.({
eventId: loaded.eventId,
title: loaded.title,
body: loaded.body,
sender: loaded.sender,
timestamp: Date.now(),
replies: loaded.replies,
});
};
const loaded = await reloadThread();
applyLoaded(loaded);
// Local echo can land slightly after send; refresh once more.
window.setTimeout(() => {
reloadThread().then(applyLoaded);
}, 400);
}, [onReplySent, reloadThread]);
const handleDeleted = useCallback(() => {
handleComposerSent();
}, [handleComposerSent]);
// post is the reactive source: reloadThread pushes the local thread back through onPostUpdate
useForumRoomLiveUpdates([room], reloadThread, { threadRootId: rootEventId, wait: 150 });
const rootEvent = room.findEventById(rootEventId);
const rootEditing = editEventId === rootEventId;
const canEditRoot = rootEvent ? canEditEvent(mx, rootEvent) : false;
const canDeleteRoot = rootEvent
? permissions.action('redact', mx.getSafeUserId()) || rootEvent.getSender() === mx.getUserId()
: false;
const { canSendReaction, reactionRelations, handleReactionToggle } = useForumMessageReactions(
room,
rootEvent,
);
const handleDeleteRoot = useCallback(() => {
if (!rootEvent) return;
const eventId = rootEvent.getId();
if (!eventId) return;
mx.redactEvent(roomId, eventId).then(() => {
handleComposerSent();
});
}, [handleComposerSent, mx, rootEvent, roomId]);
const handleEditRootClose = useCallback(() => {
setEditEventId(undefined);
handleComposerSent();
}, [handleComposerSent]);
const toggleBranch = useCallback((branchKey: string) => {
setCollapsedBranches((prev) => {
const next = new Set(prev);
if (next.has(branchKey)) next.delete(branchKey);
else next.add(branchKey);
return next;
});
}, []);
const handleReplyTo = useCallback(
(eventId: string) => {
const replyEvt = room.findEventById(eventId);
if (!replyEvt) return;
const editedReply = getEditedEvent(eventId, replyEvt, timelineSet);
const content = editedReply?.getContent()['m.new_content'] ?? replyEvt.getContent();
const { body, formatted_body: formattedBody } = content;
const senderId = replyEvt.getSender();
setReplyToEventId(eventId);
if (senderId && typeof body === 'string') {
setReplyDraft({
userId: senderId,
eventId,
body,
formattedBody,
relation: { rel_type: RelationType.Thread, event_id: rootEventId },
});
}
window.setTimeout(() => {
const target = document.querySelector(`[data-event-id="${eventId}"]`);
target?.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
if (!mobileOrTablet()) ReactEditor.focus(editor);
}, 0);
},
[editor, rootEventId, room, setReplyDraft, timelineSet],
);
const rootBranchKey = forumBranchKey(rootEventId);
const rootReplyCount = countAllReplies(post.replies);
const rootRepliesCollapsed = collapsedBranches.has(rootBranchKey);
const replyTargetEventId = replyDraft?.eventId;
const title = useMemo(() => {
const local = loadPostThreadLocal(mx, roomId, rootEventId);
return local?.title || post.title || titleHint || '(untitled post)';
}, [mx, post.title, roomId, rootEventId, titleHint]);
return (
handleReplyTo(post.eventId)}
onEdit={() => setEditEventId(rootEventId)}
onDeleted={handleDeleted}
className={forumMessageSurfaceClass(
theme.ForumTopicDetailOp,
post.eventId,
replyTargetEventId,
)}
>
{rootEditing && rootEvent ? (
) : (
<>
{reactionRelations && (
)}
>
)}
{!rootEditing && (
handleReplyTo(post.eventId)}
replyActive={replyTargetEventId === post.eventId}
onEdit={() => setEditEventId(rootEventId)}
canEdit={canEditRoot}
onDelete={handleDeleteRoot}
canDelete={canDeleteRoot}
/>
)}
{post.replies.length > 0 && (
toggleBranch(rootBranchKey)}
>
{!rootRepliesCollapsed &&
post.replies.map((reply) => (
{
handleComposerSent();
}}
onDeleted={handleDeleted}
onReplyTo={handleReplyTo}
replyTargetEventId={replyTargetEventId}
collapsedBranches={collapsedBranches}
onToggleBranch={toggleBranch}
/>
))}
)}
{
handleComposerSent();
}}
/>
);
}
export function ForumThreadDetail({
roomId,
rootEventId,
titleHint,
initialPost,
fileDropContainerRef,
onReplySent,
}: ForumThreadDetailProps) {
const mx = useMatrixClient();
const [post, setPost] = useState(null);
const [loading, setLoading] = useState(true);
const [error, setError] = useState(null);
const room = mx.getRoom(roomId);
useEffect(() => {
let cancelled = false;
if (initialPost?.eventId === rootEventId) {
setPost(initialPost);
setError(null);
setLoading(false);
return () => {
cancelled = true;
};
}
setLoading(true);
setError(null);
loadPostThread(mx, roomId, rootEventId)
.then((loaded) => {
if (cancelled) return;
setPost(loaded);
if (!loaded) setError('Post not found.');
})
.catch((err) => {
if (!cancelled) {
setError(err instanceof Error ? err.message : 'Could not load this thread.');
}
})
.finally(() => {
if (!cancelled) setLoading(false);
});
return () => {
cancelled = true;
};
}, [mx, roomId, rootEventId, initialPost]);
if (loading) {
return (
Loading…
);
}
if (error || !post || !room) {
return (
{error || 'Post not found.'}
);
}
return (
);
}