pdfmake 0.2.10 → 0.2.12

package/package.json

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

package/src/columnCalculator.js

@@ -2,7 +2,7 @@
 
 var isString = require('./helpers').isString;
 
-function buildColumnWidths(columns, availableWidth) {
+function buildColumnWidths(columns, availableWidth, offsetTotal = 0, tableNode) {
 	var autoColumns = [],
 		autoMin = 0, autoMax = 0,
 		starColumns = [],
@@ -25,10 +25,31 @@ function buildColumnWidths(columns, availableWidth) {
 		}
 	});
 
-	fixedColumns.forEach(function (col) {
+	fixedColumns.forEach(function (col, colIndex) {
 		// width specified as %
 		if (isString(col.width) && /\d+%/.test(col.width)) {
-			col.width = parseFloat(col.width) * initial_availableWidth / 100;
+			// In tables we have to take into consideration the reserved width for paddings and borders
+			var reservedWidth = 0;
+			if (tableNode) {
+				var paddingLeft = tableNode._layout.paddingLeft(colIndex, tableNode);
+				var paddingRight = tableNode._layout.paddingRight(colIndex, tableNode);
+				var borderLeft = tableNode._layout.vLineWidth(colIndex, tableNode);
+				var borderRight = tableNode._layout.vLineWidth(colIndex + 1, tableNode);
+				if (colIndex === 0) {
+					// first column assumes whole borderLeft and half of border right
+					reservedWidth = paddingLeft + paddingRight + borderLeft + (borderRight / 2);
+
+				} else if (colIndex === fixedColumns.length - 1) {
+					// last column assumes whole borderRight and half of border left
+					reservedWidth = paddingLeft + paddingRight + (borderLeft / 2) + borderRight;
+
+				} else {
+					// Columns in the middle assume half of each border
+					reservedWidth = paddingLeft + paddingRight + (borderLeft / 2) + (borderRight / 2);
+				}
+			}
+			var totalAvailableWidth = initial_availableWidth + offsetTotal;
+			col.width = (parseFloat(col.width) * totalAvailableWidth / 100) - reservedWidth;
 		}
 		if (col.width < (col._minWidth) && col.elasticWidth) {
 			col._calcWidth = col._minWidth;

package/src/docMeasure.js

@@ -509,16 +509,16 @@ DocMeasure.prototype.measureOrderedList = function (node) {
 			if (item.listMarker._inlines) {
 				node._gapSize.width = Math.max(node._gapSize.width, item.listMarker._inlines[0].width);
 			}
-		}  // TODO: else - nested lists numbering
+
+			if (node.reversed) {
+				counter--;
+			} else {
+				counter++;
+			}
+		}
 
 		node._minWidth = Math.max(node._minWidth, items[i]._minWidth);
 		node._maxWidth = Math.max(node._maxWidth, items[i]._maxWidth);
-
-		if (node.reversed) {
-			counter--;
-		} else {
-			counter++;
-		}
 	}
 
 	node._minWidth += node._gapSize.width;

package/src/documentContext.js

@@ -19,8 +19,6 @@ function DocumentContext(pageSize, pageMargins) {
 
 	this.snapshots = [];
 
-	this.endingCell = null;
-
 	this.tracker = new TraversalTracker();
 
 	this.backgroundLength = [];
@@ -42,7 +40,6 @@ DocumentContext.prototype.beginColumnGroup = function () {
 			availableWidth: this.availableWidth,
 			page: this.page
 		},
-		endingCell: this.endingCell,
 		lastColumnWidth: this.lastColumnWidth
 	});
 
@@ -52,9 +49,8 @@ DocumentContext.prototype.beginColumnGroup = function () {
 DocumentContext.prototype.beginColumn = function (width, offset, endingCell) {
 	var saved = this.snapshots[this.snapshots.length - 1];
 
-	this.calculateBottomMost(saved);
+	this.calculateBottomMost(saved, endingCell);
 
-	this.endingCell = endingCell;
 	this.page = saved.page;
 	this.x = this.x + this.lastColumnWidth + (offset || 0);
 	this.y = saved.y;
@@ -64,10 +60,9 @@ DocumentContext.prototype.beginColumn = function (width, offset, endingCell) {
 	this.lastColumnWidth = width;
 };
 
-DocumentContext.prototype.calculateBottomMost = function (destContext) {
-	if (this.endingCell) {
-		this.saveContextInEndingCell(this.endingCell);
-		this.endingCell = null;
+DocumentContext.prototype.calculateBottomMost = function (destContext, endingCell) {
+	if (endingCell) {
+		this.saveContextInEndingCell(endingCell);
 	} else {
 		destContext.bottomMost = bottomMostContext(this, destContext.bottomMost);
 	}
@@ -93,12 +88,11 @@ DocumentContext.prototype.saveContextInEndingCell = function (endingCell) {
 	};
 };
 
-DocumentContext.prototype.completeColumnGroup = function (height) {
+DocumentContext.prototype.completeColumnGroup = function (height, endingCell) {
 	var saved = this.snapshots.pop();
 
-	this.calculateBottomMost(saved);
+	this.calculateBottomMost(saved, endingCell);
 
-	this.endingCell = null;
 	this.x = saved.x;
 
 	var y = saved.bottomMost.y;
@@ -175,7 +169,6 @@ DocumentContext.prototype.beginDetachedBlock = function () {
 		availableHeight: this.availableHeight,
 		availableWidth: this.availableWidth,
 		page: this.page,
-		endingCell: this.endingCell,
 		lastColumnWidth: this.lastColumnWidth
 	});
 };
@@ -188,7 +181,6 @@ DocumentContext.prototype.endDetachedBlock = function () {
 	this.availableWidth = saved.availableWidth;
 	this.availableHeight = saved.availableHeight;
 	this.page = saved.page;
-	this.endingCell = saved.endingCell;
 	this.lastColumnWidth = saved.lastColumnWidth;
 };
 

package/src/helpers.js

@@ -32,6 +32,17 @@ function isUndefined(variable) {
 	return variable === undefined;
 }
 
+/**
+ * @param {any} variable
+ * @returns {boolean}
+ */
+function isPositiveInteger(variable) {
+	if (!isNumber(variable) || !Number.isInteger(variable) || variable <= 0) {
+			return false;
+	}
+	return true;
+}
+
 function pack() {
 	var result = {};
 
@@ -117,6 +128,7 @@ module.exports = {
 	isObject: isObject,
 	isNull: isNull,
 	isUndefined: isUndefined,
+	isPositiveInteger: isPositiveInteger,
 	pack: pack,
 	fontStringify: fontStringify,
 	offsetVector: offsetVector,

package/src/imageMeasure.js

@@ -1,51 +1,55 @@
-'use strict';
-
-var fs = require('fs');
-
-function ImageMeasure(pdfKitDoc, imageDictionary) {
-	this.pdfKitDoc = pdfKitDoc;
-	this.imageDictionary = imageDictionary || {};
-}
-
-ImageMeasure.prototype.measureImage = function (src) {
-	var image;
-	var that = this;
-
-	if (!this.pdfKitDoc._imageRegistry[src]) {
-		try {
-			image = this.pdfKitDoc.openImage(realImageSrc(src));
-			if (!image) {
-				throw 'No image';
-			}
-		} catch (error) {
-			throw 'Invalid image: ' + error.toString() + '\nImages dictionary should contain dataURL entries (or local file paths in node.js)';
-		}
-		image.embed(this.pdfKitDoc);
-		this.pdfKitDoc._imageRegistry[src] = image;
-	} else {
-		image = this.pdfKitDoc._imageRegistry[src];
-	}
-
-	return { width: image.width, height: image.height };
-
-	function realImageSrc(src) {
-		var img = that.imageDictionary[src];
-
-		if (!img) {
-			return src;
-		}
-
-		if (fs.existsSync(img)) {
-			return fs.readFileSync(img);
-		}
-
-		var index = img.indexOf('base64,');
-		if (index < 0) {
-			return that.imageDictionary[src];
-		}
-
-		return Buffer.from(img.substring(index + 7), 'base64');
-	}
-};
-
-module.exports = ImageMeasure;
+'use strict';
+
+var fs = require('fs');
+
+function ImageMeasure(pdfKitDoc, imageDictionary) {
+	this.pdfKitDoc = pdfKitDoc;
+	this.imageDictionary = imageDictionary || {};
+}
+
+ImageMeasure.prototype.measureImage = function (src) {
+	var image;
+	var that = this;
+
+	if (!this.pdfKitDoc._imageRegistry[src]) {
+		try {
+			image = this.pdfKitDoc.openImage(realImageSrc(src));
+			if (!image) {
+				throw 'No image';
+			}
+		} catch (error) {
+			throw 'Invalid image: ' + error.toString() + '\nImages dictionary should contain dataURL entries (or local file paths in node.js)';
+		}
+		image.embed(this.pdfKitDoc);
+		this.pdfKitDoc._imageRegistry[src] = image;
+	} else {
+		image = this.pdfKitDoc._imageRegistry[src];
+	}
+
+	return { width: image.width, height: image.height };
+
+	function realImageSrc(src) {
+		var img = that.imageDictionary[src];
+
+		if (!img) {
+			return src;
+		}
+
+		if (typeof img === 'object') {
+			throw 'Not supported image definition: ' + JSON.stringify(img);
+		}
+
+		if (fs.existsSync(img)) {
+			return fs.readFileSync(img);
+		}
+
+		var index = img.indexOf('base64,');
+		if (index < 0) {
+			return that.imageDictionary[src];
+		}
+
+		return Buffer.from(img.substring(index + 7), 'base64');
+	}
+};
+
+module.exports = ImageMeasure;

package/src/layoutBuilder.js

@@ -511,6 +511,21 @@ LayoutBuilder.prototype.processColumns = function (columnNode) {
 	}
 };
 
+LayoutBuilder.prototype.findStartingSpanCell = function (arr, i) {
+	let requiredColspan = 1;
+	for (let index = i - 1; index >= 0; index--) {
+			if (!arr[index]._span) {
+				if (arr[index].rowSpan > 1 && (arr[index].colSpan || 1) === requiredColspan) {
+					return arr[index];
+				} else {
+					return null;
+				}
+			}
+			requiredColspan++;
+	}
+	return null;
+}
+
 LayoutBuilder.prototype.processRow = function (columns, widths, gaps, tableBody, tableRow, height) {
 	var self = this;
 	var pageBreaks = [], positions = [];
@@ -531,17 +546,52 @@ LayoutBuilder.prototype.processRow = function (columns, widths, gaps, tableBody,
 				}
 			}
 
-			self.writer.context().beginColumn(width, leftOffset, getEndingCell(column, i));
+			// if rowspan starts in this cell, we retrieve the last cell affected by the rowspan
+			var endingCell = getEndingCell(column, i);
+			if (endingCell) {
+				// We store a reference of the ending cell in the first cell of the rowspan
+				column._endingCell = endingCell;
+			}
+
+			// Check if exists and retrieve the cell that started the rowspan in case we are in the cell just after
+			var startingSpanCell = self.findStartingSpanCell(columns, i);
+			var endingSpanCell = null;
+			if (startingSpanCell && startingSpanCell._endingCell) {
+				// Reference to the last cell of the rowspan
+				endingSpanCell = startingSpanCell._endingCell;
+			}
+
+			// We pass the endingSpanCell reference to store the context just after processing rowspan cell
+			self.writer.context().beginColumn(width, leftOffset, endingSpanCell);
 			if (!column._span) {
 				self.processNode(column);
 				addAll(positions, column.positions);
 			} else if (column._columnEndingContext) {
 				// row-span ending
+				// Recover the context after processing the rowspanned cell
 				self.writer.context().markEnding(column);
 			}
 		}
 
-		self.writer.context().completeColumnGroup(height);
+		// Check if last cell is part of a span
+		var endingSpanCell = null;
+		var lastColumn = columns.length > 0 ? columns[columns.length - 1] : null;
+		if (lastColumn) {
+			// Previous column cell has a rowspan
+			if (lastColumn._endingCell) {
+				endingSpanCell = lastColumn._endingCell;
+			// Previous column cell is part of a span
+			} else if (lastColumn._span === true) {
+				// We get the cell that started the span where we set a reference to the ending cell
+				var startingSpanCell = self.findStartingSpanCell(columns, columns.length);
+				if (startingSpanCell) {
+					// Context will be stored here (ending cell)
+					endingSpanCell = startingSpanCell._endingCell;
+				}
+			}
+		}
+
+		self.writer.context().completeColumnGroup(height, endingSpanCell);
 	});
 
 	return { pageBreaks: pageBreaks, positions: positions };

package/src/styleContextStack.js

@@ -84,50 +84,9 @@ StyleContextStack.prototype.autopush = function (item) {
 		this.push(styleNames[i]);
 	}
 
-	var styleProperties = [
-		'font',
-		'fontSize',
-		'fontFeatures',
-		'bold',
-		'italics',
-		'alignment',
-		'color',
-		'columnGap',
-		'fillColor',
-		'fillOpacity',
-		'decoration',
-		'decorationStyle',
-		'decorationColor',
-		'background',
-		'lineHeight',
-		'characterSpacing',
-		'noWrap',
-		'markerColor',
-		'leadingIndent',
-		'sup',
-		'sub'
-		//'tableCellPadding'
-		// 'cellBorder',
-		// 'headerCellBorder',
-		// 'oddRowCellBorder',
-		// 'evenRowCellBorder',
-		// 'tableBorder'
-	];
-	var styleOverrideObject = {};
-	var pushStyleOverrideObject = false;
-
-	styleProperties.forEach(function (key) {
-		if (!isUndefined(item[key]) && !isNull(item[key])) {
-			styleOverrideObject[key] = item[key];
-			pushStyleOverrideObject = true;
-		}
-	});
-
-	if (pushStyleOverrideObject) {
-		this.push(styleOverrideObject);
-	}
-
-	return styleNames.length + (pushStyleOverrideObject ? 1 : 0);
+	// rather than spend significant time making a styleOverrideObject, just add item
+	this.push(item);
+	return styleNames.length + 1;
 };
 
 /**

package/src/tableProcessor.js

@@ -3,6 +3,7 @@
 var ColumnCalculator = require('./columnCalculator');
 var isFunction = require('./helpers').isFunction;
 var isNumber = require('./helpers').isNumber;
+var isPositiveInteger = require('./helpers').isPositiveInteger;
 
 function TableProcessor(tableNode) {
 	this.tableNode = tableNode;
@@ -18,18 +19,34 @@ TableProcessor.prototype.beginTable = function (writer) {
 	this.layout = tableNode._layout;
 
 	availableWidth = writer.context().availableWidth - this.offsets.total;
-	ColumnCalculator.buildColumnWidths(tableNode.table.widths, availableWidth);
+	ColumnCalculator.buildColumnWidths(tableNode.table.widths, availableWidth, this.offsets.total, tableNode);
 
 	this.tableWidth = tableNode._offsets.total + getTableInnerContentWidth();
 	this.rowSpanData = prepareRowSpanData();
 	this.cleanUpRepeatables = false;
 
-	this.headerRows = tableNode.table.headerRows || 0;
-	if (this.headerRows > tableNode.table.body.length) {
-		throw new Error(`Too few rows in the table. Property headerRows requires at least ${this.headerRows}, contains only ${tableNode.table.body.length}`);
+	// headersRows and rowsWithoutPageBreak (headerRows + keepWithHeaderRows)
+	this.headerRows = 0;
+	this.rowsWithoutPageBreak = 0;
+
+	var headerRows = tableNode.table.headerRows;
+
+	if (isPositiveInteger(headerRows)) {
+		this.headerRows = headerRows;
+
+		if (this.headerRows > tableNode.table.body.length) {
+			throw new Error(`Too few rows in the table. Property headerRows requires at least ${this.headerRows}, contains only ${tableNode.table.body.length}`);
+		}
+
+		this.rowsWithoutPageBreak = this.headerRows;
+
+		const keepWithHeaderRows = tableNode.table.keepWithHeaderRows;
+
+		if (isPositiveInteger(keepWithHeaderRows)) {
+				this.rowsWithoutPageBreak += keepWithHeaderRows;
+		}
 	}
 
-	this.rowsWithoutPageBreak = this.headerRows + (tableNode.table.keepWithHeaderRows || 0);
 	this.dontBreakRows = tableNode.table.dontBreakRows || false;
 
 	if (this.rowsWithoutPageBreak) {