pdfmake 0.3.0-beta.8 → 0.3.0

package/js/SVGMeasure.js

@@ -0,0 +1,69 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _xmldoc = _interopRequireDefault(require("xmldoc"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * 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 tage is <svg/>, returns xmldoc DOM
+ *
+ * @param {string} svgString
+ * @returns {object}
+ */
+const parseSVG = svgString => {
+  let doc;
+  try {
+    doc = new _xmldoc.default.XmlDocument(svgString);
+  } catch (err) {
+    throw new Error('SVGMeasure: ' + err);
+  }
+  if (doc.name !== "svg") {
+    throw new Error('SVGMeasure: expected <svg> document');
+  }
+  return doc;
+};
+class SVGMeasure {
+  constructor() {}
+  measureSVG(svgString) {
+    let doc = parseSVG(svgString);
+    let docWidth = stripUnits(doc.attr.width);
+    let docHeight = stripUnits(doc.attr.height);
+    if ((docWidth === undefined || docHeight === undefined) && typeof doc.attr.viewBox === 'string') {
+      let viewBoxParts = doc.attr.viewBox.split(/[,\s]+/);
+      if (viewBoxParts.length !== 4) {
+        throw new Error("Unexpected svg viewbox format, should have 4 entries but found: '" + doc.attr.viewBox + "'");
+      }
+      if (docWidth === undefined) {
+        docWidth = stripUnits(viewBoxParts[2]);
+      }
+      if (docHeight === undefined) {
+        docHeight = stripUnits(viewBoxParts[3]);
+      }
+    }
+    return {
+      width: docWidth,
+      height: docHeight
+    };
+  }
+  writeDimensions(svgString, dimensions) {
+    let doc = parseSVG(svgString);
+    doc.attr.width = "" + dimensions.width;
+    doc.attr.height = "" + dimensions.height;
+    return doc.toString();
+  }
+}
+var _default = exports.default = SVGMeasure;

package/js/StyleContextStack.js

@@ -0,0 +1,168 @@
+"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 poped 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) {
+    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 style = this.styleDictionary[item];
+          if (style && (0, _variableType.isValue)(style[property])) {
+            return style[property];
+          }
+        } 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;