refactor: consolidate message handling

This commit is contained in:
7w1 committed 2026-07-20 21:45:18 -05:00
1 parent 348c8a44a7
commit a092f66de2
15 files changed
+1067 -2151

No files matched your search

@@ -0,0 +1,5 @@
---
default: patch
---
Refactored all message renderers to use a single shared system for visual consistency.
@@ -0,0 +1,513 @@
import type { ComponentProps, MouseEventHandler, ReactNode } from 'react';
import { useCallback, useEffect, useMemo, useState } from 'react';
import type { HTMLReactParserOptions } from 'html-react-parser';
import type { Opts as LinkifyOpts } from 'linkifyjs';
import { Avatar, Box, Text } from 'folds';
import type { IImageContent } from '$types/matrix/common';
import type { MatrixEvent, Room } from '$types/matrix-sdk';
import { EventType, MatrixEventEvent } from '$types/matrix-sdk';
import { M_POLL_START } from 'matrix-js-sdk';
import { useAtomValue } from 'jotai';
import {
AvatarBase,
ImageContent,
MessageNotDecryptedContent,
MessageUnsupportedContent,
ModernLayout,
MSticker,
RedactedContent,
Reply,
Time,
Username,
UsernameBold,
type RenderImageContentProps,
} from '$components/message';
import { UserAvatar } from '$components/user-avatar';
import { Image } from '$components/media';
import { ImageViewer } from '$components/image-viewer';
import { RenderMessageContent } from '$components/RenderMessageContent';
import { PowerIcon } from '$components/power';
import { userFallbackIcon } from '$components/icons/phosphor';
import { EncryptedContent, Pronouns } from '$features/room/message';
import { useMatrixClient } from '$hooks/useMatrixClient';
import { useMatrixEventRenderer } from '$hooks/useMatrixEventRenderer';
import { useMediaAuthentication } from '$hooks/useMediaAuthentication';
import { useRoomMemberHydration } from '$hooks/useRoomMemberHydration';
import { useSableCosmetics } from '$hooks/useSableCosmetics';
import { useRoomCreators } from '$hooks/useRoomCreators';
import { usePowerLevels } from '$hooks/usePowerLevels';
import { useGetMemberPowerTag, getPowerTagIconSrc } from '$hooks/useMemberPowerTag';
import { useUserProfile, type UserProfile } from '$hooks/useUserProfile';
import { useOpenUserRoomProfile } from '$state/hooks/userRoomProfile';
import type { PerMessageProfileBeeperFormat } from '$hooks/usePerMessageProfile';
import { convertBeeperFormatToOurPerMessageProfile } from '$hooks/usePerMessageProfile';
import { getParsedPronouns } from '$utils/pronouns';
import { useMentionClickHandler } from '$hooks/useMentionClickHandler';
import { useSpoilerClickHandler } from '$hooks/useSpoilerClickHandler';
import { useSettingsLinkBaseUrl } from '$features/settings/useSettingsLinkBaseUrl';
import {
factoryRenderLinkifyWithMention,
getReactCustomHtmlParser,
LINKIFY_OPTS,
makeMentionCustomProps,
renderMatrixMention,
} from '$plugins/react-custom-html-parser';
import { nicknamesAtom } from '$state/nicknames';
import { settingsAtom } from '$state/settings';
import { useSetting } from '$state/hooks/settings';
import type { GetContentCallback } from '$types/matrix/room';
import { getEditedEvent, getMemberAvatarMxc, getMemberDisplayName } from '$utils/room';
import { getMxIdLocalPart, mxcUrlToHttp } from '$utils/matrix';
import * as customHtmlCss from '$styles/CustomHtml.css';
type MessagePreviewRendererOptions = {
room: Room;
mediaAutoLoad?: boolean;
urlPreview?: boolean;
htmlReactParserOptions: HTMLReactParserOptions;
linkifyOpts: LinkifyOpts;
};
type MessagePreviewRendererContext = MessagePreviewRendererOptions & {
mx: ReturnType<typeof useMatrixClient>;
};
function LazyImage(props: ComponentProps<typeof Image>) {
return <Image {...props} loading="lazy" />;
}
function resolvePreviewContent(
room: Room,
event: MatrixEvent,
fallbackGetContent: GetContentCallback
) {
const eventId = event.getId();
const timeline = eventId ? room.getTimelineForEvent(eventId) : undefined;
const editedEvent =
eventId && timeline ? getEditedEvent(eventId, event, timeline.getTimelineSet()) : undefined;
const fallbackContent = fallbackGetContent() as Record<string, unknown>;
const editedContent = editedEvent?.getContent()?.['m.new_content'] as
| Record<string, unknown>
| undefined;
return {
content: editedContent ?? fallbackContent,
edited: !!editedEvent || event.getContent()['m.new_content'] !== undefined,
};
}
function renderStickerImageContent(
mediaAutoLoad: boolean | undefined,
props: RenderImageContentProps
) {
return (
<ImageContent
{...props}
autoPlay={mediaAutoLoad}
renderImage={LazyImage}
renderViewer={(viewerProps) => <ImageViewer {...viewerProps} />}
/>
);
}
function renderRoomMessage(
ctx: MessagePreviewRendererContext,
event: MatrixEvent,
displayName: string,
getContent: GetContentCallback
) {
if (event.isRedacted()) {
return <RedactedContent reason={event.getUnsigned().redacted_because?.content.reason} />;
}
const resolved = resolvePreviewContent(ctx.room, event, getContent);
const content = resolved.content as { msgtype?: string };
const resolvedGetContent = (() => resolved.content) as GetContentCallback;
return (
<RenderMessageContent
displayName={displayName}
msgType={content.msgtype ?? ''}
ts={event.getTs()}
getContent={resolvedGetContent}
edited={resolved.edited}
mediaAutoLoad={ctx.mediaAutoLoad}
urlPreview={ctx.urlPreview}
htmlReactParserOptions={ctx.htmlReactParserOptions}
linkifyOpts={ctx.linkifyOpts}
outlineAttachment
mEvent={event}
mx={ctx.mx}
room={ctx.room}
/>
);
}
function renderEncryptedDecrypted(
ctx: MessagePreviewRendererContext,
event: MatrixEvent,
displayName: string,
decryptedEvent: MatrixEvent,
eventTimeline: NonNullable<ReturnType<Room['getTimelineForEvent']>>
) {
const eventId = event.getId()!;
if (decryptedEvent.isRedacted()) return <RedactedContent />;
const decryptedType = decryptedEvent.getType();
const stickerType: string = EventType.Sticker;
const messageType: string = EventType.RoomMessage;
const encryptedType: string = EventType.RoomMessageEncrypted;
if (decryptedType === stickerType) {
return (
<MSticker
content={decryptedEvent.getContent()}
renderImageContent={renderStickerImageContent.bind(null, ctx.mediaAutoLoad)}
/>
);
}
if (decryptedType === messageType) {
const editedEvent = getEditedEvent(eventId, decryptedEvent, eventTimeline.getTimelineSet());
const getContent = (() =>
editedEvent?.getContent()?.['m.new_content'] ??
decryptedEvent.getContent()) as GetContentCallback;
return renderRoomMessage(ctx, decryptedEvent, displayName, getContent);
}
if (decryptedType === encryptedType) {
return (
<Text>
<MessageNotDecryptedContent />
</Text>
);
}
return (
<Text>
<MessageUnsupportedContent />
</Text>
);
}
function renderEncrypted(
ctx: MessagePreviewRendererContext,
event: MatrixEvent,
displayName: string
) {
const eventId = event.getId()!;
const eventTimeline = ctx.room.getTimelineForEvent(eventId);
const decryptedEvent = eventTimeline?.getEvents().find((item) => item.getId() === eventId);
if (!decryptedEvent || !eventTimeline) return <MessageNotDecryptedContent />;
return (
<EncryptedContent mEvent={decryptedEvent}>
{renderEncryptedDecrypted.bind(null, ctx, event, displayName, decryptedEvent, eventTimeline)}
</EncryptedContent>
);
}
function renderSticker(
ctx: MessagePreviewRendererContext,
event: MatrixEvent,
_displayName: string,
getContent: GetContentCallback
) {
if (event.isRedacted()) {
return <RedactedContent reason={event.getUnsigned().redacted_because?.content.reason} />;
}
return (
<MSticker
content={getContent() as IImageContent}
renderImageContent={renderStickerImageContent.bind(null, ctx.mediaAutoLoad)}
/>
);
}
function renderFallback(_ctx: MessagePreviewRendererContext, event: MatrixEvent) {
if (event.isRedacted()) {
return <RedactedContent reason={event.getUnsigned().redacted_because?.content.reason} />;
}
return (
<Box grow="Yes" direction="Column">
<Text size="T400" priority="300">
<code className={customHtmlCss.Code}>{event.getType()}</code>
{' event'}
</Text>
</Box>
);
}
function renderTombstone(_ctx: MessagePreviewRendererContext, event: MatrixEvent) {
if (event.isRedacted()) {
return <RedactedContent reason={event.getUnsigned().redacted_because?.content.reason} />;
}
return <Text>{event.getContent().body ?? 'This room has been replaced.'}</Text>;
}
export function useMessagePreviewRenderer(options: MessagePreviewRendererOptions) {
const mx = useMatrixClient();
const context = useMemo<MessagePreviewRendererContext>(() => ({ ...options, mx }), [mx, options]);
const handlers = useMemo(
() => ({
[EventType.RoomMessage]: renderRoomMessage.bind(null, context),
[EventType.RoomMessageEncrypted]: renderEncrypted.bind(null, context),
[EventType.Sticker]: renderSticker.bind(null, context),
[EventType.RoomTombstone]: renderTombstone.bind(null, context),
[M_POLL_START.name]: renderRoomMessage.bind(null, context),
}),
[context]
);
return useMatrixEventRenderer<[MatrixEvent, string, GetContentCallback]>(
handlers,
undefined,
renderFallback.bind(null, context)
);
}
type RoomMessagePreviewRendererOptions = {
highlightRegex?: RegExp;
settingsLinkBaseUrl?: string;
};
export function useRoomMessagePreviewRenderer(
room: Room,
options: RoomMessagePreviewRendererOptions = {}
) {
const mx = useMatrixClient();
const useAuthentication = useMediaAuthentication();
const nicknames = useAtomValue(nicknamesAtom);
const defaultSettingsLinkBaseUrl = useSettingsLinkBaseUrl();
const settingsLinkBaseUrl = options.settingsLinkBaseUrl ?? defaultSettingsLinkBaseUrl;
const mentionClickHandler = useMentionClickHandler(room.roomId);
const spoilerClickHandler = useSpoilerClickHandler();
const [mediaAutoLoad] = useSetting(settingsAtom, 'mediaAutoLoad');
const [urlPreview] = useSetting(settingsAtom, 'urlPreview');
const [autoplayEmojis] = useSetting(settingsAtom, 'autoplayEmojis');
const [incomingInlineImagesDefaultHeight] = useSetting(
settingsAtom,
'incomingInlineImagesDefaultHeight'
);
const [incomingInlineImagesMaxHeight] = useSetting(settingsAtom, 'incomingInlineImagesMaxHeight');
const linkifyOpts = useMemo<LinkifyOpts>(
() => ({
...LINKIFY_OPTS,
render: factoryRenderLinkifyWithMention(
settingsLinkBaseUrl,
(href) =>
renderMatrixMention(
mx,
room.roomId,
href,
makeMentionCustomProps(mentionClickHandler),
nicknames
),
mentionClickHandler
),
}),
[mx, room.roomId, mentionClickHandler, nicknames, settingsLinkBaseUrl]
);
const htmlReactParserOptions = useMemo<HTMLReactParserOptions>(
() =>
getReactCustomHtmlParser(mx, room.roomId, {
settingsLinkBaseUrl,
linkifyOpts,
highlightRegex: options.highlightRegex,
useAuthentication,
handleSpoilerClick: spoilerClickHandler,
handleMentionClick: mentionClickHandler,
nicknames,
autoplayEmojis,
incomingInlineImagesDefaultHeight,
incomingInlineImagesMaxHeight,
}),
[
mx,
room.roomId,
settingsLinkBaseUrl,
linkifyOpts,
options.highlightRegex,
useAuthentication,
spoilerClickHandler,
mentionClickHandler,
nicknames,
autoplayEmojis,
incomingInlineImagesDefaultHeight,
incomingInlineImagesMaxHeight,
]
);
const rendererOptions = useMemo<MessagePreviewRendererOptions>(
() => ({
room,
mediaAutoLoad,
urlPreview,
htmlReactParserOptions,
linkifyOpts,
}),
[room, mediaAutoLoad, urlPreview, htmlReactParserOptions, linkifyOpts]
);
return useMessagePreviewRenderer(rendererOptions);
}
export type MessagePreviewProps = {
room: Room;
event: MatrixEvent;
renderContent: ReturnType<typeof useMessagePreviewRenderer>;
profile?: Partial<UserProfile>;
actions?: ReactNode;
onOpen?: MouseEventHandler<HTMLButtonElement>;
hour24Clock: boolean;
dateFormatString: string;
};
export function MessagePreview({
room,
event,
renderContent,
profile,
actions,
onOpen,
hour24Clock,
dateFormatString,
}: MessagePreviewProps) {
const mx = useMatrixClient();
const useAuthentication = useMediaAuthentication();
const nicknames = useAtomValue(nicknamesAtom);
const sender = event.getSender() ?? '';
const openUserRoomProfile = useOpenUserRoomProfile();
const [contentVersion, setContentVersion] = useState(0);
useEffect(() => {
const handleUpdate = () => setContentVersion((version) => version + 1);
event.on(MatrixEventEvent.Decrypted, handleUpdate);
event.on(MatrixEventEvent.Replaced, handleUpdate);
return () => {
event.off(MatrixEventEvent.Decrypted, handleUpdate);
event.off(MatrixEventEvent.Replaced, handleUpdate);
};
}, [event]);
useRoomMemberHydration(room, sender);
const userProfile = useUserProfile(sender, room, profile);
const { color, font } = useSableCosmetics(sender, room);
const powerLevels = usePowerLevels(room);
const creators = useRoomCreators(room);
const getMemberPowerTag = useGetMemberPowerTag(room, creators, powerLevels);
const fallbackDisplayName =
getMemberDisplayName(room, sender, nicknames) ??
userProfile.displayName ??
profile?.displayName ??
getMxIdLocalPart(sender) ??
sender;
const perMessageProfile = useMemo(() => {
void contentVersion;
const { content } = resolvePreviewContent(
room,
event,
() => event.getContent()['m.new_content'] ?? event.getContent()
);
const beeperProfile = content['com.beeper.per_message_profile'] as
| PerMessageProfileBeeperFormat
| undefined;
return beeperProfile ? convertBeeperFormatToOurPerMessageProfile(beeperProfile) : undefined;
}, [room, event, contentVersion]);
const [showPronouns] = useSetting(settingsAtom, 'showPronouns');
const [parsePronouns] = useSetting(settingsAtom, 'parsePronouns');
const { cleanedDisplayName: displayName, inlinePronoun } = useMemo(
() => getParsedPronouns(perMessageProfile?.name || fallbackDisplayName, parsePronouns),
[perMessageProfile?.name, fallbackDisplayName, parsePronouns]
);
const pronouns = useMemo(() => {
const resolved = [...(perMessageProfile?.pronouns ?? userProfile.pronouns ?? [])];
if (
inlinePronoun &&
!resolved.some((item) => item.summary?.toLowerCase() === inlinePronoun.toLowerCase())
) {
resolved.push({ summary: inlinePronoun, language: 'en' });
}
return resolved;
}, [perMessageProfile?.pronouns, userProfile.pronouns, inlinePronoun]);
const avatarMxc =
perMessageProfile?.avatarUrl ??
getMemberAvatarMxc(room, sender) ??
userProfile.avatarUrl ??
profile?.avatarUrl;
const memberPowerTag = getMemberPowerTag(sender);
const tagIconSrc = memberPowerTag?.icon
? getPowerTagIconSrc(mx, useAuthentication, memberPowerTag.icon)
: undefined;
const getContent = useCallback(
() => event.getContent()['m.new_content'] ?? event.getContent(),
[event]
) as GetContentCallback;
const handleUserClick: MouseEventHandler<HTMLButtonElement> = useCallback(
(evt) => {
evt.preventDefault();
evt.stopPropagation();
openUserRoomProfile(
room.roomId,
undefined,
sender,
evt.currentTarget.getBoundingClientRect()
);
},
[openUserRoomProfile, room.roomId, sender]
);
return (
<ModernLayout
before={
<AvatarBase>
<Avatar as="button" size="300" data-user-id={sender} onClick={handleUserClick}>
<UserAvatar
userId={sender}
src={
avatarMxc
? (mxcUrlToHttp(mx, avatarMxc, useAuthentication, 48, 48, 'crop') ?? undefined)
: undefined
}
alt={displayName}
renderFallback={() => userFallbackIcon('lg')}
/>
</Avatar>
</AvatarBase>
}
>
<Box gap="300" justifyContent="SpaceBetween" alignItems="Center" grow="Yes">
<Box gap="200" alignItems="Baseline">
<Box alignItems="Center" gap="200">
<Username
as="button"
data-user-id={sender}
onClick={handleUserClick}
onContextMenu={handleUserClick}
style={{ color, fontFamily: font }}
>
<Text as="span" truncate>
<UsernameBold>{displayName}</UsernameBold>
</Text>
</Username>
{showPronouns && <Pronouns pronouns={pronouns} tagColor={color ?? 'currentColor'} />}
{tagIconSrc && <PowerIcon size="100" iconSrc={tagIconSrc} />}
</Box>
<Time ts={event.getTs()} hour24Clock={hour24Clock} dateFormatString={dateFormatString} />
</Box>
{actions}
</Box>
{event.replyEventId && (
<Reply
room={room}
replyEventId={event.replyEventId}
threadRootId={event.threadRootId}
mentions={event.getContent()['m.mentions']}
onClick={onOpen}
/>
)}
<Box direction="Column" grow="Yes" style={{ minWidth: 0 }}>
{renderContent(event.getType(), false, event, displayName, getContent)}
</Box>
</ModernLayout>
);
}
@@ -0,0 +1 @@
export * from './MessagePreview';
@@ -1,11 +1,13 @@
import { useAtom } from 'jotai';
import type { ReactNode } from 'react';
import { useCallback, useEffect, useRef, useState } from 'react';
import { Box, IconButton, Text } from 'folds';
import { sizedIcon, X } from '$components/icons/phosphor';
import { createLogger } from '$utils/debug';
import type { InAppBannerNotification } from '$state/sessions';
import { inAppBannerAtom } from '$state/sessions';
import { MessagePreview, useRoomMessagePreviewRenderer } from '$components/message-preview';
import { useSetting } from '$state/hooks/settings';
import { settingsAtom } from '$state/settings';
import * as css from './NotificationBanner.css';
const log = createLogger('NotificationBanner');
@@ -31,31 +33,36 @@ function BodyText({ text, hovered }: { text: string; hovered: boolean }) {
);
}
// Same as BodyText but renders a pre-built ReactNode (rich HTML with mxc/mention transforms).
function BodyNode({ node, hovered }: { node: ReactNode; hovered: boolean }) {
const ref = useRef<HTMLDivElement>(null);
const [overflow, setOverflow] = useState(false);
useEffect(() => {
const el = ref.current;
if (!el) return;
setOverflow(el.scrollHeight > el.clientHeight);
}, [node]);
return (
<div ref={ref} className={css.BannerBody} data-overflow={overflow} data-hovered={hovered}>
<Text size="T200" priority="300">
{node}
</Text>
</div>
);
}
type BannerItemProps = {
notification: InAppBannerNotification;
onDismiss: (id: string) => void;
};
function BannerMessage({ notification }: { notification: InAppBannerNotification }) {
const room = notification.room!;
const event = notification.event!;
const renderContent = useRoomMessagePreviewRenderer(room);
const [hour24Clock] = useSetting(settingsAtom, 'hour24Clock');
const [dateFormatString] = useSetting(settingsAtom, 'dateFormatString');
return (
<MessagePreview
room={room}
event={event}
renderContent={renderContent}
actions={
notification.roomName && (
<Text size="T200" priority="300" truncate>
#{notification.roomName}
</Text>
)
}
hour24Clock={hour24Clock}
dateFormatString={dateFormatString}
/>
);
}
function BannerItem({ notification, onDismiss }: BannerItemProps) {
const [dismissing, setDismissing] = useState(false);
const [paused, setPaused] = useState(false);
@@ -118,7 +125,7 @@ function BannerItem({ notification, onDismiss }: BannerItemProps) {
onMouseEnter={handleMouseEnter}
onMouseLeave={handleMouseLeave}
>
{notification.icon && (
{!notification.event && notification.icon && (
<img
src={notification.icon}
alt=""
@@ -129,21 +136,23 @@ function BannerItem({ notification, onDismiss }: BannerItemProps) {
/>
)}
<div className={css.BannerContent}>
<Text size="T300" truncate className={css.BannerTitle}>
{notification.senderName ?? notification.title}
{(notification.roomName || notification.serverName) && (
<span className={css.BannerSubtitle}>
{' ('}
{notification.roomName && `#${notification.roomName}`}
{notification.roomName && notification.serverName && ', '}
{notification.serverName})
</span>
)}
</Text>
{notification.bodyNode ? (
<BodyNode node={notification.bodyNode} hovered={paused} />
{notification.room && notification.event ? (
<BannerMessage notification={notification} />
) : (
notification.body && <BodyText text={notification.body} hovered={paused} />
<>
<Text size="T300" truncate className={css.BannerTitle}>
{notification.senderName ?? notification.title}
{(notification.roomName || notification.serverName) && (
<span className={css.BannerSubtitle}>
{' ('}
{notification.roomName && `#${notification.roomName}`}
{notification.roomName && notification.serverName && ', '}
{notification.serverName})
</span>
)}
</Text>
{notification.body && <BodyText text={notification.body} hovered={paused} />}
</>
)}
</div>
<Box shrink="No">
@@ -56,10 +56,6 @@ export function MessageSearch({
const mx = useMatrixClient();
const mDirects = useAtomValue(mDirectAtom);
const allRooms = useRooms(mx, allRoomsAtom, mDirects);
const [mediaAutoLoad] = useSetting(settingsAtom, 'mediaAutoLoad');
const [urlPreview] = useSetting(settingsAtom, 'urlPreview');
const [legacyUsernameColor] = useSetting(settingsAtom, 'legacyUsernameColor');
const [hour24Clock] = useSetting(settingsAtom, 'hour24Clock');
const [dateFormatString] = useSetting(settingsAtom, 'dateFormatString');
@@ -295,10 +291,7 @@ export function MessageSearch({
room={groupRoom}
highlights={highlights}
items={group.items}
mediaAutoLoad={mediaAutoLoad}
urlPreview={urlPreview}
onOpen={navigateRoom}
legacyUsernameColor={legacyUsernameColor || mDirects.has(groupRoom.roomId)}
hour24Clock={hour24Clock}
dateFormatString={dateFormatString}
/>
@@ -1,164 +1,79 @@
import type { MouseEventHandler, ComponentProps } from 'react';
import { useEffect, useMemo, useState } from 'react';
import type { IEventWithRoomId, Room } from '$types/matrix-sdk';
import { JoinRule, RelationType, EventType } from '$types/matrix-sdk';
import type { IImageContent } from '$types/matrix/common';
import type { HTMLReactParserOptions } from 'html-react-parser';
import type { MouseEventHandler } from 'react';
import { useMemo } from 'react';
import type { Room } from '$types/matrix-sdk';
import { JoinRule, MatrixEvent, RelationType } from '$types/matrix-sdk';
import { Avatar, Box, Chip, Header, Text, config } from 'folds';
import type { Opts as LinkifyOpts } from 'linkifyjs';
import { useMatrixClient } from '$hooks/useMatrixClient';
import {
factoryRenderLinkifyWithMention,
getReactCustomHtmlParser,
LINKIFY_OPTS,
makeHighlightRegex,
makeMentionCustomProps,
renderMatrixMention,
} from '$plugins/react-custom-html-parser';
import { getMxIdLocalPart, mxcUrlToHttp } from '$utils/matrix';
import { useMatrixEventRenderer } from '$hooks/useMatrixEventRenderer';
import type { GetContentCallback } from '$types/matrix/room';
import {
AvatarBase,
ImageContent,
MSticker,
ModernLayout,
RedactedContent,
Reply,
Time,
Username,
UsernameBold,
type RenderImageContentProps,
} from '$components/message';
import { RenderMessageContent } from '$components/RenderMessageContent';
import { Image } from '$components/media';
import { ImageViewer } from '$components/image-viewer';
import * as customHtmlCss from '$styles/CustomHtml.css';
import { RoomAvatar, RoomIcon } from '$components/room-avatar';
import { getMemberAvatarMxc, getMemberDisplayName, getRoomAvatarUrl } from '$utils/room';
import { useAtomValue } from 'jotai';
import { nicknamesAtom } from '$state/nicknames';
import { profilesCacheAtom } from '$state/userRoomProfile';
import { MessagePreview, useRoomMessagePreviewRenderer } from '$components/message-preview';
import { SequenceCard } from '$components/sequence-card';
import { UserAvatar } from '$components/user-avatar';
import { userFallbackIcon } from '$components/icons/phosphor';
import { useMentionClickHandler } from '$hooks/useMentionClickHandler';
import { useSpoilerClickHandler } from '$hooks/useSpoilerClickHandler';
import { useMatrixClient } from '$hooks/useMatrixClient';
import { useMediaAuthentication } from '$hooks/useMediaAuthentication';
import { usePowerLevels } from '$hooks/usePowerLevels';
import { usePowerLevelTags } from '$hooks/usePowerLevelTags';
import { useTheme } from '$hooks/useTheme';
import { PowerIcon } from '$components/power';
import colorMXID from '$utils/colorMXID';
import {
getPowerTagIconSrc,
useAccessiblePowerTagColors,
useGetMemberPowerTag,
} from '$hooks/useMemberPowerTag';
import { useRoomCreators } from '$hooks/useRoomCreators';
import { useRoomCreatorsTag } from '$hooks/useRoomCreatorsTag';
import { useSettingsLinkBaseUrl } from '$features/settings/useSettingsLinkBaseUrl';
import { useSetting } from '$state/hooks/settings';
import { settingsAtom } from '$state/settings';
import { hydrateRoomMembers } from '$client/roomMemberHydration';
import { useRoomAvatar, useRoomName } from '$hooks/useRoomMeta';
import { makeHighlightRegex } from '$plugins/react-custom-html-parser';
import { mxcUrlToHttp } from '$utils/matrix';
import type { UserProfile } from '$hooks/useUserProfile';
import type { ResultItem } from './useMessageSearch';
type SearchResultRendererContext = {
mx: ReturnType<typeof useMatrixClient>;
type SearchResultItemProps = {
room: Room;
mediaAutoLoad?: boolean;
urlPreview?: boolean;
htmlReactParserOptions: HTMLReactParserOptions;
linkifyOpts: LinkifyOpts;
highlightRegex: RegExp | undefined;
item: ResultItem;
renderContent: ReturnType<typeof useRoomMessagePreviewRenderer>;
hour24Clock: boolean;
dateFormatString: string;
onOpen: (roomId: string, eventId: string) => void;
};
function LazyImage(props: ComponentProps<typeof Image>) {
return <Image {...props} loading="lazy" />;
}
function renderSearchStickerImageContent(
mediaAutoLoad: boolean | undefined,
props: RenderImageContentProps
) {
return (
<ImageContent
{...props}
autoPlay={mediaAutoLoad}
renderImage={LazyImage}
renderViewer={(p) => <ImageViewer {...p} />}
/>
function SearchResultItem({
room,
item,
renderContent,
hour24Clock,
dateFormatString,
onOpen,
}: SearchResultItemProps) {
const event = useMemo(() => new MatrixEvent(item.event), [item.event]);
const sender = event.getSender() ?? '';
const contextProfile = item.context?.profile_info?.[sender];
const profile = useMemo<Partial<UserProfile> | undefined>(
() =>
contextProfile
? {
displayName: contextProfile.displayname,
avatarUrl: contextProfile.avatar_url,
}
: undefined,
[contextProfile]
);
}
const relation = item.event.content['m.relates_to'];
const openEventId =
relation?.rel_type === RelationType.Replace ? relation.event_id : item.event.event_id;
function renderSearchResultRoomMessage(
ctx: SearchResultRendererContext,
event: IEventWithRoomId,
displayName: string,
getContent: GetContentCallback
) {
if (event.unsigned?.redacted_because) {
return <RedactedContent reason={event.unsigned?.redacted_because.content.reason} />;
}
const handleOpen: MouseEventHandler<HTMLButtonElement> = (evt) => {
evt.stopPropagation();
if (openEventId) onOpen(room.roomId, openEventId);
};
return (
<RenderMessageContent
displayName={displayName}
msgType={event.content.msgtype ?? ''}
ts={event.origin_server_ts}
getContent={getContent}
mediaAutoLoad={ctx.mediaAutoLoad}
urlPreview={ctx.urlPreview}
htmlReactParserOptions={ctx.htmlReactParserOptions}
linkifyOpts={ctx.linkifyOpts}
highlightRegex={ctx.highlightRegex}
outlineAttachment
mx={ctx.mx}
room={ctx.room}
/>
);
}
function renderSearchResultReaction(
ctx: SearchResultRendererContext,
event: IEventWithRoomId,
_displayName: string,
getContent: GetContentCallback
) {
if (event.unsigned?.redacted_because) {
return <RedactedContent reason={event.unsigned?.redacted_because.content.reason} />;
}
return (
<MSticker
content={getContent() as IImageContent}
renderImageContent={renderSearchStickerImageContent.bind(null, ctx.mediaAutoLoad)}
/>
);
}
function renderSearchResultTombstone(_ctx: SearchResultRendererContext, event: IEventWithRoomId) {
const { content } = event;
return (
<Box grow="Yes" direction="Column">
<Text size="T400" priority="300">
Room Tombstone. {content.body}
</Text>
</Box>
);
}
function renderSearchResultFallback(_ctx: SearchResultRendererContext, event: IEventWithRoomId) {
if (event.unsigned?.redacted_because) {
return <RedactedContent reason={event.unsigned?.redacted_because.content.reason} />;
}
return (
<Box grow="Yes" direction="Column">
<Text size="T400" priority="300">
<code className={customHtmlCss.Code}>{event.type}</code>
{' event'}
</Text>
</Box>
<SequenceCard
style={{ padding: config.space.S400 }}
variant="SurfaceVariant"
direction="Column"
>
<MessagePreview
room={room}
event={event}
profile={profile}
renderContent={renderContent}
actions={
<Chip onClick={handleOpen} variant="Secondary" radii="400">
<Text size="T200">Open</Text>
</Chip>
}
onOpen={handleOpen}
hour24Clock={hour24Clock}
dateFormatString={dateFormatString}
/>
</SequenceCard>
);
}
@@ -166,145 +81,25 @@ type SearchResultGroupProps = {
room: Room;
highlights: string[];
items: ResultItem[];
mediaAutoLoad?: boolean;
urlPreview?: boolean;
onOpen: (roomId: string, eventId: string) => void;
legacyUsernameColor?: boolean;
hour24Clock: boolean;
dateFormatString: string;
};
export function SearchResultGroup({
room,
highlights,
items,
mediaAutoLoad,
urlPreview,
onOpen,
legacyUsernameColor,
hour24Clock,
dateFormatString,
}: SearchResultGroupProps) {
const mx = useMatrixClient();
const useAuthentication = useMediaAuthentication();
const roomName = useRoomName(room);
const roomAvatarMxc = useRoomAvatar(room);
const highlightRegex = useMemo(() => makeHighlightRegex(highlights), [highlights]);
const powerLevels = usePowerLevels(room);
const creators = useRoomCreators(room);
const creatorsTag = useRoomCreatorsTag();
const powerLevelTags = usePowerLevelTags(room, powerLevels);
const getMemberPowerTag = useGetMemberPowerTag(room, creators, powerLevels);
const theme = useTheme();
const accessibleTagColors = useAccessiblePowerTagColors(theme.kind, creatorsTag, powerLevelTags);
const nicknames = useAtomValue(nicknamesAtom);
const cachedProfiles = useAtomValue(profilesCacheAtom);
const [, forceUpdate] = useState(0);
useEffect(() => {
let disposed = false;
const unknownUserIds = items
.map((item) => item.event.sender)
.filter((sender) => sender && !room.getMember(sender));
if (unknownUserIds.length > 0) {
hydrateRoomMembers(mx, room.roomId, unknownUserIds).then(() => {
if (!disposed) forceUpdate((n) => n + 1);
});
}
return () => {
disposed = true;
};
}, [mx, room, items]);
const settingsLinkBaseUrl = useSettingsLinkBaseUrl();
const [incomingInlineImagesDefaultHeight] = useSetting(
settingsAtom,
'incomingInlineImagesDefaultHeight'
);
const [incomingInlineImagesMaxHeight] = useSetting(settingsAtom, 'incomingInlineImagesMaxHeight');
const mentionClickHandler = useMentionClickHandler(room.roomId);
const spoilerClickHandler = useSpoilerClickHandler();
const linkifyOpts = useMemo<LinkifyOpts>(
() => ({
...LINKIFY_OPTS,
render: factoryRenderLinkifyWithMention(
settingsLinkBaseUrl,
(href) =>
renderMatrixMention(
mx,
room.roomId,
href,
makeMentionCustomProps(mentionClickHandler),
nicknames
),
mentionClickHandler
),
}),
[mx, room, mentionClickHandler, nicknames, settingsLinkBaseUrl]
);
const htmlReactParserOptions = useMemo<HTMLReactParserOptions>(
() =>
getReactCustomHtmlParser(mx, room.roomId, {
settingsLinkBaseUrl,
linkifyOpts,
highlightRegex,
useAuthentication,
handleSpoilerClick: spoilerClickHandler,
handleMentionClick: mentionClickHandler,
nicknames,
incomingInlineImagesDefaultHeight,
incomingInlineImagesMaxHeight,
}),
[
mx,
room,
linkifyOpts,
highlightRegex,
mentionClickHandler,
spoilerClickHandler,
useAuthentication,
nicknames,
settingsLinkBaseUrl,
incomingInlineImagesDefaultHeight,
incomingInlineImagesMaxHeight,
]
);
const rendererContext = useMemo<SearchResultRendererContext>(
() => ({
mx,
room,
mediaAutoLoad,
urlPreview,
htmlReactParserOptions,
linkifyOpts,
highlightRegex,
}),
[mx, room, mediaAutoLoad, urlPreview, htmlReactParserOptions, linkifyOpts, highlightRegex]
);
const matrixEventHandlers = useMemo(
() => ({
[EventType.RoomMessage]: renderSearchResultRoomMessage.bind(null, rendererContext),
[EventType.Reaction]: renderSearchResultReaction.bind(null, rendererContext),
[EventType.RoomTombstone]: renderSearchResultTombstone.bind(null, rendererContext),
}),
[rendererContext]
);
const renderMatrixEvent = useMatrixEventRenderer<[IEventWithRoomId, string, GetContentCallback]>(
matrixEventHandlers,
undefined,
renderSearchResultFallback.bind(null, rendererContext)
);
const handleOpenClick: MouseEventHandler = (evt) => {
const eventId = evt.currentTarget.getAttribute('data-event-id');
if (!eventId) return;
onOpen(room.roomId, eventId);
};
const renderContent = useRoomMessagePreviewRenderer(room, { highlightRegex });
return (
<Box direction="Column" gap="200">
@@ -313,8 +108,13 @@ export function SearchResultGroup({
<Avatar size="200" radii="300">
<RoomAvatar
roomId={room.roomId}
src={getRoomAvatarUrl(mx, room, 96, useAuthentication)}
alt={room.name}
src={
roomAvatarMxc
? (mxcUrlToHttp(mx, roomAvatarMxc, useAuthentication, 96, 96, 'crop') ??
undefined)
: undefined
}
alt={roomName}
renderFallback={() => (
<RoomIcon
size="50"
@@ -326,116 +126,22 @@ export function SearchResultGroup({
/>
</Avatar>
<Text size="H4" truncate>
{room.name}
{roomName}
</Text>
</Box>
</Header>
<Box direction="Column" gap="100">
{items.map((item) => {
const { event } = item;
const displayName =
getMemberDisplayName(room, event.sender, nicknames) ??
item.context.profile_info?.[event.sender]?.displayname ??
cachedProfiles[event.sender]?.displayName ??
getMxIdLocalPart(event.sender) ??
event.sender;
const senderAvatarMxc = getMemberAvatarMxc(room, event.sender);
const relation = event.content['m.relates_to'];
const mainEventId =
relation?.rel_type === RelationType.Replace ? relation.event_id : event.event_id;
const getContent = (() =>
event.content['m.new_content'] ?? event.content) as GetContentCallback;
const replyEventId = relation?.['m.in_reply_to']?.event_id;
const threadRootId =
relation?.rel_type === RelationType.Thread ? relation.event_id : undefined;
const memberPowerTag = getMemberPowerTag(event.sender);
const tagColor = memberPowerTag?.color
? accessibleTagColors?.get(memberPowerTag.color)
: undefined;
const tagIconSrc = memberPowerTag?.icon
? getPowerTagIconSrc(mx, useAuthentication, memberPowerTag.icon)
: undefined;
const usernameColor = legacyUsernameColor ? colorMXID(event.sender) : tagColor;
return (
<SequenceCard
key={event.event_id}
style={{ padding: config.space.S400 }}
variant="SurfaceVariant"
direction="Column"
>
<ModernLayout
before={
<AvatarBase>
<Avatar size="300">
<UserAvatar
userId={event.sender}
src={
senderAvatarMxc
? (mxcUrlToHttp(
mx,
senderAvatarMxc,
useAuthentication,
48,
48,
'crop'
) ?? undefined)
: undefined
}
alt={displayName}
renderFallback={() => userFallbackIcon('lg')}
/>
</Avatar>
</AvatarBase>
}
>
<Box gap="300" justifyContent="SpaceBetween" alignItems="Center" grow="Yes">
<Box gap="200" alignItems="Baseline">
<Box alignItems="Center" gap="200">
<Username style={{ color: usernameColor }}>
<Text as="span" truncate>
<UsernameBold>{displayName}</UsernameBold>
</Text>
</Username>
{tagIconSrc && <PowerIcon size="100" iconSrc={tagIconSrc} />}
</Box>
<Time
ts={event.origin_server_ts}
hour24Clock={hour24Clock}
dateFormatString={dateFormatString}
/>
</Box>
<Box shrink="No" gap="200" alignItems="Center">
<Chip
data-event-id={mainEventId}
onClick={handleOpenClick}
variant="Secondary"
radii="400"
>
<Text size="T200">Open</Text>
</Chip>
</Box>
</Box>
{replyEventId && (
<Reply
room={room}
replyEventId={replyEventId}
threadRootId={threadRootId}
mentions={event.content['m.mentions']}
onClick={handleOpenClick}
/>
)}
{renderMatrixEvent(event.type, false, event, displayName, getContent)}
</ModernLayout>
</SequenceCard>
);
})}
{items.map((item) => (
<SearchResultItem
key={item.event.event_id}
room={room}
item={item}
renderContent={renderContent}
hour24Clock={hour24Clock}
dateFormatString={dateFormatString}
onOpen={onOpen}
/>
))}
</Box>
</Box>
);
+39 -211
View File
@@ -1,66 +1,21 @@
import type { ChangeEventHandler, MouseEventHandler } from 'react';
import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
import {
Box,
Header,
IconButton,
Input,
Scroll,
Spinner,
Text,
Avatar,
config,
Chip,
toRem,
} from 'folds';
import { useCallback, useEffect, useRef, useState } from 'react';
import { Box, Header, IconButton, Input, Scroll, Spinner, Text, config, Chip, toRem } from 'folds';
import type { EventTimelineSet, MatrixEvent, Room, Thread } from '$types/matrix-sdk';
import { EventType, NotificationCountType, RoomEvent, ThreadEvent } from '$types/matrix-sdk';
import { NotificationCountType, RoomEvent, ThreadEvent } from '$types/matrix-sdk';
import { useAtomValue } from 'jotai';
import type { HTMLReactParserOptions } from 'html-react-parser';
import type { Opts as LinkifyOpts } from 'linkifyjs';
import { useMatrixClient } from '$hooks/useMatrixClient';
import { useMediaAuthentication } from '$hooks/useMediaAuthentication';
import { useSettingsLinkBaseUrl } from '$features/settings/useSettingsLinkBaseUrl';
import { useRoomNavigate } from '$hooks/useRoomNavigate';
import { nicknamesAtom } from '$state/nicknames';
import { profilesCacheAtom } from '$state/userRoomProfile';
import { useRoomMemberHydration } from '$hooks/useRoomMemberHydration';
import { getMemberAvatarMxc, getMemberDisplayName, reactionOrEditEvent } from '$utils/room';
import { getMxIdLocalPart, mxcUrlToHttp } from '$utils/matrix';
import { UserAvatar } from '$components/user-avatar';
import { MessageNotDecryptedContent, MessageBadEncryptedContent } from '$components/message';
import {
Chats,
chipIcon,
composerIcon,
MagnifyingGlass,
userFallbackIcon,
X,
} from '$components/icons/phosphor';
import {
AvatarBase,
ModernLayout,
RedactedContent,
Time,
Username,
UsernameBold,
Reply,
} from '$components/message';
import { RenderMessageContent } from '$components/RenderMessageContent';
import { getMemberDisplayName, reactionOrEditEvent } from '$utils/room';
import { getMxIdLocalPart } from '$utils/matrix';
import { Chats, chipIcon, composerIcon, MagnifyingGlass, X } from '$components/icons/phosphor';
import { settingsAtom } from '$state/settings';
import { useSetting } from '$state/hooks/settings';
import type { GetContentCallback } from '$types/matrix/room';
import { useMentionClickHandler } from '$hooks/useMentionClickHandler';
import { useSpoilerClickHandler } from '$hooks/useSpoilerClickHandler';
import {
factoryRenderLinkifyWithMention,
getReactCustomHtmlParser,
LINKIFY_OPTS,
makeMentionCustomProps,
renderMatrixMention,
} from '$plugins/react-custom-html-parser';
import { MessagePreview, useRoomMessagePreviewRenderer } from '$components/message-preview';
import { UnreadBadge, UnreadBadgeCenter } from '$components/unread-badge';
import { EncryptedContent } from './message';
import * as css from './ThreadDrawer.css';
import { SidebarResizer } from '$pages/client/sidebar/SidebarResizer';
import { mobileOrTablet } from '$utils/user-agent';
@@ -73,59 +28,12 @@ type ThreadPreviewProps = {
};
function ThreadPreview({ room, thread, onClick, onJump }: ThreadPreviewProps) {
const mx = useMatrixClient();
const useAuthentication = useMediaAuthentication();
const navigateRoom = useRoomNavigate();
const { navigateRoom } = useRoomNavigate();
const nicknames = useAtomValue(nicknamesAtom);
const cachedProfiles = useAtomValue(profilesCacheAtom);
const settingsLinkBaseUrl = useSettingsLinkBaseUrl();
const [hour24Clock] = useSetting(settingsAtom, 'hour24Clock');
const [dateFormatString] = useSetting(settingsAtom, 'dateFormatString');
const [mediaAutoLoad] = useSetting(settingsAtom, 'mediaAutoLoad');
const [urlPreview] = useSetting(settingsAtom, 'urlPreview');
const mentionClickHandler = useMentionClickHandler(room.roomId);
const spoilerClickHandler = useSpoilerClickHandler();
const linkifyOpts = useMemo<LinkifyOpts>(
() => ({
...LINKIFY_OPTS,
render: factoryRenderLinkifyWithMention(
settingsLinkBaseUrl,
(href: string) =>
renderMatrixMention(
mx,
room.roomId,
href,
makeMentionCustomProps(mentionClickHandler),
nicknames
),
mentionClickHandler
),
}),
[mx, room.roomId, nicknames, mentionClickHandler, settingsLinkBaseUrl]
);
const htmlReactParserOptions = useMemo<HTMLReactParserOptions>(
() =>
getReactCustomHtmlParser(mx, room.roomId, {
settingsLinkBaseUrl,
linkifyOpts,
handleSpoilerClick: spoilerClickHandler,
handleMentionClick: mentionClickHandler,
useAuthentication,
nicknames,
}),
[
mx,
room,
linkifyOpts,
mentionClickHandler,
spoilerClickHandler,
useAuthentication,
nicknames,
settingsLinkBaseUrl,
]
);
const renderContent = useRoomMessagePreviewRenderer(room);
const handleJumpClick: MouseEventHandler = useCallback(
(evt) => {
@@ -153,9 +61,6 @@ function ThreadPreview({ room, thread, onClick, onJump }: ThreadPreviewProps) {
);
const { rootEvent } = thread;
const senderId = rootEvent?.getSender() ?? '';
useRoomMemberHydration(room, senderId);
const lastReply = thread.events.findLast(
(ev: MatrixEvent) => ev.getId() !== thread.id && !reactionOrEditEvent(ev)
);
@@ -164,14 +69,6 @@ function ThreadPreview({ room, thread, onClick, onJump }: ThreadPreviewProps) {
if (!rootEvent) return null;
const displayName =
getMemberDisplayName(room, senderId, nicknames) ??
cachedProfiles[senderId]?.displayName ??
getMxIdLocalPart(senderId) ??
senderId;
const senderAvatarMxc = getMemberAvatarMxc(room, senderId);
const getContent = (() => rootEvent.getContent()) as GetContentCallback;
const localReplyCount = thread.events.filter(
(ev: MatrixEvent) => ev.getId() !== thread.id && !reactionOrEditEvent(ev)
).length;
@@ -194,38 +91,11 @@ function ThreadPreview({ room, thread, onClick, onJump }: ThreadPreviewProps) {
className={css.ThreadBrowserItem}
onClick={() => onClick(thread.id)}
>
<ModernLayout
before={
<AvatarBase>
<Avatar size="300">
<UserAvatar
userId={senderId}
src={
senderAvatarMxc
? (mxcUrlToHttp(mx, senderAvatarMxc, useAuthentication, 48, 48, 'crop') ??
undefined)
: undefined
}
alt={displayName}
renderFallback={() => userFallbackIcon('lg')}
/>
</Avatar>
</AvatarBase>
}
>
<Box gap="300" justifyContent="SpaceBetween" alignItems="Center" grow="Yes">
<Box gap="200" alignItems="Baseline">
<Username>
<Text as="span" truncate>
<UsernameBold>{displayName}</UsernameBold>
</Text>
</Username>
<Time
ts={rootEvent.getTs()}
hour24Clock={hour24Clock}
dateFormatString={dateFormatString}
/>
</Box>
<MessagePreview
room={room}
event={rootEvent}
renderContent={renderContent}
actions={
<Box shrink="No" alignItems="Center" gap="200">
{unreadTotal > 0 && (
<UnreadBadgeCenter>
@@ -236,74 +106,32 @@ function ThreadPreview({ room, thread, onClick, onJump }: ThreadPreviewProps) {
<Text size="T200">Jump</Text>
</Chip>
</Box>
</Box>
{rootEvent.replyEventId && (
<Reply
room={room}
replyEventId={rootEvent.replyEventId}
threadRootId={rootEvent.threadRootId}
mentions={rootEvent.getContent()['m.mentions']}
onClick={handleJumpClick}
/>
)}
<Box style={{ maxHeight: '200px', overflow: 'auto', flexShrink: 0 }}>
<EncryptedContent mEvent={rootEvent}>
{() => {
if (rootEvent.isRedacted()) {
return <RedactedContent />;
}
const type = rootEvent.getType();
if (type === (EventType.RoomMessageEncrypted as string)) {
return <MessageNotDecryptedContent />;
}
if (rootEvent.isDecryptionFailure()) {
return <MessageBadEncryptedContent />;
}
return (
<RenderMessageContent
displayName={displayName}
msgType={rootEvent.getContent().msgtype ?? ''}
ts={rootEvent.getTs()}
getContent={getContent}
edited={!!rootEvent.replacingEvent()}
mediaAutoLoad={mediaAutoLoad}
urlPreview={urlPreview}
htmlReactParserOptions={htmlReactParserOptions}
linkifyOpts={linkifyOpts}
outlineAttachment
mEvent={rootEvent}
mx={mx}
room={room}
/>
);
}}
</EncryptedContent>
</Box>
{replyCount > 0 && (
<Box gap="100" alignItems="Center" style={{ marginTop: config.space.S200 }}>
<Text size="T200" priority="300" style={{ flexShrink: 0 }}>
{replyCount} {replyCount === 1 ? 'reply' : 'replies'}
}
onOpen={handleJumpClick}
hour24Clock={hour24Clock}
dateFormatString={dateFormatString}
/>
{replyCount > 0 && (
<Box gap="100" alignItems="Center" style={{ marginTop: config.space.S200 }}>
<Text size="T200" priority="300" style={{ flexShrink: 0 }}>
{replyCount} {replyCount === 1 ? 'reply' : 'replies'}
</Text>
{lastReply && lastBody && (
<Text
size="T200"
priority="300"
style={{
overflow: 'hidden',
textOverflow: 'ellipsis',
whiteSpace: 'nowrap',
minWidth: 0,
}}
>
· {lastDisplayName}: {lastBody.slice(0, 60)}
</Text>
{lastReply && lastBody && (
<Text
size="T200"
priority="300"
style={{
overflow: 'hidden',
textOverflow: 'ellipsis',
whiteSpace: 'nowrap',
minWidth: 0,
}}
>
· {lastDisplayName}: {lastBody.slice(0, 60)}
</Text>
)}
</Box>
)}
</ModernLayout>
)}
</Box>
)}
</Box>
);
}
+1 -1
View File
@@ -225,7 +225,7 @@ function MorePronounsPill({ pronouns, tagColor, maxPillLength }: MorePronounsPil
* Component to render pronouns in the chat timeline.
* It also filters them.
*/
const Pronouns = as<
export const Pronouns = as<
'span',
{
pronouns?: PronounSet[];
@@ -1,9 +1,7 @@
import type { MouseEventHandler, ReactNode, ComponentProps } from 'react';
import type { MouseEventHandler, ReactNode } from 'react';
import { forwardRef, useCallback, useMemo, useRef } from 'react';
import type { MatrixEvent, Room, RoomPinnedEventsEventContent } from '$types/matrix-sdk';
import type { IImageContent } from '$types/matrix/common';
import {
Avatar,
Box,
Chip,
color,
@@ -16,107 +14,40 @@ import {
Text,
toRem,
} from 'folds';
import type { Opts as LinkifyOpts } from 'linkifyjs';
import type { HTMLReactParserOptions } from 'html-react-parser';
import { useAtomValue } from 'jotai';
import { useVirtualizer } from '@tanstack/react-virtual';
import { createLogger } from '$utils/debug';
import { useRoomPinnedEvents } from '$hooks/useRoomPinnedEvents';
import { SequenceCard } from '$components/sequence-card';
import { useRoomEvent } from '$hooks/useRoomEvent';
import { useMediaAuthentication } from '$hooks/useMediaAuthentication';
import {
AvatarBase,
DefaultPlaceholder,
ImageContent,
MessageNotDecryptedContent,
MessageUnsupportedContent,
ModernLayout,
MSticker,
RedactedContent,
Reply,
Time,
Username,
UsernameBold,
type RenderImageContentProps,
} from '$components/message';
import { UserAvatar } from '$components/user-avatar';
import {
dropzoneIcon,
menuIcon,
composerIcon,
PushPin,
userFallbackIcon,
X,
} from '$components/icons/phosphor';
import { getMxIdLocalPart, mxcUrlToHttp } from '$utils/matrix';
import { DefaultPlaceholder } from '$components/message';
import { dropzoneIcon, menuIcon, composerIcon, PushPin, X } from '$components/icons/phosphor';
import { useMatrixClient } from '$hooks/useMatrixClient';
import {
getEditedEvent,
getMemberAvatarMxc,
getMemberDisplayName,
getStateEvent,
} from '$utils/room';
import type { GetContentCallback } from '$types/matrix/room';
import { getStateEvent } from '$utils/room';
import type { StateEvents } from '$types/matrix-sdk';
import { useMentionClickHandler } from '$hooks/useMentionClickHandler';
import { useSpoilerClickHandler } from '$hooks/useSpoilerClickHandler';
import { useRoomMemberHydration } from '$hooks/useRoomMemberHydration';
import { useSettingsLinkBaseUrl } from '$features/settings/useSettingsLinkBaseUrl';
import {
factoryRenderLinkifyWithMention,
getReactCustomHtmlParser,
LINKIFY_OPTS,
makeMentionCustomProps,
renderMatrixMention,
} from '$plugins/react-custom-html-parser';
import type { RenderMatrixEvent } from '$hooks/useMatrixEventRenderer';
import { useMatrixEventRenderer } from '$hooks/useMatrixEventRenderer';
import { RenderMessageContent } from '$components/RenderMessageContent';
import { useSetting } from '$state/hooks/settings';
import { settingsAtom } from '$state/settings';
import * as customHtmlCss from '$styles/CustomHtml.css';
import { Image } from '$components/media';
import { ImageViewer } from '$components/image-viewer';
import { useRoomNavigate } from '$hooks/useRoomNavigate';
import { VirtualTile } from '$components/virtualizer';
import { usePowerLevelsContext } from '$hooks/usePowerLevels';
import { AsyncStatus, useAsyncCallback } from '$hooks/useAsyncCallback';
import { ContainerColor } from '$styles/ContainerColor.css';
import { usePowerLevelTags } from '$hooks/usePowerLevelTags';
import { useTheme } from '$hooks/useTheme';
import { PowerIcon } from '$components/power';
import { useRoomCreators } from '$hooks/useRoomCreators';
import { useRoomPermissions } from '$hooks/useRoomPermissions';
import type { GetMemberPowerTag } from '$hooks/useMemberPowerTag';
import {
getPowerTagIconSrc,
useAccessiblePowerTagColors,
useGetMemberPowerTag,
} from '$hooks/useMemberPowerTag';
import { useRoomCreatorsTag } from '$hooks/useRoomCreatorsTag';
import { nicknamesAtom } from '$state/nicknames';
import { profilesCacheAtom } from '$state/userRoomProfile';
import { useSableCosmetics } from '$hooks/useSableCosmetics';
import { EncryptedContent } from '$features/room/message';
import { MessagePreview, useRoomMessagePreviewRenderer } from '$components/message-preview';
import type { PinReadMarker } from '$features/room/RoomViewHeader';
import * as css from './RoomPinMenu.css';
import { CustomAccountDataEvent } from '$types/matrix/accountData';
import { EventType } from '$types/matrix-sdk';
import { M_POLL_START } from 'matrix-js-sdk';
const log = createLogger('RoomPinMenu');
type PinnedMessageProps = {
room: Room;
eventId: string;
renderContent: RenderMatrixEvent<[MatrixEvent, string, GetContentCallback]>;
renderContent: ReturnType<typeof useRoomMessagePreviewRenderer>;
onOpen: (roomId: string, eventId: string) => void;
canPinEvent: boolean;
getMemberPowerTag: GetMemberPowerTag;
accessibleTagColors: Map<string, string>;
hour24Clock: boolean;
dateFormatString: string;
isNew: boolean;
@@ -135,85 +66,20 @@ function PinnedMessageActiveContent(
renderContent,
hour24Clock,
dateFormatString,
getMemberPowerTag,
renderOptions,
handleOpenClick,
} = props;
const mx = useMatrixClient();
const useAuthentication = useMediaAuthentication();
const nicknames = useAtomValue(nicknamesAtom);
const cachedProfiles = useAtomValue(profilesCacheAtom);
const sender = pinnedEvent.getSender()!;
useRoomMemberHydration(room, sender);
const { color: usernameColor, font: usernameFont } = useSableCosmetics(sender, room);
const displayName =
getMemberDisplayName(room, sender, nicknames) ??
cachedProfiles[sender]?.displayName ??
getMxIdLocalPart(sender) ??
sender;
const senderAvatarMxc = getMemberAvatarMxc(room, sender);
const getContent = (() => pinnedEvent.getContent()) as GetContentCallback;
const content = pinnedEvent.getContent();
const memberPowerTag = getMemberPowerTag(sender);
const tagIconSrc = memberPowerTag?.icon
? getPowerTagIconSrc(mx, useAuthentication, memberPowerTag.icon)
: undefined;
return (
<ModernLayout
before={
<AvatarBase>
<Avatar size="300">
<UserAvatar
userId={sender}
src={
senderAvatarMxc
? (mxcUrlToHttp(mx, senderAvatarMxc, useAuthentication, 48, 48, 'crop') ??
undefined)
: undefined
}
alt={displayName}
renderFallback={() => userFallbackIcon('lg')}
/>
</Avatar>
</AvatarBase>
}
>
<Box gap="300" justifyContent="SpaceBetween" alignItems="Center" grow="Yes">
<Box gap="200" alignItems="Baseline">
<Box alignItems="Center" gap="200">
<Username style={{ color: usernameColor, font: usernameFont }}>
<Text as="span" truncate>
<UsernameBold>{displayName}</UsernameBold>
</Text>
</Username>
{tagIconSrc && <PowerIcon size="100" iconSrc={tagIconSrc} />}
</Box>
<Time
ts={pinnedEvent.getTs()}
hour24Clock={hour24Clock}
dateFormatString={dateFormatString}
/>
</Box>
{renderOptions()}
</Box>
{pinnedEvent.replyEventId && (
<Reply
room={room}
replyEventId={pinnedEvent.replyEventId}
threadRootId={pinnedEvent.threadRootId}
mentions={content['m.mentions']}
onClick={handleOpenClick}
/>
)}
<Box direction="Column" grow="Yes" style={{ minWidth: 0 }}>
{renderContent(pinnedEvent.getType(), false, pinnedEvent, displayName, getContent)}
</Box>
</ModernLayout>
<MessagePreview
room={room}
event={pinnedEvent}
renderContent={renderContent}
actions={renderOptions()}
onOpen={handleOpenClick}
hour24Clock={hour24Clock}
dateFormatString={dateFormatString}
/>
);
}
@@ -298,223 +164,6 @@ function PinnedMessage(props: PinnedMessageProps) {
);
}
type PinMenuRendererContext = {
mx: ReturnType<typeof useMatrixClient>;
room: Room;
mediaAutoLoad: boolean;
urlPreview: boolean;
htmlReactParserOptions: HTMLReactParserOptions;
linkifyOpts: LinkifyOpts;
};
function PinMenuLazyImage(props: ComponentProps<typeof Image>) {
return <Image {...props} loading="lazy" />;
}
function renderPinMenuStickerImageContent(
mediaAutoLoad: boolean | undefined,
props: RenderImageContentProps
) {
return (
<ImageContent
{...props}
autoPlay={mediaAutoLoad}
renderImage={PinMenuLazyImage}
renderViewer={(p) => <ImageViewer {...p} />}
/>
);
}
function renderPinMenuRoomMessage(
ctx: PinMenuRendererContext,
event: MatrixEvent,
displayName: string,
getContent: GetContentCallback
) {
if (event.isRedacted()) {
const unsigned = event.getUnsigned();
const redactionContent = unsigned.redacted_because?.content as { reason?: string } | undefined;
return <RedactedContent reason={redactionContent?.reason} />;
}
return (
<RenderMessageContent
displayName={displayName}
msgType={event.getContent().msgtype ?? ''}
ts={event.getTs()}
getContent={getContent}
edited={!!event.replacingEvent()}
mediaAutoLoad={ctx.mediaAutoLoad}
urlPreview={ctx.urlPreview}
htmlReactParserOptions={ctx.htmlReactParserOptions}
linkifyOpts={ctx.linkifyOpts}
outlineAttachment
mEvent={event}
mx={ctx.mx}
room={ctx.room}
/>
);
}
function renderPinMenuEncryptedDecrypted(
ctx: PinMenuRendererContext,
event: MatrixEvent,
displayName: string,
mEvent: MatrixEvent,
evtTimeline: NonNullable<ReturnType<Room['getTimelineForEvent']>>
) {
const eventId = event.getId()!;
const eventType = mEvent.getType();
const stickerEventType: string = EventType.Sticker;
const roomMessageEventType: string = EventType.RoomMessage;
const encryptedMessageEventType: string = EventType.RoomMessageEncrypted;
if (mEvent.isRedacted()) return <RedactedContent />;
if (eventType === stickerEventType) {
return (
<MSticker
content={mEvent.getContent()}
renderImageContent={renderPinMenuStickerImageContent.bind(null, ctx.mediaAutoLoad)}
/>
);
}
if (eventType === roomMessageEventType) {
const editedEvent = getEditedEvent(eventId, mEvent, evtTimeline.getTimelineSet());
const getContent = (() => {
const eventContent = mEvent.getContent();
const editContent = editedEvent?.getContent();
return (editContent?.['m.new_content'] ?? eventContent) as Record<string, unknown>;
}) as GetContentCallback;
return (
<RenderMessageContent
displayName={displayName}
msgType={mEvent.getContent().msgtype ?? ''}
ts={mEvent.getTs()}
edited={!!editedEvent || !!mEvent.replacingEvent()}
getContent={getContent}
mediaAutoLoad={ctx.mediaAutoLoad}
urlPreview={ctx.urlPreview}
htmlReactParserOptions={ctx.htmlReactParserOptions}
linkifyOpts={ctx.linkifyOpts}
mx={ctx.mx}
room={ctx.room}
mEvent={event}
/>
);
}
if (eventType === encryptedMessageEventType) {
return (
<Text>
<MessageNotDecryptedContent />
</Text>
);
}
return (
<Text>
<MessageUnsupportedContent />
</Text>
);
}
function renderPinMenuEncrypted(
ctx: PinMenuRendererContext,
event: MatrixEvent,
displayName: string
) {
const eventId = event.getId()!;
const evtTimeline = ctx.room.getTimelineForEvent(eventId);
const mEvent = evtTimeline?.getEvents().find((e: MatrixEvent) => e.getId() === eventId);
if (!mEvent || !evtTimeline) {
return (
<Box grow="Yes" direction="Column">
<Text size="T400" priority="300">
<code className={customHtmlCss.Code}>{event.getType()}</code>
{' event'}
</Text>
</Box>
);
}
return (
<EncryptedContent mEvent={mEvent}>
{renderPinMenuEncryptedDecrypted.bind(null, ctx, event, displayName, mEvent, evtTimeline)}
</EncryptedContent>
);
}
function renderPinMenuSticker(
ctx: PinMenuRendererContext,
event: MatrixEvent,
_displayName: string,
getContent: GetContentCallback
) {
if (event.isRedacted()) {
const unsigned = event.getUnsigned();
const redactionContent = unsigned.redacted_because?.content as
| Record<string, unknown>
| undefined;
return <RedactedContent reason={redactionContent?.reason as string | undefined} />;
}
return (
<MSticker
content={getContent() as IImageContent}
renderImageContent={renderPinMenuStickerImageContent.bind(null, ctx.mediaAutoLoad)}
/>
);
}
function renderPinMenuPollStart(
ctx: PinMenuRendererContext,
event: MatrixEvent,
displayName: string,
getContent: GetContentCallback
) {
if (event.isRedacted()) {
const unsigned = event.getUnsigned();
const redactionContent = unsigned.redacted_because?.content as { reason?: string } | undefined;
return <RedactedContent reason={redactionContent?.reason} />;
}
return (
<RenderMessageContent
displayName={displayName}
msgType={event.getContent().msgtype ?? ''}
ts={event.getTs()}
getContent={getContent}
edited={!!event.replacingEvent()}
mediaAutoLoad={ctx.mediaAutoLoad}
urlPreview={ctx.urlPreview}
htmlReactParserOptions={ctx.htmlReactParserOptions}
linkifyOpts={ctx.linkifyOpts}
outlineAttachment
mEvent={event}
mx={ctx.mx}
room={ctx.room}
/>
);
}
function renderPinMenuFallback(_ctx: PinMenuRendererContext, event: MatrixEvent) {
if (event.isRedacted()) {
const unsigned = event.getUnsigned();
const redactionContent = unsigned.redacted_because?.content as
| Record<string, unknown>
| undefined;
return <RedactedContent reason={redactionContent?.reason as string | undefined} />;
}
return (
<Box grow="Yes" direction="Column">
<Text size="T400" priority="300">
<code className={customHtmlCss.Code}>{event.getType()}</code>
{' event'}
</Text>
</Box>
);
}
type RoomPinMenuProps = {
room: Room;
requestClose: () => void;
@@ -525,30 +174,14 @@ export const RoomPinMenu = forwardRef<HTMLDivElement, RoomPinMenuProps>(
({ room, requestClose, currentHash }, ref) => {
const mx = useMatrixClient();
const userId = mx.getUserId()!;
const nicknames = useAtomValue(nicknamesAtom);
const powerLevels = usePowerLevelsContext();
const creators = useRoomCreators(room);
const permissions = useRoomPermissions(creators, powerLevels);
const canPinEvent = permissions.stateEvent(EventType.RoomPinnedEvents, userId);
const creatorsTag = useRoomCreatorsTag();
const powerLevelTags = usePowerLevelTags(room, powerLevels);
const getMemberPowerTag = useGetMemberPowerTag(room, creators, powerLevels);
const theme = useTheme();
const accessibleTagColors = useAccessiblePowerTagColors(
theme.kind,
creatorsTag,
powerLevelTags
);
const pinnedEvents = useRoomPinnedEvents(room);
const sortedPinnedEvent = useMemo(() => Array.from(pinnedEvents).reverse(), [pinnedEvents]);
const useAuthentication = useMediaAuthentication();
const [mediaAutoLoad] = useSetting(settingsAtom, 'mediaAutoLoad');
const [urlPreview] = useSetting(settingsAtom, 'urlPreview');
const [hour24Clock] = useSetting(settingsAtom, 'hour24Clock');
const [dateFormatString] = useSetting(settingsAtom, 'dateFormatString');
@@ -573,77 +206,7 @@ export const RoomPinMenu = forwardRef<HTMLDivElement, RoomPinMenuProps>(
overscan: 4,
});
const mentionClickHandler = useMentionClickHandler(room.roomId);
const settingsLinkBaseUrl = useSettingsLinkBaseUrl();
const spoilerClickHandler = useSpoilerClickHandler();
const linkifyOpts = useMemo<LinkifyOpts>(
() => ({
...LINKIFY_OPTS,
render: factoryRenderLinkifyWithMention(
settingsLinkBaseUrl,
(href) =>
renderMatrixMention(
mx,
room.roomId,
href,
makeMentionCustomProps(mentionClickHandler),
nicknames
),
mentionClickHandler
),
}),
[mx, room, mentionClickHandler, nicknames, settingsLinkBaseUrl]
);
const htmlReactParserOptions = useMemo<HTMLReactParserOptions>(
() =>
getReactCustomHtmlParser(mx, room.roomId, {
settingsLinkBaseUrl,
linkifyOpts,
useAuthentication,
handleSpoilerClick: spoilerClickHandler,
handleMentionClick: mentionClickHandler,
nicknames,
}),
[
mx,
room,
linkifyOpts,
mentionClickHandler,
spoilerClickHandler,
useAuthentication,
nicknames,
settingsLinkBaseUrl,
]
);
const rendererContext = useMemo<PinMenuRendererContext>(
() => ({
mx,
room,
mediaAutoLoad,
urlPreview,
htmlReactParserOptions,
linkifyOpts,
}),
[mx, room, mediaAutoLoad, urlPreview, htmlReactParserOptions, linkifyOpts]
);
const matrixEventHandlers = useMemo(
() => ({
[EventType.RoomMessage]: renderPinMenuRoomMessage.bind(null, rendererContext),
[EventType.RoomMessageEncrypted]: renderPinMenuEncrypted.bind(null, rendererContext),
[EventType.Sticker]: renderPinMenuSticker.bind(null, rendererContext),
[M_POLL_START.name]: renderPinMenuPollStart.bind(null, rendererContext),
}),
[rendererContext]
);
const renderMatrixEvent = useMatrixEventRenderer<[MatrixEvent, string, GetContentCallback]>(
matrixEventHandlers,
undefined,
renderPinMenuFallback.bind(null, rendererContext)
);
const renderMatrixEvent = useRoomMessagePreviewRenderer(room);
const handleOpen = (roomId: string, eventId: string) => {
navigateRoom(roomId, eventId);
@@ -712,8 +275,6 @@ export const RoomPinMenu = forwardRef<HTMLDivElement, RoomPinMenuProps>(
renderContent={renderMatrixEvent}
onOpen={handleOpen}
canPinEvent={canPinEvent}
getMemberPowerTag={getMemberPowerTag}
accessibleTagColors={accessibleTagColors}
hour24Clock={hour24Clock}
isNew={isNew}
dateFormatString={dateFormatString}
@@ -1,4 +1,4 @@
import { useCallback, useState } from 'react';
import { useCallback, useMemo, useState } from 'react';
import { useQuery, useQueryClient } from '@tanstack/react-query';
import { Box, Text, Chip, IconButton } from 'folds';
import {
@@ -10,7 +10,8 @@ import {
PencilSimple,
X,
} from '$components/icons/phosphor';
import type { Room } from '$types/matrix-sdk';
import type { DelayedEventInfo, Room } from '$types/matrix-sdk';
import { MatrixEvent } from '$types/matrix-sdk';
import { useAtom, useAtomValue, useSetAtom } from 'jotai';
import { useMatrixClient } from '$hooks/useMatrixClient';
import { getDelayedEvents, cancelDelayedEvent } from '$utils/delayedEvents';
@@ -22,6 +23,7 @@ import {
import { timeHourMinute, timeDayMonthYear } from '$utils/time';
import { useSetting } from '$state/hooks/settings';
import { settingsAtom } from '$state/settings';
import { MessagePreview, useRoomMessagePreviewRenderer } from '$components/message-preview';
import { SchedulePickerDialog } from './SchedulePickerDialog';
import * as css from './ScheduledMessagesList.css';
@@ -30,6 +32,106 @@ type ScheduledMessagesListProps = {
onEditMessage?: (body: string, formattedBody?: string) => void;
};
type ScheduledEvent = NonNullable<DelayedEventInfo['scheduled']>[number];
type ScheduledMessageRowProps = {
room: Room;
event: ScheduledEvent;
hour24Clock: boolean;
onEdit: (delayId: string, body: string, formattedBody?: string, scheduledTs?: number) => void;
onCancel: (delayId: string) => void;
};
function ScheduledMessageRow({
room,
event,
hour24Clock,
onEdit,
onCancel,
}: ScheduledMessageRowProps) {
const mx = useMatrixClient();
const [dateFormatString] = useSetting(settingsAtom, 'dateFormatString');
const renderContent = useRoomMessagePreviewRenderer(room);
const deliveryTs = 'delay' in event ? event.running_since + event.delay : event.running_since;
const isEncrypted = event.type === 'm.room.encrypted';
const body = !isEncrypted && typeof event.content.body === 'string' ? event.content.body : '';
const formattedBody =
!isEncrypted && typeof event.content.formatted_body === 'string'
? event.content.formatted_body
: undefined;
const matrixEvent = useMemo(
() =>
new MatrixEvent({
type: event.type,
content: event.content,
room_id: room.roomId,
sender: mx.getSafeUserId(),
event_id: `$scheduled-${event.delay_id}`,
origin_server_ts: event.running_since,
}),
[event, mx, room.roomId]
);
return (
<Box className={css.ScheduledMessageRow} direction="Column" gap="100">
{isEncrypted ? (
<Box direction="Row" gap="100" alignItems="Center">
{chipIcon(Lock)}
<Text size="T300" priority="300">
Encrypted — cancel and resend to edit
</Text>
</Box>
) : (
<MessagePreview
room={room}
event={matrixEvent}
renderContent={renderContent}
actions={
<Box gap="100" shrink="No">
<IconButton
size="300"
variant="SurfaceVariant"
radii="300"
onClick={() => onEdit(event.delay_id, body, formattedBody, deliveryTs)}
aria-label="Edit scheduled message"
>
{chipIcon(PencilSimple)}
</IconButton>
<IconButton
size="300"
variant="Critical"
radii="300"
onClick={() => onCancel(event.delay_id)}
aria-label="Cancel scheduled message"
>
{chipIcon(X)}
</IconButton>
</Box>
}
hour24Clock={hour24Clock}
dateFormatString={dateFormatString}
/>
)}
<Box justifyContent="SpaceBetween" alignItems="Center" gap="200">
<Text size="T200" priority="300">
{timeDayMonthYear(deliveryTs)} at {timeHourMinute(deliveryTs, hour24Clock)}
</Text>
{isEncrypted && (
<IconButton
size="300"
variant="Critical"
radii="300"
onClick={() => onCancel(event.delay_id)}
aria-label="Cancel scheduled message"
>
{chipIcon(X)}
</IconButton>
)}
</Box>
</Box>
);
}
export function ScheduledMessagesList({ room, onEditMessage }: ScheduledMessagesListProps) {
const mx = useMatrixClient();
const queryClient = useQueryClient();
@@ -49,10 +151,9 @@ export function ScheduledMessagesList({ room, onEditMessage }: ScheduledMessages
});
const roomEvents = data?.scheduled?.filter(
// eslint-disable-next-line @typescript-eslint/no-explicit-any
(evt: any) =>
evt.room_id === room.roomId &&
(evt.type === 'm.room.message' || evt.type === 'm.room.encrypted')
(event) =>
event.room_id === room.roomId &&
(event.type === 'm.room.message' || event.type === 'm.room.encrypted')
);
const invalidateEvents = useCallback(() => {
@@ -69,12 +170,8 @@ export function ScheduledMessagesList({ room, onEditMessage }: ScheduledMessages
const handleEdit = useCallback(
(delayId: string, body: string, formattedBody?: string, scheduledTs?: number) => {
if (onEditMessage) {
onEditMessage(body, formattedBody);
}
if (scheduledTs) {
setScheduledTime(new Date(scheduledTs));
}
onEditMessage?.(body, formattedBody);
if (scheduledTs) setScheduledTime(new Date(scheduledTs));
setEditingDelayId(delayId);
},
[onEditMessage, setScheduledTime, setEditingDelayId]
@@ -88,12 +185,8 @@ export function ScheduledMessagesList({ room, onEditMessage }: ScheduledMessages
[setScheduledTime, setEditingDelayId]
);
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const visibleEvents = roomEvents?.filter((e: any) => e.delay_id !== editingDelayId) ?? [];
if (!supported || visibleEvents.length === 0) {
return null;
}
const visibleEvents = roomEvents?.filter((event) => event.delay_id !== editingDelayId) ?? [];
if (!supported || visibleEvents.length === 0) return null;
return (
<Box direction="Column">
@@ -112,68 +205,16 @@ export function ScheduledMessagesList({ room, onEditMessage }: ScheduledMessages
</Box>
{expanded && (
<Box direction="Column" className={css.ScheduledMessagesPanel}>
{/* eslint-disable-next-line @typescript-eslint/no-explicit-any */}
{visibleEvents.map((evt: any) => {
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">
{chipIcon(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"
>
{chipIcon(PencilSimple)}
</IconButton>
)}
<IconButton
size="300"
variant="Critical"
radii="300"
onClick={() => handleCancel(evt.delay_id)}
aria-label="Cancel scheduled message"
>
{chipIcon(X)}
</IconButton>
</Box>
</Box>
);
})}
{visibleEvents.map((event) => (
<ScheduledMessageRow
key={event.delay_id}
room={room}
event={event}
hour24Clock={hour24Clock}
onEdit={handleEdit}
onCancel={handleCancel}
/>
))}
</Box>
)}
{editingDelayId && !onEditMessage && (
@@ -534,6 +534,8 @@ export function BackgroundNotifications() {
roomName: room.name ?? room.getCanonicalAlias() ?? undefined,
senderName,
body: notificationPayload.options.body,
room,
event: mEvent,
icon: notificationPayload.options.icon,
onClick: notifOnClick,
});
+2 -25
View File
@@ -17,9 +17,6 @@ import {
SyncState,
EventType,
} from '$types/matrix-sdk';
import parse from 'html-react-parser';
import { getReactCustomHtmlParser, LINKIFY_OPTS } from '$plugins/react-custom-html-parser';
import { sanitizeCustomHtml } from '$utils/sanitize';
import { roomToUnreadAtom } from '$state/room/roomToUnread';
import LogoSVG from '$public/res/svg/logo.svg';
import LogoUnreadSVG from '$public/res/svg/unread.svg';
@@ -54,7 +51,6 @@ import { getMxIdLocalPart, mxcUrlToHttp } from '$utils/matrix';
import { useSelectedRoom } from '$hooks/router/useSelectedRoom';
import { useInboxNotificationsSelected } from '$hooks/router/useInbox';
import { useMediaAuthentication } from '$hooks/useMediaAuthentication';
import { useSettingsLinkBaseUrl } from '$features/settings/useSettingsLinkBaseUrl';
import { ShareTargetFeature } from '$features/share-target/ShareTargetFeature';
import { registrationAtom } from '$state/serviceWorkerRegistration';
import { pendingNotificationAtom, inAppBannerAtom, activeSessionIdAtom } from '$state/sessions';
@@ -312,7 +308,6 @@ function MessageNotifications() {
const clientStartTimeRef = useRef(Date.now());
const mx = useMatrixClient();
const useAuthentication = useMediaAuthentication();
const appBaseUrl = useSettingsLinkBaseUrl();
const [showNotifications] = useSetting(settingsAtom, 'useInAppNotifications');
const [showSystemNotifications] = useSetting(settingsAtom, 'useSystemNotifications');
const [usePushNotifications] = useSetting(settingsAtom, 'usePushNotifications');
@@ -556,7 +551,6 @@ function MessageNotifications() {
getMemberDisplayName(room, sender, nicknamesRef.current) ??
getMxIdLocalPart(sender) ??
sender;
const content = mEvent.getContent();
// Events reaching here are already decrypted (m.room.encrypted is skipped
// above). Pass isEncryptedRoom:false so the preview always shows the actual
// message body when showMessageContent is enabled.
@@ -568,23 +562,6 @@ function MessageNotifications() {
showEncryptedMessageContent,
});
// Build a rich ReactNode body using the same HTML parser as the room
// timeline — mxc images, mention pills, linkify, spoilers, code blocks.
let bodyNode: ReactNode;
if (
showMessageContent &&
content.format === 'org.matrix.custom.html' &&
content.formatted_body
) {
const htmlParserOpts = getReactCustomHtmlParser(mx, room.roomId, {
settingsLinkBaseUrl: appBaseUrl,
linkifyOpts: LINKIFY_OPTS,
useAuthentication,
nicknames: nicknamesRef.current,
});
bodyNode = parse(sanitizeCustomHtml(content.formatted_body), htmlParserOpts) as ReactNode;
}
const payload = buildRoomMessageNotification({
roomName: room.name ?? 'Unknown',
roomAvatar,
@@ -605,7 +582,8 @@ function MessageNotifications() {
serverName,
senderName: resolvedSenderName,
body: previewText,
bodyNode,
room,
event: mEvent,
icon: roomAvatar,
onClick: () => {
window.focus();
@@ -636,7 +614,6 @@ function MessageNotifications() {
setInAppBanner,
setPending,
selectedRoomId,
appBaseUrl,
useAuthentication,
]);
+168 -483
View File
@@ -1,7 +1,7 @@
import type { ChangeEventHandler, ComponentProps, MouseEventHandler, ReactNode } from 'react';
import type { ChangeEventHandler, MouseEventHandler, ReactNode } from 'react';
import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
import type { MatrixEvent, Room } from 'matrix-js-sdk';
import { ClientEvent, EventType, JoinRule, M_POLL_START } from 'matrix-js-sdk';
import { ClientEvent, JoinRule } from 'matrix-js-sdk';
import {
Avatar,
Box,
@@ -44,74 +44,35 @@ import type { BookmarkItemContent } from '$types/matrix-sdk-events';
import { SequenceCard } from '../../../components/sequence-card';
import { useRoomNavigate } from '../../../hooks/useRoomNavigate';
import { useMatrixClient } from '../../../hooks/useMatrixClient';
import { getMxIdLocalPart, mxcUrlToHttp } from '../../../utils/matrix';
import type { RenderImageContentProps } from '../../../components/message';
import {
AvatarBase,
ImageContent,
MessageNotDecryptedContent,
MessageUnsupportedContent,
ModernLayout,
MSticker,
RedactedContent,
Time,
Username,
UsernameBold,
} from '../../../components/message';
import { UserAvatar } from '../../../components/user-avatar';
import { getMxIdLocalPart } from '../../../utils/matrix';
import { Time } from '../../../components/message';
import { RoomAvatar, RoomIcon } from '../../../components/room-avatar';
import {
getEditedEvent,
getMemberAvatarMxc,
getMemberDisplayName,
getRoomAvatarUrl,
} from '../../../utils/room';
import { getRoomAvatarUrl } from '../../../utils/room';
import { useSetting } from '../../../state/hooks/settings';
import { settingsAtom } from '../../../state/settings';
import { ScreenSize, useScreenSizeContext } from '../../../hooks/useScreenSize';
import { BackRouteHandler } from '../../../components/BackRouteHandler';
import { useMediaAuthentication } from '../../../hooks/useMediaAuthentication';
import { mDirectAtom } from '../../../state/mDirectList';
import { profilesCacheAtom } from '../../../state/userRoomProfile';
import { stopPropagation } from '../../../utils/keyboard';
import { highlightText, makeHighlightRegex } from '../../../plugins/react-custom-html-parser';
import colorMXID from '$utils/colorMXID';
import { RenderMessageContent } from '$components/RenderMessageContent';
import type { GetContentCallback } from '$types/matrix/room';
import { useRoomEvent } from '$hooks/useRoomEvent';
import type { HTMLReactParserOptions } from 'html-react-parser';
import type { Opts } from 'linkifyjs';
import { ImageViewer } from '$components/image-viewer';
import { Image } from '$components/media';
import { EncryptedContent } from '$features/room/message';
import * as customHtmlCss from '$styles/CustomHtml.css';
import type { IImageContent } from '$types/matrix/common';
import { useMatrixEventRenderer } from '$hooks/useMatrixEventRenderer';
import { MessagePreview, useRoomMessagePreviewRenderer } from '$components/message-preview';
import { MATRIX_SABLE_UNSTABLE_BOOKMARKS_INDEX_EVENT } from '$unstable/prefixes';
import { hydrateRoomMembers } from '$client/roomMemberHydration';
import { useDebounce } from '$hooks/useDebounce';
type RemoveBookmarkDialogProps = {
open: boolean;
sender?: string;
displayName?: string;
senderAvatarMxc?: string;
renderMatrixEvent: () => ReactNode;
onConfirm: () => void;
onClose: () => void;
};
function RemoveBookmarkDialog({
open,
sender,
displayName,
senderAvatarMxc,
renderMatrixEvent,
onConfirm,
onClose,
}: RemoveBookmarkDialogProps) {
const mx = useMatrixClient();
const useAuthentication = useMediaAuthentication();
return (
<Overlay open={open} backdrop={<OverlayBackdrop />}>
<OverlayCenter>
@@ -141,44 +102,16 @@ function RemoveBookmarkDialog({
</Header>
<Box style={{ padding: config.space.S400 }} direction="Column" gap="400">
<Text priority="400">Are you sure you want to remove this bookmark?</Text>
{sender && (
<Box
style={{
padding: config.space.S200,
borderRadius: config.radii.R300,
}}
direction="Column"
gap="200"
>
{sender && (
<Box gap="200" alignItems="Center">
<Avatar size="200">
<UserAvatar
userId={sender}
src={
senderAvatarMxc
? (mxcUrlToHttp(
mx,
senderAvatarMxc,
useAuthentication,
32,
32,
'crop'
) ?? undefined)
: undefined
}
alt={displayName ?? sender}
renderFallback={() => <Icon size="50" src={Icons.User} filled />}
/>
</Avatar>
<Text size="T300" truncate>
<b>{displayName ?? sender}</b>
</Text>
</Box>
)}
{renderMatrixEvent()}
</Box>
)}
<Box
style={{
padding: config.space.S200,
borderRadius: config.radii.R300,
}}
direction="Column"
gap="200"
>
{renderMatrixEvent()}
</Box>
<Button variant="Critical" onClick={onConfirm}>
<Text size="B400">Remove</Text>
</Button>
@@ -190,217 +123,11 @@ function RemoveBookmarkDialog({
);
}
type BookmarkItemRowProps = {
item: BookmarkItemContent;
room?: Room;
displayName: string;
senderAvatarMxc?: string;
usernameColor?: string;
hour24Clock: boolean;
dateFormatString: string;
onOpen: MouseEventHandler;
onRemove: (bookmarkId: string) => void;
highlightRegex?: RegExp;
};
type BookmarkItemRowBodyProps = {
item: BookmarkItemContent;
room: Room;
highlightRegex?: RegExp;
displayName: string;
};
type BookmarkItemRowBodyFallbackProps = {
item: BookmarkItemContent;
highlightRegex?: RegExp;
};
type bookmarkRendererContext = {
mx: ReturnType<typeof useMatrixClient>;
room?: Room;
mediaAutoLoad: boolean;
urlPreview: boolean;
htmlReactParserOptions: HTMLReactParserOptions;
linkifyOpts: Opts;
};
function BookmarkLazyImage(props: ComponentProps<typeof Image>) {
return <Image {...props} loading="lazy" />;
}
function renderBookmarkStickerImageContent(
mediaAutoLoad: boolean | undefined,
props: RenderImageContentProps
) {
return (
<ImageContent
{...props}
autoPlay={mediaAutoLoad}
renderImage={BookmarkLazyImage}
renderViewer={(p) => <ImageViewer {...p} />}
/>
);
}
function renderBookmarkEncryptedDecrypted(
ctx: bookmarkRendererContext,
event: MatrixEvent,
displayName: string,
mEvent: MatrixEvent,
evtTimeline: NonNullable<ReturnType<Room['getTimelineForEvent']>>
) {
const eventId = event.getId()!;
const eventType = mEvent.getType();
const stickerEventType: string = EventType.Sticker;
const roomMessageEventType: string = EventType.RoomMessage;
const encryptedMessageEventType: string = EventType.RoomMessageEncrypted;
if (mEvent.isRedacted()) return <RedactedContent />;
if (eventType === stickerEventType) {
return (
<MSticker
content={mEvent.getContent()}
renderImageContent={renderBookmarkStickerImageContent.bind(null, ctx.mediaAutoLoad)}
/>
);
}
if (eventType === roomMessageEventType) {
const editedEvent = getEditedEvent(eventId, mEvent, evtTimeline.getTimelineSet());
const getContent = (() => {
const eventContent = mEvent.getContent();
const editContent = editedEvent?.getContent();
return (editContent?.['m.new_content'] ?? eventContent) as Record<string, unknown>;
}) as GetContentCallback;
return (
<RenderMessageContent
displayName={displayName}
msgType={mEvent.getContent().msgtype ?? ''}
ts={mEvent.getTs()}
edited={!!editedEvent || !!mEvent.replacingEvent()}
getContent={getContent}
mediaAutoLoad={ctx.mediaAutoLoad}
urlPreview={ctx.urlPreview}
htmlReactParserOptions={ctx.htmlReactParserOptions}
linkifyOpts={ctx.linkifyOpts}
mx={ctx.mx}
room={ctx.room}
mEvent={event}
/>
);
}
if (eventType === encryptedMessageEventType) {
return (
<Text>
<MessageNotDecryptedContent />
</Text>
);
}
return (
<Text>
<MessageUnsupportedContent />
</Text>
);
}
function renderBookmarkEncrypted(
ctx: bookmarkRendererContext,
event: MatrixEvent,
displayName: string
) {
const eventId = event.getId()!;
const evtTimeline = ctx.room?.getTimelineForEvent(eventId);
const mEvent = evtTimeline?.getEvents().find((e: MatrixEvent) => e.getId() === eventId);
if (!mEvent || !evtTimeline) {
return (
<Box grow="Yes" direction="Column">
<Text size="T400" priority="300">
<code className={customHtmlCss.Code}>{event.getType()}</code>
{' event'}
</Text>
</Box>
);
}
return (
<EncryptedContent mEvent={mEvent}>
{renderBookmarkEncryptedDecrypted.bind(null, ctx, event, displayName, mEvent, evtTimeline)}
</EncryptedContent>
);
}
function renderBookmarkRoomMessage(
ctx: bookmarkRendererContext,
event: MatrixEvent,
displayName: string,
getContent: GetContentCallback
) {
if (event.isRedacted()) {
const unsigned = event.getUnsigned();
const redactionContent = unsigned.redacted_because?.content as { reason?: string } | undefined;
return <RedactedContent reason={redactionContent?.reason} />;
}
return (
<RenderMessageContent
displayName={displayName}
msgType={event.getContent().msgtype ?? ''}
ts={event.getTs()}
getContent={getContent}
edited={!!event.replacingEvent()}
mediaAutoLoad={ctx.mediaAutoLoad}
urlPreview={ctx.urlPreview}
htmlReactParserOptions={ctx.htmlReactParserOptions}
linkifyOpts={ctx.linkifyOpts}
outlineAttachment
mEvent={event}
mx={ctx.mx}
room={ctx.room}
/>
);
}
function renderBookmarkSticker(
ctx: bookmarkRendererContext,
event: MatrixEvent,
_displayName: string,
getContent: GetContentCallback
) {
if (event.isRedacted()) {
const unsigned = event.getUnsigned();
const redactionContent = unsigned.redacted_because?.content as
| Record<string, unknown>
| undefined;
return <RedactedContent reason={redactionContent?.reason as string | undefined} />;
}
return (
<MSticker
content={getContent() as IImageContent}
renderImageContent={renderBookmarkStickerImageContent.bind(null, ctx.mediaAutoLoad)}
/>
);
}
function renderBookmarkFallback(_ctx: bookmarkRendererContext, event: MatrixEvent) {
if (event.isRedacted()) {
const unsigned = event.getUnsigned();
const redactionContent = unsigned.redacted_because?.content as
| Record<string, unknown>
| undefined;
return <RedactedContent reason={redactionContent?.reason as string | undefined} />;
}
return (
<Box grow="Yes" direction="Column">
<Text size="T400" priority="300">
<code className={customHtmlCss.Code}>{event.getType()}</code>
{' event'}
</Text>
</Box>
);
}
function BookmarkItemRowBodyFallback({ item, highlightRegex }: BookmarkItemRowBodyFallbackProps) {
return (
<Text size="T400" style={{ whiteSpace: 'pre-wrap' }}>
@@ -413,69 +140,27 @@ function BookmarkItemRowBodyFallback({ item, highlightRegex }: BookmarkItemRowBo
);
}
function BookmarkItemRowBody({
room,
item,
highlightRegex,
displayName,
}: BookmarkItemRowBodyProps) {
const mx = useMatrixClient();
const [mediaAutoLoad] = useSetting(settingsAtom, 'mediaAutoLoad');
const [urlPreview] = useSetting(settingsAtom, 'urlPreview');
const event = useRoomEvent(room, item.event_id); // TODO: only fetch when in view (virtualizer?)
const getContent = (() => event?.getContent()) as GetContentCallback;
const rendererContext = useMemo<bookmarkRendererContext>(
() => ({
mx,
room,
mediaAutoLoad,
urlPreview,
htmlReactParserOptions: {},
linkifyOpts: {},
}),
[mx, room, mediaAutoLoad, urlPreview]
);
// TODO: abstract this (code from pin menu) and reuse in a lot of places
const matrixEventHandlers = useMemo(
() => ({
[EventType.RoomMessage]: renderBookmarkRoomMessage.bind(null, rendererContext),
[EventType.RoomMessageEncrypted]: renderBookmarkEncrypted.bind(null, rendererContext),
[EventType.Sticker]: renderBookmarkSticker.bind(null, rendererContext),
[M_POLL_START.name]: renderBookmarkRoomMessage.bind(null, rendererContext),
}),
[rendererContext]
);
const renderMatrixEvent = useMatrixEventRenderer<[MatrixEvent, string, GetContentCallback]>(
matrixEventHandlers,
undefined,
renderBookmarkFallback.bind(null, rendererContext)
);
if (!event) {
return <BookmarkItemRowBodyFallback item={item} highlightRegex={highlightRegex} />;
}
return renderMatrixEvent(event.getType(), false, event, displayName, getContent);
}
type BookmarkItemRowProps = {
item: BookmarkItemContent;
room: Room;
hour24Clock: boolean;
dateFormatString: string;
onOpen: (eventId: string) => void;
onRemove: (bookmarkId: string) => void;
highlightRegex?: RegExp;
};
function BookmarkItemRow({
item,
room,
displayName,
senderAvatarMxc,
usernameColor,
hour24Clock,
dateFormatString,
onOpen,
onRemove,
highlightRegex,
}: BookmarkItemRowProps) {
const mx = useMatrixClient();
const useAuthentication = useMediaAuthentication();
const event = useRoomEvent(room, item.event_id);
const renderContent = useRoomMessagePreviewRenderer(room, { highlightRegex });
const [confirmOpen, setConfirmOpen] = useState(false);
const handleConfirmRemove = () => {
@@ -483,26 +168,60 @@ function BookmarkItemRow({
onRemove(item.bookmark_id);
};
const handleOpen: MouseEventHandler<HTMLButtonElement> = (evt) => {
evt.stopPropagation();
onOpen(item.event_id);
};
const actions = (
<Box gap="200" alignItems="Center" shrink="Yes" wrap="WrapReverse" justifyContent="End">
<Box gap="100" alignItems="Center">
<Icon size="50" src={Icons.Bookmark} />
<Time
ts={item.bookmarked_ts}
hour24Clock={hour24Clock}
dateFormatString={dateFormatString}
/>
</Box>
<Box gap="200" alignItems="Center">
<Chip onClick={handleOpen} variant="Secondary" radii="400">
<Text size="T200">Jump</Text>
</Chip>
<IconButton
onClick={(evt: React.MouseEvent) => {
evt.stopPropagation();
setConfirmOpen(true);
}}
size="300"
radii="300"
aria-label="Remove bookmark"
style={{ color: color.Critical.Main }}
>
<Icon src={Icons.Delete} size="100" />
</IconButton>
</Box>
</Box>
);
return (
<>
<RemoveBookmarkDialog
open={confirmOpen}
sender={item.sender}
displayName={displayName}
senderAvatarMxc={senderAvatarMxc}
onConfirm={handleConfirmRemove}
renderMatrixEvent={() => {
return room ? (
<BookmarkItemRowBody
highlightRegex={highlightRegex}
displayName={displayName}
renderMatrixEvent={() =>
event ? (
<MessagePreview
room={room}
item={item}
event={event}
renderContent={renderContent}
onOpen={handleOpen}
hour24Clock={hour24Clock}
dateFormatString={dateFormatString}
/>
) : (
<BookmarkItemRowBodyFallback item={item} />
);
}}
)
}
onClose={() => setConfirmOpen(false)}
/>
<SequenceCard
@@ -510,85 +229,86 @@ function BookmarkItemRow({
variant="SurfaceVariant"
direction="Column"
>
<ModernLayout
before={
<AvatarBase>
<Avatar size="300">
<UserAvatar
userId={item.sender ?? ''}
src={
senderAvatarMxc
? (mxcUrlToHttp(mx, senderAvatarMxc, useAuthentication, 48, 48, 'crop') ??
undefined)
: undefined
}
alt={displayName}
renderFallback={() => <Icon size="200" src={Icons.User} filled />}
/>
</Avatar>
</AvatarBase>
}
>
<Box gap="300" justifyContent="SpaceBetween" alignItems="Center" grow="Yes">
<Box gap="200" alignItems="Baseline" wrap="Wrap">
<Username style={{ color: usernameColor }}>
<Text as="span" truncate>
<UsernameBold>{displayName}</UsernameBold>
</Text>
</Username>
<Time
ts={item.event_ts}
hour24Clock={hour24Clock}
dateFormatString={dateFormatString}
/>
</Box>
<Box gap="200" alignItems="Center" shrink="Yes" wrap="WrapReverse" justifyContent="End">
<Box gap="100" alignItems="Center">
<Icon size="50" src={Icons.Bookmark} />
<Time
ts={item.bookmarked_ts}
hour24Clock={hour24Clock}
dateFormatString={dateFormatString}
/>
</Box>
<Box gap="200" alignItems="Center">
<Chip
data-event-id={item.event_id}
onClick={onOpen}
variant="Secondary"
radii="400"
>
<Text size="T200">Jump</Text>
</Chip>
<IconButton
onClick={(evt: React.MouseEvent) => {
evt.stopPropagation();
setConfirmOpen(true);
}}
size="300"
radii="300"
aria-label="Remove bookmark"
style={{ color: color.Critical.Main }}
>
<Icon src={Icons.Delete} size="100" />
</IconButton>
</Box>
</Box>
{event ? (
<MessagePreview
room={room}
event={event}
renderContent={renderContent}
actions={actions}
onOpen={handleOpen}
hour24Clock={hour24Clock}
dateFormatString={dateFormatString}
/>
) : (
<Box direction="Column" gap="200">
{actions}
<BookmarkItemRowBodyFallback item={item} highlightRegex={highlightRegex} />
</Box>
)}
</SequenceCard>
</>
);
}
<Box grow="Yes" direction="Column">
{room ? (
<BookmarkItemRowBody
highlightRegex={highlightRegex}
displayName={displayName}
room={room}
item={item}
/>
) : (
<BookmarkItemRowBodyFallback item={item} />
)}
function UnavailableBookmarkItemRow({
item,
displayName,
hour24Clock,
dateFormatString,
onOpen,
onRemove,
highlightRegex,
}: Omit<BookmarkItemRowProps, 'room' | 'onOpen'> & {
displayName: string;
onOpen: (eventId: string) => void;
}) {
const [confirmOpen, setConfirmOpen] = useState(false);
const handleOpen: MouseEventHandler<HTMLButtonElement> = (evt) => {
evt.stopPropagation();
onOpen(item.event_id);
};
return (
<>
<RemoveBookmarkDialog
open={confirmOpen}
onConfirm={() => {
setConfirmOpen(false);
onRemove(item.bookmark_id);
}}
renderMatrixEvent={() => <BookmarkItemRowBodyFallback item={item} />}
onClose={() => setConfirmOpen(false)}
/>
<SequenceCard
style={{ padding: config.space.S400 }}
variant="SurfaceVariant"
direction="Column"
gap="200"
>
<Box justifyContent="SpaceBetween" alignItems="Center" gap="200">
<Text size="T300" truncate>
<b>{displayName}</b>
</Text>
<Box gap="200" alignItems="Center">
<Time
ts={item.bookmarked_ts}
hour24Clock={hour24Clock}
dateFormatString={dateFormatString}
/>
<Chip onClick={handleOpen} variant="Secondary" radii="400">
<Text size="T200">Jump</Text>
</Chip>
<IconButton
onClick={() => setConfirmOpen(true)}
size="300"
radii="300"
aria-label="Remove bookmark"
style={{ color: color.Critical.Main }}
>
<Icon src={Icons.Delete} size="100" />
</IconButton>
</Box>
</ModernLayout>
</Box>
<BookmarkItemRowBodyFallback item={item} highlightRegex={highlightRegex} />
</SequenceCard>
</>
);
@@ -602,7 +322,6 @@ type BookmarkResultGroupProps = {
onRemove: (bookmarkId: string) => void;
hour24Clock: boolean;
dateFormatString: string;
legacyUsernameColor?: boolean;
highlightRegex?: RegExp;
};
function BookmarkResultGroup({
@@ -613,7 +332,6 @@ function BookmarkResultGroup({
onRemove,
hour24Clock,
dateFormatString,
legacyUsernameColor,
highlightRegex,
}: BookmarkResultGroupProps) {
const mx = useMatrixClient();
@@ -621,34 +339,6 @@ function BookmarkResultGroup({
const room = mx.getRoom(roomId);
const cachedProfiles = useAtomValue(profilesCacheAtom);
const [, forceUpdate] = useState(0);
useEffect(() => {
let disposed = false;
if (room) {
const unknownUserIds = items
.map((item) => item.sender)
.filter(
(sender): sender is string =>
typeof sender === 'string' && sender.startsWith('@') && !room.getMember(sender)
);
if (unknownUserIds.length > 0) {
hydrateRoomMembers(mx, room.roomId, unknownUserIds).then(() => {
if (!disposed) forceUpdate((n) => n + 1);
});
}
}
return () => {
disposed = true;
};
}, [mx, room, items]);
const handleOpenClick: MouseEventHandler = (evt) => {
const eventId = evt.currentTarget.getAttribute('data-event-id');
if (!eventId) return;
onOpen(roomId, eventId);
};
return (
<Box direction="Column" gap="200">
<Header size="300">
@@ -679,33 +369,31 @@ function BookmarkResultGroup({
</Header>
<Box direction="Column" gap="100">
{items.map((item) => {
const displayName = room
? (getMemberDisplayName(room, item.sender ?? '') ??
cachedProfiles[item.sender ?? '']?.displayName ??
getMxIdLocalPart(item.sender ?? '') ??
item.sender ??
'Unknown')
: (cachedProfiles[item.sender ?? '']?.displayName ??
getMxIdLocalPart(item.sender ?? '') ??
item.sender ??
'Unknown');
const senderAvatarMxc =
room && item.sender ? getMemberAvatarMxc(room, item.sender) : undefined;
const usernameColor =
legacyUsernameColor && item.sender ? colorMXID(item.sender) : undefined;
if (room) {
return (
<BookmarkItemRow
key={item.bookmark_id}
item={item}
room={room}
hour24Clock={hour24Clock}
dateFormatString={dateFormatString}
onOpen={(eventId) => onOpen(roomId, eventId)}
onRemove={onRemove}
highlightRegex={highlightRegex}
/>
);
}
const sender = item.sender ?? '';
const displayName =
cachedProfiles[sender]?.displayName ?? getMxIdLocalPart(sender) ?? sender ?? 'Unknown';
return (
<BookmarkItemRow
<UnavailableBookmarkItemRow
key={item.bookmark_id}
item={item}
room={room ?? undefined}
displayName={displayName}
senderAvatarMxc={senderAvatarMxc}
usernameColor={usernameColor}
hour24Clock={hour24Clock}
dateFormatString={dateFormatString}
onOpen={handleOpenClick}
onOpen={(eventId) => onOpen(roomId, eventId)}
onRemove={onRemove}
highlightRegex={highlightRegex}
/>
@@ -761,9 +449,7 @@ export function Bookmarks() {
const { refresh, remove } = useBookmarkActions();
const { navigateRoom } = useRoomNavigate();
const screenSize = useScreenSizeContext();
const mDirects = useAtomValue(mDirectAtom);
const [legacyUsernameColor] = useSetting(settingsAtom, 'legacyUsernameColor');
const [hour24Clock] = useSetting(settingsAtom, 'hour24Clock');
const [dateFormatString] = useSetting(settingsAtom, 'dateFormatString');
@@ -923,7 +609,6 @@ export function Bookmarks() {
onRemove={remove}
hour24Clock={hour24Clock}
dateFormatString={dateFormatString}
legacyUsernameColor={legacyUsernameColor || mDirects.has(roomId)}
highlightRegex={highlightRegex}
/>
</Box>
+64 -466
View File
@@ -1,4 +1,4 @@
import type { MouseEventHandler, ComponentProps } from 'react';
import type { MouseEventHandler } from 'react';
import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
import { Avatar, Box, Chip, Header, IconButton, Scroll, Text, config, toRem } from 'folds';
import {
@@ -11,96 +11,33 @@ import {
sizedIcon,
} from '$components/icons/phosphor';
import { useSearchParams } from 'react-router-dom';
import type {
INotification,
INotificationsResponse,
IRoomEvent,
MatrixEvent,
Room,
} from '$types/matrix-sdk';
import type { IImageContent } from '$types/matrix/common';
import { JoinRule, Method, RelationType, EventType } from '$types/matrix-sdk';
import type { INotification, INotificationsResponse, Room } from '$types/matrix-sdk';
import { EventType, JoinRule, MatrixEvent, Method } from '$types/matrix-sdk';
import { useVirtualizer } from '@tanstack/react-virtual';
import type { HTMLReactParserOptions } from 'html-react-parser';
import type { Opts as LinkifyOpts } from 'linkifyjs';
import { useAtomValue } from 'jotai';
import { nicknamesAtom } from '$state/nicknames';
import { profilesCacheAtom } from '$state/userRoomProfile';
import { Page, PageContent, PageContentCenter, PageHeader } from '$components/page';
import { useMatrixClient } from '$hooks/useMatrixClient';
import { getMxIdLocalPart, mxcUrlToHttp } from '$utils/matrix';
import type { InboxNotificationsPathSearchParams } from '$pages/paths';
import { AsyncStatus, useAsyncCallback } from '$hooks/useAsyncCallback';
import { SequenceCard } from '$components/sequence-card';
import { RoomAvatar, RoomIcon } from '$components/room-avatar';
import {
getEditedEvent,
getMemberAvatarMxc,
getMemberDisplayName,
getRoomAvatarUrl,
} from '$utils/room';
import { getRoomAvatarUrl } from '$utils/room';
import { ScrollTopContainer } from '$components/scroll-top-container';
import { useInterval } from '$hooks/useInterval';
import {
AvatarBase,
ImageContent,
MSticker,
MessageNotDecryptedContent,
MessageUnsupportedContent,
ModernLayout,
RedactedContent,
Reply,
Time,
Username,
UsernameBold,
type RenderImageContentProps,
} from '$components/message';
import {
factoryRenderLinkifyWithMention,
getReactCustomHtmlParser,
LINKIFY_OPTS,
makeMentionCustomProps,
renderMatrixMention,
} from '$plugins/react-custom-html-parser';
import { RenderMessageContent } from '$components/RenderMessageContent';
import { useSetting } from '$state/hooks/settings';
import { settingsAtom } from '$state/settings';
import { Image } from '$components/media';
import { ImageViewer } from '$components/image-viewer';
import type { GetContentCallback } from '$types/matrix/room';
import { useMatrixEventRenderer } from '$hooks/useMatrixEventRenderer';
import * as customHtmlCss from '$styles/CustomHtml.css';
import { useRoomNavigate } from '$hooks/useRoomNavigate';
import { useRoomUnread } from '$state/hooks/unread';
import { roomToUnreadAtom } from '$state/room/roomToUnread';
import { markAsRead } from '$utils/notifications';
import { ContainerColor } from '$styles/ContainerColor.css';
import { VirtualTile } from '$components/virtualizer';
import { hydrateRoomMembers } from '$client/roomMemberHydration';
import { UserAvatar } from '$components/user-avatar';
import { userFallbackIcon } from '$components/icons/phosphor';
import { EncryptedContent } from '$features/room/message';
import { useMentionClickHandler } from '$hooks/useMentionClickHandler';
import { useSpoilerClickHandler } from '$hooks/useSpoilerClickHandler';
import { MessagePreview, useRoomMessagePreviewRenderer } from '$components/message-preview';
import { useSettingsLinkBaseUrl } from '$features/settings/useSettingsLinkBaseUrl';
import { ScreenSize, useScreenSizeContext } from '$hooks/useScreenSize';
import { BackRouteHandler } from '$components/BackRouteHandler';
import { useMediaAuthentication } from '$hooks/useMediaAuthentication';
import { allRoomsAtom } from '$state/room-list/roomList';
import { usePowerLevels } from '$hooks/usePowerLevels';
import { usePowerLevelTags } from '$hooks/usePowerLevelTags';
import { useTheme } from '$hooks/useTheme';
import { PowerIcon } from '$components/power';
import colorMXID from '$utils/colorMXID';
import { mDirectAtom } from '$state/mDirectList';
import {
getPowerTagIconSrc,
useAccessiblePowerTagColors,
useGetMemberPowerTag,
} from '$hooks/useMemberPowerTag';
import { useRoomCreatorsTag } from '$hooks/useRoomCreatorsTag';
import { useRoomCreators } from '$hooks/useRoomCreators';
type RoomNotificationsGroup = {
roomId: string;
@@ -205,314 +142,75 @@ const useNotificationTimeline = (
return [notificationTimeline, loadTimeline, silentReloadTimeline];
};
type NotificationRendererContext = {
mx: ReturnType<typeof useMatrixClient>;
room: Room;
mediaAutoLoad?: boolean;
urlPreview?: boolean;
htmlReactParserOptions: HTMLReactParserOptions;
linkifyOpts: LinkifyOpts;
};
function NotificationLazyImage(props: ComponentProps<typeof Image>) {
return <Image {...props} loading="lazy" />;
}
function renderNotificationStickerImageContent(
mediaAutoLoad: boolean | undefined,
props: RenderImageContentProps
) {
return (
<ImageContent
{...props}
autoPlay={mediaAutoLoad}
renderImage={NotificationLazyImage}
renderViewer={(p) => <ImageViewer {...p} />}
/>
);
}
function renderNotificationRoomMessage(
ctx: NotificationRendererContext,
event: IRoomEvent,
displayName: string,
getContent: GetContentCallback
) {
if (event.unsigned?.redacted_because) {
return <RedactedContent reason={event.unsigned?.redacted_because.content.reason} />;
}
const evtTimeline = ctx.room.getTimelineForEvent(event.event_id);
const mEvent = evtTimeline?.getEvents().find((e) => e.getId() === event.event_id);
return (
<RenderMessageContent
displayName={displayName}
msgType={event.content.msgtype ?? ''}
ts={event.origin_server_ts}
getContent={getContent}
mediaAutoLoad={ctx.mediaAutoLoad}
urlPreview={ctx.urlPreview}
htmlReactParserOptions={ctx.htmlReactParserOptions}
linkifyOpts={ctx.linkifyOpts}
outlineAttachment
mx={ctx.mx}
room={ctx.room}
mEvent={mEvent}
/>
);
}
function renderNotificationEncryptedDecrypted(
ctx: NotificationRendererContext,
evt: IRoomEvent,
displayName: string,
mEvent: MatrixEvent,
evtTimeline: NonNullable<ReturnType<Room['getTimelineForEvent']>>
) {
if (mEvent.isRedacted()) return <RedactedContent />;
if (mEvent.getType() === (EventType.Sticker as string)) {
return (
<MSticker
content={mEvent.getContent()}
renderImageContent={renderNotificationStickerImageContent.bind(null, ctx.mediaAutoLoad)}
/>
);
}
if (mEvent.getType() === (EventType.RoomMessage as string)) {
const editedEvent = getEditedEvent(evt.event_id, mEvent, evtTimeline.getTimelineSet());
const getContent = (() =>
editedEvent?.getContent()['m.new_content'] ?? mEvent.getContent()) as GetContentCallback;
return (
<RenderMessageContent
displayName={displayName}
msgType={mEvent.getContent().msgtype ?? ''}
ts={mEvent.getTs()}
edited={!!editedEvent}
getContent={getContent}
mediaAutoLoad={ctx.mediaAutoLoad}
urlPreview={ctx.urlPreview}
htmlReactParserOptions={ctx.htmlReactParserOptions}
linkifyOpts={ctx.linkifyOpts}
mx={ctx.mx}
room={ctx.room}
mEvent={mEvent}
/>
);
}
if (mEvent.getType() === (EventType.RoomMessageEncrypted as string)) {
return (
<Text>
<MessageNotDecryptedContent />
</Text>
);
}
return (
<Text>
<MessageUnsupportedContent />
</Text>
);
}
function renderNotificationEncrypted(
ctx: NotificationRendererContext,
evt: IRoomEvent,
displayName: string
) {
const evtTimeline = ctx.room.getTimelineForEvent(evt.event_id);
const mEvent = evtTimeline?.getEvents().find((e) => e.getId() === evt.event_id);
if (!mEvent || !evtTimeline) {
return (
<Box grow="Yes" direction="Column">
<Text size="T400" priority="300">
<code className={customHtmlCss.Code}>{evt.type}</code>
{' event'}
</Text>
</Box>
);
}
return (
<EncryptedContent mEvent={mEvent}>
{renderNotificationEncryptedDecrypted.bind(null, ctx, evt, displayName, mEvent, evtTimeline)}
</EncryptedContent>
);
}
function renderNotificationSticker(
ctx: NotificationRendererContext,
event: IRoomEvent,
_displayName: string,
getContent: GetContentCallback
) {
if (event.unsigned?.redacted_because) {
return <RedactedContent reason={event.unsigned?.redacted_because.content.reason} />;
}
return (
<MSticker
content={getContent() as IImageContent}
renderImageContent={renderNotificationStickerImageContent.bind(null, ctx.mediaAutoLoad)}
/>
);
}
function renderNotificationTombstone(_ctx: NotificationRendererContext, event: IRoomEvent) {
const { content } = event;
return (
<Box grow="Yes" direction="Column">
<Text size="T400" priority="300">
Room Tombstone. {content.body}
</Text>
</Box>
);
}
function renderNotificationFallback(_ctx: NotificationRendererContext, event: IRoomEvent) {
if (event.unsigned?.redacted_because) {
return <RedactedContent reason={event.unsigned?.redacted_because.content.reason} />;
}
return (
<Box grow="Yes" direction="Column">
<Text size="T400" priority="300">
<code className={customHtmlCss.Code}>{event.type}</code>
{' event'}
</Text>
</Box>
);
}
type RoomNotificationsGroupProps = {
room: Room;
appBaseUrl: string;
notifications: INotification[];
mediaAutoLoad?: boolean;
urlPreview?: boolean;
hideReads: boolean;
onOpen: (roomId: string, eventId: string) => void;
legacyUsernameColor?: boolean;
hour24Clock: boolean;
dateFormatString: string;
};
type NotificationItemProps = {
room: Room;
notification: INotification;
renderContent: ReturnType<typeof useRoomMessagePreviewRenderer>;
onOpen: (roomId: string, eventId: string) => void;
hour24Clock: boolean;
dateFormatString: string;
};
function NotificationItem({
room,
notification,
renderContent,
onOpen,
hour24Clock,
dateFormatString,
}: NotificationItemProps) {
const event = useMemo(() => new MatrixEvent(notification.event), [notification.event]);
const handleOpen: MouseEventHandler<HTMLButtonElement> = (evt) => {
evt.stopPropagation();
onOpen(room.roomId, notification.event.event_id);
};
return (
<SequenceCard
style={{ padding: config.space.S400 }}
variant="SurfaceVariant"
direction="Column"
>
<MessagePreview
room={room}
event={event}
renderContent={renderContent}
actions={
<Chip onClick={handleOpen} variant="Secondary" radii="400">
<Text size="T200">Open</Text>
</Chip>
}
onOpen={handleOpen}
hour24Clock={hour24Clock}
dateFormatString={dateFormatString}
/>
</SequenceCard>
);
}
function RoomNotificationsGroupComp({
room,
appBaseUrl,
notifications,
mediaAutoLoad,
urlPreview,
hideReads,
onOpen,
legacyUsernameColor,
hour24Clock,
dateFormatString,
}: Readonly<RoomNotificationsGroupProps>) {
const mx = useMatrixClient();
const useAuthentication = useMediaAuthentication();
const unread = useRoomUnread(room.roomId, roomToUnreadAtom);
const nicknames = useAtomValue(nicknamesAtom);
const cachedProfiles = useAtomValue(profilesCacheAtom);
const [, forceUpdate] = useState(0);
useEffect(() => {
let disposed = false;
const unknownUserIds = notifications
.map((n) => n.event.sender)
.filter((sender) => sender && !room.getMember(sender));
if (unknownUserIds.length > 0) {
hydrateRoomMembers(mx, room.roomId, unknownUserIds).then(() => {
if (!disposed) forceUpdate((n) => n + 1);
});
}
return () => {
disposed = true;
};
}, [mx, room, notifications]);
const powerLevels = usePowerLevels(room);
const creators = useRoomCreators(room);
const creatorsTag = useRoomCreatorsTag();
const powerLevelTags = usePowerLevelTags(room, powerLevels);
const getMemberPowerTag = useGetMemberPowerTag(room, creators, powerLevels);
const theme = useTheme();
const accessibleTagColors = useAccessiblePowerTagColors(theme.kind, creatorsTag, powerLevelTags);
const mentionClickHandler = useMentionClickHandler(room.roomId);
const spoilerClickHandler = useSpoilerClickHandler();
const linkifyOpts = useMemo<LinkifyOpts>(
() => ({
...LINKIFY_OPTS,
render: factoryRenderLinkifyWithMention(
appBaseUrl,
(href) =>
renderMatrixMention(
mx,
room.roomId,
href,
makeMentionCustomProps(mentionClickHandler),
nicknames
),
mentionClickHandler
),
}),
[appBaseUrl, mx, room, mentionClickHandler, nicknames]
);
const htmlReactParserOptions = useMemo<HTMLReactParserOptions>(
() =>
getReactCustomHtmlParser(mx, room.roomId, {
settingsLinkBaseUrl: appBaseUrl,
linkifyOpts,
useAuthentication,
handleSpoilerClick: spoilerClickHandler,
handleMentionClick: mentionClickHandler,
nicknames,
}),
[
appBaseUrl,
mx,
room,
linkifyOpts,
mentionClickHandler,
spoilerClickHandler,
useAuthentication,
nicknames,
]
);
const rendererContext = useMemo<NotificationRendererContext>(
() => ({
mx,
room,
mediaAutoLoad,
urlPreview,
htmlReactParserOptions,
linkifyOpts,
}),
[mx, room, mediaAutoLoad, urlPreview, htmlReactParserOptions, linkifyOpts]
);
const matrixEventHandlers = useMemo(
() => ({
[EventType.RoomMessage]: renderNotificationRoomMessage.bind(null, rendererContext),
[EventType.RoomMessageEncrypted]: renderNotificationEncrypted.bind(null, rendererContext),
[EventType.Sticker]: renderNotificationSticker.bind(null, rendererContext),
[EventType.RoomTombstone]: renderNotificationTombstone.bind(null, rendererContext),
}),
[rendererContext]
);
const renderMatrixEvent = useMatrixEventRenderer<[IRoomEvent, string, GetContentCallback]>(
matrixEventHandlers,
undefined,
renderNotificationFallback.bind(null, rendererContext)
);
const handleOpenClick: MouseEventHandler = (evt) => {
const eventId = evt.currentTarget.getAttribute('data-event-id');
if (!eventId) return;
onOpen(room.roomId, eventId);
};
const renderContent = useRoomMessagePreviewRenderer(room, { settingsLinkBaseUrl: appBaseUrl });
const handleMarkAsRead = () => {
markAsRead(mx, room.roomId, hideReads);
};
@@ -554,108 +252,17 @@ function RoomNotificationsGroupComp({
</Box>
</Header>
<Box direction="Column" gap="100">
{notifications.map((notification) => {
const { event } = notification;
const displayName =
getMemberDisplayName(room, event.sender, nicknames) ??
cachedProfiles[event.sender]?.displayName ??
getMxIdLocalPart(event.sender) ??
event.sender;
const senderAvatarMxc = getMemberAvatarMxc(room, event.sender);
const getContent = (() => event.content) as GetContentCallback;
const relation = event.content['m.relates_to'];
const replyEventId = relation?.['m.in_reply_to']?.event_id;
const threadRootId =
relation?.rel_type === RelationType.Thread ? relation.event_id : undefined;
// doesn't work for encrypted rooms
// not a big deal really, don't want to bother with finding the event by id and decrypting
const mentions = event.content['m.mentions'];
const memberPowerTag = getMemberPowerTag(event.sender);
const tagColor = memberPowerTag?.color
? accessibleTagColors?.get(memberPowerTag.color)
: undefined;
const tagIconSrc = memberPowerTag?.icon
? getPowerTagIconSrc(mx, useAuthentication, memberPowerTag.icon)
: undefined;
const usernameColor = legacyUsernameColor ? colorMXID(event.sender) : tagColor;
return (
<SequenceCard
key={notification.event.event_id}
style={{ padding: config.space.S400 }}
variant="SurfaceVariant"
direction="Column"
>
<ModernLayout
before={
<AvatarBase>
<Avatar size="300">
<UserAvatar
userId={event.sender}
src={
senderAvatarMxc
? (mxcUrlToHttp(
mx,
senderAvatarMxc,
useAuthentication,
48,
48,
'crop'
) ?? undefined)
: undefined
}
alt={displayName}
renderFallback={() => userFallbackIcon('lg')}
/>
</Avatar>
</AvatarBase>
}
>
<Box gap="300" justifyContent="SpaceBetween" alignItems="Center" grow="Yes">
<Box gap="200" alignItems="Baseline">
<Box alignItems="Center" gap="200">
<Username style={{ color: usernameColor }}>
<Text as="span" truncate>
<UsernameBold>{displayName}</UsernameBold>
</Text>
</Username>
{tagIconSrc && <PowerIcon size="100" iconSrc={tagIconSrc} />}
</Box>
<Time
ts={event.origin_server_ts}
hour24Clock={hour24Clock}
dateFormatString={dateFormatString}
/>
</Box>
<Box shrink="No" gap="200" alignItems="Center">
<Chip
data-event-id={event.event_id}
onClick={handleOpenClick}
variant="Secondary"
radii="400"
>
<Text size="T200">Open</Text>
</Chip>
</Box>
</Box>
{replyEventId && (
<Reply
room={room}
replyEventId={replyEventId}
threadRootId={threadRootId}
mentions={mentions}
onClick={handleOpenClick}
/>
)}
{renderMatrixEvent(event.type, false, event, displayName, getContent)}
</ModernLayout>
</SequenceCard>
);
})}
{notifications.map((notification) => (
<NotificationItem
key={notification.event.event_id}
room={room}
notification={notification}
renderContent={renderContent}
onOpen={onOpen}
hour24Clock={hour24Clock}
dateFormatString={dateFormatString}
/>
))}
</Box>
</Box>
);
@@ -676,13 +283,9 @@ const FAST_REFRESH_MS = 2500;
export function Notifications() {
const mx = useMatrixClient();
const [hideReads] = useSetting(settingsAtom, 'hideReads');
const [mediaAutoLoad] = useSetting(settingsAtom, 'mediaAutoLoad');
const [urlPreview] = useSetting(settingsAtom, 'urlPreview');
const [legacyUsernameColor] = useSetting(settingsAtom, 'legacyUsernameColor');
const [hour24Clock] = useSetting(settingsAtom, 'hour24Clock');
const [dateFormatString] = useSetting(settingsAtom, 'dateFormatString');
const screenSize = useScreenSizeContext();
const mDirects = useAtomValue(mDirectAtom);
const appBaseUrl = useSettingsLinkBaseUrl();
const { navigateRoom } = useRoomNavigate();
@@ -826,13 +429,8 @@ export function Notifications() {
room={groupRoom}
appBaseUrl={appBaseUrl}
notifications={group.notifications}
mediaAutoLoad={mediaAutoLoad}
urlPreview={urlPreview}
hideReads={hideReads}
onOpen={navigateRoom}
legacyUsernameColor={
legacyUsernameColor || mDirects.has(groupRoom.roomId)
}
hour24Clock={hour24Clock}
dateFormatString={dateFormatString}
/>
+4 -7
View File
@@ -1,6 +1,5 @@
import type { ReactNode } from 'react';
import { atom } from 'jotai';
import type { IdTokenClaims } from '$types/matrix-sdk';
import type { IdTokenClaims, MatrixEvent, Room } from '$types/matrix-sdk';
import { createLogger } from '$utils/debug';
import {
atomWithLocalStorage,
@@ -232,11 +231,9 @@ export type InAppBannerNotification = {
/** Display name of the sender. */
senderName?: string;
body?: string;
/**
* Pre-rendered rich body with mxc/mention transforms (built in ClientNonUIFeatures).
* When present, takes precedence over the plain-text `body` fallback.
*/
bodyNode?: ReactNode;
/** Full event context for rendering the same rich preview used elsewhere. */
room?: Room;
event?: MatrixEvent;
/** URL of an avatar or room icon to display inside the banner. */
icon?: string;
onClick: () => void;