pdfmake 0.3.0-beta.8 → 0.3.0-beta.9

package/js/standardPageSizes.js

@@ -0,0 +1,56 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _default = exports.default = {
+  '4A0': [4767.87, 6740.79],
+  '2A0': [3370.39, 4767.87],
+  A0: [2383.94, 3370.39],
+  A1: [1683.78, 2383.94],
+  A2: [1190.55, 1683.78],
+  A3: [841.89, 1190.55],
+  A4: [595.28, 841.89],
+  A5: [419.53, 595.28],
+  A6: [297.64, 419.53],
+  A7: [209.76, 297.64],
+  A8: [147.40, 209.76],
+  A9: [104.88, 147.40],
+  A10: [73.70, 104.88],
+  B0: [2834.65, 4008.19],
+  B1: [2004.09, 2834.65],
+  B2: [1417.32, 2004.09],
+  B3: [1000.63, 1417.32],
+  B4: [708.66, 1000.63],
+  B5: [498.90, 708.66],
+  B6: [354.33, 498.90],
+  B7: [249.45, 354.33],
+  B8: [175.75, 249.45],
+  B9: [124.72, 175.75],
+  B10: [87.87, 124.72],
+  C0: [2599.37, 3676.54],
+  C1: [1836.85, 2599.37],
+  C2: [1298.27, 1836.85],
+  C3: [918.43, 1298.27],
+  C4: [649.13, 918.43],
+  C5: [459.21, 649.13],
+  C6: [323.15, 459.21],
+  C7: [229.61, 323.15],
+  C8: [161.57, 229.61],
+  C9: [113.39, 161.57],
+  C10: [79.37, 113.39],
+  RA0: [2437.80, 3458.27],
+  RA1: [1729.13, 2437.80],
+  RA2: [1218.90, 1729.13],
+  RA3: [864.57, 1218.90],
+  RA4: [609.45, 864.57],
+  SRA0: [2551.18, 3628.35],
+  SRA1: [1814.17, 2551.18],
+  SRA2: [1275.59, 1814.17],
+  SRA3: [907.09, 1275.59],
+  SRA4: [637.80, 907.09],
+  EXECUTIVE: [521.86, 756.00],
+  FOLIO: [612.00, 936.00],
+  LEGAL: [612.00, 1008.00],
+  LETTER: [612.00, 792.00],
+  TABLOID: [792.00, 1224.00]
+};

package/js/tableLayouts.js

@@ -0,0 +1,98 @@
+"use strict";
+
+exports.__esModule = true;
+exports.tableLayouts = exports.defaultTableLayout = void 0;
+/*eslint no-unused-vars: ["error", {"args": "none"}]*/
+
+const tableLayouts = exports.tableLayouts = {
+  noBorders: {
+    hLineWidth(i) {
+      return 0;
+    },
+    vLineWidth(i) {
+      return 0;
+    },
+    paddingLeft(i) {
+      return i && 4 || 0;
+    },
+    paddingRight(i, node) {
+      return i < node.table.widths.length - 1 ? 4 : 0;
+    }
+  },
+  headerLineOnly: {
+    hLineWidth(i, node) {
+      if (i === 0 || i === node.table.body.length) {
+        return 0;
+      }
+      return i === node.table.headerRows ? 2 : 0;
+    },
+    vLineWidth(i) {
+      return 0;
+    },
+    paddingLeft(i) {
+      return i === 0 ? 0 : 8;
+    },
+    paddingRight(i, node) {
+      return i === node.table.widths.length - 1 ? 0 : 8;
+    }
+  },
+  lightHorizontalLines: {
+    hLineWidth(i, node) {
+      if (i === 0 || i === node.table.body.length) {
+        return 0;
+      }
+      return i === node.table.headerRows ? 2 : 1;
+    },
+    vLineWidth(i) {
+      return 0;
+    },
+    hLineColor(i) {
+      return i === 1 ? 'black' : '#aaa';
+    },
+    paddingLeft(i) {
+      return i === 0 ? 0 : 8;
+    },
+    paddingRight(i, node) {
+      return i === node.table.widths.length - 1 ? 0 : 8;
+    }
+  }
+};
+const defaultTableLayout = exports.defaultTableLayout = {
+  hLineWidth(i, node) {
+    return 1;
+  },
+  vLineWidth(i, node) {
+    return 1;
+  },
+  hLineColor(i, node) {
+    return 'black';
+  },
+  vLineColor(i, node) {
+    return 'black';
+  },
+  hLineStyle(i, node) {
+    return null;
+  },
+  vLineStyle(i, node) {
+    return null;
+  },
+  paddingLeft(i, node) {
+    return 4;
+  },
+  paddingRight(i, node) {
+    return 4;
+  },
+  paddingTop(i, node) {
+    return 2;
+  },
+  paddingBottom(i, node) {
+    return 2;
+  },
+  fillColor(i, node) {
+    return null;
+  },
+  fillOpacity(i, node) {
+    return 1;
+  },
+  defaultBorder: true
+};

package/js/virtual-fs.js

@@ -0,0 +1,60 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+const normalizeFilename = filename => {
+  if (filename.indexOf(__dirname) === 0) {
+    filename = filename.substring(__dirname.length);
+  }
+  if (filename.indexOf('/') === 0) {
+    filename = filename.substring(1);
+  }
+  return filename;
+};
+class VirtualFileSystem {
+  constructor() {
+    this.storage = {};
+  }
+
+  /**
+   * @param {string} filename
+   * @returns {boolean}
+   */
+  existsSync(filename) {
+    const normalizedFilename = normalizeFilename(filename);
+    return typeof this.storage[normalizedFilename] !== 'undefined';
+  }
+
+  /**
+   * @param {string} filename
+   * @param {?string|?object} options
+   * @returns {string|Buffer}
+   */
+  readFileSync(filename, options) {
+    const normalizedFilename = normalizeFilename(filename);
+    const encoding = typeof options === 'object' ? options.encoding : options;
+    if (!this.existsSync(normalizedFilename)) {
+      throw new Error(`File '${normalizedFilename}' not found in virtual file system`);
+    }
+    const buffer = this.storage[normalizedFilename];
+    if (encoding) {
+      return buffer.toString(encoding);
+    }
+    return buffer;
+  }
+
+  /**
+   * @param {string} filename
+   * @param {string|Buffer} content
+   * @param {?string|?object} options
+   */
+  writeFileSync(filename, content, options) {
+    const normalizedFilename = normalizeFilename(filename);
+    const encoding = typeof options === 'object' ? options.encoding : options;
+    if (!content && !options) {
+      throw new Error('No content');
+    }
+    this.storage[normalizedFilename] = encoding || typeof content === 'string' ? new Buffer(content, encoding) : content;
+  }
+}
+var _default = exports.default = new VirtualFileSystem();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pdfmake",
-  "version": "0.3.0-beta.8",
+  "version": "0.3.0-beta.9",
   "description": "Client/server side PDF printing in pure JavaScript",
   "main": "js/index.js",
   "esnext": "src/index.js",

package/src/DocMeasure.js

@@ -433,16 +433,17 @@ class DocMeasure {
 				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

@@ -18,7 +18,6 @@ class DocumentContext extends EventEmitter {
 		this.page = -1;
 
 		this.snapshots = [];
-		this.endingCell = null;
 		this.backgroundLength = [];
 
 		this.addPage(pageSize);
@@ -38,7 +37,6 @@ class DocumentContext extends EventEmitter {
 				availableWidth: this.availableWidth,
 				page: this.page
 			},
-			endingCell: this.endingCell,
 			lastColumnWidth: this.lastColumnWidth
 		});
 
@@ -48,9 +46,8 @@ class DocumentContext extends EventEmitter {
 	beginColumn(width, offset, endingCell) {
 		let 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;
@@ -60,10 +57,9 @@ class DocumentContext extends EventEmitter {
 		this.lastColumnWidth = width;
 	}
 
-	calculateBottomMost(destContext) {
-		if (this.endingCell) {
-			this.saveContextInEndingCell(this.endingCell);
-			this.endingCell = null;
+	calculateBottomMost(destContext, endingCell) {
+		if (endingCell) {
+			this.saveContextInEndingCell(endingCell);
 		} else {
 			destContext.bottomMost = bottomMostContext(this, destContext.bottomMost);
 		}
@@ -89,12 +85,11 @@ class DocumentContext extends EventEmitter {
 		};
 	}
 
-	completeColumnGroup(height) {
+	completeColumnGroup(height, endingCell) {
 		let saved = this.snapshots.pop();
 
-		this.calculateBottomMost(saved);
+		this.calculateBottomMost(saved, endingCell);
 
-		this.endingCell = null;
 		this.x = saved.x;
 
 		let y = saved.bottomMost.y;
@@ -171,7 +166,6 @@ class DocumentContext extends EventEmitter {
 			availableHeight: this.availableHeight,
 			availableWidth: this.availableWidth,
 			page: this.page,
-			endingCell: this.endingCell,
 			lastColumnWidth: this.lastColumnWidth
 		});
 	}
@@ -184,7 +178,6 @@ class DocumentContext extends EventEmitter {
 		this.availableWidth = saved.availableWidth;
 		this.availableHeight = saved.availableHeight;
 		this.page = saved.page;
-		this.endingCell = saved.endingCell;
 		this.lastColumnWidth = saved.lastColumnWidth;
 	}
 

package/src/LayoutBuilder.js

@@ -495,6 +495,21 @@ class LayoutBuilder {
 		}
 	}
 
+	findStartingSpanCell(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;
+	}
+
 	processRow(columns, widths, gaps, tableBody, tableRow, height) {
 		const storePageBreakData = data => {
 			let pageDesc;
@@ -535,17 +550,52 @@ class LayoutBuilder {
 				}
 			}
 
-			this.writer.context().beginColumn(width, leftOffset, getEndingCell(column, i));
+			// if rowspan starts in this cell, we retrieve the last cell affected by the rowspan
+			const 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
+			let startingSpanCell = this.findStartingSpanCell(columns, i);
+			let 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
+			this.writer.context().beginColumn(width, leftOffset, endingSpanCell);
 			if (!column._span) {
 				this.processNode(column);
 				addAll(positions, column.positions);
 			} else if (column._columnEndingContext) {
 				// row-span ending
+				// Recover the context after processing the rowspanned cell
 				this.writer.context().markEnding(column);
 			}
 		}
 
-		this.writer.context().completeColumnGroup(height);
+		// Check if last cell is part of a span
+		let endingSpanCell = null;
+		const 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
+				const startingSpanCell = this.findStartingSpanCell(columns, columns.length);
+				if (startingSpanCell) {
+					// Context will be stored here (ending cell)
+					endingSpanCell = startingSpanCell._endingCell;
+				}
+			}
+		}
+
+		this.writer.context().completeColumnGroup(height, endingSpanCell);
 
 		this.writer.removeListener('pageChanged', storePageBreakData);
 

package/src/StyleContextStack.js

@@ -79,50 +79,9 @@ class StyleContextStack {
 			this.push(styleNames[i]);
 		}
 
-		let 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'
-		];
-		let styleOverrideObject = {};
-		let pushStyleOverrideObject = false;
-
-		styleProperties.forEach(key => {
-			if (isValue(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

@@ -1,5 +1,5 @@
 import ColumnCalculator from './columnCalculator';
-import { isNumber } from './helpers/variableType';
+import { isNumber, isPositiveInteger } from './helpers/variableType';
 
 class TableProcessor {
 	constructor(tableNode) {
@@ -95,18 +95,34 @@ class TableProcessor {
 		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;
+
+		const 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) {

package/src/columnCalculator.js

@@ -1,6 +1,6 @@
 import { isString } from './helpers/variableType';
 
-function buildColumnWidths(columns, availableWidth) {
+function buildColumnWidths(columns, availableWidth, offsetTotal = 0, tableNode) {
 	let autoColumns = [];
 	let autoMin = 0;
 	let autoMax = 0;
@@ -24,10 +24,31 @@ function buildColumnWidths(columns, availableWidth) {
 		}
 	});
 
-	fixedColumns.forEach(col => {
+	fixedColumns.forEach((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
+			let reservedWidth = 0;
+			if (tableNode) {
+        const paddingLeft = tableNode._layout.paddingLeft(colIndex, tableNode);
+        const paddingRight = tableNode._layout.paddingRight(colIndex, tableNode);
+        const borderLeft = tableNode._layout.vLineWidth (colIndex, tableNode);
+        const 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);
+        }
+			}
+			const 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/helpers/variableType.js

@@ -14,6 +14,17 @@ export function isNumber(variable) {
 	return (typeof variable === 'number') || (variable instanceof Number);
 }
 
+/**
+ * @param {any} variable
+ * @returns {boolean}
+ */
+export function isPositiveInteger(variable) {
+	if (!isNumber(variable) || !Number.isInteger(variable) || variable <= 0) {
+			return false;
+	}
+	return true;
+}
+
 /**
  * @param {any} variable
  * @returns {boolean}