handsontable 17.1.0 → 18.0.0-rc2

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

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

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

@@ -0,0 +1,17 @@
+import type { HotInstance } from '../../../core/types';
+/**
+ * A port that reports the visibility of a visual column index, abstracting the
+ * Handsontable column index mapper away from the visibility-sync logic.
+ */
+export interface ColumnVisibility {
+    /**
+     * Returns true if the visual column index is visible (not hidden by any source).
+     */
+    isVisible(visualColumnIndex: number): boolean;
+}
+/**
+ * Creates a ColumnVisibility port adapter backed by the Handsontable column index mapper.
+ * The adapter converts visual column indices to physical before querying the merged hiding state,
+ * so it correctly handles column moves.
+ */
+export declare function createColumnVisibilityAdapter(hot: HotInstance): ColumnVisibility;

package/plugins/nestedHeaders/stateManager/columnVisibility.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createColumnVisibilityAdapter", {
+    enumerable: true,
+    get: function() {
+        return createColumnVisibilityAdapter;
+    }
+});
+function createColumnVisibilityAdapter(hot) {
+    return {
+        isVisible (visualColumnIndex) {
+            const physicalIndex = hot.columnIndexMapper.getPhysicalFromVisualIndex(visualColumnIndex);
+            if (physicalIndex === null) {
+                return false;
+            }
+            return !hot.columnIndexMapper.isHidden(physicalIndex);
+        }
+    };
+}

package/plugins/nestedHeaders/stateManager/columnVisibility.mjs

@@ -0,0 +1,15 @@
+/**
+ * Creates a ColumnVisibility port adapter backed by the Handsontable column index mapper.
+ * The adapter converts visual column indices to physical before querying the merged hiding state,
+ * so it correctly handles column moves.
+ */ export function createColumnVisibilityAdapter(hot) {
+    return {
+        isVisible (visualColumnIndex) {
+            const physicalIndex = hot.columnIndexMapper.getPhysicalFromVisualIndex(visualColumnIndex);
+            if (physicalIndex === null) {
+                return false;
+            }
+            return !hot.columnIndexMapper.isHidden(physicalIndex);
+        }
+    };
+}

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

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

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

@@ -0,0 +1,94 @@
+import TreeNode from '../../../utils/dataStructures/tree';
+import type { HeaderVisibility } from './utils';
+import type SourceSettings from './sourceSettings';
+/**
+ * Interface representing the base header settings shape.
+ */
+export interface HeaderSettings {
+    label: string;
+    colspan: number;
+    origColspan: number;
+    rowspan?: number;
+    origRowspan?: number;
+    collapsible: boolean;
+    isCollapsed: boolean;
+    crossHiddenColumns: number[];
+    isHidden: boolean;
+    isRoot: boolean;
+    isPlaceholder: boolean;
+    isRowspanPlaceholder?: boolean;
+    headerClassNames: string[];
+    /**
+     * Explicit per-header collapse-visibility marker. Unset means the header follows the default
+     * ('expanded' - hidden when its group collapses) within a group that uses `visibleWhen`.
+     */
+    visibleWhen?: HeaderVisibility;
+    [key: string]: unknown;
+}
+/**
+ * Interface representing header node data in the tree
+ * (extends base settings with tree-specific properties).
+ */
+export interface HeaderNodeData extends HeaderSettings {
+    headerLevel: number;
+    columnIndex: number;
+    /**
+     * A cloned subtree stored during collapse, restored on expand.
+     */
+    clonedTree?: TreeNode<HeaderNodeData> | null;
+}
+/**
+ * Builds and manages a tree structure representing the nested headers configuration, mapping visual column indexes to header nodes.
+ *
+ * @private
+ * @class HeadersTree
+ */
+export default class HeadersTree {
+    #private;
+    /**
+     * Initializes the headers tree with the given source settings used to build the nested header structure.
+     */
+    constructor(sourceSettings: SourceSettings);
+    /**
+     * Gets an array of the all root nodes.
+     *
+     * @returns {TreeNode[]}
+     */
+    getRoots(): TreeNode<HeaderNodeData>[];
+    /**
+     * Gets a root node by specified visual column index.
+     *
+     * @param {number} columnIndex A visual column index.
+     * @returns {TreeNode|undefined}
+     */
+    getRootByColumn(columnIndex: number): TreeNode<HeaderNodeData> | undefined;
+    /**
+     * Gets a tree node by its position in the grid settings.
+     *
+     * @param {number} headerLevel Header level index.
+     * @param {number} columnIndex A visual column index.
+     * @returns {TreeNode|undefined}
+     */
+    getNode(headerLevel: number, columnIndex: number): TreeNode<HeaderNodeData> | undefined;
+    /**
+     * Builds (or rebuilds if called again) root nodes indexes.
+     */
+    rebuildTreeIndex(): void;
+    /**
+     * Builds trees based on SourceSettings class.
+     */
+    buildTree(): void;
+    /**
+     * Builds leaves for specified tree node.
+     *
+     * @param {TreeNode} parentNode A node to which the leaves applies.
+     * @param {number} columnIndex A visual column index.
+     * @param {number} headerLevel Currently processed header level.
+     * @param {number} [extractionLength=1] Determines column extraction length for node children.
+     */
+    buildLeaves(parentNode: TreeNode<HeaderNodeData>, columnIndex: number, headerLevel: number, extractionLength?: number): void;
+    /**
+     * Clears the tree to the initial state.
+     */
+    clear(): void;
+}

package/plugins/nestedHeaders/stateManager/headersTree.js

@@ -10,6 +10,7 @@ Object.defineProperty(exports, "default", {
 });
 const _array = require("../../../helpers/array");
 const _tree = /*#__PURE__*/ _interop_require_default(require("../../../utils/dataStructures/tree"));
+const _utils = require("./utils");
 function _check_private_redeclaration(obj, privateCollection) {
     if (privateCollection.has(obj)) {
         throw new TypeError("Cannot initialize the same private elements twice on an object");
@@ -55,24 +56,7 @@ function _interop_require_default(obj) {
         default: obj
     };
 }
-var /**
-   * The collection of nested headers settings structured into trees. The root trees are stored
-   * under the visual column index.
-   *
-   * @private
-   * @type {Map<number, TreeNode>}
-   */ _rootNodes = /*#__PURE__*/ new WeakMap(), /**
-   * A map that translates the visual column indexes that intersect the range
-   * defined by the header colspan width to the root index.
-   *
-   * @private
-   * @type {Map<number, number>}
-   */ _rootsIndex = /*#__PURE__*/ new WeakMap(), /**
-   * The instance of the SourceSettings class.
-   *
-   * @private
-   * @type {SourceSettings}
-   */ _sourceSettings = /*#__PURE__*/ new WeakMap();
+var _rootNodes = /*#__PURE__*/ new WeakMap(), _rootsIndex = /*#__PURE__*/ new WeakMap(), _sourceSettings = /*#__PURE__*/ new WeakMap();
 class HeadersTree {
     /**
    * Gets an array of the all root nodes.
@@ -96,7 +80,7 @@ class HeadersTree {
     /**
    * Gets a tree node by its position in the grid settings.
    *
-   * @param {number} headerLevel Header level index (there is support only for positive values).
+   * @param {number} headerLevel Header level index.
    * @param {number} columnIndex A visual column index.
    * @returns {TreeNode|undefined}
    */ getNode(headerLevel, columnIndex) {
@@ -111,7 +95,7 @@ class HeadersTree {
         let treeNode;
         // Collect all parent nodes that depend on the collapsed node.
         rootNode.walkDown((node)=>{
-            const { data: { origColspan, headerLevel: nodeHeaderLevel } } = node;
+            const { origColspan, headerLevel: nodeHeaderLevel } = node.data;
             if (headerLevel === nodeHeaderLevel) {
                 if (normColumnIndex >= columnCursor && normColumnIndex <= columnCursor + origColspan - 1) {
                     treeNode = node;
@@ -128,7 +112,8 @@ class HeadersTree {
    */ rebuildTreeIndex() {
         let columnIndex = 0;
         _class_private_field_get(this, _rootsIndex).clear();
-        (0, _array.arrayEach)(_class_private_field_get(this, _rootNodes), ([, { data: { colspan } }])=>{
+        (0, _array.arrayEach)(_class_private_field_get(this, _rootNodes), ([, node])=>{
+            const { colspan } = node.data;
             // Map tree range (colspan range/width) into visual column index of the root node.
             for(let i = columnIndex; i < columnIndex + colspan; i++){
                 _class_private_field_get(this, _rootsIndex).set(i, columnIndex);
@@ -137,15 +122,19 @@ class HeadersTree {
         });
     }
     /**
-   * Builds trees based on SourceSettings class. Calling a method causes clearing the tree state built
-   * from the previous call.
+   * Builds trees based on SourceSettings class.
    */ buildTree() {
         this.clear();
         const columnsCount = _class_private_field_get(this, _sourceSettings).getColumnsCount();
         let columnIndex = 0;
         while(columnIndex < columnsCount){
             const columnSettings = _class_private_field_get(this, _sourceSettings).getHeaderSettings(0, columnIndex);
-            const rootNode = new _tree.default();
+            // Transient placeholder data - buildLeaves() overwrites it with the real header node data.
+            const rootNode = new _tree.default({
+                ...(0, _utils.createDefaultHeaderSettings)(),
+                headerLevel: 0,
+                columnIndex
+            });
             _class_private_field_get(this, _rootNodes).set(columnIndex, rootNode);
             this.buildLeaves(rootNode, columnIndex, 0, columnSettings.origColspan);
             columnIndex += columnSettings.origColspan;
@@ -162,7 +151,8 @@ class HeadersTree {
    */ buildLeaves(parentNode, columnIndex, headerLevel, extractionLength = 1) {
         const columnsSettings = _class_private_field_get(this, _sourceSettings).getHeadersSettings(headerLevel, columnIndex, extractionLength);
         headerLevel += 1;
-        (0, _array.arrayEach)(columnsSettings, (columnSettings)=>{
+        (0, _array.arrayEach)(columnsSettings, (rawColumnSettings)=>{
+            const columnSettings = rawColumnSettings;
             const nodeData = {
                 ...columnSettings,
                 /**
@@ -196,16 +186,33 @@ class HeadersTree {
         _class_private_field_get(this, _rootNodes).clear();
         _class_private_field_get(this, _rootsIndex).clear();
     }
-    constructor(sourceSettings){
-        _class_private_field_init(this, _rootNodes, {
+    /**
+   * Initializes the headers tree with the given source settings used to build the nested header structure.
+   */ constructor(sourceSettings){
+        /**
+   * The collection of nested headers settings structured into trees.
+   *
+   * @private
+   * @type {Map<number, TreeNode>}
+   */ _class_private_field_init(this, _rootNodes, {
             writable: true,
             value: void 0
         });
-        _class_private_field_init(this, _rootsIndex, {
+        /**
+   * A map that translates the visual column indexes.
+   *
+   * @private
+   * @type {Map<number, number>}
+   */ _class_private_field_init(this, _rootsIndex, {
             writable: true,
             value: void 0
         });
-        _class_private_field_init(this, _sourceSettings, {
+        /**
+   * The instance of the SourceSettings class.
+   *
+   * @private
+   * @type {SourceSettings}
+   */ _class_private_field_init(this, _sourceSettings, {
             writable: true,
             value: void 0
         });

package/plugins/nestedHeaders/stateManager/headersTree.mjs

@@ -40,24 +40,8 @@ function _class_private_field_set(receiver, privateMap, value) {
 }
 import { arrayEach } from '../../../helpers/array.mjs';
 import TreeNode from '../../../utils/dataStructures/tree.mjs';
-var /**
-   * The collection of nested headers settings structured into trees. The root trees are stored
-   * under the visual column index.
-   *
-   * @private
-   * @type {Map<number, TreeNode>}
-   */ _rootNodes = /*#__PURE__*/ new WeakMap(), /**
-   * A map that translates the visual column indexes that intersect the range
-   * defined by the header colspan width to the root index.
-   *
-   * @private
-   * @type {Map<number, number>}
-   */ _rootsIndex = /*#__PURE__*/ new WeakMap(), /**
-   * The instance of the SourceSettings class.
-   *
-   * @private
-   * @type {SourceSettings}
-   */ _sourceSettings = /*#__PURE__*/ new WeakMap();
+import { createDefaultHeaderSettings } from './utils.mjs';
+var _rootNodes = /*#__PURE__*/ new WeakMap(), _rootsIndex = /*#__PURE__*/ new WeakMap(), _sourceSettings = /*#__PURE__*/ new WeakMap();
 class HeadersTree {
     /**
    * Gets an array of the all root nodes.
@@ -81,7 +65,7 @@ class HeadersTree {
     /**
    * Gets a tree node by its position in the grid settings.
    *
-   * @param {number} headerLevel Header level index (there is support only for positive values).
+   * @param {number} headerLevel Header level index.
    * @param {number} columnIndex A visual column index.
    * @returns {TreeNode|undefined}
    */ getNode(headerLevel, columnIndex) {
@@ -96,7 +80,7 @@ class HeadersTree {
         let treeNode;
         // Collect all parent nodes that depend on the collapsed node.
         rootNode.walkDown((node)=>{
-            const { data: { origColspan, headerLevel: nodeHeaderLevel } } = node;
+            const { origColspan, headerLevel: nodeHeaderLevel } = node.data;
             if (headerLevel === nodeHeaderLevel) {
                 if (normColumnIndex >= columnCursor && normColumnIndex <= columnCursor + origColspan - 1) {
                     treeNode = node;
@@ -113,7 +97,8 @@ class HeadersTree {
    */ rebuildTreeIndex() {
         let columnIndex = 0;
         _class_private_field_get(this, _rootsIndex).clear();
-        arrayEach(_class_private_field_get(this, _rootNodes), ([, { data: { colspan } }])=>{
+        arrayEach(_class_private_field_get(this, _rootNodes), ([, node])=>{
+            const { colspan } = node.data;
             // Map tree range (colspan range/width) into visual column index of the root node.
             for(let i = columnIndex; i < columnIndex + colspan; i++){
                 _class_private_field_get(this, _rootsIndex).set(i, columnIndex);
@@ -122,15 +107,19 @@ class HeadersTree {
         });
     }
     /**
-   * Builds trees based on SourceSettings class. Calling a method causes clearing the tree state built
-   * from the previous call.
+   * Builds trees based on SourceSettings class.
    */ buildTree() {
         this.clear();
         const columnsCount = _class_private_field_get(this, _sourceSettings).getColumnsCount();
         let columnIndex = 0;
         while(columnIndex < columnsCount){
             const columnSettings = _class_private_field_get(this, _sourceSettings).getHeaderSettings(0, columnIndex);
-            const rootNode = new TreeNode();
+            // Transient placeholder data - buildLeaves() overwrites it with the real header node data.
+            const rootNode = new TreeNode({
+                ...createDefaultHeaderSettings(),
+                headerLevel: 0,
+                columnIndex
+            });
             _class_private_field_get(this, _rootNodes).set(columnIndex, rootNode);
             this.buildLeaves(rootNode, columnIndex, 0, columnSettings.origColspan);
             columnIndex += columnSettings.origColspan;
@@ -147,7 +136,8 @@ class HeadersTree {
    */ buildLeaves(parentNode, columnIndex, headerLevel, extractionLength = 1) {
         const columnsSettings = _class_private_field_get(this, _sourceSettings).getHeadersSettings(headerLevel, columnIndex, extractionLength);
         headerLevel += 1;
-        arrayEach(columnsSettings, (columnSettings)=>{
+        arrayEach(columnsSettings, (rawColumnSettings)=>{
+            const columnSettings = rawColumnSettings;
             const nodeData = {
                 ...columnSettings,
                 /**
@@ -181,16 +171,33 @@ class HeadersTree {
         _class_private_field_get(this, _rootNodes).clear();
         _class_private_field_get(this, _rootsIndex).clear();
     }
-    constructor(sourceSettings){
-        _class_private_field_init(this, _rootNodes, {
+    /**
+   * Initializes the headers tree with the given source settings used to build the nested header structure.
+   */ constructor(sourceSettings){
+        /**
+   * The collection of nested headers settings structured into trees.
+   *
+   * @private
+   * @type {Map<number, TreeNode>}
+   */ _class_private_field_init(this, _rootNodes, {
             writable: true,
             value: void 0
         });
-        _class_private_field_init(this, _rootsIndex, {
+        /**
+   * A map that translates the visual column indexes.
+   *
+   * @private
+   * @type {Map<number, number>}
+   */ _class_private_field_init(this, _rootsIndex, {
             writable: true,
             value: void 0
         });
-        _class_private_field_init(this, _sourceSettings, {
+        /**
+   * The instance of the SourceSettings class.
+   *
+   * @private
+   * @type {SourceSettings}
+   */ _class_private_field_init(this, _sourceSettings, {
             writable: true,
             value: void 0
         });
@@ -200,37 +207,9 @@ class HeadersTree {
         _class_private_field_set(this, _sourceSettings, sourceSettings);
     }
 }
-/* eslint-disable jsdoc/require-description-complete-sentence */ /**
+/**
+ * Builds and manages a tree structure representing the nested headers configuration, mapping visual column indexes to header nodes.
+ *
  * @private
  * @class HeadersTree
- *
- * The header tree class keeps nested header settings in the tree
- * structure for easier node manipulation (e.q collapse or expand column).
- * That trees represent the current state of the nested headers. From the
- * trees, the matrix is generated for nested header renderers.
- *
- * The second role of the module is validation. While building the tree,
- * there is check whether the configuration contains overlapping
- * headers. If true, then the exception is thrown.
- *
- * The tree is static; it means that its column indexing never changes
- * even when a collapsing header is performed. The structure is based
- * on visual column indexes.
- *
- * For example, for that header configuration:
- *   +----+----+----+----+----+
- *   │ A1                │ A2 │
- *   +----+----+----+----+----+
- *   │ B1           │ B2 │ B3 │
- *   +----+----+----+----+----+
- *   │ C1      │ C2 │ C3 │ C4 │
- *   +----+----+----+----+----+
- *
- * The tree structures look like:
- *                (0)                      (4)           // a visual column index
- *                 │                        │
- *        .------(A1)------.              (A2)--.
- *   .--(B1)--.           (B2)--.              (B3)--.
- *  (C1)     (C2)              (C3)                 (C4)
- *
- */ /* eslint-enable jsdoc/require-description-complete-sentence */ export { HeadersTree as default };
+ */ export { HeadersTree as default };

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

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

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

@@ -0,0 +1,211 @@
+import type { HeaderNodeData } from './headersTree';
+import type { NodeModificationResult } from './nodeModifiers';
+import type { ColumnVisibility } from './columnVisibility';
+import type TreeNode from '../../../utils/dataStructures/tree';
+/**
+ * The state manager is a source of truth for nested headers configuration.
+ *
+ * @class StateManager
+ */
+export default class StateManager {
+    #private;
+    /**
+     * Sets a new state for the nested headers plugin based on settings passed
+     * directly to the plugin.
+     *
+     * @param {Array[]} nestedHeadersSettings The user-defined settings.
+     * @returns {boolean} Returns `true` if the settings are processed correctly, `false` otherwise.
+     */
+    setState(nestedHeadersSettings: unknown[][]): boolean;
+    /**
+     * Sets columns limit to the state will be trimmed.
+     *
+     * @param {number} columnsCount The number of columns to limit to.
+     */
+    setColumnsLimit(columnsCount: number): void;
+    /**
+     * Merges settings with current plugin state.
+     *
+     * @param {object[]} settings An array of objects to merge with the current source settings.
+     */
+    mergeStateWith(settings: {
+        row: number;
+        col: number;
+        [key: string]: unknown;
+    }[]): void;
+    /**
+     * Maps the current state with a callback.
+     *
+     * @param {Function} callback A function that is called for every header source settings.
+     */
+    mapState(callback: (headerSettings: Record<string, unknown>) => unknown): void;
+    /**
+     * 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: number, amount: number): void;
+    /**
+     * 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: number, amount: number): void;
+    /**
+     * Maps the current tree nodes with a callback.
+     *
+     * @param {Function} callback A function that is called for every tree node.
+     * @returns {Array}
+     */
+    mapNodes(callback: Function): never[];
+    /**
+     * Triggers an action from the NodeModifiers module.
+     *
+     * @param {string} action An action name to trigger.
+     * @param {number} headerLevel Header level index.
+     * @param {number} columnIndex A visual column index.
+     * @returns {object|undefined}
+     */
+    triggerNodeModification(action: string, headerLevel: number, columnIndex: number): NodeModificationResult | undefined;
+    /**
+     * 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.
+     * @returns {object|undefined}
+     */
+    triggerColumnModification(action: string, columnIndex: number): NodeModificationResult | undefined;
+    /**
+     * 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: ColumnVisibility): void;
+    /**
+     * @memberof StateManager#
+     * @function rowCoordsToLevel
+     *
+     * Translates row coordinates into header level.
+     *
+     * @param {number} rowIndex A visual row index.
+     * @returns {number|null} Returns unsigned number.
+     */
+    rowCoordsToLevel(rowIndex: number): number | null;
+    /**
+     * @memberof StateManager#
+     * @function levelToRowCoords
+     *
+     * Translates header level into row coordinates.
+     *
+     * @param {number} headerLevel Header level index.
+     * @returns {number} Returns negative number.
+     */
+    levelToRowCoords(headerLevel: number): number | null;
+    /**
+     * Gets column header settings for a specified column and header index.
+     *
+     * @param {number} headerLevel Header level.
+     * @param {number} columnIndex A visual column index.
+     * @returns {object|null}
+     */
+    getHeaderSettings(headerLevel: number, columnIndex: number): HeaderNodeData | null;
+    /**
+     * Gets tree data that is connected to the column header.
+     *
+     * @param {number} headerLevel Header level.
+     * @param {number} columnIndex A visual column index.
+     * @returns {object|null}
+     */
+    getHeaderTreeNodeData(headerLevel: number, columnIndex: number): {
+        [key: string]: unknown;
+        headerLevel: number;
+        columnIndex: number;
+        clonedTree?: TreeNode<HeaderNodeData> | null;
+        label: string;
+        colspan: number;
+        origColspan: number;
+        rowspan?: number;
+        origRowspan?: number;
+        collapsible: boolean;
+        isCollapsed: boolean;
+        crossHiddenColumns: number[];
+        isHidden: boolean;
+        isRoot: boolean;
+        isPlaceholder: boolean;
+        isRowspanPlaceholder?: boolean;
+        headerClassNames: string[];
+        visibleWhen?: import("./utils").HeaderVisibility;
+    } | null;
+    /**
+     * Gets tree node that is connected to the column header.
+     *
+     * @param {number} headerLevel Header level.
+     * @param {number} columnIndex A visual column index.
+     * @returns {TreeNode|null}
+     */
+    getHeaderTreeNode(headerLevel: number, columnIndex: number): TreeNode | null;
+    /**
+     * Finds the most top header level of the column header.
+     *
+     * @param {number} columnIndexFrom A visual column index.
+     * @param {number} [columnIndexTo] A visual column index.
+     * @returns {number} Returns a header level in format -1 to -N.
+     */
+    findTopMostEntireHeaderLevel(columnIndexFrom: number, columnIndexTo?: number): number | null;
+    /**
+     * Finds the left-most column index where the nested header begins.
+     *
+     * @param {number} headerLevel Header level.
+     * @param {number} columnIndex A visual column index.
+     * @returns {number}
+     */
+    findLeftMostColumnIndex(headerLevel: number, columnIndex: number): number;
+    /**
+     * Finds the right-most column index where the nested header ends.
+     *
+     * @param {number} headerLevel Header level.
+     * @param {number} columnIndex A visual column index.
+     * @returns {number}
+     */
+    findRightMostColumnIndex(headerLevel: number, columnIndex: number): number;
+    /**
+     * Gets a total number of headers levels.
+     *
+     * @returns {number}
+     */
+    getLayersCount(): number;
+    /**
+     * Gets a total number of columns count.
+     *
+     * @returns {number}
+     */
+    getColumnsCount(): number;
+    /**
+     * 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(): number[];
+    /**
+     * Clears the column state manager to the initial state.
+     */
+    clear(): void;
+}