handsontable 18.0.0 → 18.1.0-rc1

package/3rdparty/walkontable/src/selection/border/types.d.ts

@@ -14,6 +14,8 @@ export interface BorderInstanceSettings {
         width?: number;
         color?: string;
         cornerVisible?: boolean | ((...args: unknown[]) => boolean);
+        adjustHandlesVisible?: boolean | ((...args: unknown[]) => boolean);
+        moveEnabled?: boolean | ((...args: unknown[]) => boolean);
         style?: string;
         [key: string]: unknown;
     };
@@ -48,3 +50,31 @@ export interface SelectionHandles {
     };
     [key: string]: unknown;
 }
+export interface AdjustHandles {
+    top: HTMLDivElement;
+    bottom: HTMLDivElement;
+    start: HTMLDivElement;
+    end: HTMLDivElement;
+    styles: {
+        top: CSSStyleDeclaration;
+        bottom: CSSStyleDeclaration;
+        start: CSSStyleDeclaration;
+        end: CSSStyleDeclaration;
+        [key: string]: CSSStyleDeclaration;
+    };
+    [key: string]: unknown;
+}
+export interface MoveZone {
+    top: HTMLDivElement;
+    bottom: HTMLDivElement;
+    start: HTMLDivElement;
+    end: HTMLDivElement;
+    styles: {
+        top: CSSStyleDeclaration;
+        bottom: CSSStyleDeclaration;
+        start: CSSStyleDeclaration;
+        end: CSSStyleDeclaration;
+        [key: string]: CSSStyleDeclaration;
+    };
+    [key: string]: unknown;
+}

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

@@ -11,21 +11,19 @@ Object.defineProperty(exports, "SelectionManager", {
 const _element = require("../../../../helpers/dom/element");
 const _scanner = require("./scanner");
 const _border = /*#__PURE__*/ _interop_require_default(require("./border/border"));
+const _constants = require("./constants");
 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);
-    }
+    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");
         }
@@ -33,9 +31,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) {
@@ -52,9 +48,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) {
@@ -93,6 +87,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();
@@ -201,6 +265,16 @@ class SelectionManager {
                 _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 === _constants.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();
@@ -208,6 +282,7 @@ class SelectionManager {
             }
             if (className) {
                 const elements = _class_private_field_get(this, _scanner1).setActiveSelection(selection).scan();
+                const isActiveHeader = selectionType === _constants.ACTIVE_HEADER_TYPE;
                 elements.forEach((element)=>{
                     if (classNamesMap.has(element)) {
                         const classNamesLayers = classNamesMap.get(element);
@@ -233,9 +308,19 @@ class SelectionManager {
                             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 === _constants.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);
         }
@@ -270,6 +355,13 @@ class SelectionManager {
    *
    * @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,
@@ -303,6 +395,144 @@ class SelectionManager {
         _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 ((0, _element.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 ((0, _element.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 ((0, _element.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) {