pdfmake 0.3.6 → 0.3.8

package/src/Printer.js

@@ -13,11 +13,13 @@ class PdfPrinter {
 	 * @param {object} fontDescriptors font definition dictionary
 	 * @param {object} virtualfs
 	 * @param {object} urlResolver
+	 * @param {(path: string) => boolean} localAccessPolicy
 	 */
-	constructor(fontDescriptors, virtualfs, urlResolver) {
+	constructor(fontDescriptors, virtualfs, urlResolver, localAccessPolicy) {
 		this.fontDescriptors = fontDescriptors;
 		this.virtualfs = virtualfs;
 		this.urlResolver = urlResolver;
+		this.localAccessPolicy = localAccessPolicy;
 	}
 
 	/**
@@ -69,7 +71,7 @@ class PdfPrinter {
 			font: null
 		};
 
-		this.pdfKitDoc = new PDFDocument(this.fontDescriptors, docDefinition.images, docDefinition.patterns, docDefinition.attachments, pdfOptions, this.virtualfs);
+		this.pdfKitDoc = new PDFDocument(this.fontDescriptors, docDefinition.images, docDefinition.patterns, docDefinition.attachments, pdfOptions, this.virtualfs, this.localAccessPolicy);
 		embedFiles(docDefinition, this.pdfKitDoc);
 
 		const builder = new LayoutBuilder(pageSize, normalizePageMargin(docDefinition.pageMargins), new SVGMeasure());

package/src/Renderer.js

@@ -188,7 +188,7 @@ class Renderer {
 
 			let opacity = isNumber(inline.opacity) ? inline.opacity : 1;
 			this.pdfDocument.opacity(opacity);
-			this.pdfDocument.fill(inline.color || 'black');
+			this.pdfDocument.fill(this.pdfDocument.resolveColor(inline.color, 'black'));
 
 			this.pdfDocument._font = inline.font;
 			this.pdfDocument.fontSize(inline.fontSize);
@@ -287,14 +287,14 @@ class Renderer {
 		let strokeOpacity = isNumber(vector.strokeOpacity) ? vector.strokeOpacity : 1;
 
 		if (vector.color && vector.lineColor) {
-			this.pdfDocument.fillColor(vector.color, fillOpacity);
-			this.pdfDocument.strokeColor(vector.lineColor, strokeOpacity);
+			this.pdfDocument.fillColor(this.pdfDocument.resolveColor(vector.color, 'black'), fillOpacity);
+			this.pdfDocument.strokeColor(this.pdfDocument.resolveColor(vector.lineColor, 'black'), strokeOpacity);
 			this.pdfDocument.fillAndStroke();
 		} else if (vector.color) {
-			this.pdfDocument.fillColor(vector.color, fillOpacity);
+			this.pdfDocument.fillColor(this.pdfDocument.resolveColor(vector.color, 'black'), fillOpacity);
 			this.pdfDocument.fill();
 		} else {
-			this.pdfDocument.strokeColor(vector.lineColor || 'black', strokeOpacity);
+			this.pdfDocument.strokeColor(this.pdfDocument.resolveColor(vector.lineColor, 'black'), strokeOpacity);
 			this.pdfDocument.stroke();
 		}
 	}
@@ -436,7 +436,7 @@ class Renderer {
 	renderWatermark(page) {
 		let watermark = page.watermark;
 
-		this.pdfDocument.fill(watermark.color);
+		this.pdfDocument.fill(this.pdfDocument.resolveColor(watermark.color, 'black'));
 		this.pdfDocument.opacity(watermark.opacity);
 
 		this.pdfDocument.save();

package/src/TableProcessor.js

@@ -1,9 +1,20 @@
 import ColumnCalculator from './columnCalculator';
 import { isNumber, isPositiveInteger } from './helpers/variableType';
 
+const PAGE_BREAK_VALUES = new Set(['before', 'beforeOdd', 'beforeEven', 'after', 'afterOdd', 'afterEven']);
+
+const hasExplicitPageBreak = cell => {
+	if (!cell || typeof cell !== 'object') {
+		return false;
+	}
+
+	return PAGE_BREAK_VALUES.has(cell.pageBreak);
+};
+
 class TableProcessor {
 	constructor(tableNode) {
 		this.tableNode = tableNode;
+		this._isCurrentRowUnbreakable = false;
 	}
 
 	beginTable(writer) {
@@ -163,7 +174,11 @@ class TableProcessor {
 
 		this.rowTopPageY = writer.context().y + this.rowPaddingTop;
 
-		if (this.dontBreakRows && rowIndex > 0) {
+		const rowCells = this.tableNode.table.body[rowIndex] || [];
+		const rowHasPageBreak = rowCells.some(hasExplicitPageBreak);
+		this._isCurrentRowUnbreakable = this.dontBreakRows && rowIndex > 0 && !rowHasPageBreak;
+
+		if (this._isCurrentRowUnbreakable) {
 			writer.beginUnbreakableBlock();
 		}
 		this.rowTopY = writer.context().y;
@@ -589,7 +604,9 @@ class TableProcessor {
 			this.headerRepeatable = writer.currentBlockToRepeatable();
 		}
 
-		if (this.dontBreakRows) {
+		const shouldCommitCurrentRowUnbreakable = this.dontBreakRows && (rowIndex === 0 || this._isCurrentRowUnbreakable);
+
+		if (shouldCommitCurrentRowUnbreakable) {
 			const pageChangedCallback = () => {
 				if (rowIndex > 0 && !this.headerRows && this.layout.hLineWhenBroken !== false) {
 					// Draw the top border of the row after a page break
@@ -604,6 +621,8 @@ class TableProcessor {
 			writer.removeListener('pageChanged', pageChangedCallback);
 		}
 
+		this._isCurrentRowUnbreakable = false;
+
 		if (this.headerRepeatable && (rowIndex === (this.rowsWithoutPageBreak - 1) || rowIndex === this.tableNode.table.body.length - 1)) {
 			writer.commitUnbreakableBlock();
 			writer.pushToRepeatables(this.headerRepeatable);

package/src/TextDecorator.js

@@ -1,6 +1,6 @@
 import { isNumber } from './helpers/variableType';
 
-const groupDecorations = line => {
+const groupDecorations = (line, pdfDocument) => {
 	let groups = [];
 	let currentGroup = null;
 	for (let i = 0, l = line.inlines.length; i < l; i++) {
@@ -13,7 +13,7 @@ const groupDecorations = line => {
 		if (!Array.isArray(decoration)) {
 			decoration = [decoration];
 		}
-		let color = inline.decorationColor || inline.color || 'black';
+		let color = pdfDocument.resolveColor(pdfDocument.resolveColor(inline.decorationColor, inline.color), 'black');
 		let style = inline.decorationStyle || 'solid';
 		let thickness = isNumber(inline.decorationThickness) ? inline.decorationThickness : null;
 		for (let ii = 0, ll = decoration.length; ii < ll; ii++) {
@@ -49,11 +49,12 @@ class TextDecorator {
 		let height = line.getHeight();
 		for (let i = 0, l = line.inlines.length; i < l; i++) {
 			let inline = line.inlines[i];
-			if (!inline.background) {
+
+			let color = this.pdfDocument.resolveColor(inline.background, undefined);
+			if (!color) {
 				continue;
 			}
 
-			let color = inline.background;
 			let patternColor = this.pdfDocument.providePattern(inline.background);
 			if (patternColor !== null) {
 				color = patternColor;
@@ -67,7 +68,7 @@ class TextDecorator {
 	}
 
 	drawDecorations(line, x, y) {
-		let groups = groupDecorations(line);
+		let groups = groupDecorations(line, this.pdfDocument);
 		for (let i = 0, l = groups.length; i < l; i++) {
 			this._drawDecoration(groups[i], x, y);
 		}

package/src/URLResolver.js

@@ -1,13 +1,48 @@
-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}")`);
+
+const MAX_REDIRECTS = 30;
+
+/**
+ * @param {string} url
+ * @param {object} headers
+ * @param {(url: string) => boolean} urlAccessPolicy
+ * @returns {Promise<Response>}
+ */
+async function fetchUrl(url, headers = {}, urlAccessPolicy) {
+	for (let i = 0; i <= MAX_REDIRECTS; i++) {
+		if ((typeof urlAccessPolicy !== 'undefined') && (urlAccessPolicy(url) !== true)) {
+			throw new Error(`Access to URL denied by resource access policy: ${url}`);
+		}
+
+		try {
+			let response = await fetch(url, { headers, redirect: 'manual' });
+
+			// redirect url
+			if (response.status >= 300 && response.status < 400) {
+				let location = response.headers.get('location');
+				if (!location) {
+					throw new Error('Redirect response missing Location header');
+				}
+				url = new URL(location, url).href;
+				continue;
+			}
+
+			// browsers do not support redirect: 'manual'
+			if (response.type === 'opaqueredirect') {
+				response = await fetch(url, {headers});
+			}
+
+			if (!response.ok) {
+				throw new Error(`Failed to fetch (status code: ${response.status})`);
+			}
+
+			return response;
+
+		} catch (error) {
+			throw new Error(`Network request failed (url: "${url}", error: ${error.message})`, {cause: error});
 		}
-		return await response.arrayBuffer();
-	} catch (error) {
-		throw new Error(`Network request failed (url: "${url}", error: ${error.message})`, { cause: error });
 	}
+
+	throw new Error(`Network request failed (url: "${url}", error: Too many redirects)`);
 }
 
 class URLResolver {
@@ -31,11 +66,16 @@ class URLResolver {
 					return; // url was downloaded earlier
 				}
 
-				if ((typeof this.urlAccessPolicy !== 'undefined') && (this.urlAccessPolicy(url) !== true)) {
-					throw new Error(`Access to URL denied by resource access policy: ${url}`);
+				const response = await fetchUrl(url, headers, this.urlAccessPolicy);
+
+				// validate access policy on redirected url (in browsers, only the final URL is validated)
+				if (response.redirected) {
+					if ((typeof this.urlAccessPolicy !== 'undefined') && (this.urlAccessPolicy(response.url) !== true)) {
+						throw new Error(`Access to URL denied by resource access policy: ${response.url}`);
+					}
 				}
 
-				const buffer = await fetchUrl(url, headers);
+				const buffer = await response.arrayBuffer();
 				this.fs.writeFileSync(url, buffer);
 			}
 			// else cannot be resolved

package/src/base.js

@@ -9,6 +9,7 @@ class pdfmake {
 	constructor() {
 		this.virtualfs = virtualfs;
 		this.urlAccessPolicy = undefined;
+		this.localAccessPolicy = undefined;
 	}
 
 	/**
@@ -34,11 +35,16 @@ class pdfmake {
 				'No URL access policy defined. Consider using setUrlAccessPolicy() to restrict external resource downloads.'
 			);
 		}
+		if (typeof this.localAccessPolicy === 'undefined' && isServer) {
+			console.warn(
+				'No local access policy defined. Consider using setLocalAccessPolicy() to restrict local file system access.'
+			);
+		}
 
 		let urlResolver = new URLResolver(this.virtualfs);
 		urlResolver.setUrlAccessPolicy(this.urlAccessPolicy);
 
-		let printer = new Printer(this.fonts, this.virtualfs, urlResolver);
+		let printer = new Printer(this.fonts, this.virtualfs, urlResolver, this.localAccessPolicy);
 		const pdfDocumentPromise = printer.createPdfKitDocument(docDefinition, options);
 
 		return this._transformToDocument(pdfDocumentPromise);

package/src/index.js

@@ -6,6 +6,17 @@ class pdfmake extends pdfmakeBase {
 		super();
 	}
 
+	/**
+	 * @param {(path: string) => boolean} callback
+	 */
+	setLocalAccessPolicy(callback) {
+		if (callback !== undefined && typeof callback !== 'function') {
+			throw new Error("Parameter 'callback' has an invalid type. Function or undefined expected.");
+		}
+
+		this.localAccessPolicy = callback;
+	}
+
 	_transformToDocument(doc) {
 		return new OutputDocumentServer(doc);
 	}