pdfmake-acroforms 0.3.4

package/src/Line.js

@@ -0,0 +1,108 @@
+class Line {
+	/**
+	 * @param {number} maxWidth Maximum width this line can have
+	 */
+	constructor(maxWidth) {
+		this.maxWidth = maxWidth;
+		this.leadingCut = 0;
+		this.trailingCut = 0;
+		this.inlineWidths = 0;
+		this.inlines = [];
+	}
+
+	/**
+	 * @param {object} inline
+	 */
+	addInline(inline) {
+		if (this.inlines.length === 0) {
+			this.leadingCut = inline.leadingCut || 0;
+		}
+		this.trailingCut = inline.trailingCut || 0;
+
+		inline.x = this.inlineWidths - this.leadingCut;
+
+		this.inlines.push(inline);
+		this.inlineWidths += inline.width;
+
+		if (inline.lineEnd) {
+			this.newLineForced = true;
+		}
+	}
+
+	/**
+	 * @returns {number}
+	 */
+	getHeight() {
+		return Math.max(...this.inlines.map(item => item.height || 0));
+	}
+
+	/**
+	 * @returns {number}
+	 */
+	getAscenderHeight() {
+		let y = 0;
+
+		this.inlines.forEach(inline => {
+			y = Math.max(y, inline.acroform ? inline.height : inline.font.ascender / 1000 * inline.fontSize);
+		});
+
+		return y;
+	}
+
+	/**
+	 * @returns {number}
+	 */
+	getWidth() {
+		return this.inlineWidths - this.leadingCut - this.trailingCut;
+	}
+
+	/**
+	 * @returns {number}
+	 */
+	getAvailableWidth() {
+		return this.maxWidth - this.getWidth();
+	}
+
+	/**
+	 * @param {object} inline
+	 * @param {Array} nextInlines
+	 * @returns {boolean}
+	 */
+	hasEnoughSpaceForInline(inline, nextInlines = []) {
+		if (this.inlines.length === 0) {
+			return true;
+		}
+		if (this.newLineForced) {
+			return false;
+		}
+
+		let inlineWidth = inline.width;
+		let inlineTrailingCut = inline.trailingCut || 0;
+		if (inline.noNewLine) {
+			for (let i = 0, l = nextInlines.length; i < l; i++) {
+				let nextInline = nextInlines[i];
+				inlineWidth += nextInline.width;
+				inlineTrailingCut += nextInline.trailingCut || 0;
+				if (!nextInline.noNewLine) {
+					break;
+				}
+			}
+		}
+
+		return (this.inlineWidths + inlineWidth - this.leadingCut - inlineTrailingCut) <= this.maxWidth;
+	}
+
+	clone() {
+		let result = new Line(this.maxWidth);
+
+		for (let key in this) {
+			if (this.hasOwnProperty(key)) {
+				result[key] = this[key];
+			}
+		}
+
+		return result;
+	}
+}
+
+export default Line;

package/src/OutputDocument.js

@@ -0,0 +1,64 @@
+class OutputDocument {
+
+	/**
+	 * @param {Promise<object>} pdfDocumentPromise
+	 */
+	constructor(pdfDocumentPromise) {
+		this.bufferSize = 1073741824;
+		this.pdfDocumentPromise = pdfDocumentPromise;
+		this.bufferPromise = null;
+	}
+
+	/**
+	 * @returns {Promise<object>}
+	 */
+	getStream() {
+		return this.pdfDocumentPromise;
+	}
+
+	/**
+	 * @returns {Promise<Buffer>}
+	 */
+	getBuffer() {
+		const getBufferInternal = (async () => {
+			const stream = await this.getStream();
+			return new Promise((resolve) => {
+				let chunks = [];
+				stream.on('readable', () => {
+					let chunk;
+					while ((chunk = stream.read(this.bufferSize)) !== null) {
+						chunks.push(chunk);
+					}
+				});
+				stream.on('end', () => {
+					resolve(Buffer.concat(chunks));
+				});
+				stream.end();
+			});
+		});
+
+		if (this.bufferPromise === null) {
+			this.bufferPromise = getBufferInternal();
+		}
+		return this.bufferPromise;
+	}
+
+	/**
+	 * @returns {Promise<string>}
+	 */
+	async getBase64() {
+		const buffer = await this.getBuffer();
+		return buffer.toString('base64');
+	}
+
+	/**
+	 * @returns {Promise<string>}
+	 */
+	async getDataUrl() {
+		const data = await this.getBase64();
+		return 'data:application/pdf;base64,' + data;
+	}
+
+}
+
+export default OutputDocument;

package/src/OutputDocumentServer.js

@@ -0,0 +1,32 @@
+import OutputDocument from './OutputDocument';
+import fs from 'fs';
+
+class OutputDocumentServer extends OutputDocument {
+
+	/**
+	 * @param {string} filename
+	 * @returns {Promise}
+	 */
+	async write(filename) {
+		const stream = await this.getStream();
+		const writeStream = fs.createWriteStream(filename);
+
+		const streamEnded = new Promise((resolve, reject) => {
+			stream.on('end', resolve);
+			stream.on('error', reject);
+		});
+
+		const writeClosed = new Promise((resolve, reject) => {
+			writeStream.on('close', resolve);
+			writeStream.on('error', reject);
+		});
+
+		stream.pipe(writeStream);
+		stream.end();
+
+		await Promise.all([streamEnded, writeClosed]);
+	}
+
+}
+
+export default OutputDocumentServer;

package/src/PDFDocument.js

@@ -0,0 +1,178 @@
+import PDFKit from 'pdfkit';
+
+const typeName = (bold, italics) => {
+	let type = 'normal';
+	if (bold && italics) {
+		type = 'bolditalics';
+	} else if (bold) {
+		type = 'bold';
+	} else if (italics) {
+		type = 'italics';
+	}
+	return type;
+};
+
+class PDFDocument extends PDFKit {
+	constructor(fonts = {}, images = {}, patterns = {}, attachments = {}, options = {}, virtualfs = null, subsetFonts = true) {
+		super(options);
+
+		this.fonts = {};
+		this.fontCache = {};
+		for (let font in fonts) {
+			if (fonts.hasOwnProperty(font)) {
+				let fontDef = fonts[font];
+
+				this.fonts[font] = {
+					normal: fontDef.normal,
+					bold: fontDef.bold,
+					italics: fontDef.italics,
+					bolditalics: fontDef.bolditalics
+				};
+			}
+		}
+
+		this.patterns = {};
+		for (let pattern in patterns) {
+			if (patterns.hasOwnProperty(pattern)) {
+				let patternDef = patterns[pattern];
+				this.patterns[pattern] = this.pattern(patternDef.boundingBox, patternDef.xStep, patternDef.yStep, patternDef.pattern, patternDef.colored);
+			}
+		}
+
+
+		this.images = images;
+		this.attachments = attachments;
+		this.virtualfs = virtualfs;
+		this.subsetFonts = subsetFonts; //TODO maybe automatically set this flag
+	}
+
+	getFontType(bold, italics) {
+		return typeName(bold, italics);
+	}
+
+	getFontFile(familyName, bold, italics) {
+		let type = this.getFontType(bold, italics);
+		if (!this.fonts[familyName] || !this.fonts[familyName][type]) {
+			return null;
+		}
+
+		return this.fonts[familyName][type];
+	}
+
+	provideFont(familyName, bold, italics) {
+		let type = this.getFontType(bold, italics);
+		if (this.getFontFile(familyName, bold, italics) === null) {
+			throw new Error(`Font '${familyName}' in style '${type}' is not defined in the font section of the document definition.`);
+		}
+
+		this.fontCache[familyName] = this.fontCache[familyName] || {};
+
+		if (!this.fontCache[familyName][type]) {
+			let def = this.fonts[familyName][type];
+			if (!Array.isArray(def)) {
+				def = [def];
+			}
+
+			if (this.virtualfs && this.virtualfs.existsSync(def[0])) {
+				def[0] = this.virtualfs.readFileSync(def[0]);
+			}
+
+
+			this.fontCache[familyName][type] = this.font(...def)._font;
+			
+		}
+
+		return this.fontCache[familyName][type];
+	}
+
+	provideImage(src) {
+		const realImageSrc = src => {
+			let image = this.images[src];
+
+			if (!image) {
+				return src;
+			}
+
+			if (this.virtualfs && this.virtualfs.existsSync(image)) {
+				return this.virtualfs.readFileSync(image);
+			}
+
+			let index = image.indexOf('base64,');
+			if (index < 0) {
+				return this.images[src];
+			}
+
+			return Buffer.from(image.substring(index + 7), 'base64');
+		};
+
+		if (this._imageRegistry[src]) {
+			return this._imageRegistry[src];
+		}
+
+		let image;
+
+		try {
+			image = this.openImage(realImageSrc(src));
+			if (!image) {
+				throw new Error('No image');
+			}
+		} catch (error) {
+			throw new Error(`Invalid image: ${error.toString()}\nImages dictionary should contain dataURL entries (or local file paths in node.js)`);
+		}
+
+		image.embed(this);
+		this._imageRegistry[src] = image;
+
+		return image;
+	}
+
+	/**
+	 * @param {Array} color pdfmake format: [<pattern name>, <color>]
+	 * @returns {Array} pdfkit format: [<pattern object>, <color>]
+	 */
+	providePattern(color) {
+		if (Array.isArray(color) && color.length === 2) {
+			return [this.patterns[color[0]], color[1]];
+		}
+
+		return null;
+	}
+
+	provideAttachment(src) {
+		const checkRequired = obj => {
+			if (!obj) {
+				throw new Error('No attachment');
+			}
+			if (!obj.src) {
+				throw new Error('The "src" key is required for attachments');
+			}
+
+			return obj;
+		};
+
+		if (typeof src === 'object') {
+			return checkRequired(src);
+		}
+
+		let attachment = checkRequired(this.attachments[src]);
+
+		if (this.virtualfs && this.virtualfs.existsSync(attachment.src)) {
+			return this.virtualfs.readFileSync(attachment.src);
+		}
+
+		return attachment;
+	}
+
+	setOpenActionAsPrint() {
+		let printActionRef = this.ref({
+			Type: 'Action',
+			S: 'Named',
+			N: 'Print'
+		});
+		this._root.data.OpenAction = printActionRef;
+		printActionRef.end();
+	}
+}
+
+
+export default PDFDocument;

package/src/PageElementWriter.js

@@ -0,0 +1,191 @@
+import ElementWriter from './ElementWriter';
+import { normalizePageSize, normalizePageMargin } from './PageSize';
+import DocumentContext from './DocumentContext';
+
+/**
+ * An extended ElementWriter which can handle:
+ * - page-breaks (it adds new pages when there's not enough space left),
+ * - repeatable fragments (like table-headers, which are repeated everytime
+ *                         a page-break occurs)
+ * - transactions (used for unbreakable-blocks when we want to make sure
+ *                 whole block will be rendered on the same page)
+ */
+class PageElementWriter extends ElementWriter {
+
+	/**
+	 * @param {DocumentContext} context
+	 */
+	constructor(context) {
+		super(context);
+		this.transactionLevel = 0;
+		this.repeatables = [];
+	}
+
+	addLine(line, dontUpdateContextPosition, index) {
+		return this._fitOnPage(() => super.addLine(line, dontUpdateContextPosition, index));
+	}
+
+	addImage(image, index) {
+		return this._fitOnPage(() => super.addImage(image, index));
+	}
+
+	addCanvas(image, index) {
+		return this._fitOnPage(() => super.addCanvas(image, index));
+	}
+
+	addSVG(image, index) {
+		return this._fitOnPage(() => super.addSVG(image, index));
+	}
+
+	addQr(qr, index) {
+		return this._fitOnPage(() => super.addQr(qr, index));
+	}
+
+	addAttachment(attachment, index) {
+		return this._fitOnPage(() => super.addAttachment(attachment, index));
+	}
+
+	addAcroForm(node, index) {
+		return this._fitOnPage(() => super.addAcroForm(node, index));
+	}
+
+	addVector(vector, ignoreContextX, ignoreContextY, index, forcePage) {
+		return super.addVector(vector, ignoreContextX, ignoreContextY, index, forcePage);
+	}
+
+	beginClip(width, height) {
+		return super.beginClip(width, height);
+	}
+
+	endClip() {
+		return super.endClip();
+	}
+
+	beginVerticalAlignment(verticalAlignment) {
+		return super.beginVerticalAlignment(verticalAlignment);
+	}
+
+	endVerticalAlignment(verticalAlignment) {
+		return super.endVerticalAlignment(verticalAlignment);
+	}
+
+	addFragment(fragment, useBlockXOffset, useBlockYOffset, dontUpdateContextPosition) {
+		return this._fitOnPage(() => super.addFragment(fragment, useBlockXOffset, useBlockYOffset, dontUpdateContextPosition));
+	}
+
+	moveToNextPage(pageOrientation) {
+		let nextPage = this.context().moveToNextPage(pageOrientation);
+
+		// moveToNextPage is called multiple times for table, because is called for each column
+		// and repeatables are inserted only in the first time. If columns are used, is needed
+		// call for table in first column and then for table in the second column (is other repeatables).
+		this.repeatables.forEach(function (rep) {
+			if (rep.insertedOnPages[this.context().page] === undefined) {
+				rep.insertedOnPages[this.context().page] = true;
+				this.addFragment(rep, true);
+			} else {
+				this.context().moveDown(rep.height);
+			}
+		}, this);
+
+		this.emit('pageChanged', {
+			prevPage: nextPage.prevPage,
+			prevY: nextPage.prevY,
+			y: this.context().y
+		});
+	}
+
+	addPage(pageSize, pageOrientation, pageMargin, customProperties = {}) {
+		let prevPage = this.page;
+		let prevY = this.y;
+
+		this.context().addPage(normalizePageSize(pageSize, pageOrientation), normalizePageMargin(pageMargin), customProperties);
+
+		this.emit('pageChanged', {
+			prevPage: prevPage,
+			prevY: prevY,
+			y: this.context().y
+		});
+	}
+
+	beginUnbreakableBlock(width, height) {
+		if (this.transactionLevel++ === 0) {
+			this.originalX = this.context().x;
+			this.pushContext(width, height);
+		}
+	}
+
+	commitUnbreakableBlock(forcedX, forcedY) {
+		if (--this.transactionLevel === 0) {
+			let unbreakableContext = this.context();
+			this.popContext();
+
+			let nbPages = unbreakableContext.pages.length;
+			if (nbPages > 0) {
+				// no support for multi-page unbreakableBlocks
+				let fragment = unbreakableContext.pages[0];
+				fragment.xOffset = forcedX;
+				fragment.yOffset = forcedY;
+
+				//TODO: vectors can influence height in some situations
+				if (nbPages > 1) {
+					// on out-of-context blocs (headers, footers, background) height should be the whole DocumentContext height
+					if (forcedX !== undefined || forcedY !== undefined) {
+						fragment.height = unbreakableContext.getCurrentPage().pageSize.height - unbreakableContext.pageMargins.top - unbreakableContext.pageMargins.bottom;
+					} else {
+						fragment.height = this.context().getCurrentPage().pageSize.height - this.context().pageMargins.top - this.context().pageMargins.bottom;
+						for (let i = 0, l = this.repeatables.length; i < l; i++) {
+							fragment.height -= this.repeatables[i].height;
+						}
+					}
+				} else {
+					fragment.height = unbreakableContext.y;
+				}
+
+				if (forcedX !== undefined || forcedY !== undefined) {
+					super.addFragment(fragment, true, true, true);
+				} else {
+					this.addFragment(fragment);
+				}
+			}
+		}
+	}
+
+	currentBlockToRepeatable() {
+		let unbreakableContext = this.context();
+		let rep = { items: [] };
+
+		unbreakableContext.pages[0].items.forEach(item => {
+			rep.items.push(item);
+		});
+
+		rep.xOffset = this.originalX;
+
+		//TODO: vectors can influence height in some situations
+		rep.height = unbreakableContext.y;
+
+		rep.insertedOnPages = [];
+
+		return rep;
+	}
+
+	pushToRepeatables(rep) {
+		this.repeatables.push(rep);
+	}
+
+	popFromRepeatables() {
+		this.repeatables.pop();
+	}
+
+	_fitOnPage(addFct) {
+		let position = addFct();
+		if (!position) {
+			this.moveToNextPage();
+			position = addFct();
+		}
+		return position;
+	}
+
+}
+
+export default PageElementWriter;

package/src/PageSize.js

@@ -0,0 +1,53 @@
+import sizes from './standardPageSizes';
+import { isString, isNumber } from './helpers/variableType';
+
+export function normalizePageSize(pageSize, pageOrientation) {
+	function isNeedSwapPageSizes(pageOrientation) {
+		if (isString(pageOrientation)) {
+			pageOrientation = pageOrientation.toLowerCase();
+			return ((pageOrientation === 'portrait') && (size.width > size.height)) ||
+				((pageOrientation === 'landscape') && (size.width < size.height));
+		}
+		return false;
+	}
+
+	function pageSizeToWidthAndHeight(pageSize) {
+		if (isString(pageSize)) {
+			let size = sizes[pageSize.toUpperCase()];
+			if (!size) {
+				throw new Error(`Page size ${pageSize} not recognized`);
+			}
+			return { width: size[0], height: size[1] };
+		}
+
+		return pageSize;
+	}
+
+	// if pageSize.height is set to auto, set the height to infinity so there are no page breaks.
+	if (pageSize && pageSize.height === 'auto') {
+		pageSize.height = Infinity;
+	}
+
+	let size = pageSizeToWidthAndHeight(pageSize || 'A4');
+	if (isNeedSwapPageSizes(pageOrientation)) { // swap page sizes
+		size = { width: size.height, height: size.width };
+	}
+	size.orientation = size.width > size.height ? 'landscape' : 'portrait';
+	return size;
+}
+
+export function normalizePageMargin(margin) {
+	if (isNumber(margin)) {
+		margin = { left: margin, right: margin, top: margin, bottom: margin };
+	} else if (Array.isArray(margin)) {
+		if (margin.length === 2) {
+			margin = { left: margin[0], top: margin[1], right: margin[0], bottom: margin[1] };
+		} else if (margin.length === 4) {
+			margin = { left: margin[0], top: margin[1], right: margin[2], bottom: margin[3] };
+		} else {
+			throw new Error('Invalid pageMargins definition');
+		}
+	}
+
+	return margin;
+}