8 Commits
Author SHA1 Message Date
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
24 changed files with 565 additions and 370 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.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.185
title: Discord collectibles
date: 2026-08-24
summary: Add Discord-style profile effects, nameplates, and avatar decorations to Paarrot profiles.
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.
---
## Discord collectibles
## Profile caching
- 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.
- 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.
+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",
@@ -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',
},
]);
+52 -21
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,39 @@ 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();
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 +104,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 +112,7 @@ export const TikTokEmbed = as<'div', TikTokEmbedProps>(({ url, ...props }, ref)
fetchTikTokOEmbed(url).then((info) => {
if (cancelled) return;
if (info) {
setState({
status: 'loaded',
@@ -105,6 +121,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 +151,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 +186,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 +220,27 @@ 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}
{state.thumbnailUrl ? (
<img
src={state.thumbnailUrl}
alt={state.title}
className={css.TikTokThumbnail}
crossOrigin="anonymous"
/>
)}
) : 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 +257,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>
);
});
@@ -14,8 +14,8 @@ import {
DiscordCollectibleItem,
collectibleKindLabel,
defaultPreviewAspectRatio,
fetchPublishedCollectiblesCatalog,
groupCollectibleItems,
isElectronCollectiblesAvailable,
uploadCollectibleToMatrix,
variantItemLabel,
} from '../../../utils/discordCollectibles';
@@ -347,24 +347,26 @@ export function CollectiblesSection({ collectibles, onApply }: CollectiblesSecti
const [error, setError] = useState<string>();
const [selectedByGroup, setSelectedByGroup] = useState<Record<string, string>>({});
const desktopAvailable = isElectronCollectiblesAvailable();
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(() => {
loadCatalog();
@@ -431,17 +433,6 @@ 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 }}>
+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}>
+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);
};
+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 -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: {