handsontable 0.0.0-next-9891faa-20240822 → 0.0.0-next-0306a1a-20240826

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

@@ -1,61 +1,84 @@
 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); }
-import { ViewportBaseCalculator } from "./viewportBase.mjs";
-export const DEFAULT_HEIGHT = 23;
-
+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";
 /**
  * @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 allows to adjust the `startRow` and `endRow` parameters.
+ * @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 {number} horizontalScrollbarHeight The scrollbar height.
  */
 /**
- * Calculates indexes of rows to render OR rows that are visible OR partially visible in the viewport.
+ * Calculates indexes of rows to render OR rows that are visible.
+ * To redo the calculation, you need to create a new calculator.
  *
  * @class ViewportRowsCalculator
  */
-export class ViewportRowsCalculator extends ViewportBaseCalculator {
+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}
+   */
+
   /**
    * @param {ViewportRowsCalculatorOptions} options Object with all options specified for row viewport calculation.
    */
-  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;
+  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);
     this.calculate();
   }
 
@@ -63,31 +86,90 @@ export class ViewportRowsCalculator extends ViewportBaseCalculator {
    * Calculates viewport.
    */
   calculate() {
-    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;
+    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;
         break;
       }
     }
-    this._finalize(this);
-  }
+    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;
+    }
 
-  /**
-   * 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;
+    // 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;
+    }
+
+    // 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;
     }
-    return rowHeight;
   }
 }

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

@@ -4,8 +4,6 @@ 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, DEFAULT_ROW_HEIGHT, DEFAULT_COLUMN_WIDTH } from "./calculator/index.mjs";
+import { ViewportColumnsCalculator, ViewportRowsCalculator } 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 { 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 };
+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 };

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

@@ -253,9 +253,8 @@ class Table {
     const columnHeadersCount = columnHeaders.length;
     let runFastDraw = fastDraw;
     if (this.isMaster) {
-      wtOverlays.beforeDraw();
       this.holderOffset = (0, _element.offset)(this.holder);
-      runFastDraw = wtViewport.createCalculators(runFastDraw);
+      runFastDraw = wtViewport.createRenderCalculators(runFastDraw);
       if (rowHeadersCount && !wtSettings.getSetting('fixedColumnsStart')) {
         const leftScrollPos = wtOverlays.inlineStartOverlay.getScrollPosition();
         const previousState = this.correctHeaderWidth;
@@ -265,8 +264,16 @@ 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 {
@@ -307,9 +314,8 @@ class Table {
           this.markOversizedRows();
         }
         if (this.isMaster) {
-          if (!this.wtSettings.getSetting('externalRowCalculator')) {
-            wtViewport.createVisibleCalculators();
-          }
+          wtViewport.createVisibleCalculators();
+          wtViewport.createPartiallyVisibleCalculators();
           wtOverlays.refresh(false);
           wtOverlays.applyToDOM();
           const hiderWidth = (0, _element.outerWidth)(this.hider);

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

@@ -249,9 +249,8 @@ class Table {
     const columnHeadersCount = columnHeaders.length;
     let runFastDraw = fastDraw;
     if (this.isMaster) {
-      wtOverlays.beforeDraw();
       this.holderOffset = offset(this.holder);
-      runFastDraw = wtViewport.createCalculators(runFastDraw);
+      runFastDraw = wtViewport.createRenderCalculators(runFastDraw);
       if (rowHeadersCount && !wtSettings.getSetting('fixedColumnsStart')) {
         const leftScrollPos = wtOverlays.inlineStartOverlay.getScrollPosition();
         const previousState = this.correctHeaderWidth;
@@ -261,8 +260,16 @@ 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 {
@@ -303,9 +310,8 @@ class Table {
           this.markOversizedRows();
         }
         if (this.isMaster) {
-          if (!this.wtSettings.getSetting('externalRowCalculator')) {
-            wtViewport.createVisibleCalculators();
-          }
+          wtViewport.createVisibleCalculators();
+          wtViewport.createPartiallyVisibleCalculators();
           wtOverlays.refresh(false);
           wtOverlays.applyToDOM();
           const hiderWidth = outerWidth(this.hider);

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

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

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

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

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

@@ -2,7 +2,6 @@
 
 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; }
@@ -11,6 +10,11 @@ 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.
@@ -21,12 +25,20 @@ function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.h
 /**
  * @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.
    */
@@ -37,9 +49,6 @@ class ColumnStretching {
       stretchingColumnWidthFn,
       columnWidthFn
     } = _ref;
-    /**
-     * @type {number}
-     */
     _defineProperty(this, "stretchAllRatio", 0);
     /**
      * @type {number}
@@ -189,7 +198,7 @@ class ColumnStretching {
   _getColumnWidth(column) {
     let width = _classPrivateFieldGet(_columnWidthFn, this).call(this, column);
     if (isNaN(width)) {
-      width = _calculator.DEFAULT_COLUMN_WIDTH;
+      width = ColumnStretching.DEFAULT_WIDTH;
     }
     return width;
   }

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

@@ -7,7 +7,11 @@ 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"); }
-import { DEFAULT_COLUMN_WIDTH } from "../calculator/index.mjs";
+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.
@@ -18,12 +22,20 @@ import { DEFAULT_COLUMN_WIDTH } from "../calculator/index.mjs";
 /**
  * @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.
    */
@@ -34,9 +46,6 @@ export class ColumnStretching {
       stretchingColumnWidthFn,
       columnWidthFn
     } = _ref;
-    /**
-     * @type {number}
-     */
     _defineProperty(this, "stretchAllRatio", 0);
     /**
      * @type {number}
@@ -186,7 +195,7 @@ export class ColumnStretching {
   _getColumnWidth(column) {
     let width = _classPrivateFieldGet(_columnWidthFn, this).call(this, column);
     if (isNaN(width)) {
-      width = DEFAULT_COLUMN_WIDTH;
+      width = ColumnStretching.DEFAULT_WIDTH;
     }
     return width;
   }

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

@@ -31,8 +31,6 @@ 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();
@@ -243,20 +241,25 @@ class Viewport {
   }
 
   /**
-   * 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).
+   * Creates:
+   * - rowsRenderCalculator (before draw, to qualify rows for rendering)
+   * - rowsVisibleCalculator (after draw, to measure which rows are actually visible).
    *
-   * @param {'rendered' | 'fullyVisible' | 'partiallyVisible'} calculatorTypes The list of the calculation types.
+   * @param {number} calculationType The render type ID, which determines for what type of
+   *                                 calculation calculator is created.
    * @returns {ViewportRowsCalculator}
    */
   createRowsCalculator() {
-    let calculatorTypes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ['rendered', 'fullyVisible', 'partiallyVisible'];
+    let calculationType = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _calculator.RENDER_TYPE;
     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;
@@ -280,31 +283,36 @@ 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 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).
+   * Creates:
+   * - columnsRenderCalculator (before draw, to qualify columns for rendering)
+   * - columnsVisibleCalculator (after draw, to measure which columns are actually visible).
    *
-   * @param {'rendered' | 'fullyVisible' | 'partiallyVisible'} calculatorTypes The list of the calculation types.
+   * @param {number} calculationType The render type ID, which determines for what type of
+   *                                 calculation calculator is created.
    * @returns {ViewportColumnsCalculator}
    */
   createColumnsCalculator() {
-    let calculatorTypes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ['rendered', 'fullyVisible', 'partiallyVisible'];
+    let calculationType = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _calculator.RENDER_TYPE;
     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;
@@ -318,12 +326,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
     });
   }
@@ -336,43 +344,46 @@ class Viewport {
    *                           If `false` or `undefined`, will perform a full redraw.
    * @returns {boolean} The fastDraw value, possibly modified.
    */
-  createCalculators() {
+  createRenderCalculators() {
     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 = rowsCalculator.getResultsFor('fullyVisible');
+      const proposedRowsVisibleCalculator = this.createRowsCalculator(_calculator.FULLY_VISIBLE_TYPE);
       fastDraw = this.areAllProposedVisibleRowsAlreadyRendered(proposedRowsVisibleCalculator);
     }
     if (fastDraw && !wtSettings.getSetting('renderAllColumns')) {
-      const proposedColumnsVisibleCalculator = columnsCalculator.getResultsFor('fullyVisible');
+      const proposedColumnsVisibleCalculator = this.createColumnsCalculator(_calculator.FULLY_VISIBLE_TYPE);
       fastDraw = this.areAllProposedVisibleColumnsAlreadyRendered(proposedColumnsVisibleCalculator);
     }
     if (!fastDraw) {
-      this.rowsRenderCalculator = rowsCalculator.getResultsFor('rendered');
-      this.columnsRenderCalculator = columnsCalculator.getResultsFor('rendered');
+      this.rowsRenderCalculator = this.createRowsCalculator(_calculator.RENDER_TYPE);
+      this.columnsRenderCalculator = this.createColumnsCalculator(_calculator.RENDER_TYPE);
     }
-    this.rowsVisibleCalculator = rowsCalculator.getResultsFor('fullyVisible');
-    this.columnsVisibleCalculator = columnsCalculator.getResultsFor('fullyVisible');
-    this.rowsPartiallyVisibleCalculator = rowsCalculator.getResultsFor('partiallyVisible');
-    this.columnsPartiallyVisibleCalculator = columnsCalculator.getResultsFor('partiallyVisible');
+
+    // delete temporarily to make sure that renderers always use rowsRenderCalculator, not rowsVisibleCalculator
+    this.rowsVisibleCalculator = null;
+    this.columnsVisibleCalculator = null;
     return fastDraw;
   }
 
   /**
-   * Creates rows and columns calculators (after draw, to determine what are
-   * the actually fully visible and partially visible rows and columns).
+   * Creates rowsVisibleCalculator and columnsVisibleCalculator (after draw, to determine what are
+   * the actually fully visible rows and columns).
    */
   createVisibleCalculators() {
-    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');
+    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);
   }
 
   /**