@flowaccount/pdfmake 1.0.0 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowaccount/pdfmake",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "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/documentContext.js

@@ -75,7 +75,7 @@ DocumentContext.prototype.resetMarginXTopParent = function () {
 	this.marginXTopParent = null;
 };
 
-DocumentContext.prototype.beginColumn = function (width, offset, endingCell) {
+DocumentContext.prototype.beginColumn = function (width, offset, endingCell, heightOffset) {
 	var saved = this.snapshots[this.snapshots.length - 1];
 
 	this.calculateBottomMost(saved, endingCell);
@@ -84,7 +84,7 @@ DocumentContext.prototype.beginColumn = function (width, offset, endingCell) {
 	this.x = this.x + this.lastColumnWidth + (offset || 0);
 	this.y = saved.y;
 	this.availableWidth = width;	//saved.availableWidth - offset;
-	this.availableHeight = saved.availableHeight;
+	this.availableHeight = saved.availableHeight - (heightOffset || 0);
 
 	this.lastColumnWidth = width;
 };

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.
  *
@@ -840,7 +990,7 @@ LayoutBuilder.prototype._getRowSpanEndingCell = function (tableBody, rowIndex, c
 	return null;
 };
 
-LayoutBuilder.prototype.processRow = function ({ marginX = [0, 0], dontBreakRows = false, rowsWithoutPageBreak = 0, cells, widths, gaps, tableNode, tableBody, rowIndex, height }) {
+LayoutBuilder.prototype.processRow = function ({ marginX = [0, 0], dontBreakRows = false, rowsWithoutPageBreak = 0, cells, widths, gaps, tableNode, tableBody, rowIndex, height, heightOffset = 0 }) {
 	var self = this;
 	var isUnbreakableRow = dontBreakRows || rowIndex <= rowsWithoutPageBreak - 1;
 	var pageBreaks = [];
@@ -848,8 +998,108 @@ 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;
+			}
+		}
+
+		// Apply heightOffset from table definition to adjust page break calculation
+		// This allows fine-tuning of page break detection for specific tables
+		// heightOffset is passed as parameter from processTable
+		if (heightOffset) {
+			estimatedHeight = (estimatedHeight || 0) + heightOffset;
+		}
+
+		// 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;
@@ -898,7 +1148,7 @@ LayoutBuilder.prototype.processRow = function ({ marginX = [0, 0], dontBreakRows
 			}
 
 			// We pass the endingSpanCell reference to store the context just after processing rowspan cell
-			self.writer.context().beginColumn(width, leftOffset, endOfRowSpanCell);
+			self.writer.context().beginColumn(width, leftOffset, endOfRowSpanCell, heightOffset);
 
 			if (!cell._span) {
 				self.processNode(cell);
@@ -1053,6 +1303,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;
@@ -1082,6 +1335,8 @@ LayoutBuilder.prototype.processTable = function (tableNode) {
 			height = undefined;
 		}
 
+		var heightOffset = tableNode.heightOffset != undefined ? tableNode.heightOffset : 0;
+
 		var pageBeforeProcessing = this.writer.context().page;
 
 		var result = this.processRow({
@@ -1094,7 +1349,8 @@ LayoutBuilder.prototype.processTable = function (tableNode) {
 			tableBody: tableNode.table.body,
 			tableNode,
 			rowIndex: i,
-			height
+			height,
+			heightOffset
 		});
 		addAll(tableNode.positions, result.positions);
 
@@ -1107,7 +1363,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

@@ -45,6 +45,9 @@ var findFont = function (fonts, requiredFonts, defaultFont) {
  * @class Creates an instance of a PdfPrinter which turns document definition into a pdf
  *
  * @param {Object} fontDescriptors font definition dictionary
+ * @param {Object} [options] optional configuration
+ * @param {Number} [options.maxImageCacheSize] maximum number of images to cache (default: 100)
+ * @param {Number} [options.imageCacheTTL] cache time-to-live in milliseconds (default: 3600000 = 1 hour)
  *
  * @example
  * var fontDescriptors = {
@@ -56,10 +59,22 @@ var findFont = function (fonts, requiredFonts, defaultFont) {
  *	}
  * };
  *
- * var printer = new PdfPrinter(fontDescriptors);
+ * var printer = new PdfPrinter(fontDescriptors, {
+ *   maxImageCacheSize: 50,
+ *   imageCacheTTL: 30 * 60 * 1000 // 30 minutes
+ * });
  */
-function PdfPrinter(fontDescriptors) {
+function PdfPrinter(fontDescriptors, options) {
 	this.fontDescriptors = fontDescriptors;
+	options = options || {};
+
+	// Cache configuration with memory leak prevention
+	this._cacheConfig = {
+		maxSize: isNumber(options.maxImageCacheSize) ? options.maxImageCacheSize : 100,
+		ttl: isNumber(options.imageCacheTTL) ? options.imageCacheTTL : 3600000 // 1 hour default
+	};
+
+	// LRU cache: Map maintains insertion order, so we can implement LRU easily
 	this._remoteImageCache = new Map();
 }
 
@@ -115,6 +130,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';
@@ -196,7 +215,67 @@ PdfPrinter.prototype.resolveRemoteImages = function (docDefinition, timeoutMs) {
 	return resolveRemoteImages.call(this, docDefinition, timeoutMs);
 };
 
+/**
+ * Clears the remote image cache
+ * Useful for freeing memory or forcing fresh image fetches
+ */
+PdfPrinter.prototype.clearImageCache = function () {
+	this._remoteImageCache.clear();
+};
+
+/**
+ * Gets cache statistics for monitoring
+ * @return {Object} Cache statistics
+ */
+PdfPrinter.prototype.getImageCacheStats = function () {
+	var now = Date.now();
+	var cache = this._remoteImageCache;
+	var expired = 0;
+	var valid = 0;
+
+	cache.forEach(function (entry) {
+		if (now - entry.timestamp > this._cacheConfig.ttl) {
+			expired++;
+		} else {
+			valid++;
+		}
+	}, this);
+
+	return {
+		size: cache.size,
+		maxSize: this._cacheConfig.maxSize,
+		ttl: this._cacheConfig.ttl,
+		validEntries: valid,
+		expiredEntries: expired
+	};
+};
+
+/**
+ * Removes expired entries from cache
+ */
+PdfPrinter.prototype.cleanExpiredCache = function () {
+	var now = Date.now();
+	var cache = this._remoteImageCache;
+	var keysToDelete = [];
+
+	cache.forEach(function (entry, key) {
+		if (now - entry.timestamp > this._cacheConfig.ttl) {
+			keysToDelete.push(key);
+		}
+	}, this);
+
+	keysToDelete.forEach(function (key) {
+		cache.delete(key);
+	});
+
+	return keysToDelete.length;
+};
+
 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')) {
@@ -800,11 +879,12 @@ function resolveRemoteImages(docDefinition, timeoutMs) {
 
 	var timeout = typeof timeoutMs === 'number' && timeoutMs > 0 ? timeoutMs : undefined;
 	var tasks = [];
+	var cacheConfig = this._cacheConfig;
 
 	remoteTargets.forEach(function (descriptor, key) {
 		var cacheKey = createCacheKey(descriptor.url, descriptor.headers);
 		tasks.push(
-			ensureRemoteBuffer(descriptor.url, descriptor.headers, cacheKey, cache, timeout)
+			ensureRemoteBuffer(descriptor.url, descriptor.headers, cacheKey, cache, timeout, cacheConfig)
 				.then(function (buffer) {
 					images[key] = buffer;
 				})
@@ -906,14 +986,39 @@ function registerInlineImage(node, images) {
 	return null;
 }
 
-function ensureRemoteBuffer(url, headers, cacheKey, cache, timeout) {
-	var existing = cache.get(cacheKey);
-	if (existing) {
-		return Promise.resolve(existing);
+function ensureRemoteBuffer(url, headers, cacheKey, cache, timeout, cacheConfig) {
+	var now = Date.now();
+
+	// Check if image is in cache and not expired
+	var cached = cache.get(cacheKey);
+	if (cached) {
+		var age = now - cached.timestamp;
+		if (age < cacheConfig.ttl) {
+			// Move to end (LRU: mark as recently used)
+			cache.delete(cacheKey);
+			cache.set(cacheKey, cached);
+			return Promise.resolve(cached.buffer);
+		} else {
+			// Expired - remove from cache
+			cache.delete(cacheKey);
+		}
 	}
 
+	// Fetch remote image and cache the result
 	return fetchRemote(url, headers, timeout).then(function (buffer) {
-		cache.set(cacheKey, buffer);
+		// Implement LRU eviction if cache is full
+		if (cache.size >= cacheConfig.maxSize) {
+			// Remove oldest entry (first entry in Map)
+			var firstKey = cache.keys().next().value;
+			cache.delete(firstKey);
+		}
+
+		// Store with timestamp for TTL
+		cache.set(cacheKey, {
+			buffer: buffer,
+			timestamp: now
+		});
+
 		return buffer;
 	});
 }