17 Commits
Author SHA1 Message Date
litruv b294bb0c06 Revert reporting the activity bar against the message in the viewport.
Trigger cinny-mobile / dispatch (push) Successful in 1s
The activity bar shows readers of the latest rendered event again. The scroll listener and the extra prop are gone.
2026-10-31 23:51:34 +11:00
litruv a6fac786b3 Fetch the TikTok oEmbed through the main process in Electron and drop the thumbnail crossOrigin.
Trigger cinny-mobile / dispatch (push) Successful in 1s
2026-10-15 23:12:55 +11:00
litruv a4e96dd01f Remove the Paarrot delivery receipt.
Trigger cinny-mobile / dispatch (push) Successful in 2s
Delivery markers (com.paarrot.received) are no longer sent or rendered; the activity bar shows only read receipts. Markers already sent to servers remain there.
2026-10-13 19:04:54 +11:00
litruv f0495cccca Report the activity bar against the message in the viewport.
Trigger cinny-mobile / dispatch (push) Successful in 1s
2026-10-13 14:34:25 +11:00
litruv 76e5f960d1 Add Telegram-style delivery receipt to Paarrot.
Trigger cinny-mobile / dispatch (push) Successful in 1s
Matrix has no delivery receipt type in the spec (Synapse only accepts
m.read, m.read.private and m.fully_read), so delivery is recorded as a
client-defined event com.paarrot.received related to the target message
with m.reference. The app sends the marker when a notification fires for
a message, and the bottom-right indicator shows a single tick when
received-but-not-read and the existing double tick once read. Other
clients see an unknown event; cinny never renders it in the timeline
because events with a relation are skipped unless show hidden events is on.
2026-10-13 08:01:04 +11:00
litruv bd649d4e16 Apply the flat composer chrome to all themes instead of stationery only.
Trigger cinny-mobile / dispatch (push) Successful in 1s
2026-10-13 03:10:20 +11:00
litruv 2639982d5b Add word wrap, line numbers, and language override to code blocks. 2026-10-13 03:09:31 +11:00
litruv 95d1cb9630 Show cached spaces on the loading splash until the chats are ready
Trigger cinny-mobile / dispatch (push) Successful in 1s
The splash hid as soon as sync reported Prepared, so the first paint after it
disappeared showed the empty state. Hide only once the room-list atoms actually
contain chats, and bind those atoms while the splash is still up so the first
paint is already populated.

Also fixes the ClientEvent.Sync handler signature: data is the third argument,
so reading it as the second made fromCache always undefined.
2026-10-06 11:11:27 +11:00
litruv fabbbc40af Skip sourcemap generation in CI builds
Trigger cinny-mobile / dispatch (push) Successful in 1s
2026-10-06 08:04:04 +11:00
litruv 72c71bc789 Add 4.11.193 update notes for the shared profile cache.
Trigger cinny-mobile / dispatch (push) Successful in 1s
Move the Discord collectibles entry into the older list, and list 4.11.177 there too - its document was bundled but never referenced by the manifest.
2026-10-06 07:49:42 +11:00
litruv 9b657e3ab4 Cache profile fields and assets behind one shared store.
Trigger cinny-mobile / dispatch (push) Successful in 1s
Colour, banner, collectibles, and profile each read the same extended
profile endpoint through separate caches with mismatched TTLs, so a
single profile view fired three round trips. They now read through one
cache with a shared TTL and in-flight dedupe, and profile media is kept
as blob URLs instead of being re-downloaded per mount.

useUserProfile now prefers the SDK's sync-cached user and only fetches
when both the SDK and the cache are cold.
2026-10-06 07:42:47 +11:00
litruv f2caef5592 Open the last seen channel on startup.
Trigger cinny-mobile / dispatch (push) Successful in 1s
2026-10-06 00:37:57 +11:00
litruv 47979718eb Fix responsive message images
Trigger cinny-mobile / dispatch (push) Successful in 2s
Constrain image attachments to their parent while preserving their aspect ratio.
2026-08-25 00:02:45 +10:00
litruv 862307ee7d Add TikTok player iframe
Trigger cinny-mobile / dispatch (push) Successful in 2s
Use TikTok's supported player endpoint rather than injecting its oEmbed script.
2026-08-24 23:58:31 +10:00
litruv b16263b481 Enable native HTTP for Capacitor.
Trigger cinny-mobile / dispatch (push) Successful in 1s
Route mobile fetch requests through Capacitor's native network bridge to support redirected collectible catalog downloads.
2026-08-24 20:06:27 +10:00
litruv c34cfaf33f Enable collectibles on mobile clients.
Trigger cinny-mobile / dispatch (push) Successful in 1s
Fetch and cache the published catalog in the renderer when Electron is unavailable, then download selected CDN assets directly for Matrix upload.
2026-08-24 19:52:50 +10:00
litruv 87c9f59826 Use public Discord collectibles catalog.
Trigger cinny-mobile / dispatch (push) Successful in 2s
Remove local token setup in favor of the cached published catalog and document the collectible profile experience in the latest update notes.
2026-08-24 19:29:48 +10:00
40 changed files with 1305 additions and 512 deletions
+3
View File
@@ -7,6 +7,9 @@
"LocalNotifications": {
"smallIcon": "ic_stat_paarrot",
"iconColor": "#FF8A00"
},
"CapacitorHttp": {
"enabled": true
}
}
}
+22
View File
@@ -0,0 +1,22 @@
---
version: 4.11.177
title: Profile colors & banners
date: 2026-08-23
summary: Username colors now follow MSC4522 with separate dark and light theme pickers.
---
## Profile colors (MSC4522)
Username colors are now stored on your Matrix profile instead of inside avatar images. In turn **will need to be updated in your Account settings**, this is now cross compatible with Element + Cinny
- Set **separate colors for dark and light themes** in Settings → Account → Profile.
- Per-room username overrides are read from member profile data when available.
![Paarrot](./images/usernamecolors.png)
## Profile banners (MSC4133)
Profile banners now live on your Matrix profile via `m.banner_url` (MSC4133), not embedded in avatar metadata.
- Upload or remove a banner independently from your avatar.
- Other clients that support MSC4133 can read your banner directly.
+22
View File
@@ -0,0 +1,22 @@
---
version: 4.11.185
title: Discord collectibles
date: 2026-08-24
summary: Add Discord-style profile effects, nameplates, and avatar decorations to Paarrot profiles.
---
## Discord collectibles
- Browse and apply profile effects, animated nameplates, and avatar decorations in Settings → Account → Profile.
- Collectible assets are uploaded to your Matrix profile, so other Paarrot users can see them without Discord.
- The catalog now comes from a public git, and no Discord token is required in Paarrot for the cosmetics.
- Profile-effect previews play their intro and loop animations, with a mini profile preview for each effect.
![Discord Cosmetics 1](./images/discordcosmetics1.png) ![Discord Cosmetics 2](./images/discordcosmetics2.png)
## Profile presentation
- Avatar decorations render in messages, profile cards, and the bottom sidebar avatar.
- Nameplates to the right of messages, beneath timestamps and can be displayed behind the bottom sidebar avatar with opacity settings.
- Customize the sidebar nameplate opacity in Settings → General → Collectibles.
+10 -18
View File
@@ -1,22 +1,14 @@
---
version: 4.11.177
title: Profile colors & banners
date: 2026-08-23
summary: Username colors now follow MSC4522 with separate dark and light theme pickers.
version: 4.11.193
title: Profile caching
date: 2026-10-06
summary: Profile colour, banner, and collectibles now share one cache, so opening a profile makes one request instead of three.
---
## Profile colors (MSC4522)
## Profile caching
Username colors are now stored on your Matrix profile instead of inside avatar images. In turn **will need to be updated in your Account settings**, this is now cross compatible with Element + Cinny
- Set **separate colors for dark and light themes** in Settings → Account → Profile.
- Per-room username overrides are read from member profile data when available.
![Paarrot](./images/usernamecolors.png)
## Profile banners (MSC4133)
Profile banners now live on your Matrix profile via `m.banner_url` (MSC4133), not embedded in avatar metadata.
- Upload or remove a banner independently from your avatar.
- Other clients that support MSC4133 can read your banner directly.
- Colour, banner, and collectibles all come from the same profile endpoint, and they now read through one shared cache with a single TTL instead of keeping three separate caches with different expiries.
- Opening a profile view costs one request, and concurrent viewers of the same user share it instead of each firing their own.
- Banner and collectible images are kept as cached blob URLs and reused across views, instead of being re-downloaded and discarded every time a profile opens.
- Profile cards read the sync-cached user when it is available and only fetch when both the SDK cache and the shared cache are cold.
- A redundant database scan was removed from the crypto startup path, which shaves a little off launch.
Binary file not shown.

After

Width:  |  Height:  |  Size: 15 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 105 KiB

+12
View File
@@ -1,6 +1,18 @@
{
"current": "currentupdate.md",
"older": [
{
"file": "4.11.185.md",
"version": "4.11.185",
"title": "Discord collectibles",
"date": "2026-08-24"
},
{
"file": "4.11.177.md",
"version": "4.11.177",
"title": "Profile colors & banners",
"date": "2026-08-23"
},
{
"file": "4.11.175.md",
"version": "4.11.175",
+2
View File
@@ -104,6 +104,7 @@ import {
VideoOff,
Volume2,
VolumeX,
WrapText,
X,
} from 'lucide-react';
@@ -233,6 +234,7 @@ export const Icons = {
Vlc: Play,
VolumeHigh: Volume2,
VolumeMute: VolumeX,
WrapText,
Warning: TriangleAlert,
ImagePlay,
} as const;
@@ -262,7 +262,7 @@ export function MImage({ content, renderImageContent, outlined }: MImageProps) {
<AttachmentBox
style={{
width: toRem(width),
height: toRem(height),
aspectRatio: `${width} / ${height}`,
['--media-h' as string]: `${height}px`,
}}
data-paarrot-media-height={height}
@@ -8,7 +8,7 @@ export const Attachment = recipe({
color: color.SurfaceVariant.OnContainer,
borderRadius: config.radii.R400,
overflow: 'hidden',
maxWidth: toRem(400),
maxWidth: `min(100%, ${toRem(400)})`,
},
variants: {
outlined: {
@@ -33,7 +33,7 @@ export const AttachmentHeader = style({
export const AttachmentBox = style([
DefaultReset,
{
maxWidth: toRem(400),
maxWidth: `min(100%, ${toRem(400)})`,
maxHeight: toRem(400),
overflow: 'hidden',
},
@@ -112,5 +112,7 @@ export const TikTokEmbedContainer = style([
alignItems: 'center',
justifyContent: 'center',
backgroundColor: '#000',
border: 'none',
display: 'block',
},
]);
+61 -29
View File
@@ -42,6 +42,12 @@ export function isTikTokUrl(url: string): boolean {
return TIKTOK_URL_PATTERNS.some((pattern) => pattern.test(url));
}
function extractTikTokVideoId(url: string, embedHtml = ''): string | null {
const urlMatch = url.match(/\/video\/(\d+)/i) ?? url.match(/\/v\/(\d+)/i);
const embedMatch = embedHtml.match(/data-video-id=["'](\d+)["']/i);
return urlMatch?.[1] ?? embedMatch?.[1] ?? null;
}
/**
* Fetches TikTok video metadata using oEmbed API
* @param url The TikTok video URL
@@ -53,29 +59,45 @@ async function fetchTikTokOEmbed(url: string): Promise<{
authorUrl: string;
thumbnailUrl: string;
embedHtml: string;
videoId: string | null;
} | null> {
try {
const oembedUrl = `${TIKTOK_OEMBED_API}?url=${encodeURIComponent(url)}`;
const response = await fetch(oembedUrl);
if (!response.ok) return null;
const data = await response.json();
const electron = (window as any).electron;
let data;
if (electron?.tiktok?.getOEmbed) {
data = await electron.tiktok.getOEmbed(url);
} else {
const oembedUrl = `${TIKTOK_OEMBED_API}?url=${encodeURIComponent(url)}`;
const response = await fetch(oembedUrl);
if (!response.ok) return null;
data = await response.json();
}
if (!data) return null;
return {
title: data.title || 'TikTok Video',
authorName: data.author_name || 'Unknown',
authorUrl: data.author_url || url,
thumbnailUrl: data.thumbnail_url || '',
embedHtml: data.html || '',
videoId: extractTikTokVideoId(url, data.html || ''),
};
} catch {
return null;
}
}
type TikTokEmbedState =
type TikTokEmbedState =
| { status: 'loading' }
| { status: 'loaded'; title: string; authorName: string; authorUrl: string; thumbnailUrl: string; embedHtml: string }
| {
status: 'loaded';
title: string;
authorName: string;
authorUrl: string;
thumbnailUrl: string;
embedHtml: string;
videoId: string | null;
}
| { status: 'error' };
type TikTokEmbedProps = {
@@ -88,7 +110,7 @@ type TikTokEmbedProps = {
*/
export const TikTokEmbed = as<'div', TikTokEmbedProps>(({ url, ...props }, ref) => {
const [state, setState] = useState<TikTokEmbedState>({ status: 'loading' });
const [showEmbed, setShowEmbed] = useState(false);
const [showPlayer, setShowPlayer] = useState(false);
// Fetch video info on mount
useEffect(() => {
@@ -96,7 +118,7 @@ export const TikTokEmbed = as<'div', TikTokEmbedProps>(({ url, ...props }, ref)
fetchTikTokOEmbed(url).then((info) => {
if (cancelled) return;
if (info) {
setState({
status: 'loaded',
@@ -105,6 +127,7 @@ export const TikTokEmbed = as<'div', TikTokEmbedProps>(({ url, ...props }, ref)
authorUrl: info.authorUrl,
thumbnailUrl: info.thumbnailUrl,
embedHtml: info.embedHtml,
videoId: info.videoId,
});
} else {
setState({ status: 'error' });
@@ -134,9 +157,9 @@ export const TikTokEmbed = as<'div', TikTokEmbedProps>(({ url, ...props }, ref)
TikTok - Loading...
</Text>
</div>
<Box
className={css.TikTokThumbnailContainer}
alignItems="Center"
<Box
className={css.TikTokThumbnailContainer}
alignItems="Center"
justifyContent="Center"
style={{ background: '#000', display: 'flex' }}
>
@@ -169,7 +192,7 @@ export const TikTokEmbed = as<'div', TikTokEmbedProps>(({ url, ...props }, ref)
}
// Loaded state - show thumbnail or embed
if (!showEmbed) {
if (!showPlayer) {
return (
<Box shrink="No" className={css.TikTokEmbed} direction="Column" {...props} ref={ref}>
<div className={css.TikTokEmbedHeader}>
@@ -203,23 +226,22 @@ export const TikTokEmbed = as<'div', TikTokEmbedProps>(({ url, ...props }, ref)
<button
type="button"
className={css.TikTokThumbnailButton}
onClick={() => setShowEmbed(true)}
aria-label="Load TikTok video"
onClick={() => setShowPlayer(true)}
aria-label="Play TikTok video"
>
{state.thumbnailUrl && (
<img
src={state.thumbnailUrl}
alt={state.title}
className={css.TikTokThumbnail}
crossOrigin="anonymous"
/>
)}
{state.thumbnailUrl ? (
<img src={state.thumbnailUrl} alt={state.title} className={css.TikTokThumbnail} />
) : null}
</button>
</Box>
);
}
// Show embed (using dangerouslySetInnerHTML for TikTok's oEmbed HTML)
const playerUrl = state.videoId
? `https://www.tiktok.com/player/v1/${state.videoId}?autoplay=1`
: null;
// Use TikTok's documented player instead of injecting the oEmbed script.
return (
<Box shrink="No" className={css.TikTokEmbed} direction="Column" {...props} ref={ref}>
<div className={css.TikTokEmbedHeader}>
@@ -236,10 +258,20 @@ export const TikTokEmbed = as<'div', TikTokEmbedProps>(({ url, ...props }, ref)
{state.title}
</Text>
</div>
<div
className={css.TikTokEmbedContainer}
dangerouslySetInnerHTML={{ __html: state.embedHtml }}
/>
{playerUrl ? (
<iframe
className={css.TikTokEmbedContainer}
src={playerUrl}
title="TikTok video player"
allow="autoplay; encrypted-media; fullscreen; picture-in-picture"
allowFullScreen
/>
) : (
<div
className={css.TikTokEmbedContainer}
dangerouslySetInnerHTML={{ __html: state.embedHtml }}
/>
)}
</Box>
);
});
+2 -2
View File
@@ -6,8 +6,8 @@ export const RoomInputWrap = style({
width: '100%',
});
/* Notebook-flat composer chrome — Stationery only (other themes keep Editor inset border) */
globalStyle(`.stationery ${RoomInputWrap} .${editorCss.Editor}`, {
/* Notebook-flat composer chrome — all themes */
globalStyle(`${RoomInputWrap} .${editorCss.Editor}`, {
borderRadius: 0,
boxShadow: 'none',
borderTop: `${config.borderWidth.B300} solid ${color.SurfaceVariant.ContainerLine}`,
+4 -4
View File
@@ -100,7 +100,7 @@ import colorMXID from '../../../util/colorMXID';
import { useIsDirectRoom } from '../../hooks/useRoom';
import { useAccessiblePowerTagColors, useGetMemberPowerTag } from '../../hooks/useMemberPowerTag';
import { useRoomCreators } from '../../hooks/useRoomCreators';
import { isStationeryTheme, useTheme } from '../../hooks/useTheme';
import { useTheme } from '../../hooks/useTheme';
import { useRoomCreatorsTag } from '../../hooks/useRoomCreatorsTag';
import { usePowerLevelTags } from '../../hooks/usePowerLevelTags';
import { useComposingCheck } from '../../hooks/useComposingCheck';
@@ -694,9 +694,9 @@ export const RoomInput = forwardRef<HTMLDivElement, RoomInputProps>(
backgroundColor: color.SurfaceVariant.Container,
border: `${config.borderWidth.B300} solid ${color.SurfaceVariant.ContainerLine}`,
borderBottom: 'none',
borderRadius: isStationeryTheme(theme) ? 0 : undefined,
borderTopLeftRadius: isStationeryTheme(theme) ? undefined : config.radii.R400,
borderTopRightRadius: isStationeryTheme(theme) ? undefined : config.radii.R400,
borderRadius: 0,
borderTopLeftRadius: 0,
borderTopRightRadius: 0,
marginBottom: config.space.S100,
}}
direction="Column"
+5 -4
View File
@@ -24,17 +24,18 @@ export type RoomViewFollowingProps = {
export const RoomViewFollowing = as<'div', RoomViewFollowingProps>(
({ className, room, ...props }, ref) => {
const mx = useMatrixClient();
const myUserId = mx.getUserId();
const [open, setOpen] = useState(false);
const latestEvent = useRoomLatestRenderedEvent(room);
const latestEventReaders = useRoomEventReaders(room, latestEvent?.getId());
const eventId = latestEvent?.getId();
const latestEventReaders = useRoomEventReaders(room, eventId);
const names = latestEventReaders
.filter((readerId) => readerId !== mx.getUserId())
.filter((readerId) => readerId !== myUserId)
.map(
(readerId) => getMemberDisplayName(room, readerId) ?? getMxIdLocalPart(readerId) ?? readerId
);
const eventId = latestEvent?.getId();
if (names.length === 0) {
return null;
}
@@ -14,8 +14,8 @@ import {
DiscordCollectibleItem,
collectibleKindLabel,
defaultPreviewAspectRatio,
fetchPublishedCollectiblesCatalog,
groupCollectibleItems,
isElectronCollectiblesAvailable,
uploadCollectibleToMatrix,
variantItemLabel,
} from '../../../utils/discordCollectibles';
@@ -338,9 +338,6 @@ export function CollectiblesSection({ collectibles, onApply }: CollectiblesSecti
);
const previewDisplayName = profile.displayName;
const [kind, setKind] = useState<CollectibleKind>('profile_effect');
const [hasToken, setHasToken] = useState(false);
const [tokenInput, setTokenInput] = useState('');
const [tokenSaving, setTokenSaving] = useState(false);
const [catalogLoading, setCatalogLoading] = useState(false);
const [catalogError, setCatalogError] = useState<string>();
const [items, setItems] = useState<DiscordCollectibleItem[]>([]);
@@ -350,40 +347,30 @@ export function CollectiblesSection({ collectibles, onApply }: CollectiblesSecti
const [error, setError] = useState<string>();
const [selectedByGroup, setSelectedByGroup] = useState<Record<string, string>>({});
const desktopAvailable = isElectronCollectiblesAvailable();
const refreshTokenState = useCallback(async () => {
if (!desktopAvailable) return;
const result = await window.electron!.discordCollectibles!.hasToken();
setHasToken(Boolean(result?.data));
}, [desktopAvailable]);
const loadCatalog = useCallback(async (force = false) => {
if (!desktopAvailable) return;
setCatalogLoading(true);
setCatalogError(undefined);
try {
const result = await window.electron!.discordCollectibles!.fetchCatalog(force);
if (!result?.success || !result.data?.items) {
throw new Error(result?.error || 'Failed to load Discord catalog.');
const desktopCatalog = window.electron?.discordCollectibles;
if (desktopCatalog) {
const result = await desktopCatalog.fetchCatalog(force);
if (!result?.success || !result.data?.items) {
throw new Error(result?.error || 'Failed to load collectibles catalog.');
}
setItems(result.data.items as DiscordCollectibleItem[]);
} else {
setItems(await fetchPublishedCollectiblesCatalog(force));
}
setItems(result.data.items as DiscordCollectibleItem[]);
} catch (e) {
setCatalogError(e instanceof Error ? e.message : 'Failed to load catalog.');
setItems([]);
}
setCatalogLoading(false);
}, [desktopAvailable]);
}, []);
useEffect(() => {
refreshTokenState();
}, [refreshTokenState]);
useEffect(() => {
if (hasToken) {
loadCatalog();
}
}, [hasToken, loadCatalog]);
loadCatalog();
}, [loadCatalog]);
const current = collectibles[KIND_FIELD[kind]];
@@ -416,27 +403,6 @@ export function CollectiblesSection({ collectibles, onApply }: CollectiblesSecti
});
}, [filteredGroups]);
const handleSaveToken = async () => {
if (!desktopAvailable) return;
setTokenSaving(true);
setCatalogError(undefined);
try {
await window.electron!.discordCollectibles!.setToken(tokenInput);
setTokenInput('');
await refreshTokenState();
} catch (e) {
setCatalogError(e instanceof Error ? e.message : 'Failed to save token.');
}
setTokenSaving(false);
};
const handleClearToken = async () => {
if (!desktopAvailable) return;
await window.electron!.discordCollectibles!.clearToken();
setItems([]);
await refreshTokenState();
};
const handleApply = async (item: DiscordCollectibleItem) => {
setApplyingId(item.id);
setError(undefined);
@@ -467,62 +433,27 @@ export function CollectiblesSection({ collectibles, onApply }: CollectiblesSecti
kind === 'avatar_decoration' && css.CollectibleGroupGridDecorations
);
if (!desktopAvailable) {
return (
<Box direction="Column" gap="200">
<Text size="T200" style={{ opacity: 0.8 }}>
Discord profile overlays are available in the Paarrot desktop app. Assets are fetched live from
Discord and uploaded to your Matrix profile when you pick one.
</Text>
</Box>
);
}
return (
<Box direction="Column" gap="300">
<Text size="T200" style={{ opacity: 0.8 }}>
Browse Discord shop collectibles live, then download and upload only what you pick to Matrix.
Your Discord token stays on this device and is only used to list the shop catalog.
Browse a community-published Discord collectibles catalog, then download and upload only what
you pick to Matrix.
</Text>
{!hasToken ? (
<Box direction="Column" gap="200">
<Text size="T300">Discord token (required to list the shop)</Text>
<Input
size="300"
variant="Secondary"
style={{ width: '100%' }}
type="password"
placeholder="User token or Bot xxxxx"
value={tokenInput}
onChange={(e) => setTokenInput(e.target.value)}
/>
<Button
size="300"
variant="Primary"
fill="Solid"
radii="300"
onClick={handleSaveToken}
disabled={tokenSaving || !tokenInput.trim()}
>
<Text size="B300">{tokenSaving ? 'Saving…' : 'Save token'}</Text>
</Button>
{catalogError && <Text size="T200" style={{ color: color.Critical.Main }}>{catalogError}</Text>}
</Box>
) : (
<Box gap="200" alignItems="Center" wrap="Wrap">
<Text size="T200" style={{ opacity: 0.8 }}>Discord token saved on this device.</Text>
<Button size="300" variant="Secondary" fill="Soft" radii="300" onClick={() => loadCatalog(true)} disabled={catalogLoading}>
<Text size="B300">{catalogLoading ? 'Refreshing…' : 'Refresh catalog'}</Text>
</Button>
<Button size="300" variant="Critical" fill="Soft" radii="300" onClick={handleClearToken}>
<Text size="B300">Remove token</Text>
</Button>
</Box>
)}
<Box gap="200" alignItems="Center" wrap="Wrap">
<Button
size="300"
variant="Secondary"
fill="Soft"
radii="300"
onClick={() => loadCatalog(true)}
disabled={catalogLoading}
>
<Text size="B300">{catalogLoading ? 'Refreshing…' : 'Refresh catalog'}</Text>
</Button>
</Box>
{hasToken && (
<>
<>
<Box gap="200" wrap="Wrap">
{KIND_TABS.map((tab) => (
<Button
@@ -559,7 +490,7 @@ export function CollectiblesSection({ collectibles, onApply }: CollectiblesSecti
{catalogLoading && (
<Box gap="200" alignItems="Center">
<Spinner size="100" variant="Secondary" />
<Text size="T200">Loading catalog from Discord…</Text>
<Text size="T200">Loading collectibles catalog…</Text>
</Box>
)}
@@ -606,8 +537,7 @@ export function CollectiblesSection({ collectibles, onApply }: CollectiblesSecti
{!catalogLoading && filteredGroups.length === 0 && (
<Text size="T200" style={{ opacity: 0.7 }}>No items match your search.</Text>
)}
</>
)}
</>
</Box>
);
}
+25
View File
@@ -0,0 +1,25 @@
import { useEffect } from 'react';
import { useLocation, useMatches } from 'react-router-dom';
import { useMatrixClient } from './useMatrixClient';
import { setLastActivePath } from '../state/lastActivePath';
import { withRoomEventId } from '../pages/pathUtils';
/**
* Remembers the last channel the user opened. Only room routes are stored, so
* visiting the inbox, explore or settings does not replace the last seen channel.
* Permalinks are stored as the channel itself, without the event id.
*/
export const useLastActivePathMapper = () => {
const mx = useMatrixClient();
const location = useLocation();
const matches = useMatches();
useEffect(() => {
const userId = mx.getUserId();
if (!userId) return;
if (!matches.some((match) => match.params?.roomIdOrAlias)) return;
setLastActivePath(userId, withRoomEventId(location.pathname));
}, [mx, location, matches]);
};
+17 -46
View File
@@ -1,14 +1,13 @@
import { useCallback, useEffect, useState } from 'react';
import { useMatrixClient } from './useMatrixClient';
import { useMediaAuthentication } from './useMediaAuthentication';
import { mxcUrlToHttp } from '../utils/matrix';
import { getCurrentAccessToken } from '../utils/auth';
import {
extractBannerUrlFromProfile,
deleteBannerUrl,
loadBannerUrl,
registerBannerCacheClear,
saveBannerUrl,
} from '../utils/profileFields';
import { getProfileFields, registerProfileCacheListener } from '../utils/profileCache';
import { getProfileAssetUrl } from '../utils/profileAssetCache';
/**
* Hook to manage the user's profile banner (MSC4427 via MSC4133).
@@ -34,7 +33,7 @@ export function useUserBanner(): [
const load = async () => {
setLoading(true);
try {
const bannerMxc = await loadBannerUrl(mx, userId);
const bannerMxc = extractBannerUrlFromProfile(await getProfileFields(mx, userId));
if (!cancelled) setBanner(bannerMxc);
} catch {
if (!cancelled) setBanner(undefined);
@@ -65,40 +64,15 @@ export function useUserBanner(): [
return [banner, updateBanner, loading];
}
const userBannerCache = new Map<string, { bannerMxc: string | undefined; timestamp: number }>();
const CACHE_TTL_MS = 5 * 60 * 1000;
registerBannerCacheClear((userId: string) => {
userBannerCache.delete(userId);
});
async function fetchBannerBlobUrl(
mx: ReturnType<typeof useMatrixClient>,
bannerMxc: string,
useAuthentication: boolean
): Promise<string | undefined> {
const bannerHttpUrl = mxcUrlToHttp(mx, bannerMxc, useAuthentication);
if (!bannerHttpUrl) return undefined;
const accessToken = getCurrentAccessToken();
const headers: HeadersInit = {};
if (useAuthentication && accessToken) {
headers.Authorization = `Bearer ${accessToken}`;
}
const response = await fetch(bannerHttpUrl, { headers });
if (!response.ok) return undefined;
const blob = await response.blob();
return URL.createObjectURL(blob);
}
/**
* Hook to get another user's profile banner as a blob URL.
* Profile fields come from the shared profile cache, and the media itself is
* cached so reopening the same profile does not re-download the banner.
*/
export function useOtherUserBanner(userId: string): string | undefined {
const mx = useMatrixClient();
const useAuthentication = useMediaAuthentication();
const [bannerBlobUrl, setBannerBlobUrl] = useState<string | undefined>();
useEffect(() => {
@@ -107,34 +81,31 @@ export function useOtherUserBanner(userId: string): string | undefined {
return undefined;
}
let blobUrl: string | undefined;
let cancelled = false;
const load = async () => {
const cached = userBannerCache.get(userId);
let bannerMxc: string | undefined;
if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
bannerMxc = cached.bannerMxc;
} else {
bannerMxc = await loadBannerUrl(mx, userId);
userBannerCache.set(userId, { bannerMxc, timestamp: Date.now() });
}
const fields = await getProfileFields(mx, userId);
if (cancelled) return;
const bannerMxc = extractBannerUrlFromProfile(fields);
if (!bannerMxc) {
if (!cancelled) setBannerBlobUrl(undefined);
setBannerBlobUrl(undefined);
return;
}
blobUrl = await fetchBannerBlobUrl(mx, bannerMxc, useAuthentication);
const blobUrl = await getProfileAssetUrl(mx, bannerMxc, useAuthentication);
if (!cancelled) setBannerBlobUrl(blobUrl);
};
const unsubscribe = registerProfileCacheListener((changedUserId) => {
if (changedUserId === userId) load();
});
load();
return () => {
cancelled = true;
if (blobUrl) URL.revokeObjectURL(blobUrl);
unsubscribe();
};
}, [mx, useAuthentication, userId]);
+28 -76
View File
@@ -1,16 +1,16 @@
import { useCallback, useEffect, useState } from 'react';
import { useMatrixClient } from './useMatrixClient';
import { useMediaAuthentication } from './useMediaAuthentication';
import { mxcUrlToHttp } from '../utils/matrix';
import { getCurrentAccessToken } from '../utils/auth';
import {
CollectibleProfileFields,
StoredCollectible,
loadUserCollectibles,
extractCollectiblesFromProfile,
saveAvatarDecoration,
saveNameplate,
saveProfileEffect,
} from '../utils/profileFields';
import { clearProfileCache, getCachedProfileFields, getProfileFields, registerProfileCacheListener } from '../utils/profileCache';
import { getProfileAssetUrl } from '../utils/profileAssetCache';
import { CollectibleKind } from '../utils/discordCollectibles';
export function useUserCollectibles(): [
@@ -34,7 +34,7 @@ export function useUserCollectibles(): [
const load = async () => {
setLoading(true);
try {
const data = await loadUserCollectibles(mx, userId);
const data = extractCollectiblesFromProfile(await getProfileFields(mx, userId));
if (!cancelled) setCollectibles(data);
} catch {
if (!cancelled) setCollectibles({});
@@ -52,19 +52,14 @@ export function useUserCollectibles(): [
async (kind: CollectibleKind, collectible: StoredCollectible | undefined) => {
if (kind === 'profile_effect') {
await saveProfileEffect(mx, collectible);
clearUserCollectiblesCache(mx.getUserId());
setCollectibles((prev) => ({ ...prev, profile_effect: collectible }));
return;
}
if (kind === 'nameplate') {
} else if (kind === 'nameplate') {
await saveNameplate(mx, collectible);
clearUserCollectiblesCache(mx.getUserId());
setCollectibles((prev) => ({ ...prev, nameplate: collectible }));
return;
} else {
await saveAvatarDecoration(mx, collectible);
}
await saveAvatarDecoration(mx, collectible);
clearUserCollectiblesCache(mx.getUserId());
setCollectibles((prev) => ({ ...prev, avatar_decoration: collectible }));
clearProfileCache(mx.getUserId());
setCollectibles((prev) => ({ ...prev, [kind]: collectible }));
},
[mx]
);
@@ -72,55 +67,21 @@ export function useUserCollectibles(): [
return [collectibles, updateCollectible, loading];
}
const collectibleCache = new Map<string, { data: CollectibleProfileFields; timestamp: number }>();
const collectibleCacheListeners = new Set<(userId: string) => void>();
const CACHE_TTL_MS = 5 * 60 * 1000;
export function clearUserCollectiblesCache(userId?: string): void {
if (!userId) return;
collectibleCache.delete(userId);
collectibleCacheListeners.forEach((listener) => listener(userId));
}
async function fetchMxcBlobUrl(
mx: ReturnType<typeof useMatrixClient>,
mxc: string,
useAuthentication: boolean
): Promise<string | undefined> {
const httpUrl = mxcUrlToHttp(mx, mxc, useAuthentication);
if (!httpUrl) return undefined;
const accessToken = getCurrentAccessToken();
const headers: HeadersInit = {};
if (useAuthentication && accessToken) {
headers.Authorization = `Bearer ${accessToken}`;
}
const response = await fetch(httpUrl, { headers });
if (!response.ok) return undefined;
const blob = await response.blob();
return URL.createObjectURL(blob);
}
/**
* Shared profile fields for another user, served from the profile cache so a
* timeline of many messages by the same author resolves one request per user.
*/
export function useOtherUserCollectibles(userId: string): CollectibleProfileFields & {
assetUrls: Record<string, string | undefined>;
} {
const mx = useMatrixClient();
const useAuthentication = useMediaAuthentication();
const [collectibles, setCollectibles] = useState<CollectibleProfileFields>({});
const [assetUrls, setAssetUrls] = useState<Record<string, string | undefined>>({});
const [cacheVersion, setCacheVersion] = useState(0);
useEffect(() => {
const handleCacheClear = (clearedUserId: string) => {
if (clearedUserId === userId) {
setCacheVersion((version) => version + 1);
}
};
collectibleCacheListeners.add(handleCacheClear);
return () => collectibleCacheListeners.delete(handleCacheClear);
}, [userId]);
const [collectibles, setCollectibles] = useState<CollectibleProfileFields>(() => {
const cached = getCachedProfileFields(userId);
return cached ? extractCollectiblesFromProfile(cached) : {};
});
const [assetUrls, setAssetUrls] = useState<Record<string, string | undefined>>({});
useEffect(() => {
if (!userId) {
@@ -130,19 +91,9 @@ export function useOtherUserCollectibles(userId: string): CollectibleProfileFiel
}
let cancelled = false;
const blobUrls: string[] = [];
const load = async () => {
const cached = collectibleCache.get(userId);
let data: CollectibleProfileFields;
if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
data = cached.data;
} else {
data = await loadUserCollectibles(mx, userId);
collectibleCache.set(userId, { data, timestamp: Date.now() });
}
const data = extractCollectiblesFromProfile(await getProfileFields(mx, userId));
if (cancelled) return;
setCollectibles(data);
@@ -156,24 +107,25 @@ export function useOtherUserCollectibles(userId: string): CollectibleProfileFiel
for (const [kind, collectible] of entries) {
if (!collectible) continue;
for (const [role, mxc] of Object.entries(collectible.assets)) {
const blobUrl = await fetchMxcBlobUrl(mx, mxc, useAuthentication);
if (blobUrl) {
blobUrls.push(blobUrl);
urls[`${kind}:${role}`] = blobUrl;
}
const blobUrl = await getProfileAssetUrl(mx, mxc, useAuthentication);
if (blobUrl) urls[`${kind}:${role}`] = blobUrl;
}
}
if (!cancelled) setAssetUrls(urls);
};
const unsubscribe = registerProfileCacheListener((changedUserId) => {
if (changedUserId === userId) load();
});
load();
return () => {
cancelled = true;
blobUrls.forEach((url) => URL.revokeObjectURL(url));
unsubscribe();
};
}, [cacheVersion, mx, useAuthentication, userId]);
}, [mx, useAuthentication, userId]);
return { ...collectibles, assetUrls };
}
+27 -59
View File
@@ -5,13 +5,13 @@ import { ThemeKind, useTheme } from './useTheme';
import {
ColorPreference,
deleteColorPreference,
extractColorPreferenceFromProfile,
extractMemberColorPreference,
hasColorPreference,
loadColorPreference,
registerPreferenceCacheClear,
resolveColorForTheme,
saveColorPreference,
} from '../utils/profileFields';
import { getCachedProfileFields, getProfileFields, registerProfileCacheListener } from '../utils/profileCache';
/**
* Hook to manage the user's MSC4522 color preference on their global profile.
@@ -37,7 +37,7 @@ export function useUserColorPreference(): [
const load = async () => {
setLoading(true);
try {
const loaded = await loadColorPreference(mx, userId);
const loaded = extractColorPreferenceFromProfile(await getProfileFields(mx, userId));
if (!cancelled) setPreference(loaded);
} catch (e) {
console.error('Failed to load color preference:', e);
@@ -69,80 +69,48 @@ export function useUserColorPreference(): [
return [preference, updatePreference, loading];
}
class LRUCache<K, V> {
private cache = new Map<K, V>();
constructor(private maxSize: number) {}
get(key: K): V | undefined {
const value = this.cache.get(key);
if (value !== undefined) {
this.cache.delete(key);
this.cache.set(key, value);
}
return value;
}
set(key: K, value: V): void {
if (this.cache.has(key)) {
this.cache.delete(key);
} else if (this.cache.size >= this.maxSize) {
const firstKey = this.cache.keys().next().value;
if (firstKey !== undefined) this.cache.delete(firstKey);
}
this.cache.set(key, value);
}
delete(key: K): void {
this.cache.delete(key);
}
}
const preferenceCache = new LRUCache<string, { preference: ColorPreference | undefined; timestamp: number }>(200);
const CACHE_TTL_MS = 30 * 60 * 1000;
registerPreferenceCacheClear((userId: string) => {
preferenceCache.delete(userId);
});
/**
* Hook to get another user's MSC4522 color preference from their global profile.
* Reads through the shared profile cache so the same request is not repeated for
* every message, reply, or profile view by the same user.
*/
export function useOtherUserColorPreference(userId: string): ColorPreference | undefined {
const mx = useMatrixClient();
const cachedEntry = preferenceCache.get(userId);
const cachedPreference =
cachedEntry && Date.now() - cachedEntry.timestamp < CACHE_TTL_MS ? cachedEntry.preference : undefined;
const [preference, setPreference] = useState<ColorPreference | undefined>(cachedPreference);
const [preference, setPreference] = useState<ColorPreference | undefined>(() => {
const cached = getCachedProfileFields(userId);
return cached ? extractColorPreferenceFromProfile(cached) : undefined;
});
useEffect(() => {
if (!userId) {
setPreference(undefined);
return;
}
const cached = preferenceCache.get(userId);
if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
setPreference(cached.preference);
return;
return undefined;
}
let cancelled = false;
const load = async () => {
try {
const loaded = await loadColorPreference(mx, userId);
preferenceCache.set(userId, { preference: loaded, timestamp: Date.now() });
if (!cancelled) setPreference(loaded);
} catch {
if (!cancelled) setPreference(undefined);
}
const apply = (fields: Record<string, unknown>) => {
if (cancelled) return;
setPreference(extractColorPreferenceFromProfile(fields));
};
load();
const unsubscribe = registerProfileCacheListener((changedUserId) => {
if (changedUserId === userId) {
const fields = getCachedProfileFields(userId);
if (fields) apply(fields);
}
});
getProfileFields(mx, userId)
.then(apply)
.catch(() => {
if (!cancelled) setPreference(undefined);
});
return () => {
cancelled = true;
unsubscribe();
};
}, [mx, userId]);
+37 -9
View File
@@ -1,11 +1,13 @@
import { useEffect, useState } from 'react';
import { UserEvent, UserEventHandlerMap } from 'matrix-js-sdk';
import { useMatrixClient } from './useMatrixClient';
import { getCachedProfileFields, getProfileFields, registerProfileCacheListener } from '../utils/profileCache';
export type UserProfile = {
avatarUrl?: string;
displayName?: string;
};
export const useUserProfile = (userId: string): UserProfile => {
const mx = useMatrixClient();
@@ -18,8 +20,33 @@ export const useUserProfile = (userId: string): UserProfile => {
});
useEffect(() => {
if (!userId) return undefined;
const user = mx.getUser(userId);
const onAvatarChange: UserEventHandlerMap[UserEvent.AvatarUrl] = (event, myUser) => {
let disposed = false;
const applyFields = (fields: Record<string, unknown>) => {
const avatarUrl = typeof fields.avatar_url === 'string' ? fields.avatar_url : undefined;
const displayName = typeof fields.displayname === 'string' ? fields.displayname : undefined;
if (!avatarUrl && !displayName) return;
setProfile((cp) => ({
avatarUrl: avatarUrl ?? cp.avatarUrl,
displayName: displayName ?? cp.displayName,
}));
};
// The SDK already holds profile data from sync, so only hit the network when
// both the SDK and the shared profile cache are cold.
const cached = getCachedProfileFields(userId);
if (cached) {
applyFields(cached);
} else if (!user?.displayName && !user?.avatarUrl) {
getProfileFields(mx, userId).then((fields) => {
if (!disposed) applyFields(fields);
});
}
const onProfileChange: UserEventHandlerMap[UserEvent.AvatarUrl] = (event, myUser) => {
setProfile((cp) => ({
...cp,
avatarUrl: myUser.avatarUrl,
@@ -32,17 +59,18 @@ export const useUserProfile = (userId: string): UserProfile => {
}));
};
mx.getProfileInfo(userId).then((info) =>
setProfile({
avatarUrl: info.avatar_url,
displayName: info.displayname,
})
);
const unsubscribeCache = registerProfileCacheListener((changedUserId) => {
if (changedUserId !== userId) return;
const fields = getCachedProfileFields(userId);
if (fields) applyFields(fields);
});
user?.on(UserEvent.AvatarUrl, onAvatarChange);
user?.on(UserEvent.AvatarUrl, onProfileChange);
user?.on(UserEvent.DisplayName, onDisplayNameChange);
return () => {
user?.removeListener(UserEvent.AvatarUrl, onAvatarChange);
disposed = true;
unsubscribeCache();
user?.removeListener(UserEvent.AvatarUrl, onProfileChange);
user?.removeListener(UserEvent.DisplayName, onDisplayNameChange);
};
}, [mx, userId]);
+15 -5
View File
@@ -70,8 +70,16 @@ import { Create } from './client/create';
import { CreateSpaceModalRenderer } from '../features/create-space';
import { SearchModalRenderer } from '../features/search';
import { getCurrentSession } from '../state/sessions';
import { getLastActivePath } from '../state/lastActivePath';
import { AnimatedOutlet } from '../components/AnimatedOutlet';
/**
* Startup landing path: the channel the user last opened, falling back to the inbox
* when nothing has been remembered for the account yet.
*/
const getStartupPath = (userId: string): string =>
getLastActivePath(userId) ?? getInboxNotificationsPath();
export const createRouter = (clientConfig: ClientConfig, screenSize: ScreenSize) => {
const { hashRouter } = clientConfig;
const mobile = screenSize === ScreenSize.Mobile;
@@ -88,7 +96,8 @@ export const createRouter = (clientConfig: ClientConfig, screenSize: ScreenSize)
<Route
index
loader={() => {
if (getCurrentSession()) return redirect(getInboxNotificationsPath());
const session = getCurrentSession();
if (session) return redirect(getStartupPath(session.userId));
const afterLoginPath = getAppPathFromHref(getOriginBaseUrl(), window.location.href);
if (afterLoginPath) setAfterLoginRedirectPath(afterLoginPath);
return redirect(getLoginPath());
@@ -98,7 +107,8 @@ export const createRouter = (clientConfig: ClientConfig, screenSize: ScreenSize)
loader={({ request }) => {
const url = new URL(request.url);
const addingAccount = url.searchParams.get('add-account') === 'true';
const hasSession = !!getCurrentSession();
const session = getCurrentSession();
const hasSession = !!session;
// Log to localStorage for persistence across reloads
const debugInfo = {
@@ -117,9 +127,9 @@ export const createRouter = (clientConfig: ClientConfig, screenSize: ScreenSize)
if (debugLog.length > 10) debugLog.shift(); // Keep last 10
localStorage.setItem('debug-router-logs', JSON.stringify(debugLog));
if (hasSession && !addingAccount) {
console.log('[Router] Redirecting to Inbox/Notifications because session exists and not adding account');
return redirect(getInboxNotificationsPath());
if (session && !addingAccount) {
console.log('[Router] Redirecting to last seen channel for existing session');
return redirect(getStartupPath(session.userId));
}
return null;
+3 -1
View File
@@ -10,6 +10,7 @@ import {
getAfterLoginRedirectPath,
} from '../../afterLoginRedirectPath';
import { getHomePath } from '../../pathUtils';
import { getLastActivePath } from '../../../state/lastActivePath';
import { setFallbackSession } from '../../../state/sessions';
import { getLocalStorageItem, setLocalStorageItem } from '../../../state/utils/atomWithLocalStorage';
@@ -149,7 +150,8 @@ export const useLoginComplete = (data?: CustomLoginResponse) => {
const afterLoginRedirectUrl = getAfterLoginRedirectPath();
deleteAfterLoginRedirectPath();
const targetPath = afterLoginRedirectUrl ?? getHomePath();
const targetPath =
afterLoginRedirectUrl ?? getLastActivePath(loginRes.user_id) ?? getHomePath();
console.log('[Login] Login complete, reloading to initialize client:', {
targetPath,
userId: loginRes.user_id,
@@ -8,6 +8,7 @@ import { makeNavToActivePathAtom } from '../../state/navToActivePath';
import { NavToActivePathProvider } from '../../state/hooks/navToActivePath';
import { makeOpenedSidebarFolderAtom } from '../../state/openedSidebarFolder';
import { OpenedSidebarFolderProvider } from '../../state/hooks/openedSidebarFolder';
import { useLastActivePathMapper } from '../../hooks/useLastActivePathMapper';
type ClientInitStorageAtomProps = {
children: ReactNode;
@@ -24,6 +25,8 @@ export function ClientInitStorageAtom({ children }: ClientInitStorageAtomProps)
const openedSidebarFolderAtom = useMemo(() => makeOpenedSidebarFolderAtom(userId), [userId]);
useLastActivePathMapper();
return (
<ClosedNavCategoriesProvider value={closedNavCategoriesAtom}>
<ClosedLobbyCategoriesProvider value={closedLobbyCategoriesAtom}>
+49
View File
@@ -0,0 +1,49 @@
import { keyframes, style } from '@vanilla-extract/css';
import { config, DefaultReset, toRem } from 'folds';
const particleRise = keyframes({
'0%': {
opacity: 0,
transform: 'translateY(24px) scale(0.85)',
},
'100%': {
opacity: 1,
transform: 'translateY(0) scale(1)',
},
});
export const SplashSpaces = style([
DefaultReset,
{
display: 'flex',
flexWrap: 'wrap',
justifyContent: 'center',
alignItems: 'center',
gap: config.space.S300,
maxWidth: toRem(420),
},
]);
export const SplashSpace = style({
animation: `${particleRise} 450ms cubic-bezier(0.16, 1, 0.3, 1) both`,
});
export const SplashSpaceImage = style({
width: '100%',
height: '100%',
borderRadius: 'inherit',
});
export const SplashStatus = style({
animation: `${particleRise} 450ms cubic-bezier(0.16, 1, 0.3, 1) both`,
});
export const SplashSpaceFallback = style({
width: '100%',
height: '100%',
borderRadius: 'inherit',
textTransform: 'capitalize',
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
});
+128
View File
@@ -0,0 +1,128 @@
import { Avatar, AvatarFallback, AvatarImage, Box, Spinner, Text, color } from 'folds';
import React, { useEffect, useState } from 'react';
import { ClientEvent, MatrixClient, Room } from 'matrix-js-sdk';
import { SplashScreen } from '../../components/splash-screen';
import { getAccountData, getMDirects, getRoomAvatarUrl, isSpace } from '../../utils/room';
import { AccountDataEvent } from '../../../types/matrix/accountData';
import { nameInitials } from '../../utils/common';
import colorMXID from '../../../util/colorMXID';
import * as css from './ClientLoading.css';
type CachedChats = {
spaces: Room[];
directs: number;
};
const getSnapshot = (mx: MatrixClient): CachedChats => {
const rooms = mx.getRooms();
const mDirectEvent = getAccountData(mx, AccountDataEvent.Direct);
const directs = mDirectEvent ? getMDirects(mDirectEvent) : new Set<string>();
return {
spaces: rooms
.filter((room) => isSpace(room) && room.getMyMembership() === 'join')
.sort((a, b) => (a.name ?? '').localeCompare(b.name ?? '')),
directs: rooms.filter((room) => directs.has(room.roomId)).length,
};
};
/**
* Cached rooms are restored asynchronously from the IndexedDB store, so poll
* while connecting to show the user's spaces as soon as they become available.
*/
function useCachedChats(mx?: MatrixClient): CachedChats {
const [snapshot, setSnapshot] = useState<CachedChats>(() =>
mx ? getSnapshot(mx) : { spaces: [], directs: 0 },
);
useEffect(() => {
if (!mx) return undefined;
const update = () => setSnapshot(getSnapshot(mx));
update();
const timer = setInterval(update, 400);
mx.on(ClientEvent.Room, update);
mx.on(ClientEvent.AccountData, update);
return () => {
clearInterval(timer);
mx.removeListener(ClientEvent.Room, update);
mx.removeListener(ClientEvent.AccountData, update);
};
}, [mx]);
return snapshot;
}
function SplashSpaceAvatar({ mx, room, index }: { mx: MatrixClient; room: Room; index: number }) {
// Authenticated media needs the full client context, which is not available
// while loading; fall back to initials when the plain URL fails.
const src = getRoomAvatarUrl(mx, room, 96);
const [error, setError] = useState(false);
return (
<Avatar
size="300"
radii="400"
className={css.SplashSpace}
style={{ animationDelay: `${Math.min(index * 80, 640)}ms` }}
>
{src && !error ? (
<AvatarImage
className={css.SplashSpaceImage}
src={src}
alt={room.name}
onError={() => setError(true)}
draggable={false}
/>
) : (
<AvatarFallback
className={css.SplashSpaceFallback}
style={{ backgroundColor: colorMXID(room.roomId), color: color.Surface.Container }}
>
<Text size="H6">{nameInitials(room.name, 2)}</Text>
</AvatarFallback>
)}
</Avatar>
);
}
const foundLine = (spaces: number, directs: number): string => {
const parts = [];
if (spaces > 0) parts.push(`Found ${spaces} ${spaces === 1 ? 'space' : 'spaces'}`);
if (directs > 0) parts.push(`${directs} ${directs === 1 ? 'chat' : 'chats'}`);
return parts.join(' · ');
};
export function ClientLoading({ mx }: { mx?: MatrixClient }) {
const { spaces, directs } = useCachedChats(mx);
return (
<SplashScreen>
<Box direction="Column" grow="Yes" alignItems="Center" justifyContent="Center" gap="400">
<Spinner variant="Secondary" size="600" />
<Text>Heating up</Text>
{mx && (spaces.length > 0 || directs > 0) && (
<>
{spaces.length > 0 && (
<Box className={css.SplashSpaces}>
{spaces.map((space, index) => (
<SplashSpaceAvatar key={space.roomId} mx={mx} room={space} index={index} />
))}
</Box>
)}
<Text
size="T300"
align="Center"
className={css.SplashStatus}
style={{ animationDelay: `${Math.min(spaces.length * 80, 640) + 120}ms` }}
>
{foundLine(spaces.length, directs)}
</Text>
</>
)}
</Box>
</SplashScreen>
);
}
+167 -20
View File
@@ -1,6 +1,12 @@
import { Box, Button, config, Dialog, IconButton, Menu, MenuItem, PopOut, RectCords, Spinner, Text } from 'folds';
import { Box, Button, config, Dialog, IconButton, Menu, MenuItem, PopOut, RectCords, Text } from 'folds';
import { Icon, Icons } from '../../components/icons';
import { HttpApiEvent, HttpApiEventHandlerMap, MatrixClient, SyncState } from 'matrix-js-sdk';
import {
ClientEvent,
HttpApiEvent,
HttpApiEventHandlerMap,
MatrixClient,
SyncState,
} from 'matrix-js-sdk';
import FocusTrap from 'focus-trap-react';
import React, { MouseEventHandler, ReactNode, useCallback, useEffect, useRef, useState } from 'react';
import {
@@ -11,6 +17,7 @@ import {
startClient,
} from '../../../client/initMatrix';
import { SplashScreen } from '../../components/splash-screen';
import { ClientLoading } from './ClientLoading';
import { ServerConfigsLoader } from '../../components/ServerConfigsLoader';
import { CapabilitiesProvider } from '../../hooks/useCapabilities';
import { MediaConfigProvider } from '../../hooks/useMediaConfig';
@@ -20,6 +27,10 @@ import { SpecVersions } from './SpecVersions';
import { AsyncStatus, useAsyncCallback } from '../../hooks/useAsyncCallback';
import { useSyncState } from '../../hooks/useSyncState';
import { stopPropagation } from '../../utils/keyboard';
import { useAtomValue } from 'jotai';
import { allRoomsAtom, useBindAllRoomsAtom } from '../../state/room-list/roomList';
import { mDirectAtom, useBindMDirectAtom } from '../../state/mDirectList';
import { roomToParentsAtom, useBindRoomToParentsAtom } from '../../state/room/roomToParents';
import { AuthMetadataProvider } from '../../hooks/useAuthMetadata';
import { getCurrentSession } from '../../state/sessions';
import { CallProviderWrapper } from '../../features/call/CallProviderWrapper';
@@ -29,17 +40,6 @@ import { AccountSwitcher } from '../../components/account-switcher';
import { getLoginPath, withSearchParam } from '../pathUtils';
import { useViewTransitions } from '../../hooks/useViewTransitions';
function ClientRootLoading() {
return (
<SplashScreen>
<Box direction="Column" grow="Yes" alignItems="Center" justifyContent="Center" gap="400">
<Spinner variant="Secondary" size="600" />
<Text>Heating up</Text>
</Box>
</SplashScreen>
);
}
const useLogoutListener = (mx?: MatrixClient) => {
useEffect(() => {
const handleLogout: HttpApiEventHandlerMap[HttpApiEvent.SessionLoggedOut] = async () => {
@@ -140,6 +140,21 @@ const useBackgroundSync = (mx?: MatrixClient) => {
}, [mx]);
};
/**
* Binds the atoms the chat UI reads while the splash is still up. Without this,
* they are only bound after the splash hides, so the first paint shows the empty
* state ("No Direct Messages") for a moment.
*
* Only the context-free bindings go here: the rest (unread, typing, auto-join)
* needs the RoomsNotificationPreferences provider, which lives inside children.
*/
function ClientAtomBinder({ mx }: { mx: MatrixClient }) {
useBindMDirectAtom(mx, mDirectAtom);
useBindAllRoomsAtom(mx, allRoomsAtom);
useBindRoomToParentsAtom(mx, roomToParentsAtom);
return null;
}
type ClientRootProps = {
children: ReactNode;
};
@@ -148,6 +163,49 @@ export function ClientRoot({ children }: ClientRootProps) {
const [loading, setLoading] = useState(true);
const mxRef = useRef<MatrixClient | undefined>(undefined);
const recoverInFlight = useRef(false);
// Hold the splash briefly after chats are loaded so the space particles
// finish animating before the UI swaps in.
const splashHoldTimer = useRef<number | undefined>(undefined);
// Grace window for the first network sync to land after the cache is ready;
// hide anyway if we are offline so the UI is never blocked.
const firstNetworkSyncGrace = useRef<number | undefined>(undefined);
// Hard deadline so a sync that never lands (offline, empty store, errored
// first sync) can not leave the splash up forever.
const splashDeadline = useRef<number | undefined>(undefined);
const scheduleHide = useCallback((reason?: string) => {
if (splashHoldTimer.current !== undefined) return;
if (reason) console.log(`[ClientRoot] Hiding splash: ${reason}`);
splashHoldTimer.current = window.setTimeout(() => {
splashHoldTimer.current = undefined;
setLoading(false);
}, 1500);
}, []);
// The UI renders chats from the room-list atoms, which are filled by
// ClientAtomBinder while the splash is still up. Gate the hide on those atoms
// so the first paint after the splash already contains the chats.
const roomsAtom = useAtomValue(allRoomsAtom);
const directsAtom = useAtomValue(mDirectAtom);
const chatsReady =
roomsAtom.length > 0 && directsAtom.size > 0 && roomsAtom.some((roomId) => directsAtom.has(roomId));
const tryHide = useCallback(
(reason: string): boolean => {
if (chatsReady) {
scheduleHide(reason);
return true;
}
return false;
},
[chatsReady, scheduleHide]
);
// The atoms fill in as the store restores the cache; hide as soon as they do.
useEffect(() => {
if (loading && chatsReady) scheduleHide('chats populated');
}, [loading, chatsReady, scheduleHide]);
const { baseUrl } = getCurrentSession() ?? {};
// Enable view transitions for smooth navigation
@@ -168,6 +226,20 @@ export function ClientRoot({ children }: ClientRootProps) {
mxRef.current = mx;
}, [mx]);
useEffect(() => {
return () => {
if (splashHoldTimer.current !== undefined) {
window.clearTimeout(splashHoldTimer.current);
}
if (firstNetworkSyncGrace.current !== undefined) {
window.clearTimeout(firstNetworkSyncGrace.current);
}
if (splashDeadline.current !== undefined) {
window.clearTimeout(splashDeadline.current);
}
};
}, []);
const [startState, startMatrix] = useAsyncCallback<void, Error, [MatrixClient]>(
useCallback((m) => startClient(m), [])
);
@@ -188,6 +260,45 @@ export function ClientRoot({ children }: ClientRootProps) {
}
}, [mx, startMatrix]);
// Cached rooms and m.direct land asynchronously from the IndexedDB store, so
// watch for them while loading and hide as soon as the chats are populated.
useEffect(() => {
if (!mx || !loading) return undefined;
const check = () => tryHide('chats populated');
check();
console.log(
'[ClientRoot] Splash gate:',
mx.getSyncState(),
`${roomsAtom.length} rooms in atom`,
`${directsAtom.size} m.direct`
);
// Prepared can fire before this listener attaches, so look at the current
// state too, and never let the splash outlive the deadline.
const syncState = mx.getSyncState();
if (syncState === SyncState.Prepared || syncState === SyncState.Syncing) check();
if (splashDeadline.current === undefined) {
splashDeadline.current = window.setTimeout(() => {
splashDeadline.current = undefined;
scheduleHide('deadline reached, showing whatever the cache has');
}, 10000);
}
const poll = window.setInterval(check, 400);
mx.on(ClientEvent.Room, check);
mx.on(ClientEvent.AccountData, check);
return () => {
window.clearInterval(poll);
mx.removeListener(ClientEvent.Room, check);
mx.removeListener(ClientEvent.AccountData, check);
};
}, [mx, loading, chatsReady, tryHide, scheduleHide, roomsAtom, directsAtom]);
// Timeout if sync takes too long - nudge the client rather than immediately erroring
useEffect(() => {
if (!mx || !loading) return;
@@ -200,19 +311,54 @@ export function ClientRoot({ children }: ClientRootProps) {
return () => clearTimeout(timeout);
}, [mx, loading]);
// Soft-recover from sync ERROR (e.g. sleep/wake with no network).
// Never block the UI — SyncStatus / title bar already show "Connection Lost".
// Hold the splash until the chats are actually populated, then keep it a
// moment longer so the space particles finish animating.
// Soft-recover from sync ERROR (e.g. sleep/wake with no network); the grace
// window ensures we never block the UI when offline.
useSyncState(
mx,
useCallback((state) => {
useCallback((state, prevState, data) => {
const client = mxRef.current;
if (state === SyncState.Prepared || state === SyncState.Syncing) {
setLoading(false);
if (state === SyncState.Prepared) {
console.log(
'[ClientRoot] Prepared from',
prevState ?? 'nothing',
data?.fromCache ? '(cache)' : '(network)'
);
}
if (tryHide(data?.fromCache ? 'cache populated' : 'first network sync')) {
return;
}
if (data?.fromCache) {
// Cache-only prepared: the room list is still being restored, so wait
// for it, but hide anyway once the grace expires so we never block the
// UI when offline.
if (firstNetworkSyncGrace.current === undefined) {
firstNetworkSyncGrace.current = window.setTimeout(() => {
firstNetworkSyncGrace.current = undefined;
scheduleHide('cache grace expired');
}, 5000);
}
} else {
// First network sync completed: whatever we have is what the UI shows.
scheduleHide('first network sync completed');
}
recoverInFlight.current = false;
return;
}
if (state !== SyncState.Error || !client || recoverInFlight.current) {
if (state !== SyncState.Error || !client) {
return;
}
// Sync failed (no network, first sync never landed). Show whatever the
// cache restored instead of leaving the splash up.
if (client.getRooms().length > 0) scheduleHide('sync error with cached chats');
if (recoverInFlight.current) {
return;
}
@@ -243,7 +389,7 @@ export function ClientRoot({ children }: ClientRootProps) {
// Give Wi‑Fi a moment to come back after lid open / resume
window.setTimeout(recover, 1500);
}, [])
}, [tryHide, scheduleHide])
);
// Also nudge sync when the laptop wakes / network returns
@@ -274,6 +420,7 @@ export function ClientRoot({ children }: ClientRootProps) {
return (
<SpecVersions baseUrl={baseUrl!}>
<TitleBar mx={mx} />
{mx && <ClientAtomBinder mx={mx} />}
{(loadState.status === AsyncStatus.Error || startState.status === AsyncStatus.Error) && (
<SplashScreen>
<Box direction="Column" grow="Yes" alignItems="Center" justifyContent="Center" gap="400">
@@ -296,7 +443,7 @@ export function ClientRoot({ children }: ClientRootProps) {
</SplashScreen>
)}
{loading || !mx ? (
<ClientRootLoading />
<ClientLoading mx={mx} />
) : (
<MatrixClientProvider value={mx}>
<PluginLoader matrixClient={mx}>
+162 -21
View File
@@ -17,7 +17,21 @@ import {
} from 'html-react-parser';
import { MatrixClient } from 'matrix-js-sdk';
import classNames from 'classnames';
import { Box, Chip, config, Header, IconButton, Scroll, Text, toRem } from 'folds';
import {
Box,
Button,
Chip,
config,
Header,
IconButton,
Menu,
MenuItem,
PopOut,
RectCords,
Scroll,
Text,
toRem,
} from 'folds';
import { Icon, Icons } from '../components/icons';
import { IntermediateRepresentation, Opts as LinkifyOpts, OptFn } from 'linkifyjs';
import Linkify from 'linkify-react';
@@ -40,13 +54,22 @@ import {
parseMatrixToUser,
testMatrixTo,
} from './matrix-to';
import { onEnterOrSpace } from '../utils/keyboard';
import { onEnterOrSpace, stopPropagation } from '../utils/keyboard';
import { copyToClipboard, tryDecodeURIComponent } from '../utils/dom';
import { useTimeoutToggle } from '../hooks/useTimeoutToggle';
import { settingsAtom } from '../state/settings';
import { useSetting } from '../state/hooks/settings';
import FocusTrap from 'focus-trap-react';
import {
AUTO_LANGUAGE,
LANGUAGE_OPTIONS,
PLAIN_LANGUAGE,
} from './react-prism/languages';
import { AuthenticatedImg } from '../components/authenticated-media';
import { openExternalUrl } from '../utils/tauri';
const ReactPrism = lazy(() => import('./react-prism/ReactPrism'));
const PrismCode = lazy(() => import('./react-prism/PrismCode'));
/**
* Click handler for external links - uses Tauri shell on desktop/mobile
@@ -242,13 +265,7 @@ const extractTextFromChildren = (nodes: ChildNode[]): string => {
return text;
};
export function CodeBlock({
children,
opts,
}: {
children: ChildNode[];
opts: HTMLReactParserOptions;
}) {
export function CodeBlock({ children }: { children: ChildNode[] }) {
const code = children[0];
const languageClass =
code instanceof Element && code.name === 'code' ? code.attribs.class : undefined;
@@ -257,20 +274,48 @@ export function CodeBlock({
? languageClass.replace('language-', '')
: languageClass;
const text = useMemo(() => extractTextFromChildren(children).replace(/\n$/, ''), [children]);
const LINE_LIMIT = 14;
const largeCodeBlock = useMemo(
() => extractTextFromChildren(children).split('\n').length > LINE_LIMIT,
[children]
);
const largeCodeBlock = useMemo(() => text.split('\n').length > LINE_LIMIT, [text]);
const [expanded, setExpand] = useState(false);
const [copied, setCopied] = useTimeoutToggle();
// Word wrap and line numbers are remembered as preferences, but can be toggled per code block
const [wrapSetting, setWrapSetting] = useSetting(settingsAtom, 'codeWordWrap');
const [lineNumbersSetting, setLineNumbersSetting] = useSetting(settingsAtom, 'codeLineNumbers');
const [wrap, setWrap] = useState(wrapSetting);
const [lineNumbers, setLineNumbers] = useState(lineNumbersSetting);
// Language override for this block (empty means use the language the message declared)
const [override, setOverride] = useState(AUTO_LANGUAGE);
const [menuCords, setMenuCords] = useState<RectCords>();
const activeLanguage =
override === AUTO_LANGUAGE ? language : override === PLAIN_LANGUAGE ? undefined : override;
const languageLabel =
override === AUTO_LANGUAGE
? language ?? 'Code'
: (LANGUAGE_OPTIONS.find((option) => option.value === override)?.label ?? override);
const handleCopy = () => {
copyToClipboard(extractTextFromChildren(children));
copyToClipboard(text);
setCopied();
};
const toggleWrap = () => {
const next = !wrap;
setWrap(next);
setWrapSetting(next);
};
const toggleLineNumbers = () => {
const next = !lineNumbers;
setLineNumbers(next);
setLineNumbersSetting(next);
};
const toggleExpand = () => {
setExpand(!expanded);
};
@@ -279,11 +324,51 @@ export function CodeBlock({
<Text size="T300" as="pre" className={css.CodeBlock}>
<Header variant="Surface" size="400" className={css.CodeBlockHeader}>
<Box grow="Yes">
<Text size="L400" truncate>
{language ?? 'Code'}
</Text>
<Button
variant="Surface"
fill="None"
size="300"
radii="300"
type="button"
aria-haspopup="true"
aria-expanded={!!menuCords}
title="Override language"
after={<Icon size="100" src={Icons.ChevronBottom} />}
onClick={(event) => {
event.stopPropagation();
setMenuCords(event.currentTarget.getBoundingClientRect());
}}
>
<Text size="B300" truncate>
{languageLabel}
</Text>
</Button>
</Box>
<Box shrink="No" gap="200">
<Chip
variant={wrap ? 'Primary' : 'Surface'}
fill="None"
radii="Pill"
outlined
aria-pressed={wrap}
title="Toggle word wrap"
onClick={toggleWrap}
before={<Icon size="50" src={Icons.WrapText} />}
>
<Text size="B300">Wrap</Text>
</Chip>
<Chip
variant={lineNumbers ? 'Primary' : 'Surface'}
fill="None"
radii="Pill"
outlined
aria-pressed={lineNumbers}
title="Toggle line numbers"
onClick={toggleLineNumbers}
before={<Icon size="50" src={Icons.OrderList} />}
>
<Text size="B300">Lines</Text>
</Chip>
<Chip
variant={copied ? 'Success' : 'Surface'}
fill="None"
@@ -315,19 +400,75 @@ export function CodeBlock({
)}
</Box>
</Header>
<PopOut
anchor={menuCords}
offset={5}
position="Bottom"
align="Start"
content={
<FocusTrap
focusTrapOptions={{
initialFocus: false,
onDeactivate: () => setMenuCords(undefined),
clickOutsideDeactivates: true,
isKeyForward: (evt: KeyboardEvent) =>
evt.key === 'ArrowDown' || evt.key === 'ArrowRight',
isKeyBackward: (evt: KeyboardEvent) =>
evt.key === 'ArrowUp' || evt.key === 'ArrowLeft',
escapeDeactivates: stopPropagation,
}}
>
<Scroll
style={{ maxHeight: toRem(320) }}
direction="Vertical"
variant="Surface"
size="300"
visibility="Hover"
hideTrack
>
<Menu>
{LANGUAGE_OPTIONS.map((option) => (
<MenuItem
key={option.value || 'auto'}
size="300"
variant={option.value === override ? 'SurfaceVariant' : 'Surface'}
aria-selected={option.value === override}
radii="300"
onClick={() => {
setMenuCords(undefined);
setOverride(option.value);
}}
>
<Box grow="Yes">
<Text size="T300">{option.label}</Text>
</Box>
</MenuItem>
))}
</Menu>
</Scroll>
</FocusTrap>
}
/>
<Scroll
style={{
maxHeight: largeCodeBlock && !expanded ? toRem(300) : undefined,
paddingBottom: largeCodeBlock ? config.space.S400 : undefined,
}}
direction="Both"
direction={wrap ? 'Vertical' : 'Both'}
variant="SurfaceVariant"
size="300"
visibility="Hover"
hideTrack
>
<div id="code-block-content" className={css.CodeBlockInternal}>
{domToReact(children, opts)}
<div
id="code-block-content"
className={wrap ? css.CodeBlockInternalWrapped : css.CodeBlockInternal}
>
<ErrorBoundary fallback={<code className={css.CodeBlockContent}>{text}</code>}>
<Suspense fallback={<code className={css.CodeBlockContent}>{text}</code>}>
<PrismCode text={text} language={activeLanguage} showLineNumbers={lineNumbers} />
</Suspense>
</ErrorBoundary>
</div>
</Scroll>
{largeCodeBlock && !expanded && <Box className={css.CodeBlockBottomShadow} />}
@@ -444,7 +585,7 @@ export const getReactCustomHtmlParser = (
}
if (name === 'pre') {
return <CodeBlock opts={opts}>{children}</CodeBlock>;
return <CodeBlock>{children}</CodeBlock>;
}
if (name === 'blockquote') {
+86
View File
@@ -0,0 +1,86 @@
import classNames from 'classnames';
import Prism from 'prismjs';
import * as css from '../../styles/CustomHtml.css';
// Side-effect import: registers every prism language grammar and the token colors
// used by the classes below (`token <type>` inside a `code` element).
import './ReactPrism';
export type PrismSegment = {
type?: string;
text: string;
};
export type PrismLine = PrismSegment[];
/**
* Tokenizes `text` with the prism grammar of `language` and splits the result into
* lines. Tokens spanning multiple lines (block comments, multiline strings) are split
* so every line keeps the token type of its segments, which keeps the colors correct
* when lines are rendered one row at a time.
*/
export function tokenizeToLines(text: string, language?: string): PrismLine[] {
const grammar = language ? Prism.languages[language] : undefined;
if (!grammar) return text.split('\n').map((line) => [{ text: line }]);
const lines: PrismLine[] = [[]];
const append = (type: string | undefined, value: string) => {
const parts = value.split('\n');
parts.forEach((part, index) => {
if (index > 0) lines.push([]);
if (part) lines[lines.length - 1].push({ type, text: part });
});
};
const walk = (stream: Prism.TokenStream, type?: string) => {
if (typeof stream === 'string') {
append(type, stream);
return;
}
if (Array.isArray(stream)) {
stream.forEach((child) => walk(child, type));
return;
}
walk(stream.content, stream.type);
};
Prism.tokenize(text, grammar).forEach((token) => walk(token));
return lines;
}
export default function PrismCode({
text,
language,
showLineNumbers,
}: {
text: string;
language?: string;
showLineNumbers: boolean;
}) {
const lines = tokenizeToLines(text, language);
return (
<code className={classNames(css.CodeBlockContent, language)}>
{lines.map((line, lineIndex) => (
<span key={`line-${lineIndex}`} className={css.CodeBlockLine}>
{showLineNumbers && <span className={css.CodeBlockLineNumber}>{lineIndex + 1}</span>}
<span className={css.CodeBlockLineContent}>
{line.map((segment, segmentIndex) =>
segment.type ? (
<span key={`token-${segmentIndex}`} className={`token ${segment.type}`}>
{segment.text}
</span>
) : (
segment.text
),
)}
</span>
</span>
))}
</code>
);
}
+43
View File
@@ -0,0 +1,43 @@
// Languages offered by the code block language override menu.
// Every entry is registered by the prism component imports in ReactPrism.tsx.
export type LanguageOption = {
value: string;
label: string;
};
// Empty value means "use the language the message declared"
export const AUTO_LANGUAGE = '';
export const PLAIN_LANGUAGE = 'plain';
export const LANGUAGE_OPTIONS: LanguageOption[] = [
{ value: AUTO_LANGUAGE, label: 'Auto' },
{ value: PLAIN_LANGUAGE, label: 'Plain text' },
{ value: 'bash', label: 'Bash' },
{ value: 'c', label: 'C' },
{ value: 'cpp', label: 'C++' },
{ value: 'csharp', label: 'C#' },
{ value: 'css', label: 'CSS' },
{ value: 'diff', label: 'Diff' },
{ value: 'docker', label: 'Docker' },
{ value: 'go', label: 'Go' },
{ value: 'graphql', label: 'GraphQL' },
{ value: 'html', label: 'HTML' },
{ value: 'ini', label: 'INI' },
{ value: 'java', label: 'Java' },
{ value: 'javascript', label: 'JavaScript' },
{ value: 'json', label: 'JSON' },
{ value: 'jsx', label: 'JSX' },
{ value: 'kotlin', label: 'Kotlin' },
{ value: 'lua', label: 'Lua' },
{ value: 'markdown', label: 'Markdown' },
{ value: 'properties', label: 'Properties' },
{ value: 'python', label: 'Python' },
{ value: 'rust', label: 'Rust' },
{ value: 'sass', label: 'Sass' },
{ value: 'sql', label: 'SQL' },
{ value: 'toml', label: 'TOML' },
{ value: 'tsx', label: 'TSX' },
{ value: 'typescript', label: 'TypeScript' },
{ value: 'xml', label: 'XML' },
{ value: 'yaml', label: 'YAML' },
];
+16
View File
@@ -0,0 +1,16 @@
import { getLocalStorageItem, setLocalStorageItem } from './utils/atomWithLocalStorage';
const LAST_ACTIVE_PATH_KEY = 'lastActivePath';
const getStoreKey = (userId: string): string => `${LAST_ACTIVE_PATH_KEY}${userId}`;
/**
* Last channel (room route) the user opened, remembered per account so the app
* reopens there on startup instead of the inbox.
*/
export const getLastActivePath = (userId: string): string | undefined =>
getLocalStorageItem<string | undefined>(getStoreKey(userId), undefined);
export const setLastActivePath = (userId: string, path: string): void => {
setLocalStorageItem(getStoreKey(userId), path);
};
+4
View File
@@ -51,6 +51,8 @@ export interface Settings {
showHiddenEvents: boolean;
legacyUsernameColor: boolean;
sidebarNameplateOpacity: number;
codeWordWrap: boolean;
codeLineNumbers: boolean;
showNotifications: boolean;
isNotificationSounds: boolean;
@@ -95,6 +97,8 @@ const defaultSettings: Settings = {
showHiddenEvents: false,
legacyUsernameColor: false,
sidebarNameplateOpacity: 60,
codeWordWrap: true,
codeLineNumbers: true,
showNotifications: true,
isNotificationSounds: true,
+38
View File
@@ -165,6 +165,44 @@ export const CodeBlockInternal = style([
},
]);
export const CodeBlockInternalWrapped = style([
CodeBlockInternal,
{
whiteSpace: 'pre-wrap',
overflowWrap: 'anywhere',
wordBreak: 'break-word',
},
]);
export const CodeBlockContent = style({
display: 'block',
});
export const CodeBlockLine = style({
display: 'flex',
alignItems: 'flex-start',
gap: config.space.S200,
// Keeps blank lines visible when line numbers are off (an empty row would
// otherwise collapse to zero height because the newlines are no longer rendered)
minHeight: '1lh',
});
export const CodeBlockLineNumber = style([
CodeFont,
{
flexShrink: 0,
minWidth: toRem(24),
textAlign: 'right',
opacity: 0.6,
userSelect: 'none',
},
]);
export const CodeBlockLineContent = style({
flex: '1',
minWidth: 0,
});
export const CodeBlockBottomShadow = style({
position: 'absolute',
bottom: 0,
+103 -16
View File
@@ -37,9 +37,87 @@ export type DownloadedCollectibleAsset = DiscordCollectibleAsset & {
};
const CDN_HOST_RE = /(^|\.)(discordapp\.com|discordapp\.net|discord\.com)$/i;
const PUBLISHED_CATALOG_URLS = [
'https://github.com/litruv/discord-collectibles/releases/download/latest/profileeffects.json',
'https://github.com/litruv/discord-collectibles/releases/download/latest/nameplate.json',
'https://github.com/litruv/discord-collectibles/releases/download/latest/avatardecorations.json',
];
const CATALOG_CACHE_KEY = 'paarrot.discordCollectiblesCatalog';
const CATALOG_CACHE_TTL_MS = 6 * 60 * 60 * 1000;
export function isElectronCollectiblesAvailable(): boolean {
return Boolean(window.electron?.discordCollectibles);
type PublishedCatalog = {
schema_version: number;
fetchedAt: string;
items: DiscordCollectibleItem[];
};
function isPublishedCatalog(value: unknown): value is { schema_version: number; items: DiscordCollectibleItem[] } {
if (!value || typeof value !== 'object') return false;
const catalog = value as Record<string, unknown>;
return (
catalog.schema_version === 1 &&
Array.isArray(catalog.items) &&
catalog.items.every(
(item) =>
item &&
typeof item === 'object' &&
typeof (item as DiscordCollectibleItem).id === 'string' &&
Array.isArray((item as DiscordCollectibleItem).assets)
)
);
}
function loadCachedCatalog(): PublishedCatalog | undefined {
try {
const raw = localStorage.getItem(CATALOG_CACHE_KEY);
if (!raw) return undefined;
const cached = JSON.parse(raw) as PublishedCatalog;
if (
!isPublishedCatalog(cached) ||
typeof cached.fetchedAt !== 'string' ||
Date.now() - Date.parse(cached.fetchedAt) >= CATALOG_CACHE_TTL_MS
) {
return undefined;
}
return cached;
} catch {
return undefined;
}
}
function saveCachedCatalog(catalog: PublishedCatalog): void {
try {
localStorage.setItem(CATALOG_CACHE_KEY, JSON.stringify(catalog));
} catch {
// A full or unavailable storage backend should not prevent catalog use.
}
}
export async function fetchPublishedCollectiblesCatalog(
force = false
): Promise<DiscordCollectibleItem[]> {
const cached = loadCachedCatalog();
if (!force && cached) return cached.items;
try {
const documents = await Promise.all(
PUBLISHED_CATALOG_URLS.map(async (url) => {
const response = await fetch(url);
if (!response.ok) throw new Error(`Catalog request failed with HTTP ${response.status}.`);
const catalog = await response.json();
if (!isPublishedCatalog(catalog)) throw new Error('Catalog has an unsupported schema.');
return catalog;
})
);
const items = documents.flatMap((catalog) => catalog.items);
if (items.length === 0) throw new Error('Catalog is empty.');
saveCachedCatalog({ schema_version: 1, fetchedAt: new Date().toISOString(), items });
return items;
} catch (error) {
if (cached) return cached.items;
throw error;
}
}
function isCdnUrl(value: unknown): value is string {
@@ -73,22 +151,31 @@ export async function downloadCollectibleAssets(
assets: DiscordCollectibleAsset[]
): Promise<DownloadedCollectibleAsset[]> {
const api = window.electron?.discordCollectibles;
if (!api) {
throw new Error('Discord collectibles are only available in the Paarrot desktop app.');
if (api) {
const result = await api.downloadAssets(assets);
if (!result?.success || !result.data) {
throw new Error(result?.error || 'Failed to download collectible assets from Discord CDN.');
}
return result.data.map((asset) => ({
role: asset.role,
url: asset.url,
filename: asset.filename,
mimeType: asset.mimeType,
data: asset.data instanceof Uint8Array ? asset.data : new Uint8Array(asset.data),
}));
}
const result = await api.downloadAssets(assets);
if (!result?.success || !result.data) {
throw new Error(result?.error || 'Failed to download collectible assets from Discord CDN.');
}
return result.data.map((asset) => ({
role: asset.role,
url: asset.url,
filename: asset.filename,
mimeType: asset.mimeType,
data: asset.data instanceof Uint8Array ? asset.data : new Uint8Array(asset.data),
}));
return Promise.all(
assets.map(async (asset) => {
if (!isCdnUrl(asset.url)) throw new Error('Collectible asset URL is not a Discord CDN URL.');
const response = await fetch(asset.url);
if (!response.ok) throw new Error(`Failed to download ${asset.filename}: HTTP ${response.status}.`);
return {
...asset,
data: new Uint8Array(await response.arrayBuffer()),
};
})
);
}
export async function uploadCollectibleToMatrix(
+73
View File
@@ -0,0 +1,73 @@
import { MatrixClient } from 'matrix-js-sdk';
import { mxcUrlToHttp } from './matrix';
import { getCurrentAccessToken } from './auth';
/**
* Blob URLs for profile assets (banner, nameplate, avatar decoration).
*
* Kept in one cache so reopening the same profile does not re-download the
* same media on every mount. Entries are revoked only when evicted.
*/
const MAX_ASSET_CACHE_ENTRIES = 200;
const assetCache = new Map<string, string>();
const inflightAssets = new Map<string, Promise<string | undefined>>();
function evictOldest(): void {
const firstKey = assetCache.keys().next().value;
if (firstKey === undefined) return;
const url = assetCache.get(firstKey);
assetCache.delete(firstKey);
if (url) URL.revokeObjectURL(url);
}
export async function getProfileAssetUrl(
mx: MatrixClient,
mxcUrl: string,
useAuthentication: boolean
): Promise<string | undefined> {
if (!mxcUrl) return undefined;
const cached = assetCache.get(mxcUrl);
if (cached) return cached;
const pending = inflightAssets.get(mxcUrl);
if (pending) return pending;
const request = (async () => {
const httpUrl = mxcUrlToHttp(mx, mxcUrl, useAuthentication);
if (!httpUrl) return undefined;
const headers: HeadersInit = {};
if (useAuthentication) {
const accessToken = getCurrentAccessToken();
if (accessToken) headers.Authorization = `Bearer ${accessToken}`;
}
try {
const response = await fetch(httpUrl, { headers });
if (!response.ok) return undefined;
const blob = await response.blob();
const blobUrl = URL.createObjectURL(blob);
if (assetCache.size >= MAX_ASSET_CACHE_ENTRIES) evictOldest();
assetCache.set(mxcUrl, blobUrl);
return blobUrl;
} catch {
return undefined;
}
})();
inflightAssets.set(mxcUrl, request);
try {
return await request;
} finally {
if (inflightAssets.get(mxcUrl) === request) inflightAssets.delete(mxcUrl);
}
}
export function clearProfileAssetCache(): void {
assetCache.forEach((url) => URL.revokeObjectURL(url));
assetCache.clear();
inflightAssets.clear();
}
+91
View File
@@ -0,0 +1,91 @@
import { MatrixClient } from 'matrix-js-sdk';
/**
* Single shared cache for a user's profile fields.
*
* Colour, banner and collectibles all come from the same profile endpoint, so they
* must read through one cache instead of each keeping their own - otherwise opening
* a profile view fires the same request three times.
*/
export type ProfileFields = Record<string, unknown>;
export const PROFILE_CACHE_TTL_MS = 5 * 60 * 1000;
const MAX_PROFILE_CACHE_ENTRIES = 500;
type ProfileCacheEntry = { fields: ProfileFields; timestamp: number };
const profileCache = new Map<string, ProfileCacheEntry>();
const inflightRequests = new Map<string, Promise<ProfileFields>>();
const cacheListeners = new Set<(userId: string) => void>();
export function registerProfileCacheListener(fn: (userId: string) => void): () => void {
cacheListeners.add(fn);
return () => cacheListeners.delete(fn);
}
export function clearProfileCache(userId?: string): void {
if (!userId) return;
profileCache.delete(userId);
inflightRequests.delete(userId);
cacheListeners.forEach((listener) => listener(userId));
}
function setProfileCache(userId: string, fields: ProfileFields): void {
if (profileCache.size >= MAX_PROFILE_CACHE_ENTRIES) {
const firstKey = profileCache.keys().next().value;
if (firstKey !== undefined) profileCache.delete(firstKey);
}
profileCache.set(userId, { fields, timestamp: Date.now() });
}
/** Cached profile fields, or undefined when the entry is missing or expired. */
export function getCachedProfileFields(userId: string): ProfileFields | undefined {
if (!userId) return undefined;
const entry = profileCache.get(userId);
if (!entry || Date.now() - entry.timestamp >= PROFILE_CACHE_TTL_MS) return undefined;
return entry.fields;
}
/**
* Profile fields for a user, served from the shared cache when possible.
* Concurrent callers for the same user share one request.
*/
export async function getProfileFields(mx: MatrixClient, userId: string): Promise<ProfileFields> {
if (!userId) return {};
const cached = getCachedProfileFields(userId);
if (cached) return cached;
const pending = inflightRequests.get(userId);
if (pending) return pending;
const request = (async () => {
let fields: ProfileFields = {};
try {
if (await mx.doesServerSupportExtendedProfiles()) {
fields = await mx.getExtendedProfile(userId);
}
} catch {
// Server may not support MSC4133, or the user has no extended fields.
}
if (Object.keys(fields).length === 0) {
try {
fields = (await mx.getProfileInfo(userId)) as ProfileFields;
} catch {
fields = {};
}
}
setProfileCache(userId, fields);
return fields;
})();
inflightRequests.set(userId, request);
try {
return await request;
} finally {
if (inflightRequests.get(userId) === request) inflightRequests.delete(userId);
}
}
+8 -73
View File
@@ -1,5 +1,6 @@
import { MatrixClient, Room } from 'matrix-js-sdk';
import { ThemeKind } from '../hooks/useTheme';
import { clearProfileCache, getProfileFields } from './profileCache';
/** MSC4522 stable profile field for username colors */
export const PROFILE_KEY_COLOR_PREFERENCE_STABLE = 'm.color_preference';
@@ -120,26 +121,8 @@ export function extractCollectiblesFromProfile(profile: Record<string, unknown>)
};
}
async function loadCollectiblesFromProfile(mx: MatrixClient, userId: string): Promise<CollectibleProfileFields> {
if (await mx.doesServerSupportExtendedProfiles()) {
try {
const profile = await mx.getExtendedProfile(userId);
return extractCollectiblesFromProfile(profile);
} catch {
// fall through
}
}
try {
const profile = (await mx.getProfileInfo(userId)) as Record<string, unknown>;
return extractCollectiblesFromProfile(profile);
} catch {
return {};
}
}
export async function loadUserCollectibles(mx: MatrixClient, userId: string): Promise<CollectibleProfileFields> {
return loadCollectiblesFromProfile(mx, userId);
return extractCollectiblesFromProfile(await getProfileFields(mx, userId));
}
export async function saveCollectible(
@@ -179,21 +162,7 @@ export async function getBannerUrlProfileKey(mx: MatrixClient): Promise<string>
}
export async function loadBannerUrl(mx: MatrixClient, userId: string): Promise<string | undefined> {
if (await mx.doesServerSupportExtendedProfiles()) {
try {
const profile = await mx.getExtendedProfile(userId);
return extractBannerUrlFromProfile(profile);
} catch {
// fall through
}
}
try {
const profile = (await mx.getProfileInfo(userId)) as Record<string, unknown>;
return extractBannerUrlFromProfile(profile);
} catch {
return undefined;
}
return extractBannerUrlFromProfile(await getProfileFields(mx, userId));
}
export async function saveBannerUrl(mx: MatrixClient, bannerMxc: string): Promise<void> {
@@ -204,7 +173,7 @@ export async function saveBannerUrl(mx: MatrixClient, bannerMxc: string): Promis
const key = await getBannerUrlProfileKey(mx);
await mx.setExtendedProfileProperty(key, bannerMxc);
const userId = mx.getUserId();
if (userId) clearBannerCache(userId);
if (userId) clearProfileCache(userId);
}
export async function deleteBannerUrl(mx: MatrixClient): Promise<void> {
@@ -215,17 +184,7 @@ export async function deleteBannerUrl(mx: MatrixClient): Promise<void> {
const key = await getBannerUrlProfileKey(mx);
await mx.deleteExtendedProfileProperty(key);
const userId = mx.getUserId();
if (userId) clearBannerCache(userId);
}
let bannerCacheClearImpl: (userId: string) => void = () => {};
export function registerBannerCacheClear(fn: (userId: string) => void): void {
bannerCacheClearImpl = fn;
}
function clearBannerCache(userId: string): void {
bannerCacheClearImpl(userId);
if (userId) clearProfileCache(userId);
}
export async function getColorPreferenceProfileKey(mx: MatrixClient): Promise<string> {
@@ -239,21 +198,7 @@ export async function loadColorPreference(
mx: MatrixClient,
userId: string
): Promise<ColorPreference | undefined> {
if (await mx.doesServerSupportExtendedProfiles()) {
try {
const profile = await mx.getExtendedProfile(userId);
return extractColorPreferenceFromProfile(profile);
} catch {
// fall through to standard profile endpoint
}
}
try {
const profile = (await mx.getProfileInfo(userId)) as Record<string, unknown>;
return extractColorPreferenceFromProfile(profile);
} catch {
return undefined;
}
return extractColorPreferenceFromProfile(await getProfileFields(mx, userId));
}
export function extractMemberColorPreference(room: Room | undefined, userId: string): ColorPreference | undefined {
@@ -272,17 +217,7 @@ export async function saveColorPreference(mx: MatrixClient, preference: ColorPre
const key = await getColorPreferenceProfileKey(mx);
await mx.setExtendedProfileProperty(key, preference);
const userId = mx.getUserId();
if (userId) clearPreferenceCache(userId);
}
let preferenceCacheClearImpl: (userId: string) => void = () => {};
export function registerPreferenceCacheClear(fn: (userId: string) => void): void {
preferenceCacheClearImpl = fn;
}
function clearPreferenceCache(userId: string): void {
preferenceCacheClearImpl(userId);
if (userId) clearProfileCache(userId);
}
export async function deleteColorPreference(mx: MatrixClient): Promise<void> {
@@ -293,5 +228,5 @@ export async function deleteColorPreference(mx: MatrixClient): Promise<void> {
const key = await getColorPreferenceProfileKey(mx);
await mx.deleteExtendedProfileProperty(key);
const userId = mx.getUserId();
if (userId) clearPreferenceCache(userId);
if (userId) clearProfileCache(userId);
}
+1 -22
View File
@@ -239,28 +239,7 @@ export const initClient = async (session: Session): Promise<MatrixClient> => {
await mx.initRustCrypto({
storagePrefix: `${session.userId}@${session.deviceId}`,
});
// List databases after init to verify isolation
try {
const dbsAfterInit = await getAllIndexedDBNames();
console.log('[initMatrix] 📦 Databases after initialization:', dbsAfterInit);
// Check if a shared crypto database was created despite storagePrefix
const hasSharedCrypto = dbsAfterInit.includes('matrix-js-sdk::matrix-sdk-crypto');
if (hasSharedCrypto) {
console.warn('[initMatrix] ⚠️ WARNING: Shared crypto database still exists after init!');
console.warn('[initMatrix] The storagePrefix option may not be working correctly.');
}
// List account-specific databases
const accountDbs = dbsAfterInit.filter(db =>
db.includes(session.userId) || db.includes(session.deviceId)
);
console.log('[initMatrix] 📁 Account-specific databases:', accountDbs);
} catch (e) {
console.log('[initMatrix] Could not list databases after init:', e);
}
console.log('[initMatrix] ✅ Client initialized successfully!');
mx.setMaxListeners(50);
-3
View File
@@ -114,9 +114,6 @@ interface ElectronAPI {
}) => void) => void;
};
discordCollectibles?: {
hasToken: () => Promise<{ success: boolean; data?: boolean; error?: string }>;
setToken: (token: string) => Promise<{ success: boolean; error?: string }>;
clearToken: () => Promise<{ success: boolean; error?: string }>;
fetchCatalog: (force?: boolean) => Promise<{
success: boolean;
data?: { items: unknown[]; fetchedAt: string };
+3 -1
View File
@@ -361,7 +361,9 @@ export default defineConfig(() => ({
build: {
target: 'es2022',
outDir: 'dist',
sourcemap: true,
// Maps are excluded from packaged builds anyway (electron-builder `!**/*.map`),
// so skip generating them in CI to save build time.
sourcemap: !process.env.CI,
copyPublicDir: false,
rollupOptions: {
input: {