pdfmake-acroforms 0.3.4

package/src/TextBreaker.js

@@ -0,0 +1,181 @@
+import LineBreaker from 'linebreak';
+import { isObject } from './helpers/variableType';
+import StyleContextStack from './StyleContextStack';
+
+/**
+ * @param {string} text
+ * @param {boolean} noWrap
+ * @param {boolean} breakAll
+ * @returns {Array}
+ */
+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;
+	let bk;
+
+	while ((bk = breaker.nextBreak())) {
+		let word = text.slice(last, bk.position);
+
+		if (bk.required || word.match(/\r?\n$|\r$/)) { // new line
+			word = word.replace(/\r?\n$|\r$/, '');
+			words.push({ text: word, lineEnd: true });
+		} else {
+			words.push({ text: word });
+		}
+
+		last = bk.position;
+	}
+
+	return words;
+};
+
+/**
+ * @param {Array} words
+ * @param {boolean} noWrap
+ * @returns {?string}
+ */
+const getFirstWord = (words, noWrap) => {
+	let word = words[0];
+	if (word === undefined) {
+		return null;
+	}
+
+	if (noWrap) { // text was not wrapped, we need only first word
+		let tmpWords = splitWords(word.text, false);
+		if (tmpWords[0] === undefined) {
+			return null;
+		}
+		word = tmpWords[0];
+	}
+
+	return word.text;
+};
+
+/**
+ * @param {Array} words
+ * @param {boolean} noWrap
+ * @returns {?string}
+ */
+const getLastWord = (words, noWrap) => {
+	let word = words[words.length - 1];
+	if (word === undefined) {
+		return null;
+	}
+
+	if (word.lineEnd) {
+		return null;
+	}
+
+	if (noWrap) { // text was not wrapped, we need only last word
+		let tmpWords = splitWords(word.text, false);
+		if (tmpWords[tmpWords.length - 1] === undefined) {
+			return null;
+		}
+		word = tmpWords[tmpWords.length - 1];
+	}
+
+	return word.text;
+};
+
+class TextBreaker {
+	/**
+	 * @param {string|Array} texts
+	 * @param {StyleContextStack} styleContextStack
+	 * @returns {Array}
+	 */
+	getBreaks(texts, styleContextStack) {
+		let results = [];
+
+		if (!Array.isArray(texts)) {
+			texts = [texts];
+		}
+
+		let lastWord = null;
+		for (let i = 0, l = texts.length; i < l; i++) {
+			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.text) {
+					if (item._textRef && item._textRef._textNodeRef.text) {
+						item.text = item._textRef._textNodeRef.text;
+					}
+					words = splitWords(item.text, noWrap, breakAll);
+				} else if (item.acroform) {
+					words = [item];
+				}
+				style = StyleContextStack.copyStyle(item);
+			} else {
+				words = splitWords(item, noWrap, breakAll);
+			}
+
+			if (lastWord && words.length && !lastWord.acroform) {
+				let firstWord = getFirstWord(words, noWrap);
+
+				let wrapWords = splitWords(lastWord + firstWord, false);
+				if (wrapWords.length === 1) {
+					results[results.length - 1].noNewLine = true;
+				}
+			}
+
+			for (let i2 = 0, l2 = words.length; i2 < l2; i2++) {
+				let result = {};
+				if (words[0].acroform) {
+					result = words[0];
+				} else {
+					result = {
+						text: words[i2].text
+					};
+				}
+
+				if (words[i2].lineEnd) {
+					result.lineEnd = true;
+				}
+
+				StyleContextStack.copyStyle(style, result);
+
+				results.push(result);
+			}
+
+			lastWord = null;
+			if (i + 1 < l) {
+				if (words[0].acroform) {
+					lastWord = words[0];
+				} else {
+					lastWord = getLastWord(words, noWrap);
+				}
+			}
+		}
+
+		return results;
+	}
+}
+
+export default TextBreaker;

package/src/TextDecorator.js

@@ -0,0 +1,175 @@
+import { isNumber } from './helpers/variableType';
+
+const groupDecorations = line => {
+	let groups = [];
+	let currentGroup = null;
+	for (let i = 0, l = line.inlines.length; i < l; i++) {
+		let inline = line.inlines[i];
+		let decoration = inline.decoration;
+		if (!decoration) {
+			currentGroup = null;
+			continue;
+		}
+		if (!Array.isArray(decoration)) {
+			decoration = [decoration];
+		}
+		let color = 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++) {
+			let decorationItem = decoration[ii];
+			if (!currentGroup || decorationItem !== currentGroup.decoration ||
+				style !== currentGroup.decorationStyle || color !== currentGroup.decorationColor) {
+
+				currentGroup = {
+					line: line,
+					decoration: decorationItem,
+					decorationColor: color,
+					decorationStyle: style,
+					decorationThickness: thickness,
+					inlines: [inline]
+				};
+				groups.push(currentGroup);
+			} else {
+				currentGroup.inlines.push(inline);
+			}
+		}
+	}
+
+	return groups;
+};
+
+class TextDecorator {
+
+	constructor(pdfDocument) {
+		this.pdfDocument = pdfDocument;
+	}
+
+	drawBackground(line, x, y) {
+		let height = line.getHeight();
+		for (let i = 0, l = line.inlines.length; i < l; i++) {
+			let inline = line.inlines[i];
+			if (!inline.background) {
+				continue;
+			}
+
+			let color = inline.background;
+			let patternColor = this.pdfDocument.providePattern(inline.background);
+			if (patternColor !== null) {
+				color = patternColor;
+			}
+
+			let justifyShift = (inline.justifyShift || 0);
+			this.pdfDocument.fillColor(color)
+				.rect(x + inline.x - justifyShift, y, inline.width + justifyShift, height)
+				.fill();
+		}
+	}
+
+	drawDecorations(line, x, y) {
+		let groups = groupDecorations(line);
+		for (let i = 0, l = groups.length; i < l; i++) {
+			this._drawDecoration(groups[i], x, y);
+		}
+	}
+
+	_drawDecoration(group, x, y) {
+		const maxInline = () => {
+			let max = 0;
+			for (let i = 0, l = group.inlines.length; i < l; i++) {
+				let inline = group.inlines[i];
+				max = inline.fontSize > max ? i : max;
+			}
+			return group.inlines[max];
+		};
+
+		const width = () => {
+			let sum = 0;
+			for (let i = 0, l = group.inlines.length; i < l; i++) {
+				let justifyShift = (group.inlines[i].justifyShift || 0);
+				sum += group.inlines[i].width + justifyShift;
+			}
+			return sum;
+		};
+
+		let firstInline = group.inlines[0];
+		let biggerInline = maxInline();
+		let totalWidth = width();
+		let lineAscent = group.line.getAscenderHeight();
+		let ascent = biggerInline.font.ascender / 1000 * biggerInline.fontSize;
+		let height = biggerInline.height;
+		let descent = height - ascent;
+
+		let lw = isNumber(group.decorationThickness)
+			? group.decorationThickness
+			: 0.5 + Math.floor(Math.max(biggerInline.fontSize - 8, 0) / 2) * 0.12;
+
+		switch (group.decoration) {
+			case 'underline':
+				y += lineAscent + descent * 0.45;
+				break;
+			case 'overline':
+				y += lineAscent - (ascent * 0.85);
+				break;
+			case 'lineThrough':
+				y += lineAscent - (ascent * 0.25);
+				break;
+			default:
+				throw new Error(`Unknown decoration : ${group.decoration}`);
+		}
+
+		if (group.inlines[0].sup) {
+			y -= group.inlines[0].fontSize * 0.75;
+		}
+		if (group.inlines[0].sub) {
+			y += group.inlines[0].fontSize * 0.35;
+		}
+
+		this.pdfDocument.save();
+
+		if (group.decorationStyle === 'double') {
+			let gap = Math.max(0.5, lw, biggerInline.fontSize * 0.15);
+			this.pdfDocument.fillColor(group.decorationColor)
+				.rect(x + firstInline.x, y - lw / 2, totalWidth, lw / 2).fill()
+				.rect(x + firstInline.x, y + gap - lw / 2, totalWidth, lw / 2).fill();
+		} else if (group.decorationStyle === 'dashed') {
+			let nbDashes = Math.ceil(totalWidth / (3.96 + 2.84));
+			let rdx = x + firstInline.x;
+			this.pdfDocument.rect(rdx, y, totalWidth, lw).clip();
+			this.pdfDocument.fillColor(group.decorationColor);
+			for (let i = 0; i < nbDashes; i++) {
+				this.pdfDocument.rect(rdx, y - lw / 2, 3.96, lw).fill();
+				rdx += 3.96 + 2.84;
+			}
+		} else if (group.decorationStyle === 'dotted') {
+			let nbDots = Math.ceil(totalWidth / (lw * 3));
+			let rx = x + firstInline.x;
+			this.pdfDocument.rect(rx, y, totalWidth, lw).clip();
+			this.pdfDocument.fillColor(group.decorationColor);
+			for (let i = 0; i < nbDots; i++) {
+				this.pdfDocument.rect(rx, y - lw / 2, lw, lw).fill();
+				rx += (lw * 3);
+			}
+		} else if (group.decorationStyle === 'wavy') {
+			let sh = 0.7, sv = 1;
+			let nbWaves = Math.ceil(totalWidth / (sh * 2)) + 1;
+			let rwx = x + firstInline.x - 1;
+			this.pdfDocument.rect(x + firstInline.x, y - sv, totalWidth, y + sv).clip();
+			this.pdfDocument.lineWidth(lw / 3);
+			this.pdfDocument.moveTo(rwx, y);
+			for (let i = 0; i < nbWaves; i++) {
+				this.pdfDocument.bezierCurveTo(rwx + sh, y - sv, rwx + sh * 2, y - sv, rwx + sh * 3, y)
+					.bezierCurveTo(rwx + sh * 4, y + sv, rwx + sh * 5, y + sv, rwx + sh * 6, y);
+				rwx += sh * 6;
+			}
+			this.pdfDocument.stroke(group.decorationColor);
+		} else {
+			this.pdfDocument.fillColor(group.decorationColor)
+				.rect(x + firstInline.x, y - lw / 2, totalWidth, lw)
+				.fill();
+		}
+		this.pdfDocument.restore();
+	}
+}
+
+export default TextDecorator;

package/src/TextInlines.js

@@ -0,0 +1,229 @@
+import TextBreaker from './TextBreaker';
+import StyleContextStack from './StyleContextStack';
+
+const LEADING = /^(\s)+/g;
+const TRAILING = /(\s)+$/g;
+
+/**
+ * @param {Array} array
+ * @returns {Array}
+ */
+const flattenTextArray = array => {
+	function flatten(array) {
+		return array.reduce((prev, cur) => {
+			let current = Array.isArray(cur.text) ? flatten(cur.text) : cur;
+			let more = [].concat(current).some(Array.isArray);
+			return prev.concat(more ? flatten(current) : current);
+		}, []);
+	}
+
+	if (!Array.isArray(array)) {
+		array = [array];
+	}
+
+	// TODO: Styling in nested text (issue: https://github.com/bpampuch/pdfmake/issues/1174)
+
+	array = flatten(array);
+
+	return array;
+};
+
+
+/**
+ * Text measurement utility
+ */
+class TextInlines {
+
+	/**
+	 * @param {object} pdfDocument object is instance of PDFDocument
+	 */
+	constructor(pdfDocument) {
+		this.pdfDocument = pdfDocument;
+	}
+
+	/**
+	 * Converts an array of strings (or inline-definition-objects) into a collection
+	 * of inlines and calculated minWidth/maxWidth and their min/max widths
+	 *
+	 * @param {Array|object} textArray an array of inline-definition-objects (or strings)
+	 * @param {StyleContextStack} styleContextStack current style stack
+	 * @returns {object} collection of inlines, minWidth, maxWidth
+	 */
+	buildInlines(textArray, styleContextStack) {
+		const getTrimmedWidth = item => {
+			return Math.max(0, item.width - item.leadingCut - item.trailingCut);
+		};
+
+		let minWidth = 0;
+		let maxWidth = 0;
+		let currentLineWidth;
+
+		let flattenedTextArray = flattenTextArray(textArray);
+
+		const textBreaker = new TextBreaker();
+		let brokenText = textBreaker.getBreaks(flattenedTextArray, styleContextStack);
+
+		let measuredText = this.measure(brokenText, styleContextStack);
+
+		measuredText.forEach(inline => {
+			minWidth = Math.max(minWidth, getTrimmedWidth(inline));
+
+			if (!currentLineWidth) {
+				currentLineWidth = { width: 0, leadingCut: inline.leadingCut, trailingCut: 0 };
+			}
+
+			currentLineWidth.width += inline.width;
+			currentLineWidth.trailingCut = inline.trailingCut;
+
+			maxWidth = Math.max(maxWidth, getTrimmedWidth(currentLineWidth));
+
+			if (inline.lineEnd) {
+				currentLineWidth = null;
+			}
+		});
+
+		if (StyleContextStack.getStyleProperty({}, styleContextStack, 'noWrap', false)) {
+			minWidth = maxWidth;
+		}
+
+		return {
+			items: measuredText,
+			minWidth: minWidth,
+			maxWidth: maxWidth
+		};
+	}
+
+	measure(array, styleContextStack) {
+		if (array.length) {
+			let leadingIndent = StyleContextStack.getStyleProperty(array[0], styleContextStack, 'leadingIndent', 0);
+			if (leadingIndent) {
+				array[0].leadingCut = -leadingIndent;
+				array[0].leadingIndent = leadingIndent;
+			}
+		}
+
+		array.forEach(item => {
+			let font = StyleContextStack.getStyleProperty(item, styleContextStack, 'font', 'Roboto');
+			let bold = StyleContextStack.getStyleProperty(item, styleContextStack, 'bold', false);
+			let italics = StyleContextStack.getStyleProperty(item, styleContextStack, 'italics', false);
+
+			item.font = this.pdfDocument.provideFont(font, bold, italics);
+
+			item.alignment = StyleContextStack.getStyleProperty(item, styleContextStack, 'alignment', 'left');
+			item.fontSize = StyleContextStack.getStyleProperty(item, styleContextStack, 'fontSize', 12);
+			item.fontFeatures = StyleContextStack.getStyleProperty(item, styleContextStack, 'fontFeatures', null);
+			item.characterSpacing = StyleContextStack.getStyleProperty(item, styleContextStack, 'characterSpacing', 0);
+			item.color = StyleContextStack.getStyleProperty(item, styleContextStack, 'color', 'black');
+			item.decoration = StyleContextStack.getStyleProperty(item, styleContextStack, 'decoration', null);
+			item.decorationColor = StyleContextStack.getStyleProperty(item, styleContextStack, 'decorationColor', null);
+			item.decorationStyle = StyleContextStack.getStyleProperty(item, styleContextStack, 'decorationStyle', null);
+			item.decorationThickness = StyleContextStack.getStyleProperty(item, styleContextStack, 'decorationThickness', null);
+			item.background = StyleContextStack.getStyleProperty(item, styleContextStack, 'background', null);
+			item.link = StyleContextStack.getStyleProperty(item, styleContextStack, 'link', null);
+			item.linkToPage = StyleContextStack.getStyleProperty(item, styleContextStack, 'linkToPage', null);
+			item.linkToDestination = StyleContextStack.getStyleProperty(item, styleContextStack, 'linkToDestination', null);
+			item.noWrap = item.acroform ? true: StyleContextStack.getStyleProperty(item, styleContextStack, 'noWrap', null);
+			item.opacity = StyleContextStack.getStyleProperty(item, styleContextStack, 'opacity', 1);
+			item.sup = StyleContextStack.getStyleProperty(item, styleContextStack, 'sup', false);
+			item.sub = StyleContextStack.getStyleProperty(item, styleContextStack, 'sub', false);
+
+			if (item.sup || item.sub) {
+				// font size reduction taken from here: https://en.wikipedia.org/wiki/Subscript_and_superscript#Desktop_publishing
+				item.fontSize *= 0.58;
+			}
+
+			let lineHeight = StyleContextStack.getStyleProperty(item, styleContextStack, 'lineHeight', 1);
+
+			if (item.acroform) {
+				item.width = item.width || 25;
+				item.height = item.height || 15;
+			}  else {
+				item.width = this.widthOfText(item.text, item);
+				item.height = item.font.lineHeight(item.fontSize) * lineHeight;
+
+				if (!item.leadingCut) {
+					item.leadingCut = 0;
+				}
+
+				let preserveLeadingSpaces = StyleContextStack.getStyleProperty(item, styleContextStack, 'preserveLeadingSpaces', false);
+				if (!preserveLeadingSpaces) {
+					let leadingSpaces = item.text.match(LEADING);
+					if (leadingSpaces) {
+						item.leadingCut += this.widthOfText(leadingSpaces[0], item);
+					}
+				}
+
+				item.trailingCut = 0;
+
+				let preserveTrailingSpaces = StyleContextStack.getStyleProperty(item, styleContextStack, 'preserveTrailingSpaces', false);
+				if (!preserveTrailingSpaces) {
+					let trailingSpaces = item.text.match(TRAILING);
+					if (trailingSpaces) {
+						item.trailingCut = this.widthOfText(trailingSpaces[0], item);
+					}
+				}
+			}
+		}, this);
+
+		return array;
+	}
+
+	/**
+	 * Width of text
+	 *
+	 * @param {string} text
+	 * @param {object} inline
+	 * @returns {number}
+	 */
+	widthOfText(text, inline) {
+		return inline.font.widthOfString(text, inline.fontSize, inline.fontFeatures) + ((inline.characterSpacing || 0) * (text.length - 1));
+	}
+
+	/**
+	 * Returns size of the specified string (without breaking it) using the current style
+	 *
+	 * @param {string} text text to be measured
+	 * @param {object} styleContextStack current style stack
+	 * @returns {object} size of the specified string
+	 */
+	sizeOfText(text, styleContextStack) {
+		//TODO: refactor - extract from measure
+		let fontName = StyleContextStack.getStyleProperty({}, styleContextStack, 'font', 'Roboto');
+		let fontSize = StyleContextStack.getStyleProperty({}, styleContextStack, 'fontSize', 12);
+		let fontFeatures = StyleContextStack.getStyleProperty({}, styleContextStack, 'fontFeatures', null);
+		let bold = StyleContextStack.getStyleProperty({}, styleContextStack, 'bold', false);
+		let italics = StyleContextStack.getStyleProperty({}, styleContextStack, 'italics', false);
+		let lineHeight = StyleContextStack.getStyleProperty({}, styleContextStack, 'lineHeight', 1);
+		let characterSpacing = StyleContextStack.getStyleProperty({}, styleContextStack, 'characterSpacing', 0);
+
+		let font = this.pdfDocument.provideFont(fontName, bold, italics);
+
+		return {
+			width: this.widthOfText(text, { font: font, fontSize: fontSize, characterSpacing: characterSpacing, fontFeatures: fontFeatures }),
+			height: font.lineHeight(fontSize) * lineHeight,
+			fontSize: fontSize,
+			lineHeight: lineHeight,
+			ascender: font.ascender / 1000 * fontSize,
+			descender: font.descender / 1000 * fontSize
+		};
+	}
+
+	/**
+	 * Returns size of the specified rotated string (without breaking it) using the current style
+	 *
+	 * @param {string} text text to be measured
+	 * @param {number} angle
+	 * @param {object} styleContextStack current style stack
+	 * @returns {object} size of the specified string
+	 */
+	sizeOfRotatedText(text, angle, styleContextStack) {
+		let angleRad = angle * Math.PI / -180;
+		let size = this.sizeOfText(text, styleContextStack);
+		return {
+			width: Math.abs(size.height * Math.sin(angleRad)) + Math.abs(size.width * Math.cos(angleRad)),
+			height: Math.abs(size.width * Math.sin(angleRad)) + Math.abs(size.height * Math.cos(angleRad))
+		};
+	}
+}
+
+export default TextInlines;

package/src/URLResolver.js

@@ -0,0 +1,43 @@
+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})`);
+	}
+}
+
+class URLResolver {
+	constructor(fs) {
+		this.fs = fs;
+		this.resolving = {};
+	}
+
+	resolve(url, headers = {}) {
+		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 Promise.all(Object.values(this.resolving));
+	}
+
+}
+
+export default URLResolver;

package/src/base.js

@@ -0,0 +1,70 @@
+import Printer from './Printer';
+import virtualfs from './virtual-fs';
+import { pack } from './helpers/tools';
+import { isObject } from './helpers/variableType';
+
+class pdfmake {
+
+	constructor() {
+		this.virtualfs = virtualfs;
+		this.urlResolver = null;
+	}
+
+	/**
+	 * @param {object} docDefinition
+	 * @param {?object} options
+	 * @returns {object}
+	 */
+	createPdf(docDefinition, options = {}) {
+		if (!isObject(docDefinition)) {
+			throw new Error("Parameter 'docDefinition' has an invalid type. Object expected.");
+		}
+
+		if (!isObject(options)) {
+			throw new Error("Parameter 'options' has an invalid type. Object expected.");
+		}
+
+		options.progressCallback = this.progressCallback;
+		options.tableLayouts = this.tableLayouts;
+
+		let printer = new Printer(this.fonts, this.virtualfs, this.urlResolver());
+		const pdfDocumentPromise = printer.createPdfKitDocument(docDefinition, options);
+
+		return this._transformToDocument(pdfDocumentPromise);
+	}
+
+	setProgressCallback(callback) {
+		this.progressCallback = callback;
+	}
+
+	addTableLayouts(tableLayouts) {
+		this.tableLayouts = pack(this.tableLayouts, tableLayouts);
+	}
+
+	setTableLayouts(tableLayouts) {
+		this.tableLayouts = tableLayouts;
+	}
+
+	clearTableLayouts() {
+		this.tableLayouts = {};
+	}
+
+	addFonts(fonts) {
+		this.fonts = pack(this.fonts, fonts);
+	}
+
+	setFonts(fonts) {
+		this.fonts = fonts;
+	}
+
+	clearFonts() {
+		this.fonts = {};
+	}
+
+	_transformToDocument(doc) {
+		return doc;
+	}
+
+}
+
+export default pdfmake;