jspdf-autotable
Version:
Generate pdf tables with javascript (jsPDF plugin)
1,415 lines (1,357 loc) • 72 kB
JavaScript
/*!
*
* jsPDF AutoTable plugin v3.2.2
*
* Copyright (c) 2014 Simon Bengtsson, https://github.com/simonbengtsson/jsPDF-AutoTable
* Licensed under the MIT License.
* http://opensource.org/licenses/mit-license
*
* * /if (typeof window === 'object') window.jspdfAutoTableVersion = '" + newVersion + "';/*"
*
*/
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory(require("jspdf"));
else if(typeof define === 'function' && define.amd)
define(["jspdf"], factory);
else {
var a = typeof exports === 'object' ? factory(require("jspdf")) : factory(root["jsPDF"]);
for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
}
})(window, function(__WEBPACK_EXTERNAL_MODULE__6__) {
return /******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId]) {
/******/ return installedModules[moduleId].exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ }
/******/ };
/******/
/******/ // define __esModule on exports
/******/ __webpack_require__.r = function(exports) {
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ }
/******/ Object.defineProperty(exports, '__esModule', { value: true });
/******/ };
/******/
/******/ // create a fake namespace object
/******/ // mode & 1: value is a module id, require it
/******/ // mode & 2: merge all properties of value into the ns
/******/ // mode & 4: return value when already ns object
/******/ // mode & 8|1: behave like require
/******/ __webpack_require__.t = function(value, mode) {
/******/ if(mode & 1) value = __webpack_require__(value);
/******/ if(mode & 8) return value;
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ var ns = Object.create(null);
/******/ __webpack_require__.r(ns);
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ return ns;
/******/ };
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = 7);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var defaultsDocument = null;
var previousTableState;
var tableState = null;
exports.globalDefaults = {};
exports.documentDefaults = {};
function default_1() {
return tableState;
}
exports.default = default_1;
function getGlobalOptions() {
return exports.globalDefaults;
}
exports.getGlobalOptions = getGlobalOptions;
function getDocumentOptions() {
return exports.documentDefaults;
}
exports.getDocumentOptions = getDocumentOptions;
var TableState = /** @class */ (function () {
function TableState(doc) {
this.doc = doc;
}
TableState.prototype.pageHeight = function () {
return this.pageSize().height;
};
;
TableState.prototype.pageWidth = function () {
return this.pageSize().width;
};
;
TableState.prototype.pageSize = function () {
var pageSize = this.doc.internal.pageSize;
// JSPDF 1.4 uses get functions instead of properties on pageSize
if (pageSize.width == null) {
pageSize = {
width: pageSize.getWidth(),
height: pageSize.getHeight()
};
}
return pageSize;
};
;
TableState.prototype.scaleFactor = function () {
return this.doc.internal.scaleFactor;
};
;
TableState.prototype.pageNumber = function () {
var pageInfo = this.doc.internal.getCurrentPageInfo();
if (!pageInfo) {
// Only recent versions of jspdf has pageInfo
return this.doc.internal.getNumberOfPages();
}
return pageInfo.pageNumber;
};
return TableState;
}());
function setupState(doc) {
previousTableState = tableState;
tableState = new TableState(doc);
if (doc !== defaultsDocument) {
defaultsDocument = doc;
exports.documentDefaults = {};
}
}
exports.setupState = setupState;
function resetState() {
tableState = previousTableState;
}
exports.resetState = resetState;
function setDefaults(defaults, doc) {
if (doc === void 0) { doc = null; }
if (doc) {
exports.documentDefaults = defaults || {};
defaultsDocument = doc;
}
else {
exports.globalDefaults = defaults || {};
}
}
exports.setDefaults = setDefaults;
/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var config_1 = __webpack_require__(2);
var state_1 = __webpack_require__(0);
var polyfills_1 = __webpack_require__(3);
function getStringWidth(text, styles) {
var fontSize = styles.fontSize / state_1.default().scaleFactor();
applyStyles(styles);
text = Array.isArray(text) ? text : [text];
var maxWidth = 0;
text.forEach(function (line) {
var width = state_1.default().doc.getStringUnitWidth(line);
if (width > maxWidth) {
maxWidth = width;
}
});
var precision = 10000 * state_1.default().scaleFactor();
maxWidth = Math.floor(maxWidth * precision) / precision;
return maxWidth * fontSize;
}
exports.getStringWidth = getStringWidth;
/**
* Ellipsize the text to fit in the width
*/
function ellipsize(text, width, styles, ellipsizeStr) {
if (ellipsizeStr === void 0) { ellipsizeStr = '...'; }
if (Array.isArray(text)) {
var value_1 = [];
text.forEach(function (str, i) {
value_1[i] = ellipsize(str, width, styles, ellipsizeStr);
});
return value_1;
}
var precision = 10000 * state_1.default().scaleFactor();
width = Math.ceil(width * precision) / precision;
if (width >= getStringWidth(text, styles)) {
return text;
}
while (width < getStringWidth(text + ellipsizeStr, styles)) {
if (text.length <= 1) {
break;
}
text = text.substring(0, text.length - 1);
}
return text.trim() + ellipsizeStr;
}
exports.ellipsize = ellipsize;
function addTableBorder() {
var table = state_1.default().table;
var styles = { lineWidth: table.settings.tableLineWidth, lineColor: table.settings.tableLineColor };
applyStyles(styles);
var fs = getFillStyle(styles);
if (fs) {
state_1.default().doc.rect(table.pageStartX, table.pageStartY, table.width, table.cursor.y - table.pageStartY, fs);
}
}
exports.addTableBorder = addTableBorder;
function getFillStyle(styles) {
var drawLine = styles.lineWidth > 0;
var drawBackground = styles.fillColor || styles.fillColor === 0;
if (drawLine && drawBackground) {
return 'DF'; // Fill then stroke
}
else if (drawLine) {
return 'S'; // Only stroke (transparent background)
}
else if (drawBackground) {
return 'F'; // Only fill, no stroke
}
else {
return false;
}
}
exports.getFillStyle = getFillStyle;
function applyUserStyles() {
applyStyles(state_1.default().table.userStyles);
}
exports.applyUserStyles = applyUserStyles;
function applyStyles(styles) {
var doc = state_1.default().doc;
var styleModifiers = {
fillColor: doc.setFillColor,
textColor: doc.setTextColor,
fontStyle: doc.setFontStyle,
lineColor: doc.setDrawColor,
lineWidth: doc.setLineWidth,
font: doc.setFont,
fontSize: doc.setFontSize
};
Object.keys(styleModifiers).forEach(function (name) {
var style = styles[name];
var modifier = styleModifiers[name];
if (typeof style !== 'undefined') {
if (Array.isArray(style)) {
modifier.apply(this, style);
}
else {
modifier(style);
}
}
});
}
exports.applyStyles = applyStyles;
// This is messy, only keep array and number format the next major version
function marginOrPadding(value, defaultValue) {
var newValue = {};
if (Array.isArray(value)) {
if (value.length >= 4) {
newValue = { 'top': value[0], 'right': value[1], 'bottom': value[2], 'left': value[3] };
}
else if (value.length === 3) {
newValue = { 'top': value[0], 'right': value[1], 'bottom': value[2], 'left': value[1] };
}
else if (value.length === 2) {
newValue = { 'top': value[0], 'right': value[1], 'bottom': value[0], 'left': value[1] };
}
else if (value.length === 1) {
value = value[0];
}
else {
value = defaultValue;
}
}
else if (typeof value === 'object') {
if (value['vertical']) {
value['top'] = value['vertical'];
value['bottom'] = value['vertical'];
}
if (value['horizontal']) {
value['right'] = value['horizontal'];
value['left'] = value['horizontal'];
}
for (var _i = 0, _a = ['top', 'right', 'bottom', 'left']; _i < _a.length; _i++) {
var side = _a[_i];
newValue[side] = (value[side] || value[side] === 0) ? value[side] : defaultValue;
}
}
if (typeof value === 'number') {
newValue = { 'top': value, 'right': value, 'bottom': value, 'left': value };
}
return newValue;
}
exports.marginOrPadding = marginOrPadding;
function styles(styles) {
styles = Array.isArray(styles) ? styles : [styles];
return polyfills_1.assign.apply(void 0, [config_1.defaultStyles()].concat(styles));
}
exports.styles = styles;
/***/ }),
/* 2 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
/**
* Ratio between font size and font height. The number comes from jspdf's source code
*/
exports.FONT_ROW_RATIO = 1.15;
var state_1 = __webpack_require__(0);
function defaultConfig() {
return {
// Html content
html: null,
// Custom content
head: null,
body: null,
foot: null,
// Properties
includeHiddenHtml: false,
startY: null,
margin: 40 / state_1.default().scaleFactor(),
pageBreak: 'auto',
rowPageBreak: 'auto',
tableWidth: 'auto',
showHead: 'everyPage',
showFoot: 'everyPage',
tableLineWidth: 0,
tableLineColor: 200,
tableId: null,
// Styling
theme: 'striped',
useCss: false,
styles: {},
headStyles: {},
bodyStyles: {},
footStyles: {},
alternateRowStyles: {},
columnStyles: {},
// Hooks
// Use to change the content of the cell before width calculations etc are performed
didParseCell: function (data) {
},
willDrawCell: function (data) {
},
// Use to draw additional content such as images in table cells
didDrawCell: function (data) {
},
// Use to draw additional content to each page such as headers and footers
didDrawPage: function (data) {
},
};
}
exports.defaultConfig = defaultConfig;
// Base style for all themes
function defaultStyles() {
return {
font: "helvetica",
fontStyle: 'normal',
overflow: 'linebreak',
fillColor: false,
textColor: 20,
halign: 'left',
valign: 'top',
fontSize: 10,
cellPadding: 5 / state_1.default().scaleFactor(),
lineColor: 200,
lineWidth: 0 / state_1.default().scaleFactor(),
cellWidth: 'auto',
minCellHeight: 0
};
}
exports.defaultStyles = defaultStyles;
/**
* Styles for the themes (overriding the default styles)
*/
function getTheme(name) {
var themes = {
'striped': {
table: { fillColor: 255, textColor: 80, fontStyle: 'normal' },
head: { textColor: 255, fillColor: [41, 128, 185], fontStyle: 'bold' },
body: {},
foot: { textColor: 255, fillColor: [41, 128, 185], fontStyle: 'bold' },
alternateRow: { fillColor: 245 }
},
'grid': {
table: { fillColor: 255, textColor: 80, fontStyle: 'normal', lineWidth: 0.1 },
head: { textColor: 255, fillColor: [26, 188, 156], fontStyle: 'bold', lineWidth: 0 },
body: {},
foot: { textColor: 255, fillColor: [26, 188, 156], fontStyle: 'bold', lineWidth: 0 },
alternateRow: {}
},
'plain': {
head: { fontStyle: 'bold' },
foot: { fontStyle: 'bold' }
}
};
return themes[name];
}
exports.getTheme = getTheme;
/***/ }),
/* 3 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/*
* Include common small polyfills instead of requiring the user to to do it
*/
Object.defineProperty(exports, "__esModule", { value: true });
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
function assign(target) {
'use strict';
var varArgs = [];
for (var _i = 1; _i < arguments.length; _i++) {
varArgs[_i - 1] = arguments[_i];
}
if (target == null) { // TypeError if undefined or null
throw new TypeError('Cannot convert undefined or null to object');
}
var to = Object(target);
for (var index = 1; index < arguments.length; index++) {
var nextSource = arguments[index];
if (nextSource != null) { // Skip over if undefined or null
for (var nextKey in nextSource) {
// Avoid bugs when hasOwnProperty is shadowed
if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
to[nextKey] = nextSource[nextKey];
}
}
}
}
return to;
}
exports.assign = assign;
/***/ }),
/* 4 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var config_1 = __webpack_require__(2);
var state_1 = __webpack_require__(0);
var HookData_1 = __webpack_require__(9);
var common_1 = __webpack_require__(1);
var assign = __webpack_require__(5);
var CellHooks = /** @class */ (function () {
function CellHooks() {
this.didParseCell = [];
this.willDrawCell = [];
this.didDrawCell = [];
this.didDrawPage = [];
}
return CellHooks;
}());
var Table = /** @class */ (function () {
function Table() {
this.columns = [];
this.head = [];
this.body = [];
this.foot = [];
this.height = 0;
this.width = 0;
this.preferredWidth = 0;
this.wrappedWidth = 0;
this.minWidth = 0;
this.headHeight = 0;
this.footHeight = 0;
this.startPageNumber = 1;
this.pageNumber = 1;
this.styles = {
styles: {},
headStyles: {},
bodyStyles: {},
footStyles: {},
alternateRowStyles: {},
columnStyles: {},
};
this.cellHooks = new CellHooks();
}
Object.defineProperty(Table.prototype, "pageCount", {
get: function () {
return this.pageNumber;
},
enumerable: true,
configurable: true
});
Table.prototype.allRows = function () {
return this.head.concat(this.body).concat(this.foot);
};
Table.prototype.callCellHooks = function (handlers, cell, row, column) {
for (var _i = 0, handlers_1 = handlers; _i < handlers_1.length; _i++) {
var handler = handlers_1[_i];
if (handler(new HookData_1.CellHookData(cell, row, column)) === false) {
return false;
}
}
return true;
};
Table.prototype.callEndPageHooks = function () {
common_1.applyUserStyles();
for (var _i = 0, _a = this.cellHooks.didDrawPage; _i < _a.length; _i++) {
var handler = _a[_i];
handler(new HookData_1.HookData());
}
};
Table.prototype.margin = function (side) {
return common_1.marginOrPadding(this.settings.margin, config_1.defaultConfig().margin)[side];
};
return Table;
}());
exports.Table = Table;
var Row = /** @class */ (function () {
function Row(raw, index, section) {
this.cells = {};
this.height = 0;
this.maxCellLineCount = 1;
this.maxCellHeight = 0;
this.pageNumber = 1;
this.spansMultiplePages = false;
this.raw = raw;
if (raw._element) {
this.raw = raw._element;
}
this.index = index;
this.section = section;
}
Object.defineProperty(Row.prototype, "pageCount", {
get: function () {
return this.pageNumber;
},
enumerable: true,
configurable: true
});
return Row;
}());
exports.Row = Row;
var Cell = /** @class */ (function () {
function Cell(raw, themeStyles, section) {
this.contentWidth = 0;
this.wrappedWidth = 0;
this.minWidth = 0;
this.textPos = {};
this.height = 0;
this.width = 0;
this.rowSpan = raw && raw.rowSpan || 1;
this.colSpan = raw && raw.colSpan || 1;
this.styles = assign(themeStyles, raw && raw.styles || {});
this.section = section;
var text;
var content = raw && raw.content != null ? raw.content : raw;
content = content && content.title != null ? content.title : content;
this.raw = raw && raw._element ? raw._element : raw;
// Stringify 0 and false, but not undefined or null
text = content != null ? '' + content : '';
var splitRegex = /\r\n|\r|\n/g;
this.text = text.split(splitRegex);
this.contentWidth = this.padding('horizontal') + common_1.getStringWidth(this.text, this.styles);
if (typeof this.styles.cellWidth === 'number') {
this.minWidth = this.styles.cellWidth;
this.wrappedWidth = this.styles.cellWidth;
}
else if (this.styles.cellWidth === 'wrap') {
this.minWidth = this.contentWidth;
this.wrappedWidth = this.contentWidth;
}
else { // auto
var defaultMinWidth = 10 / state_1.default().scaleFactor();
this.minWidth = this.styles.minCellWidth || defaultMinWidth;
this.wrappedWidth = this.contentWidth;
if (this.minWidth > this.wrappedWidth) {
this.wrappedWidth = this.minWidth;
}
}
}
Cell.prototype.padding = function (name) {
var padding = common_1.marginOrPadding(this.styles.cellPadding, common_1.styles([]).cellPadding);
if (name === 'vertical') {
return padding.top + padding.bottom;
}
else if (name === 'horizontal') {
return padding.left + padding.right;
}
else {
return padding[name];
}
};
return Cell;
}());
exports.Cell = Cell;
var Column = /** @class */ (function () {
function Column(dataKey, raw, index) {
this.preferredWidth = 0;
this.minWidth = 0;
this.wrappedWidth = 0;
this.width = 0;
this.dataKey = dataKey;
this.raw = raw;
this.index = index;
}
return Column;
}());
exports.Column = Column;
/***/ }),
/* 5 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/*
object-assign
(c) Sindre Sorhus
@license MIT
*/
/* eslint-disable no-unused-vars */
var getOwnPropertySymbols = Object.getOwnPropertySymbols;
var hasOwnProperty = Object.prototype.hasOwnProperty;
var propIsEnumerable = Object.prototype.propertyIsEnumerable;
function toObject(val) {
if (val === null || val === undefined) {
throw new TypeError('Object.assign cannot be called with null or undefined');
}
return Object(val);
}
function shouldUseNative() {
try {
if (!Object.assign) {
return false;
}
// Detect buggy property enumeration order in older V8 versions.
// https://bugs.chromium.org/p/v8/issues/detail?id=4118
var test1 = new String('abc'); // eslint-disable-line no-new-wrappers
test1[5] = 'de';
if (Object.getOwnPropertyNames(test1)[0] === '5') {
return false;
}
// https://bugs.chromium.org/p/v8/issues/detail?id=3056
var test2 = {};
for (var i = 0; i < 10; i++) {
test2['_' + String.fromCharCode(i)] = i;
}
var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
return test2[n];
});
if (order2.join('') !== '0123456789') {
return false;
}
// https://bugs.chromium.org/p/v8/issues/detail?id=3056
var test3 = {};
'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
test3[letter] = letter;
});
if (Object.keys(Object.assign({}, test3)).join('') !==
'abcdefghijklmnopqrst') {
return false;
}
return true;
} catch (err) {
// We don't expect any of the above to throw, but better to be safe.
return false;
}
}
module.exports = shouldUseNative() ? Object.assign : function (target, source) {
var from;
var to = toObject(target);
var symbols;
for (var s = 1; s < arguments.length; s++) {
from = Object(arguments[s]);
for (var key in from) {
if (hasOwnProperty.call(from, key)) {
to[key] = from[key];
}
}
if (getOwnPropertySymbols) {
symbols = getOwnPropertySymbols(from);
for (var i = 0; i < symbols.length; i++) {
if (propIsEnumerable.call(from, symbols[i])) {
to[symbols[i]] = from[symbols[i]];
}
}
}
}
return to;
};
/***/ }),
/* 6 */
/***/ (function(module, exports) {
module.exports = __WEBPACK_EXTERNAL_MODULE__6__;
/***/ }),
/* 7 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var tableDrawer_1 = __webpack_require__(8);
var widthCalculator_1 = __webpack_require__(10);
var inputParser_1 = __webpack_require__(11);
var state_1 = __webpack_require__(0);
__webpack_require__(15);
var common_1 = __webpack_require__(1);
var jsPDF = __webpack_require__(6);
function autoTable() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
state_1.setupState(this);
// 1. Parse and unify user input
var table = inputParser_1.parseInput(args);
// 2. Calculate preliminary table, column, row and cell dimensions
widthCalculator_1.calculateWidths(table);
// 3. Output table to pdf
tableDrawer_1.drawTable(table);
table.finalY = table.cursor.y;
this.previousAutoTable = table;
this.lastAutoTable = table;
this.autoTable.previous = table; // Deprecated
common_1.applyUserStyles();
state_1.resetState();
return this;
}
jsPDF.API.autoTable = autoTable;
// Assign false to enable `doc.lastAutoTable.finalY || 40` sugar;
jsPDF.API.lastAutoTable = false;
jsPDF.API.previousAutoTable = false; // deprecated in v3
jsPDF.API.autoTable.previous = false; // deprecated in v3
jsPDF.API.autoTableSetDefaults = function (defaults) {
state_1.setDefaults(defaults, this);
return this;
};
jsPDF.autoTableSetDefaults = function (defaults, doc) {
state_1.setDefaults(defaults, doc);
return this;
};
jsPDF.API.autoTableHtmlToJson = function (tableElem, includeHiddenElements) {
includeHiddenElements = includeHiddenElements || false;
if (!tableElem || !(tableElem instanceof HTMLTableElement)) {
console.error("A HTMLTableElement has to be sent to autoTableHtmlToJson");
return null;
}
var columns = {}, rows = [];
var header = tableElem.rows[0];
for (var i = 0; i < header.cells.length; i++) {
var cell = header.cells[i];
var style = window.getComputedStyle(cell);
if (includeHiddenElements || style.display !== 'none') {
columns[i] = cell;
}
}
var _loop_1 = function (i) {
var tableRow = tableElem.rows[i];
var style = window.getComputedStyle(tableRow);
if (includeHiddenElements || style.display !== 'none') {
var rowData_1 = [];
Object.keys(columns).forEach(function (key) {
var cell = tableRow.cells[key];
rowData_1.push(cell);
});
rows.push(rowData_1);
}
};
for (var i = 1; i < tableElem.rows.length; i++) {
_loop_1(i);
}
var values = Object.keys(columns).map(function (key) {
return columns[key];
});
return { columns: values, rows: rows, data: rows };
};
/**
* @deprecated
*/
jsPDF.API.autoTableEndPosY = function () {
console.error("Use of deprecated function: autoTableEndPosY. Use doc.previousAutoTable.finalY instead.");
var prev = this.previousAutoTable;
if (prev.cursor && typeof prev.cursor.y === 'number') {
return prev.cursor.y;
}
else {
return 0;
}
};
/**
* @deprecated
*/
jsPDF.API.autoTableAddPageContent = function (hook) {
console.error("Use of deprecated function: autoTableAddPageContent. Use jsPDF.autoTableSetDefaults({didDrawPage: () => {}}) instead.");
if (!jsPDF.API.autoTable.globalDefaults) {
jsPDF.API.autoTable.globalDefaults = {};
}
jsPDF.API.autoTable.globalDefaults.addPageContent = hook;
return this;
};
/**
* @deprecated
*/
jsPDF.API.autoTableAddPage = function () {
console.error("Use of deprecated function: autoTableAddPage. Use doc.addPage()");
this.addPage();
return this;
};
/***/ }),
/* 8 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var config_1 = __webpack_require__(2);
var common_1 = __webpack_require__(1);
var models_1 = __webpack_require__(4);
var state_1 = __webpack_require__(0);
var assign = __webpack_require__(5);
function drawTable(table) {
var settings = table.settings;
table.cursor = {
x: table.margin('left'),
y: settings.startY == null ? table.margin('top') : settings.startY
};
var minTableBottomPos = settings.startY + table.margin('bottom') + table.headHeight + table.footHeight;
if (settings.pageBreak === 'avoid') {
minTableBottomPos += table.height;
}
if (settings.pageBreak === 'always' || settings.startY != null && settings.startY !== false && minTableBottomPos > state_1.default().pageHeight()) {
nextPage(state_1.default().doc);
table.cursor.y = table.margin('top');
}
table.pageStartX = table.cursor.x;
table.pageStartY = table.cursor.y;
table.startPageNumber = state_1.default().pageNumber();
// a empty row used to cached cells those break through page
var cachedBreakPageRow = new models_1.Row([], 0, 'body');
cachedBreakPageRow.index = -1;
common_1.applyUserStyles();
if (settings.showHead === true || settings.showHead === 'firstPage' || settings.showHead === 'everyPage') {
table.head.forEach(function (row) { return printRow(row); });
}
common_1.applyUserStyles();
table.body.forEach(function (row, index) {
printFullRow(row, index === table.body.length - 1, cachedBreakPageRow);
});
common_1.applyUserStyles();
if (settings.showFoot === true || settings.showFoot === 'lastPage' || settings.showFoot === 'everyPage') {
table.foot.forEach(function (row) { return printRow(row); });
}
common_1.addTableBorder();
table.callEndPageHooks();
}
exports.drawTable = drawTable;
function printFullRow(row, isLastRow, cachedBreakPageRow) {
var remainingTexts = {};
var table = state_1.default().table;
var remainingPageSpace = getRemainingPageSpace(isLastRow);
if (remainingPageSpace < row.maxCellHeight) {
if (remainingPageSpace < getOneRowHeight(row) || (table.settings.rowPageBreak === 'avoid' && !rowHeightGreaterThanMaxTableHeight(row))) {
addPage(cachedBreakPageRow);
}
else {
// Modify the row to fit the current page and calculate text and height of partial row
row.spansMultiplePages = true;
for (var j = 0; j < table.columns.length; j++) {
var column = table.columns[j];
var cell = row.cells[column.index];
if (!cell) {
continue;
}
var fontHeight = cell.styles.fontSize / state_1.default().scaleFactor() * config_1.FONT_ROW_RATIO;
var vPadding = cell.padding('vertical');
var remainingLineCount = Math.floor((remainingPageSpace - vPadding) / fontHeight);
// Note that this will cut cells with specified custom min height at page break
if (Array.isArray(cell.text) && cell.text.length > remainingLineCount) {
remainingTexts[column.index] = cell.text.splice(remainingLineCount, cell.text.length);
var actualHeight = Math.floor(cell.text.length * fontHeight);
if (cell.rowSpan === 1) {
row.height = Math.min(row.height, actualHeight);
}
var newCell = new models_1.Cell(cell, cell.styles, cell.section);
newCell.height = cell.height;
newCell.width = cell.width;
newCell.text = remainingTexts[column.index];
cachedBreakPageRow.cells[column.index] = newCell;
}
else if (cell.height > remainingPageSpace) {
// this cell has rowspan and it will break through page
// cache the cell so that border can be printed in next page
var cachedCell = new models_1.Cell(cell, cell.styles, cell.section);
cachedCell.height = cell.height;
cachedCell.width = cell.width;
cachedCell.text = [];
cachedBreakPageRow.cells[column.index] = cachedCell;
}
cell.height = Math.min(remainingPageSpace, cell.height);
}
}
}
printRow(row);
if (cachedBreakPageRow && !(Object.keys(cachedBreakPageRow.cells).length === 0)) {
// calculate remaining height of rowspan cell
Object.keys(cachedBreakPageRow.cells).forEach(function (key) {
cachedBreakPageRow.cells[key].height -= row.height;
});
}
}
function getOneRowHeight(row) {
return state_1.default().table.columns.reduce(function (acc, column) {
var cell = row.cells[column.index];
if (!cell)
return 0;
var fontHeight = cell.styles.fontSize / state_1.default().scaleFactor() * config_1.FONT_ROW_RATIO;
var vPadding = cell.padding('vertical');
var oneRowHeight = vPadding + fontHeight;
return oneRowHeight > acc ? oneRowHeight : acc;
}, 0);
}
function rowHeightGreaterThanMaxTableHeight(row) {
var table = state_1.default().table;
var pageHeight = state_1.default().pageHeight();
var maxTableHeight = pageHeight - table.margin('top') - table.margin('bottom');
return row.maxCellHeight > maxTableHeight;
}
function printRow(row) {
var table = state_1.default().table;
table.cursor.x = table.margin('left');
row.y = table.cursor.y;
row.x = table.cursor.x;
// For backwards compatibility reset those after addingRow event
table.cursor.x = table.margin('left');
row.y = table.cursor.y;
row.x = table.cursor.x;
for (var _i = 0, _a = table.columns; _i < _a.length; _i++) {
var column = _a[_i];
var cell = row.cells[column.index];
if (!cell) {
table.cursor.x += column.width;
continue;
}
common_1.applyStyles(cell.styles);
cell.x = table.cursor.x;
cell.y = row.y;
if (cell.styles.valign === 'top') {
cell.textPos.y = table.cursor.y + cell.padding('top');
}
else if (cell.styles.valign === 'bottom') {
cell.textPos.y = table.cursor.y + cell.height - cell.padding('bottom');
}
else {
cell.textPos.y = table.cursor.y + cell.height / 2;
}
if (cell.styles.halign === 'right') {
cell.textPos.x = cell.x + cell.width - cell.padding('right');
}
else if (cell.styles.halign === 'center') {
cell.textPos.x = cell.x + cell.width / 2;
}
else {
cell.textPos.x = cell.x + cell.padding('left');
}
if (table.callCellHooks(table.cellHooks.willDrawCell, cell, row, column) === false) {
table.cursor.x += column.width;
continue;
}
var fillStyle = common_1.getFillStyle(cell.styles);
if (fillStyle) {
state_1.default().doc.rect(cell.x, table.cursor.y, cell.width, cell.height, fillStyle);
}
state_1.default().doc.autoTableText(cell.text, cell.textPos.x, cell.textPos.y, {
halign: cell.styles.halign,
valign: cell.styles.valign,
maxWidth: cell.width - cell.padding('left') - cell.padding('right')
});
table.callCellHooks(table.cellHooks.didDrawCell, cell, row, column);
table.cursor.x += column.width;
}
table.cursor.y += row.height;
}
function getRemainingPageSpace(isLastRow) {
var table = state_1.default().table;
var bottomContentHeight = table.margin('bottom');
var showFoot = table.settings.showFoot;
if (showFoot === true || showFoot === 'everyPage' || (showFoot === 'lastPage' && isLastRow)) {
bottomContentHeight += table.footHeight;
}
return state_1.default().pageHeight() - table.cursor.y - bottomContentHeight;
}
function addPage(cachedBreakPageRow) {
var table = state_1.default().table;
common_1.applyUserStyles();
if (table.settings.showFoot === true || table.settings.showFoot === 'everyPage') {
table.foot.forEach(function (row) { return printRow(row); });
}
table.finalY = table.cursor.y;
// Add user content just before adding new page ensure it will
// be drawn above other things on the page
table.callEndPageHooks();
common_1.addTableBorder();
nextPage(state_1.default().doc);
table.pageNumber++;
table.cursor = { x: table.margin('left'), y: table.margin('top') };
table.pageStartX = table.cursor.x;
table.pageStartY = table.cursor.y;
if (table.settings.showHead === true || table.settings.showHead === 'everyPage') {
table.head.forEach(function (row) { return printRow(row); });
}
if (cachedBreakPageRow && !(Object.keys(cachedBreakPageRow.cells).length === 0)) {
// when there is a cached row, print it firstly
var cloneCachedRow_1 = assign({}, cachedBreakPageRow);
cloneCachedRow_1.height = 0;
Object.keys(cachedBreakPageRow.cells).forEach(function (key) {
// recalculate maxCellHeight
if (cloneCachedRow_1.maxCellHeight < cachedBreakPageRow.cells[key].height) {
cloneCachedRow_1.maxCellHeight = cachedBreakPageRow.cells[key].height;
}
if (cachedBreakPageRow.cells[key].rowSpan > 1)
return;
// cachedRow height should be equal to the height of non-spanning cells
cloneCachedRow_1.height = cachedBreakPageRow.cells[key].height;
});
cachedBreakPageRow.cells = {};
printFullRow(cloneCachedRow_1, false, cachedBreakPageRow);
}
}
exports.addPage = addPage;
function nextPage(doc) {
var current = state_1.default().pageNumber();
doc.setPage(current + 1);
var newCurrent = state_1.default().pageNumber();
if (newCurrent === current) {
doc.addPage();
}
}
/***/ }),
/* 9 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var state_1 = __webpack_require__(0);
var HookData = /** @class */ (function () {
function HookData() {
var table = state_1.default().table;
this.table = table;
this.pageNumber = table.pageNumber;
this.settings = table.settings;
this.cursor = table.cursor;
this.doc = state_1.default().doc;
}
Object.defineProperty(HookData.prototype, "pageCount", {
get: function () {
return this.pageNumber;
},
enumerable: true,
configurable: true
});
return HookData;
}());
exports.HookData = HookData;
var CellHookData = /** @class */ (function (_super) {
__extends(CellHookData, _super);
function CellHookData(cell, row, column) {
var _this = _super.call(this) || this;
_this.cell = cell;
_this.row = row;
_this.column = column;
_this.section = row.section;
return _this;
}
return CellHookData;
}(HookData));
exports.CellHookData = CellHookData;
/***/ }),
/* 10 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var config_1 = __webpack_require__(2);
var common_1 = __webpack_require__(1);
var state_1 = __webpack_require__(0);
/**
* Calculate the column widths
*/
function calculateWidths(table) {
// TODO Handle these cases
var columnMinWidth = 10 / state_1.default().scaleFactor();
if (columnMinWidth * table.columns.length > table.width) {
console.error('Columns could not fit on page');
}
else if (table.minWidth > table.width) {
console.error("Column widths to wide and can't fit page");
}
var copy = table.columns.slice(0);
var diffWidth = table.width - table.wrappedWidth;
distributeWidth(copy, diffWidth, table.wrappedWidth);
applyColSpans(table);
fitContent(table);
applyRowSpans(table);
}
exports.calculateWidths = calculateWidths;
function applyRowSpans(table) {
var rowSpanCells = {};
var colRowSpansLeft = 1;
var all = table.allRows();
for (var rowIndex = 0; rowIndex < all.length; rowIndex++) {
var row = all[rowIndex];
for (var _i = 0, _a = table.columns; _i < _a.length; _i++) {
var column = _a[_i];
var data = rowSpanCells[column.index];
if (colRowSpansLeft > 1) {
colRowSpansLeft--;
delete row.cells[column.index];
}
else if (data) {
data.cell.height += row.height;
if (data.cell.height > row.maxCellHeight) {
data.row.maxCellHeight = data.cell.height;
data.row.maxCellLineCount = Array.isArray(data.cell.text) ? data.cell.text.length : 1;
}
colRowSpansLeft = data.cell.colSpan;
delete row.cells[column.index];
data.left--;
if (data.left <= 1) {
delete rowSpanCells[column.index];
}
}
else {
var cell = row.cells[column.index];
if (!cell) {
continue;
}
cell.height = row.height;
if (cell.rowSpan > 1) {
var remaining = all.length - rowIndex;
var left = cell.rowSpan > remaining ? remaining : cell.rowSpan;
rowSpanCells[column.index] = { cell: cell, left: left, row: row };
}
}
}
if (row.section === 'head') {
table.headHeight += row.maxCellHeight;
}
if (row.section === 'foot') {
table.footHeight += row.maxCellHeight;
}
table.height += row.height;
}
}
function applyColSpans(table) {
var all = table.allRows();
for (var rowIndex = 0; rowIndex < all.length; rowIndex++) {
var row = all[rowIndex];
var colSpanCell = null;
var combinedColSpanWidth = 0;
var colSpansLeft = 0;
for (var columnIndex = 0; columnIndex < table.columns.length; columnIndex++) {
var column = table.columns[columnIndex];
var cell = null;
// Width and colspan
colSpansLeft -= 1;
if (colSpansLeft > 1 && table.columns[columnIndex + 1]) {
combinedColSpanWidth += column.width;
delete row.cells[column.index];
continue;
}
else if (colSpanCell) {
cell = colSpanCell;
delete row.cells[column.index];
colSpanCell = null;
}
else {
cell = row.cells[column.index];
if (!cell)
continue;
colSpansLeft = cell.colSpan;
combinedColSpanWidth = 0;
if (cell.colSpan > 1) {
colSpanCell = cell;
combinedColSpanWidth += column.width;
continue;
}
}
cell.width = column.width + combinedColSpanWidth;
}
}
}
function fitContent(table) {
var rowSpanHeight = { count: 0, height: 0 };
for (var _i = 0, _a = table.allRows(); _i < _a.length; _i++) {
var row = _a[_i];
for (var _b = 0, _c = table.columns; _b < _c.length; _b++) {
var column = _c[_b];
var cell = row.cells[column.index];
if (!cell)
continue;
common_1.applyStyles(cell.styles);
var textSpace = cell.width - cell.padding('horizontal');
if (cell.styles.overflow === 'linebreak') {
// Add one pt to textSpace to fix rounding error
cell.text = state_1.default().doc.splitTextToSize(cell.text, textSpace + 1 / (state_1.default().scaleFactor() || 1), { fontSize: cell.styles.fontSize });
}
else if (cell.styles.overflow === 'ellipsize') {
cell.text = common_1.ellipsize(cell.text, textSpace, cell.styles);
}
else if (cell.styles.overflow === 'hidden') {
cell.text = common_1.ellipsize(cell.text, textSpace, cell.styles, '');
}
else if (typeof cell.styles.overflow === 'function') {
cell.text = cell.styles.overflow(cell.text, textSpace);
}
var lineCount = Array.isArray(cell.text) ? cell.text.length : 1;
var fontHeight = cell.styles.fontSize / state_1.default().scaleFactor() * config_1.FONT_ROW_RATIO;
cell.contentHeight = lineCount * fontHeight + cell.padding('vertical');
if (cell.styles.minCellHeight > cell.contentHeight) {
cell.contentHeight = cell.styles.minCellHeight;
}
var realContentHeight = cell.contentHeight / cell.rowSpan;
if (cell.rowSpan > 1 && (rowSpanHeight.count * rowSpanHeight.height < realContentHeight * cell.rowSpan)) {
rowSpanHeight = { height: realContentHeight, count: cell.rowSpan };
}
else if (rowSpanHeight && rowSpanHeight.count > 0) {
if (rowSpanHeight.height > realContentHeight) {
realContentHeight = rowSpanHeight.height;
}
}
if (realContentHeight > row.height) {
row.height = realContentHeight;
row.maxCellHeight = realContentHeight;
row.maxCellLineCount = lineCount;
}
}
rowSpanHeight.count--;
}
}
function distributeWidth(autoColumns, diffWidth, wrappedAutoColumnsWidth) {
for (var i = 0; i < autoColumns.length; i++) {
var column = autoColumns[i];
var ratio = column.wrappedWidth / wrappedAutoColumnsWidth;
var suggestedChange = diffWidth * ratio;
var suggestedWidth = column.wrappedWidth + suggestedChange;
if (suggestedWidth >= column.minWidth) {
column.width = suggestedWidth;
}
else {
// We can't reduce the width of this column. Mark as none auto column and start over
// Add 1 to minWidth as linebreaks calc otherwise sometimes made two rows
column.width = column.minWidth + 1 / state_1.default().scaleFactor();
wrappedAutoColumnsWidth -= column.wrappedWidth;
autoColumns.splice(i, 1);
distributeWidth(autoColumns, diffWidth, wrappedAutoColumnsWidth);
break;
}
}
}
/***/ }),
/* 11 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var models_1 = __webpack_require__(4);
var config_1 = __webpack_require__(2);
var htmlParser_1 = __webpack_require__(12);
var polyfills_1 = __webpack_require__(3);
var common_1 = __webpack_require__(1);
var state_1 = __webpack_require__(0);
var inputValidator_1 = __webpack_require__(14);
/**
* Create models from the user input
*/
function parseInput(args) {
var tableOptions = parseUserArguments(args);
var globalOptions = state_1.getGlobalOptions();
var documentOptions = state_1.getDocumentOptions();
var allOptions = [globalOptions, documentOptions, tableOptions];
inputValidator_1.default(allOptions);
var table = new models_1.Table();
state_1.default().table = table;
table.id = tableOptions.tableId;
var doc = state_1.default().doc;
table.userStyles = {
// Setting to black for versions of jspdf without getTextColor
textColor: doc.getTextColor ? doc.getTextColor() : 0,
fontSize: doc.internal.getFontSize(),
fontStyle: doc.internal.getFont().fontStyle,
font: doc.internal.getFont().fontName
};
var _loop_1 = function (styleProp) {
var styles = allOptions.map(function (opts) { return opts[styleProp] || {}; });
table.styles[styleProp] = polyfills_1.assign.apply(void 0, [{}].concat(styles));
};
// Merge styles one level deeper
for (var _i = 0, _a = Object.keys(table.styles); _i < _a.length; _i++) {
var styleProp = _a[_i];
_loop_1(styleProp);
}
// Append hooks
for (var _b = 0, allOptions_1 = allOptions; _b < allOptions_1.length; _b++) {
var opts = allOptions_1[_b];
for (var _c = 0, _d = Object.keys(table.cellHooks); _c < _d.length; _c++) {
var hookName = _d[_c];
if (opts && typeof opts[hookName] === 'function') {
table.cellHooks[hookName].push(opts[hookName]);
}
}
}
table.settings = polyfills_1.assign.apply(void 0, [{}, config_1.defaultConfig()].concat(allOptions));
table.settings.margin = common_1.marginOrPadding(table.settings.margin, config_1.defaultConfig().margin);
if (table.settings.theme === 'auto') {
table.settings.theme = table.settings.useCss ? 'plain' : 'striped';
}
if (table.settings.startY === false) {
delete table.settings.startY;
}
var previous = state_1.defau