handsontable 18.0.0 → 18.1.0-rc7

package/3rdparty/walkontable/src/axisSizing/positionCache/sparseStrategy.mjs

@@ -0,0 +1,203 @@
+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;
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+import { lowerBound, sampleBaseSize } from './strategy.mjs';
+var _base = /*#__PURE__*/ new WeakMap(), _totalItems = /*#__PURE__*/ new WeakMap(), _indexes = /*#__PURE__*/ new WeakMap(), _deltaPrefix = /*#__PURE__*/ new WeakMap(), _sizes = /*#__PURE__*/ new WeakMap(), /**
+   * Returns how many exception indexes are smaller than the given index — the position in
+   * `#deltaPrefix` holding their summed deltas. Binary search, O(log k).
+   *
+   * @param {number} index The exclusive upper bound item index.
+   * @returns {number} The number of exceptions below the index.
+   */ _countExceptionsBelow = /*#__PURE__*/ new WeakSet();
+/**
+ * Position lookups for a uniform base size plus per-index overrides ("exceptions" — e.g. the
+ * DOM-measured oversized rows on top of the default row height). Stores only the exceptions:
+ * their sorted indexes and the prefix sums of their size deltas against the base. Building costs
+ * O(exceptions log exceptions) — independent of the total item count — and every offset is
+ * `index × base + binary-searched delta sum`. At 1M uniform rows with a few thousand oversized
+ * rows this replaces a 1M-iteration prefix-sum build and an 8 MB allocation per rebuild.
+ */ export class SparsePositionStrategy {
+    /**
+   * Returns the cumulative size before the given item index.
+   *
+   * @param {number} index The item index.
+   * @returns {number} The cumulative size before this index.
+   */ getOffset(index) {
+        if (index <= 0) {
+            return 0;
+        }
+        const clamped = Math.min(index, _class_private_field_get(this, _totalItems));
+        return clamped * _class_private_field_get(this, _base) + _class_private_field_get(this, _deltaPrefix)[_class_private_method_get(this, _countExceptionsBelow, countExceptionsBelow).call(this, clamped)];
+    }
+    /**
+   * Finds the item index at a given pixel offset by binary-searching the index space over
+   * `getOffset` (O(log n log k)). Same return semantics as the prefix-sum strategy.
+   *
+   * @param {number} offset The pixel offset.
+   * @returns {number} The index whose cumulative start position is at or just before the offset.
+   */ findIndexAtOffset(offset) {
+        if (offset <= 0 || _class_private_field_get(this, _totalItems) === 0) {
+            return 0;
+        }
+        const index = lowerBound(_class_private_field_get(this, _totalItems), (mid)=>this.getOffset(mid + 1) <= offset);
+        return Math.min(index, _class_private_field_get(this, _totalItems) - 1);
+    }
+    /**
+   * Returns the size of the single item at the given index.
+   *
+   * @param {number} index The item index.
+   * @returns {number} The exception size, the base size, or `0` outside the item range.
+   */ getSizeAt(index) {
+        if (index < 0 || index >= _class_private_field_get(this, _totalItems)) {
+            return 0;
+        }
+        return _class_private_field_get(this, _sizes).get(index) ?? _class_private_field_get(this, _base);
+    }
+    /**
+   * Returns the total size of all items.
+   *
+   * @returns {number}
+   */ getTotalSize() {
+        return _class_private_field_get(this, _totalItems) * _class_private_field_get(this, _base) + _class_private_field_get(this, _deltaPrefix)[_class_private_field_get(this, _deltaPrefix).length - 1];
+    }
+    /**
+   * @param {Record<number, number|undefined>} exceptions Per-index size overrides.
+   * @param {number} totalItems The total item count read at build time.
+   * @param {Function} sizeFn A function that returns the size for a given index.
+   * @param {number} defaultSize The default item size read at build time.
+   */ constructor(exceptions, totalItems, sizeFn, defaultSize){
+        _class_private_method_init(this, _countExceptionsBelow);
+        /**
+   * The base size shared by every non-exception item.
+   *
+   * @type {number}
+   */ _class_private_field_init(this, _base, {
+            writable: true,
+            value: void 0
+        });
+        /**
+   * The total item count read at build time.
+   *
+   * @type {number}
+   */ _class_private_field_init(this, _totalItems, {
+            writable: true,
+            value: void 0
+        });
+        /**
+   * Sorted item indexes that override the base size.
+   *
+   * @type {Float64Array}
+   */ _class_private_field_init(this, _indexes, {
+            writable: true,
+            value: void 0
+        });
+        /**
+   * Prefix sums of the exceptions' size deltas against the base: `#deltaPrefix[j]` is the summed
+   * extra size of the first `j` exceptions. One element longer than `#indexes`.
+   *
+   * @type {Float64Array}
+   */ _class_private_field_init(this, _deltaPrefix, {
+            writable: true,
+            value: void 0
+        });
+        /**
+   * Exception sizes keyed by item index, for O(1) single-item reads.
+   *
+   * @type {Map<number, number>}
+   */ _class_private_field_init(this, _sizes, {
+            writable: true,
+            value: void 0
+        });
+        /**
+   * Sparse mode never holds a full prefix-sum array.
+   *
+   * @type {null}
+   */ this.prefixSum = null;
+        const sizes = new Map();
+        for (const key of Object.keys(exceptions)){
+            const index = Number(key);
+            // Skip wiped records and records of items that no longer exist (item count shrank).
+            if (exceptions[index] !== undefined && index >= 0 && index < totalItems) {
+                // The record supplies only the KEY set. The size is read through `sizeFn` — the same
+                // resolution the prefix-sum strategy applies per item — so both strategies agree on
+                // every exception. Reading the record's raw value instead would skip the size funnel's
+                // clamp (`max(provided size, measured oversized size)`) and under-count a stale record
+                // whose provided size grew after it was measured.
+                const size = sizeFn(index);
+                sizes.set(index, isNaN(size) ? defaultSize : size);
+            }
+        }
+        // Integer-like record keys already arrive in ascending order (`Object.keys` index-key
+        // ordering, preserved through the Map). The sort is defensive only — it guards the binary
+        // searches against a future non-index-keyed provider, and it is numeric by default on a
+        // typed array.
+        const indexes = Float64Array.from(sizes.keys()).sort();
+        // Sample the base from the LAST non-exception item (see `sampleBaseSize` for why the last).
+        // Walk past trailing exception items; with every item excepted, fall back to the default size.
+        let sampleIndex = totalItems - 1;
+        while(sampleIndex >= 0 && sizes.has(sampleIndex)){
+            sampleIndex -= 1;
+        }
+        const base = sampleBaseSize(sampleIndex, sizeFn, defaultSize);
+        const deltaPrefix = new Float64Array(indexes.length + 1);
+        for(let j = 0; j < indexes.length; j++){
+            deltaPrefix[j + 1] = deltaPrefix[j] + (sizes.get(indexes[j]) - base);
+        }
+        _class_private_field_set(this, _base, base);
+        _class_private_field_set(this, _totalItems, totalItems);
+        _class_private_field_set(this, _indexes, indexes);
+        _class_private_field_set(this, _deltaPrefix, deltaPrefix);
+        _class_private_field_set(this, _sizes, sizes);
+    }
+}
+function countExceptionsBelow(index) {
+    const indexes = _class_private_field_get(this, _indexes);
+    return lowerBound(indexes.length, (mid)=>indexes[mid] < index);
+}

package/3rdparty/walkontable/src/axisSizing/positionCache/strategy.d.mts

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

package/3rdparty/walkontable/src/axisSizing/positionCache/strategy.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The contract every position-lookup strategy implements. A strategy is an immutable snapshot
+ * built from the sizes read at build time — `PositionCache` (the facade in `index.ts`) constructs
+ * exactly one of them per build and delegates every read to it, so no strategy ever branches on
+ * "which mode am I in".
+ */
+export interface PositionStrategy {
+    /**
+     * The prefix-sum array when the strategy holds one (`PrefixSumPositionStrategy` only); `null`
+     * otherwise. Exposed for the facade's `prefixSum` back-compat field and its `isBuilt()` type
+     * guard.
+     */
+    readonly prefixSum: Float64Array | null;
+    /**
+     * Returns the cumulative size before the given item index.
+     */
+    getOffset(index: number): number;
+    /**
+     * Finds the item index whose cumulative start position is at or just before the given offset.
+     */
+    findIndexAtOffset(offset: number): number;
+    /**
+     * Returns the size of the single item at the given index.
+     */
+    getSizeAt(index: number): number;
+    /**
+     * Returns the total size of all items.
+     */
+    getTotalSize(): number;
+}
+/**
+ * Samples the size shared by (or defaulted for) the tail of the item list. Samples the LAST
+ * item, never the first rendered one: `getDefaultRowHeight` adds a 1px border compensation to the
+ * first rendered visible row, so sampling index 0 at build time (scroll position 0) would
+ * propagate that +1 to every arithmetic offset. Used by the uniform and sparse strategies.
+ *
+ * @param {number} sampleIndex The index to sample; pass a negative value to force the default.
+ * @param {Function} sizeFn A function that returns the size for a given index.
+ * @param {number} defaultSize The fallback size when the sample is missing (NaN) or out of range.
+ * @returns {number} The sampled or default size.
+ */
+export declare function sampleBaseSize(sampleIndex: number, sizeFn: (index: number) => number, defaultSize: number): number;
+/**
+ * Classic lower-bound binary search over `[0, hi]`: returns the smallest index for which
+ * `isBelow` is `false`. The predicate must be monotone — `true` for every index below the answer,
+ * `false` from the answer on. Shared by the strategies' offset-to-index lookups and the sparse
+ * strategy's exception counting, so the search/clamp logic lives in one place.
+ *
+ * @param {number} hi The exclusive upper bound of the search range.
+ * @param {Function} isBelow A monotone predicate deciding whether the answer lies above `mid`.
+ * @returns {number} The lower-bound index, in `[0, hi]`.
+ */
+export declare function lowerBound(hi: number, isBelow: (mid: number) => boolean): number;

package/3rdparty/walkontable/src/axisSizing/positionCache/strategy.js

@@ -0,0 +1,40 @@
+/**
+ * The contract every position-lookup strategy implements. A strategy is an immutable snapshot
+ * built from the sizes read at build time — `PositionCache` (the facade in `index.ts`) constructs
+ * exactly one of them per build and delegates every read to it, so no strategy ever branches on
+ * "which mode am I in".
+ */ "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 lowerBound () {
+        return lowerBound;
+    },
+    get sampleBaseSize () {
+        return sampleBaseSize;
+    }
+});
+function sampleBaseSize(sampleIndex, sizeFn, defaultSize) {
+    const sampled = sampleIndex >= 0 ? sizeFn(sampleIndex) : NaN;
+    return isNaN(sampled) ? defaultSize : sampled;
+}
+function lowerBound(hi, isBelow) {
+    let lo = 0;
+    while(lo < hi){
+        // eslint-disable-next-line no-bitwise
+        const mid = lo + hi >>> 1;
+        if (isBelow(mid)) {
+            lo = mid + 1;
+        } else {
+            hi = mid;
+        }
+    }
+    return lo;
+}

package/3rdparty/walkontable/src/axisSizing/positionCache/strategy.mjs

@@ -0,0 +1,41 @@
+/**
+ * The contract every position-lookup strategy implements. A strategy is an immutable snapshot
+ * built from the sizes read at build time — `PositionCache` (the facade in `index.ts`) constructs
+ * exactly one of them per build and delegates every read to it, so no strategy ever branches on
+ * "which mode am I in".
+ */ /**
+ * Samples the size shared by (or defaulted for) the tail of the item list. Samples the LAST
+ * item, never the first rendered one: `getDefaultRowHeight` adds a 1px border compensation to the
+ * first rendered visible row, so sampling index 0 at build time (scroll position 0) would
+ * propagate that +1 to every arithmetic offset. Used by the uniform and sparse strategies.
+ *
+ * @param {number} sampleIndex The index to sample; pass a negative value to force the default.
+ * @param {Function} sizeFn A function that returns the size for a given index.
+ * @param {number} defaultSize The fallback size when the sample is missing (NaN) or out of range.
+ * @returns {number} The sampled or default size.
+ */ export function sampleBaseSize(sampleIndex, sizeFn, defaultSize) {
+    const sampled = sampleIndex >= 0 ? sizeFn(sampleIndex) : NaN;
+    return isNaN(sampled) ? defaultSize : sampled;
+}
+/**
+ * Classic lower-bound binary search over `[0, hi]`: returns the smallest index for which
+ * `isBelow` is `false`. The predicate must be monotone — `true` for every index below the answer,
+ * `false` from the answer on. Shared by the strategies' offset-to-index lookups and the sparse
+ * strategy's exception counting, so the search/clamp logic lives in one place.
+ *
+ * @param {number} hi The exclusive upper bound of the search range.
+ * @param {Function} isBelow A monotone predicate deciding whether the answer lies above `mid`.
+ * @returns {number} The lower-bound index, in `[0, hi]`.
+ */ export function lowerBound(hi, isBelow) {
+    let lo = 0;
+    while(lo < hi){
+        // eslint-disable-next-line no-bitwise
+        const mid = lo + hi >>> 1;
+        if (isBelow(mid)) {
+            lo = mid + 1;
+        } else {
+            hi = mid;
+        }
+    }
+    return lo;
+}

package/3rdparty/walkontable/src/axisSizing/positionCache/uniformStrategy.d.mts

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

package/3rdparty/walkontable/src/axisSizing/positionCache/uniformStrategy.d.ts

@@ -0,0 +1,47 @@
+import type { PositionStrategy } from './strategy';
+/**
+ * Position lookups for items that all share one size: every answer is plain arithmetic — no
+ * allocation, no iteration. Active when the size source reports uniform sizes and no per-item
+ * override (e.g. a measured oversized row) exists.
+ */
+export declare class UniformPositionStrategy implements PositionStrategy {
+    #private;
+    /**
+     * Uniform mode never holds a prefix-sum array.
+     *
+     * @type {null}
+     */
+    readonly prefixSum: null;
+    /**
+     * @param {number} size The size shared by every item.
+     * @param {number} totalItems The total item count read at build time.
+     */
+    constructor(size: number, totalItems: number);
+    /**
+     * Returns the cumulative size before the given item index.
+     *
+     * @param {number} index The item index.
+     * @returns {number} The cumulative size before this index.
+     */
+    getOffset(index: number): number;
+    /**
+     * Finds the item index at a given pixel offset arithmetically.
+     *
+     * @param {number} offset The pixel offset.
+     * @returns {number} The index whose cumulative start position is at or just before the offset.
+     */
+    findIndexAtOffset(offset: number): number;
+    /**
+     * Returns the size of the single item at the given index.
+     *
+     * @param {number} index The item index.
+     * @returns {number} The item size, or `0` outside the item range.
+     */
+    getSizeAt(index: number): number;
+    /**
+     * Returns the total size of all items.
+     *
+     * @returns {number}
+     */
+    getTotalSize(): number;
+}

package/3rdparty/walkontable/src/axisSizing/positionCache/uniformStrategy.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "UniformPositionStrategy", {
+    enumerable: true,
+    get: function() {
+        return UniformPositionStrategy;
+    }
+});
+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 _size = /*#__PURE__*/ new WeakMap(), _totalItems = /*#__PURE__*/ new WeakMap();
+class UniformPositionStrategy {
+    /**
+   * Returns the cumulative size before the given item index.
+   *
+   * @param {number} index The item index.
+   * @returns {number} The cumulative size before this index.
+   */ getOffset(index) {
+        if (index <= 0) {
+            return 0;
+        }
+        return Math.min(index, _class_private_field_get(this, _totalItems)) * _class_private_field_get(this, _size);
+    }
+    /**
+   * Finds the item index at a given pixel offset arithmetically.
+   *
+   * @param {number} offset The pixel offset.
+   * @returns {number} The index whose cumulative start position is at or just before the offset.
+   */ findIndexAtOffset(offset) {
+        if (offset <= 0 || _class_private_field_get(this, _totalItems) === 0) {
+            return 0;
+        }
+        return Math.min(Math.floor(offset / _class_private_field_get(this, _size)), _class_private_field_get(this, _totalItems) - 1);
+    }
+    /**
+   * Returns the size of the single item at the given index.
+   *
+   * @param {number} index The item index.
+   * @returns {number} The item size, or `0` outside the item range.
+   */ getSizeAt(index) {
+        if (index < 0 || index >= _class_private_field_get(this, _totalItems)) {
+            return 0;
+        }
+        return _class_private_field_get(this, _size);
+    }
+    /**
+   * Returns the total size of all items.
+   *
+   * @returns {number}
+   */ getTotalSize() {
+        return _class_private_field_get(this, _totalItems) * _class_private_field_get(this, _size);
+    }
+    /**
+   * @param {number} size The size shared by every item.
+   * @param {number} totalItems The total item count read at build time.
+   */ constructor(size, totalItems){
+        /**
+   * The size shared by every item.
+   *
+   * @type {number}
+   */ _class_private_field_init(this, _size, {
+            writable: true,
+            value: void 0
+        });
+        /**
+   * The total item count read at build time.
+   *
+   * @type {number}
+   */ _class_private_field_init(this, _totalItems, {
+            writable: true,
+            value: void 0
+        });
+        /**
+   * Uniform mode never holds a prefix-sum array.
+   *
+   * @type {null}
+   */ this.prefixSum = null;
+        _class_private_field_set(this, _size, size);
+        _class_private_field_set(this, _totalItems, totalItems);
+    }
+}

package/3rdparty/walkontable/src/axisSizing/positionCache/uniformStrategy.mjs

@@ -0,0 +1,115 @@
+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 _size = /*#__PURE__*/ new WeakMap(), _totalItems = /*#__PURE__*/ new WeakMap();
+/**
+ * Position lookups for items that all share one size: every answer is plain arithmetic — no
+ * allocation, no iteration. Active when the size source reports uniform sizes and no per-item
+ * override (e.g. a measured oversized row) exists.
+ */ export class UniformPositionStrategy {
+    /**
+   * Returns the cumulative size before the given item index.
+   *
+   * @param {number} index The item index.
+   * @returns {number} The cumulative size before this index.
+   */ getOffset(index) {
+        if (index <= 0) {
+            return 0;
+        }
+        return Math.min(index, _class_private_field_get(this, _totalItems)) * _class_private_field_get(this, _size);
+    }
+    /**
+   * Finds the item index at a given pixel offset arithmetically.
+   *
+   * @param {number} offset The pixel offset.
+   * @returns {number} The index whose cumulative start position is at or just before the offset.
+   */ findIndexAtOffset(offset) {
+        if (offset <= 0 || _class_private_field_get(this, _totalItems) === 0) {
+            return 0;
+        }
+        return Math.min(Math.floor(offset / _class_private_field_get(this, _size)), _class_private_field_get(this, _totalItems) - 1);
+    }
+    /**
+   * Returns the size of the single item at the given index.
+   *
+   * @param {number} index The item index.
+   * @returns {number} The item size, or `0` outside the item range.
+   */ getSizeAt(index) {
+        if (index < 0 || index >= _class_private_field_get(this, _totalItems)) {
+            return 0;
+        }
+        return _class_private_field_get(this, _size);
+    }
+    /**
+   * Returns the total size of all items.
+   *
+   * @returns {number}
+   */ getTotalSize() {
+        return _class_private_field_get(this, _totalItems) * _class_private_field_get(this, _size);
+    }
+    /**
+   * @param {number} size The size shared by every item.
+   * @param {number} totalItems The total item count read at build time.
+   */ constructor(size, totalItems){
+        /**
+   * The size shared by every item.
+   *
+   * @type {number}
+   */ _class_private_field_init(this, _size, {
+            writable: true,
+            value: void 0
+        });
+        /**
+   * The total item count read at build time.
+   *
+   * @type {number}
+   */ _class_private_field_init(this, _totalItems, {
+            writable: true,
+            value: void 0
+        });
+        /**
+   * Uniform mode never holds a prefix-sum array.
+   *
+   * @type {null}
+   */ this.prefixSum = null;
+        _class_private_field_set(this, _size, size);
+        _class_private_field_set(this, _totalItems, totalItems);
+    }
+}

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

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

package/3rdparty/walkontable/src/{utils/row.d.ts → axisSizing/rowUtils.d.ts}

@@ -1,24 +1,26 @@
-import type { DataAccessObject } from '../types';
-import type Settings from '../settings';
+import type { TableDeps } from '../table/baseTable';
 /**
  * Row utils class contains all necessary information about sizes of the rows.
  *
  * @class {RowUtils}
  */
 export default class RowUtils {
+    #private;
     /**
-     * @type {TableDao}
+     * @type {Settings}
      */
-    dataAccessObject: DataAccessObject;
+    wtSettings: import("../settings").default;
     /**
-     * @type {Settings}
+     * Read-only access to the dependencies, for the renderer, which reads `rowUtils.deps` externally
+     * and so cannot reach the private `#deps`.
+     *
+     * @returns {TableDeps}
      */
-    wtSettings: Settings;
+    get deps(): TableDeps;
     /**
-     * @param {TableDao} dataAccessObject The table Data Access Object.
-     * @param {Settings} wtSettings The walkontable settings.
+     * @param {TableDeps} deps The table module dependencies.
      */
-    constructor(dataAccessObject: DataAccessObject, wtSettings: Settings);
+    constructor(deps: TableDeps);
     /**
      * Returns row height based on passed source index.
      *