@digicole/pdfmake-rtl 1.2.0 → 2.1.1

package/src/line.js

@@ -1,104 +1,122 @@
-'use strict';
-
-/**
- * Creates an instance of Line
- *
- * @constructor
- * @this {Line}
- * @param {Number} Maximum width this line can have
- */
-function Line(maxWidth) {
-	this.maxWidth = maxWidth;
-	this.leadingCut = 0;
-	this.trailingCut = 0;
-	this.inlineWidths = 0;
-	this.inlines = [];
-}
-
-Line.prototype.getAscenderHeight = function () {
-	var y = 0;
-
-	this.inlines.forEach(function (inline) {
-		y = Math.max(y, inline.font.ascender / 1000 * inline.fontSize);
-	});
-	return y;
-};
-
-Line.prototype.hasEnoughSpaceForInline = function (inline, nextInlines) {
-	nextInlines = nextInlines || [];
-
-	if (this.inlines.length === 0) {
-		return true;
-	}
-	if (this.newLineForced) {
-		return false;
-	}
-
-	var inlineWidth = inline.width;
-	var inlineTrailingCut = inline.trailingCut || 0;
-	if (inline.noNewLine) {
-		for (var i = 0, l = nextInlines.length; i < l; i++) {
-			var nextInline = nextInlines[i];
-			inlineWidth += nextInline.width;
-			inlineTrailingCut += nextInline.trailingCut || 0;
-			if (!nextInline.noNewLine) {
-				break;
-			}
-		}
-	}
-
-	return (this.inlineWidths + inlineWidth - this.leadingCut - inlineTrailingCut) <= this.maxWidth;
-};
-
-Line.prototype.addInline = function (inline) {
-	if (this.inlines.length === 0) {
-		this.leadingCut = inline.leadingCut || 0;
-	}
-	this.trailingCut = inline.trailingCut || 0;
-
-	// For RTL text, we'll position inlines from right to left
-	// The actual RTL positioning will be handled in the alignment phase
-	inline.x = this.inlineWidths - this.leadingCut;
-
-	this.inlines.push(inline);
-	this.inlineWidths += inline.width;
-
-	if (inline.lineEnd) {
-		this.newLineForced = true;
-	}
-};
-
-Line.prototype.getWidth = function () {
-	return this.inlineWidths - this.leadingCut - this.trailingCut;
-};
-
-Line.prototype.getAvailableWidth = function () {
-	return this.maxWidth - this.getWidth();
-};
-
-/**
- * Returns line height
- * @return {Number}
- */
-Line.prototype.getHeight = function () {
-	var max = 0;
-
-	this.inlines.forEach(function (item) {
-		max = Math.max(max, item.height || 0);
-	});
-
-	return max;
-};
-
-/**
- * Check if this line should be rendered RTL
- * @return {Boolean}
- */
-Line.prototype.isRTL = function () {
-	// Check if any inline in this line is marked as RTL
-	return this.inlines.some(function (inline) {
-		return inline.isRTL || inline.direction === 'rtl';
-	});
-};
-
-module.exports = Line;
+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() {
+		let max = 0;
+
+		this.inlines.forEach(item => {
+			max = Math.max(max, item.height || 0);
+		});
+
+		return max;
+	}
+
+	/**
+	 * @returns {number}
+	 */
+	getAscenderHeight() {
+		let y = 0;
+
+		this.inlines.forEach(inline => {
+			y = Math.max(y, 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;
+	}
+
+	/**
+	 * Check if this line should be rendered RTL
+	 * @returns {boolean}
+	 */
+	isRTL() {
+		return this.inlines.some(inline => inline.isRTL || inline.direction === 'rtl');
+	}
+
+	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/pageElementWriter.js

@@ -1,174 +1,187 @@
-'use strict';
-
-var isUndefined = require('./helpers').isUndefined;
-var ElementWriter = require('./elementWriter');
-
-/**
- * Creates an instance of PageElementWriter - 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)
- */
-function PageElementWriter(context, tracker) {
-	this.transactionLevel = 0;
-	this.repeatables = [];
-	this.tracker = tracker;
-	this.writer = new ElementWriter(context, tracker);
-}
-
-function fitOnPage(self, addFct) {
-	var position = addFct(self);
-	if (!position) {
-		self.moveToNextPage();
-		position = addFct(self);
-	}
-	return position;
-}
-
-PageElementWriter.prototype.addLine = function (line, dontUpdateContextPosition, index) {
-	return fitOnPage(this, function (self) {
-		return self.writer.addLine(line, dontUpdateContextPosition, index);
-	});
-};
-
-PageElementWriter.prototype.addImage = function (image, index) {
-	return fitOnPage(this, function (self) {
-		return self.writer.addImage(image, index);
-	});
-};
-
-PageElementWriter.prototype.addSVG = function (image, index) {
-	return fitOnPage(this, function (self) {
-		return self.writer.addSVG(image, index);
-	});
-};
-
-PageElementWriter.prototype.addQr = function (qr, index) {
-	return fitOnPage(this, function (self) {
-		return self.writer.addQr(qr, index);
-	});
-};
-
-PageElementWriter.prototype.addVector = function (vector, ignoreContextX, ignoreContextY, index, forcePage) {
-	return this.writer.addVector(vector, ignoreContextX, ignoreContextY, index, forcePage);
-};
-
-PageElementWriter.prototype.beginClip = function (width, height) {
-	return this.writer.beginClip(width, height);
-};
-
-PageElementWriter.prototype.endClip = function () {
-	return this.writer.endClip();
-};
-
-PageElementWriter.prototype.alignCanvas = function (node) {
-	this.writer.alignCanvas(node);
-};
-
-PageElementWriter.prototype.addFragment = function (fragment, useBlockXOffset, useBlockYOffset, dontUpdateContextPosition) {
-	if (!this.writer.addFragment(fragment, useBlockXOffset, useBlockYOffset, dontUpdateContextPosition)) {
-		this.moveToNextPage();
-		this.writer.addFragment(fragment, useBlockXOffset, useBlockYOffset, dontUpdateContextPosition);
-	}
-};
-
-PageElementWriter.prototype.moveToNextPage = function (pageOrientation) {
-
-	var nextPage = this.writer.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 (isUndefined(rep.insertedOnPages[this.writer.context.page])) {
-			rep.insertedOnPages[this.writer.context.page] = true;
-			this.writer.addFragment(rep, true);
-		} else {
-			this.writer.context.moveDown(rep.height);
-		}
-	}, this);
-
-	this.writer.tracker.emit('pageChanged', {
-		prevPage: nextPage.prevPage,
-		prevY: nextPage.prevY,
-		y: this.writer.context.y
-	});
-};
-
-PageElementWriter.prototype.beginUnbreakableBlock = function (width, height) {
-	if (this.transactionLevel++ === 0) {
-		this.originalX = this.writer.context.x;
-		this.writer.pushContext(width, height);
-	}
-};
-
-PageElementWriter.prototype.commitUnbreakableBlock = function (forcedX, forcedY) {
-	if (--this.transactionLevel === 0) {
-		var unbreakableContext = this.writer.context;
-		this.writer.popContext();
-
-		var nbPages = unbreakableContext.pages.length;
-		if (nbPages > 0) {
-			// no support for multi-page unbreakableBlocks
-			var 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.writer.context.getCurrentPage().pageSize.height - this.writer.context.pageMargins.top - this.writer.context.pageMargins.bottom;
-					for (var 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) {
-				this.writer.addFragment(fragment, true, true, true);
-			} else {
-				this.addFragment(fragment);
-			}
-		}
-	}
-};
-
-PageElementWriter.prototype.currentBlockToRepeatable = function () {
-	var unbreakableContext = this.writer.context;
-	var rep = { items: [] };
-
-	unbreakableContext.pages[0].items.forEach(function (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;
-};
-
-PageElementWriter.prototype.pushToRepeatables = function (rep) {
-	this.repeatables.push(rep);
-};
-
-PageElementWriter.prototype.popFromRepeatables = function () {
-	this.repeatables.pop();
-};
-
-PageElementWriter.prototype.context = function () {
-	return this.writer.context;
-};
-
-module.exports = PageElementWriter;
+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));
+	}
+
+	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;