Fix block quotes doing mitosis (#893)

should preserve the new lines more accurately and probably fixes a
couple other bugs

<!-- Please read
https://github.com/SableClient/Sable/blob/dev/CONTRIBUTING.md before
submitting your pull request -->

### Description

<!-- Please include a summary of the change. Please also include
relevant motivation and context. List any dependencies that are required
for this change. -->

Fixes block quotes creating extra block quote lines when editing a
message/bio

Internal because its covered by the existing changesets for this update.

#### Type of change

- [x] Bug fix (non-breaking change which fixes an issue)
- [ ] New feature (non-breaking change which adds functionality)
- [ ] Breaking change (fix or feature that would cause existing
functionality to not work as expected)
- [ ] This change requires a documentation update

### Checklist:

- [ ] My code follows the style guidelines of this project
- [ ] I have performed a self-review of my own code
- [ ] I have commented my code, particularly in hard-to-understand areas
- [ ] I have made corresponding changes to the documentation
- [ ] My changes generate no new warnings

### AI disclosure:

- [x] Partially AI assisted (clarify which code was AI assisted and
briefly explain what it does).
- [ ] Fully AI generated (explain what all the generated code does in
moderate detail).
<!-- Write any explanation required here, but do not generate the
explanation using AI!! You must prove you understand what the code in
this PR does. -->

Tests were updated by AI

Author: 7w1

src/app/plugins/markdown/bidirectional.test.ts

@@ -73,11 +73,16 @@ describe('bidirectional round-trip', () => {
   });
 
   it('round-trips blockquotes', () => {
-    const markdown = '> Quote text';
-    const html = markdownToHtml(markdown);
-    const injected = injectDataMd(html);
-    const result = htmlToMarkdown(injected);
-    expect(result).toContain('> Quote text');
+    const roundtrip = (markdown: string) => {
+      const html = markdownToHtml(markdown);
+      const injected = injectDataMd(html);
+      return htmlToMarkdown(injected);
+    };
+    expect(roundtrip('> Quote text')).toBe('> Quote text');
+    expect(roundtrip('> line one\n> line two')).toBe('> line one\n> line two');
+    expect(roundtrip('> test\ntest')).toBe('> test\ntest');
+    expect(roundtrip('> test\n\n> test')).toBe('> test\n\n> test');
+    expect((markdownToHtml('> test\n\n> test').match(/<blockquote/g) ?? []).length).toBe(2);
   });
 
   it('round-trips unordered lists', () => {

src/app/plugins/markdown/expandBlockNewlines.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from 'vitest';
+import { expandBlockBoundariesAfterSingleNewlines } from './expandBlockNewlines';
+import { markdownToHtml } from './markdownToHtml';
+
+describe('expandBlockBoundariesAfterSingleNewlines', () => {
+  it('does not expand between consecutive blockquote lines', () => {
+    const md = '> test\n> test\n> test';
+    expect(expandBlockBoundariesAfterSingleNewlines(md)).toBe(md);
+  });
+
+  it('still expands before the first blockquote line', () => {
+    expect(expandBlockBoundariesAfterSingleNewlines('intro\n> quote')).toBe('intro\n\n> quote');
+  });
+
+  it('still expands when a blockquote ends', () => {
+    expect(expandBlockBoundariesAfterSingleNewlines('> quote\nplain')).toBe('> quote\n\nplain');
+  });
+});
+
+describe('consecutive blockquotes', () => {
+  it('produces a single blockquote element', () => {
+    const html = markdownToHtml('> test\n> test\n> test');
+    expect((html.match(/<blockquote/g) ?? []).length).toBe(1);
+  });
+});

src/app/plugins/markdown/expandBlockNewlines.ts

@@ -136,6 +136,10 @@ function nextLineIsBlockStarter(md: string, newlineIdx: number): boolean {
 }
 
 function shouldExpandSingleNewline(md: string, newlineIdx: number): boolean {
+  // Consecutive `>` lines belong to one blockquote, keep the single `\n` between them.
+  if (prevLineIsBlockquote(md, newlineIdx) && nextLineContinuesBlockquote(md, newlineIdx)) {
+    return false;
+  }
   if (nextLineIsBlockStarter(md, newlineIdx)) return true;
   // CommonMark lazy continuation keeps non-`>` lines inside blockquotes, close on single `\n`.
   if (prevLineIsBlockquote(md, newlineIdx) && !nextLineContinuesBlockquote(md, newlineIdx)) {

src/app/plugins/markdown/htmlToMarkdown.test.ts

@@ -100,9 +100,17 @@ describe('htmlToMarkdown', () => {
   });
 
   it('converts blockquotes', () => {
-    const result = htmlToMarkdown('<blockquote>Quote text</blockquote>');
-    expect(result).toContain('>');
-    expect(result).toContain('Quote text');
+    expect(htmlToMarkdown('<blockquote>Quote text</blockquote>')).toBe('> Quote text');
+    expect(htmlToMarkdown('<blockquote><p>test</p></blockquote><p>test</p>')).toBe('> test\ntest');
+    expect(htmlToMarkdown('<blockquote><p>line one</p><p>line two</p></blockquote>')).toBe(
+      '> line one\n> line two'
+    );
+    expect(htmlToMarkdown('<blockquote><p>line one<br>line two</p></blockquote>')).toBe(
+      '> line one\n> line two'
+    );
+    expect(
+      htmlToMarkdown('<blockquote><p>first</p></blockquote><blockquote><p>second</p></blockquote>')
+    ).toBe('> first\n\n> second');
   });
 
   it('converts unordered lists', () => {

src/app/plugins/markdown/htmlToMarkdown.ts

@@ -66,15 +66,15 @@ function processNodes(nodes: ChildNode[]): string {
     const prev = filtered[i - 1];
     // Adjacent <p> blocks must become \n\n in markdown so the editor gets separate Slate
     // paragraphs and marked emits <p> per block again on send (single \n would collapse).
-    if (
-      i > 0 &&
-      prev &&
-      isTag(prev) &&
-      isTag(cur) &&
-      prev.name.toLowerCase() === 'p' &&
-      cur.name.toLowerCase() === 'p'
-    ) {
-      parts.push('\n');
+    if (i > 0 && prev && isTag(prev) && isTag(cur)) {
+      const prevTag = prev.name.toLowerCase();
+      const curTag = cur.name.toLowerCase();
+      if (
+        (prevTag === 'p' && curTag === 'p') ||
+        (prevTag === 'blockquote' && curTag === 'blockquote')
+      ) {
+        parts.push('\n');
+      }
     }
     parts.push(processNode(cur));
   }
@@ -333,19 +333,57 @@ function processParagraph(
   return `${content}\n`;
 }
 
+function collectBlockquoteBodyLines(
+  node: Element,
+  listDepth: number,
+  insideCode: boolean
+): string[] {
+  const lines: string[] = [];
+  const pushLine = (line: string) => {
+    lines.push(line);
+  };
+  const pushMultiline = (text: string) => {
+    for (const part of text.split('\n')) {
+      pushLine(part);
+    }
+  };
+
+  for (const child of node.children) {
+    if (isText(child)) {
+      if (/^\s*$/.test(child.data)) continue;
+      const text = insideCode ? child.data : escapeMarkdownInlineSequences(child.data);
+      pushMultiline(text);
+      continue;
+    }
+
+    if (!isTag(child)) continue;
+
+    const tag = child.name.toLowerCase();
+    if (tag === 'p') {
+      pushMultiline(processChildren(child.children, listDepth, insideCode));
+    } else if (tag === 'br') {
+      pushLine('');
+    } else if (tag === 'blockquote') {
+      lines.push(...collectBlockquoteBodyLines(child, listDepth, insideCode));
+    } else {
+      pushMultiline(processNode(child, listDepth, insideCode).trimEnd());
+    }
+  }
+
+  return lines;
+}
+
 function processBlockquote(
   node: Element,
   listDepth: number = 0,
   insideCode: boolean = false
 ): string {
-  const content = node.children
-    .map((child) => {
-      if (isTag(child) && child.name === 'br') return '\n';
-      const text = processNode(child, listDepth, insideCode);
-      return text.replace(/\n/g, '\n> ');
-    })
-    .join('');
-  return `> ${content}\n`;
+  const marker = node.attribs['data-md'] ? `${node.attribs['data-md']} ` : '> ';
+  const lines = collectBlockquoteBodyLines(node, listDepth, insideCode);
+  const body = lines
+    .map((line) => (line.length === 0 ? marker.trimEnd() : `${marker}${line}`))
+    .join('\n');
+  return `${body}\n`;
 }
 
 /**

src/app/plugins/markdown/markdownToHtml.test.ts

@@ -163,6 +163,12 @@ describe('markdownToHtml', () => {
       expect(html).toContain('<blockquote>');
       expect(html).toContain('line one');
       expect(html).toContain('line two');
+      expect((html.match(/<blockquote/g) ?? []).length).toBe(1);
+    });
+
+    it('keeps three or more consecutive blockquote lines in one blockquote', () => {
+      const html = markdownToHtml('> test\n> test\n> test');
+      expect((html.match(/<blockquote/g) ?? []).length).toBe(1);
     });
 
     it('does not promote -# inside fenced code when the fence follows a single newline', () => {