@flowaccount/pdfmake 1.0.0 → 1.0.2

package/src/tableProcessor.js

@@ -310,6 +310,72 @@ TableProcessor.prototype.drawHorizontalLine = function (lineIndex, writer, overr
 	}
 };
 
+
+/**
+ * Draws vertical lines to fill the gap when a row is forced to the next page.
+ * This prevents missing vertical lines at the bottom of the page.
+ * @param {number} rowIndex - The index of the row being forced to next page
+ * @param {object} writer - The document writer
+ * @param {number} y0 - Starting Y position
+ * @param {number} y1 - Ending Y position (page break point)
+ */
+TableProcessor.prototype.drawVerticalLinesForForcedPageBreak = function (rowIndex, writer, y0, y1) {
+	if (!this.rowSpanData || rowIndex <= 0) {
+		return;
+	}
+
+	var body = this.tableNode.table.body;
+	var prevRowIndex = rowIndex - 1; // Use previous row for cell border detection
+
+	// Get X positions for vertical lines (similar logic to endRow's getLineXs)
+	var xs = [];
+	var cols = 0;
+
+	for (var i = 0, l = body[prevRowIndex].length; i < l; i++) {
+		if (!cols) {
+			xs.push({ x: this.rowSpanData[i].left, index: i });
+			var item = body[prevRowIndex][i];
+			cols = (item._colSpan || item.colSpan || 0);
+		}
+		if (cols > 0) {
+			cols--;
+		}
+	}
+	xs.push({ x: this.rowSpanData[this.rowSpanData.length - 1].left, index: this.rowSpanData.length - 1 });
+
+	// Draw vertical lines for each column position
+	for (var xi = 0, xl = xs.length; xi < xl; xi++) {
+		var leftCellBorder = false;
+		var colIndex = xs[xi].index;
+
+		// Check if we need to draw a vertical line at this position
+		// based on cell borders from the previous row
+		var cell;
+		if (colIndex < body[prevRowIndex].length) {
+			cell = body[prevRowIndex][colIndex];
+			leftCellBorder = cell.border ? cell.border[0] : this.layout.defaultBorder;
+		}
+
+		// Check cell before
+		if (colIndex > 0 && !leftCellBorder) {
+			cell = body[prevRowIndex][colIndex - 1];
+			leftCellBorder = cell.border ? cell.border[2] : this.layout.defaultBorder;
+		}
+
+		if (leftCellBorder) {
+			this.drawVerticalLine(
+				xs[xi].x,
+				y0,
+				y1,
+				xs[xi].index,
+				writer,
+				prevRowIndex,
+				xi > 0 ? xs[xi - 1].index : null
+			);
+		}
+	}
+};
+
 TableProcessor.prototype.drawVerticalLine = function (x, y0, y1, vLineColIndex, writer, vLineRowIndex, beforeVLineColIndex) {
 	var width = this.layout.vLineWidth(vLineColIndex, this.tableNode);
 	if (width === 0) {
@@ -409,9 +475,11 @@ TableProcessor.prototype.endTable = function (writer) {
 	}
 };
 
-TableProcessor.prototype.endRow = function (rowIndex, writer, pageBreaks) {
+TableProcessor.prototype.endRow = function (rowIndex, writer, pageBreaks, nextRowCells, layoutBuilder) {
 	var l, i;
 	var self = this;
+	var tableLayout = this.tableNode && this.tableNode._layout;
+	var nearBottomThreshold = (tableLayout && tableLayout.nearBottomThreshold) || 20;
 
 	writer.tracker.stopTracking('pageChanged', this.rowCallback);
 	writer.context().moveDown(this.layout.paddingBottom(rowIndex, this.tableNode));
@@ -437,7 +505,7 @@ TableProcessor.prototype.endRow = function (rowIndex, writer, pageBreaks) {
 			var pageBreak = pageBreaks[i];
 			ys[ys.length - 1].y1 = pageBreak.prevY;
 
-			ys.push({ y0: pageBreak.y, page: pageBreak.prevPage + 1 });
+			ys.push({ y0: pageBreak.y, page: pageBreak.prevPage + 1, forced: pageBreak.forced });
 		}
 	}
 
@@ -473,11 +541,21 @@ TableProcessor.prototype.endRow = function (rowIndex, writer, pageBreaks) {
 		}
 
 		// Draw horizontal lines before the vertical lines so they are not overridden
+		// Only set isPageBreak=true when at TRUE page bottom (not just forced breaks)
+		var ctx = writer.context();
+		var currentPage = ctx.getCurrentPage && ctx.getCurrentPage();
+		var pageHeight = currentPage ? (currentPage.pageSize.height - ctx.pageMargins.bottom) : 0;
+
 		if (willBreak && this.layout.hLineWhenBroken !== false) {
-			this.drawHorizontalLine(rowIndex + 1, writer, y2, true, null, true);
+			// Check if we're at the true page bottom
+			var isAtTruePageBottom = (pageHeight - y2) <= nearBottomThreshold;
+			this.drawHorizontalLine(rowIndex + 1, writer, y2, true, null, isAtTruePageBottom);
 		}
 		if (rowBreakWithoutHeader && this.layout.hLineWhenBroken !== false) {
-			this.drawHorizontalLine(rowIndex, writer, y1, true, null, true);
+			// Check if previous segment ended at true page bottom
+			var prevSegmentY = (yi > 0) ? ys[yi - 1].y1 : 0;
+			var prevWasAtPageBottom = (pageHeight - prevSegmentY) <= nearBottomThreshold;
+			this.drawHorizontalLine(rowIndex, writer, y1, true, null, prevWasAtPageBottom);
 		}
 
 		for (i = 0, l = xs.length; i < l; i++) {
@@ -596,7 +674,57 @@ TableProcessor.prototype.endRow = function (rowIndex, writer, pageBreaks) {
 		}
 	}
 
-	this.drawHorizontalLine(rowIndex + 1, writer);
+	// Look ahead: Check if next row will cause a page break
+	// If yes, skip drawing the horizontal line at the end of current row
+	// This feature is OPT-IN: only enabled when forcePageBreakForAllRows === true
+	var shouldSkipHorizontalLine = false;
+
+	if (nextRowCells && layoutBuilder) {
+		// Only perform look-ahead if forcePageBreakForAllRows is explicitly enabled
+		// This prevents affecting existing PDFs that don't use this feature
+		if (tableLayout && tableLayout.forcePageBreakForAllRows === true) {
+			var nextRowEstimatedHeight = 0;
+
+			// Try to get maximum cell height from next row's measured content
+			if (layoutBuilder._getMaxCellHeight) {
+				var maxNextCellHeight = layoutBuilder._getMaxCellHeight(nextRowCells);
+				if (maxNextCellHeight > 0) {
+					nextRowEstimatedHeight = maxNextCellHeight + 10; // Add padding
+				}
+			}
+
+			// Fallback: use minRowHeight from table layout
+			if (nextRowEstimatedHeight === 0) {
+				var footerGapOpt = writer.context()._footerGapOption;
+				nextRowEstimatedHeight = (tableLayout && tableLayout.minRowHeight) || (footerGapOpt && footerGapOpt.minRowHeight) || 80;
+			}
+
+			// Check current available height (after current row has been processed)
+			var currentAvailableHeight = writer.context().availableHeight;
+
+			// Skip drawing the horizontal line if EITHER:
+			// 1. Next row won't fit (will cause page break), OR
+			// 2. We're very close to page bottom (remaining space <= threshold)
+			// This prevents duplicate/orphaned lines at page boundaries
+			if (nextRowEstimatedHeight > currentAvailableHeight || currentAvailableHeight <= nearBottomThreshold) {
+				// Exception: Check if this line should always be drawn (critical boundary)
+				// Allow layout to specify via alwaysDrawHLine callback
+				var shouldAlwaysDrawLine = false;
+				if (typeof tableLayout.alwaysDrawHLine === 'function') {
+					shouldAlwaysDrawLine = tableLayout.alwaysDrawHLine(rowIndex + 1, this.tableNode, writer);
+				}
+
+				if (!shouldAlwaysDrawLine) {
+					shouldSkipHorizontalLine = true;
+				}
+			}
+		}
+	}
+
+	// Draw horizontal line at the end of the row, unless next row will cause a page break
+	if (!shouldSkipHorizontalLine) {
+		this.drawHorizontalLine(rowIndex + 1, writer);
+	}
 
 	if (this.headerRows && rowIndex === this.headerRows - 1) {
 		this.headerRepeatable = writer.currentBlockToRepeatable();