pdfmake 0.3.0-beta.3 → 0.3.0-beta.5

package/js/3rd-party/svg-to-pdfkit.js

@@ -2,10 +2,7 @@
 
 exports.__esModule = true;
 exports.default = void 0;
-
 var _source = _interopRequireDefault(require("./svg-to-pdfkit/source.js"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 var _default = _source.default;
 exports.default = _default;

package/js/DocMeasure.js

@@ -2,25 +2,15 @@
 
 exports.__esModule = true;
 exports.default = void 0;
-
 var _TextInlines = _interopRequireDefault(require("./TextInlines"));
-
 var _StyleContextStack = _interopRequireDefault(require("./StyleContextStack"));
-
 var _columnCalculator = _interopRequireDefault(require("./columnCalculator"));
-
 var _tableLayouts = require("./tableLayouts");
-
 var _variableType = require("./helpers/variableType");
-
 var _node = require("./helpers/node");
-
 var _tools = require("./helpers/tools");
-
 var _qrEnc = _interopRequireDefault(require("./qrEnc.js"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 class DocMeasure {
   constructor(pdfDocument, styleDictionary, defaultStyle, svgMeasure, tableLayouts) {
     this.pdfDocument = pdfDocument;
@@ -30,6 +20,7 @@ class DocMeasure {
     this.tableLayouts = tableLayouts;
     this.autoImageIndex = 1;
   }
+
   /**
    * Measures all nodes and sets min/max-width properties required for the second
    * layout-pass.
@@ -37,17 +28,13 @@ class DocMeasure {
    * @param {object} docStructure document-definition-object
    * @returns {object} document-measurement-object
    */
-
-
   measureDocument(docStructure) {
     return this.measureNode(docStructure);
   }
-
   measureNode(node) {
     return this.styleStack.auto(node, () => {
       // TODO: refactor + rethink whether this is the proper way to handle margins
       node._margin = (0, _node.getNodeMargin)(node, this.styleStack);
-
       if (node.columns) {
         return extendMargins(this.measureColumns(node));
       } else if (node.stack) {
@@ -76,19 +63,15 @@ class DocMeasure {
         throw new Error(`Unrecognized document structure: ${(0, _node.stringifyNode)(node)}`);
       }
     });
-
     function extendMargins(node) {
       let margin = node._margin;
-
       if (margin) {
         node._minWidth += margin[0] + margin[2];
         node._maxWidth += margin[0] + margin[2];
       }
-
       return node;
     }
   }
-
   measureImageWithDimensions(node, dimensions) {
     if (node.fit) {
       let factor = dimensions.width / dimensions.height > node.fit[0] / node.fit[1] ? node.fit[0] / dimensions.width : node.fit[1] / dimensions.height;
@@ -97,31 +80,25 @@ class DocMeasure {
     } else {
       node._width = node._minWidth = node._maxWidth = node.width || dimensions.width;
       node._height = node.height || dimensions.height * node._width / dimensions.width;
-
       if ((0, _variableType.isNumber)(node.maxWidth) && node.maxWidth < node._width) {
         node._width = node._minWidth = node._maxWidth = node.maxWidth;
         node._height = node._width * dimensions.height / dimensions.width;
       }
-
       if ((0, _variableType.isNumber)(node.maxHeight) && node.maxHeight < node._height) {
         node._height = node.maxHeight;
         node._width = node._minWidth = node._maxWidth = node._height * dimensions.width / dimensions.height;
       }
-
       if ((0, _variableType.isNumber)(node.minWidth) && node.minWidth > node._width) {
         node._width = node._minWidth = node._maxWidth = node.minWidth;
         node._height = node._width * dimensions.height / dimensions.width;
       }
-
       if ((0, _variableType.isNumber)(node.minHeight) && node.minHeight > node._height) {
         node._height = node.minHeight;
         node._width = node._minWidth = node._maxWidth = node._height * dimensions.width / dimensions.height;
       }
     }
-
     node._alignment = this.styleStack.getProperty('alignment');
   }
-
   convertIfBase64Image(node) {
     if (/^data:image\/(jpeg|jpg|png);base64,/.test(node.image)) {
       // base64 image
@@ -130,7 +107,6 @@ class DocMeasure {
       node.image = label;
     }
   }
-
   measureImage(node) {
     this.convertIfBase64Image(node);
     let image = this.pdfDocument.provideImage(node.image);
@@ -141,26 +117,25 @@ class DocMeasure {
     this.measureImageWithDimensions(node, imageSize);
     return node;
   }
-
   measureSVG(node) {
     let dimensions = this.svgMeasure.measureSVG(node.svg);
     this.measureImageWithDimensions(node, dimensions);
-    node.font = this.styleStack.getProperty('font'); // scale SVG based on final dimension
+    node.font = this.styleStack.getProperty('font');
 
+    // scale SVG based on final dimension
     node.svg = this.svgMeasure.writeDimensions(node.svg, {
       width: node._width,
       height: node._height
     });
     return node;
   }
-
   measureLeaf(node) {
     if (node._textRef && node._textRef._textNodeRef.text) {
       node.text = node._textRef._textNodeRef.text;
-    } // Make sure style properties of the node itself are considered when building inlines.
-    // We could also just pass [node] to buildInlines, but that fails for bullet points.
-
+    }
 
+    // Make sure style properties of the node itself are considered when building inlines.
+    // We could also just pass [node] to buildInlines, but that fails for bullet points.
     let styleStack = this.styleStack.clone();
     styleStack.push(node);
     let data = this.textInlines.buildInlines(node.text, styleStack);
@@ -169,18 +144,15 @@ class DocMeasure {
     node._maxWidth = data.maxWidth;
     return node;
   }
-
   measureToc(node) {
     if (node.toc.title) {
       node.toc.title = this.measureNode(node.toc.title);
     }
-
     if (node.toc._items.length > 0) {
       let body = [];
       let textStyle = node.toc.textStyle || {};
       let numberStyle = node.toc.numberStyle || textStyle;
       let textMargin = node.toc.textMargin || [0, 0, 0, 0];
-
       for (let i = 0, l = node.toc._items.length; i < l; i++) {
         let item = node.toc._items[i];
         let lineStyle = item._textNodeRef.tocStyle || textStyle;
@@ -202,7 +174,6 @@ class DocMeasure {
           margin: [0, lineMargin[1], 0, lineMargin[3]]
         }]);
       }
-
       node.toc._table = {
         table: {
           dontBreakRows: true,
@@ -213,28 +184,22 @@ class DocMeasure {
       };
       node.toc._table = this.measureNode(node.toc._table);
     }
-
     return node;
   }
-
   measureVerticalContainer(node) {
     let items = node.stack;
     node._minWidth = 0;
     node._maxWidth = 0;
-
     for (let i = 0, l = items.length; i < l; i++) {
       items[i] = this.measureNode(items[i]);
       node._minWidth = Math.max(node._minWidth, items[i]._minWidth);
       node._maxWidth = Math.max(node._maxWidth, items[i]._maxWidth);
     }
-
     return node;
   }
-
   gapSizeForList() {
     return this.textInlines.sizeOfText('9. ', this.styleStack);
   }
-
   buildUnorderedMarker(styleStack, gapSize, type) {
     function buildDisc(gapSize, color) {
       // TODO: ascender-based calculations
@@ -250,7 +215,6 @@ class DocMeasure {
         }]
       };
     }
-
     function buildSquare(gapSize, color) {
       // TODO: ascender-based calculations
       let size = gapSize.fontSize / 3;
@@ -265,7 +229,6 @@ class DocMeasure {
         }]
       };
     }
-
     function buildCircle(gapSize, color) {
       // TODO: ascender-based calculations
       let radius = gapSize.fontSize / 6;
@@ -280,52 +243,41 @@ class DocMeasure {
         }]
       };
     }
-
     let marker;
     let color = styleStack.getProperty('markerColor') || styleStack.getProperty('color') || 'black';
-
     switch (type) {
       case 'circle':
         marker = buildCircle(gapSize, color);
         break;
-
       case 'square':
         marker = buildSquare(gapSize, color);
         break;
-
       case 'none':
         marker = {};
         break;
-
       case 'disc':
       default:
         marker = buildDisc(gapSize, color);
         break;
     }
-
     marker._minWidth = marker._maxWidth = gapSize.width;
     marker._minHeight = marker._maxHeight = gapSize.height;
     return marker;
   }
-
   buildOrderedMarker(counter, styleStack, type, separator) {
     function prepareAlpha(counter) {
       function toAlpha(num) {
         return (num >= 26 ? toAlpha((num / 26 >> 0) - 1) : '') + 'abcdefghijklmnopqrstuvwxyz'[num % 26 >> 0];
       }
-
       if (counter < 1) {
         return counter.toString();
       }
-
       return toAlpha(counter - 1);
     }
-
     function prepareRoman(counter) {
       if (counter < 1 || counter > 4999) {
         return counter.toString();
       }
-
       let num = counter;
       let lookup = {
         M: 1000,
@@ -343,84 +295,66 @@ class DocMeasure {
         I: 1
       };
       let roman = '';
-
       for (let i in lookup) {
         while (num >= lookup[i]) {
           roman += i;
           num -= lookup[i];
         }
       }
-
       return roman;
     }
-
     function prepareDecimal(counter) {
       return counter.toString();
     }
-
     let counterText;
-
     switch (type) {
       case 'none':
         counterText = null;
         break;
-
       case 'upper-alpha':
         counterText = prepareAlpha(counter).toUpperCase();
         break;
-
       case 'lower-alpha':
         counterText = prepareAlpha(counter);
         break;
-
       case 'upper-roman':
         counterText = prepareRoman(counter);
         break;
-
       case 'lower-roman':
         counterText = prepareRoman(counter).toLowerCase();
         break;
-
       case 'decimal':
       default:
         counterText = prepareDecimal(counter);
         break;
     }
-
     if (counterText === null) {
       return {};
     }
-
     if (separator) {
       if (Array.isArray(separator)) {
         if (separator[0]) {
           counterText = separator[0] + counterText;
         }
-
         if (separator[1]) {
           counterText += separator[1];
         }
-
         counterText += ' ';
       } else {
         counterText += `${separator} `;
       }
     }
-
     let textArray = {
       text: counterText
     };
     let markerColor = styleStack.getProperty('markerColor');
-
     if (markerColor) {
       textArray.color = markerColor;
     }
-
     return {
       _inlines: this.textInlines.buildInlines(textArray, styleStack).items
     };
   }
-
   measureUnorderedList(node) {
     let style = this.styleStack.clone();
     let items = node.ul;
@@ -428,90 +362,69 @@ class DocMeasure {
     node._gapSize = this.gapSizeForList();
     node._minWidth = 0;
     node._maxWidth = 0;
-
     for (let i = 0, l = items.length; i < l; i++) {
       let item = items[i] = this.measureNode(items[i]);
-
       if (!item.ol && !item.ul) {
         item.listMarker = this.buildUnorderedMarker(style, node._gapSize, item.listType || node.type);
       }
-
       node._minWidth = Math.max(node._minWidth, items[i]._minWidth + node._gapSize.width);
       node._maxWidth = Math.max(node._maxWidth, items[i]._maxWidth + node._gapSize.width);
     }
-
     return node;
   }
-
   measureOrderedList(node) {
     let style = this.styleStack.clone();
     let items = node.ol;
     node.type = node.type || 'decimal';
     node.separator = node.separator || '.';
     node.reversed = node.reversed || false;
-
     if (!(0, _variableType.isNumber)(node.start)) {
       node.start = node.reversed ? items.length : 1;
     }
-
     node._gapSize = this.gapSizeForList();
     node._minWidth = 0;
     node._maxWidth = 0;
     let counter = node.start;
-
     for (let i = 0, l = items.length; i < l; i++) {
       let item = items[i] = this.measureNode(items[i]);
-
       if (!item.ol && !item.ul) {
         let counterValue = (0, _variableType.isNumber)(item.counter) ? item.counter : counter;
         item.listMarker = this.buildOrderedMarker(counterValue, style, item.listType || node.type, node.separator);
-
         if (item.listMarker._inlines) {
           node._gapSize.width = Math.max(node._gapSize.width, item.listMarker._inlines[0].width);
         }
       } // TODO: else - nested lists numbering
 
-
       node._minWidth = Math.max(node._minWidth, items[i]._minWidth);
       node._maxWidth = Math.max(node._maxWidth, items[i]._maxWidth);
-
       if (node.reversed) {
         counter--;
       } else {
         counter++;
       }
     }
-
     node._minWidth += node._gapSize.width;
     node._maxWidth += node._gapSize.width;
-
     for (let i = 0, l = items.length; i < l; i++) {
       let item = items[i];
-
       if (!item.ol && !item.ul) {
         item.listMarker._minWidth = item.listMarker._maxWidth = node._gapSize.width;
       }
     }
-
     return node;
   }
-
   measureColumns(node) {
     let columns = node.columns;
     node._gap = this.styleStack.getProperty('columnGap') || 0;
-
     for (let i = 0, l = columns.length; i < l; i++) {
       columns[i] = this.measureNode(columns[i]);
     }
-
     let measures = _columnCalculator.default.measureMinMax(columns);
-
     let numGaps = columns.length > 0 ? columns.length - 1 : 0;
     node._minWidth = measures.min + node._gap * numGaps;
     node._maxWidth = measures.max + node._gap * numGaps;
     return node;
   }
-
   measureTable(node) {
     extendTableWidths(node);
     node._layout = getLayout(this.tableLayouts);
@@ -521,28 +434,22 @@ class DocMeasure {
     let row;
     let cols;
     let rows;
-
     for (col = 0, cols = node.table.body[0].length; col < cols; col++) {
       let c = node.table.widths[col];
       c._minWidth = 0;
       c._maxWidth = 0;
-
       for (row = 0, rows = node.table.body.length; row < rows; row++) {
         let rowData = node.table.body[row];
         let data = rowData[col];
-
         if (data === undefined) {
           throw new Error(`Malformed table row, a cell is undefined.\nRow index: ${row}\nColumn index: ${col}\nRow data: ${(0, _node.stringifyNode)(rowData)}`);
         }
-
         if (data === null) {
           // transform to object
           data = '';
         }
-
         if (!data._span) {
           data = rowData[col] = this.styleStack.auto(data, measureCb(this, data));
-
           if (data.colSpan && data.colSpan > 1) {
             markSpans(rowData, col, data.colSpan);
             colSpans.push({
@@ -556,103 +463,81 @@ class DocMeasure {
             c._maxWidth = Math.max(c._maxWidth, data._maxWidth);
           }
         }
-
         if (data.rowSpan && data.rowSpan > 1) {
           markVSpans(node.table, row, col, data.rowSpan);
         }
       }
     }
-
     extendWidthsForColSpans();
-
     let measures = _columnCalculator.default.measureMinMax(node.table.widths);
-
     node._minWidth = measures.min + node._offsets.total;
     node._maxWidth = measures.max + node._offsets.total;
     return node;
-
     function measureCb(_this, data) {
       return () => {
         if ((0, _variableType.isObject)(data)) {
           data.fillColor = _this.styleStack.getProperty('fillColor');
           data.fillOpacity = _this.styleStack.getProperty('fillOpacity');
         }
-
         return _this.measureNode(data);
       };
     }
-
     function getLayout(tableLayouts) {
       let layout = node.layout;
-
       if ((0, _variableType.isString)(layout)) {
         layout = tableLayouts[layout];
       }
-
       return (0, _tools.pack)(_tableLayouts.defaultTableLayout, layout);
     }
-
     function getOffsets(layout) {
       let offsets = [];
       let totalOffset = 0;
       let prevRightPadding = 0;
-
       for (let i = 0, l = node.table.widths.length; i < l; i++) {
         let lOffset = prevRightPadding + layout.vLineWidth(i, node) + layout.paddingLeft(i, node);
         offsets.push(lOffset);
         totalOffset += lOffset;
         prevRightPadding = layout.paddingRight(i, node);
       }
-
       totalOffset += prevRightPadding + layout.vLineWidth(node.table.widths.length, node);
       return {
         total: totalOffset,
         offsets: offsets
       };
     }
-
     function extendWidthsForColSpans() {
       let q;
       let j;
-
       for (let i = 0, l = colSpans.length; i < l; i++) {
         let span = colSpans[i];
         let currentMinMax = getMinMax(span.col, span.span, node._offsets);
         let minDifference = span.minWidth - currentMinMax.minWidth;
         let maxDifference = span.maxWidth - currentMinMax.maxWidth;
-
         if (minDifference > 0) {
           q = minDifference / span.span;
-
           for (j = 0; j < span.span; j++) {
             node.table.widths[span.col + j]._minWidth += q;
           }
         }
-
         if (maxDifference > 0) {
           q = maxDifference / span.span;
-
           for (j = 0; j < span.span; j++) {
             node.table.widths[span.col + j]._maxWidth += q;
           }
         }
       }
     }
-
     function getMinMax(col, span, offsets) {
       let result = {
         minWidth: 0,
         maxWidth: 0
       };
-
       for (let i = 0; i < span; i++) {
         result.minWidth += node.table.widths[col + i]._minWidth + (i ? offsets.offsets[col + i] : 0);
         result.maxWidth += node.table.widths[col + i]._maxWidth + (i ? offsets.offsets[col + i] : 0);
       }
-
       return result;
     }
-
     function markSpans(rowData, col, span) {
       for (let i = 1; i < span; i++) {
         rowData[col + i] = {
@@ -663,7 +548,6 @@ class DocMeasure {
         };
       }
     }
-
     function markVSpans(table, row, col, span) {
       for (let i = 1; i < span; i++) {
         table.body[row + i][col] = {
@@ -675,23 +559,18 @@ class DocMeasure {
         };
       }
     }
-
     function extendTableWidths(node) {
       if (!node.table.widths) {
         node.table.widths = 'auto';
       }
-
       if ((0, _variableType.isString)(node.table.widths)) {
         node.table.widths = [node.table.widths];
-
         while (node.table.widths.length < node.table.body[0].length) {
           node.table.widths.push(node.table.widths[node.table.widths.length - 1]);
         }
       }
-
       for (let i = 0, l = node.table.widths.length; i < l; i++) {
         let w = node.table.widths[i];
-
         if ((0, _variableType.isNumber)(w) || (0, _variableType.isString)(w)) {
           node.table.widths[i] = {
             width: w
@@ -700,59 +579,47 @@ class DocMeasure {
       }
     }
   }
-
   measureCanvas(node) {
     let w = 0;
     let h = 0;
-
     for (let i = 0, l = node.canvas.length; i < l; i++) {
       let vector = node.canvas[i];
-
       switch (vector.type) {
         case 'ellipse':
           w = Math.max(w, vector.x + vector.r1);
           h = Math.max(h, vector.y + vector.r2);
           break;
-
         case 'rect':
           w = Math.max(w, vector.x + vector.w);
           h = Math.max(h, vector.y + vector.h);
           break;
-
         case 'line':
           w = Math.max(w, vector.x1, vector.x2);
           h = Math.max(h, vector.y1, vector.y2);
           break;
-
         case 'polyline':
           for (let i2 = 0, l2 = vector.points.length; i2 < l2; i2++) {
             w = Math.max(w, vector.points[i2].x);
             h = Math.max(h, vector.points[i2].y);
           }
-
           break;
       }
     }
-
     node._minWidth = node._maxWidth = w;
     node._minHeight = node._maxHeight = h;
     node._alignment = this.styleStack.getProperty('alignment');
     return node;
   }
-
   measureQr(node) {
     node = _qrEnc.default.measure(node);
     node._alignment = this.styleStack.getProperty('alignment');
     return node;
   }
-
   measureAttachment(node) {
     node._width = node.width || 7;
     node._height = node.height || 18;
     return node;
   }
-
 }
-
 var _default = DocMeasure;
 exports.default = _default;