handsontable 17.1.0 → 18.0.0-rc2

package/plugins/nestedHeaders/stateManager/index.mjs

@@ -38,28 +38,65 @@ function _class_private_field_set(receiver, privateMap, value) {
     _class_apply_descriptor_set(receiver, descriptor, value);
     return value;
 }
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
 import { arrayMap, arrayReduce } from '../../../helpers/array.mjs';
 import SourceSettings from './sourceSettings.mjs';
 import HeadersTree from './headersTree.mjs';
 import { triggerNodeModification } from './nodeModifiers/index.mjs';
+import { isDeclarativeGroup } from './nodeModifiers/utils/tree.mjs';
 import { generateMatrix } from './matrixGenerator.mjs';
+import { syncVisibilityOnTree } from './syncVisibility.mjs';
 import { TRAVERSAL_DF_PRE } from '../../../utils/dataStructures/tree.mjs';
-var /**
-   * The instance of the source settings class.
-   *
-   * @private
-   * @type {SourceSettings}
-   */ _sourceSettings = /*#__PURE__*/ new WeakMap(), /**
-   * The instance of the headers tree. The tree is generated after setting new configuration data.
-   *
-   * @private
-   * @type {HeadersTree}
-   */ _headersTree = /*#__PURE__*/ new WeakMap(), /**
+var _sourceSettings = /*#__PURE__*/ new WeakMap(), _headersTree = /*#__PURE__*/ new WeakMap(), /**
    * Cached matrix which is generated from the tree structure.
    *
    * @private
    * @type {Array[]}
-   */ _stateMatrix = /*#__PURE__*/ new WeakMap();
+   */ _stateMatrix = /*#__PURE__*/ new WeakMap(), /**
+   * The last column-visibility adapter passed to syncVisibility(). Stored so that
+   * mapState()/mergeStateWith() can re-apply it after rebuilding the tree.
+   */ _lastColumnVisibility = /*#__PURE__*/ new WeakMap(), /**
+   * Rebuilds the header tree after a structural mutation while preserving the collapsed state.
+   *
+   * Visibility is derived BEFORE re-collapsing, so collapseNode picks the correct first *visible*
+   * representative (and clones the right children) even when columns are hidden by an external
+   * source; then it is derived again to reflect the re-applied collapse. Re-running the collapse -
+   * rather than only restoring the `isCollapsed` flag - rebuilds the `clonedTree` needed to expand
+   * the group again.
+   *
+   * @param {Function} mutate Applies the structural change to the source settings.
+   * @param {Function} shiftColumnIndex Maps a pre-rebuild collapsed column index to its new position.
+   */ _rebuildPreservingCollapse = /*#__PURE__*/ new WeakSet(), /**
+   * Captures the header level and visual column index of every currently collapsed node, so the
+   * collapsed state can be re-applied after a tree rebuild (e.g. after inserting/removing columns).
+   *
+   * @returns {Array<{headerLevel: number, columnIndex: number}>}
+   */ _snapshotCollapsedNodes = /*#__PURE__*/ new WeakSet(), /**
+   * Re-collapses the nodes captured by #snapshotCollapsedNodes() on the freshly rebuilt tree. The
+   * `shiftColumnIndex` callback maps a pre-rebuild visual column index to its post-rebuild position.
+   * Re-running the collapse reconstructs both the `isCollapsed` flag (header indicator) and the
+   * `clonedTree` needed to expand the group later.
+   *
+   * @param {Array<{headerLevel: number, columnIndex: number}>} collapsedNodes The captured nodes.
+   * @param {Function} shiftColumnIndex Maps an old visual column index to the new one.
+   */ _reapplyCollapsedNodes = /*#__PURE__*/ new WeakSet(), /**
+   * Re-applies the last column visibility adapter after a tree rebuild, so that mapState() and
+   * mergeStateWith() calls from CollapsibleColumns do not discard visibility state set earlier.
+   * The collapsed state is restored separately by #rebuildPreservingCollapse re-running the collapse.
+   */ _applySyncVisibility = /*#__PURE__*/ new WeakSet(), /**
+   * Re-derives tree-node visibility (colspan, isHidden, crossHiddenColumns) from the last column
+   * visibility adapter WITHOUT regenerating the state matrix. Used as the first pass of
+   * #rebuildPreservingCollapse, where the matrix would be immediately discarded by re-collapsing.
+   */ _deriveVisibility = /*#__PURE__*/ new WeakSet();
 class StateManager {
     /**
    * Sets a new state for the nested headers plugin based on settings passed
@@ -77,12 +114,11 @@ class StateManager {
             _class_private_field_get(this, _sourceSettings).clear();
             hasError = true;
         }
-        _class_private_field_set(this, _stateMatrix, generateMatrix(_class_private_field_get(this, _headersTree).getRoots()));
+        _class_private_method_get(this, _applySyncVisibility, applySyncVisibility).call(this);
         return hasError;
     }
     /**
-   * Sets columns limit to the state will be trimmed. All headers (colspans) which
-   * overlap the column limit will be reduced to keep the structure solid.
+   * Sets columns limit to the state will be trimmed.
    *
    * @param {number} columnsCount The number of columns to limit to.
    */ setColumnsLimit(columnsCount) {
@@ -91,45 +127,56 @@ class StateManager {
     /**
    * Merges settings with current plugin state.
    *
-   * By default only foreign keys are merged with source state and passed to the tree. But only
-   * known keys are exported to matrix.
-   *
    * @param {object[]} settings An array of objects to merge with the current source settings.
-   *                            It is a requirement that every object has `row` and `col` properties
-   *                            which points to the specific header settings object.
    */ mergeStateWith(settings) {
         const transformedSettings = arrayMap(settings, ({ row, ...rest })=>{
+            // Negative rows are header-coordinate; map them to a header level. An out-of-range row keeps
+            // its (negative) value, which getHeaderSettings() resolves to no match - same as before.
             return {
-                row: row < 0 ? this.rowCoordsToLevel(row) : row,
+                row: row < 0 ? this.rowCoordsToLevel(row) ?? row : row,
                 ...rest
             };
         });
-        _class_private_field_get(this, _sourceSettings).mergeWith(transformedSettings);
-        _class_private_field_get(this, _headersTree).buildTree();
-        _class_private_field_set(this, _stateMatrix, generateMatrix(_class_private_field_get(this, _headersTree).getRoots()));
+        _class_private_method_get(this, _rebuildPreservingCollapse, rebuildPreservingCollapse).call(this, ()=>_class_private_field_get(this, _sourceSettings).mergeWith(transformedSettings), (columnIndex)=>columnIndex);
     }
     /**
-   * Maps the current state with a callback. For each header settings the callback function
-   * is called. If the function returns value that value is merged with the state.
-   *
-   * By default only foreign keys are merged with source state and passed to the tree. But only
-   * known keys are exported to matrix.
+   * Maps the current state with a callback.
    *
    * @param {Function} callback A function that is called for every header source settings.
-   *                            Each time the callback is called, the returned value extends
-   *                            header settings.
    */ mapState(callback) {
-        _class_private_field_get(this, _sourceSettings).map(callback);
-        _class_private_field_get(this, _headersTree).buildTree();
-        _class_private_field_set(this, _stateMatrix, generateMatrix(_class_private_field_get(this, _headersTree).getRoots()));
+        _class_private_method_get(this, _rebuildPreservingCollapse, rebuildPreservingCollapse).call(this, ()=>_class_private_field_get(this, _sourceSettings).map(callback), (columnIndex)=>columnIndex);
+    }
+    /**
+   * Inserts `amount` columns into the source settings at the visual `columnIndex`, then rebuilds
+   * the tree and re-derives visibility. Headers spanning the insertion point are extended; columns
+   * inserted at a header boundary become standalone headers.
+   *
+   * @param {number} columnIndex A visual column index at which the new columns are inserted.
+   * @param {number} amount The number of columns to insert.
+   */ insertColumns(columnIndex, amount) {
+        _class_private_method_get(this, _rebuildPreservingCollapse, rebuildPreservingCollapse).call(this, ()=>_class_private_field_get(this, _sourceSettings).insertColumns(columnIndex, amount), (c)=>c >= columnIndex ? c + amount : c);
     }
     /**
-   * Maps the current tree nodes with a callback. For each node the callback function
-   * is called. If the function returns value that value is added to returned array.
+   * Removes `amount` columns from the source settings starting at the visual `columnIndex`, then
+   * rebuilds the tree and re-derives visibility. Headers overlapping the removed range are shrunk,
+   * re-anchored, or dropped when they lose all their columns.
+   *
+   * @param {number} columnIndex A visual column index from which the columns are removed.
+   * @param {number} amount The number of columns to remove.
+   */ removeColumns(columnIndex, amount) {
+        const endIndex = columnIndex + amount;
+        _class_private_method_get(this, _rebuildPreservingCollapse, rebuildPreservingCollapse).call(this, ()=>_class_private_field_get(this, _sourceSettings).removeColumns(columnIndex, amount), (c)=>{
+            if (c < columnIndex) {
+                return c;
+            }
+            // The anchor column was removed but the group may survive - re-anchor to the range start.
+            return c >= endIndex ? c - amount : columnIndex;
+        });
+    }
+    /**
+   * Maps the current tree nodes with a callback.
    *
    * @param {Function} callback A function that is called for every tree node.
-   *                            Each time the callback is called, the returned value is
-   *                            added to returned array.
    * @returns {Array}
    */ mapNodes(callback) {
         return arrayReduce(_class_private_field_get(this, _headersTree).getRoots(), (acc, rootNode)=>{
@@ -143,31 +190,26 @@ class StateManager {
         }, []);
     }
     /**
-   * Triggers an action (e.g. "collapse") from the NodeModifiers module. The module
-   * modifies a tree structure in such a way as to obtain the correct structure consistent with the
-   * called action.
+   * Triggers an action from the NodeModifiers module.
    *
    * @param {string} action An action name to trigger.
-   * @param {number} headerLevel Header level index (there is support for negative and positive values).
+   * @param {number} headerLevel Header level index.
    * @param {number} columnIndex A visual column index.
    * @returns {object|undefined}
    */ triggerNodeModification(action, headerLevel, columnIndex) {
         if (headerLevel < 0) {
-            headerLevel = this.rowCoordsToLevel(headerLevel);
+            headerLevel = this.rowCoordsToLevel(headerLevel) ?? 0;
         }
         const nodeToProcess = _class_private_field_get(this, _headersTree).getNode(headerLevel, columnIndex);
         let actionResult;
         if (nodeToProcess) {
             actionResult = triggerNodeModification(action, nodeToProcess, columnIndex);
-            // TODO (perf-tip): Trigger matrix generation once after multiple node modifications.
             _class_private_field_set(this, _stateMatrix, generateMatrix(_class_private_field_get(this, _headersTree).getRoots()));
         }
-        return actionResult;
+        return actionResult ?? undefined;
     }
     /**
-   * Triggers an action (e.g. "hide-column") from the NodeModifiers module. The action is
-   * triggered starting from the lowest header. The module modifies a tree structure in
-   * such a way as to obtain the correct structure consistent with the called action.
+   * Triggers an action from the NodeModifiers module starting from the lowest header.
    *
    * @param {string} action An action name to trigger.
    * @param {number} columnIndex A visual column index.
@@ -175,30 +217,26 @@ class StateManager {
    */ triggerColumnModification(action, columnIndex) {
         return this.triggerNodeModification(action, -1, columnIndex);
     }
-    /* eslint-disable jsdoc/require-description-complete-sentence */ /**
+    /**
+   * Derives tree-node visibility state (colspan, crossHiddenColumns, isHidden) from an external
+   * ColumnVisibility port, then regenerates the state matrix. Call this whenever the hiding map
+   * changes (HiddenColumns, CollapsibleColumns) or after column sequence changes.
+   *
+   * @param {ColumnVisibility} columnVisibility The visibility port.
+   */ syncVisibility(columnVisibility) {
+        _class_private_field_set(this, _lastColumnVisibility, columnVisibility);
+        syncVisibilityOnTree(_class_private_field_get(this, _headersTree).getRoots(), columnVisibility);
+        _class_private_field_set(this, _stateMatrix, generateMatrix(_class_private_field_get(this, _headersTree).getRoots()));
+    }
+    /**
    * @memberof StateManager#
    * @function rowCoordsToLevel
    *
-   * Translates row coordinates into header level. The row coordinates counts from -1 to -N
-   * and describes headers counting from most closest to most distant from the table.
-   * The header levels are counted from 0 to N where 0 describes most distant header
-   * from the table.
-   *
-   *  Row coords             Header level
-   *           +--------------+
-   *       -3  │ A1 │ A1      │  0
-   *           +--------------+
-   *       -2  │ B1 │ B2 │ B3 │  1
-   *           +--------------+
-   *       -1  │ C1 │ C2 │ C3 │  2
-   *           +==============+
-   *           │    │    │    │
-   *           +--------------+
-   *           │    │    │    │
+   * Translates row coordinates into header level.
    *
    * @param {number} rowIndex A visual row index.
    * @returns {number|null} Returns unsigned number.
-   */ /* eslint-enable jsdoc/require-description-complete-sentence */ rowCoordsToLevel(rowIndex) {
+   */ rowCoordsToLevel(rowIndex) {
         if (rowIndex >= 0) {
             return null;
         }
@@ -208,30 +246,15 @@ class StateManager {
         }
         return headerLevel;
     }
-    /* eslint-disable jsdoc/require-description-complete-sentence */ /**
+    /**
    * @memberof StateManager#
    * @function levelToRowCoords
    *
-   * Translates header level into row coordinates. The row coordinates counts from -1 to -N
-   * and describes headers counting from most closest to most distant from the table.
-   * The header levels are counted from 0 to N where 0 describes most distant header
-   * from the table.
-   *
-   *  Header level            Row coords
-   *           +--------------+
-   *        0  │ A1 │ A1      │  -3
-   *           +--------------+
-   *        1  │ B1 │ B2 │ B3 │  -2
-   *           +--------------+
-   *        2  │ C1 │ C2 │ C3 │  -1
-   *           +==============+
-   *           │    │    │    │
-   *           +--------------+
-   *           │    │    │    │
+   * Translates header level into row coordinates.
    *
    * @param {number} headerLevel Header level index.
    * @returns {number} Returns negative number.
-   */ /* eslint-enable jsdoc/require-description-complete-sentence */ levelToRowCoords(headerLevel) {
+   */ levelToRowCoords(headerLevel) {
         if (headerLevel < 0) {
             return null;
         }
@@ -242,16 +265,14 @@ class StateManager {
         return rowIndex;
     }
     /**
-   * Gets column header settings for a specified column and header index. The returned object contains
-   * all information necessary for header renderers. It contains header label, colspan length, or hidden
-   * flag.
+   * Gets column header settings for a specified column and header index.
    *
-   * @param {number} headerLevel Header level (there is support for negative and positive values).
+   * @param {number} headerLevel Header level.
    * @param {number} columnIndex A visual column index.
    * @returns {object|null}
    */ getHeaderSettings(headerLevel, columnIndex) {
         if (headerLevel < 0) {
-            headerLevel = this.rowCoordsToLevel(headerLevel);
+            headerLevel = this.rowCoordsToLevel(headerLevel) ?? 0;
         }
         if (headerLevel === null || headerLevel >= this.getLayersCount()) {
             return null;
@@ -259,11 +280,9 @@ class StateManager {
         return _class_private_field_get(this, _stateMatrix)[headerLevel]?.[columnIndex] ?? null;
     }
     /**
-   * Gets tree data that is connected to the column header. The returned object contains all information
-   * necessary for modifying tree structure (column collapsing, hiding, etc.). It contains a header
-   * label, colspan length, or visual column index that indicates which column index the node is rendered from.
+   * Gets tree data that is connected to the column header.
    *
-   * @param {number} headerLevel Header level (there is support for negative and positive values).
+   * @param {number} headerLevel Header level.
    * @param {number} columnIndex A visual column index.
    * @returns {object|null}
    */ getHeaderTreeNodeData(headerLevel, columnIndex) {
@@ -278,26 +297,25 @@ class StateManager {
     /**
    * Gets tree node that is connected to the column header.
    *
-   * @param {number} headerLevel Header level (there is support for negative and positive values).
+   * @param {number} headerLevel Header level.
    * @param {number} columnIndex A visual column index.
    * @returns {TreeNode|null}
    */ getHeaderTreeNode(headerLevel, columnIndex) {
+        let resolvedLevel = headerLevel;
         if (headerLevel < 0) {
-            headerLevel = this.rowCoordsToLevel(headerLevel);
+            resolvedLevel = this.rowCoordsToLevel(headerLevel);
         }
-        if (headerLevel === null || headerLevel >= this.getLayersCount()) {
+        if (resolvedLevel === null || resolvedLevel >= this.getLayersCount()) {
             return null;
         }
-        const node = _class_private_field_get(this, _headersTree).getNode(headerLevel, columnIndex);
+        const node = _class_private_field_get(this, _headersTree).getNode(resolvedLevel, columnIndex);
         if (!node) {
             return null;
         }
         return node;
     }
     /**
-   * Finds the most top header level of the column header that is rendered entirely within
-   * the passed visual columns range. If multiple columns headers are found within the range the
-   * most top header level value will be returned.
+   * Finds the most top header level of the column header.
    *
    * @param {number} columnIndexFrom A visual column index.
    * @param {number} [columnIndexTo] A visual column index.
@@ -312,13 +330,12 @@ class StateManager {
                 break;
             }
             atLeastOneRootFound = true;
-            // eslint-disable-next-line
+            // eslint-disable-next-line no-loop-func
             rootNode.walkDown((node)=>{
                 const { columnIndex: nodeColumnIndex, headerLevel: nodeHeaderLevel, origColspan, isHidden } = node.data;
                 if (isHidden) {
                     return;
                 }
-                // if the header fits entirely within the columns range get and save the node header level
                 if (origColspan <= columnsWidth && nodeColumnIndex >= columnIndexFrom && nodeColumnIndex + origColspan - 1 <= columnIndexTo && (headerLevel === null || nodeHeaderLevel < headerLevel)) {
                     headerLevel = nodeHeaderLevel;
                 }
@@ -330,11 +347,9 @@ class StateManager {
         return this.levelToRowCoords(headerLevel ?? 0);
     }
     /**
-   * The method is helpful in cases where the column index targets in-between currently
-   * collapsed column. In that case, the method returns the left-most column index
-   * where the nested header begins.
+   * Finds the left-most column index where the nested header begins.
    *
-   * @param {number} headerLevel Header level (there is support for negative and positive values).
+   * @param {number} headerLevel Header level.
    * @param {number} columnIndex A visual column index.
    * @returns {number}
    */ findLeftMostColumnIndex(headerLevel, columnIndex) {
@@ -357,11 +372,9 @@ class StateManager {
         return stepBackColumn;
     }
     /**
-   * The method is helpful in cases where the column index targets in-between currently
-   * collapsed column. In that case, the method returns the right-most column index
-   * where the nested header ends.
+   * Finds the right-most column index where the nested header ends.
    *
-   * @param {number} headerLevel Header level (there is support for negative and positive values).
+   * @param {number} headerLevel Header level.
    * @param {number} columnIndex A visual column index.
    * @returns {number}
    */ findRightMostColumnIndex(headerLevel, columnIndex) {
@@ -399,18 +412,87 @@ class StateManager {
         return _class_private_field_get(this, _sourceSettings).getColumnsCount();
     }
     /**
+   * Computes the visual column indexes that should be hidden purely by the `visibleWhen` rules of
+   * declarative collapsible groups (issue #10243), given each group's current `isCollapsed` state.
+   *
+   * A group is "declarative" when at least one of its direct children declares an explicit
+   * `visibleWhen` ('collapsed', 'expanded', or 'always'); legacy groups (no markers) are left to the
+   * regular first-visible-child collapse path and are skipped here. Within a declarative group a child
+   * with no marker defaults to `'expanded'` - it is hidden when the group collapses, matching the
+   * default collapse behavior; `'always'` is the explicit opt-in for staying visible in both states.
+   * Only `collapsible` groups are considered. At least one column per group always stays visible so the
+   * group's collapse indicator survives. The result is a pure function of the tree shape, the markers,
+   * and the `isCollapsed` flags, so it stays correct across tree rebuilds.
+   *
+   * @returns {number[]} Visual column indexes to hide.
+   */ getVisibleWhenHiddenColumns() {
+        const columnsToHide = [];
+        _class_private_field_get(this, _headersTree).getRoots().forEach((rootNode)=>{
+            rootNode.walkDown((node)=>{
+                const childNodes = node.childs;
+                if (node.data.collapsible !== true || childNodes.length === 0) {
+                    return;
+                }
+                // Only declarative groups (at least one explicit `visibleWhen` marker) are handled here;
+                // legacy groups keep the first-visible-child collapse path. The predicate lives in one place
+                // so this computation and the collapse/expand modifiers agree on what "declarative" means.
+                if (!isDeclarativeGroup(node)) {
+                    return;
+                }
+                const isGroupCollapsed = node.data.isCollapsed === true;
+                const childrenToHide = childNodes.filter((childNode)=>{
+                    // An unset child defaults to 'expanded' (hidden on collapse).
+                    const visibility = childNode.data.visibleWhen ?? 'expanded';
+                    return visibility === 'expanded' && isGroupCollapsed || visibility === 'collapsed' && !isGroupCollapsed;
+                });
+                // Never hide every column of the group through `visibleWhen` - the collapse indicator renders
+                // on the group's first visible column, so keep the first child visible when a (mis)configuration
+                // would otherwise blank the whole group and leave no way to expand it back. Known limitation:
+                // if that kept column is independently hidden by another source (HiddenColumns or trimming) the
+                // indicator can still be lost. Reading the external hidden state here is avoided on purpose -
+                // this set feeds the hiding map that syncVisibility consumes, so a node's `isHidden` flag
+                // already carries this set's own previous effect and cannot be trusted as an external-only signal.
+                if (childrenToHide.length === childNodes.length) {
+                    childrenToHide.shift();
+                }
+                childrenToHide.forEach(({ data: { columnIndex, origColspan } })=>{
+                    for(let i = 0; i < origColspan; i++){
+                        columnsToHide.push(columnIndex + i);
+                    }
+                });
+            });
+        });
+        return columnsToHide;
+    }
+    /**
    * Clears the column state manager to the initial state.
    */ clear() {
         _class_private_field_set(this, _stateMatrix, []);
         _class_private_field_get(this, _sourceSettings).clear();
         _class_private_field_get(this, _headersTree).clear();
+        _class_private_field_set(this, _lastColumnVisibility, null);
     }
     constructor(){
-        _class_private_field_init(this, _sourceSettings, {
+        _class_private_method_init(this, _rebuildPreservingCollapse);
+        _class_private_method_init(this, _snapshotCollapsedNodes);
+        _class_private_method_init(this, _reapplyCollapsedNodes);
+        _class_private_method_init(this, _applySyncVisibility);
+        _class_private_method_init(this, _deriveVisibility);
+        /**
+   * The instance of the source settings class.
+   *
+   * @private
+   * @type {SourceSettings}
+   */ _class_private_field_init(this, _sourceSettings, {
             writable: true,
             value: void 0
         });
-        _class_private_field_init(this, _headersTree, {
+        /**
+   * The instance of the headers tree.
+   *
+   * @private
+   * @type {HeadersTree}
+   */ _class_private_field_init(this, _headersTree, {
             writable: true,
             value: void 0
         });
@@ -418,38 +500,60 @@ class StateManager {
             writable: true,
             value: void 0
         });
+        _class_private_field_init(this, _lastColumnVisibility, {
+            writable: true,
+            value: void 0
+        });
         _class_private_field_set(this, _sourceSettings, new SourceSettings());
         _class_private_field_set(this, _headersTree, new HeadersTree(_class_private_field_get(this, _sourceSettings)));
         _class_private_field_set(this, _stateMatrix, [
             []
         ]);
+        _class_private_field_set(this, _lastColumnVisibility, null);
+    }
+}
+function rebuildPreservingCollapse(mutate, shiftColumnIndex) {
+    const collapsedNodes = _class_private_method_get(this, _snapshotCollapsedNodes, snapshotCollapsedNodes).call(this);
+    mutate();
+    _class_private_field_get(this, _headersTree).buildTree();
+    // Derive visibility before re-collapsing, but skip the matrix here - #reapplyCollapsedNodes
+    // reads the tree (not the matrix) and the trailing #applySyncVisibility regenerates it once,
+    // so building the matrix at this point would only be discarded work.
+    _class_private_method_get(this, _deriveVisibility, deriveVisibility).call(this);
+    _class_private_method_get(this, _reapplyCollapsedNodes, reapplyCollapsedNodes).call(this, collapsedNodes, shiftColumnIndex);
+    _class_private_method_get(this, _applySyncVisibility, applySyncVisibility).call(this);
+}
+function snapshotCollapsedNodes() {
+    const collapsedNodes = [];
+    _class_private_field_get(this, _headersTree).getRoots().forEach((rootNode)=>{
+        rootNode.walkDown((node)=>{
+            const data = node.data;
+            if (data.isCollapsed) {
+                collapsedNodes.push({
+                    headerLevel: data.headerLevel,
+                    columnIndex: data.columnIndex
+                });
+            }
+        });
+    });
+    return collapsedNodes;
+}
+function reapplyCollapsedNodes(collapsedNodes, shiftColumnIndex) {
+    collapsedNodes.forEach(({ headerLevel, columnIndex })=>{
+        this.triggerNodeModification('collapse', headerLevel, shiftColumnIndex(columnIndex));
+    });
+}
+function applySyncVisibility() {
+    _class_private_method_get(this, _deriveVisibility, deriveVisibility).call(this);
+    _class_private_field_set(this, _stateMatrix, generateMatrix(_class_private_field_get(this, _headersTree).getRoots()));
+}
+function deriveVisibility() {
+    if (_class_private_field_get(this, _lastColumnVisibility)) {
+        syncVisibilityOnTree(_class_private_field_get(this, _headersTree).getRoots(), _class_private_field_get(this, _lastColumnVisibility));
     }
 }
 /**
  * The state manager is a source of truth for nested headers configuration.
- * The state generation process is divided into three stages.
- *
- *   +---------------------+  1. User-defined configuration normalization;
- *   │                     │  The source settings class normalizes and shares API for
- *   │   SourceSettings    │  raw settings passed by the developer. It is only consumed by
- *   │                     │  the header tree module.
- *   +---------------------+
- *             │
- *            \│/
- *   +---------------------+  2. Building a tree structure for validation and easier node manipulation;
- *   │                     │  The header tree generates a tree based on source settings for future
- *   │     HeadersTree     │  node manipulation (such as collapsible columns feature). While generating a tree
- *   │                     │  the source settings is checked to see if the configuration has overlapping headers.
- *   +---------------------+  If `true` the colspan matrix generation is skipped, overlapped headers are not supported.
- *             │
- *            \│/
- *   +---------------------+  3. Matrix generation;
- *   │                     │  Based on built trees the matrix generation is performed. That part of code
- *   │  matrix generation  │  generates an array structure similar to normalized data from the SourceSettings
- *   │                     │  but with the difference that this structure contains column settings which changed
- *   +---------------------+  during runtime (after the tree manipulation) e.q after collapse or expand column.
- *                            That settings describes how the TH element should be modified (colspan attribute,
- *                            CSS classes, etc) for a specific column and layer level.
  *
  * @class StateManager
  */ export { StateManager as default };

package/plugins/nestedHeaders/stateManager/matrixGenerator.d.mts

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

package/plugins/nestedHeaders/stateManager/matrixGenerator.d.ts

@@ -0,0 +1,32 @@
+import type TreeNode from '../../../utils/dataStructures/tree';
+/**
+ * A function that dump a tree structure into multidimensional array. That structure is
+ * later processed by header renderers to modify TH elements to achieve a proper
+ * DOM structure.
+ *
+ * That structure contains settings object for every TH element generated by Walkontable.
+ * The matrix operates on visual column index.
+ *
+ * Output example:
+ *   [
+ *     [
+ *       { label: 'A1', colspan: 2, origColspan: 2, isHidden: false, ... },
+ *       { label: '', colspan: 1, origColspan: 1, isHidden: true, ... },
+ *       { label: '', colspan: 1, origColspan: 1, isHidden: false, ... },
+ *     ],
+ *     [
+ *       { label: 'true', colspan: 1, origColspan: 1, isHidden: false, ... },
+ *       { label: 'B2', colspan: 1, origColspan: 1, isHidden: false, ... },
+ *       { label: '4', colspan: 1, origColspan: 1, isHidden: false, ... },
+ *     ],
+ *     [
+ *       { label: '', colspan: 1, origColspan: 1, isHidden: false, ... },
+ *       { label: '', colspan: 1, origColspan: 1, isHidden: false, ... },
+ *       { label: '', colspan: 1, origColspan: 1, isHidden: false, ... },
+ *     ],
+ *   ]
+ *
+ * @param {TreeNode[]} headerRoots An array of root nodes.
+ * @returns {Array[]}
+ */
+export declare function generateMatrix(headerRoots: TreeNode[]): Record<string, unknown>[][];

package/plugins/nestedHeaders/stateManager/matrixGenerator.js

@@ -1,4 +1,4 @@
-/* eslint-disable jsdoc/require-description-complete-sentence */ "use strict";
+"use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
@@ -21,7 +21,7 @@ function generateMatrix(headerRoots) {
             for(let i = columnIndex; i < columnIndex + origColspan; i++){
                 const isColumnHidden = crossHiddenColumns.includes(i);
                 if (isColumnHidden || isRootSettingsFound) {
-                    colspanHeaderLayer.push((0, _utils.createPlaceholderHeaderSettings)(nodeData));
+                    colspanHeaderLayer.push((0, _utils.createPlaceholderHeaderSettings)());
                 } else {
                     const headerRootSettings = createHeaderSettings(nodeData);
                     headerRootSettings.isRoot = true;

package/plugins/nestedHeaders/stateManager/matrixGenerator.mjs

@@ -1,4 +1,4 @@
-/* eslint-disable jsdoc/require-description-complete-sentence */ import { arrayEach } from '../../../helpers/array.mjs';
+import { arrayEach } from '../../../helpers/array.mjs';
 import { createDefaultHeaderSettings, createPlaceholderHeaderSettings } from './utils.mjs';
 /**
  * A function that dump a tree structure into multidimensional array. That structure is
@@ -40,7 +40,7 @@ import { createDefaultHeaderSettings, createPlaceholderHeaderSettings } from './
             for(let i = columnIndex; i < columnIndex + origColspan; i++){
                 const isColumnHidden = crossHiddenColumns.includes(i);
                 if (isColumnHidden || isRootSettingsFound) {
-                    colspanHeaderLayer.push(createPlaceholderHeaderSettings(nodeData));
+                    colspanHeaderLayer.push(createPlaceholderHeaderSettings());
                 } else {
                     const headerRootSettings = createHeaderSettings(nodeData);
                     headerRootSettings.isRoot = true;

package/plugins/nestedHeaders/stateManager/nodeModifiers/collapse.d.mts

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

package/plugins/nestedHeaders/stateManager/nodeModifiers/collapse.d.ts

@@ -0,0 +1,11 @@
+import type TreeNode from '../../../../utils/dataStructures/tree';
+import type { HeaderNodeData } from '../headersTree';
+import type { NodeModificationResult } from './index';
+/**
+ * Collapsing a node is a process where the processing node is collapsed
+ * to the colspan width of the first child.
+ *
+ * @param {TreeNode} nodeToProcess A tree node to process.
+ * @returns {object} Returns an object with properties.
+ */
+export declare function collapseNode(nodeToProcess: TreeNode<HeaderNodeData>): NodeModificationResult;