@speajus/markdown-to-pdf 1.0.19 → 1.0.21

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.21",
   "description": "A new project created with Intent by Augment.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -26,6 +26,7 @@
   },
   "files": [
     "dist",
+    "scripts",
     "README.md"
   ],
   "scripts": {

package/scripts/patch-fontkit-colr.js

@@ -0,0 +1,105 @@
+/**
+ * Patches fontkit's COLRGlyph class to guard against null baseGlyphRecord.
+ *
+ * Some emoji fonts have a COLR table but null/missing baseGlyphRecord,
+ * causing `TypeError: Cannot read properties of null (reading 'length')`
+ * when fontkit's COLRGlyph.layers getter is called.
+ *
+ * This script patches both the src and dist files of fontkit in node_modules.
+ */
+const fs = require('fs');
+const path = require('path');
+
+const nmDir = path.join(__dirname, '..', 'node_modules');
+
+function patchFile(filePath, patches) {
+  if (!fs.existsSync(filePath)) return false;
+  let content = fs.readFileSync(filePath, 'utf8');
+  let changed = false;
+  for (const [search, replace] of patches) {
+    if (content.includes(search) && !content.includes(replace)) {
+      // Replace ALL occurrences (some bundled files may have multiple copies)
+      content = content.split(search).join(replace);
+      changed = true;
+    }
+  }
+  if (changed) {
+    fs.writeFileSync(filePath, content, 'utf8');
+    console.log(`  Patched: ${filePath}`);
+  }
+  return changed;
+}
+
+// Patch 1: Guard against null baseGlyphRecord in COLRGlyph.layers getter
+const layersGetterPatch = [
+  'let high = colr.baseGlyphRecord.length - 1;',
+  'if (!colr || !colr.baseGlyphRecord) { return null; } let high = colr.baseGlyphRecord.length - 1;',
+];
+
+// Patch 2: Don't create COLRGlyph for COLR v1 fonts (no v0 baseGlyphRecord)
+// COLR v1 uses a different paint-based structure that fontkit doesn't support.
+// Without this, COLR v1 glyphs (e.g. OpenMoji) get typed as COLR but can't
+// render, and they also won't fall back to SBIX/CBDT/SVG alternatives.
+const getGlyphPatch = [
+  'this.directory.tables.COLR && this.directory.tables.CPAL)',
+  'this.directory.tables.COLR && this.directory.tables.CPAL && this.COLR && this.COLR.baseGlyphRecord)',
+];
+
+// Patch 3: Fix _getContours crash for composite glyphs in COLR fonts
+// When a composite TTF glyph references a component that is a COLRGlyph,
+// calling _getContours() on it crashes because COLRGlyph doesn't have that method.
+// Use _getBaseGlyph to get the TTF outline instead.
+const getContoursPatch = [
+  'this._font.getGlyph(component.glyphID)._getContours()',
+  '((g) => { if (!g || typeof g._getContours !== "function") return []; return g._getContours(); })(this._font._getBaseGlyph(component.glyphID) || this._font.getGlyph(component.glyphID))',
+];
+
+// Patch 4: Fix _decode crash in TTF subsetter for COLR glyphs
+// COLRGlyph doesn't have _decode() method. The subsetter needs to handle
+// COLR glyphs gracefully by treating them as simple (non-compound) glyphs.
+const decodePatch = [
+  'let glyf = glyph._decode();',
+  'let glyf = typeof glyph._decode === "function" ? glyph._decode() : null;',
+];
+
+const allPatches = [layersGetterPatch, getGlyphPatch, getContoursPatch, decodePatch];
+
+let patchCount = 0;
+
+// 1. Patch fontkit dist/src files directly
+const fontkitPaths = [
+  path.join(nmDir, 'fontkit'),
+  path.join(nmDir, 'pdfkit', 'node_modules', 'fontkit'),
+];
+
+for (const fontkitDir of fontkitPaths) {
+  if (!fs.existsSync(fontkitDir)) continue;
+  for (const distFile of ['dist/browser-module.mjs', 'dist/main.cjs']) {
+    if (patchFile(path.join(fontkitDir, distFile), allPatches)) patchCount++;
+  }
+  if (patchFile(path.join(fontkitDir, 'src', 'glyph', 'COLRGlyph.js'), [layersGetterPatch])) patchCount++;
+}
+
+// 2. Patch pdfkit standalone bundles (these embed fontkit inline)
+const pdfkitBundles = [
+  path.join(nmDir, 'pdfkit', 'js', 'pdfkit.standalone.js'),
+  path.join(nmDir, 'pdfkit', 'js', 'pdfkit.js'),
+];
+
+for (const bundle of pdfkitBundles) {
+  if (patchFile(bundle, allPatches)) patchCount++;
+}
+
+// 3. Clear Vite dep cache so it re-bundles with patched files
+const viteCacheDir = path.join(nmDir, '.vite');
+if (fs.existsSync(viteCacheDir)) {
+  fs.rmSync(viteCacheDir, { recursive: true, force: true });
+  console.log('  Cleared Vite dep cache (.vite)');
+}
+
+if (patchCount > 0) {
+  console.log(`fontkit COLR patch: ${patchCount} file(s) patched.`);
+} else {
+  console.log('fontkit COLR patch: already applied or fontkit not found.');
+}
+