handsontable 0.0.0-next-a7809f3-20240708 → 0.0.0-next-b799724-20240710

package/plugins/autoRowSize/autoRowSize.js

@@ -2,22 +2,24 @@
 
 exports.__esModule = true;
 require("core-js/modules/es.error.cause.js");
+require("core-js/modules/es.array.push.js");
 var _base = require("../base");
-var _array = require("../../helpers/array");
 var _feature = require("../../helpers/feature");
-var _element = require("../../helpers/dom/element");
 var _ghostTable = _interopRequireDefault(require("../../utils/ghostTable"));
 var _object = require("../../helpers/object");
 var _number = require("../../helpers/number");
 var _samplesGenerator = _interopRequireDefault(require("../../utils/samplesGenerator"));
 var _string = require("../../helpers/string");
 var _translations = require("../../translations");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
-function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
+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 _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
+function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
 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"); }
 const PLUGIN_KEY = exports.PLUGIN_KEY = 'autoRowSize';
 const PLUGIN_PRIORITY = exports.PLUGIN_PRIORITY = 40;
@@ -107,6 +109,7 @@ const ROW_WIDTHS_MAP_NAME = 'autoRowSize';
  * :::
  */
 /* eslint-enable jsdoc/require-description-complete-sentence */
+var _visualRowsToRefresh = /*#__PURE__*/new WeakMap();
 var _AutoRowSize_brand = /*#__PURE__*/new WeakSet();
 class AutoRowSize extends _base.BasePlugin {
   static get PLUGIN_KEY() {
@@ -135,7 +138,9 @@ class AutoRowSize extends _base.BasePlugin {
   constructor(hotInstance) {
     super(hotInstance);
     /**
-     * On before view render listener.
+     * Calculates specific rows height (overwrite cache values).
+     *
+     * @param {number[]} visualRows List of visual rows to calculate.
      */
     _classPrivateMethodInitSpec(this, _AutoRowSize_brand);
     _defineProperty(this, "headerHeight", null);
@@ -175,13 +180,6 @@ class AutoRowSize extends _base.BasePlugin {
         value: cellValue
       };
     }));
-    /**
-     * `true` if only the first calculation was performed.
-     *
-     * @private
-     * @type {boolean}
-     */
-    _defineProperty(this, "firstCalculation", true);
     /**
      * `true` if the size calculation is in progress.
      *
@@ -201,6 +199,12 @@ class AutoRowSize extends _base.BasePlugin {
      * @type {PhysicalIndexToValueMap}
      */
     _defineProperty(this, "rowHeightsMap", new _translations.PhysicalIndexToValueMap());
+    /**
+     * An array of row indexes whose height will be recalculated.
+     *
+     * @type {number[]}
+     */
+    _classPrivateFieldInitSpec(this, _visualRowsToRefresh, []);
     this.hot.rowIndexMapper.registerMap(ROW_WIDTHS_MAP_NAME, this.rowHeightsMap);
 
     // Leave the listener active to allow auto-sizing the rows when the plugin is disabled.
@@ -234,10 +238,22 @@ class AutoRowSize extends _base.BasePlugin {
       }
       return _assertClassBrand(_AutoRowSize_brand, _this, _onAfterLoadData).call(_this, ...args);
     });
-    this.addHook('beforeChangeRender', changes => _assertClassBrand(_AutoRowSize_brand, this, _onBeforeChange).call(this, changes));
+    this.addHook('beforeChangeRender', function () {
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      return _assertClassBrand(_AutoRowSize_brand, _this, _onBeforeChange).call(_this, ...args);
+    });
     this.addHook('beforeColumnResize', () => this.recalculateAllRowsHeight());
-    this.addHook('beforeViewRender', force => _assertClassBrand(_AutoRowSize_brand, this, _onBeforeViewRender).call(this, force));
+    this.addHook('afterFormulasValuesUpdate', function () {
+      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+        args[_key3] = arguments[_key3];
+      }
+      return _assertClassBrand(_AutoRowSize_brand, _this, _onAfterFormulasValuesUpdate).call(_this, ...args);
+    });
+    this.addHook('beforeRender', () => _assertClassBrand(_AutoRowSize_brand, this, _onBeforeRender).call(this));
     this.addHook('modifyRowHeight', (height, row) => this.getRowHeight(row, height));
+    this.addHook('init', () => _assertClassBrand(_AutoRowSize_brand, this, _onInit).call(this));
     this.addHook('modifyColumnHeaderHeight', () => this.getColumnHeaderHeight());
     super.enablePlugin();
   }
@@ -250,16 +266,36 @@ class AutoRowSize extends _base.BasePlugin {
     super.disablePlugin();
 
     // Leave the listener active to allow auto-sizing the rows when the plugin is disabled.
-    // This is necesseary for height recalculation for resize handler doubleclick (ManualRowResize).
+    // This is necessary for height recalculation for resize handler doubleclick (ManualRowResize).
     this.addHook('beforeRowResize', (size, row, isDblClick) => _assertClassBrand(_AutoRowSize_brand, this, _onBeforeRowResize).call(this, size, row, isDblClick));
   }
 
+  /**
+   * Calculates heights for visible rows in the viewport only.
+   */
+  calculateVisibleRowsHeight() {
+    // Keep last row heights unchanged for situation when all columns was deleted or trimmed
+    if (!this.hot.countCols()) {
+      return;
+    }
+    const firstVisibleRow = this.getFirstVisibleRow();
+    const lastVisibleRow = this.getLastVisibleRow();
+    if (firstVisibleRow === -1 || lastVisibleRow === -1) {
+      return;
+    }
+    const overwriteCache = this.hot.renderCall;
+    this.calculateRowsHeight({
+      from: firstVisibleRow,
+      to: lastVisibleRow
+    }, undefined, overwriteCache);
+  }
+
   /**
    * Calculate a given rows height.
    *
    * @param {number|object} rowRange Row index or an object with `from` and `to` indexes as a range.
    * @param {number|object} colRange Column index or an object with `from` and `to` indexes as a range.
-   * @param {boolean} [force=false] If `true` the calculation will be processed regardless of whether the width exists in the cache.
+   * @param {boolean} [overwriteCache=false] If `true` the calculation will be processed regardless of whether the width exists in the cache.
    */
   calculateRowsHeight() {
     let rowRange = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
@@ -270,8 +306,7 @@ class AutoRowSize extends _base.BasePlugin {
       from: 0,
       to: this.hot.countCols() - 1
     };
-    let force = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-    // eslint-disable-line max-len
+    let overwriteCache = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
     const rowsRange = typeof rowRange === 'number' ? {
       from: rowRange,
       to: rowRange
@@ -284,15 +319,17 @@ class AutoRowSize extends _base.BasePlugin {
       const samples = this.samplesGenerator.generateRowSamples(-1, columnsRange);
       this.ghostTable.addColumnHeadersRow(samples.get(-1));
     }
-    (0, _number.rangeEach)(rowsRange.from, rowsRange.to, row => {
+    (0, _number.rangeEach)(rowsRange.from, rowsRange.to, visualRow => {
+      let physicalRow = this.hot.toPhysicalRow(visualRow);
+      if (physicalRow === null) {
+        physicalRow = visualRow;
+      }
+
       // For rows we must calculate row height even when user had set height value manually.
       // We can shrink column but cannot shrink rows!
-      if (force || this.rowHeightsMap.getValueAtIndex(row) === null) {
-        const samples = this.samplesGenerator.generateRowSamples(row, columnsRange);
-        (0, _array.arrayEach)(samples, _ref => {
-          let [rowIndex, sample] = _ref;
-          return this.ghostTable.addRow(rowIndex, sample);
-        });
+      if (overwriteCache || this.rowHeightsMap.getValueAtIndex(physicalRow) === null) {
+        const samples = this.samplesGenerator.generateRowSamples(visualRow, columnsRange);
+        samples.forEach((sample, row) => this.ghostTable.addRow(row, sample));
       }
     });
     if (this.ghostTable.rows.length) {
@@ -315,12 +352,14 @@ class AutoRowSize extends _base.BasePlugin {
    * To retrieve height for specified row use {@link AutoRowSize#getRowHeight} method.
    *
    * @param {object|number} colRange Row index or an object with `from` and `to` properties which define row range.
+   * @param {boolean} [overwriteCache] If `true` the calculation will be processed regardless of whether the width exists in the cache.
    */
   calculateAllRowsHeight() {
     let colRange = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
       from: 0,
       to: this.hot.countCols() - 1
     };
+    let overwriteCache = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
     let current = 0;
     const length = this.hot.countRows() - 1;
     let timer = null;
@@ -335,7 +374,7 @@ class AutoRowSize extends _base.BasePlugin {
       this.calculateRowsHeight({
         from: current,
         to: Math.min(current + AutoRowSize.CALCULATION_STEP, length)
-      }, colRange);
+      }, colRange, overwriteCache);
       current = current + AutoRowSize.CALCULATION_STEP + 1;
       if (current < length) {
         timer = (0, _feature.requestAnimationFrame)(loop);
@@ -355,12 +394,11 @@ class AutoRowSize extends _base.BasePlugin {
     const syncLimit = this.getSyncCalculationLimit();
 
     // sync
-    if (this.firstCalculation && syncLimit >= 0) {
+    if (syncLimit >= 0) {
       this.calculateRowsHeight({
         from: 0,
         to: syncLimit
-      }, colRange);
-      this.firstCalculation = false;
+      }, colRange, overwriteCache);
       current = syncLimit + 1;
     }
     // async
@@ -371,7 +409,6 @@ class AutoRowSize extends _base.BasePlugin {
       this.hot.view.adjustElementsSize();
     }
   }
-
   /**
    * Sets the sampling options.
    *
@@ -393,9 +430,11 @@ class AutoRowSize extends _base.BasePlugin {
    * Recalculates all rows height (overwrite cache values).
    */
   recalculateAllRowsHeight() {
-    if ((0, _element.isVisible)(this.hot.view._wt.wtTable.TABLE)) {
-      this.clearCache();
-      this.calculateAllRowsHeight();
+    if (this.hot.view.isVisible()) {
+      this.calculateAllRowsHeight({
+        from: 0,
+        to: this.hot.countCols() - 1
+      }, true);
     }
   }
 
@@ -435,8 +474,7 @@ class AutoRowSize extends _base.BasePlugin {
    * @param {number} [defaultHeight] If no height is found, `defaultHeight` is returned instead.
    * @returns {number} The height of the specified row, in pixels.
    */
-  getRowHeight(row) {
-    let defaultHeight = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
+  getRowHeight(row, defaultHeight) {
     const cachedHeight = row < 0 ? this.headerHeight : this.rowHeightsMap.getValueAtIndex(this.hot.toPhysicalRow(row));
     let height = defaultHeight;
     if (cachedHeight !== null && cachedHeight > (defaultHeight || 0)) {
@@ -460,14 +498,8 @@ class AutoRowSize extends _base.BasePlugin {
    * @returns {number} Returns row index, -1 if table is not rendered or if there are no rows to base the the calculations on.
    */
   getFirstVisibleRow() {
-    const wot = this.hot.view._wt;
-    if (wot.wtViewport.rowsVisibleCalculator) {
-      return wot.wtTable.getFirstVisibleRow();
-    }
-    if (wot.wtViewport.rowsRenderCalculator) {
-      return wot.wtTable.getFirstRenderedRow();
-    }
-    return -1;
+    var _this$hot$view$getFir;
+    return (_this$hot$view$getFir = this.hot.view.getFirstRenderedVisibleRow()) !== null && _this$hot$view$getFir !== void 0 ? _this$hot$view$getFir : -1;
   }
 
   /**
@@ -476,22 +508,27 @@ class AutoRowSize extends _base.BasePlugin {
    * @returns {number} Returns row index or -1 if table is not rendered.
    */
   getLastVisibleRow() {
-    const wot = this.hot.view._wt;
-    if (wot.wtViewport.rowsVisibleCalculator) {
-      return wot.wtTable.getLastVisibleRow();
-    }
-    if (wot.wtViewport.rowsRenderCalculator) {
-      return wot.wtTable.getLastRenderedRow();
-    }
-    return -1;
+    var _this$hot$view$getLas;
+    return (_this$hot$view$getLas = this.hot.view.getLastRenderedVisibleRow()) !== null && _this$hot$view$getLas !== void 0 ? _this$hot$view$getLas : -1;
   }
 
   /**
-   * Clears cached heights.
+   * Clears cache of calculated row heights. If you want to clear only selected rows pass an array with their indexes.
+   * Otherwise whole cache will be cleared.
+   *
+   * @param {number[]} [physicalRows] List of physical row indexes to clear.
    */
-  clearCache() {
+  clearCache(physicalRows) {
     this.headerHeight = null;
-    this.rowHeightsMap.init();
+    if (Array.isArray(physicalRows)) {
+      this.hot.batchExecution(() => {
+        physicalRows.forEach(physicalIndex => {
+          this.rowHeightsMap.setValueAtIndex(physicalIndex, null);
+        });
+      }, true);
+    } else {
+      this.rowHeightsMap.clear();
+    }
   }
 
   /**
@@ -520,8 +557,13 @@ class AutoRowSize extends _base.BasePlugin {
    * @returns {boolean}
    */
   isNeedRecalculate() {
-    return !!(0, _array.arrayFilter)(this.rowHeightsMap.getValues().slice(0, this.measuredRows), item => item === null).length;
+    return !!this.rowHeightsMap.getValues().slice(0, this.measuredRows).filter(item => item === null).length;
   }
+
+  /**
+   * On before view render listener.
+   */
+
   /**
    * Destroys the plugin instance.
    */
@@ -531,29 +573,32 @@ class AutoRowSize extends _base.BasePlugin {
   }
 }
 exports.AutoRowSize = AutoRowSize;
-function _onBeforeViewRender() {
-  const force = this.hot.renderCall;
-  const fixedRowsBottom = this.hot.getSettings().fixedRowsBottom;
-  const firstVisibleRow = this.getFirstVisibleRow();
-  const lastVisibleRow = this.getLastVisibleRow();
-  if (firstVisibleRow === -1 || lastVisibleRow === -1) {
-    return;
-  }
-  this.calculateRowsHeight({
-    from: firstVisibleRow,
-    to: lastVisibleRow
-  }, undefined, force);
-
-  // Calculate rows height synchronously for bottom overlay
-  if (fixedRowsBottom) {
-    const totalRows = this.hot.countRows() - 1;
-    this.calculateRowsHeight({
-      from: totalRows - fixedRowsBottom,
-      to: totalRows
-    });
+function _calculateSpecificRowsHeight(visualRows) {
+  const columnsRange = {
+    from: 0,
+    to: this.hot.countCols() - 1
+  };
+  visualRows.forEach(visualRow => {
+    // For rows we must calculate row height even when user had set height value manually.
+    // We can shrink column but cannot shrink rows!
+    const samples = this.samplesGenerator.generateRowSamples(visualRow, columnsRange);
+    samples.forEach((sample, row) => this.ghostTable.addRow(row, sample));
+  });
+  if (this.ghostTable.rows.length) {
+    this.hot.batchExecution(() => {
+      this.ghostTable.getHeights((visualRow, height) => {
+        const physicalRow = this.hot.toPhysicalRow(visualRow);
+        this.rowHeightsMap.setValueAtIndex(physicalRow, height);
+      });
+    }, true);
+    this.ghostTable.clean();
   }
-  if (this.isNeedRecalculate() && !this.inProgress) {
-    this.calculateAllRowsHeight();
+}
+function _onBeforeRender() {
+  this.calculateVisibleRowsHeight();
+  if (!this.inProgress) {
+    _assertClassBrand(_AutoRowSize_brand, this, _calculateSpecificRowsHeight).call(this, _classPrivateFieldGet(_visualRowsToRefresh, this));
+    _classPrivateFieldSet(_visualRowsToRefresh, this, []);
   }
 }
 /**
@@ -574,17 +619,13 @@ function _onBeforeRowResize(size, row, isDblClick) {
 }
 /**
  * On after load data listener.
+ *
+ * @param {Array} sourceData Source data.
+ * @param {boolean} isFirstLoad `true` if this is the first load.
  */
-function _onAfterLoadData() {
-  if (this.hot.view) {
+function _onAfterLoadData(sourceData, isFirstLoad) {
+  if (!isFirstLoad) {
     this.recalculateAllRowsHeight();
-  } else {
-    // first load - initialization
-    this.hot._registerTimeout(() => {
-      if (this.hot) {
-        this.recalculateAllRowsHeight();
-      }
-    });
   }
 }
 /**
@@ -593,16 +634,37 @@ function _onAfterLoadData() {
  * @param {Array} changes 2D array containing information about each of the edited cells.
  */
 function _onBeforeChange(changes) {
-  let range = null;
-  if (changes.length === 1) {
-    range = changes[0][0];
-  } else if (changes.length > 1) {
-    range = {
-      from: changes[0][0],
-      to: changes[changes.length - 1][0]
-    };
-  }
-  if (range !== null) {
-    this.clearCacheByRange(range);
-  }
+  const changedRows = changes.reduce((acc, _ref) => {
+    let [row] = _ref;
+    if (acc.indexOf(row) === -1) {
+      acc.push(row);
+    }
+    return acc;
+  }, []);
+  _classPrivateFieldGet(_visualRowsToRefresh, this).push(...changedRows);
+}
+/**
+ * On after Handsontable init plugin with all necessary values.
+ */
+function _onInit() {
+  this.recalculateAllRowsHeight();
+}
+/**
+ * After formulas values updated listener.
+ *
+ * @param {Array} changes An array of modified data.
+ */
+function _onAfterFormulasValuesUpdate(changes) {
+  const changedRows = changes.reduce((acc, change) => {
+    var _change$address;
+    const physicalRow = (_change$address = change.address) === null || _change$address === void 0 ? void 0 : _change$address.row;
+    if (Number.isInteger(physicalRow)) {
+      const visualRow = this.hot.toVisualRow(physicalRow);
+      if (acc.indexOf(visualRow) === -1) {
+        acc.push(visualRow);
+      }
+    }
+    return acc;
+  }, []);
+  _classPrivateFieldGet(_visualRowsToRefresh, this).push(...changedRows);
 }