ids-enterprise-wc 1.15.9-patch.5 → 1.15.9-patch.7

package/chunks/{ids-chunk-UEVOEMEM-full.js → ids-chunk-HZO4QUAW-full.js}

@@ -34,19 +34,22 @@ import {
 } from "./ids-chunk-3BYETIBG-full.js";
 import {
   IdsDataGridFilters
-} from "./ids-chunk-HGKIZXDQ-full.js";
+} from "./ids-chunk-RLOOHWYV-full.js";
 import {
   IdsDataGridFormatters
 } from "./ids-chunk-34MMRVVB-full.js";
 import {
   IdsDataGridHeader
-} from "./ids-chunk-7URDZKCS-full.js";
+} from "./ids-chunk-7IP7SLQZ-full.js";
 import {
   IdsDataGridRow
-} from "./ids-chunk-LZU34NYE-full.js";
+} from "./ids-chunk-CSOF2USI-full.js";
 import {
   IdsDataGridCell
-} from "./ids-chunk-FW4DOBQU-full.js";
+} from "./ids-chunk-FPEINRXY-full.js";
+import {
+  DEFAULT_COLUMN_MIN_WIDTH
+} from "./ids-chunk-4MSGTAOV-full.js";
 import {
   containerArguments,
   containerTypes
@@ -2688,7 +2691,7 @@ var Base = ids_pager_mixin_default(
     )
   )
 );
-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_fn, attachDragSelection_fn, createSelectionBorder_fn, updateSelectionBorder_fn, attachCopyPasteCellHandlers_fn, attachKeyboardListeners_fn, 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_fn, attachDragSelection_fn, createSelectionBorder_fn, updateSelectionBorder_fn, attachCopyPasteCellHandlers_fn, attachKeyboardListeners_fn, 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 Base {
   constructor() {
     super();
@@ -3655,7 +3658,8 @@ var IdsDataGrid = class extends Base {
       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;
@@ -3665,6 +3669,7 @@ var IdsDataGrid = class extends Base {
       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);
       }
@@ -3672,6 +3677,82 @@ var IdsDataGrid = class extends Base {
       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
@@ -4763,7 +4844,11 @@ var IdsDataGrid = class extends Base {
     this.activeCell.cell = Number(cellNumber);
     this.activeCell.row = Number(rowIndex);
     const currentCell = this.cellByIndex(rowIndex, cellNumber);
-    this.updateActiveCellCache(rowIndex, cellNumber, currentCell?.value);
+    if (reason === "redraw") {
+      this.clearActiveCellCache();
+    } else {
+      this.updateActiveCellCache(rowIndex, cellNumber, currentCell?.value, true);
+    }
     let rowNode = this.rowByIndex(rowIndex);
     if (!rowNode && this.virtualScroll) {
       const setActiveCellData = {
@@ -5317,15 +5402,20 @@ var IdsDataGrid = class extends Base {
    * @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
@@ -5816,7 +5906,13 @@ attachKeyboardListeners_fn = function() {
       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);
@@ -5838,26 +5934,60 @@ attachKeyboardListeners_fn = function() {
     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;
+    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 firstRow = this.rowByIndex(0);
       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?.();
@@ -5963,8 +6093,44 @@ attachKeyboardListeners_fn = function() {
     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();
@@ -5996,7 +6162,98 @@ attachKeyboardListeners_fn = function() {
     }
   });
   this.offEvent("keydown.body", this.header);
-  this.onEvent("keydown.body", this.header, () => {
+  this.onEvent("keydown.body", this.header, (e) => {
+    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);
@@ -6540,6 +6797,73 @@ scrollRowIntoView_fn = function(rowIndex, doScroll = true) {
     __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;
@@ -6909,7 +7233,7 @@ saveEditedCellsBeforeScroll_fn = function() {
     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();
   }
@@ -6948,7 +7272,8 @@ restoreActiveCellAfterScroll_fn = function() {
   const {
     rowIndex,
     columnIndex,
-    currentValue
+    currentValue,
+    wasEditing
   } = __privateGet(this, _activeCellCache);
   if (rowIndex < 0 || rowIndex >= this.data.length || columnIndex < 0 || columnIndex >= this.visibleColumns.length) {
     return;
@@ -6960,7 +7285,9 @@ restoreActiveCellAfterScroll_fn = function() {
   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;
@@ -6969,15 +7296,12 @@ restoreActiveCellAfterScroll_fn = function() {
     __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;
@@ -7038,4 +7362,4 @@ IdsDataGrid = __decorateClass([
 export {
   IdsDataGrid
 };
-//# sourceMappingURL=ids-chunk-UEVOEMEM-full.js.map
+//# sourceMappingURL=ids-chunk-HZO4QUAW-full.js.map