pdfmake-acroforms 0.3.4

package/js/browser-extensions/OutputDocumentBrowser.js

@@ -0,0 +1,82 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _OutputDocument = _interopRequireDefault(require("../OutputDocument"));
+var _fileSaver = require("file-saver");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * @returns {Window}
+ */
+const openWindow = () => {
+  // we have to open the window immediately and store the reference
+  // otherwise popup blockers will stop us
+  let win = window.open('', '_blank');
+  if (win === null) {
+    throw new Error('Open PDF in new window blocked by browser');
+  }
+  return win;
+};
+class OutputDocumentBrowser extends _OutputDocument.default {
+  /**
+   * @returns {Promise<Blob>}
+   */
+  async getBlob() {
+    const buffer = await this.getBuffer();
+    return new Blob([buffer], {
+      type: 'application/pdf'
+    });
+  }
+
+  /**
+   * @param {string} filename
+   * @returns {Promise}
+   */
+  async download(filename = 'file.pdf') {
+    const blob = await this.getBlob();
+    (0, _fileSaver.saveAs)(blob, filename);
+  }
+
+  /**
+   * @param {Window} win
+   * @returns {Promise}
+   */
+  async open(win = null) {
+    if (!win) {
+      win = openWindow();
+    }
+    const blob = await this.getBlob();
+    try {
+      let urlCreator = window.URL || window.webkitURL;
+      let pdfUrl = urlCreator.createObjectURL(blob);
+      win.location.href = pdfUrl;
+
+      /* temporarily disabled
+      if (win === window) {
+      	return;
+      } else {
+      	setTimeout(() => {
+      		if (win.window === null) { // is closed by AdBlock
+      			window.location.href = pdfUrl; // open in actual window
+      		}
+      		return;
+      	}, 500);
+      }
+      */
+    } catch (e) {
+      win.close();
+      throw e;
+    }
+  }
+
+  /**
+   * @param {Window} win
+   * @returns {Promise}
+   */
+  async print(win = null) {
+    const stream = await this.getStream();
+    stream.setOpenActionAsPrint();
+    await this.open(win);
+  }
+}
+var _default = exports.default = OutputDocumentBrowser;

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 _URLResolver = _interopRequireDefault(require("../URLResolver"));
+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 _URLResolver.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,3 @@
+"use strict";
+
+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/pdfkit/js/data/Courier.afm', 'utf8'),
+      encoding: 'utf8'
+    },
+    'data/Courier-Bold.afm': {
+      data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/Courier-Bold.afm', 'utf8'),
+      encoding: 'utf8'
+    },
+    'data/Courier-Oblique.afm': {
+      data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/Courier-Oblique.afm', 'utf8'),
+      encoding: 'utf8'
+    },
+    'data/Courier-BoldOblique.afm': {
+      data: fs.readFileSync(__dirname + '/../../../node_modules/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/pdfkit/js/data/Helvetica.afm', 'utf8'),
+      encoding: 'utf8'
+    },
+    'data/Helvetica-Bold.afm': {
+      data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/Helvetica-Bold.afm', 'utf8'),
+      encoding: 'utf8'
+    },
+    'data/Helvetica-Oblique.afm': {
+      data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/Helvetica-Oblique.afm', 'utf8'),
+      encoding: 'utf8'
+    },
+    'data/Helvetica-BoldOblique.afm': {
+      data: fs.readFileSync(__dirname + '/../../../node_modules/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/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/pdfkit/js/data/Times-Roman.afm', 'utf8'),
+      encoding: 'utf8'
+    },
+    'data/Times-Bold.afm': {
+      data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/Times-Bold.afm', 'utf8'),
+      encoding: 'utf8'
+    },
+    'data/Times-Italic.afm': {
+      data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/Times-Italic.afm', 'utf8'),
+      encoding: 'utf8'
+    },
+    'data/Times-BoldItalic.afm': {
+      data: fs.readFileSync(__dirname + '/../../../node_modules/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/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,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, defaultMargin = 0) {
+    if (node.marginLeft !== undefined || node.marginTop !== undefined || node.marginRight !== undefined || node.marginBottom !== undefined) {
+      return [node.marginLeft ?? currentMargin[0] ?? defaultMargin, node.marginTop ?? currentMargin[1] ?? defaultMargin, node.marginRight ?? currentMargin[2] ?? defaultMargin, node.marginBottom ?? currentMargin[3] ?? defaultMargin];
+    }
+    return currentMargin;
+  }
+  function flattenStyleArray(styleArray, styleStack, visited = new Set()) {
+    styleArray = Array.isArray(styleArray) ? styleArray : [styleArray];
+
+    // style is not valid array of strings
+    if (!styleArray.every(item => (0, _variableType.isString)(item))) {
+      return {};
+    }
+    let flattenedStyles = {};
+    for (let index = 0; index < styleArray.length; index++) {
+      let styleName = styleArray[index];
+      let style = styleStack.styleDictionary[styleName];
+
+      // style not found
+      if (style === undefined) {
+        continue;
+      }
+      if (visited.has(styleName)) {
+        continue;
+      }
+      if (style.extends !== undefined) {
+        flattenedStyles = {
+          ...flattenedStyles,
+          ...flattenStyleArray(style.extends, styleStack, new Set([...visited, styleName]))
+        };
+      }
+      if (style.margin !== undefined) {
+        flattenedStyles = {
+          margin: convertMargin(style.margin)
+        };
+        continue;
+      }
+      flattenedStyles = {
+        margin: processSingleMargins(style, flattenedStyles.margin ?? {}, undefined)
+      };
+    }
+    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 !== undefined) {
+    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,46 @@
+"use strict";
+
+exports.__esModule = true;
+exports.convertToDynamicContent = convertToDynamicContent;
+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;
+  }
+}
+function convertToDynamicContent(staticContent) {
+  return () =>
+  // copy to new object
+  JSON.parse(JSON.stringify(staticContent));
+}