pdfmake 0.2.1 → 0.3.0-beta.1

package/src/columnCalculator.js

@@ -1,17 +1,16 @@
-'use strict';
-
-var isString = require('./helpers').isString;
+import { isString } from './helpers/variableType';
 
 function buildColumnWidths(columns, availableWidth) {
-	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,7 +24,7 @@ function buildColumnWidths(columns, availableWidth) {
 		}
 	});
 
-	fixedColumns.forEach(function (col) {
+	fixedColumns.forEach(col => {
 		// width specified as %
 		if (isString(col.width) && /\d+%/.test(col.width)) {
 			col.width = parseFloat(col.width) * initial_availableWidth / 100;
@@ -42,43 +41,43 @@ function buildColumnWidths(columns, availableWidth) {
 	// 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;
 			});
 		}
@@ -95,13 +94,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);
@@ -126,9 +124,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,39 @@
+/**
+ * @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 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;
@@ -784,6 +789,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
+};

package/src/virtual-fs.js

@@ -0,0 +1,66 @@
+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;
+	}
+
+}
+
+export default new VirtualFileSystem();

package/standard-fonts/Courier.js

@@ -0,0 +1,8 @@
+module.exports = {
+	Courier: {
+		normal: 'Courier',
+		bold: 'Courier-Bold',
+		italics: 'Courier-Oblique',
+		bolditalics: 'Courier-BoldOblique'
+	}
+};

package/standard-fonts/Helvetica.js

@@ -0,0 +1,9 @@
+module.exports = {
+	Helvetica: {
+		normal: 'Helvetica',
+		bold: 'Helvetica-Bold',
+		italics: 'Helvetica-Oblique',
+		bolditalics: 'Helvetica-BoldOblique'
+	}
+};
+

package/standard-fonts/Symbol.js

@@ -0,0 +1,5 @@
+module.exports = {
+	Symbol: {
+		normal: 'Symbol'
+	}
+};

package/standard-fonts/Times.js

@@ -0,0 +1,8 @@
+module.exports = {
+	Times: {
+		normal: 'Times-Roman',
+		bold: 'Times-Bold',
+		italics: 'Times-Italic',
+		bolditalics: 'Times-BoldItalic'
+	}
+};

package/standard-fonts/ZapfDingbats.js

@@ -0,0 +1,5 @@
+module.exports = {
+	ZapfDingbats: {
+		normal: 'ZapfDingbats'
+	}
+};

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

@@ -1,55 +0,0 @@
-'use strict';
-
-function VirtualFileSystem() {
-	this.fileSystem = {};
-	this.dataSystem = {};
-}
-
-VirtualFileSystem.prototype.existsSync = function (filename) {
-	filename = fixFilename(filename);
-	return typeof this.fileSystem[filename] !== 'undefined'
-		|| typeof this.dataSystem[filename] !== 'undefined';
-}
-
-VirtualFileSystem.prototype.readFileSync = function (filename, options) {
-	filename = fixFilename(filename);
-
-	var dataContent = this.dataSystem[filename];
-	if (typeof dataContent === 'string' && options === 'utf8') {
-		return dataContent;
-	}
-
-	if (dataContent) {
-		return new Buffer(dataContent, typeof dataContent === 'string' ? 'base64' : undefined);
-	}
-
-	var content = this.fileSystem[filename];
-	if (content) {
-		return content;
-	}
-
-	throw 'File \'' + filename + '\' not found in virtual file system';
-};
-
-VirtualFileSystem.prototype.writeFileSync = function (filename, content) {
-	this.fileSystem[fixFilename(filename)] = content;
-};
-
-VirtualFileSystem.prototype.bindFS = function (data) {
-	this.dataSystem = data || {};
-};
-
-
-function fixFilename(filename) {
-	if (filename.indexOf(__dirname) === 0) {
-		filename = filename.substring(__dirname.length);
-	}
-
-	if (filename.indexOf('/') === 0) {
-		filename = filename.substring(1);
-	}
-
-	return filename;
-}
-
-module.exports = new VirtualFileSystem();