// @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 (
); } 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 (

{title}

· {formatForumTimeAgo(post.timestamp)}
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 ( ); }