pdfmake-acroforms 0.3.4

package/src/browser-extensions/OutputDocumentBrowser.js

@@ -0,0 +1,80 @@
+import OutputDocument from '../OutputDocument';
+import { saveAs } from 'file-saver';
+
+/**
+ * @returns {Window}
+ */
+const openWindow = () => {
+	// we have to open the window immediately and store the reference
+	// otherwise popup blockers will stop us
+	let win = window.open('', '_blank');
+	if (win === null) {
+		throw new Error('Open PDF in new window blocked by browser');
+	}
+
+	return win;
+};
+
+class OutputDocumentBrowser extends OutputDocument {
+
+	/**
+	 * @returns {Promise<Blob>}
+	 */
+	async getBlob() {
+		const buffer = await this.getBuffer();
+		return new Blob([buffer], { type: 'application/pdf' });
+	}
+
+	/**
+	 * @param {string} filename
+	 * @returns {Promise}
+	 */
+	async download(filename = 'file.pdf') {
+		const blob = await this.getBlob();
+		saveAs(blob, filename);
+	}
+
+	/**
+	 * @param {Window} win
+	 * @returns {Promise}
+	 */
+	async open(win = null) {
+		if (!win) {
+			win = openWindow();
+		}
+		const blob = await this.getBlob();
+		try {
+			let urlCreator = window.URL || window.webkitURL;
+			let pdfUrl = urlCreator.createObjectURL(blob);
+			win.location.href = pdfUrl;
+
+			/* temporarily disabled
+			if (win === window) {
+				return;
+			} else {
+				setTimeout(() => {
+					if (win.window === null) { // is closed by AdBlock
+						window.location.href = pdfUrl; // open in actual window
+					}
+					return;
+				}, 500);
+			}
+			*/
+		} catch (e) {
+			win.close();
+			throw e;
+		}
+	}
+
+	/**
+	 * @param {Window} win
+	 * @returns {Promise}
+	 */
+	async print(win = null) {
+		const stream = await this.getStream();
+		stream.setOpenActionAsPrint();
+		await this.open(win);
+	}
+}
+
+export default OutputDocumentBrowser;

package/src/browser-extensions/fonts/Roboto.js

@@ -0,0 +1,27 @@
+var fs = require('fs');
+
+var fontContainer = {
+	vfs: {
+		'Roboto-Regular.ttf': { data: fs.readFileSync(__dirname + '/../../../fonts/Roboto/Roboto-Regular.ttf', 'base64'), encoding: 'base64' },
+		'Roboto-Medium.ttf': { data: fs.readFileSync(__dirname + '/../../../fonts/Roboto/Roboto-Medium.ttf', 'base64'), encoding: 'base64' },
+		'Roboto-Italic.ttf': { data: fs.readFileSync(__dirname + '/../../../fonts/Roboto/Roboto-Italic.ttf', 'base64'), encoding: 'base64' },
+		'Roboto-MediumItalic.ttf': { data: fs.readFileSync(__dirname + '/../../../fonts/Roboto/Roboto-MediumItalic.ttf', 'base64'), encoding: 'base64' }
+	},
+	fonts: {
+		Roboto: {
+			normal: 'Roboto-Regular.ttf',
+			bold: 'Roboto-Medium.ttf',
+			italics: 'Roboto-Italic.ttf',
+			bolditalics: 'Roboto-MediumItalic.ttf'
+		}
+	}
+};
+
+var _global = typeof window === 'object' ? window : typeof global === 'object' ? global : typeof self === 'object' ? self : this;
+if (typeof _global.pdfMake !== 'undefined' && typeof _global.pdfMake.addFontContainer !== 'undefined') {
+	_global.pdfMake.addFontContainer(fontContainer);
+}
+
+if (typeof module !== 'undefined') {
+	module.exports = fontContainer;
+}

package/src/browser-extensions/index.js

@@ -0,0 +1,55 @@
+import pdfmakeBase from '../base';
+import OutputDocumentBrowser from './OutputDocumentBrowser';
+import URLResolver from '../URLResolver';
+import fs from 'fs';
+import configurator from 'core-js/configurator';
+
+// core-js: Polyfills will be used only if natives completely unavailable.
+configurator({
+	useNative: ['Promise']
+});
+
+let defaultClientFonts = {
+	Roboto: {
+		normal: 'Roboto-Regular.ttf',
+		bold: 'Roboto-Medium.ttf',
+		italics: 'Roboto-Italic.ttf',
+		bolditalics: 'Roboto-MediumItalic.ttf'
+	}
+};
+
+class pdfmake extends pdfmakeBase {
+	constructor() {
+		super();
+		this.urlResolver = () => new URLResolver(this.virtualfs);
+		this.fonts = defaultClientFonts;
+	}
+
+	addFontContainer(fontContainer) {
+		this.addVirtualFileSystem(fontContainer.vfs);
+		this.addFonts(fontContainer.fonts);
+	}
+
+	addVirtualFileSystem(vfs) {
+		for (let key in vfs) {
+			if (vfs.hasOwnProperty(key)) {
+				let data;
+				let encoding;
+				if (typeof vfs[key] === 'object') {
+					data = vfs[key].data;
+					encoding = vfs[key].encoding || 'base64';
+				} else {
+					data = vfs[key];
+					encoding = 'base64';
+				}
+				fs.writeFileSync(key, data, encoding);
+			}
+		}
+	}
+
+	_transformToDocument(doc) {
+		return new OutputDocumentBrowser(doc);
+	}
+}
+
+export default new pdfmake();

package/src/browser-extensions/pdfMake.js

@@ -0,0 +1 @@
+module.exports = require('./index').default;

package/src/browser-extensions/standard-fonts/Courier.js

@@ -0,0 +1,27 @@
+var fs = require('fs');
+
+var fontContainer = {
+	vfs: {
+		'data/Courier.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/Courier.afm', 'utf8'), encoding: 'utf8' },
+		'data/Courier-Bold.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/Courier-Bold.afm', 'utf8'), encoding: 'utf8' },
+		'data/Courier-Oblique.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/Courier-Oblique.afm', 'utf8'), encoding: 'utf8' },
+		'data/Courier-BoldOblique.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/Courier-BoldOblique.afm', 'utf8'), encoding: 'utf8' }
+	},
+	fonts: {
+		Courier: {
+			normal: 'Courier',
+			bold: 'Courier-Bold',
+			italics: 'Courier-Oblique',
+			bolditalics: 'Courier-BoldOblique'
+		}
+	}
+};
+
+var _global = typeof window === 'object' ? window : typeof global === 'object' ? global : typeof self === 'object' ? self : this;
+if (typeof _global.pdfMake !== 'undefined' && typeof _global.pdfMake.addFontContainer !== 'undefined') {
+	_global.pdfMake.addFontContainer(fontContainer);
+}
+
+if (typeof module !== 'undefined') {
+	module.exports = fontContainer;
+}

package/src/browser-extensions/standard-fonts/Helvetica.js

@@ -0,0 +1,27 @@
+var fs = require('fs');
+
+var fontContainer = {
+	vfs: {
+		'data/Helvetica.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/Helvetica.afm', 'utf8'), encoding: 'utf8' },
+		'data/Helvetica-Bold.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/Helvetica-Bold.afm', 'utf8'), encoding: 'utf8' },
+		'data/Helvetica-Oblique.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/Helvetica-Oblique.afm', 'utf8'), encoding: 'utf8' },
+		'data/Helvetica-BoldOblique.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/Helvetica-BoldOblique.afm', 'utf8'), encoding: 'utf8' }
+	},
+	fonts: {
+		Helvetica: {
+			normal: 'Helvetica',
+			bold: 'Helvetica-Bold',
+			italics: 'Helvetica-Oblique',
+			bolditalics: 'Helvetica-BoldOblique'
+		}
+	}
+};
+
+var _global = typeof window === 'object' ? window : typeof global === 'object' ? global : typeof self === 'object' ? self : this;
+if (typeof _global.pdfMake !== 'undefined' && typeof _global.pdfMake.addFontContainer !== 'undefined') {
+	_global.pdfMake.addFontContainer(fontContainer);
+}
+
+if (typeof module !== 'undefined') {
+	module.exports = fontContainer;
+}

package/src/browser-extensions/standard-fonts/Symbol.js

@@ -0,0 +1,21 @@
+var fs = require('fs');
+
+var fontContainer = {
+	vfs: {
+		'data/Symbol.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/Symbol.afm', 'utf8'), encoding: 'utf8' }
+	},
+	fonts: {
+		Symbol: {
+			normal: 'Symbol'
+		}
+	}
+};
+
+var _global = typeof window === 'object' ? window : typeof global === 'object' ? global : typeof self === 'object' ? self : this;
+if (typeof _global.pdfMake !== 'undefined' && typeof _global.pdfMake.addFontContainer !== 'undefined') {
+	_global.pdfMake.addFontContainer(fontContainer);
+}
+
+if (typeof module !== 'undefined') {
+	module.exports = fontContainer;
+}

package/src/browser-extensions/standard-fonts/Times.js

@@ -0,0 +1,27 @@
+var fs = require('fs');
+
+var fontContainer = {
+	vfs: {
+		'data/Times-Roman.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/Times-Roman.afm', 'utf8'), encoding: 'utf8' },
+		'data/Times-Bold.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/Times-Bold.afm', 'utf8'), encoding: 'utf8' },
+		'data/Times-Italic.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/Times-Italic.afm', 'utf8'), encoding: 'utf8' },
+		'data/Times-BoldItalic.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/Times-BoldItalic.afm', 'utf8'), encoding: 'utf8' }
+	},
+	fonts: {
+		Times: {
+			normal: 'Times-Roman',
+			bold: 'Times-Bold',
+			italics: 'Times-Italic',
+			bolditalics: 'Times-BoldItalic'
+		}
+	}
+};
+
+var _global = typeof window === 'object' ? window : typeof global === 'object' ? global : typeof self === 'object' ? self : this;
+if (typeof _global.pdfMake !== 'undefined' && typeof _global.pdfMake.addFontContainer !== 'undefined') {
+	_global.pdfMake.addFontContainer(fontContainer);
+}
+
+if (typeof module !== 'undefined') {
+	module.exports = fontContainer;
+}

package/src/browser-extensions/standard-fonts/ZapfDingbats.js

@@ -0,0 +1,21 @@
+var fs = require('fs');
+
+var fontContainer = {
+	vfs: {
+		'data/ZapfDingbats.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/ZapfDingbats.afm', 'utf8'), encoding: 'utf8' }
+	},
+	fonts: {
+		ZapfDingbats: {
+			normal: 'ZapfDingbats'
+		}
+	}
+};
+
+var _global = typeof window === 'object' ? window : typeof global === 'object' ? global : typeof self === 'object' ? self : this;
+if (typeof _global.pdfMake !== 'undefined' && typeof _global.pdfMake.addFontContainer !== 'undefined') {
+	_global.pdfMake.addFontContainer(fontContainer);
+}
+
+if (typeof module !== 'undefined') {
+	module.exports = fontContainer;
+}

package/src/browser-extensions/virtual-fs-cjs.js

@@ -0,0 +1 @@
+module.exports = require('../virtual-fs').default;

package/src/columnCalculator.js

@@ -0,0 +1,154 @@
+import { isString } from './helpers/variableType';
+
+function buildColumnWidths(columns, availableWidth, offsetTotal = 0, tableNode) {
+	let autoColumns = [];
+	let autoMin = 0;
+	let autoMax = 0;
+	let starColumns = [];
+	let starMaxMin = 0;
+	let starMaxMax = 0;
+	let fixedColumns = [];
+	let initial_availableWidth = availableWidth;
+
+	columns.forEach(column => {
+		if (isAutoColumn(column)) {
+			autoColumns.push(column);
+			autoMin += column._minWidth;
+			autoMax += column._maxWidth;
+		} else if (isStarColumn(column)) {
+			starColumns.push(column);
+			starMaxMin = Math.max(starMaxMin, column._minWidth);
+			starMaxMax = Math.max(starMaxMax, column._maxWidth);
+		} else {
+			fixedColumns.push(column);
+		}
+	});
+
+	fixedColumns.forEach((col, colIndex) => {
+		// width specified as %
+		if (isString(col.width) && /\d+%/.test(col.width)) {
+			// 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;
+		} else {
+			col._calcWidth = col.width;
+		}
+
+		availableWidth -= col._calcWidth;
+	});
+
+	// http://www.freesoft.org/CIE/RFC/1942/18.htm
+	// http://www.w3.org/TR/CSS2/tables.html#width-layout
+	// http://dev.w3.org/csswg/css3-tables-algorithms/Overview.src.htm
+	let minW = autoMin + starMaxMin * starColumns.length;
+	let maxW = autoMax + starMaxMax * starColumns.length;
+	if (minW >= availableWidth) {
+		// case 1 - there's no way to fit all columns within available width
+		// that's actually pretty bad situation with PDF as we have no horizontal scroll
+		// no easy workaround (unless we decide, in the future, to split single words)
+		// currently we simply use minWidths for all columns
+		autoColumns.forEach(col => {
+			col._calcWidth = col._minWidth;
+		});
+
+		starColumns.forEach(col => {
+			col._calcWidth = starMaxMin; // starMaxMin already contains padding
+		});
+	} else {
+		if (maxW < availableWidth) {
+			// case 2 - we can fit rest of the table within available space
+			autoColumns.forEach(col => {
+				col._calcWidth = col._maxWidth;
+				availableWidth -= col._calcWidth;
+			});
+		} else {
+			// maxW is too large, but minW fits within available width
+			let W = availableWidth - minW;
+			let D = maxW - minW;
+
+			autoColumns.forEach(col => {
+				let d = col._maxWidth - col._minWidth;
+				col._calcWidth = col._minWidth + d * W / D;
+				availableWidth -= col._calcWidth;
+			});
+		}
+
+		if (starColumns.length > 0) {
+			let starSize = availableWidth / starColumns.length;
+
+			starColumns.forEach(col => {
+				col._calcWidth = starSize;
+			});
+		}
+	}
+}
+
+function isAutoColumn(column) {
+	return column.width === 'auto';
+}
+
+function isStarColumn(column) {
+	return column.width === null || column.width === undefined || column.width === '*' || column.width === 'star';
+}
+
+//TODO: refactor and reuse in measureTable
+function measureMinMax(columns) {
+	let result = { min: 0, max: 0 };
+	let maxStar = { min: 0, max: 0 };
+	let starCount = 0;
+
+	for (let i = 0, l = columns.length; i < l; i++) {
+		let c = columns[i];
+
+		if (isStarColumn(c)) {
+			maxStar.min = Math.max(maxStar.min, c._minWidth);
+			maxStar.max = Math.max(maxStar.max, c._maxWidth);
+			starCount++;
+		} else if (isAutoColumn(c)) {
+			result.min += c._minWidth;
+			result.max += c._maxWidth;
+		} else {
+			result.min += ((c.width !== undefined && c.width) || c._minWidth);
+			result.max += ((c.width !== undefined && c.width) || c._maxWidth);
+		}
+	}
+
+	if (starCount) {
+		result.min += starCount * maxStar.min;
+		result.max += starCount * maxStar.max;
+	}
+
+	return result;
+}
+
+/**
+ * Calculates column widths
+ */
+export default {
+	buildColumnWidths: buildColumnWidths,
+	measureMinMax: measureMinMax,
+	isAutoColumn: isAutoColumn,
+	isStarColumn: isStarColumn
+};

package/src/helpers/node.js

@@ -0,0 +1,134 @@
+import { isNumber, isString } from './variableType';
+
+function fontStringify(key, val) {
+	if (key === 'font') {
+		return 'font';
+	}
+	return val;
+}
+
+/**
+ * Convert node to readable string
+ *
+ * @param {object} node
+ * @returns {string}
+ */
+export function stringifyNode(node) {
+	return JSON.stringify(node, fontStringify);
+}
+
+/**
+ * @param {object} node
+ * @returns {?string}
+ */
+export function getNodeId(node) {
+	if (node.id) {
+		return node.id;
+	}
+
+	if (Array.isArray(node.text)) {
+		for (let n of node.text) {
+			let nodeId = getNodeId(n);
+			if (nodeId) {
+				return nodeId;
+			}
+		}
+	}
+
+	return null;
+}
+
+/**
+ * @param {object} node
+ * @param {object} styleStack object is instance of PDFDocument
+ * @returns {?Array}
+ */
+export function getNodeMargin(node, styleStack) {
+
+	function processSingleMargins(node, currentMargin, defaultMargin = 0) {
+		if (node.marginLeft !== undefined || node.marginTop !== undefined || node.marginRight !== undefined || node.marginBottom !== undefined) {
+			return [
+				node.marginLeft ?? currentMargin[0] ?? defaultMargin,
+				node.marginTop ?? currentMargin[1] ?? defaultMargin,
+				node.marginRight ?? currentMargin[2] ?? defaultMargin,
+				node.marginBottom ?? currentMargin[3] ?? defaultMargin
+			];
+		}
+		return currentMargin;
+	}
+
+	function flattenStyleArray(styleArray, styleStack, visited = new Set()) {
+		styleArray = Array.isArray(styleArray) ? styleArray : [styleArray];
+
+		// style is not valid array of strings
+		if (!styleArray.every(item => isString(item))) {
+			return {};
+		}
+
+		let flattenedStyles = {};
+		for (let index = 0; index < styleArray.length; index++) {
+			let styleName = styleArray[index];
+			let style = styleStack.styleDictionary[styleName];
+
+			// style not found
+			if (style === undefined) {
+				continue;
+			}
+
+			if (visited.has(styleName)) {
+				continue;
+			}
+
+			if (style.extends !== undefined) {
+				flattenedStyles = { ...flattenedStyles, ...flattenStyleArray(style.extends, styleStack, new Set([...visited, styleName])) };
+			}
+
+			if (style.margin !== undefined) {
+				flattenedStyles = { margin: convertMargin(style.margin) };
+				continue;
+			}
+
+			flattenedStyles = { margin: processSingleMargins(style, flattenedStyles.margin ?? {}, undefined) };
+		}
+
+		return flattenedStyles;
+	}
+
+	function convertMargin(margin) {
+		if (isNumber(margin)) {
+			margin = [margin, margin, margin, margin];
+		} else if (Array.isArray(margin)) {
+			if (margin.length === 2) {
+				margin = [margin[0], margin[1], margin[0], margin[1]];
+			}
+		}
+		return margin;
+	}
+
+	let margin = [undefined, undefined, undefined, undefined];
+
+	if (node.style) {
+		let styleArray = Array.isArray(node.style) ? node.style : [node.style];
+		let flattenedStyleArray = flattenStyleArray(styleArray, styleStack);
+
+		if (flattenedStyleArray) {
+			margin = processSingleMargins(flattenedStyleArray, margin);
+		}
+
+		if (flattenedStyleArray.margin) {
+			margin = convertMargin(flattenedStyleArray.margin);
+		}
+	}
+
+	margin = processSingleMargins(node, margin);
+
+	if (node.margin !== undefined) {
+		margin = convertMargin(node.margin);
+	}
+
+	if (margin[0] === undefined && margin[1] === undefined && margin[2] === undefined && margin[3] === undefined) {
+		return null;
+	}
+
+	return margin;
+}

package/src/helpers/tools.js

@@ -0,0 +1,44 @@
+export function pack(...args) {
+	let result = {};
+
+	for (let i = 0, l = args.length; i < l; i++) {
+		let obj = args[i];
+
+		if (obj) {
+			for (let key in obj) {
+				if (obj.hasOwnProperty(key)) {
+					result[key] = obj[key];
+				}
+			}
+		}
+	}
+
+	return result;
+}
+
+export function offsetVector(vector, x, y) {
+	switch (vector.type) {
+		case 'ellipse':
+		case 'rect':
+			vector.x += x;
+			vector.y += y;
+			break;
+		case 'line':
+			vector.x1 += x;
+			vector.x2 += x;
+			vector.y1 += y;
+			vector.y2 += y;
+			break;
+		case 'polyline':
+			for (let i = 0, l = vector.points.length; i < l; i++) {
+				vector.points[i].x += x;
+				vector.points[i].y += y;
+			}
+			break;
+	}
+}
+
+export function convertToDynamicContent(staticContent) {
+	return () => // copy to new object
+		JSON.parse(JSON.stringify(staticContent));
+}

package/src/helpers/variableType.js

@@ -0,0 +1,50 @@
+/**
+ * @param {any} variable
+ * @returns {boolean}
+ */
+export function isString(variable) {
+	return (typeof variable === 'string') || (variable instanceof String);
+}
+
+/**
+ * @param {any} variable
+ * @returns {boolean}
+ */
+export function isNumber(variable) {
+	return ((typeof variable === 'number') || (variable instanceof Number)) && !Number.isNaN(variable);
+}
+
+/**
+ * @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}
+ */
+export function isObject(variable) {
+	return (variable !== null) && !Array.isArray(variable) && !isString(variable) && !isNumber(variable) && (typeof variable === 'object');
+}
+
+/**
+ * @param {any} variable
+ * @returns {boolean}
+ */
+export function isEmptyObject(variable) {
+	return isObject(variable) && (Object.keys(variable).length === 0);
+}
+
+/**
+ * @param {any} variable
+ * @returns {boolean}
+ */
+export function isValue(variable) {
+	return (variable !== undefined) && (variable !== null);
+}