pdfmake 0.3.0-beta.9 → 0.3.0

package/src/LayoutBuilder.js

@@ -7,7 +7,7 @@ import TableProcessor from './TableProcessor';
 import Line from './Line';
 import { isString, isValue, isNumber } from './helpers/variableType';
 import { stringifyNode, getNodeId } from './helpers/node';
-import { pack, offsetVector } from './helpers/tools';
+import { pack, offsetVector, convertToDynamicContent } from './helpers/tools';
 import TextInlines from './TextInlines';
 import StyleContextStack from './StyleContextStack';
 
@@ -32,6 +32,7 @@ class LayoutBuilder {
 		this.pageMargins = pageMargins;
 		this.svgMeasure = svgMeasure;
 		this.tableLayouts = {};
+		this.nestedLevel = 0;
 	}
 
 	registerTableLayouts(tableLayouts) {
@@ -71,7 +72,17 @@ class LayoutBuilder {
 				return false;
 			}
 
-			linearNodeList = linearNodeList.filter(node => node.positions.length > 0);
+			const hasRenderableContent = node => {
+				if (!node || node.positions.length === 0) {
+					return false;
+				}
+				if (node.text === '' && !node.listMarker) {
+					return false;
+				}
+				return true;
+			};
+
+			linearNodeList = linearNodeList.filter(hasRenderableContent);
 
 			linearNodeList.forEach(node => {
 				let nodeInfo = {};
@@ -167,23 +178,42 @@ class LayoutBuilder {
 		watermark
 	) {
 
+		const isNecessaryAddFirstPage = (docStructure) => {
+			if (docStructure.stack && docStructure.stack.length > 0 && docStructure.stack[0].section) {
+				return false;
+			} else if (docStructure.section) {
+				return false;
+			}
+
+			return true;
+		};
+
 		this.linearNodeList = [];
 		docStructure = this.docPreprocessor.preprocessDocument(docStructure);
 		docStructure = this.docMeasure.measureDocument(docStructure);
 
-		this.writer = new PageElementWriter(
-			new DocumentContext(this.pageSize, this.pageMargins));
+		this.writer = new PageElementWriter(new DocumentContext());
 
-		this.writer.context().addListener('pageAdded', () => {
-			this.addBackground(background);
+		this.writer.context().addListener('pageAdded', (page) => {
+			let backgroundGetter = background;
+			if (page.customProperties['background'] || page.customProperties['background'] === null) {
+				backgroundGetter = page.customProperties['background'];
+			}
+
+			this.addBackground(backgroundGetter);
 		});
 
-		this.addBackground(background);
+		if (isNecessaryAddFirstPage(docStructure)) {
+			this.writer.addPage(
+				this.pageSize,
+				null,
+				this.pageMargins
+			);
+		}
+
 		this.processNode(docStructure);
 		this.addHeadersAndFooters(header, footer);
-		if (watermark != null) {
-			this.addWatermark(watermark, pdfDocument, defaultStyle);
-		}
+		this.addWatermark(watermark, pdfDocument, defaultStyle);
 
 		return { pages: this.writer.context().pages, linearNodeList: this.linearNodeList };
 	}
@@ -198,31 +228,37 @@ class LayoutBuilder {
 
 		if (pageBackground) {
 			this.writer.beginUnbreakableBlock(pageSize.width, pageSize.height);
-			pageBackground = this.docPreprocessor.preprocessDocument(pageBackground);
-			this.processNode(this.docMeasure.measureDocument(pageBackground));
+			pageBackground = this.docPreprocessor.preprocessBlock(pageBackground);
+			this.processNode(this.docMeasure.measureBlock(pageBackground));
 			this.writer.commitUnbreakableBlock(0, 0);
 			context.backgroundLength[context.page] += pageBackground.positions.length;
 		}
 	}
 
-	addStaticRepeatable(headerOrFooter, sizeFunction) {
-		this.addDynamicRepeatable(() => // copy to new object
-			JSON.parse(JSON.stringify(headerOrFooter)), sizeFunction);
-	}
-
-	addDynamicRepeatable(nodeGetter, sizeFunction) {
+	addDynamicRepeatable(nodeGetter, sizeFunction, customPropertyName) {
 		let pages = this.writer.context().pages;
 
 		for (let pageIndex = 0, l = pages.length; pageIndex < l; pageIndex++) {
 			this.writer.context().page = pageIndex;
 
-			let node = nodeGetter(pageIndex + 1, l, this.writer.context().pages[pageIndex].pageSize);
+			let customProperties = this.writer.context().getCurrentPage().customProperties;
+
+			let pageNodeGetter = nodeGetter;
+			if (customProperties[customPropertyName] || customProperties[customPropertyName] === null) {
+				pageNodeGetter = customProperties[customPropertyName];
+			}
+
+			if ((typeof pageNodeGetter === 'undefined') || (pageNodeGetter === null)) {
+				continue;
+			}
+
+			let node = pageNodeGetter(pageIndex + 1, l, this.writer.context().pages[pageIndex].pageSize);
 
 			if (node) {
-				let sizes = sizeFunction(this.writer.context().getCurrentPage().pageSize, this.pageMargins);
+				let sizes = sizeFunction(this.writer.context().getCurrentPage().pageSize, this.writer.context().getCurrentPage().pageMargins);
 				this.writer.beginUnbreakableBlock(sizes.width, sizes.height);
-				node = this.docPreprocessor.preprocessDocument(node);
-				this.processNode(this.docMeasure.measureDocument(node));
+				node = this.docPreprocessor.preprocessBlock(node);
+				this.processNode(this.docMeasure.measureBlock(node));
 				this.writer.commitUnbreakableBlock(sizes.x, sizes.y);
 			}
 		}
@@ -243,58 +279,62 @@ class LayoutBuilder {
 			height: pageMargins.bottom
 		});
 
-		if (typeof header === 'function') {
-			this.addDynamicRepeatable(header, headerSizeFct);
-		} else if (header) {
-			this.addStaticRepeatable(header, headerSizeFct);
-		}
-
-		if (typeof footer === 'function') {
-			this.addDynamicRepeatable(footer, footerSizeFct);
-		} else if (footer) {
-			this.addStaticRepeatable(footer, footerSizeFct);
-		}
+		this.addDynamicRepeatable(header, headerSizeFct, 'header');
+		this.addDynamicRepeatable(footer, footerSizeFct, 'footer');
 	}
 
 	addWatermark(watermark, pdfDocument, defaultStyle) {
-		if (isString(watermark)) {
-			watermark = { 'text': watermark };
-		}
+		let pages = this.writer.context().pages;
+		for (let i = 0, l = pages.length; i < l; i++) {
+			let pageWatermark = watermark;
+			if (pages[i].customProperties['watermark'] || pages[i].customProperties['watermark'] === null) {
+				pageWatermark = pages[i].customProperties['watermark'];
+			}
 
-		if (!watermark.text) { // empty watermark text
-			return;
-		}
+			if (pageWatermark === undefined || pageWatermark === null) {
+				continue;
+			}
 
-		watermark.font = watermark.font || defaultStyle.font || 'Roboto';
-		watermark.fontSize = watermark.fontSize || 'auto';
-		watermark.color = watermark.color || 'black';
-		watermark.opacity = isNumber(watermark.opacity) ? watermark.opacity : 0.6;
-		watermark.bold = watermark.bold || false;
-		watermark.italics = watermark.italics || false;
-		watermark.angle = isValue(watermark.angle) ? watermark.angle : null;
+			if (isString(pageWatermark)) {
+				pageWatermark = { 'text': pageWatermark };
+			}
 
-		if (watermark.angle === null) {
-			watermark.angle = Math.atan2(this.pageSize.height, this.pageSize.width) * -180 / Math.PI;
-		}
+			if (!pageWatermark.text) { // empty watermark text
+				continue;
+			}
 
-		if (watermark.fontSize === 'auto') {
-			watermark.fontSize = getWatermarkFontSize(this.pageSize, watermark, pdfDocument);
+			pages[i].watermark = getWatermarkObject({ ...pageWatermark }, pages[i].pageSize, pdfDocument, defaultStyle);
 		}
 
-		let watermarkObject = {
-			text: watermark.text,
-			font: pdfDocument.provideFont(watermark.font, watermark.bold, watermark.italics),
-			fontSize: watermark.fontSize,
-			color: watermark.color,
-			opacity: watermark.opacity,
-			angle: watermark.angle
-		};
+		function getWatermarkObject(watermark, pageSize, pdfDocument, defaultStyle) {
+			watermark.font = watermark.font || defaultStyle.font || 'Roboto';
+			watermark.fontSize = watermark.fontSize || 'auto';
+			watermark.color = watermark.color || 'black';
+			watermark.opacity = isNumber(watermark.opacity) ? watermark.opacity : 0.6;
+			watermark.bold = watermark.bold || false;
+			watermark.italics = watermark.italics || false;
+			watermark.angle = isValue(watermark.angle) ? watermark.angle : null;
+
+			if (watermark.angle === null) {
+				watermark.angle = Math.atan2(pageSize.height, pageSize.width) * -180 / Math.PI;
+			}
 
-		watermarkObject._size = getWatermarkSize(watermark, pdfDocument);
+			if (watermark.fontSize === 'auto') {
+				watermark.fontSize = getWatermarkFontSize(pageSize, watermark, pdfDocument);
+			}
 
-		let pages = this.writer.context().pages;
-		for (let i = 0, l = pages.length; i < l; i++) {
-			pages[i].watermark = watermarkObject;
+			let watermarkObject = {
+				text: watermark.text,
+				font: pdfDocument.provideFont(watermark.font, watermark.bold, watermark.italics),
+				fontSize: watermark.fontSize,
+				color: watermark.color,
+				opacity: watermark.opacity,
+				angle: watermark.angle
+			};
+
+			watermarkObject._size = getWatermarkSize(watermark, pdfDocument);
+
+			return watermarkObject;
 		}
 
 		function getWatermarkSize(watermark, pdfDocument) {
@@ -369,16 +409,50 @@ class LayoutBuilder {
 				}
 			}
 
-			if (margin) {
-				this.writer.context().moveDown(margin[1]);
+			const isDetachedBlock = node.relativePosition || node.absolutePosition;
+
+			// Detached nodes have no margins, their position is only determined by 'x' and 'y'
+			if (margin && !isDetachedBlock) {
+				const availableHeight = this.writer.context().availableHeight;
+				// If top margin is bigger than available space, move to next page
+				// Necessary for nodes inside tables
+				if (availableHeight - margin[1] < 0) {
+					// Consume the whole available space
+					this.writer.context().moveDown(availableHeight);
+					this.writer.moveToNextPage(node.pageOrientation);
+					/**
+					 * TODO - Something to consider:
+					 * Right now the node starts at the top of next page (after header)
+					 * Another option would be to apply just the top margin that has not been consumed in the page before
+					 * It would something like: this.write.context().moveDown(margin[1] - availableHeight)
+					 */
+				} else {
+					this.writer.context().moveDown(margin[1]);
+				}
+				// Apply lateral margins
 				this.writer.context().addMargin(margin[0], margin[2]);
 			}
-
 			callback();
 
-			if (margin) {
+			// Detached nodes have no margins, their position is only determined by 'x' and 'y'
+			if (margin && !isDetachedBlock) {
+				const availableHeight = this.writer.context().availableHeight;
+				// If bottom margin is bigger than available space, move to next page
+				// Necessary for nodes inside tables
+				if (availableHeight - margin[3] < 0) {
+					this.writer.context().moveDown(availableHeight);
+					this.writer.moveToNextPage(node.pageOrientation);
+					/**
+					 * TODO - Something to consider:
+					 * Right now next node starts at the top of next page (after header)
+					 * Another option would be to apply the bottom margin that has not been consumed in the next page?
+					 * It would something like: this.write.context().moveDown(margin[3] - availableHeight)
+					 */
+				} else {
+					this.writer.context().moveDown(margin[3]);
+				}
+				// Apply lateral margins
 				this.writer.context().addMargin(-margin[0], -margin[2]);
-				this.writer.context().moveDown(margin[3]);
 			}
 
 			if (node.pageBreak === 'after') {
@@ -419,6 +493,8 @@ class LayoutBuilder {
 
 			if (node.stack) {
 				this.processVerticalContainer(node);
+			} else if (node.section) {
+				this.processSection(node);
 			} else if (node.columns) {
 				this.processColumns(node);
 			} else if (node.ul) {
@@ -465,8 +541,78 @@ class LayoutBuilder {
 		}, this);
 	}
 
+	// section
+	processSection(sectionNode) {
+		// TODO: properties
+
+		let page = this.writer.context().getCurrentPage();
+		if (!page || (page && page.items.length)) { // move to new empty page
+			// page definition inherit from current page
+			if (sectionNode.pageSize === 'inherit') {
+				sectionNode.pageSize = page ? { width: page.pageSize.width, height: page.pageSize.height } : undefined;
+			}
+			if (sectionNode.pageOrientation === 'inherit') {
+				sectionNode.pageOrientation = page ? page.pageSize.orientation : undefined;
+			}
+			if (sectionNode.pageMargins === 'inherit') {
+				sectionNode.pageMargins = page ? page.pageMargins : undefined;
+			}
+
+			if (sectionNode.header === 'inherit') {
+				sectionNode.header = page ? page.customProperties.header : undefined;
+			}
+
+			if (sectionNode.footer === 'inherit') {
+				sectionNode.footer = page ? page.customProperties.footer : undefined;
+			}
+
+			if (sectionNode.background === 'inherit') {
+				sectionNode.background = page ? page.customProperties.background : undefined;
+			}
+
+			if (sectionNode.watermark === 'inherit') {
+				sectionNode.watermark = page ? page.customProperties.watermark : undefined;
+			}
+
+			if (sectionNode.header && typeof sectionNode.header !== 'function' && sectionNode.header !== null) {
+				sectionNode.header = convertToDynamicContent(sectionNode.header);
+			}
+
+			if (sectionNode.footer && typeof sectionNode.footer !== 'function' && sectionNode.footer !== null) {
+				sectionNode.footer = convertToDynamicContent(sectionNode.footer);
+			}
+
+			let customProperties = {};
+			if (typeof sectionNode.header !== 'undefined') {
+				customProperties.header = sectionNode.header;
+			}
+
+			if (typeof sectionNode.footer !== 'undefined') {
+				customProperties.footer = sectionNode.footer;
+			}
+
+			if (typeof sectionNode.background !== 'undefined') {
+				customProperties.background = sectionNode.background;
+			}
+
+			if (typeof sectionNode.watermark !== 'undefined') {
+				customProperties.watermark = sectionNode.watermark;
+			}
+
+			this.writer.addPage(
+				sectionNode.pageSize || this.pageSize,
+				sectionNode.pageOrientation,
+				sectionNode.pageMargins || this.pageMargins,
+				customProperties
+			);
+		}
+
+		this.processNode(sectionNode.section);
+	}
+
 	// columns
 	processColumns(columnNode) {
+		this.nestedLevel++;
 		let columns = columnNode.columns;
 		let availableWidth = this.writer.context().availableWidth;
 		let gaps = gapArray(columnNode._gap);
@@ -476,9 +622,17 @@ class LayoutBuilder {
 		}
 
 		ColumnCalculator.buildColumnWidths(columns, availableWidth);
-		let result = this.processRow(columns, columns, gaps);
+		let result = this.processRow({
+			marginX: columnNode._margin ? [columnNode._margin[0], columnNode._margin[2]] : [0, 0],
+			cells: columns,
+			widths: columns,
+			gaps
+		});
 		addAll(columnNode.positions, result.positions);
-
+		this.nestedLevel--;
+		if (this.nestedLevel === 0) {
+			this.writer.context().resetMarginXTopParent();
+		}
 		function gapArray(gap) {
 			if (!gap) {
 				return null;
@@ -495,130 +649,306 @@ class LayoutBuilder {
 		}
 	}
 
-	findStartingSpanCell(arr, i) {
+	/**
+	* Searches for a cell in the same row that starts a rowspan and is positioned immediately before the current cell.
+	* Alternatively, it finds a cell where the colspan initiating the rowspan extends to the cell just before the current one.
+	*
+	* @param {Array<object>} arr - An array representing cells in a row.
+	* @param {number} i - The index of the current cell to search backward from.
+	* @returns {object|null} The starting cell of the rowspan if found; otherwise, `null`.
+	*/
+	_findStartingRowSpanCell(arr, i) {
 		let requiredColspan = 1;
-    for (let index = i - 1; index >= 0; index--) {
-        if (!arr[index]._span) {
-					if (arr[index].rowSpan > 1 && (arr[index].colSpan || 1) === requiredColspan) {
-            return arr[index];
-					} else {
-						return null;
-					}
-        }
-				requiredColspan++;
-    }
-    return null;
+		for (let index = i - 1; index >= 0; index--) {
+			if (!arr[index]._span) {
+				if (arr[index].rowSpan > 1 && (arr[index].colSpan || 1) === requiredColspan) {
+					return arr[index];
+				} else {
+					return null;
+				}
+			}
+			requiredColspan++;
+		}
+		return null;
+	}
+
+	/**
+	* Retrieves a page break description for a specified page from a list of page breaks.
+	*
+	* @param {Array<object>} pageBreaks - An array of page break descriptions, each containing `prevPage` properties.
+	* @param {number} page - The page number to find the associated page break for.
+	* @returns {object|undefined} The page break description object for the specified page if found; otherwise, `undefined`.
+	*/
+	_getPageBreak(pageBreaks, page) {
+		return pageBreaks.find(desc => desc.prevPage === page);
+	}
+
+	_getPageBreakListBySpan(tableNode, page, rowIndex) {
+		if (!tableNode || !tableNode._breaksBySpan) {
+			return null;
+		}
+		const breaksList = tableNode._breaksBySpan.filter(desc => desc.prevPage === page && rowIndex <= desc.rowIndexOfSpanEnd);
+
+		let y = Number.MAX_VALUE,
+			prevY = Number.MIN_VALUE;
+
+		breaksList.forEach(b => {
+			prevY = Math.max(b.prevY, prevY);
+			y = Math.min(b.y, y);
+		});
+
+		return {
+			prevPage: page,
+			prevY: prevY,
+			y: y
+		};
+	}
+
+	_findSameRowPageBreakByRowSpanData(breaksBySpan, page, rowIndex) {
+		if (!breaksBySpan) {
+			return null;
+		}
+		return breaksBySpan.find(desc => desc.prevPage === page && rowIndex === desc.rowIndexOfSpanEnd);
 	}
 
-	processRow(columns, widths, gaps, tableBody, tableRow, height) {
-		const storePageBreakData = data => {
-			let pageDesc;
+	_updatePageBreaksData(pageBreaks, tableNode, rowIndex) {
+		Object.keys(tableNode._bottomByPage).forEach(p => {
+			const page = Number(p);
+			const pageBreak = this._getPageBreak(pageBreaks, page);
+			if (pageBreak) {
+				pageBreak.prevY = Math.max(pageBreak.prevY, tableNode._bottomByPage[page]);
+			}
+			if (tableNode._breaksBySpan && tableNode._breaksBySpan.length > 0) {
+				const breaksBySpanList = tableNode._breaksBySpan.filter(pb => pb.prevPage === page && rowIndex <= pb.rowIndexOfSpanEnd);
 
-			for (let i = 0, l = pageBreaks.length; i < l; i++) {
-				let desc = pageBreaks[i];
-				if (desc.prevPage === data.prevPage) {
-					pageDesc = desc;
-					break;
+				if (breaksBySpanList && breaksBySpanList.length > 0) {
+					breaksBySpanList.forEach(b => {
+						b.prevY = Math.max(b.prevY, tableNode._bottomByPage[page]);
+					});
 				}
 			}
+		});
+	}
+
+	/**
+	* Resolves the Y-coordinates for a target object by comparing two break points.
+	*
+	* @param {object} break1 - The first break point with `prevY` and `y` properties.
+	* @param {object} break2 - The second break point with `prevY` and `y` properties.
+	* @param {object} target - The target object to be updated with resolved Y-coordinates.
+	* @property {number} target.prevY - Updated to the maximum `prevY` value between `break1` and `break2`.
+	* @property {number} target.y - Updated to the minimum `y` value between `break1` and `break2`.
+	*/
+	_resolveBreakY(break1, break2, target) {
+		target.prevY = Math.max(break1.prevY, break2.prevY);
+		target.y = Math.min(break1.y, break2.y);
+	};
 
+	_storePageBreakData(data, startsRowSpan, pageBreaks, tableNode) {
+		if (!startsRowSpan) {
+			let pageDesc = this._getPageBreak(pageBreaks, data.prevPage);
+			let pageDescBySpan = this._getPageBreakListBySpan(tableNode, data.prevPage, data.rowIndex);
 			if (!pageDesc) {
-				pageDesc = data;
+				pageDesc = {
+					...data
+				};
 				pageBreaks.push(pageDesc);
 			}
-			pageDesc.prevY = Math.max(pageDesc.prevY, data.prevY);
-			pageDesc.y = Math.min(pageDesc.y, data.y);
-		};
+			if (pageDescBySpan) {
+				this._resolveBreakY(pageDesc, pageDescBySpan, pageDesc);
+			}
+			this._resolveBreakY(pageDesc, data, pageDesc);
+		} else {
+			const breaksBySpan = tableNode && tableNode._breaksBySpan || null;
+			let pageDescBySpan = this._findSameRowPageBreakByRowSpanData(breaksBySpan, data.prevPage, data.rowIndex);
+			if (!pageDescBySpan) {
+				pageDescBySpan = {
+					...data,
+					rowIndexOfSpanEnd: data.rowIndex + data.rowSpan - 1
+				};
+				if (!tableNode._breaksBySpan) {
+					tableNode._breaksBySpan = [];
+				}
+				tableNode._breaksBySpan.push(pageDescBySpan);
+			}
+			pageDescBySpan.prevY = Math.max(pageDescBySpan.prevY, data.prevY);
+			pageDescBySpan.y = Math.min(pageDescBySpan.y, data.y);
+			let pageDesc = this._getPageBreak(pageBreaks, data.prevPage);
+			if (pageDesc) {
+				this._resolveBreakY(pageDesc, pageDescBySpan, pageDesc);
+			}
+		}
+	};
+
+	/**
+	* Calculates the left offset for a column based on the specified gap values.
+	*
+	* @param {number} i - The index of the column for which the offset is being calculated.
+	* @param {Array<number>} gaps - An array of gap values for each column.
+	* @returns {number} The left offset for the column. Returns `gaps[i]` if it exists, otherwise `0`.
+	*/
+	_colLeftOffset(i, gaps) {
+		if (gaps && gaps.length > i) {
+			return gaps[i];
+		}
+		return 0;
+	}
+
+	/**
+	* Retrieves the ending cell for a row span in case it exists in a specified table column.
+	*
+	* @param {Array<Array<object>>} tableBody - The table body, represented as a 2D array of cell objects.
+	* @param {number} rowIndex - The index of the starting row for the row span.
+	* @param {object} column - The column object containing row span information.
+	* @param {number} columnIndex - The index of the column within the row.
+	* @returns {object|null} The cell at the end of the row span if it exists; otherwise, `null`.
+	* @throws {Error} If the row span extends beyond the total row count.
+	*/
+	_getRowSpanEndingCell(tableBody, rowIndex, column, columnIndex) {
+		if (column.rowSpan && column.rowSpan > 1) {
+			let endingRow = rowIndex + column.rowSpan - 1;
+			if (endingRow >= tableBody.length) {
+				throw new Error(`Row span for column ${columnIndex} (with indexes starting from 0) exceeded row count`);
+			}
+			return tableBody[endingRow][columnIndex];
+		}
 
+		return null;
+	}
+
+	processRow({ marginX = [0, 0], dontBreakRows = false, rowsWithoutPageBreak = 0, cells, widths, gaps, tableNode, tableBody, rowIndex, height }) {
+		const isUnbreakableRow = dontBreakRows || rowIndex <= rowsWithoutPageBreak - 1;
 		let pageBreaks = [];
+		let pageBreaksByRowSpan = [];
 		let positions = [];
+		let willBreakByHeight = false;
+		widths = widths || cells;
+
+		// Check if row should break by height
+		if (!isUnbreakableRow && height > this.writer.context().availableHeight) {
+			willBreakByHeight = true;
+		}
 
-		this.writer.addListener('pageChanged', storePageBreakData);
+		// Use the marginX if we are in a top level table/column (not nested)
+		const marginXParent = this.nestedLevel === 1 ? marginX : null;
+		const _bottomByPage = tableNode ? tableNode._bottomByPage : null;
+		this.writer.context().beginColumnGroup(marginXParent, _bottomByPage);
 
-		widths = widths || columns;
+		for (let i = 0, l = cells.length; i < l; i++) {
+			let cell = cells[i];
 
-		this.writer.context().beginColumnGroup();
+			// Page change handler
+			const storePageBreakClosure = data => {
+				const startsRowSpan = cell.rowSpan && cell.rowSpan > 1;
+				if (startsRowSpan) {
+					data.rowSpan = cell.rowSpan;
+				}
+				data.rowIndex = rowIndex;
+				this._storePageBreakData(data, startsRowSpan, pageBreaks, tableNode);
+			};
+
+			this.writer.addListener('pageChanged', storePageBreakClosure);
 
-		for (let i = 0, l = columns.length; i < l; i++) {
-			let column = columns[i];
 			let width = widths[i]._calcWidth;
-			let leftOffset = colLeftOffset(i);
+			let leftOffset = this._colLeftOffset(i, gaps);
+			// Check if exists and retrieve the cell that started the rowspan in case we are in the cell just after
+			let startingSpanCell = this._findStartingRowSpanCell(cells, i);
 
-			if (column.colSpan && column.colSpan > 1) {
-				for (let j = 1; j < column.colSpan; j++) {
+			if (cell.colSpan && cell.colSpan > 1) {
+				for (let j = 1; j < cell.colSpan; j++) {
 					width += widths[++i]._calcWidth + gaps[i];
 				}
 			}
 
 			// if rowspan starts in this cell, we retrieve the last cell affected by the rowspan
-			const endingCell = getEndingCell(column, i);
-			if (endingCell) {
+			const rowSpanEndingCell = this._getRowSpanEndingCell(tableBody, rowIndex, cell, i);
+			if (rowSpanEndingCell) {
 				// We store a reference of the ending cell in the first cell of the rowspan
-				column._endingCell = endingCell;
+				cell._endingCell = rowSpanEndingCell;
+				cell._endingCell._startingRowSpanY = cell._startingRowSpanY;
 			}
 
-			// Check if exists and retrieve the cell that started the rowspan in case we are in the cell just after
-			let startingSpanCell = this.findStartingSpanCell(columns, i);
-			let endingSpanCell = null;
+			// If we are after a cell that started a rowspan
+			let endOfRowSpanCell = null;
 			if (startingSpanCell && startingSpanCell._endingCell) {
 				// Reference to the last cell of the rowspan
-				endingSpanCell = startingSpanCell._endingCell;
+				endOfRowSpanCell = startingSpanCell._endingCell;
+				// Store if we are in an unbreakable block when we save the context and the originalX
+				if (this.writer.transactionLevel > 0) {
+					endOfRowSpanCell._isUnbreakableContext = true;
+					endOfRowSpanCell._originalXOffset = this.writer.originalX;
+				}
 			}
 
 			// We pass the endingSpanCell reference to store the context just after processing rowspan cell
-			this.writer.context().beginColumn(width, leftOffset, endingSpanCell);
-			if (!column._span) {
-				this.processNode(column);
-				addAll(positions, column.positions);
-			} else if (column._columnEndingContext) {
+			this.writer.context().beginColumn(width, leftOffset, endOfRowSpanCell);
+
+			if (!cell._span) {
+				this.processNode(cell);
+				this.writer.context().updateBottomByPage();
+				addAll(positions, cell.positions);
+			} else if (cell._columnEndingContext) {
+				let discountY = 0;
+				if (dontBreakRows) {
+					// Calculate how many points we have to discount to Y when dontBreakRows and rowSpan are combined
+					const ctxBeforeRowSpanLastRow = this.writer.contextStack[this.writer.contextStack.length - 1];
+					discountY = ctxBeforeRowSpanLastRow.y - cell._startingRowSpanY;
+				}
+				let originalXOffset = 0;
+				// If context was saved from an unbreakable block and we are not in an unbreakable block anymore
+				// We have to sum the originalX (X before starting unbreakable block) to X
+				if (cell._isUnbreakableContext && !this.writer.transactionLevel) {
+					originalXOffset = cell._originalXOffset;
+				}
 				// row-span ending
 				// Recover the context after processing the rowspanned cell
-				this.writer.context().markEnding(column);
+				this.writer.context().markEnding(cell, originalXOffset, discountY);
 			}
+			this.writer.removeListener('pageChanged', storePageBreakClosure);
 		}
 
 		// Check if last cell is part of a span
 		let endingSpanCell = null;
-		const lastColumn = columns.length > 0 ? columns[columns.length - 1] : null;
+		const lastColumn = cells.length > 0 ? cells[cells.length - 1] : null;
 		if (lastColumn) {
 			// Previous column cell has a rowspan
 			if (lastColumn._endingCell) {
 				endingSpanCell = lastColumn._endingCell;
-			// Previous column cell is part of a span
+				// Previous column cell is part of a span
 			} else if (lastColumn._span === true) {
 				// We get the cell that started the span where we set a reference to the ending cell
-				const startingSpanCell = this.findStartingSpanCell(columns, columns.length);
+				const startingSpanCell = this._findStartingRowSpanCell(cells, cells.length);
 				if (startingSpanCell) {
 					// Context will be stored here (ending cell)
 					endingSpanCell = startingSpanCell._endingCell;
+					// Store if we are in an unbreakable block when we save the context and the originalX
+					if (this.writer.transactionLevel > 0) {
+						endingSpanCell._isUnbreakableContext = true;
+						endingSpanCell._originalXOffset = this.writer.originalX;
+					}
 				}
 			}
 		}
 
-		this.writer.context().completeColumnGroup(height, endingSpanCell);
-
-		this.writer.removeListener('pageChanged', storePageBreakData);
-
-		return { pageBreaks: pageBreaks, positions: positions };
-
-		function colLeftOffset(i) {
-			if (gaps && gaps.length > i) {
-				return gaps[i];
-			}
-			return 0;
+		// If content did not break page, check if we should break by height
+		if (willBreakByHeight && !isUnbreakableRow && pageBreaks.length === 0) {
+			this.writer.context().moveDown(this.writer.context().availableHeight);
+			this.writer.moveToNextPage();
 		}
 
-		function getEndingCell(column, columnIndex) {
-			if (column.rowSpan && column.rowSpan > 1) {
-				let endingRow = tableRow + column.rowSpan - 1;
-				if (endingRow >= tableBody.length) {
-					throw new Error(`Row span for column ${columnIndex} (with indexes starting from 0) exceeded row count`);
-				}
-				return tableBody[endingRow][columnIndex];
-			}
+		const bottomByPage = this.writer.context().completeColumnGroup(height, endingSpanCell);
 
-			return null;
+		if (tableNode) {
+			tableNode._bottomByPage = bottomByPage;
+			// If there are page breaks in this row, update data with prevY of last cell
+			this._updatePageBreaksData(pageBreaks, tableNode, rowIndex);
 		}
+
+		return {
+			pageBreaksBySpan: pageBreaksByRowSpan,
+			pageBreaks: pageBreaks,
+			positions: positions
+		};
 	}
 
 	// lists
@@ -667,12 +997,23 @@ class LayoutBuilder {
 
 	// tables
 	processTable(tableNode) {
+		this.nestedLevel++;
 		let processor = new TableProcessor(tableNode);
 
 		processor.beginTable(this.writer);
 
 		let rowHeights = tableNode.table.heights;
 		for (let i = 0, l = tableNode.table.body.length; i < l; i++) {
+			// if dontBreakRows and row starts a rowspan
+			// we store the 'y' of the beginning of each rowSpan
+			if (processor.dontBreakRows) {
+				tableNode.table.body[i].forEach(cell => {
+					if (cell.rowSpan && cell.rowSpan > 1) {
+						cell._startingRowSpanY = this.writer.context().y;
+					}
+				});
+			}
+
 			processor.beginRow(i, this.writer);
 
 			let height;
@@ -688,13 +1029,40 @@ class LayoutBuilder {
 				height = undefined;
 			}
 
-			let result = this.processRow(tableNode.table.body[i], tableNode.table.widths, tableNode._offsets.offsets, tableNode.table.body, i, height);
+			const pageBeforeProcessing = this.writer.context().page;
+
+			let result = this.processRow({
+				marginX: tableNode._margin ? [tableNode._margin[0], tableNode._margin[2]] : [0, 0],
+				dontBreakRows: processor.dontBreakRows,
+				rowsWithoutPageBreak: processor.rowsWithoutPageBreak,
+				cells: tableNode.table.body[i],
+				widths: tableNode.table.widths,
+				gaps: tableNode._offsets.offsets,
+				tableBody: tableNode.table.body,
+				tableNode,
+				rowIndex: i,
+				height
+			});
+
 			addAll(tableNode.positions, result.positions);
 
+			if (!result.pageBreaks || result.pageBreaks.length === 0) {
+				const breaksBySpan = tableNode && tableNode._breaksBySpan || null;
+				const breakBySpanData = this._findSameRowPageBreakByRowSpanData(breaksBySpan, pageBeforeProcessing, i);
+				if (breakBySpanData) {
+					const finalBreakBySpanData = this._getPageBreakListBySpan(tableNode, breakBySpanData.prevPage, i);
+					result.pageBreaks.push(finalBreakBySpanData);
+				}
+			}
+
 			processor.endRow(i, this.writer, result.pageBreaks);
 		}
 
 		processor.endTable(this.writer);
+		this.nestedLevel--;
+		if (this.nestedLevel === 0) {
+			this.writer.context().resetMarginXTopParent();
+		}
 	}
 
 	// leafs (texts)
@@ -762,6 +1130,27 @@ class LayoutBuilder {
 			return newInline;
 		}
 
+		function findMaxFitLength(text, maxWidth, measureFn) {
+			let low = 1;
+			let high = text.length;
+			let bestFit = 1;
+
+			while (low <= high) {
+				const mid = Math.floor((low + high) / 2);
+				const part = text.substring(0, mid);
+				const width = measureFn(part);
+
+				if (width <= maxWidth) {
+					bestFit = mid;
+					low = mid + 1;
+				} else {
+					high = mid - 1;
+				}
+			}
+
+			return bestFit;
+		}
+
 		if (!textNode._inlines || textNode._inlines.length === 0) {
 			return null;
 		}
@@ -777,11 +1166,9 @@ class LayoutBuilder {
 			isForceContinue = false;
 
 			if (!inline.noWrap && inline.text.length > 1 && inline.width > line.getAvailableWidth()) {
-				let widthPerChar = inline.width / inline.text.length;
-				let maxChars = Math.floor(line.getAvailableWidth() / widthPerChar);
-				if (maxChars < 1) {
-					maxChars = 1;
-				}
+				let maxChars = findMaxFitLength(inline.text, line.getAvailableWidth(), (txt) =>
+					textInlines.widthOfText(txt, inline)
+				);
 				if (maxChars < inline.text.length) {
 					let newInline = cloneInline(inline);