From 14f31f57c143dadeb2731c33764c14aa303b8979 Mon Sep 17 00:00:00 2001 From: litruv Date: Sun, 1 Nov 2026 01:24:59 +1100 Subject: [PATCH] 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. --- src/app/features/room/RoomViewTyping.tsx | 104 ++++++------- src/app/features/settings/account/Profile.tsx | 137 ++++++++++++++++++ src/app/hooks/useUserTypingVerb.ts | 114 +++++++++++++++ src/app/utils/profileFields.ts | 55 +++++++ 4 files changed, 349 insertions(+), 61 deletions(-) create mode 100644 src/app/hooks/useUserTypingVerb.ts diff --git a/src/app/features/room/RoomViewTyping.tsx b/src/app/features/room/RoomViewTyping.tsx index 49cb8289..c92c06d0 100644 --- a/src/app/features/room/RoomViewTyping.tsx +++ b/src/app/features/room/RoomViewTyping.tsx @@ -11,6 +11,12 @@ 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'; + +const joinNames = (parts: string[]): string => + parts.length === 1 ? parts[0] : `${parts.slice(0, -1).join(', ')} and ${parts[parts.length - 1]}`; export type RoomViewTypingProps = { room: Room; @@ -21,17 +27,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 +83,15 @@ export const RoomViewTyping = as<'div', RoomViewTypingProps>( > - {typingNames.length === 1 && ( - <> - {typingNames[0]} - - {' is typing...'} - - - )} - {typingNames.length === 2 && ( - <> - {typingNames[0]} - - {' and '} - - {typingNames[1]} - - {' are typing...'} - - - )} - {typingNames.length === 3 && ( - <> - {typingNames[0]} - - {', '} - - {typingNames[1]} - - {' and '} - - {typingNames[2]} - - {' are typing...'} - - - )} - {typingNames.length > 3 && ( - <> - {typingNames[0]} - - {', '} - - {typingNames[1]} - - {', '} - - {typingNames[2]} - - {' and '} - - {typingNames.length - 3} others - - {' are typing...'} - - - )} + {clauses.map((clause, index) => ( + + {index > 0 && (index === clauses.length - 1 ? ' and ' : ', ')} + {clause.name} + {!sharedSuffix && ` ${clause.suffix}`} + + ))} + {sharedSuffix} + {'...'} diff --git a/src/app/features/settings/account/Profile.tsx b/src/app/features/settings/account/Profile.tsx index f31b0b0a..18efe972 100644 --- a/src/app/features/settings/account/Profile.tsx +++ b/src/app/features/settings/account/Profile.tsx @@ -41,10 +41,14 @@ import { CollectiblesSection } from './CollectiblesSection'; import { useUserCollectibles } from '../../../hooks/useUserCollectibles'; import { pickAvatarDecorationUrl } from '../../../utils/collectibleAssets'; import * as avatarDecorationCss from '../../../styles/AvatarDecoration.css'; +import { useUserTypingVerb } from '../../../hooks/useUserTypingVerb'; +import { TypingIndicator } from '../../../components/typing-indicator'; import { ColorPreference, hasColorPreference, + parseTypingVerb, resolveColorForTheme, + TYPING_VERB_PRESETS, } from '../../../utils/profileFields'; /** @@ -142,6 +146,44 @@ function ProfileBanner({ avatarRef, nameRef }: { avatarRef: React.RefObject(); + + useEffect(() => { + setLocalVerb(typingVerb ?? ''); + }, [typingVerb]); + + const handleVerbSave = async () => { + const parsed = parseTypingVerb(localVerb); + if (!parsed) { + setVerbError('Use letters, numbers and single spaces only.'); + return; + } + + setSavingVerb(true); + setVerbError(undefined); + try { + await setTypingVerb(parsed); + } catch (e) { + setVerbError('Failed to save typing verb. Server may not support profile fields (MSC4133).'); + } + setSavingVerb(false); + }; + + const handleVerbRemove = async () => { + setSavingVerb(true); + setVerbError(undefined); + try { + await setTypingVerb(undefined); + setLocalVerb(''); + } catch (e) { + setVerbError('Failed to remove typing verb'); + } + setSavingVerb(false); + }; + const [isEditingName, setIsEditingName] = useState(false); const [editedName, setEditedName] = useState(profile.displayName || ''); const [savingName, setSavingName] = useState(false); @@ -1024,6 +1066,101 @@ function ProfileBanner({ avatarRef, nameRef }: { avatarRef: React.RefObject + {/* Paarrot custom typing verb */} + + Typing verb + + + {TYPING_VERB_PRESETS.map((preset) => ( + { + setLocalVerb(preset); + setVerbError(undefined); + }} + style={{ + backgroundColor: color.Surface.Container, + border: `${toRem(1)} solid ${color.Surface.ContainerLine}`, + padding: `${toRem(4)} ${toRem(8)}`, + borderRadius: toRem(16), + cursor: 'pointer', + }} + > + {preset} + + ))} + + + { + setLocalVerb(e.target.value); + setVerbError(undefined); + }} + placeholder="Custom typing verb..." + maxLength={48} + /> + + + + } + /> + + + + {profile.displayName || getMxIdLocalPart(userId)} + {` is ${parseTypingVerb(localVerb) ?? 'typing'}...`} + + + + + + {typingVerb && ( + + )} + + + {verbError && ( + {verbError} + )} + + Promise, + boolean +] { + const mx = useMatrixClient(); + const [verb, setVerb] = useState(); + 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 { + 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 = {}; + for (const userId of userIds) verbs[userId] = getCachedTypingVerb(userId); + return verbs; +} diff --git a/src/app/utils/profileFields.ts b/src/app/utils/profileFields.ts index 93908f11..ee325dbb 100644 --- a/src/app/utils/profileFields.ts +++ b/src/app/utils/profileFields.ts @@ -23,6 +23,38 @@ 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; @@ -230,3 +262,26 @@ export async function deleteColorPreference(mx: MatrixClient): Promise { const userId = mx.getUserId(); if (userId) clearProfileCache(userId); } + +export async function saveTypingVerb(mx: MatrixClient, verb: string): Promise { + 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 { + 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); +}