37 Commits
Author SHA1 Message Date
litruv 3cd159a63e Drop the redundant try around the render check fetch.
Checks / checks (push) Successful in 1m58s
Trigger cinny-mobile / dispatch (push) Successful in 1s
2026-11-01 04:01:33 +11:00
litruv 0688075542 Point the commit link at the public web base.
Checks / checks (push) Successful in 1m56s
Trigger cinny-mobile / dispatch (push) Successful in 2s
2026-11-01 03:58:19 +11:00
litruv 7edf179ec9 Drop the explicit undefined initialisation of encInfo.
Checks / checks (push) Successful in 1m56s
Trigger cinny-mobile / dispatch (push) Successful in 1s
2026-11-01 03:45:49 +11:00
litruv c0aa7fa8f5 Comment the fixing commit when a check issue closes.
Checks / checks (push) Successful in 1m56s
Trigger cinny-mobile / dispatch (push) Successful in 1s
2026-11-01 03:43:06 +11:00
litruv a77f72f5d6 Strip the ANSI codes from check output before matching findings.
Checks / checks (push) Successful in 1m56s
Trigger cinny-mobile / dispatch (push) Successful in 1s
2026-11-01 03:37:32 +11:00
litruv 7689433376 Page the open issue list so dedupe sees every check issue.
Checks / checks (push) Successful in 1m58s
Trigger cinny-mobile / dispatch (push) Successful in 1s
2026-11-01 03:32:37 +11:00
litruv 6e6d4322c5 Port the ESLint config to flat format and file check findings as Gitea issues.
Checks / checks (push) Successful in 2m38s
Trigger cinny-mobile / dispatch (push) Successful in 2s
2026-11-01 03:20:19 +11:00
litruv bb27305b70 Add a developer tools view for public profile fields.
Trigger cinny-mobile / dispatch (push) Successful in 1s
2026-11-01 02:03:29 +11:00
litruv fcbd9b4b66 Remove the unused joinNames helper from the typing indicator. 2026-11-01 02:03:23 +11:00
litruv 14f31f57c1 Add a per-user custom typing verb to the typing indicator.
The verb is a profile field (im.paarrot.typing_verb) read through the shared profile cache. The sentence builder replaces the four hardcoded branches, and the profile settings page has presets, a text input, and a live preview.
2026-11-01 01:24:59 +11:00
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
litruv d59945eb4c Add configurable sidebar nameplate background.
Trigger cinny-mobile / dispatch (push) Successful in 2s
Render the equipped nameplate behind the larger settings avatar with blur-aware sidebar controls, adjustable opacity, and immediate collectible cache invalidation.
2026-08-24 18:48:48 +10:00
litruv 0cbc5d9a1c Add Discord collectibles to profiles, messages, and settings.
Trigger cinny-mobile / dispatch (push) Successful in 1s
Integrate profile effects, nameplates, and avatar decorations with live catalog browsing, Matrix profile storage, and rendering across user heroes, DMs, messages, and the sidebar avatar.
2026-08-24 00:54:48 +10:00
litruv 6cb1e14632 Fix What's New dialog layout and improve dev styling/debugging.
Trigger cinny-mobile / dispatch (push) Successful in 1s
Portal the updates dialog to document.body with stable data attributes,
fix max-width (invalid S800 token), bundle update images for Capacitor,
and add readable vanilla-extract class names plus portalContainer tap fixes.
2026-08-23 16:54:59 +10:00
litruv 7d866404b3 Fix Android updates dialog, mobile About page, and user color crash guard.
Trigger cinny-mobile / dispatch (push) Successful in 2s
Use stripBase for update static copy paths, show Settings detail on mobile
when nav is hidden, pause Settings focus trap during release notes, and guard
extractMemberColorPreference when room is not a Matrix Room instance.
2026-08-23 16:18:35 +10:00
litruv c264de53b5 Fix View updates on Android: bundled notes, portal stack, tap handling.
Trigger cinny-mobile / dispatch (push) Successful in 2s
Bundle update markdown at build time for Capacitor, portal into
portalContainer above Settings, defer open to avoid FocusTrap closing
on the same tap, and disable click-outside dismiss.
2026-08-23 08:38:23 +10:00
litruv b6f3f5c0aa Move update manifest generator into cinny for standalone Android builds.
Trigger cinny-mobile / dispatch (push) Successful in 2s
2026-08-23 08:26:27 +10:00
litruv 25be638c5e Fix auto-show of What's New on first launch after an app update.
Trigger cinny-mobile / dispatch (push) Successful in 1s
2026-08-23 08:23:15 +10:00
litruv a20c871726 Fix updates dialog on Android by portaling above Settings and resolving Capacitor asset URLs.
Trigger cinny-mobile / dispatch (push) Successful in 2s
2026-08-23 08:19:51 +10:00
litruv e65a516350 Add MSC4522 username colors, release notes dialog, and profile layout fixes.
Trigger cinny-mobile / dispatch (push) Successful in 1s
Replace legacy profile style metadata with MSC4133 profile fields, add in-app update notes, tighten account profile name spacing, and wire desktop media save helpers through the client.
2026-08-23 08:06:48 +10:00
litruv 9887903f49 Add centralized saveMedia helpers for image, video, and file downloads.
Trigger cinny-mobile / dispatch (push) Successful in 2s
Platforms can register a custom saver; viewers share one download/save path instead of FileSaver call sites.
2026-08-09 20:49:00 +10:00
106 changed files with 13623 additions and 1791 deletions
-72
View File
@@ -1,72 +0,0 @@
module.exports = {
env: {
browser: true,
es2021: true,
},
extends: [
"eslint:recommended",
"plugin:react/recommended",
"plugin:react-hooks/recommended",
"plugin:@typescript-eslint/eslint-recommended",
"plugin:@typescript-eslint/recommended",
'airbnb',
'prettier',
],
parser: "@typescript-eslint/parser",
parserOptions: {
ecmaFeatures: {
jsx: true,
},
ecmaVersion: 'latest',
sourceType: 'module',
},
"globals": {
JSX: "readonly"
},
plugins: [
'react',
'@typescript-eslint'
],
rules: {
'linebreak-style': 0,
'no-underscore-dangle': 0,
"no-shadow": "off",
"import/prefer-default-export": "off",
"import/extensions": "off",
"import/no-unresolved": "off",
"import/no-extraneous-dependencies": [
"error",
{
devDependencies: true,
},
],
'react/no-unstable-nested-components': [
'error',
{ allowAsProps: true },
],
"react/jsx-filename-extension": [
"error",
{
extensions: [".tsx", ".jsx"],
},
],
"react/require-default-props": "off",
"react/jsx-props-no-spreading": "off",
"react-hooks/rules-of-hooks": "error",
"react-hooks/exhaustive-deps": "error",
"@typescript-eslint/no-unused-vars": "error",
"@typescript-eslint/no-shadow": "error"
},
overrides: [
{
files: ['*.ts'],
rules: {
'no-undef': 'off',
},
},
],
};
+45
View File
@@ -0,0 +1,45 @@
name: Checks
on:
push:
branches:
- main
jobs:
checks:
runs-on: ubuntu-latest
steps:
- name: Checkout repository
uses: actions/checkout@v4
with:
fetch-depth: 1
- name: Setup Node.js
uses: actions/setup-node@v4
with:
node-version: '22'
cache: 'npm'
- name: Install dependencies
run: npm ci --prefer-offline
# ci-checks.sh always exits 0: findings become issues, not failed builds.
- name: Run checks
env:
API_BASE: ${{ github.server_url }}/api/v1
# github.server_url is the internal runner host, so the commit link needs the public one.
WEB_BASE: https://git.ruv.wtf
REPO: ${{ github.repository }}
SHA: ${{ github.sha }}
# Prefer a PAT with issue write scope (secret: GITEA_TOKEN).
# Default GITHUB_TOKEN is usually scoped to this repo only.
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
TOKEN="${GITEA_TOKEN:-${GITHUB_TOKEN:-}}"
if [ -z "$TOKEN" ]; then
echo "No GITEA_TOKEN/GITHUB_TOKEN available to file issues"
exit 0
fi
export TOKEN
bash scripts/ci-checks.sh
+3
View File
@@ -7,6 +7,9 @@
"LocalNotifications": {
"smallIcon": "ic_stat_paarrot",
"iconColor": "#FF8A00"
},
"CapacitorHttp": {
"enabled": true
}
}
}
+90
View File
@@ -0,0 +1,90 @@
import { createRequire } from 'node:module';
import { fixupConfigRules } from '@eslint/compat';
import globals from 'globals';
import js from '@eslint/js';
import airbnb from 'eslint-config-airbnb';
import prettier from 'eslint-config-prettier';
import tsParser from '@typescript-eslint/parser';
import tsPlugin from '@typescript-eslint/eslint-plugin';
import importPlugin from 'eslint-plugin-import';
import jsxAllyPlugin from 'eslint-plugin-jsx-a11y';
import reactPlugin from 'eslint-plugin-react';
import reactHooksPlugin from 'eslint-plugin-react-hooks';
const require = createRequire(import.meta.url);
// Config entries without `files` only match .js/.mjs, so every entry needs the same file set.
const files = ['**/*.js', '**/*.mjs', '**/*.cjs', '**/*.ts', '**/*.tsx'];
// eslint-config-airbnb 19 is legacy-only: `extends` are paths to rule modules and flat config
// rejects `extends`/`env`/`parserOptions`, so take their rules and set the env here instead.
const airbnbRules = (config) => (config.extends || []).flatMap((p) => airbnbRules(require(p))).concat(config);
// Plugins are registered once (redefining a plugin is an error) and fixed up so the legacy
// rules that call context.getFilename still work.
export default [
...fixupConfigRules([
{
files,
plugins: {
react: reactPlugin,
'react-hooks': reactHooksPlugin,
'@typescript-eslint': tsPlugin,
import: importPlugin,
'jsx-a11y': jsxAllyPlugin,
},
languageOptions: {
parser: tsParser,
ecmaVersion: 'latest',
sourceType: 'module',
globals: { ...globals.browser, ...globals.es2021, JSX: 'readonly' },
},
},
]),
...[
js.configs.recommended,
reactPlugin.configs.flat.recommended,
reactHooksPlugin.configs.flat.recommended,
tsPlugin.configs['flat/eslint-recommended'],
tsPlugin.configs['flat/recommended'],
...airbnbRules(airbnb),
prettier,
{
rules: {
'linebreak-style': 0,
'no-underscore-dangle': 0,
"no-shadow": "off",
"import/prefer-default-export": "off",
"import/extensions": "off",
"import/no-unresolved": "off",
"import/no-extraneous-dependencies": [
"error",
{
devDependencies: true,
},
],
'react/no-unstable-nested-components': [
'error',
{ allowAsProps: true },
],
"react/jsx-filename-extension": [
"error",
{
extensions: [".tsx", ".jsx"],
},
],
"react/require-default-props": "off",
"react/jsx-props-no-spreading": "off",
"react-hooks/rules-of-hooks": "error",
"react-hooks/exhaustive-deps": "error",
"@typescript-eslint/no-unused-vars": "error",
"@typescript-eslint/no-shadow": "error"
},
},
].flatMap((config) => (Array.isArray(config) ? config : [config]).map((config) => ({ files, rules: config.rules || {}, ...(config.settings ? { settings: config.settings } : {}) }))),
{ files: ['*.ts'], rules: { 'no-undef': 'off' } },
];
+1521 -1
View File
File diff suppressed because it is too large Load Diff
+6 -1
View File
@@ -9,7 +9,7 @@
},
"scripts": {
"start": "vite",
"build": "vite build",
"build": "node scripts/generate-update-manifest.mjs && vite build",
"lint": "yarn check:eslint && yarn check:prettier",
"check:eslint": "eslint src/*",
"check:prettier": "prettier --check .",
@@ -84,8 +84,10 @@
"react-error-boundary": "6.1.2",
"react-google-recaptcha": "3.1.0",
"react-i18next": "17.0.8",
"react-markdown": "10.1.0",
"react-range": "1.10.0",
"react-router-dom": "7.18.1",
"remark-gfm": "4.0.1",
"sanitize-html": "2.17.5",
"slate": "0.124.1",
"slate-dom": "0.124.1",
@@ -95,6 +97,8 @@
},
"devDependencies": {
"@esbuild-plugins/node-globals-polyfill": "0.2.3",
"@eslint/compat": "2.1.1",
"@eslint/js": "10.0.1",
"@monaco-editor/react": "4.7.0",
"@rollup/plugin-inject": "5.0.5",
"@rollup/plugin-wasm": "6.2.2",
@@ -119,6 +123,7 @@
"eslint-plugin-jsx-a11y": "6.10.2",
"eslint-plugin-react": "7.37.5",
"eslint-plugin-react-hooks": "7.1.1",
"globals": "17.13.0",
"monaco-editor": "0.52.2",
"prettier": "3.9.4",
"typescript": "6.0.3",
+16
View File
@@ -0,0 +1,16 @@
---
version: 4.11.175
title: Stability & polish
date: 2026-08-10
summary: Desktop update flow improvements and UI refinements.
---
## Desktop updates
- Smoother download and install flow in the title bar updater.
- Better handling when an update is already downloading.
## UI polish
- Refined spacing and contrast in settings panels.
- Improved mobile layout for room headers and notifications.
+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.
+14
View File
@@ -0,0 +1,14 @@
---
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 caching
- 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

File diff suppressed because one or more lines are too long

After

Width:  |  Height:  |  Size: 889 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 58 KiB

+23
View File
@@ -0,0 +1,23 @@
{
"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",
"title": "Stability & polish",
"date": "2026-08-10"
}
]
}
+90
View File
@@ -0,0 +1,90 @@
#!/usr/bin/env bash
# Files one open Gitea issue per rule key, deduped by the marker line in the issue body.
# Never exits non-zero: findings are reported, not enforced.
set -u
API_BASE="${API_BASE:?API_BASE is required}"
REPO="${REPO:?REPO is required}"
TOKEN="${TOKEN:?TOKEN is required}"
SHA="${SHA:-}"
BASE="${WEB_BASE:-${API_BASE%/api/v1}}"
LABEL="ci-checks"
SHOW="${SHOW:-50}"
cd "$(dirname "$0")/.."
WORK=$(mktemp -d)
trap 'rm -rf "$WORK"' EXIT
FINDINGS="$WORK/findings.tsv"
: > "$FINDINGS"
# key<TAB>violation, one line per finding.
npx eslint src --format json > "$WORK/eslint.json" || true
jq -r --arg root "$PWD" '.[] | .filePath as $f | .messages[] | select(.ruleId) | "eslint/" + .ruleId + "\t" + (($f | ltrimstr($root + "/")) + ":" + (.line | tostring))' "$WORK/eslint.json" >> "$FINDINGS"
npx prettier --check . > "$WORK/prettier.log" 2>&1 || true
# Prettier forces colour in CI, so strip the ANSI codes before matching.
sed -E 's/\x1b\[[0-9;]*m//g' "$WORK/prettier.log" | sed -nE 's/^\[warn\] (.*)$/prettier\t\1/p' >> "$FINDINGS"
npx tsc --noEmit > "$WORK/tsc.log" 2>&1 || true
sed -E 's/\x1b\[[0-9;]*m//g' "$WORK/tsc.log" | sed -nE 's/^(.*)\(([0-9]+),([0-9]+)\): error (TS[0-9]+):.*/tsc\/\4\t\1(\2,\3)/p' >> "$FINDINGS"
api() { # api METHOD PATH [JSON] -> response body on stdout, non-zero on HTTP failure
local method=$1 path=$2 data=${3-} code
code=$(curl -sS -o "$WORK/resp" -w '%{http_code}' -X "$method" \
-H "Authorization: token $TOKEN" -H 'Content-Type: application/json' \
${data:+-d "$data"} "$API_BASE/repos/$REPO$path") || return 1
case "$code" in
200 | 201) cat "$WORK/resp" ;;
*) echo "HTTP $code $method $path: $(cat "$WORK/resp")" >&2; return 1 ;;
esac
}
body() { # body KEY HASH VIOLATIONS_FILE
printf '<!-- ci-check: %s -->\n<!-- ci-check-hash: %s -->\n\n`%s`: %d violations.\n\n```text\n' \
"$1" "$2" "$1" "$(wc -l < "$3")"
head -n "$SHOW" "$3"
printf '```\n'
}
LABEL_ID=$(api GET "/labels?limit=100" | jq -r --arg n "$LABEL" '[.[] | select(.name == $n) | .id] | first // empty')
if [ -z "$LABEL_ID" ]; then
LABEL_ID=$(api POST "/labels" "$(jq -n --arg n "$LABEL" '{name: $n, color: "006060"}')" | jq -r '.id')
fi
# Gitea caps per_page at 50, so paging is required or dedupe misses issues past the first page.
# Accumulate as JSONL: passing the accumulated set as a jq program argument overflows argv.
OPEN="$WORK/open.jsonl"
: > "$OPEN"
for page in 1 2 3 4 5 6 7 8; do
api GET "/issues?state=open&limit=50&page=$page" | jq -c --arg l "$LABEL" '[.[] | select((.labels // []) | any(.name == $l))]' > "$WORK/page.json"
n=$(jq -r 'length' "$WORK/page.json")
[ -z "$n" ] && break
jq -c '.[]' "$WORK/page.json" >> "$OPEN"
[ "$n" -lt 50 ] && break
done
for key in $(cut -f1 "$FINDINGS" | sort -u); do
vf="$WORK/violations.tsv"
awk -F'\t' -v k="$key" '$1 == k' "$FINDINGS" | sort > "$vf"
hash=$(sha256sum < "$vf" | cut -d' ' -f1)
row=$(jq -c --arg k "$key" 'select((.body // "") | contains("<!-- ci-check: " + $k + " -->"))' "$OPEN" | head -1)
if [ -z "$row" ]; then
api POST "/issues" "$(jq -n --arg t "ci-check: $key" --arg b "$(body "$key" "$hash" "$vf")" --argjson l "$LABEL_ID" '{title: $t, body: $b, labels: [$l]}')" > /dev/null
elif ! echo "$row" | jq -e --arg h "$hash" '(.body // "") | contains("<!-- ci-check-hash: " + $h + " -->")' > /dev/null; then
api PATCH "/issues/$(jq -r '.number' <<< "$row")" "$(jq -n --arg b "$(body "$key" "$hash" "$vf")" '{body: $b}')" > /dev/null
fi
done
jq -r '[((.body // "") | capture("<!-- ci-check: (?<k>[^ ]+) -->").k), .number] | @tsv' "$OPEN" > "$WORK/keys.tsv"
while IFS=$'\t' read -r key number; do
if ! grep -qF -- "$key"$'\t' "$FINDINGS"; then
if [ -n "$SHA" ]; then
api POST "/issues/$number/comments" "$(jq -n --arg b "Fixed in [$(printf '%s' "$SHA" | cut -c1-7)]($BASE/commit/$SHA)." '{body: $b}')" > /dev/null
fi
api PATCH "/issues/$number" '{"state": "closed"}' > /dev/null
fi
done < "$WORK/keys.tsv"
exit 0
+114
View File
@@ -0,0 +1,114 @@
#!/usr/bin/env node
/**
* Regenerates public/update/manifest.json from markdown files.
*
* - currentupdate.md is always the "current" entry
* - Other *.md files matching X.Y.Z.md become "older" (sorted newest first)
* - title, date, version come from YAML frontmatter when present
*/
import fs from 'fs';
import path from 'path';
import { fileURLToPath } from 'url';
const __dirname = path.dirname(fileURLToPath(import.meta.url));
const ROOT = path.resolve(__dirname, '..');
const UPDATE_DIR = path.join(ROOT, 'public', 'update');
const MANIFEST_PATH = path.join(UPDATE_DIR, 'manifest.json');
const CURRENT_FILE = 'currentupdate.md';
const VERSION_FILE_RE = /^(\d+\.\d+\.\d+)\.md$/;
const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
function parseFrontmatter(source) {
const match = FRONTMATTER_RE.exec(source.trimStart());
if (!match) return {};
const frontmatter = {};
match[1].split('\n').forEach((line) => {
const colon = line.indexOf(':');
if (colon <= 0) return;
const key = line.slice(0, colon).trim();
const raw = line.slice(colon + 1).trim();
frontmatter[key] = raw.replace(/^['"]|['"]$/g, '');
});
return frontmatter;
}
function compareVersions(a, b) {
const pa = a.split('.').map((part) => Number.parseInt(part, 10));
const pb = b.split('.').map((part) => Number.parseInt(part, 10));
const len = Math.max(pa.length, pb.length);
for (let i = 0; i < len; i += 1) {
const na = pa[i] ?? 0;
const nb = pb[i] ?? 0;
if (na !== nb) return nb - na;
}
return 0;
}
function readMarkdownMeta(fileName) {
const filePath = path.join(UPDATE_DIR, fileName);
const source = fs.readFileSync(filePath, 'utf8');
const frontmatter = parseFrontmatter(source);
const versionFromName = VERSION_FILE_RE.exec(fileName)?.[1];
return {
file: fileName,
version: frontmatter.version ?? versionFromName,
title: frontmatter.title,
date: frontmatter.date,
};
}
function buildManifest() {
if (!fs.existsSync(UPDATE_DIR)) {
throw new Error(`Update directory not found: ${UPDATE_DIR}`);
}
const currentPath = path.join(UPDATE_DIR, CURRENT_FILE);
if (!fs.existsSync(currentPath)) {
throw new Error(`Missing ${CURRENT_FILE} in ${UPDATE_DIR}`);
}
const older = fs
.readdirSync(UPDATE_DIR, { withFileTypes: true })
.filter((entry) => entry.isFile() && VERSION_FILE_RE.test(entry.name))
.map((entry) => readMarkdownMeta(entry.name))
.filter((entry) => entry.version)
.sort((a, b) => compareVersions(a.version, b.version));
return {
current: CURRENT_FILE,
older: older.map(({ file, version, title, date }) => {
const item = { file };
if (version) item.version = version;
if (title) item.title = title;
if (date) item.date = date;
return item;
}),
};
}
function main() {
const manifest = buildManifest();
const json = `${JSON.stringify(manifest, null, 2)}\n`;
let previous = null;
if (fs.existsSync(MANIFEST_PATH)) {
previous = fs.readFileSync(MANIFEST_PATH, 'utf8');
}
if (previous === json) {
console.log('[update-manifest] manifest.json is already up to date');
return;
}
fs.writeFileSync(MANIFEST_PATH, json, 'utf8');
console.log(
`[update-manifest] wrote manifest.json (${manifest.older.length} older version(s))`
);
}
main();
+4
View File
@@ -1,7 +1,9 @@
import React, { ReactNode, useCallback, useState } from 'react';
import FocusTrap from 'focus-trap-react';
import { useAtomValue } from 'jotai';
import { Modal, Overlay, OverlayBackdrop, OverlayCenter, PopOutContainerProvider } from 'folds';
import { stopPropagation } from '../utils/keyboard';
import { releaseNotesDialogAtom } from '../state/releaseNotes';
type Modal500Props = {
requestClose: () => void;
@@ -10,11 +12,13 @@ type Modal500Props = {
export function Modal500({ requestClose, children }: Modal500Props) {
const [modalEl, setModalEl] = useState<HTMLDivElement | null>(null);
const modalRef = useCallback((el: HTMLDivElement | null) => setModalEl(el), []);
const releaseNotesOpen = useAtomValue(releaseNotesDialogAtom).open;
return (
<Overlay open backdrop={<OverlayBackdrop />}>
<OverlayCenter>
<FocusTrap
active={!releaseNotesOpen}
focusTrapOptions={{
initialFocus: false,
clickOutsideDeactivates: true,
+9 -3
View File
@@ -5,7 +5,7 @@ import classNames from 'classnames';
import { Box, Button, Chip, Header, IconButton, Input, Menu, PopOut, RectCords, Scroll, Spinner, Text, as, config } from 'folds';
import { Icon, Icons } from '../icons';
import FocusTrap from 'focus-trap-react';
import FileSaver from 'file-saver';
import { saveMediaBlob } from '../../utils/saveMedia';
import * as css from './PdfViewer.css';
import { AsyncStatus } from '../../hooks/useAsyncCallback';
import { useZoom } from '../../hooks/useZoom';
@@ -61,8 +61,14 @@ export const PdfViewer = as<'div', PdfViewerProps>(
}
}, [docState, pageNo, zoom]);
const handleDownload = () => {
FileSaver.saveAs(src, name);
const handleDownload = async () => {
try {
const res = await fetch(src);
if (!res.ok) throw new Error('Failed to fetch PDF');
await saveMediaBlob(await res.blob(), name);
} catch (error) {
console.warn('[PdfViewer] Failed to download:', error);
}
};
const handleJumpSubmit: FormEventHandler<HTMLFormElement> = (evt) => {
@@ -34,7 +34,7 @@ function UserRoomProfileContextMenu({ state }: { state: UserRoomProfileState })
escapeDeactivates: stopPropagation,
}}
>
<Menu style={{ width: toRem(340) }}>
<Menu style={{ width: toRem(260) }}>
<SpaceProvider value={space ?? null}>
<RoomProvider value={room}>
<UserRoomProfile userId={userId} />
+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;
@@ -6,12 +6,11 @@ import React, {
useRef,
useState,
} from 'react';
import FileSaver from 'file-saver';
import classNames from 'classnames';
import { as } from 'folds';
import { Icon, Icons } from '../icons';
import * as css from './ImageViewer.css';
import { downloadMedia } from '../../utils/matrix';
import { downloadAndSaveMedia } from '../../utils/saveMedia';
import { getCurrentAccessToken } from '../../utils/auth';
const ZOOM_MIN = 1;
@@ -270,18 +269,13 @@ export const ImageViewer = as<'div', ImageViewerProps>(
const handleDownload = async () => {
try {
const fileContent = await downloadMedia(src, getCurrentAccessToken());
FileSaver.saveAs(fileContent, alt);
await downloadAndSaveMedia(src, alt, getCurrentAccessToken());
} catch (error) {
console.warn('[ImageViewer] Failed to download media:', error);
try {
const response = await fetch(src);
if (response.ok) {
const blob = await response.blob();
FileSaver.saveAs(blob, alt);
}
} catch {
window.open(src, '_blank');
} catch {
// ignore
}
}
};
+3 -4
View File
@@ -2,7 +2,6 @@ import { Badge, Box, IconButton, Spinner, Text, as, toRem } from 'folds';
import { Icon, Icons } from '../icons';
import React, { ReactNode, useCallback } from 'react';
import { EncryptedAttachmentInfo } from 'browser-encrypt-attachment';
import FileSaver from 'file-saver';
import { mimeTypeToExt } from '../../utils/mimeTypes';
import { useMatrixClient } from '../../hooks/useMatrixClient';
import { useMediaAuthentication } from '../../hooks/useMediaAuthentication';
@@ -14,6 +13,7 @@ import {
mxcUrlToHttp,
} from '../../utils/matrix';
import { getCurrentAccessToken } from '../../utils/auth';
import { saveMediaBlob } from '../../utils/saveMedia';
const badgeStyles = { maxWidth: toRem(100) };
@@ -36,9 +36,8 @@ export function FileDownloadButton({ filename, url, mimeType, encInfo }: FileDow
? await downloadEncryptedMedia(mediaUrl, (encBuf) => decryptFile(encBuf, mimeType, encInfo), accessToken)
: await downloadMedia(mediaUrl, accessToken);
const fileURL = URL.createObjectURL(fileContent);
FileSaver.saveAs(fileURL, filename);
return fileURL;
await saveMediaBlob(fileContent, filename);
return true;
}, [mx, url, useAuthentication, mimeType, encInfo, filename])
);
@@ -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}
+1 -1
View File
@@ -117,7 +117,7 @@ export const Reply = as<'div', ReplyProps>(
const { body } = replyEvent?.getContent() ?? {};
const sender = replyEvent?.getSender();
const senderAvatarMxc = sender ? getMemberAvatarMxc(room, sender) : undefined;
const customUserColor = useOtherUserColor(sender ?? '', senderAvatarMxc);
const customUserColor = useOtherUserColor(sender ?? '', room);
const powerTag = sender ? getMemberPowerTag?.(sender) : undefined;
const tagColor = powerTag?.color ? accessibleTagColors?.get(powerTag.color) : undefined;
@@ -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',
},
@@ -1,8 +1,8 @@
import React, { ReactNode, useCallback, useState } from 'react';
import { Box, Button, Modal, Overlay, OverlayBackdrop, OverlayCenter, Spinner, Text, Tooltip, TooltipProvider, as } from 'folds';
import { Icon, Icons } from '../../icons';
import FileSaver from 'file-saver';
import { EncryptedAttachmentInfo } from 'browser-encrypt-attachment';
import { saveMediaBlob } from '../../../utils/saveMedia';
import FocusTrap from 'focus-trap-react';
import { IFileInfo } from '../../../../types/matrix/common';
import { AsyncStatus, useAsyncCallback } from '../../../hooks/useAsyncCallback';
@@ -252,9 +252,8 @@ export function DownloadFile({ body, mimeType, url, info, encInfo }: DownloadFil
? await downloadEncryptedMedia(mediaUrl, (encBuf) => decryptFile(encBuf, mimeType, encInfo), accessToken)
: await downloadMedia(mediaUrl, accessToken);
const fileURL = URL.createObjectURL(fileContent);
FileSaver.saveAs(fileURL, body);
return fileURL;
await saveMediaBlob(fileContent, body);
return fileContent;
}, [mx, url, useAuthentication, mimeType, encInfo, body])
);
@@ -268,7 +267,7 @@ export function DownloadFile({ body, mimeType, url, info, encInfo }: DownloadFil
size="400"
onClick={() =>
downloadState.status === AsyncStatus.Success
? FileSaver.saveAs(downloadState.data, body)
? saveMediaBlob(downloadState.data, body)
: download()
}
disabled={downloadState.status === AsyncStatus.Loading}
+2 -1
View File
@@ -16,6 +16,7 @@ type PageRootProps = {
export function PageRoot({ nav, children }: PageRootProps) {
const screenSize = useScreenSizeContext();
const showCompactMaster = useShowCompactMasterView();
const showDetail = !showCompactMaster || nav == null;
return (
<Box grow="Yes" className={ContainerColor({ variant: 'Background' })}>
@@ -23,7 +24,7 @@ export function PageRoot({ nav, children }: PageRootProps) {
{screenSize !== ScreenSize.Mobile && (
<Line variant="Background" size="300" direction="Vertical" />
)}
{!showCompactMaster && children}
{showDetail && children}
</Box>
);
}
+1 -1
View File
@@ -67,6 +67,7 @@ type AvatarPresenceProps = {
export const AvatarPresence = as<'div', AvatarPresenceProps>(
({ as: AsAvatarPresence, badge, variant = 'Surface', badgeBackgroundColor, children, ...props }, ref) => (
<Box as={AsAvatarPresence} className={css.AvatarPresence} {...props} ref={ref}>
{children}
{badge && (
<div
className={css.AvatarPresenceBadge}
@@ -75,7 +76,6 @@ export const AvatarPresence = as<'div', AvatarPresenceProps>(
{badge}
</div>
)}
{children}
</Box>
)
);
+1 -1
View File
@@ -12,7 +12,7 @@ export const AvatarPresenceBadge = style({
bottom: 0,
right: 0,
transform: 'translate(25%, 25%)',
zIndex: 1,
zIndex: 10,
display: 'flex',
padding: config.borderWidth.B600,
+42
View File
@@ -9,6 +9,8 @@ export const Sidebar = style([
width: toRem(66),
backgroundColor: color.Background.Container,
borderRight: `${config.borderWidth.B300} solid ${color.Background.ContainerLine}`,
position: 'relative',
isolation: 'isolate',
display: 'flex',
flexDirection: 'column',
@@ -185,6 +187,46 @@ export const SidebarAvatar = recipe({
});
export type SidebarAvatarVariants = RecipeVariants<typeof SidebarAvatar>;
/** A vertical rendition of the user's nameplate behind the bottom settings avatar. */
export const SidebarAvatarNameplate = style({
position: 'absolute',
// The 50px avatar is centered in the 66px sidebar. Pin the rotated plate's
// bottom-right corner 8px left of it so the 66px cross-axis
// spans the whole sidebar and grows upward from its bottom edge.
right: toRem(58),
bottom: toRem(-16),
width: toRem(220),
height: toRem(66),
transformOrigin: 'right bottom',
transform: 'rotate(90deg)',
objectFit: 'cover',
objectPosition: 'right center',
pointerEvents: 'none',
zIndex: -1,
});
export const SidebarAvatarLarge = style({
width: toRem(50),
height: toRem(50),
borderRadius: '50%',
backgroundColor: `color-mix(in srgb, ${color.Background.Container} 68%, transparent)`,
backdropFilter: 'blur(10px)',
WebkitBackdropFilter: 'blur(10px)',
});
export const SidebarSearchAvatar = style({
position: 'relative',
zIndex: 1,
backgroundColor: `color-mix(in srgb, ${color.Background.Container} 68%, transparent)`,
backdropFilter: 'blur(10px)',
WebkitBackdropFilter: 'blur(10px)',
});
export const SidebarAvatarForeground = style({
position: 'relative',
zIndex: 1,
});
export const SidebarFolder = recipe({
base: [
ContainerColor({ variant: 'Background' }),
@@ -0,0 +1,35 @@
import React from 'react';
import ReactMarkdown from 'react-markdown';
import remarkGfm from 'remark-gfm';
import { resolveUpdateAssetUrl } from '../../data/updateNotes';
import * as css from './UpdatesDialog.css';
type UpdateMarkdownViewerProps = {
markdown: string;
};
export function UpdateMarkdownViewer({ markdown }: UpdateMarkdownViewerProps) {
if (!markdown.trim()) {
return null;
}
return (
<div className={css.Markdown}>
<ReactMarkdown
remarkPlugins={[remarkGfm]}
components={{
a: ({ href, children }) => (
<a href={href} target="_blank" rel="noreferrer noopener">
{children}
</a>
),
img: ({ src, alt }) => (
<img src={resolveUpdateAssetUrl(src) ?? src} alt={alt ?? ''} loading="lazy" />
),
}}
>
{markdown}
</ReactMarkdown>
</div>
);
}
@@ -0,0 +1,329 @@
import { globalStyle, style } from '@vanilla-extract/css';
import { color, config, toRem } from 'folds';
const MOBILE_BREAKPOINT = '480px';
/** Above folds overlays (9999) and Settings modals. */
const UPDATES_DIALOG_Z = 10001;
const DIALOG_MAX_HEIGHT =
'calc(85vh - env(safe-area-inset-top, 0px) - env(safe-area-inset-bottom, 0px))';
/** [data-updates-dialog] — full-screen host portaled to document.body */
export const Root = style({
position: 'fixed',
inset: 0,
zIndex: UPDATES_DIALOG_Z,
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
pointerEvents: 'auto',
});
/** [data-updates-dialog-backdrop] */
export const Backdrop = style({
position: 'absolute',
inset: 0,
zIndex: 0,
backgroundColor: 'rgba(0, 0, 0, 0.55)',
});
/** [data-updates-dialog-frame] */
export const Frame = style({
position: 'relative',
zIndex: 1,
boxSizing: 'border-box',
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
width: '100%',
maxHeight: '100vh',
maxWidth: '100vw',
padding:
'env(safe-area-inset-top, 0px) env(safe-area-inset-right, 0px) env(safe-area-inset-bottom, 0px) env(safe-area-inset-left, 0px)',
pointerEvents: 'none',
});
/** [data-updates-dialog-panel] */
export const Panel = style({
position: 'relative',
display: 'flex',
flexDirection: 'column',
width: '100%',
maxWidth: toRem(560),
maxHeight: DIALOG_MAX_HEIGHT,
overflow: 'hidden',
pointerEvents: 'auto',
borderRadius: config.radii.R400,
backgroundColor: color.Surface.Container,
color: color.Surface.OnContainer,
boxShadow: config.shadow.E400,
'@media': {
[`(max-width: ${MOBILE_BREAKPOINT})`]: {
maxWidth: `calc(100vw - 2 * ${config.space.S400})`,
},
},
});
export const Hero = style({
display: 'flex',
flexDirection: 'column',
gap: config.space.S200,
padding: config.space.S500,
paddingBottom: config.space.S400,
backgroundColor: color.Primary.Container,
color: color.Primary.OnContainer,
borderBottom: `${config.borderWidth.B300} solid ${color.Primary.ContainerLine}`,
'@media': {
[`(max-width: ${MOBILE_BREAKPOINT})`]: {
padding: config.space.S400,
paddingBottom: config.space.S300,
},
},
});
export const HeroRow = style({
display: 'flex',
alignItems: 'center',
gap: config.space.S300,
minWidth: 0,
});
export const HeroLogo = style({
width: toRem(48),
height: toRem(48),
flexShrink: 0,
'@media': {
[`(max-width: ${MOBILE_BREAKPOINT})`]: {
width: toRem(40),
height: toRem(40),
},
},
});
export const HeroTitleWrap = style({
display: 'flex',
flexDirection: 'column',
gap: config.space.S100,
minWidth: 0,
});
export const BodyScroll = style({
flex: '1 1 auto',
minHeight: 0,
backgroundColor: color.Surface.Container,
color: color.Surface.OnContainer,
});
export const BodyContent = style({
display: 'flex',
flexDirection: 'column',
padding: config.space.S500,
paddingTop: config.space.S400,
'@media': {
[`(max-width: ${MOBILE_BREAKPOINT})`]: {
padding: config.space.S400,
paddingTop: config.space.S300,
},
},
});
export const BodyLoading = style({
padding: config.space.S600,
});
export const Markdown = style({
width: '100%',
color: color.Surface.OnContainer,
fontSize: toRem(14),
lineHeight: 1.55,
});
globalStyle(`${Markdown} h1, ${Markdown} h2, ${Markdown} h3, ${Markdown} h4`, {
margin: 0,
marginTop: config.space.S400,
marginBottom: config.space.S200,
lineHeight: 1.3,
color: color.Surface.OnContainer,
});
globalStyle(`${Markdown} h1:first-child, ${Markdown} h2:first-child, ${Markdown} h3:first-child, ${Markdown} h4:first-child`, {
marginTop: 0,
});
globalStyle(`${Markdown} h2`, { fontSize: toRem(18) });
globalStyle(`${Markdown} h3`, { fontSize: toRem(16) });
globalStyle(`${Markdown} p`, {
margin: 0,
marginBottom: config.space.S300,
});
globalStyle(`${Markdown} p:last-child`, { marginBottom: 0 });
globalStyle(`${Markdown} ul, ${Markdown} ol`, {
margin: 0,
marginBottom: config.space.S300,
paddingLeft: config.space.S500,
});
globalStyle(`${Markdown} li`, { marginBottom: config.space.S100 });
globalStyle(`${Markdown} li:last-child`, { marginBottom: 0 });
globalStyle(`${Markdown} a`, {
color: color.Primary.Main,
textDecoration: 'underline',
textUnderlineOffset: toRem(2),
});
globalStyle(`${Markdown} a:hover`, { color: color.Primary.MainHover });
globalStyle(`${Markdown} img`, {
display: 'block',
maxWidth: '100%',
height: 'auto',
marginTop: config.space.S200,
marginBottom: config.space.S300,
borderRadius: config.radii.R300,
border: `${config.borderWidth.B300} solid ${color.Surface.ContainerLine}`,
});
globalStyle(`${Markdown} code`, {
fontFamily: 'ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace',
fontSize: toRem(13),
padding: `0 ${config.space.S100}`,
borderRadius: config.radii.R300,
backgroundColor: color.SurfaceVariant.Container,
color: color.SurfaceVariant.OnContainer,
});
globalStyle(`${Markdown} pre`, {
margin: 0,
marginBottom: config.space.S300,
padding: config.space.S300,
borderRadius: config.radii.R300,
backgroundColor: color.SurfaceVariant.Container,
overflow: 'auto',
});
globalStyle(`${Markdown} pre code`, {
padding: 0,
backgroundColor: 'transparent',
});
globalStyle(`${Markdown} blockquote`, {
margin: 0,
marginBottom: config.space.S300,
paddingLeft: config.space.S300,
borderLeft: `${toRem(3)} solid ${color.Primary.Main}`,
color: color.Surface.OnContainer,
opacity: 0.9,
});
globalStyle(`${Markdown} hr`, {
border: 'none',
borderTop: `${config.borderWidth.B300} solid ${color.Surface.ContainerLine}`,
margin: `${config.space.S400} 0`,
});
globalStyle(`${Markdown} table`, {
width: '100%',
borderCollapse: 'collapse',
marginBottom: config.space.S300,
fontSize: toRem(13),
});
globalStyle(`${Markdown} th, ${Markdown} td`, {
padding: config.space.S200,
border: `${config.borderWidth.B300} solid ${color.Surface.ContainerLine}`,
textAlign: 'left',
});
globalStyle(`${Markdown} th`, {
backgroundColor: color.SurfaceVariant.Container,
});
export const OlderSection = style({
width: '100%',
marginTop: config.space.S500,
});
export const OlderToggle = style({
width: '100%',
});
export const OlderList = style({
listStyle: 'none',
margin: 0,
padding: 0,
display: 'flex',
flexDirection: 'column',
gap: config.space.S100,
width: '100%',
});
export const OlderListItem = style({
width: '100%',
});
export const OlderItem = style({
all: 'unset',
boxSizing: 'border-box',
display: 'flex',
flexDirection: 'column',
alignItems: 'flex-start',
gap: config.space.S100,
width: '100%',
minHeight: toRem(48),
padding: config.space.S300,
borderRadius: config.radii.R300,
border: `${config.borderWidth.B300} solid ${color.Surface.ContainerLine}`,
backgroundColor: color.SurfaceVariant.Container,
color: color.SurfaceVariant.OnContainer,
cursor: 'pointer',
textAlign: 'left',
selectors: {
'&:hover': {
backgroundColor: color.SurfaceVariant.ContainerHover,
},
'&[data-active="true"]': {
borderColor: color.Primary.Main,
backgroundColor: color.Primary.Container,
color: color.Primary.OnContainer,
},
},
});
export const Footer = style({
display: 'flex',
flexDirection: 'column',
gap: config.space.S200,
padding: config.space.S400,
paddingTop: config.space.S300,
paddingBottom: `calc(${config.space.S400} + env(safe-area-inset-bottom, 0px))`,
borderTop: `${config.borderWidth.B300} solid ${color.Surface.ContainerLine}`,
backgroundColor: color.Surface.Container,
'@media': {
[`(max-width: ${MOBILE_BREAKPOINT})`]: {
padding: config.space.S300,
paddingTop: config.space.S300,
paddingBottom: `calc(${config.space.S300} + env(safe-area-inset-bottom, 0px))`,
},
},
});
export const FooterButton = style({
width: '100%',
});
export const CloseButton = style({
position: 'absolute',
top: config.space.S300,
right: config.space.S300,
'@media': {
[`(max-width: ${MOBILE_BREAKPOINT})`]: {
top: config.space.S200,
right: config.space.S200,
},
},
});
@@ -0,0 +1,183 @@
import React, { useState } from 'react';
import { createPortal } from 'react-dom';
import FocusTrap from 'focus-trap-react';
import { Box, Button, IconButton, Scroll, Spinner, Text } from 'folds';
import { Icon, Icons } from '../icons';
import { stopPropagation } from '../../utils/keyboard';
import type { ParsedUpdateDoc, UpdateManifest } from '../../data/updateNotes';
import PaarrotSVG from '../../../../public/res/svg/paarrot.svg';
import { UpdateMarkdownViewer } from './UpdateMarkdownViewer';
import * as css from './UpdatesDialog.css';
type UpdatesDialogProps = {
manifest: UpdateManifest | null;
activeDoc: ParsedUpdateDoc | null;
loading: boolean;
onSelectFile: (file: string) => void;
onClose: () => void;
};
export function UpdatesDialog({
manifest,
activeDoc,
loading,
onSelectFile,
onClose,
}: UpdatesDialogProps) {
const [showOlderList, setShowOlderList] = useState(false);
const displayVersion = activeDoc?.version;
const displayTitle = activeDoc?.title ?? (displayVersion ? `Version ${displayVersion}` : 'Release notes');
const isCurrent = manifest && activeDoc?.file === manifest.current;
const olderEntries = manifest?.older ?? [];
const handleSelectOlder = (file: string) => {
onSelectFile(file);
setShowOlderList(false);
};
return createPortal(
<div
data-updates-dialog=""
className={css.Root}
data-disable-swipe-back="true"
data-disable-swipe-reply="true"
>
<div data-updates-dialog-backdrop="" className={css.Backdrop} aria-hidden="true" />
<div data-updates-dialog-frame="" className={css.Frame}>
<FocusTrap
focusTrapOptions={{
initialFocus: false,
clickOutsideDeactivates: false,
escapeDeactivates: stopPropagation,
}}
>
<div
role="dialog"
aria-modal="true"
aria-labelledby="updates-dialog-title"
data-updates-dialog-panel=""
className={css.Panel}
>
<Box className={css.Hero}>
<Box className={css.HeroRow}>
<img className={css.HeroLogo} src={PaarrotSVG} alt="" draggable={false} />
<Box className={css.HeroTitleWrap}>
<Text size="L400" priority="300">What&apos;s new</Text>
<Text id="updates-dialog-title" size="H4" truncate>
{displayVersion ? `Paarrot ${displayVersion}` : 'Paarrot updates'}
</Text>
</Box>
</Box>
<Text size="H6">{displayTitle}</Text>
{activeDoc?.date && (
<Text size="T200" priority="300">
{activeDoc.date}
</Text>
)}
{!loading && !isCurrent && manifest?.current && (
<Button
variant="Secondary"
fill="Soft"
radii="300"
onClick={() => onSelectFile(manifest.current)}
>
<Text size="B300">Back to current update</Text>
</Button>
)}
</Box>
<Scroll className={css.BodyScroll} visibility="Hover">
<Box className={css.BodyContent} direction="Column">
{loading && (
<Box justifyContent="Center" alignItems="Center" className={css.BodyLoading}>
<Spinner size="400" variant="Secondary" />
</Box>
)}
{!loading && activeDoc?.markdown && (
<UpdateMarkdownViewer markdown={activeDoc.markdown} />
)}
{!loading && !activeDoc?.markdown && (
<Text size="T300" priority="400">
No update notes are available right now.
</Text>
)}
{!loading && olderEntries.length > 0 && (
<Box className={css.OlderSection} direction="Column" gap="200">
<Button
className={css.OlderToggle}
variant="Secondary"
fill="Soft"
radii="300"
aria-expanded={showOlderList}
onClick={() => setShowOlderList((open) => !open)}
>
<Text size="B300">
{showOlderList
? 'Hide older versions'
: `Older versions (${olderEntries.length})`}
</Text>
</Button>
{showOlderList && (
<ul className={css.OlderList}>
{olderEntries.map((entry) => {
const isActive = activeDoc?.file === entry.file;
const label = entry.version ?? entry.file.replace(/\.md$/i, '');
return (
<li key={entry.file} className={css.OlderListItem}>
<button
type="button"
className={css.OlderItem}
data-active={isActive ? 'true' : 'false'}
onClick={() => handleSelectOlder(entry.file)}
>
<Text size="B300">{label}</Text>
{entry.title && (
<Text size="T200" priority="400">
{entry.title}
</Text>
)}
{entry.date && (
<Text size="T200" priority="300">
{entry.date}
</Text>
)}
</button>
</li>
);
})}
</ul>
)}
</Box>
)}
</Box>
</Scroll>
<Box className={css.Footer}>
<Button
className={css.FooterButton}
variant="Primary"
fill="Solid"
radii="300"
onClick={onClose}
>
<Text size="B400">Got it</Text>
</Button>
</Box>
<Box className={css.CloseButton}>
<IconButton variant="Surface" onClick={onClose} aria-label="Close">
<Icon src={Icons.Cross} />
</IconButton>
</Box>
</div>
</FocusTrap>
</div>
</div>,
document.body
);
}
@@ -0,0 +1,153 @@
import { useCallback, useEffect, useState } from 'react';
import { useAtom, useSetAtom } from 'jotai';
import {
loadCurrentUpdateDocument,
loadUpdateDocument,
loadUpdateManifest,
type ParsedUpdateDoc,
type UpdateManifest,
} from '../../data/updateNotes';
import {
clearPendingReleaseNotes,
getLastSeenAppVersion,
releaseNotesDialogAtom,
setLastSeenAppVersion,
storePendingReleaseNotes,
} from '../../state/releaseNotes';
import { getAppVersion } from '../../utils/appVersion';
import { UpdatesDialog } from './UpdatesDialog';
type UpdaterInfo = {
version: string;
releaseNotes?: unknown;
};
/** Open the What's New dialog from Settings → About (or anywhere else). */
export function useOpenReleaseNotesDialog(): () => void {
const setDialogState = useSetAtom(releaseNotesDialogAtom);
return useCallback(() => {
// Defer so the opening tap does not trip FocusTrap click-outside on Android.
window.requestAnimationFrame(() => {
setDialogState({ open: true, manual: true });
});
}, [setDialogState]);
}
export function UpdatesDialogHost() {
const [dialogState, setDialogState] = useAtom(releaseNotesDialogAtom);
const [manifest, setManifest] = useState<UpdateManifest | null>(null);
const [activeDoc, setActiveDoc] = useState<ParsedUpdateDoc | null>(null);
const [loading, setLoading] = useState(false);
const closeDialog = useCallback(() => {
setDialogState({ open: false, manual: false });
setManifest(null);
setActiveDoc(null);
setLoading(false);
getAppVersion().then((version) => {
if (version !== 'unknown') {
setLastSeenAppVersion(version);
}
});
}, [setDialogState]);
const selectFile = useCallback(async (file: string) => {
setLoading(true);
const doc = await loadUpdateDocument(file);
setActiveDoc(doc);
setLoading(false);
}, []);
// Persist updater metadata when a download finishes (version tracking after restart).
useEffect(() => {
const electron = window.electron;
if (!electron?.updater?.onUpdateDownloaded) return undefined;
const onDownloaded = (info: UpdaterInfo) => {
if (!info?.version) return;
storePendingReleaseNotes(info.version, info.releaseNotes);
};
electron.updater.onUpdateDownloaded(onDownloaded);
return undefined;
}, []);
// Show What's New after the app version changes (post-update restart).
useEffect(() => {
let cancelled = false;
const checkVersion = async () => {
const currentVersion = await getAppVersion();
if (cancelled || currentVersion === 'unknown') return;
const lastSeen = getLastSeenAppVersion();
const shouldAutoShow = lastSeen !== currentVersion;
if (shouldAutoShow) {
const loadedManifest = await loadUpdateManifest();
if (cancelled || !loadedManifest) return;
const doc = await loadUpdateDocument(loadedManifest.current);
if (cancelled || !doc) return;
setManifest(loadedManifest);
setActiveDoc(doc);
setDialogState({ open: true, manual: false });
clearPendingReleaseNotes();
}
};
const timer = window.setTimeout(checkVersion, 1500);
return () => {
cancelled = true;
window.clearTimeout(timer);
};
}, [setDialogState]);
// Load markdown when the dialog opens (manual open from About, etc.).
useEffect(() => {
if (!dialogState.open) return undefined;
let cancelled = false;
const load = async () => {
setLoading(true);
const loadedManifest = await loadUpdateManifest();
if (cancelled) return;
if (!loadedManifest) {
setManifest(null);
setActiveDoc(null);
setLoading(false);
return;
}
const doc = await loadUpdateDocument(loadedManifest.current);
if (cancelled) return;
setManifest(loadedManifest);
setActiveDoc(doc);
setLoading(false);
};
load();
return () => {
cancelled = true;
};
}, [dialogState.open]);
if (!dialogState.open) {
return null;
}
return (
<UpdatesDialog
manifest={manifest}
activeDoc={activeDoc}
loading={loading}
onSelectFile={selectFile}
onClose={closeDialog}
/>
);
}
@@ -0,0 +1,3 @@
export * from './UpdatesDialog';
export * from './UpdatesDialogHost';
export * from './UpdateMarkdownViewer';
@@ -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>
);
});
@@ -0,0 +1,28 @@
import React from 'react';
import {
pickStoredProfileEffectIntroUrl,
pickStoredProfileEffectLoopUrl,
} from '../../utils/collectibleAssets';
import { ProfileEffectMedia } from './ProfileEffectMedia';
import * as css from './styles.css';
type ProfileCollectibleOverlaysProps = {
assetUrls: Record<string, string | undefined>;
};
export function ProfileCollectibleOverlays({ assetUrls }: ProfileCollectibleOverlaysProps) {
const introUrl = pickStoredProfileEffectIntroUrl(assetUrls);
const loopUrl = pickStoredProfileEffectLoopUrl(assetUrls);
if (!introUrl && !loopUrl) return null;
return (
<div className={css.UserHeroCollectibleLayer} aria-hidden="true">
<ProfileEffectMedia
introUrl={introUrl}
loopUrl={loopUrl}
className={css.ProfileEffectOverlay}
/>
</div>
);
}
@@ -0,0 +1,77 @@
import React, { useEffect, useState } from 'react';
import { isCatalogVideoPreview } from '../../utils/collectibleAssets';
const DEFAULT_INTRO_DURATION_MS = 3000;
type ProfileEffectMediaProps = {
introUrl?: string;
loopUrl?: string;
introDurationMs?: number;
className?: string;
restartToken?: number;
};
export function ProfileEffectMedia({
introUrl,
loopUrl,
introDurationMs,
className,
restartToken = 0,
}: ProfileEffectMediaProps) {
const resolvedLoopUrl = loopUrl ?? introUrl;
const hasSequence = Boolean(introUrl && resolvedLoopUrl && introUrl !== resolvedLoopUrl);
const [phase, setPhase] = useState<'intro' | 'loop'>(hasSequence ? 'intro' : 'loop');
const [playbackEpoch, setPlaybackEpoch] = useState(0);
useEffect(() => {
setPhase(hasSequence ? 'intro' : 'loop');
}, [introUrl, resolvedLoopUrl, hasSequence]);
useEffect(() => {
setPhase(hasSequence ? 'intro' : 'loop');
setPlaybackEpoch((epoch) => epoch + 1);
}, [restartToken, hasSequence]);
const activeUrl = phase === 'intro' && introUrl ? introUrl : resolvedLoopUrl;
const shouldLoop = !hasSequence || phase === 'loop';
useEffect(() => {
if (!hasSequence || phase !== 'intro' || !introUrl) return undefined;
if (isCatalogVideoPreview(introUrl)) return undefined;
const duration = introDurationMs ?? DEFAULT_INTRO_DURATION_MS;
const timer = window.setTimeout(() => setPhase('loop'), duration);
return () => window.clearTimeout(timer);
}, [hasSequence, phase, introUrl, introDurationMs, playbackEpoch]);
if (!activeUrl) return null;
if (isCatalogVideoPreview(activeUrl)) {
return (
<video
key={`${playbackEpoch}:${activeUrl}`}
className={className}
src={activeUrl}
autoPlay
loop={shouldLoop}
muted
playsInline
onEnded={() => {
if (hasSequence && phase === 'intro') {
setPhase('loop');
}
}}
/>
);
}
return (
<img
key={`${playbackEpoch}:${activeUrl}`}
className={className}
src={activeUrl}
alt=""
draggable={false}
/>
);
}
+64 -50
View File
@@ -1,4 +1,4 @@
import React, { useState } from 'react';
import React, { ReactNode, useState } from 'react';
import { Avatar, Box, Overlay, Text, toRem } from 'folds';
import { Icon, Icons } from '../icons';
import classNames from 'classnames';
@@ -14,31 +14,36 @@ import { ImageViewer } from '../image-viewer';
import { stopPropagation } from '../../utils/keyboard';
import { useOtherUserColor } from '../../hooks/useUserColor';
import { useOtherUserBanner } from '../../hooks/useUserBanner';
import { useOtherUserProfileStyle } from '../../hooks/useUserProfileStyle';
import { useOtherUserCollectibles } from '../../hooks/useUserCollectibles';
import { pickAvatarDecorationUrl } from '../../utils/collectibleAssets';
import * as avatarDecorationCss from '../../styles/AvatarDecoration.css';
import { ProfileCollectibleOverlays } from './ProfileCollectibleOverlays';
type UserHeroProps = {
userId: string;
avatarUrl?: string;
avatarMxc?: string;
presence?: UserPresence;
children?: ReactNode;
};
export function UserHero({ userId, avatarUrl, avatarMxc, presence }: UserHeroProps) {
export function UserHero({ userId, avatarUrl, avatarMxc, presence, children }: UserHeroProps) {
const [viewAvatar, setViewAvatar] = useState<string>();
const bannerUrl = useOtherUserBanner(userId, avatarMxc); // Now returns blob URL directly
const profileStyle = useOtherUserProfileStyle(userId, avatarMxc);
console.log('[UserHero]', {
userId,
avatarMxc,
bannerUrl,
profileStyle,
});
const bannerUrl = useOtherUserBanner(userId);
const { assetUrls } = useOtherUserCollectibles(userId);
const avatarDecorationUrl = pickAvatarDecorationUrl(assetUrls);
return (
<Box
direction="Column"
className={css.UserHero}
>
<Box direction="Column" className={css.UserHeroZone}>
{bannerUrl && (
<div className={css.UserHeroBannerReflection} aria-hidden="true">
<img
className={css.UserHeroBannerReflectionImg}
src={bannerUrl}
alt=""
draggable={false}
/>
</div>
)}
<div
className={css.UserHeroCoverContainer}
style={{
@@ -56,35 +61,45 @@ export function UserHero({ userId, avatarUrl, avatarMxc, presence }: UserHeroPro
</div>
<div className={css.UserHeroAvatarContainer}>
<AvatarPresence
className={css.UserAvatarContainer}
style={profileStyle.avatarBorderColor ? { backgroundColor: profileStyle.avatarBorderColor } : undefined}
badgeBackgroundColor={profileStyle.avatarBorderColor}
className={classNames(
css.UserAvatarContainer,
!avatarUrl && css.UserAvatarContainerFallback
)}
badge={
presence && <PresenceBadge presence={presence.presence} status={presence.status} />
}
>
<Avatar
as={avatarUrl ? 'button' : 'div'}
onClick={avatarUrl ? () => setViewAvatar(avatarUrl) : undefined}
className={css.UserHeroAvatar}
size="500"
style={{
width: toRem(72),
height: toRem(72),
...(profileStyle.avatarBorderColor ? {
outline: `${toRem(4)} solid ${profileStyle.avatarBorderColor}`,
outlineOffset: toRem(-1),
} : {}),
}}
>
<UserAvatar
className={css.UserHeroAvatarImg}
userId={userId}
src={avatarUrl}
alt={userId}
renderFallback={() => <Icon size="500" src={Icons.User} filled />}
/>
</Avatar>
<div className={css.UserHeroAvatarStack}>
<Avatar
as={avatarUrl ? 'button' : 'div'}
onClick={avatarUrl ? () => setViewAvatar(avatarUrl) : undefined}
className={classNames(
css.UserHeroAvatar,
avatarUrl ? css.UserHeroAvatarWithImage : css.UserHeroAvatarBorder
)}
size="500"
style={{
width: toRem(72),
height: toRem(72),
}}
>
<UserAvatar
className={css.UserHeroAvatarImg}
userId={userId}
src={avatarUrl}
alt={userId}
renderFallback={() => <Icon size="500" src={Icons.User} filled />}
/>
</Avatar>
{avatarDecorationUrl && (
<img
className={avatarDecorationCss.AvatarDecorationOverlay}
src={avatarDecorationUrl}
alt=""
draggable={false}
/>
)}
</div>
</AvatarPresence>
{viewAvatar && (
<Overlay open backdrop={null}>
@@ -105,6 +120,12 @@ export function UserHero({ userId, avatarUrl, avatarMxc, presence }: UserHeroPro
</Overlay>
)}
</div>
{children && (
<Box direction="Column" className={css.UserHeroInfo}>
{children}
</Box>
)}
<ProfileCollectibleOverlays assetUrls={assetUrls} />
</Box>
);
}
@@ -114,16 +135,9 @@ type UserHeroNameProps = {
userId: string;
avatarMxc?: string;
};
export function UserHeroName({ displayName, userId, avatarMxc }: UserHeroNameProps) {
export function UserHeroName({ displayName, userId }: UserHeroNameProps) {
const username = getMxIdLocalPart(userId);
const userColor = useOtherUserColor(userId, avatarMxc);
console.log('[UserHeroName]', {
userId,
avatarMxc,
userColor,
fallbackColor: colorMXID(userId),
});
const userColor = useOtherUserColor(userId);
return (
<Box grow="Yes" direction="Column" gap="100">
@@ -2,7 +2,7 @@ import { Box, Button, color, config, Text, toRem } from 'folds';
import { Icon, Icons } from '../icons';
import React from 'react';
import { useNavigate } from 'react-router-dom';
import { UserHero, UserHeroName } from './UserHero';
import { UserHero } from './UserHero';
import { getMxIdServer, mxcUrlToHttp } from '../../utils/matrix';
import { getMemberAvatarMxc, getMemberDisplayName } from '../../utils/room';
import { useMatrixClient } from '../../hooks/useMatrixClient';
@@ -10,7 +10,6 @@ import { useMediaAuthentication } from '../../hooks/useMediaAuthentication';
import { usePowerLevels } from '../../hooks/usePowerLevels';
import { useRoom } from '../../hooks/useRoom';
import { useUserPresence } from '../../hooks/useUserPresence';
import { useOtherUserProfileStyle } from '../../hooks/useUserProfileStyle';
import { IgnoredUserAlert, MutualRoomsChip, OptionsChip, ServerChip, ShareChip } from './UserChips';
import { useCloseUserRoomProfile } from '../../state/hooks/userRoomProfile';
import { PowerChip } from './PowerChip';
@@ -24,7 +23,7 @@ import { useMemberPowerCompare } from '../../hooks/useMemberPowerCompare';
import { CreatorChip } from './CreatorChip';
import { getDirectCreatePath, withSearchParam } from '../../pages/pathUtils';
import { DirectCreateSearchParams } from '../../pages/paths';
import { getContrastingTextColor, stripAlphaFromColor, getTextShadowColor } from '../../utils/common';
import { getTextShadowColor } from '../../utils/common';
import classNames from 'classnames';
import { BreakWord, LineClamp3 } from '../../styles/Text.css';
import colorMXID, { getColorMXIDValue } from '../../../util/colorMXID';
@@ -65,13 +64,7 @@ export function UserRoomProfile({ userId }: UserRoomProfileProps) {
const avatarUrl = (avatarMxc && mxcUrlToHttp(mx, avatarMxc, useAuthentication)) ?? undefined;
const presence = useUserPresence(userId);
const profileStyle = useOtherUserProfileStyle(userId, avatarMxc);
const userColor = useOtherUserColor(userId, avatarMxc);
// Build gradient CSS if configured
const gradientStyle = profileStyle.gradient
? `linear-gradient(${profileStyle.gradient.direction}, ${profileStyle.gradient.startColor}, ${profileStyle.gradient.stopColor})`
: undefined;
const userColor = useOtherUserColor(userId);
const handleMessage = () => {
closeUserRoomProfile();
@@ -93,22 +86,6 @@ export function UserRoomProfile({ userId }: UserRoomProfileProps) {
// Use userColor for text, or fall back to colorMXID
const profileColor = userColor ? userColor : getColorMXIDValue(userId);
const profileTextShadow = `0 1px 4px ${getTextShadowColor(profileColor)}`;
// Use avatarBorderColor for pill background only if it has visible alpha (not fully transparent)
const hasVisibleBorder = profileStyle.avatarBorderColor && !profileStyle.avatarBorderColor.endsWith('00');
const pillBgColor = hasVisibleBorder ? stripAlphaFromColor(profileStyle.avatarBorderColor!) : undefined;
console.log('[UserRoomProfile]', {
userId,
avatarMxc,
userColor,
profileStyle,
profileColor,
profileTextShadow,
hasVisibleBorder,
pillBgColor,
fallbackColorMXID: getColorMXIDValue(userId),
});
return (
<Box direction="Column">
@@ -117,65 +94,60 @@ export function UserRoomProfile({ userId }: UserRoomProfileProps) {
avatarUrl={avatarUrl}
avatarMxc={avatarMxc}
presence={presence && presence.lastActiveTs !== 0 ? presence : undefined}
/>
<Box
direction="Column"
gap="200"
alignItems="Center"
style={{
padding: config.space.S400,
paddingTop: `calc(${config.space.S200} + ${toRem(36)})`,
marginTop: toRem(-36),
background: gradientStyle,
textAlign: 'center'
}}
>
{/* Display Name */}
<Text
size="H4"
className={classNames(BreakWord, LineClamp3)}
style={{ color: getMemberDisplayName(room, userId) !== userId ? profileColor : undefined, textShadow: profileTextShadow }}
<Box
direction="Column"
gap="200"
alignItems="Center"
style={{
padding: config.space.S400,
paddingTop: `calc(${config.space.S200} + ${toRem(36)})`,
marginTop: toRem(-36),
}}
>
{getMemberDisplayName(room, userId)}
</Text>
{/* Username */}
<Text
size="T200"
className={BreakWord}
style={{ color: profileColor, textShadow: profileTextShadow }}
>
{userId}
</Text>
{/* Status Pill */}
{presence?.status && (
<Box
<Text
size="H4"
className={classNames(BreakWord, LineClamp3)}
style={{
backgroundColor: pillBgColor || color.Surface.Container,
border: pillBgColor ? 'none' : `${toRem(1)} solid ${color.Surface.ContainerLine}`,
padding: `${toRem(6)} ${toRem(10)}`,
borderRadius: toRem(16),
maxWidth: toRem(250),
color: getMemberDisplayName(room, userId) !== userId ? profileColor : undefined,
textShadow: profileTextShadow,
}}
>
<Text
size="T300"
className={BreakWord}
{getMemberDisplayName(room, userId)}
</Text>
<Text
size="T200"
className={BreakWord}
style={{ color: profileColor, textShadow: profileTextShadow }}
>
{userId}
</Text>
{presence?.status && (
<Box
style={{
color: pillBgColor ? getContrastingTextColor(pillBgColor) : undefined
backgroundColor: color.Surface.Container,
border: `${toRem(1)} solid ${color.Surface.ContainerLine}`,
padding: `${toRem(6)} ${toRem(10)}`,
borderRadius: toRem(16),
maxWidth: toRem(250),
}}
>
{presence.status}
</Text>
</Box>
)}
<Text size="T300" className={BreakWord}>
{presence.status}
</Text>
</Box>
)}
</Box>
</UserHero>
<Box direction="Column" gap="200" alignItems="Center" style={{ padding: config.space.S400, textAlign: 'center' }}>
{/* Chips Row */}
<Box alignItems="Center" gap="200" wrap="Wrap" justifyContent="Center">
{server && <ServerChip server={server} borderColor={pillBgColor} />}
<ShareChip userId={userId} borderColor={pillBgColor} />
{creator ? <CreatorChip borderColor={pillBgColor} /> : <PowerChip userId={userId} borderColor={pillBgColor} />}
{server && <ServerChip server={server} />}
<ShareChip userId={userId} />
{creator ? <CreatorChip /> : <PowerChip userId={userId} />}
</Box>
{/* Message Button */}
@@ -195,12 +167,13 @@ export function UserRoomProfile({ userId }: UserRoomProfileProps) {
{/* Additional Chips if needed */}
{userId !== myUserId && (
<Box alignItems="Center" gap="200" wrap="Wrap" justifyContent="Center">
<MutualRoomsChip userId={userId} borderColor={pillBgColor} />
<OptionsChip userId={userId} borderColor={pillBgColor} />
<MutualRoomsChip userId={userId} />
<OptionsChip userId={userId} />
</Box>
)}
</Box>
{hasBottomContent && <Box direction="Column" gap="400" style={{ padding: config.space.S400 }}>
{hasBottomContent && (
<Box direction="Column" gap="400" style={{ padding: config.space.S400 }}>
{ignored && <IgnoredUserAlert />}
{member && membership === Membership.Ban && (
<UserBanAlert
@@ -236,7 +209,8 @@ export function UserRoomProfile({ userId }: UserRoomProfileProps) {
canKick={canKickUser && membership === Membership.Join}
canBan={canBanUser && membership !== Membership.Ban}
/>
</Box>}
</Box>
)}
</Box>
);
}
+100 -3
View File
@@ -1,4 +1,4 @@
import { style } from '@vanilla-extract/css';
import { globalStyle, style } from '@vanilla-extract/css';
import { color, config, toRem } from 'folds';
export const UserHeader = style({
@@ -10,14 +10,26 @@ export const UserHeader = style({
padding: config.space.S200,
});
export const UserHero = style({
export const UserHeroZone = style({
position: 'relative',
display: 'flex',
flexDirection: 'column',
isolation: 'isolate',
});
export const UserHeroCollectibleLayer = style({
position: 'absolute',
inset: 0,
zIndex: 10,
pointerEvents: 'none',
overflow: 'visible',
});
export const UserHeroCoverContainer = style({
position: 'relative',
height: toRem(140),
overflow: 'hidden',
zIndex: 1,
});
export const UserHeroCover = style({
height: '100%',
@@ -36,12 +48,68 @@ export const UserHeroBanner = style({
export const UserHeroAvatarContainer = style({
position: 'relative',
height: toRem(29),
zIndex: 4,
overflow: 'visible',
});
export const UserHeroBannerReflection = style({
position: 'absolute',
left: 0,
right: 0,
top: toRem(140),
bottom: 0,
overflow: 'hidden',
zIndex: 0,
pointerEvents: 'none',
});
export const UserHeroBannerReflectionImg = style({
position: 'absolute',
top: toRem(12),
left: '-10%',
width: '120%',
height: toRem(160),
objectFit: 'cover',
transformOrigin: 'top center',
transform: 'scaleY(-1) scale(1.2)',
filter: 'blur(48px) saturate(1.15)',
});
export const UserHeroInfo = style({
position: 'relative',
zIndex: 4,
textAlign: 'center',
backgroundColor: 'transparent',
});
globalStyle(`${UserHeroBannerReflection}::after`, {
content: '',
position: 'absolute',
left: 0,
right: 0,
bottom: 0,
height: toRem(72),
background: `linear-gradient(
to bottom,
transparent 0%,
color-mix(in srgb, ${color.Surface.Container} 55%, transparent) 55%,
${color.Surface.Container} 100%
)`,
pointerEvents: 'none',
});
export const UserAvatarContainer = style({
position: 'absolute',
left: '50%',
top: 0,
transform: 'translate(-50%, -50%)',
zIndex: 4,
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
});
export const UserAvatarContainerFallback = style({
backgroundColor: color.Surface.Container,
});
@@ -53,14 +121,31 @@ export const UserStatusBubble = style({
zIndex: 2,
});
export const UserHeroAvatarStack = style({
position: 'relative',
width: toRem(72),
height: toRem(72),
flexShrink: 0,
});
export const UserHeroAvatar = style({
outline: `${config.borderWidth.B600} solid ${color.Surface.Container}`,
selectors: {
'button&': {
cursor: 'pointer',
},
},
});
export const UserHeroAvatarBorder = style({
outline: `${config.borderWidth.B600} solid ${color.Surface.Container}`,
border: 'none',
});
export const UserHeroAvatarWithImage = style({
outline: 'none',
border: 'none',
boxShadow: 'none',
});
export const UserHeroAvatarImg = style({
selectors: {
[`button${UserHeroAvatar}:hover &`]: {
@@ -68,3 +153,15 @@ export const UserHeroAvatarImg = style({
},
},
});
export const ProfileEffectOverlay = style({
position: 'absolute',
left: 0,
right: 0,
top: 0,
width: '100%',
aspectRatio: '450 / 880',
objectFit: 'contain',
objectPosition: 'top center',
pointerEvents: 'none',
});
@@ -1,10 +1,9 @@
import React from 'react';
import FileSaver from 'file-saver';
import classNames from 'classnames';
import { Box, Chip, Header, IconButton, Text, as } from 'folds';
import { Icon, Icons } from '../icons';
import * as css from './VideoViewer.css';
import { downloadMedia } from '../../utils/matrix';
import { downloadAndSaveMedia } from '../../utils/saveMedia';
import { getCurrentAccessToken } from '../../utils/auth';
export type VideoViewerProps = {
@@ -14,20 +13,16 @@ export type VideoViewerProps = {
};
export const VideoViewer = as<'div', VideoViewerProps>(
({ className, alt, src, requestClose, ...props }, ref) => { const handleDownload = async () => {
({ className, alt, src, requestClose, ...props }, ref) => {
const handleDownload = async () => {
try {
const fileContent = await downloadMedia(src, getCurrentAccessToken());
FileSaver.saveAs(fileContent, alt);
await downloadAndSaveMedia(src, alt, getCurrentAccessToken());
} catch (error) {
console.warn('[VideoViewer] Failed to download media:', error);
try {
const response = await fetch(src);
if (response.ok) {
const blob = await response.blob();
FileSaver.saveAs(blob, alt);
}
} catch {
window.open(src, '_blank');
} catch {
// ignore
}
}
};
+187
View File
@@ -0,0 +1,187 @@
import bundledManifest from '../../../public/update/manifest.json';
import { trimTrailingSlash } from '../utils/common';
const bundledMarkdownByFile = import.meta.glob('../../../public/update/*.md', {
query: '?raw',
import: 'default',
eager: true,
}) as Record<string, string>;
const bundledImageByFile = import.meta.glob('../../../public/update/images/*', {
import: 'default',
eager: true,
}) as Record<string, string>;
function getUpdateBaseUrl(): string {
const basePath = trimTrailingSlash(import.meta.env.BASE_URL || './');
const relative =
basePath === '.' || basePath === '' ? 'update/' : `${basePath}/update/`;
return new URL(relative, window.location.href).href.replace(/\/$/, '');
}
function getUpdateFileUrl(file: string): string {
return new URL(file, `${getUpdateBaseUrl()}/`).href;
}
export type UpdateManifestEntry = {
file: string;
version?: string;
title?: string;
date?: string;
};
export type UpdateManifest = {
current: string;
older: UpdateManifestEntry[];
};
export type ParsedUpdateDoc = {
file: string;
version?: string;
title?: string;
date?: string;
summary?: string;
markdown: string;
};
const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
function parseFrontmatter(source: string): { frontmatter: Record<string, string>; body: string } {
const match = FRONTMATTER_RE.exec(source.trimStart());
if (!match) {
return { frontmatter: {}, body: source };
}
const frontmatter: Record<string, string> = {};
match[1].split('\n').forEach((line) => {
const colon = line.indexOf(':');
if (colon <= 0) return;
const key = line.slice(0, colon).trim();
const raw = line.slice(colon + 1).trim();
frontmatter[key] = raw.replace(/^['"]|['"]$/g, '');
});
return { frontmatter, body: match[2] };
}
function parseUpdateMarkdown(file: string, source: string): ParsedUpdateDoc {
const { frontmatter, body } = parseFrontmatter(source);
return {
file,
version: frontmatter.version,
title: frontmatter.title,
date: frontmatter.date,
summary: frontmatter.summary,
markdown: body.trim(),
};
}
function loadBundledManifest(): UpdateManifest {
const manifest = bundledManifest as UpdateManifest;
return {
current: manifest.current,
older: (manifest.older ?? []).filter((entry) => entry?.file),
};
}
function loadBundledDocument(file: string): ParsedUpdateDoc | null {
const safeFile = file.replace(/^\/+/, '');
const entry = Object.entries(bundledMarkdownByFile).find(([path]) =>
path.endsWith(`/${safeFile}`)
);
if (!entry) return null;
return parseUpdateMarkdown(safeFile, entry[1]);
}
function resolveBundledImageUrl(normalizedPath: string): string | undefined {
const needle = normalizedPath.replace(/^\/+/, '');
if (!needle) return undefined;
const entry = Object.entries(bundledImageByFile).find(([path]) => {
const normalized = path.replace(/\\/g, '/');
return normalized.endsWith(`/${needle}`) || normalized.endsWith(`/${needle.split('/').pop() ?? ''}`);
});
return entry?.[1];
}
export function resolveUpdateAssetUrl(src: string | undefined): string | undefined {
if (!src) return undefined;
if (/^(https?:|data:|blob:|capacitor:)/i.test(src)) return src;
const normalized = src.replace(/^\.\//, '').replace(/^\/+/, '');
const bundled = resolveBundledImageUrl(normalized);
if (bundled) return bundled;
if (src.startsWith('/')) return src;
return new URL(normalized, `${getUpdateBaseUrl()}/`).href;
}
export async function loadUpdateManifest(): Promise<UpdateManifest | null> {
try {
const response = await fetch(getUpdateFileUrl('manifest.json'), { cache: 'no-cache' });
if (response.ok) {
const data = (await response.json()) as UpdateManifest;
if (data?.current && Array.isArray(data.older)) {
return {
current: data.current,
older: data.older.filter((entry) => entry?.file),
};
}
}
} catch {
// fall through to bundled copy (Capacitor / offline)
}
try {
return loadBundledManifest();
} catch {
return null;
}
}
export async function loadUpdateDocument(file: string): Promise<ParsedUpdateDoc | null> {
const safeFile = file.replace(/^\/+/, '');
if (!safeFile || safeFile.includes('..')) return null;
try {
const response = await fetch(getUpdateFileUrl(safeFile), { cache: 'no-cache' });
if (response.ok) {
const source = await response.text();
return parseUpdateMarkdown(safeFile, source);
}
} catch {
// fall through to bundled copy
}
return loadBundledDocument(safeFile);
}
export async function loadCurrentUpdateDocument(): Promise<ParsedUpdateDoc | null> {
const manifest = await loadUpdateManifest();
if (!manifest) return null;
return loadUpdateDocument(manifest.current);
}
export async function getCurrentUpdatePreview(): Promise<{
title: string;
description: string;
} | null> {
const doc = await loadCurrentUpdateDocument();
if (!doc) return null;
const title = doc.title ?? (doc.version ? `Paarrot ${doc.version}` : 'Release notes');
const description =
doc.summary ??
doc.markdown
.replace(/^#+\s+/gm, '')
.replace(/!\[[^\]]*\]\([^)]+\)/g, '')
.replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
.split('\n')
.map((line) => line.replace(/^[-*•]\s*/, '').trim())
.find(Boolean) ??
'See what changed in this version.';
return { title, description };
}
@@ -105,7 +105,7 @@ function SearchResultItem({
relation?.rel_type === RelationType.Thread ? relation.event_id : undefined;
// Get custom user color from avatar metadata
const customUserColor = useOtherUserColor(event.sender, senderAvatarMxc);
const customUserColor = useOtherUserColor(event.sender, room);
const memberPowerTag = getMemberPowerTag(event.sender);
const tagColor = memberPowerTag?.color
+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}`,
+5 -5
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';
@@ -183,7 +183,7 @@ export const RoomInput = forwardRef<HTMLDivElement, RoomInputProps>(
);
// Get custom user color from avatar metadata
const replyCustomColor = useOtherUserColor(replyUserID ?? '', replyAvatarMxc);
const replyCustomColor = useOtherUserColor(replyUserID ?? '', room);
const replyPowerTag = replyUserID ? getMemberPowerTag(replyUserID) : undefined;
const replyPowerColor = replyPowerTag?.color
@@ -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"
+20 -1
View File
@@ -29,7 +29,26 @@ export const TimelineFloat = recipe({
},
});
export type TimelineFloatVariants = RecipeVariants<typeof TimelineFloat>;
export const DmNameplateBackground = style({
position: 'absolute',
inset: 0,
pointerEvents: 'none',
zIndex: 0,
overflow: 'hidden',
});
export const DmNameplateBackgroundMedia = style({
position: 'absolute',
top: 0,
right: 0,
left: 'auto',
width: toRem(280),
maxWidth: '70%',
height: toRem(64),
objectFit: 'cover',
objectPosition: 'right top',
opacity: 0.12,
});
export const CarouselScroller = style([
DefaultReset,
+36 -1
View File
@@ -117,6 +117,8 @@ import { useMediaAuthentication } from '../../hooks/useMediaAuthentication';
import { useIgnoredUsers } from '../../hooks/useIgnoredUsers';
import { useImagePackRooms } from '../../hooks/useImagePackRooms';
import { useIsDirectRoom } from '../../hooks/useRoom';
import { useOtherUserCollectibles } from '../../hooks/useUserCollectibles';
import { pickNameplateUrl } from '../../utils/collectibleAssets';
import { setupCopyHandler } from '../../utils/copyHandler';
import { useOpenUserRoomProfile } from '../../state/hooks/userRoomProfile';
import { useSpaceOptionally } from '../../hooks/useSpace';
@@ -570,6 +572,13 @@ export function RoomTimeline({ room, eventId, roomInputRef, editor }: RoomTimeli
const [messageSpacing] = useSetting(settingsAtom, 'messageSpacing');
const [legacyUsernameColor] = useSetting(settingsAtom, 'legacyUsernameColor');
const direct = useIsDirectRoom();
const dmUserId = direct ? room.guessDMUserId() ?? undefined : undefined;
const [timelineHovered, setTimelineHovered] = useState(false);
const { assetUrls: dmAssetUrls } = useOtherUserCollectibles(dmUserId ?? '');
const dmNameplateUrl = pickNameplateUrl(dmAssetUrls);
const dmNameplateIsVideo = Boolean(
dmAssetUrls['nameplate:animated'] || dmAssetUrls['nameplate:asset.webm']
);
const [hideMembershipEvents] = useSetting(settingsAtom, 'hideMembershipEvents');
const [hideNickAvatarEvents] = useSetting(settingsAtom, 'hideNickAvatarEvents');
const [mediaAutoLoad] = useSetting(settingsAtom, 'mediaAutoLoad');
@@ -2530,7 +2539,33 @@ export function RoomTimeline({ room, eventId, roomInputRef, editor }: RoomTimeli
const atLiveBottom = atBottom && liveTimelineLinked && rangeAtEnd;
return (
<Box grow="Yes" style={{ position: 'relative' }}>
<Box
grow="Yes"
style={{ position: 'relative' }}
onMouseEnter={() => setTimelineHovered(true)}
onMouseLeave={() => setTimelineHovered(false)}
>
{direct && timelineHovered && dmNameplateUrl && (
<div className={css.DmNameplateBackground} aria-hidden="true">
{dmNameplateIsVideo ? (
<video
className={css.DmNameplateBackgroundMedia}
src={dmNameplateUrl}
autoPlay
loop
muted
playsInline
/>
) : (
<img
className={css.DmNameplateBackgroundMedia}
src={dmNameplateUrl}
alt=""
draggable={false}
/>
)}
</div>
)}
<Scroll ref={scrollRef} visibility="Hover" data-room-timeline-scroll="">
<Box
ref={timelineContentRef}
+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;
}
+1 -1
View File
@@ -489,7 +489,7 @@ export function RoomViewHeader({ forumLayout = false }: RoomViewHeaderProps) {
const dmAvatarMxc =
(dmUserId ? room.getMember(dmUserId)?.getMxcAvatarUrl() : undefined) ||
(isDirect ? avatarMxc : undefined);
const dmCustomColor = useOtherUserColor(dmUserId ?? '', dmAvatarMxc);
const dmCustomColor = useOtherUserColor(dmUserId ?? '');
const dmFolderTabColor =
stationery && isDirect
? `color-mix(in srgb, ${dmCustomColor ?? colorMXID(dmUserId ?? room.roomId)} 50%, var(--folder-tab-room, #f3e6c8))`
+40 -61
View File
@@ -11,6 +11,9 @@ import { getMxIdLocalPart } from '../../utils/matrix';
import * as css from './RoomViewTyping.css';
import { useMatrixClient } from '../../hooks/useMatrixClient';
import { useRoomTypingMember } from '../../hooks/useRoomTypingMembers';
import { useTypingVerbs } from '../../hooks/useUserTypingVerb';
const DEFAULT_VERB = 'typing';
export type RoomViewTypingProps = {
room: Room;
@@ -21,17 +24,40 @@ export const RoomViewTyping = as<'div', RoomViewTypingProps>(
const mx = useMatrixClient();
const typingMembers = useRoomTypingMember(room.roomId);
const typingNames = typingMembers
const typers = typingMembers
.filter((receipt) => receipt.userId !== mx.getUserId())
.map(
(receipt) => getMemberDisplayName(room, receipt.userId) ?? getMxIdLocalPart(receipt.userId)
)
.map((receipt) => ({
userId: receipt.userId,
name: getMemberDisplayName(room, receipt.userId) ?? getMxIdLocalPart(receipt.userId),
}))
.reverse();
if (typingNames.length === 0) {
const verbs = useTypingVerbs(typers.map((typer) => typer.userId));
if (typers.length === 0) {
return null;
}
const entries = typers.slice(0, 3).map((typer) => ({
name: typer.name,
verb: verbs[typer.userId],
plural: false,
}));
if (typers.length > 3) {
entries.push({ name: `${typers.length - 3} others`, verb: undefined, plural: true });
}
// One verb for everyone keeps the joined form; mixed verbs need a clause per person
const firstVerb = verbs[typers[0].userId];
const sameVerb = typers.every((typer) => verbs[typer.userId] === firstVerb);
const clauses = entries.map((entry) => ({
name: entry.name,
suffix: `${entry.plural ? 'are' : 'is'} ${entry.verb ?? DEFAULT_VERB}`,
}));
const sharedSuffix = sameVerb
? ` ${entries.length > 1 ? 'are' : 'is'} ${firstVerb ?? DEFAULT_VERB}`
: undefined;
const handleDropAll = () => {
// some homeserver does not timeout typing status
// we have given option so user can drop their typing status
@@ -54,62 +80,15 @@ export const RoomViewTyping = as<'div', RoomViewTypingProps>(
>
<TypingIndicator />
<Text className={css.TypingText} size="T300" truncate>
{typingNames.length === 1 && (
<>
<b>{typingNames[0]}</b>
<Text as="span" size="Inherit" priority="300">
{' is typing...'}
</Text>
</>
)}
{typingNames.length === 2 && (
<>
<b>{typingNames[0]}</b>
<Text as="span" size="Inherit" priority="300">
{' and '}
</Text>
<b>{typingNames[1]}</b>
<Text as="span" size="Inherit" priority="300">
{' are typing...'}
</Text>
</>
)}
{typingNames.length === 3 && (
<>
<b>{typingNames[0]}</b>
<Text as="span" size="Inherit" priority="300">
{', '}
</Text>
<b>{typingNames[1]}</b>
<Text as="span" size="Inherit" priority="300">
{' and '}
</Text>
<b>{typingNames[2]}</b>
<Text as="span" size="Inherit" priority="300">
{' are typing...'}
</Text>
</>
)}
{typingNames.length > 3 && (
<>
<b>{typingNames[0]}</b>
<Text as="span" size="Inherit" priority="300">
{', '}
</Text>
<b>{typingNames[1]}</b>
<Text as="span" size="Inherit" priority="300">
{', '}
</Text>
<b>{typingNames[2]}</b>
<Text as="span" size="Inherit" priority="300">
{' and '}
</Text>
<b>{typingNames.length - 3} others</b>
<Text as="span" size="Inherit" priority="300">
{' are typing...'}
</Text>
</>
)}
{clauses.map((clause, index) => (
<React.Fragment key={index}>
{index > 0 && (index === clauses.length - 1 ? ' and ' : ', ')}
<b>{clause.name}</b>
{!sharedSuffix && ` ${clause.suffix}`}
</React.Fragment>
))}
{sharedSuffix}
{'...'}
</Text>
<IconButton title="Drop Typing Status" size="300" radii="Pill" onClick={handleDropAll}>
<Icon size="50" src={Icons.Cross} />
+84 -35
View File
@@ -62,6 +62,10 @@ import colorMXID from '../../../../util/colorMXID';
import { getPowerTagIconSrc } from '../../../hooks/useMemberPowerTag';
import { Presence, useUserPresence } from '../../../hooks/useUserPresence';
import { useOtherUserColor } from '../../../hooks/useUserColor';
import { useIsDirectRoom } from '../../../hooks/useRoom';
import { useOtherUserCollectibles } from '../../../hooks/useUserCollectibles';
import { pickAvatarDecorationUrl, pickNameplateUrl } from '../../../utils/collectibleAssets';
import * as avatarDecorationCss from '../../../styles/AvatarDecoration.css';
export type ReactionHandler = (keyOrMxc: string, shortcode: string) => void;
@@ -754,8 +758,15 @@ export const Message = as<'div', MessageProps>(
) => {
const mx = useMatrixClient();
const useAuthentication = useMediaAuthentication();
const direct = useIsDirectRoom();
const senderId = mEvent.getSender() ?? '';
const senderPresence = useUserPresence(senderId);
const { assetUrls } = useOtherUserCollectibles(senderId);
const nameplateUrl = pickNameplateUrl(assetUrls);
const nameplateIsVideo = Boolean(
assetUrls['nameplate:animated'] || assetUrls['nameplate:asset.webm']
);
const avatarDecorationUrl = pickAvatarDecorationUrl(assetUrls);
const [hover, setHover] = useState(false);
const { hoverProps } = useHover({ onHoverChange: setHover });
@@ -785,7 +796,7 @@ export const Message = as<'div', MessageProps>(
const senderAvatarMxc = getMemberAvatarMxc(room, senderId);
// Get custom user color from avatar metadata (takes priority)
const customUserColor = useOtherUserColor(senderId, senderAvatarMxc);
const customUserColor = useOtherUserColor(senderId, room);
const tagColor = memberPowerTag?.color
? accessibleTagColors?.get(memberPowerTag.color)
@@ -796,6 +807,7 @@ export const Message = as<'div', MessageProps>(
// Priority: custom user color > tag color (non-legacy) > colorMXID (legacy)
const usernameColor = customUserColor ?? (legacyUsernameColor ? colorMXID(senderId) : tagColor);
const showNameplate = direct && hover && Boolean(nameplateUrl);
const headerJSX = !collapse && (
<Box
@@ -824,23 +836,41 @@ export const Message = as<'div', MessageProps>(
</Username>
{tagIconSrc && <PowerIcon size="100" iconSrc={tagIconSrc} />}
</Box>
<Box shrink="No" gap="100">
{messageLayout === MessageLayout.Modern && hover && (
<>
<Text as="span" size="T200" priority="300">
{senderId}
</Text>
<Text as="span" size="T200" priority="300">
|
</Text>
</>
<Box shrink="No" className={css.MessageNameplateAnchor}>
<Box shrink="No" gap="100" alignItems="Center">
{messageLayout === MessageLayout.Modern && hover && (
<>
<Text as="span" size="T200" priority="300">
{senderId}
</Text>
<Text as="span" size="T200" priority="300">
|
</Text>
</>
)}
<Time
ts={mEvent.getTs()}
compact={messageLayout === MessageLayout.Compact}
hour24Clock={hour24Clock}
dateFormatString={dateFormatString}
/>
</Box>
{showNameplate && (
<div className={css.MessageNameplateWrap}>
{nameplateIsVideo ? (
<video
className={css.MessageNameplateOverlay}
src={nameplateUrl}
autoPlay
loop
muted
playsInline
/>
) : (
<img className={css.MessageNameplateOverlay} src={nameplateUrl} alt="" draggable={false} />
)}
</div>
)}
<Time
ts={mEvent.getTs()}
compact={messageLayout === MessageLayout.Compact}
hour24Clock={hour24Clock}
dateFormatString={dateFormatString}
/>
</Box>
</Box>
);
@@ -857,24 +887,38 @@ export const Message = as<'div', MessageProps>(
<AvatarBase
className={messageLayout === MessageLayout.Bubble ? css.BubbleAvatarBase : undefined}
>
<Avatar
className={classNames(css.MessageAvatar, presenceClass)}
as="button"
size="300"
data-user-id={senderId}
onClick={onUserClick}
>
<UserAvatar
userId={senderId}
src={
senderAvatarMxc
? mxcUrlToHttp(mx, senderAvatarMxc, useAuthentication, 48, 48, 'crop') ?? undefined
: undefined
}
alt={senderDisplayName}
renderFallback={() => <Icon size="200" src={Icons.User} filled />}
/>
</Avatar>
<div className={css.MessageAvatarStack}>
<Avatar
className={classNames(
avatarDecorationUrl ? css.MessageAvatarCircular : css.MessageAvatar,
!avatarDecorationUrl && presenceClass
)}
radii={avatarDecorationUrl ? 'Pill' : undefined}
as="button"
size="300"
data-user-id={senderId}
onClick={onUserClick}
>
<UserAvatar
userId={senderId}
src={
senderAvatarMxc
? mxcUrlToHttp(mx, senderAvatarMxc, useAuthentication, 48, 48, 'crop') ?? undefined
: undefined
}
alt={senderDisplayName}
renderFallback={() => <Icon size="200" src={Icons.User} filled />}
/>
</Avatar>
{avatarDecorationUrl && (
<img
className={avatarDecorationCss.AvatarDecorationOverlay}
src={avatarDecorationUrl}
alt=""
draggable={false}
/>
)}
</div>
</AvatarBase>
);
@@ -954,6 +998,10 @@ export const Message = as<'div', MessageProps>(
{...focusWithinProps}
ref={ref}
>
<div
className={css.MessageContentLayer}
data-message-nameplate-readable={showNameplate ? '' : undefined}
>
{!edit && (hover || !!menuAnchor || !!emojiBoardAnchor) && (
<div className={css.MessageOptionsBase}>
<Menu className={css.MessageOptionsBar} variant="SurfaceVariant">
@@ -1242,6 +1290,7 @@ export const Message = as<'div', MessageProps>(
{msgContentJSX}
</ModernLayout>
)}
</div>
</MessageBase>
);
}
+72 -3
View File
@@ -1,5 +1,35 @@
import { style } from '@vanilla-extract/css';
import { globalStyle, style } from '@vanilla-extract/css';
import { DefaultReset, config, toRem, color } from 'folds';
import * as layoutCss from '../../../components/message/layout/layout.css';
const NAMEPLATE_READABLE_TEXT_OUTLINE = [
`0 0 2px ${color.Surface.ContainerHover}`,
`0 0 4px ${color.Surface.ContainerHover}`,
`-1px -1px 0 ${color.Surface.ContainerHover}`,
`1px -1px 0 ${color.Surface.ContainerHover}`,
`-1px 1px 0 ${color.Surface.ContainerHover}`,
`1px 1px 0 ${color.Surface.ContainerHover}`,
`0 -1px 0 ${color.Surface.ContainerHover}`,
`0 1px 0 ${color.Surface.ContainerHover}`,
`-1px 0 0 ${color.Surface.ContainerHover}`,
`1px 0 0 ${color.Surface.ContainerHover}`,
].join(', ');
globalStyle(`[data-message-nameplate-readable] [data-message-header] button`, {
textShadow: NAMEPLATE_READABLE_TEXT_OUTLINE,
});
globalStyle(`[data-message-nameplate-readable] [data-message-header] time`, {
textShadow: NAMEPLATE_READABLE_TEXT_OUTLINE,
});
globalStyle(`[data-message-nameplate-readable] [data-message-header] span`, {
textShadow: NAMEPLATE_READABLE_TEXT_OUTLINE,
});
globalStyle(`[data-message-nameplate-readable] .${layoutCss.MessageTextBody.classNames.base}`, {
textShadow: NAMEPLATE_READABLE_TEXT_OUTLINE,
});
export const MessageBase = style({
position: 'relative',
@@ -51,6 +81,12 @@ export const MessageAvatar = style({
},
});
export const MessageAvatarCircular = style({
cursor: 'pointer',
position: 'relative',
overflow: 'visible',
});
export const MessageAvatarOnline = style({
'::before': {
backgroundColor: '#38842b',
@@ -69,8 +105,41 @@ export const MessageAvatarOffline = style({
},
});
export const MessageQuickReaction = style({
minWidth: toRem(32),
export const MessageAvatarStack = style({
position: 'relative',
display: 'inline-flex',
lineHeight: 0,
overflow: 'visible',
});
export const MessageNameplateAnchor = style({
position: 'relative',
flexShrink: 0,
});
export const MessageNameplateWrap = style({
position: 'absolute',
top: `calc(100% + ${toRem(6)})`,
right: 0,
width: toRem(220),
maxWidth: toRem(280),
height: toRem(42),
pointerEvents: 'none',
zIndex: 0,
});
export const MessageNameplateOverlay = style({
width: '100%',
height: '100%',
objectFit: 'cover',
objectPosition: 'right center',
pointerEvents: 'none',
borderRadius: toRem(6),
});
export const MessageContentLayer = style({
position: 'relative',
zIndex: 1,
});
export const MessageMenuGroup = style({
@@ -116,7 +116,7 @@ function PinnedMessage({
const sender = pinnedEvent?.getSender();
const senderAvatarMxc = sender ? getMemberAvatarMxc(room, sender) : undefined;
const customUserColor = useOtherUserColor(sender ?? '', senderAvatarMxc);
const customUserColor = useOtherUserColor(sender ?? '', room);
const handleOpenClick: MouseEventHandler = (evt) => {
evt.stopPropagation();
+39 -2
View File
@@ -1,5 +1,7 @@
import React, { useCallback, useEffect, useState } from 'react';
import { getVersion } from '@tauri-apps/api/app';
import { getAppVersion } from '../../../utils/appVersion';
import { useOpenReleaseNotesDialog } from '../../../components/updates-dialog/UpdatesDialogHost';
import { getCurrentUpdatePreview } from '../../../data/updateNotes';
import { Box, Text, IconButton, Scroll, Button, config, toRem } from 'folds';
import { Icon, Icons } from '../../../components/icons';
import { Page, PageContent, PageHeader } from '../../../components/page';
@@ -15,9 +17,13 @@ type AboutProps = {
};
export function About({ requestClose }: AboutProps) {
const mx = useMatrixClient();
const openReleaseNotes = useOpenReleaseNotesDialog();
const [version, setVersion] = useState<string>('');
const [protocolStatus, setProtocolStatus] = useState<string>('Checking desktop protocol integration...');
const [protocolBusy, setProtocolBusy] = useState<boolean>(false);
const [updatePreview, setUpdatePreview] = useState<{ title: string; description: string } | null>(
null
);
const formatProtocolStatus = useCallback((data: {
scheme: string;
@@ -93,8 +99,9 @@ export function About({ requestClose }: AboutProps) {
};
useEffect(() => {
getVersion().then(setVersion).catch(() => setVersion('unknown'));
getAppVersion().then(setVersion).catch(() => setVersion('unknown'));
refreshProtocolStatus();
getCurrentUpdatePreview().then(setUpdatePreview).catch(() => setUpdatePreview(null));
}, [refreshProtocolStatus]);
return (
@@ -151,6 +158,36 @@ export function About({ requestClose }: AboutProps) {
</Box>
</Box>
</Box>
<Box direction="Column" gap="100">
<Text size="L400">What&apos;s new</Text>
<SequenceCard
className={SequenceCardStyle}
variant="SurfaceVariant"
direction="Column"
gap="300"
>
<SettingTile
title={updatePreview?.title ?? 'Release notes'}
description={
updatePreview
? `Paarrot ${version} — ${updatePreview.description}`
: 'View highlights from the latest Paarrot update.'
}
after={
<Button
onClick={openReleaseNotes}
variant="Secondary"
fill="Soft"
size="300"
radii="300"
outlined
>
<Text size="B300">View updates</Text>
</Button>
}
/>
</SequenceCard>
</Box>
<Box direction="Column" gap="100">
<Text size="L400">Options</Text>
<SequenceCard
@@ -0,0 +1,50 @@
import React from 'react';
import { DiscordCollectibleItem } from '../../../utils/discordCollectibles';
import {
isCatalogVideoPreview,
pickCatalogAnimatedPreviewUrl,
pickCatalogStaticPreviewUrl,
} from '../../../utils/collectibleAssets';
type CollectiblePreviewMediaProps = {
item: DiscordCollectibleItem;
className?: string;
restartToken?: number;
};
export function CollectiblePreviewMedia({
item,
className,
restartToken = 0,
}: CollectiblePreviewMediaProps) {
const staticUrl = pickCatalogStaticPreviewUrl(item);
const animatedUrl = pickCatalogAnimatedPreviewUrl(item);
const activeUrl = animatedUrl ?? staticUrl;
if (!activeUrl) return null;
if (animatedUrl && isCatalogVideoPreview(animatedUrl)) {
return (
<video
key={restartToken}
className={className}
src={animatedUrl}
autoPlay
loop
muted
playsInline
/>
);
}
return (
<img
key={restartToken}
className={className}
src={activeUrl}
alt=""
loading="lazy"
draggable={false}
/>
);
}
@@ -0,0 +1,332 @@
import { style } from '@vanilla-extract/css';
import { color, toRem } from 'folds';
/** Discord nameplate static.png assets are 448×84. */
export const NAMEPLATE_ASPECT_RATIO = '448 / 84';
/**
* Mini profile hero preview — matches UserRoomProfile menu width (260) and UserHero layout,
* with extra vertical space below the name so effects have room to play.
*/
export const PROFILE_HERO_PREVIEW_WIDTH = 260;
export const PROFILE_HERO_CONTENT_HEIGHT = 235;
export const PROFILE_HERO_PREVIEW_EXTRA_HEIGHT = Math.round(PROFILE_HERO_CONTENT_HEIGHT * 0.5);
export const PROFILE_HERO_PREVIEW_HEIGHT = PROFILE_HERO_CONTENT_HEIGHT + PROFILE_HERO_PREVIEW_EXTRA_HEIGHT;
export const PROFILE_HERO_PREVIEW_ASPECT_RATIO = `${PROFILE_HERO_PREVIEW_WIDTH} / ${PROFILE_HERO_PREVIEW_HEIGHT}`;
export const CollectibleGroupGrid = style({
display: 'grid',
width: '100%',
});
export const CollectibleGroupGridNameplate = style({
gridTemplateColumns: 'repeat(2, minmax(0, 1fr))',
gap: toRem(3),
});
export const CollectibleGroupGridEffects = style({
gridTemplateColumns: 'repeat(auto-fill, minmax(130px, 1fr))',
gap: toRem(12),
});
export const CollectibleGroupGridDecorations = style({
gridTemplateColumns: 'repeat(auto-fill, minmax(120px, 1fr))',
gap: toRem(12),
});
export const CollectibleGroupCard = style({
position: 'relative',
display: 'flex',
flexDirection: 'column',
gap: toRem(4),
width: '100%',
});
export const CollectibleGroupPreview = style({
position: 'relative',
display: 'block',
width: '100%',
border: 'none',
padding: 0,
overflow: 'visible',
background: 'transparent',
cursor: 'pointer',
textAlign: 'left',
});
export const CollectibleGroupPreviewDisabled = style({
cursor: 'wait',
});
export const CollectibleGroupPreviewDimmed = style({
opacity: 0.5,
});
export const CollectiblePreviewFrame = style({
width: '100%',
borderRadius: toRem(6),
overflow: 'hidden',
backgroundColor: color.Surface.ContainerLine,
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
});
export const CollectiblePreviewFrameDecoration = style({
overflow: 'visible',
backgroundColor: 'transparent',
});
export const CollectiblePreviewFrameProfileEffect = style({
backgroundColor: color.Surface.Container,
alignItems: 'stretch',
justifyContent: 'stretch',
});
export const ProfileEffectHeroPreview = style({
position: 'relative',
width: '100%',
height: '100%',
overflow: 'hidden',
backgroundColor: color.Surface.Container,
});
export const ProfileEffectHeroCover = style({
position: 'absolute',
left: 0,
right: 0,
top: 0,
height: `${(140 / PROFILE_HERO_PREVIEW_HEIGHT) * 100}%`,
overflow: 'hidden',
zIndex: 1,
});
export const ProfileEffectHeroBanner = style({
width: '100%',
height: '100%',
objectFit: 'cover',
display: 'block',
});
export const ProfileEffectHeroCoverBlur = style({
width: '100%',
height: '100%',
objectFit: 'cover',
filter: 'blur(16px)',
transform: 'scale(2)',
display: 'block',
});
export const ProfileEffectHeroAvatarSlot = style({
position: 'absolute',
left: 0,
right: 0,
top: `${(140 / PROFILE_HERO_PREVIEW_HEIGHT) * 100}%`,
height: `${(29 / PROFILE_HERO_PREVIEW_HEIGHT) * 100}%`,
zIndex: 4,
pointerEvents: 'none',
});
export const ProfileEffectHeroAvatar = style({
position: 'absolute',
left: '50%',
top: 0,
transform: 'translate(-50%, -50%)',
width: `${(72 / PROFILE_HERO_PREVIEW_WIDTH) * 100}%`,
aspectRatio: '1',
borderRadius: '50%',
overflow: 'hidden',
border: `${toRem(1)} solid ${color.Surface.Container}`,
backgroundColor: color.Surface.Container,
});
export const ProfileEffectHeroAvatarImg = style({
width: '100%',
height: '100%',
display: 'block',
objectFit: 'cover',
});
export const ProfileEffectHeroInfo = style({
position: 'absolute',
left: 0,
right: 0,
top: `${((140 + 29) / PROFILE_HERO_PREVIEW_HEIGHT) * 100}%`,
marginTop: `${(-36 / PROFILE_HERO_PREVIEW_HEIGHT) * 100}%`,
paddingTop: `${(44 / PROFILE_HERO_PREVIEW_HEIGHT) * 100}%`,
paddingLeft: `${(16 / PROFILE_HERO_PREVIEW_WIDTH) * 100}%`,
paddingRight: `${(16 / PROFILE_HERO_PREVIEW_WIDTH) * 100}%`,
paddingBottom: `${(16 / PROFILE_HERO_PREVIEW_HEIGHT) * 100}%`,
display: 'flex',
flexDirection: 'column',
alignItems: 'center',
gap: `${(8 / PROFILE_HERO_PREVIEW_HEIGHT) * 100}%`,
textAlign: 'center',
zIndex: 4,
pointerEvents: 'none',
});
export const ProfileEffectHeroName = style({
width: '100%',
fontSize: toRem(11),
lineHeight: 1.2,
fontWeight: 600,
overflow: 'hidden',
textOverflow: 'ellipsis',
whiteSpace: 'nowrap',
});
export const ProfileEffectHeroEffectLayer = style({
position: 'absolute',
inset: 0,
zIndex: 10,
pointerEvents: 'none',
overflow: 'visible',
});
export const ProfileEffectHeroEffect = style({
position: 'absolute',
left: 0,
right: 0,
top: 0,
width: '100%',
aspectRatio: '450 / 880',
objectFit: 'contain',
objectPosition: 'top center',
});
export const NameplatePreview = style({
display: 'block',
width: '100%',
aspectRatio: NAMEPLATE_ASPECT_RATIO,
objectFit: 'cover',
objectPosition: 'center',
borderRadius: toRem(4),
});
export const NameplatePreviewFallback = style({
width: '100%',
aspectRatio: NAMEPLATE_ASPECT_RATIO,
borderRadius: toRem(4),
});
export const CollectibleHoverCaption = style({
position: 'absolute',
top: `calc(100% + ${toRem(2)})`,
left: 0,
right: 0,
display: 'flex',
flexDirection: 'column',
gap: toRem(1),
padding: `${toRem(4)} ${toRem(6)}`,
background: color.Surface.Container,
border: `${toRem(1)} solid ${color.Surface.ContainerLine}`,
borderRadius: toRem(4),
boxShadow: '0 2px 8px rgba(0, 0, 0, 0.12)',
opacity: 0,
transition: 'opacity 0.15s ease',
pointerEvents: 'none',
zIndex: 2,
selectors: {
[`${CollectibleGroupPreview}:hover &`]: {
opacity: 1,
},
[`${CollectibleGroupPreview}:focus-visible &`]: {
opacity: 1,
},
},
});
export const CollectibleHoverLabel = style({
color: color.Surface.OnContainer,
fontSize: toRem(12),
fontWeight: 500,
lineHeight: 1.3,
overflow: 'hidden',
textOverflow: 'ellipsis',
whiteSpace: 'nowrap',
});
export const CollectibleHoverMeta = style({
color: color.Surface.OnContainer,
fontSize: toRem(10),
lineHeight: 1.3,
opacity: 0.7,
overflow: 'hidden',
textOverflow: 'ellipsis',
whiteSpace: 'nowrap',
});
export const VariantRow = style({
display: 'flex',
flexWrap: 'wrap',
gap: toRem(4),
justifyContent: 'center',
padding: `0 ${toRem(2)}`,
});
export const VariantChip = style({
border: `${toRem(1)} solid ${color.Surface.ContainerLine}`,
borderRadius: toRem(4),
padding: 0,
background: color.Surface.Container,
cursor: 'pointer',
overflow: 'hidden',
flexShrink: 0,
});
export const VariantChipSelected = style({
border: `${toRem(2)} solid ${color.Primary.Main}`,
});
export const VariantChipNameplate = style({
width: toRem(28),
height: toRem(10),
borderRadius: toRem(3),
});
export const VariantChipThumbnail = style({
width: toRem(28),
height: toRem(28),
objectFit: 'cover',
display: 'block',
});
export const VariantChipDecorationStack = style({
position: 'relative',
width: toRem(28),
height: toRem(28),
display: 'block',
});
export const VariantChipDecorationAvatar = style({
width: '62.5%',
height: '62.5%',
borderRadius: '50%',
overflow: 'hidden',
position: 'absolute',
left: '50%',
top: '50%',
transform: 'translate(-50%, -50%)',
});
export const DecorationPreviewAvatar = style({
width: '100%',
height: '100%',
display: 'block',
objectFit: 'cover',
});
export const GridPreviewMedia = style({
width: '100%',
height: '100%',
objectFit: 'contain',
objectPosition: 'top center',
});
export const GridPreviewMediaCover = style({
width: '100%',
height: '100%',
objectFit: 'cover',
objectPosition: 'top center',
});
@@ -0,0 +1,543 @@
import React, { useCallback, useEffect, useMemo, useState } from 'react';
import classNames from 'classnames';
import { Box, Button, Input, Spinner, Text, color, toRem } from 'folds';
import { Icon, Icons } from '../../../components/icons';
import { useMatrixClient } from '../../../hooks/useMatrixClient';
import { useUserProfile } from '../../../hooks/useUserProfile';
import { useUserBanner } from '../../../hooks/useUserBanner';
import { useMediaAuthentication } from '../../../hooks/useMediaAuthentication';
import { mxcUrlToHttp } from '../../../utils/matrix';
import { UserAvatar } from '../../../components/user-avatar';
import {
CollectibleKind,
CollectibleVariantGroup,
DiscordCollectibleItem,
collectibleKindLabel,
defaultPreviewAspectRatio,
fetchPublishedCollectiblesCatalog,
groupCollectibleItems,
uploadCollectibleToMatrix,
variantItemLabel,
} from '../../../utils/discordCollectibles';
import { nameplatePaletteGradient } from '../../../utils/discordNameplatePalettes';
import {
AVATAR_DECORATION_INNER_PERCENT,
AvatarDecorationOverlay,
} from '../../../styles/AvatarDecoration.css';
import { pickCatalogStaticPreviewUrl } from '../../../utils/collectibleAssets';
import * as css from './CollectiblesSection.css';
import { CollectiblePreviewMedia } from './CollectiblePreviewMedia';
import { ProfileEffectHeroPreview } from './ProfileEffectHeroPreview';
import { StoredCollectible, CollectibleProfileFields } from '../../../utils/profileFields';
type CollectiblesSectionProps = {
collectibles: CollectibleProfileFields;
onApply: (kind: CollectibleKind, collectible: StoredCollectible | undefined) => Promise<void>;
};
const KIND_TABS: CollectibleKind[] = ['profile_effect', 'nameplate', 'avatar_decoration'];
const KIND_FIELD: Record<CollectibleKind, keyof CollectibleProfileFields> = {
profile_effect: 'profile_effect',
nameplate: 'nameplate',
avatar_decoration: 'avatar_decoration',
};
function getItemAspectRatio(item: DiscordCollectibleItem): number {
return item.previewAspectRatio ?? defaultPreviewAspectRatio(item.type);
}
function CollectiblePreview({
item,
kind,
previewAvatarUrl,
previewBannerUrl,
previewDisplayName,
previewUserId,
restartToken,
}: {
item: DiscordCollectibleItem;
kind: CollectibleKind;
previewAvatarUrl?: string;
previewBannerUrl?: string;
previewDisplayName?: string;
previewUserId: string;
restartToken: number;
}) {
if (kind === 'nameplate') {
const swatchBackground =
item.previewGradient || nameplatePaletteGradient(item.palette) || color.Surface.ContainerLine;
if (item.thumbnailUrl || item.assets.length > 0) {
return (
<CollectiblePreviewMedia
item={item}
className={css.NameplatePreview}
restartToken={restartToken}
/>
);
}
return (
<div className={css.NameplatePreviewFallback} style={{ background: swatchBackground }} />
);
}
if (kind === 'avatar_decoration') {
return (
<Box
style={{
position: 'relative',
width: `${AVATAR_DECORATION_INNER_PERCENT}%`,
aspectRatio: '1',
}}
>
<Box
style={{
width: '100%',
height: '100%',
borderRadius: '50%',
overflow: 'hidden',
backgroundColor: color.Surface.Container,
}}
>
<UserAvatar
className={css.DecorationPreviewAvatar}
userId={previewUserId}
src={previewAvatarUrl}
alt=""
renderFallback={() => <Icon size="300" src={Icons.User} filled />}
/>
</Box>
<CollectiblePreviewMedia
item={item}
className={AvatarDecorationOverlay}
restartToken={restartToken}
/>
</Box>
);
}
if (kind === 'profile_effect') {
return (
<ProfileEffectHeroPreview
item={item}
userId={previewUserId}
avatarUrl={previewAvatarUrl}
bannerUrl={previewBannerUrl}
displayName={previewDisplayName}
restartToken={restartToken}
/>
);
}
return null;
}
function VariantChip({
item,
kind,
selected,
previewAvatarUrl,
previewUserId,
onSelect,
}: {
item: DiscordCollectibleItem;
kind: CollectibleKind;
selected: boolean;
previewAvatarUrl?: string;
previewUserId: string;
onSelect: () => void;
}) {
const label = variantItemLabel(item);
if (kind === 'nameplate') {
const swatchBackground =
item.previewGradient || nameplatePaletteGradient(item.palette) || color.Surface.ContainerLine;
return (
<button
type="button"
className={classNames(css.VariantChip, selected && css.VariantChipSelected)}
onClick={onSelect}
title={label}
aria-label={label}
aria-pressed={selected}
>
<div className={css.VariantChipNameplate} style={{ background: swatchBackground }} />
</button>
);
}
if (kind === 'avatar_decoration') {
const thumbUrl = pickCatalogStaticPreviewUrl(item);
return (
<button
type="button"
className={classNames(css.VariantChip, selected && css.VariantChipSelected)}
onClick={onSelect}
title={label}
aria-label={label}
aria-pressed={selected}
>
<div className={css.VariantChipDecorationStack}>
<div className={css.VariantChipDecorationAvatar}>
<UserAvatar
className={css.DecorationPreviewAvatar}
userId={previewUserId}
src={previewAvatarUrl}
alt=""
renderFallback={() => <Icon size="100" src={Icons.User} filled />}
/>
</div>
{thumbUrl && (
<img
className={AvatarDecorationOverlay}
src={thumbUrl}
alt=""
draggable={false}
/>
)}
</div>
</button>
);
}
const thumbUrl = pickCatalogStaticPreviewUrl(item);
return (
<button
type="button"
className={classNames(css.VariantChip, selected && css.VariantChipSelected)}
onClick={onSelect}
title={label}
aria-label={label}
aria-pressed={selected}
>
{thumbUrl ? (
<img className={css.VariantChipThumbnail} src={thumbUrl} alt="" loading="lazy" />
) : (
<div className={css.VariantChipThumbnail} />
)}
</button>
);
}
function CollectibleVariantGroupCard({
group,
kind,
selectedItem,
onSelectItem,
applyingId,
onApply,
previewAvatarUrl,
previewBannerUrl,
previewDisplayName,
previewUserId,
}: {
group: CollectibleVariantGroup;
kind: CollectibleKind;
selectedItem: DiscordCollectibleItem;
onSelectItem: (item: DiscordCollectibleItem) => void;
applyingId?: string;
onApply: (item: DiscordCollectibleItem) => void;
previewAvatarUrl?: string;
previewBannerUrl?: string;
previewDisplayName?: string;
previewUserId: string;
}) {
const aspectRatio =
kind === 'profile_effect'
? css.PROFILE_HERO_PREVIEW_ASPECT_RATIO
: String(getItemAspectRatio(selectedItem));
const meta = [variantItemLabel(selectedItem), group.category].filter(Boolean).join(' · ');
const [restartToken, setRestartToken] = useState(0);
const handlePreviewHover = () => {
setRestartToken((token) => token + 1);
};
return (
<div className={css.CollectibleGroupCard}>
<button
type="button"
className={classNames(
css.CollectibleGroupPreview,
applyingId && css.CollectibleGroupPreviewDisabled,
applyingId && applyingId !== selectedItem.id && css.CollectibleGroupPreviewDimmed
)}
onMouseEnter={handlePreviewHover}
onClick={() => onApply(selectedItem)}
disabled={Boolean(applyingId)}
title={selectedItem.label}
aria-label={selectedItem.label}
>
<div
className={classNames(
css.CollectiblePreviewFrame,
kind === 'avatar_decoration' && css.CollectiblePreviewFrameDecoration,
kind === 'profile_effect' && css.CollectiblePreviewFrameProfileEffect
)}
style={{
aspectRatio: kind === 'nameplate' ? undefined : aspectRatio,
}}
>
<CollectiblePreview
item={selectedItem}
kind={kind}
previewAvatarUrl={previewAvatarUrl}
previewBannerUrl={previewBannerUrl}
previewDisplayName={previewDisplayName}
previewUserId={previewUserId}
restartToken={restartToken}
/>
</div>
<div className={css.CollectibleHoverCaption}>
<span className={css.CollectibleHoverLabel}>{selectedItem.label}</span>
<span className={css.CollectibleHoverMeta}>{meta}</span>
</div>
</button>
{group.items.length > 1 && (
<div className={css.VariantRow}>
{group.items.map((item) => (
<VariantChip
key={item.id}
item={item}
kind={kind}
selected={item.skuId === selectedItem.skuId}
previewAvatarUrl={previewAvatarUrl}
previewUserId={previewUserId}
onSelect={() => onSelectItem(item)}
/>
))}
</div>
)}
</div>
);
}
export function CollectiblesSection({ collectibles, onApply }: CollectiblesSectionProps) {
const mx = useMatrixClient();
const userId = mx.getUserId() ?? '';
const profile = useUserProfile(userId);
const [bannerMxc] = useUserBanner();
const useAuthentication = useMediaAuthentication();
const previewAvatarUrl = useMemo(
() =>
profile.avatarUrl
? mxcUrlToHttp(mx, profile.avatarUrl, useAuthentication, 96, 96, 'crop') ?? undefined
: undefined,
[mx, profile.avatarUrl, useAuthentication]
);
const previewBannerUrl = useMemo(
() =>
bannerMxc ? mxcUrlToHttp(mx, bannerMxc, useAuthentication) ?? undefined : undefined,
[bannerMxc, mx, useAuthentication]
);
const previewDisplayName = profile.displayName;
const [kind, setKind] = useState<CollectibleKind>('profile_effect');
const [catalogLoading, setCatalogLoading] = useState(false);
const [catalogError, setCatalogError] = useState<string>();
const [items, setItems] = useState<DiscordCollectibleItem[]>([]);
const [search, setSearch] = useState('');
const [applyingId, setApplyingId] = useState<string>();
const [applyProgress, setApplyProgress] = useState<string>();
const [error, setError] = useState<string>();
const [selectedByGroup, setSelectedByGroup] = useState<Record<string, string>>({});
const loadCatalog = useCallback(async (force = false) => {
setCatalogLoading(true);
setCatalogError(undefined);
try {
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));
}
} catch (e) {
setCatalogError(e instanceof Error ? e.message : 'Failed to load catalog.');
setItems([]);
}
setCatalogLoading(false);
}, []);
useEffect(() => {
loadCatalog();
}, [loadCatalog]);
const current = collectibles[KIND_FIELD[kind]];
const filteredGroups = useMemo(() => {
const query = search.trim().toLowerCase();
const filtered = items
.filter((item) => item.type === kind)
.filter((item) => {
if (!query) return true;
return (
item.name.toLowerCase().includes(query) ||
item.label.toLowerCase().includes(query) ||
item.category.toLowerCase().includes(query) ||
variantItemLabel(item).toLowerCase().includes(query)
);
});
return groupCollectibleItems(filtered);
}, [items, kind, search]);
useEffect(() => {
setSelectedByGroup((prev) => {
const next = { ...prev };
for (const group of filteredGroups) {
if (!next[group.id] || !group.items.some((item) => item.skuId === next[group.id])) {
next[group.id] = group.items[0]?.skuId ?? '';
}
}
return next;
});
}, [filteredGroups]);
const handleApply = async (item: DiscordCollectibleItem) => {
setApplyingId(item.id);
setError(undefined);
setApplyProgress(undefined);
try {
const stored = await uploadCollectibleToMatrix(mx, item, setApplyProgress);
await onApply(item.type, stored);
} catch (e) {
setError(e instanceof Error ? e.message : 'Failed to apply collectible.');
}
setApplyingId(undefined);
setApplyProgress(undefined);
};
const handleRemove = async () => {
setError(undefined);
try {
await onApply(kind, undefined);
} catch (e) {
setError(e instanceof Error ? e.message : 'Failed to remove collectible.');
}
};
const gridClassName = classNames(
css.CollectibleGroupGrid,
kind === 'nameplate' && css.CollectibleGroupGridNameplate,
kind === 'profile_effect' && css.CollectibleGroupGridEffects,
kind === 'avatar_decoration' && css.CollectibleGroupGridDecorations
);
return (
<Box direction="Column" gap="300">
<Text size="T200" style={{ opacity: 0.8 }}>
Browse a community-published Discord collectibles catalog, then download and upload only what
you pick to Matrix.
</Text>
<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>
<>
<Box gap="200" wrap="Wrap">
{KIND_TABS.map((tab) => (
<Button
key={tab}
size="300"
variant={tab === kind ? 'Primary' : 'Secondary'}
fill={tab === kind ? 'Solid' : 'Soft'}
radii="300"
onClick={() => setKind(tab)}
>
<Text size="B300">{collectibleKindLabel(tab)}</Text>
</Button>
))}
</Box>
<Input
size="300"
variant="Secondary"
style={{ width: '100%' }}
placeholder={`Search ${collectibleKindLabel(kind).toLowerCase()}s…`}
value={search}
onChange={(e) => setSearch(e.target.value)}
/>
{current && (
<Box gap="200" alignItems="Center" wrap="Wrap">
<Text size="T300">Active: {current.name}</Text>
<Button size="300" variant="Critical" fill="Soft" radii="300" onClick={handleRemove}>
<Text size="B300">Remove</Text>
</Button>
</Box>
)}
{catalogLoading && (
<Box gap="200" alignItems="Center">
<Spinner size="100" variant="Secondary" />
<Text size="T200">Loading collectibles catalog…</Text>
</Box>
)}
{catalogError && !catalogLoading && (
<Text size="T200" style={{ color: color.Critical.Main }}>{catalogError}</Text>
)}
{applyProgress && (
<Box gap="200" alignItems="Center">
<Spinner size="100" variant="Secondary" />
<Text size="T200">{applyProgress}</Text>
</Box>
)}
{error && <Text size="T200" style={{ color: color.Critical.Main }}>{error}</Text>}
<div className={gridClassName}>
{filteredGroups.map((group) => {
const selectedSku = selectedByGroup[group.id] ?? group.items[0]?.skuId;
const selectedItem =
group.items.find((item) => item.skuId === selectedSku) ?? group.items[0];
if (!selectedItem) return null;
return (
<CollectibleVariantGroupCard
key={group.id}
group={group}
kind={kind}
selectedItem={selectedItem}
onSelectItem={(item) =>
setSelectedByGroup((prev) => ({ ...prev, [group.id]: item.skuId }))
}
applyingId={applyingId}
onApply={handleApply}
previewAvatarUrl={previewAvatarUrl}
previewBannerUrl={previewBannerUrl}
previewDisplayName={previewDisplayName}
previewUserId={userId}
/>
);
})}
</div>
{!catalogLoading && filteredGroups.length === 0 && (
<Text size="T200" style={{ opacity: 0.7 }}>No items match your search.</Text>
)}
</>
</Box>
);
}
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,95 @@
import React from 'react';
import { Text } from 'folds';
import { UserAvatar } from '../../../components/user-avatar';
import { Icon, Icons } from '../../../components/icons';
import colorMXID from '../../../../util/colorMXID';
import { getMxIdLocalPart } from '../../../utils/matrix';
import { DiscordCollectibleItem } from '../../../utils/discordCollectibles';
import {
catalogProfileEffectIntroDurationMs,
pickCatalogProfileEffectIntroUrl,
pickCatalogProfileEffectLoopUrl,
} from '../../../utils/collectibleAssets';
import { ProfileEffectMedia } from '../../../components/user-profile/ProfileEffectMedia';
import * as css from './CollectiblesSection.css';
type ProfileEffectHeroPreviewProps = {
item: DiscordCollectibleItem;
userId: string;
avatarUrl?: string;
bannerUrl?: string;
displayName?: string;
profileColor?: string;
restartToken?: number;
};
export function ProfileEffectHeroPreview({
item,
userId,
avatarUrl,
bannerUrl,
displayName,
profileColor,
restartToken,
}: ProfileEffectHeroPreviewProps) {
const coverColor = colorMXID(userId);
const nameColor = profileColor ?? coverColor;
const username = getMxIdLocalPart(userId) ?? userId;
const resolvedName = displayName?.trim() || username;
const introUrl = pickCatalogProfileEffectIntroUrl(item);
const loopUrl = pickCatalogProfileEffectLoopUrl(item);
const introDurationMs = catalogProfileEffectIntroDurationMs(item);
return (
<div className={css.ProfileEffectHeroPreview} aria-hidden="true">
<div
className={css.ProfileEffectHeroCover}
style={{
backgroundColor: bannerUrl ? undefined : coverColor,
filter: bannerUrl || avatarUrl ? undefined : 'brightness(50%)',
}}
>
{bannerUrl ? (
<img className={css.ProfileEffectHeroBanner} src={bannerUrl} alt="" draggable={false} />
) : (
avatarUrl && (
<img className={css.ProfileEffectHeroCoverBlur} src={avatarUrl} alt="" draggable={false} />
)
)}
</div>
<div className={css.ProfileEffectHeroAvatarSlot}>
<div className={css.ProfileEffectHeroAvatar}>
<UserAvatar
className={css.ProfileEffectHeroAvatarImg}
userId={userId}
src={avatarUrl}
alt=""
renderFallback={() => <Icon size="300" src={Icons.User} filled />}
/>
</div>
</div>
<div className={css.ProfileEffectHeroInfo}>
<Text
size="T100"
className={css.ProfileEffectHeroName}
title={resolvedName}
style={{ color: nameColor }}
>
{resolvedName}
</Text>
</div>
<div className={css.ProfileEffectHeroEffectLayer}>
<ProfileEffectMedia
introUrl={introUrl}
loopUrl={loopUrl}
introDurationMs={introDurationMs}
restartToken={restartToken}
className={css.ProfileEffectHeroEffect}
/>
</div>
</div>
);
}
@@ -1,5 +1,6 @@
import React, { useCallback, useState } from 'react';
import { Box, Text, IconButton, Scroll, Switch, Button } from 'folds';
import { Box, Text, IconButton, Scroll, Switch, Button, Modal, Overlay, OverlayBackdrop, OverlayCenter } from 'folds';
import FocusTrap from 'focus-trap-react';
import { Icon, Icons } from '../../../components/icons';
import { Page, PageContent, PageHeader } from '../../../components/page';
import { SequenceCard } from '../../../components/sequence-card';
@@ -12,8 +13,12 @@ import {
AccountDataEditor,
AccountDataSubmitCallback,
} from '../../../components/AccountDataEditor';
import { TextViewer } from '../../../components/text-viewer';
import { copyToClipboard } from '../../../utils/dom';
import { stopPropagation } from '../../../utils/keyboard';
import { clearProfileCache } from '../../../utils/profileCache';
import { AccountData } from './AccountData';
import { ProfileFields } from './ProfileFields';
type DeveloperToolsProps = {
requestClose: () => void;
@@ -23,6 +28,67 @@ export function DeveloperTools({ requestClose }: DeveloperToolsProps) {
const [developerTools, setDeveloperTools] = useSetting(settingsAtom, 'developerTools');
const [expand, setExpend] = useState(false);
const [accountDataType, setAccountDataType] = useState<string | null>();
const [profileExpand, setProfileExpand] = useState(false);
const [profileUserId, setProfileUserId] = useState(mx.getUserId() ?? '');
const [profileFields, setProfileFields] = useState<Record<string, unknown>>({});
const [profileSupported, setProfileSupported] = useState(false);
const [profileFieldKey, setProfileFieldKey] = useState<string | null>();
const profileEditable = profileSupported && profileUserId.trim() === mx.getUserId();
const fetchProfileFields = useCallback(async (userId: string) => {
if (!userId) return;
try {
const supported = await mx.doesServerSupportExtendedProfiles();
setProfileSupported(supported);
setProfileFields(
supported
? await mx.getExtendedProfile(userId)
: ((await mx.getProfileInfo(userId)) as Record<string, unknown>),
);
} catch (err) {
console.error('Failed to fetch profile fields:', err);
setProfileSupported(false);
setProfileFields({});
}
}, [mx]);
const submitProfileField: AccountDataSubmitCallback = useCallback(
async (key, content) => {
await mx.setExtendedProfileProperty(key, content);
setProfileFields((prev) => ({ ...prev, [key]: content }));
// The rest of the client reads through the shared profile cache
clearProfileCache(profileUserId.trim());
},
[mx, profileUserId]
);
const deleteProfileField = useCallback(
async (key: string) => {
try {
await mx.deleteExtendedProfileProperty(key);
setProfileFields((prev) => {
const next = { ...prev };
delete next[key];
return next;
});
// The rest of the client reads through the shared profile cache
clearProfileCache(profileUserId.trim());
} catch (err) {
console.error('Failed to delete profile field:', err);
}
},
[mx, profileUserId]
);
const handleProfileExpand = useCallback(
(expand: boolean) => {
setProfileExpand(expand);
if (expand) fetchProfileFields(profileUserId.trim());
},
[fetchProfileFields, profileUserId]
);
const submitAccountData: AccountDataSubmitCallback = useCallback(
async (type, content) => {
@@ -42,6 +108,8 @@ export function DeveloperTools({ requestClose }: DeveloperToolsProps) {
);
}
const closeProfileField = useCallback(() => setProfileFieldKey(undefined), []);
return (
<Page>
<PageHeader outlined={false}>
@@ -109,6 +177,18 @@ export function DeveloperTools({ requestClose }: DeveloperToolsProps) {
</SequenceCard>
)}
</Box>
{developerTools && (
<ProfileFields
userId={profileUserId}
fields={profileFields}
editable={profileEditable}
expand={profileExpand}
onUserIdChange={setProfileUserId}
onExpandToggle={handleProfileExpand}
onSelect={setProfileFieldKey}
onDelete={deleteProfileField}
/>
)}
{developerTools && (
<AccountData
expand={expand}
@@ -120,6 +200,38 @@ export function DeveloperTools({ requestClose }: DeveloperToolsProps) {
</PageContent>
</Scroll>
</Box>
{profileFieldKey !== undefined && (
<Overlay open backdrop={<OverlayBackdrop />}>
<OverlayCenter>
<FocusTrap
focusTrapOptions={{
initialFocus: false,
clickOutsideDeactivates: true,
onDeactivate: closeProfileField,
escapeDeactivates: stopPropagation,
}}
>
<Modal size="500" variant="Surface">
{profileEditable ? (
<AccountDataEditor
type={profileFieldKey}
content={profileFields[profileFieldKey] as object}
submitChange={submitProfileField}
requestClose={closeProfileField}
/>
) : (
<TextViewer
name={profileFieldKey}
text={JSON.stringify(profileFields[profileFieldKey], null, 2)}
langName="json"
requestClose={closeProfileField}
/>
)}
</Modal>
</FocusTrap>
</OverlayCenter>
</Overlay>
)}
</Page>
);
}
@@ -0,0 +1,109 @@
import { Box, Text, Button, Input, MenuItem, IconButton } from 'folds';
import { Icon, Icons } from '../../../components/icons';
import { SequenceCard } from '../../../components/sequence-card';
import { SequenceCardStyle } from '../styles.css';
import { SettingTile } from '../../../components/setting-tile';
import { CutoutCard } from '../../../components/cutout-card';
type ProfileFieldsProps = {
userId: string;
fields: Record<string, unknown>;
editable: boolean;
expand: boolean;
onUserIdChange: (userId: string) => void;
onExpandToggle: (expand: boolean) => void;
onSelect: (key: string) => void;
onDelete: (key: string) => void;
};
export function ProfileFields({
userId,
fields,
editable,
expand,
onUserIdChange,
onExpandToggle,
onSelect,
onDelete,
}: ProfileFieldsProps) {
return (
<Box direction="Column" gap="100">
<Text size="L400">Public Profile Fields</Text>
<SequenceCard
className={SequenceCardStyle}
variant="SurfaceVariant"
direction="Column"
gap="400"
>
<SettingTile
title="Public Profile Fields"
description="Extended profile fields (MSC4133) as the server returns them, not through the client profile cache. Editable only when the user is you and the server supports MSC4133."
after={
<Button
onClick={() => onExpandToggle(!expand)}
variant="Secondary"
fill="Soft"
size="300"
radii="300"
outlined
before={
<Icon src={expand ? Icons.ChevronTop : Icons.ChevronBottom} size="100" filled />
}
>
<Text size="B300">{expand ? 'Collapse' : 'Expand'}</Text>
</Button>
}
/>
<Input
size="300"
variant="Secondary"
style={{ width: '100%' }}
value={userId}
onChange={(e) => onUserIdChange(e.target.value)}
placeholder="@user:server"
/>
{expand && (
<Box direction="Column" gap="100">
<Box justifyContent="SpaceBetween">
<Text size="L400">Fields</Text>
<Text size="L400">Total: {Object.keys(fields).length}</Text>
</Box>
<CutoutCard>
{Object.keys(fields).sort().map((key) => (
<MenuItem
key={key}
variant="Surface"
fill="None"
size="300"
radii="0"
after={
<Box gap="100" alignItems="Center">
{editable && (
<IconButton
size="200"
radii="Round"
title={`Delete ${key}`}
onClick={() => onDelete(key)}
>
<Icon size="50" src={Icons.Cross} />
</IconButton>
)}
<Icon size="50" src={Icons.ChevronRight} />
</Box>
}
onClick={() => onSelect(key)}
>
<Box grow="Yes">
<Text size="T200" truncate>
{key}
</Text>
</Box>
</MenuItem>
))}
</CutoutCard>
</Box>
)}
</SequenceCard>
</Box>
);
}
@@ -9,6 +9,7 @@ import React, {
import dayjs from 'dayjs';
import { as, Box, Button, Chip, color, config, Header, IconButton, Input, Menu, MenuItem, PopOut, RectCords, Scroll, Switch, Text, toRem } from 'folds';
import { useSetAtom } from 'jotai';
import { Range } from 'react-range';
import { Icon, Icons } from '../../../components/icons';
import { HexColorPicker } from 'react-colorful';
import { isKeyHotkey } from 'is-hotkey';
@@ -334,6 +335,66 @@ const emojiStyleNames: Record<EmojiStyle, string> = {
[EmojiStyle.Twemoji]: 'Twemoji',
};
function SidebarNameplate() {
const [sidebarNameplateOpacity, setSidebarNameplateOpacity] = useSetting(
settingsAtom,
'sidebarNameplateOpacity'
);
return (
<Box direction="Column" gap="100">
<Text size="L400">Collectibles</Text>
<SequenceCard className={SequenceCardStyle} variant="SurfaceVariant" direction="Column">
<SettingTile
title="Sidebar Nameplate Opacity"
description="Set to 0% to hide your equipped nameplate behind the bottom sidebar avatar."
after={
<Box gap="200" alignItems="Center" style={{ width: toRem(180) }}>
<Range
step={1}
min={0}
max={100}
values={[sidebarNameplateOpacity]}
onChange={(values) => setSidebarNameplateOpacity(values[0])}
renderTrack={(params) => (
<div
{...params.props}
style={{
...params.props.style,
width: '100%',
height: toRem(8),
borderRadius: toRem(4),
background: `linear-gradient(to right, ${color.Primary.Main} ${sidebarNameplateOpacity}%, ${color.Surface.ContainerLine} ${sidebarNameplateOpacity}%)`,
}}
>
{params.children}
</div>
)}
renderThumb={(params) => (
<div
{...params.props}
style={{
...params.props.style,
width: toRem(16),
height: toRem(16),
borderRadius: '50%',
backgroundColor: color.Primary.Main,
border: `${toRem(2)} solid ${color.Surface.Container}`,
}}
/>
)}
/>
<Text size="T300" style={{ minWidth: toRem(32), textAlign: 'right' }}>
{sidebarNameplateOpacity}%
</Text>
</Box>
}
/>
</SequenceCard>
</Box>
);
}
type EmojiStyleSelectorProps = {
selected: EmojiStyle;
onSelect: (style: EmojiStyle) => void;
@@ -1222,6 +1283,7 @@ export function General({ requestClose }: GeneralProps) {
<PageContent>
<Box direction="Column" gap="700">
<Appearance />
<SidebarNameplate />
<DateAndTime />
<Editor />
<Spaces />
@@ -126,6 +126,11 @@ export const SETTINGS_SEARCH_CATALOG: SettingsSearchEntry[] = [
},
{ page: SettingsPages.DeveloperToolsPage, title: 'Access Token', keywords: ['auth', 'secret'] },
{ page: SettingsPages.DeveloperToolsPage, title: 'Account Data', keywords: ['global', 'events'] },
{
page: SettingsPages.DeveloperToolsPage,
title: 'Public Profile Fields',
keywords: ['profile', 'msc4133', 'json'],
},
// About
{ page: SettingsPages.AboutPage, title: 'Clear Cache & Reload', keywords: ['reset', 'storage'] },
+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]);
};
+56 -280
View File
@@ -1,56 +1,16 @@
import { useCallback, useEffect, useState } from 'react';
import { MatrixClient, UserEvent, UserEventHandlerMap } from 'matrix-js-sdk';
import { useMatrixClient } from './useMatrixClient';
import { useMediaAuthentication } from './useMediaAuthentication';
import { mxcUrlToHttp } from '../utils/matrix';
import { getCurrentAccessToken } from '../utils/auth';
import {
fetchAndExtractMetadata,
extractMetadataFromImage,
embedMetadataInImage,
detectImageFormat,
getMimeType,
getExtension,
ImageMetadata,
convertImageDataToPng,
uint8ArrayToBlob,
} from '../utils/imageMetadata';
extractBannerUrlFromProfile,
deleteBannerUrl,
saveBannerUrl,
} from '../utils/profileFields';
import { getProfileFields, registerProfileCacheListener } from '../utils/profileCache';
import { getProfileAssetUrl } from '../utils/profileAssetCache';
/**
* Fetches the user's current avatar as raw image data
*/
async function fetchAvatarData(
mx: MatrixClient,
avatarMxc: string,
useAuthentication: boolean
): Promise<ArrayBuffer | null> {
const url = mxcUrlToHttp(mx, avatarMxc, useAuthentication);
if (!url) return null;
try {
// Always use current session's token to avoid stale tokens during account switches
const accessToken = getCurrentAccessToken();
let response = await fetch(url, {
method: 'GET',
headers: accessToken && useAuthentication ? { Authorization: `Bearer ${accessToken}` } : undefined,
});
// If we got a 401 and we tried with auth, fallback to unauthenticated request
if (!response.ok && response.status === 401 && accessToken && useAuthentication) {
response = await fetch(url, { method: 'GET' });
}
if (!response.ok) return null;
return await response.arrayBuffer();
} catch {
return null;
}
}
/**
* Hook to manage the user's chosen profile banner, stored in avatar image metadata
* The banner URL is embedded in avatar metadata and syncs via the avatar
* @returns The current banner URL, a setter function, and loading state
* Hook to manage the user's profile banner (MSC4427 via MSC4133).
*/
export function useUserBanner(): [
string | undefined,
@@ -58,280 +18,96 @@ export function useUserBanner(): [
boolean
] {
const mx = useMatrixClient();
const useAuthentication = useMediaAuthentication();
const [banner, setBanner] = useState<string | undefined>();
const [loading, setLoading] = useState(true);
// Extract banner from current avatar on mount and when profile changes
useEffect(() => {
const loadBanner = async () => {
setLoading(true);
try {
const userId = mx.getUserId();
if (!userId) {
setLoading(false);
return;
}
const profile = await mx.getProfileInfo(userId);
const avatarUrl = profile.avatar_url;
console.log('[useUserBanner.loadBanner] Loading banner from avatar:', avatarUrl);
if (!avatarUrl) {
setBanner(undefined);
setLoading(false);
return;
}
const httpUrl = mxcUrlToHttp(mx, avatarUrl, useAuthentication);
if (!httpUrl) {
setBanner(undefined);
setLoading(false);
return;
}
// Always use current session's token to avoid stale tokens during account switches
const accessToken = getCurrentAccessToken();
const metadata = await fetchAndExtractMetadata(httpUrl, useAuthentication ? accessToken : null);
console.log('[useUserBanner.loadBanner] Extracted banner:', metadata.banner);
setBanner(metadata.banner);
} catch {
setBanner(undefined);
}
setLoading(false);
};
loadBanner();
// Listen for avatar changes and reload banner
const userId = mx.getUserId();
if (!userId) return undefined;
const user = mx.getUser(userId);
const onAvatarChange: UserEventHandlerMap[UserEvent.AvatarUrl] = (newAvatarUrl) => {
console.log('[useUserBanner] Avatar changed event fired, new URL:', newAvatarUrl);
loadBanner();
};
user?.on(UserEvent.AvatarUrl, onAvatarChange);
return () => {
user?.removeListener(UserEvent.AvatarUrl, onAvatarChange);
};
}, [mx, useAuthentication]);
const updateBanner = useCallback(async (newBanner: string | undefined) => {
const userId = mx.getUserId();
if (!userId) {
throw new Error('No user ID');
setLoading(false);
return undefined;
}
const profile = await mx.getProfileInfo(userId);
const avatarUrl = profile.avatar_url;
let cancelled = false;
if (!avatarUrl) {
throw new Error('No avatar set. Please upload an avatar first.');
}
// Fetch current avatar
const avatarData = await fetchAvatarData(mx, avatarUrl, useAuthentication);
if (!avatarData) {
throw new Error('Failed to fetch current avatar');
}
// Detect image format — banner lives in PNG tEXt, so convert other formats first
let workingData: ArrayBuffer | Uint8Array = avatarData;
let format = detectImageFormat(workingData);
if (format === 'unknown') {
throw new Error('Unsupported avatar image format');
}
if (format !== 'png') {
console.log('[updateBanner] Converting', format, 'avatar to PNG for banner metadata');
const pngData = await convertImageDataToPng(workingData);
if (!pngData) {
throw new Error('Failed to convert avatar to PNG for banner metadata');
const load = async () => {
setLoading(true);
try {
const bannerMxc = extractBannerUrlFromProfile(await getProfileFields(mx, userId));
if (!cancelled) setBanner(bannerMxc);
} catch {
if (!cancelled) setBanner(undefined);
}
workingData = pngData;
format = 'png';
}
// Get existing metadata to preserve
const existingMetadata = extractMetadataFromImage(workingData);
console.log('[updateBanner] Existing metadata:', existingMetadata);
// Modify image metadata with new banner, preserving color.
// Empty string clears banner (PNG embed drops falsy fields after stripping old chunks).
const newMetadata: ImageMetadata = {
color: existingMetadata.color,
banner: newBanner ?? '',
avatarBorderColor: existingMetadata.avatarBorderColor,
gradient: existingMetadata.gradient,
if (!cancelled) setLoading(false);
};
console.log('[updateBanner] New metadata to embed:', newMetadata);
const newAvatarData = embedMetadataInImage(workingData, newMetadata);
load();
return () => {
cancelled = true;
};
}, [mx]);
if (!newAvatarData) {
throw new Error('Failed to embed banner in avatar metadata');
}
// Verify the banner was embedded correctly before uploading
const verifyMetadata = extractMetadataFromImage(newAvatarData);
console.log('[updateBanner] Verification - extracted metadata from new avatar:', verifyMetadata);
if ((newBanner || undefined) !== verifyMetadata.banner) {
console.error('[updateBanner] Banner verification FAILED!', 'Expected:', newBanner, 'Got:', verifyMetadata.banner);
throw new Error('Banner verification failed');
}
console.log('[updateBanner] Banner verification passed');
// Upload modified avatar with correct MIME type
const mimeType = getMimeType(format);
const extension = getExtension(format);
const blob = uint8ArrayToBlob(newAvatarData, mimeType);
const uploadResponse = await mx.uploadContent(blob, {
name: `avatar.${extension}`,
type: mimeType,
});
console.log('[updateBanner] Avatar uploaded successfully, MXC:', uploadResponse.content_uri);
// Update profile with new avatar
try {
console.log('[updateBanner] Setting avatar URL to:', uploadResponse.content_uri);
await Promise.race([
mx.setAvatarUrl(uploadResponse.content_uri),
new Promise((_, reject) => {
setTimeout(() => reject(new Error('setAvatarUrl timeout')), 30000);
})
]);
console.log('[updateBanner] setAvatarUrl completed');
// Manually sync user object to ensure event listeners are triggered
const user = mx.getUser(userId);
if (user && user.avatarUrl !== uploadResponse.content_uri) {
console.log('[updateBanner] Manually syncing user avatar URL');
user.setAvatarUrl(uploadResponse.content_uri);
const updateBanner = useCallback(
async (newBanner: string | undefined) => {
if (!newBanner) {
await deleteBannerUrl(mx);
setBanner(undefined);
return;
}
console.log('[updateBanner] Banner update complete');
} catch (error) {
throw new Error(`Failed to update avatar URL: ${error instanceof Error ? error.message : 'Unknown error'}`);
}
// Note: Don't set banner here - let the avatar change event handle it
// setBanner(newBanner);
}, [mx, useAuthentication]);
await saveBannerUrl(mx, newBanner);
setBanner(newBanner);
},
[mx]
);
return [banner, updateBanner, loading];
}
// Cache for user banners to avoid refetching for each message
const userBannerCache = new Map<string, { bannerMxc: string | undefined; timestamp: number }>();
const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
/**
* Hook to get another user's chosen profile banner from their avatar metadata
* @param userId - The user ID to get banner for
* @param avatarMxc - The user's avatar MXC URL
* @returns The user's chosen banner as a blob URL or undefined
* 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, avatarMxc: string | undefined): string | undefined {
export function useOtherUserBanner(userId: string): string | undefined {
const mx = useMatrixClient();
const useAuthentication = useMediaAuthentication();
const [bannerBlobUrl, setBannerBlobUrl] = useState<string | undefined>();
useEffect(() => {
let blobUrl: string | undefined;
if (!avatarMxc) {
console.log('[useOtherUserBanner] No avatarMxc provided for', userId);
if (!userId) {
setBannerBlobUrl(undefined);
return undefined;
}
const loadBanner = async () => {
console.log('[useOtherUserBanner] Loading banner for', userId, 'avatarMxc:', avatarMxc);
// Check cache first
const cacheKey = `${userId}:${avatarMxc}`;
const cached = userBannerCache.get(cacheKey);
let bannerMxc: string | undefined;
if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
// Use cached banner MXC
console.log('[useOtherUserBanner] Using cached bannerMxc:', cached.bannerMxc);
bannerMxc = cached.bannerMxc;
} else {
// Fetch banner MXC from avatar metadata
const httpUrl = mxcUrlToHttp(mx, avatarMxc, useAuthentication);
console.log('[useOtherUserBanner] Fetching metadata from:', httpUrl);
if (!httpUrl) {
console.log('[useOtherUserBanner] Failed to get HTTP URL');
setBannerBlobUrl(undefined);
return;
}
let cancelled = false;
// Always use current session's token to avoid stale tokens during account switches
const accessToken = getCurrentAccessToken();
const metadata = await fetchAndExtractMetadata(httpUrl, useAuthentication ? accessToken : null);
console.log('[useOtherUserBanner] Extracted metadata:', metadata);
bannerMxc = metadata.banner;
// Cache the banner MXC (not the blob URL)
userBannerCache.set(cacheKey, { bannerMxc, timestamp: Date.now() });
}
const load = async () => {
const fields = await getProfileFields(mx, userId);
if (cancelled) return;
const bannerMxc = extractBannerUrlFromProfile(fields);
if (!bannerMxc) {
console.log('[useOtherUserBanner] No banner MXC found');
setBannerBlobUrl(undefined);
return;
}
console.log('[useOtherUserBanner] Fetching banner image from MXC:', bannerMxc);
// Fetch the banner image data with authentication
const bannerHttpUrl = mxcUrlToHttp(mx, bannerMxc, useAuthentication);
if (!bannerHttpUrl) {
console.log('[useOtherUserBanner] Failed to convert banner MXC to HTTP URL');
setBannerBlobUrl(undefined);
return;
}
console.log('[useOtherUserBanner] Banner HTTP URL:', bannerHttpUrl);
// Always use current session's token to avoid stale tokens during account switches
const accessToken = getCurrentAccessToken();
const headers: HeadersInit = {};
if (useAuthentication && accessToken) {
headers.Authorization = `Bearer ${accessToken}`;
}
const response = await fetch(bannerHttpUrl, { headers });
if (!response.ok) {
setBannerBlobUrl(undefined);
return;
}
const blob = await response.blob();
blobUrl = URL.createObjectURL(blob);
setBannerBlobUrl(blobUrl);
const blobUrl = await getProfileAssetUrl(mx, bannerMxc, useAuthentication);
if (!cancelled) setBannerBlobUrl(blobUrl);
};
loadBanner();
const unsubscribe = registerProfileCacheListener((changedUserId) => {
if (changedUserId === userId) load();
});
load();
// Cleanup blob URL when component unmounts or deps change
return () => {
if (blobUrl) {
URL.revokeObjectURL(blobUrl);
}
cancelled = true;
unsubscribe();
};
}, [mx, useAuthentication, avatarMxc, userId]);
}, [mx, useAuthentication, userId]);
return bannerBlobUrl;
}
+131
View File
@@ -0,0 +1,131 @@
import { useCallback, useEffect, useState } from 'react';
import { useMatrixClient } from './useMatrixClient';
import { useMediaAuthentication } from './useMediaAuthentication';
import {
CollectibleProfileFields,
StoredCollectible,
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(): [
CollectibleProfileFields,
(kind: CollectibleKind, collectible: StoredCollectible | undefined) => Promise<void>,
boolean
] {
const mx = useMatrixClient();
const [collectibles, setCollectibles] = useState<CollectibleProfileFields>({});
const [loading, setLoading] = useState(true);
useEffect(() => {
const userId = mx.getUserId();
if (!userId) {
setLoading(false);
return undefined;
}
let cancelled = false;
const load = async () => {
setLoading(true);
try {
const data = extractCollectiblesFromProfile(await getProfileFields(mx, userId));
if (!cancelled) setCollectibles(data);
} catch {
if (!cancelled) setCollectibles({});
}
if (!cancelled) setLoading(false);
};
load();
return () => {
cancelled = true;
};
}, [mx]);
const updateCollectible = useCallback(
async (kind: CollectibleKind, collectible: StoredCollectible | undefined) => {
if (kind === 'profile_effect') {
await saveProfileEffect(mx, collectible);
} else if (kind === 'nameplate') {
await saveNameplate(mx, collectible);
} else {
await saveAvatarDecoration(mx, collectible);
}
clearProfileCache(mx.getUserId());
setCollectibles((prev) => ({ ...prev, [kind]: collectible }));
},
[mx]
);
return [collectibles, updateCollectible, loading];
}
/**
* 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 cached = getCachedProfileFields(userId);
return cached ? extractCollectiblesFromProfile(cached) : {};
});
const [assetUrls, setAssetUrls] = useState<Record<string, string | undefined>>({});
useEffect(() => {
if (!userId) {
setCollectibles({});
setAssetUrls({});
return undefined;
}
let cancelled = false;
const load = async () => {
const data = extractCollectiblesFromProfile(await getProfileFields(mx, userId));
if (cancelled) return;
setCollectibles(data);
const urls: Record<string, string | undefined> = {};
const entries = [
['profile_effect', data.profile_effect],
['nameplate', data.nameplate],
['avatar_decoration', data.avatar_decoration],
] as const;
for (const [kind, collectible] of entries) {
if (!collectible) continue;
for (const [role, mxc] of Object.entries(collectible.assets)) {
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;
unsubscribe();
};
}, [mx, useAuthentication, userId]);
return { ...collectibles, assetUrls };
}
+130 -289
View File
@@ -1,316 +1,157 @@
import { useCallback, useEffect, useState } from 'react';
import { MatrixClient, UserEvent, UserEventHandlerMap } from 'matrix-js-sdk';
import { Room } from 'matrix-js-sdk';
import { useMatrixClient } from './useMatrixClient';
import { useMediaAuthentication } from './useMediaAuthentication';
import { mxcUrlToHttp } from '../utils/matrix';
import { getCurrentAccessToken } from '../utils/auth';
import { ThemeKind, useTheme } from './useTheme';
import {
embedColorInImage,
extractColorFromImage,
removeColorFromImage,
fetchAndExtractColor,
detectImageFormat,
getMimeType,
getExtension,
uint8ArrayToBlob,
} from '../utils/imageMetadata';
ColorPreference,
deleteColorPreference,
extractColorPreferenceFromProfile,
extractMemberColorPreference,
hasColorPreference,
resolveColorForTheme,
saveColorPreference,
} from '../utils/profileFields';
import { getCachedProfileFields, getProfileFields, registerProfileCacheListener } from '../utils/profileCache';
/**
* Fetches the user's current avatar as raw image data
* Hook to manage the user's MSC4522 color preference on their global profile.
*/
async function fetchAvatarData(
mx: MatrixClient,
avatarMxc: string,
useAuthentication: boolean
): Promise<ArrayBuffer | null> {
const url = mxcUrlToHttp(mx, avatarMxc, useAuthentication);
if (!url) return null;
try {
// Always use current session's token to avoid stale tokens during account switches
const accessToken = getCurrentAccessToken();
let response = await fetch(url, {
method: 'GET',
headers: accessToken && useAuthentication ? { Authorization: `Bearer ${accessToken}` } : undefined,
});
// If we got a 401 and we tried with auth, fallback to unauthenticated request
if (!response.ok && response.status === 401 && accessToken && useAuthentication) {
console.warn('[fetchAvatarData] Auth failed (401), attempting unauthenticated fallback');
response = await fetch(url, { method: 'GET' });
}
if (!response.ok) return null;
return await response.arrayBuffer();
} catch {
return null;
}
}
/**
* Hook to manage the user's chosen profile color, stored in avatar image metadata
* The color is embedded in PNG tEXt chunk or WebP XMP chunk and syncs via the avatar
* @returns The current color, a setter function, and loading state
*/
export function useUserColor(): [
string | undefined,
(color: string | undefined) => Promise<void>,
export function useUserColorPreference(): [
ColorPreference | undefined,
(preference: ColorPreference | undefined) => Promise<void>,
boolean
] {
const mx = useMatrixClient();
const useAuthentication = useMediaAuthentication();
const [color, setColor] = useState<string | undefined>();
const [preference, setPreference] = useState<ColorPreference | undefined>();
const [loading, setLoading] = useState(true);
// Extract color from current avatar on mount and when profile changes
useEffect(() => {
const loadColor = async () => {
const userId = mx.getUserId();
if (!userId) {
setLoading(false);
return undefined;
}
let cancelled = false;
const load = async () => {
setLoading(true);
try {
const userId = mx.getUserId();
if (!userId) {
setLoading(false);
return;
}
const profile = await mx.getProfileInfo(userId);
const avatarUrl = profile.avatar_url;
if (!avatarUrl) {
setColor(undefined);
setLoading(false);
return;
}
const httpUrl = mxcUrlToHttp(mx, avatarUrl, useAuthentication);
if (!httpUrl) {
setColor(undefined);
setLoading(false);
return;
}
// Always use current session's token to avoid stale tokens during account switches
const accessToken = getCurrentAccessToken();
const extractedColor = await fetchAndExtractColor(httpUrl, useAuthentication ? accessToken : null);
setColor(extractedColor);
const loaded = extractColorPreferenceFromProfile(await getProfileFields(mx, userId));
if (!cancelled) setPreference(loaded);
} catch (e) {
console.error('Failed to load user color from avatar:', e);
setColor(undefined);
console.error('Failed to load color preference:', e);
if (!cancelled) setPreference(undefined);
}
setLoading(false);
if (!cancelled) setLoading(false);
};
loadColor();
// Listen for avatar changes and reload color
const userId = mx.getUserId();
if (!userId) return undefined;
const user = mx.getUser(userId);
const onAvatarChange: UserEventHandlerMap[UserEvent.AvatarUrl] = () => {
loadColor();
};
user?.on(UserEvent.AvatarUrl, onAvatarChange);
load();
return () => {
user?.removeListener(UserEvent.AvatarUrl, onAvatarChange);
cancelled = true;
};
}, [mx, useAuthentication]);
}, [mx]);
const updateColor = useCallback(async (newColor: string | undefined) => {
const userId = mx.getUserId();
if (!userId) return;
try {
const profile = await mx.getProfileInfo(userId);
const avatarUrl = profile.avatar_url;
if (!avatarUrl) {
// No avatar to embed color in
console.warn('Cannot set color: no avatar image set');
throw new Error('No avatar set');
}
// Fetch current avatar
const avatarData = await fetchAvatarData(mx, avatarUrl, useAuthentication);
if (!avatarData) {
console.error('Failed to fetch current avatar');
throw new Error('Failed to fetch avatar');
}
console.log('Original avatar size:', avatarData.byteLength, 'bytes');
// Detect image format
const format = detectImageFormat(avatarData);
console.log('Detected image format:', format);
if (format === 'unknown') {
console.error('Unsupported avatar image format - must be PNG, WebP, JPEG, or GIF');
throw new Error('Unsupported image format');
}
// Modify image metadata
let newAvatarData: Uint8Array | null;
if (newColor) {
newAvatarData = embedColorInImage(avatarData, newColor);
} else {
newAvatarData = removeColorFromImage(avatarData);
}
if (!newAvatarData) {
console.error('Failed to modify avatar image metadata');
throw new Error('Failed to modify image metadata');
}
console.log('Modified avatar size:', newAvatarData.byteLength, 'bytes');
// Verify the color was embedded correctly before uploading
const verifyColor = extractColorFromImage(newAvatarData);
console.log('Verification - embedded color:', verifyColor);
if (newColor && verifyColor !== newColor) {
console.error('Color verification failed! Expected:', newColor, 'Got:', verifyColor);
throw new Error('Color embedding verification failed');
}
// Upload modified avatar with correct MIME type
const mimeType = getMimeType(format);
const extension = getExtension(format);
const blob = uint8ArrayToBlob(newAvatarData, mimeType);
const uploadResponse = await mx.uploadContent(blob, {
name: `avatar.${extension}`,
type: mimeType,
});
console.log('Uploaded new avatar:', uploadResponse.content_uri);
// Update profile with new avatar
await mx.setAvatarUrl(uploadResponse.content_uri);
// Manually sync user object to ensure event listeners are triggered
const user = mx.getUser(userId);
if (user && user.avatarUrl !== uploadResponse.content_uri) {
user.setAvatarUrl(uploadResponse.content_uri);
}
setColor(newColor);
console.log('User color updated in avatar:', newColor);
} catch (e) {
console.error('Failed to update user color in avatar:', e);
throw e;
}
}, [mx, useAuthentication]);
return [color, updateColor, loading];
}
/**
* LRU Cache implementation with max size limit
*/
class LRUCache<K, V> {
private cache: Map<K, V>;
private maxSize: number;
constructor(maxSize: number) {
this.cache = new Map();
this.maxSize = maxSize;
}
get(key: K): V | undefined {
const value = this.cache.get(key);
if (value !== undefined) {
// Move to end (most recently used)
this.cache.delete(key);
this.cache.set(key, value);
}
return value;
}
set(key: K, value: V): void {
// If key exists, delete it first to re-add at end
if (this.cache.has(key)) {
this.cache.delete(key);
}
// If at max size, remove oldest (first) entry
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);
}
clear(): void {
this.cache.clear();
}
}
// LRU cache for user colors to avoid refetching for each message
const userColorCache = new LRUCache<string, { color: string | undefined; timestamp: number }>(100);
const CACHE_TTL_MS = 30 * 60 * 1000; // 30 minutes
/**
* Hook to get another user's chosen profile color from their avatar metadata
* @param userId - The user ID to get color for
* @param avatarMxc - The user's avatar MXC URL
* @returns The user's chosen color or undefined
*/
export function useOtherUserColor(userId: string, avatarMxc: string | undefined): string | undefined {
const mx = useMatrixClient();
const useAuthentication = useMediaAuthentication();
// Check cache synchronously BEFORE initializing state to avoid flash
const cacheKey = avatarMxc ? `${userId}:${avatarMxc}` : '';
const cachedEntry = cacheKey ? userColorCache.get(cacheKey) : undefined;
const cachedColor = cachedEntry && Date.now() - cachedEntry.timestamp < CACHE_TTL_MS
? cachedEntry.color
: undefined;
const [color, setColor] = useState<string | undefined>(cachedColor);
useEffect(() => {
if (!avatarMxc) {
console.log('[useOtherUserColor] No avatarMxc provided for', userId);
setColor(undefined);
return;
}
// Check cache first
const cacheKey = `${userId}:${avatarMxc}`;
const cached = userColorCache.get(cacheKey);
if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
console.log('[useOtherUserColor] Using cached color for', userId, ':', cached.color);
setColor(cached.color);
return;
}
const loadColor = async () => {
const httpUrl = mxcUrlToHttp(mx, avatarMxc, useAuthentication);
console.log('[useOtherUserColor] Loading color for', userId, 'from', httpUrl);
if (!httpUrl) {
console.log('[useOtherUserColor] Failed to get HTTP URL for', avatarMxc);
setColor(undefined);
const updatePreference = useCallback(
async (newPreference: ColorPreference | undefined) => {
if (!hasColorPreference(newPreference)) {
await deleteColorPreference(mx);
setPreference(undefined);
return;
}
// Always use current session's token to avoid stale tokens during account switches
const accessToken = getCurrentAccessToken();
const extractedColor = await fetchAndExtractColor(httpUrl, useAuthentication ? accessToken : null);
console.log('[useOtherUserColor] Extracted color for', userId, ':', extractedColor);
// Cache the result
userColorCache.set(cacheKey, { color: extractedColor, timestamp: Date.now() });
setColor(extractedColor);
};
await saveColorPreference(mx, newPreference!);
setPreference(newPreference);
},
[mx]
);
loadColor();
}, [mx, useAuthentication, avatarMxc, userId]);
return color;
return [preference, updatePreference, loading];
}
/**
* 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 [preference, setPreference] = useState<ColorPreference | undefined>(() => {
const cached = getCachedProfileFields(userId);
return cached ? extractColorPreferenceFromProfile(cached) : undefined;
});
useEffect(() => {
if (!userId) {
setPreference(undefined);
return undefined;
}
let cancelled = false;
const apply = (fields: Record<string, unknown>) => {
if (cancelled) return;
setPreference(extractColorPreferenceFromProfile(fields));
};
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]);
return preference;
}
/**
* MSC4522 per-room member color preference (overrides global profile when set).
*/
export function useMemberColorPreference(userId: string, room?: Room): ColorPreference | undefined {
const [preference, setPreference] = useState<ColorPreference | undefined>(() =>
extractMemberColorPreference(room, userId)
);
useEffect(() => {
setPreference(extractMemberColorPreference(room, userId));
}, [room, userId]);
return preference;
}
/**
* Resolve a user's username color for the active theme (MSC4522).
* Per-room member colors take precedence over global profile colors.
*/
export function useOtherUserColor(userId: string, room?: Room): string | undefined {
const theme = useTheme();
const profilePreference = useOtherUserColorPreference(userId);
const memberPreference = useMemberColorPreference(userId, room);
const preference = memberPreference ?? profilePreference;
return resolveColorForTheme(preference, theme.kind);
}
/**
* Resolve the current user's username color for the active theme.
*/
export function useUsernameColor(userId: string, room?: Room, themeKind?: ThemeKind): string | undefined {
const theme = useTheme();
const kind = themeKind ?? theme.kind;
const profilePreference = useOtherUserColorPreference(userId);
const memberPreference = useMemberColorPreference(userId, room);
const preference = memberPreference ?? profilePreference;
return resolveColorForTheme(preference, kind);
}
+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]);
-276
View File
@@ -1,276 +0,0 @@
import { useCallback, useEffect, useState } from 'react';
import { UserEvent, UserEventHandlerMap } from 'matrix-js-sdk';
import { useMatrixClient } from './useMatrixClient';
import { useMediaAuthentication } from './useMediaAuthentication';
import { mxcUrlToHttp } from '../utils/matrix';import { getCurrentAccessToken } from '../utils/auth';import {
fetchAndExtractMetadata,
extractMetadataFromImage,
embedMetadataInImage,
detectImageFormat,
getMimeType,
getExtension,
ImageMetadata,
ProfileGradient,
convertImageDataToPng,
uint8ArrayToBlob,
} from '../utils/imageMetadata';
/**
* Fetches the user's current avatar as raw image data
*/
async function fetchAvatarData(
mx: ReturnType<typeof useMatrixClient>,
avatarMxc: string,
useAuthentication: boolean
): Promise<ArrayBuffer | null> {
const url = mxcUrlToHttp(mx, avatarMxc, useAuthentication);
if (!url) return null;
try {
// Always use current session's token to avoid stale tokens during account switches
const accessToken = getCurrentAccessToken();
let response = await fetch(url, {
method: 'GET',
headers: accessToken && useAuthentication ? { Authorization: `Bearer ${accessToken}` } : undefined,
});
// If we got a 401 and we tried with auth, fallback to unauthenticated request
if (!response.ok && response.status === 401 && accessToken && useAuthentication) {
response = await fetch(url, { method: 'GET' });
}
if (!response.ok) return null;
return await response.arrayBuffer();
} catch {
return null;
}
}
export type ProfileStyleData = {
avatarBorderColor?: string;
gradient?: ProfileGradient;
};
/**
* Hook to manage the user's profile style (avatar border color and gradient)
* Stored in avatar image metadata
* @returns Current style data, a setter function, and loading state
*/
export function useUserProfileStyle(): [
ProfileStyleData,
(style: Partial<ProfileStyleData>) => Promise<void>,
boolean
] {
const mx = useMatrixClient();
const useAuthentication = useMediaAuthentication();
const [style, setStyle] = useState<ProfileStyleData>({});
const [loading, setLoading] = useState(true);
// Extract style from current avatar on mount and when profile changes
useEffect(() => {
const loadStyle = async () => {
setLoading(true);
try {
const userId = mx.getUserId();
if (!userId) {
setLoading(false);
return;
}
const profile = await mx.getProfileInfo(userId);
const avatarUrl = profile.avatar_url;
if (!avatarUrl) {
setStyle({});
setLoading(false);
return;
}
const httpUrl = mxcUrlToHttp(mx, avatarUrl, useAuthentication);
if (!httpUrl) {
setStyle({});
setLoading(false);
return;
}
// Always use current session's token to avoid stale tokens during account switches
const accessToken = getCurrentAccessToken();
const metadata = await fetchAndExtractMetadata(httpUrl, useAuthentication ? accessToken : null);
setStyle({
avatarBorderColor: metadata.avatarBorderColor,
gradient: metadata.gradient,
});
} catch {
setStyle({});
}
setLoading(false);
};
loadStyle();
// Listen for avatar changes and reload style
const userId = mx.getUserId();
if (!userId) return undefined;
const user = mx.getUser(userId);
const onAvatarChange: UserEventHandlerMap[UserEvent.AvatarUrl] = () => {
loadStyle();
};
user?.on(UserEvent.AvatarUrl, onAvatarChange);
return () => {
user?.removeListener(UserEvent.AvatarUrl, onAvatarChange);
};
}, [mx, useAuthentication]);
const updateStyle = useCallback(
async (newStyle: Partial<ProfileStyleData>) => {
const userId = mx.getUserId();
if (!userId) {
throw new Error('No user ID');
}
const profile = await mx.getProfileInfo(userId);
const avatarUrl = profile.avatar_url;
if (!avatarUrl) {
throw new Error('No avatar set. Please upload an avatar first.');
}
// Fetch current avatar
const avatarData = await fetchAvatarData(mx, avatarUrl, useAuthentication);
if (!avatarData) {
throw new Error('Failed to fetch current avatar');
}
// Border/gradient live in PNG tEXt — convert other formats first
let workingData: ArrayBuffer | Uint8Array = avatarData;
let format = detectImageFormat(workingData);
if (format === 'unknown') {
throw new Error('Unsupported avatar image format');
}
if (format !== 'png') {
const pngData = await convertImageDataToPng(workingData);
if (!pngData) {
throw new Error('Failed to convert avatar to PNG for style metadata');
}
workingData = pngData;
format = 'png';
}
// Get existing metadata to preserve
const existingMetadata = extractMetadataFromImage(workingData);
// Merge with new style
const newMetadata: ImageMetadata = {
...existingMetadata,
avatarBorderColor: newStyle.avatarBorderColor !== undefined ? newStyle.avatarBorderColor : existingMetadata.avatarBorderColor,
gradient: newStyle.gradient !== undefined ? newStyle.gradient : existingMetadata.gradient,
};
// Embed updated metadata
const newAvatarData = embedMetadataInImage(workingData, newMetadata);
if (!newAvatarData) {
throw new Error('Failed to embed style in avatar metadata');
}
// Upload modified avatar with correct MIME type
const mimeType = getMimeType(format);
const extension = getExtension(format);
const blob = uint8ArrayToBlob(newAvatarData, mimeType);
const uploadResponse = await mx.uploadContent(blob, {
name: `avatar.${extension}`,
type: mimeType,
});
// Update profile with new avatar
await mx.setAvatarUrl(uploadResponse.content_uri);
// Manually sync user object
const user = mx.getUser(userId);
if (user && user.avatarUrl !== uploadResponse.content_uri) {
user.setAvatarUrl(uploadResponse.content_uri);
}
// Update local state
setStyle((prev) => ({
...prev,
...newStyle,
}));
},
[mx, useAuthentication]
);
return [style, updateStyle, loading];
}
// Cache for other users' profile styles
const userStyleCache = new Map<string, { style: ProfileStyleData; timestamp: number }>();
const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
/**
* Hook to get another user's profile style from their avatar metadata
* @param userId - The user ID to get style for
* @param avatarMxc - The user's avatar MXC URL
* @returns The user's profile style data
*/
export function useOtherUserProfileStyle(userId: string, avatarMxc: string | undefined): ProfileStyleData {
const mx = useMatrixClient();
const useAuthentication = useMediaAuthentication();
const [style, setStyle] = useState<ProfileStyleData>({});
useEffect(() => {
if (!avatarMxc) {
console.log('[useOtherUserProfileStyle] No avatarMxc provided for', userId);
setStyle({});
return;
}
const loadStyle = async () => {
console.log('[useOtherUserProfileStyle] Loading style for', userId, 'avatarMxc:', avatarMxc);
// Check cache first
const cacheKey = `${userId}:${avatarMxc}`;
const cached = userStyleCache.get(cacheKey);
if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
console.log('[useOtherUserProfileStyle] Using cached style:', cached.style);
setStyle(cached.style);
return;
}
const httpUrl = mxcUrlToHttp(mx, avatarMxc, useAuthentication);
console.log('[useOtherUserProfileStyle] Fetching metadata from:', httpUrl);
if (!httpUrl) {
console.log('[useOtherUserProfileStyle] Failed to get HTTP URL');
setStyle({});
return;
}
// Always use current session's token to avoid stale tokens during account switches
const accessToken = getCurrentAccessToken();
const metadata = await fetchAndExtractMetadata(httpUrl, useAuthentication ? accessToken : null);
console.log('[useOtherUserProfileStyle] Extracted metadata:', metadata);
const styleData: ProfileStyleData = {
avatarBorderColor: metadata.avatarBorderColor,
gradient: metadata.gradient,
};
console.log('[useOtherUserProfileStyle] Final styleData:', styleData);
// Cache the result
userStyleCache.set(cacheKey, { style: styleData, timestamp: Date.now() });
setStyle(styleData);
};
loadStyle();
}, [mx, useAuthentication, avatarMxc, userId]);
return style;
}
+114
View File
@@ -0,0 +1,114 @@
import { useCallback, useEffect, useState } from 'react';
import { useMatrixClient } from './useMatrixClient';
import {
PROFILE_KEY_TYPING_VERB,
deleteTypingVerb,
parseTypingVerb,
saveTypingVerb,
} from '../utils/profileFields';
import {
getCachedProfileFields,
getProfileFields,
registerProfileCacheListener,
} from '../utils/profileCache';
/**
* Hook to manage the user's custom typing verb on their global profile.
*/
export function useUserTypingVerb(): [
string | undefined,
(verb: string | undefined) => Promise<void>,
boolean
] {
const mx = useMatrixClient();
const [verb, setVerb] = useState<string | undefined>();
const [loading, setLoading] = useState(true);
useEffect(() => {
const userId = mx.getUserId();
if (!userId) {
setLoading(false);
return undefined;
}
let cancelled = false;
const load = async () => {
setLoading(true);
try {
const fields = await getProfileFields(mx, userId);
const loaded = parseTypingVerb(fields[PROFILE_KEY_TYPING_VERB]);
if (!cancelled) setVerb(loaded);
} catch (e) {
console.error('Failed to load typing verb:', e);
if (!cancelled) setVerb(undefined);
}
if (!cancelled) setLoading(false);
};
load();
return () => {
cancelled = true;
};
}, [mx]);
const updateVerb = useCallback(
async (newVerb: string | undefined) => {
const parsed = parseTypingVerb(newVerb);
if (!parsed) {
await deleteTypingVerb(mx);
setVerb(undefined);
return;
}
await saveTypingVerb(mx, parsed);
setVerb(parsed);
},
[mx]
);
return [verb, updateVerb, loading];
}
/** Typing verb for a user already in the shared profile cache. */
export function getCachedTypingVerb(userId: string): string | undefined {
const fields = getCachedProfileFields(userId);
return fields ? parseTypingVerb(fields[PROFILE_KEY_TYPING_VERB]) : undefined;
}
/**
* Typing verbs for a group of users. Hooks cannot be called per typing user, so this
* reads the shared profile cache and re-renders when a cache entry arrives. Only cache
* misses are fetched.
*/
export function useTypingVerbs(userIds: string[]): Record<string, string | undefined> {
const mx = useMatrixClient();
const [, setTick] = useState(0);
const key = userIds.join(',');
useEffect(() => {
if (!key) return undefined;
let cancelled = false;
const unsubscribe = registerProfileCacheListener(() => setTick((tick) => tick + 1));
for (const userId of key.split(',')) {
if (getCachedProfileFields(userId)) continue;
// setProfileCache does not notify listeners, so a fresh fetch has to re-render here
getProfileFields(mx, userId)
.then(() => {
if (!cancelled) setTick((tick) => tick + 1);
})
.catch(() => undefined);
}
return () => {
cancelled = true;
unsubscribe();
};
}, [mx, key]);
const verbs: Record<string, string | undefined> = {};
for (const userId of userIds) verbs[userId] = getCachedTypingVerb(userId);
return verbs;
}
+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>
);
}
+4 -4
View File
@@ -58,6 +58,7 @@ import {
listenForAndroidShares,
materializeSharedFile,
} from '../../utils/androidShare';
import { UpdatesDialogHost } from '../../components/updates-dialog';
/**
* Applies the selected emoji style font to the document.
@@ -452,9 +453,7 @@ function MessageNotifications() {
function BackgroundSyncSetup() {
const mx = useMatrixClient();
// Try to make a simple fetch to verify component is rendering
try {
fetch('/_matrix/client/v3/sync', { method: 'HEAD' }).catch(() => {});
} catch {}
fetch('/_matrix/client/v3/sync', { method: 'HEAD' }).catch(() => {});
useEffect(() => {
console.log('BackgroundSyncSetup: Starting background sync for', mx.getUserId());
@@ -553,7 +552,7 @@ function AndroidShareIntentHandler() {
const originalFile = await materializeSharedFile(sharedFile, share.receivedAt);
let fileToUpload = originalFile;
let encInfo: any = undefined;
let encInfo: any;
if (room.hasEncryptionStateEvent()) {
const encrypted = await encryptFile(originalFile);
@@ -701,6 +700,7 @@ export function ClientNonUIFeatures({ children }: ClientNonUIFeaturesProps) {
<TaskbarFlashStopper />
<AndroidShareIntentHandler />
{children}
<UpdatesDialogHost />
</>
);
}
+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}>
+1 -1
View File
@@ -237,7 +237,7 @@ function NotificationItem({
relation?.rel_type === RelationType.Thread ? relation.event_id : undefined;
// Get custom user color from avatar metadata
const customUserColor = useOtherUserColor(event.sender, senderAvatarMxc);
const customUserColor = useOtherUserColor(event.sender, room);
const memberPowerTag = getMemberPowerTag(event.sender);
const tagColor = memberPowerTag?.color
+8 -1
View File
@@ -4,6 +4,7 @@ import React from 'react';
import { useAtom } from 'jotai';
import { SidebarAvatar, SidebarItem, SidebarItemTooltip } from '../../../components/sidebar';
import { searchModalAtom } from '../../../state/searchModal';
import * as sidebarCss from '../../../components/sidebar/Sidebar.css';
export function SearchTab() {
const [opened, setOpen] = useAtom(searchModalAtom);
@@ -14,7 +15,13 @@ export function SearchTab() {
<SidebarItem active={opened}>
<SidebarItemTooltip tooltip="Search">
{(triggerRef) => (
<SidebarAvatar as="button" ref={triggerRef} outlined onClick={open}>
<SidebarAvatar
as="button"
ref={triggerRef}
className={sidebarCss.SidebarSearchAvatar}
outlined
onClick={open}
>
<Icon src={Icons.Search} filled={opened} />
</SidebarAvatar>
)}
+55 -7
View File
@@ -11,6 +11,12 @@ import { nameInitials } from '../../../utils/common';
import { useMediaAuthentication } from '../../../hooks/useMediaAuthentication';
import { Settings } from '../../../features/settings';
import { useUserProfile } from '../../../hooks/useUserProfile';
import { useOtherUserCollectibles } from '../../../hooks/useUserCollectibles';
import { useSetting } from '../../../state/hooks/settings';
import { settingsAtom } from '../../../state/settings';
import { pickAvatarDecorationUrl, pickNameplateUrl } from '../../../utils/collectibleAssets';
import * as avatarDecorationCss from '../../../styles/AvatarDecoration.css';
import * as sidebarCss from '../../../components/sidebar/Sidebar.css';
import { Modal500 } from '../../../components/Modal500';
import { AccountSwitcher } from '../../../components/account-switcher';
import { stopPropagation } from '../../../utils/keyboard';
@@ -34,6 +40,13 @@ export function SettingsTab() {
const avatarUrl = profile.avatarUrl && userId
? mxcUrlToHttp(mx, profile.avatarUrl, useAuthentication, 96, 96, 'crop') ?? undefined
: undefined;
const { assetUrls } = useOtherUserCollectibles(userId ?? '');
const avatarDecorationUrl = pickAvatarDecorationUrl(assetUrls);
const nameplateUrl = pickNameplateUrl(assetUrls);
const [sidebarNameplateOpacity] = useSetting(settingsAtom, 'sidebarNameplateOpacity');
const nameplateIsVideo = Boolean(
assetUrls['nameplate:animated'] || assetUrls['nameplate:asset.webm']
);
const openSettings = () => setSettings(true);
const closeSettings = () => setSettings(false);
@@ -46,16 +59,51 @@ export function SettingsTab() {
return (
<SidebarItem active={settings}>
<SidebarAvatar
as="button"
<SidebarAvatar
as="button"
className={sidebarCss.SidebarAvatarLarge}
onClick={openSettings}
onContextMenu={handleContextMenu}
style={{ overflow: 'visible' }}
>
<UserAvatar
userId={userId ?? ''}
src={avatarUrl}
renderFallback={() => <Text size="H4">{nameInitials(displayName)}</Text>}
/>
<div className={avatarDecorationCss.SidebarAvatarStack}>
{sidebarNameplateOpacity > 0 &&
nameplateUrl &&
(nameplateIsVideo ? (
<video
className={sidebarCss.SidebarAvatarNameplate}
src={nameplateUrl}
style={{ opacity: sidebarNameplateOpacity / 100 }}
autoPlay
loop
muted
playsInline
aria-hidden="true"
/>
) : (
<img
className={sidebarCss.SidebarAvatarNameplate}
src={nameplateUrl}
style={{ opacity: sidebarNameplateOpacity / 100 }}
alt=""
draggable={false}
/>
))}
<UserAvatar
className={sidebarCss.SidebarAvatarForeground}
userId={userId ?? ''}
src={avatarUrl}
renderFallback={() => <Text size="H4">{nameInitials(displayName)}</Text>}
/>
{avatarDecorationUrl && (
<img
className={avatarDecorationCss.AvatarDecorationOverlay}
src={avatarDecorationUrl}
alt=""
draggable={false}
/>
)}
</div>
</SidebarAvatar>
<PopOut
+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);
};
+55
View File
@@ -0,0 +1,55 @@
import { atom } from 'jotai';
const LAST_SEEN_VERSION_KEY = 'paarrot:lastSeenVersion';
const PENDING_RELEASE_NOTES_KEY = 'paarrot:pendingReleaseNotes';
export type PendingReleaseNotes = {
version: string;
releaseNotes: unknown;
};
export type ReleaseNotesDialogState = {
open: boolean;
/** Opened from About instead of an automatic post-update prompt. */
manual: boolean;
};
export const releaseNotesDialogAtom = atom<ReleaseNotesDialogState>({
open: false,
manual: false,
});
export function getLastSeenAppVersion(): string | null {
return localStorage.getItem(LAST_SEEN_VERSION_KEY);
}
export function setLastSeenAppVersion(version: string): void {
localStorage.setItem(LAST_SEEN_VERSION_KEY, version);
}
export function storePendingReleaseNotes(version: string, releaseNotes: unknown): void {
try {
localStorage.setItem(
PENDING_RELEASE_NOTES_KEY,
JSON.stringify({ version, releaseNotes } satisfies PendingReleaseNotes)
);
} catch {
// ignore quota errors
}
}
export function getPendingReleaseNotes(): PendingReleaseNotes | null {
try {
const raw = localStorage.getItem(PENDING_RELEASE_NOTES_KEY);
if (!raw) return null;
const parsed = JSON.parse(raw) as PendingReleaseNotes;
if (typeof parsed?.version !== 'string') return null;
return parsed;
} catch {
return null;
}
}
export function clearPendingReleaseNotes(): void {
localStorage.removeItem(PENDING_RELEASE_NOTES_KEY);
}
+6
View File
@@ -50,6 +50,9 @@ export interface Settings {
encUrlPreview: boolean;
showHiddenEvents: boolean;
legacyUsernameColor: boolean;
sidebarNameplateOpacity: number;
codeWordWrap: boolean;
codeLineNumbers: boolean;
showNotifications: boolean;
isNotificationSounds: boolean;
@@ -93,6 +96,9 @@ const defaultSettings: Settings = {
encUrlPreview: false,
showHiddenEvents: false,
legacyUsernameColor: false,
sidebarNameplateOpacity: 60,
codeWordWrap: true,
codeLineNumbers: true,
showNotifications: true,
isNotificationSounds: true,
+29
View File
@@ -0,0 +1,29 @@
import { style } from '@vanilla-extract/css';
/** Discord presets are 128px canvases aligned to an ~80px avatar circle. */
export const AVATAR_DECORATION_SCALE_PERCENT = 119;
/** Inner avatar diameter as a fraction of the decoration canvas (80 / 128). */
export const AVATAR_DECORATION_INNER_PERCENT = 62.5;
export const AvatarDecorationOverlay = style({
position: 'absolute',
top: '50%',
left: '50%',
width: `${AVATAR_DECORATION_SCALE_PERCENT}%`,
height: `${AVATAR_DECORATION_SCALE_PERCENT}%`,
transform: 'translate(-50%, -50%)',
objectFit: 'contain',
pointerEvents: 'none',
zIndex: 2,
});
export const SidebarAvatarStack = style({
position: 'relative',
width: '100%',
height: '100%',
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
overflow: 'visible',
});
+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,
+10
View File
@@ -0,0 +1,10 @@
import { getVersion } from '@tauri-apps/api/app';
/** Returns the running app version (Electron shim or Tauri). */
export async function getAppVersion(): Promise<string> {
try {
return await getVersion();
} catch {
return 'unknown';
}
}
+102
View File
@@ -0,0 +1,102 @@
import { DiscordCollectibleItem } from './discordCollectibles';
function introDurationFromEffectMeta(effect: Record<string, unknown> | undefined): number | undefined {
if (!effect) return undefined;
const raw = effect.duration ?? effect.durationMs;
if (typeof raw !== 'number' || raw <= 0) return undefined;
return raw > 100 ? raw : raw * 1000;
}
function catalogAssetUrl(item: DiscordCollectibleItem, ...roles: string[]): string | undefined {
for (const role of roles) {
const asset = item.assets.find((entry) => entry.role === role);
if (asset?.url) return asset.url;
}
return undefined;
}
export function pickCatalogStaticPreviewUrl(item: DiscordCollectibleItem): string | undefined {
switch (item.type) {
case 'nameplate':
return catalogAssetUrl(item, 'static') ?? item.thumbnailUrl;
case 'avatar_decoration':
return catalogAssetUrl(item, 'static') ?? item.thumbnailUrl;
case 'profile_effect':
return catalogAssetUrl(item, 'thumbnail', 'reduced_motion') ?? item.thumbnailUrl;
default:
return item.thumbnailUrl;
}
}
export function pickCatalogAnimatedPreviewUrl(item: DiscordCollectibleItem): string | undefined {
switch (item.type) {
case 'nameplate':
return catalogAssetUrl(item, 'animated');
case 'avatar_decoration':
return catalogAssetUrl(item, 'animated');
case 'profile_effect':
return pickCatalogProfileEffectLoopUrl(item);
default:
return undefined;
}
}
export function pickCatalogProfileEffectIntroUrl(item: DiscordCollectibleItem): string | undefined {
return catalogAssetUrl(item, 'effect_0');
}
export function pickCatalogProfileEffectLoopUrl(item: DiscordCollectibleItem): string | undefined {
return catalogAssetUrl(item, 'effect_1', 'effect_0', 'effect_2', 'effect_3');
}
export function catalogProfileEffectIntroDurationMs(item: DiscordCollectibleItem): number | undefined {
const effect = item.effect?.effects?.[0] as Record<string, unknown> | undefined;
return introDurationFromEffectMeta(effect);
}
export function pickStoredProfileEffectIntroUrl(
assetUrls: Record<string, string | undefined>
): string | undefined {
return assetUrls['profile_effect:effect_0'];
}
export function pickStoredProfileEffectLoopUrl(
assetUrls: Record<string, string | undefined>
): string | undefined {
return (
assetUrls['profile_effect:effect_1'] ||
assetUrls['profile_effect:effect_0'] ||
assetUrls['profile_effect:effect_2'] ||
assetUrls['profile_effect:effect_3']
);
}
export function isCatalogVideoPreview(url?: string): boolean {
return Boolean(url && (url.includes('.webm') || url.includes('asset.webm')));
}
export function pickNameplateUrl(
assetUrls: Record<string, string | undefined>
): string | undefined {
return (
assetUrls['nameplate:animated'] ||
assetUrls['nameplate:asset.webm'] ||
assetUrls['nameplate:static'] ||
assetUrls['nameplate:static.png']
);
}
export function pickAvatarDecorationUrl(
assetUrls: Record<string, string | undefined>
): string | undefined {
return assetUrls['avatar_decoration:animated'] || assetUrls['avatar_decoration:animated.png'];
}
export function pickProfileEffectUrl(
assetUrls: Record<string, string | undefined>
): string | undefined {
return (
pickStoredProfileEffectLoopUrl(assetUrls) ||
assetUrls['profile_effect:reduced_motion']
);
}
+323
View File
@@ -0,0 +1,323 @@
import { MatrixClient } from 'matrix-js-sdk';
import { StoredCollectible } from './profileFields';
export type CollectibleKind = 'profile_effect' | 'nameplate' | 'avatar_decoration';
export type DiscordCollectibleAsset = {
role: string;
url: string;
filename: string;
mimeType: string;
};
export type DiscordCollectibleItem = {
id: string;
skuId: string;
name: string;
type: CollectibleKind;
category: string;
label: string;
thumbnailUrl?: string;
previewAspectRatio?: number;
previewColors?: number[];
previewGradient?: string;
palette?: string;
paletteLabel?: string;
assets: DiscordCollectibleAsset[];
effect?: {
animationType?: number;
thumbnailPreviewSrc?: string;
reducedMotionSrc?: string;
effects?: Array<Record<string, unknown>>;
};
};
export type DownloadedCollectibleAsset = DiscordCollectibleAsset & {
data: Uint8Array;
};
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;
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 {
if (typeof value !== 'string' || !value.startsWith('http')) return false;
try {
return CDN_HOST_RE.test(new URL(value).hostname);
} catch {
return false;
}
}
function replaceCdnUrls<T>(value: T, urlToMxc: Map<string, string>): T {
if (value == null) return value;
if (typeof value === 'string') {
return (isCdnUrl(value) && urlToMxc.has(value) ? urlToMxc.get(value) : value) as T;
}
if (Array.isArray(value)) {
return value.map((entry) => replaceCdnUrls(entry, urlToMxc)) as T;
}
if (typeof value === 'object') {
const out: Record<string, unknown> = {};
for (const [key, entry] of Object.entries(value as Record<string, unknown>)) {
out[key] = replaceCdnUrls(entry, urlToMxc);
}
return out as T;
}
return value;
}
export async function downloadCollectibleAssets(
assets: DiscordCollectibleAsset[]
): Promise<DownloadedCollectibleAsset[]> {
const api = window.electron?.discordCollectibles;
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),
}));
}
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(
mx: MatrixClient,
item: DiscordCollectibleItem,
onProgress?: (message: string) => void
): Promise<StoredCollectible> {
onProgress?.('Downloading from Discord…');
const downloaded = await downloadCollectibleAssets(item.assets);
const urlToMxc = new Map<string, string>();
const assets: Record<string, string> = {};
for (const asset of downloaded) {
onProgress?.(`Uploading ${asset.filename}…`);
const blob = new Blob([asset.data], { type: asset.mimeType });
const file = new File([blob], asset.filename, { type: asset.mimeType });
const response = await mx.uploadContent(file, {
name: asset.filename,
type: asset.mimeType,
includeFilename: true,
});
if (!response.content_uri) {
throw new Error(`Failed to upload ${asset.filename} to Matrix.`);
}
urlToMxc.set(asset.url, response.content_uri);
assets[asset.role] = response.content_uri;
}
const stored: StoredCollectible = {
sku_id: item.skuId,
name: item.name,
assets,
};
if (item.effect) {
stored.effect = replaceCdnUrls(item.effect, urlToMxc);
}
return stored;
}
export function collectibleKindLabel(kind: CollectibleKind): string {
switch (kind) {
case 'profile_effect':
return 'Profile effect';
case 'nameplate':
return 'Nameplate';
case 'avatar_decoration':
return 'Avatar decoration';
default:
return kind;
}
}
export type CollectibleVariantGroup = {
id: string;
name: string;
category: string;
items: DiscordCollectibleItem[];
};
function stripBundleSuffix(name: string): string {
return name.replace(/\s+Bundle$/i, '').trim();
}
function stripVariantSuffix(name: string): string {
return name.replace(/\s*\([^)]+\)\s*$/, '').trim();
}
export function variantGroupKey(item: DiscordCollectibleItem): string {
const baseName = stripVariantSuffix(stripBundleSuffix(item.name));
return `${item.type}:${baseName}`;
}
export function variantGroupDisplayName(item: DiscordCollectibleItem): string {
return stripVariantSuffix(stripBundleSuffix(item.name));
}
export function variantItemLabel(item: DiscordCollectibleItem): string {
if (item.paletteLabel) return item.paletteLabel;
const nameMatch = item.name.match(/\(([^)]+)\)\s*$/);
if (nameMatch) return nameMatch[1];
const labelMatch = item.label.match(/\(([^)]+)\)\s*$/);
if (labelMatch) return labelMatch[1];
if (item.label && item.label !== item.name) return item.label;
return 'Default';
}
function dedupeVariantItems(items: DiscordCollectibleItem[]): DiscordCollectibleItem[] {
const seen = new Set<string>();
return items.filter((item) => {
if (seen.has(item.skuId)) return false;
seen.add(item.skuId);
return true;
});
}
export function groupCollectibleItems(items: DiscordCollectibleItem[]): CollectibleVariantGroup[] {
const map = new Map<string, DiscordCollectibleItem[]>();
for (const item of items) {
const key = variantGroupKey(item);
const list = map.get(key);
if (list) list.push(item);
else map.set(key, [item]);
}
return [...map.entries()]
.map(([id, groupItems]) => {
const items = dedupeVariantItems(groupItems).sort((a, b) =>
variantItemLabel(a).localeCompare(variantItemLabel(b))
);
return {
id,
name: variantGroupDisplayName(items[0]),
category: items[0].category,
items,
};
})
.sort((a, b) => a.name.localeCompare(b.name));
}
export function defaultPreviewAspectRatio(kind: CollectibleKind): number {
switch (kind) {
case 'profile_effect':
return 450 / 880;
case 'nameplate':
return 448 / 84;
case 'avatar_decoration':
return 1;
default:
return 1;
}
}
export function gradientFromPreviewColors(colors?: number[]): string | undefined {
if (!colors?.length) return undefined;
const toRgb = (value: number) => {
const n = value >>> 0;
return `rgb(${(n >> 16) & 255}, ${(n >> 8) & 255}, ${n & 255})`;
};
if (colors.length === 1) return toRgb(colors[0]);
return `linear-gradient(135deg, ${toRgb(colors[0])}, ${toRgb(colors[1])})`;
}
+28
View File
@@ -0,0 +1,28 @@
/** Discord nameplate palette IDs from the API — mapped to representative gradient colors. */
const NAMEPLATE_PALETTE_GRADIENTS: Record<string, string> = {
crimson: 'linear-gradient(135deg, #5c0a1c, #dc143c)',
berry: 'linear-gradient(135deg, #4a1030, #c42d78)',
sky: 'linear-gradient(135deg, #0a2a5c, #3b8eed)',
teal: 'linear-gradient(135deg, #0a3d3d, #2dd4bf)',
forest: 'linear-gradient(135deg, #0a2e1a, #22c55e)',
bubble_gum: 'linear-gradient(135deg, #4a1038, #f472b6)',
violet: 'linear-gradient(135deg, #2d1050, #8b5cf6)',
cobalt: 'linear-gradient(135deg, #0a1448, #3b5bdb)',
clover: 'linear-gradient(135deg, #0a3d20, #4ade80)',
lemon: 'linear-gradient(135deg, #4a3d0a, #fbbf24)',
white: 'linear-gradient(135deg, #888888, #f0f0f0)',
black: 'linear-gradient(135deg, #1a1a1a, #404040)',
};
export function nameplatePaletteGradient(palette?: string): string | undefined {
if (!palette) return undefined;
return NAMEPLATE_PALETTE_GRADIENTS[palette];
}
export function formatNameplatePalette(palette?: string): string | undefined {
if (!palette) return undefined;
return palette
.split('_')
.map((part) => part.charAt(0).toUpperCase() + part.slice(1))
.join(' ');
}
+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);
}
}
+287
View File
@@ -0,0 +1,287 @@
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';
/** MSC4522 unstable profile field for username colors */
export const PROFILE_KEY_COLOR_PREFERENCE_UNSTABLE = 'eu.she-a.color';
/** MSC4427 unstable profile field for banner */
export const PROFILE_KEY_BANNER_URL_UNSTABLE = 'chat.commet.profile_banner';
/** MSC4427 stable profile field for banner */
export const PROFILE_KEY_BANNER_URL_STABLE = 'm.banner_url';
/** Paarrot profile effect (animated profile background) */
export const PROFILE_KEY_PROFILE_EFFECT = 'im.paarrot.profile_effect';
/** Paarrot nameplate (username bar background) */
export const PROFILE_KEY_NAMEPLATE = 'im.paarrot.nameplate';
/** Paarrot avatar decoration (avatar frame) */
export const PROFILE_KEY_AVATAR_DECORATION = 'im.paarrot.avatar_decoration';
/** Paarrot custom typing verb (shown in the typing indicator) */
export const PROFILE_KEY_TYPING_VERB = 'im.paarrot.typing_verb';
export const TYPING_VERB_PRESETS: string[] = [
'typing',
'cooking',
'thinking',
'plotting',
'brewing',
'sketching',
'humming',
'whispering',
'doodling',
'lurking',
'scheming',
'daydreaming',
];
const TYPING_VERB_MAX_LENGTH = 48;
/** Profile data arrives as unknown from the homeserver, so it is validated here. */
export function parseTypingVerb(value: unknown): string | undefined {
if (typeof value !== 'string') return undefined;
const verb = value
.replace(/[^a-zA-Z0-9 ]/g, '')
.replace(/ {2,}/g, ' ')
.trim();
if (!verb || verb.length > TYPING_VERB_MAX_LENGTH) return undefined;
return verb;
}
export type StoredCollectible = {
sku_id: string;
name: string;
assets: Record<string, string>;
effect?: unknown;
};
export type CollectibleProfileFields = {
profile_effect?: StoredCollectible;
nameplate?: StoredCollectible;
avatar_decoration?: StoredCollectible;
};
export type ColorPreference = {
on_dark?: string;
on_light?: string;
};
const HEX_COLOR_RE = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/;
export function isValidHexColor(color: string): boolean {
return HEX_COLOR_RE.test(color);
}
export function parseColorPreference(value: unknown): ColorPreference | undefined {
if (!value || typeof value !== 'object') return undefined;
const obj = value as Record<string, unknown>;
const on_dark = typeof obj.on_dark === 'string' && isValidHexColor(obj.on_dark) ? obj.on_dark : undefined;
const on_light = typeof obj.on_light === 'string' && isValidHexColor(obj.on_light) ? obj.on_light : undefined;
if (!on_dark && !on_light) return undefined;
return { on_dark, on_light };
}
export function extractColorPreferenceFromProfile(profile: Record<string, unknown>): ColorPreference | undefined {
const stable = parseColorPreference(profile[PROFILE_KEY_COLOR_PREFERENCE_STABLE]);
if (stable) return stable;
return parseColorPreference(profile[PROFILE_KEY_COLOR_PREFERENCE_UNSTABLE]);
}
export function resolveColorForTheme(
preference: ColorPreference | undefined,
themeKind: ThemeKind
): string | undefined {
if (!preference) return undefined;
if (themeKind === ThemeKind.Dark) {
return preference.on_dark ?? preference.on_light;
}
return preference.on_light ?? preference.on_dark;
}
export function hasColorPreference(preference: ColorPreference | undefined): boolean {
return Boolean(preference?.on_dark || preference?.on_light);
}
export function extractBannerUrlFromProfile(profile: Record<string, unknown>): string | undefined {
const stable = profile[PROFILE_KEY_BANNER_URL_STABLE];
if (typeof stable === 'string' && stable.startsWith('mxc://')) return stable;
const unstable = profile[PROFILE_KEY_BANNER_URL_UNSTABLE];
if (typeof unstable === 'string' && unstable.startsWith('mxc://')) return unstable;
return undefined;
}
function parseStoredCollectible(value: unknown): StoredCollectible | undefined {
if (!value || typeof value !== 'object') return undefined;
const obj = value as Record<string, unknown>;
const sku_id = typeof obj.sku_id === 'string' ? obj.sku_id : undefined;
const name = typeof obj.name === 'string' ? obj.name : undefined;
const assets = obj.assets;
if (!sku_id || !name || !assets || typeof assets !== 'object') return undefined;
const parsedAssets: Record<string, string> = {};
for (const [key, mxc] of Object.entries(assets as Record<string, unknown>)) {
if (typeof mxc === 'string' && mxc.startsWith('mxc://')) {
parsedAssets[key] = mxc;
}
}
if (Object.keys(parsedAssets).length === 0) return undefined;
return {
sku_id,
name,
assets: parsedAssets,
effect: obj.effect,
};
}
export function extractCollectiblesFromProfile(profile: Record<string, unknown>): CollectibleProfileFields {
return {
profile_effect: parseStoredCollectible(profile[PROFILE_KEY_PROFILE_EFFECT]),
nameplate: parseStoredCollectible(profile[PROFILE_KEY_NAMEPLATE]),
avatar_decoration: parseStoredCollectible(profile[PROFILE_KEY_AVATAR_DECORATION]),
};
}
export async function loadUserCollectibles(mx: MatrixClient, userId: string): Promise<CollectibleProfileFields> {
return extractCollectiblesFromProfile(await getProfileFields(mx, userId));
}
export async function saveCollectible(
mx: MatrixClient,
key: string,
collectible: StoredCollectible | undefined
): Promise<void> {
if (!(await mx.doesServerSupportExtendedProfiles())) {
throw new Error('Server does not support extended profile fields (MSC4133)');
}
if (!collectible) {
await mx.deleteExtendedProfileProperty(key);
return;
}
await mx.setExtendedProfileProperty(key, collectible);
}
export async function saveProfileEffect(mx: MatrixClient, collectible: StoredCollectible | undefined): Promise<void> {
await saveCollectible(mx, PROFILE_KEY_PROFILE_EFFECT, collectible);
}
export async function saveNameplate(mx: MatrixClient, collectible: StoredCollectible | undefined): Promise<void> {
await saveCollectible(mx, PROFILE_KEY_NAMEPLATE, collectible);
}
export async function saveAvatarDecoration(mx: MatrixClient, collectible: StoredCollectible | undefined): Promise<void> {
await saveCollectible(mx, PROFILE_KEY_AVATAR_DECORATION, collectible);
}
export async function getBannerUrlProfileKey(mx: MatrixClient): Promise<string> {
if (await mx.isVersionSupported('v1.16')) {
return PROFILE_KEY_BANNER_URL_STABLE;
}
return PROFILE_KEY_BANNER_URL_UNSTABLE;
}
export async function loadBannerUrl(mx: MatrixClient, userId: string): Promise<string | undefined> {
return extractBannerUrlFromProfile(await getProfileFields(mx, userId));
}
export async function saveBannerUrl(mx: MatrixClient, bannerMxc: string): Promise<void> {
if (!(await mx.doesServerSupportExtendedProfiles())) {
throw new Error('Server does not support extended profile fields (MSC4133)');
}
const key = await getBannerUrlProfileKey(mx);
await mx.setExtendedProfileProperty(key, bannerMxc);
const userId = mx.getUserId();
if (userId) clearProfileCache(userId);
}
export async function deleteBannerUrl(mx: MatrixClient): Promise<void> {
if (!(await mx.doesServerSupportExtendedProfiles())) {
throw new Error('Server does not support extended profile fields (MSC4133)');
}
const key = await getBannerUrlProfileKey(mx);
await mx.deleteExtendedProfileProperty(key);
const userId = mx.getUserId();
if (userId) clearProfileCache(userId);
}
export async function getColorPreferenceProfileKey(mx: MatrixClient): Promise<string> {
if (await mx.isVersionSupported('v1.16')) {
return PROFILE_KEY_COLOR_PREFERENCE_STABLE;
}
return PROFILE_KEY_COLOR_PREFERENCE_UNSTABLE;
}
export async function loadColorPreference(
mx: MatrixClient,
userId: string
): Promise<ColorPreference | undefined> {
return extractColorPreferenceFromProfile(await getProfileFields(mx, userId));
}
export function extractMemberColorPreference(room: Room | undefined, userId: string): ColorPreference | undefined {
if (!room || typeof (room as Room).getMember !== 'function' || !userId) return undefined;
const member = room.getMember(userId);
const content = member?.events.member?.getContent();
if (!content) return undefined;
return extractColorPreferenceFromProfile(content as Record<string, unknown>);
}
export async function saveColorPreference(mx: MatrixClient, preference: ColorPreference): Promise<void> {
if (!(await mx.doesServerSupportExtendedProfiles())) {
throw new Error('Server does not support extended profile fields (MSC4133)');
}
const key = await getColorPreferenceProfileKey(mx);
await mx.setExtendedProfileProperty(key, preference);
const userId = mx.getUserId();
if (userId) clearProfileCache(userId);
}
export async function deleteColorPreference(mx: MatrixClient): Promise<void> {
if (!(await mx.doesServerSupportExtendedProfiles())) {
throw new Error('Server does not support extended profile fields (MSC4133)');
}
const key = await getColorPreferenceProfileKey(mx);
await mx.deleteExtendedProfileProperty(key);
const userId = mx.getUserId();
if (userId) clearProfileCache(userId);
}
export async function saveTypingVerb(mx: MatrixClient, verb: string): Promise<void> {
if (!(await mx.doesServerSupportExtendedProfiles())) {
throw new Error('Server does not support extended profile fields (MSC4133)');
}
const value = parseTypingVerb(verb);
if (!value) throw new Error('Invalid typing verb');
await mx.setExtendedProfileProperty(PROFILE_KEY_TYPING_VERB, value);
const userId = mx.getUserId();
if (userId) clearProfileCache(userId);
}
export async function deleteTypingVerb(mx: MatrixClient): Promise<void> {
if (!(await mx.doesServerSupportExtendedProfiles())) {
throw new Error('Server does not support extended profile fields (MSC4133)');
}
await mx.deleteExtendedProfileProperty(PROFILE_KEY_TYPING_VERB);
const userId = mx.getUserId();
if (userId) clearProfileCache(userId);
}
+111
View File
@@ -0,0 +1,111 @@
import { registerMediaSaver } from './saveMedia';
import { isElectron, isTauri } from './tauri';
type ElectronSaveResult = {
success?: boolean;
canceled?: boolean;
path?: string;
error?: string;
};
type ElectronMediaApi = {
saveFile?: (payload: {
filename: string;
mimeType?: string;
data: Uint8Array;
}) => Promise<ElectronSaveResult>;
};
async function blobToUint8Array(blob: Blob): Promise<Uint8Array> {
const buffer = await blob.arrayBuffer();
return new Uint8Array(buffer);
}
function guessFilters(filename: string, mimeType?: string): Array<{ name: string; extensions: string[] }> {
const ext = filename.includes('.') ? filename.split('.').pop()!.toLowerCase() : '';
const mime = (mimeType || '').toLowerCase();
if (mime.startsWith('image/') || ['png', 'jpg', 'jpeg', 'gif', 'webp', 'bmp', 'svg'].includes(ext)) {
return [
{ name: 'Images', extensions: ['png', 'jpg', 'jpeg', 'gif', 'webp', 'bmp', 'svg'] },
{ name: 'All Files', extensions: ['*'] },
];
}
if (mime.startsWith('video/') || ['mp4', 'webm', 'mkv', 'mov'].includes(ext)) {
return [
{ name: 'Videos', extensions: ['mp4', 'webm', 'mkv', 'mov'] },
{ name: 'All Files', extensions: ['*'] },
];
}
if (mime.startsWith('audio/') || ['mp3', 'ogg', 'wav', 'm4a', 'flac'].includes(ext)) {
return [
{ name: 'Audio', extensions: ['mp3', 'ogg', 'wav', 'm4a', 'flac'] },
{ name: 'All Files', extensions: ['*'] },
];
}
if (mime === 'application/pdf' || ext === 'pdf') {
return [
{ name: 'PDF', extensions: ['pdf'] },
{ name: 'All Files', extensions: ['*'] },
];
}
if (ext) {
return [
{ name: ext.toUpperCase(), extensions: [ext] },
{ name: 'All Files', extensions: ['*'] },
];
}
return [{ name: 'All Files', extensions: ['*'] }];
}
async function saveWithElectron(blob: Blob, filename: string): Promise<void> {
const media = (window.electron as { media?: ElectronMediaApi } | undefined)?.media;
if (!media?.saveFile) {
throw new Error('Electron media.saveFile is unavailable');
}
const data = await blobToUint8Array(blob);
const result = await media.saveFile({
filename,
mimeType: blob.type || 'application/octet-stream',
data,
});
if (result?.canceled) return;
if (result?.success === false) {
throw new Error(result.error || 'Failed to save file');
}
}
async function saveWithTauri(blob: Blob, filename: string): Promise<void> {
const { save } = await import('@tauri-apps/plugin-dialog');
const { writeFile } = await import('@tauri-apps/plugin-fs');
const path = await save({
defaultPath: filename,
filters: guessFilters(filename, blob.type),
});
if (!path) return;
const data = await blobToUint8Array(blob);
await writeFile(path, data);
}
/**
* Wire Electron / Tauri native save dialogs into core saveMedia helpers.
* Call once at desktop app startup. No-ops in plain browser.
*/
export function registerDesktopMediaSaver(): void {
if (isElectron()) {
registerMediaSaver(async (blob, filename) => {
await saveWithElectron(blob, filename);
});
return;
}
if (isTauri()) {
registerMediaSaver(async (blob, filename) => {
await saveWithTauri(blob, filename);
});
}
}
+55
View File
@@ -0,0 +1,55 @@
import FileSaver from 'file-saver';
import { downloadMedia } from './matrix';
import { getCurrentAccessToken } from './auth';
export type MediaSaver = (blob: Blob, filename: string) => void | Promise<void>;
let customMediaSaver: MediaSaver | null = null;
const defaultMediaSaver: MediaSaver = (blob, filename) => {
FileSaver.saveAs(blob, filename);
};
/**
* Register a platform-specific media saver (Android MediaStore, Electron dialog, etc.).
* Pass null to restore the default FileSaver path.
*
* Platforms should call this once at startup (mobile overlay / desktop shell entry).
*/
export const registerMediaSaver = (saver: MediaSaver | null): void => {
customMediaSaver = saver;
};
/**
* Persist a Blob to disk via the registered platform saver, or FileSaver by default.
*/
export const saveMediaBlob = async (blob: Blob, filename: string): Promise<void> => {
const saver = customMediaSaver ?? defaultMediaSaver;
await saver(blob, filename);
};
/**
* Fetch media (auth download or blob:/data:/http URL) and save it via [saveMediaBlob].
*/
export const downloadAndSaveMedia = async (
src: string,
filename: string,
accessToken?: string | null
): Promise<void> => {
let blob: Blob;
try {
if (src.startsWith('blob:') || src.startsWith('data:')) {
const res = await fetch(src);
if (!res.ok) throw new Error(`Failed to fetch ${src}`);
blob = await res.blob();
} else {
blob = await downloadMedia(src, accessToken ?? getCurrentAccessToken());
}
} catch (error) {
console.warn('[saveMedia] downloadMedia failed, trying fetch fallback:', error);
const res = await fetch(src);
if (!res.ok) throw error;
blob = await res.blob();
}
await saveMediaBlob(blob, filename);
};

Some files were not shown because too many files have changed in this diff Show More