Files
pipelines/web/test/markdown.test.mjs
T
alan 0688127253 web: chat — session list, open/close, history paging, markdown, scroll (C1/C3/C4/C7/C14)
Browser Chat destination for parity with the Android app:
- session list grouped by directory (closed grouped under "Closed"), kind
  chip, activity badge, work-label meta line, "Search chats" filter (C1)
- open/close/reopen with the Android copy verbatim (C3)
- conversation history paging via the opaque next_cursor (C4)
- markdown subset renderer + code blocks (C7)
- scroll follow / "Jump to latest" / per-session saved position (C14)

Request builders in src/repository.js; pure merge/format/markdown/paging
logic in src/chat.js and src/markdown.js; view in app.js. Every server
string set with textContent, markdown built as DOM nodes.
2026-10-19 05:39:29 +01:00

182 lines
7.8 KiB
JavaScript

// The markdown subset (C7), ported from ui/chat/Markdown.kt. The parser is pure,
// so the exact block/span shapes are asserted without a browser; anything outside
// the subset must render as plain text and never be dropped.
import { test } from "node:test";
import assert from "node:assert/strict";
import { codeBlockLabel, decodeHtmlEntities, parseInline, parseMarkdown } from "../src/markdown.js";
/** Every text run in a span tree, in order, so nothing dropped can hide. */
function spanText(spans) {
return spans
.map((span) => {
if (span.kind === "plain" || span.kind === "code") return span.text;
if (span.kind === "strong" || span.kind === "emphasis" || span.kind === "link") {
return spanText(span.spans);
}
return "";
})
.join("");
}
/** Every text run in a block list, so nothing dropped can hide. */
function blockText(blocks) {
return blocks
.map((block) => {
if (block.kind === "heading" || block.kind === "paragraph") return block.text;
if (block.kind === "code") return block.code;
if (block.kind === "quote") return block.lines.join("\n");
if (block.kind === "list") return block.items.join("\n");
if (block.kind === "table") return [...block.header, ...block.rows.flat()].join("|");
return "";
})
.join("\n");
}
// --- Entities ---------------------------------------------------------------
test("decodeHtmlEntities decodes the named, decimal and hex references", () => {
assert.equal(decodeHtmlEntities("a &amp; b &lt; c &gt; d &quot;e&quot; &#x27;f&#39;"), "a & b < c > d \"e\" 'f'");
assert.equal(decodeHtmlEntities("&#65;&#x42;"), "AB");
assert.equal(decodeHtmlEntities("&hellip;&mdash;&nbsp;"), "…—\u00A0");
});
test("decodeHtmlEntities is a single pass, so a decoded ampersand is not re-decoded", () => {
assert.equal(decodeHtmlEntities("&amp;lt;"), "&lt;");
assert.equal(decodeHtmlEntities("&amp;amp;"), "&amp;");
});
test("decodeHtmlEntities leaves an unknown or malformed reference literal", () => {
assert.equal(decodeHtmlEntities("&nope; &doesnotexist;"), "&nope; &doesnotexist;");
assert.equal(decodeHtmlEntities("&#xZZ; &#; &"), "&#xZZ; &#; &");
});
test("parseMarkdown decodes entities before parsing", () => {
const blocks = parseMarkdown("a &amp; b");
assert.deepEqual(blocks, [{ kind: "paragraph", text: "a & b" }]);
});
// --- Blocks -----------------------------------------------------------------
test("parseMarkdown parses headings, paragraphs and thematic rules", () => {
const blocks = parseMarkdown("# Title\n\nA paragraph\nspanning lines.\n\n---\n\n## Sub ##");
assert.deepEqual(blocks, [
{ kind: "heading", level: 1, text: "Title" },
{ kind: "paragraph", text: "A paragraph spanning lines." },
{ kind: "rule" },
{ kind: "heading", level: 2, text: "Sub " },
]);
});
test("parseMarkdown parses a fenced block and keeps its language", () => {
const blocks = parseMarkdown("```js\nconst x = 1;\n```");
assert.deepEqual(blocks, [{ kind: "code", language: "js", code: "const x = 1;" }]);
assert.equal(codeBlockLabel("js"), "js");
});
test("a fenced block with no language is labelled code", () => {
const blocks = parseMarkdown("```\nplain\n```");
assert.deepEqual(blocks, [{ kind: "code", language: "", code: "plain" }]);
assert.equal(codeBlockLabel(""), "code");
assert.equal(codeBlockLabel(" "), "code");
});
test("tilde fences are code fences too", () => {
const blocks = parseMarkdown("~~~python\nprint(1)\n~~~");
assert.deepEqual(blocks, [{ kind: "code", language: "python", code: "print(1)" }]);
});
test("parseMarkdown parses block quotes, bullet lists and ordered lists", () => {
assert.deepEqual(parseMarkdown("> one\n> two"), [{ kind: "quote", lines: ["one", "two"] }]);
assert.deepEqual(parseMarkdown("- a\n- b"), [{ kind: "list", ordered: false, items: ["a", "b"] }]);
assert.deepEqual(parseMarkdown("1. one\n2. two"), [{ kind: "list", ordered: true, items: ["one", "two"] }]);
});
test("parseMarkdown parses a table with a --- delimiter row", () => {
const blocks = parseMarkdown("| a | b |\n| --- | --- |\n| 1 | 2 |");
assert.deepEqual(blocks, [{ kind: "table", header: ["a", "b"], rows: [["1", "2"]] }]);
});
test("a table row shorter than the header is padded, never truncated", () => {
const blocks = parseMarkdown("| a | b |\n| --- | --- |\n| 1 |");
assert.deepEqual(blocks[0].rows, [["1", ""]]);
});
test("a nested list is flattened into its run, never dropped", () => {
const blocks = parseMarkdown("- a\n - b");
assert.deepEqual(blocks, [{ kind: "list", ordered: false, items: ["a", "b"] }]);
assert.equal(blockText(blocks), "a\nb");
});
test("more than six hashes is a paragraph, not a heading", () => {
assert.deepEqual(parseMarkdown("####### x"), [{ kind: "paragraph", text: "####### x" }]);
});
// --- Inline -----------------------------------------------------------------
test("snake_case is never italicised", () => {
assert.deepEqual(parseInline("snake_case_name"), [{ kind: "plain", text: "snake_case_name" }]);
assert.deepEqual(parseInline("a_b_c"), [{ kind: "plain", text: "a_b_c" }]);
});
test("underscore emphasis works only at word boundaries", () => {
assert.deepEqual(parseInline("_italic_"), [{ kind: "emphasis", spans: [{ kind: "plain", text: "italic" }] }]);
assert.deepEqual(parseInline("a _b_ c"), [
{ kind: "plain", text: "a " },
{ kind: "emphasis", spans: [{ kind: "plain", text: "b" }] },
{ kind: "plain", text: " c" },
]);
});
test("bold, italic and inline code become their spans", () => {
assert.deepEqual(parseInline("**bold**"), [{ kind: "strong", spans: [{ kind: "plain", text: "bold" }] }]);
assert.deepEqual(parseInline("__bold__"), [{ kind: "strong", spans: [{ kind: "plain", text: "bold" }] }]);
assert.deepEqual(parseInline("*it*"), [{ kind: "emphasis", spans: [{ kind: "plain", text: "it" }] }]);
assert.deepEqual(parseInline("`code`"), [{ kind: "code", text: "code" }]);
});
test("links and bare http(s) autolinks become link spans", () => {
assert.deepEqual(parseInline("[site](https://example.com)"), [
{ kind: "link", spans: [{ kind: "plain", text: "site" }], url: "https://example.com" },
]);
assert.deepEqual(parseInline("see https://example.com now"), [
{ kind: "plain", text: "see " },
{ kind: "link", spans: [{ kind: "plain", text: "https://example.com" }], url: "https://example.com" },
{ kind: "plain", text: " now" },
]);
});
test("autolinks trim trailing punctuation", () => {
const spans = parseInline("go to https://example.com.");
const link = spans.find((span) => span.kind === "link");
assert.equal(link.url, "https://example.com");
});
// --- Out-of-subset text is never dropped ------------------------------------
test("out-of-subset HTML renders as plain text and is never dropped", () => {
assert.deepEqual(parseInline("<b>hi</b>"), [{ kind: "plain", text: "<b>hi</b>" }]);
assert.equal(blockText(parseMarkdown("<div>x</div>")), "<div>x</div>");
});
test("reference links and strikethrough render as plain text", () => {
assert.deepEqual(parseInline("[label][ref]"), [{ kind: "plain", text: "[label][ref]" }]);
assert.deepEqual(parseInline("~~gone~~"), [{ kind: "plain", text: "~~gone~~" }]);
});
test("a malformed inline marker is kept literally", () => {
assert.deepEqual(parseInline("a * b ` c"), [{ kind: "plain", text: "a * b ` c" }]);
});
test("every out-of-subset paragraph's text survives the round trip", () => {
const source = "<section>\n[ref][id] and ~~strike~~\n</section>";
const blocks = parseMarkdown(source);
const text = blockText(blocks);
assert.ok(text.includes("[ref][id] and ~~strike~~"));
});
test("spanText of a mixed inline run keeps every character", () => {
const spans = parseInline("plain **bold** `code` [link](https://e.com) tail");
assert.equal(spanText(spans), "plain bold code link tail");
});