@digicole/pdfmake-rtl 1.0.0

package/src/elementWriter.js

@@ -0,0 +1,411 @@
+'use strict';
+
+var Line = require('./line');
+var isNumber = require('./helpers').isNumber;
+var pack = require('./helpers').pack;
+var offsetVector = require('./helpers').offsetVector;
+var DocumentContext = require('./documentContext');
+
+/**
+ * Creates an instance of ElementWriter - a line/vector writer, which adds
+ * elements to current page and sets their positions based on the context
+ */
+function ElementWriter(context, tracker) {
+	this.context = context;
+	this.contextStack = [];
+	this.tracker = tracker;
+}
+
+function addPageItem(page, item, index) {
+	if (index === null || index === undefined || index < 0 || index > page.items.length) {
+		page.items.push(item);
+	} else {
+		page.items.splice(index, 0, item);
+	}
+}
+
+ElementWriter.prototype.addLine = function (line, dontUpdateContextPosition, index) {
+	var height = line.getHeight();
+	var context = this.context;
+	var page = context.getCurrentPage(),
+		position = this.getCurrentPositionOnPage();
+
+	if (context.availableHeight < height || !page) {
+		return false;
+	}
+
+	line.x = context.x + (line.x || 0);
+	line.y = context.y + (line.y || 0);
+
+	this.alignLine(line);
+
+	addPageItem(page, {
+		type: 'line',
+		item: line
+	}, index);
+	this.tracker.emit('lineAdded', line);
+
+	if (!dontUpdateContextPosition) {
+		context.moveDown(height);
+	}
+
+	return position;
+};
+
+ElementWriter.prototype.alignLine = function (line) {
+	var width = this.context.availableWidth;
+	var lineWidth = line.getWidth();
+
+	var alignment = line.inlines && line.inlines.length > 0 && line.inlines[0].alignment;
+	var isRTL = line.isRTL && line.isRTL();
+
+	var offset = 0;
+	
+	// For RTL lines, we need special handling
+	if (isRTL) {
+		// If it's RTL and no explicit alignment, default to right
+		if (!alignment || alignment === 'left') {
+			alignment = 'right';
+		}
+		
+		// For RTL, we need to reverse the order of inlines and adjust their positions
+		this.adjustRTLInlines(line, width);
+	}
+
+	switch (alignment) {
+		case 'right':
+			offset = width - lineWidth;
+			break;
+		case 'center':
+			offset = (width - lineWidth) / 2;
+			break;
+	}
+
+	if (offset) {
+		line.x = (line.x || 0) + offset;
+	}
+
+	if (alignment === 'justify' &&
+		!line.newLineForced &&
+		!line.lastLineInParagraph &&
+		line.inlines.length > 1) {
+		var additionalSpacing = (width - lineWidth) / (line.inlines.length - 1);
+
+		for (var i = 1, l = line.inlines.length; i < l; i++) {
+			offset = i * additionalSpacing;
+
+			line.inlines[i].x += offset;
+			line.inlines[i].justifyShift = additionalSpacing;
+		}
+	}
+};
+
+ElementWriter.prototype.addImage = function (image, index, type) {
+	var context = this.context;
+	var page = context.getCurrentPage(),
+		position = this.getCurrentPositionOnPage();
+
+	if (!page || (image.absolutePosition === undefined && context.availableHeight < image._height && page.items.length > 0)) {
+		return false;
+	}
+
+	if (image._x === undefined) {
+		image._x = image.x || 0;
+	}
+
+	image.x = context.x + image._x;
+	image.y = context.y;
+
+	this.alignImage(image);
+
+	addPageItem(page, {
+		type: type || 'image',
+		item: image
+	}, index);
+
+	context.moveDown(image._height);
+
+	return position;
+};
+
+ElementWriter.prototype.addSVG = function (image, index) {
+	return this.addImage(image, index, 'svg');
+};
+
+ElementWriter.prototype.addQr = function (qr, index) {
+	var context = this.context;
+	var page = context.getCurrentPage(),
+		position = this.getCurrentPositionOnPage();
+
+	if (!page || (qr.absolutePosition === undefined && context.availableHeight < qr._height)) {
+		return false;
+	}
+
+	if (qr._x === undefined) {
+		qr._x = qr.x || 0;
+	}
+
+	qr.x = context.x + qr._x;
+	qr.y = context.y;
+
+	this.alignImage(qr);
+
+	for (var i = 0, l = qr._canvas.length; i < l; i++) {
+		var vector = qr._canvas[i];
+		vector.x += qr.x;
+		vector.y += qr.y;
+		this.addVector(vector, true, true, index);
+	}
+
+	context.moveDown(qr._height);
+
+	return position;
+};
+
+ElementWriter.prototype.alignImage = function (image) {
+	var width = this.context.availableWidth;
+	var imageWidth = image._minWidth;
+	var offset = 0;
+	switch (image._alignment) {
+		case 'right':
+			offset = width - imageWidth;
+			break;
+		case 'center':
+			offset = (width - imageWidth) / 2;
+			break;
+	}
+
+	if (offset) {
+		image.x = (image.x || 0) + offset;
+	}
+};
+
+ElementWriter.prototype.alignCanvas = function (node) {
+	var width = this.context.availableWidth;
+	var canvasWidth = node._minWidth;
+	var offset = 0;
+	switch (node._alignment) {
+		case 'right':
+			offset = width - canvasWidth;
+			break;
+		case 'center':
+			offset = (width - canvasWidth) / 2;
+			break;
+	}
+	if (offset) {
+		node.canvas.forEach(function (vector) {
+			offsetVector(vector, offset, 0);
+		});
+	}
+};
+
+ElementWriter.prototype.addVector = function (vector, ignoreContextX, ignoreContextY, index, forcePage) {
+	var context = this.context;
+	var page = context.getCurrentPage();
+	if (isNumber(forcePage)) {
+		page = context.pages[forcePage];
+	}
+	var position = this.getCurrentPositionOnPage();
+
+	if (page) {
+		offsetVector(vector, ignoreContextX ? 0 : context.x, ignoreContextY ? 0 : context.y);
+		addPageItem(page, {
+			type: 'vector',
+			item: vector
+		}, index);
+		return position;
+	}
+};
+
+ElementWriter.prototype.beginClip = function (width, height) {
+	var ctx = this.context;
+	var page = ctx.getCurrentPage();
+	page.items.push({
+		type: 'beginClip',
+		item: { x: ctx.x, y: ctx.y, width: width, height: height }
+	});
+	return true;
+};
+
+ElementWriter.prototype.endClip = function () {
+	var ctx = this.context;
+	var page = ctx.getCurrentPage();
+	page.items.push({
+		type: 'endClip'
+	});
+	return true;
+};
+
+/**
+ * Adjust RTL inline positioning
+ * @param {Line} line - Line containing RTL text
+ * @param {number} availableWidth - Available width for the line
+ */
+ElementWriter.prototype.adjustRTLInlines = function (line, availableWidth) {
+	if (!line.inlines || line.inlines.length === 0) {
+		return;
+	}
+
+	// For RTL text, we need to reverse the visual order of inlines
+	// and recalculate their positions from right to left
+	var rtlInlines = [];
+	var ltrInlines = [];
+	var neutralInlines = [];
+
+	// Separate RTL, LTR, and neutral inlines
+	line.inlines.forEach(function(inline) {
+		if (inline.isRTL || inline.direction === 'rtl') {
+			rtlInlines.push(inline);
+		} else if (inline.direction === 'ltr') {
+			ltrInlines.push(inline);
+		} else {
+			neutralInlines.push(inline);
+		}
+	});
+
+	// If we have RTL inlines, reverse their order and recalculate positions
+	if (rtlInlines.length > 0) {
+		// Reverse the order of RTL inlines for proper display
+		rtlInlines.reverse();
+
+		// Recalculate x positions from right to left
+		var currentX = 0;
+		var reorderedInlines = [];
+
+		// Add LTR inlines first (if any)
+		ltrInlines.forEach(function(inline) {
+			inline.x = currentX;
+			currentX += inline.width;
+			reorderedInlines.push(inline);
+		});
+
+		// Add neutral inlines
+		neutralInlines.forEach(function(inline) {
+			inline.x = currentX;
+			currentX += inline.width;
+			reorderedInlines.push(inline);
+		});
+
+		// Add RTL inlines (already reversed)
+		rtlInlines.forEach(function(inline) {
+			inline.x = currentX;
+			currentX += inline.width;
+			reorderedInlines.push(inline);
+		});
+
+		// Replace the line's inlines with the reordered ones
+		line.inlines = reorderedInlines;
+	}
+};
+
+function cloneLine(line) {
+	var result = new Line(line.maxWidth);
+
+	for (var key in line) {
+		if (line.hasOwnProperty(key)) {
+			result[key] = line[key];
+		}
+	}
+
+	return result;
+}
+
+ElementWriter.prototype.addFragment = function (block, useBlockXOffset, useBlockYOffset, dontUpdateContextPosition) {
+	var ctx = this.context;
+	var page = ctx.getCurrentPage();
+
+	if (!useBlockXOffset && block.height > ctx.availableHeight) {
+		return false;
+	}
+
+	block.items.forEach(function (item) {
+		switch (item.type) {
+			case 'line':
+				var l = cloneLine(item.item);
+
+				if (l._node) {
+					l._node.positions[0].pageNumber = ctx.page + 1;
+				}
+				l.x = (l.x || 0) + (useBlockXOffset ? (block.xOffset || 0) : ctx.x);
+				l.y = (l.y || 0) + (useBlockYOffset ? (block.yOffset || 0) : ctx.y);
+
+				page.items.push({
+					type: 'line',
+					item: l
+				});
+				break;
+
+			case 'vector':
+				var v = pack(item.item);
+
+				offsetVector(v, useBlockXOffset ? (block.xOffset || 0) : ctx.x, useBlockYOffset ? (block.yOffset || 0) : ctx.y);
+				if (v._isFillColorFromUnbreakable) {
+					// If the item is a fillColor from an unbreakable block
+					// We have to add it at the beginning of the items body array of the page
+					delete v._isFillColorFromUnbreakable;
+					const endOfBackgroundItemsIndex = ctx.backgroundLength[ctx.page];
+					page.items.splice(endOfBackgroundItemsIndex, 0, {
+						type: 'vector',
+						item: v
+					});
+				} else {
+					page.items.push({
+						type: 'vector',
+						item: v
+					});
+				}
+				break;
+
+			case 'image':
+			case 'svg':
+				var img = pack(item.item);
+
+				img.x = (img.x || 0) + (useBlockXOffset ? (block.xOffset || 0) : ctx.x);
+				img.y = (img.y || 0) + (useBlockYOffset ? (block.yOffset || 0) : ctx.y);
+
+				page.items.push({
+					type: item.type,
+					item: img
+				});
+				break;
+		}
+	});
+
+	if (!dontUpdateContextPosition) {
+		ctx.moveDown(block.height);
+	}
+
+	return true;
+};
+
+/**
+ * Pushes the provided context onto the stack or creates a new one
+ *
+ * pushContext(context) - pushes the provided context and makes it current
+ * pushContext(width, height) - creates and pushes a new context with the specified width and height
+ * pushContext() - creates a new context for unbreakable blocks (with current availableWidth and full-page-height)
+ */
+ElementWriter.prototype.pushContext = function (contextOrWidth, height) {
+	if (contextOrWidth === undefined) {
+		height = this.context.getCurrentPage().height - this.context.pageMargins.top - this.context.pageMargins.bottom;
+		contextOrWidth = this.context.availableWidth;
+	}
+
+	if (isNumber(contextOrWidth)) {
+		contextOrWidth = new DocumentContext({ width: contextOrWidth, height: height }, { left: 0, right: 0, top: 0, bottom: 0 });
+	}
+
+	this.contextStack.push(this.context);
+	this.context = contextOrWidth;
+};
+
+ElementWriter.prototype.popContext = function () {
+	this.context = this.contextStack.pop();
+};
+
+ElementWriter.prototype.getCurrentPositionOnPage = function () {
+	return (this.contextStack[0] || this.context).getCurrentPosition();
+};
+
+
+module.exports = ElementWriter;

package/src/fontProvider.js

@@ -0,0 +1,68 @@
+'use strict';
+
+var isArray = require('./helpers').isArray;
+
+function typeName(bold, italics) {
+	var type = 'normal';
+	if (bold && italics) {
+		type = 'bolditalics';
+	} else if (bold) {
+		type = 'bold';
+	} else if (italics) {
+		type = 'italics';
+	}
+	return type;
+}
+
+function FontProvider(fontDescriptors, pdfKitDoc) {
+	this.fonts = {};
+	this.pdfKitDoc = pdfKitDoc;
+	this.fontCache = {};
+
+	for (var font in fontDescriptors) {
+		if (fontDescriptors.hasOwnProperty(font)) {
+			var fontDef = fontDescriptors[font];
+
+			this.fonts[font] = {
+				normal: fontDef.normal,
+				bold: fontDef.bold,
+				italics: fontDef.italics,
+				bolditalics: fontDef.bolditalics
+			};
+		}
+	}
+}
+
+FontProvider.prototype.getFontType = function (bold, italics) {
+	return typeName(bold, italics);
+};
+
+FontProvider.prototype.getFontFile = function (familyName, bold, italics) {
+	var type = this.getFontType(bold, italics);
+	if (!this.fonts[familyName] || !this.fonts[familyName][type]) {
+		return null;
+	}
+
+	return this.fonts[familyName][type];
+};
+
+FontProvider.prototype.provideFont = function (familyName, bold, italics) {
+	var 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]) {
+		var def = this.fonts[familyName][type];
+		if (!isArray(def)) {
+			def = [def];
+		}
+		this.fontCache[familyName][type] = this.pdfKitDoc.font.apply(this.pdfKitDoc, def)._font;
+	}
+
+	return this.fontCache[familyName][type];
+};
+
+module.exports = FontProvider;

package/src/helpers.js

@@ -0,0 +1,138 @@
+'use strict';
+
+function isString(variable) {
+	return typeof variable === 'string' || variable instanceof String;
+}
+
+function isNumber(variable) {
+	return typeof variable === 'number' || variable instanceof Number;
+}
+
+function isBoolean(variable) {
+	return typeof variable === 'boolean';
+}
+
+function isArray(variable) {
+	return Array.isArray(variable);
+}
+
+function isFunction(variable) {
+	return typeof variable === 'function';
+}
+
+function isObject(variable) {
+	return variable !== null && typeof variable === 'object';
+}
+
+function isNull(variable) {
+	return variable === null;
+}
+
+function isUndefined(variable) {
+	return variable === undefined;
+}
+
+/**
+ * @param {any} variable
+ * @returns {boolean}
+ */
+function isPositiveInteger(variable) {
+	if (!isNumber(variable) || !Number.isInteger(variable) || variable <= 0) {
+		return false;
+	}
+	return true;
+}
+
+function pack() {
+	var result = {};
+
+	for (var i = 0, l = arguments.length; i < l; i++) {
+		var obj = arguments[i];
+
+		if (obj) {
+			for (var key in obj) {
+				if (obj.hasOwnProperty(key)) {
+					result[key] = obj[key];
+				}
+			}
+		}
+	}
+
+	return result;
+}
+
+function offsetVector(vector, x, y) {
+	switch (vector.type) {
+		case 'ellipse':
+		case 'rect':
+			vector.x += x;
+			vector.y += y;
+			break;
+		case 'line':
+			vector.x1 += x;
+			vector.x2 += x;
+			vector.y1 += y;
+			vector.y2 += y;
+			break;
+		case 'polyline':
+			for (var i = 0, l = vector.points.length; i < l; i++) {
+				vector.points[i].x += x;
+				vector.points[i].y += y;
+			}
+			break;
+	}
+}
+
+function fontStringify(key, val) {
+	if (key === 'font') {
+		return 'font';
+	}
+	return val;
+}
+
+function getNodeId(node) {
+	if (node.id) {
+		return node.id;
+	}
+
+	if (isArray(node.text)) {
+		for (var i = 0, l = node.text.length; i < l; i++) {
+			var n = node.text[i];
+			var nodeId = getNodeId(n);
+			if (nodeId) {
+				return nodeId;
+			}
+		}
+	}
+
+	return null;
+}
+
+function isPattern(color) {
+	return isArray(color) && color.length === 2;
+}
+
+// converts from a [<pattern name>, <color>] as used by pdfmake
+// into [<pattern object>, <color>] as used by pdfkit
+// (the pattern has to be registered in the doc definition of course)
+function getPattern(color, patterns) {
+	return [patterns[color[0]], color[1]];
+}
+
+module.exports = {
+	isString: isString,
+	isNumber: isNumber,
+	isBoolean: isBoolean,
+	isArray: isArray,
+	isFunction: isFunction,
+	isObject: isObject,
+	isNull: isNull,
+	isUndefined: isUndefined,
+	isPositiveInteger: isPositiveInteger,
+	pack: pack,
+	fontStringify: fontStringify,
+	offsetVector: offsetVector,
+	getNodeId: getNodeId,
+	isPattern: isPattern,
+	getPattern: getPattern
+};

package/src/imageMeasure.js

@@ -0,0 +1,62 @@
+'use strict';
+
+var fs = require('fs');
+
+function ImageMeasure(pdfKitDoc, imageDictionary) {
+	this.pdfKitDoc = pdfKitDoc;
+	this.imageDictionary = imageDictionary || {};
+}
+
+ImageMeasure.prototype.measureImage = function (src) {
+	var image;
+	var that = this;
+
+	if (!this.pdfKitDoc._imageRegistry[src]) {
+		try {
+			image = this.pdfKitDoc.openImage(realImageSrc(src));
+			if (!image) {
+				throw 'No image';
+			}
+		} catch (error) {
+			throw 'Invalid image: ' + error.toString() + '\nImages dictionary should contain dataURL entries (or local file paths in node.js)';
+		}
+		image.embed(this.pdfKitDoc);
+		this.pdfKitDoc._imageRegistry[src] = image;
+	} else {
+		image = this.pdfKitDoc._imageRegistry[src];
+	}
+
+	var imageSize = { width: image.width, height: image.height };
+
+	// If EXIF orientation calls for it, swap width and height
+	if (image.orientation > 4) {
+		imageSize = { width: image.height, height: image.width };
+	}
+
+	return imageSize;
+
+	function realImageSrc(src) {
+		var img = that.imageDictionary[src];
+
+		if (!img) {
+			return src;
+		}
+
+		if (typeof img === 'object') {
+			throw 'Not supported image definition: ' + JSON.stringify(img);
+		}
+
+		if (fs.existsSync(img)) {
+			return fs.readFileSync(img);
+		}
+
+		var index = img.indexOf('base64,');
+		if (index < 0) {
+			return that.imageDictionary[src];
+		}
+
+		return Buffer.from(img.substring(index + 7), 'base64');
+	}
+};
+
+module.exports = ImageMeasure;