pdfmake 0.2.4 → 0.3.0-beta.2

package/js/base.js

@@ -0,0 +1,69 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _Printer = _interopRequireDefault(require("./Printer"));
+
+var _virtualFs = _interopRequireDefault(require("./virtual-fs"));
+
+var _tools = require("./helpers/tools");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class pdfmake {
+  constructor() {
+    this.virtualfs = _virtualFs.default;
+    this.urlResolver = null;
+  }
+  /**
+   * @param {object} docDefinition
+   * @param {?object} options
+   * @returns {object}
+   */
+
+
+  createPdf(docDefinition, options = {}) {
+    options.progressCallback = this.progressCallback;
+    options.tableLayouts = this.tableLayouts;
+    let printer = new _Printer.default(this.fonts, this.virtualfs, this.urlResolver);
+    const pdfDocumentPromise = printer.createPdfKitDocument(docDefinition, options);
+    return this._transformToDocument(pdfDocumentPromise);
+  }
+
+  setProgressCallback(callback) {
+    this.progressCallback = callback;
+  }
+
+  addTableLayouts(tableLayouts) {
+    this.tableLayouts = (0, _tools.pack)(this.tableLayouts, tableLayouts);
+  }
+
+  setTableLayouts(tableLayouts) {
+    this.tableLayouts = tableLayouts;
+  }
+
+  clearTableLayouts() {
+    this.tableLayouts = {};
+  }
+
+  addFonts(fonts) {
+    this.fonts = (0, _tools.pack)(this.fonts, fonts);
+  }
+
+  setFonts(fonts) {
+    this.fonts = fonts;
+  }
+
+  clearFonts() {
+    this.fonts = {};
+  }
+
+  _transformToDocument(doc) {
+    return doc;
+  }
+
+}
+
+var _default = pdfmake;
+exports.default = _default;

package/js/browser-extensions/OutputDocumentBrowser.js

@@ -0,0 +1,131 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _OutputDocument = _interopRequireDefault(require("../OutputDocument"));
+
+var _fileSaver = require("file-saver");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * @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>}
+   */
+  getBlob() {
+    return new Promise((resolve, reject) => {
+      this.getBuffer().then(buffer => {
+        try {
+          let blob = new Blob([buffer], {
+            type: 'application/pdf'
+          });
+          resolve(blob);
+        } catch (e) {
+          reject(e);
+        }
+      }, result => {
+        reject(result);
+      });
+    });
+  }
+  /**
+   * @param {string} filename
+   * @returns {Promise}
+   */
+
+
+  download(filename = 'file.pdf') {
+    return new Promise((resolve, reject) => {
+      this.getBlob().then(blob => {
+        try {
+          (0, _fileSaver.saveAs)(blob, filename);
+          resolve();
+        } catch (e) {
+          reject(e);
+        }
+      }, result => {
+        reject(result);
+      });
+    });
+  }
+  /**
+   * @param {Window} win
+   * @returns {Promise}
+   */
+
+
+  open(win = null) {
+    return new Promise((resolve, reject) => {
+      if (!win) {
+        win = openWindow();
+      }
+
+      this.getBlob().then(blob => {
+        try {
+          let urlCreator = window.URL || window.webkitURL;
+          let pdfUrl = urlCreator.createObjectURL(blob);
+          win.location.href = pdfUrl; //
+
+          resolve();
+          /* temporarily disabled
+          if (win === window) {
+          	resolve();
+          } else {
+          	setTimeout(() => {
+          		if (win.window === null) { // is closed by AdBlock
+          			window.location.href = pdfUrl; // open in actual window
+          		}
+          		resolve();
+          	}, 500);
+          }
+          */
+        } catch (e) {
+          win.close();
+          reject(e);
+        }
+      }, result => {
+        reject(result);
+      });
+    });
+  }
+  /**
+   * @param {Window} win
+   * @returns {Promise}
+   */
+
+
+  print(win = null) {
+    return new Promise((resolve, reject) => {
+      this.getStream().then(stream => {
+        stream.setOpenActionAsPrint();
+        return this.open(win).then(() => {
+          resolve();
+        }, result => {
+          reject(result);
+        });
+      }, result => {
+        reject(result);
+      });
+    });
+  }
+
+}
+
+var _default = OutputDocumentBrowser;
+exports.default = _default;

package/js/browser-extensions/URLBrowserResolver.js

@@ -0,0 +1,94 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+const fetchUrl = (url, headers = {}) => {
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    xhr.open('GET', url, true);
+
+    for (let headerName in headers) {
+      xhr.setRequestHeader(headerName, headers[headerName]);
+    }
+
+    xhr.responseType = 'arraybuffer';
+
+    xhr.onreadystatechange = () => {
+      if (xhr.readyState !== 4) {
+        return;
+      }
+
+      const ok = xhr.status >= 200 && xhr.status < 300;
+
+      if (!ok) {
+        setTimeout(() => {
+          reject(new TypeError(`Failed to fetch (url: "${url}")`));
+        }, 0);
+      }
+    };
+
+    xhr.onload = () => {
+      const ok = xhr.status >= 200 && xhr.status < 300;
+
+      if (ok) {
+        resolve(xhr.response);
+      }
+    };
+
+    xhr.onerror = () => {
+      setTimeout(() => {
+        reject(new TypeError(`Network request failed (url: "${url}")`));
+      }, 0);
+    };
+
+    xhr.ontimeout = () => {
+      setTimeout(() => {
+        reject(new TypeError(`Network request failed (url: "${url}")`));
+      }, 0);
+    };
+
+    xhr.send();
+  });
+};
+
+class URLBrowserResolver {
+  constructor(fs) {
+    this.fs = fs;
+    this.resolving = {};
+  }
+
+  resolve(url, headers = {}) {
+    if (!this.resolving[url]) {
+      this.resolving[url] = new Promise((resolve, reject) => {
+        if (url.toLowerCase().indexOf('https://') === 0 || url.toLowerCase().indexOf('http://') === 0) {
+          fetchUrl(url, headers).then(buffer => {
+            this.fs.writeFileSync(url, buffer);
+            resolve();
+          }, result => {
+            reject(result);
+          });
+        } else {
+          // cannot be resolved
+          resolve();
+        }
+      });
+    }
+
+    return this.resolving[url];
+  }
+
+  resolved() {
+    return new Promise((resolve, reject) => {
+      Promise.all(Object.values(this.resolving)).then(() => {
+        resolve();
+      }, result => {
+        reject(result);
+      });
+    });
+  }
+
+}
+
+var _default = URLBrowserResolver;
+exports.default = _default;

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

@@ -0,0 +1,42 @@
+"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,70 @@
+"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(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// 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 = new pdfmake();
+
+exports.default = _default;

package/js/browser-extensions/pdfMake.js

@@ -0,0 +1,17 @@
+"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,42 @@
+"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,42 @@
+"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,27 @@
+"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,42 @@
+"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,27 @@
+"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;