handsontable 18.0.0 → 18.1.0-rc1

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

@@ -0,0 +1,112 @@
+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;
+}
+import { lowerBound } from './strategy.mjs';
+var _totalItems = /*#__PURE__*/ new WeakMap();
+/**
+ * Position lookups over fully heterogeneous sizes: one prefix-sum array entry per item, where
+ * `prefixSum[i]` is the summed size of items `0..i-1`. Building walks every item once (O(n) time
+ * and memory); offset reads are O(1) and offset-to-index lookups are an O(log n) binary search.
+ * This is the general fallback when neither the uniform nor the sparse strategy applies (per-item
+ * size settings or a size-modifying hook exist).
+ */ export class PrefixSumPositionStrategy {
+    /**
+   * 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;
+        }
+        if (index >= _class_private_field_get(this, _totalItems)) {
+            return this.prefixSum[_class_private_field_get(this, _totalItems)];
+        }
+        return this.prefixSum[index];
+    }
+    /**
+   * Finds the item index at a given pixel offset using binary search over the prefix sums.
+   *
+   * @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.prefixSum[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 size (difference between consecutive prefix sums), or `0` outside the
+   *   item range.
+   */ getSizeAt(index) {
+        if (index < 0 || index >= _class_private_field_get(this, _totalItems)) {
+            return 0;
+        }
+        return this.prefixSum[index + 1] - this.prefixSum[index];
+    }
+    /**
+   * Returns the total size of all items.
+   *
+   * @returns {number}
+   */ getTotalSize() {
+        return this.prefixSum[_class_private_field_get(this, _totalItems)];
+    }
+    /**
+   * @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 size for items that report NaN.
+   */ constructor(totalItems, sizeFn, defaultSize){
+        /**
+   * The total item count read at build time.
+   *
+   * @type {number}
+   */ _class_private_field_init(this, _totalItems, {
+            writable: true,
+            value: void 0
+        });
+        const prefixSum = new Float64Array(totalItems + 1);
+        prefixSum[0] = 0;
+        for(let i = 0; i < totalItems; i++){
+            const size = sizeFn(i);
+            prefixSum[i + 1] = prefixSum[i] + (isNaN(size) ? defaultSize : size);
+        }
+        this.prefixSum = prefixSum;
+        _class_private_field_set(this, _totalItems, totalItems);
+    }
+}

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

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

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

@@ -0,0 +1,53 @@
+import type { PositionStrategy } from './strategy';
+/**
+ * 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 declare class SparsePositionStrategy implements PositionStrategy {
+    #private;
+    /**
+     * Sparse mode never holds a full prefix-sum array.
+     *
+     * @type {null}
+     */
+    readonly prefixSum: null;
+    /**
+     * @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: Record<number, number | undefined>, totalItems: number, sizeFn: (index: number) => number, defaultSize: 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 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: number): number;
+    /**
+     * 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: number): number;
+    /**
+     * Returns the total size of all items.
+     *
+     * @returns {number}
+     */
+    getTotalSize(): number;
+}

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

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SparsePositionStrategy", {
+    enumerable: true,
+    get: function() {
+        return SparsePositionStrategy;
+    }
+});
+const _strategy = require("./strategy");
+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);
+}
+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();
+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 = (0, _strategy.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 = (0, _strategy.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 (0, _strategy.lowerBound)(indexes.length, (mid)=>indexes[mid] < index);
+}

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

@@ -0,0 +1,196 @@
+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;
+}