@flowaccount/pdfmake 0.2.20-staging.2

package/src/3rd-party/svg-to-pdfkit.js

@@ -0,0 +1,3 @@
+var SVGtoPDF = require('./svg-to-pdfkit/source.js');
+
+module.exports = SVGtoPDF;

package/src/browser-extensions/URLBrowserResolver.js

@@ -0,0 +1,96 @@
+'use strict';
+
+// Internet Explorer polyfills
+if (typeof window !== 'undefined' && !window.Promise) {
+	require('core-js/features/promise');
+}
+require('core-js/es/object/values');
+
+var fetchUrl = function (url, headers) {
+	return new Promise(function (resolve, reject) {
+		var xhr = new XMLHttpRequest();
+		xhr.open('GET', url, true);
+		for (var headerName in headers) {
+			xhr.setRequestHeader(headerName, headers[headerName]);
+		}
+		xhr.responseType = 'arraybuffer';
+
+		xhr.onreadystatechange = function () {
+			if (xhr.readyState !== 4) {
+				return;
+			}
+
+			var ok = xhr.status >= 200 && xhr.status < 300;
+			if (!ok) {
+				setTimeout(function () {
+					reject(new TypeError('Failed to fetch (url: "' + url + '")'));
+				}, 0);
+			}
+		};
+
+		xhr.onload = function () {
+			var ok = xhr.status >= 200 && xhr.status < 300;
+			if (ok) {
+				resolve(xhr.response);
+			}
+		};
+
+		xhr.onerror = function () {
+			setTimeout(function () {
+				reject(new TypeError('Network request failed (url: "' + url + '")'));
+			}, 0);
+		};
+
+		xhr.ontimeout = function () {
+			setTimeout(function () {
+				reject(new TypeError('Network request failed (url: "' + url + '")'));
+			}, 0);
+		};
+
+		xhr.send();
+	});
+};
+
+function URLBrowserResolver(fs) {
+	this.fs = fs;
+	this.resolving = {};
+}
+
+URLBrowserResolver.prototype.resolve = function (url, headers) {
+	if (!this.resolving[url]) {
+		var _this = this;
+		this.resolving[url] = new Promise(function (resolve, reject) {
+			if (url.toLowerCase().indexOf('https://') === 0 || url.toLowerCase().indexOf('http://') === 0) {
+				if (_this.fs.existsSync(url)) {
+					// url was downloaded earlier
+					resolve();
+				} else {
+					fetchUrl(url, headers).then(function (buffer) {
+						_this.fs.writeFileSync(url, buffer);
+						resolve();
+					}, function (result) {
+						reject(result);
+					});
+				}
+			} else {
+				// cannot be resolved
+				resolve();
+			}
+		});
+	}
+
+	return this.resolving[url];
+};
+
+URLBrowserResolver.prototype.resolved = function () {
+	var _this = this;
+	return new Promise(function (resolve, reject) {
+		Promise.all(Object.values(_this.resolving)).then(function () {
+			resolve();
+		}, function (result) {
+			reject(result);
+		});
+	});
+};
+
+module.exports = URLBrowserResolver;

package/src/browser-extensions/pdfMake.js

@@ -0,0 +1,361 @@
+'use strict';
+
+var isFunction = require('../helpers').isFunction;
+var isUndefined = require('../helpers').isUndefined;
+//var isNull = require('../helpers').isNull;
+var pack = require('../helpers').pack;
+var FileSaver = require('file-saver');
+var saveAs = FileSaver.saveAs;
+
+var defaultClientFonts = {
+	Roboto: {
+		normal: 'Roboto-Regular.ttf',
+		bold: 'Roboto-Medium.ttf',
+		italics: 'Roboto-Italic.ttf',
+		bolditalics: 'Roboto-MediumItalic.ttf'
+	}
+};
+
+var globalVfs;
+var globalFonts;
+var globalTableLayouts;
+
+function Document(docDefinition, tableLayouts, fonts, vfs) {
+	this.docDefinition = docDefinition;
+	this.tableLayouts = tableLayouts || null;
+	this.fonts = fonts || defaultClientFonts;
+	this.vfs = vfs;
+	this._remoteImagesPrefetched = false;
+}
+
+function canCreatePdf() {
+	// Ensure the browser provides the level of support needed
+	try {
+		var arr = new Uint8Array(1);
+		var proto = { foo: function () { return 42; } };
+		Object.setPrototypeOf(proto, Uint8Array.prototype);
+		Object.setPrototypeOf(arr, proto);
+		return arr.foo() === 42;
+	} catch (e) {
+		return false;
+	}
+}
+
+Document.prototype._createDoc = function (options, cb) {
+	var getExtendedUrl = function (url) {
+		if (typeof url === 'object') {
+			return { url: url.url, headers: url.headers };
+		}
+
+		return { url: url, headers: {} };
+	};
+
+	options = options || {};
+	if (this.tableLayouts) {
+		options.tableLayouts = this.tableLayouts;
+	}
+
+	var PdfPrinter = require('../printer');
+
+	var printer = new PdfPrinter(this.fonts);
+	require('fs').bindFS(this.vfs); // bind virtual file system to file system
+
+	if (!isFunction(cb)) {
+		var doc = printer.createPdfKitDocument(this.docDefinition, options);
+
+		return doc;
+	}
+
+	var URLBrowserResolver = require('./URLBrowserResolver');
+	var urlResolver = new URLBrowserResolver(require('fs'));
+
+	for (var font in this.fonts) {
+		if (this.fonts.hasOwnProperty(font)) {
+			if (this.fonts[font].normal) {
+				if (Array.isArray(this.fonts[font].normal)) { // TrueType Collection
+					var url = getExtendedUrl(this.fonts[font].normal[0]);
+					urlResolver.resolve(url.url, url.headers);
+					this.fonts[font].normal[0] = url.url;
+				} else {
+					var url = getExtendedUrl(this.fonts[font].normal);
+					urlResolver.resolve(url.url, url.headers);
+					this.fonts[font].normal = url.url;
+				}
+			}
+			if (this.fonts[font].bold) {
+				if (Array.isArray(this.fonts[font].bold)) { // TrueType Collection
+					var url = getExtendedUrl(this.fonts[font].bold[0]);
+					urlResolver.resolve(url.url, url.headers);
+					this.fonts[font].bold[0] = url.url;
+				} else {
+					var url = getExtendedUrl(this.fonts[font].bold);
+					urlResolver.resolve(url.url, url.headers);
+					this.fonts[font].bold = url.url;
+				}
+			}
+			if (this.fonts[font].italics) {
+				if (Array.isArray(this.fonts[font].italics)) { // TrueType Collection
+					var url = getExtendedUrl(this.fonts[font].italics[0]);
+					urlResolver.resolve(url.url, url.headers);
+					this.fonts[font].italics[0] = url.url;
+				} else {
+					var url = getExtendedUrl(this.fonts[font].italics);
+					urlResolver.resolve(url.url, url.headers);
+					this.fonts[font].italics = url.url;
+				}
+			}
+			if (this.fonts[font].bolditalics) {
+				if (Array.isArray(this.fonts[font].bolditalics)) { // TrueType Collection
+					var url = getExtendedUrl(this.fonts[font].bolditalics[0]);
+					urlResolver.resolve(url.url, url.headers);
+					this.fonts[font].bolditalics[0] = url.url;
+				} else {
+					var url = getExtendedUrl(this.fonts[font].bolditalics);
+					urlResolver.resolve(url.url, url.headers);
+					this.fonts[font].bolditalics = url.url;
+				}
+			}
+		}
+	}
+
+	if (this.docDefinition.images) {
+		for (var image in this.docDefinition.images) {
+			if (this.docDefinition.images.hasOwnProperty(image)) {
+				var originalVal = this.docDefinition.images[image];
+				var urlImg = getExtendedUrl(originalVal);
+				if (typeof urlImg.url === 'string' && (urlImg.url.toLowerCase().startsWith('http://') || urlImg.url.toLowerCase().startsWith('https://'))) {
+					urlResolver.resolve(urlImg.url, urlImg.headers);
+					this.docDefinition.images[image] = urlImg.url; 
+				} else {
+					this.docDefinition.images[image] = urlImg.url;
+				}
+			}
+		}
+	}
+
+	var _this = this;
+
+	urlResolver.resolved().then(function () {
+		var doc = printer.createPdfKitDocument(_this.docDefinition, options);
+
+		cb(doc);
+	}, function (result) {
+		throw result;
+	});
+};
+
+Document.prototype._flushDoc = function (doc, callback) {
+	var chunks = [];
+	var result;
+
+	doc.on('readable', function () {
+		var chunk;
+		while ((chunk = doc.read(9007199254740991)) !== null) {
+			chunks.push(chunk);
+		}
+	});
+	doc.on('end', function () {
+		result = Buffer.concat(chunks);
+		callback(result, doc._pdfMakePages);
+	});
+	doc.end();
+};
+
+Document.prototype._getPages = function (options, cb) {
+	if (!cb) {
+		throw '_getPages is an async method and needs a callback argument';
+	}
+	var _this = this;
+
+	this._createDoc(options, function (doc) {
+		_this._flushDoc(doc, function (ignoreBuffer, pages) {
+			cb(pages);
+		});
+	});
+};
+
+Document.prototype._bufferToBlob = function (buffer) {
+	var blob;
+	try {
+		blob = new Blob([buffer], { type: 'application/pdf' });
+	} catch (e) {
+		// Old browser which can't handle it without making it an byte array (ie10)
+		if (e.name === 'InvalidStateError') {
+			var byteArray = new Uint8Array(buffer);
+			blob = new Blob([byteArray.buffer], { type: 'application/pdf' });
+		}
+	}
+
+	if (!blob) {
+		throw 'Could not generate blob';
+	}
+
+	return blob;
+};
+
+Document.prototype._openWindow = function () {
+	// we have to open the window immediately and store the reference
+	// otherwise popup blockers will stop us
+	var win = window.open('', '_blank');
+	if (win === null) {
+		throw 'Open PDF in new window blocked by browser';
+	}
+
+	return win;
+};
+
+Document.prototype._openPdf = function (options, win) {
+	if (!win) {
+		win = this._openWindow();
+	}
+	try {
+		this.getBlob(function (result) {
+			var urlCreator = window.URL || window.webkitURL;
+			var pdfUrl = urlCreator.createObjectURL(result);
+			win.location.href = pdfUrl;
+
+			/* temporarily disabled
+			if (win !== window) {
+				setTimeout(function () {
+					if (isNull(win.window)) { // is closed by AdBlock
+						window.location.href = pdfUrl; // open in actual window
+					}
+				}, 500);
+			}
+			*/
+		}, options);
+	} catch (e) {
+		win.close();
+		throw e;
+	}
+};
+
+Document.prototype.open = function (options, win) {
+	options = options || {};
+	options.autoPrint = false;
+	win = win || null;
+
+	this._openPdf(options, win);
+};
+
+
+Document.prototype.print = function (options, win) {
+	options = options || {};
+	options.autoPrint = true;
+	win = win || null;
+
+	this._openPdf(options, win);
+};
+
+/**
+ * download(defaultFileName = 'file.pdf', cb = null, options = {})
+ * or
+ * download(cb, options = {})
+ */
+Document.prototype.download = function (defaultFileName, cb, options) {
+	if (isFunction(defaultFileName)) {
+		if (!isUndefined(cb)) {
+			options = cb;
+		}
+		cb = defaultFileName;
+		defaultFileName = null;
+	}
+
+	defaultFileName = defaultFileName || 'file.pdf';
+	this.getBlob(function (result) {
+		saveAs(result, defaultFileName);
+
+		if (isFunction(cb)) {
+			cb();
+		}
+	}, options);
+};
+
+Document.prototype.getBase64 = function (cb, options) {
+	if (!cb) {
+		throw 'getBase64 is an async method and needs a callback argument';
+	}
+	this.getBuffer(function (buffer) {
+		cb(buffer.toString('base64'));
+	}, options);
+};
+
+Document.prototype.getDataUrl = function (cb, options) {
+	if (!cb) {
+		throw 'getDataUrl is an async method and needs a callback argument';
+	}
+	this.getBuffer(function (buffer) {
+		cb('data:application/pdf;base64,' + buffer.toString('base64'));
+	}, options);
+};
+
+Document.prototype.getBlob = function (cb, options) {
+	if (!cb) {
+		throw 'getBlob is an async method and needs a callback argument';
+	}
+	var that = this;
+	this.getBuffer(function (result) {
+		var blob = that._bufferToBlob(result);
+		cb(blob);
+	}, options);
+};
+
+Document.prototype.getBuffer = function (cb, options) {
+	if (!cb) {
+		throw 'getBuffer is an async method and needs a callback argument';
+	}
+
+	var _this = this;
+
+	this._createDoc(options, function (doc) {
+		_this._flushDoc(doc, function (buffer) {
+			cb(buffer);
+		});
+	});
+};
+
+Document.prototype.getStream = function (options, cb) {
+	if (!isFunction(cb)) {
+		var doc = this._createDoc(options);
+		return doc;
+	}
+
+	this._createDoc(options, function (doc) {
+		cb(doc);
+	});
+};
+
+module.exports = {
+	createPdf: function (docDefinition, tableLayouts, fonts, vfs) {
+		if (!canCreatePdf()) {
+			throw 'Your browser does not provide the level of support needed';
+		}
+		return new Document(
+			docDefinition,
+			tableLayouts || globalTableLayouts || global.pdfMake.tableLayouts,
+			fonts || globalFonts || global.pdfMake.fonts,
+			vfs || globalVfs || global.pdfMake.vfs
+		);
+	},
+	addVirtualFileSystem: function (vfs) {
+		globalVfs = vfs;
+	},
+	addFonts: function (fonts) {
+		globalFonts = pack(globalFonts, fonts);
+	},
+	setFonts: function (fonts) {
+		globalFonts = fonts;
+	},
+	clearFonts: function () {
+		globalFonts = undefined;
+	},
+	addTableLayouts: function (tableLayouts) {
+		globalTableLayouts = pack(globalTableLayouts, tableLayouts);
+	},
+	setTableLayouts: function (tableLayouts) {
+		globalTableLayouts = tableLayouts;
+	},
+	clearTableLayouts: function () {
+		globalTableLayouts = undefined;
+	}
+};

package/src/browser-extensions/tokenizer-shim.js

@@ -0,0 +1,16 @@
+// Browser shim for @flowaccount/node-icu-tokenizer
+// The original package depends on native bindings resolved via 'bindings' which
+// pulls in Node core modules (path) not polyfilled by default in webpack 5.
+// For browser builds we degrade gracefully: tokenize() will produce a single
+// token spanning the whole input so existing logic that iterates tokens still works.
+
+'use strict';
+
+class BrowserTokenizer {
+	tokenize(str) {
+		if (typeof str !== 'string') { return []; }
+		return [ { token: str, type: 'TEXT', start: 0, end: str.length } ];
+	}
+}
+
+module.exports = BrowserTokenizer;

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

@@ -0,0 +1,55 @@
+'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();

package/src/columnCalculator.js

@@ -0,0 +1,157 @@
+'use strict';
+
+var isString = require('./helpers').isString;
+
+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) {
+		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(function (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;
+			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);
+				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);
+				}
+			}
+			var 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
+	var minW = autoMin + starMaxMin * starColumns.length;
+	var 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) {
+			col._calcWidth = col._minWidth;
+		});
+
+		starColumns.forEach(function (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) {
+				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;
+
+			autoColumns.forEach(function (col) {
+				var d = col._maxWidth - col._minWidth;
+				col._calcWidth = col._minWidth + d * W / D;
+				availableWidth -= col._calcWidth;
+			});
+		}
+
+		if (starColumns.length > 0) {
+			var starSize = availableWidth / starColumns.length;
+
+			starColumns.forEach(function (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) {
+	var result = { min: 0, max: 0 };
+
+	var maxStar = { min: 0, max: 0 };
+	var starCount = 0;
+
+	for (var i = 0, l = columns.length; i < l; i++) {
+		var 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
+ * @private
+ */
+module.exports = {
+	buildColumnWidths: buildColumnWidths,
+	measureMinMax: measureMinMax,
+	isAutoColumn: isAutoColumn,
+	isStarColumn: isStarColumn
+};