@flowaccount/pdfmake 0.2.20-staging.2

package/src/docPreprocessor.js

@@ -0,0 +1,277 @@
+'use strict';
+
+var isString = require('./helpers').isString;
+var isNumber = require('./helpers').isNumber;
+var isBoolean = require('./helpers').isBoolean;
+var isArray = require('./helpers').isArray;
+var isUndefined = require('./helpers').isUndefined;
+var fontStringify = require('./helpers').fontStringify;
+
+function DocPreprocessor() {
+
+}
+
+DocPreprocessor.prototype.preprocessDocument = function (docStructure) {
+	this.parentNode = null;
+	this.tocs = {};
+	this.nodeReferences = {};
+	return this.preprocessNode(docStructure);
+};
+
+DocPreprocessor.prototype.preprocessNode = function (node) {
+	// expand shortcuts and casting values
+	if (isArray(node)) {
+		node = { stack: node };
+	} else if (isString(node)) {
+		node = { text: node };
+	} else if (isNumber(node) || isBoolean(node)) {
+		node = { text: node.toString() };
+	} else if (node === undefined || node === null) {
+		node = { text: '' };
+	} else if (Object.keys(node).length === 0) { // empty object
+		node = { text: '' };
+	} else if ('text' in node && (node.text === undefined || node.text === null)) {
+		node.text = '';
+	}
+
+	if (node.columns) {
+		return this.preprocessColumns(node);
+	} else if (node.stack) {
+		return this.preprocessVerticalContainer(node);
+	} else if (node.layers) {
+		return this.preprocessLayers(node);
+	} else if (node.ul) {
+		return this.preprocessList(node);
+	} else if (node.ol) {
+		return this.preprocessList(node);
+	} else if (node.table) {
+		return this.preprocessTable(node);
+	} else if (node.text !== undefined) {
+		return this.preprocessText(node);
+	} else if (node.toc) {
+		return this.preprocessToc(node);
+	} else if (node.image) {
+		return this.preprocessImage(node);
+	} else if (node.svg) {
+		return this.preprocessSVG(node);
+	} else if (node.canvas) {
+		return this.preprocessCanvas(node);
+	} else if (node.qr) {
+		return this.preprocessQr(node);
+	} else if (node.pageReference || node.textReference) {
+		return this.preprocessText(node);
+	} else {
+		throw 'Unrecognized document structure: ' + JSON.stringify(node, fontStringify);
+	}
+};
+
+DocPreprocessor.prototype.preprocessColumns = function (node) {
+	var columns = node.columns;
+
+	for (var i = 0, l = columns.length; i < l; i++) {
+		columns[i] = this.preprocessNode(columns[i]);
+	}
+
+	return node;
+};
+
+DocPreprocessor.prototype.preprocessVerticalContainer = function (node) {
+	var items = node.stack;
+
+	for (var i = 0, l = items.length; i < l; i++) {
+		items[i] = this.preprocessNode(items[i]);
+	}
+
+	return node;
+};
+
+DocPreprocessor.prototype.preprocessLayers = function (node) {
+	var items = node.layers;
+
+	for (var i = 0, l = items.length; i < l; i++) {
+		items[i] = this.preprocessNode(items[i]);
+	}
+
+	return node;
+};
+
+DocPreprocessor.prototype.preprocessList = function (node) {
+	var items = node.ul || node.ol;
+
+	for (var i = 0, l = items.length; i < l; i++) {
+		items[i] = this.preprocessNode(items[i]);
+	}
+
+	return node;
+};
+
+DocPreprocessor.prototype.preprocessTable = function (node) {
+	var col, row, cols, rows;
+
+	if (!node.table.body || !node.table.body[0]) {
+		return node;
+	}
+
+	for (col = 0, cols = node.table.body[0].length; col < cols; col++) {
+		for (row = 0, rows = node.table.body.length; row < rows; row++) {
+			var rowData = node.table.body[row];
+			var data = rowData[col];
+			if (data !== undefined) {
+				if (data === null) { // transform to object
+					data = '';
+				}
+				if (!data._span) {
+					rowData[col] = this.preprocessNode(data);
+				}
+			}
+		}
+	}
+
+	return node;
+};
+
+DocPreprocessor.prototype.preprocessText = function (node) {
+	var i;
+	var l;
+
+	if (node.tocItem) {
+		if (!isArray(node.tocItem)) {
+			node.tocItem = [node.tocItem];
+		}
+
+		for (i = 0, l = node.tocItem.length; i < l; i++) {
+			if (!isString(node.tocItem[i])) {
+				node.tocItem[i] = '_default_';
+			}
+
+			var tocItemId = node.tocItem[i];
+
+			if (!this.tocs[tocItemId]) {
+				this.tocs[tocItemId] = { toc: { _items: [], _pseudo: true } };
+			}
+
+			if (!node.id) {
+				node.id = 'toc-' + tocItemId + '-' + this.tocs[tocItemId].toc._items.length;
+			}
+
+			var tocItemRef = {
+				_nodeRef: this._getNodeForNodeRef(node),
+				_textNodeRef: node
+			};
+			this.tocs[tocItemId].toc._items.push(tocItemRef);
+		}
+	}
+
+	if (node.id) {
+		if (this.nodeReferences[node.id]) {
+			if (!this.nodeReferences[node.id]._pseudo) {
+				throw "Node id '" + node.id + "' already exists";
+			}
+
+			this.nodeReferences[node.id]._nodeRef = this._getNodeForNodeRef(node);
+			this.nodeReferences[node.id]._textNodeRef = node;
+			this.nodeReferences[node.id]._pseudo = false;
+		} else {
+			this.nodeReferences[node.id] = {
+				_nodeRef: this._getNodeForNodeRef(node),
+				_textNodeRef: node
+			};
+		}
+	}
+
+	if (node.pageReference) {
+		if (!this.nodeReferences[node.pageReference]) {
+			this.nodeReferences[node.pageReference] = {
+				_nodeRef: {},
+				_textNodeRef: {},
+				_pseudo: true
+			};
+		}
+		node.text = '00000';
+		node.linkToDestination = node.pageReference;
+		node._pageRef = this.nodeReferences[node.pageReference];
+	}
+
+	if (node.textReference) {
+		if (!this.nodeReferences[node.textReference]) {
+			this.nodeReferences[node.textReference] = {
+				_nodeRef: {},
+				_pseudo: true
+			};
+		}
+
+		node.text = '';
+		node.linkToDestination = node.textReference;
+		node._textRef = this.nodeReferences[node.textReference];
+	}
+
+	if (node.text && node.text.text) {
+		node.text = [this.preprocessNode(node.text)];
+	} else if (isArray(node.text)) {
+		var isSetParentNode = false;
+		if (this.parentNode === null) {
+			this.parentNode = node;
+			isSetParentNode = true;
+		}
+
+		for (i = 0, l = node.text.length; i < l; i++) {
+			node.text[i] = this.preprocessNode(node.text[i]);
+		}
+
+		if (isSetParentNode) {
+			this.parentNode = null;
+		}
+	}
+
+	return node;
+};
+
+DocPreprocessor.prototype.preprocessToc = function (node) {
+	if (!node.toc.id) {
+		node.toc.id = '_default_';
+	}
+
+	node.toc.title = node.toc.title ? this.preprocessNode(node.toc.title) : null;
+	node.toc._items = [];
+
+	if (this.tocs[node.toc.id]) {
+		if (!this.tocs[node.toc.id].toc._pseudo) {
+			throw "TOC '" + node.toc.id + "' already exists";
+		}
+
+		node.toc._items = this.tocs[node.toc.id].toc._items;
+	}
+
+	this.tocs[node.toc.id] = node;
+
+	return node;
+};
+
+DocPreprocessor.prototype.preprocessImage = function (node) {
+	if (!isUndefined(node.image.type) && !isUndefined(node.image.data) && (node.image.type === 'Buffer') && isArray(node.image.data)) {
+		node.image = Buffer.from(node.image.data);
+	}
+	return node;
+};
+
+DocPreprocessor.prototype.preprocessSVG = function (node) {
+	return node;
+};
+
+DocPreprocessor.prototype.preprocessCanvas = function (node) {
+	return node;
+};
+
+DocPreprocessor.prototype.preprocessQr = function (node) {
+	return node;
+};
+
+DocPreprocessor.prototype._getNodeForNodeRef = function (node) {
+	if (this.parentNode) {
+		return this.parentNode;
+	}
+
+	return node;
+};
+
+module.exports = DocPreprocessor;

package/src/documentContext.js

@@ -0,0 +1,383 @@
+'use strict';
+
+var TraversalTracker = require('./traversalTracker');
+var isString = require('./helpers').isString;
+
+/**
+ * Creates an instance of DocumentContext - a store for current x, y positions and available width/height.
+ * It facilitates column divisions and vertical sync
+ */
+function DocumentContext(pageSize, pageMargins, footerGapOption = {}) {
+	this.pages = [];
+
+	this.pageMargins = pageMargins;
+
+	this.x = pageMargins.left;
+	this.availableWidth = pageSize.width - pageMargins.left - pageMargins.right;
+	this.availableHeight = 0;
+	this.page = -1;
+
+	this._footerColumnGuides = null;
+  	this._footerGapOption = footerGapOption;
+
+	this.snapshots = [];
+
+	this.tracker = new TraversalTracker();
+
+	this.backgroundLength = [];
+
+	this.addPage(pageSize);
+}
+
+DocumentContext.prototype.beginColumnGroup = function (marginXTopParent, bottomByPage = {}) {
+	this.snapshots.push({
+		x: this.x,
+		y: this.y,
+		availableHeight: this.availableHeight,
+		availableWidth: this.availableWidth,
+		page: this.page,
+		bottomByPage: bottomByPage ? bottomByPage : {},
+		bottomMost: {
+			x: this.x,
+			y: this.y,
+			availableHeight: this.availableHeight,
+			availableWidth: this.availableWidth,
+			page: this.page
+		},
+		lastColumnWidth: this.lastColumnWidth
+	});
+
+	this.lastColumnWidth = 0;
+	if (marginXTopParent) {
+		this.marginXTopParent = marginXTopParent;
+	}
+};
+
+DocumentContext.prototype.updateBottomByPage = function () {
+	const lastSnapshot = this.snapshots[this.snapshots.length - 1];
+	if (!lastSnapshot) {
+		return;
+	}
+
+	if (!lastSnapshot.bottomByPage) {
+		lastSnapshot.bottomByPage = {};
+	}
+
+	const lastPage = this.page;
+	let previousBottom = -Number.MIN_VALUE;
+	if (lastSnapshot.bottomByPage[lastPage] !== undefined) {
+		previousBottom = lastSnapshot.bottomByPage[lastPage];
+	}
+	lastSnapshot.bottomByPage[lastPage] = Math.max(previousBottom, this.y);
+};
+
+DocumentContext.prototype.resetMarginXTopParent = function () {
+	this.marginXTopParent = null;
+};
+
+DocumentContext.prototype.beginColumn = function (width, offset, endingCell) {
+	var saved = this.snapshots[this.snapshots.length - 1];
+
+	this.calculateBottomMost(saved, endingCell);
+
+	this.page = saved.page;
+	this.x = this.x + this.lastColumnWidth + (offset || 0);
+	this.y = saved.y;
+	this.availableWidth = width;	//saved.availableWidth - offset;
+	this.availableHeight = saved.availableHeight;
+
+	this.lastColumnWidth = width;
+};
+
+DocumentContext.prototype.calculateBottomMost = function (destContext, endingCell) {
+	if (endingCell) {
+		this.saveContextInEndingCell(endingCell);
+	} else {
+		destContext.bottomMost = bottomMostContext(this, destContext.bottomMost);
+	}
+};
+
+DocumentContext.prototype.markEnding = function (endingCell, originalXOffset, discountY) {
+	this.page = endingCell._columnEndingContext.page;
+	this.x = endingCell._columnEndingContext.x + originalXOffset;
+	this.y = endingCell._columnEndingContext.y - discountY;
+	this.availableWidth = endingCell._columnEndingContext.availableWidth;
+	this.availableHeight = endingCell._columnEndingContext.availableHeight;
+	this.lastColumnWidth = endingCell._columnEndingContext.lastColumnWidth;
+};
+
+DocumentContext.prototype.saveContextInEndingCell = function (endingCell) {
+	endingCell._columnEndingContext = {
+		page: this.page,
+		x: this.x,
+		y: this.y,
+		availableHeight: this.availableHeight,
+		availableWidth: this.availableWidth,
+		lastColumnWidth: this.lastColumnWidth
+	};
+};
+
+DocumentContext.prototype.completeColumnGroup = function (height, endingCell) {
+	var saved = this.snapshots.pop();
+
+	this.calculateBottomMost(saved, endingCell);
+
+	this.x = saved.x;
+
+	var y = saved.bottomMost.y;
+	if (height) {
+		if (saved.page === saved.bottomMost.page) {
+			if ((saved.y + height) > y) {
+				y = saved.y + height;
+			}
+		} else {
+			y += height;
+		}
+	}
+
+	this.y = y;
+	this.page = saved.bottomMost.page;
+	this.height = saved.bottomMost.y - saved.y;
+	this.availableWidth = saved.availableWidth;
+	this.availableHeight = saved.bottomMost.availableHeight;
+	if (height) {
+		this.availableHeight -= (y - saved.bottomMost.y);
+	}
+	this.lastColumnWidth = saved.lastColumnWidth;
+	return saved.bottomByPage;
+};
+
+DocumentContext.prototype.addMargin = function (left, right) {
+	this.x += left;
+	this.availableWidth -= left + (right || 0);
+};
+
+DocumentContext.prototype.moveDown = function (offset) {
+	this.y += offset;
+	this.availableHeight -= offset;
+
+	return this.availableHeight > 0;
+};
+
+DocumentContext.prototype.initializePage = function () {
+	this.y = this.pageMargins.top;
+	this.availableHeight = this.getCurrentPage().pageSize.height - this.pageMargins.top - this.pageMargins.bottom;
+	this.fullHeight = this.availableHeight;
+	const { pageCtx, isSnapshot } = this.pageSnapshot();
+	pageCtx.availableWidth = this.getCurrentPage().pageSize.width - this.pageMargins.left - this.pageMargins.right;
+	if (isSnapshot && this.marginXTopParent) {
+		pageCtx.availableWidth -= this.marginXTopParent[0];
+		pageCtx.availableWidth -= this.marginXTopParent[1];
+	}
+};
+
+DocumentContext.prototype.pageSnapshot = function () {
+	if (this.snapshots[0]) {
+		return { pageCtx: this.snapshots[0], isSnapshot: true };
+	} else {
+		return { pageCtx: this, isSnapshot: false };
+	}
+};
+
+DocumentContext.prototype.moveTo = function (x, y) {
+	if (x !== undefined && x !== null) {
+		this.x = x;
+		this.availableWidth = this.getCurrentPage().pageSize.width - this.x - this.pageMargins.right;
+	}
+	if (y !== undefined && y !== null) {
+		this.y = y;
+		this.availableHeight = this.getCurrentPage().pageSize.height - this.y - this.pageMargins.bottom;
+	}
+};
+
+DocumentContext.prototype.moveToRelative = function (x, y) {
+	if (x !== undefined && x !== null) {
+		this.x = this.x + x;
+	}
+	if (y !== undefined && y !== null) {
+		this.y = this.y + y;
+	}
+};
+
+DocumentContext.prototype.beginDetachedBlock = function () {
+	this.snapshots.push({
+		x: this.x,
+		y: this.y,
+		availableHeight: this.availableHeight,
+		availableWidth: this.availableWidth,
+		page: this.page,
+		lastColumnWidth: this.lastColumnWidth
+	});
+};
+
+DocumentContext.prototype.endDetachedBlock = function () {
+	var saved = this.snapshots.pop();
+
+	this.x = saved.x;
+	this.y = saved.y;
+	this.availableWidth = saved.availableWidth;
+	this.availableHeight = saved.availableHeight;
+	this.page = saved.page;
+	this.lastColumnWidth = saved.lastColumnWidth;
+};
+
+function pageOrientation(pageOrientationString, currentPageOrientation) {
+	if (pageOrientationString === undefined) {
+		return currentPageOrientation;
+	} else if (isString(pageOrientationString) && (pageOrientationString.toLowerCase() === 'landscape')) {
+		return 'landscape';
+	} else {
+		return 'portrait';
+	}
+}
+
+var getPageSize = function (currentPage, newPageOrientation) {
+
+	newPageOrientation = pageOrientation(newPageOrientation, currentPage.pageSize.orientation);
+
+	if (newPageOrientation !== currentPage.pageSize.orientation) {
+		return {
+			orientation: newPageOrientation,
+			width: currentPage.pageSize.height,
+			height: currentPage.pageSize.width
+		};
+	} else {
+		return {
+			orientation: currentPage.pageSize.orientation,
+			width: currentPage.pageSize.width,
+			height: currentPage.pageSize.height
+		};
+	}
+
+};
+
+
+DocumentContext.prototype.moveToNextPage = function (pageOrientation) {
+	var nextPageIndex = this.page + 1;
+
+	var prevPage = this.page;
+	var prevY = this.y;
+
+	// If we are in a column group
+	if (this.snapshots.length > 0) {
+		var lastSnapshot = this.snapshots[this.snapshots.length - 1];
+		// We have to update prevY accordingly by also taking into consideration
+		// the 'y' of cells that don't break page
+		if (lastSnapshot.bottomMost && lastSnapshot.bottomMost.y) {
+			prevY = Math.max(this.y, lastSnapshot.bottomMost.y);
+		}
+	}
+
+	var createNewPage = nextPageIndex >= this.pages.length;
+	if (createNewPage) {
+		var currentAvailableWidth = this.availableWidth;
+		var currentPageOrientation = this.getCurrentPage().pageSize.orientation;
+
+		var pageSize = getPageSize(this.getCurrentPage(), pageOrientation);
+		this.addPage(pageSize);
+
+		if (currentPageOrientation === pageSize.orientation) {
+			this.availableWidth = currentAvailableWidth;
+		}
+	} else {
+		this.page = nextPageIndex;
+		this.initializePage();
+	}
+
+	return {
+		newPageCreated: createNewPage,
+		prevPage: prevPage,
+		prevY: prevY,
+		y: this.y
+	};
+};
+
+
+DocumentContext.prototype.addPage = function (pageSize) {
+	var page = { items: [], pageSize: pageSize };
+	this.pages.push(page);
+	this.backgroundLength.push(0);
+	this.page = this.pages.length - 1;
+	this.initializePage();
+
+	this.tracker.emit('pageAdded');
+
+	return page;
+};
+
+DocumentContext.prototype.getCurrentPage = function () {
+	if (this.page < 0 || this.page >= this.pages.length) {
+		return null;
+	}
+
+	return this.pages[this.page];
+};
+
+DocumentContext.prototype.getCurrentPosition = function () {
+	var pageSize = this.getCurrentPage().pageSize;
+	var innerHeight = pageSize.height - this.pageMargins.top - this.pageMargins.bottom;
+	var innerWidth = pageSize.width - this.pageMargins.left - this.pageMargins.right;
+
+	return {
+		pageNumber: this.page + 1,
+		pageOrientation: pageSize.orientation,
+		pageInnerHeight: innerHeight,
+		pageInnerWidth: innerWidth,
+		left: this.x,
+		top: this.y,
+		verticalRatio: ((this.y - this.pageMargins.top) / innerHeight),
+		horizontalRatio: ((this.x - this.pageMargins.left) / innerWidth)
+	};
+};
+
+function bottomMostContext(c1, c2) {
+	if (!c1 && !c2) {
+		return {
+			page: 0,
+			x: 0,
+			y: 0,
+			availableHeight: 0,
+			availableWidth: 0
+		};
+	}
+
+	if (!c1) {
+		return {
+			page: c2.page,
+			x: c2.x,
+			y: c2.y,
+			availableHeight: c2.availableHeight,
+			availableWidth: c2.availableWidth
+		};
+	}
+
+	if (!c2) {
+		return {
+			page: c1.page,
+			x: c1.x,
+			y: c1.y,
+			availableHeight: c1.availableHeight,
+			availableWidth: c1.availableWidth
+		};
+	}
+
+	var r;
+
+	if (c1.page > c2.page) {
+		r = c1;
+	} else if (c2.page > c1.page) {
+		r = c2;
+	} else {
+		r = (c1.y > c2.y) ? c1 : c2;
+	}
+
+	return {
+		page: r.page,
+		x: r.x,
+		y: r.y,
+		availableHeight: r.availableHeight,
+		availableWidth: r.availableWidth
+	};
+}
+
+module.exports = DocumentContext;