Files
pplus-web/scripts/quarto-css.mjs
T
alexm 7000662539
Build, test, deploy / site (push) Successful in 7m44s
A proof's time limit is the reader's to set
The Prove view gives each routine 3 seconds on the clock. On a slow or
busy device that runs out before the proof does, and claims stay open
with nothing to say why.

- The view says when the time, not the proof, stopped the checker, that
  what was not finished is open and not disproved, and offers to prove
  again with the next longer time. The setting is at the foot of the
  view: 3, 10 or 30 seconds or 2 minutes for each routine, kept in the
  browser (pplus.proveclock).
- A proof rendered with Quarto takes prove-seconds on the shortcode or
  pplus-prove-seconds for the site, and the render warns when the time
  ran out.
- The home page's own example is proved with no time on the clock, and
  the tests that hold a proof's outcome give it time to spare, so
  neither depends on the machine.
- core moves to 38e6e2c, whose report says which routines the clock
  stopped.
2026-11-13 07:01:35 -05:00

167 lines
9.6 KiB
JavaScript

#!/usr/bin/env node
// SPDX-FileCopyrightText: 2026 Scientific Computing Studio, LLC
// SPDX-License-Identifier: Apache-2.0
/**
* Write quarto/_extensions/pplus/pplus-views.css: the app's own rules for what the static views draw, so a Quarto
* page shows the flowchart, the table of values, the proof and the rest exactly as the app does.
*
* pixi run quarto-css (build first; `pixi run test` fails while the file is out of date)
*
* It renders every static view of a few catalog problems (src/quarto/render.ts, as `quarto render` would), collects
* the classes they use, and copies from styles.css every rule whose selectors use only those classes, each selector
* scoped under `.pplus-static`. The app's color tokens come along: light by default, dark when the Quarto page is
* dark (`body.quarto-dark`, or Bootstrap's `data-bs-theme="dark"`); the paper and ink follow the page's own.
*
* It also copies the course's stylesheets for the machine views (course/*.css), writes pplus-hw.css from
* styles/course/bridge.css, and copies pplus-core's KDE syntax for Mojo (core/library/syntax/mojo.xml, which core's corpus
* pipeline writes) to syntax/mojo.xml, for the listings Pandoc highlights.
*
* node scripts/quarto-css.mjs --check exit 1 if a file is not what this would write
*/
import fs from 'node:fs';
import path from 'node:path';
import { fileURLToPath, pathToFileURL } from 'node:url';
const ROOT = fileURLToPath(new URL('..', import.meta.url));
const OUT = path.join(ROOT, 'quarto/_extensions/pplus/pplus-views.css');
const dist = (p) => pathToFileURL(path.join(ROOT, 'dist', p)).href;
if (!fs.existsSync(path.join(ROOT, 'dist/quarto/render.js'))) { console.error('quarto-css: dist/ is missing; run `pixi run build` first'); process.exit(1); }
const { installDocument } = await import(dist('quarto/dom.js'));
installDocument();
const { renderStatic, STATIC_VIEWS } = await import(dist('quarto/render.js'));
const { problemById } = await import(dist('core/catalog.js'));
/* ---------- the classes the views use ---------- */
const samples = [];
for (const id of ['count-base', 'count-base-proved', 'match-off-by-one', 'five-bugs', 'binary-search', 'asm-two-pointers', 'demo']) {
const p = problemById(id);
const files = Object.fromEntries(Object.entries(p.sources).filter(([, v]) => typeof v === 'string' && v.trim()));
for (const lang of Object.keys(files)) samples.push({ files, lang, call: p.call ?? null, setup: p.setup, machine: p.machine });
}
samples.push({ files: { mojo: fs.readFileSync(path.join(ROOT, 'core/library/mojo/stress/lifecycle-moves.mojo'), 'utf8') }, lang: 'mojo' });
const used = new Set();
for (const s of samples) for (const view of STATIC_VIEWS.filter((v) => v !== 'hw')) {
let html = '';
try { html = renderStatic({ ...s, view }).html; } catch { continue; }
for (const m of html.matchAll(/class="([^"]*)"/g)) for (const c of m[1].split(/\s+/)) if (c) used.add(c);
}
// the editor's token colors and the step colors, whichever a sample happened to show
for (const c of ['tok-keyword', 'tok-builtin', 'tok-string', 'tok-number', 'tok-comment', 'tok-label', 'tok-op', 'tok-error', 'tok-punct', 'tok-convention', 'tok-transfer', 'tok-name']) used.add(c);
// the notice a rendered proof carries when the build machine ran out of the prover's time: no sample does (it is the machine's)
used.add('proof-timeout');
/* ---------- styles.css as rules ---------- */
/** Top-level rules and @media blocks: { selector, body } or { media, rules }. Comments are dropped. */
function parse(css) {
css = css.replace(/\/\*[\s\S]*?\*\//g, '');
const out = [];
let i = 0;
const block = (from) => { let depth = 0; for (let k = from; k < css.length; k++) { if (css[k] === '{') depth++; else if (css[k] === '}' && --depth === 0) return k; } return css.length; };
while (i < css.length) {
const open = css.indexOf('{', i);
if (open < 0) break;
const prelude = css.slice(i, open).trim();
const close = block(open);
const body = css.slice(open + 1, close);
if (prelude.startsWith('@media')) out.push({ media: prelude, rules: parse(body) });
else if (!prelude.startsWith('@')) out.push({ selector: prelude, body: body.trim() });
i = close + 1;
}
return out;
}
const tokens = { light: new Map(), dark: new Map() };
const LIGHT = /^:root$/, DARK = /^:root\[data-theme="dark"\]$/;
const SKIP_TOKENS = new Set(['--paper', '--paper-2', '--paper-3', '--ink', '--ink-2', '--ink-3', '--line', '--line-2', '--mono', '--sans', 'color-scheme']);
/** A selector the static views can use: every class in it is one they emit, and nothing in it names the app's page. */
function keep(sel) {
if (/(^|[\s>+~(,])(html|body|:root)\b/.test(sel) || /\[data-theme|\.is-embed|\.shell|\.home|::?-webkit|:hover|:focus|:active/.test(sel)) return false;
const classes = [...sel.matchAll(/\.([\w-]+)/g)].map((m) => m[1]);
if (!classes.length) return false;
return classes.every((c) => used.has(c));
}
function scoped(rules, indent = '') {
const lines = [];
for (const r of rules) {
if (r.media) {
// the app's narrow-screen rearrangements are for its workspace; a page keeps the view's own layout
continue;
}
const sels = r.selector.split(',').map((s) => s.trim());
if (sels.length === 1 && LIGHT.test(sels[0])) { collect(r.body, tokens.light); continue; }
if (sels.length === 1 && DARK.test(sels[0])) { collect(r.body, tokens.dark); continue; }
const kept = sels.filter(keep);
if (!kept.length || !r.body) continue;
lines.push(`${indent}${kept.map((s) => `.pplus-static ${s}`).join(',\n' + indent)} {\n${r.body.split('\n').map((l) => `${indent} ${l.trim()}`).filter((l) => l.trim()).join('\n')}\n${indent}}`);
}
return lines;
}
function collect(body, into) {
for (const decl of body.split(';')) {
const k = decl.slice(0, decl.indexOf(':')).trim();
const v = decl.slice(decl.indexOf(':') + 1).trim();
if (k.startsWith('--') && v && !SKIP_TOKENS.has(k)) into.set(k, v);
}
}
const rules = scoped(parse(fs.readFileSync(path.join(ROOT, 'styles.css'), 'utf8')));
const decls = (m) => [...m].map(([k, v]) => ` ${k}: ${v};`).join('\n');
const text = `/* pplus-views.css: GENERATED by \`pixi run quarto-css\` (scripts/quarto-css.mjs) from styles.css. Do not edit.
The app's own rules for what the static views draw, scoped under .pplus-static, with the app's color tokens;
the paper and ink follow the Quarto page (Bootstrap's variables). */
.pplus-static {
--paper: var(--bs-body-bg, #ffffff);
--paper-2: color-mix(in srgb, var(--bs-body-bg, #ffffff) 94%, var(--bs-body-color, #16191f));
--paper-3: color-mix(in srgb, var(--bs-body-bg, #ffffff) 88%, var(--bs-body-color, #16191f));
--ink: var(--bs-body-color, #16191f);
--ink-2: color-mix(in srgb, var(--bs-body-color, #16191f) 68%, var(--bs-body-bg, #ffffff));
--ink-3: color-mix(in srgb, var(--bs-body-color, #16191f) 48%, var(--bs-body-bg, #ffffff));
--line: color-mix(in srgb, var(--bs-body-color, #16191f) 14%, var(--bs-body-bg, #ffffff));
--line-2: color-mix(in srgb, var(--bs-body-color, #16191f) 24%, var(--bs-body-bg, #ffffff));
--mono: var(--bs-font-monospace, "IBM Plex Mono", ui-monospace, Menlo, Consolas, monospace);
--sans: inherit;
--bg: var(--paper); --bg-2: var(--paper-2); --bg-3: var(--paper-3); --fg: var(--ink); --fg-2: var(--ink-2); --note: var(--ink-3);
--current: var(--marker-bg); --last: var(--last-bg); --radius: var(--r-lg);
${decls(tokens.light)}
}
body.quarto-dark .pplus-static,
[data-bs-theme="dark"] .pplus-static {
${decls(tokens.dark)}
}
${rules.join('\n\n')}
`;
/* ---------- the machine views: the course's stylesheets, as the board uses them ---------- */
// tokens.css, kit.css and asm86.css are the course site's own, written for Quarto pages: they go in unchanged
// (styles/course/README.md). bridge.css's :root block maps the app's tokens onto the ones a Quarto page already
// has, so a page gets the rest of it: the board's adjustments to the course views.
const EXT = path.join(ROOT, 'quarto/_extensions/pplus');
const outputs = [[OUT, text]];
for (const f of ['tokens.css', 'kit.css', 'asm86.css']) outputs.push([path.join(EXT, 'course', f), fs.readFileSync(path.join(ROOT, 'styles/course', f), 'utf8')]);
const bridge = fs.readFileSync(path.join(ROOT, 'styles/course/bridge.css'), 'utf8');
const afterRoot = bridge.slice(bridge.indexOf('}', bridge.indexOf(':root {')) + 1).replace(/^\s+/, '');
outputs.push([path.join(EXT, 'pplus-hw.css'), `/* pplus-hw.css: GENERATED by \`pixi run quarto-css\` (scripts/quarto-css.mjs) from styles/course/bridge.css. Do not edit.
The Hardware board's adjustments to the course's machine views (course/*.css), for the pplus-hw shortcodes. A Quarto
page already has the colors and fonts those files read (--bs-body-bg, --bs-body-color, body.quarto-dark). */
${afterRoot}`]);
outputs.push([path.join(EXT, 'syntax', 'mojo.xml'), fs.readFileSync(path.join(ROOT, 'core/library/syntax/mojo.xml'), 'utf8')]);
if (process.argv.includes('--check')) {
const stale = outputs.filter(([file, want]) => !fs.existsSync(file) || fs.readFileSync(file, 'utf8') !== want).map(([file]) => path.relative(ROOT, file));
if (stale.length) { console.error(`quarto-css: out of date: ${stale.join(', ')}; run \`pixi run quarto-css\``); process.exit(1); }
console.log('quarto-css: up to date');
} else {
for (const [file, want] of outputs) { fs.mkdirSync(path.dirname(file), { recursive: true }); fs.writeFileSync(file, want); }
console.log(`quarto-css: wrote ${outputs.map(([f]) => path.relative(ROOT, f)).join(', ')} (${rules.length} rules, ${used.size} classes)`);
}
process.exit(0);