ids-enterprise-wc 1.15.9-patch.6 → 1.15.9-patch.8

package/enterprise-wc.all.iife.js

@@ -78111,32 +78111,28 @@ ids-trigger-button[slot=trigger-end] {
      * @returns {IdsDataGridCell | null} the cell above this cell
      */
     get cellAbove() {
-      return this.rowAbove?.cellByIndex(this.columnIndex) ?? null;
+      return this.dataGrid?.findNextNavigableCell(this, "up" /* Up */) ?? null;
     }
     /**
      * Get the cell below this cell
      * @returns {IdsDataGridCell | null} the cell below this cell
      */
     get cellBelow() {
-      return this.rowBelow?.cellByIndex(this.columnIndex) ?? null;
+      return this.dataGrid?.findNextNavigableCell(this, "down" /* Down */) ?? null;
     }
     /**
      * Get the cell to the left of this cell
      * @returns {IdsDataGridCell | null} the cell to the left of this cell
      */
     get cellLeft() {
-      const cellLeft = this.dataGrid?.rowByIndex(this.rowIndex)?.cellByIndex(this.columnIndex - 1);
-      if (cellLeft && cellLeft !== this) return cellLeft;
-      return this.rowAbove?.cellByIndex(this.dataGrid?.columns.length ?? 0) ?? null;
+      return this.dataGrid?.findNextNavigableCell(this, "left" /* Left */) ?? null;
     }
     /**
      * Get the cell to the right of this cell
      * @returns {IdsDataGridCell | null} the cell to the right of this cell
      */
     get cellRight() {
-      const cellRight = this.dataGrid?.rowByIndex(this.rowIndex)?.cellByIndex(this.columnIndex + 1) ?? null;
-      if (cellRight && cellRight !== this) return cellRight;
-      return this.rowBelow?.cellByIndex(0) ?? null;
+      return this.dataGrid?.findNextNavigableCell(this, "right" /* Right */) ?? null;
     }
     /**
      * Get the next editable cell to the left of this cell
@@ -78750,7 +78746,7 @@ ids-trigger-button[slot=trigger-end] {
       });
     }
     this.onEvent("keyup", this.editor?.input, () => {
-      this.dataGrid.updateActiveCellCache(this.row, this.columnIndex, this.editor?.input?.value || "");
+      this.dataGrid.updateActiveCellCache(this.row, this.columnIndex, this.editor?.input?.value || "", true);
     });
     this.onEvent("keydown", this.editor?.input, (e) => {
       if (e.key === "Enter") {
@@ -80516,6 +80512,9 @@ ids-trigger-button[slot=trigger-end] {
     }
   }
 
+  // src/components/ids-data-grid/ids-data-grid-column.ts
+  var DEFAULT_COLUMN_MIN_WIDTH = 12;
+
   // src/components/ids-data-grid/ids-data-grid-empty-message.ts
   function emptyMessageDefaults() {
     return {
@@ -84257,6 +84256,16 @@ ids-loading-indicator[stopped] {
       columnIndex = Math.min(columnIndex, maxColumnIndex);
       return cells[columnIndex] ?? null;
     }
+    /**
+     * Get the cell HTMLElement by logical column index (accounting for rowspan)
+     * @param {number} logicalColumnIndex the zero-based logical column index
+     * @returns {IdsDataGridCell} html element for cell
+     */
+    cellByLogicalIndex(logicalColumnIndex) {
+      const columnId = this.dataGrid.visibleColumns[logicalColumnIndex]?.id;
+      if (!columnId) return null;
+      return this.querySelector(`ids-data-grid-cell[aria-colindex="${logicalColumnIndex + 1}"]`) ?? null;
+    }
     /**
      * Is this row currently expanded
      * @returns {boolean} true if expanded
@@ -87928,7 +87937,7 @@ ids-icon {
       )
     )
   );
-  var _activeCellCache, _editedCellsCache, _startSelectionCell, _endSelectionCell, _currentScroll, _afterSetActiveCellFn, _header, _IdsDataGrid_instances, redrawBodyTemplate_fn, _lastSelectedRow, _initiallySelectedRow, _lastShiftedRow, resetLastSelectedRow_fn, resetInitiallySelectedRow_fn, resetLastShiftedRow_fn, toggleShiftSelectionInBetween_fn, getSelection_fn, attachEventHandlers_fn41, attachDragSelection_fn, createSelectionBorder_fn, updateSelectionBorder_fn, attachCopyPasteCellHandlers_fn, attachKeyboardListeners_fn9, setColumnWidths_fn, setFrozenColumnWidth_fn, calcMaxContentWidth_fn, reapplyDirtyStates_fn, setColumnGroupsWidth_fn, appendMissingRows_fn, _virtualScrollMaxRowsInDom, attachScrollEvents_fn, attachVirtualScrollEvent_fn, calculateColumnsOnscreen_fn, detachScrollEvents_fn, syncTreeHiddenStates_fn, handleTreeRowExpandCollapse_fn, recycleAllTreeRows_fn, handleVirtualScroll_fn, _customScrollEventCache, triggerCustomScrollEvent_fn, positionVirtualScrollWindow_fn, restoreScrollPosition_fn, scrollTo_fn, scrollToTreeRow_fn, scrollRowIntoView_fn, setVirtualScrollPaddingBottom_fn, scrollTreeRowIntoView_fn, recycleTreeRowsDown_fn, recycleTreeRowsUp_fn, recycleAllRows_fn, recycleTopRowsDown_fn, recycleBottomRowsUp_fn, saveCellOriginalValue_fn, updateCellDirtyState_fn, findParentRow_fn, findRootRow_fn, updateRowCount_fn, applyAutoFit_fn, removeAttachedMenus_fn, filterColumnList_fn, handleCopy_fn, handlePaste_fn, saveEditedCellsBeforeScroll_fn, restoreActiveCellAfterScroll_fn, restoreEditedCellsAfterScroll_fn;
+  var _activeCellCache, _editedCellsCache, _startSelectionCell, _endSelectionCell, _currentScroll, _afterSetActiveCellFn, _header, _IdsDataGrid_instances, redrawBodyTemplate_fn, _lastSelectedRow, _initiallySelectedRow, _lastShiftedRow, resetLastSelectedRow_fn, resetInitiallySelectedRow_fn, resetLastShiftedRow_fn, toggleShiftSelectionInBetween_fn, getSelection_fn, attachEventHandlers_fn41, attachDragSelection_fn, createSelectionBorder_fn, updateSelectionBorder_fn, attachCopyPasteCellHandlers_fn, attachKeyboardListeners_fn9, setColumnWidths_fn, setFrozenColumnWidth_fn, calcMaxContentWidth_fn, reapplyDirtyStates_fn, setColumnGroupsWidth_fn, appendMissingRows_fn, _virtualScrollMaxRowsInDom, attachScrollEvents_fn, attachVirtualScrollEvent_fn, calculateColumnsOnscreen_fn, detachScrollEvents_fn, syncTreeHiddenStates_fn, handleTreeRowExpandCollapse_fn, recycleAllTreeRows_fn, handleVirtualScroll_fn, _customScrollEventCache, triggerCustomScrollEvent_fn, positionVirtualScrollWindow_fn, restoreScrollPosition_fn, scrollTo_fn, scrollToTreeRow_fn, scrollRowIntoView_fn, getVisibleRowIndex_fn, findNextVisibleRow_fn, scrollToActivateRow_fn, ensureRowInViewport_fn, setVirtualScrollPaddingBottom_fn, scrollTreeRowIntoView_fn, recycleTreeRowsDown_fn, recycleTreeRowsUp_fn, recycleAllRows_fn, recycleTopRowsDown_fn, recycleBottomRowsUp_fn, saveCellOriginalValue_fn, updateCellDirtyState_fn, findParentRow_fn, findRootRow_fn, updateRowCount_fn, applyAutoFit_fn, removeAttachedMenus_fn, filterColumnList_fn, handleCopy_fn, handlePaste_fn, saveEditedCellsBeforeScroll_fn, restoreActiveCellAfterScroll_fn, restoreEditedCellsAfterScroll_fn;
   var IdsDataGrid = class extends Base68 {
     constructor() {
       super();
@@ -88895,7 +88904,8 @@ ids-icon {
         if (this.activeCellEditor) {
           const rowIndex = this.activeCell.row;
           const cell = this.activeCell.cell;
-          this.updateActiveCellCache(rowIndex, cell, __privateGet(this, _activeCellCache)?.currentValue || "");
+          const activeNode = this.activeCell.node;
+          this.updateActiveCellCache(rowIndex, cell, __privateGet(this, _activeCellCache)?.currentValue || "", activeNode?.isEditing);
         }
         if (__privateGet(this, _activeCellCache)) {
           __privateGet(this, _activeCellCache).shouldReinstateCell = true;
@@ -88905,6 +88915,7 @@ ids-icon {
         this.resetCache();
         if (this.treeGrid) {
           __privateMethod(this, _IdsDataGrid_instances, recycleAllTreeRows_fn).call(this, Math.floor(this.container.scrollTop / this.virtualScrollSettings.ROW_HEIGHT));
+          __privateMethod(this, _IdsDataGrid_instances, restoreActiveCellAfterScroll_fn).call(this);
         } else {
           __privateMethod(this, _IdsDataGrid_instances, appendMissingRows_fn).call(this);
         }
@@ -88912,6 +88923,82 @@ ids-icon {
         this.data = this.data.concat(value);
       }
     }
+    /**
+     * Find a cell by logical position, accounting for rowspan
+     * @param {number} rowIndex the row index
+     * @param {number} columnIndex the logical column index
+     * @returns {IdsDataGridCell | null} the cell at the logical position
+     */
+    findCellByLogicalPosition(rowIndex, columnIndex) {
+      if (rowIndex < 0 || rowIndex >= this.data.length) return null;
+      if (columnIndex < 0 || columnIndex >= this.visibleColumns.length) return null;
+      if (this.treeGrid && this.data[rowIndex]?.rowHidden) return null;
+      const row = this.rowByIndex(rowIndex);
+      if (!row) return null;
+      const columnId = this.visibleColumns[columnIndex]?.id;
+      if (!columnId) return null;
+      return row.cellByLogicalIndex?.(columnIndex) ?? row.cellByIndex(columnIndex) ?? null;
+    }
+    /**
+     * Find the next navigable cell in a given direction
+     * @param {IdsDataGridCell} currentCell the current cell
+     * @param {IdsDirection} direction the navigation direction
+     * @returns {IdsDataGridCell | null} the next navigable cell
+     */
+    findNextNavigableCell(currentCell, direction) {
+      const currentRowIndex = currentCell.rowIndex;
+      const currentColumnIndex = currentCell.columnIndex;
+      switch (direction) {
+        case "up" /* Up */: {
+          if (currentRowIndex === 0) return null;
+          for (let targetRowIndex = currentRowIndex - 1; targetRowIndex >= 0; targetRowIndex--) {
+            const cell = this.findCellByLogicalPosition(targetRowIndex, currentColumnIndex);
+            if (cell) return cell;
+          }
+          return null;
+        }
+        case "down" /* Down */: {
+          if (currentRowIndex >= this.data.length - 1) return null;
+          const currentRowData = this.data[currentRowIndex];
+          const columnId = this.visibleColumns[currentColumnIndex]?.id;
+          const currentSpan = currentRowData?.rowspan?.[columnId] || 1;
+          const startRowIndex = currentRowIndex + currentSpan;
+          for (let targetRowIndex = startRowIndex; targetRowIndex < this.data.length; targetRowIndex++) {
+            const cell = this.findCellByLogicalPosition(targetRowIndex, currentColumnIndex);
+            if (cell) return cell;
+          }
+          return null;
+        }
+        case "left" /* Left */: {
+          for (let colIndex = currentColumnIndex - 1; colIndex >= 0; colIndex--) {
+            const cell = this.findCellByLogicalPosition(currentRowIndex, colIndex);
+            if (cell && cell !== currentCell) return cell;
+          }
+          if (currentRowIndex > 0) {
+            for (let colIndex = this.visibleColumns.length - 1; colIndex >= 0; colIndex--) {
+              const cell = this.findCellByLogicalPosition(currentRowIndex - 1, colIndex);
+              if (cell) return cell;
+            }
+          }
+          return null;
+        }
+        case "right" /* Right */: {
+          for (let colIndex = currentColumnIndex + 1; colIndex < this.visibleColumns.length; colIndex++) {
+            const cell = this.findCellByLogicalPosition(currentRowIndex, colIndex);
+            if (cell && cell !== currentCell) return cell;
+          }
+          if (currentRowIndex < this.data.length - 1) {
+            for (let colIndex = 0; colIndex < this.visibleColumns.length; colIndex++) {
+              const cell = this.findCellByLogicalPosition(currentRowIndex + 1, colIndex);
+              if (cell) return cell;
+            }
+          }
+          return null;
+        }
+        default:
+          return null;
+      }
+    }
     /**
      * Set the data of the data grid
      * @param {Array} value The array to use
@@ -90006,7 +90093,7 @@ ids-icon {
       if (reason === "redraw") {
         this.clearActiveCellCache();
       } else {
-        this.updateActiveCellCache(rowIndex, cellNumber, currentCell?.value);
+        this.updateActiveCellCache(rowIndex, cellNumber, currentCell?.value, true);
       }
       let rowNode = this.rowByIndex(rowIndex);
       if (!rowNode && this.virtualScroll) {
@@ -90561,15 +90648,20 @@ ids-icon {
      * @param {number} row - The row index
      * @param {number} cell - The cell index
      * @param {string} cellValue - The current cell value
+     * @param {boolean} isEditing - Whether the cell is currently in edit mode
      */
-    updateActiveCellCache(row, cell, cellValue) {
-      __privateSet(this, _activeCellCache, {
+    updateActiveCellCache(row, cell, cellValue, isEditing) {
+      const cacheUpdate = {
         rowIndex: row,
         columnIndex: cell,
         currentValue: cellValue,
         hasLeaveViewport: false,
         shouldReinstateCell: true
-      });
+      };
+      if (isEditing !== void 0) {
+        cacheUpdate.wasEditing = isEditing;
+      }
+      __privateSet(this, _activeCellCache, cacheUpdate);
     }
     /**
      * Clears the active cell cache, optionally checking if the cached row is within viewport
@@ -91060,7 +91152,13 @@ ids-icon {
         if (e.key === "ArrowDown") newRowIndex = 1;
         if (e.key === "ArrowRight") newColIndex = 1;
         if (e.key === "ArrowLeft") newColIndex = -1;
-        __privateGet(this, _activeCellCache).rowIndex = Math.max(__privateGet(this, _activeCellCache).rowIndex + newRowIndex, 0);
+        if (this.treeGrid && newRowIndex !== 0) {
+          const direction = newRowIndex === 1 ? "down" /* Down */ : "up" /* Up */;
+          const nextRowIndex = __privateMethod(this, _IdsDataGrid_instances, findNextVisibleRow_fn).call(this, __privateGet(this, _activeCellCache).rowIndex, direction);
+          __privateGet(this, _activeCellCache).rowIndex = nextRowIndex !== -1 ? nextRowIndex : __privateGet(this, _activeCellCache).rowIndex;
+        } else {
+          __privateGet(this, _activeCellCache).rowIndex = Math.max(__privateGet(this, _activeCellCache).rowIndex + newRowIndex, 0);
+        }
         __privateGet(this, _activeCellCache).columnIndex = Math.max(__privateGet(this, _activeCellCache).columnIndex + newColIndex, 0);
         requestAnimationTimeout(() => {
           __privateMethod(this, _IdsDataGrid_instances, restoreActiveCellAfterScroll_fn).call(this);
@@ -91076,32 +91174,68 @@ ids-icon {
       if (!activeCell) {
         const firstRow = this.rowByIndex(0);
         activeCell = firstRow?.cellByIndex(0) ?? null;
-        activeCell.activate(false, "keyboard");
+        activeCell?.activate(false, "keyboard");
       }
       if (activeCell?.isEditing) return;
       e.preventDefault();
       e.stopPropagation();
       const previousActiveRow = Number(activeCell?.rowIndex || 0);
-      if (key === "ArrowUp") activeCell = activeCell?.cellAbove ?? null;
-      else if (key === "ArrowDown") activeCell = activeCell?.cellBelow ?? null;
-      else if (key === "ArrowLeft" && !e.metaKey) activeCell = activeCell?.cellLeft ?? null;
-      else if (key === "ArrowRight" && !e.metaKey) activeCell = activeCell?.cellRight ?? null;
-      else if (key === "PageUp") {
-        const firstRow = this.rowByIndex(0);
+      if (key === "ArrowUp") {
+        if (activeCell?.rowIndex === 0) {
+          const columnIndex = activeCell?.columnIndex ?? 0;
+          const headerCell = this.header?.querySelector(`[aria-colindex="${columnIndex + 1}"][tabindex="0"]`);
+          if (headerCell) {
+            headerCell.setAttribute(attributes.TABINDEX, "0");
+            this.header?.querySelectorAll(".ids-data-grid-header-cell").forEach((cell) => {
+              cell.classList.remove("is-focused");
+            });
+            headerCell.focus();
+            return;
+          }
+        }
+        const prevCell = activeCell;
+        activeCell = this.findNextNavigableCell(activeCell, "up" /* Up */);
+        if (!activeCell && this.virtualScroll && prevCell && prevCell.rowIndex > 0) {
+          const nextRowIndex = __privateMethod(this, _IdsDataGrid_instances, findNextVisibleRow_fn).call(this, prevCell.rowIndex, "up" /* Up */);
+          if (nextRowIndex !== -1) {
+            __privateMethod(this, _IdsDataGrid_instances, scrollToActivateRow_fn).call(this, nextRowIndex, prevCell.columnIndex, "up" /* Up */);
+            return;
+          }
+        }
+        if (this.virtualScroll && activeCell) {
+          __privateMethod(this, _IdsDataGrid_instances, ensureRowInViewport_fn).call(this, activeCell.rowIndex, "up" /* Up */);
+        }
+      } else if (key === "ArrowDown") {
+        const prevCell = activeCell;
+        activeCell = this.findNextNavigableCell(activeCell, "down" /* Down */);
+        if (!activeCell && this.virtualScroll && prevCell && prevCell.rowIndex < this.data.length - 1) {
+          const nextRowIndex = __privateMethod(this, _IdsDataGrid_instances, findNextVisibleRow_fn).call(this, prevCell.rowIndex, "down" /* Down */);
+          if (nextRowIndex !== -1) {
+            __privateMethod(this, _IdsDataGrid_instances, scrollToActivateRow_fn).call(this, nextRowIndex, prevCell.columnIndex, "down" /* Down */);
+            return;
+          }
+        }
+        if (this.virtualScroll && activeCell) {
+          __privateMethod(this, _IdsDataGrid_instances, ensureRowInViewport_fn).call(this, activeCell.rowIndex, "down" /* Down */);
+        }
+      } else if (key === "ArrowLeft" && !e.metaKey) {
+        activeCell = this.findNextNavigableCell(activeCell, "left" /* Left */);
+      } else if (key === "ArrowRight" && !e.metaKey) {
+        activeCell = this.findNextNavigableCell(activeCell, "right" /* Right */);
+      } else if (key === "PageUp") {
         const columnIndex = activeCell?.columnIndex ?? 0;
-        activeCell = firstRow?.cellByIndex(columnIndex) ?? null;
+        activeCell = this.findCellByLogicalPosition(0, columnIndex);
       } else if (key === "PageDown") {
         const lastRowIndex = this.data.length - 1;
-        const lastRow = this.rowByIndex(lastRowIndex);
         const columnIndex = activeCell?.columnIndex ?? 0;
-        activeCell = lastRow?.cellByIndex(columnIndex) ?? null;
+        activeCell = this.findCellByLogicalPosition(lastRowIndex, columnIndex);
       } else if (key === "Home" || key === "ArrowLeft" && e.metaKey) {
-        const currentRow = this.rowByIndex(activeCell?.rowIndex ?? 0);
-        activeCell = currentRow?.cellByIndex(0) ?? null;
+        const currentRowIndex = activeCell?.rowIndex ?? 0;
+        activeCell = this.findCellByLogicalPosition(currentRowIndex, 0);
       } else if (key === "End" || key === "ArrowRight" && e.metaKey) {
-        const currentRow = this.rowByIndex(activeCell?.rowIndex ?? 0);
-        const lastColumnIndex = this.columns.length - 1;
-        activeCell = currentRow?.cellByIndex(lastColumnIndex) ?? null;
+        const currentRowIndex = activeCell?.rowIndex ?? 0;
+        const lastColumnIndex = this.visibleColumns.length - 1;
+        activeCell = this.findCellByLogicalPosition(currentRowIndex, lastColumnIndex);
       }
       const activeRowIndex = activeCell?.rowIndex ?? previousActiveRow;
       activeCell?.focus?.();
@@ -91145,7 +91279,7 @@ ids-icon {
       if (this.openMenu) return;
       if (activeCell.isEditing) return;
       if (!activeCell.canClose()) return;
-      const row = this.rowByIndex(activeCell.row);
+      const row = this.rowByIndex(activeCell.rowIndex);
       if (!row || row.disabled) return;
       const button = activeCell.querySelector("ids-button");
       if (button) {
@@ -91207,8 +91341,44 @@ ids-icon {
       if (!this.isEditable) {
         return;
       }
-      const nextCell = e.shiftKey ? this.activeCell?.node?.cellLeftEditable : this.activeCell?.node?.cellRightEditable;
+      let nextCell = e.shiftKey ? this.activeCell?.node?.cellLeftEditable : this.activeCell?.node?.cellRightEditable;
+      while (nextCell && nextCell.hasAttribute?.("hidden")) {
+        nextCell = e.shiftKey ? nextCell?.cellLeftEditable : nextCell?.cellRightEditable;
+      }
       if (!nextCell) {
+        if (!e.shiftKey && this.addNewAtEnd && this.activeCell?.node) {
+          const currentRowIndex = this.activeCell.node.rowIndex;
+          const isLastRow = currentRowIndex === this.data.length - 1;
+          if (isLastRow) {
+            e.stopImmediatePropagation();
+            e.stopPropagation();
+            e.preventDefault();
+            const newRowData = {};
+            this.visibleColumns.forEach((column) => {
+              if (column.field && column.field !== "selectionCheckbox" && column.field !== "selectionRadio") {
+                newRowData[column.field] = "";
+              }
+            });
+            this.addRow(newRowData);
+            requestAnimationFrame(() => {
+              const newRowIndex = this.data.length - 1;
+              const newRow = this.rowByIndex(newRowIndex);
+              if (newRow) {
+                const firstEditableCell = newRow.querySelector(".is-editable:not(.is-readonly):not(.is-disabled)");
+                if (firstEditableCell) {
+                  const columnIndex = firstEditableCell.columnIndex;
+                  this.setActiveCell(columnIndex, newRowIndex, false, "keyboard");
+                  if (this.editNextOnEnterPress) {
+                    firstEditableCell.startCellEdit?.();
+                  } else {
+                    firstEditableCell.focus?.();
+                  }
+                }
+              }
+            });
+            return;
+          }
+        }
         return;
       }
       e.stopImmediatePropagation();
@@ -91240,7 +91410,105 @@ ids-icon {
       }
     });
     this.offEvent("keydown.body", this.header);
-    this.onEvent("keydown.body", this.header, () => {
+    this.onEvent("keydown.body", this.header, (e) => {
+      const path = eventPath(e);
+      const inFilter = findInPath(path, ".ids-data-grid-header-cell-filter-wrapper");
+      const target = e.target;
+      const isEditable = inFilter || target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement || target?.isContentEditable || findInPath(path, "ids-input");
+      if (isEditable) {
+        return;
+      }
+      if (e.key === "ArrowUp") {
+        e.preventDefault();
+        e.stopPropagation();
+        return;
+      }
+      if (e.key === "ArrowDown") {
+        e.preventDefault();
+        e.stopPropagation();
+        const focusedHeaderCell = e.target;
+        const columnIndexAttr = focusedHeaderCell.getAttribute("aria-colindex");
+        if (columnIndexAttr) {
+          const columnIndex = parseInt(columnIndexAttr) - 1;
+          const firstRow = this.rowByIndex(0);
+          if (firstRow) {
+            const targetCell = firstRow.cellByIndex(columnIndex);
+            if (targetCell) {
+              this.setActiveCell(columnIndex, 0, false, "keyboard");
+              targetCell.focus();
+              return;
+            }
+          }
+        }
+      }
+      if (e.key === "ArrowLeft" || e.key === "ArrowRight") {
+        const focusedHeaderCell = e.target;
+        const columnIndexAttr = focusedHeaderCell.getAttribute("aria-colindex");
+        if (e.shiftKey && columnIndexAttr) {
+          e.preventDefault();
+          e.stopPropagation();
+          const columnId = focusedHeaderCell.getAttribute("column-id");
+          if (columnId) {
+            const column = this.columnDataById(columnId);
+            if (column && column.resizable) {
+              const RESIZE_INCREMENT = 5;
+              const DEFAULT_COLUMNSIZE = 110;
+              const currentWidth = typeof column.width === "number" ? column.width : DEFAULT_COLUMNSIZE;
+              const proposedWidth = e.key === "ArrowRight" ? currentWidth + RESIZE_INCREMENT : currentWidth - RESIZE_INCREMENT;
+              const minWidth = column.minWidth || DEFAULT_COLUMN_MIN_WIDTH;
+              const maxWidth = column.maxWidth || Number.MAX_SAFE_INTEGER;
+              const newWidth = Math.max(minWidth, Math.min(maxWidth, proposedWidth));
+              if (newWidth !== currentWidth) {
+                this.setColumnWidth(columnId, newWidth);
+                let columnText = this.localeAPI?.translate("ColumnResizeAria");
+                columnText = columnText.replace("{0}", column.name).replace("{1}", newWidth);
+                focusedHeaderCell.setAttribute("aria-label", columnText);
+              }
+            }
+          }
+          return;
+        }
+        e.preventDefault();
+        e.stopPropagation();
+        if (columnIndexAttr) {
+          const currentColumnIndex = parseInt(columnIndexAttr) - 1;
+          const nextColumnIndex = e.key === "ArrowRight" ? currentColumnIndex + 1 : currentColumnIndex - 1;
+          if (nextColumnIndex >= 0 && nextColumnIndex < this.visibleColumns.length) {
+            const nextHeaderCell = this.header?.querySelector(`[aria-colindex="${nextColumnIndex + 1}"][tabindex="0"]`);
+            if (nextHeaderCell) {
+              nextHeaderCell.focus();
+              return;
+            }
+          }
+        }
+      }
+      if (e.key === " " || e.key === "Space") {
+        const focusedHeaderCell = e.target;
+        if (focusedHeaderCell.hasAttribute("tabindex") && focusedHeaderCell.classList.contains("ids-data-grid-header-cell")) {
+          e.preventDefault();
+          e.stopPropagation();
+          const headerCheckbox = focusedHeaderCell.querySelector(".ids-data-grid-checkbox");
+          if (headerCheckbox) {
+            if (headerCheckbox.classList.contains("checked") || headerCheckbox.classList.contains("indeterminate")) {
+              this.deSelectAllRows();
+            } else {
+              this.selectAllRows();
+            }
+          }
+          const columnCheckbox = focusedHeaderCell.querySelector(".ids-checkbox input");
+          if (columnCheckbox) {
+            const checkbox = columnCheckbox;
+            checkbox.checked = !checkbox.checked;
+            const columnIndex = parseInt(focusedHeaderCell.getAttribute("aria-colindex") || "1") - 1;
+            if (checkbox.checked) {
+              this.selectColumn(columnIndex);
+            } else {
+              this.deSelectColumn(columnIndex);
+            }
+          }
+          return;
+        }
+      }
       this.activeCell = {};
     });
     this.offEvent("keydown.body", this);
@@ -91784,6 +92052,73 @@ ids-icon {
       __privateMethod(this, _IdsDataGrid_instances, restoreEditedCellsAfterScroll_fn).call(this);
     }
   };
+  /**
+   * Convert data row index to visible row index for tree grids
+   * @param {number} rowIndex - The data row index
+   * @returns {number} The visible row index, or -1 if row is hidden
+   * @private
+   */
+  getVisibleRowIndex_fn = function(rowIndex) {
+    if (!this.treeGrid) return rowIndex;
+    return this.virtualRows.findIndex((row) => row === this.data[rowIndex]);
+  };
+  /**
+   * Find the next non-hidden row index in the specified direction
+   * @param {number} startRowIndex - The starting data row index
+   * @param {IdsDirection} direction - The navigation direction (Up or Down)
+   * @returns {number} The next non-hidden row index, or -1 if none found
+   * @private
+   */
+  findNextVisibleRow_fn = function(startRowIndex, direction) {
+    const step = direction === "down" /* Down */ ? 1 : -1;
+    let nextRowIndex = startRowIndex + step;
+    while (nextRowIndex >= 0 && nextRowIndex < this.data.length && this.treeGrid && this.data[nextRowIndex]?.rowHidden) {
+      nextRowIndex += step;
+    }
+    return nextRowIndex >= 0 && nextRowIndex < this.data.length ? nextRowIndex : -1;
+  };
+  /**
+   * Scroll to bring a row into view and activate its cell
+   * @param {number} nextRowIndex - The data row index to bring into view
+   * @param {number} columnIndex - The column index of the cell to activate
+   * @param {IdsDirection} direction - The navigation direction (Up or Down)
+   * @private
+   */
+  scrollToActivateRow_fn = function(nextRowIndex, columnIndex, direction) {
+    if (nextRowIndex < 0 || nextRowIndex >= this.data.length) return;
+    const visibleRowIndex = __privateMethod(this, _IdsDataGrid_instances, getVisibleRowIndex_fn).call(this, nextRowIndex);
+    if (visibleRowIndex === -1) return;
+    const { ROW_HEIGHT } = this.virtualScrollSettings;
+    const containerHeight = this.container.clientHeight;
+    const headerHeight = this.header?.clientHeight ?? 0;
+    const targetScrollTop = direction === "down" /* Down */ ? (visibleRowIndex + 1) * ROW_HEIGHT - containerHeight + headerHeight : visibleRowIndex * ROW_HEIGHT;
+    this.container.scrollTop = Math.max(targetScrollTop, 0);
+    requestAnimationFrame(() => {
+      const activeCell = this.findCellByLogicalPosition(nextRowIndex, columnIndex);
+      if (activeCell) {
+        activeCell.focus();
+        this.setActiveCell(activeCell.columnIndex, activeCell.rowIndex, false, "keyboard");
+      }
+    });
+  };
+  ensureRowInViewport_fn = function(rowIndex, direction) {
+    if (!this.virtualScroll || !this.container) return;
+    const { ROW_HEIGHT } = this.virtualScrollSettings;
+    const containerHeight = this.container.clientHeight;
+    const headerHeight = this.header?.clientHeight ?? 0;
+    const scrollTop = this.container.scrollTop;
+    const viewportTop = scrollTop;
+    const viewportBottom = scrollTop + containerHeight - headerHeight;
+    const effectiveRowIndex = __privateMethod(this, _IdsDataGrid_instances, getVisibleRowIndex_fn).call(this, rowIndex);
+    if (effectiveRowIndex === -1) return;
+    const rowTop = effectiveRowIndex * ROW_HEIGHT;
+    const rowBottom = rowTop + ROW_HEIGHT;
+    if (direction === "up" /* Up */ && rowTop < viewportTop) {
+      this.container.scrollTop = rowTop;
+    } else if (direction === "down" /* Down */ && rowBottom > viewportBottom) {
+      this.container.scrollTop = rowBottom - containerHeight + headerHeight;
+    }
+  };
   setVirtualScrollPaddingBottom_fn = function(settings, totalRows, offsetTop) {
     const maxHeight = totalRows * settings.ROW_HEIGHT;
     const paddingBottom = maxHeight - settings.MAX_ROWS_IN_DOM * settings.ROW_HEIGHT - offsetTop;
@@ -92153,7 +92488,7 @@ ids-icon {
       editedCells.push(this.activeCell?.node);
       const activeCell = this.activeCell.node;
       const currentValue = activeCell.editor?.input?.value || "";
-      this.updateActiveCellCache(this.activeCell.row, this.activeCell.cell, currentValue);
+      this.updateActiveCellCache(this.activeCell.row, this.activeCell.cell, currentValue, true);
       __privateGet(this, _activeCellCache).shouldReinstateCell = true;
       this.commitCellEdit();
     }
@@ -92186,14 +92521,14 @@ ids-icon {
    * @private
    */
   restoreActiveCellAfterScroll_fn = function() {
-    const isHeaderActive = this.header && this.header.activeColumn >= 0;
-    if (!__privateGet(this, _activeCellCache) || !__privateGet(this, _activeCellCache)?.shouldReinstateCell || isHeaderActive) {
+    if (!__privateGet(this, _activeCellCache) || !__privateGet(this, _activeCellCache)?.shouldReinstateCell) {
       return;
     }
     const {
       rowIndex,
       columnIndex,
-      currentValue
+      currentValue,
+      wasEditing
     } = __privateGet(this, _activeCellCache);
     if (rowIndex < 0 || rowIndex >= this.data.length || columnIndex < 0 || columnIndex >= this.visibleColumns.length) {
       return;
@@ -92205,7 +92540,9 @@ ids-icon {
     const scrollTop = this.container?.scrollTop || 0;
     const containerHeight = this.container?.clientHeight || 0;
     const rowHeight = this.virtualScrollSettings.ROW_HEIGHT;
-    const rowTop = rowIndex * rowHeight;
+    const effectiveRowIndex = __privateMethod(this, _IdsDataGrid_instances, getVisibleRowIndex_fn).call(this, rowIndex);
+    if (effectiveRowIndex === -1) return;
+    const rowTop = effectiveRowIndex * rowHeight;
     const rowBottom = rowTop + rowHeight;
     const viewportTop = scrollTop;
     const viewportBottom = scrollTop + containerHeight;
@@ -92214,15 +92551,12 @@ ids-icon {
       __privateGet(this, _activeCellCache).hasLeaveViewport = true;
       return;
     }
-    if (!__privateGet(this, _activeCellCache).hasLeaveViewport) {
-      return;
-    }
     const cellElement = this.cellByIndex(rowIndex, columnIndex);
     if (!cellElement) {
       return;
     }
     this.setActiveCell(columnIndex, rowIndex, false, "internal");
-    if (cellElement.column?.editor) {
+    if (wasEditing === true && cellElement.column?.editor) {
       cellElement.startCellEdit();
       if (cellElement.editor?.input) {
         cellElement.editor.input.value = currentValue;