feat: port MSC4140 scheduled messages from cinny#2671

This commit is contained in:
jasonlaguidice committed 2026-03-03 22:56:07 -08:00
1 parent a2d61da254
commit 7e22d86a51
10 files changed
+892 -55

No files matched your search

+218 -54
View File
@@ -30,10 +30,13 @@ import {
IconButton,
Icons,
Line,
Menu,
MenuItem,
Overlay,
OverlayBackdrop,
OverlayCenter,
PopOut,
RectCords,
Scroll,
Text,
toRem,
@@ -130,6 +133,23 @@ import {
getImageMsgContent,
getVideoMsgContent,
} from './msgContent';
import FocusTrap from 'focus-trap-react';
import { useQueryClient } from '@tanstack/react-query';
import {
delayedEventsSupportedAtom,
roomIdToScheduledTimeAtomFamily,
roomIdToEditingScheduledDelayIdAtomFamily,
} from '$state/scheduledMessages';
import {
sendDelayedMessage,
sendDelayedMessageE2EE,
computeDelayMs,
cancelDelayedEvent,
} from '$utils/delayedEvents';
import { SchedulePickerDialog } from './schedule-send';
import * as css from './schedule-send/SchedulePickerDialog.css';
import { timeHourMinute, timeDayMonthYear } from '$utils/time';
import { stopPropagation } from '$utils/keyboard';
const getReplyContent = (replyDraft: IReplyDraft | undefined): IEventRelation => {
if (!replyDraft) return {};
@@ -242,6 +262,17 @@ export const RoomInput = forwardRef<HTMLDivElement, RoomInputProps>(
const isComposing = useComposingCheck();
const queryClient = useQueryClient();
const delayedEventsSupported = useAtomValue(delayedEventsSupportedAtom);
const [scheduledTime, setScheduledTime] = useAtom(roomIdToScheduledTimeAtomFamily(roomId));
const [editingScheduledDelayId, setEditingScheduledDelayId] = useAtom(
roomIdToEditingScheduledDelayIdAtomFamily(roomId)
);
const [scheduleMenuAnchor, setScheduleMenuAnchor] = useState<RectCords>();
const [showSchedulePicker, setShowSchedulePicker] = useState(false);
const [hour24Clock] = useSetting(settingsAtom, 'hour24Clock');
const isEncrypted = room.hasEncryptionStateEvent();
useElementSizeObserver(
useCallback(() => document.body, []),
useCallback((width) => setHideStickerBtn(width < 500), [])
@@ -428,21 +459,54 @@ export const RoomInput = forwardRef<HTMLDivElement, RoomInputProps>(
if (replyDraft) {
content['m.relates_to'] = getReplyContent(replyDraft);
}
if (replyDraft) {
const invalidate = () =>
queryClient.invalidateQueries({ queryKey: ['delayedEvents', roomId] });
const resetInput = () => {
resetEditor(editor);
resetEditorHistory(editor);
setInputKey((prev) => prev + 1);
setReplyDraft(undefined);
}
sendTypingStatus(false);
};
resetEditor(editor);
resetEditorHistory(editor);
setInputKey((prev) => prev + 1);
sendTypingStatus(false);
try {
await mx.sendMessage(roomId, content as any);
} catch (error) {
log.error('failed to send message', { roomId }, error);
if (scheduledTime) {
try {
const delayMs = computeDelayMs(scheduledTime);
if (editingScheduledDelayId) {
await cancelDelayedEvent(mx, editingScheduledDelayId);
}
if (isEncrypted) {
await sendDelayedMessageE2EE(mx, roomId, room, content, delayMs);
} else {
await sendDelayedMessage(mx, roomId, content, delayMs);
}
invalidate();
setEditingScheduledDelayId(null);
setScheduledTime(null);
resetInput();
} catch {
// Network/server error — leave editor and scheduled state intact for retry
}
} else if (editingScheduledDelayId) {
try {
await cancelDelayedEvent(mx, editingScheduledDelayId);
mx.sendMessage(roomId, content as any);
invalidate();
setEditingScheduledDelayId(null);
resetInput();
} catch {
// Cancel failed — leave state intact for retry
}
} else {
try {
await mx.sendMessage(roomId, content as any);
} catch (error) {
log.error('failed to send message', { roomId }, error);
}
resetInput();
}
}, [mx, roomId, editor, replyDraft, sendTypingStatus, setReplyDraft, isMarkdown, commands]);
}, [mx, roomId, room, editor, replyDraft, sendTypingStatus, setReplyDraft, isMarkdown, commands, scheduledTime, setScheduledTime, isEncrypted, queryClient, editingScheduledDelayId, setEditingScheduledDelayId]);
const handleKeyDown: KeyboardEventHandler = useCallback(
(evt) => {
@@ -617,43 +681,73 @@ export const RoomInput = forwardRef<HTMLDivElement, RoomInputProps>(
onKeyUp={handleKeyUp}
onPaste={handlePaste}
top={
replyDraft && (
<div>
<Box
alignItems="Center"
gap="300"
style={{ padding: `${config.space.S200} ${config.space.S300} 0` }}
>
<IconButton
onClick={() => setReplyDraft(undefined)}
variant="SurfaceVariant"
size="300"
radii="300"
<>
{scheduledTime && (
<div>
<Box
alignItems="Center"
gap="300"
style={{ padding: `${config.space.S200} ${config.space.S300} 0` }}
>
<Icon src={Icons.Cross} size="50" />
</IconButton>
<Box direction="Row" gap="200" alignItems="Center">
{replyDraft.relation?.rel_type === RelationType.Thread && <ThreadIndicator />}
<ReplyLayout
userColor={replyUsernameColor}
username={
<Text size="T300" truncate style={{ fontFamily: replyUsernameFont }}>
<b>
{getMemberDisplayName(room, replyDraft.userId, nicknames) ??
getMxIdLocalPart(replyDraft.userId) ??
replyDraft.userId}
</b>
</Text>
}
<IconButton
onClick={() => {
setScheduledTime(null);
setEditingScheduledDelayId(null);
}}
variant="SurfaceVariant"
size="300"
radii="300"
>
<Text size="T300" truncate>
{replyBodyJSX}
<Icon src={Icons.Cross} size="50" />
</IconButton>
<Box direction="Row" gap="200" alignItems="Center">
<Icon size="100" src={Icons.Clock} />
<Text size="T300">
Scheduled for {timeDayMonthYear(scheduledTime.getTime())} at{' '}
{timeHourMinute(scheduledTime.getTime(), hour24Clock)}
</Text>
</ReplyLayout>
</Box>
</Box>
</Box>
</div>
)
</div>
)}
{replyDraft && (
<div>
<Box
alignItems="Center"
gap="300"
style={{ padding: `${config.space.S200} ${config.space.S300} 0` }}
>
<IconButton
onClick={() => setReplyDraft(undefined)}
variant="SurfaceVariant"
size="300"
radii="300"
>
<Icon src={Icons.Cross} size="50" />
</IconButton>
<Box direction="Row" gap="200" alignItems="Center">
{replyDraft.relation?.rel_type === RelationType.Thread && <ThreadIndicator />}
<ReplyLayout
userColor={replyUsernameColor}
username={
<Text size="T300" truncate style={{ fontFamily: replyUsernameFont }}>
<b>
{getMemberDisplayName(room, replyDraft.userId, nicknames) ??
getMxIdLocalPart(replyDraft.userId) ??
replyDraft.userId}
</b>
</Text>
}
>
<Text size="T300" truncate>
{replyBodyJSX}
</Text>
</ReplyLayout>
</Box>
</Box>
</div>
)}
</>
}
before={
<IconButton
@@ -742,15 +836,74 @@ export const RoomInput = forwardRef<HTMLDivElement, RoomInputProps>(
</PopOut>
)}
</UseStateProvider>
<IconButton
onClick={submit}
onMouseDown={(e: MouseEvent) => e.preventDefault()}
variant="SurfaceVariant"
size="300"
radii="300"
>
<Icon src={Icons.Send} />
</IconButton>
<PopOut
anchor={scheduleMenuAnchor}
position="Top"
align="End"
offset={5}
content={
<FocusTrap
focusTrapOptions={{
initialFocus: false,
onDeactivate: () => setScheduleMenuAnchor(undefined),
clickOutsideDeactivates: true,
escapeDeactivates: stopPropagation,
}}
>
<Menu>
<Box direction="Column" gap="100" style={{ padding: config.space.S100 }}>
<MenuItem
size="300"
radii="300"
onClick={() => {
setScheduleMenuAnchor(undefined);
submit();
}}
before={<Icon size="100" src={Icons.Send} />}
>
<Text size="B300">Send Now</Text>
</MenuItem>
<MenuItem
size="300"
radii="300"
onClick={() => {
setScheduleMenuAnchor(undefined);
setShowSchedulePicker(true);
}}
before={<Icon size="100" src={Icons.Clock} />}
>
<Text size="B300">Schedule Send</Text>
</MenuItem>
</Box>
</Menu>
</FocusTrap>
}
/>
<Box display="Flex" alignItems="Center">
<IconButton
onClick={submit}
onMouseDown={(e: MouseEvent) => e.preventDefault()}
variant={scheduledTime ? 'Primary' : 'SurfaceVariant'}
size="300"
radii="0"
className={delayedEventsSupported ? css.SplitSendButton : undefined}
>
<Icon src={scheduledTime ? Icons.Clock : Icons.Send} />
</IconButton>
{delayedEventsSupported && (
<IconButton
onClick={(evt: MouseEvent<HTMLButtonElement>) => {
setScheduleMenuAnchor(evt.currentTarget.getBoundingClientRect());
}}
variant={scheduledTime ? 'Primary' : 'SurfaceVariant'}
size="300"
radii="0"
className={css.SplitChevronButton}
>
<Icon size="50" src={Icons.ChevronBottom} />
</IconButton>
)}
</Box>
</>
}
bottom={
@@ -762,6 +915,17 @@ export const RoomInput = forwardRef<HTMLDivElement, RoomInputProps>(
)
}
/>
{showSchedulePicker && (
<SchedulePickerDialog
initialTime={scheduledTime?.getTime()}
showEncryptionWarning={isEncrypted}
onCancel={() => setShowSchedulePicker(false)}
onSubmit={(date) => {
setScheduledTime(date);
setShowSchedulePicker(false);
}}
/>
)}
</div>
);
}
+21 -1
View File
@@ -1,4 +1,6 @@
import { useCallback, useRef, useState } from 'react';
import { useAtomValue } from 'jotai';
import { Transforms } from 'slate';
import { Box, Text, config, toRem } from 'folds';
import { EventType, Room } from '$types/matrix-sdk';
import { ReactEditor } from 'slate-react';
@@ -7,7 +9,7 @@ import { useStateEvent } from '$hooks/useStateEvent';
import { StateEvent } from '$types/matrix/room';
import { usePowerLevelsContext } from '$hooks/usePowerLevels';
import { useMatrixClient } from '$hooks/useMatrixClient';
import { useEditor } from '$components/editor';
import { useEditor, resetEditor } from '$components/editor';
import { Page } from '$components/page';
import { useKeyDown } from '$hooks/useKeyDown';
import { editableActiveElement } from '$utils/dom';
@@ -28,6 +30,9 @@ import { RoomTombstone } from './RoomTombstone';
import { RoomViewTyping } from './RoomViewTyping';
import { RoomTimeline } from './RoomTimeline';
import { RoomInputPlaceholder } from './RoomInputPlaceholder';
import { ScheduledMessagesList } from './schedule-send';
import { useDelayedEventsSupport } from '$hooks/useDelayedEventsSupport';
import { delayedEventsSupportedAtom } from '$state/scheduledMessages';
const FN_KEYS_REGEX = /^F\d+$/;
const shouldFocusMessageField = (evt: KeyboardEvent): boolean => {
@@ -82,6 +87,18 @@ export function RoomView({ room, eventId }: { room: Room; eventId?: string }) {
const [editorResetKey, setEditorResetKey] = useState(0);
const handleResetEditor = useCallback(() => setEditorResetKey((prev) => prev + 1), []);
useDelayedEventsSupport();
const delayedEventsSupported = useAtomValue(delayedEventsSupportedAtom);
const handleEditMessage = useCallback(
(body: string) => {
resetEditor(editor);
if (body) Transforms.insertText(editor, body);
ReactEditor.focus(editor);
},
[editor]
);
useKeyDown(
window,
useCallback(
@@ -133,6 +150,9 @@ export function RoomView({ room, eventId }: { room: Room; eventId?: string }) {
<GlobalModalManager />
</Box>
<Box shrink="No" direction="Column">
{canMessage && delayedEventsSupported && (
<ScheduledMessagesList room={room} onEditMessage={handleEditMessage} />
)}
<div style={{ padding: `0 ${config.space.S400}` }}>
{tombstoneEvent ? (
<RoomTombstone
@@ -0,0 +1,18 @@
import { style } from '@vanilla-extract/css';
import { config, toRem } from 'folds';
export const SchedulePickerContent = style({
padding: config.space.S400,
minWidth: toRem(300),
});
export const SplitSendButton = style({
borderRadius: `${config.radii.R300} 0 0 ${config.radii.R300}`,
});
export const SplitChevronButton = style({
borderRadius: `0 ${config.radii.R300} ${config.radii.R300} 0`,
borderLeft: '1px solid currentColor',
opacity: 0.7,
paddingInline: toRem(2),
});
@@ -0,0 +1,270 @@
import React, { MouseEventHandler, useState } from 'react';
import FocusTrap from 'focus-trap-react';
import {
Dialog,
Overlay,
OverlayCenter,
OverlayBackdrop,
Header,
config,
Box,
Text,
IconButton,
Icon,
Icons,
color,
Button,
Chip,
PopOut,
RectCords,
} from 'folds';
import { stopPropagation } from '$utils/keyboard';
import { timeDayMonthYear, timeHourMinute, hoursToMs, daysToMs } from '$utils/time';
import { DatePicker, TimePicker } from '$components/time-date';
import { useSetting } from '$state/hooks/settings';
import { settingsAtom } from '$state/settings';
type SchedulePickerDialogProps = {
initialTime?: number;
showEncryptionWarning?: boolean;
onCancel: () => void;
onSubmit: (scheduledDate: Date) => void;
};
export function SchedulePickerDialog({
initialTime,
showEncryptionWarning,
onCancel,
onSubmit,
}: SchedulePickerDialogProps) {
const now = Date.now();
const maxDelay = daysToMs(30);
const defaultTs = initialTime ?? now + hoursToMs(1);
const [ts, setTs] = useState(() => Math.max(defaultTs, now + 60000));
const [error, setError] = useState<string>();
const [hour24Clock] = useSetting(settingsAtom, 'hour24Clock');
const [timePickerCords, setTimePickerCords] = useState<RectCords>();
const [datePickerCords, setDatePickerCords] = useState<RectCords>();
const handleTimePicker: MouseEventHandler<HTMLButtonElement> = (evt) => {
setTimePickerCords(evt.currentTarget.getBoundingClientRect());
};
const handleDatePicker: MouseEventHandler<HTMLButtonElement> = (evt) => {
setDatePickerCords(evt.currentTarget.getBoundingClientRect());
};
const handlePreset = (offsetMs: number) => {
setTs(Date.now() + offsetMs);
setError(undefined);
};
const handleSubmit = () => {
const delay = ts - Date.now();
if (delay <= 0) {
setError('Scheduled time must be in the future');
return;
}
if (delay > maxDelay) {
setError('Cannot schedule more than 30 days in advance');
return;
}
setError(undefined);
onSubmit(new Date(ts));
};
const isPast = ts <= now;
return (
<Overlay open backdrop={<OverlayBackdrop />}>
<OverlayCenter>
<FocusTrap
focusTrapOptions={{
initialFocus: false,
onDeactivate: onCancel,
clickOutsideDeactivates: true,
escapeDeactivates: stopPropagation,
}}
>
<Dialog variant="Surface">
<Header
style={{
padding: `0 ${config.space.S200} 0 ${config.space.S400}`,
borderBottomWidth: config.borderWidth.B300,
}}
variant="Surface"
size="500"
>
<Box grow="Yes">
<Text size="H4">Schedule Send</Text>
</Box>
<IconButton size="300" onClick={onCancel} radii="300">
<Icon src={Icons.Cross} />
</IconButton>
</Header>
<Box direction="Column" gap="500" style={{ padding: config.space.S400 }}>
<Box direction="Row" gap="300">
<Box direction="Column" gap="100">
<Text size="L400" priority="400">
Time
</Text>
<Box gap="100" alignItems="Center">
<Chip
size="500"
variant="Surface"
fill="None"
outlined
radii="300"
aria-pressed={!!timePickerCords}
after={<Icon size="50" src={Icons.ChevronBottom} />}
onClick={handleTimePicker}
>
<Text size="B300">{timeHourMinute(ts, hour24Clock)}</Text>
</Chip>
<PopOut
anchor={timePickerCords}
offset={5}
position="Bottom"
align="Center"
content={
<FocusTrap
focusTrapOptions={{
initialFocus: false,
onDeactivate: () => setTimePickerCords(undefined),
clickOutsideDeactivates: true,
isKeyForward: (evt: KeyboardEvent) =>
evt.key === 'ArrowDown' || evt.key === 'ArrowRight',
isKeyBackward: (evt: KeyboardEvent) =>
evt.key === 'ArrowUp' || evt.key === 'ArrowLeft',
escapeDeactivates: stopPropagation,
}}
>
<TimePicker
min={now}
max={now + maxDelay}
value={ts}
onChange={setTs}
/>
</FocusTrap>
}
/>
</Box>
</Box>
<Box direction="Column" gap="100">
<Text size="L400" priority="400">
Date
</Text>
<Box gap="100" alignItems="Center">
<Chip
size="500"
variant="Surface"
fill="None"
outlined
radii="300"
aria-pressed={!!datePickerCords}
after={<Icon size="50" src={Icons.ChevronBottom} />}
onClick={handleDatePicker}
>
<Text size="B300">{timeDayMonthYear(ts)}</Text>
</Chip>
<PopOut
anchor={datePickerCords}
offset={5}
position="Bottom"
align="Center"
content={
<FocusTrap
focusTrapOptions={{
initialFocus: false,
onDeactivate: () => setDatePickerCords(undefined),
clickOutsideDeactivates: true,
isKeyForward: (evt: KeyboardEvent) =>
evt.key === 'ArrowDown' || evt.key === 'ArrowRight',
isKeyBackward: (evt: KeyboardEvent) =>
evt.key === 'ArrowUp' || evt.key === 'ArrowLeft',
escapeDeactivates: stopPropagation,
}}
>
<DatePicker
min={now}
max={now + maxDelay}
value={ts}
onChange={setTs}
/>
</FocusTrap>
}
/>
</Box>
</Box>
</Box>
<Box direction="Column" gap="100">
<Text size="L400">Quick Schedule</Text>
<Box gap="200" wrap="Wrap">
<Chip
variant="SurfaceVariant"
radii="Pill"
onClick={() => handlePreset(hoursToMs(1))}
>
<Text size="B300">In 1 hour</Text>
</Chip>
<Chip
variant="SurfaceVariant"
radii="Pill"
onClick={() => handlePreset(hoursToMs(4))}
>
<Text size="B300">In 4 hours</Text>
</Chip>
<Chip
variant="SurfaceVariant"
radii="Pill"
onClick={() => {
const tomorrow = new Date();
tomorrow.setDate(tomorrow.getDate() + 1);
tomorrow.setHours(9, 0, 0, 0);
setTs(tomorrow.getTime());
setError(undefined);
}}
>
<Text size="B300">Tomorrow 9 AM</Text>
</Chip>
<Chip
variant="SurfaceVariant"
radii="Pill"
onClick={() => {
const tomorrow = new Date();
tomorrow.setDate(tomorrow.getDate() + 1);
tomorrow.setHours(14, 0, 0, 0);
setTs(tomorrow.getTime());
setError(undefined);
}}
>
<Text size="B300">Tomorrow 2 PM</Text>
</Chip>
</Box>
</Box>
{showEncryptionWarning && (
<Text size="T300" priority="400">
Note: This message will be encrypted with current room keys. Devices that join
or are added after scheduling may not be able to decrypt it.
</Text>
)}
{(error || isPast) && (
<Text style={{ color: color.Critical.Main }} size="T300">
{error || 'Selected time is in the past'}
</Text>
)}
<Button
type="submit"
variant="Primary"
aria-disabled={isPast}
onClick={handleSubmit}
>
<Text size="B400">Schedule Send</Text>
</Button>
</Box>
</Dialog>
</FocusTrap>
</OverlayCenter>
</Overlay>
);
}
@@ -0,0 +1,32 @@
import { style } from '@vanilla-extract/css';
import { config, toRem } from 'folds';
export const ScheduledMessagesToggle = style({
padding: `${config.space.S100} ${config.space.S400}`,
});
export const ScheduledMessagesPanel = style({
padding: `${config.space.S200} ${config.space.S400}`,
maxHeight: toRem(200),
overflowY: 'auto',
});
export const ScheduledMessageRow = style({
padding: `${config.space.S200} 0`,
borderBottomWidth: config.borderWidth.B300,
borderBottomStyle: 'solid',
borderBottomColor: 'currentcolor',
opacity: 0.8,
selectors: {
'&:last-child': {
borderBottom: 'none',
},
},
});
export const MessagePreview = style({
overflow: 'hidden',
textOverflow: 'ellipsis',
whiteSpace: 'nowrap',
maxWidth: toRem(300),
});
@@ -0,0 +1,182 @@
import React, { useCallback, useState } from 'react';
import { useQuery, useQueryClient } from '@tanstack/react-query';
import { Box, Text, Chip, Icon, Icons, IconButton } from 'folds';
import { Room } from '$types/matrix-sdk';
import { useAtom, useAtomValue, useSetAtom } from 'jotai';
import { useMatrixClient } from '$hooks/useMatrixClient';
import { getDelayedEvents, cancelDelayedEvent } from '$utils/delayedEvents';
import {
delayedEventsSupportedAtom,
roomIdToScheduledTimeAtomFamily,
roomIdToEditingScheduledDelayIdAtomFamily,
} from '$state/scheduledMessages';
import { timeHourMinute, timeDayMonthYear } from '$utils/time';
import { useSetting } from '$state/hooks/settings';
import { settingsAtom } from '$state/settings';
import { SchedulePickerDialog } from './SchedulePickerDialog';
import * as css from './ScheduledMessagesList.css';
type ScheduledMessagesListProps = {
room: Room;
onEditMessage?: (body: string, formattedBody?: string) => void;
};
export function ScheduledMessagesList({ room, onEditMessage }: ScheduledMessagesListProps) {
const mx = useMatrixClient();
const queryClient = useQueryClient();
const supported = useAtomValue(delayedEventsSupportedAtom);
const setScheduledTime = useSetAtom(roomIdToScheduledTimeAtomFamily(room.roomId));
const [hour24Clock] = useSetting(settingsAtom, 'hour24Clock');
const [expanded, setExpanded] = useState(false);
const [editingDelayId, setEditingDelayId] = useAtom(
roomIdToEditingScheduledDelayIdAtomFamily(room.roomId)
);
const { data } = useQuery({
queryKey: ['delayedEvents', room.roomId],
queryFn: () => getDelayedEvents(mx),
refetchInterval: 30000,
enabled: supported,
});
const roomEvents = data?.delayed_events.filter(
(evt) =>
evt.room_id === room.roomId &&
(evt.type === 'm.room.message' || evt.type === 'm.room.encrypted')
);
const invalidateEvents = useCallback(() => {
queryClient.invalidateQueries({ queryKey: ['delayedEvents', room.roomId] });
}, [queryClient, room.roomId]);
const handleCancel = useCallback(
async (delayId: string) => {
await cancelDelayedEvent(mx, delayId);
invalidateEvents();
},
[mx, invalidateEvents]
);
const handleEdit = useCallback(
(delayId: string, body: string, formattedBody?: string, scheduledTs?: number) => {
if (onEditMessage) {
onEditMessage(body, formattedBody);
}
if (scheduledTs) {
setScheduledTime(new Date(scheduledTs));
}
setEditingDelayId(delayId);
},
[onEditMessage, setScheduledTime, setEditingDelayId]
);
const handleReschedule = useCallback(
(scheduledDate: Date) => {
setScheduledTime(scheduledDate);
setEditingDelayId(null);
},
[setScheduledTime, setEditingDelayId]
);
const visibleEvents = roomEvents?.filter((e) => e.delay_id !== editingDelayId) ?? [];
if (!supported || visibleEvents.length === 0) {
return null;
}
return (
<Box direction="Column">
<Box className={css.ScheduledMessagesToggle}>
<Chip
variant="SurfaceVariant"
radii="Pill"
before={<Icon size="50" src={Icons.Clock} />}
after={
<Icon size="50" src={expanded ? Icons.ChevronTop : Icons.ChevronBottom} />
}
onClick={() => setExpanded(!expanded)}
>
<Text size="B300">
{visibleEvents.length} scheduled{' '}
{visibleEvents.length === 1 ? 'message' : 'messages'}
</Text>
</Chip>
</Box>
{expanded && (
<Box direction="Column" className={css.ScheduledMessagesPanel}>
{visibleEvents.map((evt) => {
const deliveryTs =
'delay' in evt ? evt.running_since + evt.delay : evt.running_since;
const isEncryptedEvt = evt.type === 'm.room.encrypted';
const body = isEncryptedEvt
? ''
: typeof evt.content.body === 'string'
? evt.content.body
: '';
const formattedBody =
!isEncryptedEvt && typeof evt.content.formatted_body === 'string'
? evt.content.formatted_body
: undefined;
return (
<Box
key={evt.delay_id}
className={css.ScheduledMessageRow}
direction="Row"
gap="200"
alignItems="Center"
justifyContent="SpaceBetween"
>
<Box direction="Column" gap="100" grow="Yes" style={{ minWidth: 0 }}>
{isEncryptedEvt ? (
<Box direction="Row" gap="100" alignItems="Center">
<Icon size="50" src={Icons.Lock} />
<Text size="T300" priority="300">
Encrypted — cancel and resend to edit
</Text>
</Box>
) : (
<Text className={css.MessagePreview} size="T300">
{body}
</Text>
)}
<Text size="T200" priority="300">
{timeDayMonthYear(deliveryTs)} at {timeHourMinute(deliveryTs, hour24Clock)}
</Text>
</Box>
<Box gap="100" shrink="No">
{!isEncryptedEvt && (
<IconButton
size="300"
variant="SurfaceVariant"
radii="300"
onClick={() => handleEdit(evt.delay_id, body, formattedBody, deliveryTs)}
aria-label="Edit scheduled message"
>
<Icon size="50" src={Icons.Pencil} />
</IconButton>
)}
<IconButton
size="300"
variant="Critical"
radii="300"
onClick={() => handleCancel(evt.delay_id)}
aria-label="Cancel scheduled message"
>
<Icon size="50" src={Icons.Cross} />
</IconButton>
</Box>
</Box>
);
})}
</Box>
)}
{editingDelayId && !onEditMessage && (
<SchedulePickerDialog
onCancel={() => setEditingDelayId(null)}
onSubmit={handleReschedule}
/>
)}
</Box>
);
}
@@ -0,0 +1,2 @@
export { SchedulePickerDialog } from './SchedulePickerDialog';
export { ScheduledMessagesList } from './ScheduledMessagesList';
+20
View File
@@ -0,0 +1,20 @@
import { useEffect } from 'react';
import { useSetAtom } from 'jotai';
import { useMatrixClient } from '$hooks/useMatrixClient';
import { delayedEventsSupportedAtom } from '$state/scheduledMessages';
import { supportsDelayedEvents } from '$utils/delayedEvents';
export function useDelayedEventsSupport(): void {
const mx = useMatrixClient();
const setSupported = useSetAtom(delayedEventsSupportedAtom);
useEffect(() => {
let cancelled = false;
supportsDelayedEvents(mx).then((supported) => {
if (!cancelled) setSupported(supported);
});
return () => {
cancelled = true;
};
}, [mx, setSupported]);
}
+15
View File
@@ -0,0 +1,15 @@
import { atom } from 'jotai';
import { atomFamily } from 'jotai/utils';
export const delayedEventsSupportedAtom = atom<boolean>(false);
export const roomIdToScheduledTimeAtomFamily = atomFamily<string, ReturnType<typeof atom<Date | null>>>(
() => atom<Date | null>(null)
);
// Save the delay_id instead of cancelling the message immediately in case
// the edit process is cancelled
export const roomIdToEditingScheduledDelayIdAtomFamily = atomFamily<
string,
ReturnType<typeof atom<string | null>>
>(() => atom<string | null>(null));
+114
View File
@@ -0,0 +1,114 @@
import {
EventType,
IContent,
MatrixClient,
MatrixEvent,
Room,
UpdateDelayedEventAction,
} from '$types/matrix-sdk';
import type {
DelayedEventInfo,
SendDelayedEventResponse,
} from '$types/matrix-sdk';
// Grab types needed for encryption
interface EncryptableBackend {
encryptEvent(event: MatrixEvent, room: Room): Promise<void>;
}
export async function supportsDelayedEvents(mx: MatrixClient): Promise<boolean> {
try {
return await mx.doesServerSupportUnstableFeature('org.matrix.msc4140');
} catch {
return false;
}
}
export async function sendDelayedMessage(
mx: MatrixClient,
roomId: string,
content: IContent,
delayMs: number,
threadId?: string | null
): Promise<SendDelayedEventResponse> {
return mx._unstable_sendDelayedEvent(
roomId,
{ delay: delayMs },
threadId ?? null,
EventType.RoomMessage,
content as any // eslint-disable-line @typescript-eslint/no-explicit-any
);
}
/**
* Send a delayed message in an E2EE room by pre-encrypting the content at
* scheduling time. The message is encrypted with the current Megolm session.
* Devices that join or add new device keys after this call will not be
* able to decrypt it.
*/
export async function sendDelayedMessageE2EE(
mx: MatrixClient,
roomId: string,
room: Room,
content: IContent,
delayMs: number,
threadId?: string | null
): Promise<SendDelayedEventResponse> {
const crypto = mx.getCrypto();
if (!crypto || !('encryptEvent' in crypto)) {
throw new Error('Encryption not available: no crypto backend with encryptEvent');
}
// Create a temporary MatrixEvent to encrypt in-place.
const event = new MatrixEvent({
type: EventType.RoomMessage,
content,
room_id: roomId,
sender: mx.getUserId() ?? '',
event_id: `~${roomId}:${Date.now()}`,
origin_server_ts: Date.now(),
unsigned: {},
});
// Minimal interface to CryptoAPI
await (crypto as unknown as EncryptableBackend).encryptEvent(event, room);
// After encryption:
// event.getWireType() === 'm.room.encrypted'
// event.getWireContent() === the Megolm ciphertext object
// Pass the pre-encrypted payload directly to the delayed-events API.
// eslint-disable-next-line @typescript-eslint/no-explicit-any
return (mx as any)._unstable_sendDelayedEvent(
roomId,
{ delay: delayMs },
threadId ?? null,
event.getWireType(),
event.getWireContent()
);
}
export async function getDelayedEvents(
mx: MatrixClient
): Promise<DelayedEventInfo> {
return mx._unstable_getDelayedEvents();
}
export async function cancelDelayedEvent(
mx: MatrixClient,
delayId: string
): Promise<void> {
await mx._unstable_updateDelayedEvent(delayId, UpdateDelayedEventAction.Cancel);
}
export async function sendDelayedEventNow(
mx: MatrixClient,
delayId: string
): Promise<void> {
await mx._unstable_updateDelayedEvent(delayId, UpdateDelayedEventAction.Send);
}
export function computeDelayMs(targetDate: Date): number {
const delay = targetDate.getTime() - Date.now();
if (delay <= 0) throw new Error('Scheduled time must be in the future');
return delay;
}