From fe095884bee660557a2cf3be80d2184ca48ce083 Mon Sep 17 00:00:00 2001 From: Sluijsens Date: Tue, 17 Nov 2026 08:59:21 +0100 Subject: [PATCH] Admin: themaknop met drie standen (licht, donker, automatisch), toont de huidige stand, volgt de systeemvoorkeur live Co-Authored-By: Claude Sonnet 5.5 --- .../components/layout/ThemeToggle.test.tsx | 82 +++++++++ .../src/components/layout/ThemeToggle.tsx | 70 ++++++-- frontend/src/hooks/useTheme.test.ts | 167 +++++++++++------- frontend/src/hooks/useTheme.ts | 83 ++++++--- frontend/src/i18n/locales/en/translation.json | 10 +- frontend/src/i18n/locales/nl/translation.json | 10 +- 6 files changed, 316 insertions(+), 106 deletions(-) create mode 100644 frontend/src/components/layout/ThemeToggle.test.tsx diff --git a/frontend/src/components/layout/ThemeToggle.test.tsx b/frontend/src/components/layout/ThemeToggle.test.tsx new file mode 100644 index 0000000..1272d1d --- /dev/null +++ b/frontend/src/components/layout/ThemeToggle.test.tsx @@ -0,0 +1,82 @@ +import { beforeEach, describe, expect, it, vi } from 'vitest'; +import { render, screen } from '@testing-library/react'; +import userEvent from '@testing-library/user-event'; +import i18n from '@/i18n/config'; +import { ThemeToggle } from './ThemeToggle'; + +const media = (dark: boolean) => + vi.spyOn(window, 'matchMedia').mockImplementation( + () => ({ matches: dark, addEventListener: () => undefined, removeEventListener: () => undefined }) as unknown as MediaQueryList, + ); + +beforeEach(async () => { + localStorage.clear(); + document.documentElement.className = ''; + vi.restoreAllMocks(); + await i18n.changeLanguage('nl'); +}); + +describe('ThemeToggle', () => { + it.each([ + ['light', 'Thema: licht'], + ['dark', 'Thema: donker'], + ])('shows the CURRENT %s theme in its name (not the action)', (mode, name) => { + localStorage.setItem('cms-theme', mode); + media(false); + + render(); + + const button = screen.getByTestId('theme-toggle'); + expect(button).toHaveAccessibleName(name); + expect(button).toHaveAttribute('data-mode', mode); + expect(button).toHaveAttribute('title', name); + }); + + it('says in words what automatic currently is', () => { + media(true); + + render(); + + expect(screen.getByTestId('theme-toggle')).toHaveAccessibleName('Thema: automatisch (nu donker)'); + expect(screen.getByTestId('theme-toggle')).toHaveAttribute('data-mode', 'auto'); + }); + + it('opens a menu with three options, the current one marked, and chooses with the keyboard', async () => { + media(false); + localStorage.setItem('cms-theme', 'light'); + render(); + + screen.getByTestId('theme-toggle').focus(); + await userEvent.keyboard('{Enter}'); + + expect(await screen.findByTestId('theme-option-light')).toHaveAttribute('aria-current', 'true'); + expect(screen.getByTestId('theme-option-dark')).not.toHaveAttribute('aria-current'); + expect(screen.getByTestId('theme-option-auto')).toHaveTextContent('Automatisch'); + + await userEvent.click(screen.getByTestId('theme-option-dark')); + + expect(localStorage.getItem('cms-theme')).toBe('dark'); + expect(document.documentElement.classList.contains('dark')).toBe(true); + expect(screen.getByTestId('theme-toggle')).toHaveAccessibleName('Thema: donker'); + }); + + it('works on the first click: automatic to dark flips what is shown at once', async () => { + media(false); + render(); + + await userEvent.click(screen.getByTestId('theme-toggle')); + await userEvent.click(await screen.findByTestId('theme-option-dark')); + + expect(document.documentElement.classList.contains('dark')).toBe(true); + expect(document.documentElement.classList.contains('light')).toBe(false); + }); + + it('has English texts too', async () => { + await i18n.changeLanguage('en'); + media(true); + + render(); + + expect(screen.getByTestId('theme-toggle')).toHaveAccessibleName('Theme: automatic (now dark)'); + }); +}); diff --git a/frontend/src/components/layout/ThemeToggle.tsx b/frontend/src/components/layout/ThemeToggle.tsx index 60041f8..7f8416f 100644 --- a/frontend/src/components/layout/ThemeToggle.tsx +++ b/frontend/src/components/layout/ThemeToggle.tsx @@ -1,20 +1,66 @@ -import { Sun, Moon } from 'lucide-react'; +import { Monitor, Moon, Sun } from 'lucide-react'; import { useTranslation } from 'react-i18next'; -import { useTheme } from '@/hooks/useTheme'; +import { + DropdownMenu, + DropdownMenuCheck, + DropdownMenuContent, + DropdownMenuItem, + DropdownMenuLabel, + DropdownMenuSeparator, + DropdownMenuTrigger, +} from '@/components/ui/dropdown-menu'; +import { useTheme, type ThemeMode } from '@/hooks/useTheme'; +const MODES: { mode: ThemeMode; icon: typeof Sun }[] = [ + { mode: 'light', icon: Sun }, + { mode: 'dark', icon: Moon }, + { mode: 'auto', icon: Monitor }, +]; + +/** + * Three states: light, dark, automatic (follow the system). The button shows the CURRENT choice (sun = light, moon = + * dark, monitor = automatic), its name says it in words ("Theme: automatic (now dark)"), and a small menu with the three + * options (the current one marked) changes it. + */ export function ThemeToggle() { const { t } = useTranslation(); - const { isDark, toggleTheme } = useTheme(); + const { mode, theme, setMode } = useTheme(); + const Icon = MODES.find((m) => m.mode === mode)!.icon; + const label = + mode === 'auto' + ? t('theme.labelAuto', { now: t(`theme.mode.${theme}`).toLowerCase() }) + : t('theme.label', { mode: t(`theme.mode.${mode}`).toLowerCase() }); return ( - + + + + + + {t('theme.title')} + + {MODES.map(({ mode: option, icon: OptionIcon }) => ( + setMode(option)} + aria-current={mode === option ? 'true' : undefined} + data-testid={`theme-option-${option}`} + > + + {t(`theme.mode.${option}`)} + + + ))} + + ); } diff --git a/frontend/src/hooks/useTheme.test.ts b/frontend/src/hooks/useTheme.test.ts index dfa1956..3872b44 100644 --- a/frontend/src/hooks/useTheme.test.ts +++ b/frontend/src/hooks/useTheme.test.ts @@ -2,6 +2,33 @@ import { describe, it, expect, beforeEach, vi } from 'vitest'; import { renderHook, act } from '@testing-library/react'; import { useTheme } from './useTheme'; +type Listener = () => void; + +/** A matchMedia that can change its answer and tell its listeners, like the system preference does. */ +function system(initialDark: boolean) { + let dark = initialDark; + const listeners = new Set(); + vi.spyOn(window, 'matchMedia').mockImplementation( + () => + ({ + get matches() { + return dark; + }, + addEventListener: (_: string, l: Listener) => listeners.add(l), + removeEventListener: (_: string, l: Listener) => listeners.delete(l), + }) as unknown as MediaQueryList, + ); + return { + change(next: boolean) { + dark = next; + listeners.forEach((l) => l()); + }, + listenerCount: () => listeners.size, + }; +} + +const shown = () => (document.documentElement.classList.contains('dark') ? 'dark' : 'light'); + beforeEach(() => { localStorage.clear(); document.documentElement.className = ''; @@ -9,96 +36,112 @@ beforeEach(() => { }); describe('useTheme', () => { - it('defaults to light when no preference is stored and OS prefers light', () => { - vi.spyOn(window, 'matchMedia').mockReturnValue({ matches: false } as MediaQueryList); + it('is automatic when nothing is stored, and follows the system', () => { + system(true); const { result } = renderHook(() => useTheme()); - expect(result.current.theme).toBe('light'); - expect(result.current.isDark).toBe(false); - }); - it('defaults to dark when OS prefers dark and nothing is stored', () => { - vi.spyOn(window, 'matchMedia').mockReturnValue({ matches: true } as MediaQueryList); - const { result } = renderHook(() => useTheme()); + expect(result.current.mode).toBe('auto'); expect(result.current.theme).toBe('dark'); expect(result.current.isDark).toBe(true); + expect(shown()).toBe('dark'); }); - it('uses stored localStorage value over OS preference', () => { - localStorage.setItem('cms-theme', 'dark'); - vi.spyOn(window, 'matchMedia').mockReturnValue({ matches: false } as MediaQueryList); - const { result } = renderHook(() => useTheme()); - expect(result.current.theme).toBe('dark'); - }); - - it('toggleTheme switches from light to dark', () => { - localStorage.setItem('cms-theme', 'light'); - const { result } = renderHook(() => useTheme()); - act(() => { result.current.toggleTheme(); }); - expect(result.current.theme).toBe('dark'); - expect(localStorage.getItem('cms-theme')).toBe('dark'); - expect(document.documentElement.classList.contains('dark')).toBe(true); - }); - - it('toggleTheme switches from dark to light', () => { - localStorage.setItem('cms-theme', 'dark'); - const { result } = renderHook(() => useTheme()); - act(() => { result.current.toggleTheme(); }); - expect(result.current.theme).toBe('light'); - expect(localStorage.getItem('cms-theme')).toBe('light'); - expect(document.documentElement.classList.contains('light')).toBe(true); - }); -}); - -describe('first click', () => { - const media = (dark: boolean) => vi.spyOn(window, 'matchMedia').mockReturnValue({ matches: dark } as MediaQueryList); - const shown = () => (document.documentElement.classList.contains('dark') ? 'dark' : 'light'); - it.each([ - ['light', 'dark'], - ['dark', 'light'], - ])('flips the shown theme straight away when the OS prefers %s and nothing is stored or applied', (os, expected) => { - media(os === 'dark'); + ['light', true, 'light'], + ['dark', false, 'dark'], + ])('a stored %s wins over the system (dark=%s)', (stored, osDark, expected) => { + localStorage.setItem('cms-theme', stored); + system(osDark); + const { result } = renderHook(() => useTheme()); - expect(shown()).toBe(os); - act(() => { result.current.toggleTheme(); }); - - expect(shown()).toBe(expected); + expect(result.current.mode).toBe(stored); expect(result.current.theme).toBe(expected); + expect(shown()).toBe(expected); }); - it('flips from what is shown even when the stored value is unusable', () => { + it('treats an unusable stored value as automatic', () => { localStorage.setItem('cms-theme', 'system'); - media(true); - document.documentElement.className = 'system'; + system(true); + const { result } = renderHook(() => useTheme()); + expect(result.current.mode).toBe('auto'); expect(shown()).toBe('dark'); - act(() => { result.current.toggleTheme(); }); - expect(shown()).toBe('light'); }); - it('follows the shown theme when it differs from the stored one', () => { - localStorage.setItem('cms-theme', 'light'); + it.each([ + ['light', false], + ['dark', false], + ['auto', true], + ] as const)('setMode(%s) applies it at the very first call and stores it', (mode, osDark) => { + system(osDark); + const { result } = renderHook(() => useTheme()); + + act(() => result.current.setMode(mode)); + + expect(localStorage.getItem('cms-theme')).toBe(mode); + expect(result.current.mode).toBe(mode); + expect(shown()).toBe(mode === 'auto' ? (osDark ? 'dark' : 'light') : mode); + }); + + it('the first choice works at once, whatever the page carried before', () => { + system(true); document.documentElement.className = 'dark'; const { result } = renderHook(() => useTheme()); - expect(result.current.theme).toBe('dark'); - act(() => { result.current.toggleTheme(); }); + act(() => result.current.setMode('light')); + expect(shown()).toBe('light'); - expect(localStorage.getItem('cms-theme')).toBe('light'); + expect(result.current.theme).toBe('light'); }); - it('keeps two toggles on the page in step', () => { + it('in automatic mode it follows a change of the system preference live, without reload', () => { + const os = system(false); + const { result } = renderHook(() => useTheme()); + expect(shown()).toBe('light'); + + act(() => os.change(true)); + + expect(result.current.theme).toBe('dark'); + expect(shown()).toBe('dark'); + }); + + it('with a fixed theme a change of the system preference changes nothing', () => { localStorage.setItem('cms-theme', 'light'); + const os = system(false); + const { result } = renderHook(() => useTheme()); + + act(() => os.change(true)); + + expect(result.current.theme).toBe('light'); + expect(shown()).toBe('light'); + }); + + it('keeps two toggles on the page in step, and stops listening when they are gone', () => { + const os = system(false); const a = renderHook(() => useTheme()); const b = renderHook(() => useTheme()); - act(() => { a.result.current.toggleTheme(); }); - expect(b.result.current.theme).toBe('dark'); + act(() => a.result.current.setMode('dark')); + expect(b.result.current.mode).toBe('dark'); + expect(os.listenerCount()).toBeGreaterThan(0); - act(() => { b.result.current.toggleTheme(); }); - expect(shown()).toBe('light'); - expect(a.result.current.theme).toBe('light'); + a.unmount(); + b.unmount(); + expect(os.listenerCount()).toBe(0); + }); + + it('still works for this page view when the storage cannot be written', () => { + system(false); + vi.spyOn(Storage.prototype, 'setItem').mockImplementation(() => { + throw new Error('private mode'); + }); + const { result } = renderHook(() => useTheme()); + + act(() => result.current.setMode('dark')); + + expect(result.current.mode).toBe('dark'); + expect(shown()).toBe('dark'); }); }); diff --git a/frontend/src/hooks/useTheme.ts b/frontend/src/hooks/useTheme.ts index 2309e51..ee41be1 100644 --- a/frontend/src/hooks/useTheme.ts +++ b/frontend/src/hooks/useTheme.ts @@ -1,63 +1,90 @@ import { useCallback, useSyncExternalStore } from 'react'; -type Theme = 'light' | 'dark'; +/** What the user chose: a fixed theme, or follow the system (also the default when nothing is stored). */ +export type ThemeMode = 'light' | 'dark' | 'auto'; +/** The theme that is actually shown. */ +export type Theme = 'light' | 'dark'; const STORAGE_KEY = 'cms-theme'; +const DARK_QUERY = '(prefers-color-scheme: dark)'; const listeners = new Set<() => void>(); -function isTheme(value: string | null): value is Theme { - return value === 'light' || value === 'dark'; +/** Only used when storage cannot be written (private mode): the choice then lasts for this page view. */ +let memoryMode: ThemeMode | null = null; + +function storedMode(): ThemeMode { + if (memoryMode) return memoryMode; + try { + const stored = localStorage.getItem(STORAGE_KEY); + return stored === 'light' || stored === 'dark' ? stored : 'auto'; + } catch { + return memoryMode ?? 'auto'; + } } -function preferredTheme(): Theme { - const stored = localStorage.getItem(STORAGE_KEY); - if (isTheme(stored)) return stored; - return window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light'; +function systemTheme(): Theme { + return window.matchMedia(DARK_QUERY).matches ? 'dark' : 'light'; } function apply(theme: Theme) { - document.documentElement.classList.remove('light', 'dark'); - document.documentElement.classList.add(theme); + const classes = document.documentElement.classList; + if (!classes.contains(theme) || classes.contains(theme === 'dark' ? 'light' : 'dark')) { + classes.remove('light', 'dark'); + classes.add(theme); + } } -/** - * The theme that is actually shown, which is what the class says: the stylesheet only - * knows that class. The stored value and the OS preference are only the way to pick a theme when - * the page carries none (or an unusable one); in that case it is applied right away, so the state - * we report and what the user sees can never differ. A first click then always flips what is shown. - */ -function currentTheme(): Theme { - const classes = document.documentElement.classList; - if (classes.contains('dark')) return 'dark'; - if (classes.contains('light')) return 'light'; - - const theme = preferredTheme(); +/** The shown theme for a mode; it is put on right away, so what we report is what the user sees. */ +function resolve(mode: ThemeMode): Theme { + const theme = mode === 'auto' ? systemTheme() : mode; apply(theme); return theme; } +/** One primitive per state, so useSyncExternalStore sees no change while nothing changed. */ +function snapshot(): string { + const mode = storedMode(); + return `${mode}:${resolve(mode)}`; +} + +function notifyAll() { + listeners.forEach((notify) => notify()); +} + function subscribe(listener: () => void) { listeners.add(listener); + // In automatic mode the page follows a change of the system preference live, without a reload; another tab that + // changes the choice is followed as well. + const media = typeof window.matchMedia === 'function' ? window.matchMedia(DARK_QUERY) : null; + media?.addEventListener?.('change', listener); + const onStorage = (event: StorageEvent) => { + if (event.key === STORAGE_KEY || event.key === null) listener(); + }; + window.addEventListener('storage', onStorage); return () => { listeners.delete(listener); + media?.removeEventListener?.('change', listener); + window.removeEventListener('storage', onStorage); }; } export function useTheme() { // One source of truth shared by every toggle on the page (desktop sidebar, mobile overlay). - const theme = useSyncExternalStore(subscribe, currentTheme, () => 'light' as Theme); + const state = useSyncExternalStore(subscribe, snapshot, () => 'auto:light'); + const [mode, theme] = state.split(':') as [ThemeMode, Theme]; - const toggleTheme = useCallback(() => { - const next: Theme = currentTheme() === 'dark' ? 'light' : 'dark'; + const setMode = useCallback((next: ThemeMode) => { try { localStorage.setItem(STORAGE_KEY, next); + memoryMode = null; } catch { - // Storage can be unavailable (private mode); the switch itself still works. + // Storage can be unavailable (private mode); the switch itself still works for this page view. + memoryMode = next; } - apply(next); - listeners.forEach((notify) => notify()); + resolve(next); + notifyAll(); }, []); - return { theme, isDark: theme === 'dark', toggleTheme }; + return { mode, theme, isDark: theme === 'dark', setMode }; } diff --git a/frontend/src/i18n/locales/en/translation.json b/frontend/src/i18n/locales/en/translation.json index f547247..74115b4 100644 --- a/frontend/src/i18n/locales/en/translation.json +++ b/frontend/src/i18n/locales/en/translation.json @@ -18,8 +18,14 @@ "closeMenu": "Close navigation" }, "theme": { - "switchToLight": "Switch to light theme", - "switchToDark": "Switch to dark theme" + "title": "Theme", + "label": "Theme: {{mode}}", + "labelAuto": "Theme: automatic (now {{now}})", + "mode": { + "light": "Light", + "dark": "Dark", + "auto": "Automatic" + } }, "session": { "unreachable": { diff --git a/frontend/src/i18n/locales/nl/translation.json b/frontend/src/i18n/locales/nl/translation.json index 4830c87..9114c49 100644 --- a/frontend/src/i18n/locales/nl/translation.json +++ b/frontend/src/i18n/locales/nl/translation.json @@ -18,8 +18,14 @@ "closeMenu": "Navigatie sluiten" }, "theme": { - "switchToLight": "Overschakelen naar licht thema", - "switchToDark": "Overschakelen naar donker thema" + "title": "Thema", + "label": "Thema: {{mode}}", + "labelAuto": "Thema: automatisch (nu {{now}})", + "mode": { + "light": "Licht", + "dark": "Donker", + "auto": "Automatisch" + } }, "session": { "unreachable": {