xonecas.io
8058
Ir

irvc / commit d4a861e

add typing indicators, add a chat settings section and a setting to enable/disable indicators, rejigger the appearance settings to make a bit more sense

Jason Moiron2026-10-20 d4a861e49f0f96557489b6f92536138a1c074f0e parent f25f378

8 files changed

typing_test.go+66−0
@@ -0,0 +1,66 @@
1+package main
2+
3+import (
4+ "path/filepath"
5+ "strings"
6+ "testing"
7+)
8+
9+func testClient(h *hub, id int64, name string) *client {
10+ c := &client{hub: h, userID: id, username: name, send: make(chan []byte, 8)}
11+ h.clients[id] = map[*client]bool{c: true}
12+ return c
13+}
14+
15+func got(c *client) bool { return len(c.send) > 0 }
16+
17+func drain(cs ...*client) {
18+ for _, c := range cs {
19+ for len(c.send) > 0 {
20+ <-c.send
21+ }
22+ }
23+}
24+
25+// Typing is relayed to everyone for a text channel, only to the two
26+// participants for a DM, and never faster than typingEvery per connection.
27+func TestTypingRelay(t *testing.T) {
28+ db := OpenDB(filepath.Join(t.TempDir(), "t.db"))
29+ h := newHub(db)
30+ a, b, outsider := testClient(h, 1, "a"), testClient(h, 2, "b"), testClient(h, 3, "c")
31+
32+ var text, dm int64
33+ db.QueryRow(`SELECT id FROM channels WHERE type = 'text' LIMIT 1`).Scan(&text)
34+ res, err := db.Exec(`INSERT INTO channels (type, name, position, created_at) VALUES ('dm', 'u:1:2', 0, 0)`)
35+ if err != nil {
36+ t.Fatal(err)
37+ }
38+ dm, _ = res.LastInsertId()
39+
40+ h.typing(a, text)
41+ if !got(a) || !got(b) || !got(outsider) {
42+ t.Fatal("text channel typing should reach everyone")
43+ }
44+ if ev := string(<-b.send); !strings.Contains(ev, `"username":"a"`) {
45+ t.Fatalf("unexpected event %s", ev)
46+ }
47+
48+ h.typing(a, text) // within typingEvery
49+ if got(b) {
50+ t.Fatal("typing events should be rate limited per connection")
51+ }
52+
53+ drain(a, b, outsider)
54+ a.typedAt = a.typedAt.Add(-2 * typingEvery)
55+ h.typing(a, dm)
56+ if !got(b) || got(outsider) {
57+ t.Fatal("DM typing should reach only its participants")
58+ }
59+
60+ outsider.typedAt = outsider.typedAt.Add(-2 * typingEvery)
61+ drain(a, b, outsider)
62+ h.typing(outsider, dm)
63+ if got(b) || got(a) {
64+ t.Fatal("a non-participant must not be able to type into a DM")
65+ }
66+}
web/src/components/Composer.tsx+3−0
@@ -21,11 +21,13 @@ export default function Composer({
2121 users,
2222 onEditLast,
2323 onCollapseImages,
24+ onTyping,
2425 }: {
2526 channel: Channel;
2627 users: UserSummary[];
2728 onEditLast: () => void;
2829 onCollapseImages: () => void;
30+ onTyping: () => void;
2931 }) {
3032 const [body, setBody] = useState("");
3133 const [mention, setMention] = useState<{ query: string; start: number; index: number } | null>(
@@ -238,6 +240,7 @@ export default function Composer({
238240 value={body}
239241 onChange={(e) => {
240242 setBody(e.target.value);
243+ if (e.target.value.trim()) onTyping();
241244 detectMention(e.target.value, e.target.selectionStart ?? e.target.value.length);
242245 }}
243246 onKeyDown={onKeyDown}
web/src/lib/settings.ts+2−0
@@ -26,6 +26,7 @@ export interface Settings {
2626 deafened: boolean;
2727 gateThreshold: number;
2828 joinSound: boolean;
29+ typingIndicator: boolean;
2930 ringSound: boolean;
3031 screenShareQuality: ScreenShareQuality;
3132 fontSize: FontSize;
@@ -42,6 +43,7 @@ export const defaultSettings: Settings = {
4243 deafened: false,
4344 gateThreshold: -60,
4445 joinSound: true,
46+ typingIndicator: true,
4547 ringSound: true,
4648 screenShareQuality: "720p",
4749 fontSize: "normal",
web/src/lib/theme.ts+35−12
@@ -33,16 +33,21 @@ export const tokenLabels: Record<Token, string> = {
3333 danger: "danger",
3434 };
3535
36+// "custom" is not a palette of its own: it layers the user's color overrides on
37+// top of `base`, the built-in palette that was active when custom was chosen.
3638 export const presets = [
3739 { id: "nicotine", label: "80s nicotine" },
3840 { id: "tuxedo", label: "tuxedo" },
41+ { id: "custom", label: "custom" },
3942 ] as const;
4043
4144 export type PresetId = (typeof presets)[number]["id"];
45+export type BasePreset = Exclude<PresetId, "custom">;
4246
4347 export interface ThemePrefs {
4448 mode: Mode;
4549 preset: PresetId;
50+ base: BasePreset;
4651 overrides: Record<Mode, Partial<Record<Token, string>>>;
4752 // Experimental: the terminal scheme the palette was seeded from (name, plus
4853 // the colors it contributes to skittles), and per-username colors.
@@ -55,6 +60,7 @@ const key = "irvc.theme";
5560 export const defaultPrefs: ThemePrefs = {
5661 mode: "light",
5762 preset: "nicotine",
63+ base: "nicotine",
5864 overrides: { light: {}, dark: {} },
5965 scheme: null,
6066 skittles: false,
@@ -79,31 +85,45 @@ export function loadPrefs(): ThemePrefs {
7985 if (presets.some((p) => p.id === raw)) return { ...defaultPrefs, preset: raw as PresetId };
8086 if (!raw || typeof raw !== "object") return { ...defaultPrefs, mode: systemMode() };
8187 const p = raw as Partial<ThemePrefs>;
88+ const mode: Mode = p.mode === "dark" ? "dark" : "light";
89+ const overrides = { light: p.overrides?.light ?? {}, dark: p.overrides?.dark ?? {} };
90+ let preset: PresetId = presets.some((x) => x.id === p.preset) ? (p.preset as PresetId) : defaultPrefs.preset;
91+ let base: BasePreset = p.base === "tuxedo" || p.base === "nicotine" ? p.base : defaultPrefs.base;
92+ // Overrides used to sit on top of any preset. They now only exist under
93+ // "custom", so a saved palette with edits becomes a custom one.
94+ if (preset !== "custom" && Object.keys(overrides[mode]).length > 0) {
95+ base = preset;
96+ preset = "custom";
97+ }
8298 return {
83- mode: p.mode === "dark" ? "dark" : "light",
84- preset: presets.some((x) => x.id === p.preset) ? (p.preset as PresetId) : defaultPrefs.preset,
85- overrides: { light: p.overrides?.light ?? {}, dark: p.overrides?.dark ?? {} },
99+ mode,
100+ preset,
101+ base,
102+ overrides,
86103 scheme: p.scheme?.name && Array.isArray(p.scheme.colors) ? p.scheme : null,
87104 skittles: p.skittles === true,
88105 };
89106 }
90107
108+// basePalette is the built-in palette whose CSS is in effect.
109+const basePalette = (p: ThemePrefs): BasePreset => (p.preset === "custom" ? p.base : p.preset);
110+
91111 // applyTheme writes the mode class, the preset attribute and the user's
92112 // overrides onto <html>. The palettes themselves live in CSS, so switching
93113 // preset is a single attribute change.
94114 export function applyTheme(prefs: ThemePrefs) {
95115 const el = document.documentElement;
96116 el.classList.toggle("dark", prefs.mode === "dark");
97- el.dataset.preset = prefs.preset;
117+ el.dataset.preset = basePalette(prefs);
98118 for (const t of TOKENS) {
99- const v = prefs.overrides[prefs.mode][t];
119+ const v = prefs.preset === "custom" ? prefs.overrides[prefs.mode][t] : undefined;
100120 if (v) el.style.setProperty(cssVar(t), v);
101121 else el.style.removeProperty(cssVar(t));
102122 }
103123 // Skittles: --user-N are only defined while it is on; userColor() falls back
104124 // to the accent otherwise. Needs the resolved bg/fg, hence after the loop.
105125 const colors = prefs.skittles
106- ? skittlesPalette(prefs.scheme?.colors, effective("bg"), effective("fg"), prefs.preset)
126+ ? skittlesPalette(prefs.scheme?.colors, effective("bg"), effective("fg"), basePalette(prefs))
107127 : [];
108128 for (let i = 0; i < SKITTLES; i++) {
109129 if (colors[i]) el.style.setProperty(`--user-${i}`, colors[i]);
@@ -154,7 +174,12 @@ export function useTheme() {
154174 const setMode = useCallback((mode: Mode) => setPrefs((p) => ({ ...p, mode })), []);
155175 const setPreset = useCallback(
156176 (preset: PresetId) =>
157- setPrefs((p) => ({ ...p, preset, scheme: null, overrides: { light: {}, dark: {} } })),
177+ setPrefs((p) => {
178+ if (preset === p.preset) return p;
179+ // Custom starts from whatever built-in palette (and mode) is showing.
180+ const base = preset === "custom" ? basePalette(p) : p.base;
181+ return { ...p, preset, base, scheme: null, overrides: { light: {}, dark: {} } };
182+ }),
158183 [],
159184 );
160185 const setToken = useCallback(
@@ -165,10 +190,6 @@ export function useTheme() {
165190 })),
166191 [],
167192 );
168- const resetTokens = useCallback(
169- () => setPrefs((p) => ({ ...p, scheme: null, overrides: { ...p.overrides, [p.mode]: {} } })),
170- [],
171- );
172193 // A scheme is dark or light by nature, so applying one switches to that mode
173194 // and overrides every token there; the other mode keeps its palette.
174195 const setScheme = useCallback(
@@ -178,6 +199,8 @@ export function useTheme() {
178199 return {
179200 ...p,
180201 mode,
202+ preset: "custom",
203+ base: basePalette(p),
181204 scheme: { name: s.n, colors: schemeColors(s) },
182205 overrides: { ...p.overrides, [mode]: toPalette(s) },
183206 };
@@ -186,5 +209,5 @@ export function useTheme() {
186209 );
187210 const setSkittles = useCallback((skittles: boolean) => setPrefs((p) => ({ ...p, skittles })), []);
188211
189- return { prefs, setMode, setPreset, setToken, resetTokens, setScheme, setSkittles };
212+ return { prefs, setMode, setPreset, setToken, setScheme, setSkittles };
190213 }
web/src/lib/types.ts+3−1
@@ -53,11 +53,13 @@ export interface WSEvent {
5353 | "channel"
5454 | "channel_delete"
5555 | "ring"
56- | "ring_end";
56+ | "ring_end"
57+ | "typing";
5758 message?: Message;
5859 users?: string[];
5960 roster?: UserSummary[];
6061 voice?: Record<string, VoiceOccupant[]>;
6162 channel?: Channel;
6263 channelId?: number;
64+ username?: string;
6365 }
web/src/views/Chat.tsx+69−0
@@ -56,6 +56,20 @@ function loadLastChannel(userId: number): number | null {
5656 }
5757 }
5858
59+// How long a "typing" event keeps someone listed. Clients resend every few
60+// seconds while typing, so this only has to outlast that gap.
61+const typingTtl = 5_000;
62+const typingEvery = 3_000;
63+
64+// typingLabel is the line shown under the message list.
65+function typingLabel(names: string[]) {
66+ if (names.length === 0) return "";
67+ if (names.length === 1) return `${names[0]} is typing…`;
68+ if (names.length === 2) return `${names[0]} and ${names[1]} are typing…`;
69+ if (names.length === 3) return `${names[0]}, ${names[1]} and ${names[2]} are typing…`;
70+ return "several people are typing…";
71+}
72+
5973 export default function Chat({ user, onLogout }: { user: User; onLogout: () => void }) {
6074 const [channels, setChannels] = useState<Channel[]>([]);
6175 const [hiddenDms, setHiddenDms] = useState<number[]>(loadHiddenDms);
@@ -80,6 +94,9 @@ export default function Chat({ user, onLogout }: { user: User; onLogout: () => v
8094 // thing we told it and replay that on every (re)connect.
8195 const voiceState = useRef<VoiceState>({ channelId: 0, muted: false, deafened: false });
8296 const { settings, update } = useSettings();
97+ // channel id -> username -> when we last heard them type
98+ const [typing, setTyping] = useState<Record<number, Record<string, number>>>({});
99+ const lastTypingSent = useRef({ channel: 0, at: 0 });
83100
84101 const markRead = useCallback((id: number) => {
85102 setUnread((u) => {
@@ -119,10 +136,22 @@ export default function Chat({ user, onLogout }: { user: User; onLogout: () => v
119136 if (c) open(c);
120137 })
121138 .catch(() => {});
139+ } else if (ev.type === "typing") {
140+ if (!settings.typingIndicator || !ev.channelId || !ev.username) return;
141+ if (ev.username === user.username) return;
142+ setTyping((t) => ({
143+ ...t,
144+ [ev.channelId!]: { ...t[ev.channelId!], [ev.username!]: Date.now() },
145+ }));
122146 } else if (ev.type === "ring_end" && ev.channelId) {
123147 setRinging((r) => (r === ev.channelId ? null : r));
124148 } else if (ev.message) {
125149 if (ev.type === "message") {
150+ // A sent message ends that person's typing.
151+ setTyping((t) => {
152+ const { [ev.message!.username]: _, ...rest } = t[ev.message!.channelId] ?? {};
153+ return t[ev.message!.channelId] ? { ...t, [ev.message!.channelId]: rest } : t;
154+ });
126155 setChannels((cs) => {
127156 if (!cs.some((c) => c.id === ev.message!.channelId)) {
128157 api<Channel[]>("/channels")
@@ -203,6 +232,41 @@ export default function Chat({ user, onLogout }: { user: User; onLogout: () => v
203232 }
204233 }, [collapsed]);
205234
235+ // Expire stale typing entries; the interval only runs while there are any.
236+ const anyTyping = Object.values(typing).some((c) => Object.keys(c).length > 0);
237+ useEffect(() => {
238+ if (!anyTyping) return;
239+ const id = setInterval(() => {
240+ const cutoff = Date.now() - typingTtl;
241+ setTyping((t) => {
242+ let changed = false;
243+ const next: typeof t = {};
244+ for (const [ch, users] of Object.entries(t)) {
245+ const live = Object.fromEntries(Object.entries(users).filter(([, at]) => at > cutoff));
246+ if (Object.keys(live).length !== Object.keys(users).length) changed = true;
247+ if (Object.keys(live).length) next[Number(ch)] = live;
248+ else if (Object.keys(users).length) changed = true;
249+ }
250+ return changed ? next : t;
251+ });
252+ }, 1000);
253+ return () => clearInterval(id);
254+ }, [anyTyping]);
255+
256+ // Turning the setting off hides everything already showing.
257+ useEffect(() => {
258+ if (!settings.typingIndicator) setTyping({});
259+ }, [settings.typingIndicator]);
260+
261+ function sendTyping() {
262+ if (!settings.typingIndicator || !selected) return;
263+ const now = Date.now();
264+ const last = lastTypingSent.current;
265+ if (last.channel === selected.id && now - last.at < typingEvery) return;
266+ lastTypingSent.current = { channel: selected.id, at: now };
267+ send(JSON.stringify({ type: "typing", channelId: selected.id }));
268+ }
269+
206270 // Escape dismisses the message actions pane, same as its close button.
207271 useEffect(() => {
208272 if (!active) return;
@@ -511,6 +575,10 @@ export default function Chat({ user, onLogout }: { user: User; onLogout: () => v
511575 onCancelEdit={() => setEditing(null)}
512576 onSaveEdit={saveEdit}
513577 />
578+ <div className="h-5 shrink-0 truncate px-3 text-xs text-faint md:px-4" aria-live="polite">
579+ {settings.typingIndicator &&
580+ typingLabel(Object.keys(typing[selected.id] ?? {}).sort())}
581+ </div>
514582 {active && !editing && (
515583 <MessageActions
516584 message={active}
@@ -525,6 +593,7 @@ export default function Chat({ user, onLogout }: { user: User; onLogout: () => v
525593 channel={selected}
526594 users={users}
527595 onEditLast={startEditLast}
596+ onTyping={sendTyping}
528597 onCollapseImages={() =>
529598 setCollapsed(
530599 (prev) =>
web/src/views/Settings.tsx+51−50
@@ -1,5 +1,5 @@
11 import { useEffect, useRef, useState } from "react";
2-import { Moon, RotateCcw, Sun } from "lucide-react";
2+import { Moon, Sun } from "lucide-react";
33 import { Room } from "livekit-client";
44 import { Button, Field, Section, Select, TextInput, Toggle } from "@/ui";
55 import type { AudioPresetName, FontSize, ScreenShareQuality, Settings as Prefs } from "../lib/settings";
@@ -66,7 +66,6 @@ export default function SettingsView({
6666 setMode: (m: Mode) => void;
6767 setPreset: (p: PresetId) => void;
6868 setToken: (t: Token, color: string) => void;
69- resetTokens: () => void;
7069 setScheme: (s: Scheme) => void;
7170 setSkittles: (v: boolean) => void;
7271 };
@@ -77,68 +76,70 @@ export default function SettingsView({
7776 // preview. In a call, reuse the live level to avoid capturing twice.
7877 const preview = useMicPreview(settings, voice.status !== "live");
7978 const meter = voice.status === "live" ? voice.micLevel : preview;
80- const { prefs, setMode, setPreset, setToken, resetTokens, setScheme, setSkittles } = theme;
79+ const { prefs, setMode, setPreset, setToken, setScheme, setSkittles } = theme;
8180
8281 return (
8382 <div className="mx-auto w-full max-w-2xl space-y-6 p-4 md:p-6">
8483 <Section label="Appearance">
85- <div className="flex gap-2 px-2">
86- {(["light", "dark"] as const).map((m) => (
87- <Button
88- key={m}
89- variant={prefs.mode === m ? "primary" : "secondary"}
90- className="flex-1"
91- onClick={() => setMode(m)}
92- >
93- {m === "light" ? <Sun /> : <Moon />} {m}
94- </Button>
95- ))}
96- </div>
97- <Field label="palette">
98- <Select
99- value={prefs.preset}
100- onChange={(v) => setPreset(v as PresetId)}
101- options={presets.map((p) => ({ value: p.id, label: p.label }))}
102- />
103- </Field>
10484 <Field label="text size">
10585 <Select
10686 value={settings.fontSize}
10787 onChange={(v) => update({ fontSize: v as FontSize })}
10888 options={[
109- { value: "normal", label: "normal" },
110- { value: "default", label: "browser default" },
111- { value: "large", label: "Help I'm old" },
89+ { value: "default", label: "default" },
90+ { value: "normal", label: "medium" },
91+ { value: "large", label: "help i'm old" },
11292 ]}
11393 />
11494 </Field>
95+ <Toggle label="skittles" checked={prefs.skittles} onChange={setSkittles} />
96+ <Field label="palette">
97+ <Select
98+ value={prefs.preset}
99+ onChange={(v) => setPreset(v as PresetId)}
100+ options={presets.map((p) => ({ value: p.id, label: p.label }))}
101+ />
102+ </Field>
103+ {prefs.preset === "custom" ? (
104+ <>
105+ <div className="grid grid-cols-1 gap-x-4 gap-y-1 sm:grid-cols-2">
106+ {TOKENS.map((t) => (
107+ <ColorField
108+ key={t}
109+ token={t}
110+ mode={prefs.mode}
111+ preset={prefs.base}
112+ override={prefs.overrides[prefs.mode][t]}
113+ onChange={(color) => setToken(t, color)}
114+ />
115+ ))}
116+ </div>
117+ <Field label="load palette">
118+ <SchemePicker current={prefs.scheme?.name} onPick={setScheme} />
119+ </Field>
120+ </>
121+ ) : (
122+ <div className="mt-2 flex gap-2 px-2">
123+ {(["light", "dark"] as const).map((m) => (
124+ <Button
125+ key={m}
126+ variant={prefs.mode === m ? "primary" : "secondary"}
127+ className="flex-1"
128+ onClick={() => setMode(m)}
129+ >
130+ {m === "light" ? <Sun /> : <Moon />} {m}
131+ </Button>
132+ ))}
133+ </div>
134+ )}
115135 </Section>
116136
117- <Section label={`Colors · ${prefs.mode} mode`}>
118- <div className="grid grid-cols-1 gap-x-4 gap-y-1 sm:grid-cols-2">
119- {TOKENS.map((t) => (
120- <ColorField
121- key={t}
122- token={t}
123- mode={prefs.mode}
124- preset={prefs.preset}
125- override={prefs.overrides[prefs.mode][t]}
126- onChange={(color) => setToken(t, color)}
127- />
128- ))}
129- </div>
130- <div className="space-y-1 pt-2">
131- <h3 className="section-label px-2">experimental</h3>
132- <Field label="external palette">
133- <SchemePicker current={prefs.scheme?.name} onPick={setScheme} />
134- </Field>
135- <Toggle label="skittles" checked={prefs.skittles} onChange={setSkittles} />
136- </div>
137- <div className="flex justify-end px-2 pt-1">
138- <Button variant="ghost" onClick={resetTokens}>
139- <RotateCcw /> reset to palette
140- </Button>
141- </div>
137+ <Section label="Chat">
138+ <Toggle
139+ label="typing indicator"
140+ checked={settings.typingIndicator}
141+ onChange={(v) => update({ typingIndicator: v })}
142+ />
142143 </Section>
143144
144145 <Section label="Sounds">
ws.go+35−0
@@ -23,6 +23,7 @@ type event struct {
2323 Voice map[string][]VoiceOccupant `json:"voice,omitempty"`
2424 Channel *Channel `json:"channel,omitempty"`
2525 ChannelID int64 `json:"channelId,omitempty"`
26+ Username string `json:"username,omitempty"`
2627 }
2728
2829 // VoiceOccupant is one user in a voice channel, as broadcast with presence.
@@ -47,6 +48,7 @@ type client struct {
4748 userID int64
4849 username string
4950 voiceID int64
51+ typedAt time.Time // last accepted typing event; only touched by readPump
5052 muted bool
5153 deafened bool
5254 conn *websocket.Conn
@@ -122,6 +124,37 @@ func (h *hub) setVoice(c *client, channelID int64, muted, deafened bool) {
122124 h.broadcastPresence()
123125 }
124126
127+// typingEvery is the shortest gap between typing events relayed for one
128+// connection, so a client cannot flood a channel with them.
129+const typingEvery = 2 * time.Second
130+
131+// typing tells everyone who can see channelID that c's user is typing in it.
132+// It is ephemeral: nothing is stored, and it is relayed only to people who are
133+// allowed in the channel (everyone for text, the two participants for a DM).
134+func (h *hub) typing(c *client, channelID int64) {
135+ if time.Since(c.typedAt) < typingEvery {
136+ return
137+ }
138+ var chType, chName string
139+ if h.db.QueryRow(`SELECT type, name FROM channels WHERE id = ?`, channelID).Scan(&chType, &chName) != nil {
140+ return
141+ }
142+ ev := event{Type: "typing", ChannelID: channelID, Username: c.username}
143+ switch chType {
144+ case "text":
145+ h.broadcast(ev)
146+ case "dm":
147+ if u1, u2, ok := parseDM(chName); ok && (u1 == c.userID || u2 == c.userID) {
148+ h.sendTo(ev, u1, u2)
149+ } else {
150+ return
151+ }
152+ default:
153+ return
154+ }
155+ c.typedAt = time.Now()
156+}
157+
125158 func (h *hub) users() []string {
126159 h.mu.Lock()
127160 defer h.mu.Unlock()
@@ -299,6 +332,8 @@ func (c *client) readPump() {
299332 switch in.Type {
300333 case "voice":
301334 c.hub.setVoice(c, in.ChannelID, in.Muted, in.Deafened)
335+ case "typing":
336+ c.hub.typing(c, in.ChannelID)
302337 case "ping":
303338 // Application-level heartbeat: the browser answers protocol pings
304339 // itself, so a client cannot see them. This lets it detect a