pdfmake 0.3.0-beta.17 → 0.3.0-beta.19

package/js/DocMeasure.js

@@ -31,11 +31,16 @@ class DocMeasure {
   measureDocument(docStructure) {
     return this.measureNode(docStructure);
   }
+  measureBlock(node) {
+    return this.measureNode(node);
+  }
   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) {
+      if (node.section) {
+        return extendMargins(this.measureSection(node));
+      } else if (node.columns) {
         return extendMargins(this.measureColumns(node));
       } else if (node.stack) {
         return extendMargins(this.measureVerticalContainer(node));
@@ -423,6 +428,12 @@ class DocMeasure {
     }
     return node;
   }
+  measureSection(node) {
+    // TODO: properties
+
+    node.section = this.measureNode(node.section);
+    return node;
+  }
   measureColumns(node) {
     let columns = node.columns;
     node._gap = this.styleStack.getProperty('columnGap') || 0;

package/js/DocPreprocessor.js

@@ -22,9 +22,15 @@ class DocPreprocessor {
     this.parentNode = null;
     this.tocs = [];
     this.nodeReferences = [];
-    return this.preprocessNode(docStructure);
+    return this.preprocessNode(docStructure, true);
   }
-  preprocessNode(node) {
+  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 = {
@@ -39,10 +45,15 @@ class DocPreprocessor {
       // cast value in text property
       node.text = convertValueToString(node.text);
     }
-    if (node.columns) {
+    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);
+      return this.preprocessVerticalContainer(node, isSectionAllowed);
     } else if (node.ul) {
       return this.preprocessList(node);
     } else if (node.ol) {
@@ -69,6 +80,10 @@ class DocPreprocessor {
       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++) {
@@ -76,10 +91,10 @@ class DocPreprocessor {
     }
     return node;
   }
-  preprocessVerticalContainer(node) {
+  preprocessVerticalContainer(node, isSectionAllowed) {
     let items = node.stack;
     for (let i = 0, l = items.length; i < l; i++) {
-      items[i] = this.preprocessNode(items[i]);
+      items[i] = this.preprocessNode(items[i], isSectionAllowed);
     }
     return node;
   }

package/js/DocumentContext.js

@@ -204,7 +204,7 @@ class DocumentContext extends _events.EventEmitter {
       let currentAvailableWidth = this.availableWidth;
       let currentPageOrientation = this.getCurrentPage().pageSize.orientation;
       let pageSize = getPageSize(this.getCurrentPage(), pageOrientation);
-      this.addPage(pageSize);
+      this.addPage(pageSize, null, this.getCurrentPage().customProperties);
       if (currentPageOrientation === pageSize.orientation) {
         this.availableWidth = currentAvailableWidth;
       }
@@ -219,7 +219,7 @@ class DocumentContext extends _events.EventEmitter {
       y: this.y
     };
   }
-  addPage(pageSize, pageMargin = null) {
+  addPage(pageSize, pageMargin = null, customProperties = {}) {
     if (pageMargin !== null) {
       this.pageMargins = pageMargin;
       this.x = pageMargin.left;
@@ -228,13 +228,14 @@ class DocumentContext extends _events.EventEmitter {
     let page = {
       items: [],
       pageSize: pageSize,
-      pageMargins: this.pageMargins
+      pageMargins: this.pageMargins,
+      customProperties: customProperties
     };
     this.pages.push(page);
     this.backgroundLength.push(0);
     this.page = this.pages.length - 1;
     this.initializePage();
-    this.emit('pageAdded');
+    this.emit('pageAdded', page);
     return page;
   }
   getCurrentPage() {

package/js/LayoutBuilder.js

@@ -62,7 +62,16 @@ class LayoutBuilder {
       if (typeof pageBreakBeforeFct !== 'function') {
         return false;
       }
-      linearNodeList = linearNodeList.filter(node => node.positions.length > 0);
+      const hasRenderableContent = node => {
+        if (!node || node.positions.length === 0) {
+          return false;
+        }
+        if (node.text === '' && !node.listMarker) {
+          return false;
+        }
+        return true;
+      };
+      linearNodeList = linearNodeList.filter(hasRenderableContent);
       linearNodeList.forEach(node => {
         let nodeInfo = {};
         ['id', 'text', 'ul', 'ol', 'table', 'image', 'qr', 'canvas', 'svg', 'columns', 'headlineLevel', 'style', 'pageBreak', 'pageOrientation', 'width', 'height'].forEach(key => {
@@ -132,19 +141,31 @@ class LayoutBuilder {
     return result.pages;
   }
   tryLayoutDocument(docStructure, pdfDocument, styleDictionary, defaultStyle, background, header, footer, watermark) {
+    const isNecessaryAddFirstPage = docStructure => {
+      if (docStructure.stack && docStructure.stack.length > 0 && docStructure.stack[0].section) {
+        return false;
+      } else if (docStructure.section) {
+        return false;
+      }
+      return true;
+    };
     this.linearNodeList = [];
     docStructure = this.docPreprocessor.preprocessDocument(docStructure);
     docStructure = this.docMeasure.measureDocument(docStructure);
     this.writer = new _PageElementWriter.default(new _DocumentContext.default());
-    this.writer.context().addListener('pageAdded', () => {
-      this.addBackground(background);
+    this.writer.context().addListener('pageAdded', page => {
+      let backgroundGetter = background;
+      if (page.customProperties['background'] || page.customProperties['background'] === null) {
+        backgroundGetter = page.customProperties['background'];
+      }
+      this.addBackground(backgroundGetter);
     });
-    this.writer.addPage(this.pageSize, null, this.pageMargins);
+    if (isNecessaryAddFirstPage(docStructure)) {
+      this.writer.addPage(this.pageSize, null, this.pageMargins);
+    }
     this.processNode(docStructure);
     this.addHeadersAndFooters(header, footer);
-    if (watermark != null) {
-      this.addWatermark(watermark, pdfDocument, defaultStyle);
-    }
+    this.addWatermark(watermark, pdfDocument, defaultStyle);
     return {
       pages: this.writer.context().pages,
       linearNodeList: this.linearNodeList
@@ -157,22 +178,30 @@ class LayoutBuilder {
     let pageBackground = backgroundGetter(context.page + 1, pageSize);
     if (pageBackground) {
       this.writer.beginUnbreakableBlock(pageSize.width, pageSize.height);
-      pageBackground = this.docPreprocessor.preprocessDocument(pageBackground);
-      this.processNode(this.docMeasure.measureDocument(pageBackground));
+      pageBackground = this.docPreprocessor.preprocessBlock(pageBackground);
+      this.processNode(this.docMeasure.measureBlock(pageBackground));
       this.writer.commitUnbreakableBlock(0, 0);
       context.backgroundLength[context.page] += pageBackground.positions.length;
     }
   }
-  addDynamicRepeatable(nodeGetter, sizeFunction) {
+  addDynamicRepeatable(nodeGetter, sizeFunction, customPropertyName) {
     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);
+      let customProperties = this.writer.context().getCurrentPage().customProperties;
+      let pageNodeGetter = nodeGetter;
+      if (customProperties[customPropertyName] || customProperties[customPropertyName] === null) {
+        pageNodeGetter = customProperties[customPropertyName];
+      }
+      if (typeof pageNodeGetter === 'undefined' || pageNodeGetter === null) {
+        continue;
+      }
+      let node = pageNodeGetter(pageIndex + 1, l, this.writer.context().pages[pageIndex].pageSize);
       if (node) {
         let sizes = sizeFunction(this.writer.context().getCurrentPage().pageSize, this.writer.context().getCurrentPage().pageMargins);
         this.writer.beginUnbreakableBlock(sizes.width, sizes.height);
-        node = this.docPreprocessor.preprocessDocument(node);
-        this.processNode(this.docMeasure.measureDocument(node));
+        node = this.docPreprocessor.preprocessBlock(node);
+        this.processNode(this.docMeasure.measureBlock(node));
         this.writer.commitUnbreakableBlock(sizes.x, sizes.y);
       }
     }
@@ -190,27 +219,30 @@ class LayoutBuilder {
       width: pageSize.width,
       height: pageMargins.bottom
     });
-    if (header) {
-      this.addDynamicRepeatable(header, headerSizeFct);
-    }
-    if (footer) {
-      this.addDynamicRepeatable(footer, footerSizeFct);
-    }
+    this.addDynamicRepeatable(header, headerSizeFct, 'header');
+    this.addDynamicRepeatable(footer, footerSizeFct, 'footer');
   }
   addWatermark(watermark, pdfDocument, defaultStyle) {
-    if ((0, _variableType.isString)(watermark)) {
-      watermark = {
-        'text': watermark
-      };
-    }
-    if (!watermark.text) {
-      // empty watermark text
-      return;
-    }
     let pages = this.writer.context().pages;
     for (let i = 0, l = pages.length; i < l; i++) {
+      let pageWatermark = watermark;
+      if (pages[i].customProperties['watermark'] || pages[i].customProperties['watermark'] === null) {
+        pageWatermark = pages[i].customProperties['watermark'];
+      }
+      if (pageWatermark === undefined || pageWatermark === null) {
+        continue;
+      }
+      if ((0, _variableType.isString)(pageWatermark)) {
+        pageWatermark = {
+          'text': pageWatermark
+        };
+      }
+      if (!pageWatermark.text) {
+        // empty watermark text
+        continue;
+      }
       pages[i].watermark = getWatermarkObject({
-        ...watermark
+        ...pageWatermark
       }, pages[i].pageSize, pdfDocument, defaultStyle);
     }
     function getWatermarkObject(watermark, pageSize, pdfDocument, defaultStyle) {
@@ -391,6 +423,8 @@ class LayoutBuilder {
       }
       if (node.stack) {
         this.processVerticalContainer(node);
+      } else if (node.section) {
+        this.processSection(node);
       } else if (node.columns) {
         this.processColumns(node);
       } else if (node.ul) {
@@ -435,6 +469,62 @@ class LayoutBuilder {
     }, this);
   }
 
+  // section
+  processSection(sectionNode) {
+    // TODO: properties
+
+    let page = this.writer.context().getCurrentPage();
+    if (!page || page && page.items.length) {
+      // move to new empty page
+      // page definition inherit from current page
+      if (sectionNode.pageSize === 'inherit') {
+        sectionNode.pageSize = page ? {
+          width: page.pageSize.width,
+          height: page.pageSize.height
+        } : undefined;
+      }
+      if (sectionNode.pageOrientation === 'inherit') {
+        sectionNode.pageOrientation = page ? page.pageSize.orientation : undefined;
+      }
+      if (sectionNode.pageMargins === 'inherit') {
+        sectionNode.pageMargins = page ? page.pageMargins : undefined;
+      }
+      if (sectionNode.header === 'inherit') {
+        sectionNode.header = page ? page.customProperties.header : undefined;
+      }
+      if (sectionNode.footer === 'inherit') {
+        sectionNode.footer = page ? page.customProperties.footer : undefined;
+      }
+      if (sectionNode.background === 'inherit') {
+        sectionNode.background = page ? page.customProperties.background : undefined;
+      }
+      if (sectionNode.watermark === 'inherit') {
+        sectionNode.watermark = page ? page.customProperties.watermark : undefined;
+      }
+      if (sectionNode.header && typeof sectionNode.header !== 'function' && sectionNode.header !== null) {
+        sectionNode.header = (0, _tools.convertToDynamicContent)(sectionNode.header);
+      }
+      if (sectionNode.footer && typeof sectionNode.footer !== 'function' && sectionNode.footer !== null) {
+        sectionNode.footer = (0, _tools.convertToDynamicContent)(sectionNode.footer);
+      }
+      let customProperties = {};
+      if (typeof sectionNode.header !== 'undefined') {
+        customProperties.header = sectionNode.header;
+      }
+      if (typeof sectionNode.footer !== 'undefined') {
+        customProperties.footer = sectionNode.footer;
+      }
+      if (typeof sectionNode.background !== 'undefined') {
+        customProperties.background = sectionNode.background;
+      }
+      if (typeof sectionNode.watermark !== 'undefined') {
+        customProperties.watermark = sectionNode.watermark;
+      }
+      this.writer.addPage(sectionNode.pageSize || this.pageSize, sectionNode.pageOrientation, sectionNode.pageMargins || this.pageMargins, customProperties);
+    }
+    this.processNode(sectionNode.section);
+  }
+
   // columns
   processColumns(columnNode) {
     this.nestedLevel++;
@@ -912,6 +1002,23 @@ class LayoutBuilder {
       }
       return newInline;
     }
+    function findMaxFitLength(text, maxWidth, measureFn) {
+      let low = 1;
+      let high = text.length;
+      let bestFit = 1;
+      while (low <= high) {
+        const mid = Math.floor((low + high) / 2);
+        const part = text.substring(0, mid);
+        const width = measureFn(part);
+        if (width <= maxWidth) {
+          bestFit = mid;
+          low = mid + 1;
+        } else {
+          high = mid - 1;
+        }
+      }
+      return bestFit;
+    }
     if (!textNode._inlines || textNode._inlines.length === 0) {
       return null;
     }
@@ -923,11 +1030,7 @@ class LayoutBuilder {
       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;
-        }
+        let maxChars = findMaxFitLength(inline.text, line.getAvailableWidth(), txt => textInlines.widthOfText(txt, inline));
         if (maxChars < inline.text.length) {
           let newInline = cloneInline(inline);
           newInline.text = inline.text.substr(maxChars);

package/js/OutputDocument.js

@@ -23,26 +23,24 @@ class OutputDocument {
    * @returns {Promise<Buffer>}
    */
   getBuffer() {
-    if (this.bufferPromise === null) {
-      this.bufferPromise = new Promise((resolve, reject) => {
-        this.getStream().then(stream => {
-          let chunks = [];
-          let result;
-          stream.on('readable', () => {
-            let chunk;
-            while ((chunk = stream.read(this.bufferSize)) !== null) {
-              chunks.push(chunk);
-            }
-          });
-          stream.on('end', () => {
-            result = Buffer.concat(chunks);
-            resolve(result);
-          });
-          stream.end();
-        }, result => {
-          reject(result);
+    const getBufferInternal = async () => {
+      const stream = await this.getStream();
+      return new Promise(resolve => {
+        let chunks = [];
+        stream.on('readable', () => {
+          let chunk;
+          while ((chunk = stream.read(this.bufferSize)) !== null) {
+            chunks.push(chunk);
+          }
+        });
+        stream.on('end', () => {
+          resolve(Buffer.concat(chunks));
         });
+        stream.end();
       });
+    };
+    if (this.bufferPromise === null) {
+      this.bufferPromise = getBufferInternal();
     }
     return this.bufferPromise;
   }
@@ -50,27 +48,17 @@ class OutputDocument {
   /**
    * @returns {Promise<string>}
    */
-  getBase64() {
-    return new Promise((resolve, reject) => {
-      this.getBuffer().then(buffer => {
-        resolve(buffer.toString('base64'));
-      }, result => {
-        reject(result);
-      });
-    });
+  async getBase64() {
+    const buffer = await this.getBuffer();
+    return buffer.toString('base64');
   }
 
   /**
    * @returns {Promise<string>}
    */
-  getDataUrl() {
-    return new Promise((resolve, reject) => {
-      this.getBase64().then(data => {
-        resolve('data:application/pdf;base64,' + data);
-      }, result => {
-        reject(result);
-      });
-    });
+  async getDataUrl() {
+    const data = await this.getBase64();
+    return 'data:application/pdf;base64,' + data;
   }
 }
 var _default = exports.default = OutputDocument;

package/js/OutputDocumentServer.js

@@ -10,17 +10,12 @@ class OutputDocumentServer extends _OutputDocument.default {
    * @param {string} filename
    * @returns {Promise}
    */
-  write(filename) {
-    return new Promise((resolve, reject) => {
-      this.getStream().then(stream => {
-        stream.pipe(_fs.default.createWriteStream(filename));
-        stream.on('end', () => {
-          resolve();
-        });
-        stream.end();
-      }, result => {
-        reject(result);
-      });
+  async write(filename) {
+    const stream = await this.getStream();
+    return new Promise(resolve => {
+      stream.pipe(_fs.default.createWriteStream(filename));
+      stream.on('end', resolve);
+      stream.end();
     });
   }
 }

package/js/PageElementWriter.js

@@ -73,10 +73,10 @@ class PageElementWriter extends _ElementWriter.default {
       y: this.context().y
     });
   }
-  addPage(pageSize, pageOrientation, pageMargin) {
+  addPage(pageSize, pageOrientation, pageMargin, customProperties = {}) {
     let prevPage = this.page;
     let prevY = this.y;
-    this.context().addPage((0, _PageSize.normalizePageSize)(pageSize, pageOrientation), (0, _PageSize.normalizePageMargin)(pageMargin));
+    this.context().addPage((0, _PageSize.normalizePageSize)(pageSize, pageOrientation), (0, _PageSize.normalizePageMargin)(pageMargin), customProperties);
     this.emit('pageChanged', {
       prevPage: prevPage,
       prevY: prevY,