pdfmake 0.3.4 → 0.3.6

package/js/Printer.js

@@ -11,28 +11,13 @@ var _Renderer = _interopRequireDefault(require("./Renderer"));
 var _variableType = require("./helpers/variableType");
 var _tools = require("./helpers/tools");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-/**
- * Printer which turns document definition into a pdf
- *
- * @example
- * var fontDescriptors = {
- *	Roboto: {
- *		normal: 'fonts/Roboto-Regular.ttf',
- *		bold: 'fonts/Roboto-Medium.ttf',
- *		italics: 'fonts/Roboto-Italic.ttf',
- *		bolditalics: 'fonts/Roboto-MediumItalic.ttf'
- *	}
- * };
- *
- * var printer = new PdfPrinter(fontDescriptors);
- */
 class PdfPrinter {
   /**
    * @param {object} fontDescriptors font definition dictionary
    * @param {object} virtualfs
    * @param {object} urlResolver
    */
-  constructor(fontDescriptors, virtualfs = null, urlResolver = null) {
+  constructor(fontDescriptors, virtualfs, urlResolver) {
     this.fontDescriptors = fontDescriptors;
     this.virtualfs = virtualfs;
     this.urlResolver = urlResolver;
@@ -126,9 +111,6 @@ class PdfPrinter {
         headers: {}
       };
     };
-    if (this.urlResolver === null) {
-      return;
-    }
     for (let font in this.fontDescriptors) {
       if (this.fontDescriptors.hasOwnProperty(font)) {
         if (this.fontDescriptors[font].normal) {

package/js/Renderer.js

@@ -42,6 +42,7 @@ class Renderer {
   constructor(pdfDocument, progressCallback) {
     this.pdfDocument = pdfDocument;
     this.progressCallback = progressCallback;
+    this.outlineMap = [];
   }
   renderPages(pages) {
     this.pdfDocument._pdfMakePages = pages; // TODO: Why?
@@ -121,6 +122,18 @@ class Renderer {
           break;
       }
     }
+    if (line._outline) {
+      let parentOutline = this.pdfDocument.outline;
+      if (line._outline.parentId && this.outlineMap[line._outline.parentId]) {
+        parentOutline = this.outlineMap[line._outline.parentId];
+      }
+      let outline = parentOutline.addItem(line._outline.text, {
+        expanded: line._outline.expanded
+      });
+      if (line._outline.id) {
+        this.outlineMap[line._outline.id] = outline;
+      }
+    }
     if (line._pageNodeRef) {
       preparePageNodeRefLine(line._pageNodeRef, line.inlines[0]);
     }

package/js/SVGMeasure.js

@@ -28,8 +28,10 @@ const parseSVG = svgString => {
   let doc;
   try {
     doc = new _xmldoc.XmlDocument(svgString);
-  } catch (err) {
-    throw new Error('Invalid svg document (' + err + ')');
+  } catch (error) {
+    throw new Error('Invalid svg document (' + error + ')', {
+      cause: error
+    });
   }
   if (doc.name !== "svg") {
     throw new Error('Invalid svg document (expected <svg>)');

package/js/TableProcessor.js

@@ -20,7 +20,7 @@ class TableProcessor {
     const prepareRowSpanData = () => {
       let rsd = [];
       let x = 0;
-      let lastWidth = 0;
+      let lastWidth;
       rsd.push({
         left: 0,
         rowSpan: 0
@@ -250,7 +250,6 @@ class TableProcessor {
               lineColor: borderColor
             }, false, (0, _variableType.isNumber)(overrideY), null, forcePage);
             currentLine = null;
-            borderColor = null;
             cellAbove = null;
             currentCell = null;
             rowCellAbove = null;
@@ -325,9 +324,6 @@ class TableProcessor {
       dash: dash,
       lineColor: borderColor
     }, false, true);
-    cellBefore = null;
-    currentCell = null;
-    borderColor = null;
   }
   endTable(writer) {
     if (this.cleanUpRepeatables) {

package/js/URLResolver.js

@@ -12,13 +12,23 @@ async function fetchUrl(url, headers = {}) {
     }
     return await response.arrayBuffer();
   } catch (error) {
-    throw new Error(`Network request failed (url: "${url}", error: ${error.message})`);
+    throw new Error(`Network request failed (url: "${url}", error: ${error.message})`, {
+      cause: error
+    });
   }
 }
 class URLResolver {
   constructor(fs) {
     this.fs = fs;
     this.resolving = {};
+    this.urlAccessPolicy = undefined;
+  }
+
+  /**
+   * @param {(url: string) => boolean} callback
+   */
+  setUrlAccessPolicy(callback) {
+    this.urlAccessPolicy = callback;
   }
   resolve(url, headers = {}) {
     const resolveUrlInternal = async () => {
@@ -26,6 +36,9 @@ class URLResolver {
         if (this.fs.existsSync(url)) {
           return; // url was downloaded earlier
         }
+        if (typeof this.urlAccessPolicy !== 'undefined' && this.urlAccessPolicy(url) !== true) {
+          throw new Error(`Access to URL denied by resource access policy: ${url}`);
+        }
         const buffer = await fetchUrl(url, headers);
         this.fs.writeFileSync(url, buffer);
       }

package/js/base.js

@@ -6,11 +6,12 @@ var _Printer = _interopRequireDefault(require("./Printer"));
 var _virtualFs = _interopRequireDefault(require("./virtual-fs"));
 var _tools = require("./helpers/tools");
 var _variableType = require("./helpers/variableType");
+var _URLResolver = _interopRequireDefault(require("./URLResolver"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 class pdfmake {
   constructor() {
     this.virtualfs = _virtualFs.default;
-    this.urlResolver = null;
+    this.urlAccessPolicy = undefined;
   }
 
   /**
@@ -27,10 +28,26 @@ class pdfmake {
     }
     options.progressCallback = this.progressCallback;
     options.tableLayouts = this.tableLayouts;
-    let printer = new _Printer.default(this.fonts, this.virtualfs, this.urlResolver());
+    const isServer = typeof process !== 'undefined' && process?.versions?.node;
+    if (typeof this.urlAccessPolicy === 'undefined' && isServer) {
+      console.warn('No URL access policy defined. Consider using setUrlAccessPolicy() to restrict external resource downloads.');
+    }
+    let urlResolver = new _URLResolver.default(this.virtualfs);
+    urlResolver.setUrlAccessPolicy(this.urlAccessPolicy);
+    let printer = new _Printer.default(this.fonts, this.virtualfs, urlResolver);
     const pdfDocumentPromise = printer.createPdfKitDocument(docDefinition, options);
     return this._transformToDocument(pdfDocumentPromise);
   }
+
+  /**
+   * @param {(url: string) => boolean} callback
+   */
+  setUrlAccessPolicy(callback) {
+    if (callback !== undefined && typeof callback !== 'function') {
+      throw new Error("Parameter 'callback' has an invalid type. Function or undefined expected.");
+    }
+    this.urlAccessPolicy = callback;
+  }
   setProgressCallback(callback) {
     this.progressCallback = callback;
   }

package/js/browser-extensions/index.js

@@ -4,7 +4,6 @@ exports.__esModule = true;
 exports.default = void 0;
 var _base = _interopRequireDefault(require("../base"));
 var _OutputDocumentBrowser = _interopRequireDefault(require("./OutputDocumentBrowser"));
-var _URLResolver = _interopRequireDefault(require("../URLResolver"));
 var _fs = _interopRequireDefault(require("fs"));
 var _configurator = _interopRequireDefault(require("core-js/configurator"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
@@ -23,7 +22,6 @@ let defaultClientFonts = {
 class pdfmake extends _base.default {
   constructor() {
     super();
-    this.urlResolver = () => new _URLResolver.default(this.virtualfs);
     this.fonts = defaultClientFonts;
   }
   addFontContainer(fontContainer) {

package/js/index.js

@@ -2,11 +2,9 @@
 
 const pdfmakeBase = require('./base').default;
 const OutputDocumentServer = require('./OutputDocumentServer').default;
-const URLResolver = require('./URLResolver').default;
 class pdfmake extends pdfmakeBase {
   constructor() {
     super();
-    this.urlResolver = () => new URLResolver(this.virtualfs);
   }
   _transformToDocument(doc) {
     return new OutputDocumentServer(doc);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pdfmake",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "Client/server side PDF printing in pure JavaScript",
   "main": "js/index.js",
   "esnext": "src/index.js",
@@ -18,15 +18,15 @@
     "@babel/core": "^7.29.0",
     "@babel/plugin-transform-modules-commonjs": "^7.28.6",
     "@babel/preset-env": "^7.29.0",
-    "@eslint/js": "^9.39.2",
+    "@eslint/js": "^10.0.1",
     "assert": "^2.1.0",
     "babel-loader": "^10.0.0",
     "brfs": "^2.0.2",
     "browserify-zlib": "^0.2.0",
     "buffer": "^6.0.3",
     "core-js": "^3.48.0",
-    "eslint": "^9.39.2",
-    "eslint-plugin-jsdoc": "^62.5.4",
+    "eslint": "^10.0.1",
+    "eslint-plugin-jsdoc": "^62.7.0",
     "expose-loader": "^5.0.1",
     "file-saver": "^2.0.5",
     "globals": "^17.3.0",
@@ -43,7 +43,7 @@
     "terser-webpack-plugin": "^5.3.16",
     "transform-loader": "^0.2.4",
     "util": "^0.12.5",
-    "webpack": "^5.105.0",
+    "webpack": "^5.105.2",
     "webpack-cli": "^6.0.1"
   },
   "engines": {

package/src/DocMeasure.js

@@ -95,10 +95,12 @@ class DocMeasure {
 			node._width = node._minWidth = node._maxWidth = node.cover.width;
 			node._height = node._minHeight = node._maxHeight = node.cover.height;
 		} else {
+			let nodeWidth = isNumber(node.width) ? node.width : undefined;
+			let nodeHeight = isNumber(node.height) ? node.height : undefined;
 			let ratio = dimensions.width / dimensions.height;
 
-			node._width = node._minWidth = node._maxWidth = node.width || (node.height ? (node.height * ratio) : dimensions.width);
-			node._height = node.height || (node.width ? node.width / ratio : dimensions.height);
+			node._width = node._minWidth = node._maxWidth = nodeWidth || (nodeHeight ? (nodeHeight * ratio) : dimensions.width);
+			node._height = nodeHeight || (nodeWidth ? nodeWidth / ratio : dimensions.height);
 
 			if (isNumber(node.maxWidth) && node.maxWidth < node._width) {
 				node._width = node._minWidth = node._maxWidth = node.maxWidth;
@@ -218,6 +220,10 @@ class DocMeasure {
 					{ text: item._textNodeRef.text, linkToDestination: destination, alignment: 'left', style: lineStyle, margin: lineMargin },
 					{ text: '00000', linkToDestination: destination, alignment: 'right', _tocItemRef: item._nodeRef, style: lineNumberStyle, margin: [0, lineMargin[1], 0, lineMargin[3]] }
 				]);
+
+				if (node.toc.outlines) {
+					item._textNodeRef.outline = item._textNodeRef.outline || true;
+				}
 			}
 
 			node.toc._table = {

package/src/DocumentContext.js

@@ -19,7 +19,7 @@ class DocumentContext extends EventEmitter {
 		this.backgroundLength = [];
 	}
 
-	beginColumnGroup(marginXTopParent, bottomByPage = {}) {
+	beginColumnGroup(marginXTopParent, bottomByPage = {}, snakingColumns = false, columnGap = 0, columnWidths = null) {
 		this.snapshots.push({
 			x: this.x,
 			y: this.y,
@@ -34,7 +34,10 @@ class DocumentContext extends EventEmitter {
 				availableWidth: this.availableWidth,
 				page: this.page
 			},
-			lastColumnWidth: this.lastColumnWidth
+			lastColumnWidth: this.lastColumnWidth,
+			snakingColumns: snakingColumns,
+			gap: columnGap,
+			columnWidths: columnWidths
 		});
 
 		this.lastColumnWidth = 0;
@@ -45,20 +48,74 @@ class DocumentContext extends EventEmitter {
 
 	updateBottomByPage() {
 		const lastSnapshot = this.snapshots[this.snapshots.length - 1];
+		if (!lastSnapshot) {
+			return;
+		}
 		const lastPage = this.page;
 		let previousBottom = -Number.MIN_VALUE;
-		if (lastSnapshot.bottomByPage[lastPage]) {
+		if (lastSnapshot.bottomByPage && lastSnapshot.bottomByPage[lastPage]) {
 			previousBottom = lastSnapshot.bottomByPage[lastPage];
 		}
-		lastSnapshot.bottomByPage[lastPage] = Math.max(previousBottom, this.y);
+		if (lastSnapshot.bottomByPage) {
+			lastSnapshot.bottomByPage[lastPage] = Math.max(previousBottom, this.y);
+		}
 	}
 
 	resetMarginXTopParent() {
 		this.marginXTopParent = null;
 	}
 
+	/**
+	 * Find the most recent (deepest) snaking column group snapshot.
+	 * @returns {object|null}
+	 */
+	getSnakingSnapshot() {
+		for (let i = this.snapshots.length - 1; i >= 0; i--) {
+			if (this.snapshots[i].snakingColumns) {
+				return this.snapshots[i];
+			}
+		}
+		return null;
+	}
+
+	inSnakingColumns() {
+		return !!this.getSnakingSnapshot();
+	}
+
+	/**
+	 * Check if we're inside a nested non-snaking column group (e.g., a table row)
+	 * within an outer snaking column group. This is used to prevent snaking-specific
+	 * breaks inside table cells — the table's own page break mechanism should handle
+	 * row breaks, and column breaks should happen between rows.
+	 * @returns {boolean}
+	 */
+	isInNestedNonSnakingGroup() {
+		for (let i = this.snapshots.length - 1; i >= 0; i--) {
+			let snap = this.snapshots[i];
+			if (snap.snakingColumns) {
+				return false; // Reached snaking snapshot without finding inner group
+			}
+			if (!snap.overflowed) {
+				return true; // Found non-snaking, non-overflowed inner group
+			}
+		}
+		return false;
+	}
+
 	beginColumn(width, offset, endingCell) {
+		// Find the correct snapshot for this column group.
+		// When a snaking column break (moveToNextColumn) occurs during inner column
+		// processing, overflowed snapshots may sit above this column group's snapshot.
+		// We need to skip past those to find the one from our beginColumnGroup call.
 		let saved = this.snapshots[this.snapshots.length - 1];
+		if (saved && saved.overflowed) {
+			for (let i = this.snapshots.length - 1; i >= 0; i--) {
+				if (!this.snapshots[i].overflowed) {
+					saved = this.snapshots[i];
+					break;
+				}
+			}
+		}
 
 		this.calculateBottomMost(saved, endingCell);
 
@@ -102,6 +159,48 @@ class DocumentContext extends EventEmitter {
 	completeColumnGroup(height, endingCell) {
 		let saved = this.snapshots.pop();
 
+		// Track the maximum bottom position across all columns (including overflowed).
+		// Critical for snaking: content after columns must appear below the tallest column.
+		let maxBottomY = this.y;
+		let maxBottomPage = this.page;
+		let maxBottomAvailableHeight = this.availableHeight;
+
+		// Pop overflowed snapshots created by moveToNextColumn (snaking columns).
+		// Merge their bottomMost values to find the true maximum.
+		while (saved && saved.overflowed) {
+			let bm = bottomMostContext(
+				{
+					page: maxBottomPage,
+					y: maxBottomY,
+					availableHeight: maxBottomAvailableHeight
+				},
+				saved.bottomMost || {}
+			);
+			maxBottomPage = bm.page;
+			maxBottomY = bm.y;
+			maxBottomAvailableHeight = bm.availableHeight;
+			saved = this.snapshots.pop();
+		}
+
+		if (!saved) {
+			return {};
+		}
+
+		// Apply the max bottom from all overflowed columns to this base snapshot
+		if (
+			maxBottomPage > saved.bottomMost.page ||
+			(maxBottomPage === saved.bottomMost.page &&
+				maxBottomY > saved.bottomMost.y)
+		) {
+			saved.bottomMost = {
+				x: saved.x,
+				y: maxBottomY,
+				page: maxBottomPage,
+				availableHeight: maxBottomAvailableHeight,
+				availableWidth: saved.availableWidth
+			};
+		}
+
 		this.calculateBottomMost(saved, endingCell);
 
 		this.x = saved.x;
@@ -125,16 +224,152 @@ class DocumentContext extends EventEmitter {
 			this.availableHeight -= (y - saved.bottomMost.y);
 		}
 
-		 if (height && (saved.bottomMost.y - saved.y < height)) {
-		 	this.height = height;
-		 } else {
+		if (height && (saved.bottomMost.y - saved.y < height)) {
+			this.height = height;
+		} else {
 			this.height = saved.bottomMost.y - saved.y;
-		 }
+		}
 
 		this.lastColumnWidth = saved.lastColumnWidth;
 		return saved.bottomByPage;
 	}
 
+	/**
+	 * Move to the next column in a column group (snaking columns).
+	 * Creates an overflowed snapshot to track that we've moved to the next column.
+	 * @returns {object} Position info for the new column
+	 */
+	moveToNextColumn() {
+		let prevY = this.y;
+		let snakingSnapshot = this.getSnakingSnapshot();
+
+		if (!snakingSnapshot) {
+			return { prevY: prevY, y: this.y };
+		}
+
+		// Update snaking snapshot's bottomMost with current position BEFORE resetting.
+		// This captures where content reached in the current column (overflow point).
+		this.calculateBottomMost(snakingSnapshot, null);
+
+		// Calculate new X position: move right by current column width + gap
+		let overflowCount = 0;
+		for (let i = this.snapshots.length - 1; i >= 0; i--) {
+			if (this.snapshots[i].overflowed) {
+				overflowCount++;
+			} else {
+				break;
+			}
+		}
+
+		let currentColumnWidth = (snakingSnapshot.columnWidths && snakingSnapshot.columnWidths[overflowCount]) || this.lastColumnWidth || this.availableWidth;
+		let nextColumnWidth = (snakingSnapshot.columnWidths && snakingSnapshot.columnWidths[overflowCount + 1]) || currentColumnWidth;
+
+		this.lastColumnWidth = nextColumnWidth;
+
+		let newX = this.x + (currentColumnWidth || 0) + (snakingSnapshot.gap || 0);
+		let newY = snakingSnapshot.y;
+
+		this.snapshots.push({
+			x: newX,
+			y: newY,
+			availableHeight: snakingSnapshot.availableHeight,
+			availableWidth: nextColumnWidth,
+			page: this.page,
+			overflowed: true,
+			bottomMost: {
+				x: newX,
+				y: newY,
+				availableHeight: snakingSnapshot.availableHeight,
+				availableWidth: nextColumnWidth,
+				page: this.page
+			},
+			lastColumnWidth: nextColumnWidth,
+			snakingColumns: true,
+			gap: snakingSnapshot.gap,
+			columnWidths: snakingSnapshot.columnWidths
+		});
+
+		this.x = newX;
+		this.y = newY;
+		this.availableHeight = snakingSnapshot.availableHeight;
+		this.availableWidth = nextColumnWidth;
+
+		// Sync non-overflowed inner snapshots (e.g. inner column groups for
+		// product/price rows) with the new snaking column position.
+		// Without this, inner beginColumn would read stale y/page/x values.
+		for (let i = this.snapshots.length - 2; i >= 0; i--) {
+			let snapshot = this.snapshots[i];
+			if (snapshot.overflowed || snapshot.snakingColumns) {
+				break; // Stop at first overflowed or snaking snapshot
+			}
+			snapshot.x = newX;
+			snapshot.y = newY;
+			snapshot.page = this.page;
+			snapshot.availableHeight = snakingSnapshot.availableHeight;
+			if (snapshot.bottomMost) {
+				snapshot.bottomMost.x = newX;
+				snapshot.bottomMost.y = newY;
+				snapshot.bottomMost.page = this.page;
+				snapshot.bottomMost.availableHeight = snakingSnapshot.availableHeight;
+			}
+		}
+
+		return { prevY: prevY, y: this.y };
+	}
+
+	/**
+	 * Reset snaking column state when moving to a new page.
+	 * Clears overflowed snapshots, resets X to left margin, sets width to first column,
+	 * and syncs all snapshots to new page coordinates.
+	 */
+	resetSnakingColumnsForNewPage() {
+		let snakingSnapshot = this.getSnakingSnapshot();
+		if (!snakingSnapshot) {
+			return;
+		}
+
+		let pageTopY = this.pageMargins.top;
+		let pageInnerHeight = this.getCurrentPage().pageSize.height - this.pageMargins.top - this.pageMargins.bottom;
+
+		// When moving to new page, start at first column.
+		// Reset width to FIRST column width, not last column from previous page.
+		let firstColumnWidth = snakingSnapshot.columnWidths ? snakingSnapshot.columnWidths[0] : (this.lastColumnWidth || this.availableWidth);
+
+		// Clean up overflowed snapshots
+		while (this.snapshots.length > 1 && this.snapshots[this.snapshots.length - 1].overflowed) {
+			this.snapshots.pop();
+		}
+
+		// Reset X to start of first column (left margin)
+		if (this.marginXTopParent) {
+			this.x = this.pageMargins.left + this.marginXTopParent[0];
+		} else {
+			this.x = this.pageMargins.left;
+		}
+		this.availableWidth = firstColumnWidth;
+		this.lastColumnWidth = firstColumnWidth;
+
+		// Sync all snapshots to new page state.
+		// When page break occurs within snaking columns, update ALL snapshots
+		// (not just snaking column snapshots) to reflect new page coordinates.
+		// This ensures nested structures (like inner product/price columns)
+		// don't retain stale values that would cause layout corruption.
+		for (let i = 0; i < this.snapshots.length; i++) {
+			let snapshot = this.snapshots[i];
+			let isSnakingSnapshot = !!snapshot.snakingColumns;
+			snapshot.x = this.x;
+			snapshot.y = isSnakingSnapshot ? pageTopY : this.y;
+			snapshot.availableHeight = isSnakingSnapshot ? pageInnerHeight : this.availableHeight;
+			snapshot.page = this.page;
+			if (snapshot.bottomMost) {
+				snapshot.bottomMost.x = this.x;
+				snapshot.bottomMost.y = isSnakingSnapshot ? pageTopY : this.y;
+				snapshot.bottomMost.availableHeight = isSnakingSnapshot ? pageInnerHeight : this.availableHeight;
+				snapshot.bottomMost.page = this.page;
+			}
+		}
+	}
+
 	addMargin(left, right) {
 		this.x += left;
 		this.availableWidth -= left + (right || 0);
@@ -318,7 +553,6 @@ const getPageSize = (currentPage, newPageOrientation) => {
 			height: currentPage.pageSize.height
 		};
 	}
-
 };