fix: preserve line breaks in generated text/plain alternative #421

2026-06-15 23:15:04 +02:00
parent c51c3655d5
commit 0b9fe5451f
4 changed files with 229 additions and 87 deletions
@@ -0,0 +1,164 @@
+import { parseHtmlSafely } from '@/lib/email-sanitization';
+
+// Block-level tags whose boundaries become line breaks in the plain-text
+// rendering. Without this, the DOM's textContent would run every block
+// together on a single line (#421).
+const BLOCK_TAGS = new Set([
+  'address',
+  'article',
+  'aside',
+  'blockquote',
+  'div',
+  'dd',
+  'dl',
+  'dt',
+  'footer',
+  'h1',
+  'h2',
+  'h3',
+  'h4',
+  'h5',
+  'h6',
+  'header',
+  'li',
+  'nav',
+  'ol',
+  'p',
+  'pre',
+  'section',
+  'table',
+  'tr',
+  'ul',
+]);
+
+// Paragraph-level blocks that, with `paragraphSpacing` enabled, are separated by
+// a blank line rather than a single newline - matching how they render visually.
+const PARAGRAPH_TAGS = new Set([
+  'blockquote',
+  'h1',
+  'h2',
+  'h3',
+  'h4',
+  'h5',
+  'h6',
+  'ol',
+  'p',
+  'pre',
+  'table',
+  'ul',
+]);
+
+export interface HtmlToPlainTextOptions {
+  /**
+   * Separate paragraph-level blocks (<p>, headings, lists, ...) with a blank
+   * line instead of a single newline. Use for email bodies where paragraphs
+   * are visually spaced; leave off for compact output like signatures.
+   */
+  paragraphSpacing?: boolean;
+}
+
+function normalizeLineBreaks(value: string): string {
+  return value
+    .replace(/\r\n?/g, '\n')
+    .replace(new RegExp(String.fromCharCode(160), 'g'), ' ')
+    .replace(/[ \t]+\n/g, '\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
+/**
+ * Converts HTML into readable plain text, preserving line structure from block
+ * elements and <br> tags. Links render as `text <href>` unless the text already
+ * is the href. Used to derive the text/plain alternative of an HTML email.
+ */
+export function htmlToPlainText(html: string, options: HtmlToPlainTextOptions = {}): string {
+  const { paragraphSpacing = false } = options;
+  const document = parseHtmlSafely(html);
+  const chunks: string[] = [];
+
+  const appendText = (value: string) => {
+    if (!value) return;
+    const normalized = value.replace(/\s+/g, ' ');
+    if (!normalized.trim()) return;
+    const previous = chunks[chunks.length - 1];
+    if (previous && !previous.endsWith('\n') && !previous.endsWith(' ')) {
+      chunks.push(' ');
+    }
+    chunks.push(normalized);
+  };
+
+  // Number of newline characters already trailing the accumulated output.
+  const trailingNewlines = (): number => {
+    let count = 0;
+    for (let i = chunks.length - 1; i >= 0; i--) {
+      const chunk = chunks[i];
+      let j = chunk.length - 1;
+      let inner = 0;
+      while (j >= 0 && chunk[j] === '\n') {
+        inner++;
+        j--;
+      }
+      count += inner;
+      if (j >= 0) break; // chunk had non-newline content, stop counting
+    }
+    return count;
+  };
+
+  // Ensures at least `min` trailing newlines, without emitting leading ones.
+  const ensureNewlines = (min: number) => {
+    if (chunks.length === 0) return;
+    for (let current = trailingNewlines(); current < min; current++) {
+      chunks.push('\n');
+    }
+  };
+
+  const walk = (node: Node) => {
+    if (node.nodeType === Node.TEXT_NODE) {
+      appendText(node.textContent || '');
+      return;
+    }
+
+    if (node.nodeType !== Node.ELEMENT_NODE) {
+      return;
+    }
+
+    const element = node as HTMLElement;
+    const tagName = element.tagName.toLowerCase();
+
+    if (tagName === 'br') {
+      // Additive so consecutive <br> can form a blank line (capped by normalize).
+      if (chunks.length > 0) chunks.push('\n');
+      return;
+    }
+
+    if (tagName === 'a') {
+      const text = element.textContent?.replace(/\s+/g, ' ').trim() || '';
+      const href = element.getAttribute('href')?.trim() || '';
+      const normalizedHref = href.replace(/^mailto:/i, '');
+      if (text && normalizedHref && text === normalizedHref) {
+        appendText(text);
+        return;
+      }
+      if (text && href && text !== href) {
+        appendText(`${text} <${href}>`);
+        return;
+      }
+    }
+
+    const separator = paragraphSpacing && PARAGRAPH_TAGS.has(tagName) ? 2 : 1;
+    const isBlock = BLOCK_TAGS.has(tagName);
+
+    if (isBlock) {
+      ensureNewlines(separator);
+    }
+
+    Array.from(element.childNodes).forEach(walk);
+
+    if (isBlock) {
+      ensureNewlines(separator);
+    }
+  };
+
+  Array.from(document.body.childNodes).forEach(walk);
+  return normalizeLineBreaks(chunks.join(''));
+}