handsontable 14.6.1 → 15.0.0-next-fdd4480-20241205

package/plugins/stretchColumns/strategies/_base.js

@@ -0,0 +1,85 @@
+"use strict";
+
+exports.__esModule = true;
+require("core-js/modules/es.error.cause.js");
+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); }
+/**
+ * @typedef StretchStrategyCalcArgs
+ * @property {number} viewportWidth The width of the viewport.
+ */
+/**
+ * The base strategy stretching strategy to extend from.
+ *
+ * @private
+ * @class StretchStrategy
+ */
+class StretchStrategy {
+  constructor(overwriteColumnWidthFn) {
+    /**
+     * The width of the viewport.
+     *
+     * @type {number}
+     */
+    _defineProperty(this, "viewportWidth", void 0);
+    /**
+     * The function to overwrite the column width.
+     *
+     * @type {function(number, number): number | undefined}
+     */
+    _defineProperty(this, "overwriteColumnWidthFn", void 0);
+    /**
+     * The map that stores the base column widths.
+     *
+     * @type {Map<number, number>}
+     */
+    _defineProperty(this, "baseWidths", new Map());
+    /**
+     * The map that stores the calculated, stretched column widths.
+     *
+     * @type {Map<number, number>}
+     */
+    _defineProperty(this, "stretchedWidths", new Map());
+    this.overwriteColumnWidthFn = overwriteColumnWidthFn;
+  }
+
+  /**
+   * Prepares the strategy for the calculation.
+   *
+   * @param {StretchStrategyCalcArgs} calcArgs The calculation arguments.
+   */
+  prepare(_ref) {
+    let {
+      viewportWidth
+    } = _ref;
+    this.viewportWidth = viewportWidth;
+    this.baseWidths.clear();
+    this.stretchedWidths.clear();
+  }
+
+  /**
+   * Sets the base widths of the columns with which the strategy will work with.
+   *
+   * @param {number} columnVisualIndex The visual index of the column.
+   * @param {number} columnWidth The width of the column.
+   */
+  setColumnBaseWidth(columnVisualIndex, columnWidth) {
+    this.baseWidths.set(columnVisualIndex, columnWidth);
+  }
+
+  /**
+   * Calculates the width of the column.
+   */
+  calculate() {}
+
+  /**
+   * Gets the calculated stretched column widths.
+   *
+   * @returns {Array<number[]>}
+   */
+  getWidths() {
+    return Array.from(this.stretchedWidths);
+  }
+}
+exports.StretchStrategy = StretchStrategy;

package/plugins/stretchColumns/strategies/_base.mjs

@@ -0,0 +1,81 @@
+import "core-js/modules/es.error.cause.js";
+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); }
+/**
+ * @typedef StretchStrategyCalcArgs
+ * @property {number} viewportWidth The width of the viewport.
+ */
+/**
+ * The base strategy stretching strategy to extend from.
+ *
+ * @private
+ * @class StretchStrategy
+ */
+export class StretchStrategy {
+  constructor(overwriteColumnWidthFn) {
+    /**
+     * The width of the viewport.
+     *
+     * @type {number}
+     */
+    _defineProperty(this, "viewportWidth", void 0);
+    /**
+     * The function to overwrite the column width.
+     *
+     * @type {function(number, number): number | undefined}
+     */
+    _defineProperty(this, "overwriteColumnWidthFn", void 0);
+    /**
+     * The map that stores the base column widths.
+     *
+     * @type {Map<number, number>}
+     */
+    _defineProperty(this, "baseWidths", new Map());
+    /**
+     * The map that stores the calculated, stretched column widths.
+     *
+     * @type {Map<number, number>}
+     */
+    _defineProperty(this, "stretchedWidths", new Map());
+    this.overwriteColumnWidthFn = overwriteColumnWidthFn;
+  }
+
+  /**
+   * Prepares the strategy for the calculation.
+   *
+   * @param {StretchStrategyCalcArgs} calcArgs The calculation arguments.
+   */
+  prepare(_ref) {
+    let {
+      viewportWidth
+    } = _ref;
+    this.viewportWidth = viewportWidth;
+    this.baseWidths.clear();
+    this.stretchedWidths.clear();
+  }
+
+  /**
+   * Sets the base widths of the columns with which the strategy will work with.
+   *
+   * @param {number} columnVisualIndex The visual index of the column.
+   * @param {number} columnWidth The width of the column.
+   */
+  setColumnBaseWidth(columnVisualIndex, columnWidth) {
+    this.baseWidths.set(columnVisualIndex, columnWidth);
+  }
+
+  /**
+   * Calculates the width of the column.
+   */
+  calculate() {}
+
+  /**
+   * Gets the calculated stretched column widths.
+   *
+   * @returns {Array<number[]>}
+   */
+  getWidths() {
+    return Array.from(this.stretchedWidths);
+  }
+}

package/plugins/stretchColumns/strategies/all.js

@@ -0,0 +1,71 @@
+"use strict";
+
+exports.__esModule = true;
+require("core-js/modules/es.array.push.js");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.for-each.js");
+require("core-js/modules/esnext.iterator.reduce.js");
+var _src = require("../../../3rdparty/walkontable/src");
+var _base = require("./_base");
+/**
+ * The strategy calculates the column widths by stretching all columns evenly.
+ *
+ * @private
+ * @class StretchAllStrategy
+ */
+class StretchAllStrategy extends _base.StretchStrategy {
+  /**
+   * Calculates the columns widths.
+   */
+  calculate() {
+    const allColumnsWidth = Array.from(this.baseWidths).reduce((sum, _ref) => {
+      let [, width] = _ref;
+      return sum + width;
+    }, 0);
+    const remainingViewportWidth = this.viewportWidth - allColumnsWidth;
+    if (remainingViewportWidth < 0) {
+      this.stretchedWidths.clear();
+      return;
+    }
+    const initialStretchRatio = this.viewportWidth / allColumnsWidth;
+    const stretchedWidths = [];
+    const fixedColumns = [];
+    let viewportWidth = this.viewportWidth;
+    let allStretchedColumnsWidth = 0;
+    this.baseWidths.forEach((columnWidth, columnVisualIndex) => {
+      const stretchedWidth = Math.round(columnWidth * initialStretchRatio);
+      const finalWidth = this.overwriteColumnWidthFn(stretchedWidth, columnVisualIndex);
+      if (stretchedWidth === finalWidth && stretchedWidth >= _src.DEFAULT_COLUMN_WIDTH) {
+        stretchedWidths.push([columnVisualIndex, finalWidth]);
+        allStretchedColumnsWidth += finalWidth;
+      } else if (stretchedWidth !== finalWidth) {
+        stretchedWidths.push([columnVisualIndex, finalWidth]);
+        fixedColumns.push(columnVisualIndex);
+        viewportWidth -= finalWidth;
+      }
+    });
+    if (viewportWidth <= _src.DEFAULT_COLUMN_WIDTH) {
+      this.stretchedWidths.clear();
+      return;
+    }
+    const finalStretchRatio = viewportWidth / allStretchedColumnsWidth;
+    let lastColumnIndex = -1;
+    let sumColumnsWithoutLastOne = 0;
+    stretchedWidths.forEach((_ref2, index) => {
+      let [columnVisualIndex, columnWidth] = _ref2;
+      let newWidth = columnWidth;
+      if (!fixedColumns.includes(columnVisualIndex)) {
+        newWidth = Math.round(columnWidth * finalStretchRatio);
+      }
+      this.stretchedWidths.set(columnVisualIndex, newWidth);
+      lastColumnIndex = columnVisualIndex;
+      if (index < stretchedWidths.length - 1) {
+        sumColumnsWithoutLastOne += newWidth;
+      }
+    });
+    if (this.stretchedWidths.size > 1) {
+      this.stretchedWidths.set(lastColumnIndex, Math.round(this.viewportWidth - sumColumnsWithoutLastOne));
+    }
+  }
+}
+exports.StretchAllStrategy = StretchAllStrategy;

package/plugins/stretchColumns/strategies/all.mjs

@@ -0,0 +1,67 @@
+import "core-js/modules/es.array.push.js";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.for-each.js";
+import "core-js/modules/esnext.iterator.reduce.js";
+import { DEFAULT_COLUMN_WIDTH } from "../../../3rdparty/walkontable/src/index.mjs";
+import { StretchStrategy } from "./_base.mjs";
+/**
+ * The strategy calculates the column widths by stretching all columns evenly.
+ *
+ * @private
+ * @class StretchAllStrategy
+ */
+export class StretchAllStrategy extends StretchStrategy {
+  /**
+   * Calculates the columns widths.
+   */
+  calculate() {
+    const allColumnsWidth = Array.from(this.baseWidths).reduce((sum, _ref) => {
+      let [, width] = _ref;
+      return sum + width;
+    }, 0);
+    const remainingViewportWidth = this.viewportWidth - allColumnsWidth;
+    if (remainingViewportWidth < 0) {
+      this.stretchedWidths.clear();
+      return;
+    }
+    const initialStretchRatio = this.viewportWidth / allColumnsWidth;
+    const stretchedWidths = [];
+    const fixedColumns = [];
+    let viewportWidth = this.viewportWidth;
+    let allStretchedColumnsWidth = 0;
+    this.baseWidths.forEach((columnWidth, columnVisualIndex) => {
+      const stretchedWidth = Math.round(columnWidth * initialStretchRatio);
+      const finalWidth = this.overwriteColumnWidthFn(stretchedWidth, columnVisualIndex);
+      if (stretchedWidth === finalWidth && stretchedWidth >= DEFAULT_COLUMN_WIDTH) {
+        stretchedWidths.push([columnVisualIndex, finalWidth]);
+        allStretchedColumnsWidth += finalWidth;
+      } else if (stretchedWidth !== finalWidth) {
+        stretchedWidths.push([columnVisualIndex, finalWidth]);
+        fixedColumns.push(columnVisualIndex);
+        viewportWidth -= finalWidth;
+      }
+    });
+    if (viewportWidth <= DEFAULT_COLUMN_WIDTH) {
+      this.stretchedWidths.clear();
+      return;
+    }
+    const finalStretchRatio = viewportWidth / allStretchedColumnsWidth;
+    let lastColumnIndex = -1;
+    let sumColumnsWithoutLastOne = 0;
+    stretchedWidths.forEach((_ref2, index) => {
+      let [columnVisualIndex, columnWidth] = _ref2;
+      let newWidth = columnWidth;
+      if (!fixedColumns.includes(columnVisualIndex)) {
+        newWidth = Math.round(columnWidth * finalStretchRatio);
+      }
+      this.stretchedWidths.set(columnVisualIndex, newWidth);
+      lastColumnIndex = columnVisualIndex;
+      if (index < stretchedWidths.length - 1) {
+        sumColumnsWithoutLastOne += newWidth;
+      }
+    });
+    if (this.stretchedWidths.size > 1) {
+      this.stretchedWidths.set(lastColumnIndex, Math.round(this.viewportWidth - sumColumnsWithoutLastOne));
+    }
+  }
+}

package/plugins/stretchColumns/strategies/last.js

@@ -0,0 +1,79 @@
+"use strict";
+
+exports.__esModule = true;
+require("core-js/modules/es.error.cause.js");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.reduce.js");
+var _base = require("./_base");
+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 _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"); }
+/**
+ * @typedef StretchStrategyCalcArgs
+ * @property {number} viewportWidth The width of the viewport.
+ */
+/**
+ * The strategy calculates only the last column widths to fill the viewport.
+ *
+ * @private
+ * @class StretchLastStrategy
+ */
+var _lastColumnWidth = /*#__PURE__*/new WeakMap();
+var _lastColumnIndex = /*#__PURE__*/new WeakMap();
+class StretchLastStrategy extends _base.StretchStrategy {
+  constructor() {
+    super(...arguments);
+    /**
+     * The width of the last calculated column.
+     *
+     * @type {number}
+     */
+    _classPrivateFieldInitSpec(this, _lastColumnWidth, 0);
+    /**
+     * The index of the last calculated column.
+     *
+     * @type {number}
+     */
+    _classPrivateFieldInitSpec(this, _lastColumnIndex, -1);
+  }
+  /**
+   * Prepares the strategy for the calculation.
+   *
+   * @param {StretchStrategyCalcArgs} calcArgs The calculation arguments.
+   */
+  prepare(calcArgs) {
+    super.prepare(calcArgs);
+    _classPrivateFieldSet(_lastColumnWidth, this, 0);
+    _classPrivateFieldSet(_lastColumnIndex, this, -1);
+  }
+
+  /**
+   * Sets the base widths of the columns with which the strategy will work with.
+   *
+   * @param {number} columnVisualIndex The visual index of the column.
+   * @param {number} columnWidth The width of the column.
+   */
+  setColumnBaseWidth(columnVisualIndex, columnWidth) {
+    super.setColumnBaseWidth(columnVisualIndex, columnWidth);
+    _classPrivateFieldSet(_lastColumnIndex, this, columnVisualIndex);
+    _classPrivateFieldSet(_lastColumnWidth, this, columnWidth);
+  }
+
+  /**
+   * Calculates the columns widths.
+   */
+  calculate() {
+    if (_classPrivateFieldGet(_lastColumnIndex, this) === -1) {
+      return;
+    }
+    const allColumnsWidth = Array.from(this.baseWidths).reduce((sum, _ref) => {
+      let [, width] = _ref;
+      return sum + width;
+    }, 0);
+    const lastColumnWidth = Math.max(this.viewportWidth - allColumnsWidth + _classPrivateFieldGet(_lastColumnWidth, this), 0);
+    this.stretchedWidths.set(_classPrivateFieldGet(_lastColumnIndex, this), lastColumnWidth);
+  }
+}
+exports.StretchLastStrategy = StretchLastStrategy;

package/plugins/stretchColumns/strategies/last.mjs

@@ -0,0 +1,75 @@
+import "core-js/modules/es.error.cause.js";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.reduce.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 _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 { StretchStrategy } from "./_base.mjs";
+/**
+ * @typedef StretchStrategyCalcArgs
+ * @property {number} viewportWidth The width of the viewport.
+ */
+/**
+ * The strategy calculates only the last column widths to fill the viewport.
+ *
+ * @private
+ * @class StretchLastStrategy
+ */
+var _lastColumnWidth = /*#__PURE__*/new WeakMap();
+var _lastColumnIndex = /*#__PURE__*/new WeakMap();
+export class StretchLastStrategy extends StretchStrategy {
+  constructor() {
+    super(...arguments);
+    /**
+     * The width of the last calculated column.
+     *
+     * @type {number}
+     */
+    _classPrivateFieldInitSpec(this, _lastColumnWidth, 0);
+    /**
+     * The index of the last calculated column.
+     *
+     * @type {number}
+     */
+    _classPrivateFieldInitSpec(this, _lastColumnIndex, -1);
+  }
+  /**
+   * Prepares the strategy for the calculation.
+   *
+   * @param {StretchStrategyCalcArgs} calcArgs The calculation arguments.
+   */
+  prepare(calcArgs) {
+    super.prepare(calcArgs);
+    _classPrivateFieldSet(_lastColumnWidth, this, 0);
+    _classPrivateFieldSet(_lastColumnIndex, this, -1);
+  }
+
+  /**
+   * Sets the base widths of the columns with which the strategy will work with.
+   *
+   * @param {number} columnVisualIndex The visual index of the column.
+   * @param {number} columnWidth The width of the column.
+   */
+  setColumnBaseWidth(columnVisualIndex, columnWidth) {
+    super.setColumnBaseWidth(columnVisualIndex, columnWidth);
+    _classPrivateFieldSet(_lastColumnIndex, this, columnVisualIndex);
+    _classPrivateFieldSet(_lastColumnWidth, this, columnWidth);
+  }
+
+  /**
+   * Calculates the columns widths.
+   */
+  calculate() {
+    if (_classPrivateFieldGet(_lastColumnIndex, this) === -1) {
+      return;
+    }
+    const allColumnsWidth = Array.from(this.baseWidths).reduce((sum, _ref) => {
+      let [, width] = _ref;
+      return sum + width;
+    }, 0);
+    const lastColumnWidth = Math.max(this.viewportWidth - allColumnsWidth + _classPrivateFieldGet(_lastColumnWidth, this), 0);
+    this.stretchedWidths.set(_classPrivateFieldGet(_lastColumnIndex, this), lastColumnWidth);
+  }
+}

package/plugins/stretchColumns/stretchColumns.d.ts

@@ -0,0 +1,11 @@
+import Core from '../../core';
+import { BasePlugin } from '../base';
+
+export type Settings = 'all' | 'last' | 'none';
+
+export class StretchColumns extends BasePlugin {
+  constructor(hotInstance: Core);
+
+  isEnabled(): boolean;
+  getColumnWidth(columnVisualIndex: number): number | null;
+}

package/plugins/stretchColumns/stretchColumns.js

@@ -0,0 +1,222 @@
+"use strict";
+
+exports.__esModule = true;
+require("core-js/modules/es.error.cause.js");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.for-each.js");
+var _base = require("../base");
+var _calculator = require("./calculator");
+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 _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 = 'stretchColumns';
+const PLUGIN_PRIORITY = exports.PLUGIN_PRIORITY = 155;
+
+/* eslint-disable jsdoc/require-description-complete-sentence */
+/**
+ * @plugin StretchColumns
+ * @class StretchColumns
+ *
+ * @description
+ * This plugin allows to set column widths based on their widest cells.
+ *
+ * By default, the plugin is declared as `'none'`, which makes it disabled (same as if it was declared as `false`).
+ *
+ * The plugin determines what happens when the declared grid width is different from the calculated sum of all column widths.
+ *
+ * ```js
+ * // fit the grid to the container, by stretching only the last column
+ * stretchH: 'last',
+ *
+ * // fit the grid to the container, by stretching all columns evenly
+ * stretchH: 'all',
+ * ```
+ *
+ * To configure this plugin see {@link Options#stretchH}.
+ *
+ * @example
+ *
+ * ::: only-for javascript
+ * ```js
+ * const hot = new Handsontable(document.getElementById('example'), {
+ *   data: getData(),
+ *   stretchH: 'all',
+ * });
+ * ```
+ * :::
+ *
+ * ::: only-for react
+ * ```jsx
+ * const hotRef = useRef(null);
+ *
+ * ...
+ *
+ * // First, let's construct Handsontable
+ * <HotTable
+ *   ref={hotRef}
+ *   data={getData()}
+ *   stretchH={'all'}
+ * />
+ * ```
+ * :::
+ */
+/* eslint-enable jsdoc/require-description-complete-sentence */
+var _stretchCalculator = /*#__PURE__*/new WeakMap();
+var _previousTableWidth = /*#__PURE__*/new WeakMap();
+var _resizeObserver = /*#__PURE__*/new WeakMap();
+var _StretchColumns_brand = /*#__PURE__*/new WeakSet();
+class StretchColumns extends _base.BasePlugin {
+  constructor() {
+    super(...arguments);
+    /**
+     * Hook that modifies the column width - applies by the stretching logic.
+     *
+     * @param {number} width The column width.
+     * @param {number} column The visual column index.
+     * @param {string} source The source of the modification.
+     * @returns {number}
+     */
+    _classPrivateMethodInitSpec(this, _StretchColumns_brand);
+    /**
+     * The stretch calculator.
+     *
+     * @type {StretchCalculator}
+     */
+    _classPrivateFieldInitSpec(this, _stretchCalculator, new _calculator.StretchCalculator(this.hot));
+    /**
+     * The previous width of the root element. Helps to determine if the width has changed.
+     *
+     * @type {number | null}
+     */
+    _classPrivateFieldInitSpec(this, _previousTableWidth, null);
+    /**
+     * It observes the root element to detect changes in its width, and if detected, then it triggers
+     * the table dimension calculations. In a situation where the browser's vertical scrollbar
+     * appears - caused by some external UI element, the observer triggers the render.
+     *
+     * @type {ResizeObserver}
+     */
+    _classPrivateFieldInitSpec(this, _resizeObserver, new ResizeObserver(entries => {
+      requestAnimationFrame(() => {
+        var _this$hot;
+        if (!((_this$hot = this.hot) !== null && _this$hot !== void 0 && _this$hot.view.isHorizontallyScrollableByWindow())) {
+          return;
+        }
+        entries.forEach(_ref => {
+          let {
+            contentRect
+          } = _ref;
+          if (_classPrivateFieldGet(_previousTableWidth, this) !== null && _classPrivateFieldGet(_previousTableWidth, this) !== contentRect.width) {
+            this.hot.refreshDimensions();
+            this.hot.view.adjustElementsSize();
+          }
+          _classPrivateFieldSet(_previousTableWidth, this, contentRect.width);
+        });
+      });
+    }));
+  }
+  static get PLUGIN_KEY() {
+    return PLUGIN_KEY;
+  }
+  static get PLUGIN_PRIORITY() {
+    return PLUGIN_PRIORITY;
+  }
+  static get SETTING_KEYS() {
+    return true;
+  }
+  /**
+   * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit}
+   * hook and if it returns `true` then the {@link #enablePlugin} method is called.
+   *
+   * @returns {boolean}
+   */
+  isEnabled() {
+    return ['all', 'last'].includes(this.hot.getSettings().stretchH);
+  }
+
+  /**
+   * Enables the plugin functionality for this Handsontable instance.
+   */
+  enablePlugin() {
+    var _this = this;
+    if (this.enabled) {
+      return;
+    }
+    _classPrivateFieldGet(_stretchCalculator, this).useStrategy(this.hot.getSettings().stretchH);
+    _classPrivateFieldGet(_resizeObserver, this).observe(this.hot.rootElement);
+    this.addHook('beforeRender', function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      return _assertClassBrand(_StretchColumns_brand, _this, _onBeforeRender).call(_this, ...args);
+    });
+    this.addHook('modifyColWidth', function () {
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      return _assertClassBrand(_StretchColumns_brand, _this, _onModifyColWidth).call(_this, ...args);
+    }, 10);
+    super.enablePlugin();
+  }
+
+  /**
+   * Updates the plugin's state. This method is executed when {@link Core#updateSettings} is invoked.
+   */
+  updatePlugin() {
+    _classPrivateFieldGet(_stretchCalculator, this).useStrategy(this.hot.getSettings().stretchH);
+    super.updatePlugin();
+  }
+
+  /**
+   * Disables the plugin functionality for this Handsontable instance.
+   */
+  disablePlugin() {
+    super.disablePlugin();
+    _classPrivateFieldGet(_resizeObserver, this).unobserve(this.hot.rootElement);
+  }
+
+  /**
+   * Gets the calculated column width based on the stretching
+   * strategy defined by {@link Options#stretchH} option.
+   *
+   * @param {number} columnVisualIndex The visual index of the column.
+   * @returns {number | null}
+   */
+  getColumnWidth(columnVisualIndex) {
+    return _classPrivateFieldGet(_stretchCalculator, this).getStretchedWidth(columnVisualIndex);
+  }
+  /**
+   * Destroys the plugin instance.
+   */
+  destroy() {
+    _classPrivateFieldGet(_resizeObserver, this).disconnect();
+    _classPrivateFieldSet(_resizeObserver, this, null);
+    _classPrivateFieldSet(_stretchCalculator, this, null);
+    super.destroy();
+  }
+}
+exports.StretchColumns = StretchColumns;
+function _onModifyColWidth(width, column, source) {
+  if (source === this.pluginName) {
+    return;
+  }
+  const newWidth = this.getColumnWidth(column);
+  if (typeof newWidth === 'number') {
+    return newWidth;
+  }
+  return width;
+}
+/**
+ * On each before render the plugin recalculates the column widths
+ * based on the chosen stretching strategy.
+ *
+ * @param {boolean} fullRender If `true` then the full render is in progress.
+ */
+function _onBeforeRender(fullRender) {
+  if (fullRender) {
+    _classPrivateFieldGet(_stretchCalculator, this).refreshStretching();
+  }
+}