seriesoftubes/tests/dark-mode.test.js
jvanvik 08eb349d87
Some checks are pending
CI / plan (push) Waiting to run
CI / part (push) Blocked by required conditions
CI / build (push) Waiting to run
CI / translations (push) Waiting to run
CI / test (push) Blocked by required conditions
CI / timings (push) Blocked by required conditions
Container image / gate (push) Waiting to run
Container image / test (push) Blocked by required conditions
Container image / publish (push) Blocked by required conditions
Merge upstream: POP standards, latency contracts, device transfer, typed links and NOC downgrades (3.4.0, 3.5.0)
Conflicts, file by file:
- CHANGELOG.md: the fork's Unreleased bullets on top; 3.5.0 and 3.4.0 exactly as upstream has them.
- src/i18n/en.js, site/i18n/{de,es,fr,it,pt}.js: merged label by label, sorted; the labels each side dropped stay dropped.
- src/agent/10-domains.js, 30-docs.js, 40-read.js: both sides' enums, state docs and tables (popStd as the build standard, popTiers, ip4, mp).
- src/agent/20-commands.js: the fork's wording on accept and upRouter, upstream's acceptFix, utilityKitAll/New and pt*; theme, session and transfer acts in the local table.
- src/game/60-features/80-new-game.js: ip4, rgen and mp next to popTiers.
- src/game/80-simulation/29-route-core.js, 30-compute.js: the route core takes both SATN and the spill tiers (TT).
- src/game/80-simulation/40-billing.js: upstream's gulfPair and borderShut; linkCut() is built on borderShut, linkDown() keeps express and satellite.
- src/game/80-simulation/50-sanitize.js: PNI bundles up to PNI_LAG_MAX next to the fork's link kinds; popStdSanitize then ptSanitize; mpSanitize then lcSanitize.
- src/game/80-simulation/75-customer-lifecycle.js: clGrow() stops at a type's most (#137) and at an IPv4 block that is not free (#150).
- src/game/90-actions/60-links.js: rmLink keeps the express guard and moves on to the next parallel link (#119).
- src/game/90-actions/85-routing-and-routers.js: rmRouter checks the PNIs on its routers (#323), upRouter keeps own().
- src/game/90-actions/89-game-and-settings.js: the menu keeps the build standard and session tiles and gains Send to another device.
- src/game/93-ui/40-hud-and-panels.js, 70-link-panels.js: offers show both the IPv4 note and Buy and sign; link headers name their cities, the closed-border section reads in dark mode; the express count stays.
- src/game/93-ui/50-city-panel.js: the teleport section and Link to a city.
- src/game/94-dashboard/40-connections.js: upstream's per-table next port size replaces the fork's own 400G guard.
- src/game/94-dashboard/90-noc-window.js, 96-map/95-clicks.js, 99-loop.js: both sides' acts and boot steps.
- src/styles/40-modal.css: the dark-mode tag tokens and the transfer textarea.
- tests/mcp-commands.test.js: both sides' sample args.

Interaction fixes:
- POP standards and the build standard: a POP marked as a kind keeps its kind's routers (ptKind). The build
  standard's router jobs and the intern's model swaps leave it alone; every other target still applies. Both sheets say so.
- Spill tiers: pathMs() fills a path's ground latency and satellite edges too, so a tier's detour costs users its
  latency (it went uncharged before).
- Send to another device: a session network goes by the session's own #mp= link; its save file is called a copy.
- Buy and sign (#241) does not buy for an offer whose IPv4 block does not fit.
- Dark mode: the closed-border title and the renewal ticks use the dark-aware red (upstream's #292 test follows).
- Server-run tables: the new acts classified (pt*, acceptFix and utilityKitAll quote their cost); mp-sim fixtures
  written again with tests/lib/mp-sim-fixtures.js.

Review fixes:
- POP standards: ptSave, ptApply, ptPlan, ptAll and popStdSet find a POP with own(), so 'toString' is no POP (also
  decomToggle, decomGo, dkStay).
- Server-run envelope: an arg value that names anything on Object.prototype is refused, in args, drafts and
  ctx.win.ui.
- Decommissioning a POP drops its POP-standard mark, so live state stays what a reload makes of it (the T2 gate
  refused later pt* acts).
- acceptFix, ptApply, ptAll and utilityKitAll take a quote within 1% (quoteNear), like utilityKit and bstdApply:
  router prices drift daily.
- The transfer paste box reads in dark mode (--text, as input.t).
- A session's #mp= link pasted under From another device opens it (saved, then loaded again with it), in MP builds.
- The express and satellite circuit panels name their cities as links (#196); a circuit shows the closed-border
  section (#329).
- CHANGELOG: the fork's 400G connections bullet goes (3.5.0 ships it); bullets for POP kinds, the session link and Buy
  and sign's IPv4 check.
2026-11-12 00:52:42 +01:00

443 lines
33 KiB
JavaScript
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

// 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. Read
// from the page's HTML (the harness runs script bodies outside the DOM, so a <script>'s text is empty there).
const html = assemble().html, headEnd = html.indexOf('</head>'), st = html.indexOf('<style>');
const scripts = [...html.slice(0, headEnd).matchAll(/<script>([\s\S]*?)<\/script>/g)], s = scripts.find((m) => /sot-theme/.test(m[1]));
assert.ok(s && st >= 0 && st < headEnd && s.index < 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();");
// mapStill() says how the map stands (MAP_MOVING, MAP_AMBIENT, MAP_STILL; 99-loop.js), not just whether it is still.
assert.equal(ev('mapStill(0,performance.now())'), ev('MAP_STILL'), 'an unchanged frame is skipped');
ev("ACT.themeSet({v:'light'})");
assert.equal(ev('mapStill(0,performance.now())'), ev('MAP_MOVING'), '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)}`);
// The text colours of warnings and tags read on every card and tint they sit on, not only on the paper.
for (const t of ['tx-red', 'tx-amber', 'tx-blue']) 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)}`);
// 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');
});
// Two things that kept their day colours at night: the capacity market's Hot and Cool tags (bright pastel chips on the
// dark dashboard), and red warning text in var(--bad), 3.8 to 4.8:1 on the dark cards. --bad stays the fill under white
// letters (buttons, counters, bars); text takes var(--tx-red,var(--bad)), which by day is --bad as before.
test('at night the market\'s Hot and Cool tags take the dark tints, and red text reads (AA) on every card', () => {
const html = assemble().html, css = html.slice(html.indexOf('<style>'), html.indexOf('</style>')).replace(/\/\*[\s\S]*?\*\//g, '');
const block = (sel) => { const i = css.indexOf(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(); };
const rules = css.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; };
// var(--token,fallback) as each look paints it: the dark value, or the fallback (the light look never sets the tint).
const paint = (v, look) => { const m = /^var\(--([a-z-]+),\s*(#[0-9A-Fa-f]{6})\)$/.exec(v); assert.ok(m, `a themed colour: ${v}`); return look === 'dark' ? val(dark, m[1]) : (assert.equal(val(light, m[1]), null, `--${m[1]} is dark-only`), m[2]); };
for (const [tag, bg, fg, was] of [['cmhot', 'tint-o', 'tx-amber', ['#FFE1D6', '#B43A12']], ['cmcool', 'tint-b', 'tx-blue', ['#DDF1FB', '#1E6A8C']]]) {
const b = decl(`.tag.${tag}`, 'background'), c = decl(`.tag.${tag}`, 'color');
assert.ok(b.startsWith(`var(--${bg},`) && c.startsWith(`var(--${fg},`), `.tag.${tag}: ${b} / ${c}`);
assert.deepEqual([paint(b, 'light'), paint(c, 'light')], was, `.tag.${tag} looks as it did by day`);
const r = cr(paint(c, 'dark'), paint(b, 'dark'));
assert.ok(r >= 4.5, `.tag.${tag} at night: ${r.toFixed(2)}`);
}
// No tag keeps a bare pastel fill: it would be a bright patch on the dark panels.
const pale = (h) => lum(h) > 0.5;
for (const r of rules) if (!r.sel.some((s) => s.startsWith(':root')) && r.sel.some((s) => /\.tag\b/.test(s))) {
const m = /(?:^|;)\s*background\s*:\s*(#[0-9A-Fa-f]{6})\b/.exec(r.body);
assert.ok(!(m && pale(m[1])), `${r.sel.join(',')} has a bare pastel background ${m && m[1]}`);
}
// Red as text takes the dark-aware colour everywhere, in the styles and in the game's own markup and HUD (the test
// above checks --tx-red on every card and tint). `color:var(--bad)`, `color:${x?'var(--bad)':…}`, `.style.color=…'var(--bad)'`.
const RED = /(?<![-\w])color\s*(?::|=)\s*(?:\$\{[^}]*?|[^;'"`{}(]*?)'?(?<!--tx-red,)var\(--bad\)/g;
const cssLeft = [...css.matchAll(RED)].map((m) => m[0]);
assert.deepEqual(cssLeft, [], 'red text in the styles in --bad');
const dir = path.join(__dirname, '..', 'src', 'game'), left = [];
for (const f of fs.readdirSync(dir, { recursive: true }).filter((f) => f.endsWith('.js'))) {
const s = fs.readFileSync(path.join(dir, f), 'utf8');
for (const m of s.matchAll(RED)) left.push(`${f}: ${m[0].slice(-60)}`);
}
assert.deepEqual(left, [], 'red text in the game\'s markup in --bad');
// The fills keep --bad (white letters on it): a button, a counter, a bar.
assert.equal(decl('.b.red', 'background'), 'var(--bad)');
assert.equal(decl('.b.red', 'color'), '#fff');
});
// --ink stays near-black at night: it is the outline and the text on bright fills (yellow buttons, warning tags). Text in
// it on a card's own fill (--soft, --paper) all but vanishes in the dark look, as the transfer paste box's did (1.5:1):
// such text takes --text, as input.t does.
test('at night no text is --ink on a card\'s own fill: the transfer paste box reads (AA)', () => {
const html = assemble().html, css = html.slice(html.indexOf('<style>'), html.indexOf('</style>')).replace(/\/\*[\s\S]*?\*\//g, '');
const block = (sel) => { const i = css.indexOf(sel + '{'); return css.slice(i, css.indexOf('}', i)); };
const dark = block(':root[data-theme="dark"]');
const val = (b, k) => { const m = new RegExp(`--${k}:\\s*([^;\\n]+);`).exec(b); return m && m[1].trim(); };
const rules = css.split('}').map((r) => { const i = r.indexOf('{'); return i < 0 ? null : { sel: r.slice(0, i).trim(), body: r.slice(i + 1) }; }).filter(Boolean);
const prop = (b, p) => { const m = new RegExp(`(?:^|;)\\s*${p}\\s*:\\s*([^;]+)`).exec(b); return m && m[1].trim(); };
const ink = rules.filter((r) => !r.sel.startsWith(':root') && /^var\(--(soft|paper)\)$/.test(prop(r.body, 'background') || '') && prop(r.body, 'color') === 'var(--ink)').map((r) => r.sel);
assert.deepEqual(ink, [], '--ink text on --soft or --paper');
const box = rules.find((r) => r.sel === 'textarea.xfer-in');
assert.ok(box, 'the paste box has its rule');
assert.equal(prop(box.body, 'color'), 'var(--text)');
assert.equal(prop(box.body, '-webkit-text-fill-color'), 'var(--text)');
assert.ok(cr(val(dark, 'text'), val(dark, 'soft')) >= 4.5, `--text on --soft: ${cr(val(dark, 'text'), val(dark, 'soft')).toFixed(2)}`);
});
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();
});