Skip to content

Qwen3.8-Flash-Next on any consumer hardware: one-click install for Windows / Linux. Strata inference engine, OpenAI/Anthropic API on localhost, optional image input.

C++

Markdown: a single newline inside a paragraph is a soft break (a space); two spaces or a backslash at the end of a line keeps a line break (#3818)

Niko1221c1e80f7952f0
diff --git a/apps/host/src/components/Markdown.tsx b/apps/host/src/components/Markdown.tsx
index 996b191f2..1750d40b3 100644
--- a/apps/host/src/components/Markdown.tsx
+++ b/apps/host/src/components/Markdown.tsx
@@ -47,6 +47,15 @@ function inline(text: string, onOpenLink?: (url: string) => void, imageSession?:
: <Fragment key={p}>{inlineMarks(part.text, onOpenLink, imageSession)}</Fragment>)}</Fragment>;
});
}
+/** Does this line continue the paragraph above it, or does it start a block of its own? */
+export function continuesParagraph(lines: string[], at: number): boolean {
+ const line = lines[at];
+ if (!line.trim() || /^\s*```/.test(line) || /^(#{1,6})\s+(.+)$/.test(line) || /^\s*[-*+]\s+\S/.test(line) || /^\s*\d+[.)]\s+\S/.test(line) || /^>\s?/.test(line))
+ return false;
+ if (line.includes('|') && at + 1 < lines.length && /^\s*\|?\s*:?-{3,}/.test(lines[at + 1]))
+ return false;
+ return !displayBlock(lines, at);
+}
export function Markdown({ text, onOpenLink, onPreviewHtml, imageSession }: {
text: string;
onOpenLink?: (url: string) => void;
@@ -113,8 +122,19 @@ export function Markdown({ text, onOpenLink, onPreviewHtml, imageSession }: {
i++;
continue;
}
- nodes.push(<p key={i}>{tr(inline(line, onOpenLink, imageSession))}</p>);
+ // One paragraph: a single newline inside it is a soft break (a space); two spaces or a backslash at the end of a line is a hard break (#3818).
+ const key = i, parts: ReactNode[] = [];
+ let current = line;
i++;
+ while (true) {
+ const hard = /( {2,}|\\)$/.test(current);
+ parts.push(<Fragment key={parts.length}>{tr(inline(current.replace(/( {2,}|\\)$/, ''), onOpenLink, imageSession))}</Fragment>);
+ if (i >= lines.length || !continuesParagraph(lines, i))
+ break;
+ parts.push(hard ? <br key={`b${parts.length}`}/> : ' ');
+ current = lines[i++].trimStart();
+ }
+ nodes.push(<p key={key}>{tr(parts)}</p>);
}
return <>{tr(nodes)}</>;
}
diff --git a/apps/host/tests/markdown-soft-breaks.test.mjs b/apps/host/tests/markdown-soft-breaks.test.mjs
new file mode 100644
index 000000000..3909d5a3f
--- /dev/null
+++ b/apps/host/tests/markdown-soft-breaks.test.mjs
@@ -0,0 +1,34 @@
+// #3818: a single newline inside a paragraph is a space; a blank line starts a new paragraph; two trailing spaces or a backslash is a line break.
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { resolve } from 'node:path';
+import { createRequire } from 'node:module';
+import { build } from 'esbuild';
+
+const root = resolve(import.meta.dirname, '..');
+const bundle = await build({
+ stdin: { contents: `import React from 'react'; import { renderToStaticMarkup } from 'react-dom/server'; import { Markdown } from './src/components/Markdown.tsx'; export const html = text => renderToStaticMarkup(React.createElement(Markdown, { text }));`, resolveDir: root, loader: 'ts' },
+ bundle: true, write: false, platform: 'node', format: 'cjs', jsx: 'automatic', external: ['katex', 'katex/dist/katex.min.css'],
+ plugins: [{ name: 'stub', setup(b) {
+ b.onResolve({ filter: /^\.\/ui$/ }, () => ({ path: 'ui', namespace: 'test-stub' }));
+ b.onLoad({ filter: /.*/, namespace: 'test-stub' }, () => ({ contents: 'export const IconBtn = () => null; export const Btn = () => null;' }));
+ } }],
+});
+const mod = { exports: {} };
+new Function('require', 'module', 'exports', bundle.outputFiles[0].text)(createRequire(import.meta.url), mod, mod.exports);
+const { html } = mod.exports;
+const paragraphs = out => (out.match(/<p>/g) ?? []).length;
+
+test('a single newline is a soft break, a blank line a new paragraph', () => {
+ const soft = html('Line one\nLine two');
+ assert.equal(paragraphs(soft), 1); assert.match(soft, /Line one Line two/);
+ assert.equal(paragraphs(html('One\n\nTwo')), 2);
+});
+test('two trailing spaces or a backslash keep a line break', () => {
+ assert.match(html('One \nTwo'), /One<br\/>Two/);
+ assert.match(html('One' + String.fromCharCode(92) + String.fromCharCode(10) + 'Two'), /One<br\/>Two/);
+});
+test('a list, heading or code block right after a line still starts its own block', () => {
+ const out = html('Intro\n- a\n- b\n## Head\ntext\n```\ncode\n```');
+ assert.match(out, /<p>Intro<\/p><ul>/); assert.match(out, /<h2>Head<\/h2><p>text<\/p>/);
+});