@flowaccount/pdfmake 1.0.7-staging.1 → 1.0.7-staging.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowaccount/pdfmake",
-  "version": "1.0.7-staging.1",
+  "version": "1.0.7-staging.4",
   "description": "Client/server side PDF printing in pure JavaScript",
   "main": "src/printer.js",
   "browser": "build/pdfmake.js",

package/src/layoutBuilder.js

@@ -538,13 +538,32 @@ LayoutBuilder.prototype.processNode = function (node) {
 					startY: ctx.y,
 					startPage: ctx.page,
 					availableHeight: ctx.availableHeight,
-					itemCount: currentPage ? currentPage.items.length : 0
+					itemCount: currentPage ? currentPage.items.length : 0,
+					x: ctx.x,
+					summaryRenderedPage: null
 				};
 			}
 
 			// Process the stack
 			self.processVerticalContainer(node);
 
+			// Track which page summary was rendered on (summary is first item, unbreakable)
+			if (preRenderState && node.stack && node.stack[0]) {
+				var summaryNode = node.stack[0];
+				if (summaryNode.summary || summaryNode.unbreakable) {
+					// Summary is unbreakable, check if it was pushed to a new page
+					// by comparing its height with available space at startPage
+					var summaryHeight = Math.abs(summaryNode._height || 0);
+					if (summaryHeight <= preRenderState.availableHeight) {
+						// Summary fit on startPage
+						preRenderState.summaryRenderedPage = preRenderState.startPage;
+					} else {
+						// Summary was pushed to next page
+						preRenderState.summaryRenderedPage = preRenderState.startPage + 1;
+					}
+				}
+			}
+
 			// Post-render repositioning
 			if (footerGapEnabled && preRenderState) {
 				var ctx = self.writer.context();
@@ -683,6 +702,132 @@ LayoutBuilder.prototype.processNode = function (node) {
 					// Intermediate pages (remark only) should not be repositioned
 					var pageIdx = ctx.page;
 					if (pageIdx > preRenderState.startPage) {
+						// Also reposition items on the START page (where summary might be)
+						var startPage = pages[preRenderState.startPage];
+						if (startPage && startPage.items && startPage.items.length > 0) {
+							var startPageHeight = startPage.pageSize.height;
+							var startPageBottom = startPageHeight - pageMargins.bottom;
+
+							// Find content bottom on start page
+							var startContentBottom = 0;
+							for (var si = 0; si < startPage.items.length; si++) {
+								var sItem = startPage.items[si];
+								var sItemBottom = 0;
+								if (sItem.item) {
+									if (typeof sItem.item.y === 'number') {
+										var sh = 0;
+										// Line items have getHeight() method
+										if (sItem.type === 'line' && typeof sItem.item.getHeight === 'function') {
+											sh = sItem.item.getHeight();
+										} else {
+											sh = sItem.item.h || sItem.item.height || 0;
+										}
+										sItemBottom = sItem.item.y + sh;
+									}
+									if (typeof sItem.item.y2 === 'number' && sItem.item.y2 > sItemBottom) {
+										sItemBottom = sItem.item.y2;
+									}
+								}
+								if (sItemBottom > startContentBottom) {
+									startContentBottom = sItemBottom;
+								}
+							}
+
+							// Calculate gap and move items on start page
+							var startGapHeight = startPageBottom - startContentBottom;
+							if (startGapHeight > 0) {
+								var startStackStartY = preRenderState.startY;
+								for (var si = 0; si < startPage.items.length; si++) {
+									var sItem = startPage.items[si];
+									var sItemY = null;
+									if (sItem.item && typeof sItem.item.y1 === 'number') {
+										sItemY = sItem.item.y1;
+									} else if (sItem.item && typeof sItem.item.y === 'number') {
+										sItemY = sItem.item.y;
+									} else if (sItem.item && sItem.item.points && Array.isArray(sItem.item.points) && sItem.item.points.length > 0) {
+										// For polylines, use the first point's Y
+										sItemY = sItem.item.points[0].y;
+									}
+
+									// Skip items fully above footer start
+									if (sItemY === null || sItemY < startStackStartY) continue;
+
+									// Move item down
+									if (sItem.item && typeof sItem.item.y === 'number') {
+										sItem.item.y += startGapHeight;
+									}
+									if (sItem.item && typeof sItem.item.y1 === 'number') {
+										sItem.item.y1 += startGapHeight;
+									}
+									if (sItem.item && typeof sItem.item.y2 === 'number') {
+										sItem.item.y2 += startGapHeight;
+									}
+									// Handle polylines (points array)
+									if (sItem.item && sItem.item.points && Array.isArray(sItem.item.points)) {
+										for (var spi = 0; spi < sItem.item.points.length; spi++) {
+											if (typeof sItem.item.points[spi].y === 'number') {
+												sItem.item.points[spi].y += startGapHeight;
+											}
+										}
+									}
+								}
+
+								// MULTI-PAGE: Draw guide lines in the gap area (same as single-page)
+								var colSpec = node._footerGapOption && node._footerGapOption.columns ? node._footerGapOption.columns : (self._footerGapOption && self._footerGapOption.columns);
+								if (colSpec) {
+									var rawWidths = colSpec.content && colSpec.content.vLines ? colSpec.content.vLines : [];
+									if (rawWidths && rawWidths.length > 1) {
+										var style = (colSpec.style || {});
+										var lw = style.lineWidth != null ? style.lineWidth : 0.5;
+										var lc = style.color || '#000000';
+										var dashCfg = style.dash;
+										var includeOuter = colSpec.includeOuter !== false;
+										var startIndex = includeOuter ? 0 : 1;
+										var endIndex = includeOuter ? rawWidths.length : rawWidths.length - 1;
+										var pageX = preRenderState.x || pageMargins.left;
+
+										for (var ci = startIndex; ci < endIndex; ci++) {
+											var xGuide = pageX + rawWidths[ci] - 0.25;
+											// Extend first and last vertical lines to content bottom after moving
+											var isFirstOrLast = (ci === 0) || (ci === rawWidths.length - 1);
+											var vLineY2 = isFirstOrLast ? (startContentBottom + startGapHeight) : (startStackStartY + startGapHeight);
+											startPage.items.push({
+												type: 'vector',
+												item: {
+													type: 'line',
+													x1: xGuide,
+													y1: startStackStartY,
+													x2: xGuide,
+													y2: vLineY2,
+													lineWidth: lw,
+													lineColor: lc,
+													dash: dashCfg ? {
+														length: dashCfg.length,
+														space: dashCfg.space != null ? dashCfg.space : dashCfg.gap
+													} : undefined,
+													_footerGuideLine: true
+												}
+											});
+										}
+
+										// Remove existing horizontal line at startStackStartY (drawn by tableProcessor)
+										// It's at wrong position now - we'll draw new one at bottom of gap
+										for (var ri = startPage.items.length - 1; ri >= 0; ri--) {
+											var rItem = startPage.items[ri];
+											if (rItem.type === 'vector' && rItem.item && rItem.item.type === 'line') {
+												// Check if it's a horizontal line at startStackStartY
+												if (Math.abs(rItem.item.y1 - startStackStartY) < 1 &&
+													Math.abs(rItem.item.y2 - startStackStartY) < 1) {
+													startPage.items.splice(ri, 1);
+													break;
+												}
+											}
+										}
+									}
+								}
+							}
+						}
+
 						var page = pages[pageIdx];
 						if (page && page.items && page.items.length > 0) {
 							var pageHeight = page.pageSize.height;
@@ -703,19 +848,35 @@ LayoutBuilder.prototype.processNode = function (node) {
 									if (typeof item.item.y2 === 'number' && item.item.y2 > itemBottom) {
 										itemBottom = item.item.y2;
 									}
+									// Handle polylines (points array)
+									if (item.item.points && Array.isArray(item.item.points)) {
+										for (var pi = 0; pi < item.item.points.length; pi++) {
+											if (typeof item.item.points[pi].y === 'number' && item.item.points[pi].y > itemBottom) {
+												itemBottom = item.item.points[pi].y;
+											}
+										}
+									}
 								}
 								if (itemBottom > contentBottom) {
 									contentBottom = itemBottom;
 								}
 							}
 
-							// Footer starts at contentBottom - footerHeight
-							var stackStartY = contentBottom - stackHeight;
+							// Check if summary is on the last page
+							var summaryOnLastPage = (preRenderState.summaryRenderedPage === pageIdx);
 
-							// Calculate gap: how much to move footer down
-							var gapHeight = pageBottom - contentBottom;
-							if (gapHeight > 0) {
-								// Only move items that are part of footer (Y >= footerStartY)
+							var stackStartY;
+							if (summaryOnLastPage) {
+								// Summary is on this page - move all: summary + remark + footer together
+								// Calculate header threshold for this page
+								var repeatableHeaderHeight = 0;
+								for (var ri = 0; ri < self.writer.repeatables.length; ri++) {
+									repeatableHeaderHeight += self.writer.repeatables[ri].height;
+								}
+								var headerThreshold = pageMargins.top + repeatableHeaderHeight;
+
+								// Find minimum Y of all items below header threshold
+								stackStartY = contentBottom;
 								for (var i = 0; i < page.items.length; i++) {
 									var item = page.items[i];
 									var itemY = null;
@@ -724,23 +885,92 @@ LayoutBuilder.prototype.processNode = function (node) {
 									} else if (item.item && typeof item.item.y === 'number') {
 										itemY = item.item.y;
 									} else if (item.item && item.item.points && Array.isArray(item.item.points) && item.item.points.length > 0) {
-										// For polylines, use the first point's Y
 										itemY = item.item.points[0].y;
 									}
+									if (itemY !== null && itemY >= headerThreshold && itemY < stackStartY) {
+										stackStartY = itemY;
+									}
+								}
 
-									// Skip items above footer
-									if (itemY === null || itemY < stackStartY) continue;
+								// Draw guide lines in the gap area (same as single-page)
+								var gapHeightForLines = pageBottom - contentBottom;
+								if (gapHeightForLines > 0) {
+									var colSpec = node._footerGapOption && node._footerGapOption.columns ? node._footerGapOption.columns : (self._footerGapOption && self._footerGapOption.columns);
+									if (colSpec) {
+										var rawWidths = colSpec.content && colSpec.content.vLines ? colSpec.content.vLines : [];
+										if (rawWidths && rawWidths.length > 1) {
+											var style = (colSpec.style || {});
+											var lw = style.lineWidth != null ? style.lineWidth : 0.5;
+											var lc = style.color || '#000000';
+											var dashCfg = style.dash;
+											var includeOuter = colSpec.includeOuter !== false;
+											var startIndex = includeOuter ? 0 : 1;
+											var endIndex = includeOuter ? rawWidths.length : rawWidths.length - 1;
+											var pageX = preRenderState.x || pageMargins.left;
+
+											for (var ci = startIndex; ci < endIndex; ci++) {
+												var xGuide = pageX + rawWidths[ci] - 0.25;
+												page.items.push({
+													type: 'vector',
+													item: {
+														type: 'line',
+														x1: xGuide,
+														y1: stackStartY,
+														x2: xGuide,
+														y2: stackStartY + gapHeightForLines,
+														lineWidth: lw,
+														lineColor: lc,
+														dash: dashCfg ? {
+															length: dashCfg.length,
+															space: dashCfg.space != null ? dashCfg.space : dashCfg.gap
+														} : undefined,
+														_footerGuideLine: true
+													}
+												});
+											}
+										}
+									}
+								}
+							} else {
+								// Summary is NOT on this page - move only footer
+								stackStartY = contentBottom - stackHeight;
+							}
 
-									// Don't move items that are near the top margin (table headers)
-									// Use actual header height from repeatables instead of hardcoded threshold
+							// Calculate gap: how much to move footer stack down
+							var gapHeight = pageBottom - contentBottom;
+							if (gapHeight > 0) {
+								// Calculate header threshold if not already calculated
+								if (typeof headerThreshold === 'undefined') {
 									var repeatableHeaderHeight = 0;
 									for (var ri = 0; ri < self.writer.repeatables.length; ri++) {
 										repeatableHeaderHeight += self.writer.repeatables[ri].height;
 									}
-									var headerThreshold = pageMargins.top + repeatableHeaderHeight;
+									headerThreshold = pageMargins.top + repeatableHeaderHeight;
+								}
+
+								// Move all items that are part of footer stack (Y >= stackStartY)
+								for (var i = 0; i < page.items.length; i++) {
+									var item = page.items[i];
+
+									// Skip guide lines (they're already positioned correctly)
+									if (item.item && item.item._footerGuideLine) continue;
+
+									var itemY = null;
+									if (item.item && typeof item.item.y1 === 'number') {
+										itemY = item.item.y1;
+									} else if (item.item && typeof item.item.y === 'number') {
+										itemY = item.item.y;
+									} else if (item.item && item.item.points && Array.isArray(item.item.points) && item.item.points.length > 0) {
+										itemY = item.item.points[0].y;
+									}
+
+									// Skip items above footer stack
+									if (itemY === null || itemY < stackStartY) continue;
+
+									// Skip items in header area (repeated headers)
 									if (itemY < headerThreshold) continue;
 
-									// Move footer item down
+									// Move footer stack item down
 									if (item.item && typeof item.item.y === 'number') {
 										item.item.y += gapHeight;
 									}

package/src/tableProcessor.js

@@ -560,11 +560,13 @@ TableProcessor.prototype.endRow = function (rowIndex, writer, pageBreaks, nextRo
 		var ctx = writer.context();
 		var currentPage = ctx.getCurrentPage && ctx.getCurrentPage();
 		var pageHeight = currentPage ? (currentPage.pageSize.height - ctx.pageMargins.bottom) : 0;
-
+		var footerGapOptBreak = ctx._footerGapOption;
+		var hLineY = (footerGapOptBreak && footerGapOptBreak.enabled) ? pageHeight - 0.25 : y2;
 		if (willBreak && this.layout.hLineWhenBroken !== false) {
 			// Check if we're at the true page bottom
 			var isAtTruePageBottom = (pageHeight - y2) <= nearBottomThreshold;
-			this.drawHorizontalLine(rowIndex + 1, writer, y2, true, null, isAtTruePageBottom);
+			// Use pageHeight for footer gap tables, y2 for normal tables
+			this.drawHorizontalLine(rowIndex + 1, writer, hLineY, true, null, isAtTruePageBottom);
 		}
 		if (rowBreakWithoutHeader && this.layout.hLineWhenBroken !== false) {
 			// Check if previous segment ended at true page bottom
@@ -573,6 +575,10 @@ TableProcessor.prototype.endRow = function (rowIndex, writer, pageBreaks, nextRo
 			this.drawHorizontalLine(rowIndex, writer, y1, true, null, prevWasAtPageBottom);
 		}
 
+		// vLineY: ONLY use hLineY when BOTH willBreak AND footerGapOptBreak.enabled are true
+		// Otherwise use y2 (original behavior) to avoid NaN errors
+		var vLineY = (willBreak && footerGapOptBreak && footerGapOptBreak.enabled) ? hLineY : y2;
+
 		for (i = 0, l = xs.length; i < l; i++) {
 			var leftCellBorder = false;
 			var rightCellBorder = false;
@@ -599,7 +605,7 @@ TableProcessor.prototype.endRow = function (rowIndex, writer, pageBreaks, nextRo
 			}
 
 			if (leftCellBorder) {
-				this.drawVerticalLine(xs[i].x, y1 - hzLineOffset, y2 + this.bottomLineWidth, xs[i].index, writer, rowIndex, xs[i - 1] ? xs[i - 1].index : null);
+				this.drawVerticalLine(xs[i].x, y1 - hzLineOffset, vLineY + this.bottomLineWidth, xs[i].index, writer, rowIndex, xs[i - 1] ? xs[i - 1].index : null);
 			}
 
 			if (i < l - 1) {

package/src/textTools.js

@@ -317,7 +317,7 @@ function getStyleProperty(item, styleContextStack, property, defaultValue) {
 	}
 
 	if(property === 'bold' && (item.text === '' || item.text === '\u200B')) {
-		return false
+		return false;
 	}
 
 	if (value !== null && value !== undefined) {