pdfmake 0.3.0-beta.8 → 0.3.0-beta.9

package/js/browser-extensions/fonts/Roboto.js

@@ -0,0 +1,38 @@
+"use strict";
+
+var fs = require('fs');
+var fontContainer = {
+  vfs: {
+    'Roboto-Regular.ttf': {
+      data: fs.readFileSync(__dirname + '/../../../fonts/Roboto/Roboto-Regular.ttf', 'base64'),
+      encoding: 'base64'
+    },
+    'Roboto-Medium.ttf': {
+      data: fs.readFileSync(__dirname + '/../../../fonts/Roboto/Roboto-Medium.ttf', 'base64'),
+      encoding: 'base64'
+    },
+    'Roboto-Italic.ttf': {
+      data: fs.readFileSync(__dirname + '/../../../fonts/Roboto/Roboto-Italic.ttf', 'base64'),
+      encoding: 'base64'
+    },
+    'Roboto-MediumItalic.ttf': {
+      data: fs.readFileSync(__dirname + '/../../../fonts/Roboto/Roboto-MediumItalic.ttf', 'base64'),
+      encoding: 'base64'
+    }
+  },
+  fonts: {
+    Roboto: {
+      normal: 'Roboto-Regular.ttf',
+      bold: 'Roboto-Medium.ttf',
+      italics: 'Roboto-Italic.ttf',
+      bolditalics: 'Roboto-MediumItalic.ttf'
+    }
+  }
+};
+var _global = typeof window === 'object' ? window : typeof global === 'object' ? global : typeof self === 'object' ? self : void 0;
+if (typeof _global.pdfMake !== 'undefined' && typeof _global.pdfMake.addFontContainer !== 'undefined') {
+  _global.pdfMake.addFontContainer(fontContainer);
+}
+if (typeof module !== 'undefined') {
+  module.exports = fontContainer;
+}

package/js/browser-extensions/index.js

@@ -0,0 +1,53 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _base = _interopRequireDefault(require("../base"));
+var _OutputDocumentBrowser = _interopRequireDefault(require("./OutputDocumentBrowser"));
+var _URLBrowserResolver = _interopRequireDefault(require("./URLBrowserResolver"));
+var _fs = _interopRequireDefault(require("fs"));
+var _configurator = _interopRequireDefault(require("core-js/configurator"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// core-js: Polyfills will be used only if natives completely unavailable.
+(0, _configurator.default)({
+  useNative: ['Promise']
+});
+let defaultClientFonts = {
+  Roboto: {
+    normal: 'Roboto-Regular.ttf',
+    bold: 'Roboto-Medium.ttf',
+    italics: 'Roboto-Italic.ttf',
+    bolditalics: 'Roboto-MediumItalic.ttf'
+  }
+};
+class pdfmake extends _base.default {
+  constructor() {
+    super();
+    this.urlResolver = new _URLBrowserResolver.default(this.virtualfs);
+    this.fonts = defaultClientFonts;
+  }
+  addFontContainer(fontContainer) {
+    this.addVirtualFileSystem(fontContainer.vfs);
+    this.addFonts(fontContainer.fonts);
+  }
+  addVirtualFileSystem(vfs) {
+    for (let key in vfs) {
+      if (vfs.hasOwnProperty(key)) {
+        let data;
+        let encoding;
+        if (typeof vfs[key] === 'object') {
+          data = vfs[key].data;
+          encoding = vfs[key].encoding || 'base64';
+        } else {
+          data = vfs[key];
+          encoding = 'base64';
+        }
+        _fs.default.writeFileSync(key, data, encoding);
+      }
+    }
+  }
+  _transformToDocument(doc) {
+    return new _OutputDocumentBrowser.default(doc);
+  }
+}
+var _default = exports.default = new pdfmake();

package/js/browser-extensions/pdfMake.js

@@ -0,0 +1,15 @@
+"use strict";
+
+const isBrowserSupported = () => {
+  if (typeof window === 'undefined' || typeof window.navigator === 'undefined') {
+    // Enviroment is not browser.
+    return true;
+  }
+
+  // Internet Explorer 10 and older is not supported.
+  return window.navigator.userAgent.indexOf("MSIE") === -1;
+};
+if (!isBrowserSupported()) {
+  throw new Error('pdfmake: Internet Explorer 10 and older is not supported. Upgrade to version 11 or use modern browser.');
+}
+module.exports = require('./index').default;

package/js/browser-extensions/standard-fonts/Courier.js

@@ -0,0 +1,38 @@
+"use strict";
+
+var fs = require('fs');
+var fontContainer = {
+  vfs: {
+    'data/Courier.afm': {
+      data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/Courier.afm', 'utf8'),
+      encoding: 'utf8'
+    },
+    'data/Courier-Bold.afm': {
+      data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/Courier-Bold.afm', 'utf8'),
+      encoding: 'utf8'
+    },
+    'data/Courier-Oblique.afm': {
+      data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/Courier-Oblique.afm', 'utf8'),
+      encoding: 'utf8'
+    },
+    'data/Courier-BoldOblique.afm': {
+      data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/Courier-BoldOblique.afm', 'utf8'),
+      encoding: 'utf8'
+    }
+  },
+  fonts: {
+    Courier: {
+      normal: 'Courier',
+      bold: 'Courier-Bold',
+      italics: 'Courier-Oblique',
+      bolditalics: 'Courier-BoldOblique'
+    }
+  }
+};
+var _global = typeof window === 'object' ? window : typeof global === 'object' ? global : typeof self === 'object' ? self : void 0;
+if (typeof _global.pdfMake !== 'undefined' && typeof _global.pdfMake.addFontContainer !== 'undefined') {
+  _global.pdfMake.addFontContainer(fontContainer);
+}
+if (typeof module !== 'undefined') {
+  module.exports = fontContainer;
+}

package/js/browser-extensions/standard-fonts/Helvetica.js

@@ -0,0 +1,38 @@
+"use strict";
+
+var fs = require('fs');
+var fontContainer = {
+  vfs: {
+    'data/Helvetica.afm': {
+      data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/Helvetica.afm', 'utf8'),
+      encoding: 'utf8'
+    },
+    'data/Helvetica-Bold.afm': {
+      data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/Helvetica-Bold.afm', 'utf8'),
+      encoding: 'utf8'
+    },
+    'data/Helvetica-Oblique.afm': {
+      data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/Helvetica-Oblique.afm', 'utf8'),
+      encoding: 'utf8'
+    },
+    'data/Helvetica-BoldOblique.afm': {
+      data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/Helvetica-BoldOblique.afm', 'utf8'),
+      encoding: 'utf8'
+    }
+  },
+  fonts: {
+    Helvetica: {
+      normal: 'Helvetica',
+      bold: 'Helvetica-Bold',
+      italics: 'Helvetica-Oblique',
+      bolditalics: 'Helvetica-BoldOblique'
+    }
+  }
+};
+var _global = typeof window === 'object' ? window : typeof global === 'object' ? global : typeof self === 'object' ? self : void 0;
+if (typeof _global.pdfMake !== 'undefined' && typeof _global.pdfMake.addFontContainer !== 'undefined') {
+  _global.pdfMake.addFontContainer(fontContainer);
+}
+if (typeof module !== 'undefined') {
+  module.exports = fontContainer;
+}

package/js/browser-extensions/standard-fonts/Symbol.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var fs = require('fs');
+var fontContainer = {
+  vfs: {
+    'data/Symbol.afm': {
+      data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/Symbol.afm', 'utf8'),
+      encoding: 'utf8'
+    }
+  },
+  fonts: {
+    Symbol: {
+      normal: 'Symbol'
+    }
+  }
+};
+var _global = typeof window === 'object' ? window : typeof global === 'object' ? global : typeof self === 'object' ? self : void 0;
+if (typeof _global.pdfMake !== 'undefined' && typeof _global.pdfMake.addFontContainer !== 'undefined') {
+  _global.pdfMake.addFontContainer(fontContainer);
+}
+if (typeof module !== 'undefined') {
+  module.exports = fontContainer;
+}

package/js/browser-extensions/standard-fonts/Times.js

@@ -0,0 +1,38 @@
+"use strict";
+
+var fs = require('fs');
+var fontContainer = {
+  vfs: {
+    'data/Times-Roman.afm': {
+      data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/Times-Roman.afm', 'utf8'),
+      encoding: 'utf8'
+    },
+    'data/Times-Bold.afm': {
+      data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/Times-Bold.afm', 'utf8'),
+      encoding: 'utf8'
+    },
+    'data/Times-Italic.afm': {
+      data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/Times-Italic.afm', 'utf8'),
+      encoding: 'utf8'
+    },
+    'data/Times-BoldItalic.afm': {
+      data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/Times-BoldItalic.afm', 'utf8'),
+      encoding: 'utf8'
+    }
+  },
+  fonts: {
+    Times: {
+      normal: 'Times-Roman',
+      bold: 'Times-Bold',
+      italics: 'Times-Italic',
+      bolditalics: 'Times-BoldItalic'
+    }
+  }
+};
+var _global = typeof window === 'object' ? window : typeof global === 'object' ? global : typeof self === 'object' ? self : void 0;
+if (typeof _global.pdfMake !== 'undefined' && typeof _global.pdfMake.addFontContainer !== 'undefined') {
+  _global.pdfMake.addFontContainer(fontContainer);
+}
+if (typeof module !== 'undefined') {
+  module.exports = fontContainer;
+}

package/js/browser-extensions/standard-fonts/ZapfDingbats.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var fs = require('fs');
+var fontContainer = {
+  vfs: {
+    'data/ZapfDingbats.afm': {
+      data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/ZapfDingbats.afm', 'utf8'),
+      encoding: 'utf8'
+    }
+  },
+  fonts: {
+    ZapfDingbats: {
+      normal: 'ZapfDingbats'
+    }
+  }
+};
+var _global = typeof window === 'object' ? window : typeof global === 'object' ? global : typeof self === 'object' ? self : void 0;
+if (typeof _global.pdfMake !== 'undefined' && typeof _global.pdfMake.addFontContainer !== 'undefined') {
+  _global.pdfMake.addFontContainer(fontContainer);
+}
+if (typeof module !== 'undefined') {
+  module.exports = fontContainer;
+}

package/js/browser-extensions/virtual-fs-cjs.js

@@ -0,0 +1,3 @@
+"use strict";
+
+module.exports = require('../virtual-fs').default;

package/js/columnCalculator.js

@@ -0,0 +1,148 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _variableType = require("./helpers/variableType");
+function buildColumnWidths(columns, availableWidth, offsetTotal = 0, tableNode) {
+  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, colIndex) => {
+    // width specified as %
+    if ((0, _variableType.isString)(col.width) && /\d+%/.test(col.width)) {
+      // In tables we have to take into consideration the reserved width for paddings and borders
+      let reservedWidth = 0;
+      if (tableNode) {
+        const paddingLeft = tableNode._layout.paddingLeft(colIndex, tableNode);
+        const paddingRight = tableNode._layout.paddingRight(colIndex, tableNode);
+        const borderLeft = tableNode._layout.vLineWidth(colIndex, tableNode);
+        const borderRight = tableNode._layout.vLineWidth(colIndex + 1, tableNode);
+        if (colIndex === 0) {
+          // first column assumes whole borderLeft and half of border right
+          reservedWidth = paddingLeft + paddingRight + borderLeft + borderRight / 2;
+        } else if (colIndex === fixedColumns.length - 1) {
+          // last column assumes whole borderRight and half of border left
+          reservedWidth = paddingLeft + paddingRight + borderLeft / 2 + borderRight;
+        } else {
+          // Columns in the middle assume half of each border
+          reservedWidth = paddingLeft + paddingRight + borderLeft / 2 + borderRight / 2;
+        }
+      }
+      const totalAvailableWidth = initial_availableWidth + offsetTotal;
+      col.width = parseFloat(col.width) * totalAvailableWidth / 100 - reservedWidth;
+    }
+    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 = exports.default = {
+  buildColumnWidths: buildColumnWidths,
+  measureMinMax: measureMinMax,
+  isAutoColumn: isAutoColumn,
+  isStarColumn: isStarColumn
+};

package/js/helpers/node.js

@@ -0,0 +1,98 @@
+"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,40 @@
+"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,59 @@
+"use strict";
+
+exports.__esModule = true;
+exports.isEmptyObject = isEmptyObject;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
+exports.isPositiveInteger = isPositiveInteger;
+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 isPositiveInteger(variable) {
+  if (!isNumber(variable) || !Number.isInteger(variable) || variable <= 0) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * @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,15 @@
+"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();