pdfmake 0.3.0-beta.10 → 0.3.0-beta.12

package/js/TableProcessor.js

@@ -113,13 +113,18 @@ class TableProcessor {
       }
     }
     this.dontBreakRows = tableNode.table.dontBreakRows || false;
-    if (this.rowsWithoutPageBreak) {
+    if (this.rowsWithoutPageBreak || this.dontBreakRows) {
       writer.beginUnbreakableBlock();
+      // Draw the top border of the table
+      this.drawHorizontalLine(0, writer);
+      if (this.rowsWithoutPageBreak && this.dontBreakRows) {
+        // We just increase the value of transactionLevel
+        writer.beginUnbreakableBlock();
+      }
     }
 
     // update the border properties of all cells before drawing any lines
     prepareCellBorders(this.tableNode.table.body);
-    this.drawHorizontalLine(0, writer);
   }
   onRowBreak(rowIndex, writer) {
     return () => {
@@ -135,7 +140,12 @@ class TableProcessor {
     this.rowPaddingBottom = this.layout.paddingBottom(rowIndex, this.tableNode);
     this.rowCallback = this.onRowBreak(rowIndex, writer);
     writer.addListener('pageChanged', this.rowCallback);
-    if (this.dontBreakRows) {
+    if (rowIndex == 0 && !this.dontBreakRows && !this.rowsWithoutPageBreak) {
+      // We store the 'y' to draw later and if necessary the top border of the table
+      this._tableTopBorderY = writer.context().y;
+      writer.context().moveDown(this.topLineWidth);
+    }
+    if (this.dontBreakRows && rowIndex > 0) {
       writer.beginUnbreakableBlock();
     }
     this.rowTopY = writer.context().y;
@@ -143,7 +153,7 @@ class TableProcessor {
     writer.context().availableHeight -= this.reservedAtBottom;
     writer.context().moveDown(this.rowPaddingTop);
   }
-  drawHorizontalLine(lineIndex, writer, overrideY) {
+  drawHorizontalLine(lineIndex, writer, overrideY, moveDown = true, forcePage) {
     let lineWidth = this.layout.hLineWidth(lineIndex, this.tableNode);
     if (lineWidth) {
       let style = this.layout.hLineStyle(lineIndex, this.tableNode);
@@ -237,7 +247,7 @@ class TableProcessor {
               lineWidth: lineWidth,
               dash: dash,
               lineColor: borderColor
-            }, false, overrideY);
+            }, false, (0, _variableType.isNumber)(overrideY), null, forcePage);
             currentLine = null;
             borderColor = null;
             cellAbove = null;
@@ -246,7 +256,9 @@ class TableProcessor {
           }
         }
       }
-      writer.context().moveDown(lineWidth);
+      if (moveDown) {
+        writer.context().moveDown(lineWidth);
+      }
     }
   }
   drawVerticalLine(x, y0, y1, vLineColIndex, writer, vLineRowIndex, beforeVLineColIndex) {
@@ -369,6 +381,15 @@ class TableProcessor {
     }
     ys[ys.length - 1].y1 = endingY;
     let skipOrphanePadding = ys[0].y1 - ys[0].y0 === this.rowPaddingTop;
+    if (rowIndex === 0 && !skipOrphanePadding && !this.rowsWithoutPageBreak && !this.dontBreakRows) {
+      // Draw the top border of the table
+      let pageTableStartedAt = null;
+      if (pageBreaks && pageBreaks.length > 0) {
+        // Get the page where table started at
+        pageTableStartedAt = pageBreaks[0].prevPage;
+      }
+      this.drawHorizontalLine(0, writer, this._tableTopBorderY, false, pageTableStartedAt);
+    }
     for (let yi = skipOrphanePadding ? 1 : 0, yl = ys.length; yi < yl; yi++) {
       let willBreak = yi < ys.length - 1;
       let rowBreakWithoutHeader = yi > 0 && !this.headerRows;
@@ -385,6 +406,14 @@ class TableProcessor {
         // TableProcessor should be pageChanged listener, instead of processRow
         this.reservedAtBottom = 0;
       }
+
+      // Draw horizontal lines before the vertical lines so they are not overridden
+      if (willBreak && this.layout.hLineWhenBroken !== false) {
+        this.drawHorizontalLine(rowIndex + 1, writer, y2);
+      }
+      if (rowBreakWithoutHeader && this.layout.hLineWhenBroken !== false) {
+        this.drawHorizontalLine(rowIndex, writer, y1);
+      }
       for (let i = 0, l = xs.length; i < l; i++) {
         let leftCellBorder = false;
         let rightCellBorder = false;
@@ -467,12 +496,6 @@ class TableProcessor {
           }
         }
       }
-      if (willBreak && this.layout.hLineWhenBroken !== false) {
-        this.drawHorizontalLine(rowIndex + 1, writer, y2);
-      }
-      if (rowBreakWithoutHeader && this.layout.hLineWhenBroken !== false) {
-        this.drawHorizontalLine(rowIndex, writer, y1);
-      }
     }
     writer.context().page = endingPage;
     writer.context().y = endingY;
@@ -505,7 +528,8 @@ class TableProcessor {
     }
     if (this.dontBreakRows) {
       const pageChangedCallback = () => {
-        if (!this.headerRows && this.layout.hLineWhenBroken !== false) {
+        if (rowIndex > 0 && !this.headerRows && this.layout.hLineWhenBroken !== false) {
+          // Draw the top border of the row after a page break
           this.drawHorizontalLine(rowIndex, writer);
         }
       };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pdfmake",
-  "version": "0.3.0-beta.10",
+  "version": "0.3.0-beta.12",
   "description": "Client/server side PDF printing in pure JavaScript",
   "main": "js/index.js",
   "esnext": "src/index.js",
@@ -10,33 +10,33 @@
   },
   "dependencies": {
     "@foliojs-fork/linebreak": "^1.1.2",
-    "@foliojs-fork/pdfkit": "^0.14.0",
+    "@foliojs-fork/pdfkit": "^0.15.1",
     "iconv-lite": "^0.6.3",
     "xmldoc": "^1.3.0"
   },
   "devDependencies": {
-    "@babel/cli": "^7.25.6",
-    "@babel/core": "^7.25.2",
-    "@babel/plugin-transform-modules-commonjs": "^7.24.8",
-    "@babel/preset-env": "^7.25.4",
-    "@eslint/js": "^9.9.1",
+    "@babel/cli": "^7.25.9",
+    "@babel/core": "^7.26.0",
+    "@babel/plugin-transform-modules-commonjs": "^7.25.9",
+    "@babel/preset-env": "^7.26.0",
+    "@eslint/js": "^9.14.0",
     "assert": "^2.1.0",
-    "babel-loader": "^9.1.3",
+    "babel-loader": "^9.2.1",
     "brfs": "^2.0.2",
     "browserify-zlib": "^0.2.0",
     "buffer": "6.0.3",
     "core-js": "3.19.0",
-    "eslint": "^9.9.1",
-    "eslint-plugin-jsdoc": "^50.2.2",
+    "eslint": "^9.14.0",
+    "eslint-plugin-jsdoc": "^50.4.3",
     "expose-loader": "^5.0.0",
     "file-saver": "^2.0.5",
-    "globals": "^15.9.0",
-    "mocha": "^10.7.3",
+    "globals": "^15.11.0",
+    "mocha": "^10.8.2",
     "npm-run-all": "^4.1.5",
     "process": "^0.11.10",
     "rewire": "^7.0.0",
     "shx": "^0.3.4",
-    "sinon": "^18.0.0",
+    "sinon": "^19.0.2",
     "source-map-loader": "^5.0.0",
     "stream-browserify": "^3.0.0",
     "string-replace-webpack-plugin": "^0.1.3",
@@ -44,7 +44,7 @@
     "terser-webpack-plugin": "^5.3.10",
     "transform-loader": "^0.2.4",
     "util": "^0.12.5",
-    "webpack": "^5.94.0",
+    "webpack": "^5.96.1",
     "webpack-cli": "^5.1.4"
   },
   "engines": {

package/src/3rd-party/svg-to-pdfkit/LICENSE

@@ -1,9 +1,9 @@
-The MIT License (MIT)
-
-Copyright (c) 2019 SVG-to-PDFKit contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+The MIT License (MIT)
+
+Copyright (c) 2019 SVG-to-PDFKit contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/src/DocumentContext.js

@@ -23,13 +23,14 @@ class DocumentContext extends EventEmitter {
 		this.addPage(pageSize);
 	}
 
-	beginColumnGroup(marginXTopParent) {
+	beginColumnGroup(marginXTopParent, bottomByPage = {}) {
 		this.snapshots.push({
 			x: this.x,
 			y: this.y,
 			availableHeight: this.availableHeight,
 			availableWidth: this.availableWidth,
 			page: this.page,
+      bottomByPage: bottomByPage ? bottomByPage : {},
 			bottomMost: {
 				x: this.x,
 				y: this.y,
@@ -46,6 +47,16 @@ class DocumentContext extends EventEmitter {
 		}
 	}
 
+	updateBottomByPage () {
+		const lastSnapshot = this.snapshots[this.snapshots.length - 1];
+		const lastPage = this.page;
+		let previousBottom = -Number.MIN_VALUE;
+		if (lastSnapshot.bottomByPage[lastPage]) {
+			previousBottom = lastSnapshot.bottomByPage[lastPage];
+		}
+		lastSnapshot.bottomByPage[lastPage] = Math.max(previousBottom, this.y);
+	}
+
 	resetMarginXTopParent() {
 		this.marginXTopParent = null;
 	}
@@ -118,6 +129,7 @@ class DocumentContext extends EventEmitter {
 			this.availableHeight -= (y - saved.bottomMost.y);
 		}
 		this.lastColumnWidth = saved.lastColumnWidth;
+		return saved.bottomByPage;
 	}
 
 	addMargin(left, right) {

package/src/ElementWriter.js

@@ -259,9 +259,12 @@ class ElementWriter extends EventEmitter {
 		}
 	}
 
-	addVector(vector, ignoreContextX, ignoreContextY, index) {
+	addVector(vector, ignoreContextX, ignoreContextY, index, forcePage) {
 		let context = this.context();
 		let page = context.getCurrentPage();
+		if (isNumber(forcePage)) {
+			page = context.pages[forcePage];
+		}
 		let position = this.getCurrentPositionOnPage();
 
 		if (page) {

package/src/LayoutBuilder.js

@@ -539,7 +539,15 @@ 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) {
@@ -554,114 +562,239 @@ class LayoutBuilder {
 		return null;
 	}
 
-	processRow({ marginX = [0, 0], dontBreakRows = false, rowsWithoutPageBreak = 0, cells, widths, gaps, tableBody, rowIndex, height }) {
-		const updatePageBreakData = (page, prevY) => {
-			let pageDesc;
-			// Find page break data for this row and page
-			for (let i = 0, l = pageBreaks.length; i < l; i++) {
-				let desc = pageBreaks[i];
-				if (desc.prevPage === page) {
-					pageDesc = desc;
-					break;
-				}
-			}
-			// If row has page break in this page, update prevY
-			if (pageDesc) {
-				pageDesc.prevY = Math.max(pageDesc.prevY, prevY);
-			}
+	/**
+	* 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);
+	}
 
-		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;
-		this.writer.addListener('pageChanged', storePageBreakData);
+		widths = widths || cells;
 
 		// Check if row should break by height
 		if (!isUnbreakableRow && height > this.writer.context().availableHeight) {
 			willBreakByHeight = true;
 		}
 
-		widths = widths || cells;
 		// Use the marginX if we are in a top level table/column (not nested)
 		const marginXParent = this.nestedLevel === 1 ? marginX : null;
-
-		this.writer.context().beginColumnGroup(marginXParent);
+		const _bottomByPage = tableNode ? tableNode._bottomByPage : null;
+		this.writer.context().beginColumnGroup(marginXParent, _bottomByPage);
 
 		for (let i = 0, l = cells.length; i < l; i++) {
-			let column = cells[i];
+			let cell = cells[i];
+
+			// 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);
+
 			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;
-				column._endingCell._startingRowSpanY = column._startingRowSpanY;
+				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(cells, 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) {
-					endingSpanCell._isUnbreakableContext = true;
-					endingSpanCell._originalXOffset = this.writer.originalX;
+					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);
+			this.writer.context().beginColumn(width, leftOffset, endOfRowSpanCell);
 
-			if (!column._span) {
-				this.processNode(column);
-				addAll(positions, column.positions);
-			} else if (column._columnEndingContext) {
+			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 - column._startingRowSpanY;
+					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 (column._isUnbreakableContext && !this.writer.transactionLevel) {
-					originalXOffset = column._originalXOffset;
+				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, originalXOffset, discountY);
+				this.writer.context().markEnding(cell, originalXOffset, discountY);
 			}
+			this.writer.removeListener('pageChanged', storePageBreakClosure);
 		}
 
 		// Check if last cell is part of a span
@@ -674,7 +807,7 @@ class LayoutBuilder {
 				// 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(cells, cells.length);
+				const startingSpanCell = this._findStartingRowSpanCell(cells, cells.length);
 				if (startingSpanCell) {
 					// Context will be stored here (ending cell)
 					endingSpanCell = startingSpanCell._endingCell;
@@ -687,38 +820,25 @@ class LayoutBuilder {
 			}
 		}
 
-		// If there are page breaks in this row, update data with prevY of last cell
-		updatePageBreakData(this.writer.context().page, this.writer.context().y);
-
 		// If content did not break page, check if we should break by height
-		if (!isUnbreakableRow && pageBreaks.length === 0 && willBreakByHeight) {
+		if (willBreakByHeight && !isUnbreakableRow && pageBreaks.length === 0) {
 			this.writer.context().moveDown(this.writer.context().availableHeight);
 			this.writer.moveToNextPage();
 		}
 
-		this.writer.context().completeColumnGroup(height, endingSpanCell);
-		this.writer.removeListener('pageChanged', storePageBreakData);
+		const bottomByPage = this.writer.context().completeColumnGroup(height, endingSpanCell);
 
-		return { pageBreaks: pageBreaks, positions: positions };
-
-		function colLeftOffset(i) {
-			if (gaps && gaps.length > i) {
-				return gaps[i];
-			}
-			return 0;
+		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);
 		}
 
-		function getEndingCell(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;
-		}
+		return {
+			pageBreaksBySpan : pageBreaksByRowSpan,
+			pageBreaks: pageBreaks,
+			positions: positions
+		};
 	}
 
 	// lists
@@ -799,6 +919,8 @@ class LayoutBuilder {
 				height = undefined;
 			}
 
+			const pageBeforeProcessing = this.writer.context().page;
+
 			let result = this.processRow({
 				marginX: tableNode._margin ? [tableNode._margin[0], tableNode._margin[2]] : [0, 0],
 				dontBreakRows: processor.dontBreakRows,
@@ -807,12 +929,22 @@ class LayoutBuilder {
 				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);
 		}
 

package/src/PageElementWriter.js

@@ -39,8 +39,8 @@ class PageElementWriter extends ElementWriter {
 		return this._fitOnPage(() => super.addAttachment(attachment, index));
 	}
 
-	addVector(vector, ignoreContextX, ignoreContextY, index) {
-		return super.addVector(vector, ignoreContextX, ignoreContextY, index);
+	addVector(vector, ignoreContextX, ignoreContextY, index, forcePage) {
+		return super.addVector(vector, ignoreContextX, ignoreContextY, index, forcePage);
 	}
 
 	beginClip(width, height) {