handsontable 17.1.0 → 18.0.0-rc2

package/plugins/collapsibleColumns/collapsibleColumns.mjs

@@ -49,13 +49,13 @@ function _class_private_method_init(obj, privateSet) {
     privateSet.add(obj);
 }
 import { BasePlugin } from '../base/index.mjs';
-import { throwWithCause } from '../../helpers/errors.mjs';
-import { arrayEach, arrayFilter, arrayUnique } from '../../helpers/array.mjs';
+import { arrayEach, arrayFilter, arrayMap, arrayUnique, getDifferenceOfArrays } from '../../helpers/array.mjs';
 import { rangeEach } from '../../helpers/number.mjs';
 import { warn } from '../../helpers/console.mjs';
-import { addClass, hasClass, removeClass, fastInnerText, removeAttribute, setAttribute } from '../../helpers/dom/element.mjs';
+import { addClass, eventTargetEl, hasClass, removeClass, fastInnerText, removeAttribute, setAttribute } from '../../helpers/dom/element.mjs';
 import { stopImmediatePropagation } from '../../helpers/dom/event.mjs';
-import { EDITOR_EDIT_GROUP as SHORTCUTS_GROUP_EDITOR } from '../../shortcutContexts/index.mjs';
+import { throwWithCause } from '../../helpers/errors.mjs';
+import { EDITOR_EDIT_GROUP as SHORTCUTS_GROUP_EDITOR } from '../../shortcuts/contexts/index.mjs';
 import { A11Y_EXPANDED, A11Y_HIDDEN } from '../../helpers/a11y.mjs';
 export const PLUGIN_KEY = 'collapsibleColumns';
 export const PLUGIN_PRIORITY = 290;
@@ -63,6 +63,10 @@ const SETTING_KEYS = [
     'nestedHeaders'
 ];
 const COLLAPSIBLE_ELEMENT_CLASS = 'collapsibleIndicator';
+// Name of the hiding map that holds columns hidden by the per-child `visibleWhen` rules (issue
+// #10243). Kept separate from the main collapsed-columns map so `getCollapsedColumns()` and the
+// collapse hooks never report a column that is merely hidden in the expanded state.
+const VISIBLE_WHEN_MAP_NAME = 'collapsibleColumns.visibleWhen';
 const SHORTCUTS_GROUP = PLUGIN_KEY;
 const actionDictionary = new Map([
     [
@@ -84,31 +88,55 @@ const actionDictionary = new Map([
 ]);
 var /**
    * Map of collapsed columns by the plugin.
-   *
-   * @private
-   * @type {HidingMap|null}
    */ _collapsedColumnsMap = /*#__PURE__*/ new WeakMap(), /**
+   * Map of columns hidden by the per-child `visibleWhen` rules (issue #10243), kept separate from
+   * `#collapsedColumnsMap`.
+   */ _visibleWhenMap = /*#__PURE__*/ new WeakMap(), /**
+   * Checks whether a collapse or expand action is possible for the given filtered coordinates.
+   *
+   * @param {Array} filteredCoords Header coordinates filtered to header rows only.
+   * @param {string} action Action definition ('collapse' or 'expand').
+   * @returns {boolean}
+   */ _checkIsActionPossible = /*#__PURE__*/ new WeakSet(), /**
+   * Moves the active cell selection off any column a collapse or expand action just hid, so the
+   * highlight never lingers on a now-hidden column (for example a `visibleWhen: 'collapsed'` summary
+   * column that is hidden again when its group expands).
+   *
+   * @param {number[]} hiddenColumnsIndexes Visual indexes of columns this action hid.
+   */ _adjustSelectionAfterHide = /*#__PURE__*/ new WeakSet(), /**
+   * Re-derives the set of columns hidden by the per-child `visibleWhen` rules (issue #10243) from the
+   * current header tree (markers + each group's `isCollapsed` state) and writes it into the dedicated
+   * `#visibleWhenMap`. Pure recompute - safe to call after any collapse/expand toggle, settings
+   * update, or column insert/remove. The hidden set is passed in by the toggle path (which has just
+   * computed it) and re-derived for the settings/structure-change paths. The map is rewritten only
+   * when the hidden set actually changed, so a legacy collapsible setup - which never produces a
+   * `visibleWhen` hidden set - does not pay an index-cache rebuild on every update.
+   */ _refreshVisibleWhenColumns = /*#__PURE__*/ new WeakSet(), /**
+   * Re-derives the `visibleWhen` hidden set after NestedHeaders rebuilds the header tree on column
+   * insertion or removal. The tree (with `isCollapsed` restored) is the source of truth, so a full
+   * refresh keeps the hidden set correct without tracking shifted indexes manually.
+   */ _onAfterColumnStructureChange = /*#__PURE__*/ new WeakMap(), /**
    * Adds the indicator to the headers.
    *
    * @param {number} column Column index.
    * @param {HTMLElement} TH TH element.
    * @param {number} headerLevel The index of header level counting from the top (positive
    *                             values counting from 0 to N).
-   */ _onAfterGetColHeader = /*#__PURE__*/ new WeakSet(), /**
+   */ _onAfterGetColHeader = /*#__PURE__*/ new WeakMap(), /**
    * Indicator mouse event callback.
    *
    * @param {object} event Mouse event.
    * @param {object} coords Event coordinates.
-   */ _onBeforeOnCellMouseDown = /*#__PURE__*/ new WeakSet(), /**
+   */ _onBeforeOnCellMouseDown = /*#__PURE__*/ new WeakMap(), /**
    * Updates the plugin state after HoT initialization.
-   */ _onInit = /*#__PURE__*/ new WeakSet(), /**
+   */ _onInit = /*#__PURE__*/ new WeakMap(), /**
    * Updates the plugin state after new dataset load.
    *
    * @param {Array[]} sourceData Array of arrays or array of objects containing data.
    * @param {boolean} initialLoad Flag that determines whether the data has been loaded
    *                              during the initialization.
-   */ _onAfterLoadData = /*#__PURE__*/ new WeakSet();
-/* eslint-disable jsdoc/require-description-complete-sentence */ /**
+   */ _onAfterLoadData = /*#__PURE__*/ new WeakMap();
+/**
  * @plugin CollapsibleColumns
  * @class CollapsibleColumns
  *
@@ -208,18 +236,26 @@ var /**
  * ```
  * :::
  */ export class CollapsibleColumns extends BasePlugin {
-    static get PLUGIN_KEY() {
+    /**
+   * Returns the plugin key used to identify this plugin in Handsontable settings.
+   */ static get PLUGIN_KEY() {
         return PLUGIN_KEY;
     }
-    static get PLUGIN_PRIORITY() {
+    /**
+   * Returns the priority order used to determine the order in which plugins are initialized.
+   */ static get PLUGIN_PRIORITY() {
         return PLUGIN_PRIORITY;
     }
-    static get PLUGIN_DEPS() {
+    /**
+   * Returns the list of plugin dependencies required before this plugin can be initialized.
+   */ static get PLUGIN_DEPS() {
         return [
             'plugin:NestedHeaders'
         ];
     }
-    static get SETTING_KEYS() {
+    /**
+   * Returns the setting keys that trigger a plugin update when changed via `updateSettings`.
+   */ static get SETTING_KEYS() {
         return [
             PLUGIN_KEY,
             ...SETTING_KEYS
@@ -243,13 +279,26 @@ var /**
         if (!nestedHeaders) {
             warn('You need to configure the Nested Headers plugin in order to use collapsible headers.');
         }
-        _class_private_field_set(this, _collapsedColumnsMap, this.hot.columnIndexMapper.createAndRegisterIndexMap(this.pluginName, 'hiding'));
+        if (this.pluginName) {
+            _class_private_field_set(this, _collapsedColumnsMap, this.hot.columnIndexMapper.createAndRegisterIndexMap(this.pluginName, 'hiding'));
+        }
+        _class_private_field_set(this, _visibleWhenMap, this.hot.columnIndexMapper.createAndRegisterIndexMap(VISIBLE_WHEN_MAP_NAME, 'hiding'));
         this.nestedHeadersPlugin = this.hot.getPlugin('nestedHeaders');
         this.headerStateManager = this.nestedHeadersPlugin.getStateManager();
-        this.addHook('init', ()=>_class_private_method_get(this, _onInit, onInit).call(this));
-        this.addHook('afterLoadData', (...args)=>_class_private_method_get(this, _onAfterLoadData, onAfterLoadData).call(this, ...args));
-        this.addHook('afterGetColHeader', (...args)=>_class_private_method_get(this, _onAfterGetColHeader, onAfterGetColHeader).call(this, ...args));
-        this.addHook('beforeOnCellMouseDown', (event, coords, TD)=>_class_private_method_get(this, _onBeforeOnCellMouseDown, onBeforeOnCellMouseDown).call(this, event, coords, TD));
+        this.addHook('init', _class_private_field_get(this, _onInit));
+        this.addHook('afterLoadData', _class_private_field_get(this, _onAfterLoadData));
+        this.addHook('afterGetColHeader', _class_private_field_get(this, _onAfterGetColHeader));
+        this.addHook('beforeOnCellMouseDown', _class_private_field_get(this, _onBeforeOnCellMouseDown));
+        // NestedHeaders (priority 280) rebuilds the header tree on column insert/remove before this
+        // plugin (priority 290) runs, so refreshing here re-derives the `visibleWhen` hidden set against
+        // the freshly rebuilt tree (with `isCollapsed` already restored). There is intentionally no
+        // `afterColumnMove` refresh: a `manualColumnMove` does not rebuild the tree (its `columnIndex`
+        // values are structural), and the collapsed-columns map already strands its entries on a move the
+        // same way - so collapsed groups (legacy and `visibleWhen` alike) do not survive `manualColumnMove`.
+        // That is a pre-existing collapsible-columns limitation; refreshing only `visibleWhen` here would
+        // diverge from legacy collapse without fixing it.
+        this.addHook('afterCreateCol', _class_private_field_get(this, _onAfterColumnStructureChange));
+        this.addHook('afterRemoveCol', _class_private_field_get(this, _onAfterColumnStructureChange));
         this.registerShortcuts();
         super.enablePlugin();
         // @TODO: Workaround for broken plugin initialization abstraction (#6806).
@@ -266,31 +315,38 @@ var /**
         if (!this.hot.view) {
             return;
         }
-        if (!this.nestedHeadersPlugin.detectedOverlappedHeaders) {
+        if (!this.nestedHeadersPlugin?.detectedOverlappedHeaders) {
             const { collapsibleColumns } = this.hot.getSettings();
             if (typeof collapsibleColumns === 'boolean') {
                 // Add `collapsible: true` attribute to all headers with colspan higher than 1.
-                this.headerStateManager.mapState((headerSettings)=>{
+                this.headerStateManager?.mapState((headerSettings)=>{
                     return {
-                        collapsible: headerSettings.origColspan > 1
+                        collapsible: Number(headerSettings.origColspan) > 1
                     };
                 });
             } else if (Array.isArray(collapsibleColumns)) {
-                this.headerStateManager.mapState(()=>{
+                this.headerStateManager?.mapState(()=>{
                     return {
                         collapsible: false
                     };
                 });
-                this.headerStateManager.mergeStateWith(collapsibleColumns);
+                this.headerStateManager?.mergeStateWith(collapsibleColumns);
             }
         }
+        // Apply the per-child `visibleWhen` rules once the `collapsible` flags are in place - on the
+        // initial render this hides every `visibleWhen: 'collapsed'` column (all groups start expanded).
+        _class_private_method_get(this, _refreshVisibleWhenColumns, refreshVisibleWhenColumns).call(this);
         super.updatePlugin();
     }
     /**
    * Disables the plugin functionality for this Handsontable instance.
    */ disablePlugin() {
-        this.hot.columnIndexMapper.unregisterMap(this.pluginName);
+        if (this.pluginName) {
+            this.hot.columnIndexMapper.unregisterMap(this.pluginName);
+        }
+        this.hot.columnIndexMapper.unregisterMap(VISIBLE_WHEN_MAP_NAME);
         _class_private_field_set(this, _collapsedColumnsMap, null);
+        _class_private_field_set(this, _visibleWhenMap, null);
         this.nestedHeadersPlugin = null;
         this.unregisterShortcuts();
         this.clearButtons();
@@ -301,15 +357,28 @@ var /**
    *
    * @private
    */ registerShortcuts() {
-        this.hot.getShortcutManager().getContext('grid').addShortcut({
+        this.hot.getShortcutManager().getContext('grid')?.addShortcut({
             keys: [
                 [
                     'Enter'
                 ]
             ],
             callback: ()=>{
-                const { row, col } = this.hot.getSelectedRangeActive().highlight;
-                const { collapsible, isCollapsed, columnIndex } = this.headerStateManager.getHeaderTreeNodeData(row, col) ?? {};
+                const activeRange = this.hot.getSelectedRangeActive();
+                if (!activeRange) {
+                    return;
+                }
+                const { row, col } = activeRange.highlight;
+                if (row === null || col === null) {
+                    return;
+                }
+                const nodeData = this.headerStateManager?.getHeaderTreeNodeData(row, col) ?? {
+                    collapsible: false,
+                    isCollapsed: false,
+                    columnIndex: 0,
+                    headerLevel: 0
+                };
+                const { collapsible, isCollapsed, columnIndex } = nodeData;
                 if (!collapsible) {
                     return;
                 }
@@ -327,7 +396,7 @@ var /**
                 // prevent default Enter behavior (move to the next row within a selection range)
                 return false;
             },
-            runOnlyIf: ()=>this.hot.getSelectedRangeActive()?.isSingle() && this.hot.getSelectedRangeActive()?.highlight.isHeader(),
+            runOnlyIf: ()=>!!(this.hot.getSelectedRangeActive()?.isSingle() && this.hot.getSelectedRangeActive()?.highlight.isHeader()),
             group: SHORTCUTS_GROUP,
             relativeToGroup: SHORTCUTS_GROUP_EDITOR,
             position: 'before'
@@ -338,7 +407,7 @@ var /**
    *
    * @private
    */ unregisterShortcuts() {
-        this.hot.getShortcutManager().getContext('grid').removeShortcutsByGroup(SHORTCUTS_GROUP);
+        this.hot.getShortcutManager().getContext('grid')?.removeShortcutsByGroup(SHORTCUTS_GROUP);
     }
     /**
    * Clears the expand/collapse buttons.
@@ -350,13 +419,16 @@ var /**
         }
         const headerLevels = this.hot.view._wt.getSetting('columnHeaders').length;
         const mainHeaders = this.hot.view._wt.wtTable.THEAD;
-        const topHeaders = this.hot.view._wt.wtOverlays.topOverlay.clone.wtTable.THEAD;
-        const topLeftCornerHeaders = this.hot.view._wt.wtOverlays.topInlineStartCornerOverlay ? this.hot.view._wt.wtOverlays.topInlineStartCornerOverlay.clone.wtTable.THEAD : null;
+        const topHeaders = this.hot.view._wt.wtOverlays.topOverlay?.clone?.wtTable.THEAD ?? null;
+        const topLeftCornerHeaders = this.hot.view._wt.wtOverlays.topInlineStartCornerOverlay ? this.hot.view._wt.wtOverlays.topInlineStartCornerOverlay.clone?.wtTable.THEAD ?? null : null;
         const removeButton = function(button) {
-            if (button) {
+            if (button && button.parentNode) {
                 button.parentNode.removeChild(button);
             }
         };
+        if (!mainHeaders || !topHeaders) {
+            return;
+        }
         rangeEach(0, headerLevels - 1, (i)=>{
             const masterLevel = mainHeaders.childNodes[i];
             const topLevel = topHeaders.childNodes[i];
@@ -373,10 +445,11 @@ var /**
                     removeButton(button);
                 }
             });
-        }, true);
+        });
     }
     /**
-   * Expands section at the provided coords.
+   * Expands section at the provided coords. `coords.col` may be any column the group's header spans,
+   * not only its first (anchor) column - it resolves to the owning collapsible group.
    *
    * @param {object} coords Contains coordinates information. (`coords.row`, `coords.col`).
    */ expandSection(coords) {
@@ -385,7 +458,8 @@ var /**
         ], 'expand');
     }
     /**
-   * Collapses section at the provided coords.
+   * Collapses section at the provided coords. `coords.col` may be any column the group's header spans,
+   * not only its first (anchor) column - it resolves to the owning collapsible group.
    *
    * @param {object} coords Contains coordinates information. (`coords.row`, `coords.col`).
    */ collapseSection(coords) {
@@ -398,11 +472,11 @@ var /**
    *
    * @param {string} action 'collapse' or 'expand'.
    */ toggleAllCollapsibleSections(action) {
-        const coords = this.headerStateManager.mapNodes((headerSettings)=>{
+        const coords = this.headerStateManager?.mapNodes((headerSettings)=>{
             const { collapsible, origColspan, headerLevel, columnIndex, isCollapsed } = headerSettings;
-            if (collapsible === true && origColspan > 1 && (isCollapsed && action === 'expand' || !isCollapsed && action === 'collapse')) {
+            if (collapsible === true && Number(origColspan) > 1 && (isCollapsed && action === 'expand' || !isCollapsed && action === 'collapse')) {
                 return {
-                    row: this.headerStateManager.levelToRowCoords(headerLevel),
+                    row: this.headerStateManager?.levelToRowCoords(Number(headerLevel)) ?? 0,
                     col: columnIndex
                 };
             }
@@ -429,7 +503,7 @@ var /**
    * @fires Hooks#afterColumnCollapse
    * @fires Hooks#afterColumnExpand
    */ toggleCollapsibleSection(coords, action) {
-        if (!actionDictionary.has(action)) {
+        if (action === undefined || !actionDictionary.has(action)) {
             throwWithCause(`Unsupported action is passed (${action}).`);
         }
         if (!Array.isArray(coords)) {
@@ -437,27 +511,41 @@ var /**
         }
         // Ignore coordinates which points to the cells range.
         const filteredCoords = arrayFilter(coords, ({ row })=>row < 0);
-        let isActionPossible = filteredCoords.length > 0;
-        arrayEach(filteredCoords, ({ row, col: column })=>{
-            const { collapsible, isCollapsed } = this.headerStateManager.getHeaderSettings(row, column) ?? {};
-            if (!collapsible || isCollapsed && action === 'collapse' || !isCollapsed && action === 'expand') {
-                isActionPossible = false;
-                return false;
-            }
-        });
+        const isActionPossible = _class_private_method_get(this, _checkIsActionPossible, checkIsActionPossible).call(this, filteredCoords, action);
         const nodeModRollbacks = [];
         const affectedColumnsIndexes = [];
+        // Snapshot the declarative `visibleWhen` hidden set (issue #10243) before the nodes are toggled.
+        // triggerNodeModification flips `isCollapsed` for declarative groups, so re-deriving afterwards
+        // tells us which columns the toggle hid/showed - used for selection adjustment and the
+        // action-performed check.
+        const visibleWhenHiddenBefore = this.headerStateManager?.getVisibleWhenHiddenColumns() ?? [];
         if (isActionPossible) {
             arrayEach(filteredCoords, ({ row, col: column })=>{
-                const { colspanCompensation, affectedColumns, rollbackModification } = this.headerStateManager.triggerNodeModification(action, row, column);
-                if (colspanCompensation > 0) {
+                const { affectedColumns, rollbackModification } = this.headerStateManager?.triggerNodeModification(action, row, column) ?? {
+                    colspanCompensation: 0,
+                    affectedColumns: [],
+                    rollbackModification: ()=>{}
+                };
+                // Always keep the rollback - a declarative group toggles `isCollapsed` without reporting
+                // affected columns, so its rollback must still run if the before-hook vetoes the action.
+                // No-op modifications return an empty rollback, so this stays safe.
+                nodeModRollbacks.push(rollbackModification);
+                // Gate on whether any columns were affected, not on the colspan delta. A collapse can own
+                // columns without changing the colspan - when the columns it claims are already hidden by
+                // another source (e.g. HiddenColumns) the colspan is unchanged, but the collapse must still
+                // record those columns so the group stays collapsed if that external hide is later removed.
+                if (affectedColumns.length > 0) {
                     affectedColumnsIndexes.push(...affectedColumns);
-                    nodeModRollbacks.push(rollbackModification);
                 }
             });
         }
         const currentCollapsedColumns = this.getCollapsedColumns();
         let destinationCollapsedColumns = [];
+        // The collapse hooks report the collapsed-columns map only. A declarative `visibleWhen` group
+        // hides its columns through the separate `#visibleWhenMap` (so `getCollapsedColumns()` stays a
+        // faithful record of legacy collapses), so for such a group `destinationCollapsedColumns` equals
+        // `currentCollapsedColumns` even though columns were hidden - the `successfullyCollapsed` flag,
+        // not the array delta, tells a consumer whether the toggle did anything.
         if (action === 'collapse') {
             destinationCollapsedColumns = arrayUnique([
                 ...currentCollapsedColumns,
@@ -477,21 +565,32 @@ var /**
         }
         this.hot.batchExecution(()=>{
             arrayEach(affectedColumnsIndexes, (visualColumn)=>{
-                _class_private_field_get(this, _collapsedColumnsMap).setValueAtIndex(this.hot.toPhysicalColumn(visualColumn), actionTranslator.hideColumn);
+                _class_private_field_get(this, _collapsedColumnsMap)?.setValueAtIndex(this.hot.toPhysicalColumn(visualColumn), actionTranslator.hideColumn);
             });
         }, true);
-        const isActionPerformed = this.getCollapsedColumns().length !== currentCollapsedColumns.length;
-        const selectionRange = this.hot.getSelectedRangeActive();
-        if (action === 'collapse' && isActionPerformed && selectionRange) {
-            const { row, col } = selectionRange.highlight;
-            const isHidden = this.hot.rowIndexMapper.isHidden(row) || this.hot.columnIndexMapper.isHidden(col);
-            if (isHidden && affectedColumnsIndexes.includes(col)) {
-                const nextRow = row >= 0 ? this.hot.rowIndexMapper.getNearestNotHiddenIndex(row, 1, true) : row;
-                const nextColumn = col >= 0 ? this.hot.columnIndexMapper.getNearestNotHiddenIndex(col, 1, true) : col;
-                if (nextRow !== null && nextColumn !== null) {
-                    this.hot.selectCell(nextRow, nextColumn);
-                }
-            }
+        // The declarative `visibleWhen` hidden set is a pure function of the `isCollapsed` flags that the
+        // node modification just toggled, so re-derive it and diff against the snapshot taken before the
+        // toggle. `newlyHiddenByVisibleWhen` are the columns this toggle hid through `visibleWhen` - on a
+        // collapse the group's own columns, on an expand the `visibleWhen: 'collapsed'` summary columns
+        // that are only visible while collapsed. Only refresh when it changed, so a plain legacy collapse
+        // does not trigger an extra cache update that would disturb the selection adjustment below.
+        const visibleWhenHiddenAfter = this.headerStateManager?.getVisibleWhenHiddenColumns() ?? [];
+        const newlyHiddenByVisibleWhen = getDifferenceOfArrays(visibleWhenHiddenAfter, visibleWhenHiddenBefore);
+        const isVisibleWhenChanged = newlyHiddenByVisibleWhen.length > 0 || visibleWhenHiddenAfter.length !== visibleWhenHiddenBefore.length;
+        if (isVisibleWhenChanged) {
+            // Pass the already-computed set so the refresh does not walk the header tree a third time.
+            _class_private_method_get(this, _refreshVisibleWhenColumns, refreshVisibleWhenColumns).call(this, visibleWhenHiddenAfter);
+        }
+        const isActionPerformed = this.getCollapsedColumns().length !== currentCollapsedColumns.length || isVisibleWhenChanged;
+        // Move the selection off any column this toggle hid - a collapse hides the group's columns plus
+        // any `visibleWhen` columns, while an expand hides the `visibleWhen: 'collapsed'` columns that are
+        // only visible while collapsed.
+        const newlyHiddenColumns = action === 'collapse' ? arrayUnique([
+            ...affectedColumnsIndexes,
+            ...newlyHiddenByVisibleWhen
+        ]) : newlyHiddenByVisibleWhen;
+        if (isActionPerformed && newlyHiddenColumns.length > 0) {
+            _class_private_method_get(this, _adjustSelectionAfterHide, adjustSelectionAfterHide).call(this, newlyHiddenColumns);
         }
         this.hot.runHooks(actionTranslator.afterHook, currentCollapsedColumns, destinationCollapsedColumns, isActionPossible, isActionPerformed);
         this.hot.view.adjustElementsSize();
@@ -503,16 +602,35 @@ var /**
    * @private
    * @returns {number[]}
    */ getCollapsedColumns() {
-        return _class_private_field_get(this, _collapsedColumnsMap).getHiddenIndexes();
+        return _class_private_field_get(this, _collapsedColumnsMap)?.getHiddenIndexes() ?? [];
     }
     /**
    * Destroys the plugin instance.
    */ destroy() {
         _class_private_field_set(this, _collapsedColumnsMap, null);
+        _class_private_field_set(this, _visibleWhenMap, null);
         super.destroy();
     }
     constructor(...args){
-        super(...args), _class_private_method_init(this, _onAfterGetColHeader), _class_private_method_init(this, _onBeforeOnCellMouseDown), _class_private_method_init(this, _onInit), _class_private_method_init(this, _onAfterLoadData), _class_private_field_init(this, _collapsedColumnsMap, {
+        super(...args), _class_private_method_init(this, _checkIsActionPossible), _class_private_method_init(this, _adjustSelectionAfterHide), _class_private_method_init(this, _refreshVisibleWhenColumns), _class_private_field_init(this, _collapsedColumnsMap, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _visibleWhenMap, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onAfterColumnStructureChange, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onAfterGetColHeader, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onBeforeOnCellMouseDown, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onInit, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onAfterLoadData, {
             writable: true,
             value: void 0
         }), /**
@@ -525,71 +643,126 @@ var /**
    *
    * @private
    * @type {StateManager}
-   */ this.headerStateManager = null, _class_private_field_set(this, _collapsedColumnsMap, null);
-    }
-}
-function onAfterGetColHeader(column, TH, headerLevel) {
-    const { collapsible, origColspan, isCollapsed } = this.headerStateManager.getHeaderSettings(headerLevel, column) ?? {};
-    const isNodeCollapsible = collapsible && origColspan > 1 && column >= this.hot.getSettings().fixedColumnsStart;
-    const isAriaTagsEnabled = this.hot.getSettings().ariaTags;
-    let collapsibleElement = TH.querySelector(`.${COLLAPSIBLE_ELEMENT_CLASS}`);
-    removeAttribute(TH, [
-        A11Y_EXPANDED('')[0]
-    ]);
-    if (isNodeCollapsible) {
-        if (!collapsibleElement) {
-            collapsibleElement = this.hot.rootDocument.createElement('div');
-            addClass(collapsibleElement, COLLAPSIBLE_ELEMENT_CLASS);
-            TH.querySelector('div:first-child').appendChild(collapsibleElement);
-        }
-        removeClass(collapsibleElement, [
-            'collapsed',
-            'expanded'
-        ]);
-        if (isCollapsed) {
-            addClass(collapsibleElement, 'collapsed');
-            fastInnerText(collapsibleElement, '+');
-            // Add ARIA tags
-            if (isAriaTagsEnabled) {
-                setAttribute(TH, ...A11Y_EXPANDED(false));
+   */ this.headerStateManager = null, _class_private_field_set(this, _collapsedColumnsMap, null), _class_private_field_set(this, _visibleWhenMap, null), _class_private_field_set(this, _onAfterColumnStructureChange, ()=>{
+            _class_private_method_get(this, _refreshVisibleWhenColumns, refreshVisibleWhenColumns).call(this);
+        }), _class_private_field_set(this, _onAfterGetColHeader, (column, TH, headerLevel)=>{
+            const headerSettings = this.headerStateManager?.getHeaderSettings(headerLevel, column);
+            const { collapsible, origColspan, isCollapsed } = headerSettings ?? {};
+            const isNodeCollapsible = collapsible === true && (origColspan ?? 0) > 1 && column >= (this.hot.getSettings().fixedColumnsStart ?? 0);
+            const isAriaTagsEnabled = this.hot.getSettings().ariaTags;
+            let collapsibleElement = TH.querySelector(`.${COLLAPSIBLE_ELEMENT_CLASS}`);
+            removeAttribute(TH, [
+                A11Y_EXPANDED('')[0]
+            ]);
+            if (isNodeCollapsible) {
+                if (!collapsibleElement) {
+                    collapsibleElement = this.hot.rootDocument.createElement('div');
+                    addClass(collapsibleElement, COLLAPSIBLE_ELEMENT_CLASS);
+                    TH.querySelector('div:first-child')?.appendChild(collapsibleElement);
+                }
+                const el = collapsibleElement;
+                removeClass(el, [
+                    'collapsed',
+                    'expanded'
+                ]);
+                if (isCollapsed) {
+                    addClass(el, 'collapsed');
+                    fastInnerText(el, '+');
+                    // Add ARIA tags
+                    if (isAriaTagsEnabled) {
+                        setAttribute(TH, ...A11Y_EXPANDED(false));
+                    }
+                } else {
+                    addClass(el, 'expanded');
+                    fastInnerText(el, '-');
+                    // Add ARIA tags
+                    if (isAriaTagsEnabled) {
+                        setAttribute(TH, ...A11Y_EXPANDED(true));
+                    }
+                }
+                if (isAriaTagsEnabled) {
+                    setAttribute(el, ...A11Y_HIDDEN());
+                }
+            } else {
+                collapsibleElement?.remove();
             }
-        } else {
-            addClass(collapsibleElement, 'expanded');
-            fastInnerText(collapsibleElement, '-');
-            // Add ARIA tags
-            if (isAriaTagsEnabled) {
-                setAttribute(TH, ...A11Y_EXPANDED(true));
+        }), _class_private_field_set(this, _onBeforeOnCellMouseDown, (event, coords)=>{
+            const target = eventTargetEl(event);
+            if (hasClass(target, COLLAPSIBLE_ELEMENT_CLASS)) {
+                if (hasClass(target, 'expanded')) {
+                    this.eventManager.fireEvent(target, 'mouseup');
+                    this.toggleCollapsibleSection([
+                        coords
+                    ], 'collapse');
+                } else if (hasClass(target, 'collapsed')) {
+                    this.eventManager.fireEvent(target, 'mouseup');
+                    this.toggleCollapsibleSection([
+                        coords
+                    ], 'expand');
+                }
+                stopImmediatePropagation(event);
             }
-        }
-        if (isAriaTagsEnabled) {
-            setAttribute(collapsibleElement, ...A11Y_HIDDEN());
-        }
-    } else {
-        collapsibleElement?.remove();
+        }), _class_private_field_set(this, _onInit, ()=>{
+            // @TODO: Workaround for broken plugin initialization abstraction (#6806).
+            this.updatePlugin();
+        }), _class_private_field_set(this, _onAfterLoadData, (_sourceData, initialLoad)=>{
+            if (!initialLoad) {
+                this.updatePlugin();
+            }
+        });
     }
 }
-function onBeforeOnCellMouseDown(event, coords) {
-    if (hasClass(event.target, COLLAPSIBLE_ELEMENT_CLASS)) {
-        if (hasClass(event.target, 'expanded')) {
-            this.eventManager.fireEvent(event.target, 'mouseup');
-            this.toggleCollapsibleSection([
-                coords
-            ], 'collapse');
-        } else if (hasClass(event.target, 'collapsed')) {
-            this.eventManager.fireEvent(event.target, 'mouseup');
-            this.toggleCollapsibleSection([
-                coords
-            ], 'expand');
-        }
-        stopImmediatePropagation(event);
+function checkIsActionPossible(filteredCoords, action) {
+    if (filteredCoords.length === 0) {
+        return false;
     }
+    let isActionPossible = true;
+    arrayEach(filteredCoords, ({ row, col: column })=>{
+        // Read the tree node, not the generated matrix: a declarative group (issue #10243) can hide its
+        // own anchor column when collapsed, in which case the matrix cell at the anchor is a hidden
+        // placeholder with no collapse state. The tree node always carries the authoritative
+        // `collapsible`/`isCollapsed` regardless of which columns are hidden.
+        const { collapsible, isCollapsed } = this.headerStateManager?.getHeaderTreeNodeData(row, column) ?? {};
+        if (!collapsible || isCollapsed && action === 'collapse' || !isCollapsed && action === 'expand') {
+            isActionPossible = false;
+            return false;
+        }
+    });
+    return isActionPossible;
 }
-function onInit() {
-    // @TODO: Workaround for broken plugin initialization abstraction (#6806).
-    this.updatePlugin();
+function adjustSelectionAfterHide(hiddenColumnsIndexes) {
+    const selectionRange = this.hot.getSelectedRangeActive();
+    if (!selectionRange) {
+        return;
+    }
+    const { row, col } = selectionRange.highlight;
+    if (row === null || col === null) {
+        return;
+    }
+    const isHidden = this.hot.rowIndexMapper.isHidden(row) || this.hot.columnIndexMapper.isHidden(col);
+    if (isHidden && hiddenColumnsIndexes.includes(col)) {
+        const nextRow = row >= 0 ? this.hot.rowIndexMapper.getNearestNotHiddenIndex(row, 1, true) : row;
+        const nextColumn = col >= 0 ? this.hot.columnIndexMapper.getNearestNotHiddenIndex(col, 1, true) : col;
+        if (nextRow !== null && nextColumn !== null) {
+            this.hot.selectCell(nextRow, nextColumn);
+        }
+    }
 }
-function onAfterLoadData(sourceData, initialLoad) {
-    if (!initialLoad) {
-        this.updatePlugin();
+function refreshVisibleWhenColumns(visualColumnsToHide = this.headerStateManager?.getVisibleWhenHiddenColumns() ?? []) {
+    if (!_class_private_field_get(this, _visibleWhenMap)) {
+        return;
     }
+    const visibleWhenMap = _class_private_field_get(this, _visibleWhenMap);
+    const nextHiddenColumns = arrayMap(visualColumnsToHide, (visualColumn)=>this.hot.toPhysicalColumn(visualColumn));
+    const currentHiddenColumns = visibleWhenMap.getHiddenIndexes();
+    const isUnchanged = nextHiddenColumns.length === currentHiddenColumns.length && getDifferenceOfArrays(nextHiddenColumns, currentHiddenColumns).length === 0;
+    if (isUnchanged) {
+        return;
+    }
+    this.hot.batchExecution(()=>{
+        visibleWhenMap.clear();
+        arrayEach(nextHiddenColumns, (physicalColumn)=>{
+            visibleWhenMap.setValueAtIndex(physicalColumn, true);
+        });
+    }, true);
 }

package/plugins/collapsibleColumns/index.d.mts

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

package/plugins/collapsibleColumns/index.d.ts

@@ -1 +1 @@
-export * from './collapsibleColumns';
+export { PLUGIN_KEY, PLUGIN_PRIORITY, CollapsibleColumns, } from './collapsibleColumns';

package/plugins/columnSorting/columnSorting.d.mts

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