Orca is the place for working with a fleet of agents (e.g. Grok Bot, Claude Code). Run any coding agent with your own subscription. Available on desktop, mobile and remote runtime.
TypeScript adeagent-ideai-agentsautomationbotclaude-codecodexghosttygrok-bothermes-agentmobile-appmuseopenclawopencodeorchestrationpiruntimeterminalworktreesyc-backed
fix(mobile): keep table/list line breaks, item paragraphs and list code blocks through rich Markdown saves (#35259)
OrcaWinec62243dedec
diff --git a/config/scripts/mobile-web-app/mobile-web-app-code-block-selection.mjs b/config/scripts/mobile-web-app/mobile-web-app-code-block-selection.mjsindex db51faf8b06..ee550cf77a4 100644--- a/config/scripts/mobile-web-app/mobile-web-app-code-block-selection.mjs+++ b/config/scripts/mobile-web-app/mobile-web-app-code-block-selection.mjs@@ -41,7 +41,37 @@ async function verifyCodeBlockSelections({html: '<p>Before</p>\n<p>After</p>',literal: 'code',collapsed: true,- saved: 'Before\n\n```\ncode\n```\n\nAfter'+ saved: 'Before\n\n```\ncode\n```\n\nAfter',+ cleanBefore: true+ },+ {+ markdown: 'First\n\nAfter',+ html: '<p>First</p>\n<p>After</p>',+ literal: 'code',+ caret: { selector: 'p', offset: 2 },+ saved: 'Fi\n\n```\ncode\n```\n\nrst\n\nAfter'+ },+ {+ markdown: 'First\n\nAfter',+ html: '<p>First</p>\n<p>After</p>',+ literal: 'code',+ caret: { selector: 'p', offset: 'end' },+ saved: 'First\n\n```\ncode\n```\n\nAfter'+ },+ {+ markdown: '- First\n- Next',+ html: '<ul><li><p>First</p></li><li><p>Next</p></li></ul>',+ literal: 'code',+ caret: { selector: 'li p', offset: 'end' },+ saved: '- First\n ```\n code\n ```\n- Next'+ },+ {+ markdown: '',+ html: '<p class="is-empty"><br></p>',+ literal: 'code',+ caret: { selector: 'p', offset: 0 },+ saved: '```\ncode\n```',+ cleanBefore: true},{markdown: 'Before\n\nSelected text\n\n- after',@@ -55,14 +85,23 @@ async function verifyCodeBlockSelections({const { page, consoleErrors } = await openPage(browser)try {await setContent(page, sample.markdown, sample.html)- await (sample.partial || sample.collapsed || sample.paragraph+ await (sample.partial || sample.collapsed || sample.paragraph || sample.caret? page.evaluate(- ({ partial, paragraph }) => {+ ({ partial, paragraph, caret }) => {const editor = document.querySelector('#first-surface #editor')const paragraphs = editor.querySelectorAll('p')editor.focus()const range = document.createRange()- if (partial) {+ if (caret) {+ const target = editor.querySelector(caret.selector)+ if (caret.offset === 'end') {+ range.selectNodeContents(target)+ range.collapse(false)+ } else {+ range.setStart(target.firstChild ?? target, caret.offset)+ range.collapse(true)+ }+ } else if (partial) {range.setStart(paragraphs[0].firstChild, 7)range.setEnd(paragraphs[2].firstChild, 4)} else if (paragraph) {@@ -74,7 +113,11 @@ async function verifyCodeBlockSelections({window.getSelection().removeAllRanges()window.getSelection().addRange(range)},- { partial: sample.partial === true, paragraph: sample.paragraph === true }+ {+ partial: sample.partial === true,+ paragraph: sample.paragraph === true,+ caret: sample.caret ?? null+ }): select(page, 'all'))const selected = await page.evaluate(() => window.getSelection().toString())@@ -83,6 +126,15 @@ async function verifyCodeBlockSelections({await expect.poll(() => page.evaluate(() => globalThis.__orcaEditor.changes.at(-1))).toBe(saved)+ if (sample.cleanBefore) {+ // No blank line may appear above a code block inserted at an empty line or a block start.+ expect(+ await page.evaluate(() => {+ const before = document.querySelector('#first-surface #editor pre').previousSibling+ return before === null || (before.nodeName !== 'BR' && before.textContent !== '')+ })+ ).toBe(true)+ }await page.keyboard.press(`${historyModifier}+z`)await expect.poll(() => readSurface(page)).toBe(sample.html)expect(await page.evaluate(() => window.getSelection().toString())).toBe(selected)diff --git a/mobile/src/components/rich-markdown/editor-commands.ts b/mobile/src/components/rich-markdown/editor-commands.tsindex bc5eacaab71..9ebd7bb692e 100644--- a/mobile/src/components/rich-markdown/editor-commands.ts+++ b/mobile/src/components/rich-markdown/editor-commands.ts@@ -17,6 +17,48 @@ const TASK_LIST_HTML =const CODE_BLOCK_HTML = '<pre data-language=""><code>code</code></pre><p><br></p>'+function drawsContent(node: Node): boolean {+ return (+ /[^ \t\r\n]/.test(node.textContent ?? '') ||+ ((node instanceof Element || node instanceof DocumentFragment) &&+ node.querySelector('img') !== null) ||+ (node instanceof Element && node.tagName.toLowerCase() === 'img')+ )+}++// Native insertHTML merges the fragment's first block into a block with content before the caret, so the PRE becomes prose.+function caretFollowsContent(scope: RichMarkdownEditorScope): boolean {+ const selection = scope.getSelection()+ if (!selection || selection.rangeCount === 0 || !selection.isCollapsed) {+ return false+ }+ const caret = selection.getRangeAt(0)+ const editor = editorElement(scope)+ if (caret.startContainer === editor) {+ const previous = editor.childNodes.item(caret.startOffset - 1)+ return (+ previous !== null &&+ !(previous instanceof Element && previous.closest('table')) &&+ drawsContent(previous)+ )+ }+ const anchor =+ caret.startContainer instanceof Element+ ? caret.startContainer+ : caret.startContainer.parentElement+ if (!anchor || !editor.contains(anchor) || anchor.closest('table, pre')) {+ return false+ }+ const block = anchor.closest('p, div, li, h1, h2, h3, h4, h5, h6, blockquote')+ if (!block || block === editor || !editor.contains(block)) {+ return false+ }+ const before = scope.getDocument().createRange()+ before.setStart(block, 0)+ before.setEnd(caret.startContainer, caret.startOffset)+ return drawsContent(before.cloneContents())+}+function exec(scope: RichMarkdownEditorScope, command: string, value?: string) {scope.getDocument().execCommand(command, false, value)}@@ -81,7 +123,12 @@ const COMMANDS: Record<if (scope.getSelection()?.isCollapsed === false) {exec(scope, 'formatBlock', 'pre')} else {- exec(scope, 'insertHTML', CODE_BLOCK_HTML)+ // A leading break ends the caret's line first; the stray root <br> it leaves saves as nothing.+ exec(+ scope,+ 'insertHTML',+ caretFollowsContent(scope) ? `<br>${CODE_BLOCK_HTML}` : CODE_BLOCK_HTML+ )}},link: (scope) => insertUrl(scope, 'link', 'createLink'),diff --git a/mobile/src/components/rich-markdown/html-block-markdown.ts b/mobile/src/components/rich-markdown/html-block-markdown.tsindex d668e17f73e..4d211268dce 100644--- a/mobile/src/components/rich-markdown/html-block-markdown.ts+++ b/mobile/src/components/rich-markdown/html-block-markdown.ts@@ -1,10 +1,11 @@-import { codeFenceFor } from './markdown-code-fence'+import { codeBlockMarkdown } from './html-code-block-markdown'import { escapeTableCell } from './markdown-table-rows'import {inlineChildren,inlineMarkdown,inlineNodesMarkdown,- textContent+ textContent,+ trailingLineBreaks} from './html-inline-markdown'import { holdsUnownedList, listMarkdown } from './html-list-markdown'@@ -139,6 +140,15 @@ function headingCodeMarkdown(element: Element): string {return blocks.join('\n\n')}+// A lone trailing <br> is the browser's caret placeholder (a cleared cell keeps one); a run of two is authored spacing.+function tableCellMarkdown(cell: Element): string {+ const markdown = inlineChildren(cell, 'cell')+ .replace(/\r\n?|\n/g, ' ')+ .trim()+ const trailing = trailingLineBreaks(markdown)+ return trailing.count === 1 ? markdown.slice(0, trailing.start).trimEnd() : markdown+}+// Unknown block elements serialize inline content so browser-created tags cannot lose user text.export function blockMarkdown(node: Node): string {if (node.nodeType === Node.TEXT_NODE) {@@ -164,11 +174,7 @@ export function blockMarkdown(node: Node): string {return quoteMarkdown(node)}if (tag === 'pre') {- const language = node.getAttribute('data-language') ?? ''- // Drop trailing newlines: browsers leave a placeholder <br> after Enter at the end of a block.- const code = textContent(node).replace(/\n+$/, '')- const fence = codeFenceFor(code)- return `${fence}${language}\n${code}\n${fence}`+ return codeBlockMarkdown(node)}if (tag === 'ul' || tag === 'ol') {return listMarkdown(node, 0)@@ -179,7 +185,7 @@ export function blockMarkdown(node: Node): string {return ''}const cellsFor = (row: Element) =>- Array.from(row.children).map((cell) => escapeTableCell(inlineChildren(cell).trim()))+ Array.from(row.children).map((cell) => escapeTableCell(tableCellMarkdown(cell)))const headers = cellsFor(rows[0]!)const bodyRows = rows.slice(1).map(cellsFor)const separator = headers.map(() => '---').join(' | ')diff --git a/mobile/src/components/rich-markdown/html-code-block-markdown.ts b/mobile/src/components/rich-markdown/html-code-block-markdown.tsnew file mode 100644index 00000000000..3cfb0ffb588--- /dev/null+++ b/mobile/src/components/rich-markdown/html-code-block-markdown.ts@@ -0,0 +1,11 @@+import { textContent } from './html-inline-markdown'+import { codeFenceFor } from './markdown-code-fence'++/** A PRE as a fenced block, written the same at top level and inside list items. */+export function codeBlockMarkdown(pre: Element): string {+ const language = pre.getAttribute('data-language') ?? ''+ // Drop trailing newlines: browsers leave a placeholder <br> after Enter at the end of a block.+ const code = textContent(pre).replace(/\n+$/, '')+ const fence = codeFenceFor(code)+ return `${fence}${language}\n${code}\n${fence}`+}diff --git a/mobile/src/components/rich-markdown/html-inline-markdown.ts b/mobile/src/components/rich-markdown/html-inline-markdown.tsindex cc99828ff0d..a26fd365003 100644--- a/mobile/src/components/rich-markdown/html-inline-markdown.ts+++ b/mobile/src/components/rich-markdown/html-inline-markdown.ts@@ -46,35 +46,123 @@ function isInlineCode(node: Node): boolean {)}+/**+ * How breaks inside the serialized run are spelled: `newline` for multi-line blocks, `cell` for table+ * cells and `item` for list items, which must stay on one source line. Items also turn sibling P/DIV+ * blocks (native Enter) into breaks.+ */+export type InlineLineBreaks = 'newline' | 'cell' | 'item'++export const LINE_BREAK_TAG = '<br />'++// Cells and items reopen `<br>` tokens as breaks, so escape only that opener in typed text; raw newlines render as spaces.+function singleLineText(text: string): string {+ return text.replace(/\r\n?|\n/g, ' ').replace(/<(?=[bB][rR][ \t]*\/?>)/g, '<')+}++/** Where the trailing run of `<br />` tags (spaces between them included) starts, and its length. */+export function trailingLineBreaks(markdown: string): { start: number; count: number } {+ let start = markdown.length+ let count = 0+ for (;;) {+ let end = start+ while (end > 0 && /\s/.test(markdown[end - 1] ?? '')) {+ end -= 1+ }+ if (!markdown.endsWith(LINE_BREAK_TAG, end)) {+ return { start, count }+ }+ start = end - LINE_BREAK_TAG.length+ count += 1+ }+}++function markMarkdown(delimiter: string, inner: string, breaks: InlineLineBreaks): string {+ if (breaks === 'newline') {+ return `${delimiter}${inner}${delimiter}`+ }+ // Edge breaks go outside the delimiters: CommonMark readers leave `**a<br />**` unclosed.+ let start = 0+ while (inner.startsWith(LINE_BREAK_TAG, start)) {+ start += LINE_BREAK_TAG.length+ }+ let end = inner.length+ while (end > start && inner.endsWith(LINE_BREAK_TAG, end)) {+ end -= LINE_BREAK_TAG.length+ }+ const body = inner.slice(start, end)+ return body ? `${inner.slice(0, start)}${delimiter}${body}${delimiter}${inner.slice(end)}` : inner+}++function isCollapsibleText(node: Node): boolean {+ return node.nodeType === Node.TEXT_NODE && /^[ \t\r\n]*$/.test(node.textContent ?? '')+}++// The last node that draws something, so a trailing <br> is found through marks and wrappers.+function lastRenderedLeaf(node: Node): Node | null {+ for (let child = node.lastChild; child; child = child.previousSibling) {+ if (child.nodeType === Node.TEXT_NODE) {+ if (!isCollapsibleText(child)) {+ return child+ }+ continue+ }+ if (!(child instanceof Element)) {+ continue+ }+ const tag = child.tagName.toLowerCase()+ if (tag === 'br' || tag === 'img') {+ return child+ }+ if (tag === 'label' || tag === 'ul' || tag === 'ol') {+ continue+ }+ const leaf = lastRenderedLeaf(child)+ if (leaf) {+ return leaf+ }+ }+ return null+}++function endsWithLineBreak(node: Node): boolean {+ const leaf =+ node instanceof Element && node.tagName.toLowerCase() === 'br' ? node : lastRenderedLeaf(node)+ return leaf instanceof Element && leaf.tagName.toLowerCase() === 'br'+}+// Serialize task label as empty: checkbox chrome is replaced by list writer’s Markdown marker.-export function inlineMarkdown(node: Node | null | undefined): string {+export function inlineMarkdown(+ node: Node | null | undefined,+ breaks: InlineLineBreaks = 'newline'+): string {if (!node) {return ''}if (node.nodeType === Node.TEXT_NODE) {- return textContent(node)+ return breaks === 'newline' ? textContent(node) : singleLineText(textContent(node))}if (!(node instanceof Element)) {return ''}const tag = node.tagName.toLowerCase()if (tag === 'br') {- return '\n'+ return breaks === 'newline' ? '\n' : LINE_BREAK_TAG}if (tag === 'strong' || tag === 'b') {- return `**${inlineChildren(node)}**`+ return markMarkdown('**', inlineChildren(node, breaks), breaks)}if (tag === 'em' || tag === 'i') {- return `*${inlineChildren(node)}*`+ return markMarkdown('*', inlineChildren(node, breaks), breaks)}if (tag === 's' || tag === 'del' || tag === 'strike') {- return `~~${inlineChildren(node)}~~`+ return markMarkdown('~~', inlineChildren(node, breaks), breaks)}if (isInlineCode(node)) {return codeMarkdown(inlineCodeText(node))}if (tag === 'a') {- return `[${inlineChildren(node)}](${node.getAttribute('href') ?? ''})`+ return `[${inlineChildren(node, breaks)}](${node.getAttribute('href') ?? ''})`}if (tag === 'img') {return ` ?? ''})`@@ -82,33 +170,87 @@ export function inlineMarkdown(node: Node | null | undefined): string {if (tag === 'label') {return ''}- return inlineChildren(node)+ return inlineChildren(node, breaks)}-export function inlineChildren(element: Element): string {- return inlineNodesMarkdown(element.childNodes)+export function inlineChildren(element: Element, breaks: InlineLineBreaks = 'newline'): string {+ return inlineNodesMarkdown(element.childNodes, breaks)}-export function inlineNodesMarkdown(nodes: Iterable<Node>): string {+// Adjacent text nodes are joined before escaping so a `<br>` typed across a node split stays literal.+export function inlineNodesMarkdown(+ nodes: Iterable<Node>,+ breaks: InlineLineBreaks = 'newline'+): string {const parts: string[] = []let code = ''+ let text = ''+ let whitespace = ''+ let emitted = false+ let previousBlock = false+ let previousEndsWithBreak = false+ const emit = (markdown: string, block: boolean, endsWithBreak: boolean) => {+ if (block || previousBlock) {+ if (emitted && !previousEndsWithBreak) {+ parts.push(LINE_BREAK_TAG)+ }+ } else if (whitespace) {+ parts.push(whitespace)+ }+ whitespace = ''+ parts.push(markdown)+ emitted = true+ previousBlock = block+ previousEndsWithBreak = endsWithBreak+ }+ const flushText = () => {+ if (!text) {+ return+ }+ const value = text.replace(/\u00a0/g, ' ')+ if (breaks === 'newline') {+ emit(value, false, false)+ } else if (breaks === 'item' && /^[ \t\r\n]*$/.test(text)) {+ // Formatting whitespace beside a block draws nothing; between inline runs it is a space.+ whitespace += singleLineText(value)+ } else {+ emit(singleLineText(value), false, false)+ }+ text = ''+ }+ const flushCode = () => {+ if (code) {+ emit(codeMarkdown(code), false, false)+ code = ''+ }+ }for (const child of nodes) {if (isInlineCode(child)) {+ flushText()code += inlineCodeText(child)continue}- const markdown = inlineMarkdown(child)- if (!markdown) {+ if (child.nodeType === Node.TEXT_NODE) {+ if (child.textContent) {+ flushCode()+ text += child.textContent+ }continue}- if (code) {- parts.push(codeMarkdown(code))- code = ''+ const block = breaks === 'item' && child instanceof Element && /^(p|div)$/i.test(child.tagName)+ // Spaces at a block's edges collapse, so they stay out of the line they would now share.+ const markdown = block ? inlineMarkdown(child, breaks).trim() : inlineMarkdown(child, breaks)+ if (!markdown) {+ continue}- parts.push(markdown)+ flushText()+ flushCode()+ emit(markdown, block, breaks === 'item' && endsWithLineBreak(child))}- if (code) {- parts.push(codeMarkdown(code))+ flushText()+ flushCode()+ if (whitespace && !previousBlock) {+ parts.push(whitespace)}return parts.join('')}diff --git a/mobile/src/components/rich-markdown/html-list-markdown.ts b/mobile/src/components/rich-markdown/html-list-markdown.tsindex e5c50dbf451..372b78006df 100644--- a/mobile/src/components/rich-markdown/html-list-markdown.ts+++ b/mobile/src/components/rich-markdown/html-list-markdown.ts@@ -1,4 +1,17 @@-import { inlineChildren } from './html-inline-markdown'+import { codeBlockMarkdown } from './html-code-block-markdown'+import { inlineNodesMarkdown, LINE_BREAK_TAG, trailingLineBreaks } from './html-inline-markdown'+import { openingFence } from './markdown-code-fence'++function itemInlineMarkdown(nodes: Iterable<Node>): string {+ const markdown = inlineNodesMarkdown(nodes, 'item')+ .replace(/\r\n?|\n/g, ' ')+ .trim()+ // A lone trailing <br> is the browser's invisible caret placeholder; a run of two draws an empty line.+ const trailing = trailingLineBreaks(markdown)+ return trailing.count === 1 && trailing.start > 0+ ? markdown.slice(0, trailing.start).trimEnd()+ : markdown+}// Remove checkbox label/nested lists on clone only: live checkbox must remain, nested lists serialize at own indentation.export function listItemText(item: Element): string {@@ -9,7 +22,104 @@ export function listItemText(item: Element): string {}clone.querySelectorAll('label').forEach((label) => label.remove())clone.querySelectorAll('ul, ol').forEach((list) => list.remove())- return inlineChildren(clone).trim()+ return itemInlineMarkdown(clone.childNodes)+}++function hasOwnedCodeBlock(item: Element): boolean {+ const pending = Array.from(item.children)+ for (let node = pending.pop(); node; node = pending.pop()) {+ const tag = node.tagName.toLowerCase()+ if (tag === 'pre') {+ return true+ }+ if (tag === 'p' || tag === 'div') {+ pending.push(...Array.from(node.children))+ }+ }+ return false+}++// An item's paragraphs and code blocks as Markdown lines, or null when the one-line writer applies.+// Headings, quotes, tables and rules also fall back to that writer rather than lose their markers here.+function listItemCodeBlocks(item: Element, isTask: boolean): string | null {+ if (!hasOwnedCodeBlock(item)) {+ return null+ }+ let body = ''+ let previousCode: boolean | null = null+ let firstCode = false+ // A fence needs no blank line beside it, so tight README items stay tight; paragraphs need one.+ const push = (markdown: string, code: boolean) => {+ if (previousCode === null) {+ firstCode = code+ } else {+ body += previousCode || code ? '\n' : '\n\n'+ }+ body += markdown+ previousCode = code+ }+ let inline: Node[] = []+ let nested = false+ const flush = () => {+ const markdown = itemInlineMarkdown(inline)+ inline = []+ // A paragraph holding only the caret placeholder saves as nothing, as it does outside lists.+ if (markdown && markdown !== LINE_BREAK_TAG) {+ push(markdown, false)+ }+ }+ const pending: (Node | null)[] = []+ const pushChildren = (parent: Node) => {+ for (let index = parent.childNodes.length - 1; index >= 0; index -= 1) {+ const child = parent.childNodes.item(index)+ if (child) {+ pending.push(child)+ }+ }+ }+ pushChildren(item)+ while (pending.length) {+ const node = pending.pop()+ if (!node) {+ flush()+ continue+ }+ if (node instanceof Element) {+ const tag = node.tagName.toLowerCase()+ if (tag === 'ul' || tag === 'ol' || tag === 'label') {+ nested ||= tag !== 'label'+ continue+ }+ if (nested || /^(h[1-6]|blockquote|table|hr)$/.test(tag)) {+ return null+ }+ if (tag === 'pre') {+ const language = node.getAttribute('data-language') ?? ''+ if (openingFence(`\`\`\`${language}`)?.language !== language) {+ return null+ }+ flush()+ push(codeBlockMarkdown(node), true)+ continue+ }+ if (tag === 'p' || tag === 'div') {+ flush()+ pending.push(null)+ pushChildren(node)+ continue+ }+ }+ if (nested && node.textContent?.trim()) {+ return null+ }+ inline.push(node)+ }+ flush()+ if (!body) {+ return null+ }+ // The task reader cannot open a fence after the checkbox, so an empty first line holds the place.+ return isTask && firstCode ? `${LINE_BREAK_TAG}\n${body}` : body}/** The lists directly inside an item, rather than every list anywhere beneath it. */@@ -43,10 +153,25 @@ export function listMarkdown(element: Element, depth: number): string {const listNumber = item.getAttribute('data-list-number') || item.getAttribute('value')marker = tag === 'ol' ? `${listNumber || orderedStart + index}. ` : '- '}- const line = indent + marker + listItemText(item)+ const blocks = listItemCodeBlocks(item, isTask)+ const continuation = indent + ' '.repeat(tag === 'ol' ? marker.length : 2)+ // Blank separator lines stay empty; content lines take the item's continuation indent.+ const line = blocks+ ? indent ++ marker ++ blocks+ .split('\n')+ .map((text, lineIndex) => (lineIndex === 0 || !text ? text : continuation + text))+ .join('\n')+ : indent + marker + listItemText(item)+ // Children of a wide ordered marker start at its content column, or readers end the item.+ const nestedIndent = blocks+ ? ' '.repeat(Math.max(0, continuation.length - indent.length - 2))+ : ''const nested = directNestedLists(item).map((list) => listMarkdown(list, depth + 1)).filter(Boolean)+ .map((markdown) => (nestedIndent ? markdown.replace(/^(?=.)/gm, nestedIndent) : markdown)).join('\n')return nested ? `${line}\n${nested}` : line})diff --git a/mobile/src/components/rich-markdown/markdown-inline-render.ts b/mobile/src/components/rich-markdown/markdown-inline-render.tsindex 9cccdcdcd30..efdfdccd61e 100644--- a/mobile/src/components/rich-markdown/markdown-inline-render.ts+++ b/mobile/src/components/rich-markdown/markdown-inline-render.ts@@ -5,9 +5,10 @@ import {import { escapeAttr, escapeHtml, escapeLiteralHtml, isSafeUrl } from './markdown-escaping'// Build global exec regex per recursive call: shared lastIndex would leak between nested parses. Escape text between recognized inline forms.-export function renderInline(text: string): string {+// Table cells and list items opt in to attribute-free `<br>` tokens, the only way they hold a line break.+export function renderInline(text: string, allowLineBreaks = false): string {const pattern =- /(!\[[^\]]*\]\([^)]+\)|`+|~~[^~]+~~|\*\*[^*]+\*\*|__[^_]+__|\*[^*\n]+\*|_[^_\n]+_|\[[^\]]+\]\([^)]+\)|https?:\/\/[^\s<]+)/g+ /(!\[[^\]]*\]\([^)]+\)|`+|~~[^~]+~~|\*\*[^*]+\*\*|__[^_]+__|\*[^*\n]+\*|_[^_\n]+_|\[[^\]]+\]\([^)]+\)|https?:\/\/[^\s<]+|<[bB][rR][ \t]*\/?>)/glet codeSpans: MarkdownCodeSpanScanner | undefinedlet output = ''let lastIndex = 0@@ -17,10 +18,12 @@ export function renderInline(text: string): string {const token = match[0]const image = token.match(/^!\[([^\]]*)\]\(([^)]+)\)$/)const link = token.match(/^\[([^\]]+)\]\(([^)]+)\)$/)- if (image && isSafeUrl(image[2])) {+ if (token.startsWith('<')) {+ output += allowLineBreaks ? '<br />' : escapeHtml(token)+ } else if (image && isSafeUrl(image[2])) {output += `<img src="${escapeAttr(image[2]!)}" alt="${escapeAttr(image[1] ?? '')}" />`} else if (link && isSafeUrl(link[2])) {- output += `<a href="${escapeAttr(link[2]!)}">${renderInline(link[1]!)}</a>`+ output += `<a href="${escapeAttr(link[2]!)}">${renderInline(link[1]!, allowLineBreaks)}</a>`} else if (/^https?:\/\//i.test(token)) {output += `<a href="${escapeAttr(token)}">${escapeHtml(token)}</a>`} else if (token.startsWith('`')) {@@ -37,11 +40,11 @@ export function renderInline(text: string): string {pattern.lastIndex = spanEnd}} else if (token.startsWith('~~')) {- output += `<s>${renderInline(token.slice(2, -2))}</s>`+ output += `<s>${renderInline(token.slice(2, -2), allowLineBreaks)}</s>`} else if (token.startsWith('**') || token.startsWith('__')) {- output += `<strong>${renderInline(token.slice(2, -2))}</strong>`+ output += `<strong>${renderInline(token.slice(2, -2), allowLineBreaks)}</strong>`} else {- output += `<em>${renderInline(token.slice(1, -1))}</em>`+ output += `<em>${renderInline(token.slice(1, -1), allowLineBreaks)}</em>`}lastIndex = pattern.lastIndexmatch = pattern.exec(text)diff --git a/mobile/src/components/rich-markdown/markdown-list-block-boundaries.test.ts b/mobile/src/components/rich-markdown/markdown-list-block-boundaries.test.tsnew file mode 100644index 00000000000..9f596557563--- /dev/null+++ b/mobile/src/components/rich-markdown/markdown-list-block-boundaries.test.ts@@ -0,0 +1,107 @@+// @vitest-environment happy-dom+import { afterEach, expect, it } from 'vitest'+import { createRichMarkdownEditorDocument } from './create-rich-markdown-editor-document'+import { RICH_MARKDOWN_EDITOR_MARKUP } from './document-markup'+import { quietRichMarkdownEditorHost } from './rich-markdown-editor-host.test-support'+import type { MobileRichMarkdownEditorMessage } from '../mobile-rich-markdown-editor-contract'++const stopDocuments: (() => void)[] = []+const lists = [+ ['bullet', '- First\n- Next\n\nOutside', 'li'],+ ['task', '- [ ] First\n- [x] Next\n\nOutside', 'li > div']+] as const++function surface(source: string) {+ document.body.innerHTML = RICH_MARKDOWN_EDITOR_MARKUP+ const messages: MobileRichMarkdownEditorMessage[] = []+ const editorDocument = createRichMarkdownEditorDocument({+ ...quietRichMarkdownEditorHost(),+ postToHost: (message) => messages.push(message)+ })+ stopDocuments.push(editorDocument.stop)+ editorDocument.send.setMarkdown(source, 7)+ return { editorDocument, editor: document.getElementById('editor')!, messages }+}++afterEach(() => {+ stopDocuments.splice(0).forEach((stop) => stop())+ document.body.innerHTML = ''+})++for (const [kind, source, selector] of lists) {+ it.each([+ ['<p>First</p><p>Second</p>', 'First<br />Second', 'First<br>Second'],+ [+ '<p><code>First</code></p><p><code>Second</code></p>',+ '`First`<br />`Second`',+ '<code>First</code><br><code>Second</code>'+ ]+ ])(+ `preserves ${kind} item block boundaries through host save and reopen: %s`,+ (html, text, inline) => {+ const { editorDocument, editor, messages } = surface(source)+ const body = editor.querySelector(selector)!+ body.innerHTML = html+ const live = body.outerHTML+ const contents = Array.from(editor.querySelectorAll('li')).map((item) => item.textContent)+ const checks = Array.from(editor.querySelectorAll<HTMLInputElement>('input')).map(+ (input) => input.checked+ )+ editor.dispatchEvent(new InputEvent('input', { bubbles: true, inputType: 'insertParagraph' }))+ const markdown = source.replace('First', text)++ expect(body.outerHTML).toBe(live)+ expect(messages.filter((message) => message.type === 'change')).toEqual([+ { type: 'change', generation: 7, markdown }+ ])+ editorDocument.send.setMarkdown(markdown, 8)+ expect(editor.querySelector(selector)!.querySelector('p')!.innerHTML).toBe(inline)+ expect(Array.from(editor.querySelectorAll('li')).map((item) => item.textContent)).toEqual(+ contents+ )+ expect(+ Array.from(editor.querySelectorAll<HTMLInputElement>('input')).map((input) => input.checked)+ ).toEqual(checks)+ expect(editor.querySelector(':scope > p')?.textContent).toBe('Outside')+ expect(editorDocument.send.currentMarkdown()).toBe(markdown)+ }+ )+}++it.each([+ ['<p>First<br></p><p>Second</p>', 'First<br />Second'],+ ['<p>First</p><p><br></p><p>Second</p>', 'First<br /><br />Second'],+ ['<p>First</p>\n <p>Second</p>', 'First<br />Second'],+ ['<p>First\n</p><p>Second</p>', 'First<br />Second'],+ ['First<div>Second</div>Third', 'First<br />Second<br />Third'],+ ['First<br><div>Second</div>', 'First<br />Second'],+ ['<strong>First</strong> <em>Second</em>', '**First** *Second*']+])('keeps existing breaks, empty lines and inline spaces without duplication: %j', (html, text) => {+ const { editorDocument, editor } = surface('- First\n- Next')+ const item = editor.querySelector('li')!+ item.innerHTML = html+ const live = item.outerHTML+ const markdown = `- ${text}\n- Next`++ expect(editorDocument.send.currentMarkdown()).toBe(markdown)+ expect(item.outerHTML).toBe(live)+ editorDocument.send.setMarkdown(markdown, 8)+ expect(editorDocument.send.currentMarkdown()).toBe(markdown)+})++it('retains nested lists and checkbox labels while serializing the owning item once', () => {+ const { editorDocument, editor } = surface('- [x] First\n 8. Child\n 9. Next\n- [ ] Last')+ const paragraph = editor.querySelector('li > div > p')!+ paragraph.insertAdjacentHTML('afterend', '<p>Second</p>')+ const live = editor.innerHTML+ const markdown = '- [x] First<br />Second\n 8. Child\n 9. Next\n- [ ] Last'++ expect(editorDocument.send.currentMarkdown()).toBe(markdown)+ expect(editor.innerHTML).toBe(live)+ editorDocument.send.setMarkdown(markdown, 8)+ expect(editor.querySelectorAll('li').length).toBe(4)+ expect(editor.querySelectorAll('ol li').length).toBe(2)+ expect(editor.querySelectorAll('input').length).toBe(2)+ expect(editor.querySelector<HTMLInputElement>('input')!.checked).toBe(true)+ expect(editorDocument.send.currentMarkdown()).toBe(markdown)+})diff --git a/mobile/src/components/rich-markdown/markdown-list-code-blocks.test.ts b/mobile/src/components/rich-markdown/markdown-list-code-blocks.test.tsnew file mode 100644index 00000000000..001da174a63--- /dev/null+++ b/mobile/src/components/rich-markdown/markdown-list-code-blocks.test.ts@@ -0,0 +1,155 @@+// @vitest-environment happy-dom+import { afterEach, describe, expect, it } from 'vitest'+import { createRichMarkdownEditorDocument } from './create-rich-markdown-editor-document'+import { RICH_MARKDOWN_EDITOR_MARKUP } from './document-markup'+import { quietRichMarkdownEditorHost } from './rich-markdown-editor-host.test-support'+import type { RichMarkdownEditorDocument } from './document-host-seams'+import type { MobileRichMarkdownEditorMessage } from '../mobile-rich-markdown-editor-contract'++let mounted: RichMarkdownEditorDocument | undefined++afterEach(() => {+ mounted?.stop()+ mounted = undefined+ document.body.innerHTML = ''+})++function open(markdown: string) {+ document.body.innerHTML = RICH_MARKDOWN_EDITOR_MARKUP+ const messages: MobileRichMarkdownEditorMessage[] = []+ const editorDocument = createRichMarkdownEditorDocument(+ quietRichMarkdownEditorHost({ postToHost: (message) => messages.push(message) })+ )+ mounted = editorDocument+ editorDocument.send.setMarkdown(markdown, 7)+ return { editorDocument, messages, editor: document.getElementById('editor')! }+}++const contexts = [+ { name: 'bullet', source: '- Intro\n- Next\n\nOutside', selector: 'li' },+ { name: 'ordered', source: '10. Intro\n11. Next\n\nOutside', selector: 'li' },+ { name: 'task', source: '- [x] Intro\n- [ ] Next\n\nOutside', selector: 'li > div' },+ {+ name: 'nested ordered',+ source: '- Parent\n 3. Intro\n 4. Next\n- Last\n\nOutside',+ selector: 'ol li'+ }+]++describe('mobile list code blocks', () => {+ it.each(contexts)(+ 'preserves literal code and continuation paragraphs in $name items',+ ({ source, selector }) => {+ const { editorDocument, messages, editor } = open(source)+ const body = editor.querySelector(selector)!+ body.innerHTML =+ '<p>Before <strong>bold</strong><br>continued</p><pre data-language="js"><code></code></pre><p>After <em>tail</em></p>'+ const code = ' indented\n\ttab\n\t\n \n\n````\n<tag>& <'+ body.querySelector('code')!.textContent = code+ const items = editor.querySelectorAll('li').length+ const before = body.innerHTML+ messages.length = 0+ editor.dispatchEvent(new Event('input'))+ const saved = editorDocument.send.currentMarkdown()+ expect(body.innerHTML).toBe(before)+ expect(messages).toEqual([{ type: 'change', markdown: saved, generation: 7 }])+ editorDocument.send.setMarkdown(saved, 8)+ const reopened = editor.querySelector(selector)!+ expect(reopened.querySelector('pre')?.textContent).toBe(code)+ expect(reopened.querySelector('pre')?.getAttribute('data-language')).toBe('js')+ expect(Array.from(reopened.querySelectorAll('p')).map((node) => node.textContent)).toEqual([+ 'Before boldcontinued',+ 'After tail'+ ])+ expect(reopened.querySelector('p br')).not.toBeNull()+ expect(reopened.querySelector('strong')?.textContent).toBe('bold')+ expect(reopened.querySelector('em')?.textContent).toBe('tail')+ expect(editor.querySelectorAll('li').length).toBe(items)+ expect(editor.querySelector(':scope > p')?.textContent).toBe('Outside')+ expect(editorDocument.send.currentMarkdown()).toBe(saved)+ }+ )++ it.each([+ { source: '1. Install:\n ```bash\n npm i\n ```\n2. Run', selector: 'li' },+ {+ source: '- Parent\n 3. Intro\n\n ```js\n code\n ```\n\n After\n 4. Next',+ selector: 'ol li'+ }+ ])('reads an indented fenced block inside its item: $source', ({ source, selector }) => {+ const { editorDocument, editor } = open(source)+ const body = editor.querySelector(selector)!+ expect(body.querySelector('pre')).not.toBeNull()+ expect(editor.querySelectorAll(':scope > ol, :scope > ul').length).toBe(1)+ const saved = editorDocument.send.currentMarkdown()+ editorDocument.send.setMarkdown(saved, 8)+ expect(editor.querySelector(selector)?.querySelector('pre')?.textContent).toBe(+ body.querySelector('pre')?.textContent+ )+ expect(editorDocument.send.currentMarkdown()).toBe(saved)+ })++ it('keeps tables, quotes, rules and headings after a list fence as their own blocks', () => {+ const source = [+ '1. Run:',+ ' ```bash',+ ' x',+ ' ```',+ ' | Flag | Desc |',+ ' | --- | --- |',+ ' | a | b |',+ '2. Note',+ ' ```',+ ' y',+ ' ```',+ ' > careful',+ '3. Rule',+ ' ```',+ ' z',+ ' ```',+ ' ***',+ '- # Title',+ ' ```',+ ' w',+ ' ```',+ ' ### Sub'+ ].join('\n')+ const { editorDocument, editor } = open(source)+ expect(editor.querySelectorAll('li pre').length).toBe(4)+ expect(editor.querySelector('table td')?.textContent).toBe('a')+ expect(editor.querySelector('hr')).not.toBeNull()+ expect(editor.querySelector('ul li p')?.textContent).toBe('# Title')++ const saved = editorDocument.send.currentMarkdown()+ expect(saved).toContain('| Flag | Desc |')+ expect(saved).toContain('careful')+ expect(saved).toContain('### Sub')+ expect(saved).toContain('- # Title')+ editorDocument.send.setMarkdown(saved, 8)+ expect(editorDocument.send.currentMarkdown()).toBe(saved)+ })++ it('writes a code block inserted into an item as a fence its reader keeps in place', () => {+ const { editorDocument, editor } = open('- Intro\n- Next')+ editor+ .querySelector('li')!+ .insertAdjacentHTML('beforeend', '<pre data-language=""><code>a\nb</code></pre><p><br></p>')++ const saved = editorDocument.send.currentMarkdown()+ expect(saved).toBe('- Intro\n ```\n a\n b\n ```\n- Next')+ editorDocument.send.setMarkdown(saved, 8)+ expect(editor.querySelectorAll('li').length).toBe(2)+ expect(editor.querySelector('li pre')?.textContent).toBe('a\nb')+ })++ it('keeps an empty first task line before code and retains checked state', () => {+ const { editorDocument, editor } = open('- [x] Intro\n- [ ] Next')+ const body = editor.querySelector('li > div')!+ body.innerHTML = '<p><br></p><pre data-language=""><code>literal</code></pre><p>After</p>'+ const saved = editorDocument.send.currentMarkdown()+ editorDocument.send.setMarkdown(saved, 8)+ expect(editor.querySelector<HTMLInputElement>('li > label input')?.checked).toBe(true)+ expect(editor.querySelector('li pre')?.textContent).toBe('literal')+ expect(editorDocument.send.currentMarkdown()).toBe(saved)+ })+})diff --git a/mobile/src/components/rich-markdown/markdown-list-linebreaks.test.ts b/mobile/src/components/rich-markdown/markdown-list-linebreaks.test.tsnew file mode 100644index 00000000000..ebcc69ac183--- /dev/null+++ b/mobile/src/components/rich-markdown/markdown-list-linebreaks.test.ts@@ -0,0 +1,127 @@+// @vitest-environment happy-dom+import { afterEach, expect, it } from 'vitest'+import { createRichMarkdownEditorDocument } from './create-rich-markdown-editor-document'+import { RICH_MARKDOWN_EDITOR_MARKUP } from './document-markup'+import { quietRichMarkdownEditorHost } from './rich-markdown-editor-host.test-support'+import type { MobileRichMarkdownEditorMessage } from '../mobile-rich-markdown-editor-contract'++const stopDocuments: (() => void)[] = []+const lists = [+ ['bullet', '- First\n- Next\n\nOutside', 'li > p'],+ ['task', '- [ ] First\n- [x] Next\n\nOutside', 'li > div > p']+] as const++function surface(source: string) {+ document.body.innerHTML = RICH_MARKDOWN_EDITOR_MARKUP+ const messages: MobileRichMarkdownEditorMessage[] = []+ const editorDocument = createRichMarkdownEditorDocument({+ ...quietRichMarkdownEditorHost(),+ postToHost: (message) => messages.push(message)+ })+ stopDocuments.push(editorDocument.stop)+ editorDocument.send.setMarkdown(source, 7)+ return { editorDocument, editor: document.getElementById('editor')!, messages }+}++afterEach(() => {+ stopDocuments.splice(0).forEach((stop) => stop())+ document.body.innerHTML = ''+})++for (const [kind, source, selector] of lists) {+ it.each([+ ['First<br>Second', 'First<br />Second'],+ ['<strong>First<br>Second</strong>', '**First<br />Second**'],+ ['<code>First</code><br><code>Second</code>', '`First`<br />`Second`']+ ])(`keeps ${kind} item soft break inside its list through host save: %s`, (html, text) => {+ const { editorDocument, editor, messages } = surface(source)+ editor.querySelector(selector)!.innerHTML = html+ const live = editor.querySelector(selector)!.outerHTML+ const items = Array.from(editor.querySelectorAll('li')).map((item) => item.textContent)+ const checkboxes = Array.from(editor.querySelectorAll<HTMLInputElement>('input')).map(+ (input) => input.checked+ )+ editor.dispatchEvent(new InputEvent('input', { bubbles: true, inputType: 'insertLineBreak' }))+ const markdown = source.replace('First', text)++ expect(editor.querySelector(selector)!.outerHTML).toBe(live)+ expect(messages.filter((message) => message.type === 'change')).toEqual([+ { type: 'change', generation: 7, markdown }+ ])+ editorDocument.send.setMarkdown(markdown, 8)+ expect(Array.from(editor.querySelectorAll('li')).map((item) => item.textContent)).toEqual(items)+ expect(+ Array.from(editor.querySelectorAll<HTMLInputElement>('input')).map((input) => input.checked)+ ).toEqual(checkboxes)+ expect(editor.querySelector(selector)?.innerHTML).toBe(html)+ expect(editor.querySelector(':scope > p')?.textContent).toBe('Outside')+ expect(editorDocument.send.currentMarkdown()).toBe(markdown)+ })+}++it.each([+ ['- First\n- Next', 'li > p', '<br>'],+ ['3. First\n4. Next', 'li > p', 'a<BR/>b'],+ ['- [ ] First\n- [x] Next', 'li > div > p', '<br onload="run()">']+])('keeps typed list markup literal: %s', (source, selector, text) => {+ const { editorDocument, editor } = surface(source)+ editor.querySelector(selector)!.textContent = text+ const markdown = editorDocument.send.currentMarkdown()+ editorDocument.send.setMarkdown(markdown, 8)++ expect(editor.querySelector(selector)?.textContent).toBe(text)+ expect(editor.querySelector(selector)?.children.length).toBe(0)+ expect(editor.querySelectorAll('li').length).toBe(2)+ expect(editorDocument.send.currentMarkdown()).toBe(markdown)+})++it('recognizes attribute-free list breaks while keeping code and paragraph markup literal', () => {+ const { editor } = surface('- `<br>`\n- <br>\n- a<BR/>b\n- <br onload="run()">\n\n<br />')++ expect(editor.querySelector('li code')?.textContent).toBe('<br>')+ expect(editor.querySelectorAll('li')[1]?.textContent).toBe('<br>')+ expect(editor.querySelectorAll('li')[2]?.querySelector('p')?.innerHTML).toBe('a<br>b')+ expect(editor.querySelectorAll('li')[3]?.textContent).toBe('<br onload="run()">')+ expect(editor.querySelector('[onload]')).toBe(null)+ expect(editor.lastElementChild?.textContent).toBe('<br />')+ expect(editor.lastElementChild?.children.length).toBe(0)+})++it.each([+ ['- First\n- Next\n- Last', 'li > p'],+ ['- [ ] First\n- [x] Next\n- [ ] Last', 'li > div > p']+])('keeps a cleared item in its list instead of writing a bare marker: %s', (source, selector) => {+ const { editorDocument, editor } = surface(source)+ editor.querySelectorAll(selector)[1]!.replaceChildren(document.createElement('br'))+ const markdown = editorDocument.send.currentMarkdown()+ editorDocument.send.setMarkdown(markdown, 8)++ expect(editor.children.length).toBe(1)+ expect(Array.from(editor.querySelectorAll('li')).map((item) => item.textContent)).toEqual([+ 'First',+ '',+ 'Last'+ ])+ expect(editorDocument.send.currentMarkdown()).toBe(markdown)+})++it.each([+ ['<span>First</span><br>', 'First'],+ ['<p>First<br></p>', 'First'],+ ['<p><strong>First<br></strong></p>', '**First**'],+ ['<span>First</span><br><ul><li><p>Child</p></li></ul>', 'First\n - Child'],+ ['<p>First<br><br></p>', 'First<br /><br />'],+ ['<p><br>First</p>', '<br />First'],+ ['<p>\n First\n</p>', 'First']+])('drops only the caret placeholder break from an item: %j', (html, text) => {+ const { editorDocument, editor } = surface('- First\n- Next\n\nOutside')+ const item = editor.querySelector('li')!+ item.innerHTML = html+ const live = item.outerHTML+ const markdown = `- ${text}\n- Next\n\nOutside`++ expect(editorDocument.send.currentMarkdown()).toBe(markdown)+ expect(item.outerHTML).toBe(live)+ editorDocument.send.setMarkdown(markdown, 8)+ expect(editorDocument.send.currentMarkdown()).toBe(markdown)+})diff --git a/mobile/src/components/rich-markdown/markdown-list-parse.ts b/mobile/src/components/rich-markdown/markdown-list-parse.tsindex b3b9f4a744e..39267c2c5e1 100644--- a/mobile/src/components/rich-markdown/markdown-list-parse.ts+++ b/mobile/src/components/rich-markdown/markdown-list-parse.ts@@ -1,3 +1,6 @@+import { closesFence, openingFence } from './markdown-code-fence'+import { isTableSeparator } from './markdown-table-rows'+/** One list line, with its marker read and its nesting resolved against the lines around it. */export type ParsedListItem = {indent: number@@ -6,6 +9,8 @@ export type ParsedListItem = {/** Whether the item's checkbox is ticked, or null when it is not a task at all. */task: boolean | nulltext: string+ /** The item's own lines, first line included, when they hold a fenced code block. */+ blockSource?: stringchildren: ParsedListItem[]}@@ -41,6 +46,92 @@ export function listKind(item: ParsedListItem): 'task' | 'ol' | 'ul' {return item.ordered ? 'ol' : 'ul'}+function removeIndentation(line: string, width: number): string {+ let index = 0+ let removed = 0+ while (index < line.length && removed < width) {+ if (line[index] === ' ') {+ removed += 1+ } else if (line[index] === '\t') {+ removed += 4+ } else {+ break+ }+ index += 1+ }+ return ' '.repeat(Math.max(0, removed - width)) + line.slice(index)+}++// Headings, quotes, rules and tables end the item's blocks, so they keep reading as they did before.+function endsItemBlocks(content: string, next: string): boolean {+ const line = content.trimStart()+ return (+ /^(#{1,6}\s|>|(-{3,}|\*{3,}|_{3,})\s*$)/.test(line) ||+ (line.includes('|') && isTableSeparator(next))+ )+}++// Indented continuation lines join the item only when they hold a fence; other items keep one-line reading.+function listItemBlocks(+ lines: string[],+ startIndex: number,+ item: ParsedListItem+): { source: string; nextIndex: number } | null {+ if (+ /^\[[ xX]\]$/.test(item.text) ||+ (item.task !== null && (!item.text.trim() || openingFence(item.text)))+ ) {+ return null+ }+ const marker = (lines[startIndex] ?? '').match(/^(\s*)(?:[-*+]|\d+[.)])([ \t]+)/)+ if (!marker) {+ return null+ }+ const width = indentationWidth(marker[0])+ const body = [item.text]+ let fence = openingFence(item.text)+ let hasCode = fence !== null+ let index = startIndex + 1+ let end = index+ while (index < lines.length) {+ const line = lines[index] ?? ''+ if (!line.trim()) {+ body.push(fence ? removeIndentation(line, width) : '')+ index += 1+ if (fence) {+ end = index+ }+ continue+ }+ if (indentationWidth(line.match(/^[ \t]*/)?.[0] ?? '') < width) {+ break+ }+ const content = removeIndentation(line, width)+ if (+ !fence &&+ (parseListLine(line) ||+ endsItemBlocks(content, removeIndentation(lines[index + 1] ?? '', width)))+ ) {+ break+ }+ body.push(content)+ if (fence) {+ if (closesFence(content, fence.fence)) {+ fence = null+ }+ } else {+ fence = openingFence(content)+ hasCode ||= fence !== null+ }+ index += 1+ end = index+ }+ if (!hasCode) {+ return null+ }+ return { source: body.slice(0, end - startIndex).join('\n'), nextIndex: end }+}+// Parse contiguous list run with stack: indent can drop several levels and caller needs end index to resume block parsing.export function parseListTree(lines: string[],@@ -60,7 +151,11 @@ export function parseListTree(}stack[stack.length - 1]!.children.push(item)stack.push(item)- index += 1+ const blocks = listItemBlocks(lines, index, item)+ if (blocks) {+ item.blockSource = blocks.source+ }+ index = blocks?.nextIndex ?? index + 1}return { items: root.children, nextIndex: index }}diff --git a/mobile/src/components/rich-markdown/markdown-list-render.ts b/mobile/src/components/rich-markdown/markdown-list-render.tsindex 46af79cd67c..0f2d2dc0161 100644--- a/mobile/src/components/rich-markdown/markdown-list-render.ts+++ b/mobile/src/components/rich-markdown/markdown-list-render.ts@@ -1,9 +1,31 @@+import { openingFence } from './markdown-code-fence'import { renderInline } from './markdown-inline-render'import { listKind, type ParsedListItem } from './markdown-list-parse'import type { RichMarkdownEditorScope } from './document-scope'+// The leading lines stay one inline paragraph so block syntax on the marker line (`- # Title`) reads as text.+function itemContent(item: ParsedListItem, renderBlocks: (markdown: string) => string): string {+ if (item.blockSource === undefined) {+ return `<p>${renderInline(item.text, true)}</p>`+ }+ const lines = item.blockSource.split('\n')+ let lead = 0+ while (lead < lines.length && lines[lead]?.trim() && !openingFence(lines[lead] ?? '')) {+ lead += 1+ }+ const paragraph = lines.slice(0, lead).join('\n')+ return (+ (paragraph ? `<p>${renderInline(paragraph, true).replace(/\n/g, '<br />')}</p>` : '') ++ renderBlocks(lines.slice(lead).join('\n'))+ )+}+// Render one list per same-kind run; disable task checkboxes under read-only surface or user toggles would go unrecorded.-export function renderListItems(scope: RichMarkdownEditorScope, items: ParsedListItem[]): string {+export function renderListItems(+ scope: RichMarkdownEditorScope,+ items: ParsedListItem[],+ renderBlocks: (markdown: string) => string+): string {const html: string[] = []let index = 0while (index < items.length) {@@ -22,20 +44,22 @@ export function renderListItems(scope: RichMarkdownEditorScope, items: ParsedLis: ''const rendered = group.map((item) => {- const children = item.children.length ? renderListItems(scope, item.children) : ''+ const children = item.children.length+ ? renderListItems(scope, item.children, renderBlocks)+ : ''if (kind === 'task') {const checked = item.task === truereturn (`<li data-checked="${String(checked)}"><label contenteditable="false">` +`<input type="checkbox" ${checked ? 'checked ' : ''}${scope.editable ? '' : 'disabled '}/>` +- `</label><div><p>${renderInline(item.text)}</p>${children}</div></li>`+ `</label><div>${itemContent(item, renderBlocks)}${children}</div></li>`)}const orderedAttrs =kind === 'ol' && item.orderedNumber !== null? ` value="${item.orderedNumber}" data-list-number="${item.orderedNumber}"`: ''- return `<li${orderedAttrs}><p>${renderInline(item.text)}</p>${children}</li>`+ return `<li${orderedAttrs}>${itemContent(item, renderBlocks)}${children}</li>`}).join('')html.push(`<${tag}${attrs}>${rendered}</${tag}>`)diff --git a/mobile/src/components/rich-markdown/markdown-table-linebreaks.test.ts b/mobile/src/components/rich-markdown/markdown-table-linebreaks.test.tsnew file mode 100644index 00000000000..58cdc2896d0--- /dev/null+++ b/mobile/src/components/rich-markdown/markdown-table-linebreaks.test.ts@@ -0,0 +1,121 @@+// @vitest-environment happy-dom+import { afterEach, expect, it } from 'vitest'+import { createRichMarkdownEditorDocument } from './create-rich-markdown-editor-document'+import { RICH_MARKDOWN_EDITOR_MARKUP } from './document-markup'+import { quietRichMarkdownEditorHost } from './rich-markdown-editor-host.test-support'+import type { MobileRichMarkdownEditorMessage } from '../mobile-rich-markdown-editor-contract'++const stopDocuments: (() => void)[] = []+const original = '| Header | Other |\n| --- | --- |\n| First | Right |\n\nOutside'++afterEach(() => {+ stopDocuments.splice(0).forEach((stop) => stop())+ document.body.innerHTML = ''+})++function surface() {+ document.body.innerHTML = RICH_MARKDOWN_EDITOR_MARKUP+ const messages: MobileRichMarkdownEditorMessage[] = []+ const editorDocument = createRichMarkdownEditorDocument({+ ...quietRichMarkdownEditorHost(),+ postToHost: (message) => messages.push(message)+ })+ stopDocuments.push(editorDocument.stop)+ editorDocument.send.setMarkdown(original, 7)+ return { editorDocument, editor: document.getElementById('editor')!, messages }+}++function cellTexts(editor: HTMLElement) {+ return Array.from(editor.querySelectorAll('tr')).map((row) =>+ Array.from(row.children).map((node) => node.textContent)+ )+}++it.each([+ ['First<br>Second', 'First<br />Second'],+ ['<strong>First<br>Second</strong>', '**First<br />Second**'],+ ['<code>First</code><br><code>Second</code>', '`First`<br />`Second`']+])('keeps a cell line break in its own table row through host save: %s', (html, cell) => {+ const { editorDocument, editor, messages } = surface()+ editor.querySelector('td')!.innerHTML = html+ const live = editor.innerHTML+ editor.dispatchEvent(new InputEvent('input', { bubbles: true, inputType: 'insertLineBreak' }))+ const markdown = original.replace('| First |', `| ${cell} |`)++ expect(editor.innerHTML).toBe(live)+ expect(messages.filter((message) => message.type === 'change')).toEqual([+ { type: 'change', generation: 7, markdown }+ ])+ editorDocument.send.setMarkdown(markdown, 8)+ expect(cellTexts(editor)).toEqual([+ ['Header', 'Other'],+ ['FirstSecond', 'Right']+ ])+ expect(editor.querySelector('td')?.innerHTML).toBe(html)+ expect(editorDocument.send.currentMarkdown()).toBe(markdown)+})++it.each([+ ['<br>', ''],+ ['First<br>', 'First'],+ ['<strong>First<br></strong>', '**First**'],+ ['\n First\n', 'First']+])('drops placeholder breaks and formatting newlines from a cell: %j', (html, cell) => {+ const { editorDocument, editor } = surface()+ editor.querySelector('td')!.innerHTML = html++ const markdown = editorDocument.send.currentMarkdown()+ expect(markdown).toBe(original.replace('| First |', cell ? `| ${cell} |` : '| |'))+ editorDocument.send.setMarkdown(markdown, 8)+ expect(editor.querySelectorAll('tr').length).toBe(2)+ expect(editor.querySelector('td')?.querySelector('br')).toBe(null)+})++it('keeps an authored run of trailing cell breaks byte-for-byte', () => {+ const { editorDocument } = surface()+ const markdown = original.replace('| First |', '| x<br /><br /> |')+ editorDocument.send.setMarkdown(markdown, 8)++ expect(editorDocument.send.currentMarkdown()).toBe(markdown)+})++it.each(['<br>', '<BR />', 'a<br/>b', '<br onload="run()">'])(+ 'keeps typed table markup literal: %s',+ (text) => {+ const { editorDocument, editor } = surface()+ editor.querySelector('td')!.textContent = text+ const markdown = editorDocument.send.currentMarkdown()+ editorDocument.send.setMarkdown(markdown, 8)++ expect(editor.querySelector('td')?.textContent).toBe(text)+ expect(editor.querySelector('td')?.children.length).toBe(0)+ expect(editor.querySelectorAll('tr').length).toBe(2)+ expect(editorDocument.send.currentMarkdown()).toBe(markdown)+ }+)++it('keeps a typed break literal when the browser splits it across text nodes', () => {+ const { editorDocument, editor } = surface()+ editor.querySelector('td')!.replaceChildren(document.createTextNode('<b'), 'r>')+ const markdown = editorDocument.send.currentMarkdown()+ editorDocument.send.setMarkdown(markdown, 8)++ expect(editor.querySelector('td')?.textContent).toBe('<br>')+ expect(editor.querySelector('td')?.children.length).toBe(0)+})++it('recognizes attribute-free table breaks without interpreting code or paragraph HTML', () => {+ const { editorDocument, editor } = surface()+ editorDocument.send.setMarkdown(+ '| `<br>` | <br> |\n| --- | --- |\n| a<BR/>b | <br onload="run()"> |\n\n<br />',+ 8+ )++ expect(editor.querySelector('th code')?.textContent).toBe('<br>')+ expect(editor.querySelectorAll('th')[1]?.textContent).toBe('<br>')+ expect(editor.querySelectorAll('td')[0]?.innerHTML).toBe('a<br>b')+ expect(editor.querySelectorAll('td')[1]?.textContent).toBe('<br onload="run()">')+ expect(editor.querySelector('[onload]')).toBe(null)+ expect(editor.lastElementChild?.textContent).toBe('<br />')+ expect(editor.lastElementChild?.children.length).toBe(0)+})diff --git a/mobile/src/components/rich-markdown/markdown-to-html.ts b/mobile/src/components/rich-markdown/markdown-to-html.tsindex 3d65100259c..bb87cc60312 100644--- a/mobile/src/components/rich-markdown/markdown-to-html.ts+++ b/mobile/src/components/rich-markdown/markdown-to-html.ts@@ -29,7 +29,12 @@ function quoteMarkup(probe: () => Element, quote: string[], structured: string):}// Read fenced/table/list blocks by their own consumed line runs, not flat replacements; empty source still needs paragraph for placeholder.-export function markdownToHtml(scope: RichMarkdownEditorScope, markdown: string): string {+// Inside a list item paragraphs read `<br>` tokens, the item writer's only line-break spelling.+export function markdownToHtml(+ scope: RichMarkdownEditorScope,+ markdown: string,+ insideListItem = false+): string {let lines = markdown.replace(/\r\n?/g, '\n').split('\n')let html: string[] = []let index = 0@@ -96,11 +101,11 @@ export function markdownToHtml(scope: RichMarkdownEditorScope, markdown: string)rows.push(splitTableRow(lines[index] ?? ''))index += 1}- const head = headers.map((cell) => `<th>${renderInline(cell)}</th>`).join('')+ const head = headers.map((cell) => `<th>${renderInline(cell, true)}</th>`).join('')const body = rows.map((row) =>- `<tr>${headers.map((_, cellIndex) => `<td>${renderInline(row[cellIndex] ?? '')}</td>`).join('')}</tr>`+ `<tr>${headers.map((_, cellIndex) => `<td>${renderInline(row[cellIndex] ?? '', true)}</td>`).join('')}</tr>`).join('')html.push(`<table><thead><tr>${head}</tr></thead><tbody>${body}</tbody></table>`)@@ -129,7 +134,9 @@ export function markdownToHtml(scope: RichMarkdownEditorScope, markdown: string)const list = parseListTree(lines, index)// Empty marker produces no list item and no index progress; fall through as text instead of continuing forever.if (list.nextIndex > index) {- html.push(renderListItems(scope, list.items))+ html.push(+ renderListItems(scope, list.items, (content) => markdownToHtml(scope, content, true))+ )index = list.nextIndexcontinue}@@ -153,7 +160,9 @@ export function markdownToHtml(scope: RichMarkdownEditorScope, markdown: string)paragraph.push(lines[index] ?? '')index += 1}- html.push(`<p>${renderInline(paragraph.join('\n')).replace(/\n/g, '<br />')}</p>`)+ html.push(+ `<p>${renderInline(paragraph.join('\n'), insideListItem).replace(/\n/g, '<br />')}</p>`+ )}return html.join('\n') || '<p class="is-empty"><br /></p>'}