pdfmake 0.3.0-beta.18 → 0.3.0-beta.19

package/src/Printer.js

@@ -43,91 +43,83 @@ class PdfPrinter {
 	 * @param {object} options
 	 * @returns {Promise<PDFDocument>} resolved promise return a pdfkit document
 	 */
-	createPdfKitDocument(docDefinition, options = {}) {
-		return new Promise((resolve, reject) => {
-			this.resolveUrls(docDefinition).then(() => {
-				try {
-					docDefinition.version = docDefinition.version || '1.3';
-					docDefinition.subset = docDefinition.subset || undefined;
-					docDefinition.tagged = typeof docDefinition.tagged === 'boolean' ? docDefinition.tagged : false;
-					docDefinition.displayTitle = typeof docDefinition.displayTitle === 'boolean' ? docDefinition.displayTitle : false;
-					docDefinition.compress = typeof docDefinition.compress === 'boolean' ? docDefinition.compress : true;
-					docDefinition.images = docDefinition.images || {};
-					docDefinition.attachments = docDefinition.attachments || {};
-					docDefinition.pageMargins = isValue(docDefinition.pageMargins) ? docDefinition.pageMargins : 40;
-					docDefinition.patterns = docDefinition.patterns || {};
-
-					if (docDefinition.header && typeof docDefinition.header !== 'function') {
-						docDefinition.header = convertToDynamicContent(docDefinition.header);
-					}
+	async createPdfKitDocument(docDefinition, options = {}) {
+		await this.resolveUrls(docDefinition);
+
+		docDefinition.version = docDefinition.version || '1.3';
+		docDefinition.subset = docDefinition.subset || undefined;
+		docDefinition.tagged = typeof docDefinition.tagged === 'boolean' ? docDefinition.tagged : false;
+		docDefinition.displayTitle = typeof docDefinition.displayTitle === 'boolean' ? docDefinition.displayTitle : false;
+		docDefinition.compress = typeof docDefinition.compress === 'boolean' ? docDefinition.compress : true;
+		docDefinition.images = docDefinition.images || {};
+		docDefinition.attachments = docDefinition.attachments || {};
+		docDefinition.pageMargins = isValue(docDefinition.pageMargins) ? docDefinition.pageMargins : 40;
+		docDefinition.patterns = docDefinition.patterns || {};
+
+		if (docDefinition.header && typeof docDefinition.header !== 'function') {
+			docDefinition.header = convertToDynamicContent(docDefinition.header);
+		}
 
-					if (docDefinition.footer && typeof docDefinition.footer !== 'function') {
-						docDefinition.footer = convertToDynamicContent(docDefinition.footer);
-					}
+		if (docDefinition.footer && typeof docDefinition.footer !== 'function') {
+			docDefinition.footer = convertToDynamicContent(docDefinition.footer);
+		}
 
-					let pageSize = normalizePageSize(docDefinition.pageSize, docDefinition.pageOrientation);
-
-					let pdfOptions = {
-						size: [pageSize.width, pageSize.height],
-						pdfVersion: docDefinition.version,
-						subset: docDefinition.subset,
-						tagged: docDefinition.tagged,
-						displayTitle: docDefinition.displayTitle,
-						compress: docDefinition.compress,
-						userPassword: docDefinition.userPassword,
-						ownerPassword: docDefinition.ownerPassword,
-						permissions: docDefinition.permissions,
-						lang: docDefinition.language,
-						fontLayoutCache: typeof options.fontLayoutCache === 'boolean' ? options.fontLayoutCache : true,
-						bufferPages: options.bufferPages || false,
-						autoFirstPage: false,
-						info: createMetadata(docDefinition),
-						font: null
-					};
-
-					this.pdfKitDoc = new PDFDocument(this.fontDescriptors, docDefinition.images, docDefinition.patterns, docDefinition.attachments, pdfOptions, this.virtualfs);
-					embedFiles(docDefinition, this.pdfKitDoc);
-
-					const builder = new LayoutBuilder(pageSize, normalizePageMargin(docDefinition.pageMargins), new SVGMeasure());
-
-					builder.registerTableLayouts(tableLayouts);
-					if (options.tableLayouts) {
-						builder.registerTableLayouts(options.tableLayouts);
-					}
+		let pageSize = normalizePageSize(docDefinition.pageSize, docDefinition.pageOrientation);
+
+		let pdfOptions = {
+			size: [pageSize.width, pageSize.height],
+			pdfVersion: docDefinition.version,
+			subset: docDefinition.subset,
+			tagged: docDefinition.tagged,
+			displayTitle: docDefinition.displayTitle,
+			compress: docDefinition.compress,
+			userPassword: docDefinition.userPassword,
+			ownerPassword: docDefinition.ownerPassword,
+			permissions: docDefinition.permissions,
+			lang: docDefinition.language,
+			fontLayoutCache: typeof options.fontLayoutCache === 'boolean' ? options.fontLayoutCache : true,
+			bufferPages: options.bufferPages || false,
+			autoFirstPage: false,
+			info: createMetadata(docDefinition),
+			font: null
+		};
 
-					let pages = builder.layoutDocument(docDefinition.content, this.pdfKitDoc, docDefinition.styles || {}, docDefinition.defaultStyle || { fontSize: 12, font: 'Roboto' }, docDefinition.background, docDefinition.header, docDefinition.footer, docDefinition.watermark, docDefinition.pageBreakBefore);
-					let maxNumberPages = docDefinition.maxPagesNumber || -1;
-					if (isNumber(maxNumberPages) && maxNumberPages > -1) {
-						pages = pages.slice(0, maxNumberPages);
-					}
+		this.pdfKitDoc = new PDFDocument(this.fontDescriptors, docDefinition.images, docDefinition.patterns, docDefinition.attachments, pdfOptions, this.virtualfs);
+		embedFiles(docDefinition, this.pdfKitDoc);
 
-					// if pageSize.height is set to Infinity, calculate the actual height of the page that
-					// was laid out using the height of each of the items in the page.
-					if (pageSize.height === Infinity) {
-						let pageHeight = calculatePageHeight(pages, docDefinition.pageMargins);
-						pages.forEach(page => {
-							page.pageSize.height = pageHeight;
-						});
-					}
+		const builder = new LayoutBuilder(pageSize, normalizePageMargin(docDefinition.pageMargins), new SVGMeasure());
 
-					const renderer = new Renderer(this.pdfKitDoc, options.progressCallback);
-					renderer.renderPages(pages);
+		builder.registerTableLayouts(tableLayouts);
+		if (options.tableLayouts) {
+			builder.registerTableLayouts(options.tableLayouts);
+		}
 
-					resolve(this.pdfKitDoc);
-				} catch (e) {
-					reject(e);
-				}
-			}, result => {
-				reject(result);
+		let pages = builder.layoutDocument(docDefinition.content, this.pdfKitDoc, docDefinition.styles || {}, docDefinition.defaultStyle || { fontSize: 12, font: 'Roboto' }, docDefinition.background, docDefinition.header, docDefinition.footer, docDefinition.watermark, docDefinition.pageBreakBefore);
+		let maxNumberPages = docDefinition.maxPagesNumber || -1;
+		if (isNumber(maxNumberPages) && maxNumberPages > -1) {
+			pages = pages.slice(0, maxNumberPages);
+		}
+
+		// if pageSize.height is set to Infinity, calculate the actual height of the page that
+		// was laid out using the height of each of the items in the page.
+		if (pageSize.height === Infinity) {
+			let pageHeight = calculatePageHeight(pages, docDefinition.pageMargins);
+			pages.forEach(page => {
+				page.pageSize.height = pageHeight;
 			});
-		});
+		}
+
+		const renderer = new Renderer(this.pdfKitDoc, options.progressCallback);
+		renderer.renderPages(pages);
+
+		return this.pdfKitDoc;
 	}
 
 	/**
 	 * @param {object} docDefinition
 	 * @returns {Promise}
 	 */
-	resolveUrls(docDefinition) {
+	async resolveUrls(docDefinition) {
 		const getExtendedUrl = url => {
 			if (typeof url === 'object') {
 				return { url: url.url, headers: url.headers };
@@ -136,96 +128,90 @@ class PdfPrinter {
 			return { url: url, headers: {} };
 		};
 
-		return new Promise((resolve, reject) => {
-			if (this.urlResolver === null) {
-				resolve();
-			}
+		if (this.urlResolver === null) {
+			return;
+		}
 
-			for (let font in this.fontDescriptors) {
-				if (this.fontDescriptors.hasOwnProperty(font)) {
-					if (this.fontDescriptors[font].normal) {
-						if (Array.isArray(this.fontDescriptors[font].normal)) { // TrueType Collection
-							let url = getExtendedUrl(this.fontDescriptors[font].normal[0]);
-							this.urlResolver.resolve(url.url, url.headers);
-							this.fontDescriptors[font].normal[0] = url.url;
-						} else {
-							let url = getExtendedUrl(this.fontDescriptors[font].normal);
-							this.urlResolver.resolve(url.url, url.headers);
-							this.fontDescriptors[font].normal = url.url;
-						}
+		for (let font in this.fontDescriptors) {
+			if (this.fontDescriptors.hasOwnProperty(font)) {
+				if (this.fontDescriptors[font].normal) {
+					if (Array.isArray(this.fontDescriptors[font].normal)) { // TrueType Collection
+						let url = getExtendedUrl(this.fontDescriptors[font].normal[0]);
+						this.urlResolver.resolve(url.url, url.headers);
+						this.fontDescriptors[font].normal[0] = url.url;
+					} else {
+						let url = getExtendedUrl(this.fontDescriptors[font].normal);
+						this.urlResolver.resolve(url.url, url.headers);
+						this.fontDescriptors[font].normal = url.url;
 					}
-					if (this.fontDescriptors[font].bold) {
-						if (Array.isArray(this.fontDescriptors[font].bold)) { // TrueType Collection
-							let url = getExtendedUrl(this.fontDescriptors[font].bold[0]);
-							this.urlResolver.resolve(url.url, url.headers);
-							this.fontDescriptors[font].bold[0] = url.url;
-						} else {
-							let url = getExtendedUrl(this.fontDescriptors[font].bold);
-							this.urlResolver.resolve(url.url, url.headers);
-							this.fontDescriptors[font].bold = url.url;
-						}
+				}
+				if (this.fontDescriptors[font].bold) {
+					if (Array.isArray(this.fontDescriptors[font].bold)) { // TrueType Collection
+						let url = getExtendedUrl(this.fontDescriptors[font].bold[0]);
+						this.urlResolver.resolve(url.url, url.headers);
+						this.fontDescriptors[font].bold[0] = url.url;
+					} else {
+						let url = getExtendedUrl(this.fontDescriptors[font].bold);
+						this.urlResolver.resolve(url.url, url.headers);
+						this.fontDescriptors[font].bold = url.url;
 					}
-					if (this.fontDescriptors[font].italics) {
-						if (Array.isArray(this.fontDescriptors[font].italics)) { // TrueType Collection
-							let url = getExtendedUrl(this.fontDescriptors[font].italics[0]);
-							this.urlResolver.resolve(url.url, url.headers);
-							this.fontDescriptors[font].italics[0] = url.url;
-						} else {
-							let url = getExtendedUrl(this.fontDescriptors[font].italics);
-							this.urlResolver.resolve(url.url, url.headers);
-							this.fontDescriptors[font].italics = url.url;
-						}
+				}
+				if (this.fontDescriptors[font].italics) {
+					if (Array.isArray(this.fontDescriptors[font].italics)) { // TrueType Collection
+						let url = getExtendedUrl(this.fontDescriptors[font].italics[0]);
+						this.urlResolver.resolve(url.url, url.headers);
+						this.fontDescriptors[font].italics[0] = url.url;
+					} else {
+						let url = getExtendedUrl(this.fontDescriptors[font].italics);
+						this.urlResolver.resolve(url.url, url.headers);
+						this.fontDescriptors[font].italics = url.url;
 					}
-					if (this.fontDescriptors[font].bolditalics) {
-						if (Array.isArray(this.fontDescriptors[font].bolditalics)) { // TrueType Collection
-							let url = getExtendedUrl(this.fontDescriptors[font].bolditalics[0]);
-							this.urlResolver.resolve(url.url, url.headers);
-							this.fontDescriptors[font].bolditalics[0] = url.url;
-						} else {
-							let url = getExtendedUrl(this.fontDescriptors[font].bolditalics);
-							this.urlResolver.resolve(url.url, url.headers);
-							this.fontDescriptors[font].bolditalics = url.url;
-						}
+				}
+				if (this.fontDescriptors[font].bolditalics) {
+					if (Array.isArray(this.fontDescriptors[font].bolditalics)) { // TrueType Collection
+						let url = getExtendedUrl(this.fontDescriptors[font].bolditalics[0]);
+						this.urlResolver.resolve(url.url, url.headers);
+						this.fontDescriptors[font].bolditalics[0] = url.url;
+					} else {
+						let url = getExtendedUrl(this.fontDescriptors[font].bolditalics);
+						this.urlResolver.resolve(url.url, url.headers);
+						this.fontDescriptors[font].bolditalics = url.url;
 					}
 				}
 			}
+		}
 
-			if (docDefinition.images) {
-				for (let image in docDefinition.images) {
-					if (docDefinition.images.hasOwnProperty(image)) {
-						let url = getExtendedUrl(docDefinition.images[image]);
-						this.urlResolver.resolve(url.url, url.headers);
-						docDefinition.images[image] = url.url;
-					}
+		if (docDefinition.images) {
+			for (let image in docDefinition.images) {
+				if (docDefinition.images.hasOwnProperty(image)) {
+					let url = getExtendedUrl(docDefinition.images[image]);
+					this.urlResolver.resolve(url.url, url.headers);
+					docDefinition.images[image] = url.url;
 				}
 			}
+		}
 
-			if (docDefinition.attachments) {
-				for (let attachment in docDefinition.attachments) {
-					if (docDefinition.attachments.hasOwnProperty(attachment) && docDefinition.attachments[attachment].src) {
-						let url = getExtendedUrl(docDefinition.attachments[attachment].src);
-						this.urlResolver.resolve(url.url, url.headers);
-						docDefinition.attachments[attachment].src = url.url;
-					}
+		if (docDefinition.attachments) {
+			for (let attachment in docDefinition.attachments) {
+				if (docDefinition.attachments.hasOwnProperty(attachment) && docDefinition.attachments[attachment].src) {
+					let url = getExtendedUrl(docDefinition.attachments[attachment].src);
+					this.urlResolver.resolve(url.url, url.headers);
+					docDefinition.attachments[attachment].src = url.url;
 				}
 			}
+		}
 
-			if (docDefinition.files) {
-				for (let file in docDefinition.files) {
-					if (docDefinition.files.hasOwnProperty(file) && docDefinition.files[file].src) {
-						let url = getExtendedUrl(docDefinition.files[file].src);
-						this.urlResolver.resolve(url.url, url.headers);
-						docDefinition.files[file].src = url.url;
-					}
+		if (docDefinition.files) {
+			for (let file in docDefinition.files) {
+				if (docDefinition.files.hasOwnProperty(file) && docDefinition.files[file].src) {
+					let url = getExtendedUrl(docDefinition.files[file].src);
+					this.urlResolver.resolve(url.url, url.headers);
+					docDefinition.files[file].src = url.url;
 				}
 			}
+		}
 
-			this.urlResolver.resolved().then(() => {
-				resolve();
-			}, result => {
-				reject(result);
-			});
-		});
+		await this.urlResolver.resolved();
 	}
 }
 

package/src/TextBreaker.js

@@ -5,15 +5,34 @@ import StyleContextStack from './StyleContextStack';
 /**
  * @param {string} text
  * @param {boolean} noWrap
+ * @param {boolean} breakAll
  * @returns {Array}
  */
-const splitWords = (text, noWrap) => {
+const splitWords = (text, noWrap, breakAll = false) => {
 	let words = [];
+	if (text === undefined || text === null) {
+		text = '';
+	} else {
+		text = String(text);
+	}
 
 	if (noWrap) {
 		words.push({ text: text });
 		return words;
 	}
+	if (breakAll) {
+		return text.split('').map(c => {
+			if(c.match(/^\n$|^\r$/)) { // new line
+				return { text: '', lineEnd: true };
+			}
+			return { text: c };
+		});
+	}
+
+	if (text.length === 0) {
+		words.push({ text: '' });
+		return words;
+	}
 
 	let breaker = new LineBreaker(text);
 	let last = 0;
@@ -101,16 +120,16 @@ class TextBreaker {
 			let item = texts[i];
 			let style = null;
 			let words;
-
+			let breakAll = StyleContextStack.getStyleProperty(item || {}, styleContextStack, 'wordBreak', 'normal') === 'break-all';
 			let noWrap = StyleContextStack.getStyleProperty(item || {}, styleContextStack, 'noWrap', false);
 			if (isObject(item)) {
 				if (item._textRef && item._textRef._textNodeRef.text) {
 					item.text = item._textRef._textNodeRef.text;
 				}
-				words = splitWords(item.text, noWrap);
+				words = splitWords(item.text, noWrap, breakAll);
 				style = StyleContextStack.copyStyle(item);
 			} else {
-				words = splitWords(item, noWrap);
+				words = splitWords(item, noWrap, breakAll);
 			}
 
 			if (lastWord && words.length) {

package/src/URLResolver.js

@@ -1,46 +1,14 @@
-import http from 'http';
-import https from 'https';
-
-const MAX_REDIRECTS = 30;
-
-const fetchUrl = (url, headers = {}, redirectCount = 0) => {
-	if (redirectCount >= MAX_REDIRECTS) {
-		return new Promise((_, reject) => {
-			reject(new Error(`Too many redirects (limit: ${MAX_REDIRECTS})`));
-		});
+async function fetchUrl(url, headers = {}) {
+	try {
+		const response = await fetch(url, { headers });
+		if (!response.ok) {
+			throw new Error(`Failed to fetch (status code: ${response.status}, url: "${url}")`);
+		}
+		return await response.arrayBuffer();
+	} catch (error) {
+		throw new Error(`Network request failed (url: "${url}", error: ${error.message})`);
 	}
-	return new Promise((resolve, reject) => {
-		const parsedUrl = new URL(url);
-		const h = (parsedUrl.protocol === 'https:') ? https : http;
-		let options = {
-			headers: headers
-		};
-
-		h.get(url, options, res => {
-			if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) { // redirect url
-				res.resume();
-
-				fetchUrl(res.headers.location, {}, redirectCount + 1).then(buffer => {
-					resolve(buffer);
-				}, result => {
-					reject(result);
-				});
-				return;
-			}
-
-			const ok = res.statusCode >= 200 && res.statusCode < 300;
-			if (!ok) {
-				reject(new TypeError(`Failed to fetch (status code: ${res.statusCode}, url: "${url}")`));
-				res.resume();
-				return;
-			}
-
-			const chunks = [];
-			res.on('end', () => resolve(Buffer.concat(chunks)));
-			res.on('data', d => chunks.push(d));
-		}).on('error', reject);
-	});
-};
+}
 
 class URLResolver {
 	constructor(fs) {
@@ -49,38 +17,25 @@ class URLResolver {
 	}
 
 	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) {
-					if (this.fs.existsSync(url)) {
-						// url was downloaded earlier
-						resolve();
-					} else {
-						fetchUrl(url, headers).then(buffer => {
-							this.fs.writeFileSync(url, buffer);
-							resolve();
-						}, result => {
-							reject(result);
-						});
-					}
-				} else {
-					// cannot be resolved
-					resolve();
+		const resolveUrlInternal = async () => {
+			if (url.toLowerCase().startsWith('https://') || url.toLowerCase().startsWith('http://')) {
+				if (this.fs.existsSync(url)) {
+					return; // url was downloaded earlier
 				}
-			});
-		}
+				const buffer = await fetchUrl(url, headers);
+				this.fs.writeFileSync(url, buffer);
+			}
+			// else cannot be resolved
+		};
 
+		if (!this.resolving[url]) {
+			this.resolving[url] = resolveUrlInternal();
+		}
 		return this.resolving[url];
 	}
 
 	resolved() {
-		return new Promise((resolve, reject) => {
-			Promise.all(Object.values(this.resolving)).then(() => {
-				resolve();
-			}, result => {
-				reject(result);
-			});
-		});
+		return Promise.all(Object.values(this.resolving));
 	}
 
 }

package/src/browser-extensions/OutputDocumentBrowser.js

@@ -20,98 +20,60 @@ 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);
-			});
-		});
+	async getBlob() {
+		const buffer = await this.getBuffer();
+		return new Blob([buffer], { type: 'application/pdf' });
 	}
 
 	/**
 	 * @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);
-			});
-		});
+	async download(filename = 'file.pdf') {
+		const blob = await this.getBlob();
+		saveAs(blob, filename);
 	}
 
 	/**
 	 * @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;
+	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;
 
-					//
-					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);
+			/* temporarily disabled
+			if (win === window) {
+				return;
+			} else {
+				setTimeout(() => {
+					if (win.window === null) { // is closed by AdBlock
+						window.location.href = pdfUrl; // open in actual window
 					}
-					*/
-				} catch (e) {
-					win.close();
-					reject(e);
-				}
-			}, result => {
-				reject(result);
-			});
-		});
+					return;
+				}, 500);
+			}
+			*/
+		} finally {
+			win.close();
+		}
 	}
 
 	/**
 	 * @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);
-			});
-		});
+	async print(win = null) {
+		const stream = await this.getStream();
+		stream.setOpenActionAsPrint();
+		await this.open(win);
 	}
-
 }
 
 export default OutputDocumentBrowser;

package/src/browser-extensions/index.js

@@ -1,6 +1,6 @@
 import pdfmakeBase from '../base';
 import OutputDocumentBrowser from './OutputDocumentBrowser';
-import URLBrowserResolver from './URLBrowserResolver';
+import URLResolver from '../URLResolver';
 import fs from 'fs';
 import configurator from 'core-js/configurator';
 
@@ -21,7 +21,7 @@ let defaultClientFonts = {
 class pdfmake extends pdfmakeBase {
 	constructor() {
 		super();
-		this.urlResolver = () => new URLBrowserResolver(this.virtualfs);
+		this.urlResolver = () => new URLResolver(this.virtualfs);
 		this.fonts = defaultClientFonts;
 	}