pdfmake 0.2.1 → 0.3.0-beta.1

package/js/columnCalculator.js

@@ -0,0 +1,142 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _variableType = require("./helpers/variableType");
+
+function buildColumnWidths(columns, availableWidth) {
+  let autoColumns = [];
+  let autoMin = 0;
+  let autoMax = 0;
+  let starColumns = [];
+  let starMaxMin = 0;
+  let starMaxMax = 0;
+  let fixedColumns = [];
+  let initial_availableWidth = availableWidth;
+  columns.forEach(column => {
+    if (isAutoColumn(column)) {
+      autoColumns.push(column);
+      autoMin += column._minWidth;
+      autoMax += column._maxWidth;
+    } else if (isStarColumn(column)) {
+      starColumns.push(column);
+      starMaxMin = Math.max(starMaxMin, column._minWidth);
+      starMaxMax = Math.max(starMaxMax, column._maxWidth);
+    } else {
+      fixedColumns.push(column);
+    }
+  });
+  fixedColumns.forEach(col => {
+    // width specified as %
+    if ((0, _variableType.isString)(col.width) && /\d+%/.test(col.width)) {
+      col.width = parseFloat(col.width) * initial_availableWidth / 100;
+    }
+
+    if (col.width < col._minWidth && col.elasticWidth) {
+      col._calcWidth = col._minWidth;
+    } else {
+      col._calcWidth = col.width;
+    }
+
+    availableWidth -= col._calcWidth;
+  }); // http://www.freesoft.org/CIE/RFC/1942/18.htm
+  // http://www.w3.org/TR/CSS2/tables.html#width-layout
+  // http://dev.w3.org/csswg/css3-tables-algorithms/Overview.src.htm
+
+  let minW = autoMin + starMaxMin * starColumns.length;
+  let maxW = autoMax + starMaxMax * starColumns.length;
+
+  if (minW >= availableWidth) {
+    // case 1 - there's no way to fit all columns within available width
+    // that's actually pretty bad situation with PDF as we have no horizontal scroll
+    // no easy workaround (unless we decide, in the future, to split single words)
+    // currently we simply use minWidths for all columns
+    autoColumns.forEach(col => {
+      col._calcWidth = col._minWidth;
+    });
+    starColumns.forEach(col => {
+      col._calcWidth = starMaxMin; // starMaxMin already contains padding
+    });
+  } else {
+    if (maxW < availableWidth) {
+      // case 2 - we can fit rest of the table within available space
+      autoColumns.forEach(col => {
+        col._calcWidth = col._maxWidth;
+        availableWidth -= col._calcWidth;
+      });
+    } else {
+      // maxW is too large, but minW fits within available width
+      let W = availableWidth - minW;
+      let D = maxW - minW;
+      autoColumns.forEach(col => {
+        let d = col._maxWidth - col._minWidth;
+        col._calcWidth = col._minWidth + d * W / D;
+        availableWidth -= col._calcWidth;
+      });
+    }
+
+    if (starColumns.length > 0) {
+      let starSize = availableWidth / starColumns.length;
+      starColumns.forEach(col => {
+        col._calcWidth = starSize;
+      });
+    }
+  }
+}
+
+function isAutoColumn(column) {
+  return column.width === 'auto';
+}
+
+function isStarColumn(column) {
+  return column.width === null || column.width === undefined || column.width === '*' || column.width === 'star';
+} //TODO: refactor and reuse in measureTable
+
+
+function measureMinMax(columns) {
+  let result = {
+    min: 0,
+    max: 0
+  };
+  let maxStar = {
+    min: 0,
+    max: 0
+  };
+  let starCount = 0;
+
+  for (let i = 0, l = columns.length; i < l; i++) {
+    let c = columns[i];
+
+    if (isStarColumn(c)) {
+      maxStar.min = Math.max(maxStar.min, c._minWidth);
+      maxStar.max = Math.max(maxStar.max, c._maxWidth);
+      starCount++;
+    } else if (isAutoColumn(c)) {
+      result.min += c._minWidth;
+      result.max += c._maxWidth;
+    } else {
+      result.min += c.width !== undefined && c.width || c._minWidth;
+      result.max += c.width !== undefined && c.width || c._maxWidth;
+    }
+  }
+
+  if (starCount) {
+    result.min += starCount * maxStar.min;
+    result.max += starCount * maxStar.max;
+  }
+
+  return result;
+}
+/**
+ * Calculates column widths
+ */
+
+
+var _default = {
+  buildColumnWidths: buildColumnWidths,
+  measureMinMax: measureMinMax,
+  isAutoColumn: isAutoColumn,
+  isStarColumn: isStarColumn
+};
+exports.default = _default;

package/js/helpers/node.js

@@ -0,0 +1,122 @@
+"use strict";
+
+exports.__esModule = true;
+exports.getNodeId = getNodeId;
+exports.getNodeMargin = getNodeMargin;
+exports.stringifyNode = stringifyNode;
+
+var _variableType = require("./variableType");
+
+function fontStringify(key, val) {
+  if (key === 'font') {
+    return 'font';
+  }
+
+  return val;
+}
+/**
+ * Convert node to readable string
+ *
+ * @param {object} node
+ * @returns {string}
+ */
+
+
+function stringifyNode(node) {
+  return JSON.stringify(node, fontStringify);
+}
+/**
+ * @param {object} node
+ * @returns {?string}
+ */
+
+
+function getNodeId(node) {
+  if (node.id) {
+    return node.id;
+  }
+
+  if (Array.isArray(node.text)) {
+    for (let n of node.text) {
+      let nodeId = getNodeId(n);
+
+      if (nodeId) {
+        return nodeId;
+      }
+    }
+  }
+
+  return null;
+}
+/**
+ * @param {object} node
+ * @param {object} styleStack object is instance of PDFDocument
+ * @returns {?Array}
+ */
+
+
+function getNodeMargin(node, styleStack) {
+  function processSingleMargins(node, currentMargin) {
+    if (node.marginLeft || node.marginTop || node.marginRight || node.marginBottom) {
+      return [node.marginLeft || currentMargin[0] || 0, node.marginTop || currentMargin[1] || 0, node.marginRight || currentMargin[2] || 0, node.marginBottom || currentMargin[3] || 0];
+    }
+
+    return currentMargin;
+  }
+
+  function flattenStyleArray(styleArray, styleStack) {
+    let flattenedStyles = {};
+
+    for (let i = styleArray.length - 1; i >= 0; i--) {
+      let styleName = styleArray[i];
+      let style = styleStack.styleDictionary[styleName];
+
+      for (let key in style) {
+        if (style.hasOwnProperty(key)) {
+          flattenedStyles[key] = style[key];
+        }
+      }
+    }
+
+    return flattenedStyles;
+  }
+
+  function convertMargin(margin) {
+    if ((0, _variableType.isNumber)(margin)) {
+      margin = [margin, margin, margin, margin];
+    } else if (Array.isArray(margin)) {
+      if (margin.length === 2) {
+        margin = [margin[0], margin[1], margin[0], margin[1]];
+      }
+    }
+
+    return margin;
+  }
+
+  let margin = [undefined, undefined, undefined, undefined];
+
+  if (node.style) {
+    let styleArray = Array.isArray(node.style) ? node.style : [node.style];
+    let flattenedStyleArray = flattenStyleArray(styleArray, styleStack);
+
+    if (flattenedStyleArray) {
+      margin = processSingleMargins(flattenedStyleArray, margin);
+    }
+
+    if (flattenedStyleArray.margin) {
+      margin = convertMargin(flattenedStyleArray.margin);
+    }
+  }
+
+  margin = processSingleMargins(node, margin);
+
+  if (node.margin) {
+    margin = convertMargin(node.margin);
+  }
+
+  if (margin[0] === undefined && margin[1] === undefined && margin[2] === undefined && margin[3] === undefined) {
+    return null;
+  }
+
+  return margin;
+}

package/js/helpers/tools.js

@@ -0,0 +1,48 @@
+"use strict";
+
+exports.__esModule = true;
+exports.offsetVector = offsetVector;
+exports.pack = pack;
+
+function pack(...args) {
+  let result = {};
+
+  for (let i = 0, l = args.length; i < l; i++) {
+    let obj = args[i];
+
+    if (obj) {
+      for (let key in obj) {
+        if (obj.hasOwnProperty(key)) {
+          result[key] = obj[key];
+        }
+      }
+    }
+  }
+
+  return result;
+}
+
+function offsetVector(vector, x, y) {
+  switch (vector.type) {
+    case 'ellipse':
+    case 'rect':
+      vector.x += x;
+      vector.y += y;
+      break;
+
+    case 'line':
+      vector.x1 += x;
+      vector.x2 += x;
+      vector.y1 += y;
+      vector.y2 += y;
+      break;
+
+    case 'polyline':
+      for (let i = 0, l = vector.points.length; i < l; i++) {
+        vector.points[i].x += x;
+        vector.points[i].y += y;
+      }
+
+      break;
+  }
+}

package/js/helpers/variableType.js

@@ -0,0 +1,52 @@
+"use strict";
+
+exports.__esModule = true;
+exports.isEmptyObject = isEmptyObject;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
+exports.isString = isString;
+exports.isValue = isValue;
+
+/**
+ * @param {any} variable
+ * @returns {boolean}
+ */
+function isString(variable) {
+  return typeof variable === 'string' || variable instanceof String;
+}
+/**
+ * @param {any} variable
+ * @returns {boolean}
+ */
+
+
+function isNumber(variable) {
+  return typeof variable === 'number' || variable instanceof Number;
+}
+/**
+ * @param {any} variable
+ * @returns {boolean}
+ */
+
+
+function isObject(variable) {
+  return variable !== null && !Array.isArray(variable) && !isString(variable) && !isNumber(variable) && typeof variable === 'object';
+}
+/**
+ * @param {any} variable
+ * @returns {boolean}
+ */
+
+
+function isEmptyObject(variable) {
+  return isObject(variable) && Object.keys(variable).length === 0;
+}
+/**
+ * @param {any} variable
+ * @returns {boolean}
+ */
+
+
+function isValue(variable) {
+  return variable !== undefined && variable !== null;
+}

package/js/index.js

@@ -0,0 +1,21 @@
+"use strict";
+
+const pdfmakeBase = require('./base').default;
+
+const OutputDocumentServer = require('./OutputDocumentServer').default;
+
+const URLResolver = require('./URLResolver').default;
+
+class pdfmake extends pdfmakeBase {
+  constructor() {
+    super();
+    this.urlResolver = new URLResolver(this.virtualfs);
+  }
+
+  _transformToDocument(doc) {
+    return new OutputDocumentServer(doc);
+  }
+
+}
+
+module.exports = new pdfmake();