@refinitiv-ui/efx-grid 0.0.0-dev.12023565035.1

package/lib/tr-grid-printer/es6/GridPrinter.js

@@ -0,0 +1,794 @@
+import { Dom } from "../../tr-grid-util/es6/Dom.js";
+import { injectCss, prettifyCss } from "../../tr-grid-util/es6/Util.js";
+import { Table } from "../../tr-grid-util/es6/Table.js";
+
+import { PrintTrait } from "./PrintTrait.js";
+import { SectionWriter } from "./SectionWriter.js";
+
+
+/** @private
+* @type {Node}
+*/
+let _dummyNode = null;
+
+
+/** TODO: Move this logic to PrintTrait
+* @private
+* @param {Object=} options
+* @return {!Object}
+*/
+let _getPageSize = function (options) {
+	let pageWidth = 0;
+	let pageHeight = 0;
+
+	if (options) {
+		if (options["pageWidth"]) {
+			pageWidth = options["pageWidth"];
+		}
+		if (options["pageHeight"]) {
+			pageHeight = options["pageHeight"];
+		}
+	}
+	if (!pageWidth) {
+		pageWidth = Math.max(document.documentElement.clientWidth, window.innerWidth || 0);
+	}
+	if (!pageHeight) {
+		pageHeight = Math.max(document.documentElement.clientHeight, window.innerHeight || 0);
+	}
+
+	// TODO: Subtract page margins
+	pageWidth -= 2; // HACK: Prevent chrome from populating table incorrectly
+	pageHeight -= 10; // HACK: Prevent chrome from populating table incorrectly
+
+	return {
+		"pageWidth": pageWidth,
+		"pageHeight": pageHeight
+	};
+};
+
+/** @private
+* @param {Node} nodeA
+* @param {Node} nodeB
+*/
+let swapNode = function (nodeA, nodeB) {
+	if (!nodeA || !nodeB || !nodeA.parentNode || !nodeB.parentNode) {
+		Dom.removeParent(nodeA);
+		Dom.removeParent(nodeB);
+		return;
+	}
+
+	if (!_dummyNode) {
+		_dummyNode = document.createElement("span");
+	}
+
+	nodeA.parentNode.replaceChild(_dummyNode, nodeA);
+	nodeB.parentNode.replaceChild(nodeA, nodeB);
+	_dummyNode.parentNode.replaceChild(nodeB, _dummyNode);
+};
+/** @private
+* @param {Node} fromNode
+* @param {Node} toNode
+*/
+let copyNode = function (fromNode, toNode) {
+	if (fromNode && toNode) {
+		let i, attrs;
+		if (toNode.hasAttributes()) {
+			attrs = toNode.attributes;
+			for (i = attrs.length; --i >= 0;) {
+				toNode.removeAttribute(attrs[i].name);
+			}
+		}
+
+		if (fromNode.hasAttributes()) {
+			attrs = fromNode.attributes;
+			for (i = attrs.length; --i >= 0;) {
+				toNode.setAttribute(attrs[i].name, attrs[i].value);
+			}
+		}
+
+		Dom.removeChildren(toNode);
+
+		let chdr = fromNode.childNodes;
+		let childCount = chdr.length;
+		for (i = 0; i < childCount; ++i) {
+			toNode.appendChild(chdr[i].cloneNode(true));
+		}
+	}
+};
+
+/** @private
+* @param {Table|SubTable} tbl
+* @param {number} colIndex
+* @param {string} alignment
+*/
+let _setColumnAlignment = function (tbl, colIndex, alignment) {
+	if (!alignment || alignment === "default") {
+		return;
+	}
+	let cells = tbl.getCellsInColumn(colIndex);
+	if (!cells) return;
+	for (let i = cells.length; --i >= 0;) {
+		let cell = cells[i];
+		cell.classList.add("tr-align-" + alignment);
+	}
+};
+
+/** @private
+* @param {*} grid grid element, currently supports atlas-blotter, ef-grid, tr.CompositeGrid, rt.Grid and Core
+* @return {Object} core grid
+*/
+let _getCoreGrid = function (grid) {
+	let core = null;
+	try {
+		if (grid.api) { // ef-grid or atlas-blotter
+			core = grid.api.getCoreGrid();
+		} else if (grid.getCoreGrid) { // tr.CompositeGrid or rt.Grid
+			core = grid.getCoreGrid();
+		} else if (grid.getPlugin) { // coreGrid
+			core = grid;
+		}
+		// TODO: support react/angular wrapper
+	} catch (err) {
+		console.log("Cannot print the given object");
+	}
+	return core;
+};
+
+/** @namespace
+*/
+let GridPrinter = {};
+/** @private
+* @type {string}
+*/
+GridPrinter._styles = ""; // Static variable
+/** @type {PrintTrait}
+* @private
+*/
+GridPrinter._printTrait = null;
+/** @type {Element}
+* @private
+*/
+GridPrinter._blankPage = null;
+/** @type {tr.Grid}
+* @private
+*/
+GridPrinter._grid = null;
+/** @type {boolean}
+* @private
+*/
+GridPrinter._manualObs = false;
+/** @type {!Object}
+* @private
+*/
+GridPrinter._options = {};
+
+/** @public
+* @param {GridPrinter.Options} options
+*/
+GridPrinter.setPrintOptions = function (options) {
+	if (options) {
+		GridPrinter._options = options;
+	} else {
+		GridPrinter._options = {};
+	}
+};
+
+/** @public
+* @param {HTMLIFrameElement=} iFrameElement If not specified, current window is used instead. Specify null to un-observe existing window object.
+*/
+GridPrinter.observe = function (iFrameElement) {
+	let pt = GridPrinter.getPrintTrait();
+	pt.observe(iFrameElement);
+	GridPrinter._manualObs = pt.isObserving();
+};
+/** @public
+*/
+GridPrinter.unobserve = function () {
+	let pt = GridPrinter.getPrintTrait();
+	pt.unobserve();
+	GridPrinter._manualObs = pt.isObserving();
+};
+/** @public
+* @param {boolean=} bool
+*/
+GridPrinter.enableDebugMode = function (bool) {
+	PrintTrait.DEBUG = bool !== false;
+};
+
+/** @public
+* @param {tr.Grid} grid
+* @param {Object=} options
+* @return {!Object}
+*/
+GridPrinter.getPreFlightInfo = function (grid, options) {
+	let pfInfo = options || {};
+	if (!pfInfo.pageCount) {
+		pfInfo.pageCount = 0;
+	}
+	if (!grid) {
+		return pfInfo;
+	}
+
+	let colCount = grid.getColumnCount();
+	if (!colCount) {
+		return pfInfo;
+	}
+	pfInfo._calculated = false;
+	if (GridPrinter._options["pageWidth"]) {
+		options.pageWidth = GridPrinter._options["pageWidth"];
+	}
+	if (GridPrinter._options["pageHeight"]) {
+		options.pageHeight = GridPrinter._options["pageHeight"];
+	}
+
+	let pageSize = _getPageSize(options);
+	let pageWidth = pfInfo.pageWidth = pageSize.pageWidth;
+	let pageHeight = pfInfo.pageHeight = pageSize.pageHeight;
+
+	// Find primary column that will exist in every page
+	let c;
+	let primaryColIndex = 0;
+	let identifierCol = GridPrinter._options["identifierField"] || GridPrinter._options["primaryColumn"];
+	// if(typeof identifierCol === "string") {
+	// for(c = 0; c < colCount; ++c) {
+	// if() {
+	// }
+	// }
+	// } else
+	if (typeof identifierCol === "number") {
+		primaryColIndex = identifierCol;
+	}
+
+	let primaryCol = pfInfo.primaryColumn = GridPrinter._newColInfo(grid, primaryColIndex);
+
+	// Collect properties from all visible columns
+	// Create a column set that fit the page width
+	// Create multiple column sets for single grid
+	let colSets = []; // Each set will fit a single page
+	let colSet, colInfo;
+	// let defaultMinWidth = 50; // WARNING: Hardcoded value
+	let availSpace = 0;
+	for (c = 0; c < colCount; ++c) {
+		if (c == primaryCol.index) {
+			continue;
+		}
+
+		let colVisible = grid.isColumnVisible(c);
+		if (!colVisible) {
+			continue;
+		}
+		colInfo = GridPrinter._newColInfo(grid, c);
+
+		availSpace -= colInfo.width;
+		if (availSpace <= 0 || !colSets.length) {
+			colSet = {
+				columns: []
+			};
+			colSet.columns.push(primaryCol); // Primary column must exist as the first column on each page
+			availSpace = pageWidth - primaryCol.width;
+			availSpace -= colInfo.width;
+
+			colSets.push(colSet);
+		}
+		colSet.columns.push(colInfo);
+	}
+
+
+	let colSetCount = colSets.length;
+	if (!colSetCount) {
+		colSetCount = 1;
+		colSets.push([primaryCol]);
+	}
+	pfInfo.columnSets = colSets;
+
+	// Resolve scalable columns and width
+	for (let i = 0; i < colSetCount; ++i) {
+		colSet = colSets[i];
+		colCount = colSet.columns.length;
+		let scalableColumns = [];
+		availSpace = pageWidth;
+		for (c = 0; c < colCount; ++c) {
+			colInfo = colSet.columns[c];
+			if (colInfo.scalability) {
+				scalableColumns.push(colInfo);
+			} else {
+				availSpace -= colInfo.width;
+			}
+		}
+		let scalableColCount = scalableColumns.length;
+		if (scalableColCount) {
+			let avgWidth = (availSpace / scalableColCount); // TODO: Take min width into account
+			for (c = 0; c < scalableColCount; ++c) {
+				scalableColumns[c].width = (avgWidth * (c + 1) | 0) - (avgWidth * c | 0);
+			}
+		}
+
+		let totalWidth = 0;
+		let widths = colSet.widths = new Array(colCount);
+		for (c = 0; c < colCount; ++c) {
+			colInfo = colSet.columns[c];
+			widths[c] = colInfo.width;
+			totalWidth += colInfo.width;
+		}
+		colSet.width = totalWidth;
+	}
+
+	// Find total row count per table. Remove all empty rows after the last occupied row.
+	let dv = grid.getDataSource();
+	let totalRowCount = pfInfo.totalRowcount = dv.getVisibleRowCount();
+
+	// Find cutoff point for each page
+	let titleSect = grid.getSection("title");
+	let headerHeight = pfInfo.headerHeight = (titleSect.isVisible()) ? titleSect.getDefaultRowHeight() : 0;
+	let rowHeight = pfInfo.rowHeight = grid.getSection("content").getDefaultRowHeight();
+	let maxRowPerPage = (pageHeight - headerHeight) / rowHeight | 0;
+	if (!(maxRowPerPage > 0)) { // NaN, negative number, or zero is not allowed.
+		maxRowPerPage = 1; // number of content rows
+	}
+	pfInfo.maxRowPerPage = maxRowPerPage;
+
+	let gridCount = pfInfo.gridCount = Math.ceil(totalRowCount / maxRowPerPage); // Number of grid require to render all of the rows. Grid must fit a single page
+	// let lastPageRowCount = totalRowCount - (totalRowCount / maxRowPerPage | 0);
+	pfInfo.pageCount = gridCount * colSetCount;
+
+
+	// TODO: Stack the table horizontally, if there is enough space
+	// if(colSetCount == 1 && pageCount > 1) {
+	// availSpace = pageWidth;
+	// tableWidth = tables[0]._width;
+	// let numGridPerPage = Math.floor(pageWidth / tableWidth);
+
+	// let margin = 4;
+	// let takenSpace = numTablePerPage * tableWidth + (numTablePerPage - 1) * margin;
+	// if(takenSpace > pageWidth) {
+	// numGridPerPage--; // There is not enough space for margin
+	// }
+	// if(numGridPerPage > 1) {
+
+	// }
+	// }
+
+	pfInfo._calculated = true; // Internal flag
+
+	return pfInfo;
+};
+
+/** @public
+* @param {*} grid grid element, currently supports atlas-blotter, ef-grid, tr.CompositeGrid, rt.Grid and Core
+* @param {Object=} options
+* @return {Element}
+*/
+GridPrinter.createPrintElement = function (grid, options) {
+	if (!grid) {
+		grid = GridPrinter._grid;
+	} else {
+		grid = _getCoreGrid(grid);
+	}
+
+	if (!grid) {
+		return null;
+	}
+
+	let pfInfo = options || GridPrinter._printInfo;
+	if (!pfInfo || !pfInfo._calculated) {
+		pfInfo = GridPrinter.getPreFlightInfo(grid, pfInfo);
+	}
+
+	// TODO: Check if we need to recalculate everything again
+	let maxRowPerPage = pfInfo.maxRowPerPage;
+	let totalRowCount = pfInfo.totalRowcount;
+	let rowHeight = pfInfo.rowHeight;
+	let headerHeight = pfInfo.headerHeight;
+	let colSets = pfInfo.columnSets;
+	let colSetCount = pfInfo.columnSets.length;
+	let primaryColumn = pfInfo.primaryColumn;
+	let gridCount = pfInfo.gridCount;
+	let contentWriter = new SectionWriter(); // content section
+	let headerWriter = new SectionWriter();
+
+	let gridContentSection = grid.getSectionSettings("content");
+	gridContentSection.snapshot(contentWriter);
+
+	let gridHeaderSection = grid.getSectionSettings("title");
+	if (gridHeaderSection) {
+		gridHeaderSection.snapshot(headerWriter);
+	}
+
+	// Begin element construction
+	let tables = [];
+	let t;
+	for (t = 0; t < gridCount; ++t) { // For each table
+		let rowStart = t * maxRowPerPage;
+		let rowEnd = rowStart + maxRowPerPage;
+		if (rowEnd > totalRowCount) {
+			rowEnd = totalRowCount;
+		}
+		let rowCount = rowEnd - rowStart;
+
+		for (let s = 0; s < colSetCount; ++s) { // For each column set
+			let colSet = colSets[s];
+			let colCount = colSet.columns.length;
+			let c, col, colIndex;
+			let tbl = new Table(null, {
+				colCount: colCount,
+				rowCount: rowCount,
+				rowHeight: rowHeight
+			});
+
+			tbl.setColumnWidths(colSet.widths);
+
+			if (headerHeight) {
+				tbl.addHeaderRows(); // TODO: support multiple rows
+				let thead = tbl.getHeader();
+				thead.setDefaultRowHeight(headerHeight);
+
+				// Render header columns
+				for (c = 0; c < colCount; ++c) { // Create header and columns
+					col = colSet.columns[c];
+					colIndex = col.index;
+					copyNode(headerWriter.getCellElement(colIndex, 0), thead.getCell(c, 0));
+					_setColumnAlignment(thead, c, col.alignment);
+				}
+
+				// TODO: Span the header rows
+			}
+
+			// Render content section
+			for (c = 0; c < colCount; ++c) { // Populate each cell
+				col = colSet.columns[c];
+				colIndex = col.index;
+				let isPrimary = colIndex === primaryColumn.index;
+
+				for (let r = 0; r < rowCount; ++r) {
+					let rowIndex = rowStart + r;
+					let masterCell = contentWriter.getCellElement(colIndex, rowIndex);
+					let cell = tbl.getCell(c, r);
+					if (isPrimary) {
+						copyNode(masterCell, cell);
+					} else {
+						swapNode(masterCell, cell);
+					}
+				}
+
+				_setColumnAlignment(tbl, c, col.alignment);
+			}
+
+			tbl._tableNum = t;
+			tables.push(tbl);
+		}
+	}
+
+	// Produce the root element to be appended to the page
+	let pageCount = pfInfo.pageCount;
+	let rootElem = document.createElement("div");
+	rootElem.className = "tr-printing-root";
+	rootElem.style.display = "block"; // This will beat any CSS selector
+	for (t = 0; t < pageCount; ++t) {
+		rootElem.appendChild(tables[t].getElement());
+	}
+	// rootElem.appendChild(headerWriter.getElement());
+	// rootElem.appendChild(contentWriter.getElement());
+
+	return rootElem;
+};
+
+GridPrinter._applyCss = function () {
+	if (GridPrinter._styles) {
+		return;
+	}
+	GridPrinter._styles = prettifyCss([
+		".tr-printing-mode, .tr-printing-mode body", [
+			"width: 100%;",
+			"height: unset;",
+			"padding: 0;",
+			"margin: 0;",
+			"background-color: white;",
+			"overflow: hidden; /* No scrollbar for printing */"
+		],
+		".tr-printing-mode body > *", [
+			"display: none;"
+		],
+		".tr-printing-root", [
+			"width: 100%;",
+			"background-color: white;"
+		],
+		".tr-printing-root > *", [
+			"page-break-after: always;"
+		],
+		".tr-printing-root table", [
+			"border-collapse: collapse;",
+			"table-layout:fixed; /* To force clipping text */"
+		],
+		".tr-printing-root tr", [
+			"height: 21px;",
+			"color: unset;",
+			"background-color: unset;"
+		],
+		".tr-printing-root td", [
+			"border: 1px solid black;",
+			"padding: 0 5px;",
+			"height: unset;",
+			"font-size: 12px;",
+			"text-overflow: ellipsis;",
+			"white-space: nowrap;",
+			"overflow: hidden;"
+		],
+		".tr-printing-root td, .tr-printing-root tr:hover td, .tr-printing-root tr td:hover", [
+			"color: black;",
+			"background-color: white;"
+		],
+		".tr-printing-root .tr-align-left", [
+			"text-align: left;"
+		],
+		".tr-printing-root .tr-align-right", [
+			"text-align: right;"
+		],
+		".tr-printing-root .tr-align-center", [
+			"text-align: center;"
+		],
+		".tr-printing-root .cell ef-icon", [
+			"margin-top: 3px;"
+		],
+		".tr-printing-root .cell .sort-symbol", [
+			"margin-left: 4px;",
+			"display: inline-block;"
+		],
+		".tr-printing-root .cell .sort-symbol", [
+			"margin-left: 4px;",
+			"display: inline-block;"
+		],
+		// eslint-disable-next-line no-multi-str
+		".tr-printing-root .priority-symbol:last-child,\
+		.tr-printing-root .sortable-indicator:last-child,\
+		.tr-printing-root .sort-symbol:last-child", [
+			"margin-right: 0px;"
+		],
+		".tr-printing-root .sortable-indicator:last-child", [
+			"opacity: 0.5;"
+		],
+		".tr-printing-root .folder .expander", [
+			"margin-right: 7px;",
+			"margin-left: 3px;"
+		],
+		".tr-printing-root .folder .fallback-arrow", [
+			"vertical-align: middle;",
+			"font-size: 7px;",
+			"line-height: 1;",
+			"display: inline-block;", // For transformation
+			"transform: scaleX(1.5);",
+			"font-family: Arial;"
+		],
+		".tr-printing-root .folder.closed .expander", [
+			"transform: translate(0px, 1px) rotate(-90deg);"
+		],
+		".tr-printing-root .folder.closed .expander .fallback-arrow", [
+			"transform: translate(0px, -1px) rotate(-90deg) scaleX(1.5);"
+		],
+		".tr-printing-root .print-inline", [
+			"display:inline-block;"
+		],
+		".tr-printing-root .text", [
+			"vertical-align: middle;",
+			"overflow: hidden;",
+			"text-overflow: ellipsis;"
+		],
+		".tr-printing-root .group-header, .tr-printing-root .ric-arrow", [
+			"color: black !important;"
+		],
+		".tr-printing-root .group-header-box", [
+			"display: inline-block;",
+			"width: 180px;"
+		],
+		".tr-printing-root .group-header-box *", [
+			"display: inline-block;"
+		],
+		".tr-printing-root .tr-percent-bar", [
+			"position:relative;",
+			"text-align: left;",
+			"overflow: hidden;",
+			"white-space: nowrap;"
+		],
+		".tr-printing-root .tr-percent-bar>div", [
+			"position:relative;",
+			"display: inline-block;",
+			"height: 8px;",
+			"vertical-align: middle;"
+		],
+		".tr-printing-root .tr-percent-bar>div>div", [
+			"position:absolute;",
+			"height: 100%;"
+		],
+		".tr-printing-root .tr-percent-bar>span", [
+			"display: inline-block;",
+			"vertical-align: middle;",
+			"box-sizing: border-box;",
+			"padding-left: 4px;",
+			"padding-right: 4px;",
+			"overflow: hidden;",
+			"max-width: 100%;"
+		],
+		".tr-printing-wrapper", [
+			"white-space: nowrap;",
+			"overflow: hidden;"
+		],
+		"/* For safety */",
+		".tr-printing-wrapper > *", [
+			"display: inline-block;",
+			"vertical-align: top;"
+		],
+		".tr-printing-wrapper  > * + *", [
+			"margin-left: 4px;"
+		],
+		".tr-blank-page", [
+			"page-break-after: always;",
+			"height: 1px;",
+			"visibility: hidden;"
+		],
+		".tr-printing-flex-row", [
+			"display: flex;",
+			"width: 100%;",
+			"min-width: 0;",
+			"align-items: center;"
+		],
+		".tr-printing-flex-row>*:not(.tr-printing-float-right)", [
+			"flex: 1 1 0;"
+		],
+		"@media screen", [
+			prettifyCss([
+				"/* For debugging */",
+				".tr-printing-mode", [
+					"overflow: auto;",
+					"background-color: lightgrey;"
+				],
+				".tr-printing-root > * + *", [
+					"margin-top: 4px;"
+				]
+			])
+		]
+	]);
+	injectCss(GridPrinter._styles, document.body);
+};
+
+/** @public
+* @param {*} grid grid element, currently supports efx-grid, atlas-blotter, ef-grid, tr.CompositeGrid, rt.Grid and Core
+*/
+GridPrinter.print = function (grid) {
+	let core = null;
+	if (grid) {
+		GridPrinter._applyCss();
+		core = _getCoreGrid(grid);
+	}
+
+	if (core) {
+		GridPrinter._grid = core;
+
+		let pt = GridPrinter.getPrintTrait(); // initialize
+		if (!GridPrinter._manualObs) {
+			pt.observe(); // Observe current window
+		}
+
+		pt.print();
+	} else {
+		GridPrinter._grid = null;
+	}
+};
+
+
+/** @public
+* @ignore
+* @return {!PrintTrait}
+*/
+GridPrinter.getPrintTrait = function () {
+	let pt = GridPrinter._printTrait;
+	if (!pt) {
+		pt = new PrintTrait();
+		GridPrinter.setPrintTrait(pt);
+	}
+	return pt;
+};
+/** @public
+* @ignore
+* @param {PrintTrait} pt
+*/
+GridPrinter.setPrintTrait = function (pt) {
+	if(GridPrinter._printTrait && GridPrinter._printTrait !== pt) {
+		GridPrinter._printTrait.dispose();
+	}
+
+	GridPrinter._printTrait = pt || null;
+	if (pt) {
+		// TODO: pt.fixPaperSize(); // WORKAROUND: We cannot detect the change in paper size during the browser's preview dialog.
+
+		pt.addEventListener('pageCounting', GridPrinter._onPageCounting);
+		pt.addEventListener('beforeprint', GridPrinter._onBeforePrint);
+		pt.addEventListener('afterprint', GridPrinter._onAfterPrint);
+	}
+};
+/** @private
+* @param {tr.Grid} grid
+* @param {number} idx
+* @return {!Object}
+*/
+GridPrinter._newColInfo = function (grid, idx) {
+	let minWidth = grid.getMinimumColumnWidth(idx);
+	if (minWidth <= 0) {
+		minWidth = 50; // WARNING: Hard-coded value
+	}
+	let scalability = grid.getColumnScalability(idx);
+	let width = scalability ? minWidth : grid.getColumnWidth(idx);
+
+	return {
+		"index": idx,
+		"width": width,
+		"data": grid.getColumnData(idx),
+		"scalability": scalability,
+		"minWidth": minWidth,
+		"alignment": grid.getColumnAlignment(idx)
+	};
+};
+/** @private
+*/
+GridPrinter._removePrintElements = function () {
+	Dom.removeParent(GridPrinter._blankPage);
+	GridPrinter._blankPage = null;
+
+	Dom.removeParent(GridPrinter._printElem);
+	GridPrinter._printElem = null;
+};
+
+
+/** @private
+* @param {Object} e Event argument created from PrintTrait
+*/
+GridPrinter._onPageCounting = function (e) {
+	GridPrinter._removePrintElements();
+
+	GridPrinter._printInfo = GridPrinter.getPreFlightInfo(GridPrinter._grid, e);
+	if (GridPrinter._printInfo.pageCount) {
+		// There is no need to render anything at this phase
+		GridPrinter._blankPage = PrintTrait.createBlankPages(GridPrinter._printInfo.pageCount);
+		e.bodyElement.appendChild(GridPrinter._blankPage);
+	}
+};
+/** @private
+* @param {Object} e
+*/
+GridPrinter._onBeforePrint = function (e) {
+	GridPrinter._removePrintElements();
+
+	if (GridPrinter._printInfo && GridPrinter._printInfo.pageCount) {
+		GridPrinter._printElem = GridPrinter.createPrintElement(GridPrinter._grid, GridPrinter._printInfo); // TODO: Use new sizes given from PrintTrait
+
+		// let elem = GridPrinter._printTrait.createClientBox(e.pageWidth, e.pageHeight);
+		e.bodyElement.appendChild(GridPrinter._printElem);
+	}
+};
+/** @private
+* @param {Object} e
+*/
+GridPrinter._onAfterPrint = function (e) {
+	GridPrinter._removePrintElements();
+
+	if (!GridPrinter._manualObs) {
+		GridPrinter.getPrintTrait().unobserve();
+	}
+
+	GridPrinter._printInfo = null;
+	if (GridPrinter._grid) {
+		GridPrinter._grid.updateLayout();
+		GridPrinter._grid = null;
+	}
+};
+
+/** @typedef {Object} GridPrinter~Options
+* @description Configuration object for customizing priting behavior can be passed through `GridPrinter.setPrintOptions` method
+* @property {number=} pageWidth Paper width in pixel. This limits number of columns to be shown on a single page
+* @property {number=} pageHeight Paper height in pixel. This limits number of rows to be shown on a single page
+* @property {number=} primaryColumn Column index that will be placed as the first column on each page.
+*/
+GridPrinter.Options;
+
+
+
+export default GridPrinter;
+export { GridPrinter };