handsontable 18.0.0 → 18.1.0-rc1

package/3rdparty/walkontable/src/selection/manager.mjs

@@ -4,15 +4,12 @@ function _check_private_redeclaration(obj, privateCollection) {
     }
 }
 function _class_apply_descriptor_get(receiver, descriptor) {
-    if (descriptor.get) {
-        return descriptor.get.call(receiver);
-    }
+    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.set) descriptor.set.call(receiver, value);
+    else {
         if (!descriptor.writable) {
             throw new TypeError("attempted to set read only private field");
         }
@@ -20,9 +17,7 @@ function _class_apply_descriptor_set(receiver, descriptor, value) {
     }
 }
 function _class_extract_field_descriptor(receiver, privateMap, action) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to " + action + " private field on non-instance");
-    }
+    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) {
@@ -39,18 +34,17 @@ function _class_private_field_set(receiver, privateMap, 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");
-    }
+    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 { removeClass, addClass, setAttribute, removeAttribute } from '../../../../helpers/dom/element.mjs';
+import { removeClass, addClass, setAttribute, removeAttribute, isHTMLElement } from '../../../../helpers/dom/element.mjs';
 import { SelectionScanner } from './scanner.mjs';
 import Border from './border/border.mjs';
+import { ACTIVE_HEADER_TYPE, CUSTOM_SELECTION_TYPE } from './constants.mjs';
 var /**
    * The overlay's Walkontable instance that are currently processed.
    *
@@ -78,6 +72,76 @@ var /**
    *
    * @type {Map}
    */ _selectionBorders = /*#__PURE__*/ new WeakMap(), /**
+   * Checks whether a custom-border selection falls entirely outside the active overlay's rendered
+   * cell range, so its border does not need to be drawn (and its DOM does not need to exist) here.
+   * Mirrors the range test `Border#appear` performs before it early-outs, so culling produces the
+   * same visual result while avoiding the cost of materializing off-screen border DOM.
+   *
+   * @param {Selection} selection The custom-border selection instance.
+   * @returns {boolean}
+   */ _isCustomSelectionOffscreen = /*#__PURE__*/ new WeakSet(), /**
+   * Tags the neighbours of a single active-header cell: the TH directly BEFORE an active header gets
+   * `<className>-prev` (the theme colors its inline-end border, giving the active header its
+   * inline-start accent), and every TH of the TBODY row directly ABOVE an active row header gets
+   * `<className>-prev-row` (the theme colors its bottom border, giving the active row header its top
+   * accent). Selecting on these stamped classes replaces the former
+   * `th:has(+ th.ht__active_highlight)` and `tr:has(+ tr > th.ht__active_highlight) th` theme rules:
+   * with the class name inside a `:has()` argument, every toggle of it (the selection pass re-applies
+   * it on each draw, and it moves between the recycled header nodes while scrolling) forced a style
+   * invalidation scaled to the whole host page. The row tag lands on TH elements (not the TR) so the
+   * per-band header render and `#resetCells` fully own its cleanup. Called once per scanned
+   * active-header element, from the class-applying pass in `render`.
+   *
+   * @param {HTMLElement} element A scanned active-header element.
+   * @param {string} activeHeaderClassName The active header class name (the neighbour classes derive from it).
+   * @param {Map} classNamesMap The render cycle's element→classNames map (applied and cleaned up later).
+   */ _markActiveHeaderNeighbor = /*#__PURE__*/ new WeakSet(), /**
+   * Tags every TH of the TBODY row directly above the given active row-header cell — the row-axis
+   * half of {@link SelectionManager#markActiveHeaderNeighbor}.
+   *
+   * @param {HTMLElement} element The active row-header cell.
+   * @param {string} activeHeaderClassName The active header class name (the neighbour class derives from it).
+   * @param {Map} classNamesMap The render cycle's element→classNames map (applied and cleaned up later).
+   */ _markPreviousRowHeaders = /*#__PURE__*/ new WeakSet(), /**
+   * Adds a seam class to a header element in the render cycle's class map, creating the per-element
+   * entry on first use. Shared by the frozen column/row seam taggers.
+   *
+   * @param {Map} classNamesMap The render cycle's element→classNames map (applied and cleaned up later).
+   * @param {HTMLElement} th The header element to tag.
+   * @param {string} seamClassName The seam class to add.
+   */ _tagSeamClass = /*#__PURE__*/ new WeakSet(), /**
+   * Tags the last frozen column header with a seam class when the first non-frozen column is the
+   * active header. That header's inline-start edge lands on the frozen-pane seam, which is drawn by
+   * the frozen overlay (a separate table) and is therefore out of reach of the neighbour `:has()`
+   * rule that gives every other active header its inline-start accent. The class lets the theme color
+   * that seam to match. No-op unless `fixedColumnsStart` is used and this is the frozen overlay.
+   *
+   * @param {number[]} corners The active-header selection corners `[fromRow, fromColumn, toRow, toColumn]`.
+   * @param {string} activeHeaderClassName The active header class name (the seam class derives from it).
+   * @param {Map} classNamesMap The render cycle's element→classNames map (applied and cleaned up later).
+   */ _markFrozenColumnSeamHeader = /*#__PURE__*/ new WeakSet(), /**
+   * Row-axis mirror of {@link SelectionManager#markFrozenColumnSeamHeader} for the top freeze:
+   * tags the last top-frozen row header with a seam class when the first non-frozen row is the
+   * active header. That row's top edge lands on the top freeze line, which is drawn by the top
+   * overlay (a separate table) and is therefore out of reach of the `:has(+ tr ...)` rule that gives
+   * every other active row header its top accent. The class lets the theme color the seam's bottom
+   * border to match. No-op unless `fixedRowsTop` is used and this is the top overlay.
+   *
+   * @param {number[]} corners The active-header selection corners `[fromRow, fromColumn, toRow, toColumn]`.
+   * @param {string} activeHeaderClassName The active header class name (the seam class derives from it).
+   * @param {Map} classNamesMap The render cycle's element→classNames map (applied and cleaned up later).
+   */ _markFrozenTopRowSeamHeader = /*#__PURE__*/ new WeakSet(), /**
+   * Row-axis mirror of {@link SelectionManager#markFrozenColumnSeamHeader} for the bottom freeze:
+   * tags the first bottom-frozen row header with a seam class when the last non-frozen row is the
+   * active header. That row's bottom edge lands on the bottom freeze line, which is drawn by the
+   * bottom overlay (a separate table) and is therefore out of reach of the `:has(+ tr ...)` rule that
+   * gives every other active row header its top accent. The class lets the theme color the seam's top
+   * border to match. No-op unless `fixedRowsBottom` is used and this is the bottom overlay.
+   *
+   * @param {number[]} corners The active-header selection corners `[fromRow, fromColumn, toRow, toColumn]`.
+   * @param {string} activeHeaderClassName The active header class name (the seam class derives from it).
+   * @param {Map} classNamesMap The render cycle's element→classNames map (applied and cleaned up later).
+   */ _markFrozenBottomRowSeamHeader = /*#__PURE__*/ new WeakSet(), /**
    * Resets the elements to their initial state (remove the CSS classes that are added in the
    * previous render cycle).
    */ _resetCells = /*#__PURE__*/ new WeakSet();
@@ -192,6 +256,16 @@ var /**
                 _class_private_field_get(this, _destroyListeners).add(selection);
                 selection.addLocalHook('destroy', ()=>this.destroyBorders(selection));
             }
+            // Virtualize custom borders. A per-cell custom-border selection outside this overlay's rendered
+            // range draws nothing anyway - `appear()` early-outs once `getCell()` reports the cell as not
+            // rendered. Skipping it here (without calling `getBorderInstance`) means its Border DOM is never
+            // created while off-screen, which is what lets grids with very many bordered cells scale: only
+            // the visible borders get DOM and layout work, mirroring cell virtualization. The visual result
+            // is identical to letting `appear()` early-out, just without the O(all-borders) DOM.
+            if (selectionType === CUSTOM_SELECTION_TYPE && _class_private_method_get(this, _isCustomSelectionOffscreen, isCustomSelectionOffscreen).call(this, selection)) {
+                _class_private_field_get(this, _selectionBorders).get(selection)?.get(_class_private_field_get(this, _activeOverlaysWot))?.disappear();
+                continue; // eslint-disable-line no-continue
+            }
             const borderInstance = this.getBorderInstance(selection);
             if (selection.isEmpty()) {
                 borderInstance?.disappear();
@@ -199,6 +273,7 @@ var /**
             }
             if (className) {
                 const elements = _class_private_field_get(this, _scanner).setActiveSelection(selection).scan();
+                const isActiveHeader = selectionType === ACTIVE_HEADER_TYPE;
                 elements.forEach((element)=>{
                     if (classNamesMap.has(element)) {
                         const classNamesLayers = classNamesMap.get(element);
@@ -224,9 +299,19 @@ var /**
                             headerAttributesMap.get(element).push(...attrs);
                         }
                     }
+                    // Tag the active-header neighbour classes in this same pass, so the scanned element set is
+                    // walked once. Order into `classNamesMap` does not matter — it is applied after the loop.
+                    if (isActiveHeader) {
+                        _class_private_method_get(this, _markActiveHeaderNeighbor, markActiveHeaderNeighbor).call(this, element, className, classNamesMap);
+                    }
                 });
             }
             const corners = selection.getCorners();
+            if (selectionType === ACTIVE_HEADER_TYPE && className) {
+                _class_private_method_get(this, _markFrozenColumnSeamHeader, markFrozenColumnSeamHeader).call(this, corners, className, classNamesMap);
+                _class_private_method_get(this, _markFrozenTopRowSeamHeader, markFrozenTopRowSeamHeader).call(this, corners, className, classNamesMap);
+                _class_private_method_get(this, _markFrozenBottomRowSeamHeader, markFrozenBottomRowSeamHeader).call(this, corners, className, classNamesMap);
+            }
             _class_private_field_get(this, _activeOverlaysWot).getSetting('onBeforeDrawBorders', corners, selectionType);
             borderInstance?.appear(corners);
         }
@@ -261,6 +346,13 @@ var /**
    *
    * @param {SelectionsContainer | null} selections The Highlight instance that holds Selection instances.
    */ constructor(selections){
+        _class_private_method_init(this, _isCustomSelectionOffscreen);
+        _class_private_method_init(this, _markActiveHeaderNeighbor);
+        _class_private_method_init(this, _markPreviousRowHeaders);
+        _class_private_method_init(this, _tagSeamClass);
+        _class_private_method_init(this, _markFrozenColumnSeamHeader);
+        _class_private_method_init(this, _markFrozenTopRowSeamHeader);
+        _class_private_method_init(this, _markFrozenBottomRowSeamHeader);
         _class_private_method_init(this, _resetCells);
         _class_private_field_init(this, _activeOverlaysWot, {
             writable: true,
@@ -294,6 +386,144 @@ var /**
         _class_private_field_set(this, _selections, selections);
     }
 }
+function isCustomSelectionOffscreen(selection) {
+    // A hidden/trimmed cell has a `null` cellRange (nothing to draw); treat it as off-screen and
+    // avoid `getCorners()`, which dereferences the range.
+    if (selection.isEmpty()) {
+        return true;
+    }
+    const { wtTable } = _class_private_field_get(this, _activeOverlaysWot);
+    const [fromRow, fromColumn, toRow, toColumn] = selection.getCorners();
+    const firstRow = wtTable.getFirstRenderedRow();
+    const lastRow = wtTable.getLastRenderedRow();
+    const firstColumn = wtTable.getFirstRenderedColumn();
+    const lastColumn = wtTable.getLastRenderedColumn();
+    // Nothing (or only headers) rendered in this overlay - the border cannot be visible here.
+    if (firstRow < 0 && lastRow < 0 || firstColumn < 0 && lastColumn < 0) {
+        return true;
+    }
+    return toRow < firstRow || fromRow > lastRow || toColumn < firstColumn || fromColumn > lastColumn;
+}
+function markActiveHeaderNeighbor(element, activeHeaderClassName, classNamesMap) {
+    if (element.nodeName !== 'TH') {
+        return;
+    }
+    const previousHeader = element.previousElementSibling;
+    if (previousHeader !== null && previousHeader.nodeName === 'TH') {
+        _class_private_method_get(this, _tagSeamClass, tagSeamClass).call(this, classNamesMap, previousHeader, `${activeHeaderClassName}-prev`);
+    }
+    _class_private_method_get(this, _markPreviousRowHeaders, markPreviousRowHeaders).call(this, element, activeHeaderClassName, classNamesMap);
+}
+function markPreviousRowHeaders(element, activeHeaderClassName, classNamesMap) {
+    const row = element.parentElement;
+    if (row === null || row.nodeName !== 'TR' || row.parentElement === null || row.parentElement.nodeName !== 'TBODY') {
+        return;
+    }
+    const previousRow = row.previousElementSibling;
+    if (previousRow === null || previousRow.nodeName !== 'TR') {
+        return;
+    }
+    for(let i = 0; i < previousRow.children.length; i++){
+        const cell = previousRow.children[i];
+        if (cell.nodeName !== 'TH') {
+            break;
+        }
+        _class_private_method_get(this, _tagSeamClass, tagSeamClass).call(this, classNamesMap, cell, `${activeHeaderClassName}-prev-row`);
+    }
+}
+function tagSeamClass(classNamesMap, th, seamClassName) {
+    if (classNamesMap.has(th)) {
+        classNamesMap.get(th).set(seamClassName, 1);
+    } else {
+        classNamesMap.set(th, new Map([
+            [
+                seamClassName,
+                1
+            ]
+        ]));
+    }
+}
+function markFrozenColumnSeamHeader(corners, activeHeaderClassName, classNamesMap) {
+    const wot = _class_private_field_get(this, _activeOverlaysWot);
+    const fixedColumnsStart = wot.getSetting('fixedColumnsStart');
+    if (fixedColumnsStart <= 0) {
+        return;
+    }
+    const { wtTable } = wot;
+    // Only the overlay that renders the frozen columns (and nothing past them) owns the seam line.
+    if (wtTable.getLastRenderedColumn() !== fixedColumnsStart - 1) {
+        return;
+    }
+    // The selection's inline-start column must sit exactly on the freeze line.
+    if (Math.min(corners[1], corners[3]) !== fixedColumnsStart) {
+        return;
+    }
+    const seamClassName = `${activeHeaderClassName}-seam`;
+    const headerLevels = wtTable.getColumnHeadersCount();
+    for(let level = 0; level < headerLevels; level++){
+        const th = wtTable.getColumnHeader(fixedColumnsStart - 1, level);
+        if (isHTMLElement(th)) {
+            _class_private_method_get(this, _tagSeamClass, tagSeamClass).call(this, classNamesMap, th, seamClassName);
+        }
+    }
+}
+function markFrozenTopRowSeamHeader(corners, activeHeaderClassName, classNamesMap) {
+    const wot = _class_private_field_get(this, _activeOverlaysWot);
+    const fixedRowsTop = wot.getSetting('fixedRowsTop');
+    if (fixedRowsTop <= 0) {
+        return;
+    }
+    const { wtTable } = wot;
+    const lastFrozenRow = fixedRowsTop - 1;
+    // Only the overlay that renders the top-frozen rows (ending exactly on the freeze line) owns the
+    // seam line.
+    if (wtTable.getLastRenderedRow() !== lastFrozenRow) {
+        return;
+    }
+    // The selection's top row must sit exactly on the first non-frozen row.
+    if (Math.min(corners[0], corners[2]) !== fixedRowsTop) {
+        return;
+    }
+    const seamClassName = `${activeHeaderClassName}-row-seam-top`;
+    const headerLevels = wtTable.getRowHeadersCount();
+    for(let level = 0; level < headerLevels; level++){
+        const th = wtTable.getRowHeader(lastFrozenRow, level);
+        // Overlays without row headers (e.g. the plain `top` overlay) return a TD here; only tag actual
+        // row-header cells.
+        if (isHTMLElement(th) && th.nodeName === 'TH') {
+            _class_private_method_get(this, _tagSeamClass, tagSeamClass).call(this, classNamesMap, th, seamClassName);
+        }
+    }
+}
+function markFrozenBottomRowSeamHeader(corners, activeHeaderClassName, classNamesMap) {
+    const wot = _class_private_field_get(this, _activeOverlaysWot);
+    const fixedRowsBottom = wot.getSetting('fixedRowsBottom');
+    if (fixedRowsBottom <= 0) {
+        return;
+    }
+    const { wtTable } = wot;
+    const totalRows = wot.getSetting('totalRows');
+    const firstFrozenRow = totalRows - fixedRowsBottom;
+    // Only the overlay that renders the bottom-frozen rows (starting exactly on the freeze line) owns
+    // the seam line.
+    if (wtTable.getFirstRenderedRow() !== firstFrozenRow) {
+        return;
+    }
+    // The selection's bottom row must sit exactly on the last non-frozen row.
+    if (Math.max(corners[0], corners[2]) !== firstFrozenRow - 1) {
+        return;
+    }
+    const seamClassName = `${activeHeaderClassName}-row-seam-bottom`;
+    const headerLevels = wtTable.getRowHeadersCount();
+    for(let level = 0; level < headerLevels; level++){
+        const th = wtTable.getRowHeader(firstFrozenRow, level);
+        // Overlays without row headers (e.g. the plain `bottom` overlay) return a TD here; only tag
+        // actual row-header cells.
+        if (isHTMLElement(th) && th.nodeName === 'TH') {
+            _class_private_method_get(this, _tagSeamClass, tagSeamClass).call(this, classNamesMap, th, seamClassName);
+        }
+    }
+}
 function resetCells() {
     const appliedOverlaysClasses = _class_private_field_get(this, _appliedClasses).get(_class_private_field_get(this, _activeOverlaysWot));
     if (!appliedOverlaysClasses) {

package/3rdparty/walkontable/src/selection/scanner.js

@@ -15,15 +15,12 @@ function _check_private_redeclaration(obj, privateCollection) {
     }
 }
 function _class_apply_descriptor_get(receiver, descriptor) {
-    if (descriptor.get) {
-        return descriptor.get.call(receiver);
-    }
+    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.set) descriptor.set.call(receiver, value);
+    else {
         if (!descriptor.writable) {
             throw new TypeError("attempted to set read only private field");
         }
@@ -31,9 +28,7 @@ function _class_apply_descriptor_set(receiver, descriptor, value) {
     }
 }
 function _class_extract_field_descriptor(receiver, privateMap, action) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to " + action + " private field on non-instance");
-    }
+    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) {
@@ -50,9 +45,7 @@ function _class_private_field_set(receiver, privateMap, 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");
-    }
+    if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
     return fn;
 }
 function _class_private_method_init(obj, privateSet) {

package/3rdparty/walkontable/src/selection/scanner.mjs

@@ -4,15 +4,12 @@
     }
 }
 function _class_apply_descriptor_get(receiver, descriptor) {
-    if (descriptor.get) {
-        return descriptor.get.call(receiver);
-    }
+    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.set) descriptor.set.call(receiver, value);
+    else {
         if (!descriptor.writable) {
             throw new TypeError("attempted to set read only private field");
         }
@@ -20,9 +17,7 @@ function _class_apply_descriptor_set(receiver, descriptor, value) {
     }
 }
 function _class_extract_field_descriptor(receiver, privateMap, action) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to " + action + " private field on non-instance");
-    }
+    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) {
@@ -39,9 +34,7 @@ function _class_private_field_set(receiver, privateMap, 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");
-    }
+    if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
     return fn;
 }
 function _class_private_method_init(obj, privateSet) {

package/3rdparty/walkontable/src/settings/accessor.d.mts

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

package/3rdparty/walkontable/src/settings/accessor.d.ts

@@ -0,0 +1,74 @@
+import type { StylesHandler } from '../types';
+import type { SettingsPort } from '../ports';
+/**
+ * @class Settings
+ */
+export default class Settings implements SettingsPort {
+    /**
+     * Reference to settings.
+     *
+     * @protected
+     * @type {object}
+     */
+    settings: Record<string, unknown>;
+    /**
+     * The defaults values of settings.
+     * Void 0 means it is required, null means it can be empty.
+     *
+     * @public
+     * @type {Readonly<object>}
+     */
+    defaults: Record<string, unknown>;
+    /**
+     * @param {object} settings The user defined settings.
+     */
+    constructor(settings: Record<string, unknown>);
+    /**
+     * Update settings.
+     *
+     * @param {object|string} settings The singular settings to update or if passed as object to merge with.
+     * @param {*} value The value to set if the first argument is passed as string.
+     * @returns {Settings}
+     */
+    update(settings: string | Record<string, unknown>, value?: unknown): this;
+    /**
+     * Get setting by name.
+     *
+     * @param {$Keys<SettingsPure>} key The settings key to retrieve.
+     * @param {*} [param1] Additional parameter passed to the options defined as function.
+     * @param {*} [param2] Additional parameter passed to the options defined as function.
+     * @param {*} [param3] Additional parameter passed to the options defined as function.
+     * @param {*} [param4] Additional parameter passed to the options defined as function.
+     * @returns {*}
+     */
+    getSetting(key: 'stylesHandler'): StylesHandler;
+    getSetting(key: 'preventOverflow'): 'horizontal' | 'vertical' | false;
+    getSetting(key: 'rtlMode'): boolean;
+    getSetting(key: 'isDataViewInstance'): boolean;
+    getSetting(key: 'fixedColumnsStart'): number;
+    getSetting(key: 'fixedRowsTop'): number;
+    getSetting(key: 'fixedRowsBottom'): number;
+    getSetting(key: 'totalRows'): number | undefined;
+    getSetting(key: 'totalColumns'): number | undefined;
+    getSetting(key: 'rowHeaderWidth'): number | undefined;
+    getSetting(key: 'defaultColumnWidth'): number | undefined;
+    getSetting(key: 'viewportRowRenderingThreshold'): number | 'auto';
+    getSetting(key: 'viewportColumnRenderingThreshold'): number | 'auto';
+    getSetting(key: 'viewportRowRenderingOffsetIsAuto'): boolean;
+    getSetting(key: 'viewportColumnRenderingOffsetIsAuto'): boolean;
+    getSetting<T = any>(key: string, param1?: any, param2?: unknown, param3?: unknown, param4?: unknown): T;
+    /**
+     * Get a setting value without any evaluation.
+     *
+     * @param {string} key The settings key to retrieve.
+     * @returns {*}
+     */
+    getSettingPure<T = any>(key: string): T;
+    /**
+     * Checks if setting exists.
+     *
+     * @param {boolean} key The settings key to check.
+     * @returns {boolean}
+     */
+    has(key: string): boolean;
+}

package/3rdparty/walkontable/src/settings/accessor.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return Settings;
+    }
+});
+const _object = require("../../../../helpers/object");
+const _errors = require("../../../../helpers/errors");
+const _defaults = require("./defaults");
+class Settings {
+    /**
+   * Update settings.
+   *
+   * @param {object|string} settings The singular settings to update or if passed as object to merge with.
+   * @param {*} value The value to set if the first argument is passed as string.
+   * @returns {Settings}
+   */ update(settings, value) {
+        if (value === undefined) {
+            (0, _object.objectEach)(settings, (settingValue, key)=>{
+                this.settings[key] = settingValue;
+            });
+        } else {
+            this.settings[settings] = value;
+        }
+        return this;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getSetting(key, param1, param2, param3, param4) {
+        if (typeof this.settings[key] === 'function') {
+            return this.settings[key](param1, param2, param3, param4);
+        } else if (param1 !== undefined && Array.isArray(this.settings[key])) {
+            return this.settings[key][param1];
+        }
+        return this.settings[key];
+    }
+    // eslint-disable-next-line jsdoc/require-jsdoc -- TypeScript overload implementation; documented in the overload signature above
+    getSettingPure(key) {
+        return this.settings[key];
+    }
+    /**
+   * Checks if setting exists.
+   *
+   * @param {boolean} key The settings key to check.
+   * @returns {boolean}
+   */ has(key) {
+        return !!this.settings[key];
+    }
+    /**
+   * @param {object} settings The user defined settings.
+   */ constructor(settings){
+        /**
+   * Reference to settings.
+   *
+   * @protected
+   * @type {object}
+   */ this.settings = {};
+        /**
+   * The defaults values of settings.
+   * Void 0 means it is required, null means it can be empty.
+   *
+   * @public
+   * @type {Readonly<object>}
+   */ this.defaults = Object.freeze((0, _defaults.getDefaults)(this));
+        (0, _object.objectEach)(this.defaults, (value, key)=>{
+            if (settings[key] !== undefined) {
+                this.settings[key] = settings[key];
+            } else if (value === undefined) {
+                (0, _errors.throwWithCause)(`A required setting "${key}" was not provided`);
+            } else {
+                this.settings[key] = value;
+            }
+        });
+    }
+}

package/3rdparty/walkontable/src/settings/accessor.mjs

@@ -0,0 +1,71 @@
+import { objectEach } from '../../../../helpers/object.mjs';
+import { throwWithCause } from '../../../../helpers/errors.mjs';
+import { getDefaults } from './defaults.mjs';
+class Settings {
+    /**
+   * Update settings.
+   *
+   * @param {object|string} settings The singular settings to update or if passed as object to merge with.
+   * @param {*} value The value to set if the first argument is passed as string.
+   * @returns {Settings}
+   */ update(settings, value) {
+        if (value === undefined) {
+            objectEach(settings, (settingValue, key)=>{
+                this.settings[key] = settingValue;
+            });
+        } else {
+            this.settings[settings] = value;
+        }
+        return this;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getSetting(key, param1, param2, param3, param4) {
+        if (typeof this.settings[key] === 'function') {
+            return this.settings[key](param1, param2, param3, param4);
+        } else if (param1 !== undefined && Array.isArray(this.settings[key])) {
+            return this.settings[key][param1];
+        }
+        return this.settings[key];
+    }
+    // eslint-disable-next-line jsdoc/require-jsdoc -- TypeScript overload implementation; documented in the overload signature above
+    getSettingPure(key) {
+        return this.settings[key];
+    }
+    /**
+   * Checks if setting exists.
+   *
+   * @param {boolean} key The settings key to check.
+   * @returns {boolean}
+   */ has(key) {
+        return !!this.settings[key];
+    }
+    /**
+   * @param {object} settings The user defined settings.
+   */ constructor(settings){
+        /**
+   * Reference to settings.
+   *
+   * @protected
+   * @type {object}
+   */ this.settings = {};
+        /**
+   * The defaults values of settings.
+   * Void 0 means it is required, null means it can be empty.
+   *
+   * @public
+   * @type {Readonly<object>}
+   */ this.defaults = Object.freeze(getDefaults(this));
+        objectEach(this.defaults, (value, key)=>{
+            if (settings[key] !== undefined) {
+                this.settings[key] = settings[key];
+            } else if (value === undefined) {
+                throwWithCause(`A required setting "${key}" was not provided`);
+            } else {
+                this.settings[key] = value;
+            }
+        });
+    }
+}
+/**
+ * @class Settings
+ */ export { Settings as default };

package/3rdparty/walkontable/src/settings/defaults.d.mts

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