handsontable 0.0.0-next-802f59c-20241024 → 0.0.0-next-adeb5a2-20241025

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

@@ -0,0 +1,193 @@
+import "core-js/modules/es.error.cause.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 { DEFAULT_COLUMN_WIDTH } from "../calculator/index.mjs";
+/**
+ * @typedef {object} ColumnStretchingOptions
+ * @property {number} totalColumns Total number of columns.
+ * @property {Function} columnWidthFn Function that returns the width of the column at a given index (in px).
+ * @property {'all' | 'last' | 'none'} stretchMode Stretch mode 'all', 'last' or 'none'.
+ * @property {Function} stretchingColumnWidthFn Function that returns the new width of the stretched column.
+ */
+/**
+ * @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 {
+  /**
+   * @param {ColumnStretchingOptions} options Object with all options specified for column viewport calculation.
+   */
+  constructor(_ref) {
+    let {
+      totalColumns,
+      stretchMode,
+      stretchingColumnWidthFn,
+      columnWidthFn
+    } = _ref;
+    /**
+     * @type {number}
+     */
+    _defineProperty(this, "stretchAllRatio", 0);
+    /**
+     * @type {number}
+     */
+    _defineProperty(this, "stretchLastWidth", 0);
+    /**
+     * @type {number[]}
+     */
+    _defineProperty(this, "stretchAllColumnsWidth", []);
+    /**
+     * @type {number}
+     */
+    _classPrivateFieldInitSpec(this, _totalTargetWidth, 0);
+    /**
+     * @type {boolean}
+     */
+    _defineProperty(this, "needVerifyLastColumnWidth", true);
+    /**
+     * The total number of columns.
+     *
+     * @type {function(): number}
+     */
+    _classPrivateFieldInitSpec(this, _totalColumns, () => 0);
+    /**
+     * Function that returns the width of the stretched column at a given index (in px).
+     *
+     * @type {function(): number}
+     */
+    _classPrivateFieldInitSpec(this, _stretchingColumnWidthFn, width => width);
+    /**
+     * Function that returns the width of the column at a given index (in px).
+     *
+     * @type {function(): number}
+     */
+    _classPrivateFieldInitSpec(this, _columnWidthFn, width => width);
+    /**
+     * Stretch mode.
+     *
+     * @type {function(): 'all' | 'last' | 'none'}
+     */
+    _classPrivateFieldInitSpec(this, _stretchMode, () => 'none');
+    _classPrivateFieldSet(_totalColumns, this, totalColumns);
+    _classPrivateFieldSet(_stretchMode, this, stretchMode);
+    _classPrivateFieldSet(_stretchingColumnWidthFn, this, stretchingColumnWidthFn !== null && stretchingColumnWidthFn !== void 0 ? stretchingColumnWidthFn : _classPrivateFieldGet(_stretchingColumnWidthFn, this));
+    _classPrivateFieldSet(_columnWidthFn, this, columnWidthFn !== null && columnWidthFn !== void 0 ? columnWidthFn : _classPrivateFieldGet(_columnWidthFn, this));
+  }
+
+  /**
+   * Recalculate columns stretching.
+   *
+   * @param {number} totalWidth The total width of the table.
+   */
+  refreshStretching(totalWidth) {
+    if (_classPrivateFieldGet(_stretchMode, this).call(this) === 'none') {
+      return;
+    }
+    this.stretchAllRatio = 0;
+    this.stretchAllColumnsWidth = [];
+    this.needVerifyLastColumnWidth = true;
+    this.stretchLastWidth = 0;
+    _classPrivateFieldSet(_totalTargetWidth, this, totalWidth);
+    let sumAll = 0;
+    for (let i = 0; i < _classPrivateFieldGet(_totalColumns, this).call(this); i++) {
+      const columnWidth = this._getColumnWidth(i);
+      const permanentColumnWidth = _classPrivateFieldGet(_stretchingColumnWidthFn, this).call(this, undefined, i);
+      if (typeof permanentColumnWidth === 'number') {
+        totalWidth -= permanentColumnWidth;
+      } else {
+        sumAll += columnWidth;
+      }
+    }
+    const remainingSize = totalWidth - sumAll;
+    if (_classPrivateFieldGet(_stretchMode, this).call(this) === 'all' && remainingSize > 0) {
+      this.stretchAllRatio = totalWidth / sumAll;
+      this.stretchAllColumnsWidth = [];
+      this.needVerifyLastColumnWidth = true;
+    } else if (_classPrivateFieldGet(_stretchMode, this).call(this) === 'last' && totalWidth !== Infinity) {
+      const columnWidth = this._getColumnWidth(_classPrivateFieldGet(_totalColumns, this).call(this) - 1);
+      const lastColumnWidth = remainingSize + columnWidth;
+      this.stretchLastWidth = lastColumnWidth >= 0 ? lastColumnWidth : columnWidth;
+    }
+  }
+
+  /**
+   * Get stretched column width based on stretchH (all or last) setting passed in handsontable instance.
+   *
+   * @param {number} column The visual column index.
+   * @param {number} baseWidth The default column width.
+   * @returns {number|null}
+   */
+  getStretchedColumnWidth(column, baseWidth) {
+    let result = null;
+    if (_classPrivateFieldGet(_stretchMode, this).call(this) === 'all' && this.stretchAllRatio !== 0) {
+      result = this._getStretchedAllColumnWidth(column, baseWidth);
+    } else if (_classPrivateFieldGet(_stretchMode, this).call(this) === 'last' && this.stretchLastWidth !== 0) {
+      result = this._getStretchedLastColumnWidth(column);
+    }
+    return result;
+  }
+
+  /**
+   * @param {number} column The visual column index.
+   * @param {number} baseWidth The default column width.
+   * @returns {number}
+   * @private
+   */
+  _getStretchedAllColumnWidth(column, baseWidth) {
+    let sumRatioWidth = 0;
+    if (!this.stretchAllColumnsWidth[column]) {
+      const stretchedWidth = Math.round(baseWidth * this.stretchAllRatio);
+      const newStretchedWidth = _classPrivateFieldGet(_stretchingColumnWidthFn, this).call(this, stretchedWidth, column);
+      if (newStretchedWidth === undefined) {
+        this.stretchAllColumnsWidth[column] = stretchedWidth;
+      } else {
+        this.stretchAllColumnsWidth[column] = isNaN(newStretchedWidth) ? this._getColumnWidth(column) : newStretchedWidth;
+      }
+    }
+    if (this.stretchAllColumnsWidth.length === _classPrivateFieldGet(_totalColumns, this).call(this) && this.needVerifyLastColumnWidth) {
+      this.needVerifyLastColumnWidth = false;
+      for (let i = 0; i < this.stretchAllColumnsWidth.length; i++) {
+        sumRatioWidth += this.stretchAllColumnsWidth[i];
+      }
+      if (sumRatioWidth !== _classPrivateFieldGet(_totalTargetWidth, this)) {
+        this.stretchAllColumnsWidth[this.stretchAllColumnsWidth.length - 1] += _classPrivateFieldGet(_totalTargetWidth, this) - sumRatioWidth;
+      }
+    }
+    return this.stretchAllColumnsWidth[column];
+  }
+
+  /**
+   * @param {number} column The visual column index.
+   * @returns {number|null}
+   * @private
+   */
+  _getStretchedLastColumnWidth(column) {
+    if (column === _classPrivateFieldGet(_totalColumns, this).call(this) - 1) {
+      return this.stretchLastWidth;
+    }
+    return null;
+  }
+
+  /**
+   * @param {number} column The visual column index.
+   * @returns {number}
+   * @private
+   */
+  _getColumnWidth(column) {
+    let width = _classPrivateFieldGet(_columnWidthFn, this).call(this, column);
+    if (isNaN(width)) {
+      width = DEFAULT_COLUMN_WIDTH;
+    }
+    return width;
+  }
+}

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

@@ -27,6 +27,7 @@ class Viewport {
     this.oversizedColumnHeaders = [];
     this.hasOversizedColumnHeadersMarked = {};
     this.clientHeight = 0;
+    this.containerWidth = NaN;
     this.rowHeaderWidth = NaN;
     this.rowsVisibleCalculator = null;
     this.columnsVisibleCalculator = null;
@@ -55,65 +56,55 @@ class Viewport {
     }
     return height;
   }
-
-  /**
-   * @returns {number}
-   */
-  getViewportHeight() {
-    let containerHeight = this.getWorkspaceHeight();
-    if (containerHeight === Infinity) {
-      return containerHeight;
-    }
-    const columnHeaderHeight = this.getColumnHeaderHeight();
-    if (columnHeaderHeight > 0) {
-      containerHeight -= columnHeaderHeight;
-    }
-    return containerHeight;
-  }
-
-  /**
-   * Gets the width of the table workspace (in pixels). The workspace size in the current
-   * implementation returns the width of the table holder element including scrollbar width when
-   * the table has defined size and the width of the window excluding scrollbar width when
-   * the table has no defined size (the window is a scrollable container).
-   *
-   * This is a bug, as the method should always return stable values, always without scrollbar width.
-   * Changing this behavior would break the column calculators, which would also need to be adjusted.
-   *
-   * @returns {number}
-   */
   getWorkspaceWidth() {
+    const {
+      wtSettings
+    } = this;
     const {
       rootDocument,
       rootWindow
     } = this.domBindings;
     const trimmingContainer = this.dataAccessObject.inlineStartOverlayTrimmingContainer;
+    const docOffsetWidth = rootDocument.documentElement.offsetWidth;
+    const totalColumns = wtSettings.getSetting('totalColumns');
+    const preventOverflow = wtSettings.getSetting('preventOverflow');
+    const isRtl = wtSettings.getSetting('rtlMode');
+    const tableRect = this.wtTable.TABLE.getBoundingClientRect();
+    const inlineStart = isRtl ? tableRect.right - docOffsetWidth : tableRect.left;
+    const tableOffset = docOffsetWidth - inlineStart;
     let width;
-    if (trimmingContainer === rootWindow) {
-      const totalColumns = this.wtSettings.getSetting('totalColumns');
-      width = this.wtTable.holder.offsetWidth;
-      if (this.getRowHeaderWidth() + this.sumColumnWidths(0, totalColumns) > width) {
-        width = rootDocument.documentElement.clientWidth;
-      }
+    let overflow;
+    if (preventOverflow) {
+      return (0, _element.outerWidth)(this.wtTable.wtRootElement);
+    }
+    if (wtSettings.getSetting('freezeOverlays')) {
+      width = Math.min(tableOffset, docOffsetWidth);
     } else {
-      width = trimmingContainer.clientWidth;
+      width = Math.min(this.getContainerFillWidth(), tableOffset, docOffsetWidth);
     }
-    return width;
-  }
-
-  /**
-   * @returns {number}
-   */
-  getViewportWidth() {
-    const containerWidth = this.getWorkspaceWidth();
-    if (containerWidth === Infinity) {
-      return containerWidth;
+    if (trimmingContainer === rootWindow && totalColumns > 0 && this.sumColumnWidths(0, totalColumns - 1) > width) {
+      // in case sum of column widths is higher than available stylesheet width, let's assume using the whole window
+      // otherwise continue below, which will allow stretching
+      // this is used in `scroll_window.html`
+      // TODO test me
+      return rootDocument.documentElement.clientWidth;
     }
-    const rowHeaderWidth = this.getRowHeaderWidth();
-    if (rowHeaderWidth > 0) {
-      return containerWidth - rowHeaderWidth;
+    if (trimmingContainer !== rootWindow) {
+      overflow = (0, _element.getStyle)(this.dataAccessObject.inlineStartOverlayTrimmingContainer, 'overflow', rootWindow);
+      if (overflow === 'scroll' || overflow === 'hidden' || overflow === 'auto') {
+        // this is used in `scroll.html`
+        // TODO test me
+        return Math.max(width, trimmingContainer.clientWidth);
+      }
     }
-    return containerWidth;
+    const stretchSetting = wtSettings.getSetting('stretchH');
+    if (stretchSetting === 'none' || !stretchSetting) {
+      // if no stretching is used, return the maximum used workspace width
+      return Math.max(width, (0, _element.outerWidth)(this.wtTable.TABLE));
+    }
+
+    // if stretching is used, return the actual container width, so the columns can fit inside it
+    return width;
   }
 
   /**
@@ -134,24 +125,6 @@ class Viewport {
     return this.wtTable.hider.offsetWidth > this.getWorkspaceWidth();
   }
 
-  /**
-   * Checks if the table uses the window as a viewport and if there is a vertical scrollbar.
-   *
-   * @returns {boolean}
-   */
-  isVerticallyScrollableByWindow() {
-    return this.dataAccessObject.topOverlayTrimmingContainer === this.domBindings.rootWindow;
-  }
-
-  /**
-   * Checks if the table uses the window as a viewport and if there is a horizontal scrollbar.
-   *
-   * @returns {boolean}
-   */
-  isHorizontallyScrollableByWindow() {
-    return this.dataAccessObject.inlineStartOverlayTrimmingContainer === this.domBindings.rootWindow;
-  }
-
   /**
    * @param {number} from The visual column index from the width sum is start calculated.
    * @param {number} length The length of the column to traverse.
@@ -167,6 +140,24 @@ class Viewport {
     return sum;
   }
 
+  /**
+   * @returns {number}
+   */
+  getContainerFillWidth() {
+    if (this.containerWidth) {
+      return this.containerWidth;
+    }
+    const mainContainer = this.wtTable.holder;
+    const dummyElement = this.domBindings.rootDocument.createElement('div');
+    dummyElement.style.width = '100%';
+    dummyElement.style.height = '1px';
+    mainContainer.appendChild(dummyElement);
+    const fillWidth = dummyElement.offsetWidth;
+    this.containerWidth = fillWidth;
+    mainContainer.removeChild(dummyElement);
+    return fillWidth;
+  }
+
   /**
    * @returns {number}
    */
@@ -187,6 +178,21 @@ class Viewport {
     return this.columnHeaderHeight;
   }
 
+  /**
+   * @returns {number}
+   */
+  getViewportHeight() {
+    let containerHeight = this.getWorkspaceHeight();
+    if (containerHeight === Infinity) {
+      return containerHeight;
+    }
+    const columnHeaderHeight = this.getColumnHeaderHeight();
+    if (columnHeaderHeight > 0) {
+      containerHeight -= columnHeaderHeight;
+    }
+    return containerHeight;
+  }
+
   /**
    * @returns {number}
    */
@@ -221,6 +227,21 @@ class Viewport {
     return this.rowHeaderWidth;
   }
 
+  /**
+   * @returns {number}
+   */
+  getViewportWidth() {
+    const containerWidth = this.getWorkspaceWidth();
+    if (containerWidth === Infinity) {
+      return containerWidth;
+    }
+    const rowHeaderWidth = this.getRowHeaderWidth();
+    if (rowHeaderWidth > 0) {
+      return containerWidth - rowHeaderWidth;
+    }
+    return containerWidth;
+  }
+
   /**
    * 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;

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

@@ -1,4 +1,4 @@
-import { getScrollbarWidth, offset, outerHeight, outerWidth } from "../../../helpers/dom/element.mjs";
+import { getScrollbarWidth, getStyle, offset, outerHeight, outerWidth } from "../../../helpers/dom/element.mjs";
 import { objectEach } from "../../../helpers/object.mjs";
 import { FullyVisibleColumnsCalculationType, FullyVisibleRowsCalculationType, PartiallyVisibleColumnsCalculationType, PartiallyVisibleRowsCalculationType, RenderedAllColumnsCalculationType, RenderedAllRowsCalculationType, RenderedColumnsCalculationType, RenderedRowsCalculationType, ViewportColumnsCalculator, ViewportRowsCalculator } from "./calculator/index.mjs";
 /**
@@ -24,6 +24,7 @@ class Viewport {
     this.oversizedColumnHeaders = [];
     this.hasOversizedColumnHeadersMarked = {};
     this.clientHeight = 0;
+    this.containerWidth = NaN;
     this.rowHeaderWidth = NaN;
     this.rowsVisibleCalculator = null;
     this.columnsVisibleCalculator = null;
@@ -52,65 +53,55 @@ class Viewport {
     }
     return height;
   }
-
-  /**
-   * @returns {number}
-   */
-  getViewportHeight() {
-    let containerHeight = this.getWorkspaceHeight();
-    if (containerHeight === Infinity) {
-      return containerHeight;
-    }
-    const columnHeaderHeight = this.getColumnHeaderHeight();
-    if (columnHeaderHeight > 0) {
-      containerHeight -= columnHeaderHeight;
-    }
-    return containerHeight;
-  }
-
-  /**
-   * Gets the width of the table workspace (in pixels). The workspace size in the current
-   * implementation returns the width of the table holder element including scrollbar width when
-   * the table has defined size and the width of the window excluding scrollbar width when
-   * the table has no defined size (the window is a scrollable container).
-   *
-   * This is a bug, as the method should always return stable values, always without scrollbar width.
-   * Changing this behavior would break the column calculators, which would also need to be adjusted.
-   *
-   * @returns {number}
-   */
   getWorkspaceWidth() {
+    const {
+      wtSettings
+    } = this;
     const {
       rootDocument,
       rootWindow
     } = this.domBindings;
     const trimmingContainer = this.dataAccessObject.inlineStartOverlayTrimmingContainer;
+    const docOffsetWidth = rootDocument.documentElement.offsetWidth;
+    const totalColumns = wtSettings.getSetting('totalColumns');
+    const preventOverflow = wtSettings.getSetting('preventOverflow');
+    const isRtl = wtSettings.getSetting('rtlMode');
+    const tableRect = this.wtTable.TABLE.getBoundingClientRect();
+    const inlineStart = isRtl ? tableRect.right - docOffsetWidth : tableRect.left;
+    const tableOffset = docOffsetWidth - inlineStart;
     let width;
-    if (trimmingContainer === rootWindow) {
-      const totalColumns = this.wtSettings.getSetting('totalColumns');
-      width = this.wtTable.holder.offsetWidth;
-      if (this.getRowHeaderWidth() + this.sumColumnWidths(0, totalColumns) > width) {
-        width = rootDocument.documentElement.clientWidth;
-      }
+    let overflow;
+    if (preventOverflow) {
+      return outerWidth(this.wtTable.wtRootElement);
+    }
+    if (wtSettings.getSetting('freezeOverlays')) {
+      width = Math.min(tableOffset, docOffsetWidth);
     } else {
-      width = trimmingContainer.clientWidth;
+      width = Math.min(this.getContainerFillWidth(), tableOffset, docOffsetWidth);
     }
-    return width;
-  }
-
-  /**
-   * @returns {number}
-   */
-  getViewportWidth() {
-    const containerWidth = this.getWorkspaceWidth();
-    if (containerWidth === Infinity) {
-      return containerWidth;
+    if (trimmingContainer === rootWindow && totalColumns > 0 && this.sumColumnWidths(0, totalColumns - 1) > width) {
+      // in case sum of column widths is higher than available stylesheet width, let's assume using the whole window
+      // otherwise continue below, which will allow stretching
+      // this is used in `scroll_window.html`
+      // TODO test me
+      return rootDocument.documentElement.clientWidth;
     }
-    const rowHeaderWidth = this.getRowHeaderWidth();
-    if (rowHeaderWidth > 0) {
-      return containerWidth - rowHeaderWidth;
+    if (trimmingContainer !== rootWindow) {
+      overflow = getStyle(this.dataAccessObject.inlineStartOverlayTrimmingContainer, 'overflow', rootWindow);
+      if (overflow === 'scroll' || overflow === 'hidden' || overflow === 'auto') {
+        // this is used in `scroll.html`
+        // TODO test me
+        return Math.max(width, trimmingContainer.clientWidth);
+      }
     }
-    return containerWidth;
+    const stretchSetting = wtSettings.getSetting('stretchH');
+    if (stretchSetting === 'none' || !stretchSetting) {
+      // if no stretching is used, return the maximum used workspace width
+      return Math.max(width, outerWidth(this.wtTable.TABLE));
+    }
+
+    // if stretching is used, return the actual container width, so the columns can fit inside it
+    return width;
   }
 
   /**
@@ -131,24 +122,6 @@ class Viewport {
     return this.wtTable.hider.offsetWidth > this.getWorkspaceWidth();
   }
 
-  /**
-   * Checks if the table uses the window as a viewport and if there is a vertical scrollbar.
-   *
-   * @returns {boolean}
-   */
-  isVerticallyScrollableByWindow() {
-    return this.dataAccessObject.topOverlayTrimmingContainer === this.domBindings.rootWindow;
-  }
-
-  /**
-   * Checks if the table uses the window as a viewport and if there is a horizontal scrollbar.
-   *
-   * @returns {boolean}
-   */
-  isHorizontallyScrollableByWindow() {
-    return this.dataAccessObject.inlineStartOverlayTrimmingContainer === this.domBindings.rootWindow;
-  }
-
   /**
    * @param {number} from The visual column index from the width sum is start calculated.
    * @param {number} length The length of the column to traverse.
@@ -164,6 +137,24 @@ class Viewport {
     return sum;
   }
 
+  /**
+   * @returns {number}
+   */
+  getContainerFillWidth() {
+    if (this.containerWidth) {
+      return this.containerWidth;
+    }
+    const mainContainer = this.wtTable.holder;
+    const dummyElement = this.domBindings.rootDocument.createElement('div');
+    dummyElement.style.width = '100%';
+    dummyElement.style.height = '1px';
+    mainContainer.appendChild(dummyElement);
+    const fillWidth = dummyElement.offsetWidth;
+    this.containerWidth = fillWidth;
+    mainContainer.removeChild(dummyElement);
+    return fillWidth;
+  }
+
   /**
    * @returns {number}
    */
@@ -184,6 +175,21 @@ class Viewport {
     return this.columnHeaderHeight;
   }
 
+  /**
+   * @returns {number}
+   */
+  getViewportHeight() {
+    let containerHeight = this.getWorkspaceHeight();
+    if (containerHeight === Infinity) {
+      return containerHeight;
+    }
+    const columnHeaderHeight = this.getColumnHeaderHeight();
+    if (columnHeaderHeight > 0) {
+      containerHeight -= columnHeaderHeight;
+    }
+    return containerHeight;
+  }
+
   /**
    * @returns {number}
    */
@@ -218,6 +224,21 @@ class Viewport {
     return this.rowHeaderWidth;
   }
 
+  /**
+   * @returns {number}
+   */
+  getViewportWidth() {
+    const containerWidth = this.getWorkspaceWidth();
+    if (containerWidth === Infinity) {
+      return containerWidth;
+    }
+    const rowHeaderWidth = this.getRowHeaderWidth();
+    if (rowHeaderWidth > 0) {
+      return containerWidth - rowHeaderWidth;
+    }
+    return containerWidth;
+  }
+
   /**
    * 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;

package/base.js

@@ -45,8 +45,8 @@ Handsontable.hooks = _hooks.Hooks.getSingleton();
 Handsontable.CellCoords = _src.CellCoords;
 Handsontable.CellRange = _src.CellRange;
 Handsontable.packageName = 'handsontable';
-Handsontable.buildDate = "24/10/2024 07:23:05";
-Handsontable.version = "0.0.0-next-802f59c-20241024";
+Handsontable.buildDate = "25/10/2024 06:46:12";
+Handsontable.version = "0.0.0-next-adeb5a2-20241025";
 Handsontable.languages = {
   dictionaryKeys: _registry.dictionaryKeys,
   getLanguageDictionary: _registry.getLanguageDictionary,

package/base.mjs

@@ -35,8 +35,8 @@ Handsontable.hooks = Hooks.getSingleton();
 Handsontable.CellCoords = CellCoords;
 Handsontable.CellRange = CellRange;
 Handsontable.packageName = 'handsontable';
-Handsontable.buildDate = "24/10/2024 07:23:11";
-Handsontable.version = "0.0.0-next-802f59c-20241024";
+Handsontable.buildDate = "25/10/2024 06:46:18";
+Handsontable.version = "0.0.0-next-adeb5a2-20241025";
 Handsontable.languages = {
   dictionaryKeys,
   getLanguageDictionary,

package/core/hooks/constants.js

@@ -1368,7 +1368,6 @@ const REGISTERED_HOOKS = exports.REGISTERED_HOOKS = [/* eslint-disable jsdoc/req
  * @event Hooks#modifyColWidth
  * @param {number} width Current column width.
  * @param {number} column Visual column index.
- * @param {string} [source] String that identifies source of hook call.
  */
 'modifyColWidth',
 /**
@@ -1405,7 +1404,6 @@ const REGISTERED_HOOKS = exports.REGISTERED_HOOKS = [/* eslint-disable jsdoc/req
  * @event Hooks#modifyRowHeight
  * @param {number} height Row height.
  * @param {number} row Visual row index.
- * @param {string} [source] String that identifies source of hook call.
  */
 'modifyRowHeight',
 /**

package/core/hooks/constants.mjs

@@ -1365,7 +1365,6 @@ export const REGISTERED_HOOKS = [/* eslint-disable jsdoc/require-description-com
  * @event Hooks#modifyColWidth
  * @param {number} width Current column width.
  * @param {number} column Visual column index.
- * @param {string} [source] String that identifies source of hook call.
  */
 'modifyColWidth',
 /**
@@ -1402,7 +1401,6 @@ export const REGISTERED_HOOKS = [/* eslint-disable jsdoc/require-description-com
  * @event Hooks#modifyRowHeight
  * @param {number} height Row height.
  * @param {number} row Visual row index.
- * @param {string} [source] String that identifies source of hook call.
  */
 'modifyRowHeight',
 /**

package/core/hooks/index.d.ts

@@ -237,7 +237,7 @@ export interface Events {
   modifyColHeader?: (column: number) => void;
   modifyColumnHeaderHeight?: () => void;
   modifyColumnHeaderValue?: (headerValue: string, visualColumnIndex: number, headerLevel: number) => void | string;
-  modifyColWidth?: (width: number, column: number, source?: string) => void;
+  modifyColWidth?: (width: number, column: number) => void;
   modifyCopyableRange?: (copyableRanges: RangeType[]) => void;
   modifyFiltersMultiSelectValue?: (value: string, meta: CellProperties) => void | CellValue;
   modifyFocusedElement?: (row: number, column: number, focusedElement: HTMLElement) => void | HTMLElement;
@@ -248,7 +248,7 @@ export interface Events {
   modifyRowData?: (row: number) => void;
   modifyRowHeader?: (row: number) => void;
   modifyRowHeaderWidth?: (rowHeaderWidth: number) => void;
-  modifyRowHeight?: (height: number, row: number, source?: string) => void | number;
+  modifyRowHeight?: (height: number, row: number) => void | number;
   modifyRowHeightByOverlayName?: (height: number, row: number, overlayType: OverlayType) => void | number;
   modifySourceData?: (row: number, column: number, valueHolder: { value: CellValue }, ioMode: 'get' | 'set') => void;
   modifyTransformEnd?: (delta: CellCoords) => void;