initial big refractor, probably broke stuff and forgot stuff but oh well baby steps

This commit is contained in:
7w1 committed 2026-03-18 16:13:22 -05:00
1 parent 21dc9c5b2f
commit 6d60ff7f80
6 files changed
+2452 -2366

No files matched your search

@@ -0,0 +1,78 @@
import { Box, Chip, Spinner, Text, color, config } from 'folds';
import { MessageBase, CompactPlaceholder, DefaultPlaceholder } from '$components/message';
export type PaginationStatus = 'idle' | 'loading' | 'error';
export interface PaginationLoaderProps {
status: PaginationStatus;
direction: 'backward' | 'forward';
isCompact: boolean;
isEmpty: boolean;
onRetry: () => void;
observerRef?: (node: HTMLElement | null) => void;
}
export function PaginationLoader({
status,
direction,
isCompact,
isEmpty,
onRetry,
observerRef,
}: PaginationLoaderProps) {
if (status === 'error') {
return (
<Box
justifyContent="Center"
alignItems="Center"
gap="200"
style={{ padding: config.space.S300 }}
>
<Text style={{ color: color.Critical.Main }} size="T300">
{direction === 'backward' ? 'Failed to load history.' : 'Failed to load messages.'}
</Text>
<Chip variant="SurfaceVariant" radii="Pill" outlined onClick={onRetry}>
<Text size="B300">Retry</Text>
</Chip>
</Box>
);
}
if (isEmpty) {
const count = isCompact ? 5 : 3;
const anchorIndex = direction === 'backward' ? count - 1 : 0;
return (
<>
{[...Array(count)].map((_, i) => {
const attachRef = i === anchorIndex ? observerRef : undefined;
return (
<MessageBase key={i} ref={attachRef}>
{isCompact ? <CompactPlaceholder /> : <DefaultPlaceholder />}
</MessageBase>
);
})}
</>
);
}
return (
<Box style={{ position: 'relative', width: '100%', height: '60px', overflowAnchor: 'none' }}>
<div
ref={observerRef}
style={{
position: 'absolute',
[direction === 'backward' ? 'top' : 'bottom']: 0,
width: '100%',
height: '1px',
}}
/>
{status === 'loading' && (
<Box justifyContent="Center" alignItems="Center" style={{ position: 'absolute', inset: 0 }}>
<Spinner variant="Secondary" size="400" />
</Box>
)}
</Box>
);
}
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,143 @@
import { useMemo } from 'react';
import { MatrixEvent, EventTimelineSet, EventTimeline } from '$types/matrix-sdk';
import {
getTimelineAndBaseIndex,
getTimelineRelativeIndex,
getTimelineEvent,
} from '$utils/timeline';
import { reactionOrEditEvent } from '$utils/room';
import { inSameDay, minuteDifference } from '$utils/time';
export interface UseProcessedTimelineOptions {
items: number[];
linkedTimelines: EventTimeline[];
ignoredUsersSet: Set<string>;
showHiddenEvents: boolean;
showTombstoneEvents: boolean;
mxUserId: string | null;
readUptoEventId: string | undefined;
}
export interface ProcessedEvent {
id: string;
itemIndex: number;
mEvent: MatrixEvent;
timelineSet: EventTimelineSet;
eventSender: string | null;
collapsed: boolean;
willRenderNewDivider: boolean;
willRenderDayDivider: boolean;
}
export function useProcessedTimeline({
items,
linkedTimelines,
ignoredUsersSet,
showHiddenEvents,
showTombstoneEvents,
mxUserId,
readUptoEventId,
}: UseProcessedTimelineOptions): ProcessedEvent[] {
return useMemo(() => {
let prevEvent: MatrixEvent | undefined;
let isPrevRendered = false;
let newDivider = false;
let dayDivider = false;
const chronologicallyProcessed = items
.map((item) => {
const [eventTimeline, baseIndex] = getTimelineAndBaseIndex(linkedTimelines, item);
if (!eventTimeline) return null;
const timelineSet = eventTimeline.getTimelineSet();
const mEvent = getTimelineEvent(eventTimeline, getTimelineRelativeIndex(item, baseIndex));
if (!mEvent) return null;
const {
getId: getEvtId,
getSender: getEvtSender,
isRedacted: getEvtIsRedacted,
getTs: getEvtTs,
getType: getEvtType,
threadRootId,
} = mEvent;
const mEventId = getEvtId.call(mEvent);
if (!mEventId) return null;
const eventSender = getEvtSender.call(mEvent) ?? null;
if (eventSender && ignoredUsersSet.has(eventSender)) {
return null;
}
if (getEvtIsRedacted.call(mEvent) && !(showHiddenEvents || showTombstoneEvents)) {
return null;
}
if (!newDivider && readUptoEventId) {
const prevId = prevEvent ? prevEvent.getId() : undefined;
newDivider = prevId === readUptoEventId;
}
if (!dayDivider) {
dayDivider = prevEvent ? !inSameDay(prevEvent.getTs(), getEvtTs.call(mEvent)) : false;
}
if (threadRootId !== undefined && threadRootId !== mEventId) {
return null;
}
const isReactionOrEdit = reactionOrEditEvent(mEvent);
const willBeRendered = !isReactionOrEdit;
let collapsed = false;
if (
isPrevRendered &&
!dayDivider &&
(!newDivider || eventSender === mxUserId) &&
prevEvent !== undefined
) {
const { getSender: getPrevSender, getType: getPrevType, getTs: getPrevTs } = prevEvent;
collapsed =
getPrevSender.call(prevEvent) === eventSender &&
getPrevType.call(prevEvent) === getEvtType.call(mEvent) &&
minuteDifference(getPrevTs.call(prevEvent), getEvtTs.call(mEvent)) < 2;
}
const willRenderNewDivider = newDivider && willBeRendered && eventSender !== mxUserId;
const willRenderDayDivider = dayDivider && willBeRendered;
prevEvent = mEvent;
isPrevRendered = willBeRendered;
if (willRenderNewDivider) newDivider = false;
if (willRenderDayDivider) dayDivider = false;
if (!willBeRendered) return null;
return {
id: mEventId,
itemIndex: item,
mEvent,
timelineSet,
eventSender,
collapsed,
willRenderNewDivider,
willRenderDayDivider,
};
})
.filter((e): e is NonNullable<typeof e> => e !== null);
return chronologicallyProcessed.reverse();
}, [
items,
linkedTimelines,
ignoredUsersSet,
showHiddenEvents,
showTombstoneEvents,
mxUserId,
readUptoEventId,
]);
}
@@ -0,0 +1,241 @@
import { useCallback, MouseEventHandler } from 'react';
import { MatrixClient, Room, MatrixEvent, EventStatus, IContent } from '$types/matrix-sdk';
import { Editor } from 'slate';
import { ReactEditor } from 'slate-react';
import { getMxIdLocalPart, toggleReaction } from '$utils/matrix';
import { getMemberDisplayName, getEditedEvent } from '$utils/room';
import { createMentionElement, moveCursor } from '$components/editor';
export interface UseTimelineActionsOptions {
room: Room;
mx: MatrixClient;
editor: Editor;
alive: () => boolean;
nicknames: Record<string, string>;
globalProfiles: Record<string, any>;
spaceId?: string;
openUserRoomProfile: (
roomId: string,
spaceId: string | undefined,
userId: string,
rect: DOMRect,
undefinedArg?: undefined,
options?: any
) => void;
activeReplyId?: string;
setReplyDraft: (draft: any) => void;
openThreadId?: string;
setOpenThread: (threadId: string | undefined) => void;
setEditId: (editId: string | undefined) => void;
onEditorReset?: () => void;
handleOpenEvent: (eventId: string) => void;
}
export function useTimelineActions({
room,
mx,
editor,
alive,
nicknames,
globalProfiles,
spaceId,
openUserRoomProfile,
activeReplyId,
setReplyDraft,
openThreadId,
setOpenThread,
setEditId,
onEditorReset,
handleOpenEvent,
}: UseTimelineActionsOptions) {
const handleOpenReply: MouseEventHandler<HTMLButtonElement> = useCallback(
(evt) => {
const targetId = evt.currentTarget.getAttribute('data-event-id');
if (!targetId) return;
handleOpenEvent(targetId);
},
[handleOpenEvent]
);
const handleUserClick: MouseEventHandler<HTMLButtonElement> = useCallback(
(evt) => {
evt.preventDefault();
evt.stopPropagation();
const userId = evt.currentTarget.getAttribute('data-user-id');
if (!userId) return;
const cachedData = globalProfiles[userId];
const cleanExtended = cachedData?.extended ? { ...cachedData.extended } : undefined;
if (cleanExtended) {
delete cleanExtended['io.fsky.nyx.pronouns'];
delete cleanExtended['moe.sable.app.bio'];
delete cleanExtended['chat.commet.profile_bio'];
delete cleanExtended['chat.commet.profile_status'];
delete cleanExtended['us.cloke.msc4175.tz'];
delete cleanExtended['m.tz'];
delete cleanExtended['chat.commet.profile_banner'];
delete cleanExtended['moe.sable.app.name_color'];
delete cleanExtended.avatar_url;
delete cleanExtended.displayname;
delete cleanExtended['kitty.meow.has_cats'];
delete cleanExtended['kitty.meow.is_cat'];
}
openUserRoomProfile(
room.roomId,
spaceId,
userId,
evt.currentTarget.getBoundingClientRect(),
undefined,
{
pronouns: cachedData?.pronouns,
bio: cachedData?.bio,
timezone: cachedData?.timezone,
extended: cleanExtended,
}
);
},
[room.roomId, spaceId, openUserRoomProfile, globalProfiles]
);
const handleUsernameClick: MouseEventHandler<HTMLButtonElement> = useCallback(
(evt) => {
evt.preventDefault();
const userId = evt.currentTarget.getAttribute('data-user-id');
if (!userId) return;
const name =
getMemberDisplayName(room, userId, nicknames) ?? getMxIdLocalPart(userId) ?? userId;
editor.insertNode(
createMentionElement(
userId,
name.startsWith('@') ? name : `@${name}`,
userId === mx.getUserId()
)
);
ReactEditor.focus(editor);
moveCursor(editor);
},
[mx, room, editor, nicknames]
);
const triggerReply = useCallback(
(replyId: string, startThread = false) => {
if (activeReplyId === replyId) {
setReplyDraft(undefined);
return;
}
const replyEvt = room.findEventById(replyId);
if (!replyEvt) return;
const editedReply = getEditedEvent(replyId, replyEvt, room.getUnfilteredTimelineSet());
const { getContent, getWireContent, getSender } = replyEvt;
let editedNewContent: any;
if (editedReply) {
const { getContent: getEditedContent } = editedReply;
editedNewContent = getEditedContent.call(editedReply)['m.new_content'];
}
const content: IContent = editedNewContent ?? getContent.call(replyEvt);
const { body, formatted_body: formattedBody } = content;
const { 'm.relates_to': relation } = startThread
? { 'm.relates_to': { rel_type: 'm.thread', event_id: replyId } }
: getWireContent.call(replyEvt);
const senderId = getSender.call(replyEvt);
if (senderId) {
setReplyDraft({
userId: senderId,
eventId: replyId,
body: typeof body === 'string' ? body : '',
formattedBody: typeof formattedBody === 'string' ? formattedBody : '',
relation,
});
}
},
[room, setReplyDraft, activeReplyId]
);
const handleReplyClick = useCallback(
(evt: React.MouseEvent<HTMLButtonElement>, startThread = false) => {
const replyId = evt.currentTarget.getAttribute('data-event-id');
if (!replyId) {
setReplyDraft(undefined);
return;
}
if (startThread) {
const rootEvent = room.findEventById(replyId);
if (rootEvent && !room.getThread(replyId)) {
room.createThread(replyId, rootEvent, [], false);
}
setOpenThread(openThreadId === replyId ? undefined : replyId);
return;
}
triggerReply(replyId, false);
},
[triggerReply, setReplyDraft, setOpenThread, openThreadId, room]
);
const handleReactionToggle = useCallback(
(targetEventId: string, key: string, shortcode?: string) => {
toggleReaction(mx, room, targetEventId, key, shortcode);
},
[mx, room]
);
const handleResend = useCallback(
(mEvent: MatrixEvent) => {
const { getAssociatedStatus } = mEvent;
if (getAssociatedStatus.call(mEvent) !== EventStatus.NOT_SENT) return;
mx.resendEvent(mEvent, room).catch(() => undefined);
},
[mx, room]
);
const handleDeleteFailedSend = useCallback(
(mEvent: MatrixEvent) => {
const { getAssociatedStatus } = mEvent;
if (getAssociatedStatus.call(mEvent) !== EventStatus.NOT_SENT) return;
mx.cancelPendingEvent(mEvent);
},
[mx]
);
const handleEdit = useCallback(
(targetEditId?: string) => {
if (targetEditId) {
setEditId(targetEditId);
return;
}
setEditId(undefined);
onEditorReset?.();
requestAnimationFrame(() => {
if (!alive()) return;
ReactEditor.focus(editor);
moveCursor(editor);
});
},
[editor, alive, onEditorReset, setEditId]
);
return {
handleOpenReply,
handleUserClick,
handleUsernameClick,
handleReplyClick,
handleReactionToggle,
handleResend,
handleDeleteFailedSend,
handleEdit,
setOpenThread,
};
}
File diff suppressed because it is too large. Load diff
+603
View File
@@ -0,0 +1,603 @@
import { useState, useMemo, useCallback, useRef, useEffect, Dispatch, SetStateAction } from 'react';
import to from 'await-to-js';
import * as Sentry from '@sentry/react';
import {
MatrixClient,
Room,
MatrixEvent,
Direction,
EventTimeline,
EventTimelineSetHandlerMap,
RoomEvent,
IRoomTimelineData,
RoomEventHandlerMap,
RelationType,
ThreadEvent,
} from '$types/matrix-sdk';
import { useAlive } from '$hooks/useAlive';
import { createDebugLogger } from '$utils/debugLogger';
import { ItemRange } from '$hooks/useVirtualPaginator';
import { markAsRead } from '$utils/notifications';
import { decryptAllTimelineEvent } from '$utils/room';
import {
getInitialTimeline,
getEmptyTimeline,
getLinkedTimelines,
getTimelinesEventsCount,
getEventIdAbsoluteIndex,
getLiveTimeline,
getRoomUnreadInfo,
PAGINATION_LIMIT,
} from '$utils/timeline';
const debugLog = createDebugLogger('TimelineSync');
export const EVENT_TIMELINE_LOAD_TIMEOUT_MS = 12000;
export type PaginationStatus = 'idle' | 'loading' | 'error';
export type TimelineState = {
linkedTimelines: EventTimeline[];
range: ItemRange;
};
const useEventTimelineLoader = (
mx: MatrixClient,
room: Room,
onLoad: (eventId: string, linkedTimelines: EventTimeline[], evtAbsIndex: number) => void,
onError: (err: Error | null) => void
) =>
useCallback(
async (eventId: string) =>
Sentry.startSpan({ name: 'timeline.jump_load', op: 'matrix.timeline' }, async () => {
const jumpLoadStart = performance.now();
const withTimeout = async <T>(promise: Promise<T>, timeoutMs: number): Promise<T> =>
new Promise<T>((resolve, reject) => {
const timeoutId = globalThis.setTimeout(() => {
reject(new Error('Timed out loading event timeline'));
}, timeoutMs);
promise
.then((value) => {
globalThis.clearTimeout(timeoutId);
resolve(value);
})
.catch((error) => {
globalThis.clearTimeout(timeoutId);
reject(error);
});
});
if (!room.getUnfilteredTimelineSet().getTimelineForEvent(eventId)) {
await withTimeout(
mx.roomInitialSync(room.roomId, PAGINATION_LIMIT),
EVENT_TIMELINE_LOAD_TIMEOUT_MS
);
await withTimeout(
mx.getLatestTimeline(room.getUnfilteredTimelineSet()),
EVENT_TIMELINE_LOAD_TIMEOUT_MS
);
}
const [err, replyEvtTimeline] = await to(
withTimeout(
mx.getEventTimeline(room.getUnfilteredTimelineSet(), eventId),
EVENT_TIMELINE_LOAD_TIMEOUT_MS
)
);
if (!replyEvtTimeline) {
onError(err ?? null);
return;
}
const linkedTimelines = getLinkedTimelines(replyEvtTimeline);
const absIndex = getEventIdAbsoluteIndex(linkedTimelines, replyEvtTimeline, eventId);
if (absIndex === undefined) {
onError(err ?? null);
return;
}
Sentry.metrics.distribution(
'sable.timeline.jump_load_ms',
performance.now() - jumpLoadStart
);
onLoad(eventId, linkedTimelines, absIndex);
}),
[mx, room, onLoad, onError]
);
const useTimelinePagination = (
mx: MatrixClient,
timeline: TimelineState,
setTimeline: Dispatch<SetStateAction<TimelineState>>,
limit: number
) => {
const timelineRef = useRef(timeline);
timelineRef.current = timeline;
const alive = useAlive();
const [backwardStatus, setBackwardStatus] = useState<PaginationStatus>('idle');
const [forwardStatus, setForwardStatus] = useState<PaginationStatus>('idle');
const fetchingRef = useRef({ backward: false, forward: false });
const paginate = useMemo(() => {
const recalibratePagination = (
linkedTimelines: EventTimeline[],
timelinesEventsCount: number[],
backwards: boolean
) => {
const topTimeline = linkedTimelines[0];
const timelineMatch = (mt: EventTimeline) => (t: EventTimeline) => t === mt;
const newLTimelines = getLinkedTimelines(topTimeline);
const topTmIndex = newLTimelines.findIndex(timelineMatch(topTimeline));
const topAddedTm = topTmIndex === -1 ? [] : newLTimelines.slice(0, topTmIndex);
const topTmAddedEvt =
(newLTimelines[topTmIndex]?.getEvents()?.length ?? 0) - timelinesEventsCount[0];
const offsetRange = getTimelinesEventsCount(topAddedTm) + (backwards ? topTmAddedEvt : 0);
setTimeline((currentTimeline) => ({
linkedTimelines: newLTimelines,
range:
offsetRange > 0
? {
start: currentTimeline.range.start + offsetRange,
end: currentTimeline.range.end + offsetRange,
}
: { ...currentTimeline.range },
}));
};
return async (backwards: boolean) => {
const directionKey = backwards ? 'backward' : 'forward';
if (fetchingRef.current[directionKey]) return;
const { linkedTimelines: lTimelines } = timelineRef.current;
const timelinesEventsCount = lTimelines.map((t) => t.getEvents()?.length ?? 0);
const timelineToPaginate = backwards ? lTimelines[0] : lTimelines.at(-1);
if (!timelineToPaginate) return;
const paginationToken = timelineToPaginate.getPaginationToken(
backwards ? Direction.Backward : Direction.Forward
);
if (
!paginationToken &&
getTimelinesEventsCount(lTimelines) !==
getTimelinesEventsCount(getLinkedTimelines(timelineToPaginate))
) {
recalibratePagination(lTimelines, timelinesEventsCount, backwards);
return;
}
fetchingRef.current[directionKey] = true;
if (alive()) {
(backwards ? setBackwardStatus : setForwardStatus)('loading');
debugLog.info('timeline', 'Timeline pagination started', {
direction: backwards ? 'backward' : 'forward',
eventsLoaded: getTimelinesEventsCount(lTimelines),
hasToken: !!paginationToken,
});
}
try {
const paginateStart = performance.now();
const [err] = await to(
mx.paginateEventTimeline(timelineToPaginate, {
backwards,
limit,
})
);
if (err) {
if (alive()) {
(backwards ? setBackwardStatus : setForwardStatus)('error');
Sentry.metrics.count('sable.pagination.error', 1, {
attributes: { direction: backwards ? 'backward' : 'forward' },
});
debugLog.error('timeline', 'Timeline pagination failed', {
direction: backwards ? 'backward' : 'forward',
error: err instanceof Error ? err.message : String(err),
});
}
return;
}
const fetchedTimeline =
timelineToPaginate.getNeighbouringTimeline(
backwards ? Direction.Backward : Direction.Forward
) ?? timelineToPaginate;
const roomId = fetchedTimeline.getRoomId();
const evRoom = roomId ? mx.getRoom(roomId) : null;
if (evRoom?.hasEncryptionStateEvent()) {
await to(decryptAllTimelineEvent(mx, fetchedTimeline));
}
if (alive()) {
recalibratePagination(lTimelines, timelinesEventsCount, backwards);
(backwards ? setBackwardStatus : setForwardStatus)('idle');
Sentry.metrics.distribution(
'sable.pagination.latency_ms',
performance.now() - paginateStart,
{
attributes: {
direction: backwards ? 'backward' : 'forward',
encrypted: String(!!evRoom?.hasEncryptionStateEvent()),
},
}
);
debugLog.info('timeline', 'Timeline pagination completed', {
direction: backwards ? 'backward' : 'forward',
totalEventsNow: getTimelinesEventsCount(lTimelines),
});
}
} finally {
fetchingRef.current[directionKey] = false;
}
};
}, [mx, alive, setTimeline, limit, setBackwardStatus, setForwardStatus]);
return { paginate, backwardStatus, forwardStatus };
};
const useLiveEventArrive = (room: Room, onArrive: (mEvent: MatrixEvent) => void) => {
const onArriveRef = useRef(onArrive);
onArriveRef.current = onArrive;
useEffect(() => {
const liveTimeline = getLiveTimeline(room);
const registeredAt = Date.now();
const handleTimelineEvent: EventTimelineSetHandlerMap[RoomEvent.Timeline] = (
mEvent: MatrixEvent,
eventRoom: Room | undefined,
toStartOfTimeline: boolean | undefined,
removed: boolean,
data: IRoomTimelineData
) => {
if (eventRoom?.roomId !== room.roomId) return;
const { getTs } = mEvent;
const isLive =
data.liveEvent ||
(!toStartOfTimeline &&
!removed &&
data.timeline === liveTimeline &&
getTs.call(mEvent) >= registeredAt - 60_000);
if (!isLive) return;
onArriveRef.current(mEvent);
};
const handleRedaction: RoomEventHandlerMap[RoomEvent.Redaction] = (
mEvent: MatrixEvent,
eventRoom: Room | undefined
) => {
if (eventRoom?.roomId !== room.roomId) return;
onArriveRef.current(mEvent);
};
room.on(RoomEvent.Timeline, handleTimelineEvent);
room.on(RoomEvent.Redaction, handleRedaction);
return () => {
room.removeListener(RoomEvent.Timeline, handleTimelineEvent);
room.removeListener(RoomEvent.Redaction, handleRedaction);
};
}, [room]);
};
const useRelationUpdate = (room: Room, onRelation: () => void) => {
const onRelationRef = useRef(onRelation);
onRelationRef.current = onRelation;
useEffect(() => {
const handleTimelineEvent: EventTimelineSetHandlerMap[RoomEvent.Timeline] = (
mEvent: MatrixEvent,
eventRoom: Room | undefined,
_toStartOfTimeline: boolean | undefined,
_removed: boolean,
data: IRoomTimelineData
) => {
if (eventRoom?.roomId !== room.roomId || data.liveEvent) return;
const { getRelation } = mEvent;
if (getRelation.call(mEvent)?.rel_type === RelationType.Replace) {
onRelationRef.current();
}
};
room.on(RoomEvent.Timeline, handleTimelineEvent);
return () => {
room.removeListener(RoomEvent.Timeline, handleTimelineEvent);
};
}, [room]);
};
const useLiveTimelineRefresh = (room: Room, onRefresh: () => void) => {
const onRefreshRef = useRef(onRefresh);
onRefreshRef.current = onRefresh;
useEffect(() => {
const handleTimelineRefresh: RoomEventHandlerMap[RoomEvent.TimelineRefresh] = (r: Room) => {
if (r.roomId !== room.roomId) return;
onRefreshRef.current();
};
const handleTimelineReset: EventTimelineSetHandlerMap[RoomEvent.TimelineReset] = () => {
onRefreshRef.current();
};
const unfilteredTimelineSet = room.getUnfilteredTimelineSet();
room.on(RoomEvent.TimelineRefresh, handleTimelineRefresh);
unfilteredTimelineSet.on(RoomEvent.TimelineReset, handleTimelineReset);
return () => {
room.removeListener(RoomEvent.TimelineRefresh, handleTimelineRefresh);
unfilteredTimelineSet.removeListener(RoomEvent.TimelineReset, handleTimelineReset);
};
}, [room]);
};
const useThreadUpdate = (room: Room, onUpdate: () => void) => {
const onUpdateRef = useRef(onUpdate);
onUpdateRef.current = onUpdate;
useEffect(() => {
const handler = () => onUpdateRef.current();
room.on(ThreadEvent.New, handler);
room.on(ThreadEvent.Update, handler);
room.on(ThreadEvent.NewReply, handler);
return () => {
room.removeListener(ThreadEvent.New, handler);
room.removeListener(ThreadEvent.Update, handler);
room.removeListener(ThreadEvent.NewReply, handler);
};
}, [room]);
};
export interface UseTimelineSyncOptions {
room: Room;
mx: MatrixClient;
eventId?: string;
isAtBottom: boolean;
scrollToBottom: (behavior?: 'instant' | 'smooth') => void;
unreadInfo: ReturnType<typeof getRoomUnreadInfo>;
setUnreadInfo: Dispatch<SetStateAction<ReturnType<typeof getRoomUnreadInfo>>>;
hideReadsRef: React.MutableRefObject<boolean>;
readUptoEventIdRef: React.MutableRefObject<string | undefined>;
}
export function useTimelineSync({
room,
mx,
eventId,
isAtBottom,
scrollToBottom,
unreadInfo,
setUnreadInfo,
hideReadsRef,
readUptoEventIdRef,
}: UseTimelineSyncOptions) {
const alive = useAlive();
const [timeline, setTimeline] = useState<TimelineState>(() =>
eventId ? getEmptyTimeline() : getInitialTimeline(room)
);
const [focusItem, setFocusItem] = useState<
| {
index: number;
scrollTo: boolean;
highlight: boolean;
}
| undefined
>();
const timelineJustResetRef = useRef(false);
const eventsLength = getTimelinesEventsCount(timeline.linkedTimelines);
const liveTimelineLinked = timeline.linkedTimelines.at(-1) === getLiveTimeline(room);
const canPaginateBack =
typeof timeline.linkedTimelines[0]?.getPaginationToken(Direction.Backward) === 'string';
const rangeAtStart = timeline.range.start === 0;
const rangeAtEnd = timeline.range.end === eventsLength;
const atLiveEndRef = useRef(liveTimelineLinked && rangeAtEnd);
atLiveEndRef.current = liveTimelineLinked && rangeAtEnd;
const {
paginate: handleTimelinePagination,
backwardStatus,
forwardStatus,
} = useTimelinePagination(mx, timeline, setTimeline, PAGINATION_LIMIT);
const prevEventsLengthRef = useRef(eventsLength);
useEffect(() => {
const prev = prevEventsLengthRef.current;
const delta = eventsLength - prev;
prevEventsLengthRef.current = eventsLength;
if (delta === 0) return;
const isBatch = delta > 1;
let batchSize: string;
if (delta === 1) batchSize = 'single';
else if (delta <= 20) batchSize = 'small';
else if (delta <= 100) batchSize = 'medium';
else batchSize = 'large';
Sentry.addBreadcrumb({
category: 'timeline.events',
message: `Timeline: ${delta} event${delta === 1 ? '' : 's'} added (${batchSize})`,
level: isBatch ? 'info' : 'debug',
data: {
delta,
batchSize,
eventsLength,
prevEventsLength: prev,
liveTimelineLinked,
rangeEnd: timeline.range.end,
atBottom: isAtBottom,
rangeGap: eventsLength - timeline.range.end,
},
});
if (delta > 50 && liveTimelineLinked) {
Sentry.captureMessage('Timeline: large event batch from sliding sync', {
level: 'warning',
extra: { delta, eventsLength, rangeEnd: timeline.range.end, atBottom: isAtBottom },
tags: { feature: 'timeline', batchSize },
});
}
}, [eventsLength, liveTimelineLinked, isAtBottom, timeline.range.end]);
const loadEventTimeline = useEventTimelineLoader(
mx,
room,
useCallback(
(evtId, lTimelines, evtAbsIndex) => {
if (!alive()) return;
const evLength = getTimelinesEventsCount(lTimelines);
setTimeline({
linkedTimelines: lTimelines,
range: {
start: Math.max(evtAbsIndex - PAGINATION_LIMIT, 0),
end: Math.min(evtAbsIndex + PAGINATION_LIMIT, evLength),
},
});
setFocusItem({
index: evtAbsIndex,
scrollTo: true,
highlight: evtId !== readUptoEventIdRef.current,
});
},
[alive, readUptoEventIdRef]
),
useCallback(() => {
if (!alive()) return;
setTimeline(getInitialTimeline(room));
scrollToBottom('instant');
}, [alive, room, scrollToBottom])
);
useLiveEventArrive(
room,
useCallback(
(mEvt: MatrixEvent) => {
const { threadRootId, getSender, getRoomId } = mEvt;
if (threadRootId !== undefined) return;
if (isAtBottom && atLiveEndRef.current) {
if (
document.hasFocus() &&
(!unreadInfo?.readUptoEventId || getSender.call(mEvt) === mx.getUserId())
) {
requestAnimationFrame(() =>
markAsRead(mx, getRoomId.call(mEvt)!, hideReadsRef.current)
);
}
if (!document.hasFocus() && !unreadInfo) {
setUnreadInfo(getRoomUnreadInfo(room));
}
scrollToBottom(getSender.call(mEvt) === mx.getUserId() ? 'instant' : 'smooth');
setTimeline((ct) => ({
...ct,
range: {
start: ct.range.start + 1,
end: ct.range.end + 1,
},
}));
return;
}
setTimeline((ct) => ({ ...ct }));
if (!unreadInfo) {
setUnreadInfo(getRoomUnreadInfo(room));
}
},
[mx, room, isAtBottom, unreadInfo, scrollToBottom, setUnreadInfo, hideReadsRef]
)
);
useEffect(() => {
const handleLocalEchoUpdated: RoomEventHandlerMap[RoomEvent.LocalEchoUpdated] = (
_mEvent: MatrixEvent,
eventRoom: Room | undefined
) => {
if (eventRoom?.roomId !== room.roomId) return;
setTimeline((ct) => ({ ...ct }));
};
room.on(RoomEvent.LocalEchoUpdated, handleLocalEchoUpdated);
return () => {
room.removeListener(RoomEvent.LocalEchoUpdated, handleLocalEchoUpdated);
};
}, [room, setTimeline]);
useLiveTimelineRefresh(
room,
useCallback(() => {
const wasAtBottom = isAtBottom;
timelineJustResetRef.current = true;
setTimeline(getInitialTimeline(room));
if (wasAtBottom) {
scrollToBottom('instant');
}
}, [room, isAtBottom, scrollToBottom])
);
useRelationUpdate(
room,
useCallback(() => {
setTimeline((ct) => ({ ...ct }));
}, [])
);
useThreadUpdate(
room,
useCallback(() => {
setTimeline((ct) => ({ ...ct }));
}, [])
);
useEffect(() => {
const resetPending = timelineJustResetRef.current;
if ((isAtBottom || resetPending) && liveTimelineLinked && eventsLength > timeline.range.end) {
if (resetPending) timelineJustResetRef.current = false;
scrollToBottom('instant');
setTimeline((ct) => ({
...ct,
range: {
start: Math.max(eventsLength - PAGINATION_LIMIT, 0),
end: eventsLength,
},
}));
}
}, [isAtBottom, liveTimelineLinked, eventsLength, timeline.range.end, scrollToBottom]);
useEffect(() => {
if (eventId) return;
if (timeline.linkedTimelines.length > 0) return;
if (getLiveTimeline(room).getEvents().length === 0) return;
setTimeline(getInitialTimeline(room));
}, [eventId, room, timeline.linkedTimelines.length]);
return {
timeline,
setTimeline,
eventsLength,
liveTimelineLinked,
canPaginateBack,
rangeAtStart,
rangeAtEnd,
backwardStatus,
forwardStatus,
handleTimelinePagination,
loadEventTimeline,
focusItem,
setFocusItem,
};
}