handsontable 0.0.0-next-9ec04ce-20221121

package/plugins/nestedHeaders/stateManager/nodeModifiers/collapse.js

@@ -0,0 +1,98 @@
+"use strict";
+
+exports.__esModule = true;
+exports.collapseNode = collapseNode;
+require("core-js/modules/es.array.slice.js");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.set.js");
+require("core-js/modules/es.string.iterator.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+require("core-js/modules/es.array.from.js");
+var _array = require("../../../../helpers/array");
+var _expand = require("./expand");
+var _tree = require("./utils/tree");
+/**
+ * Collapsing a node is a process where the processing node is collapsed
+ * to the colspan width of the first child. All node children, except the
+ * first one, are hidden. To prevent losing a current state of node children
+ * on the right, all nodes are cloned (and restored while expanding), and
+ * only then original nodes are modified (hidden in this case).
+ *
+ * @param {TreeNode} nodeToProcess A tree node to process.
+ * @returns {object} Returns an object with properties:
+ *                    - rollbackModification: The function that rollbacks
+ *                      the tree to the previous state.
+ *                    - affectedColumns: The list of the visual column
+ *                      indexes which are affected. That list is passed
+ *                      to the hiddens column logic.
+ *                    - colspanCompensation: The number of colspan by
+ *                      which the processed node colspan was reduced.
+ */
+function collapseNode(nodeToProcess) {
+  var _getFirstChildPropert;
+  var nodeData = nodeToProcess.data,
+    nodeChilds = nodeToProcess.childs;
+  if (nodeData.isCollapsed || nodeData.isHidden || nodeData.origColspan <= 1) {
+    return {
+      rollbackModification: function rollbackModification() {},
+      affectedColumns: [],
+      colspanCompensation: 0
+    };
+  }
+  var isNodeReflected = (0, _tree.isNodeReflectsFirstChildColspan)(nodeToProcess);
+  if (isNodeReflected) {
+    return collapseNode(nodeChilds[0]);
+  }
+  nodeData.isCollapsed = true;
+  var allLeavesExceptMostLeft = nodeChilds.slice(1);
+  var affectedColumns = new Set();
+  if (allLeavesExceptMostLeft.length > 0) {
+    (0, _array.arrayEach)(allLeavesExceptMostLeft, function (node) {
+      (0, _tree.traverseHiddenNodeColumnIndexes)(node, function (gridColumnIndex) {
+        affectedColumns.add(gridColumnIndex);
+      });
+
+      // Clone the tree to preserve original tree state after header expanding.
+      node.data.clonedTree = node.cloneTree();
+
+      // Hide all leaves except the first leaf on the left (on headers context hide all
+      // headers on the right).
+      node.walkDown(function (_ref) {
+        var data = _ref.data;
+        data.isHidden = true;
+      });
+    });
+  } else {
+    var origColspan = nodeData.origColspan,
+      columnIndex = nodeData.columnIndex;
+
+    // Add column to "affected" started from 1. The header without children can not be
+    // collapsed so the first have to be visible (untouched).
+    for (var i = 1; i < origColspan; i++) {
+      var gridColumnIndex = columnIndex + i;
+      affectedColumns.add(gridColumnIndex);
+    }
+  }
+
+  // Calculate by how many colspan it needs to reduce the headings to match them to
+  // the first child colspan width.
+  var colspanCompensation = nodeData.colspan - ((_getFirstChildPropert = (0, _tree.getFirstChildProperty)(nodeToProcess, 'colspan')) !== null && _getFirstChildPropert !== void 0 ? _getFirstChildPropert : 1);
+  nodeToProcess.walkUp(function (node) {
+    var data = node.data;
+    data.colspan -= colspanCompensation;
+    if (data.colspan <= 1) {
+      data.colspan = 1;
+      data.isCollapsed = true;
+    } else if ((0, _tree.isNodeReflectsFirstChildColspan)(node)) {
+      data.isCollapsed = (0, _tree.getFirstChildProperty)(node, 'isCollapsed');
+    }
+  });
+  return {
+    rollbackModification: function rollbackModification() {
+      return (0, _expand.expandNode)(nodeToProcess);
+    },
+    affectedColumns: Array.from(affectedColumns),
+    colspanCompensation: colspanCompensation
+  };
+}

package/plugins/nestedHeaders/stateManager/nodeModifiers/collapse.mjs

@@ -0,0 +1,94 @@
+import "core-js/modules/es.array.slice.js";
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.set.js";
+import "core-js/modules/es.string.iterator.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+import "core-js/modules/es.array.from.js";
+import { arrayEach } from "../../../../helpers/array.mjs";
+import { expandNode } from "./expand.mjs";
+import { getFirstChildProperty, isNodeReflectsFirstChildColspan, traverseHiddenNodeColumnIndexes } from "./utils/tree.mjs";
+/**
+ * Collapsing a node is a process where the processing node is collapsed
+ * to the colspan width of the first child. All node children, except the
+ * first one, are hidden. To prevent losing a current state of node children
+ * on the right, all nodes are cloned (and restored while expanding), and
+ * only then original nodes are modified (hidden in this case).
+ *
+ * @param {TreeNode} nodeToProcess A tree node to process.
+ * @returns {object} Returns an object with properties:
+ *                    - rollbackModification: The function that rollbacks
+ *                      the tree to the previous state.
+ *                    - affectedColumns: The list of the visual column
+ *                      indexes which are affected. That list is passed
+ *                      to the hiddens column logic.
+ *                    - colspanCompensation: The number of colspan by
+ *                      which the processed node colspan was reduced.
+ */
+export function collapseNode(nodeToProcess) {
+  var _getFirstChildPropert;
+  var nodeData = nodeToProcess.data,
+    nodeChilds = nodeToProcess.childs;
+  if (nodeData.isCollapsed || nodeData.isHidden || nodeData.origColspan <= 1) {
+    return {
+      rollbackModification: function rollbackModification() {},
+      affectedColumns: [],
+      colspanCompensation: 0
+    };
+  }
+  var isNodeReflected = isNodeReflectsFirstChildColspan(nodeToProcess);
+  if (isNodeReflected) {
+    return collapseNode(nodeChilds[0]);
+  }
+  nodeData.isCollapsed = true;
+  var allLeavesExceptMostLeft = nodeChilds.slice(1);
+  var affectedColumns = new Set();
+  if (allLeavesExceptMostLeft.length > 0) {
+    arrayEach(allLeavesExceptMostLeft, function (node) {
+      traverseHiddenNodeColumnIndexes(node, function (gridColumnIndex) {
+        affectedColumns.add(gridColumnIndex);
+      });
+
+      // Clone the tree to preserve original tree state after header expanding.
+      node.data.clonedTree = node.cloneTree();
+
+      // Hide all leaves except the first leaf on the left (on headers context hide all
+      // headers on the right).
+      node.walkDown(function (_ref) {
+        var data = _ref.data;
+        data.isHidden = true;
+      });
+    });
+  } else {
+    var origColspan = nodeData.origColspan,
+      columnIndex = nodeData.columnIndex;
+
+    // Add column to "affected" started from 1. The header without children can not be
+    // collapsed so the first have to be visible (untouched).
+    for (var i = 1; i < origColspan; i++) {
+      var gridColumnIndex = columnIndex + i;
+      affectedColumns.add(gridColumnIndex);
+    }
+  }
+
+  // Calculate by how many colspan it needs to reduce the headings to match them to
+  // the first child colspan width.
+  var colspanCompensation = nodeData.colspan - ((_getFirstChildPropert = getFirstChildProperty(nodeToProcess, 'colspan')) !== null && _getFirstChildPropert !== void 0 ? _getFirstChildPropert : 1);
+  nodeToProcess.walkUp(function (node) {
+    var data = node.data;
+    data.colspan -= colspanCompensation;
+    if (data.colspan <= 1) {
+      data.colspan = 1;
+      data.isCollapsed = true;
+    } else if (isNodeReflectsFirstChildColspan(node)) {
+      data.isCollapsed = getFirstChildProperty(node, 'isCollapsed');
+    }
+  });
+  return {
+    rollbackModification: function rollbackModification() {
+      return expandNode(nodeToProcess);
+    },
+    affectedColumns: Array.from(affectedColumns),
+    colspanCompensation: colspanCompensation
+  };
+}

package/plugins/nestedHeaders/stateManager/nodeModifiers/expand.js

@@ -0,0 +1,95 @@
+"use strict";
+
+exports.__esModule = true;
+exports.expandNode = expandNode;
+require("core-js/modules/es.array.slice.js");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.set.js");
+require("core-js/modules/es.string.iterator.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+require("core-js/modules/es.array.from.js");
+var _array = require("../../../../helpers/array");
+var _collapse = require("./collapse");
+var _tree = require("./utils/tree");
+/**
+ * Expanding a node is a process where the processing node is expanded to
+ * its original colspan width. To restore an original state of all node
+ * children on the right, the modified nodes are replaced with the cloned
+ * nodes (they were cloned while collapsing).
+ *
+ * @param {TreeNode} nodeToProcess A tree node to process.
+ * @returns {object} Returns an object with properties:
+ *                    - rollbackModification: The function that rollbacks
+ *                      the tree to the previous state.
+ *                    - affectedColumns: The list of the visual column
+ *                      indexes which are affected. That list is passed
+ *                      to the hiddens column logic.
+ *                    - colspanCompensation: The number of colspan by
+ *                      which the processed node colspan was increased.
+ */
+function expandNode(nodeToProcess) {
+  var nodeData = nodeToProcess.data,
+    nodeChilds = nodeToProcess.childs;
+  if (!nodeData.isCollapsed || nodeData.isHidden || nodeData.origColspan <= 1) {
+    return {
+      rollbackModification: function rollbackModification() {},
+      affectedColumns: [],
+      colspanCompensation: 0
+    };
+  }
+  var isNodeReflected = (0, _tree.isNodeReflectsFirstChildColspan)(nodeToProcess);
+  if (isNodeReflected) {
+    return expandNode(nodeChilds[0]);
+  }
+  nodeData.isCollapsed = false;
+  var allLeavesExceptMostLeft = nodeChilds.slice(1);
+  var affectedColumns = new Set();
+  var colspanCompensation = 0;
+  if (allLeavesExceptMostLeft.length > 0) {
+    (0, _array.arrayEach)(allLeavesExceptMostLeft, function (node) {
+      // Restore original state of the collapsed headers.
+      node.replaceTreeWith(node.data.clonedTree);
+      node.data.clonedTree = null;
+      var leafData = node.data;
+
+      // Calculate by how many colspan it needs to increase the headings to match them to
+      // the colspan width of all its children.
+      colspanCompensation += leafData.colspan;
+      (0, _tree.traverseHiddenNodeColumnIndexes)(node, function (gridColumnIndex) {
+        affectedColumns.add(gridColumnIndex);
+      });
+    });
+  } else {
+    var colspan = nodeData.colspan,
+      origColspan = nodeData.origColspan,
+      columnIndex = nodeData.columnIndex;
+
+    // In a case when the node doesn't have any children restore the colspan width to
+    // its original state.
+    colspanCompensation = origColspan - colspan;
+
+    // Add column to "affected" started from 1. The header without children can not be
+    // collapsed so the first column is already visible and we shouldn't touch it.
+    for (var i = 1; i < origColspan; i++) {
+      affectedColumns.add(columnIndex + i);
+    }
+  }
+  nodeToProcess.walkUp(function (node) {
+    var data = node.data;
+    data.colspan += colspanCompensation;
+    if (data.colspan >= data.origColspan) {
+      data.colspan = data.origColspan;
+      data.isCollapsed = false;
+    } else if ((0, _tree.isNodeReflectsFirstChildColspan)(node)) {
+      data.isCollapsed = (0, _tree.getFirstChildProperty)(node, 'isCollapsed');
+    }
+  });
+  return {
+    rollbackModification: function rollbackModification() {
+      return (0, _collapse.collapseNode)(nodeToProcess);
+    },
+    affectedColumns: Array.from(affectedColumns),
+    colspanCompensation: colspanCompensation
+  };
+}

package/plugins/nestedHeaders/stateManager/nodeModifiers/expand.mjs

@@ -0,0 +1,91 @@
+import "core-js/modules/es.array.slice.js";
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.set.js";
+import "core-js/modules/es.string.iterator.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+import "core-js/modules/es.array.from.js";
+import { arrayEach } from "../../../../helpers/array.mjs";
+import { collapseNode } from "./collapse.mjs";
+import { getFirstChildProperty, isNodeReflectsFirstChildColspan, traverseHiddenNodeColumnIndexes } from "./utils/tree.mjs";
+/**
+ * Expanding a node is a process where the processing node is expanded to
+ * its original colspan width. To restore an original state of all node
+ * children on the right, the modified nodes are replaced with the cloned
+ * nodes (they were cloned while collapsing).
+ *
+ * @param {TreeNode} nodeToProcess A tree node to process.
+ * @returns {object} Returns an object with properties:
+ *                    - rollbackModification: The function that rollbacks
+ *                      the tree to the previous state.
+ *                    - affectedColumns: The list of the visual column
+ *                      indexes which are affected. That list is passed
+ *                      to the hiddens column logic.
+ *                    - colspanCompensation: The number of colspan by
+ *                      which the processed node colspan was increased.
+ */
+export function expandNode(nodeToProcess) {
+  var nodeData = nodeToProcess.data,
+    nodeChilds = nodeToProcess.childs;
+  if (!nodeData.isCollapsed || nodeData.isHidden || nodeData.origColspan <= 1) {
+    return {
+      rollbackModification: function rollbackModification() {},
+      affectedColumns: [],
+      colspanCompensation: 0
+    };
+  }
+  var isNodeReflected = isNodeReflectsFirstChildColspan(nodeToProcess);
+  if (isNodeReflected) {
+    return expandNode(nodeChilds[0]);
+  }
+  nodeData.isCollapsed = false;
+  var allLeavesExceptMostLeft = nodeChilds.slice(1);
+  var affectedColumns = new Set();
+  var colspanCompensation = 0;
+  if (allLeavesExceptMostLeft.length > 0) {
+    arrayEach(allLeavesExceptMostLeft, function (node) {
+      // Restore original state of the collapsed headers.
+      node.replaceTreeWith(node.data.clonedTree);
+      node.data.clonedTree = null;
+      var leafData = node.data;
+
+      // Calculate by how many colspan it needs to increase the headings to match them to
+      // the colspan width of all its children.
+      colspanCompensation += leafData.colspan;
+      traverseHiddenNodeColumnIndexes(node, function (gridColumnIndex) {
+        affectedColumns.add(gridColumnIndex);
+      });
+    });
+  } else {
+    var colspan = nodeData.colspan,
+      origColspan = nodeData.origColspan,
+      columnIndex = nodeData.columnIndex;
+
+    // In a case when the node doesn't have any children restore the colspan width to
+    // its original state.
+    colspanCompensation = origColspan - colspan;
+
+    // Add column to "affected" started from 1. The header without children can not be
+    // collapsed so the first column is already visible and we shouldn't touch it.
+    for (var i = 1; i < origColspan; i++) {
+      affectedColumns.add(columnIndex + i);
+    }
+  }
+  nodeToProcess.walkUp(function (node) {
+    var data = node.data;
+    data.colspan += colspanCompensation;
+    if (data.colspan >= data.origColspan) {
+      data.colspan = data.origColspan;
+      data.isCollapsed = false;
+    } else if (isNodeReflectsFirstChildColspan(node)) {
+      data.isCollapsed = getFirstChildProperty(node, 'isCollapsed');
+    }
+  });
+  return {
+    rollbackModification: function rollbackModification() {
+      return collapseNode(nodeToProcess);
+    },
+    affectedColumns: Array.from(affectedColumns),
+    colspanCompensation: colspanCompensation
+  };
+}

package/plugins/nestedHeaders/stateManager/nodeModifiers/hideColumn.js

@@ -0,0 +1,54 @@
+"use strict";
+
+require("core-js/modules/es.array.slice.js");
+require("core-js/modules/es.object.freeze.js");
+exports.__esModule = true;
+exports.hideColumn = hideColumn;
+require("core-js/modules/es.number.is-integer.js");
+require("core-js/modules/es.number.constructor.js");
+require("core-js/modules/es.array.includes.js");
+require("core-js/modules/es.string.includes.js");
+var _templateLiteralTag = require("../../../../helpers/templateLiteralTag");
+var _templateObject;
+function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
+/**
+ * @param {TreeNode} nodeToProcess A tree node to process.
+ * @param {number} gridColumnIndex The visual column index that triggers the node modification.
+ *                                 The index can be between the root node column index and
+ *                                 column index plus node colspan length.
+ */
+function hideColumn(nodeToProcess, gridColumnIndex) {
+  if (!Number.isInteger(gridColumnIndex)) {
+    throw new Error('The passed gridColumnIndex argument has invalid type.');
+  }
+  if (nodeToProcess.childs.length > 0) {
+    throw new Error((0, _templateLiteralTag.toSingleLine)(_templateObject || (_templateObject = _taggedTemplateLiteral(["The passed node is not the last node on the tree. Only for \nthe last node, the hide column modification can be applied."], ["The passed node is not the last node on the tree. Only for\\x20\nthe last node, the hide column modification can be applied."]))));
+  }
+  var crossHiddenColumns = nodeToProcess.data.crossHiddenColumns;
+  if (crossHiddenColumns.includes(gridColumnIndex)) {
+    return;
+  }
+  var isCollapsibleNode = false;
+  nodeToProcess.walkUp(function (node) {
+    var collapsible = node.data.collapsible;
+    if (collapsible) {
+      isCollapsibleNode = true;
+      return false; // Cancel tree traversing
+    }
+  });
+
+  // TODO: When the node is collapsible do not hide the column. Currently collapsible headers
+  // does not work with hidden columns (hidden index map types).
+  if (isCollapsibleNode) {
+    return;
+  }
+  nodeToProcess.walkUp(function (node) {
+    var data = node.data;
+    data.crossHiddenColumns.push(gridColumnIndex);
+    if (data.colspan > 1) {
+      data.colspan -= 1;
+    } else {
+      data.isHidden = true;
+    }
+  });
+}

package/plugins/nestedHeaders/stateManager/nodeModifiers/hideColumn.mjs

@@ -0,0 +1,50 @@
+import "core-js/modules/es.array.slice.js";
+import "core-js/modules/es.object.freeze.js";
+var _templateObject;
+function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
+import "core-js/modules/es.number.is-integer.js";
+import "core-js/modules/es.number.constructor.js";
+import "core-js/modules/es.array.includes.js";
+import "core-js/modules/es.string.includes.js";
+import { toSingleLine } from "../../../../helpers/templateLiteralTag.mjs";
+/**
+ * @param {TreeNode} nodeToProcess A tree node to process.
+ * @param {number} gridColumnIndex The visual column index that triggers the node modification.
+ *                                 The index can be between the root node column index and
+ *                                 column index plus node colspan length.
+ */
+export function hideColumn(nodeToProcess, gridColumnIndex) {
+  if (!Number.isInteger(gridColumnIndex)) {
+    throw new Error('The passed gridColumnIndex argument has invalid type.');
+  }
+  if (nodeToProcess.childs.length > 0) {
+    throw new Error(toSingleLine(_templateObject || (_templateObject = _taggedTemplateLiteral(["The passed node is not the last node on the tree. Only for \nthe last node, the hide column modification can be applied."], ["The passed node is not the last node on the tree. Only for\\x20\nthe last node, the hide column modification can be applied."]))));
+  }
+  var crossHiddenColumns = nodeToProcess.data.crossHiddenColumns;
+  if (crossHiddenColumns.includes(gridColumnIndex)) {
+    return;
+  }
+  var isCollapsibleNode = false;
+  nodeToProcess.walkUp(function (node) {
+    var collapsible = node.data.collapsible;
+    if (collapsible) {
+      isCollapsibleNode = true;
+      return false; // Cancel tree traversing
+    }
+  });
+
+  // TODO: When the node is collapsible do not hide the column. Currently collapsible headers
+  // does not work with hidden columns (hidden index map types).
+  if (isCollapsibleNode) {
+    return;
+  }
+  nodeToProcess.walkUp(function (node) {
+    var data = node.data;
+    data.crossHiddenColumns.push(gridColumnIndex);
+    if (data.colspan > 1) {
+      data.colspan -= 1;
+    } else {
+      data.isHidden = true;
+    }
+  });
+}

package/plugins/nestedHeaders/stateManager/nodeModifiers/index.js

@@ -0,0 +1,40 @@
+"use strict";
+
+exports.__esModule = true;
+exports.triggerNodeModification = triggerNodeModification;
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.map.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.string.iterator.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+var _collapse = require("./collapse");
+var _expand = require("./expand");
+var _hideColumn = require("./hideColumn");
+var _showColumn = require("./showColumn");
+/**
+ * The NodeModifiers module is responsible for the modification of a tree structure
+ * in a way to achieve new column headers state.
+ */
+
+var availableModifiers = new Map([['collapse', _collapse.collapseNode], ['expand', _expand.expandNode], ['hide-column', _hideColumn.hideColumn], ['show-column', _showColumn.showColumn]]);
+
+/**
+ * An entry point for triggering a node modifiers. If the triggered action
+ * does not exist the exception is thrown.
+ *
+ * @param {string} actionName An action name to trigger.
+ * @param {TreeNode} nodeToProcess A tree node to process.
+ * @param {number} gridColumnIndex The visual column index that comes from the nested headers grid.
+ *                                 The index, as opposed to the `columnIndex` in the tree node
+ *                                 (which describes the column index of the root node of the header
+ *                                 element), describes the index passed from the grid. Hence, the
+ *                                 index can be between the column index of the node and its colspan
+ *                                 width.
+ * @returns {object}
+ */
+function triggerNodeModification(actionName, nodeToProcess, gridColumnIndex) {
+  if (!availableModifiers.has(actionName)) {
+    throw new Error("The node modifier action (\"".concat(actionName, "\") does not exist."));
+  }
+  return availableModifiers.get(actionName)(nodeToProcess, gridColumnIndex);
+}

package/plugins/nestedHeaders/stateManager/nodeModifiers/index.mjs

@@ -0,0 +1,35 @@
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.map.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.string.iterator.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+/**
+ * The NodeModifiers module is responsible for the modification of a tree structure
+ * in a way to achieve new column headers state.
+ */
+import { collapseNode } from "./collapse.mjs";
+import { expandNode } from "./expand.mjs";
+import { hideColumn } from "./hideColumn.mjs";
+import { showColumn } from "./showColumn.mjs";
+var availableModifiers = new Map([['collapse', collapseNode], ['expand', expandNode], ['hide-column', hideColumn], ['show-column', showColumn]]);
+
+/**
+ * An entry point for triggering a node modifiers. If the triggered action
+ * does not exist the exception is thrown.
+ *
+ * @param {string} actionName An action name to trigger.
+ * @param {TreeNode} nodeToProcess A tree node to process.
+ * @param {number} gridColumnIndex The visual column index that comes from the nested headers grid.
+ *                                 The index, as opposed to the `columnIndex` in the tree node
+ *                                 (which describes the column index of the root node of the header
+ *                                 element), describes the index passed from the grid. Hence, the
+ *                                 index can be between the column index of the node and its colspan
+ *                                 width.
+ * @returns {object}
+ */
+export function triggerNodeModification(actionName, nodeToProcess, gridColumnIndex) {
+  if (!availableModifiers.has(actionName)) {
+    throw new Error("The node modifier action (\"".concat(actionName, "\") does not exist."));
+  }
+  return availableModifiers.get(actionName)(nodeToProcess, gridColumnIndex);
+}

package/plugins/nestedHeaders/stateManager/nodeModifiers/showColumn.js

@@ -0,0 +1,55 @@
+"use strict";
+
+require("core-js/modules/es.array.slice.js");
+require("core-js/modules/es.object.freeze.js");
+exports.__esModule = true;
+exports.showColumn = showColumn;
+require("core-js/modules/es.number.is-integer.js");
+require("core-js/modules/es.number.constructor.js");
+require("core-js/modules/es.array.includes.js");
+require("core-js/modules/es.string.includes.js");
+require("core-js/modules/es.array.splice.js");
+require("core-js/modules/es.array.index-of.js");
+var _templateLiteralTag = require("../../../../helpers/templateLiteralTag");
+var _templateObject;
+function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
+/**
+ * @param {TreeNode} nodeToProcess A tree node to process.
+ * @param {number} gridColumnIndex The visual column index that triggers the node modification.
+ *                                 The index can be between the root node column index and
+ *                                 column index plus node colspan length.
+ */
+function showColumn(nodeToProcess, gridColumnIndex) {
+  if (!Number.isInteger(gridColumnIndex)) {
+    throw new Error('The passed gridColumnIndex argument has invalid type.');
+  }
+  if (nodeToProcess.childs.length > 0) {
+    throw new Error((0, _templateLiteralTag.toSingleLine)(_templateObject || (_templateObject = _taggedTemplateLiteral(["The passed node is not the last node on the tree. Only for \nthe last node, the show column modification can be applied."], ["The passed node is not the last node on the tree. Only for\\x20\nthe last node, the show column modification can be applied."]))));
+  }
+  var crossHiddenColumns = nodeToProcess.data.crossHiddenColumns;
+  if (!crossHiddenColumns.includes(gridColumnIndex)) {
+    return;
+  }
+  var isCollapsibleNode = false;
+  nodeToProcess.walkUp(function (node) {
+    var collapsible = node.data.collapsible;
+    if (collapsible) {
+      isCollapsibleNode = true;
+      return false; // Cancel tree traversing
+    }
+  });
+
+  // TODO: When the node is collapsible do not show the column. Currently collapsible headers
+  // does not work with hidden columns (hidden index map types).
+  if (isCollapsibleNode) {
+    return;
+  }
+  nodeToProcess.walkUp(function (node) {
+    var data = node.data;
+    data.crossHiddenColumns.splice(data.crossHiddenColumns.indexOf(gridColumnIndex), 1);
+    if (!data.isHidden && data.colspan < data.origColspan) {
+      data.colspan += 1;
+    }
+    data.isHidden = false;
+  });
+}

package/plugins/nestedHeaders/stateManager/nodeModifiers/showColumn.mjs

@@ -0,0 +1,51 @@
+import "core-js/modules/es.array.slice.js";
+import "core-js/modules/es.object.freeze.js";
+var _templateObject;
+function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
+import "core-js/modules/es.number.is-integer.js";
+import "core-js/modules/es.number.constructor.js";
+import "core-js/modules/es.array.includes.js";
+import "core-js/modules/es.string.includes.js";
+import "core-js/modules/es.array.splice.js";
+import "core-js/modules/es.array.index-of.js";
+import { toSingleLine } from "../../../../helpers/templateLiteralTag.mjs";
+/**
+ * @param {TreeNode} nodeToProcess A tree node to process.
+ * @param {number} gridColumnIndex The visual column index that triggers the node modification.
+ *                                 The index can be between the root node column index and
+ *                                 column index plus node colspan length.
+ */
+export function showColumn(nodeToProcess, gridColumnIndex) {
+  if (!Number.isInteger(gridColumnIndex)) {
+    throw new Error('The passed gridColumnIndex argument has invalid type.');
+  }
+  if (nodeToProcess.childs.length > 0) {
+    throw new Error(toSingleLine(_templateObject || (_templateObject = _taggedTemplateLiteral(["The passed node is not the last node on the tree. Only for \nthe last node, the show column modification can be applied."], ["The passed node is not the last node on the tree. Only for\\x20\nthe last node, the show column modification can be applied."]))));
+  }
+  var crossHiddenColumns = nodeToProcess.data.crossHiddenColumns;
+  if (!crossHiddenColumns.includes(gridColumnIndex)) {
+    return;
+  }
+  var isCollapsibleNode = false;
+  nodeToProcess.walkUp(function (node) {
+    var collapsible = node.data.collapsible;
+    if (collapsible) {
+      isCollapsibleNode = true;
+      return false; // Cancel tree traversing
+    }
+  });
+
+  // TODO: When the node is collapsible do not show the column. Currently collapsible headers
+  // does not work with hidden columns (hidden index map types).
+  if (isCollapsibleNode) {
+    return;
+  }
+  nodeToProcess.walkUp(function (node) {
+    var data = node.data;
+    data.crossHiddenColumns.splice(data.crossHiddenColumns.indexOf(gridColumnIndex), 1);
+    if (!data.isHidden && data.colspan < data.origColspan) {
+      data.colspan += 1;
+    }
+    data.isHidden = false;
+  });
+}