handsontable 18.0.0 → 18.1.0-rc7

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

@@ -0,0 +1,129 @@
+"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 DefaultColumnSizeSource () {
+        return DefaultColumnSizeSource;
+    },
+    get DefaultRowSizeSource () {
+        return DefaultRowSizeSource;
+    }
+});
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) {
+        return descriptor.get.call(receiver);
+    }
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) {
+        descriptor.set.call(receiver, value);
+    } else {
+        if (!descriptor.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to " + action + " private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+var /**
+   * The Walkontable settings.
+   *
+   * @type {Settings}
+   */ _wtSettings = /*#__PURE__*/ new WeakMap();
+class DefaultRowSizeSource {
+    /**
+   * @param {number} sourceIndex The source index of the row.
+   * @returns {number | undefined}
+   */ getSize(sourceIndex) {
+        return _class_private_field_get(this, _wtSettings).getSetting('rowHeight', sourceIndex);
+    }
+    /**
+   * @param {number} sourceIndex The source index of the row.
+   * @param {string} overlayName The overlay name.
+   * @returns {number | undefined}
+   */ getSizeForOverlay(sourceIndex, overlayName) {
+        return _class_private_field_get(this, _wtSettings).getSetting('rowHeightByOverlayName', sourceIndex, overlayName);
+    }
+    /**
+   * @returns {number}
+   */ getDefaultSize() {
+        return _class_private_field_get(this, _wtSettings).getSetting('stylesHandler').getDefaultRowHeight();
+    }
+    /**
+   * @returns {boolean}
+   */ isUniform() {
+        return _class_private_field_get(this, _wtSettings).getSetting('rowHeightsUniform');
+    }
+    /**
+   * @param {Settings} wtSettings The Walkontable settings.
+   */ constructor(wtSettings){
+        _class_private_field_init(this, _wtSettings, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _wtSettings, wtSettings);
+    }
+}
+var /**
+   * The Walkontable settings.
+   *
+   * @type {Settings}
+   */ _wtSettings1 = /*#__PURE__*/ new WeakMap();
+class DefaultColumnSizeSource {
+    /**
+   * @param {number} sourceIndex The source index of the column.
+   * @returns {number | undefined}
+   */ getSize(sourceIndex) {
+        return _class_private_field_get(this, _wtSettings1).getSetting('columnWidth', sourceIndex);
+    }
+    /**
+   * @returns {number}
+   */ getDefaultSize() {
+        return _class_private_field_get(this, _wtSettings1).getSetting('defaultColumnWidth');
+    }
+    /**
+   * @returns {boolean}
+   */ isUniform() {
+        return _class_private_field_get(this, _wtSettings1).getSetting('columnWidthsUniform');
+    }
+    /**
+   * @param {Settings} wtSettings The Walkontable settings.
+   */ constructor(wtSettings){
+        _class_private_field_init(this, _wtSettings1, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _wtSettings1, wtSettings);
+    }
+}

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

@@ -0,0 +1,119 @@
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) {
+        return descriptor.get.call(receiver);
+    }
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) {
+        descriptor.set.call(receiver, value);
+    } else {
+        if (!descriptor.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to " + action + " private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+var /**
+   * The Walkontable settings.
+   *
+   * @type {Settings}
+   */ _wtSettings = /*#__PURE__*/ new WeakMap();
+/**
+ * The engine's own row-size source. Reads the row-height settings/defaults straight from `Settings`,
+ * exactly as `RowUtils` did before the port existed. In Handsontable those settings are the size
+ * funnel callbacks (`rowHeight`, `rowHeightByOverlayName`), so this one source serves both the
+ * embedded and the pure-Walkontable cases.
+ */ export class DefaultRowSizeSource {
+    /**
+   * @param {number} sourceIndex The source index of the row.
+   * @returns {number | undefined}
+   */ getSize(sourceIndex) {
+        return _class_private_field_get(this, _wtSettings).getSetting('rowHeight', sourceIndex);
+    }
+    /**
+   * @param {number} sourceIndex The source index of the row.
+   * @param {string} overlayName The overlay name.
+   * @returns {number | undefined}
+   */ getSizeForOverlay(sourceIndex, overlayName) {
+        return _class_private_field_get(this, _wtSettings).getSetting('rowHeightByOverlayName', sourceIndex, overlayName);
+    }
+    /**
+   * @returns {number}
+   */ getDefaultSize() {
+        return _class_private_field_get(this, _wtSettings).getSetting('stylesHandler').getDefaultRowHeight();
+    }
+    /**
+   * @returns {boolean}
+   */ isUniform() {
+        return _class_private_field_get(this, _wtSettings).getSetting('rowHeightsUniform');
+    }
+    /**
+   * @param {Settings} wtSettings The Walkontable settings.
+   */ constructor(wtSettings){
+        _class_private_field_init(this, _wtSettings, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _wtSettings, wtSettings);
+    }
+}
+var /**
+   * The Walkontable settings.
+   *
+   * @type {Settings}
+   */ _wtSettings1 = /*#__PURE__*/ new WeakMap();
+/**
+ * The engine's own column-size source. Reads the column-width settings/defaults straight from
+ * `Settings`, exactly as `ColumnUtils` did before the port existed.
+ */ export class DefaultColumnSizeSource {
+    /**
+   * @param {number} sourceIndex The source index of the column.
+   * @returns {number | undefined}
+   */ getSize(sourceIndex) {
+        return _class_private_field_get(this, _wtSettings1).getSetting('columnWidth', sourceIndex);
+    }
+    /**
+   * @returns {number}
+   */ getDefaultSize() {
+        return _class_private_field_get(this, _wtSettings1).getSetting('defaultColumnWidth');
+    }
+    /**
+   * @returns {boolean}
+   */ isUniform() {
+        return _class_private_field_get(this, _wtSettings1).getSetting('columnWidthsUniform');
+    }
+    /**
+   * @param {Settings} wtSettings The Walkontable settings.
+   */ constructor(wtSettings){
+        _class_private_field_init(this, _wtSettings1, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _wtSettings1, wtSettings);
+    }
+}

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

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

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

@@ -0,0 +1,162 @@
+import type { default as Table } from '../table/baseTable';
+/**
+ * The two knobs `markOversizedRows` exposes purely for the frozen-column row sync. Grouped so the
+ * shared measurement function keeps a two-argument signature for its ordinary callers.
+ */
+interface FrozenPassOptions {
+    /**
+     * Leave a wiped record this table could not re-detect alone, rather than reading it as a row that
+     * shrank back. Only the caller that measures every frozen table can tell the two apart.
+     */
+    deferShrinkDetection?: boolean;
+    /**
+     * Receives the source index of every row this call records.
+     */
+    recordedRows?: Set<number>;
+}
+/**
+ * Applies the provided column-header heights to the rendered THEAD rows. The provided height comes
+ * from the `columnHeaderHeight` setting funnel (the option, the `modifyColumnHeaderHeight` hook that
+ * AutoRowSize feeds, and the Handsontable-side render-size probe for content-driven headers). It is
+ * written as `min-height`, never `height`, so a header whose real content is taller (a wrapped or
+ * frozen-region header) is not clipped - it still expands to its content, which the frozen-overlay
+ * sync then reads. Runs on the master and every clone so all overlays get the same floor.
+ *
+ * @param {Table} table The table (master or clone) whose THEAD rows receive the heights.
+ */
+export declare function adjustColumnHeaderHeights(table: Table): void;
+/**
+ * Frozen column headers (e.g., with `white-space: normal`) are rendered only in the frozen
+ * overlays, never in the master table's THEAD. When such a header is taller than the headers
+ * of the scrollable columns, the master and top overlay THEADs render shorter than the corner
+ * and inline-start overlays, so the frozen overlay body rows sit shifted against the master.
+ * The gap can be sub-pixel: under browser zoom the frozen header content is a fraction of a
+ * pixel taller than the applied height, and that fraction accumulates into a visible 1px shift.
+ *
+ * This function runs after the frozen overlays have rendered. It reads the corner overlay's
+ * content-driven THEAD row heights with sub-pixel precision and forces the matching master and
+ * top overlay header cells to the same height so every overlay THEAD ends up the same height
+ * and the body rows stay pixel-aligned.
+ *
+ * It deliberately does NOT write to `wtViewport.oversizedColumnHeaders`. That cache is applied
+ * back to the corner overlay on the next render; growing it here would inflate the corner cell,
+ * which would then be re-measured taller, ratcheting the height up every render. Reading the
+ * corner's natural (content-driven) height and only adjusting the master/top side keeps the
+ * synchronization stable and lets the header shrink again when the content allows.
+ *
+ * @param {Table} table The master table.
+ */
+export declare function syncOversizedColumnHeadersWithFrozenOverlays(table: Table): void;
+/**
+ * Whether this draw needs the frozen-column row-height sync at all: only when frozen columns exist
+ * AND the master's rendered band starts past column 0, so at least one frozen column is rendered by
+ * the inline-start overlays and by nothing else. AutoRowSize (`externalRowCalculator`) owns every
+ * row height when it is on, and `markOversizedRows` is a no-op then.
+ *
+ * Called twice per draw, deliberately at two different moments, and they CAN disagree: the draw
+ * cycle asks before the master renders (so `resetOversizedRows` knows whether the frozen-derived
+ * records are still being maintained), which reads the band of the PREVIOUS draw; the sync asks
+ * after, on this draw's band. Each wants the answer as of its own moment, and the disagreement is
+ * the horizontal-scroll transition into or out of the frozen columns, which settles in one draw:
+ * entering, the sync records the frozen heights the master could not; leaving, the released records
+ * are re-measured by a master that now renders those columns itself.
+ *
+ * @param {Table} table The master table.
+ * @returns {boolean}
+ */
+export declare function shouldSyncOversizedRowsWithFrozenOverlays(table: Table): boolean;
+/**
+ * A row whose tallest content sits in a frozen (inline-start) column is rendered at that height only
+ * by the frozen overlays. The master renders a contiguous column band starting at the column under
+ * the horizontal scroll offset, so as soon as that band starts past column 0 the master never renders
+ * the frozen columns — and `markOversizedRows` measures the master. Left alone, the row would be
+ * recorded at its provided height while the frozen overlays render it at its content height, and
+ * every row below it would drift by the difference.
+ *
+ * This runs after the frozen overlays have rendered, and is the row-height twin of
+ * `syncOversizedColumnHeadersWithFrozenOverlays`. It measures all three tables that render frozen
+ * columns — the inline-start clone, which mirrors the master's row band, and the two corners, which
+ * hold the frozen top and bottom rows the inline-start clone does not — then re-applies the resulting
+ * heights to the tables that render those rows WITHOUT the frozen columns.
+ *
+ * Re-measuring cannot ratchet: `resetFrozenOversizedRows` cleared these rows' records moments ago,
+ * after the master rendered but before the frozen overlays did, so they rendered at their natural
+ * content height. A frozen cell that shrank back is measured smaller and recorded smaller.
+ *
+ * @param {Table} table The master table.
+ * @param {Map<number, number>} [wipedFrozenRows] The heights `resetFrozenOversizedRows` cleared, so
+ *   an unchanged row is not mistaken for a new one (which would invalidate the row-height cache on
+ *   every draw — a full prefix-sum walk when the row-size source is non-uniform).
+ * @returns {boolean} `true` when this draw's row heights are no longer the ones the viewport
+ *   calculators were built from, so the caller must rebuild them. An ordinary oversized row gets
+ *   this for free — the master invalidates inside `renderCellBand`, which is BEFORE the calculators
+ *   are computed — but a frozen-derived height is only knowable after the frozen overlays have
+ *   rendered, which is after. Without the rebuild the frame reports a visible row range measured
+ *   against the old heights.
+ */
+export declare function syncOversizedRowsWithFrozenOverlays(table: Table, wipedFrozenRows?: Map<number, number>): boolean;
+/**
+ * Resets cache of row heights. The cache should be cached for each render cycle in a case
+ * when new cell values have content which increases/decreases cell height.
+ *
+ * Returns the wiped `oversizedRows` records of the rendered band, so `markOversizedRows` can
+ * tell a re-detected UNCHANGED height (no row-height cache invalidation needed) from a genuine
+ * change. Keys are deleted, not set to `undefined`, so the row-height cache's uniform fast path
+ * can re-engage once no oversized records remain.
+ *
+ * @param {Table} table The table (master or bottom clone) whose rendered band is reset.
+ * @returns {Map<number, number>|undefined} The previous oversized heights of the rendered band,
+ *   keyed by source row index, or `undefined` when this table does not measure oversized rows.
+ */
+export declare function resetOversizedRows(table: Table): Map<number, number> | undefined;
+/**
+ * Clears the frozen-derived oversized-row records that this draw is about to re-measure, and returns
+ * their previous heights so the frozen sync can tell an unchanged row from a changed one.
+ *
+ * Timing is the whole point. This runs in the seam between the master's render and the frozen
+ * overlays' — after the master rendered (so it used the correct, still-recorded heights, and no row
+ * drifts on this frame), after the row-height cache and the viewport calculators were built from
+ * them, and before the inline-start overlays render, so those render at their natural content height
+ * and stay re-measurable rather than being forced to the cached height and ratcheting.
+ *
+ * Only the rows this draw will re-measure are cleared: the master's rendered band (which the
+ * inline-start clone mirrors) plus the frozen top and bottom rows (which the corner overlays hold).
+ * A frozen-derived record for any other row is left alone — nothing would put it back, and the
+ * summed row heights behind the scrollbar need it.
+ *
+ * @param {Table} table The master table.
+ * @returns {Map<number, number>|undefined} The cleared heights by source row, or `undefined` when
+ *   there was nothing recorded.
+ */
+export declare function resetFrozenOversizedRows(table: Table): Map<number, number> | undefined;
+/**
+ * Check if any of the rendered rows is higher than expected, and if so, cache them.
+ *
+ * The row-height position cache is invalidated only when the measured heights genuinely differ
+ * from the records `resetOversizedRows` wiped before this render: a new oversized row, a changed
+ * height, or a previously oversized row that shrank back. A steady-state redraw of the same tall
+ * rows re-records the same values and keeps the cache intact, avoiding an O(totalRows) prefix-sum
+ * rebuild on every full draw.
+ *
+ * @param {Table} table The table (master or bottom clone) whose rendered rows are measured.
+ * @param {Map<number, number>} [wipedOversizedRows] The oversized heights recorded before this
+ *   render, as returned by `resetOversizedRows`.
+ * @param {object} [frozenPass] Options used only by the frozen-column row sync.
+ * @param {boolean} [frozenPass.deferShrinkDetection=false] When `true`, a wiped record this table could not
+ *   re-detect is NOT treated as a shrunk row. The master passes this when the frozen-column row
+ *   sync runs later in the same draw: those records belong to rows whose tall content lives only in
+ *   the inline-start clone, so only that pass can tell "shrank back" from "the master never renders
+ *   it". Without the deferral a steady-state redraw would invalidate the row-height cache twice per
+ *   draw — and with a non-uniform row-size source each invalidation costs a full prefix-sum walk.
+ *   The caller keeps the map and must settle whatever is left in it.
+ * @param {Set<number>} [frozenPass.recordedRows] Filled with the source index of every row this call recorded.
+ *   The frozen sync marks exactly these as frozen-derived — a row that is oversized for a reason the
+ *   MASTER can see is not recorded here (the measured height does not exceed what is already known),
+ *   and must stay the master's to own. Adopting it would be fatal: the frozen overlays cannot
+ *   re-detect a height they never saw, so it would read as "shrank" on the next draw.
+ * @returns {boolean} `true` when this call invalidated the row-height cache. The frozen-column row
+ *   sync reads it: an invalidation there lands AFTER `wtOverlays.refresh()` sized the overlay
+ *   elements for the draw, so it has to re-size them.
+ */
+export declare function markOversizedRows(table: Table, wipedOversizedRows?: Map<number, number>, { deferShrinkDetection, recordedRows }?: FrozenPassOptions): boolean;
+export {};