pdfmake 0.3.0-beta.3 → 0.3.0-beta.4

package/js/LayoutBuilder.js

@@ -2,44 +2,29 @@
 
 exports.__esModule = true;
 exports.default = void 0;
-
 var _DocPreprocessor = _interopRequireDefault(require("./DocPreprocessor"));
-
 var _DocMeasure = _interopRequireDefault(require("./DocMeasure"));
-
 var _DocumentContext = _interopRequireDefault(require("./DocumentContext"));
-
 var _PageElementWriter = _interopRequireDefault(require("./PageElementWriter"));
-
 var _columnCalculator = _interopRequireDefault(require("./columnCalculator"));
-
 var _TableProcessor = _interopRequireDefault(require("./TableProcessor"));
-
 var _Line = _interopRequireDefault(require("./Line"));
-
 var _variableType = require("./helpers/variableType");
-
 var _node = require("./helpers/node");
-
 var _tools = require("./helpers/tools");
-
 var _TextInlines = _interopRequireDefault(require("./TextInlines"));
-
 var _StyleContextStack = _interopRequireDefault(require("./StyleContextStack"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 function addAll(target, otherArray) {
   otherArray.forEach(item => {
     target.push(item);
   });
 }
+
 /**
  * Layout engine which turns document-definition-object into a set of pages, lines, inlines
  * and vectors ready to be rendered into a PDF
  */
-
-
 class LayoutBuilder {
   /**
    * @param {object} pageSize - an object defining page width and height
@@ -52,10 +37,10 @@ class LayoutBuilder {
     this.svgMeasure = svgMeasure;
     this.tableLayouts = {};
   }
-
   registerTableLayouts(tableLayouts) {
     this.tableLayouts = (0, _tools.pack)(this.tableLayouts, tableLayouts);
   }
+
   /**
    * Executes layout engine on document-definition-object and creates an array of pages
    * containing positioned Blocks, Lines and inlines
@@ -71,14 +56,11 @@ class LayoutBuilder {
    * @param {object} pageBreakBeforeFct
    * @returns {Array} an array of pages
    */
-
-
   layoutDocument(docStructure, pdfDocument, styleDictionary, defaultStyle, background, header, footer, watermark, pageBreakBeforeFct) {
     function addPageBreaksIfNecessary(linearNodeList, pages) {
       if (typeof pageBreakBeforeFct !== 'function') {
         return false;
       }
-
       linearNodeList = linearNodeList.filter(node => node.positions.length > 0);
       linearNodeList.forEach(node => {
         let nodeInfo = {};
@@ -93,46 +75,37 @@ class LayoutBuilder {
         nodeInfo.stack = Array.isArray(node.stack);
         node.nodeInfo = nodeInfo;
       });
-
       for (let index = 0; index < linearNodeList.length; index++) {
         let node = linearNodeList[index];
-
         if (node.pageBreak !== 'before' && !node.pageBreakCalculated) {
           node.pageBreakCalculated = true;
           let pageNumber = node.nodeInfo.pageNumbers[0];
-
           if (pageBreakBeforeFct(node.nodeInfo, {
             getFollowingNodesOnPage: () => {
               let followingNodesOnPage = [];
-
               for (let ii = index + 1, l = linearNodeList.length; ii < l; ii++) {
                 if (linearNodeList[ii].nodeInfo.pageNumbers.indexOf(pageNumber) > -1) {
                   followingNodesOnPage.push(linearNodeList[ii].nodeInfo);
                 }
               }
-
               return followingNodesOnPage;
             },
             getNodesOnNextPage: () => {
               let nodesOnNextPage = [];
-
               for (let ii = index + 1, l = linearNodeList.length; ii < l; ii++) {
                 if (linearNodeList[ii].nodeInfo.pageNumbers.indexOf(pageNumber + 1) > -1) {
                   nodesOnNextPage.push(linearNodeList[ii].nodeInfo);
                 }
               }
-
               return nodesOnNextPage;
             },
             getPreviousNodesOnPage: () => {
               let previousNodesOnPage = [];
-
               for (let ii = 0; ii < index; ii++) {
                 if (linearNodeList[ii].nodeInfo.pageNumbers.indexOf(pageNumber) > -1) {
                   previousNodesOnPage.push(linearNodeList[ii].nodeInfo);
                 }
               }
-
               return previousNodesOnPage;
             }
           })) {
@@ -141,29 +114,22 @@ class LayoutBuilder {
           }
         }
       }
-
       return false;
     }
-
     this.docPreprocessor = new _DocPreprocessor.default();
     this.docMeasure = new _DocMeasure.default(pdfDocument, styleDictionary, defaultStyle, this.svgMeasure, this.tableLayouts);
-
     function resetXYs(result) {
       result.linearNodeList.forEach(node => {
         node.resetXY();
       });
     }
-
     let result = this.tryLayoutDocument(docStructure, pdfDocument, styleDictionary, defaultStyle, background, header, footer, watermark);
-
     while (addPageBreaksIfNecessary(result.linearNodeList, result.pages)) {
       resetXYs(result);
       result = this.tryLayoutDocument(docStructure, pdfDocument, styleDictionary, defaultStyle, background, header, footer, watermark);
     }
-
     return result.pages;
   }
-
   tryLayoutDocument(docStructure, pdfDocument, styleDictionary, defaultStyle, background, header, footer, watermark) {
     this.linearNodeList = [];
     docStructure = this.docPreprocessor.preprocessDocument(docStructure);
@@ -175,23 +141,19 @@ class LayoutBuilder {
     this.addBackground(background);
     this.processNode(docStructure);
     this.addHeadersAndFooters(header, footer);
-
     if (watermark != null) {
       this.addWatermark(watermark, pdfDocument, defaultStyle);
     }
-
     return {
       pages: this.writer.context().pages,
       linearNodeList: this.linearNodeList
     };
   }
-
   addBackground(background) {
     let backgroundGetter = typeof background === 'function' ? background : () => background;
     let context = this.writer.context();
     let pageSize = context.getCurrentPage().pageSize;
     let pageBackground = backgroundGetter(context.page + 1, pageSize);
-
     if (pageBackground) {
       this.writer.beginUnbreakableBlock(pageSize.width, pageSize.height);
       pageBackground = this.docPreprocessor.preprocessDocument(pageBackground);
@@ -200,19 +162,16 @@ class LayoutBuilder {
       context.backgroundLength[context.page] += pageBackground.positions.length;
     }
   }
-
   addStaticRepeatable(headerOrFooter, sizeFunction) {
-    this.addDynamicRepeatable(() => // copy to new object
+    this.addDynamicRepeatable(() =>
+    // copy to new object
     JSON.parse(JSON.stringify(headerOrFooter)), sizeFunction);
   }
-
   addDynamicRepeatable(nodeGetter, sizeFunction) {
     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);
-
       if (node) {
         let sizes = sizeFunction(this.writer.context().getCurrentPage().pageSize, this.pageMargins);
         this.writer.beginUnbreakableBlock(sizes.width, sizes.height);
@@ -222,7 +181,6 @@ class LayoutBuilder {
       }
     }
   }
-
   addHeadersAndFooters(header, footer) {
     const headerSizeFct = (pageSize, pageMargins) => ({
       x: 0,
@@ -230,39 +188,33 @@ class LayoutBuilder {
       width: pageSize.width,
       height: pageMargins.top
     });
-
     const footerSizeFct = (pageSize, pageMargins) => ({
       x: 0,
       y: pageSize.height - pageMargins.bottom,
       width: pageSize.width,
       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);
     }
   }
-
   addWatermark(watermark, pdfDocument, defaultStyle) {
     if ((0, _variableType.isString)(watermark)) {
       watermark = {
         'text': watermark
       };
     }
-
     if (!watermark.text) {
       // empty watermark text
       return;
     }
-
     watermark.font = watermark.font || defaultStyle.font || 'Roboto';
     watermark.fontSize = watermark.fontSize || 'auto';
     watermark.color = watermark.color || 'black';
@@ -270,15 +222,12 @@ class LayoutBuilder {
     watermark.bold = watermark.bold || false;
     watermark.italics = watermark.italics || false;
     watermark.angle = (0, _variableType.isValue)(watermark.angle) ? watermark.angle : null;
-
     if (watermark.angle === null) {
       watermark.angle = Math.atan2(this.pageSize.height, this.pageSize.width) * -180 / Math.PI;
     }
-
     if (watermark.fontSize === 'auto') {
       watermark.fontSize = getWatermarkFontSize(this.pageSize, watermark, pdfDocument);
     }
-
     let watermarkObject = {
       text: watermark.text,
       font: pdfDocument.provideFont(watermark.font, watermark.bold, watermark.italics),
@@ -289,11 +238,9 @@ class LayoutBuilder {
     };
     watermarkObject._size = getWatermarkSize(watermark, pdfDocument);
     let pages = this.writer.context().pages;
-
     for (let i = 0, l = pages.length; i < l; i++) {
       pages[i].watermark = watermarkObject;
     }
-
     function getWatermarkSize(watermark, pdfDocument) {
       let textInlines = new _TextInlines.default(pdfDocument);
       let styleContextStack = new _StyleContextStack.default(null, {
@@ -311,7 +258,6 @@ class LayoutBuilder {
         rotatedSize: rotatedSize
       };
     }
-
     function getWatermarkFontSize(pageSize, watermark, pdfDocument) {
       let textInlines = new _TextInlines.default(pdfDocument);
       let styleContextStack = new _StyleContextStack.default(null, {
@@ -320,22 +266,20 @@ class LayoutBuilder {
         italics: watermark.italics
       });
       let rotatedSize;
+
       /**
        * Binary search the best font size.
        * Initial bounds [0, 1000]
        * Break when range < 1
        */
-
       let a = 0;
       let b = 1000;
       let c = (a + b) / 2;
-
       while (Math.abs(a - b) > 1) {
         styleContextStack.push({
           fontSize: c
         });
         rotatedSize = textInlines.sizeOfRotatedText(watermark.text, watermark.angle, styleContextStack);
-
         if (rotatedSize.width > pageSize.width) {
           b = c;
           c = (a + b) / 2;
@@ -348,90 +292,70 @@ class LayoutBuilder {
             c = (a + b) / 2;
           }
         }
-
         styleContextStack.pop();
       }
       /*
        End binary search
        */
-
-
       return c;
     }
   }
-
   processNode(node) {
     const applyMargins = callback => {
       let margin = node._margin;
-
       if (node.pageBreak === 'before') {
         this.writer.moveToNextPage(node.pageOrientation);
       } else if (node.pageBreak === 'beforeOdd') {
         this.writer.moveToNextPage(node.pageOrientation);
-
         if ((this.writer.context().page + 1) % 2 === 1) {
           this.writer.moveToNextPage(node.pageOrientation);
         }
       } else if (node.pageBreak === 'beforeEven') {
         this.writer.moveToNextPage(node.pageOrientation);
-
         if ((this.writer.context().page + 1) % 2 === 0) {
           this.writer.moveToNextPage(node.pageOrientation);
         }
       }
-
       if (margin) {
         this.writer.context().moveDown(margin[1]);
         this.writer.context().addMargin(margin[0], margin[2]);
       }
-
       callback();
-
       if (margin) {
         this.writer.context().addMargin(-margin[0], -margin[2]);
         this.writer.context().moveDown(margin[3]);
       }
-
       if (node.pageBreak === 'after') {
         this.writer.moveToNextPage(node.pageOrientation);
       } else if (node.pageBreak === 'afterOdd') {
         this.writer.moveToNextPage(node.pageOrientation);
-
         if ((this.writer.context().page + 1) % 2 === 1) {
           this.writer.moveToNextPage(node.pageOrientation);
         }
       } else if (node.pageBreak === 'afterEven') {
         this.writer.moveToNextPage(node.pageOrientation);
-
         if ((this.writer.context().page + 1) % 2 === 0) {
           this.writer.moveToNextPage(node.pageOrientation);
         }
       }
     };
-
     this.linearNodeList.push(node);
     decorateNode(node);
     applyMargins(() => {
       let unbreakable = node.unbreakable;
-
       if (unbreakable) {
         this.writer.beginUnbreakableBlock();
       }
-
       let absPosition = node.absolutePosition;
-
       if (absPosition) {
         this.writer.context().beginDetachedBlock();
         this.writer.context().moveTo(absPosition.x || 0, absPosition.y || 0);
       }
-
       let relPosition = node.relativePosition;
-
       if (relPosition) {
         this.writer.context().beginDetachedBlock();
         this.writer.context().moveToRelative(relPosition.x || 0, relPosition.y || 0);
       }
-
       if (node.stack) {
         this.processVerticalContainer(node);
       } else if (node.columns) {
@@ -459,97 +383,80 @@ class LayoutBuilder {
       } else if (!node._span) {
         throw new Error(`Unrecognized document structure: ${(0, _node.stringifyNode)(node)}`);
       }
-
       if (absPosition || relPosition) {
         this.writer.context().endDetachedBlock();
       }
-
       if (unbreakable) {
         this.writer.commitUnbreakableBlock();
       }
     });
-  } // vertical container
-
+  }
 
+  // vertical container
   processVerticalContainer(node) {
     node.stack.forEach(item => {
       this.processNode(item);
-      addAll(node.positions, item.positions); //TODO: paragraph gap
-    }, this);
-  } // columns
+      addAll(node.positions, item.positions);
 
+      //TODO: paragraph gap
+    }, this);
+  }
 
+  // columns
   processColumns(columnNode) {
     let columns = columnNode.columns;
     let availableWidth = this.writer.context().availableWidth;
     let gaps = gapArray(columnNode._gap);
-
     if (gaps) {
       availableWidth -= (gaps.length - 1) * columnNode._gap;
     }
-
     _columnCalculator.default.buildColumnWidths(columns, availableWidth);
-
     let result = this.processRow(columns, columns, gaps);
     addAll(columnNode.positions, result.positions);
-
     function gapArray(gap) {
       if (!gap) {
         return null;
       }
-
       let gaps = [];
       gaps.push(0);
-
       for (let i = columns.length - 1; i > 0; i--) {
         gaps.push(gap);
       }
-
       return gaps;
     }
   }
-
   processRow(columns, widths, gaps, tableBody, tableRow, height) {
     const storePageBreakData = data => {
       let pageDesc;
-
       for (let i = 0, l = pageBreaks.length; i < l; i++) {
         let desc = pageBreaks[i];
-
         if (desc.prevPage === data.prevPage) {
           pageDesc = desc;
           break;
         }
       }
-
       if (!pageDesc) {
         pageDesc = data;
         pageBreaks.push(pageDesc);
       }
-
       pageDesc.prevY = Math.max(pageDesc.prevY, data.prevY);
       pageDesc.y = Math.min(pageDesc.y, data.y);
     };
-
     let pageBreaks = [];
     let positions = [];
     this.writer.addListener('pageChanged', storePageBreakData);
     widths = widths || columns;
     this.writer.context().beginColumnGroup();
-
     for (let i = 0, l = columns.length; i < l; i++) {
       let column = columns[i];
       let width = widths[i]._calcWidth;
       let leftOffset = colLeftOffset(i);
-
       if (column.colSpan && column.colSpan > 1) {
         for (let j = 1; j < column.colSpan; j++) {
           width += widths[++i]._calcWidth + gaps[i];
         }
       }
-
       this.writer.context().beginColumn(width, leftOffset, getEndingCell(column, i));
-
       if (!column._span) {
         this.processNode(column);
         addAll(positions, column.positions);
@@ -558,38 +465,31 @@ class LayoutBuilder {
         this.writer.context().markEnding(column);
       }
     }
-
     this.writer.context().completeColumnGroup(height);
     this.writer.removeListener('pageChanged', storePageBreakData);
     return {
       pageBreaks: pageBreaks,
       positions: positions
     };
-
     function colLeftOffset(i) {
       if (gaps && gaps.length > i) {
         return gaps[i];
       }
-
       return 0;
     }
-
     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];
       }
-
       return null;
     }
-  } // lists
-
+  }
 
+  // lists
   processList(orderedList, node) {
     const addMarkerToFirstLeaf = line => {
       // I'm not very happy with the way list processing is implemented
@@ -597,7 +497,6 @@ class LayoutBuilder {
       if (nextMarker) {
         let marker = nextMarker;
         nextMarker = null;
-
         if (marker.canvas) {
           let vector = marker.canvas[0];
           (0, _tools.offsetVector)(vector, -marker._minWidth, 0);
@@ -611,7 +510,6 @@ class LayoutBuilder {
         }
       }
     };
-
     let items = orderedList ? node.ol : node.ul;
     let gapSize = node._gapSize;
     this.writer.context().addMargin(gapSize.width);
@@ -624,18 +522,16 @@ class LayoutBuilder {
     });
     this.writer.removeListener('lineAdded', addMarkerToFirstLeaf);
     this.writer.context().addMargin(-gapSize.width);
-  } // tables
-
+  }
 
+  // tables
   processTable(tableNode) {
     let processor = new _TableProcessor.default(tableNode);
     processor.beginTable(this.writer);
     let rowHeights = tableNode.table.heights;
-
     for (let i = 0, l = tableNode.table.body.length; i < l; i++) {
       processor.beginRow(i, this.writer);
       let height;
-
       if (typeof rowHeights === 'function') {
         height = rowHeights(i);
       } else if (Array.isArray(rowHeights)) {
@@ -643,167 +539,130 @@ class LayoutBuilder {
       } else {
         height = rowHeights;
       }
-
       if (height === 'auto') {
         height = undefined;
       }
-
       let result = this.processRow(tableNode.table.body[i], tableNode.table.widths, tableNode._offsets.offsets, tableNode.table.body, i, height);
       addAll(tableNode.positions, result.positions);
       processor.endRow(i, this.writer, result.pageBreaks);
     }
-
     processor.endTable(this.writer);
-  } // leafs (texts)
-
+  }
 
+  // leafs (texts)
   processLeaf(node) {
     let line = this.buildNextLine(node);
-
     if (line && (node.tocItem || node.id)) {
       line._node = node;
     }
-
     let currentHeight = line ? line.getHeight() : 0;
     let maxHeight = node.maxHeight || -1;
-
     if (line) {
       let nodeId = (0, _node.getNodeId)(node);
-
       if (nodeId) {
         line.id = nodeId;
       }
     }
-
     if (node._tocItemRef) {
       line._pageNodeRef = node._tocItemRef;
     }
-
     if (node._pageRef) {
       line._pageNodeRef = node._pageRef._nodeRef;
     }
-
     if (line && line.inlines && Array.isArray(line.inlines)) {
       for (let i = 0, l = line.inlines.length; i < l; i++) {
         if (line.inlines[i]._tocItemRef) {
           line.inlines[i]._pageNodeRef = line.inlines[i]._tocItemRef;
         }
-
         if (line.inlines[i]._pageRef) {
           line.inlines[i]._pageNodeRef = line.inlines[i]._pageRef._nodeRef;
         }
       }
     }
-
     while (line && (maxHeight === -1 || currentHeight < maxHeight)) {
       let positions = this.writer.addLine(line);
       node.positions.push(positions);
       line = this.buildNextLine(node);
-
       if (line) {
         currentHeight += line.getHeight();
       }
     }
   }
-
   processToc(node) {
     if (node.toc.title) {
       this.processNode(node.toc.title);
     }
-
     if (node.toc._table) {
       this.processNode(node.toc._table);
     }
   }
-
   buildNextLine(textNode) {
     function cloneInline(inline) {
       let newInline = inline.constructor();
-
       for (let key in inline) {
         newInline[key] = inline[key];
       }
-
       return newInline;
     }
-
     if (!textNode._inlines || textNode._inlines.length === 0) {
       return null;
     }
-
     let line = new _Line.default(this.writer.context().availableWidth);
     const textInlines = new _TextInlines.default(null);
     let isForceContinue = false;
-
     while (textNode._inlines && textNode._inlines.length > 0 && (line.hasEnoughSpaceForInline(textNode._inlines[0], textNode._inlines.slice(1)) || isForceContinue)) {
       let isHardWrap = false;
-
       let inline = textNode._inlines.shift();
-
       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;
         }
-
         if (maxChars < inline.text.length) {
           let newInline = cloneInline(inline);
           newInline.text = inline.text.substr(maxChars);
           inline.text = inline.text.substr(0, maxChars);
           newInline.width = textInlines.widthOfText(newInline.text, newInline);
           inline.width = textInlines.widthOfText(inline.text, inline);
-
           textNode._inlines.unshift(newInline);
-
           isHardWrap = true;
         }
       }
-
       line.addInline(inline);
       isForceContinue = inline.noNewLine && !isHardWrap;
     }
-
     line.lastLineInParagraph = textNode._inlines.length === 0;
     return line;
-  } // images
-
+  }
 
+  // images
   processImage(node) {
     let position = this.writer.addImage(node);
     node.positions.push(position);
   }
-
   processCanvas(node) {
     let positions = this.writer.addCanvas(node);
     addAll(node.positions, positions);
   }
-
   processSVG(node) {
     let position = this.writer.addSVG(node);
     node.positions.push(position);
   }
-
   processQr(node) {
     let position = this.writer.addQr(node);
     node.positions.push(position);
   }
-
   processAttachment(node) {
     let position = this.writer.addAttachment(node);
     node.positions.push(position);
   }
-
 }
-
 function decorateNode(node) {
   let x = node.x;
   let y = node.y;
   node.positions = [];
-
   if (Array.isArray(node.canvas)) {
     node.canvas.forEach(vector => {
       let x = vector.x;
@@ -812,7 +671,6 @@ function decorateNode(node) {
       let y1 = vector.y1;
       let x2 = vector.x2;
       let y2 = vector.y2;
-
       vector.resetXY = () => {
         vector.x = x;
         vector.y = y;
@@ -823,11 +681,9 @@ function decorateNode(node) {
       };
     });
   }
-
   node.resetXY = () => {
     node.x = x;
     node.y = y;
-
     if (Array.isArray(node.canvas)) {
       node.canvas.forEach(vector => {
         vector.resetXY();
@@ -835,6 +691,5 @@ function decorateNode(node) {
     }
   };
 }
-
 var _default = LayoutBuilder;
 exports.default = _default;