pdfmake 0.3.0-beta.8 → 0.3.0

package/js/Line.js

@@ -0,0 +1,105 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+class Line {
+  /**
+   * @param {number} maxWidth Maximum width this line can have
+   */
+  constructor(maxWidth) {
+    this.maxWidth = maxWidth;
+    this.leadingCut = 0;
+    this.trailingCut = 0;
+    this.inlineWidths = 0;
+    this.inlines = [];
+  }
+
+  /**
+   * @param {object} inline
+   */
+  addInline(inline) {
+    if (this.inlines.length === 0) {
+      this.leadingCut = inline.leadingCut || 0;
+    }
+    this.trailingCut = inline.trailingCut || 0;
+    inline.x = this.inlineWidths - this.leadingCut;
+    this.inlines.push(inline);
+    this.inlineWidths += inline.width;
+    if (inline.lineEnd) {
+      this.newLineForced = true;
+    }
+  }
+
+  /**
+   * @returns {number}
+   */
+  getHeight() {
+    let max = 0;
+    this.inlines.forEach(item => {
+      max = Math.max(max, item.height || 0);
+    });
+    return max;
+  }
+
+  /**
+   * @returns {number}
+   */
+  getAscenderHeight() {
+    let y = 0;
+    this.inlines.forEach(inline => {
+      y = Math.max(y, inline.font.ascender / 1000 * inline.fontSize);
+    });
+    return y;
+  }
+
+  /**
+   * @returns {number}
+   */
+  getWidth() {
+    return this.inlineWidths - this.leadingCut - this.trailingCut;
+  }
+
+  /**
+   * @returns {number}
+   */
+  getAvailableWidth() {
+    return this.maxWidth - this.getWidth();
+  }
+
+  /**
+   * @param {object} inline
+   * @param {Array} nextInlines
+   * @returns {boolean}
+   */
+  hasEnoughSpaceForInline(inline, nextInlines = []) {
+    if (this.inlines.length === 0) {
+      return true;
+    }
+    if (this.newLineForced) {
+      return false;
+    }
+    let inlineWidth = inline.width;
+    let inlineTrailingCut = inline.trailingCut || 0;
+    if (inline.noNewLine) {
+      for (let i = 0, l = nextInlines.length; i < l; i++) {
+        let nextInline = nextInlines[i];
+        inlineWidth += nextInline.width;
+        inlineTrailingCut += nextInline.trailingCut || 0;
+        if (!nextInline.noNewLine) {
+          break;
+        }
+      }
+    }
+    return this.inlineWidths + inlineWidth - this.leadingCut - inlineTrailingCut <= this.maxWidth;
+  }
+  clone() {
+    let result = new Line(this.maxWidth);
+    for (let key in this) {
+      if (this.hasOwnProperty(key)) {
+        result[key] = this[key];
+      }
+    }
+    return result;
+  }
+}
+var _default = exports.default = Line;

package/js/OutputDocument.js

@@ -0,0 +1,64 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+class OutputDocument {
+  /**
+   * @param {Promise<object>} pdfDocumentPromise
+   */
+  constructor(pdfDocumentPromise) {
+    this.bufferSize = 1073741824;
+    this.pdfDocumentPromise = pdfDocumentPromise;
+    this.bufferPromise = null;
+  }
+
+  /**
+   * @returns {Promise<object>}
+   */
+  getStream() {
+    return this.pdfDocumentPromise;
+  }
+
+  /**
+   * @returns {Promise<Buffer>}
+   */
+  getBuffer() {
+    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;
+  }
+
+  /**
+   * @returns {Promise<string>}
+   */
+  async getBase64() {
+    const buffer = await this.getBuffer();
+    return buffer.toString('base64');
+  }
+
+  /**
+   * @returns {Promise<string>}
+   */
+  async getDataUrl() {
+    const data = await this.getBase64();
+    return 'data:application/pdf;base64,' + data;
+  }
+}
+var _default = exports.default = OutputDocument;

package/js/OutputDocumentServer.js

@@ -0,0 +1,22 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _OutputDocument = _interopRequireDefault(require("./OutputDocument"));
+var _fs = _interopRequireDefault(require("fs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class OutputDocumentServer extends _OutputDocument.default {
+  /**
+   * @param {string} filename
+   * @returns {Promise}
+   */
+  async write(filename) {
+    const stream = await this.getStream();
+    return new Promise(resolve => {
+      stream.pipe(_fs.default.createWriteStream(filename));
+      stream.on('end', resolve);
+      stream.end();
+    });
+  }
+}
+var _default = exports.default = OutputDocumentServer;

package/js/PDFDocument.js

@@ -0,0 +1,144 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _pdfkit = _interopRequireDefault(require("pdfkit"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const typeName = (bold, italics) => {
+  let type = 'normal';
+  if (bold && italics) {
+    type = 'bolditalics';
+  } else if (bold) {
+    type = 'bold';
+  } else if (italics) {
+    type = 'italics';
+  }
+  return type;
+};
+class PDFDocument extends _pdfkit.default {
+  constructor(fonts = {}, images = {}, patterns = {}, attachments = {}, options = {}, virtualfs = null) {
+    super(options);
+    this.fonts = {};
+    this.fontCache = {};
+    for (let font in fonts) {
+      if (fonts.hasOwnProperty(font)) {
+        let fontDef = fonts[font];
+        this.fonts[font] = {
+          normal: fontDef.normal,
+          bold: fontDef.bold,
+          italics: fontDef.italics,
+          bolditalics: fontDef.bolditalics
+        };
+      }
+    }
+    this.patterns = {};
+    for (let pattern in patterns) {
+      if (patterns.hasOwnProperty(pattern)) {
+        let patternDef = patterns[pattern];
+        this.patterns[pattern] = this.pattern(patternDef.boundingBox, patternDef.xStep, patternDef.yStep, patternDef.pattern, patternDef.colored);
+      }
+    }
+    this.images = images;
+    this.attachments = attachments;
+    this.virtualfs = virtualfs;
+  }
+  getFontType(bold, italics) {
+    return typeName(bold, italics);
+  }
+  getFontFile(familyName, bold, italics) {
+    let type = this.getFontType(bold, italics);
+    if (!this.fonts[familyName] || !this.fonts[familyName][type]) {
+      return null;
+    }
+    return this.fonts[familyName][type];
+  }
+  provideFont(familyName, bold, italics) {
+    let type = this.getFontType(bold, italics);
+    if (this.getFontFile(familyName, bold, italics) === null) {
+      throw new Error(`Font '${familyName}' in style '${type}' is not defined in the font section of the document definition.`);
+    }
+    this.fontCache[familyName] = this.fontCache[familyName] || {};
+    if (!this.fontCache[familyName][type]) {
+      let def = this.fonts[familyName][type];
+      if (!Array.isArray(def)) {
+        def = [def];
+      }
+      if (this.virtualfs && this.virtualfs.existsSync(def[0])) {
+        def[0] = this.virtualfs.readFileSync(def[0]);
+      }
+      this.fontCache[familyName][type] = this.font(...def)._font;
+    }
+    return this.fontCache[familyName][type];
+  }
+  provideImage(src) {
+    const realImageSrc = src => {
+      let image = this.images[src];
+      if (!image) {
+        return src;
+      }
+      if (this.virtualfs && this.virtualfs.existsSync(image)) {
+        return this.virtualfs.readFileSync(image);
+      }
+      let index = image.indexOf('base64,');
+      if (index < 0) {
+        return this.images[src];
+      }
+      return Buffer.from(image.substring(index + 7), 'base64');
+    };
+    if (this._imageRegistry[src]) {
+      return this._imageRegistry[src];
+    }
+    let image;
+    try {
+      image = this.openImage(realImageSrc(src));
+      if (!image) {
+        throw new Error('No image');
+      }
+    } catch (error) {
+      throw new Error(`Invalid image: ${error.toString()}\nImages dictionary should contain dataURL entries (or local file paths in node.js)`);
+    }
+    image.embed(this);
+    this._imageRegistry[src] = image;
+    return image;
+  }
+
+  /**
+   * @param {Array} color pdfmake format: [<pattern name>, <color>]
+   * @returns {Array} pdfkit format: [<pattern object>, <color>]
+   */
+  providePattern(color) {
+    if (Array.isArray(color) && color.length === 2) {
+      return [this.patterns[color[0]], color[1]];
+    }
+    return null;
+  }
+  provideAttachment(src) {
+    const checkRequired = obj => {
+      if (!obj) {
+        throw new Error('No attachment');
+      }
+      if (!obj.src) {
+        throw new Error('The "src" key is required for attachments');
+      }
+      return obj;
+    };
+    if (typeof src === 'object') {
+      return checkRequired(src);
+    }
+    let attachment = checkRequired(this.attachments[src]);
+    if (this.virtualfs && this.virtualfs.existsSync(attachment.src)) {
+      return this.virtualfs.readFileSync(attachment.src);
+    }
+    return attachment;
+  }
+  setOpenActionAsPrint() {
+    let printActionRef = this.ref({
+      Type: 'Action',
+      S: 'Named',
+      N: 'Print'
+    });
+    this._root.data.OpenAction = printActionRef;
+    printActionRef.end();
+  }
+}
+var _default = exports.default = PDFDocument;

package/js/PageElementWriter.js

@@ -0,0 +1,155 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _ElementWriter = _interopRequireDefault(require("./ElementWriter"));
+var _PageSize = require("./PageSize");
+var _DocumentContext = _interopRequireDefault(require("./DocumentContext"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * An extended ElementWriter which can handle:
+ * - page-breaks (it adds new pages when there's not enough space left),
+ * - repeatable fragments (like table-headers, which are repeated everytime
+ *                         a page-break occurs)
+ * - transactions (used for unbreakable-blocks when we want to make sure
+ *                 whole block will be rendered on the same page)
+ */
+class PageElementWriter extends _ElementWriter.default {
+  /**
+   * @param {DocumentContext} context
+   */
+  constructor(context) {
+    super(context);
+    this.transactionLevel = 0;
+    this.repeatables = [];
+  }
+  addLine(line, dontUpdateContextPosition, index) {
+    return this._fitOnPage(() => super.addLine(line, dontUpdateContextPosition, index));
+  }
+  addImage(image, index) {
+    return this._fitOnPage(() => super.addImage(image, index));
+  }
+  addCanvas(image, index) {
+    return this._fitOnPage(() => super.addCanvas(image, index));
+  }
+  addSVG(image, index) {
+    return this._fitOnPage(() => super.addSVG(image, index));
+  }
+  addQr(qr, index) {
+    return this._fitOnPage(() => super.addQr(qr, index));
+  }
+  addAttachment(attachment, index) {
+    return this._fitOnPage(() => super.addAttachment(attachment, index));
+  }
+  addVector(vector, ignoreContextX, ignoreContextY, index, forcePage) {
+    return super.addVector(vector, ignoreContextX, ignoreContextY, index, forcePage);
+  }
+  beginClip(width, height) {
+    return super.beginClip(width, height);
+  }
+  endClip() {
+    return super.endClip();
+  }
+  addFragment(fragment, useBlockXOffset, useBlockYOffset, dontUpdateContextPosition) {
+    return this._fitOnPage(() => super.addFragment(fragment, useBlockXOffset, useBlockYOffset, dontUpdateContextPosition));
+  }
+  moveToNextPage(pageOrientation) {
+    let nextPage = this.context().moveToNextPage(pageOrientation);
+
+    // moveToNextPage is called multiple times for table, because is called for each column
+    // and repeatables are inserted only in the first time. If columns are used, is needed
+    // call for table in first column and then for table in the second column (is other repeatables).
+    this.repeatables.forEach(function (rep) {
+      if (rep.insertedOnPages[this.context().page] === undefined) {
+        rep.insertedOnPages[this.context().page] = true;
+        this.addFragment(rep, true);
+      } else {
+        this.context().moveDown(rep.height);
+      }
+    }, this);
+    this.emit('pageChanged', {
+      prevPage: nextPage.prevPage,
+      prevY: nextPage.prevY,
+      y: this.context().y
+    });
+  }
+  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), customProperties);
+    this.emit('pageChanged', {
+      prevPage: prevPage,
+      prevY: prevY,
+      y: this.context().y
+    });
+  }
+  beginUnbreakableBlock(width, height) {
+    if (this.transactionLevel++ === 0) {
+      this.originalX = this.context().x;
+      this.pushContext(width, height);
+    }
+  }
+  commitUnbreakableBlock(forcedX, forcedY) {
+    if (--this.transactionLevel === 0) {
+      let unbreakableContext = this.context();
+      this.popContext();
+      let nbPages = unbreakableContext.pages.length;
+      if (nbPages > 0) {
+        // no support for multi-page unbreakableBlocks
+        let fragment = unbreakableContext.pages[0];
+        fragment.xOffset = forcedX;
+        fragment.yOffset = forcedY;
+
+        //TODO: vectors can influence height in some situations
+        if (nbPages > 1) {
+          // on out-of-context blocs (headers, footers, background) height should be the whole DocumentContext height
+          if (forcedX !== undefined || forcedY !== undefined) {
+            fragment.height = unbreakableContext.getCurrentPage().pageSize.height - unbreakableContext.pageMargins.top - unbreakableContext.pageMargins.bottom;
+          } else {
+            fragment.height = this.context().getCurrentPage().pageSize.height - this.context().pageMargins.top - this.context().pageMargins.bottom;
+            for (let i = 0, l = this.repeatables.length; i < l; i++) {
+              fragment.height -= this.repeatables[i].height;
+            }
+          }
+        } else {
+          fragment.height = unbreakableContext.y;
+        }
+        if (forcedX !== undefined || forcedY !== undefined) {
+          super.addFragment(fragment, true, true, true);
+        } else {
+          this.addFragment(fragment);
+        }
+      }
+    }
+  }
+  currentBlockToRepeatable() {
+    let unbreakableContext = this.context();
+    let rep = {
+      items: []
+    };
+    unbreakableContext.pages[0].items.forEach(item => {
+      rep.items.push(item);
+    });
+    rep.xOffset = this.originalX;
+
+    //TODO: vectors can influence height in some situations
+    rep.height = unbreakableContext.y;
+    rep.insertedOnPages = [];
+    return rep;
+  }
+  pushToRepeatables(rep) {
+    this.repeatables.push(rep);
+  }
+  popFromRepeatables() {
+    this.repeatables.pop();
+  }
+  _fitOnPage(addFct) {
+    let position = addFct();
+    if (!position) {
+      this.moveToNextPage();
+      position = addFct();
+    }
+    return position;
+  }
+}
+var _default = exports.default = PageElementWriter;

package/js/PageSize.js

@@ -0,0 +1,74 @@
+"use strict";
+
+exports.__esModule = true;
+exports.normalizePageMargin = normalizePageMargin;
+exports.normalizePageSize = normalizePageSize;
+var _standardPageSizes = _interopRequireDefault(require("./standardPageSizes"));
+var _variableType = require("./helpers/variableType");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function normalizePageSize(pageSize, pageOrientation) {
+  function isNeedSwapPageSizes(pageOrientation) {
+    if ((0, _variableType.isString)(pageOrientation)) {
+      pageOrientation = pageOrientation.toLowerCase();
+      return pageOrientation === 'portrait' && size.width > size.height || pageOrientation === 'landscape' && size.width < size.height;
+    }
+    return false;
+  }
+  function pageSizeToWidthAndHeight(pageSize) {
+    if ((0, _variableType.isString)(pageSize)) {
+      let size = _standardPageSizes.default[pageSize.toUpperCase()];
+      if (!size) {
+        throw new Error(`Page size ${pageSize} not recognized`);
+      }
+      return {
+        width: size[0],
+        height: size[1]
+      };
+    }
+    return pageSize;
+  }
+
+  // if pageSize.height is set to auto, set the height to infinity so there are no page breaks.
+  if (pageSize && pageSize.height === 'auto') {
+    pageSize.height = Infinity;
+  }
+  let size = pageSizeToWidthAndHeight(pageSize || 'A4');
+  if (isNeedSwapPageSizes(pageOrientation)) {
+    // swap page sizes
+    size = {
+      width: size.height,
+      height: size.width
+    };
+  }
+  size.orientation = size.width > size.height ? 'landscape' : 'portrait';
+  return size;
+}
+function normalizePageMargin(margin) {
+  if ((0, _variableType.isNumber)(margin)) {
+    margin = {
+      left: margin,
+      right: margin,
+      top: margin,
+      bottom: margin
+    };
+  } else if (Array.isArray(margin)) {
+    if (margin.length === 2) {
+      margin = {
+        left: margin[0],
+        top: margin[1],
+        right: margin[0],
+        bottom: margin[1]
+      };
+    } else if (margin.length === 4) {
+      margin = {
+        left: margin[0],
+        top: margin[1],
+        right: margin[2],
+        bottom: margin[3]
+      };
+    } else {
+      throw new Error('Invalid pageMargins definition');
+    }
+  }
+  return margin;
+}