pdfmake 0.3.4 → 0.3.5

package/src/PageElementWriter.js

@@ -173,11 +173,130 @@ class PageElementWriter extends ElementWriter {
 		this.repeatables.pop();
 	}
 
+	/**
+	 * Move to the next column in a column group (snaking columns).
+	 * Handles repeatables and emits columnChanged event.
+	 */
+	moveToNextColumn() {
+		let nextColumn = this.context().moveToNextColumn();
+
+		// Handle repeatables (like table headers) for the new column
+		this.repeatables.forEach(function (rep) {
+			// In snaking columns, we WANT headers to repeat.
+			// However, in Standard Page Breaks, headers are drawn using useBlockXOffset=true (original absolute X).
+			// This works for page breaks because margins are consistent.
+			// In Snaking Columns, the X position changes for each column.
+			// If we use true, the header is drawn at the *original* X position (Col 1), overlapping/invisible.
+			// We MUST use false to force drawing relative to the CURRENT context X (new column start).
+			this.addFragment(rep, false);
+		}, this);
+
+		this.emit('columnChanged', {
+			prevY: nextColumn.prevY,
+			y: this.context().y
+		});
+	}
+
+	/**
+	 * Check if currently in a column group that can move to next column.
+	 * Only returns true if snakingColumns is enabled for the column group.
+	 * @returns {boolean}
+	 */
+	canMoveToNextColumn() {
+		let ctx = this.context();
+		let snakingSnapshot = ctx.getSnakingSnapshot();
+
+		if (snakingSnapshot) {
+			// Check if we're inside a nested (non-snaking) column group.
+			// If so, don't allow a snaking column move — it would corrupt
+			// the inner row's layout (e.g. product name in col 1, price in col 2).
+			// The inner row should complete via normal page break instead.
+			for (let i = ctx.snapshots.length - 1; i >= 0; i--) {
+				let snap = ctx.snapshots[i];
+				if (snap.snakingColumns) {
+					break; // Reached the snaking snapshot, no inner groups found
+				}
+				if (!snap.overflowed) {
+					return false; // Found a non-snaking, non-overflowed inner group
+				}
+			}
+
+			let overflowCount = 0;
+			for (let i = ctx.snapshots.length - 1; i >= 0; i--) {
+				if (ctx.snapshots[i].overflowed) {
+					overflowCount++;
+				} else {
+					break;
+				}
+			}
+
+			if (snakingSnapshot.columnWidths &&
+				overflowCount >= snakingSnapshot.columnWidths.length - 1) {
+				return false;
+			}
+
+			let currentColumnWidth = ctx.availableWidth || ctx.lastColumnWidth || 0;
+			let nextColumnWidth = snakingSnapshot.columnWidths ?
+				snakingSnapshot.columnWidths[overflowCount + 1] : currentColumnWidth;
+			let nextX = ctx.x + currentColumnWidth + (snakingSnapshot.gap || 0);
+			let page = ctx.getCurrentPage();
+			let pageWidth = page.pageSize.width;
+			let rightMargin = page.pageMargins ? page.pageMargins.right : 0;
+			let parentRightMargin = ctx.marginXTopParent ? ctx.marginXTopParent[1] : 0;
+			let rightBoundary = pageWidth - rightMargin - parentRightMargin;
+
+			return (nextX + nextColumnWidth) <= (rightBoundary + 1);
+		}
+		return false;
+	}
+
 	_fitOnPage(addFct) {
 		let position = addFct();
 		if (!position) {
-			this.moveToNextPage();
-			position = addFct();
+			if (this.canMoveToNextColumn()) {
+				this.moveToNextColumn();
+				position = addFct();
+			}
+
+			if (!position) {
+				let ctx = this.context();
+				let snakingSnapshot = ctx.getSnakingSnapshot();
+
+				if (snakingSnapshot) {
+					if (ctx.isInNestedNonSnakingGroup()) {
+						// Inside a table cell within snaking columns — use standard page break.
+						// Don't reset snaking state; the table handles its own breaks.
+						// Column breaks happen between rows in processTable instead.
+						this.moveToNextPage();
+					} else {
+						this.moveToNextPage();
+
+						// Save lastColumnWidth before reset — if we're inside a nested
+						// column group (e.g. product/price row), the reset would overwrite
+						// it with the snaking column width, corrupting inner column layout.
+						let savedLastColumnWidth = ctx.lastColumnWidth;
+						ctx.resetSnakingColumnsForNewPage();
+						ctx.lastColumnWidth = savedLastColumnWidth;
+					}
+
+					position = addFct();
+				} else {
+					while (ctx.snapshots.length > 0 && ctx.snapshots[ctx.snapshots.length - 1].overflowed) {
+						let popped = ctx.snapshots.pop();
+						let prevSnapshot = ctx.snapshots[ctx.snapshots.length - 1];
+						if (prevSnapshot) {
+							ctx.x = prevSnapshot.x;
+							ctx.y = prevSnapshot.y;
+							ctx.availableHeight = prevSnapshot.availableHeight;
+							ctx.availableWidth = popped.availableWidth;
+							ctx.lastColumnWidth = prevSnapshot.lastColumnWidth;
+						}
+					}
+
+					this.moveToNextPage();
+					position = addFct();
+				}
+			}
 		}
 		return position;
 	}

package/src/Renderer.js

@@ -41,6 +41,7 @@ class Renderer {
 	constructor(pdfDocument, progressCallback) {
 		this.pdfDocument = pdfDocument;
 		this.progressCallback = progressCallback;
+		this.outlineMap = [];
 	}
 
 	renderPages(pages) {
@@ -128,6 +129,18 @@ class Renderer {
 			}
 		}
 
+		if (line._outline) {
+			let parentOutline = this.pdfDocument.outline;
+			if (line._outline.parentId && this.outlineMap[line._outline.parentId]) {
+				parentOutline = this.outlineMap[line._outline.parentId];
+			}
+
+			let outline = parentOutline.addItem(line._outline.text, { expanded: line._outline.expanded });
+			if (line._outline.id) {
+				this.outlineMap[line._outline.id] = outline;
+			}
+		}
+
 		if (line._pageNodeRef) {
 			preparePageNodeRefLine(line._pageNodeRef, line.inlines[0]);
 		}

package/src/SVGMeasure.js

@@ -26,8 +26,8 @@ const parseSVG = (svgString) => {
 
 	try {
 		doc = new XmlDocument(svgString);
-	} catch (err) {
-		throw new Error('Invalid svg document (' + err + ')');
+	} catch (error) {
+		throw new Error('Invalid svg document (' + error + ')', { cause: error });
 	}
 
 	if (doc.name !== "svg") {

package/src/TableProcessor.js

@@ -20,7 +20,7 @@ class TableProcessor {
 		const prepareRowSpanData = () => {
 			let rsd = [];
 			let x = 0;
-			let lastWidth = 0;
+			let lastWidth;
 
 			rsd.push({ left: 0, rowSpan: 0 });
 
@@ -274,7 +274,6 @@ class TableProcessor {
 							lineColor: borderColor
 						}, false, isNumber(overrideY), null, forcePage);
 						currentLine = null;
-						borderColor = null;
 						cellAbove = null;
 						currentCell = null;
 						rowCellAbove = null;
@@ -356,9 +355,6 @@ class TableProcessor {
 			dash: dash,
 			lineColor: borderColor
 		}, false, true);
-		cellBefore = null;
-		currentCell = null;
-		borderColor = null;
 	}
 
 	endTable(writer) {

package/src/URLResolver.js

@@ -6,7 +6,7 @@ async function fetchUrl(url, headers = {}) {
 		}
 		return await response.arrayBuffer();
 	} catch (error) {
-		throw new Error(`Network request failed (url: "${url}", error: ${error.message})`);
+		throw new Error(`Network request failed (url: "${url}", error: ${error.message})`, { cause: error });
 	}
 }