@speajus/markdown-to-pdf 1.0.19 → 1.0.20

package/dist/renderer.js

@@ -411,6 +411,21 @@ async function renderMarkdownToPdf(markdown, options) {
                     doc.moveDown(0.5);
                     break;
                 }
+                case 'html': {
+                    const htmlText = (tok.text ?? tok.raw ?? '').trim();
+                    if (/^<br\s*\/?>$/i.test(htmlText)) {
+                        doc.moveDown(0.5);
+                    }
+                    else {
+                        // Non-br HTML: render as text (fall through to default behavior)
+                        const raw = tok.text ?? tok.raw ?? '';
+                        if (raw) {
+                            applyBodyFont(insideBold, insideItalic);
+                            renderText(raw, { continued: cont, underline: false, strike: false });
+                        }
+                    }
+                    break;
+                }
                 default: {
                     const raw = tok.text ?? tok.raw ?? '';
                     if (raw) {
@@ -449,6 +464,7 @@ async function renderMarkdownToPdf(markdown, options) {
             if (linkUrl) {
                 doc.link(imgX, imgY, displayWidth, displayHeight, linkUrl);
             }
+            doc.y = imgY + displayHeight;
             doc.moveDown(0.5);
         }
         catch {
@@ -504,39 +520,101 @@ async function renderMarkdownToPdf(markdown, options) {
         }
         doc.y = savedY;
     }
+    /**
+     * Extract plain text from cell tokens, converting <br> HTML tokens to \n
+     * so that heightOfString can measure the full multiline content.
+     */
+    function cellPlainText(cell) {
+        if (!cell.tokens || cell.tokens.length === 0)
+            return cell.text;
+        function extract(tokens) {
+            let result = '';
+            for (const tok of tokens) {
+                if (tok.type === 'br') {
+                    result += '\n';
+                }
+                else if (tok.type === 'html') {
+                    const raw = (tok.text ?? tok.raw ?? '').trim();
+                    if (/^<br\s*\/?>$/i.test(raw)) {
+                        result += '\n';
+                    }
+                    else {
+                        result += tok.text ?? tok.raw ?? '';
+                    }
+                }
+                else if (tok.tokens && tok.tokens.length > 0) {
+                    result += extract(tok.tokens);
+                }
+                else {
+                    result += tok.text ?? tok.raw ?? '';
+                }
+            }
+            return result;
+        }
+        return extract(cell.tokens);
+    }
+    /**
+     * Measure the height a cell needs given its content and available width.
+     */
+    function measureCellHeight(cell, cellWidth, bold) {
+        const text = cellPlainText(cell);
+        const font = bold
+            ? safeFont(resolveFont(theme.body.font, true, false))
+            : safeFont(theme.body.font);
+        doc.font(font).fontSize(theme.body.fontSize);
+        return doc.heightOfString(text, { width: cellWidth });
+    }
     async function renderTable(table) {
         const colCount = table.header.length;
         if (colCount === 0)
             return;
         const cellPad = theme.table.cellPadding;
         const colWidth = contentWidth / colCount;
-        const rowH = theme.body.fontSize + cellPad * 2 + 4;
-        const textInsetY = (rowH - theme.body.fontSize) / 2;
-        ensureSpace(rowH * 2);
+        const minRowH = theme.body.fontSize + cellPad * 2 + 4;
+        const textWidth = colWidth - cellPad * 2;
+        ensureSpace(minRowH * 2);
         const startX = margins.left;
         let y = doc.y;
-        // Header row
+        // ── Measure header row height ──
+        let headerH = minRowH;
+        let maxHeaderTextHeight = 0;
+        for (let c = 0; c < colCount; c++) {
+            const h = measureCellHeight(table.header[c], textWidth, true);
+            maxHeaderTextHeight = Math.max(maxHeaderTextHeight, h);
+            headerH = Math.max(headerH, h + cellPad * 2 + 4);
+        }
+        const headerTextInsetY = (headerH - maxHeaderTextHeight) / 2;
+        // Header row background
         doc.save();
-        doc.rect(startX, y, contentWidth, rowH).fill(theme.table.headerBackground);
+        doc.rect(startX, y, contentWidth, headerH).fill(theme.table.headerBackground);
         doc.restore();
         for (let c = 0; c < colCount; c++) {
             const cellX = startX + c * colWidth;
-            await renderCellTokens(table.header[c], cellX + cellPad, y + textInsetY, colWidth - cellPad * 2, table.align[c] || 'left', true);
+            await renderCellTokens(table.header[c], cellX + cellPad, y + headerTextInsetY, textWidth, table.align[c] || 'left', true);
         }
         // Header border
         doc.save();
         doc.strokeColor(theme.table.borderColor).lineWidth(0.5);
-        doc.rect(startX, y, contentWidth, rowH).stroke();
+        doc.rect(startX, y, contentWidth, headerH).stroke();
         for (let c = 1; c < colCount; c++) {
             const cx = startX + c * colWidth;
-            doc.moveTo(cx, y).lineTo(cx, y + rowH).stroke();
+            doc.moveTo(cx, y).lineTo(cx, y + headerH).stroke();
         }
         doc.restore();
-        y += rowH;
+        y += headerH;
         // Body rows
         const zebraColor = theme.table.zebraColor ?? '#f9f9f9';
         for (let r = 0; r < table.rows.length; r++) {
             const row = table.rows[r];
+            // ── Measure row height ──
+            let rowH = minRowH;
+            let maxRowTextHeight = 0;
+            for (let c = 0; c < colCount; c++) {
+                const h = measureCellHeight(row[c], textWidth, false);
+                maxRowTextHeight = Math.max(maxRowTextHeight, h);
+                rowH = Math.max(rowH, h + cellPad * 2 + 4);
+            }
+            const textInsetY = (rowH - maxRowTextHeight) / 2;
             doc.y = y; // sync doc.y BEFORE ensureSpace check
             ensureSpace(rowH);
             y = doc.y; // re-sync AFTER possible page break
@@ -548,7 +626,7 @@ async function renderMarkdownToPdf(markdown, options) {
             }
             for (let c = 0; c < colCount; c++) {
                 const cellX = startX + c * colWidth;
-                await renderCellTokens(row[c], cellX + cellPad, y + textInsetY, colWidth - cellPad * 2, table.align[c] || 'left', false);
+                await renderCellTokens(row[c], cellX + cellPad, y + textInsetY, textWidth, table.align[c] || 'left', false);
             }
             doc.save();
             doc.strokeColor(theme.table.borderColor).lineWidth(0.5);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@speajus/markdown-to-pdf",
-  "version": "1.0.19",
+  "version": "1.0.20",
   "description": "A new project created with Intent by Augment.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",