handsontable 14.5.0-next-ede811d-20240717 → 14.5.0-next-cd41430-20240725

package/3rdparty/walkontable/src/calculator/viewportRows.mjs

@@ -1,84 +1,61 @@
 import "core-js/modules/es.error.cause.js";
-import "core-js/modules/es.array.at.js";
 import "core-js/modules/es.array.push.js";
-function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
-function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
 function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
 function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
-function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
-function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
-import { RENDER_TYPE, FULLY_VISIBLE_TYPE } from "./constants.mjs";
+import { ViewportBaseCalculator } from "./viewportBase.mjs";
+export const DEFAULT_HEIGHT = 23;
+
 /**
  * @typedef {object} ViewportRowsCalculatorOptions
+ * @property {Map<string, ViewportBaseCalculator>} calculationTypes The calculation types to be performed.
  * @property {number} viewportHeight Height of the viewport.
  * @property {number} scrollOffset Current vertical scroll position of the viewport.
  * @property {number} totalRows Total number of rows.
  * @property {Function} rowHeightFn Function that returns the height of the row at a given index (in px).
- * @property {Function} overrideFn Function that changes calculated this.startRow, this.endRow (used by MergeCells plugin).
- * @property {string} calculationType String which describes types of calculation which will be performed.
+ * @property {Function} overrideFn Function that allows to adjust the `startRow` and `endRow` parameters.
  * @property {number} horizontalScrollbarHeight The scrollbar height.
  */
 /**
- * Calculates indexes of rows to render OR rows that are visible.
- * To redo the calculation, you need to create a new calculator.
+ * Calculates indexes of rows to render OR rows that are visible OR partially visible in the viewport.
  *
  * @class ViewportRowsCalculator
  */
-var _options = /*#__PURE__*/new WeakMap();
-export class ViewportRowsCalculator {
-  /**
-   * Default row height.
-   *
-   * @type {number}
-   */
-  static get DEFAULT_HEIGHT() {
-    return 23;
-  }
-
-  /**
-   * Number of rendered/visible rows.
-   *
-   * @type {number}
-   */
-
+export class ViewportRowsCalculator extends ViewportBaseCalculator {
   /**
    * @param {ViewportRowsCalculatorOptions} options Object with all options specified for row viewport calculation.
    */
-  constructor(options) {
-    _defineProperty(this, "count", 0);
-    /**
-     * Index of the first rendered/visible row (can be overwritten using overrideFn).
-     *
-     * @type {number|null}
-     */
-    _defineProperty(this, "startRow", null);
-    /**
-     * Index of the last rendered/visible row (can be overwritten using overrideFn).
-     *
-     * @type {null}
-     */
-    _defineProperty(this, "endRow", null);
-    /**
-     * Position of the first rendered/visible row (in px).
-     *
-     * @type {number|null}
-     */
-    _defineProperty(this, "startPosition", null);
-    /**
-     * Determines if the viewport is visible in the trimming container.
-     *
-     * @type {boolean}
-     */
-    _defineProperty(this, "isVisibleInTrimmingContainer", false);
-    /**
-     * The calculator options.
-     *
-     * @type {ViewportRowsCalculatorOptions}
-     */
-    _classPrivateFieldInitSpec(this, _options, void 0);
-    _classPrivateFieldSet(_options, this, options);
+  constructor(_ref) {
+    let {
+      calculationTypes,
+      viewportHeight,
+      scrollOffset,
+      totalRows,
+      rowHeightFn,
+      overrideFn,
+      horizontalScrollbarHeight
+    } = _ref;
+    super(calculationTypes);
+    _defineProperty(this, "viewportHeight", 0);
+    _defineProperty(this, "scrollOffset", 0);
+    _defineProperty(this, "zeroBasedScrollOffset", 0);
+    _defineProperty(this, "totalRows", 0);
+    _defineProperty(this, "rowHeightFn", null);
+    _defineProperty(this, "rowHeight", 0);
+    _defineProperty(this, "overrideFn", null);
+    _defineProperty(this, "horizontalScrollbarHeight", 0);
+    _defineProperty(this, "innerViewportHeight", 0);
+    _defineProperty(this, "totalCalculatedHeight", 0);
+    _defineProperty(this, "startPositions", []);
+    _defineProperty(this, "needReverse", true);
+    this.viewportHeight = viewportHeight;
+    this.scrollOffset = scrollOffset;
+    this.zeroBasedScrollOffset = Math.max(scrollOffset, 0);
+    this.totalRows = totalRows;
+    this.rowHeightFn = rowHeightFn;
+    this.overrideFn = overrideFn;
+    this.horizontalScrollbarHeight = horizontalScrollbarHeight !== null && horizontalScrollbarHeight !== void 0 ? horizontalScrollbarHeight : 0;
+    this.innerViewportHeight = this.zeroBasedScrollOffset + this.viewportHeight - this.horizontalScrollbarHeight;
     this.calculate();
   }
 
@@ -86,90 +63,31 @@ export class ViewportRowsCalculator {
    * Calculates viewport.
    */
   calculate() {
-    const {
-      calculationType,
-      overrideFn,
-      rowHeightFn,
-      scrollOffset,
-      totalRows,
-      viewportHeight
-    } = _classPrivateFieldGet(_options, this);
-    const zeroBasedScrollOffset = Math.max(_classPrivateFieldGet(_options, this).scrollOffset, 0);
-    const horizontalScrollbarHeight = _classPrivateFieldGet(_options, this).horizontalScrollbarHeight || 0;
-    const innerViewportHeight = zeroBasedScrollOffset + viewportHeight - horizontalScrollbarHeight;
-    let sum = 0;
-    let needReverse = true;
-    const startPositions = [];
-    let rowHeight;
-    let firstVisibleRowHeight = 0;
-    let lastVisibleRowHeight = 0;
-
-    // Calculate the number (start and end index) of rows needed
-    for (let i = 0; i < totalRows; i++) {
-      rowHeight = rowHeightFn(i);
-      if (isNaN(rowHeight)) {
-        rowHeight = ViewportRowsCalculator.DEFAULT_HEIGHT;
-      }
-      if (sum <= zeroBasedScrollOffset && calculationType !== FULLY_VISIBLE_TYPE) {
-        this.startRow = i;
-        firstVisibleRowHeight = rowHeight;
-      }
-      if (sum >= zeroBasedScrollOffset && sum + (calculationType === FULLY_VISIBLE_TYPE ? rowHeight : 0) <= innerViewportHeight) {
-        if (this.startRow === null) {
-          this.startRow = i;
-          firstVisibleRowHeight = rowHeight;
-        }
-        this.endRow = i;
-      }
-      startPositions.push(sum);
-      sum += rowHeight;
-      lastVisibleRowHeight = rowHeight;
-      if (calculationType !== FULLY_VISIBLE_TYPE) {
-        this.endRow = i;
-      }
-      if (sum >= innerViewportHeight) {
-        needReverse = false;
+    this._initialize(this);
+    for (let row = 0; row < this.totalRows; row++) {
+      this.rowHeight = this.getRowHeight(row);
+      this._process(row, this);
+      this.startPositions.push(this.totalCalculatedHeight);
+      this.totalCalculatedHeight += this.rowHeight;
+      if (this.totalCalculatedHeight >= this.innerViewportHeight) {
+        this.needReverse = false;
         break;
       }
     }
-    const mostBottomScrollOffset = scrollOffset + viewportHeight - horizontalScrollbarHeight;
-    const topRowOffset = calculationType === FULLY_VISIBLE_TYPE ? firstVisibleRowHeight : 0;
-    const bottomRowOffset = calculationType === FULLY_VISIBLE_TYPE ? 0 : lastVisibleRowHeight;
-    if (mostBottomScrollOffset < topRowOffset || scrollOffset > startPositions.at(-1) + bottomRowOffset) {
-      this.isVisibleInTrimmingContainer = false;
-    } else {
-      this.isVisibleInTrimmingContainer = true;
-    }
-
-    // If the estimation has reached the last row and there is still some space available in the viewport,
-    // we need to render in reverse in order to fill the whole viewport with rows
-    if (this.endRow === totalRows - 1 && needReverse) {
-      this.startRow = this.endRow;
-      while (this.startRow > 0) {
-        // rowHeight is the height of the last row
-        const viewportSum = startPositions[this.endRow] + rowHeight - startPositions[this.startRow - 1];
-        if (viewportSum <= viewportHeight - horizontalScrollbarHeight || calculationType !== FULLY_VISIBLE_TYPE) {
-          this.startRow -= 1;
-        }
-        if (viewportSum >= viewportHeight - horizontalScrollbarHeight) {
-          break;
-        }
-      }
-    }
-    if (calculationType === RENDER_TYPE && this.startRow !== null && overrideFn) {
-      overrideFn(this);
-    }
-    this.startPosition = startPositions[this.startRow];
-    if (this.startPosition === undefined) {
-      this.startPosition = null;
-    }
+    this._finalize(this);
+  }
 
-    // If totalRows exceeded its total rows size set endRow to the latest item
-    if (totalRows < this.endRow) {
-      this.endRow = totalRows - 1;
-    }
-    if (this.startRow !== null) {
-      this.count = this.endRow - this.startRow + 1;
+  /**
+   * Gets the row height at the specified row index.
+   *
+   * @param {number} row Row index.
+   * @returns {number}
+   */
+  getRowHeight(row) {
+    const rowHeight = this.rowHeightFn(row);
+    if (isNaN(rowHeight)) {
+      return DEFAULT_HEIGHT;
     }
+    return rowHeight;
   }
 }

package/3rdparty/walkontable/src/index.js

@@ -4,6 +4,8 @@ exports.__esModule = true;
 var _calculator = require("./calculator");
 exports.ViewportColumnsCalculator = _calculator.ViewportColumnsCalculator;
 exports.ViewportRowsCalculator = _calculator.ViewportRowsCalculator;
+exports.DEFAULT_ROW_HEIGHT = _calculator.DEFAULT_ROW_HEIGHT;
+exports.DEFAULT_COLUMN_WIDTH = _calculator.DEFAULT_COLUMN_WIDTH;
 var _coords = _interopRequireDefault(require("./cell/coords"));
 exports.CellCoords = _coords.default;
 var _range = _interopRequireDefault(require("./cell/range"));

package/3rdparty/walkontable/src/index.mjs

@@ -1,4 +1,4 @@
-import { ViewportColumnsCalculator, ViewportRowsCalculator } from "./calculator/index.mjs";
+import { ViewportColumnsCalculator, ViewportRowsCalculator, DEFAULT_ROW_HEIGHT, DEFAULT_COLUMN_WIDTH } from "./calculator/index.mjs";
 import CellCoords from "./cell/coords.mjs";
 import CellRange from "./cell/range.mjs";
 import Walkontable from "./facade/core.mjs";
@@ -6,4 +6,4 @@ import { Selection, ACTIVE_HEADER_TYPE, AREA_TYPE, FOCUS_TYPE, FILL_TYPE, HEADER
 import * as Renderer from "./renderer/index.mjs";
 import { OrderView, SharedOrderView } from "./utils/orderView/index.mjs";
 import { getListenersCounter } from "../../../eventManager.mjs";
-export { ViewportColumnsCalculator, ViewportRowsCalculator, CellCoords, CellRange, Walkontable as default, Walkontable as Core, Selection, ACTIVE_HEADER_TYPE as HIGHLIGHT_ACTIVE_HEADER_TYPE, AREA_TYPE as HIGHLIGHT_AREA_TYPE, FOCUS_TYPE as HIGHLIGHT_FOCUS_TYPE, FILL_TYPE as HIGHLIGHT_FILL_TYPE, HEADER_TYPE as HIGHLIGHT_HEADER_TYPE, ROW_TYPE as HIGHLIGHT_ROW_TYPE, COLUMN_TYPE as HIGHLIGHT_COLUMN_TYPE, CUSTOM_SELECTION_TYPE as HIGHLIGHT_CUSTOM_SELECTION_TYPE, Renderer, OrderView, SharedOrderView, getListenersCounter };
+export { DEFAULT_ROW_HEIGHT, DEFAULT_COLUMN_WIDTH, ViewportColumnsCalculator, ViewportRowsCalculator, CellCoords, CellRange, Walkontable as default, Walkontable as Core, Selection, ACTIVE_HEADER_TYPE as HIGHLIGHT_ACTIVE_HEADER_TYPE, AREA_TYPE as HIGHLIGHT_AREA_TYPE, FOCUS_TYPE as HIGHLIGHT_FOCUS_TYPE, FILL_TYPE as HIGHLIGHT_FILL_TYPE, HEADER_TYPE as HIGHLIGHT_HEADER_TYPE, ROW_TYPE as HIGHLIGHT_ROW_TYPE, COLUMN_TYPE as HIGHLIGHT_COLUMN_TYPE, CUSTOM_SELECTION_TYPE as HIGHLIGHT_CUSTOM_SELECTION_TYPE, Renderer, OrderView, SharedOrderView, getListenersCounter };

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

@@ -253,8 +253,9 @@ class Table {
     const columnHeadersCount = columnHeaders.length;
     let runFastDraw = fastDraw;
     if (this.isMaster) {
+      wtOverlays.beforeDraw();
       this.holderOffset = (0, _element.offset)(this.holder);
-      runFastDraw = wtViewport.createRenderCalculators(runFastDraw);
+      runFastDraw = wtViewport.createCalculators(runFastDraw);
       if (rowHeadersCount && !wtSettings.getSetting('fixedColumnsStart')) {
         const leftScrollPos = wtOverlays.inlineStartOverlay.getScrollPosition();
         const previousState = this.correctHeaderWidth;
@@ -264,16 +265,8 @@ class Table {
         }
       }
     }
-    if (this.isMaster) {
-      wtOverlays.beforeDraw();
-    }
     if (runFastDraw) {
       if (this.isMaster) {
-        // in case we only scrolled without redraw, update visible rows information in oldRowsCalculator
-        wtViewport.createVisibleCalculators();
-        wtViewport.createPartiallyVisibleCalculators();
-      }
-      if (wtOverlays) {
         wtOverlays.refresh(true);
       }
     } else {
@@ -314,8 +307,9 @@ class Table {
           this.markOversizedRows();
         }
         if (this.isMaster) {
-          wtViewport.createVisibleCalculators();
-          wtViewport.createPartiallyVisibleCalculators();
+          if (!this.wtSettings.getSetting('externalRowCalculator')) {
+            wtViewport.createVisibleCalculators();
+          }
           wtOverlays.refresh(false);
           wtOverlays.applyToDOM();
           const hiderWidth = (0, _element.outerWidth)(this.hider);

package/3rdparty/walkontable/src/table.mjs

@@ -249,8 +249,9 @@ class Table {
     const columnHeadersCount = columnHeaders.length;
     let runFastDraw = fastDraw;
     if (this.isMaster) {
+      wtOverlays.beforeDraw();
       this.holderOffset = offset(this.holder);
-      runFastDraw = wtViewport.createRenderCalculators(runFastDraw);
+      runFastDraw = wtViewport.createCalculators(runFastDraw);
       if (rowHeadersCount && !wtSettings.getSetting('fixedColumnsStart')) {
         const leftScrollPos = wtOverlays.inlineStartOverlay.getScrollPosition();
         const previousState = this.correctHeaderWidth;
@@ -260,16 +261,8 @@ class Table {
         }
       }
     }
-    if (this.isMaster) {
-      wtOverlays.beforeDraw();
-    }
     if (runFastDraw) {
       if (this.isMaster) {
-        // in case we only scrolled without redraw, update visible rows information in oldRowsCalculator
-        wtViewport.createVisibleCalculators();
-        wtViewport.createPartiallyVisibleCalculators();
-      }
-      if (wtOverlays) {
         wtOverlays.refresh(true);
       }
     } else {
@@ -310,8 +303,9 @@ class Table {
           this.markOversizedRows();
         }
         if (this.isMaster) {
-          wtViewport.createVisibleCalculators();
-          wtViewport.createPartiallyVisibleCalculators();
+          if (!this.wtSettings.getSetting('externalRowCalculator')) {
+            wtViewport.createVisibleCalculators();
+          }
           wtOverlays.refresh(false);
           wtOverlays.applyToDOM();
           const hiderWidth = outerWidth(this.hider);

package/3rdparty/walkontable/src/utils/column.js

@@ -51,7 +51,8 @@ class ColumnUtils {
    * @returns {number}
    */
   getWidth(sourceIndex) {
-    return this.wtSettings.getSetting('columnWidth', sourceIndex) || this.wtSettings.getSetting('defaultColumnWidth');
+    const width = this.wtSettings.getSetting('columnWidth', sourceIndex) || this.wtSettings.getSetting('defaultColumnWidth');
+    return width;
   }
 
   /**

package/3rdparty/walkontable/src/utils/column.mjs

@@ -48,7 +48,8 @@ export default class ColumnUtils {
    * @returns {number}
    */
   getWidth(sourceIndex) {
-    return this.wtSettings.getSetting('columnWidth', sourceIndex) || this.wtSettings.getSetting('defaultColumnWidth');
+    const width = this.wtSettings.getSetting('columnWidth', sourceIndex) || this.wtSettings.getSetting('defaultColumnWidth');
+    return width;
   }
 
   /**

package/3rdparty/walkontable/src/utils/columnStretching.js

@@ -2,6 +2,7 @@
 
 exports.__esModule = true;
 require("core-js/modules/es.error.cause.js");
+var _calculator = require("../calculator");
 function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
 function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
 function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
@@ -10,11 +11,6 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
 function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
 function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
 function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
-var _totalTargetWidth = /*#__PURE__*/new WeakMap();
-var _totalColumns = /*#__PURE__*/new WeakMap();
-var _stretchingColumnWidthFn = /*#__PURE__*/new WeakMap();
-var _columnWidthFn = /*#__PURE__*/new WeakMap();
-var _stretchMode = /*#__PURE__*/new WeakMap();
 /**
  * @typedef {object} ColumnStretchingOptions
  * @property {number} totalColumns Total number of columns.
@@ -25,20 +21,12 @@ var _stretchMode = /*#__PURE__*/new WeakMap();
 /**
  * @class ColumnStretching
  */
+var _totalTargetWidth = /*#__PURE__*/new WeakMap();
+var _totalColumns = /*#__PURE__*/new WeakMap();
+var _stretchingColumnWidthFn = /*#__PURE__*/new WeakMap();
+var _columnWidthFn = /*#__PURE__*/new WeakMap();
+var _stretchMode = /*#__PURE__*/new WeakMap();
 class ColumnStretching {
-  /**
-   * Default column width.
-   *
-   * @type {number}
-   */
-  static get DEFAULT_WIDTH() {
-    return 50;
-  }
-
-  /**
-   * @type {number}
-   */
-
   /**
    * @param {ColumnStretchingOptions} options Object with all options specified for column viewport calculation.
    */
@@ -49,6 +37,9 @@ class ColumnStretching {
       stretchingColumnWidthFn,
       columnWidthFn
     } = _ref;
+    /**
+     * @type {number}
+     */
     _defineProperty(this, "stretchAllRatio", 0);
     /**
      * @type {number}
@@ -198,7 +189,7 @@ class ColumnStretching {
   _getColumnWidth(column) {
     let width = _classPrivateFieldGet(_columnWidthFn, this).call(this, column);
     if (isNaN(width)) {
-      width = ColumnStretching.DEFAULT_WIDTH;
+      width = _calculator.DEFAULT_COLUMN_WIDTH;
     }
     return width;
   }

package/3rdparty/walkontable/src/utils/columnStretching.mjs

@@ -7,11 +7,7 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
 function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
 function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
 function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
-var _totalTargetWidth = /*#__PURE__*/new WeakMap();
-var _totalColumns = /*#__PURE__*/new WeakMap();
-var _stretchingColumnWidthFn = /*#__PURE__*/new WeakMap();
-var _columnWidthFn = /*#__PURE__*/new WeakMap();
-var _stretchMode = /*#__PURE__*/new WeakMap();
+import { DEFAULT_COLUMN_WIDTH } from "../calculator/index.mjs";
 /**
  * @typedef {object} ColumnStretchingOptions
  * @property {number} totalColumns Total number of columns.
@@ -22,20 +18,12 @@ var _stretchMode = /*#__PURE__*/new WeakMap();
 /**
  * @class ColumnStretching
  */
+var _totalTargetWidth = /*#__PURE__*/new WeakMap();
+var _totalColumns = /*#__PURE__*/new WeakMap();
+var _stretchingColumnWidthFn = /*#__PURE__*/new WeakMap();
+var _columnWidthFn = /*#__PURE__*/new WeakMap();
+var _stretchMode = /*#__PURE__*/new WeakMap();
 export class ColumnStretching {
-  /**
-   * Default column width.
-   *
-   * @type {number}
-   */
-  static get DEFAULT_WIDTH() {
-    return 50;
-  }
-
-  /**
-   * @type {number}
-   */
-
   /**
    * @param {ColumnStretchingOptions} options Object with all options specified for column viewport calculation.
    */
@@ -46,6 +34,9 @@ export class ColumnStretching {
       stretchingColumnWidthFn,
       columnWidthFn
     } = _ref;
+    /**
+     * @type {number}
+     */
     _defineProperty(this, "stretchAllRatio", 0);
     /**
      * @type {number}
@@ -195,7 +186,7 @@ export class ColumnStretching {
   _getColumnWidth(column) {
     let width = _classPrivateFieldGet(_columnWidthFn, this).call(this, column);
     if (isNaN(width)) {
-      width = ColumnStretching.DEFAULT_WIDTH;
+      width = DEFAULT_COLUMN_WIDTH;
     }
     return width;
   }

package/3rdparty/walkontable/src/viewport.js

@@ -31,6 +31,8 @@ class Viewport {
     this.rowHeaderWidth = NaN;
     this.rowsVisibleCalculator = null;
     this.columnsVisibleCalculator = null;
+    this.rowsCalculatorTypes = new Map([['rendered', () => this.wtSettings.getSetting('renderAllRows') ? new _calculator.RenderedAllRowsCalculationType() : new _calculator.RenderedRowsCalculationType()], ['fullyVisible', () => new _calculator.FullyVisibleRowsCalculationType()], ['partiallyVisible', () => new _calculator.PartiallyVisibleRowsCalculationType()]]);
+    this.columnsCalculatorTypes = new Map([['rendered', () => this.wtSettings.getSetting('renderAllColumns') ? new _calculator.RenderedAllColumnsCalculationType() : new _calculator.RenderedColumnsCalculationType()], ['fullyVisible', () => new _calculator.FullyVisibleColumnsCalculationType()], ['partiallyVisible', () => new _calculator.PartiallyVisibleColumnsCalculationType()]]);
     this.eventManager = eventManager;
     this.eventManager.addEventListener(this.domBindings.rootWindow, 'resize', () => {
       this.clientHeight = this.getWorkspaceHeight();
@@ -241,25 +243,20 @@ class Viewport {
   }
 
   /**
-   * Creates:
-   * - rowsRenderCalculator (before draw, to qualify rows for rendering)
-   * - rowsVisibleCalculator (after draw, to measure which rows are actually visible).
+   * Creates rows calculators. The type of the calculations can be chosen from the list:
+   *  - 'rendered' Calculates rows that should be rendered within the current table's viewport;
+   *  - 'fullyVisible' Calculates rows that are fully visible (used mostly for scrolling purposes);
+   *  - 'partiallyVisible' Calculates rows that are partially visible (used mostly for scrolling purposes).
    *
-   * @param {number} calculationType The render type ID, which determines for what type of
-   *                                 calculation calculator is created.
+   * @param {'rendered' | 'fullyVisible' | 'partiallyVisible'} calculatorTypes The list of the calculation types.
    * @returns {ViewportRowsCalculator}
    */
   createRowsCalculator() {
-    let calculationType = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _calculator.RENDER_TYPE;
+    let calculatorTypes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ['rendered', 'fullyVisible', 'partiallyVisible'];
     const {
       wtSettings,
       wtTable
     } = this;
-    if (wtSettings.getSetting('renderAllRows') && calculationType === _calculator.RENDER_TYPE) {
-      return new _calculator.RenderAllRowsCalculator({
-        totalRows: wtSettings.getSetting('totalRows')
-      });
-    }
     let height = this.getViewportHeight();
     let scrollbarHeight;
     let fixedRowsHeight;
@@ -283,36 +280,31 @@ class Viewport {
       scrollbarHeight = (0, _element.getScrollbarWidth)(this.domBindings.rootDocument);
     }
     return new _calculator.ViewportRowsCalculator({
+      calculationTypes: calculatorTypes.map(type => [type, this.rowsCalculatorTypes.get(type)()]),
       viewportHeight: height,
       scrollOffset: pos,
       totalRows: wtSettings.getSetting('totalRows'),
       rowHeightFn: sourceRow => wtTable.getRowHeight(sourceRow),
       overrideFn: wtSettings.getSettingPure('viewportRowCalculatorOverride'),
-      calculationType,
       horizontalScrollbarHeight: scrollbarHeight
     });
   }
 
   /**
-   * Creates:
-   * - columnsRenderCalculator (before draw, to qualify columns for rendering)
-   * - columnsVisibleCalculator (after draw, to measure which columns are actually visible).
+   * Creates columns calculators. The type of the calculations can be chosen from the list:
+   *  - 'rendered' Calculates columns that should be rendered within the current table's viewport;
+   *  - 'fullyVisible' Calculates columns that are fully visible (used mostly for scrolling purposes);
+   *  - 'partiallyVisible' Calculates columns that are partially visible (used mostly for scrolling purposes).
    *
-   * @param {number} calculationType The render type ID, which determines for what type of
-   *                                 calculation calculator is created.
+   * @param {'rendered' | 'fullyVisible' | 'partiallyVisible'} calculatorTypes The list of the calculation types.
    * @returns {ViewportColumnsCalculator}
    */
   createColumnsCalculator() {
-    let calculationType = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _calculator.RENDER_TYPE;
+    let calculatorTypes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ['rendered', 'fullyVisible', 'partiallyVisible'];
     const {
       wtSettings,
       wtTable
     } = this;
-    if (wtSettings.getSetting('renderAllColumns') && calculationType === _calculator.RENDER_TYPE) {
-      return new _calculator.RenderAllColumnsCalculator({
-        totalColumns: wtSettings.getSetting('totalColumns')
-      });
-    }
     let width = this.getViewportWidth();
     let pos = Math.abs(this.dataAccessObject.inlineStartScrollPosition) - this.dataAccessObject.inlineStartParentOffset;
     this.columnHeaderHeight = NaN;
@@ -326,12 +318,12 @@ class Viewport {
       width -= (0, _element.getScrollbarWidth)(this.domBindings.rootDocument);
     }
     return new _calculator.ViewportColumnsCalculator({
+      calculationTypes: calculatorTypes.map(type => [type, this.columnsCalculatorTypes.get(type)()]),
       viewportWidth: width,
       scrollOffset: pos,
       totalColumns: wtSettings.getSetting('totalColumns'),
       columnWidthFn: sourceCol => wtTable.getColumnWidth(sourceCol),
       overrideFn: wtSettings.getSettingPure('viewportColumnCalculatorOverride'),
-      calculationType,
       inlineStartOffset: this.dataAccessObject.inlineStartParentOffset
     });
   }
@@ -344,46 +336,43 @@ class Viewport {
    *                           If `false` or `undefined`, will perform a full redraw.
    * @returns {boolean} The fastDraw value, possibly modified.
    */
-  createRenderCalculators() {
+  createCalculators() {
     let fastDraw = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
     const {
       wtSettings
     } = this;
+    const rowsCalculator = this.createRowsCalculator();
+    const columnsCalculator = this.createColumnsCalculator();
     if (fastDraw && !wtSettings.getSetting('renderAllRows')) {
-      const proposedRowsVisibleCalculator = this.createRowsCalculator(_calculator.FULLY_VISIBLE_TYPE);
+      const proposedRowsVisibleCalculator = rowsCalculator.getResultsFor('fullyVisible');
       fastDraw = this.areAllProposedVisibleRowsAlreadyRendered(proposedRowsVisibleCalculator);
     }
     if (fastDraw && !wtSettings.getSetting('renderAllColumns')) {
-      const proposedColumnsVisibleCalculator = this.createColumnsCalculator(_calculator.FULLY_VISIBLE_TYPE);
+      const proposedColumnsVisibleCalculator = columnsCalculator.getResultsFor('fullyVisible');
       fastDraw = this.areAllProposedVisibleColumnsAlreadyRendered(proposedColumnsVisibleCalculator);
     }
     if (!fastDraw) {
-      this.rowsRenderCalculator = this.createRowsCalculator(_calculator.RENDER_TYPE);
-      this.columnsRenderCalculator = this.createColumnsCalculator(_calculator.RENDER_TYPE);
+      this.rowsRenderCalculator = rowsCalculator.getResultsFor('rendered');
+      this.columnsRenderCalculator = columnsCalculator.getResultsFor('rendered');
     }
-
-    // delete temporarily to make sure that renderers always use rowsRenderCalculator, not rowsVisibleCalculator
-    this.rowsVisibleCalculator = null;
-    this.columnsVisibleCalculator = null;
+    this.rowsVisibleCalculator = rowsCalculator.getResultsFor('fullyVisible');
+    this.columnsVisibleCalculator = columnsCalculator.getResultsFor('fullyVisible');
+    this.rowsPartiallyVisibleCalculator = rowsCalculator.getResultsFor('partiallyVisible');
+    this.columnsPartiallyVisibleCalculator = columnsCalculator.getResultsFor('partiallyVisible');
     return fastDraw;
   }
 
   /**
-   * Creates rowsVisibleCalculator and columnsVisibleCalculator (after draw, to determine what are
-   * the actually fully visible rows and columns).
+   * Creates rows and columns calculators (after draw, to determine what are
+   * the actually fully visible and partially visible rows and columns).
    */
   createVisibleCalculators() {
-    this.rowsVisibleCalculator = this.createRowsCalculator(_calculator.FULLY_VISIBLE_TYPE);
-    this.columnsVisibleCalculator = this.createColumnsCalculator(_calculator.FULLY_VISIBLE_TYPE);
-  }
-
-  /**
-   * Creates rowsPartiallyVisibleCalculator and columnsPartiallyVisibleCalculator (after draw, to determine what are
-   * the actually partially visible rows and columns).
-   */
-  createPartiallyVisibleCalculators() {
-    this.rowsPartiallyVisibleCalculator = this.createRowsCalculator(_calculator.PARTIALLY_VISIBLE_TYPE);
-    this.columnsPartiallyVisibleCalculator = this.createColumnsCalculator(_calculator.PARTIALLY_VISIBLE_TYPE);
+    const rowsCalculator = this.createRowsCalculator(['fullyVisible', 'partiallyVisible']);
+    const columnsCalculator = this.createColumnsCalculator(['fullyVisible', 'partiallyVisible']);
+    this.rowsVisibleCalculator = rowsCalculator.getResultsFor('fullyVisible');
+    this.columnsVisibleCalculator = columnsCalculator.getResultsFor('fullyVisible');
+    this.rowsPartiallyVisibleCalculator = rowsCalculator.getResultsFor('partiallyVisible');
+    this.columnsPartiallyVisibleCalculator = columnsCalculator.getResultsFor('partiallyVisible');
   }
 
   /**