@digicole/pdfmake-rtl 2.1.0 → 2.1.2

package/js/Renderer.js

@@ -0,0 +1,417 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _TextDecorator = _interopRequireDefault(require("./TextDecorator"));
+var _TextInlines = _interopRequireDefault(require("./TextInlines"));
+var _variableType = require("./helpers/variableType");
+var _svgToPdfkit = _interopRequireDefault(require("./3rd-party/svg-to-pdfkit"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const findFont = (fonts, requiredFonts, defaultFont) => {
+  for (let i = 0; i < requiredFonts.length; i++) {
+    let requiredFont = requiredFonts[i].toLowerCase();
+    for (let font in fonts) {
+      if (font.toLowerCase() === requiredFont) {
+        return font;
+      }
+    }
+  }
+  return defaultFont;
+};
+
+/**
+ * Shift the "y" height of the text baseline up or down (superscript or subscript,
+ * respectively). The exact shift can / should be changed according to standard
+ * conventions.
+ *
+ * @param {number} y
+ * @param {object} inline
+ * @returns {number}
+ */
+const offsetText = (y, inline) => {
+  let newY = y;
+  if (inline.sup) {
+    newY -= inline.fontSize * 0.75;
+  }
+  if (inline.sub) {
+    newY += inline.fontSize * 0.35;
+  }
+  return newY;
+};
+class Renderer {
+  constructor(pdfDocument, progressCallback) {
+    this.pdfDocument = pdfDocument;
+    this.progressCallback = progressCallback;
+  }
+  renderPages(pages) {
+    this.pdfDocument._pdfMakePages = pages; // TODO: Why?
+
+    let totalItems = 0;
+    if (this.progressCallback) {
+      pages.forEach(page => {
+        totalItems += page.items.length;
+      });
+    }
+    let renderedItems = 0;
+    for (let i = 0; i < pages.length; i++) {
+      this.pdfDocument.addPage({
+        size: [pages[i].pageSize.width, pages[i].pageSize.height]
+      });
+      let page = pages[i];
+      for (let ii = 0, il = page.items.length; ii < il; ii++) {
+        let item = page.items[ii];
+        switch (item.type) {
+          case 'vector':
+            this.renderVector(item.item);
+            break;
+          case 'line':
+            this.renderLine(item.item, item.item.x, item.item.y);
+            break;
+          case 'image':
+            this.renderImage(item.item);
+            break;
+          case 'svg':
+            this.renderSVG(item.item);
+            break;
+          case 'attachment':
+            this.renderAttachment(item.item);
+            break;
+          case 'beginClip':
+            this.beginClip(item.item);
+            break;
+          case 'endClip':
+            this.endClip();
+            break;
+          case 'beginVerticalAlignment':
+            this.beginVerticalAlignment(item.item);
+            break;
+          case 'endVerticalAlignment':
+            this.endVerticalAlignment(item.item);
+            break;
+        }
+        renderedItems++;
+        if (this.progressCallback) {
+          this.progressCallback(renderedItems / totalItems);
+        }
+      }
+      if (page.watermark) {
+        this.renderWatermark(page);
+      }
+    }
+  }
+  renderLine(line, x, y) {
+    function preparePageNodeRefLine(_pageNodeRef, inline) {
+      let newWidth;
+      let diffWidth;
+      let textInlines = new _TextInlines.default(null);
+      if (_pageNodeRef.positions === undefined) {
+        throw new Error('Page reference id not found');
+      }
+      let pageNumber = _pageNodeRef.positions[0].pageNumber.toString();
+      inline.text = pageNumber;
+      newWidth = textInlines.widthOfText(inline.text, inline);
+      diffWidth = inline.width - newWidth;
+      inline.width = newWidth;
+      switch (inline.alignment) {
+        case 'right':
+          inline.x += diffWidth;
+          break;
+        case 'center':
+          inline.x += diffWidth / 2;
+          break;
+      }
+    }
+    if (line._pageNodeRef) {
+      preparePageNodeRefLine(line._pageNodeRef, line.inlines[0]);
+    }
+    x = x || 0;
+    y = y || 0;
+    let lineHeight = line.getHeight();
+    let ascenderHeight = line.getAscenderHeight();
+    let descent = lineHeight - ascenderHeight;
+    const textDecorator = new _TextDecorator.default(this.pdfDocument);
+    textDecorator.drawBackground(line, x, y);
+
+    //TODO: line.optimizeInlines();
+    //TODO: lines without differently styled inlines should be written to pdf as one stream
+    for (let i = 0, l = line.inlines.length; i < l; i++) {
+      let inline = line.inlines[i];
+      let shiftToBaseline = lineHeight - inline.font.ascender / 1000 * inline.fontSize - descent;
+      if (inline._pageNodeRef) {
+        preparePageNodeRefLine(inline._pageNodeRef, inline);
+      }
+      let options = {
+        lineBreak: false,
+        textWidth: inline.width,
+        characterSpacing: inline.characterSpacing,
+        wordCount: 1,
+        link: inline.link
+      };
+      if (inline.linkToDestination) {
+        options.goTo = inline.linkToDestination;
+      }
+      if (line.id && i === 0) {
+        options.destination = line.id;
+      }
+      if (inline.fontFeatures) {
+        options.features = inline.fontFeatures;
+      }
+      let opacity = (0, _variableType.isNumber)(inline.opacity) ? inline.opacity : 1;
+      this.pdfDocument.opacity(opacity);
+      this.pdfDocument.fill(inline.color || 'black');
+      this.pdfDocument._font = inline.font;
+      this.pdfDocument.fontSize(inline.fontSize);
+      let shiftedY = offsetText(y + shiftToBaseline, inline);
+      this.pdfDocument.text(inline.text, x + inline.x, shiftedY, options);
+      if (inline.linkToPage) {
+        this.pdfDocument.ref({
+          Type: 'Action',
+          S: 'GoTo',
+          D: [inline.linkToPage, 0, 0]
+        }).end();
+        this.pdfDocument.annotate(x + inline.x, shiftedY, inline.width, inline.height, {
+          Subtype: 'Link',
+          Dest: [inline.linkToPage - 1, 'XYZ', null, null, null]
+        });
+      }
+    }
+
+    // Decorations won't draw correctly for superscript
+    textDecorator.drawDecorations(line, x, y);
+  }
+  renderVector(vector) {
+    //TODO: pdf optimization (there's no need to write all properties everytime)
+    this.pdfDocument.lineWidth(vector.lineWidth || 1);
+    if (vector.dash) {
+      this.pdfDocument.dash(vector.dash.length, {
+        space: vector.dash.space || vector.dash.length,
+        phase: vector.dash.phase || 0
+      });
+    } else {
+      this.pdfDocument.undash();
+    }
+    this.pdfDocument.lineJoin(vector.lineJoin || 'miter');
+    this.pdfDocument.lineCap(vector.lineCap || 'butt');
+
+    //TODO: clipping
+
+    let gradient = null;
+    switch (vector.type) {
+      case 'ellipse':
+        this.pdfDocument.ellipse(vector.x, vector.y, vector.r1, vector.r2);
+        if (vector.linearGradient) {
+          gradient = this.pdfDocument.linearGradient(vector.x - vector.r1, vector.y, vector.x + vector.r1, vector.y);
+        }
+        break;
+      case 'rect':
+        if (vector.r) {
+          this.pdfDocument.roundedRect(vector.x, vector.y, vector.w, vector.h, vector.r);
+        } else {
+          this.pdfDocument.rect(vector.x, vector.y, vector.w, vector.h);
+        }
+        if (vector.linearGradient) {
+          gradient = this.pdfDocument.linearGradient(vector.x, vector.y, vector.x + vector.w, vector.y);
+        }
+        break;
+      case 'line':
+        this.pdfDocument.moveTo(vector.x1, vector.y1);
+        this.pdfDocument.lineTo(vector.x2, vector.y2);
+        break;
+      case 'polyline':
+        if (vector.points.length === 0) {
+          break;
+        }
+        this.pdfDocument.moveTo(vector.points[0].x, vector.points[0].y);
+        for (let i = 1, l = vector.points.length; i < l; i++) {
+          this.pdfDocument.lineTo(vector.points[i].x, vector.points[i].y);
+        }
+        if (vector.points.length > 1) {
+          let p1 = vector.points[0];
+          let pn = vector.points[vector.points.length - 1];
+          if (vector.closePath || p1.x === pn.x && p1.y === pn.y) {
+            this.pdfDocument.closePath();
+          }
+        }
+        break;
+      case 'path':
+        this.pdfDocument.path(vector.d);
+        break;
+    }
+    if (vector.linearGradient && gradient) {
+      let step = 1 / (vector.linearGradient.length - 1);
+      for (let i = 0; i < vector.linearGradient.length; i++) {
+        gradient.stop(i * step, vector.linearGradient[i]);
+      }
+      vector.color = gradient;
+    }
+    let patternColor = this.pdfDocument.providePattern(vector.color);
+    if (patternColor !== null) {
+      vector.color = patternColor;
+    }
+    let fillOpacity = (0, _variableType.isNumber)(vector.fillOpacity) ? vector.fillOpacity : 1;
+    let strokeOpacity = (0, _variableType.isNumber)(vector.strokeOpacity) ? vector.strokeOpacity : 1;
+    if (vector.color && vector.lineColor) {
+      this.pdfDocument.fillColor(vector.color, fillOpacity);
+      this.pdfDocument.strokeColor(vector.lineColor, strokeOpacity);
+      this.pdfDocument.fillAndStroke();
+    } else if (vector.color) {
+      this.pdfDocument.fillColor(vector.color, fillOpacity);
+      this.pdfDocument.fill();
+    } else {
+      this.pdfDocument.strokeColor(vector.lineColor || 'black', strokeOpacity);
+      this.pdfDocument.stroke();
+    }
+  }
+  renderImage(image) {
+    let opacity = (0, _variableType.isNumber)(image.opacity) ? image.opacity : 1;
+    this.pdfDocument.opacity(opacity);
+    if (image.cover) {
+      const align = image.cover.align || 'center';
+      const valign = image.cover.valign || 'center';
+      const width = image.cover.width ? image.cover.width : image.width;
+      const height = image.cover.height ? image.cover.height : image.height;
+      this.pdfDocument.save();
+      this.pdfDocument.rect(image.x, image.y, width, height).clip();
+      this.pdfDocument.image(image.image, image.x, image.y, {
+        cover: [width, height],
+        align: align,
+        valign: valign
+      });
+      this.pdfDocument.restore();
+    } else {
+      this.pdfDocument.image(image.image, image.x, image.y, {
+        width: image._width,
+        height: image._height
+      });
+    }
+    if (image.link) {
+      this.pdfDocument.link(image.x, image.y, image._width, image._height, image.link);
+    }
+    if (image.linkToPage) {
+      this.pdfDocument.ref({
+        Type: 'Action',
+        S: 'GoTo',
+        D: [image.linkToPage, 0, 0]
+      }).end();
+      this.pdfDocument.annotate(image.x, image.y, image._width, image._height, {
+        Subtype: 'Link',
+        Dest: [image.linkToPage - 1, 'XYZ', null, null, null]
+      });
+    }
+    if (image.linkToDestination) {
+      this.pdfDocument.goTo(image.x, image.y, image._width, image._height, image.linkToDestination);
+    }
+    if (image.linkToFile) {
+      const attachment = this.pdfDocument.provideAttachment(image.linkToFile);
+      this.pdfDocument.fileAnnotation(image.x, image.y, image._width, image._height, attachment,
+      // add empty rectangle as file annotation appearance with the same size as the rendered image
+      {
+        AP: {
+          N: {
+            Type: 'XObject',
+            Subtype: 'Form',
+            FormType: 1,
+            BBox: [image.x, image.y, image._width, image._height]
+          }
+        }
+      });
+    }
+  }
+  renderSVG(svg) {
+    let options = {
+      width: svg._width,
+      height: svg._height,
+      assumePt: true,
+      useCSS: !(0, _variableType.isString)(svg.svg),
+      ...svg.options
+    };
+    options.fontCallback = (family, bold, italic) => {
+      let fontsFamily = family.split(',').map(f => f.trim().replace(/('|")/g, ''));
+      let font = findFont(this.pdfDocument.fonts, fontsFamily, svg.font || 'Roboto');
+      let fontFile = this.pdfDocument.getFontFile(font, bold, italic);
+      if (fontFile === null) {
+        let type = this.pdfDocument.getFontType(bold, italic);
+        throw new Error(`Font '${font}' in style '${type}' is not defined in the font section of the document definition.`);
+      }
+      return fontFile;
+    };
+    (0, _svgToPdfkit.default)(this.pdfDocument, svg.svg, svg.x, svg.y, options);
+    if (svg.link) {
+      this.pdfDocument.link(svg.x, svg.y, svg._width, svg._height, svg.link);
+    }
+    if (svg.linkToPage) {
+      this.pdfDocument.ref({
+        Type: 'Action',
+        S: 'GoTo',
+        D: [svg.linkToPage, 0, 0]
+      }).end();
+      this.pdfDocument.annotate(svg.x, svg.y, svg._width, svg._height, {
+        Subtype: 'Link',
+        Dest: [svg.linkToPage - 1, 'XYZ', null, null, null]
+      });
+    }
+    if (svg.linkToDestination) {
+      this.pdfDocument.goTo(svg.x, svg.y, svg._width, svg._height, svg.linkToDestination);
+    }
+  }
+  renderAttachment(attachment) {
+    const file = this.pdfDocument.provideAttachment(attachment.attachment);
+    const options = {};
+    if (attachment.icon) {
+      options.Name = attachment.icon;
+    }
+    this.pdfDocument.fileAnnotation(attachment.x, attachment.y, attachment._width, attachment._height, file, options);
+  }
+  beginClip(rect) {
+    this.pdfDocument.save();
+    this.pdfDocument.addContent(`${rect.x} ${rect.y} ${rect.width} ${rect.height} re`);
+    this.pdfDocument.clip();
+  }
+  endClip() {
+    this.pdfDocument.restore();
+  }
+  beginVerticalAlignment(item) {
+    if (item.isCellContentMultiPage) {
+      return;
+    }
+    switch (item.verticalAlignment) {
+      case 'middle':
+        this.pdfDocument.save();
+        this.pdfDocument.translate(0, -(item.getNodeHeight() - item.getViewHeight()) / 2);
+        break;
+      case 'bottom':
+        this.pdfDocument.save();
+        this.pdfDocument.translate(0, -(item.getNodeHeight() - item.getViewHeight()));
+        break;
+    }
+  }
+  endVerticalAlignment(item) {
+    if (item.isCellContentMultiPage) {
+      return;
+    }
+    switch (item.verticalAlignment) {
+      case 'middle':
+      case 'bottom':
+        this.pdfDocument.restore();
+        break;
+    }
+  }
+  renderWatermark(page) {
+    let watermark = page.watermark;
+    this.pdfDocument.fill(watermark.color);
+    this.pdfDocument.opacity(watermark.opacity);
+    this.pdfDocument.save();
+    this.pdfDocument.rotate(watermark.angle, {
+      origin: [this.pdfDocument.page.width / 2, this.pdfDocument.page.height / 2]
+    });
+    let x = this.pdfDocument.page.width / 2 - watermark._size.size.width / 2;
+    let y = this.pdfDocument.page.height / 2 - watermark._size.size.height / 2;
+    this.pdfDocument._font = watermark.font;
+    this.pdfDocument.fontSize(watermark.fontSize);
+    this.pdfDocument.text(watermark.text, x, y, {
+      lineBreak: false
+    });
+    this.pdfDocument.restore();
+  }
+}
+var _default = exports.default = Renderer;

package/js/SVGMeasure.js

@@ -0,0 +1,92 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _xmldoc = require("xmldoc");
+var _variableType = require("./helpers/variableType");
+/**
+ * Strip unit postfix, parse number, but return undefined instead of NaN for bad input
+ *
+ * @param {string} textVal
+ * @returns {?number}
+ */
+const stripUnits = textVal => {
+  let n = parseFloat(textVal);
+  if (typeof n !== 'number' || isNaN(n)) {
+    return undefined;
+  }
+  return n;
+};
+
+/**
+ * Make sure it's valid XML and the root tag is <svg/>, returns xmldoc DOM
+ *
+ * @param {string} svgString
+ * @returns {object}
+ */
+const parseSVG = svgString => {
+  let doc;
+  try {
+    doc = new _xmldoc.XmlDocument(svgString);
+  } catch (err) {
+    throw new Error('Invalid svg document (' + err + ')');
+  }
+  if (doc.name !== "svg") {
+    throw new Error('Invalid svg document (expected <svg>)');
+  }
+  return doc;
+};
+class SVGMeasure {
+  constructor() {}
+  measureSVG(svg) {
+    let width, height, viewBox;
+    if ((0, _variableType.isString)(svg)) {
+      let doc = parseSVG(svg);
+      width = doc.attr.width;
+      height = doc.attr.height;
+      viewBox = doc.attr.viewBox;
+    } else if (typeof SVGElement !== 'undefined' && svg instanceof SVGElement && typeof getComputedStyle === 'function') {
+      width = svg.getAttribute("width");
+      height = svg.getAttribute("height");
+      viewBox = svg.getAttribute("viewBox");
+    } else {
+      throw new Error('Invalid SVG document');
+    }
+    let docWidth = stripUnits(width);
+    let docHeight = stripUnits(height);
+    if ((docWidth === undefined || docHeight === undefined) && typeof viewBox === 'string') {
+      let viewBoxParts = viewBox.split(/[,\s]+/);
+      if (viewBoxParts.length !== 4) {
+        throw new Error("Unexpected svg viewBox format, should have 4 entries but found: '" + viewBox + "'");
+      }
+      if (docWidth === undefined) {
+        docWidth = stripUnits(viewBoxParts[2]);
+      }
+      if (docHeight === undefined) {
+        docHeight = stripUnits(viewBoxParts[3]);
+      }
+    }
+    return {
+      width: docWidth,
+      height: docHeight
+    };
+  }
+  writeDimensions(svg, dimensions) {
+    if ((0, _variableType.isString)(svg)) {
+      let doc = parseSVG(svg);
+      if (typeof doc.attr.viewBox !== 'string') {
+        doc.attr.viewBox = `0 0 ${stripUnits(doc.attr.width)} ${stripUnits(doc.attr.height)}`;
+      }
+      doc.attr.width = "" + dimensions.width;
+      doc.attr.height = "" + dimensions.height;
+      return doc.toString();
+    }
+    if (!svg.hasAttribute('viewBox')) {
+      svg.setAttribute('viewBox', `0 0 ${stripUnits(svg.getAttribute('width'))} ${stripUnits(svg.getAttribute('height'))}`);
+    }
+    svg.setAttribute('width', "" + dimensions.width);
+    svg.setAttribute('height', "" + dimensions.height);
+    return svg;
+  }
+}
+var _default = exports.default = SVGMeasure;

package/js/StyleContextStack.js

@@ -0,0 +1,191 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _variableType = require("./helpers/variableType");
+/**
+ * Used for style inheritance and style overrides
+ */
+class StyleContextStack {
+  /**
+   * @param {object} styleDictionary named styles dictionary
+   * @param {object} defaultStyle optional default style definition
+   */
+  constructor(styleDictionary, defaultStyle = {}) {
+    this.styleDictionary = styleDictionary;
+    this.defaultStyle = defaultStyle;
+    this.styleOverrides = [];
+  }
+
+  /**
+   * Creates cloned version of current stack
+   *
+   * @returns {StyleContextStack} current stack snapshot
+   */
+  clone() {
+    let stack = new StyleContextStack(this.styleDictionary, this.defaultStyle);
+    this.styleOverrides.forEach(item => {
+      stack.styleOverrides.push(item);
+    });
+    return stack;
+  }
+
+  /**
+   * Pushes style-name or style-overrides-object onto the stack for future evaluation
+   *
+   * @param {string|object} styleNameOrOverride style-name (referring to styleDictionary) or
+   *                                            a new dictionary defining overriding properties
+   */
+  push(styleNameOrOverride) {
+    this.styleOverrides.push(styleNameOrOverride);
+  }
+
+  /**
+   * Removes last style-name or style-overrides-object from the stack
+   *
+   * @param {number} howMany optional number of elements to be popped (if not specified,
+   *                         one element will be removed from the stack)
+   */
+  pop(howMany = 1) {
+    while (howMany-- > 0) {
+      this.styleOverrides.pop();
+    }
+  }
+
+  /**
+   * Creates a set of named styles or/and a style-overrides-object based on the item,
+   * pushes those elements onto the stack for future evaluation and returns the number
+   * of elements pushed, so they can be easily popped then.
+   *
+   * @param {object} item - an object with optional style property and/or style overrides
+   * @returns {number} the number of items pushed onto the stack
+   */
+  autopush(item) {
+    if ((0, _variableType.isString)(item)) {
+      return 0;
+    }
+    if (typeof item.section !== 'undefined') {
+      // section node not support style overrides
+      return 0;
+    }
+    let styleNames = [];
+    if (item.style) {
+      if (Array.isArray(item.style)) {
+        styleNames = item.style;
+      } else {
+        styleNames = [item.style];
+      }
+    }
+    for (let i = 0, l = styleNames.length; i < l; i++) {
+      this.push(styleNames[i]);
+    }
+
+    // rather than spend significant time making a styleOverrideObject, just add item
+    this.push(item);
+    return styleNames.length + 1;
+  }
+
+  /**
+   * Automatically pushes elements onto the stack, using autopush based on item,
+   * executes callback and then pops elements back. Returns value returned by callback
+   *
+   * @param {object} item - an object with optional style property and/or style overrides
+   * @param {Function} callback to be called between autopush and pop
+   * @returns {object} value returned by callback
+   */
+  auto(item, callback) {
+    let pushedItems = this.autopush(item);
+    let result = callback();
+    if (pushedItems > 0) {
+      this.pop(pushedItems);
+    }
+    return result;
+  }
+
+  /**
+   * Evaluates stack and returns value of a named property
+   *
+   * @param {string} property - property name
+   * @returns {?any} property value or null if not found
+   */
+  getProperty(property) {
+    const getStylePropertyFromStyle = (styleName, property, visited = new Set()) => {
+      if (visited.has(styleName)) {
+        return undefined;
+      }
+      visited.add(styleName);
+      const style = this.styleDictionary[styleName];
+      if (!style) {
+        return undefined;
+      }
+      if ((0, _variableType.isValue)(style[property])) {
+        return style[property];
+      }
+      if (style.extends) {
+        let parents = Array.isArray(style.extends) ? style.extends : [style.extends];
+        for (let i = parents.length - 1; i >= 0; i--) {
+          let value = getStylePropertyFromStyle(parents[i], property, visited);
+          if ((0, _variableType.isValue)(value)) {
+            return value;
+          }
+        }
+      }
+      return undefined;
+    };
+    if (this.styleOverrides) {
+      for (let i = this.styleOverrides.length - 1; i >= 0; i--) {
+        let item = this.styleOverrides[i];
+        if ((0, _variableType.isString)(item)) {
+          // named-style-override
+          let value = getStylePropertyFromStyle(item, property);
+          if ((0, _variableType.isValue)(value)) {
+            return value;
+          }
+        } else if ((0, _variableType.isValue)(item[property])) {
+          // style-overrides-object
+          return item[property];
+        }
+      }
+    }
+    return this.defaultStyle && this.defaultStyle[property];
+  }
+
+  /**
+   * @param {object} item
+   * @param {StyleContextStack} styleContextStack
+   * @param {string} property
+   * @param {any} defaultValue
+   * @returns {any}
+   */
+  static getStyleProperty(item, styleContextStack, property, defaultValue) {
+    let value;
+    if ((0, _variableType.isValue)(item[property])) {
+      // item defines this property
+      return item[property];
+    }
+    if (!styleContextStack) {
+      return defaultValue;
+    }
+    styleContextStack.auto(item, () => {
+      value = styleContextStack.getProperty(property);
+    });
+    return (0, _variableType.isValue)(value) ? value : defaultValue;
+  }
+
+  /**
+   * @param {object} source
+   * @param {object} destination
+   * @returns {object}
+   */
+  static copyStyle(source = {}, destination = {}) {
+    // TODO: default style to source
+
+    for (let key in source) {
+      if (key != 'text' && source.hasOwnProperty(key)) {
+        destination[key] = source[key];
+      }
+    }
+    return destination;
+  }
+}
+var _default = exports.default = StyleContextStack;