handsontable 18.0.0 → 18.1.0-rc7

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

@@ -1,194 +0,0 @@
-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 _totalItemsFn = /*#__PURE__*/ new WeakMap(), _sizeFn = /*#__PURE__*/ new WeakMap(), _defaultSizeFn = /*#__PURE__*/ new WeakMap();
-/**
- * Cumulative prefix sum cache for O(log n) scroll-to-index lookups.
- *
- * Works for both row heights and column widths. Builds an array where
- * prefixSum[i] = sum of sizes for items 0..i-1.
- * prefixSum[0] = 0, prefixSum[n] = total size of all n items.
- *
- * Binary search on this array converts a pixel offset to an index in O(log n)
- * instead of O(n) linear iteration.
- *
- * @class PositionCache
- */ export class PositionCache {
-    /**
-   * Builds the prefix sum by reading the current total items, size function,
-   * and default size from the configured providers.
-   */ build() {
-        const totalItems = _class_private_field_get(this, _totalItemsFn).call(this);
-        const sizeFn = _class_private_field_get(this, _sizeFn);
-        const defaultSize = _class_private_field_get(this, _defaultSizeFn).call(this);
-        this.totalItems = totalItems;
-        this.prefixSum = new Float64Array(totalItems + 1);
-        this.prefixSum[0] = 0;
-        for(let i = 0; i < totalItems; i++){
-            const s = sizeFn(i);
-            this.prefixSum[i + 1] = this.prefixSum[i] + (isNaN(s) ? defaultSize : s);
-        }
-    }
-    /**
-   * Returns the cumulative size at an index (sum of items 0..index-1).
-   *
-   * @param {number} index The item index.
-   * @returns {number} The cumulative size before this index.
-   */ getOffset(index) {
-        if (!this.prefixSum || index <= 0) {
-            return 0;
-        }
-        if (index >= this.totalItems) {
-            return this.prefixSum[this.totalItems];
-        }
-        return this.prefixSum[index];
-    }
-    /**
-   * Finds the item index at a given pixel offset using binary search.
-   *
-   * @param {number} offset The pixel offset.
-   * @returns {number} The index whose cumulative start position is at or just before the offset.
-   *   Returns `0` when there are no items (`totalItems === 0`), including when `offset > 0`.
-   */ findIndexAtOffset(offset) {
-        if (!this.isBuilt() || offset <= 0 || this.totalItems === 0) {
-            return 0;
-        }
-        let lo = 0;
-        let hi = this.totalItems;
-        while(lo < hi){
-            // eslint-disable-next-line no-bitwise
-            const mid = lo + hi >>> 1;
-            if (this.prefixSum[mid + 1] <= offset) {
-                lo = mid + 1;
-            } else {
-                hi = mid;
-            }
-        }
-        return Math.min(lo, this.totalItems - 1);
-    }
-    /**
-   * Returns the size of a single item at the given index.
-   *
-   * @param {number} index The item index.
-   * @returns {number} The size of the item (difference between consecutive prefix sums).
-   */ getSizeAt(index) {
-        if (!this.prefixSum || index < 0 || index >= this.totalItems) {
-            return 0;
-        }
-        return this.prefixSum[index + 1] - this.prefixSum[index];
-    }
-    /**
-   * Builds the prefix sum only when the cache is not yet built or the item
-   * count has changed.
-   */ ensureBuilt() {
-        if (!this.isBuilt() || this.totalItems !== _class_private_field_get(this, _totalItemsFn).call(this)) {
-            this.build();
-        }
-    }
-    /**
-   * Returns the total size of all items.
-   *
-   * @returns {number}
-   */ getTotalSize() {
-        if (!this.prefixSum) {
-            return 0;
-        }
-        return this.prefixSum[this.totalItems];
-    }
-    /**
-   * Invalidates the cache so it will be rebuilt on the next
-   * {@link PositionCache#ensureBuilt} call.
-   */ invalidate() {
-        this.prefixSum = null;
-        this.totalItems = 0;
-    }
-    /**
-   * Returns whether the cache has been built.
-   *
-   * @returns {boolean}
-   */ isBuilt() {
-        return this.prefixSum !== null;
-    }
-    /**
-   * @param {object} config The configuration object.
-   * @param {Function} config.totalItemsFn A function that returns the total number of items (rows or columns).
-   * @param {Function} config.sizeFn A function that returns the size for a given index.
-   * @param {Function} config.defaultSizeFn A function that returns the default size for items
-   *   that return NaN/undefined.
-   */ constructor({ totalItemsFn, sizeFn, defaultSizeFn }){
-        /**
-   * A function that returns the total number of items (rows or columns).
-   *
-   * @type {Function}
-   */ _class_private_field_init(this, _totalItemsFn, {
-            writable: true,
-            value: void 0
-        });
-        /**
-   * A function that returns the size for a given index.
-   *
-   * @type {Function}
-   */ _class_private_field_init(this, _sizeFn, {
-            writable: true,
-            value: void 0
-        });
-        /**
-   * A function that returns the default size for items that return NaN/undefined.
-   *
-   * @type {Function}
-   */ _class_private_field_init(this, _defaultSizeFn, {
-            writable: true,
-            value: void 0
-        });
-        /**
-   * The prefix sum array. Contains the cumulative size of all items up to the index.
-   *
-   * @type {Float64Array|null}
-   */ this.prefixSum = null;
-        /**
-   * The total number of items (rows or columns).
-   *
-   * @type {number}
-   */ this.totalItems = 0;
-        _class_private_field_set(this, _totalItemsFn, totalItemsFn);
-        _class_private_field_set(this, _sizeFn, sizeFn);
-        _class_private_field_set(this, _defaultSizeFn, defaultSizeFn);
-    }
-}

package/3rdparty/walkontable/src/utils/row.d.mts

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

package/3rdparty/walkontable/src/utils/row.js

@@ -1,46 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return RowUtils;
-    }
-});
-class RowUtils {
-    /**
-   * Returns row height based on passed source index.
-   *
-   * @param {number} sourceIndex Row source index.
-   * @returns {number}
-   */ getHeight(sourceIndex) {
-        let height = this.wtSettings.getSetting('rowHeight', sourceIndex);
-        const oversizedHeight = this.dataAccessObject.wtViewport.oversizedRows[sourceIndex];
-        if (oversizedHeight !== undefined) {
-            height = height === undefined ? oversizedHeight : Math.max(height, oversizedHeight);
-        }
-        return height;
-    }
-    /**
-   * Returns row height based on passed source index for the specified overlay type.
-   *
-   * @param {number} sourceIndex Row source index.
-   * @param {'inline_start'|'top'|'top_inline_start_corner'|'bottom'|'bottom_inline_start_corner'|'master'} overlayName The overlay name.
-   * @returns {number}
-   */ getHeightByOverlayName(sourceIndex, overlayName) {
-        let height = this.wtSettings.getSetting('rowHeightByOverlayName', sourceIndex, overlayName);
-        const oversizedHeight = this.dataAccessObject.wtViewport.oversizedRows[sourceIndex];
-        if (oversizedHeight !== undefined) {
-            height = height === undefined ? oversizedHeight : Math.max(height, oversizedHeight);
-        }
-        return height;
-    }
-    /**
-   * @param {TableDao} dataAccessObject The table Data Access Object.
-   * @param {Settings} wtSettings The walkontable settings.
-   */ constructor(dataAccessObject, wtSettings){
-        this.dataAccessObject = dataAccessObject;
-        this.wtSettings = wtSettings;
-    }
-}

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

@@ -1,41 +0,0 @@
-class RowUtils {
-    /**
-   * Returns row height based on passed source index.
-   *
-   * @param {number} sourceIndex Row source index.
-   * @returns {number}
-   */ getHeight(sourceIndex) {
-        let height = this.wtSettings.getSetting('rowHeight', sourceIndex);
-        const oversizedHeight = this.dataAccessObject.wtViewport.oversizedRows[sourceIndex];
-        if (oversizedHeight !== undefined) {
-            height = height === undefined ? oversizedHeight : Math.max(height, oversizedHeight);
-        }
-        return height;
-    }
-    /**
-   * Returns row height based on passed source index for the specified overlay type.
-   *
-   * @param {number} sourceIndex Row source index.
-   * @param {'inline_start'|'top'|'top_inline_start_corner'|'bottom'|'bottom_inline_start_corner'|'master'} overlayName The overlay name.
-   * @returns {number}
-   */ getHeightByOverlayName(sourceIndex, overlayName) {
-        let height = this.wtSettings.getSetting('rowHeightByOverlayName', sourceIndex, overlayName);
-        const oversizedHeight = this.dataAccessObject.wtViewport.oversizedRows[sourceIndex];
-        if (oversizedHeight !== undefined) {
-            height = height === undefined ? oversizedHeight : Math.max(height, oversizedHeight);
-        }
-        return height;
-    }
-    /**
-   * @param {TableDao} dataAccessObject The table Data Access Object.
-   * @param {Settings} wtSettings The walkontable settings.
-   */ constructor(dataAccessObject, wtSettings){
-        this.dataAccessObject = dataAccessObject;
-        this.wtSettings = wtSettings;
-    }
-}
-/**
- * Row utils class contains all necessary information about sizes of the rows.
- *
- * @class {RowUtils}
- */ export { RowUtils as default };

package/3rdparty/walkontable/src/viewport.d.ts

@@ -1,254 +0,0 @@
-import type { DataAccessObject, DomBindings, WalkontableInstance } from './types';
-import type Settings from './settings';
-import type Table from './table';
-import type EventManager from '../../../eventManager';
-import type { CalculationTypeLike, ColumnsCalculationType, RowsCalculationType } from './calculator/viewportBase';
-import { ViewportColumnsCalculator, ViewportRowsCalculator } from './calculator';
-import { PositionCache } from './utils/positionCache';
-/**
- * @class Viewport
- */
-declare class Viewport {
-    /**
-     * @type {DataAccessObject}
-     */
-    dataAccessObject: DataAccessObject;
-    /**
-     * @type {WalkontableInstance}
-     */
-    wot: WalkontableInstance;
-    /**
-     * @type {WalkontableInstance}
-     */
-    instance: WalkontableInstance;
-    /**
-     * @type {DomBindings}
-     */
-    domBindings: DomBindings;
-    /**
-     * @type {Settings}
-     */
-    wtSettings: Settings;
-    /**
-     * @type {Table}
-     */
-    wtTable: Table;
-    /**
-     * @type {Record<number, number | undefined>}
-     */
-    oversizedRows: Record<number, number | undefined>;
-    /**
-     * @type {Record<number, number | undefined>}
-     */
-    oversizedColumnHeaders: Record<number, number | undefined>;
-    /**
-     * @type {Record<string, unknown>}
-     */
-    hasOversizedColumnHeadersMarked: Record<string, unknown>;
-    /**
-     * @type {number}
-     */
-    clientHeight: number;
-    /**
-     * @type {number}
-     */
-    columnHeaderHeight: number;
-    /**
-     * @type {number}
-     */
-    rowHeaderWidth: number;
-    /**
-     * @type {RowsCalculationType | null}
-     */
-    rowsVisibleCalculator: RowsCalculationType | null;
-    /**
-     * @type {ColumnsCalculationType | null}
-     */
-    columnsVisibleCalculator: ColumnsCalculationType | null;
-    /**
-     * @type {Map<string, () => CalculationTypeLike>}
-     */
-    rowsCalculatorTypes: Map<string, () => CalculationTypeLike>;
-    /**
-     * @type {Map<string, () => CalculationTypeLike>}
-     */
-    columnsCalculatorTypes: Map<string, () => CalculationTypeLike>;
-    /**
-     * @type {EventManager}
-     */
-    eventManager: EventManager;
-    /**
-     * @type {RowsCalculationType | null}
-     */
-    rowsRenderCalculator: RowsCalculationType | null;
-    /**
-     * @type {ColumnsCalculationType | null}
-     */
-    columnsRenderCalculator: ColumnsCalculationType | null;
-    /**
-     * @type {RowsCalculationType | null}
-     */
-    rowsPartiallyVisibleCalculator: RowsCalculationType | null;
-    /**
-     * @type {ColumnsCalculationType | null}
-     */
-    columnsPartiallyVisibleCalculator: ColumnsCalculationType | null;
-    /**
-     * @type {PositionCache}
-     */
-    rowHeightCache: PositionCache;
-    /**
-     * @type {PositionCache}
-     */
-    columnWidthCache: PositionCache;
-    /**
-     * @param {ViewportDao} dataAccessObject The Walkontable instance.
-     * @param {DomBindings} domBindings Bindings into DOM.
-     * @param {Settings} wtSettings The Walkontable settings.
-     * @param {EventManager} eventManager The instance event manager.
-     * @param {Table} wtTable The table.
-     */
-    constructor(dataAccessObject: DataAccessObject, domBindings: DomBindings, wtSettings: Settings, eventManager: EventManager, wtTable: Table);
-    /**
-     * @returns {number}
-     */
-    getWorkspaceHeight(): number;
-    /**
-     * @returns {number}
-     */
-    getViewportHeight(): number;
-    /**
-     * Gets the width of the table workspace (in pixels). The workspace size in the current
-     * implementation returns the width of the table holder element including scrollbar width when
-     * the table has defined size and the width of the window excluding scrollbar width when
-     * the table has no defined size (the window is a scrollable container).
-     *
-     * This is a bug, as the method should always return stable values, always without scrollbar width.
-     * Changing this behavior would break the column calculators, which would also need to be adjusted.
-     *
-     * @returns {number}
-     */
-    getWorkspaceWidth(): number;
-    /**
-     * @returns {number}
-     */
-    getViewportWidth(): number;
-    /**
-     * Checks if viewport has vertical scroll.
-     *
-     * @returns {boolean}
-     */
-    hasVerticalScroll(): boolean;
-    /**
-     * Checks if viewport has horizontal scroll.
-     *
-     * @returns {boolean}
-     */
-    hasHorizontalScroll(): boolean;
-    /**
-     * Checks if the table uses the window as a viewport and if there is a vertical scrollbar.
-     *
-     * @returns {boolean}
-     */
-    isVerticallyScrollableByWindow(): boolean;
-    /**
-     * Checks if the table uses the window as a viewport and if there is a horizontal scrollbar.
-     *
-     * @returns {boolean}
-     */
-    isHorizontallyScrollableByWindow(): boolean;
-    /**
-     * @param {number} from The visual column index from the width sum is start calculated.
-     * @param {number} length The length of the column to traverse.
-     * @returns {number}
-     */
-    sumColumnWidths(from: number, length: number): number;
-    /**
-     * @returns {number}
-     */
-    getWorkspaceOffset(): {
-        left: number;
-        top: number;
-    };
-    /**
-     * @returns {number}
-     */
-    getColumnHeaderHeight(): number;
-    /**
-     * @returns {number}
-     */
-    getRowHeaderWidth(): number;
-    /**
-     * Creates rows calculators. The type of the calculations can be chosen from the list:
-     *  - 'rendered' Calculates rows that should be rendered within the current table's viewport;
-     *  - 'fullyVisible' Calculates rows that are fully visible (used mostly for scrolling purposes);
-     *  - 'partiallyVisible' Calculates rows that are partially visible (used mostly for scrolling purposes).
-     *
-     * @param {'rendered' | 'fullyVisible' | 'partiallyVisible'} calculatorTypes The list of the calculation types.
-     * @returns {ViewportRowsCalculator}
-     */
-    createRowsCalculator(calculatorTypes?: string[]): ViewportRowsCalculator;
-    /**
-     * Creates columns calculators. The type of the calculations can be chosen from the list:
-     *  - 'rendered' Calculates columns that should be rendered within the current table's viewport;
-     *  - 'fullyVisible' Calculates columns that are fully visible (used mostly for scrolling purposes);
-     *  - 'partiallyVisible' Calculates columns that are partially visible (used mostly for scrolling purposes).
-     *
-     * @param {'rendered' | 'fullyVisible' | 'partiallyVisible'} calculatorTypes The list of the calculation types.
-     * @returns {ViewportColumnsCalculator}
-     */
-    createColumnsCalculator(calculatorTypes?: string[]): ViewportColumnsCalculator;
-    /**
-     * Creates rowsRenderCalculator and columnsRenderCalculator (before draw, to determine what rows and
-     * cols should be rendered).
-     *
-     * @param {boolean} fastDraw If `true`, will try to avoid full redraw and only update the border positions.
-     *                           If `false` or `undefined`, will perform a full redraw.
-     * @returns {boolean} The fastDraw value, possibly modified.
-     */
-    createCalculators(fastDraw?: boolean): boolean;
-    /**
-     * Creates rows and columns calculators (after draw, to determine what are
-     * the actually fully visible and partially visible rows and columns).
-     */
-    createVisibleCalculators(): void;
-    /**
-     * Returns information whether proposedFullyVisibleRowsCalculator viewport
-     * is contained inside rows rendered in previous draw (cached in rowsRenderCalculator).
-     *
-     * @param {ViewportRowsCalculator} proposedFullyVisibleRowsCalculator The instance of the fully visible rows viewport calculator to compare with.
-     * @param {ViewportRowsCalculator} proposedPartiallyVisibleRowsCalculator The instance of the partially visible rows viewport calculator to compare with.
-     * @returns {boolean} Returns `true` if all proposed visible rows are already rendered (meaning: redraw is not needed).
-     *                    Returns `false` if at least one proposed visible row is not already rendered (meaning: redraw is needed).
-     */
-    areAllProposedVisibleRowsAlreadyRendered(proposedFullyVisibleRowsCalculator: RowsCalculationType | undefined, proposedPartiallyVisibleRowsCalculator: RowsCalculationType | undefined): boolean;
-    /**
-     * Returns information whether proposedFullyVisibleColumnsCalculator viewport
-     * is contained inside column rendered in previous draw (cached in columnsRenderCalculator).
-     *
-     * @param {ViewportRowsCalculator} proposedFullyVisibleColumnsCalculator The instance of the fully visible columns viewport calculator to compare with.
-     * @param {ViewportRowsCalculator} proposedPartiallyVisibleColumnsCalculator The instance of the partially visible columns viewport calculator to compare with.
-     * @returns {boolean} Returns `true` if all proposed visible columns are already rendered (meaning: redraw is not needed).
-     *                    Returns `false` if at least one proposed visible column is not already rendered (meaning: redraw is needed).
-     */
-    areAllProposedVisibleColumnsAlreadyRendered(proposedFullyVisibleColumnsCalculator: ColumnsCalculationType | undefined, proposedPartiallyVisibleColumnsCalculator: ColumnsCalculationType | undefined): boolean;
-    /**
-     * Marks the row height position cache as stale. The cache will be rebuilt
-     * on the next viewport calculation.
-     */
-    invalidateRowHeightCache(): void;
-    /**
-     * Marks the column width position cache as stale. The cache will be rebuilt
-     * on the next viewport calculation.
-     */
-    invalidateColumnWidthCache(): void;
-    /**
-     * Marks both the row height and column width position caches as stale.
-     */
-    invalidateAllCaches(): void;
-    /**
-     * Resets values in keys of the hasOversizedColumnHeadersMarked object after updateSettings.
-     */
-    resetHasOversizedColumnHeadersMarked(): void;
-}
-export default Viewport;