handsontable 0.0.0-next-9ec04ce-20221121

package/3rdparty/walkontable/src/renderer/rowHeaders.mjs

@@ -0,0 +1,114 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.string.iterator.js";
+import "core-js/modules/es.weak-map.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+import "core-js/modules/es.object.set-prototype-of.js";
+import "core-js/modules/es.object.get-prototype-of.js";
+import "core-js/modules/es.reflect.construct.js";
+import "core-js/modules/es.symbol.js";
+import "core-js/modules/es.symbol.description.js";
+import "core-js/modules/es.symbol.iterator.js";
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+import { SharedOrderView } from "./../utils/orderView/index.mjs";
+import BaseRenderer from "./_base.mjs";
+/**
+ * Row headers renderer responsible for managing (inserting, tracking, rendering) TR elements belongs to TR.
+ *
+ *   <tr> (root node)
+ *     ├ <th>   --- RowHeadersRenderer
+ *     ├ <td>   \
+ *     ├ <td>    \
+ *     ├ <td>     - CellsRenderer
+ *     ├ <td>    /
+ *     └ <td>   /.
+ *
+ * @class {CellsRenderer}
+ */
+var RowHeadersRenderer = /*#__PURE__*/function (_BaseRenderer) {
+  _inherits(RowHeadersRenderer, _BaseRenderer);
+  var _super = _createSuper(RowHeadersRenderer);
+  function RowHeadersRenderer() {
+    var _this;
+    _classCallCheck(this, RowHeadersRenderer);
+    _this = _super.call(this, 'TH');
+    /**
+     * Cache for OrderView classes connected to specified node.
+     *
+     * @type {WeakMap}
+     */
+    _this.orderViews = new WeakMap();
+    /**
+     * Row index which specifies the row position of the processed row header.
+     *
+     * @type {number}
+     */
+    _this.sourceRowIndex = 0;
+    return _this;
+  }
+
+  /**
+   * Obtains the instance of the SharedOrderView class which is responsible for rendering the nodes to the root node.
+   *
+   * @param {HTMLTableRowElement} rootNode The TR element, which is root element for row headers (TH).
+   * @returns {SharedOrderView}
+   */
+  _createClass(RowHeadersRenderer, [{
+    key: "obtainOrderView",
+    value: function obtainOrderView(rootNode) {
+      var _this2 = this;
+      var orderView;
+      if (this.orderViews.has(rootNode)) {
+        orderView = this.orderViews.get(rootNode);
+      } else {
+        orderView = new SharedOrderView(rootNode, function (sourceColumnIndex) {
+          return _this2.nodesPool.obtain(_this2.sourceRowIndex, sourceColumnIndex);
+        }, this.nodeType);
+        this.orderViews.set(rootNode, orderView);
+      }
+      return orderView;
+    }
+
+    /**
+     * Renders the cells.
+     */
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$table = this.table,
+        rowsToRender = _this$table.rowsToRender,
+        rowHeaderFunctions = _this$table.rowHeaderFunctions,
+        rowHeadersCount = _this$table.rowHeadersCount,
+        rows = _this$table.rows,
+        cells = _this$table.cells;
+      for (var visibleRowIndex = 0; visibleRowIndex < rowsToRender; visibleRowIndex++) {
+        var sourceRowIndex = this.table.renderedRowToSource(visibleRowIndex);
+        var TR = rows.getRenderedNode(visibleRowIndex);
+        this.sourceRowIndex = sourceRowIndex;
+        var orderView = this.obtainOrderView(TR);
+        var cellsView = cells.obtainOrderView(TR);
+        orderView.appendView(cellsView).setSize(rowHeadersCount).setOffset(this.table.renderedColumnToSource(0)).start();
+        for (var visibleColumnIndex = 0; visibleColumnIndex < rowHeadersCount; visibleColumnIndex++) {
+          orderView.render();
+          var TH = orderView.getCurrentNode();
+          TH.className = '';
+          TH.removeAttribute('style');
+          rowHeaderFunctions[visibleColumnIndex](sourceRowIndex, TH, visibleColumnIndex);
+        }
+        orderView.end();
+      }
+    }
+  }]);
+  return RowHeadersRenderer;
+}(BaseRenderer);
+export { RowHeadersRenderer as default };

package/3rdparty/walkontable/src/renderer/rows.js

@@ -0,0 +1,99 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.reflect.construct.js");
+require("core-js/modules/es.array.slice.js");
+require("core-js/modules/es.object.freeze.js");
+require("core-js/modules/es.symbol.js");
+require("core-js/modules/es.symbol.description.js");
+require("core-js/modules/es.symbol.iterator.js");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.string.iterator.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+exports.__esModule = true;
+exports.default = void 0;
+require("core-js/modules/es.object.set-prototype-of.js");
+require("core-js/modules/es.object.get-prototype-of.js");
+var _console = require("./../../../../helpers/console");
+var _templateLiteralTag = require("./../../../../helpers/templateLiteralTag");
+var _orderView = require("./../utils/orderView");
+var _base = _interopRequireDefault(require("./_base"));
+var _templateObject;
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+var performanceWarningAppeared = false;
+
+/**
+ * Rows renderer responsible for managing (inserting, tracking, rendering) TR elements belongs to TBODY.
+ *
+ *   <tbody> (root node)
+ *     ├ <tr>   \
+ *     ├ <tr>    \
+ *     ├ <tr>     - RowsRenderer
+ *     ├ <tr>    /
+ *     └ <tr>   /.
+ *
+ * @class {RowsRenderer}
+ */
+var RowsRenderer = /*#__PURE__*/function (_BaseRenderer) {
+  _inherits(RowsRenderer, _BaseRenderer);
+  var _super = _createSuper(RowsRenderer);
+  function RowsRenderer(rootNode) {
+    var _this;
+    _classCallCheck(this, RowsRenderer);
+    _this = _super.call(this, 'TR', rootNode);
+    /**
+     * Cache for OrderView classes connected to specified node.
+     *
+     * @type {WeakMap}
+     */
+    _this.orderView = new _orderView.OrderView(rootNode, function (sourceRowIndex) {
+      return _this.nodesPool.obtain(sourceRowIndex);
+    }, _this.nodeType);
+    return _this;
+  }
+
+  /**
+   * Returns currently rendered node.
+   *
+   * @param {string} visualIndex Visual index of the rendered node (it always goeas from 0 to N).
+   * @returns {HTMLTableRowElement}
+   */
+  _createClass(RowsRenderer, [{
+    key: "getRenderedNode",
+    value: function getRenderedNode(visualIndex) {
+      return this.orderView.getNode(visualIndex);
+    }
+
+    /**
+     * Renders the cells.
+     */
+  }, {
+    key: "render",
+    value: function render() {
+      var rowsToRender = this.table.rowsToRender;
+      if (!performanceWarningAppeared && rowsToRender > 1000) {
+        performanceWarningAppeared = true;
+        (0, _console.warn)((0, _templateLiteralTag.toSingleLine)(_templateObject || (_templateObject = _taggedTemplateLiteral(["Performance tip: Handsontable rendered more than 1000 visible rows. Consider limiting \n        the number of rendered rows by specifying the table height and/or turning off the \"renderAllRows\" option."], ["Performance tip: Handsontable rendered more than 1000 visible rows. Consider limiting\\x20\n        the number of rendered rows by specifying the table height and/or turning off the \"renderAllRows\" option."]))));
+      }
+      this.orderView.setSize(rowsToRender).setOffset(this.table.renderedRowToSource(0)).start();
+      for (var visibleRowIndex = 0; visibleRowIndex < rowsToRender; visibleRowIndex++) {
+        this.orderView.render();
+      }
+      this.orderView.end();
+    }
+  }]);
+  return RowsRenderer;
+}(_base.default);
+exports.default = RowsRenderer;

package/3rdparty/walkontable/src/renderer/rows.mjs

@@ -0,0 +1,94 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+import "core-js/modules/es.object.set-prototype-of.js";
+import "core-js/modules/es.object.get-prototype-of.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.reflect.construct.js";
+import "core-js/modules/es.array.slice.js";
+import "core-js/modules/es.object.freeze.js";
+import "core-js/modules/es.symbol.js";
+import "core-js/modules/es.symbol.description.js";
+import "core-js/modules/es.symbol.iterator.js";
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.string.iterator.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+var _templateObject;
+function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+import { warn } from "./../../../../helpers/console.mjs";
+import { toSingleLine } from "./../../../../helpers/templateLiteralTag.mjs";
+import { OrderView } from "./../utils/orderView/index.mjs";
+import BaseRenderer from "./_base.mjs";
+var performanceWarningAppeared = false;
+
+/**
+ * Rows renderer responsible for managing (inserting, tracking, rendering) TR elements belongs to TBODY.
+ *
+ *   <tbody> (root node)
+ *     ├ <tr>   \
+ *     ├ <tr>    \
+ *     ├ <tr>     - RowsRenderer
+ *     ├ <tr>    /
+ *     └ <tr>   /.
+ *
+ * @class {RowsRenderer}
+ */
+var RowsRenderer = /*#__PURE__*/function (_BaseRenderer) {
+  _inherits(RowsRenderer, _BaseRenderer);
+  var _super = _createSuper(RowsRenderer);
+  function RowsRenderer(rootNode) {
+    var _this;
+    _classCallCheck(this, RowsRenderer);
+    _this = _super.call(this, 'TR', rootNode);
+    /**
+     * Cache for OrderView classes connected to specified node.
+     *
+     * @type {WeakMap}
+     */
+    _this.orderView = new OrderView(rootNode, function (sourceRowIndex) {
+      return _this.nodesPool.obtain(sourceRowIndex);
+    }, _this.nodeType);
+    return _this;
+  }
+
+  /**
+   * Returns currently rendered node.
+   *
+   * @param {string} visualIndex Visual index of the rendered node (it always goeas from 0 to N).
+   * @returns {HTMLTableRowElement}
+   */
+  _createClass(RowsRenderer, [{
+    key: "getRenderedNode",
+    value: function getRenderedNode(visualIndex) {
+      return this.orderView.getNode(visualIndex);
+    }
+
+    /**
+     * Renders the cells.
+     */
+  }, {
+    key: "render",
+    value: function render() {
+      var rowsToRender = this.table.rowsToRender;
+      if (!performanceWarningAppeared && rowsToRender > 1000) {
+        performanceWarningAppeared = true;
+        warn(toSingleLine(_templateObject || (_templateObject = _taggedTemplateLiteral(["Performance tip: Handsontable rendered more than 1000 visible rows. Consider limiting \n        the number of rendered rows by specifying the table height and/or turning off the \"renderAllRows\" option."], ["Performance tip: Handsontable rendered more than 1000 visible rows. Consider limiting\\x20\n        the number of rendered rows by specifying the table height and/or turning off the \"renderAllRows\" option."]))));
+      }
+      this.orderView.setSize(rowsToRender).setOffset(this.table.renderedRowToSource(0)).start();
+      for (var visibleRowIndex = 0; visibleRowIndex < rowsToRender; visibleRowIndex++) {
+        this.orderView.render();
+      }
+      this.orderView.end();
+    }
+  }]);
+  return RowsRenderer;
+}(BaseRenderer);
+export { RowsRenderer as default };

package/3rdparty/walkontable/src/renderer/table.js

@@ -0,0 +1,317 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+/**
+ * TableRenderer class collects all renderers and properties necessary for table creation. It's
+ * responsible for adjusting and rendering each renderer.
+ *
+ * Below is a diagram of the renderers together with an indication of what they are responisble for.
+ *   <table>
+ *     <colgroup>  \ (root node)
+ *       <col>      \
+ *       <col>       \___ ColGroupRenderer
+ *       <col>       /
+ *       <col>      /
+ *     </colgroup> /
+ *     <thead>     \ (root node)
+ *       <tr>       \
+ *         <th>      \
+ *         <th>       \____ ColumnHeadersRenderer
+ *         <th>       /
+ *         <th>      /
+ *       </tr>      /
+ *     </thead>    /
+ *     <tbody>   ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯\ (root node)
+ *       <tr>   (root node)          \
+ *         <th>  --- RowHeadersRenderer
+ *         <td>  \                     \
+ *         <td>   -- CellsRenderer      \
+ *         <td>  /                       \
+ *       </tr>                            \
+ *       <tr>   (root node)                \
+ *         <th>  --- RowHeadersRenderer     \
+ *         <td>  \                           \___ RowsRenderer
+ *         <td>   -- CellsRenderer           /
+ *         <td>  /                          /
+ *       </tr>                             /
+ *       <tr>   (root node)               /
+ *         <th>  --- RowHeadersRenderer  /
+ *         <td>  \                      /
+ *         <td>   -- CellsRenderer     /
+ *         <td>  /                    /
+ *       </tr>                       /
+ *     </tbody>  ___________________/
+ *   </table>.
+ *
+ * @class {RowsRenderer}
+ */
+var TableRenderer = /*#__PURE__*/function () {
+  function TableRenderer(rootNode) {
+    var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+      cellRenderer = _ref.cellRenderer;
+    _classCallCheck(this, TableRenderer);
+    /**
+     * Table element which will be used to render the children element.
+     *
+     * @type {HTMLTableElement}
+     */
+    this.rootNode = rootNode;
+    /**
+     * Document owner of the root node.
+     *
+     * @type {HTMLDocument}
+     */
+    this.rootDocument = this.rootNode.ownerDocument;
+    /**
+     * Renderer class responsible for rendering row headers.
+     *
+     * @type {RowsRenderer}
+     */
+    this.rowHeaders = null;
+    /**
+     * Renderer class responsible for rendering column headers.
+     *
+     * @type {ColumnHeadersRenderer}
+     */
+    this.columnHeaders = null;
+    /**
+     * Renderer class responsible for rendering col in colgroup.
+     *
+     * @type {ColGroupRenderer}
+     */
+    this.colGroup = null;
+    /**
+     * Renderer class responsible for rendering rows in tbody.
+     *
+     * @type {RowsRenderer}
+     */
+    this.rows = null;
+    /**
+     * Renderer class responsible for rendering cells.
+     *
+     * @type {CellsRenderer}
+     */
+    this.cells = null;
+    /**
+     * Row filter which contains all necessary information about row index transformation.
+     *
+     * @type {RowFilter}
+     */
+    this.rowFilter = null;
+    /**
+     * Column filter which contains all necessary information about column index transformation.
+     *
+     * @type {ColumnFilter}
+     */
+    this.columnFilter = null;
+    /**
+     * Row utils class which contains all necessary information about sizes of the rows.
+     *
+     * @type {RowUtils}
+     */
+    this.rowUtils = null;
+    /**
+     * Column utils class which contains all necessary information about sizes of the columns.
+     *
+     * @type {ColumnUtils}
+     */
+    this.columnUtils = null;
+    /**
+     * Indicates how much rows should be rendered to fill whole table viewport.
+     *
+     * @type {number}
+     */
+    this.rowsToRender = 0;
+    /**
+     * Indicates how much columns should be rendered to fill whole table viewport.
+     *
+     * @type {number}
+     */
+    this.columnsToRender = 0;
+    /**
+     * An array of functions to be used as a content factory to row headers.
+     *
+     * @type {Function[]}
+     */
+    this.rowHeaderFunctions = [];
+    /**
+     * Count of the function used to render row headers.
+     *
+     * @type {number}
+     */
+    this.rowHeadersCount = 0;
+    /**
+     * An array of functions to be used as a content factory to column headers.
+     *
+     * @type {Function[]}
+     */
+    this.columnHeaderFunctions = [];
+    /**
+     * Count of the function used to render column headers.
+     *
+     * @type {number}
+     */
+    this.columnHeadersCount = 0;
+    /**
+     * Cell renderer used to render cells content.
+     *
+     * @type {Function}
+     */
+    this.cellRenderer = cellRenderer;
+  }
+
+  /**
+   * Set row and column util classes.
+   *
+   * @param {RowUtils} rowUtils RowUtils instance which provides useful methods related to row sizes.
+   * @param {ColumnUtils} columnUtils ColumnUtils instance which provides useful methods related to row sizes.
+   */
+  _createClass(TableRenderer, [{
+    key: "setAxisUtils",
+    value: function setAxisUtils(rowUtils, columnUtils) {
+      this.rowUtils = rowUtils;
+      this.columnUtils = columnUtils;
+    }
+
+    /**
+     * Sets viewport size of the table.
+     *
+     * @param {number} rowsCount An amount of rows to render.
+     * @param {number} columnsCount An amount of columns to render.
+     */
+  }, {
+    key: "setViewportSize",
+    value: function setViewportSize(rowsCount, columnsCount) {
+      this.rowsToRender = rowsCount;
+      this.columnsToRender = columnsCount;
+    }
+
+    /**
+     * Sets row and column filter instances.
+     *
+     * @param {RowFilter} rowFilter Row filter instance which contains all necessary information about row index transformation.
+     * @param {ColumnFilter} columnFilter Column filter instance which contains all necessary information about row
+     * index transformation.
+     */
+  }, {
+    key: "setFilters",
+    value: function setFilters(rowFilter, columnFilter) {
+      this.rowFilter = rowFilter;
+      this.columnFilter = columnFilter;
+    }
+
+    /**
+     * Sets row and column header functions.
+     *
+     * @param {Function[]} rowHeaders Row header functions. Factories for creating content for row headers.
+     * @param {Function[]} columnHeaders Column header functions. Factories for creating content for column headers.
+     */
+  }, {
+    key: "setHeaderContentRenderers",
+    value: function setHeaderContentRenderers(rowHeaders, columnHeaders) {
+      this.rowHeaderFunctions = rowHeaders;
+      this.rowHeadersCount = rowHeaders.length;
+      this.columnHeaderFunctions = columnHeaders;
+      this.columnHeadersCount = columnHeaders.length;
+    }
+
+    /**
+     * Sets table renderers.
+     *
+     * @param {renderers} renderers The renderer units.
+     * @param {RowHeadersRenderer} renderers.rowHeaders Row headers renderer.
+     * @param {ColumnHeadersRenderer} renderers.columnHeaders Column headers renderer.
+     * @param {ColGroupRenderer} renderers.colGroup Col group renderer.
+     * @param {RowsRenderer} renderers.rows Rows renderer.
+     * @param {CellsRenderer} renderers.cells Cells renderer.
+     */
+  }, {
+    key: "setRenderers",
+    value: function setRenderers() {
+      var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+        rowHeaders = _ref2.rowHeaders,
+        columnHeaders = _ref2.columnHeaders,
+        colGroup = _ref2.colGroup,
+        rows = _ref2.rows,
+        cells = _ref2.cells;
+      rowHeaders.setTable(this);
+      columnHeaders.setTable(this);
+      colGroup.setTable(this);
+      rows.setTable(this);
+      cells.setTable(this);
+      this.rowHeaders = rowHeaders;
+      this.columnHeaders = columnHeaders;
+      this.colGroup = colGroup;
+      this.rows = rows;
+      this.cells = cells;
+    }
+
+    /**
+     * Transforms visual/rendered row index to source index.
+     *
+     * @param {number} rowIndex Rendered index.
+     * @returns {number}
+     */
+  }, {
+    key: "renderedRowToSource",
+    value: function renderedRowToSource(rowIndex) {
+      return this.rowFilter.renderedToSource(rowIndex);
+    }
+
+    /**
+     * Transforms visual/rendered column index to source index.
+     *
+     * @param {number} columnIndex Rendered index.
+     * @returns {number}
+     */
+  }, {
+    key: "renderedColumnToSource",
+    value: function renderedColumnToSource(columnIndex) {
+      return this.columnFilter.renderedToSource(columnIndex);
+    }
+
+    /**
+     * Renders the table.
+     */
+  }, {
+    key: "render",
+    value: function render() {
+      this.colGroup.adjust();
+      this.columnHeaders.adjust();
+      this.rows.adjust();
+      this.rowHeaders.adjust();
+      this.columnHeaders.render();
+      this.rows.render();
+      this.rowHeaders.render();
+      this.cells.render();
+
+      // After the cells are rendered calculate columns width (or columns stretch width) to prepare proper values
+      // for colGroup renderer (which renders COL elements).
+      this.columnUtils.calculateWidths();
+      this.colGroup.render();
+      var rowsToRender = this.rowsToRender,
+        rows = this.rows;
+
+      // Fix for multi-line content and for supporting `rowHeights` option.
+      for (var visibleRowIndex = 0; visibleRowIndex < rowsToRender; visibleRowIndex++) {
+        var TR = rows.getRenderedNode(visibleRowIndex);
+        if (TR.firstChild) {
+          var sourceRowIndex = this.renderedRowToSource(visibleRowIndex);
+          var rowHeight = this.rowUtils.getHeight(sourceRowIndex);
+          if (rowHeight) {
+            // Decrease height. 1 pixel will be "replaced" by 1px border top
+            TR.firstChild.style.height = "".concat(rowHeight - 1, "px");
+          } else {
+            TR.firstChild.style.height = '';
+          }
+        }
+      }
+    }
+  }]);
+  return TableRenderer;
+}();
+exports.default = TableRenderer;