mirror of
https://github.com/SableClient/Sable.git
synced 2026-11-21 01:21:18 -08:00
initial big refractor, probably broke stuff and forgot stuff but oh well baby steps
This commit is contained in:
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>
|
||||
);
|
||||
}
|
||||
+320
-2366
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
@@ -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,
|
||||
};
|
||||
}
|
||||
Reference in new issue
Block a user