mirror of
https://github.com/max-sixty/worktrunk.git
synced 2026-11-23 01:51:13 +08:00
Adds a **Try it** page at `/try-it/`, available by direct URL while production embedding is tested; excluded from navigation, site search, and the sitemap, with a noindex directive, with a live Worktrunk demo in a browser-local Alpine ARM64 VM via [Demoshell](https://demoshell.com). Nothing downloads until Run is pressed. The page includes Demoshell attribution and a permanent full-page fallback link. The VM definition lives in `docs/demos/demoshell/`: the setup recipe, Bash startup rcfile, and guide. The guide covers list → create → edit → list → merge, followed by an optional manual picker step. Merge commits the change automatically. Studio must launch Bash explicitly: changing root's login shell does not replace its running ash session. The prompt retains the `arm64js:` prefix required by Demoshell's command tracker. The README maps each file to its Studio field and provides an ARM64 Alpine Docker check using the same Bash entry point. **Production test rollout:** `m/tui:worktrunk` resolves from the allowed `worktrunk.dev` origin. The recipe, startup file, and guide draft are entered in Studio, but the final snapshot upload is stalled at 1% after setup completes. The currently published snapshot predates the prompt repair, and visitors still receive the old guide. The page is intentionally unlinked so it can be merged and tested on the accepted production origin before broader exposure. The corrected snapshot must finish saving, then the new guide must be published and tested in a fresh visitor session. Validation: the required command patterns and output checks pass on ARM64 Alpine with `wt v0.81.0`. In the real Studio preview, applying the Bash/prompt corrections allowed the required steps to check off, merge to commit automatically, and the shell to return to main. The optional picker opens and exits; its guide step uses manual completion because Demoshell did not detect the alternate-screen exit. Local docs build, type checks, plugin/site tests, and docs sync passed. Final snapshot publication and a fresh end-to-end run remain blocked by the upload. The sidebar-order test accepts Astro page routes, and the page-outline test exempts `/try-it/`, whose table of contents is disabled to give the demo more width. Disclosure from the original author: they run Demoshell. Hosting is free for eligible open-source projects, and the embed carries attribution. > _This was written by Codex on behalf of max-sixty_ --------- Co-authored-by: worktrunk-bot <254187624+worktrunk-bot@users.noreply.github.com> Co-authored-by: Claude <noreply@anthropic.com> Co-authored-by: Maximilian Roos <m@maxroos.com>
663 lines
28 KiB
JavaScript
663 lines
28 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import { readdir, readFile } from 'node:fs/promises';
|
|
import path from 'node:path';
|
|
import test from 'node:test';
|
|
import { fileURLToPath } from 'node:url';
|
|
|
|
import {
|
|
keepCurrentTocLinkVisible,
|
|
syncTocCurrentToHash,
|
|
} from '../src/components/toc-scroll.mjs';
|
|
|
|
import { withoutTrailingShellComments } from '../src/plugins/worktrunk-terminal.mjs';
|
|
|
|
const docsRoot = fileURLToPath(new URL('..', import.meta.url));
|
|
const dist = path.join(docsRoot, 'dist');
|
|
const publicRoutes = [
|
|
'/',
|
|
'/claude-code/',
|
|
'/code-signing/',
|
|
'/config/',
|
|
'/extending/',
|
|
'/faq/',
|
|
'/hook/',
|
|
'/list/',
|
|
'/llm-commits/',
|
|
'/merge/',
|
|
'/remove/',
|
|
'/step/',
|
|
'/switch/',
|
|
'/tips-patterns/',
|
|
'/try-it/',
|
|
];
|
|
|
|
async function htmlFiles(directory = dist) {
|
|
const entries = await readdir(directory, { withFileTypes: true });
|
|
const nested = await Promise.all(entries.map((entry) => {
|
|
const file = path.join(directory, entry.name);
|
|
return entry.isDirectory() ? htmlFiles(file) : entry.name.endsWith('.html') ? [file] : [];
|
|
}));
|
|
return nested.flat();
|
|
}
|
|
|
|
async function allFiles(directory = dist) {
|
|
const entries = await readdir(directory, { withFileTypes: true });
|
|
const nested = await Promise.all(entries.map((entry) => {
|
|
const file = path.join(directory, entry.name);
|
|
return entry.isDirectory() ? allFiles(file) : [file];
|
|
}));
|
|
return nested.flat();
|
|
}
|
|
|
|
function routeFile(pathname) {
|
|
if (pathname === '/') return path.join(dist, 'index.html');
|
|
if (pathname === '/404/') return path.join(dist, '404.html');
|
|
if (pathname.endsWith('/')) return path.join(dist, pathname, 'index.html');
|
|
if (pathname.endsWith('.html')) return path.join(dist, pathname);
|
|
}
|
|
|
|
const renderedPages = [
|
|
'/404/',
|
|
...publicRoutes,
|
|
'/worktrunk/',
|
|
].map(routeFile);
|
|
|
|
function fileRoute(file) {
|
|
const relative = path.relative(dist, file);
|
|
if (relative === 'index.html') return '/';
|
|
if (relative === '404.html') return '/404/';
|
|
return `/${path.dirname(relative)}/`;
|
|
}
|
|
|
|
function tableSummaries(html) {
|
|
const text = (value) => value
|
|
.replace(/<[^>]*>/g, '')
|
|
.replaceAll('&', '&')
|
|
.replaceAll('&', '&')
|
|
.replace(/\s+/g, ' ')
|
|
.trim();
|
|
return [...html.matchAll(/<table\b([^>]*)>([\s\S]*?)<\/table>/g)].map((match) => {
|
|
const body = match[2].match(/<tbody>([\s\S]*?)<\/tbody>/)?.[1] ?? '';
|
|
const rows = [...body.matchAll(/<tr\b[^>]*>([\s\S]*?)<\/tr>/g)];
|
|
return {
|
|
attributes: match[1],
|
|
headers: [...match[2].matchAll(/<th\b[^>]*>([\s\S]*?)<\/th>/g)]
|
|
.map((header) => text(header[1])),
|
|
rowLabels: rows.map((row) => (
|
|
[...row[1].matchAll(/<span\b([^>]*)>([\s\S]*?)<\/span>/g)]
|
|
.filter((label) => (
|
|
/\baria-hidden="true"/.test(label[1])
|
|
&& /\bclass="[^"]*\bwt-responsive-record-label\b[^"]*"/.test(label[1])
|
|
))
|
|
.map((label) => text(label[2]))
|
|
)),
|
|
};
|
|
});
|
|
}
|
|
|
|
function renderedText(html) {
|
|
return html
|
|
.replace(/<[^>]*>/g, '')
|
|
.replace(/&#x([\da-f]+);/giu, (_, value) => String.fromCodePoint(Number.parseInt(value, 16)))
|
|
.replace(/&#(\d+);/gu, (_, value) => String.fromCodePoint(Number(value)))
|
|
.replaceAll('"', '"')
|
|
.replaceAll('>', '>')
|
|
.replaceAll('<', '<')
|
|
.replaceAll('&', '&');
|
|
}
|
|
|
|
test('build preserves the public route contract', async () => {
|
|
const files = new Set(await htmlFiles());
|
|
const buildFiles = new Set(await allFiles());
|
|
const expected = [
|
|
path.join(dist, '404.html'),
|
|
...publicRoutes.map(routeFile),
|
|
routeFile('/worktrunk/'),
|
|
];
|
|
for (const file of expected) assert.ok(files.has(file), `missing ${file}`);
|
|
|
|
const sitemap = await readFile(path.join(dist, 'sitemap-0.xml'), 'utf8');
|
|
for (const route of publicRoutes.filter((route) => route !== '/try-it/')) {
|
|
assert.match(sitemap, new RegExp(`<loc>https://worktrunk\\.dev${route}</loc>`));
|
|
}
|
|
assert.doesNotMatch(sitemap, /worktrunk\.dev\/(?:404|worktrunk|try-it)\//);
|
|
|
|
const robots = await readFile(path.join(dist, 'robots.txt'), 'utf8');
|
|
for (const match of robots.matchAll(/^Sitemap:\s+(\S+)$/gm)) {
|
|
const url = new URL(match[1]);
|
|
assert.equal(url.origin, 'https://worktrunk.dev');
|
|
assert.ok(buildFiles.has(path.join(dist, url.pathname)), `robots.txt references missing ${url.pathname}`);
|
|
}
|
|
|
|
const compatibilityPage = await readFile(routeFile('/worktrunk/'), 'utf8');
|
|
assert.match(compatibilityPage, /<link rel="canonical" href="https:\/\/worktrunk\.dev\/"/);
|
|
assert.match(compatibilityPage, /<meta name="robots" content="noindex"/);
|
|
assert.match(compatibilityPage, /<meta property="og:url" content="https:\/\/worktrunk\.dev\/"/);
|
|
assert.doesNotMatch(compatibilityPage, /<meta property="og:url" content="https:\/\/worktrunk\.dev\/worktrunk\/"/);
|
|
|
|
const homepage = await readFile(routeFile('/'), 'utf8');
|
|
assert.match(homepage, /<title>Worktrunk — Git worktree management for parallel AI agent workflows<\/title>/);
|
|
assert.doesNotMatch(homepage, /data-contract="home-hero"/);
|
|
assert.doesNotMatch(homepage, /data-has-hero/);
|
|
assert.doesNotMatch(homepage, />\s*Learn More\s*</);
|
|
assert.match(
|
|
homepage,
|
|
/<a\b[^>]*data-contract="github-stars"[^>]*href="https:\/\/github\.com\/max-sixty\/worktrunk"[^>]*>[\s\S]*?<img\b[^>]*src="https:\/\/img\.shields\.io\/github\/stars\/max-sixty\/worktrunk\?style=social"[^>]*>[\s\S]*?<\/a>/,
|
|
);
|
|
assert.doesNotMatch(homepage, />\s*GitHub stars\s*</);
|
|
assert.match(
|
|
homepage,
|
|
/<div\b[^>]*class="wt-home"[^>]*>[\s\S]*?<p>Worktrunk is a CLI for Git worktree management, designed for <strong>parallel AI agent\s+workflows<\/strong>\.<\/p>/,
|
|
);
|
|
assert.match(homepage, /<button\b[^>]*popovertarget="starlight__sidebar"[^>]*class="[^"]*\bsl-menu-button\b[^"]*"[^>]*>[\s\S]*?<span class="sr-only[^"]*">Menu<\/span><\/button>/);
|
|
assert.match(homepage, /<sl-sidebar-pane\b[^>]*\bpopover\b[^>]*id="starlight__sidebar"[^>]*class="sidebar-pane\b/);
|
|
assert.match(homepage, /<a\b[^>]*href="\/switch\/"[^>]*><span\b[^>]*>wt switch<\/span><\/a>/);
|
|
assert.match(homepage, /<a\b[^>]*href="\/faq\/"[^>]*><span\b[^>]*>FAQ<\/span><\/a>/);
|
|
assert.doesNotMatch(homepage, /data-has-toc/);
|
|
assert.doesNotMatch(homepage, /<nav aria-labelledby="starlight__on-this-page">/);
|
|
assert.doesNotMatch(homepage, /<starlight-theme-select>/);
|
|
assert.match(homepage, /<div\b[^>]*class="wt-home"[^>]*data-contract="home-content-rail"/);
|
|
assert.match(homepage, /<h1 id="_top"[^>]*><span id="worktrunk"[^>]*>Worktrunk<\/span><\/h1>/);
|
|
assert.match(
|
|
homepage,
|
|
/<source srcset="\/assets\/docs\/dark\/wt-core-mobile\.gif"[^>]*data-demo-theme="dark"[^>]*data-demo-media="\(max-width: 42rem\)"/,
|
|
);
|
|
assert.match(
|
|
homepage,
|
|
/<source srcset="\/assets\/docs\/light\/wt-core-mobile\.gif"[^>]*data-demo-theme="light"[^>]*data-demo-media="\(max-width: 42rem\)"/,
|
|
);
|
|
assert.match(homepage, /<img src="\/assets\/docs\/light\/wt-core\.gif"/);
|
|
assert.equal(homepage.match(/<h1\b/g)?.length, 1);
|
|
assert.match(
|
|
homepage,
|
|
/<pre[^>]*><code><span class="wt-shell-command">git<\/span> <span class="wt-shell-argument">worktree<\/span> <span class="wt-shell-argument">add<\/span> <span class="wt-shell-option">-b<\/span>/,
|
|
);
|
|
const comparison = homepage.match(/<table class="cmd-compare">([\s\S]*?)<\/table>/)?.[1];
|
|
assert.ok(comparison, 'homepage is missing the command comparison table');
|
|
assert.equal(comparison.match(/<td data-label="Worktrunk">/g)?.length, 4);
|
|
assert.equal(comparison.match(/<td data-label="Plain git">/g)?.length, 4);
|
|
assert.equal(comparison.match(/class="wt-shell-command"/g)?.length, 12);
|
|
assert.equal(comparison.match(/class="wt-shell-option"/g)?.length, 4);
|
|
assert.equal(comparison.match(/class="wt-shell-argument"/g)?.length, 21);
|
|
assert.match(homepage, /class="wt-terminal-green"/);
|
|
assert.match(homepage, /class="wt-terminal-red"/);
|
|
const switchPage = await readFile(routeFile('/switch/'), 'utf8');
|
|
assert.match(switchPage, /<nav aria-labelledby="starlight__on-this-page">/);
|
|
assert.match(
|
|
switchPage,
|
|
/<a\b[^>]*data-contract="github-stars"[^>]*href="https:\/\/github\.com\/max-sixty\/worktrunk"[^>]*>[\s\S]*?<img\b[^>]*src="https:\/\/img\.shields\.io\/github\/stars\/max-sixty\/worktrunk\?style=social"[^>]*>[\s\S]*?<\/a>/,
|
|
);
|
|
assert.doesNotMatch(switchPage, /<starlight-theme-select>/);
|
|
|
|
const listPage = await readFile(routeFile('/list/'), 'utf8');
|
|
assert.match(listPage, /href="https:\/\/github\.com\/max-sixty\/worktrunk\/edit\/main\/docs\/src\/content\/docs\/list\.md"/);
|
|
assert.doesNotMatch(listPage, /docs\/src\/content\/docs\/src\/content\/docs/);
|
|
assert.match(listPage, /<span class="wt-terminal-green">\+54<\/span>/);
|
|
assert.match(listPage, /<span class="wt-terminal-red">-5<\/span>/);
|
|
assert.match(listPage, /<span class="wt-terminal-blue wt-terminal-dim">#412<\/span>/);
|
|
assert.match(
|
|
listPage,
|
|
/<div class="ec-line wt-command"><div class="code"><span[^>]*>wt<\/span><span[^>]*> <\/span><span[^>]*>list<\/span>/,
|
|
);
|
|
assert.match(listPage, /<figure class="frame wt-command-reference not-content">/);
|
|
assert.match(listPage, /<span class="wt-help-heading">Usage:<\/span>/);
|
|
assert.match(listPage, /<span class="wt-help-option">--format<\/span>/);
|
|
assert.match(listPage, /<span class="wt-help-value">\[OPTIONS\]<\/span>/);
|
|
assert.match(
|
|
listPage,
|
|
/<span class="wt-help-command">wt list<\/span> <span class="wt-help-value"><COMMAND><\/span>/,
|
|
);
|
|
|
|
const llmCommitsPage = await readFile(routeFile('/llm-commits/'), 'utf8');
|
|
assert.match(llmCommitsPage, /<span class="wt-terminal-cyan">◎<\/span>/);
|
|
assert.match(
|
|
llmCommitsPage,
|
|
/<span class="wt-terminal-bold">feat\(validation\): add input validation utilities<\/span>/,
|
|
);
|
|
|
|
const configPage = await readFile(routeFile('/config/'), 'utf8');
|
|
assert.match(
|
|
configPage,
|
|
/<figure class="frame has-title not-content"><figcaption class="header"><span class="title">~\/.config\/worktrunk\/config\.toml<\/span><\/figcaption>/,
|
|
);
|
|
const configToc = configPage.match(
|
|
/<nav aria-labelledby="starlight__on-this-page">([\s\S]*?)<\/nav>/,
|
|
)?.[1];
|
|
assert.ok(configToc, 'config page is missing its desktop table of contents');
|
|
assert.equal(
|
|
[...configToc.matchAll(/<a href="#[^"]+"/g)].length,
|
|
36,
|
|
'config table of contents should expose overview and structural section headings only',
|
|
);
|
|
for (const [id, title] of [
|
|
['user-configuration', 'User Configuration'],
|
|
['project-configuration', 'Project Configuration'],
|
|
['shell-integration', 'Shell Integration'],
|
|
['other', 'Other'],
|
|
['subcommands', 'Subcommands'],
|
|
['wt-config-shell', 'wt config shell'],
|
|
['wt-config-shell-init', 'wt config shell init'],
|
|
['wt-config-shell-install', 'wt config shell install'],
|
|
['wt-config-shell-uninstall', 'wt config shell uninstall'],
|
|
]) {
|
|
assert.match(
|
|
configToc,
|
|
new RegExp(`<a href="#${id}"[^>]*>[\\s\\S]*?<span[^>]*>${title}</span></a>`),
|
|
);
|
|
}
|
|
assert.doesNotMatch(configToc, /href="#claude-code"/);
|
|
assert.doesNotMatch(configToc, /href="#wt-config-[^"]*--command-reference"/);
|
|
|
|
const structuralSections = new Map([
|
|
['/hook/', ['hook-types', 'security', 'configuration', 'running-hooks-manually', 'recipes']],
|
|
['/list/', ['subcommands']],
|
|
['/step/', ['subcommands']],
|
|
]);
|
|
for (const [route, ids] of structuralSections) {
|
|
const page = await readFile(routeFile(route), 'utf8');
|
|
const toc = page.match(/<nav aria-labelledby="starlight__on-this-page">([\s\S]*?)<\/nav>/)?.[1];
|
|
assert.ok(toc, `${route} is missing its desktop table of contents`);
|
|
for (const id of ids) assert.match(toc, new RegExp(`<a href="#${id}"`));
|
|
}
|
|
});
|
|
|
|
test('built pages omit low-value footer navigation', async () => {
|
|
for (const page of renderedPages) {
|
|
const html = await readFile(page, 'utf8');
|
|
assert.doesNotMatch(
|
|
html,
|
|
/class="[^"]*\bpagination-links\b/,
|
|
`${page} renders previous/next pagination`,
|
|
);
|
|
assert.doesNotMatch(
|
|
html,
|
|
/data-contract="project-links"/,
|
|
`${page} renders duplicate project links`,
|
|
);
|
|
}
|
|
});
|
|
|
|
test('nested command references expose unique search-only fragment titles', async () => {
|
|
const stepPage = await readFile(routeFile('/step/'), 'utf8');
|
|
assert.match(stepPage, /<span class="wt-help-value"><COMMAND>\.\.\.<\/span>/);
|
|
assert.match(stepPage, /<h2 id="command-reference">Command reference<\/h2>/);
|
|
|
|
const references = [...stepPage.matchAll(
|
|
/<h3 id="([^"]+)"><span class="wt-pagefind-fragment-title" hidden aria-hidden="true">(wt step [^<]+) — <\/span>Command reference<\/h3>/g,
|
|
)];
|
|
for (const [, id, command] of references) {
|
|
assert.equal(id, `${command.replaceAll(' ', '-')}--command-reference`);
|
|
}
|
|
assert.deepEqual(references.map((match) => match[2]), [
|
|
'wt step commit',
|
|
'wt step squash',
|
|
'wt step rebase',
|
|
'wt step push',
|
|
'wt step diff',
|
|
'wt step copy-ignored',
|
|
'wt step eval',
|
|
'wt step for-each',
|
|
'wt step promote',
|
|
'wt step prune',
|
|
'wt step relocate',
|
|
'wt step tether',
|
|
]);
|
|
|
|
const listPage = await readFile(routeFile('/list/'), 'utf8');
|
|
assert.match(
|
|
listPage,
|
|
/<h3 id="wt-list-statusline--command-reference"><span class="wt-pagefind-fragment-title" hidden aria-hidden="true">wt list statusline — <\/span>Command reference<\/h3>/,
|
|
);
|
|
});
|
|
|
|
test('every command reference receives semantic syntax roles', async () => {
|
|
let headingCount = 0;
|
|
let frameCount = 0;
|
|
for (const page of renderedPages) {
|
|
const html = await readFile(page, 'utf8');
|
|
headingCount += [...html.matchAll(/>Command reference<\/h[23]>/g)].length;
|
|
const frames = [...html.matchAll(
|
|
/<figure class="frame wt-command-reference not-content">([\s\S]*?)<\/figure>/g,
|
|
)];
|
|
frameCount += frames.length;
|
|
for (const [, frame] of frames) {
|
|
const renderedCode = frame.match(/<code>([\s\S]*?)<\/code>/)?.[1] ?? '';
|
|
assert.match(frame, /class="wt-help-command"/, `${page} leaves the command unstyled`);
|
|
assert.match(frame, /class="wt-help-heading"/, `${page} leaves help headings unstyled`);
|
|
assert.match(frame, /class="wt-help-(?:option|value)"/, `${page} leaves help syntax unstyled`);
|
|
assert.doesNotMatch(
|
|
frame,
|
|
/<div class="code">- [^<]/,
|
|
`${page} leaves a possible-value row unstyled`,
|
|
);
|
|
const experimentalCount = [...renderedCode.matchAll(/\[experimental\]/g)].length;
|
|
const styledExperimentalCount = [
|
|
...renderedCode.matchAll(/class="wt-help-meta">\[experimental\]<\/span>/g),
|
|
].length;
|
|
assert.equal(
|
|
styledExperimentalCount,
|
|
experimentalCount,
|
|
`${page} leaves an experimental annotation unstyled`,
|
|
);
|
|
}
|
|
}
|
|
assert.ok(headingCount > 0, 'expected rendered command references');
|
|
assert.equal(frameCount, headingCount, 'some command references remain plain code blocks');
|
|
});
|
|
|
|
test('built pages only reference emitted local assets', async () => {
|
|
const files = new Set(await allFiles());
|
|
|
|
for (const page of renderedPages) {
|
|
const html = await readFile(page, 'utf8');
|
|
const assertAsset = (reference) => {
|
|
const url = new URL(reference.replaceAll('&', '&'), `https://worktrunk.dev${fileRoute(page)}`);
|
|
if (url.origin !== 'https://worktrunk.dev' || url.pathname.endsWith('/')) return;
|
|
const target = path.join(dist, decodeURIComponent(url.pathname));
|
|
assert.ok(files.has(target), `${page} references missing asset ${url.pathname}`);
|
|
};
|
|
for (const match of html.matchAll(/\s(href|src|srcset)="([^"]+)"/g)) {
|
|
const references = match[1] === 'srcset'
|
|
? match[2].split(',').map((candidate) => candidate.trim().split(/\s+/, 1)[0])
|
|
: [match[2]];
|
|
for (const reference of references) assertAsset(reference);
|
|
}
|
|
for (const match of html.matchAll(/<meta (?:property="og:image"|name="twitter:image") content="([^"]+)"/g)) {
|
|
assertAsset(match[1]);
|
|
}
|
|
}
|
|
});
|
|
|
|
test('output-only console blocks do not expose copy controls', async () => {
|
|
let outputOnlyBlocks = 0;
|
|
for (const page of renderedPages) {
|
|
const html = await readFile(page, 'utf8');
|
|
for (const match of html.matchAll(/<figure class="frame[^"]*">([\s\S]*?)<\/figure>/g)) {
|
|
const frame = match[1];
|
|
if (!/class="ec-line wt-output"/.test(frame)) continue;
|
|
if (/class="ec-line wt-(?:command|copyable)"/.test(frame)) continue;
|
|
outputOnlyBlocks += 1;
|
|
assert.doesNotMatch(frame, /class="copy"/, `${page} exposes a copy control for captured output`);
|
|
}
|
|
}
|
|
assert.equal(outputOnlyBlocks, 1, 'expected the FAQ approval transcript to exercise this case');
|
|
});
|
|
|
|
test('command-bearing console blocks emit command-only copy payloads', async () => {
|
|
let commandBearingBlocks = 0;
|
|
let perLineBlocks = 0;
|
|
for (const page of renderedPages) {
|
|
const html = await readFile(page, 'utf8');
|
|
for (const match of html.matchAll(/<figure class="frame[^"]*">([\s\S]*?)<\/figure>/g)) {
|
|
const frame = match[1];
|
|
const lines = [...frame.matchAll(
|
|
/<div class="ec-line wt-(command|copyable|output)"><div class="code">([\s\S]*?)<\/div>/g,
|
|
)];
|
|
const expected = lines
|
|
.filter((line) => line[1] !== 'output')
|
|
.map((line) => {
|
|
const text = renderedText(line[2]).replace(/\n$/u, '');
|
|
return line[1] === 'command' ? withoutTrailingShellComments(text) : text;
|
|
});
|
|
if (expected.length === 0) continue;
|
|
|
|
commandBearingBlocks += 1;
|
|
// The block control carries the bare `copy` class; per-line controls add
|
|
// `wt-line-copy`.
|
|
const encodedPayload = frame.match(
|
|
/<div class="copy">[\s\S]*?<button\b[^>]*\bdata-code="([^"]*)"/,
|
|
)?.[1];
|
|
const commands = lines
|
|
.filter((line) => line[1] === 'command')
|
|
.map((line) => withoutTrailingShellComments(renderedText(line[2]).replace(/\n$/u, '')));
|
|
const perLine = [...frame.matchAll(
|
|
/<div class="copy wt-line-copy">[\s\S]*?<button\b[^>]*\bdata-code="([^"]*)"/g,
|
|
)].map((line) => renderedText(line[1]));
|
|
// Most blocks listing several commands are menus of alternatives, so
|
|
// each command line offers its own payload in place of the block's.
|
|
if (commands.length > 1) {
|
|
perLineBlocks += 1;
|
|
assert.equal(encodedPayload, undefined, `${page} offers a block copy beside per-line copies`);
|
|
assert.deepEqual(perLine, commands, `${page} per-line copy payloads do not match its commands`);
|
|
} else {
|
|
assert.notEqual(encodedPayload, undefined, `${page} is missing a terminal copy payload`);
|
|
assert.equal(renderedText(encodedPayload), expected.join('\u007f'), `${page} copies captured output`);
|
|
assert.deepEqual(perLine, [], `${page} adds per-line copy to a single-command block`);
|
|
}
|
|
}
|
|
}
|
|
assert.ok(commandBearingBlocks > 0, 'expected command-bearing console blocks');
|
|
assert.ok(perLineBlocks > 0, 'expected blocks listing several commands');
|
|
});
|
|
|
|
test('shell copy payloads leave out trailing comments', async () => {
|
|
let payloads = 0;
|
|
for (const page of renderedPages) {
|
|
const html = await readFile(page, 'utf8');
|
|
for (const match of html.matchAll(/<figure class="frame[^"]*">([\s\S]*?)<\/figure>/g)) {
|
|
if (!/<pre\b[^>]*\bdata-language="(?:bash|sh)"/.test(match[1])) continue;
|
|
for (const button of match[1].matchAll(/<button\b[^>]*\bdata-code="([^"]*)"/g)) {
|
|
payloads += 1;
|
|
const code = renderedText(button[1]).replaceAll('\u007f', '\n');
|
|
assert.equal(code, withoutTrailingShellComments(code), `${page} copies a trailing shell comment`);
|
|
}
|
|
}
|
|
}
|
|
assert.ok(payloads > 0, 'expected shell copy payloads');
|
|
});
|
|
|
|
test('generated command references expose no copy control', async () => {
|
|
let references = 0;
|
|
for (const page of renderedPages) {
|
|
const html = await readFile(page, 'utf8');
|
|
for (const match of html.matchAll(
|
|
/<figure class="frame[^"]*\bwt-command-reference\b[^"]*">([\s\S]*?)<\/figure>/g,
|
|
)) {
|
|
references += 1;
|
|
assert.doesNotMatch(
|
|
match[1],
|
|
/class="copy/,
|
|
`${page} offers to copy a page of generated help text`,
|
|
);
|
|
}
|
|
}
|
|
assert.ok(references > 0, 'expected generated command references');
|
|
});
|
|
|
|
test('titleless code frames do not render decorative headers', async () => {
|
|
for (const page of renderedPages) {
|
|
const html = await readFile(page, 'utf8');
|
|
assert.doesNotMatch(
|
|
html,
|
|
/<figcaption class="header"><span class="title"><\/span>/,
|
|
`${page} renders chrome for an untitled code block`,
|
|
);
|
|
}
|
|
});
|
|
|
|
test('long desktop TOCs keep the current link inside their own scrollport', () => {
|
|
const scrollport = {
|
|
clientHeight: 1_000,
|
|
scrollHeight: 1_961,
|
|
scrollTop: 0,
|
|
getBoundingClientRect: () => ({ top: 0, bottom: 1_000 }),
|
|
};
|
|
const visibleToc = {
|
|
closest: () => scrollport,
|
|
getClientRects: () => [{}],
|
|
};
|
|
const current = {
|
|
closest: () => visibleToc,
|
|
getBoundingClientRect: () => ({ top: 1_386.84375, bottom: 1_411.09375 }),
|
|
};
|
|
|
|
assert.equal(keepCurrentTocLinkVisible(current), true);
|
|
assert.equal(scrollport.scrollTop, 459.09375);
|
|
|
|
current.getBoundingClientRect = () => ({ top: 500, bottom: 525 });
|
|
assert.equal(keepCurrentTocLinkVisible(current), false);
|
|
assert.equal(scrollport.scrollTop, 459.09375);
|
|
|
|
current.getBoundingClientRect = () => ({ top: 20, bottom: 45 });
|
|
assert.equal(keepCurrentTocLinkVisible(current), true);
|
|
assert.equal(scrollport.scrollTop, 431.09375);
|
|
|
|
visibleToc.getClientRects = () => [];
|
|
current.getBoundingClientRect = () => ({ top: 1_386.84375, bottom: 1_411.09375 });
|
|
assert.equal(keepCurrentTocLinkVisible(current), false);
|
|
assert.equal(scrollport.scrollTop, 431.09375);
|
|
|
|
visibleToc.getClientRects = () => [{}];
|
|
scrollport.scrollHeight = scrollport.clientHeight;
|
|
assert.equal(keepCurrentTocLinkVisible(current), false);
|
|
assert.equal(scrollport.scrollTop, 431.09375);
|
|
});
|
|
|
|
test('hash navigation selects the requested section in every rendered TOC', () => {
|
|
const link = (hash, current = false) => ({
|
|
hash,
|
|
current,
|
|
getAttribute(name) {
|
|
return name === 'aria-current' && this.current ? 'true' : null;
|
|
},
|
|
setAttribute(name, value) {
|
|
if (name === 'aria-current') this.current = value === 'true';
|
|
},
|
|
removeAttribute(name) {
|
|
if (name === 'aria-current') this.current = false;
|
|
},
|
|
textContent: hash.slice(1).replaceAll('-', ' '),
|
|
});
|
|
const root = (mobile = false) => {
|
|
const overview = link('#_top', true);
|
|
const requested = link('#reporting-a-problem');
|
|
const display = mobile ? { textContent: '' } : null;
|
|
return {
|
|
display,
|
|
links: [overview, requested],
|
|
querySelector(selector) {
|
|
return selector === '.display-current' ? display : null;
|
|
},
|
|
querySelectorAll(selector) {
|
|
if (selector === 'a') return this.links;
|
|
if (selector === 'a[aria-current="true"]') {
|
|
return this.links.filter((candidate) => candidate.current);
|
|
}
|
|
return [];
|
|
},
|
|
};
|
|
};
|
|
const desktop = root();
|
|
const mobile = root(true);
|
|
const doc = {
|
|
querySelectorAll: () => [desktop, mobile],
|
|
};
|
|
|
|
assert.equal(syncTocCurrentToHash(doc, '#reporting-a-problem'), true);
|
|
for (const toc of [desktop, mobile]) {
|
|
assert.equal(toc.links[0].current, false);
|
|
assert.equal(toc.links[1].current, true);
|
|
}
|
|
assert.equal(mobile.display.textContent, 'reporting a problem');
|
|
assert.equal(syncTocCurrentToHash(doc, '#missing'), false);
|
|
});
|
|
|
|
test('every structural content heading appears in the page outline', async () => {
|
|
// The homepage and the Try it page drop the outline to give content the width.
|
|
for (const route of publicRoutes.filter((candidate) => !['/', '/try-it/'].includes(candidate))) {
|
|
const page = await readFile(routeFile(route), 'utf8');
|
|
const headings = [...page.matchAll(/<h[12]\b[^>]*\bid="([^"]+)"/g)]
|
|
.map((match) => match[1])
|
|
.filter((id) => id !== 'starlight__on-this-page');
|
|
const toc = page.match(/<nav aria-labelledby="starlight__on-this-page">([\s\S]*?)<\/nav>/)?.[1];
|
|
assert.ok(toc, `${route} is missing its desktop table of contents`);
|
|
const links = [...toc.matchAll(/<a href="#([^"]+)"/g)].map((match) => match[1]);
|
|
assert.deepEqual(links, headings, `${route} outline does not match its structural headings`);
|
|
}
|
|
});
|
|
|
|
test('short wide tables become labeled records without capturing dense tables', async () => {
|
|
const pages = new Map(await Promise.all(publicRoutes.map(async (route) => (
|
|
[route, await readFile(routeFile(route), 'utf8')]
|
|
))));
|
|
const tables = new Map([...pages].map(([route, html]) => [route, tableSummaries(html)]));
|
|
const findTable = (route, headers) => {
|
|
const table = tables.get(route).find((candidate) => (
|
|
candidate.headers.join('|') === headers.join('|')
|
|
));
|
|
assert.ok(table, `${route} is missing table ${headers.join(' | ')}`);
|
|
return table;
|
|
};
|
|
|
|
const configFiles = findTable(
|
|
'/config/',
|
|
['File', 'Location', 'Contains', 'Committed & shared'],
|
|
);
|
|
assert.match(configFiles.attributes, /class="wt-responsive-records"/);
|
|
|
|
for (const pageTables of tables.values()) {
|
|
for (const table of pageTables) {
|
|
if (!/\bwt-responsive-records\b/.test(table.attributes)) continue;
|
|
assert.ok(table.headers.length >= 3);
|
|
assert.ok(table.rowLabels.length >= 1 && table.rowLabels.length <= 3);
|
|
assert.deepEqual(
|
|
table.rowLabels,
|
|
Array.from({ length: table.rowLabels.length }, () => table.headers),
|
|
);
|
|
}
|
|
}
|
|
|
|
assert.doesNotMatch(
|
|
findTable('/extending/', ['', 'Hooks', 'Aliases', 'Custom subcommands']).attributes,
|
|
/\bwt-responsive-records\b/,
|
|
);
|
|
assert.doesNotMatch(
|
|
findTable('/claude-code/', ['Capability', 'Claude Code', 'Codex', 'OpenCode', 'Pi', 'oh-my-pi', 'Gemini CLI']).attributes,
|
|
/\bwt-responsive-records\b/,
|
|
);
|
|
assert.doesNotMatch(
|
|
findTable('/hook/', ['Kind', 'Variable', 'Description']).attributes,
|
|
/\bwt-responsive-records\b/,
|
|
);
|
|
assert.doesNotMatch(
|
|
findTable('/list/', ['Column', 'Shows']).attributes,
|
|
/\bwt-responsive-records\b/,
|
|
);
|
|
assert.doesNotMatch(
|
|
findTable('/', ['Task', 'Worktrunk', 'Plain git']).attributes,
|
|
/\bwt-responsive-records\b/,
|
|
);
|
|
});
|
|
|
|
test('mobile menu control works without JavaScript', async () => {
|
|
const faqPage = await readFile(routeFile('/faq/'), 'utf8');
|
|
assert.match(faqPage, /<button\b[^>]*popovertarget="starlight__sidebar"/);
|
|
assert.match(faqPage, /<sl-sidebar-pane\b[^>]*\bpopover\b[^>]*id="starlight__sidebar"/);
|
|
// Starlight 0.42 drives the menu from the popover API, so nothing hydrates
|
|
// first and the pre-hydration hiding this page used to carry is obsolete.
|
|
assert.doesNotMatch(faqPage, /starlight-menu-button/);
|
|
});
|
|
|
|
test('built pages have unique IDs and valid internal page links', async () => {
|
|
const pages = await htmlFiles();
|
|
const contents = new Map(await Promise.all(pages.map(async (file) => [file, await readFile(file, 'utf8')])));
|
|
|
|
for (const [source, html] of contents) {
|
|
const ids = [...html.matchAll(/\sid="([^"]+)"/g)].map((match) => match[1]);
|
|
assert.equal(new Set(ids).size, ids.length, `duplicate ID in ${source}`);
|
|
|
|
for (const match of html.matchAll(/\shref="([^"]+)"/g)) {
|
|
const href = match[1].replaceAll('&', '&');
|
|
const url = new URL(href, `https://worktrunk.dev${fileRoute(source)}`);
|
|
if (url.origin !== 'https://worktrunk.dev') continue;
|
|
const targetFile = routeFile(decodeURIComponent(url.pathname));
|
|
if (!targetFile) continue;
|
|
const target = contents.get(targetFile);
|
|
assert.ok(target, `${source} links to missing page ${url.pathname}`);
|
|
if (!url.hash) continue;
|
|
const id = decodeURIComponent(url.hash.slice(1));
|
|
assert.match(target, new RegExp(`\\sid="${id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}"`), `${source} links to missing ${url.hash}`);
|
|
}
|
|
}
|
|
});
|