Admin: themaknop met drie standen (licht, donker, automatisch), toont de huidige stand, volgt de systeemvoorkeur live

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-17 08:59:21 +01:00
co-authored by Claude Sonnet 5.5
parent 0824bfa888
commit fe095884be
6 changed files with 316 additions and 106 deletions
+105 -62
View File
@@ -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<Listener>();
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');
});
});
+55 -28
View File
@@ -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 <html> 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 <html> 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 };
}