@flowaccount/pdfmake 0.2.20-staging.2 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowaccount/pdfmake",
-  "version": "0.2.20-staging.2",
+  "version": "1.0.1",
   "description": "Client/server side PDF printing in pure JavaScript",
   "main": "src/printer.js",
   "browser": "build/pdfmake.js",
@@ -68,7 +68,7 @@
     "format:check": "prettier --check .",
     "publish:local": "cp .npmrc.local .npmrc && npm version 0.2.20-local.$(date +%s) --no-git-tag-version && npm publish --registry=http://localhost:4872",
     "publish:staging": "npm run build && npm run test && npm version prerelease --preid=staging --no-git-tag-version && npm publish --tag staging --access public",
-    "publish:production": "npm run build && npm run test && npm publish --access public",
+    "publish:production": "npm run build && npm run test && npm publish",
     "version:patch": "npm version patch",
     "version:minor": "npm version minor",
     "version:major": "npm version major"

package/src/layoutBuilder.js

@@ -231,12 +231,14 @@ LayoutBuilder.prototype.applyFooterGapOption = function(opt) {
     if (!opt) return;
 
     if (typeof opt !== 'object') {
-        this._footerGapOption = { enabled: true };
+        this._footerGapOption = { enabled: true, forcePageBreakForAllRows: false };
         return;
     }
 
     this._footerGapOption = {
         enabled: opt.enabled !== false,
+        minRowHeight: typeof opt.minRowHeight === 'number' ? opt.minRowHeight : undefined, // Optional fallback - system auto-calculates from cell content if not provided
+        forcePageBreakForAllRows: opt.forcePageBreakForAllRows === true, // Force page break for all rows (not just inline images)
         columns: opt.columns ? {
             widths: Array.isArray(opt.columns.widths) ? opt.columns.widths.slice() : undefined,
             widthLength: opt.columns.widths.length || 0,
@@ -818,6 +820,154 @@ LayoutBuilder.prototype._colLeftOffset = function (i, gaps) {
 	return 0;
 };
 
+/**
+ * Checks if a cell or node contains an inline image.
+ *
+ * @param {object} node - The node to check for inline images.
+ * @returns {boolean} True if the node contains an inline image; otherwise, false.
+ */
+ LayoutBuilder.prototype._containsInlineImage = function (node) {
+	if (!node) {
+		return false;
+	}
+
+	// Direct image node
+	if (node.image) {
+		return true;
+	}
+
+
+	// Check in table
+	if (node.table && isArray(node.table.body)) {
+		for (var r = 0; r < node.table.body.length; r++) {
+			if (isArray(node.table.body[r])) {
+				for (var c = 0; c < node.table.body[r].length; c++) {
+					if (this._containsInlineImage(node.table.body[r][c])) {
+						return true;
+					}
+				}
+			}
+		}
+	}
+
+	return false;
+};
+
+
+/**
+ * Gets the maximum image height from cells in a row.
+ *
+ * @param {Array<object>} cells - Array of cell objects in a row.
+ * @returns {number} The maximum image height found in the cells.
+ */
+ LayoutBuilder.prototype._getMaxImageHeight = function (cells) {
+	var maxHeight = 0;
+
+	for (var i = 0; i < cells.length; i++) {
+		var cellHeight = this._getImageHeightFromNode(cells[i]);
+		if (cellHeight > maxHeight) {
+			maxHeight = cellHeight;
+		}
+	}
+
+	return maxHeight;
+};
+
+/**
+ * Gets the maximum estimated height from cells in a row.
+ * Checks for measured heights (_height property) and content-based heights.
+ *
+ * @param {Array<object>} cells - Array of cell objects in a row.
+ * @returns {number} The maximum estimated height found in the cells, or 0 if cannot estimate.
+ */
+ LayoutBuilder.prototype._getMaxCellHeight = function (cells) {
+	var maxHeight = 0;
+
+	for (var i = 0; i < cells.length; i++) {
+		var cell = cells[i];
+		if (!cell || cell._span) {
+			continue; // Skip null cells and span placeholders
+		}
+
+		var cellHeight = 0;
+
+		// Check if cell has measured height from docMeasure phase
+		if (cell._height) {
+			cellHeight = cell._height;
+		}
+		// Check for image content
+		else if (cell.image && cell._maxHeight) {
+			cellHeight = cell._maxHeight;
+		}
+		// Check for nested content with height
+		else {
+			cellHeight = this._getImageHeightFromNode(cell);
+		}
+
+		if (cellHeight > maxHeight) {
+			maxHeight = cellHeight;
+		}
+	}
+
+	return maxHeight;
+};
+
+/**
+ * Recursively gets image height from a node.
+ *
+ * @param {object} node - The node to extract image height from.
+ * @returns {number} The image height if found; otherwise, 0.
+ */
+ LayoutBuilder.prototype._getImageHeightFromNode = function (node) {
+	if (!node) {
+		return 0;
+	}
+
+	// Direct image node with height
+	if (node.image && node._height) {
+		return node._height;
+	}
+
+	var maxHeight = 0;
+
+	// Check in stack
+	if (isArray(node.stack)) {
+		for (var i = 0; i < node.stack.length; i++) {
+			var h = this._getImageHeightFromNode(node.stack[i]);
+			if (h > maxHeight) {
+				maxHeight = h;
+			}
+		}
+	}
+
+	// Check in columns
+	if (isArray(node.columns)) {
+		for (var j = 0; j < node.columns.length; j++) {
+			var h2 = this._getImageHeightFromNode(node.columns[j]);
+			if (h2 > maxHeight) {
+				maxHeight = h2;
+			}
+		}
+	}
+
+	// Check in table
+	if (node.table && isArray(node.table.body)) {
+		for (var r = 0; r < node.table.body.length; r++) {
+			if (isArray(node.table.body[r])) {
+				for (var c = 0; c < node.table.body[r].length; c++) {
+					var h3 = this._getImageHeightFromNode(node.table.body[r][c]);
+					if (h3 > maxHeight) {
+						maxHeight = h3;
+					}
+				}
+			}
+		}
+	}
+
+	return maxHeight;
+};
+
+
 /**
  * Retrieves the ending cell for a row span in case it exists in a specified table column.
  *
@@ -848,8 +998,101 @@ LayoutBuilder.prototype.processRow = function ({ marginX = [0, 0], dontBreakRows
 	var positions = [];
 	var willBreakByHeight = false;
 	var columnAlignIndexes = {};
+	var hasInlineImage = false;
 	widths = widths || cells;
 
+	// Check if row contains inline images
+	if (!isUnbreakableRow) {
+		for (var cellIdx = 0; cellIdx < cells.length; cellIdx++) {
+			if (self._containsInlineImage(cells[cellIdx])) {
+				hasInlineImage = true;
+				break;
+			}
+		}
+	}
+
+	// Check if row would cause page break and force move to next page first
+	// This keeps the entire row together on the new page
+	// Apply when: forcePageBreakForAllRows is enabled OR row has inline images
+
+	// Priority for forcePageBreakForAllRows setting:
+	// 1. Table-specific layout.forcePageBreakForAllRows
+	// 2. Tables with footerGapCollect: 'product-items' (auto-enabled)
+	// 3. Global footerGapOption.forcePageBreakForAllRows
+	var tableLayout = tableNode && tableNode._layout;
+	var footerGapOpt = self.writer.context()._footerGapOption;
+	var shouldForcePageBreak = false;
+
+	if (tableLayout && tableLayout.forcePageBreakForAllRows !== undefined) {
+		// Table-specific setting takes precedence
+		shouldForcePageBreak = tableLayout.forcePageBreakForAllRows === true;
+	} 
+
+	if (!isUnbreakableRow && (shouldForcePageBreak || hasInlineImage)) {
+		var availableHeight = self.writer.context().availableHeight;
+
+		// Calculate estimated height from actual cell content
+		var estimatedHeight = height; // Use provided height if available
+
+		if (!estimatedHeight) {
+			// Try to get maximum cell height from measured content
+			var maxCellHeight = self._getMaxCellHeight(cells);
+
+			if (maxCellHeight > 0) {
+				// Add padding for table borders and cell padding (approximate)
+				// Using smaller padding to avoid overly conservative page break detection
+				var tablePadding = 10; // Account for row padding and borders
+				estimatedHeight = maxCellHeight + tablePadding;
+			} else {
+				// Fallback: use minRowHeight from table layout or global config if provided
+				// Priority: table-specific layout > global footerGapOption > default 80
+				// Using higher default (80px) to handle text rows with wrapping and multiple lines
+				// This is conservative but prevents text rows from being split across pages
+				var minRowHeight = (tableLayout && tableLayout.minRowHeight) || (footerGapOpt && footerGapOpt.minRowHeight) || 80;
+				estimatedHeight = minRowHeight;
+			}
+		}
+
+		// Check if row won't fit on current page
+		// Strategy: Force break if row won't fit AND we're not too close to page boundary
+		// "Too close" means availableHeight is very small (< 5px) - at that point forcing
+		// a break would create a nearly-blank page
+		var minSpaceThreshold = 5; // Only skip forced break if < 5px space left
+
+		if (estimatedHeight > availableHeight && availableHeight > minSpaceThreshold) {
+			var currentPage = self.writer.context().page;
+			var currentY = self.writer.context().y;
+
+			// Draw vertical lines to fill the gap from current position to page break
+			// This ensures vertical lines extend all the way to the bottom of the page
+			if (tableNode && tableNode._tableProcessor && rowIndex > 0) {
+				tableNode._tableProcessor.drawVerticalLinesForForcedPageBreak(
+					rowIndex,
+					self.writer,
+					currentY,
+					currentY + availableHeight
+				);
+			}
+
+			// Move to next page before processing row
+			self.writer.context().moveDown(availableHeight);
+			self.writer.moveToNextPage();
+
+			// Track this page break so tableProcessor can draw borders correctly
+			pageBreaks.push({
+				prevPage: currentPage,
+				prevY: currentY + availableHeight,
+				y: self.writer.context().y,
+				page: self.writer.context().page,
+				forced: true  // Mark as forced page break
+			});
+
+			// Mark that this row should not break anymore
+			isUnbreakableRow = true;
+			dontBreakRows = true;
+		}
+	}
+
 	// Check if row should break by height
 	if (!isUnbreakableRow && height > self.writer.context().availableHeight) {
 		willBreakByHeight = true;
@@ -1053,6 +1296,9 @@ LayoutBuilder.prototype.processTable = function (tableNode) {
 	this.nestedLevel++;
 	var processor = new TableProcessor(tableNode);
 
+	// Store processor reference for forced page break vertical line drawing
+	tableNode._tableProcessor = processor;
+
 	processor.beginTable(this.writer);
 
 	var rowHeights = tableNode.table.heights;
@@ -1107,7 +1353,10 @@ LayoutBuilder.prototype.processTable = function (tableNode) {
 			}
 		}
 
-		processor.endRow(i, this.writer, result.pageBreaks);
+		// Get next row cells for look-ahead page break detection
+		var nextRowCells = (i + 1 < tableNode.table.body.length) ? tableNode.table.body[i + 1] : null;
+
+		processor.endRow(i, this.writer, result.pageBreaks, nextRowCells, this);
 	}
 
 	processor.endTable(this.writer);

package/src/printer.js

@@ -115,6 +115,10 @@ function PdfPrinter(fontDescriptors) {
  * @return {Object} a pdfKit document object which can be saved or encode to data-url
  */
 PdfPrinter.prototype.createPdfKitDocument = function (docDefinition, options) {
+	if (!docDefinition || typeof docDefinition !== 'object') {
+		throw new Error('docDefinition parameter is required and must be an object');
+	}
+
 	options = options || {};
 
 	docDefinition.version = docDefinition.version || '1.3';
@@ -197,6 +201,10 @@ PdfPrinter.prototype.resolveRemoteImages = function (docDefinition, timeoutMs) {
 };
 
 PdfPrinter.prototype.createPdfKitDocumentAsync = function (docDefinition, options) {
+	if (!docDefinition || typeof docDefinition !== 'object') {
+		return Promise.reject(new Error('docDefinition parameter is required and must be an object'));
+	}
+
 	var createOptions = options ? Object.assign({}, options) : {};
 	var timeout;
 	if (Object.prototype.hasOwnProperty.call(createOptions, 'remoteImageTimeout')) {
@@ -907,15 +915,8 @@ function registerInlineImage(node, images) {
 }
 
 function ensureRemoteBuffer(url, headers, cacheKey, cache, timeout) {
-	var existing = cache.get(cacheKey);
-	if (existing) {
-		return Promise.resolve(existing);
-	}
-
-	return fetchRemote(url, headers, timeout).then(function (buffer) {
-		cache.set(cacheKey, buffer);
-		return buffer;
-	});
+	// Cache disabled - always fetch fresh images
+	return fetchRemote(url, headers, timeout);
 }
 
 function parseRemoteDescriptor(value) {

package/src/tableProcessor.js

@@ -194,8 +194,8 @@ TableProcessor.prototype.beginRow = function (rowIndex, writer) {
 	writer.context().moveDown(this.rowPaddingTop);
 };
 
-TableProcessor.prototype.drawHorizontalLine = function (lineIndex, writer, overrideY, moveDown = true, forcePage) {
-	var lineWidth = this.layout.hLineWidth(lineIndex, this.tableNode, writer);
+TableProcessor.prototype.drawHorizontalLine = function (lineIndex, writer, overrideY, moveDown = true, forcePage, isPageBreak = false) {
+	var lineWidth = this.layout.hLineWidth(lineIndex, this.tableNode, writer, isPageBreak);
 	if (lineWidth) {
 		var style = this.layout.hLineStyle(lineIndex, this.tableNode);
 		var dash;
@@ -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);
+			// 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);
+			// 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();