pdfmake 0.2.13 → 0.3.0-beta.10

package/src/browser-extensions/OutputDocumentBrowser.js

@@ -0,0 +1,117 @@
+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>}
+	 */
+	getBlob() {
+		return new Promise((resolve, reject) => {
+			this.getBuffer().then(buffer => {
+				try {
+					let blob = new Blob([buffer], { type: 'application/pdf' });
+					resolve(blob);
+				} catch (e) {
+					reject(e);
+				}
+			}, result => {
+				reject(result);
+			});
+		});
+	}
+
+	/**
+	 * @param {string} filename
+	 * @returns {Promise}
+	 */
+	download(filename = 'file.pdf') {
+		return new Promise((resolve, reject) => {
+			this.getBlob().then(blob => {
+				try {
+					saveAs(blob, filename);
+					resolve();
+				} catch (e) {
+					reject(e);
+				}
+			}, result => {
+				reject(result);
+			});
+		});
+	}
+
+	/**
+	 * @param {Window} win
+	 * @returns {Promise}
+	 */
+	open(win = null) {
+		return new Promise((resolve, reject) => {
+			if (!win) {
+				win = openWindow();
+			}
+			this.getBlob().then(blob => {
+				try {
+					let urlCreator = window.URL || window.webkitURL;
+					let pdfUrl = urlCreator.createObjectURL(blob);
+					win.location.href = pdfUrl;
+
+					//
+					resolve();
+					/* temporarily disabled
+					if (win === window) {
+						resolve();
+					} else {
+						setTimeout(() => {
+							if (win.window === null) { // is closed by AdBlock
+								window.location.href = pdfUrl; // open in actual window
+							}
+							resolve();
+						}, 500);
+					}
+					*/
+				} catch (e) {
+					win.close();
+					reject(e);
+				}
+			}, result => {
+				reject(result);
+			});
+		});
+	}
+
+	/**
+	 * @param {Window} win
+	 * @returns {Promise}
+	 */
+	print(win = null) {
+		return new Promise((resolve, reject) => {
+			this.getStream().then(stream => {
+				stream.setOpenActionAsPrint();
+				return this.open(win).then(() => {
+					resolve();
+				}, result => {
+					reject(result);
+				});
+			}, result => {
+				reject(result);
+			});
+		});
+	}
+
+}
+
+export default OutputDocumentBrowser;

package/src/browser-extensions/URLBrowserResolver.js

@@ -1,49 +1,41 @@
-'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();
+const fetchUrl = (url, headers = {}) => {
+	return new Promise((resolve, reject) => {
+		const xhr = new XMLHttpRequest();
 		xhr.open('GET', url, true);
-		for (var headerName in headers) {
+		for (let headerName in headers) {
 			xhr.setRequestHeader(headerName, headers[headerName]);
 		}
 		xhr.responseType = 'arraybuffer';
 
-		xhr.onreadystatechange = function () {
+		xhr.onreadystatechange = () => {
 			if (xhr.readyState !== 4) {
 				return;
 			}
 
-			var ok = xhr.status >= 200 && xhr.status < 300;
+			const ok = xhr.status >= 200 && xhr.status < 300;
 			if (!ok) {
-				setTimeout(function () {
-					reject(new TypeError('Failed to fetch (url: "' + url + '")'));
+				setTimeout(() => {
+					reject(new TypeError(`Failed to fetch (url: "${url}")`));
 				}, 0);
 			}
 		};
 
-		xhr.onload = function () {
-			var ok = xhr.status >= 200 && xhr.status < 300;
+		xhr.onload = () => {
+			const 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 + '")'));
+		xhr.onerror = () => {
+			setTimeout(() => {
+				reject(new TypeError(`Network request failed (url: "${url}")`));
 			}, 0);
 		};
 
-		xhr.ontimeout = function () {
-			setTimeout(function () {
-				reject(new TypeError('Network request failed (url: "' + url + '")'));
+		xhr.ontimeout = () => {
+			setTimeout(() => {
+				reject(new TypeError(`Network request failed (url: "${url}")`));
 			}, 0);
 		};
 
@@ -51,46 +43,42 @@ var fetchUrl = function (url, headers) {
 	});
 };
 
-function URLBrowserResolver(fs) {
-	this.fs = fs;
-	this.resolving = {};
-}
+class URLBrowserResolver {
+	constructor(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(url, headers = {}) {
+		if (!this.resolving[url]) {
+			this.resolving[url] = new Promise((resolve, reject) => {
+				if (url.toLowerCase().indexOf('https://') === 0 || url.toLowerCase().indexOf('http://') === 0) {
+					fetchUrl(url, headers).then(buffer => {
+						this.fs.writeFileSync(url, buffer);
 						resolve();
-					}, function (result) {
+					}, result => {
 						reject(result);
 					});
+				} else {
+					// cannot be resolved
+					resolve();
 				}
-			} else {
-				// cannot be resolved
+			});
+		}
+
+		return this.resolving[url];
+	}
+
+	resolved() {
+		return new Promise((resolve, reject) => {
+			Promise.all(Object.values(this.resolving)).then(() => {
 				resolve();
-			}
+			}, result => {
+				reject(result);
+			});
 		});
 	}
 
-	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;
+export default URLBrowserResolver;

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 URLBrowserResolver from './URLBrowserResolver';
+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 URLBrowserResolver(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

@@ -1,329 +1 @@
-'use strict';
-
-var isFunction = require('../helpers').isFunction;
-var isUndefined = require('../helpers').isUndefined;
-var isNull = require('../helpers').isNull;
-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'
-	}
-};
-
-function Document(docDefinition, tableLayouts, fonts, vfs) {
-	this.docDefinition = docDefinition;
-	this.tableLayouts = tableLayouts || null;
-	this.fonts = fonts || defaultClientFonts;
-	this.vfs = vfs;
-}
-
-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 url = getExtendedUrl(this.docDefinition.images[image]);
-				urlResolver.resolve(url.url, url.headers);
-				this.docDefinition.images[image] = url.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 || global.pdfMake.tableLayouts,
-			fonts || global.pdfMake.fonts,
-			vfs || global.pdfMake.vfs
-		);
-	}
-};
+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/@foliojs-fork/pdfkit/js/data/Courier.afm', 'utf8'), encoding: 'utf8' },
+		'data/Courier-Bold.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/Courier-Bold.afm', 'utf8'), encoding: 'utf8' },
+		'data/Courier-Oblique.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/Courier-Oblique.afm', 'utf8'), encoding: 'utf8' },
+		'data/Courier-BoldOblique.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/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;
+}