pdfmake 0.2.13 → 0.3.0-beta.10

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/@foliojs-fork/pdfkit/js/data/Helvetica.afm', 'utf8'), encoding: 'utf8' },
+		'data/Helvetica-Bold.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/Helvetica-Bold.afm', 'utf8'), encoding: 'utf8' },
+		'data/Helvetica-Oblique.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/Helvetica-Oblique.afm', 'utf8'), encoding: 'utf8' },
+		'data/Helvetica-BoldOblique.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/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/@foliojs-fork/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/@foliojs-fork/pdfkit/js/data/Times-Roman.afm', 'utf8'), encoding: 'utf8' },
+		'data/Times-Bold.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/Times-Bold.afm', 'utf8'), encoding: 'utf8' },
+		'data/Times-Italic.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/Times-Italic.afm', 'utf8'), encoding: 'utf8' },
+		'data/Times-BoldItalic.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/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/@foliojs-fork/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

@@ -1,17 +1,16 @@
-'use strict';
-
-var isString = require('./helpers').isString;
+import { isString } from './helpers/variableType';
 
 function buildColumnWidths(columns, availableWidth, offsetTotal = 0, tableNode) {
-	var autoColumns = [],
-		autoMin = 0, autoMax = 0,
-		starColumns = [],
-		starMaxMin = 0,
-		starMaxMax = 0,
-		fixedColumns = [],
-		initial_availableWidth = availableWidth;
-
-	columns.forEach(function (column) {
+	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;
@@ -25,16 +24,16 @@ function buildColumnWidths(columns, availableWidth, offsetTotal = 0, tableNode)
 		}
 	});
 
-	fixedColumns.forEach(function (col, colIndex) {
+	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
-			var reservedWidth = 0;
+			let 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);
+				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);
@@ -48,7 +47,7 @@ function buildColumnWidths(columns, availableWidth, offsetTotal = 0, tableNode)
 					reservedWidth = paddingLeft + paddingRight + (borderLeft / 2) + (borderRight / 2);
 				}
 			}
-			var totalAvailableWidth = initial_availableWidth + offsetTotal;
+			const totalAvailableWidth = initial_availableWidth + offsetTotal;
 			col.width = (parseFloat(col.width) * totalAvailableWidth / 100) - reservedWidth;
 		}
 		if (col.width < (col._minWidth) && col.elasticWidth) {
@@ -63,43 +62,43 @@ function buildColumnWidths(columns, availableWidth, offsetTotal = 0, tableNode)
 	// 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
-	var minW = autoMin + starMaxMin * starColumns.length;
-	var maxW = autoMax + starMaxMax * starColumns.length;
+	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(function (col) {
+		autoColumns.forEach(col => {
 			col._calcWidth = col._minWidth;
 		});
 
-		starColumns.forEach(function (col) {
+		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(function (col) {
+			autoColumns.forEach(col => {
 				col._calcWidth = col._maxWidth;
 				availableWidth -= col._calcWidth;
 			});
 		} else {
 			// maxW is too large, but minW fits within available width
-			var W = availableWidth - minW;
-			var D = maxW - minW;
+			let W = availableWidth - minW;
+			let D = maxW - minW;
 
-			autoColumns.forEach(function (col) {
-				var d = col._maxWidth - col._minWidth;
+			autoColumns.forEach(col => {
+				let d = col._maxWidth - col._minWidth;
 				col._calcWidth = col._minWidth + d * W / D;
 				availableWidth -= col._calcWidth;
 			});
 		}
 
 		if (starColumns.length > 0) {
-			var starSize = availableWidth / starColumns.length;
+			let starSize = availableWidth / starColumns.length;
 
-			starColumns.forEach(function (col) {
+			starColumns.forEach(col => {
 				col._calcWidth = starSize;
 			});
 		}
@@ -116,13 +115,12 @@ function isStarColumn(column) {
 
 //TODO: refactor and reuse in measureTable
 function measureMinMax(columns) {
-	var result = { min: 0, max: 0 };
-
-	var maxStar = { min: 0, max: 0 };
-	var starCount = 0;
+	let result = { min: 0, max: 0 };
+	let maxStar = { min: 0, max: 0 };
+	let starCount = 0;
 
-	for (var i = 0, l = columns.length; i < l; i++) {
-		var c = columns[i];
+	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);
@@ -147,9 +145,8 @@ function measureMinMax(columns) {
 
 /**
  * Calculates column widths
- * @private
  */
-module.exports = {
+export default {
 	buildColumnWidths: buildColumnWidths,
 	measureMinMax: measureMinMax,
 	isAutoColumn: isAutoColumn,

package/src/helpers/node.js

@@ -0,0 +1,110 @@
+import { isNumber } 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) {
+		if (node.marginLeft || node.marginTop || node.marginRight || node.marginBottom) {
+			return [
+				node.marginLeft || currentMargin[0] || 0,
+				node.marginTop || currentMargin[1] || 0,
+				node.marginRight || currentMargin[2] || 0,
+				node.marginBottom || currentMargin[3] || 0
+			];
+		}
+		return currentMargin;
+	}
+
+	function flattenStyleArray(styleArray, styleStack) {
+		let flattenedStyles = {};
+		for (let i = styleArray.length - 1; i >= 0; i--) {
+			let styleName = styleArray[i];
+			let style = styleStack.styleDictionary[styleName];
+			for (let key in style) {
+				if (style.hasOwnProperty(key)) {
+					flattenedStyles[key] = style[key];
+				}
+			}
+		}
+		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) {
+		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,39 @@
+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;
+	}
+}

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);
+}
+
+/**
+ * @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);
+}

package/src/index.js

@@ -0,0 +1,16 @@
+const pdfmakeBase = require('./base').default;
+const OutputDocumentServer = require('./OutputDocumentServer').default;
+const URLResolver = require('./URLResolver').default;
+
+class pdfmake extends pdfmakeBase {
+	constructor() {
+		super();
+		this.urlResolver = new URLResolver(this.virtualfs);
+	}
+
+	_transformToDocument(doc) {
+		return new OutputDocumentServer(doc);
+	}
+}
+
+module.exports = new pdfmake();

package/src/qrEnc.js

@@ -1,5 +1,6 @@
 /*eslint no-unused-vars: ["error", {"args": "none"}]*/
 /*eslint no-redeclare: "off"*/
+/*eslint no-throw-literal: "off"*/
 
 'use strict';
 /* qr.js -- QR code generator in Javascript (revision 2011-01-19)
@@ -355,7 +356,7 @@ var calculateecc = function (poly, genpoly) {
 	var polylen = poly.length, genpolylen = genpoly.length;
 	for (var i = 0; i < genpolylen; ++i)
 		modulus.push(0);
-	for (var i = 0; i < polylen; ) {
+	for (var i = 0; i < polylen;) {
 		var quotient = GF256_INVMAP[modulus[i++]];
 		if (quotient >= 0) {
 			for (var j = 0; j < genpolylen; ++j) {
@@ -483,7 +484,7 @@ var makebasematrix = function (ver) {
 		}
 	}
 
-	return {matrix: matrix, reserved: reserved};
+	return { matrix: matrix, reserved: reserved };
 };
 
 // fills the data portion (i.e. unmarked in reserved) of the matrix with given
@@ -590,7 +591,7 @@ var evaluatematrix = function (matrix) {
 
 		// evaluate the current row
 		groups = [0]; // the first empty group of white
-		for (var j = 0; j < n; ) {
+		for (var j = 0; j < n;) {
 			var k;
 			for (k = 0; j < n && row[j]; ++k)
 				++j;
@@ -603,7 +604,7 @@ var evaluatematrix = function (matrix) {
 
 		// evaluate the current column
 		groups = [0];
-		for (var j = 0; j < n; ) {
+		for (var j = 0; j < n;) {
 			var k;
 			for (k = 0; j < n && matrix[j][i]; ++k)
 				++j;
@@ -677,10 +678,14 @@ var generate = function (data, ver, mode, ecclevel, mask) {
 //
 
 function generateFrame(data, options) {
-	var MODES = {'numeric': MODE_NUMERIC, 'alphanumeric': MODE_ALPHANUMERIC,
-		'octet': MODE_OCTET};
-	var ECCLEVELS = {'L': ECCLEVEL_L, 'M': ECCLEVEL_M, 'Q': ECCLEVEL_Q,
-		'H': ECCLEVEL_H};
+	var MODES = {
+		'numeric': MODE_NUMERIC, 'alphanumeric': MODE_ALPHANUMERIC,
+		'octet': MODE_OCTET
+	};
+	var ECCLEVELS = {
+		'L': ECCLEVEL_L, 'M': ECCLEVEL_M, 'Q': ECCLEVEL_Q,
+		'H': ECCLEVEL_H
+	};
 
 	options = options || {};
 	var ver = options.version || -1;
@@ -786,6 +791,6 @@ function measure(node) {
 	return node;
 }
 
-module.exports = {
+export default {
 	measure: measure
-};
+};

package/src/standardPageSizes.js

@@ -1,6 +1,4 @@
-'use strict';
-
-module.exports = {
+export default {
 	'4A0': [4767.87, 6740.79],
 	'2A0': [3370.39, 4767.87],
 	A0: [2383.94, 3370.39],

package/src/tableLayouts.js

@@ -0,0 +1,100 @@
+/*eslint no-unused-vars: ["error", {"args": "none"}]*/
+
+export {
+	tableLayouts,
+	defaultTableLayout
+};
+
+const 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 = {
+	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
+};