Dark mode: Light, Dark or Auto under Settings › Theme (#80)

A device preference (localStorage sot-theme, never in the save), applied
by a small script in <head> before the first paint, so there is no flash;
Auto follows prefers-color-scheme live, and a choice reaches other tabs
and the NOC window. Panels, HUD, drawers, toasts, modals, the phone tab
bar, charts, puzzles, the architect and Pie Control take their colours
from custom properties with night values (AA text contrast); light tints
keep their old colour as the fallback, so the light look is unchanged.

Both map renderers read a light and a dark palette (96-map/15-palette.js):
sea, land, clouds, coastlines, labels and the tube outline. A theme
switch repaints the cached layers once (the WebGL land buffers are
rebuilt once); nothing changes per frame. The multiplayer leaderboard's
own row and the menu rank badge follow the theme too.
This commit is contained in:
jvanvik 2026-11-07 01:01:50 +01:00
parent 95aa9b6532
commit 2cd6b71198
49 changed files with 645 additions and 155 deletions

View file

@ -52,7 +52,7 @@ test('src: partials follow the layout rules (docs/adr/0002-one-page-assembled-at
for (const dev of [false, true]) {
const { html, map } = assemble({ dev });
assert.equal((html.match(/^const ACT=\{$/gm) || []).length, 1, 'ACT is declared once; other action files use Object.assign(ACT,{…})');
assert.equal([...new JSDOM(html).window.document.scripts].filter((s) => !s.attributes.length).length, 2, 'the language loader and the game: one inline game script');
assert.equal([...new JSDOM(html).window.document.scripts].filter((s) => !s.attributes.length).length, 3, 'the theme, the language loader and the game: one inline game script');
assert.ok(map.length > 50 && map.every((m) => m.to >= m.from), 'the line map covers every partial');
}
});

380
tests/dark-mode.test.js Normal file
View file

@ -0,0 +1,380 @@
// Dark mode (#80): Settings › Theme is Auto (the device's light or dark setting), Light or Dark, a choice kept on the
// device (localStorage sot-theme), never in the save. The page's <head> sets <html data-theme> before the first paint;
// the panels follow through CSS custom properties, and the map paints its sea, land, clouds and labels in the night
// colours in both renderers, painting its cached layers again once when the theme changes (not on every frame).
// jsdom has no matchMedia: the tests lend the page one, before it is parsed (the harness's browser hook) or after.
const test = require('node:test');
const assert = require('node:assert/strict');
const fs = require('node:fs');
const path = require('node:path');
const { JSDOM } = require('jsdom');
const { load, browser, flush } = require('./harness');
const { assemble } = require('../scripts/lib/page');
// A device setting the test can flip: matchMedia('(prefers-color-scheme: dark)') with change listeners.
const device = (dark) => {
const q = { matches: dark, media: '(prefers-color-scheme: dark)', fns: [],
addEventListener(t, f) { if (t === 'change') this.fns.push(f); }, removeEventListener(t, f) { this.fns = this.fns.filter((x) => x !== f); },
set(v) { this.matches = v; for (const f of this.fns.slice()) f({ matches: v }); } };
return { q, attach(w) { w.matchMedia = (m) => (/prefers-color-scheme:\s*dark/.test(m) ? q : { matches: false, addEventListener() {}, removeEventListener() {} }); } };
};
const meta = (doc, n) => doc.querySelector(`meta[name="${n}"]`).getAttribute('content');
// WCAG contrast between two #RRGGBB colours.
const lum = (h) => { h = h.replace('#', ''); const c = [0, 2, 4].map((i) => parseInt(h.slice(i, i + 2), 16) / 255).map((v) => (v <= 0.03928 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4)); return 0.2126 * c[0] + 0.7152 * c[1] + 0.0722 * c[2]; };
const cr = (a, b) => { const x = lum(a), y = lum(b); return (Math.max(x, y) + 0.05) / (Math.min(x, y) + 0.05); };
// Only the page's <head>, up to its styles, as the browser runs it before the first paint: the game script at the end
// of <body> (which sets the theme as well, but late) is not there. ls: what window.localStorage gives, or throws.
const headOnly = (dark, ls) => {
const html = assemble().html, head = html.slice(0, html.indexOf('<style>')) + '</head><body></body></html>';
const dom = new JSDOM(head, { runScripts: 'dangerously', url: 'https://tests.invalid/', beforeParse(w) {
device(dark).attach(w);
if (ls) Object.defineProperty(w, 'localStorage', { configurable: true, get: () => ls(w) });
} });
const doc = dom.window.document, r = [doc.documentElement.getAttribute('data-theme'), meta(doc, 'theme-color'), meta(doc, 'color-scheme')];
dom.window.close();
return r;
};
const DARK = ['dark', '#0E2A44', 'dark'], LIGHT = ['light', '#57C4E5', 'light'];
const started = "ACT.start({});if(UI.pendGame)ACT.pitchSkip();S.nextFail=S.nextEvent=1e9;UI.speed=0;closeModal();compute();renderAll();";
test('the choice applies at boot, from the <head>, before the page is painted', () => {
for (const [storage, want, pref] of [[{ 'sot-theme': 'dark' }, 'dark', 'dark'], [{ 'sot-theme': 'light' }, 'light', 'light'], [{}, 'light', 'auto'], [{ 'sot-theme': 'neon' }, 'light', 'auto']]) {
const { dom, ev, errors } = load({ storage });
const doc = dom.window.document;
assert.equal(doc.documentElement.getAttribute('data-theme'), want, JSON.stringify(storage));
assert.equal(meta(doc, 'theme-color'), want === 'dark' ? '#0E2A44' : '#57C4E5', 'the browser bar follows');
assert.equal(meta(doc, 'color-scheme'), want);
assert.equal(ev('THEME.pref'), pref);
assert.equal(ev('THEME.dark'), want === 'dark');
assert.deepEqual(errors, []);
dom.window.close();
}
// The script that sets it sits in the <head>, before the styles: nothing is painted in the wrong colours first.
const doc = load().dom.window.document, head = [...doc.head.children];
const s = head.findIndex((e) => e.tagName === 'SCRIPT' && /sot-theme/.test(e.textContent)), st = head.findIndex((e) => e.tagName === 'STYLE');
assert.ok(s >= 0 && s < st, 'the theme script runs before the stylesheet');
// Auto with a dark device: dark from the first paint as well.
const d = device(true), h = load({ browser: d });
assert.equal(h.dom.window.document.documentElement.getAttribute('data-theme'), 'dark');
assert.equal(h.ev('THEME.dark'), true);
assert.deepEqual(h.errors, []);
});
test('the <head> alone sets the theme, and a dark device stays dark when the site\'s storage is blocked', () => {
const saved = (v) => () => ({ getItem: (k) => (k === 'sot-theme' ? v : null) });
assert.deepEqual(headOnly(true), DARK, 'Auto on a dark device');
assert.deepEqual(headOnly(false), LIGHT, 'Auto on a light device');
assert.deepEqual(headOnly(false, saved('dark')), DARK, 'Dark chosen');
assert.deepEqual(headOnly(true, saved('light')), LIGHT, 'Light chosen');
// Cookies and site data blocked (Chrome, sandboxed frames: a SecurityError), storage switched off (Firefox: null),
// or a getItem that throws: the device's setting still decides, before the first paint.
const blocked = [(w) => { throw new w.DOMException('The operation is insecure.', 'SecurityError'); }, () => null, () => ({ getItem() { throw new Error('denied'); } })];
for (const ls of blocked) {
assert.deepEqual(headOnly(true, ls), DARK, `dark device, blocked storage (${ls})`);
assert.deepEqual(headOnly(false, ls), LIGHT, `light device, blocked storage (${ls})`);
}
// The whole page with blocked storage on a dark device: dark, on Auto.
const blockedDevice = { attach(w) { device(true).attach(w); Object.defineProperty(w, 'localStorage', { configurable: true, get() { throw new w.DOMException('The operation is insecure.', 'SecurityError'); } }); } };
const { dom, ev, errors } = load({ browser: blockedDevice });
assert.equal(dom.window.document.documentElement.getAttribute('data-theme'), 'dark');
assert.deepEqual(JSON.parse(ev('JSON.stringify([THEME.pref,THEME.dark])')), ['auto', true]);
assert.deepEqual(errors, []);
dom.window.close();
});
test('Auto follows the device when its setting changes; Light and Dark do not', () => {
const d = device(false), { dom, ev, errors } = load({ browser: d });
const root = dom.window.document.documentElement;
ev(started);
assert.equal(root.getAttribute('data-theme'), 'light');
d.q.set(true);
assert.equal(root.getAttribute('data-theme'), 'dark', 'the device went dark');
assert.equal(ev('THEME.dark'), true);
assert.equal(meta(dom.window.document, 'theme-color'), '#0E2A44');
d.q.set(false);
assert.equal(root.getAttribute('data-theme'), 'light', 'and light again');
ev("ACT.themeSet({v:'dark'})");
d.q.set(true); d.q.set(false);
assert.equal(root.getAttribute('data-theme'), 'dark', 'Dark stays dark whatever the device says');
ev("ACT.themeSet({v:'light'})");
d.q.set(true);
assert.equal(root.getAttribute('data-theme'), 'light', 'Light stays light');
ev("ACT.themeSet({v:'auto'})");
assert.equal(root.getAttribute('data-theme'), 'dark', 'Auto takes the device setting at once');
assert.equal(d.q.fns.length, 1, 'one listener');
assert.deepEqual(errors, []);
});
test('a choice made in one tab reaches the others (the NOC window on a second screen too)', async () => {
const b = browser(), A = load({ browser: b }), B = load({ browser: b });
A.ev("ACT.themeSet({v:'dark'})");
await flush();
assert.equal(B.dom.window.document.documentElement.getAttribute('data-theme'), 'dark');
assert.equal(B.ev('THEME.pref'), 'dark');
A.ev("ACT.themeSet({v:'auto'})");
await flush();
assert.equal(B.dom.window.document.documentElement.getAttribute('data-theme'), 'light');
assert.deepEqual([...A.errors, ...B.errors], []);
for (const h of [A, B]) h.dom.window.close();
});
test('Settings › Theme: three choices, on the title screen and in a game, kept on the device and not in the save', () => {
const { dom, ev, errors } = load();
const doc = dom.window.document, root = doc.documentElement;
const row = () => [...doc.querySelectorAll('#modalCard [data-act="themeSet"]')].map((b) => [JSON.parse(b.dataset.args).v, b.textContent, b.className.includes('pink')]);
// The title screen: no game yet, the button still works.
ev('ACT.settings({})');
assert.deepEqual(row(), [['auto', 'Auto', true], ['light', 'Light', false], ['dark', 'Dark', false]]);
doc.querySelector('#modalCard [data-act="themeSet"][data-args*="dark"]').click();
assert.equal(root.getAttribute('data-theme'), 'dark');
assert.equal(ev("localStorage.getItem('sot-theme')"), 'dark');
assert.deepEqual(row().map((r) => r[2]), [false, false, true], 'the settings show the new choice');
ev("ACT.settingsClose({})");
// In a game: the choice is not part of it.
ev(started);
const before = ev('JSON.stringify(S)');
ev("ACT.settings({});ACT.themeSet({v:'light'})");
assert.equal(root.getAttribute('data-theme'), 'light');
assert.equal(ev("localStorage.getItem('sot-theme')"), 'light');
assert.equal(ev('JSON.stringify(S)'), before, 'the save is untouched');
ev("ACT.themeSet({v:'auto'})");
assert.equal(ev("localStorage.getItem('sot-theme')"), null, 'Auto is the default: nothing kept');
ev("ACT.themeSet({v:'sepia'});ACT.themeSet({})");
assert.equal(ev('THEME.pref'), 'auto', 'anything else is ignored');
// A puzzle keeps its settings working.
assert.ok(ev("PZ_ACTS.has('themeSet')"));
assert.deepEqual(errors, []);
});
test('the map paints sea, land, clouds and labels in the theme\'s colours, in 2D, and paints its cached land again once', () => {
const { ev, errors } = load({ storage: { 'sot-map': '2d' } });
ev(started + "const h=CITY[S.home];cam.x=h.x;cam.y=h.y;cam.z=1.4;");
// What paintWorld() fills and strokes, on a recording context.
const world = () => JSON.parse(ev(`(()=>{const r={f:[],s:[],save(){},restore(){},translate(){},beginPath(){},moveTo(){},lineTo(){},ellipse(){},setLineDash(){},
fill(){this.f.push(this.fillStyle);},stroke(){this.s.push(this.strokeStyle);}};paintWorld(r,1.4,false);return JSON.stringify({f:[...new Set(r.f)],s:[...new Set(r.s)]});})()`));
const P = JSON.parse(ev('JSON.stringify(MAP_PAL)'));
let w = world();
assert.deepEqual(w.f, [P.light.shadow, P.light.land, P.light.hill, P.light.shine]);
assert.deepEqual(w.s, [P.light.sand, P.light.coast]);
// The sea's gradient, the waves and the clouds of a 2D frame, and the labels' pills.
ev(`window.__sea=[];CTX0.createLinearGradient=()=>({addColorStop:(o,c)=>__sea.push(c)});window.__pills=[];const __p=pill;pill=function(t,f,w,h,r,fill,ink,edge){__pills.push(fill+'/'+ink+'/'+edge);return __p.apply(this,arguments);};
window.__paints=0;const __pw=paintWorld;paintWorld=function(){__paints++;return __pw.apply(this,arguments);};`);
const frame = (t) => JSON.parse(ev(`(()=>{__sea.length=0;__pills.length=0;__paints=0;draw(${t});return JSON.stringify({sea:__sea.slice(),pills:[...new Set(__pills)],paints:__paints,wave:CTX0.strokeStyle});})()`));
let f = frame(1000);
assert.deepEqual(f.sea, [P.light.sea, P.light.sea2]);
assert.ok(f.pills.includes(`${P.light.pill}/${P.light.pillInk}/${P.light.pillEdge}`), 'city labels on white pills');
assert.equal(frame(1000).paints, 0, 'nothing changed: the land is not painted again');
ev("ACT.themeSet({v:'dark'})");
assert.equal(ev('WL.key'), null, 'the land picture is let go');
assert.equal(ev('SPRC.size'), 0, 'and every sprite painted in the old colours');
w = world();
assert.deepEqual(w.f, [P.dark.shadow, P.dark.land, P.dark.hill, P.dark.shine]);
assert.deepEqual(w.s, [P.dark.sand, P.dark.coast]);
f = frame(1016);
assert.deepEqual(f.sea, [P.dark.sea, P.dark.sea2]);
assert.equal(f.paints, 1, 'the land is painted again, once');
assert.ok(f.pills.includes(`${P.dark.pill}/${P.dark.pillInk}/${P.dark.pillEdge}`), 'city labels on dark pills');
assert.ok(!f.pills.includes(`${P.light.pill}/${P.light.pillInk}/${P.light.pillEdge}`), 'no light label left');
assert.ok(f.pills.some((p) => p.startsWith('#FF4F9A/')), 'your POPs keep their pink labels');
assert.equal(frame(1016).paints, 0, 'and not on the next frame');
// Paused and unmoved, the map is drawn again for the theme (mapStill() would otherwise keep the old frame).
ev("FRAME.length=0;mapStill(0,performance.now());UI.drawnAt=performance.now();");
assert.equal(ev('mapStill(0,performance.now())'), true, 'an unchanged frame is skipped');
ev("ACT.themeSet({v:'light'})");
assert.equal(ev('mapStill(0,performance.now())'), false, 'a theme change draws the map again');
assert.deepEqual(errors, []);
});
// A WebGL2 stand-in that records calls (as tests/webgl-map.test.js).
const STUB = `(()=>{const calls=[];const gl=new Proxy({calls},{get(t,k){if(k in t)return t[k];if(typeof k==='string'&&/^[A-Z_0-9]+$/.test(k))return k;
if(k==='isContextLost')return ()=>false;return (...a)=>{calls.push([k,...a]);return {};};}});
const c=document.getElementById('mapgl'),f=document.getElementById('mapfx');
const P=()=>({p:{},u:{}}),B=()=>({v:{},b:{}});
Object.assign(GLX,{want:true,dead:false,gl,c,f,fx:f.getContext('2d'),line:P(),pk:P(),fill:P(),fan:P(),ell:P(),land:{},circ:P(),tex:{},lv:B(),hv:B(),pv:B(),cb:B(),wv:B(),dv:B(),cl:B(),empty:{},key:[],gpu:'stub'});return gl;})()`;
test('on the graphics card too: the sea, the land and its coastlines in the theme\'s colours, built again once', () => {
const { ev, errors } = load();
ev(started + "const h=CITY[S.home];cam.x=h.x;cam.y=h.y;cam.z=1.4;");
ev(STUB);
const pm = (s) => JSON.parse(ev(`JSON.stringify(glPm(${JSON.stringify(s)}))`));
const P = JSON.parse(ev('JSON.stringify(MAP_PAL)'));
// The colours sent with uniform4fv (sea, land, hills, clouds) and the coastline colours in the land's buffers.
const frame = (t) => JSON.parse(ev(`(()=>{GLX.gl.calls.length=0;draw(${t});const c=GLX.gl.calls;
const u=c.filter(x=>x[0]==='uniform4fv').map(x=>Array.from(x[2]).map(v=>Math.round(v*1e4)/1e4).join(','));
const lines=c.filter(x=>x[0]==='bufferData'&&x[3]==='STATIC_DRAW'&&x[2]&&x[2].length%LINE_STRIDE===0&&x[2].length>LINE_STRIDE*1000).map(x=>[x[2][9],x[2][10],x[2][11]].map(v=>Math.round(v*1e4)/1e4).join(','));
return JSON.stringify({u:[...new Set(u)],lines,del:c.filter(x=>x[0]==='deleteBuffer').length,land:Object.keys(GLX.land).length});})()`));
const key = (a) => a.map((v) => Math.round(v * 1e4) / 1e4).join(',');
const rgb = (s) => key(JSON.parse(ev(`JSON.stringify(glColor(${JSON.stringify(s)}).slice(0,3))`)));
let f = frame(1000);
assert.equal(ev('glOn()'), true);
for (const k of ['sea', 'sea2', 'land', 'hill', 'shadow', 'cloud']) assert.ok(f.u.includes(key(pm(P.light[k]))), `light ${k} on the card`);
assert.ok(f.lines.includes(rgb(P.light.sand)) && f.lines.includes(rgb(P.light.coast)), 'light sand and coastline in the land buffers');
assert.equal(frame(1016).lines.length, 0, 'an ordinary frame uploads no land');
assert.equal(ev('glPal()===glPal()&&GLP.m===MAP_PAL.light'), true, 'the colours are worked out once, not per frame');
ev("ACT.themeSet({v:'dark'})");
assert.equal(ev('Object.keys(GLX.land).length'), 0, 'the land is let go');
assert.ok(ev("GLX.gl.calls.filter(x=>x[0]==='deleteBuffer').length") > 0, 'its buffers freed');
f = frame(1032);
for (const k of ['sea', 'sea2', 'land', 'hill', 'shadow', 'cloud']) assert.ok(f.u.includes(key(pm(P.dark[k]))), `dark ${k} on the card`);
assert.ok(!f.u.includes(key(pm(P.light.sea))), 'no light sea left');
assert.ok(f.lines.includes(rgb(P.dark.sand)) && f.lines.includes(rgb(P.dark.coast)), 'dark sand and coastline in the new land buffers');
assert.equal(f.land, 1, 'one level of land built for the view');
assert.equal(frame(1048).lines.length, 0, 'and only once');
assert.deepEqual(errors, []);
});
// Two tubes that were nearly lost at night: a dark fiber with no channels lit yet, and a virtual circuit on the ccn
// fabric (thin, dotted, purple). Every tube is drawn over its casing, which the theme gives (MAP_PAL.*.casing).
const TUBES = "S.links.push({id:'unlit',a:'fra',b:'ams',kind:'df',own:false,sys:'dwdm',ch:[],cable:null,km:kmBetween('fra','ams'),sub:false,mo:1000,trench:'t-unlit',ready:0,day:0,cut:0,spares:false},"
+ "{id:'vc',a:'fra',b:'lon',kind:'vxc',prov:'ccn',vt:1,km:kmBetween('fra','lon'),sub:false,mo:0,cut:0,day:0});compute();cam.x=CITY.fra.x;cam.y=CITY.fra.y;cam.z=1.4;";
const tubeCols = (ev) => JSON.parse(ev("JSON.stringify(Object.fromEntries(['unlit','vc'].map(id=>[id,linkLook([S.links.find(l=>l.id===id)],S.day).col])))"));
test('every tube keeps an outline that stands out from the land and the sea, by night as by day', () => {
const { ev, errors } = load({ storage: { 'sot-map': '2d' } });
ev(started + TUBES);
const P = JSON.parse(ev('JSON.stringify(MAP_PAL)')), col = tubeCols(ev);
assert.equal(ev('linkLook([S.links.find(l=>l.id==="unlit")],S.day).dark'), true, 'an unlit dark fiber');
assert.equal(col.vc, ev('FAB.ccn.col'), 'the ccn fabric\'s colour');
// The casing is what parts a tube from the map: 3:1 at least on the land and both ends of the sea, in either theme.
// The cores sit inside it, so they must stand out from it (the unlit fiber and the purple circuit are the darkest).
for (const t of ['light', 'dark']) {
for (const bg of ['land', 'sea', 'sea2']) assert.ok(cr(P[t].casing, P[t][bg]) >= 3, `${t}: the casing on the ${bg}: ${cr(P[t].casing, P[t][bg]).toFixed(2)}`);
for (const [k, c] of Object.entries(col)) assert.ok(cr(c, P[t].casing) >= 2.5, `${t}: the ${k} core in its casing: ${cr(c, P[t].casing).toFixed(2)}`);
}
// In 2D: each core is stroked right over its casing, in the theme's colour, and a switch changes it on the next frame.
ev("window.__st=[];CTX0.stroke=function(){__st.push(this.strokeStyle);};");
const strokes = (t) => JSON.parse(ev(`(()=>{__st.length=0;draw(${t});return JSON.stringify(__st);})()`));
const under = (st, c) => st.flatMap((x, i) => (x === c && i ? [st[i - 1]] : []));
let st = strokes(1000);
for (const c of Object.values(col)) assert.deepEqual([...new Set(under(st, c))], [P.light.casing], `light: ${c} over the light casing`);
ev("ACT.themeSet({v:'dark'})");
st = strokes(1016);
for (const c of Object.values(col)) assert.deepEqual([...new Set(under(st, c))], [P.dark.casing], `dark: ${c} over the dark casing`);
assert.deepEqual(errors, []);
});
test('on the graphics card the tubes\' casing is the theme\'s too (a uniform: the tubes\' buffers are not rebuilt)', () => {
const { ev, errors } = load();
ev(started + TUBES);
ev(STUB);
const P = JSON.parse(ev('JSON.stringify(MAP_PAL)'));
assert.ok(ev('GL_LINE_VS').includes('col=vec4(uCas,1.)'), 'the casing pass takes its colour from uCas');
assert.ok(!ev('GL_LINE_VS').includes('30./255.'), 'no casing colour left in the line shader');
ev("GLX.line.u.uCas='uCas'");
const rgb = (s) => JSON.parse(ev(`JSON.stringify(glColor(${JSON.stringify(s)}).slice(0,3))`)).map((v) => Math.round(v * 1e4) / 1e4).join(',');
const frame = (t) => JSON.parse(ev(`(()=>{GLX.gl.calls.length=0;draw(${t});const c=GLX.gl.calls;
return JSON.stringify({cas:[...new Set(c.filter(x=>x[0]==='uniform3f'&&x[1]==='uCas').map(x=>x.slice(2).map(v=>Math.round(v*1e4)/1e4).join(',')))],
tubes:c.filter(x=>x[0]==='bufferData'&&x[1]===GLX.lv.b).length,seg:GLX.nSeg});})()`));
let f = frame(1000);
assert.equal(ev('glOn()'), true);
assert.ok(f.seg > 0, 'tubes on the card');
assert.deepEqual(f.cas, [rgb(P.light.casing)]);
ev("ACT.themeSet({v:'dark'})");
f = frame(1016);
assert.deepEqual(f.cas, [rgb(P.dark.casing)], 'the dark casing on the next frame');
assert.equal(f.tubes, 0, 'without building the tubes again');
assert.deepEqual(errors, []);
});
test('a puzzle\'s stepping stones keep a dashed ring that reads on the night land and sea', () => {
const { ev, errors } = load();
ev("localStorage.removeItem('sot-puzzles');pzBegin(pzDef('baltic'));closeModal();");
assert.equal(ev("pzKind('hel')"), 'via', 'Helsinki is the stepping stone');
const P = JSON.parse(ev('JSON.stringify(MAP_PAL)'));
// An rgba() ring over a solid background, as the eye sees it.
const over = (rgba, bg) => { const [r, g, b, a] = rgba.match(/[\d.]+/g).map(Number), h = bg.replace('#', '');
return '#' + [r, g, b].map((v, i) => Math.round(v * a + parseInt(h.slice(i * 2, i * 2 + 2), 16) * (1 - a)).toString(16).padStart(2, '0')).join(''); };
for (const t of ['light', 'dark']) for (const bg of ['land', 'sea']) {
const c = cr(over(P[t].via, P[t][bg]), P[t][bg]);
assert.ok(c >= 3, `${t}: the stepping-stone ring on the ${bg}: ${c.toFixed(2)}`);
}
// The ring a frame strokes (dashed 5,5) is the theme's.
ev("window.__st=[];window.__d='';CTX0.setLineDash=function(a){__d=String(a);};CTX0.stroke=function(){__st.push(this.strokeStyle+'|'+__d);};");
const rings = (t) => JSON.parse(ev(`(()=>{__st.length=0;cam.x=CITY.hel.x;cam.y=CITY.hel.y;cam.z=2;draw(${t});return JSON.stringify([...new Set(__st.filter(s=>s.endsWith('|5,5')).map(s=>s.split('|')[0]))]);})()`));
assert.deepEqual(rings(1000), [P.light.via]);
ev("ACT.themeSet({v:'dark'})");
assert.deepEqual(rings(1016), [P.dark.via]);
assert.deepEqual(errors, []);
});
test('the Pie globe starts at night in the dark theme, unless the player picked day or night', () => {
let h = load({ storage: { 'sot-theme': 'dark' } });
assert.equal(h.ev('pgNightPref()'), true);
h.ev("ACT.themeSet({v:'light'})");
assert.equal(h.ev('PG.night'), false, 'it follows the theme while the player has not chosen');
h = load({ storage: { 'sot-theme': 'dark', 'sot-globe': 'day' } });
assert.equal(h.ev('pgNightPref()'), false, 'the player\'s day view stays');
h.ev("ACT.themeSet({v:'light'});ACT.themeSet({v:'dark'})");
assert.equal(h.ev('PG.night'), false);
assert.deepEqual(h.errors, []);
});
test('dark on a phone (360 px): the settings row, the panels and every language', () => {
for (const lang of ['en', 'de', 'fr']) {
const { dom, ev, errors } = load({ lang: lang === 'en' ? undefined : lang, storage: { 'sot-theme': 'dark' } });
const doc = dom.window.document;
ev("window.innerWidth=360;window.innerHeight=740;" + started + "ACT.launchBB({city:S.home});UI.sel={type:'city',id:S.home};renderAll();ACT.settings({});");
const line = doc.querySelector('#modalCard [data-act="themeSet"]').closest('.setline');
assert.ok(line, 'the Theme row is a settings line');
assert.equal(line.querySelectorAll('[data-act="themeSet"]').length, 3);
const names = [...line.querySelectorAll('[data-act="themeSet"]')].map((b) => b.textContent);
if (lang === 'de') assert.deepEqual(names, ['Auto', 'Hell', 'Dunkel']);
if (lang === 'fr') assert.deepEqual(names, ['Auto', 'Clair', 'Sombre']);
ev("ACT.settingsClose({});ACT.dash({})");
for (const id of ['hud', 'panelBody', 'leftBody', 'dashCard', 'tabbar']) {
const t = doc.getElementById(id).textContent;
assert.doesNotMatch(t, /\b(settings|common)\.[a-z0-9_]+\b|undefined|NaN/, `${lang} ${id}`);
}
assert.equal(ev('isPhone()'), true);
assert.equal(doc.documentElement.getAttribute('data-theme'), 'dark');
assert.deepEqual(errors, []);
dom.window.close();
}
});
// The styles: every dark token the panels use is defined, and text on the dark panels passes WCAG AA (4.5:1).
test('the dark look defines every token it is used with, and its text reads (AA)', () => {
const html = assemble().html, css = html.slice(html.indexOf('<style>'), html.indexOf('</style>'));
const block = (sel) => { const i = css.indexOf(sel + '{'); assert.ok(i >= 0, sel); return css.slice(i, css.indexOf('}', i)); };
const dark = block(':root[data-theme="dark"]'), light = block(':root');
const val = (b, k) => { const m = new RegExp(`--${k}:\\s*([^;\\n]+);`).exec(b); return m && m[1].trim(); };
// Every var(--tint-…, light) and var(--tx-…, light) in the styles and the game's own markup has a dark value.
const src = css + fs.readdirSync(path.join(__dirname, '..', 'src', 'game'), { recursive: true }).filter((f) => f.endsWith('.js')).map((f) => fs.readFileSync(path.join(__dirname, '..', 'src', 'game', f), 'utf8')).join('\n');
const used = new Set([...src.matchAll(/var\(--((?:tint|tx)-[a-z]+),\s*#[0-9A-Fa-f]{3,6}\)/g)].map((m) => m[1]));
assert.ok(used.size >= 8, `tints in use (${[...used]})`);
for (const k of used) assert.ok(val(dark, k), `--${k} has a dark value`);
// Every plain var(--x) in the styles is defined for the light look (dark only overrides).
for (const m of css.matchAll(/var\(--([a-z0-9-]+)\)/g)) if (!/^(tabbar|app-h|c|rc|d|x|t|r|dl|pzdock)$/.test(m[1])) assert.ok(val(light, m[1]), `--${m[1]} is defined`);
const bgs = ['paper', 'soft', 'tint-y', 'tint-g', 'tint-r', 'tint-p', 'tint-b', 'tint-v', 'tint-o', 'tint-n'].map((k) => [k, val(dark, k)]);
for (const t of ['text', 'ink2', 'eye']) for (const [k, b] of bgs) assert.ok(cr(val(dark, t), b) >= 4.5, `--${t} on --${k}: ${cr(val(dark, t), b).toFixed(2)}`);
for (const t of ['tx-red', 'tx-amber']) assert.ok(cr(val(dark, t), val(dark, 'paper')) >= 4.5, `--${t} on the dark paper`);
// The outline stays dark in both looks, so text on bright fills (yellow buttons, warning tags) keeps reading.
assert.ok(cr(val(dark, 'ink'), '#FFD23F') >= 7, 'dark ink on the yellow buttons');
// Badge labels (10px, so 4.5:1) on their night cards: each variant's gradient, and the dimmed card of one not earned now.
const rules = css.replace(/\/\*[\s\S]*?\*\//g, '').split('}').map((r) => { const i = r.indexOf('{'); return i < 0 ? null : { sel: r.slice(0, i).split(',').map((x) => x.trim()), body: r.slice(i + 1) }; }).filter(Boolean);
const decl = (sel, prop) => { let v = null; for (const r of rules) if (r.sel.includes(sel)) { const m = new RegExp(`(?:^|;)\\s*${prop}\\s*:\\s*([^;]+)`).exec(r.body); if (m) v = m[1].trim(); } return v; };
const D = ':root[data-theme="dark"] ';
for (const v of ['freeze', 'bgp']) {
const label = decl(D + `.bdg.v-${v} .bv`, 'color') || decl(`.bdg.v-${v} .bv`, 'color'), stops = decl(D + `.bdg.on.v-${v}`, 'background').match(/#[0-9A-Fa-f]{6}/g);
assert.ok(label && stops.length >= 2, v);
for (const b of [...stops, val(dark, 'tint-n')]) assert.ok(cr(label, b) >= 4.5, `the ${v} badge label ${label} on ${b}: ${cr(label, b).toFixed(2)}`);
}
// The dashboard's Demand key is an outline in its line's colour (--text): dark ink by day as before, light at night.
assert.equal(val(light, 'text'), val(light, 'ink'), 'by day the key looks as it always did');
assert.ok(cr(val(dark, 'text'), val(dark, 'paper')) >= 3, 'at night the key\'s outline shows on the card');
});
test('the dashboard\'s Demand key matches its dashed line, by night too', () => {
const { dom, ev, errors } = load({ storage: { 'sot-theme': 'dark' } });
ev(started + "for(let i=0;i<3;i++)dayTick();ACT.dash({});");
const card = dom.window.document.getElementById('dashCard');
const line = card.querySelector('svg path[stroke-dasharray="5 4"]');
assert.ok(line, 'the dashed Demand line');
const stroke = /stroke:\s*([^;"]+)/.exec(line.getAttribute('style'))[1].trim();
const key = [...card.querySelectorAll('.legend .lg')].find((b) => JSON.parse(b.dataset.args).k === 'dem').querySelector('i');
assert.equal(key.style.borderStyle, 'dashed');
assert.equal(key.style.borderColor, stroke, 'the key is outlined in the line\'s own colour');
assert.equal(stroke, 'var(--text)');
assert.deepEqual(errors, []);
dom.window.close();
});