handsontable 18.0.0 → 18.1.0-rc11

package/3rdparty/walkontable/src/axisSizing/axisSizeSource.d.mts

@@ -0,0 +1 @@
+export * from './axisSizeSource.js';

package/3rdparty/walkontable/src/axisSizing/axisSizeSource.d.ts

@@ -0,0 +1,55 @@
+/**
+ * The sizing ports. These interfaces are the seam between the rendering engine and whoever supplies
+ * the row heights and column widths — the settings/defaults inside Walkontable, or (through the
+ * settings callbacks) the Handsontable size funnel and its `AutoRowSize`/`AutoColumnSize` plugins.
+ *
+ * A source answers only the "provided size" half of a measurement. The oversized-content merge
+ * (`Math.max(provided, measured)`) still lives in `RowUtils`/`ColumnUtils` for now; it moves behind
+ * the port in a later stage. Indexes are source indexes — the space the engine renders in, passed
+ * through unchanged.
+ */
+/**
+ * A per-axis size source. Supplies the provided size of one item plus the axis defaults.
+ */
+export interface AxisSizeSource {
+    /**
+     * The provided size in px for one item, or `undefined` when no size is provided (the caller then
+     * applies `getDefaultSize()`). Must be a cheap, pure lookup — it is called O(n) on a cache rebuild.
+     *
+     * @param {number} sourceIndex The source index of the item.
+     * @returns {number | undefined}
+     */
+    getSize(sourceIndex: number): number | undefined;
+    /**
+     * The default size in px for items with no provided size.
+     *
+     * @returns {number}
+     */
+    getDefaultSize(): number;
+    /**
+     * Whether every item is guaranteed to be `getDefaultSize()`. Enables the O(1) arithmetic fast path
+     * in the prefix-sum cache. Must be conservative — return `false` whenever any per-item override may
+     * exist.
+     *
+     * @returns {boolean}
+     */
+    isUniform(): boolean;
+}
+/**
+ * The row-height source. Adds the per-overlay height override used by frozen rows.
+ */
+export interface RowSizeSource extends AxisSizeSource {
+    /**
+     * The provided height in px for one row within a specific overlay, or `undefined` when none is
+     * provided. Lets a plugin vary a row's height per overlay (top/bottom/master).
+     *
+     * @param {number} sourceIndex The source index of the row.
+     * @param {string} overlayName The overlay name.
+     * @returns {number | undefined}
+     */
+    getSizeForOverlay(sourceIndex: number, overlayName: string): number | undefined;
+}
+/**
+ * The column-width source. No extra members beyond the base today.
+ */
+export type ColumnSizeSource = AxisSizeSource;

package/3rdparty/walkontable/src/axisSizing/axisSizeSource.js

@@ -0,0 +1,15 @@
+/**
+ * The sizing ports. These interfaces are the seam between the rendering engine and whoever supplies
+ * the row heights and column widths — the settings/defaults inside Walkontable, or (through the
+ * settings callbacks) the Handsontable size funnel and its `AutoRowSize`/`AutoColumnSize` plugins.
+ *
+ * A source answers only the "provided size" half of a measurement. The oversized-content merge
+ * (`Math.max(provided, measured)`) still lives in `RowUtils`/`ColumnUtils` for now; it moves behind
+ * the port in a later stage. Indexes are source indexes — the space the engine renders in, passed
+ * through unchanged.
+ */ /**
+ * A per-axis size source. Supplies the provided size of one item plus the axis defaults.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/3rdparty/walkontable/src/axisSizing/axisSizeSource.mjs

@@ -0,0 +1,14 @@
+/**
+ * The sizing ports. These interfaces are the seam between the rendering engine and whoever supplies
+ * the row heights and column widths — the settings/defaults inside Walkontable, or (through the
+ * settings callbacks) the Handsontable size funnel and its `AutoRowSize`/`AutoColumnSize` plugins.
+ *
+ * A source answers only the "provided size" half of a measurement. The oversized-content merge
+ * (`Math.max(provided, measured)`) still lives in `RowUtils`/`ColumnUtils` for now; it moves behind
+ * the port in a later stage. Indexes are source indexes — the space the engine renders in, passed
+ * through unchanged.
+ */ /**
+ * A per-axis size source. Supplies the provided size of one item plus the axis defaults.
+ */ /**
+ * The column-width source. No extra members beyond the base today.
+ */ export { };

package/3rdparty/walkontable/src/axisSizing/boxModel.d.mts

@@ -0,0 +1 @@
+export * from './boxModel.js';

package/3rdparty/walkontable/src/axisSizing/boxModel.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The row box-model relationship between a row's logical height and the pixel height written to the
+ * DOM. Pure functions of the border-box flag (`stylesHandler.areCellsBorderBox()`), so they carry no
+ * DOM or engine dependency and are unit-testable directly.
+ *
+ * The size caches store the LOGICAL row height (the value the calculators and `sumCellSizes` sum). The
+ * renderer writes a slightly different PIXEL height to each row element: in content-box mode it writes
+ * `logical - 1`, because that 1px is "replaced" by the row's 1px top border, so the row still occupies
+ * `logical` px in the layout; in border-box mode the border is included and it writes `logical`. Either
+ * way the rendered row occupies `logical` px, which is why the logical cache total already equals the
+ * DOM-occupied total.
+ *
+ * Centralizing the 1px constant here keeps that equality true when the border model is edited later. It
+ * also lets the hider math size the hider from the cache total and agree with the sum of the pixel
+ * heights the renderer actually wrote.
+ */
+/**
+ * The per-row border compensation in pixels: `1` in content-box mode (the row's 1px top border stands
+ * in for the missing pixel), `0` in border-box mode (the border is inside the box).
+ *
+ * @param {boolean} isBorderBox Whether cells use `box-sizing: border-box` (`stylesHandler.areCellsBorderBox()`).
+ * @returns {number}
+ */
+export declare function getRowBorderCompensation(isBorderBox: boolean): number;
+/**
+ * Converts a row's logical height to the pixel height the renderer writes to the row element.
+ *
+ * @param {number} logicalHeight The logical row height (as stored in the size cache).
+ * @param {boolean} isBorderBox Whether cells use `box-sizing: border-box` (`stylesHandler.areCellsBorderBox()`).
+ * @returns {number}
+ */
+export declare function getBoxAdjustedRowHeight(logicalHeight: number, isBorderBox: boolean): number;

package/3rdparty/walkontable/src/axisSizing/boxModel.js

@@ -0,0 +1,45 @@
+/**
+ * The row box-model relationship between a row's logical height and the pixel height written to the
+ * DOM. Pure functions of the border-box flag (`stylesHandler.areCellsBorderBox()`), so they carry no
+ * DOM or engine dependency and are unit-testable directly.
+ *
+ * The size caches store the LOGICAL row height (the value the calculators and `sumCellSizes` sum). The
+ * renderer writes a slightly different PIXEL height to each row element: in content-box mode it writes
+ * `logical - 1`, because that 1px is "replaced" by the row's 1px top border, so the row still occupies
+ * `logical` px in the layout; in border-box mode the border is included and it writes `logical`. Either
+ * way the rendered row occupies `logical` px, which is why the logical cache total already equals the
+ * DOM-occupied total.
+ *
+ * Centralizing the 1px constant here keeps that equality true when the border model is edited later. It
+ * also lets the hider math size the hider from the cache total and agree with the sum of the pixel
+ * heights the renderer actually wrote.
+ */ /**
+ * The per-row border compensation in pixels: `1` in content-box mode (the row's 1px top border stands
+ * in for the missing pixel), `0` in border-box mode (the border is inside the box).
+ *
+ * @param {boolean} isBorderBox Whether cells use `box-sizing: border-box` (`stylesHandler.areCellsBorderBox()`).
+ * @returns {number}
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get getBoxAdjustedRowHeight () {
+        return getBoxAdjustedRowHeight;
+    },
+    get getRowBorderCompensation () {
+        return getRowBorderCompensation;
+    }
+});
+function getRowBorderCompensation(isBorderBox) {
+    return isBorderBox ? 0 : 1;
+}
+function getBoxAdjustedRowHeight(logicalHeight, isBorderBox) {
+    return logicalHeight - getRowBorderCompensation(isBorderBox);
+}

package/3rdparty/walkontable/src/axisSizing/boxModel.mjs

@@ -0,0 +1,33 @@
+/**
+ * The row box-model relationship between a row's logical height and the pixel height written to the
+ * DOM. Pure functions of the border-box flag (`stylesHandler.areCellsBorderBox()`), so they carry no
+ * DOM or engine dependency and are unit-testable directly.
+ *
+ * The size caches store the LOGICAL row height (the value the calculators and `sumCellSizes` sum). The
+ * renderer writes a slightly different PIXEL height to each row element: in content-box mode it writes
+ * `logical - 1`, because that 1px is "replaced" by the row's 1px top border, so the row still occupies
+ * `logical` px in the layout; in border-box mode the border is included and it writes `logical`. Either
+ * way the rendered row occupies `logical` px, which is why the logical cache total already equals the
+ * DOM-occupied total.
+ *
+ * Centralizing the 1px constant here keeps that equality true when the border model is edited later. It
+ * also lets the hider math size the hider from the cache total and agree with the sum of the pixel
+ * heights the renderer actually wrote.
+ */ /**
+ * The per-row border compensation in pixels: `1` in content-box mode (the row's 1px top border stands
+ * in for the missing pixel), `0` in border-box mode (the border is inside the box).
+ *
+ * @param {boolean} isBorderBox Whether cells use `box-sizing: border-box` (`stylesHandler.areCellsBorderBox()`).
+ * @returns {number}
+ */ export function getRowBorderCompensation(isBorderBox) {
+    return isBorderBox ? 0 : 1;
+}
+/**
+ * Converts a row's logical height to the pixel height the renderer writes to the row element.
+ *
+ * @param {number} logicalHeight The logical row height (as stored in the size cache).
+ * @param {boolean} isBorderBox Whether cells use `box-sizing: border-box` (`stylesHandler.areCellsBorderBox()`).
+ * @returns {number}
+ */ export function getBoxAdjustedRowHeight(logicalHeight, isBorderBox) {
+    return logicalHeight - getRowBorderCompensation(isBorderBox);
+}

package/3rdparty/walkontable/src/axisSizing/columnUtils.d.mts

@@ -0,0 +1,2 @@
+export * from './columnUtils.js';
+export { default } from './columnUtils.js';

package/3rdparty/walkontable/src/{utils/column.d.ts → axisSizing/columnUtils.d.ts}

@@ -1,28 +1,30 @@
-import type { DataAccessObject } from '../types';
-import type Settings from '../settings';
+import type { TableDeps } from '../table/baseTable';
 /**
  * Column utils class contains all necessary information about sizes of the columns.
  *
  * @class {ColumnUtils}
  */
 export default class ColumnUtils {
-    /**
-     * @type {TableDao}
-     */
-    dataAccessObject: DataAccessObject;
+    #private;
     /**
      * @type {Settings}
      */
-    wtSettings: Settings;
+    wtSettings: import("../settings").default;
     /**
      * @type {Map<number, number>}
      */
     headerWidths: Map<number, number>;
     /**
-     * @param {TableDao} dataAccessObject The table Data Access Object.
-     * @param {Settings} wtSettings The walkontable settings.
+     * Read-only access to the dependencies, for the renderer, which reads `columnUtils.deps`
+     * externally and so cannot reach the private `#deps`.
+     *
+     * @returns {TableDeps}
+     */
+    get deps(): TableDeps;
+    /**
+     * @param {TableDeps} deps The table module dependencies.
      */
-    constructor(dataAccessObject: DataAccessObject, wtSettings: Settings);
+    constructor(deps: TableDeps);
     /**
      * Returns column width based on passed source index.
      *

package/3rdparty/walkontable/src/axisSizing/columnUtils.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return ColumnUtils;
+    }
+});
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) {
+        return descriptor.get.call(receiver);
+    }
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) {
+        descriptor.set.call(receiver, value);
+    } else {
+        if (!descriptor.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to " + action + " private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+var /**
+   * The table module dependencies.
+   *
+   * @type {TableDeps}
+   */ _deps = /*#__PURE__*/ new WeakMap(), /**
+   * The column-width source — supplies the provided width and the default width.
+   *
+   * @type {ColumnSizeSource}
+   */ _columnSizeSource = /*#__PURE__*/ new WeakMap();
+class ColumnUtils {
+    /**
+   * Read-only access to the dependencies, for the renderer, which reads `columnUtils.deps`
+   * externally and so cannot reach the private `#deps`.
+   *
+   * @returns {TableDeps}
+   */ get deps() {
+        return _class_private_field_get(this, _deps);
+    }
+    /**
+   * Returns column width based on passed source index.
+   *
+   * @param {number} sourceIndex Column source index.
+   * @returns {number}
+   */ getWidth(sourceIndex) {
+        // Preserve the `||` (not `??`) fallback: a provided width of `0` intentionally falls through to
+        // the default.
+        return _class_private_field_get(this, _columnSizeSource).getSize(sourceIndex) || _class_private_field_get(this, _columnSizeSource).getDefaultSize();
+    }
+    /**
+   * Returns column header height based on passed header level.
+   *
+   * @param {number} level Column header level.
+   * @returns {number}
+   */ getHeaderHeight(level) {
+        const height = this.wtSettings.getSetting('stylesHandler').getDefaultRowHeight();
+        // The provided header height arrives through the `columnHeaderHeight` setting funnel: the
+        // `columnHeaderHeight` option, the `modifyColumnHeaderHeight` hook (AutoRowSize feeds it), and -
+        // for content-driven headers with no plugin - the render-size probe, all merged per level by the
+        // Handsontable-side callback. Content taller than this is not measured here; the header cell is
+        // min-height, so it expands on its own and the probe records the result for the next draw.
+        const setting = this.wtSettings.getSetting('columnHeaderHeight');
+        const providedHeight = Array.isArray(setting) ? setting[level] : setting;
+        if (providedHeight !== undefined && providedHeight !== null) {
+            return height ? Math.max(height, providedHeight) : providedHeight;
+        }
+        return height;
+    }
+    /**
+   * Returns column header width based on passed source index.
+   *
+   * @param {number} sourceIndex Column source index.
+   * @returns {number}
+   */ getHeaderWidth(sourceIndex) {
+        const { columnFilter } = _class_private_field_get(this, _deps).getWtTable();
+        if (!columnFilter) {
+            return undefined;
+        }
+        return this.headerWidths.get(columnFilter.sourceToRendered(sourceIndex));
+    }
+    /**
+   * Calculates column header widths that can be retrieved from the cache.
+   */ calculateWidths() {
+        const { wtSettings } = this;
+        let rowHeaderWidthSetting = wtSettings.getSetting('rowHeaderWidth');
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        rowHeaderWidthSetting = wtSettings.getSetting('onModifyRowHeaderWidth', rowHeaderWidthSetting);
+        if (rowHeaderWidthSetting !== null && rowHeaderWidthSetting !== undefined) {
+            const rowHeadersCount = wtSettings.getSetting('rowHeaders').length;
+            const defaultColumnWidth = wtSettings.getSetting('defaultColumnWidth');
+            for(let visibleColumnIndex = 0; visibleColumnIndex < rowHeadersCount; visibleColumnIndex++){
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                let width = Array.isArray(rowHeaderWidthSetting) ? rowHeaderWidthSetting[visibleColumnIndex] : rowHeaderWidthSetting;
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                width = width === null || width === undefined ? defaultColumnWidth : width;
+                this.headerWidths.set(visibleColumnIndex, width);
+            }
+        }
+    }
+    /**
+   * @param {TableDeps} deps The table module dependencies.
+   */ constructor(deps){
+        _class_private_field_init(this, _deps, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _columnSizeSource, {
+            writable: true,
+            value: void 0
+        });
+        /**
+   * @type {Map<number, number>}
+   */ this.headerWidths = new Map();
+        _class_private_field_set(this, _deps, deps);
+        _class_private_field_set(this, _columnSizeSource, deps.columnSizeSource);
+        this.wtSettings = deps.wtSettings;
+    }
+}

package/3rdparty/walkontable/src/axisSizing/columnUtils.mjs

@@ -0,0 +1,142 @@
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) {
+        return descriptor.get.call(receiver);
+    }
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) {
+        descriptor.set.call(receiver, value);
+    } else {
+        if (!descriptor.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to " + action + " private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+var /**
+   * The table module dependencies.
+   *
+   * @type {TableDeps}
+   */ _deps = /*#__PURE__*/ new WeakMap(), /**
+   * The column-width source — supplies the provided width and the default width.
+   *
+   * @type {ColumnSizeSource}
+   */ _columnSizeSource = /*#__PURE__*/ new WeakMap();
+class ColumnUtils {
+    /**
+   * Read-only access to the dependencies, for the renderer, which reads `columnUtils.deps`
+   * externally and so cannot reach the private `#deps`.
+   *
+   * @returns {TableDeps}
+   */ get deps() {
+        return _class_private_field_get(this, _deps);
+    }
+    /**
+   * Returns column width based on passed source index.
+   *
+   * @param {number} sourceIndex Column source index.
+   * @returns {number}
+   */ getWidth(sourceIndex) {
+        // Preserve the `||` (not `??`) fallback: a provided width of `0` intentionally falls through to
+        // the default.
+        return _class_private_field_get(this, _columnSizeSource).getSize(sourceIndex) || _class_private_field_get(this, _columnSizeSource).getDefaultSize();
+    }
+    /**
+   * Returns column header height based on passed header level.
+   *
+   * @param {number} level Column header level.
+   * @returns {number}
+   */ getHeaderHeight(level) {
+        const height = this.wtSettings.getSetting('stylesHandler').getDefaultRowHeight();
+        // The provided header height arrives through the `columnHeaderHeight` setting funnel: the
+        // `columnHeaderHeight` option, the `modifyColumnHeaderHeight` hook (AutoRowSize feeds it), and -
+        // for content-driven headers with no plugin - the render-size probe, all merged per level by the
+        // Handsontable-side callback. Content taller than this is not measured here; the header cell is
+        // min-height, so it expands on its own and the probe records the result for the next draw.
+        const setting = this.wtSettings.getSetting('columnHeaderHeight');
+        const providedHeight = Array.isArray(setting) ? setting[level] : setting;
+        if (providedHeight !== undefined && providedHeight !== null) {
+            return height ? Math.max(height, providedHeight) : providedHeight;
+        }
+        return height;
+    }
+    /**
+   * Returns column header width based on passed source index.
+   *
+   * @param {number} sourceIndex Column source index.
+   * @returns {number}
+   */ getHeaderWidth(sourceIndex) {
+        const { columnFilter } = _class_private_field_get(this, _deps).getWtTable();
+        if (!columnFilter) {
+            return undefined;
+        }
+        return this.headerWidths.get(columnFilter.sourceToRendered(sourceIndex));
+    }
+    /**
+   * Calculates column header widths that can be retrieved from the cache.
+   */ calculateWidths() {
+        const { wtSettings } = this;
+        let rowHeaderWidthSetting = wtSettings.getSetting('rowHeaderWidth');
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        rowHeaderWidthSetting = wtSettings.getSetting('onModifyRowHeaderWidth', rowHeaderWidthSetting);
+        if (rowHeaderWidthSetting !== null && rowHeaderWidthSetting !== undefined) {
+            const rowHeadersCount = wtSettings.getSetting('rowHeaders').length;
+            const defaultColumnWidth = wtSettings.getSetting('defaultColumnWidth');
+            for(let visibleColumnIndex = 0; visibleColumnIndex < rowHeadersCount; visibleColumnIndex++){
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                let width = Array.isArray(rowHeaderWidthSetting) ? rowHeaderWidthSetting[visibleColumnIndex] : rowHeaderWidthSetting;
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                width = width === null || width === undefined ? defaultColumnWidth : width;
+                this.headerWidths.set(visibleColumnIndex, width);
+            }
+        }
+    }
+    /**
+   * @param {TableDeps} deps The table module dependencies.
+   */ constructor(deps){
+        _class_private_field_init(this, _deps, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _columnSizeSource, {
+            writable: true,
+            value: void 0
+        });
+        /**
+   * @type {Map<number, number>}
+   */ this.headerWidths = new Map();
+        _class_private_field_set(this, _deps, deps);
+        _class_private_field_set(this, _columnSizeSource, deps.columnSizeSource);
+        this.wtSettings = deps.wtSettings;
+    }
+}
+/**
+ * Column utils class contains all necessary information about sizes of the columns.
+ *
+ * @class {ColumnUtils}
+ */ export { ColumnUtils as default };

package/3rdparty/walkontable/src/axisSizing/defaultSizeSource.d.mts

@@ -0,0 +1 @@
+export * from './defaultSizeSource.js';

package/3rdparty/walkontable/src/axisSizing/defaultSizeSource.d.ts

@@ -0,0 +1,58 @@
+import type { default as Settings } from '../settings';
+import type { RowSizeSource, ColumnSizeSource } from './axisSizeSource';
+/**
+ * The engine's own row-size source. Reads the row-height settings/defaults straight from `Settings`,
+ * exactly as `RowUtils` did before the port existed. In Handsontable those settings are the size
+ * funnel callbacks (`rowHeight`, `rowHeightByOverlayName`), so this one source serves both the
+ * embedded and the pure-Walkontable cases.
+ */
+export declare class DefaultRowSizeSource implements RowSizeSource {
+    #private;
+    /**
+     * @param {Settings} wtSettings The Walkontable settings.
+     */
+    constructor(wtSettings: Settings);
+    /**
+     * @param {number} sourceIndex The source index of the row.
+     * @returns {number | undefined}
+     */
+    getSize(sourceIndex: number): number | undefined;
+    /**
+     * @param {number} sourceIndex The source index of the row.
+     * @param {string} overlayName The overlay name.
+     * @returns {number | undefined}
+     */
+    getSizeForOverlay(sourceIndex: number, overlayName: string): number | undefined;
+    /**
+     * @returns {number}
+     */
+    getDefaultSize(): number;
+    /**
+     * @returns {boolean}
+     */
+    isUniform(): boolean;
+}
+/**
+ * The engine's own column-size source. Reads the column-width settings/defaults straight from
+ * `Settings`, exactly as `ColumnUtils` did before the port existed.
+ */
+export declare class DefaultColumnSizeSource implements ColumnSizeSource {
+    #private;
+    /**
+     * @param {Settings} wtSettings The Walkontable settings.
+     */
+    constructor(wtSettings: Settings);
+    /**
+     * @param {number} sourceIndex The source index of the column.
+     * @returns {number | undefined}
+     */
+    getSize(sourceIndex: number): number | undefined;
+    /**
+     * @returns {number}
+     */
+    getDefaultSize(): number;
+    /**
+     * @returns {boolean}
+     */
+    isUniform(): boolean;
+}