@digicole/pdfmake-rtl 2.1.1 → 2.1.2

package/js/DocPreprocessor.js

@@ -0,0 +1,275 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _variableType = require("./helpers/variableType");
+var _node = require("./helpers/node");
+var _rtlUtils = require("./rtlUtils");
+const convertValueToString = value => {
+  if ((0, _variableType.isString)(value)) {
+    return value.replace(/\t/g, '    '); // expand tab as spaces
+  } else if ((0, _variableType.isNumber)(value) || typeof value === 'boolean') {
+    return value.toString();
+  } else if (!(0, _variableType.isValue)(value) || (0, _variableType.isEmptyObject)(value)) {
+    return '';
+  }
+
+  // TODO: throw exception ?
+
+  return value;
+};
+class DocPreprocessor {
+  preprocessDocument(docStructure) {
+    this.parentNode = null;
+    this.tocs = [];
+    this.nodeReferences = [];
+
+    // Check if RTL is enabled at document level
+    const documentRTL = docStructure.rtl === true;
+
+    // Process content for RTL if enabled
+    if (documentRTL && docStructure.content) {
+      docStructure.content = (0, _rtlUtils.processRTLElement)(docStructure.content, true);
+    }
+    return this.preprocessNode(docStructure, true);
+  }
+  preprocessBlock(node) {
+    this.parentNode = null;
+    this.tocs = [];
+    this.nodeReferences = [];
+    return this.preprocessNode(node);
+  }
+  preprocessNode(node, isSectionAllowed = false) {
+    // expand shortcuts and casting values
+    if (Array.isArray(node)) {
+      node = {
+        stack: node
+      };
+    } else if ((0, _variableType.isString)(node) || (0, _variableType.isNumber)(node) || typeof node === 'boolean' || !(0, _variableType.isValue)(node) || (0, _variableType.isEmptyObject)(node)) {
+      // text node defined as value
+      node = {
+        text: convertValueToString(node)
+      };
+    } else if ('text' in node) {
+      // cast value in text property
+      node.text = convertValueToString(node.text);
+    }
+
+    // Apply RTL processing if rtl property is set on this node
+    if (node && typeof node === 'object' && node.rtl === true) {
+      node = (0, _rtlUtils.processRTLElement)(node, true);
+    }
+    // Auto-detect RTL for text nodes without explicit rtl property
+    else if (node && typeof node === 'object' && node.text && typeof node.text === 'string' && (0, _rtlUtils.containsRTL)(node.text) && !node.rtl) {
+      node = (0, _rtlUtils.applyRTLToNode)(node, false);
+    }
+    // Auto-detect RTL for table nodes - reverse columns if table has RTL content
+    else if (node && typeof node === 'object' && node.table && !node.rtl) {
+      node = (0, _rtlUtils.processRTLTable)(node);
+    }
+    if (node.section) {
+      if (!isSectionAllowed) {
+        throw new Error(`Incorrect document structure, section node is only allowed at the root level of document structure: ${(0, _node.stringifyNode)(node)}`);
+      }
+      return this.preprocessSection(node);
+    } else if (node.columns) {
+      return this.preprocessColumns(node);
+    } else if (node.stack) {
+      return this.preprocessVerticalContainer(node, isSectionAllowed);
+    } else if (node.ul) {
+      return this.preprocessList(node);
+    } else if (node.ol) {
+      return this.preprocessList(node);
+    } else if (node.table) {
+      return this.preprocessTable(node);
+    } else if (node.text !== undefined) {
+      return this.preprocessText(node);
+    } else if (node.toc) {
+      return this.preprocessToc(node);
+    } else if (node.image) {
+      return this.preprocessImage(node);
+    } else if (node.svg) {
+      return this.preprocessSVG(node);
+    } else if (node.canvas) {
+      return this.preprocessCanvas(node);
+    } else if (node.qr) {
+      return this.preprocessQr(node);
+    } else if (node.attachment) {
+      return this.preprocessAttachment(node);
+    } else if (node.pageReference || node.textReference) {
+      return this.preprocessText(node);
+    } else {
+      throw new Error(`Unrecognized document structure: ${(0, _node.stringifyNode)(node)}`);
+    }
+  }
+  preprocessSection(node) {
+    node.section = this.preprocessNode(node.section);
+    return node;
+  }
+  preprocessColumns(node) {
+    let columns = node.columns;
+    for (let i = 0, l = columns.length; i < l; i++) {
+      columns[i] = this.preprocessNode(columns[i]);
+    }
+    return node;
+  }
+  preprocessVerticalContainer(node, isSectionAllowed) {
+    let items = node.stack;
+    for (let i = 0, l = items.length; i < l; i++) {
+      items[i] = this.preprocessNode(items[i], isSectionAllowed);
+    }
+    return node;
+  }
+  preprocessList(node) {
+    let items = node.ul || node.ol;
+    for (let i = 0, l = items.length; i < l; i++) {
+      items[i] = this.preprocessNode(items[i]);
+    }
+    return node;
+  }
+  preprocessTable(node) {
+    let col;
+    let row;
+    let cols;
+    let rows;
+    for (col = 0, cols = node.table.body[0].length; col < cols; col++) {
+      for (row = 0, rows = node.table.body.length; row < rows; row++) {
+        let rowData = node.table.body[row];
+        let data = rowData[col];
+        if (data !== undefined) {
+          if (data === null) {
+            // transform to object
+            data = '';
+          }
+          if (!data._span) {
+            rowData[col] = this.preprocessNode(data);
+          }
+        }
+      }
+    }
+    return node;
+  }
+  preprocessText(node) {
+    if (node.tocItem) {
+      if (!Array.isArray(node.tocItem)) {
+        node.tocItem = [node.tocItem];
+      }
+      for (let i = 0, l = node.tocItem.length; i < l; i++) {
+        if (!(0, _variableType.isString)(node.tocItem[i])) {
+          node.tocItem[i] = '_default_';
+        }
+        let tocItemId = node.tocItem[i];
+        if (!this.tocs[tocItemId]) {
+          this.tocs[tocItemId] = {
+            toc: {
+              _items: [],
+              _pseudo: true
+            }
+          };
+        }
+        if (!node.id) {
+          node.id = `toc-${tocItemId}-${this.tocs[tocItemId].toc._items.length}`;
+        }
+        let tocItemRef = {
+          _nodeRef: this._getNodeForNodeRef(node),
+          _textNodeRef: node
+        };
+        this.tocs[tocItemId].toc._items.push(tocItemRef);
+      }
+    }
+    if (node.id) {
+      if (this.nodeReferences[node.id]) {
+        if (!this.nodeReferences[node.id]._pseudo) {
+          throw new Error(`Node id '${node.id}' already exists`);
+        }
+        this.nodeReferences[node.id]._nodeRef = this._getNodeForNodeRef(node);
+        this.nodeReferences[node.id]._textNodeRef = node;
+        this.nodeReferences[node.id]._pseudo = false;
+      } else {
+        this.nodeReferences[node.id] = {
+          _nodeRef: this._getNodeForNodeRef(node),
+          _textNodeRef: node
+        };
+      }
+    }
+    if (node.pageReference) {
+      if (!this.nodeReferences[node.pageReference]) {
+        this.nodeReferences[node.pageReference] = {
+          _nodeRef: {},
+          _textNodeRef: {},
+          _pseudo: true
+        };
+      }
+      node.text = '00000';
+      node.linkToDestination = node.pageReference;
+      node._pageRef = this.nodeReferences[node.pageReference];
+    }
+    if (node.textReference) {
+      if (!this.nodeReferences[node.textReference]) {
+        this.nodeReferences[node.textReference] = {
+          _nodeRef: {},
+          _pseudo: true
+        };
+      }
+      node.text = '';
+      node.linkToDestination = node.textReference;
+      node._textRef = this.nodeReferences[node.textReference];
+    }
+    if (node.text && node.text.text) {
+      node.text = [this.preprocessNode(node.text)];
+    } else if (Array.isArray(node.text)) {
+      let isSetParentNode = false;
+      if (this.parentNode === null) {
+        this.parentNode = node;
+        isSetParentNode = true;
+      }
+      for (let i = 0, l = node.text.length; i < l; i++) {
+        node.text[i] = this.preprocessNode(node.text[i]);
+      }
+      if (isSetParentNode) {
+        this.parentNode = null;
+      }
+    }
+    return node;
+  }
+  preprocessToc(node) {
+    if (!node.toc.id) {
+      node.toc.id = '_default_';
+    }
+    node.toc.title = node.toc.title ? this.preprocessNode(node.toc.title) : null;
+    node.toc._items = [];
+    if (this.tocs[node.toc.id]) {
+      if (!this.tocs[node.toc.id].toc._pseudo) {
+        throw new Error(`TOC '${node.toc.id}' already exists`);
+      }
+      node.toc._items = this.tocs[node.toc.id].toc._items;
+    }
+    this.tocs[node.toc.id] = node;
+    return node;
+  }
+  preprocessImage(node) {
+    if (node.image.type !== undefined && node.image.data !== undefined && node.image.type === 'Buffer' && Array.isArray(node.image.data)) {
+      node.image = Buffer.from(node.image.data);
+    }
+    return node;
+  }
+  preprocessCanvas(node) {
+    return node;
+  }
+  preprocessSVG(node) {
+    return node;
+  }
+  preprocessQr(node) {
+    return node;
+  }
+  preprocessAttachment(node) {
+    return node;
+  }
+  _getNodeForNodeRef(node) {
+    if (this.parentNode) {
+      return this.parentNode;
+    }
+    return node;
+  }
+}
+var _default = exports.default = DocPreprocessor;

package/js/DocumentContext.js

@@ -0,0 +1,310 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _variableType = require("./helpers/variableType");
+var _events = require("events");
+/**
+ * A store for current x, y positions and available width/height.
+ * It facilitates column divisions and vertical sync
+ */
+class DocumentContext extends _events.EventEmitter {
+  constructor() {
+    super();
+    this.pages = [];
+    this.pageMargins = undefined;
+    this.x = undefined;
+    this.availableWidth = undefined;
+    this.availableHeight = undefined;
+    this.page = -1;
+    this.snapshots = [];
+    this.backgroundLength = [];
+  }
+  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,
+        availableHeight: this.availableHeight,
+        availableWidth: this.availableWidth,
+        page: this.page
+      },
+      lastColumnWidth: this.lastColumnWidth
+    });
+    this.lastColumnWidth = 0;
+    if (marginXTopParent) {
+      this.marginXTopParent = marginXTopParent;
+    }
+  }
+  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;
+  }
+  beginColumn(width, offset, endingCell) {
+    let saved = this.snapshots[this.snapshots.length - 1];
+    this.calculateBottomMost(saved, endingCell);
+    this.page = saved.page;
+    this.x = this.x + this.lastColumnWidth + (offset || 0);
+    this.y = saved.y;
+    this.availableWidth = width; //saved.availableWidth - offset;
+    this.availableHeight = saved.availableHeight;
+    this.lastColumnWidth = width;
+  }
+  calculateBottomMost(destContext, endingCell) {
+    if (endingCell) {
+      this.saveContextInEndingCell(endingCell);
+    } else {
+      destContext.bottomMost = bottomMostContext(this, destContext.bottomMost);
+    }
+  }
+  markEnding(endingCell, originalXOffset, discountY) {
+    this.page = endingCell._columnEndingContext.page;
+    this.x = endingCell._columnEndingContext.x + originalXOffset;
+    this.y = endingCell._columnEndingContext.y - discountY;
+    this.availableWidth = endingCell._columnEndingContext.availableWidth;
+    this.availableHeight = endingCell._columnEndingContext.availableHeight;
+    this.lastColumnWidth = endingCell._columnEndingContext.lastColumnWidth;
+  }
+  saveContextInEndingCell(endingCell) {
+    endingCell._columnEndingContext = {
+      page: this.page,
+      x: this.x,
+      y: this.y,
+      availableHeight: this.availableHeight,
+      availableWidth: this.availableWidth,
+      lastColumnWidth: this.lastColumnWidth
+    };
+  }
+  completeColumnGroup(height, endingCell) {
+    let saved = this.snapshots.pop();
+    this.calculateBottomMost(saved, endingCell);
+    this.x = saved.x;
+    let y = saved.bottomMost.y;
+    if (height) {
+      if (saved.page === saved.bottomMost.page) {
+        if (saved.y + height > y) {
+          y = saved.y + height;
+        }
+      } else {
+        y += height;
+      }
+    }
+    this.y = y;
+    this.page = saved.bottomMost.page;
+    this.availableWidth = saved.availableWidth;
+    this.availableHeight = saved.bottomMost.availableHeight;
+    if (height) {
+      this.availableHeight -= y - saved.bottomMost.y;
+    }
+    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;
+  }
+  addMargin(left, right) {
+    this.x += left;
+    this.availableWidth -= left + (right || 0);
+  }
+  moveDown(offset) {
+    this.y += offset;
+    this.availableHeight -= offset;
+    return this.availableHeight > 0;
+  }
+  initializePage() {
+    this.y = this.pageMargins.top;
+    this.availableHeight = this.getCurrentPage().pageSize.height - this.pageMargins.top - this.pageMargins.bottom;
+    const {
+      pageCtx,
+      isSnapshot
+    } = this.pageSnapshot();
+    pageCtx.availableWidth = this.getCurrentPage().pageSize.width - this.pageMargins.left - this.pageMargins.right;
+    if (isSnapshot && this.marginXTopParent) {
+      pageCtx.availableWidth -= this.marginXTopParent[0];
+      pageCtx.availableWidth -= this.marginXTopParent[1];
+    }
+  }
+  pageSnapshot() {
+    if (this.snapshots[0]) {
+      return {
+        pageCtx: this.snapshots[0],
+        isSnapshot: true
+      };
+    } else {
+      return {
+        pageCtx: this,
+        isSnapshot: false
+      };
+    }
+  }
+  moveTo(x, y) {
+    if (x !== undefined && x !== null) {
+      this.x = x;
+      this.availableWidth = this.getCurrentPage().pageSize.width - this.x - this.pageMargins.right;
+    }
+    if (y !== undefined && y !== null) {
+      this.y = y;
+      this.availableHeight = this.getCurrentPage().pageSize.height - this.y - this.pageMargins.bottom;
+    }
+  }
+  moveToRelative(x, y) {
+    if (x !== undefined && x !== null) {
+      this.x = this.x + x;
+    }
+    if (y !== undefined && y !== null) {
+      this.y = this.y + y;
+    }
+  }
+  beginDetachedBlock() {
+    this.snapshots.push({
+      x: this.x,
+      y: this.y,
+      availableHeight: this.availableHeight,
+      availableWidth: this.availableWidth,
+      page: this.page,
+      lastColumnWidth: this.lastColumnWidth
+    });
+  }
+  endDetachedBlock() {
+    let saved = this.snapshots.pop();
+    this.x = saved.x;
+    this.y = saved.y;
+    this.availableWidth = saved.availableWidth;
+    this.availableHeight = saved.availableHeight;
+    this.page = saved.page;
+    this.lastColumnWidth = saved.lastColumnWidth;
+  }
+  moveToNextPage(pageOrientation) {
+    let nextPageIndex = this.page + 1;
+    let prevPage = this.page;
+    let prevY = this.y;
+
+    // If we are in a column group
+    if (this.snapshots.length > 0) {
+      let lastSnapshot = this.snapshots[this.snapshots.length - 1];
+      // We have to update prevY accordingly by also taking into consideration
+      // the 'y' of cells that don't break page
+      if (lastSnapshot.bottomMost && lastSnapshot.bottomMost.y) {
+        prevY = Math.max(this.y, lastSnapshot.bottomMost.y);
+      }
+    }
+    let createNewPage = nextPageIndex >= this.pages.length;
+    if (createNewPage) {
+      let currentAvailableWidth = this.availableWidth;
+      let currentPageOrientation = this.getCurrentPage().pageSize.orientation;
+      let pageSize = getPageSize(this.getCurrentPage(), pageOrientation);
+      this.addPage(pageSize, null, this.getCurrentPage().customProperties);
+      if (currentPageOrientation === pageSize.orientation) {
+        this.availableWidth = currentAvailableWidth;
+      }
+    } else {
+      this.page = nextPageIndex;
+      this.initializePage();
+    }
+    return {
+      newPageCreated: createNewPage,
+      prevPage: prevPage,
+      prevY: prevY,
+      y: this.y
+    };
+  }
+  addPage(pageSize, pageMargin = null, customProperties = {}) {
+    if (pageMargin !== null) {
+      this.pageMargins = pageMargin;
+      this.x = pageMargin.left;
+      this.availableWidth = pageSize.width - pageMargin.left - pageMargin.right;
+    }
+    let page = {
+      items: [],
+      pageSize: pageSize,
+      pageMargins: this.pageMargins,
+      customProperties: customProperties
+    };
+    this.pages.push(page);
+    this.backgroundLength.push(0);
+    this.page = this.pages.length - 1;
+    this.initializePage();
+    this.emit('pageAdded', page);
+    return page;
+  }
+  getCurrentPage() {
+    if (this.page < 0 || this.page >= this.pages.length) {
+      return null;
+    }
+    return this.pages[this.page];
+  }
+  getCurrentPosition() {
+    let pageSize = this.getCurrentPage().pageSize;
+    let innerHeight = pageSize.height - this.pageMargins.top - this.pageMargins.bottom;
+    let innerWidth = pageSize.width - this.pageMargins.left - this.pageMargins.right;
+    return {
+      pageNumber: this.page + 1,
+      pageOrientation: pageSize.orientation,
+      pageInnerHeight: innerHeight,
+      pageInnerWidth: innerWidth,
+      left: this.x,
+      top: this.y,
+      verticalRatio: (this.y - this.pageMargins.top) / innerHeight,
+      horizontalRatio: (this.x - this.pageMargins.left) / innerWidth
+    };
+  }
+}
+function pageOrientation(pageOrientationString, currentPageOrientation) {
+  if (pageOrientationString === undefined) {
+    return currentPageOrientation;
+  } else if ((0, _variableType.isString)(pageOrientationString) && pageOrientationString.toLowerCase() === 'landscape') {
+    return 'landscape';
+  } else {
+    return 'portrait';
+  }
+}
+const getPageSize = (currentPage, newPageOrientation) => {
+  newPageOrientation = pageOrientation(newPageOrientation, currentPage.pageSize.orientation);
+  if (newPageOrientation !== currentPage.pageSize.orientation) {
+    return {
+      orientation: newPageOrientation,
+      width: currentPage.pageSize.height,
+      height: currentPage.pageSize.width
+    };
+  } else {
+    return {
+      orientation: currentPage.pageSize.orientation,
+      width: currentPage.pageSize.width,
+      height: currentPage.pageSize.height
+    };
+  }
+};
+function bottomMostContext(c1, c2) {
+  let r;
+  if (c1.page > c2.page) {
+    r = c1;
+  } else if (c2.page > c1.page) {
+    r = c2;
+  } else {
+    r = c1.y > c2.y ? c1 : c2;
+  }
+  return {
+    page: r.page,
+    x: r.x,
+    y: r.y,
+    availableHeight: r.availableHeight,
+    availableWidth: r.availableWidth
+  };
+}
+var _default = exports.default = DocumentContext;