@salt-ds/data-grid 0.0.0-snapshot-20230620094559

package/dist-cjs/Grid.js

@@ -0,0 +1,1026 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var core = require('@salt-ds/core');
+var window = require('@salt-ds/window');
+var styles = require('@salt-ds/styles');
+var clsx = require('clsx');
+require('./internal/Cell.js');
+var CellMeasure = require('./internal/CellMeasure.js');
+require('./internal/Cursor.js');
+require('./internal/GroupHeaderRow.js');
+require('./internal/HeaderRow.js');
+var LeftPart = require('./internal/LeftPart.js');
+var MiddlePart = require('./internal/MiddlePart.js');
+var RightPart = require('./internal/RightPart.js');
+var Scrollable = require('./internal/Scrollable.js');
+require('./internal/TableRow.js');
+var utils = require('./internal/utils.js');
+var SelectionContext = require('./SelectionContext.js');
+var EditorContext = require('./EditorContext.js');
+var CursorContext = require('./CursorContext.js');
+var gridHooks = require('./internal/gridHooks.js');
+var TopLeftPart = require('./internal/TopLeftPart.js');
+var TopPart = require('./internal/TopPart.js');
+var TopRightPart = require('./internal/TopRightPart.js');
+require('./internal/DefaultCellValue.js');
+var GridContext = require('./GridContext.js');
+var SizingContext = require('./SizingContext.js');
+var LayoutContext = require('./LayoutContext.js');
+var ColumnDragContext = require('./ColumnDragContext.js');
+var ColumnGhost = require('./internal/ColumnGhost.js');
+var ColumnDropTarget = require('./internal/ColumnDropTarget.js');
+var ColumnDataContext = require('./ColumnDataContext.js');
+var ColumnSortContext = require('./ColumnSortContext.js');
+var Grid$1 = require('./Grid.css.js');
+
+const withBaseName = core.makePrefixer("saltGrid");
+var SortOrder = /* @__PURE__ */ ((SortOrder2) => {
+  SortOrder2["ASC"] = "asc";
+  SortOrder2["DESC"] = "desc";
+  SortOrder2["NONE"] = "none";
+  return SortOrder2;
+})(SortOrder || {});
+function defaultRowKeyGetter(row, index) {
+  return `${index}`;
+}
+const Grid = function Grid2(props) {
+  var _a, _b, _c;
+  const {
+    rowData,
+    zebra,
+    hideHeader,
+    columnSeparators,
+    pinnedSeparators = true,
+    className,
+    style,
+    rowKeyGetter = defaultRowKeyGetter,
+    children,
+    defaultSelectedRowIdxs,
+    selectedRowIdxs,
+    variant = "primary",
+    rowSelectionMode = "multi",
+    onRowSelected,
+    columnMove,
+    onColumnMoved,
+    cellSelectionMode = "none",
+    onVisibleRowRangeChange,
+    headerIsFocusable,
+    getRowValidationStatus
+  } = props;
+  const targetWindow = window.useWindow();
+  styles.useComponentCssInjection({
+    testId: "salt-grid",
+    css: Grid$1,
+    window: targetWindow
+  });
+  const rootRef = react.useRef(null);
+  const scrollableRef = react.useRef(null);
+  const middleRef = react.useRef(null);
+  const topRef = react.useRef(null);
+  const leftRef = react.useRef(null);
+  const rightRef = react.useRef(null);
+  const bottomRef = react.useRef(null);
+  const [scrollSource, setScrollSource] = react.useState("user");
+  const [scrollLeft, setScrollLeft] = react.useState(0);
+  const [scrollTop, setScrollTop] = react.useState(0);
+  const [hoverRowKey, setHoverRowKey] = react.useState(void 0);
+  const [
+    { clientWidth, clientHeight, scrollBarHeight, scrollBarWidth },
+    setDimensions
+  ] = react.useState({
+    clientWidth: 0,
+    clientHeight: 0,
+    scrollBarHeight: 0,
+    scrollBarWidth: 0
+  });
+  const [rowHeight, setRowHeight] = react.useState(0);
+  const [cursorRowIdx, setCursorRowIdx] = react.useState(0);
+  const [cursorColIdx, setCursorColIdx] = react.useState(0);
+  const [focusedPart, setFocusedPart] = react.useState(
+    headerIsFocusable ? "header" : "body"
+  );
+  const [sortByColumnId, setSortByColumnId] = react.useState("");
+  const [sortOrder, setSortOrder] = react.useState("none" /* NONE */);
+  const [editMode, setEditMode] = react.useState(false);
+  const [initialText, setInitialText] = react.useState(void 0);
+  const resizeClient = react.useCallback(
+    (dimensions) => {
+      setDimensions(dimensions);
+    },
+    []
+  );
+  const {
+    leftCols,
+    midCols,
+    rightCols,
+    leftGroups,
+    midGroups,
+    rightGroups,
+    contextValue
+  } = gridHooks.useColumnRegistry(children);
+  const midColsById = react.useMemo(
+    () => new Map(
+      midCols.map((c) => [c.info.props.id, c])
+    ),
+    [midCols]
+  );
+  const leftWidth = gridHooks.useSumWidth(leftCols);
+  const midWidth = gridHooks.useSumWidth(midCols);
+  const rightWidth = gridHooks.useSumWidth(rightCols);
+  const totalWidth = gridHooks.useSum([leftWidth, midWidth, rightWidth]);
+  const hasColumnGroups = leftGroups.length > 0 || midGroups.length > 0 || rightGroups.length > 0;
+  const headRowCount = hideHeader ? 0 : hasColumnGroups ? 2 : 1;
+  const rowCount = rowData.length;
+  const botRowCount = 0;
+  const topHeight = rowHeight * headRowCount;
+  const midHeight = rowCount === 0 ? 0 : rowHeight * rowCount + 1;
+  const botHeight = botRowCount * rowHeight;
+  const totalHeight = gridHooks.useSum([topHeight, midHeight, botHeight]);
+  const clientMidWidth = gridHooks.useClientMidWidth(clientWidth, leftWidth, rightWidth);
+  const midGap = Math.max(0, Math.floor(clientMidWidth - midWidth));
+  const bodyVisColRng = gridHooks.useBodyVisibleColumnRange(
+    midCols,
+    scrollLeft,
+    clientMidWidth
+  );
+  const midGrpByColId = react.useMemo(() => {
+    const m = /* @__PURE__ */ new Map();
+    for (const g of midGroups) {
+      for (const c of g.childrenIds) {
+        m.set(c, g);
+      }
+    }
+    return m;
+  }, [midGroups]);
+  const visColGrpRng = gridHooks.useVisibleColumnGroupRange(
+    bodyVisColRng,
+    midCols,
+    midGrpByColId,
+    leftGroups.length
+  );
+  const visColGrps = react.useMemo(() => {
+    return midGroups.slice(visColGrpRng.start, visColGrpRng.end);
+  }, [visColGrpRng, midGroups]);
+  const headVisColRng = gridHooks.useHeadVisibleColumnRange(
+    bodyVisColRng,
+    visColGrps,
+    midColsById,
+    leftCols.length
+  );
+  const bodyScrOutColWh = gridHooks.useLeftScrolledOutWidth(midCols, bodyVisColRng);
+  const headScrOutColWh = gridHooks.useLeftScrolledOutWidth(midCols, headVisColRng);
+  const bodyVisAreaLeft = gridHooks.useSum([leftWidth, bodyScrOutColWh]);
+  const headVisAreaLeft = gridHooks.useSum([leftWidth, headScrOutColWh]);
+  const clientMidHeight = gridHooks.useClientMidHeight(
+    clientHeight,
+    topHeight,
+    botHeight
+  );
+  const visRowRng = gridHooks.useVisibleRowRange(
+    scrollTop,
+    clientMidHeight,
+    rowHeight,
+    rowCount
+  );
+  const bodyVisAreaTop = gridHooks.useBodyVisibleAreaTop(rowHeight, visRowRng, topHeight);
+  const bodyVisibleColumns = gridHooks.useColumnRange(midCols, bodyVisColRng);
+  const headVisibleColumns = gridHooks.useColumnRange(midCols, headVisColRng);
+  const bodyVisColWh = gridHooks.useSumRangeWidth(midCols, bodyVisColRng);
+  const headVisColWh = bodyVisColWh;
+  const rootStyle = react.useMemo(
+    () => ({
+      ...style,
+      "--grid-total-width": `${totalWidth}px`,
+      "--grid-total-height": `${totalHeight}px`,
+      "--grid-topPart-height": `${topHeight}px`,
+      "--grid-leftPart-width": `${leftWidth}px`,
+      "--grid-rightPart-width": `${rightWidth}px`,
+      "--grid-bodyVisibleColumns-width": `${bodyVisColWh}px`,
+      "--grid-bodyVisibleArea-top": `${bodyVisAreaTop}px`,
+      "--grid-bodyVisibleArea-left": `${bodyVisAreaLeft}px`,
+      "--grid-bottomHeight": `${botHeight}px`,
+      "--grid-headerVisibleColumns-width": `${headVisColWh}px`,
+      "--grid-headerVisibleArea-left": `${headVisAreaLeft}px`,
+      "--grid-scrollBar-height": `${scrollBarHeight}px`,
+      "--grid-scrollBar-width": `${scrollBarWidth}px`
+    }),
+    [
+      style,
+      totalHeight,
+      totalWidth,
+      topHeight,
+      leftWidth,
+      rightWidth,
+      botHeight,
+      bodyVisColWh,
+      bodyVisAreaLeft,
+      bodyVisAreaTop,
+      headVisColWh,
+      headVisAreaLeft,
+      scrollBarHeight,
+      scrollBarWidth
+    ]
+  );
+  const onWheel = react.useCallback(
+    (event) => {
+      let { deltaX, deltaY, shiftKey } = event;
+      if (deltaX === 0 && shiftKey) {
+        deltaX = deltaY;
+        deltaY = 0;
+      }
+      const s = scrollableRef.current;
+      if (s) {
+        s.scrollLeft += deltaX;
+        s.scrollTop += deltaY;
+      }
+      event.preventDefault();
+      event.stopPropagation();
+    },
+    [scrollableRef.current]
+  );
+  const cols = react.useMemo(
+    () => [...leftCols, ...midCols, ...rightCols],
+    [leftCols, midCols, rightCols]
+  );
+  const colsById = react.useMemo(
+    () => new Map(
+      cols.map((c) => [c.info.props.id, c])
+    ),
+    [cols]
+  );
+  const getColById = react.useCallback(
+    (id) => {
+      return colsById.get(id);
+    },
+    [colsById]
+  );
+  const columnDataContext = react.useMemo(
+    () => ({
+      getColById
+    }),
+    [getColById]
+  );
+  const isSortMode = sortByColumnId && sortOrder !== "none" /* NONE */;
+  const onSortOrderChange = (_a = getColById(sortByColumnId)) == null ? void 0 : _a.info.props.onSortOrderChange;
+  const valueGetter = ((_b = getColById(sortByColumnId)) == null ? void 0 : _b.info.props.getValue) || ((r) => {
+    return r[sortByColumnId];
+  });
+  const customSortingFn = (_c = getColById(sortByColumnId)) == null ? void 0 : _c.info.props.customSort;
+  const sortedRowData = react.useMemo(() => {
+    if (!isSortMode || onSortOrderChange)
+      return rowData;
+    if (customSortingFn) {
+      return customSortingFn({ rowData, sortOrder });
+    }
+    const sortedData = [...rowData].sort(
+      (a, b) => valueGetter(a) < valueGetter(b) ? -1 : 1
+    );
+    if (sortOrder === "desc" /* DESC */) {
+      return sortedData.reverse();
+    }
+    return sortedData;
+  }, [
+    onSortOrderChange,
+    valueGetter,
+    customSortingFn,
+    isSortMode,
+    rowData,
+    sortByColumnId,
+    sortOrder
+  ]);
+  const onClickSortColumn = react.useCallback(
+    (colHeaderId) => {
+      if (sortByColumnId === colHeaderId) {
+        switch (sortOrder) {
+          case "asc" /* ASC */:
+            setSortOrder("desc" /* DESC */);
+            break;
+          case "desc" /* DESC */:
+            setSortOrder("none" /* NONE */);
+            break;
+          default:
+            setSortOrder("asc" /* ASC */);
+        }
+      } else {
+        setSortByColumnId(colHeaderId);
+        setSortOrder("asc" /* ASC */);
+      }
+    },
+    [sortByColumnId, sortOrder]
+  );
+  const columnSortContext = react.useMemo(
+    () => ({
+      sortByColumnId,
+      setSortByColumnId,
+      sortOrder,
+      setSortOrder,
+      onClickSortColumn
+    }),
+    [
+      sortByColumnId,
+      setSortByColumnId,
+      sortOrder,
+      setSortOrder,
+      onClickSortColumn
+    ]
+  );
+  const scroll = react.useCallback(
+    (left, top, source) => {
+      setScrollSource(source || "user");
+      if (left !== void 0) {
+        setScrollLeft(left);
+      }
+      if (top !== void 0) {
+        setScrollTop(top);
+      }
+    },
+    [setScrollLeft, setScrollTop, setScrollSource]
+  );
+  const scrollToCell = gridHooks.useScrollToCell(
+    visRowRng,
+    rowHeight,
+    clientMidHeight,
+    midCols,
+    bodyVisColRng,
+    clientMidWidth,
+    scroll
+  );
+  const focusCellElement = (part, rowIdx, colIdx) => {
+    setTimeout(() => {
+      var _a2;
+      const selector = part === "body" ? `td[data-row-index="${rowIdx}"][data-column-index="${colIdx}"]` : `th[data-column-index="${colIdx}"]`;
+      const nodeToFocus = (_a2 = rootRef.current) == null ? void 0 : _a2.querySelector(selector);
+      if (nodeToFocus) {
+        nodeToFocus.focus({ preventScroll: true });
+      } else {
+        console.warn(`focusCellElement can't find the element`);
+      }
+    }, 0);
+  };
+  const startEditMode = (text) => {
+    if (editMode || cursorRowIdx == void 0 || cursorColIdx == void 0) {
+      return;
+    }
+    const c = cols[cursorColIdx];
+    const isEditable = !!contextValue.getEditor(c.info.props.id);
+    if (isEditable) {
+      setInitialText(text);
+      setEditMode(true);
+    }
+  };
+  const endEditMode = (value) => {
+    if (!editMode) {
+      return;
+    }
+    if (cursorColIdx == void 0) {
+      console.error(`endEditMode: cursorColIdx is undefined in edit mode`);
+      return;
+    }
+    const c = cols[cursorColIdx];
+    const handler = c.info.props.onChange;
+    if (cursorRowIdx == void 0) {
+      console.error(`endEditMode: cursorRowIdx is undefined in edit mode`);
+      return;
+    }
+    if (!handler) {
+      console.warn(
+        `onChange is not specified for editable column "${c.info.props.id}".`
+      );
+    } else {
+      handler(sortedRowData[cursorRowIdx], cursorRowIdx, value);
+    }
+    setEditMode(false);
+    focusCellElement(focusedPart, cursorRowIdx, cursorColIdx);
+  };
+  const cancelEditMode = () => {
+    if (!editMode) {
+      return;
+    }
+    setEditMode(false);
+    if (cursorRowIdx != null && cursorColIdx != null) {
+      focusCellElement(focusedPart, cursorRowIdx, cursorColIdx);
+    }
+  };
+  const {
+    selRowIdxs,
+    isAllSelected,
+    isAnySelected,
+    selectAll,
+    selectRows,
+    unselectAll,
+    onMouseDown: onRowSelectionMouseDown
+  } = gridHooks.useRowSelection(
+    rowKeyGetter,
+    sortedRowData,
+    defaultSelectedRowIdxs,
+    selectedRowIdxs,
+    rowSelectionMode,
+    onRowSelected
+  );
+  const rangeSelection = gridHooks.useRangeSelection(cellSelectionMode);
+  const moveCursor = react.useCallback(
+    (part, rowIdx, colIdx) => {
+      if (!headerIsFocusable && part === "header") {
+        console.warn(
+          `Cannot move focus to the header. "headerIsFocusable" prop is false.`
+        );
+        return;
+      }
+      setFocusedPart(part);
+      colIdx = utils.clamp(colIdx, 0, cols.length - 1);
+      if (part === "body") {
+        if (sortedRowData.length < 1 || cols.length < 1) {
+          return;
+        }
+        rowIdx = utils.clamp(rowIdx, 0, sortedRowData.length - 1);
+      } else if (part === "header") {
+        rowIdx = 0;
+      }
+      setCursorRowIdx(rowIdx);
+      setCursorColIdx(colIdx);
+      scrollToCell(part, rowIdx, colIdx);
+      focusCellElement(part, rowIdx, colIdx);
+      if (part === "body") {
+        rangeSelection.onCursorMove({ rowIdx, colIdx });
+      }
+    },
+    [
+      setCursorRowIdx,
+      setCursorColIdx,
+      sortedRowData,
+      rowKeyGetter,
+      cols,
+      rootRef.current,
+      scrollToCell,
+      endEditMode,
+      rangeSelection.onCursorMove,
+      focusedPart,
+      headerIsFocusable
+    ]
+  );
+  const rows = gridHooks.useRowModels(rowKeyGetter, sortedRowData, visRowRng);
+  const isLeftRaised = scrollLeft > 0;
+  const isRightRaised = scrollLeft + clientMidWidth < midWidth;
+  const isHeaderRaised = scrollTop > 0;
+  const resizeColumn = react.useCallback(
+    (colIdx, width) => {
+      const col = cols[colIdx];
+      col.info.onWidthChanged(width);
+    },
+    [cols]
+  );
+  const onResizeHandleMouseDown = gridHooks.useColumnResize(cols, resizeColumn);
+  const sizingContext = react.useMemo(
+    () => ({
+      resizeColumn,
+      rowHeight,
+      onResizeHandleMouseDown
+    }),
+    [resizeColumn, rowHeight, onResizeHandleMouseDown]
+  );
+  const layoutContext = react.useMemo(
+    () => ({
+      totalHeight,
+      totalWidth,
+      clientWidth,
+      clientHeight
+    }),
+    [totalHeight, totalWidth]
+  );
+  const editorContext = react.useMemo(
+    () => ({
+      initialText,
+      editMode,
+      startEditMode,
+      endEditMode,
+      cancelEditMode
+    }),
+    [editMode, startEditMode, endEditMode, cancelEditMode, initialText]
+  );
+  const [isFocused, setFocused] = react.useState(false);
+  const onFocus = react.useCallback(
+    (event) => {
+      setFocused(true);
+    },
+    [setFocused]
+  );
+  const onBlur = react.useCallback(
+    (event) => {
+      setFocused(false);
+    },
+    [setFocused]
+  );
+  const cursorContext = react.useMemo(
+    () => ({
+      isFocused,
+      cursorRowIdx,
+      cursorColIdx,
+      moveCursor,
+      focusedPart,
+      headerIsFocusable: Boolean(headerIsFocusable)
+    }),
+    [
+      cursorRowIdx,
+      cursorColIdx,
+      moveCursor,
+      isFocused,
+      focusedPart,
+      headerIsFocusable
+    ]
+  );
+  const onColumnMove = (columnId, fromIndex, toIndex) => {
+    if (onColumnMoved && fromIndex !== toIndex) {
+      onColumnMoved(columnId, fromIndex, toIndex);
+    }
+  };
+  const {
+    dragState,
+    onColumnMoveHandleMouseDown,
+    activeTarget,
+    onColumnMoveCancel
+  } = gridHooks.useColumnMove(
+    columnMove,
+    rootRef,
+    leftCols,
+    midCols,
+    rightCols,
+    cols,
+    scrollLeft,
+    clientMidWidth,
+    onColumnMove
+  );
+  const columnDragContext = react.useMemo(
+    () => ({
+      columnMove,
+      onColumnMoveHandleMouseDown
+    }),
+    [columnMove, onColumnMoveHandleMouseDown]
+  );
+  const onMouseDown = (event) => {
+    onRowSelectionMouseDown(event);
+    rangeSelection.onCellMouseDown(event);
+    const target = event.target;
+    try {
+      const { part, rowIndex, columnIndex } = utils.getFocusablePosition(target);
+      if (part === "header" && !headerIsFocusable) {
+        return;
+      }
+      moveCursor(part, rowIndex, columnIndex);
+    } catch (e) {
+    }
+  };
+  const onKeyUp = react.useCallback(
+    (event) => {
+      const { key } = event;
+      if (key === "Shift") {
+        rangeSelection.onKeyboardRangeSelectionEnd();
+      }
+    },
+    [rangeSelection.onKeyboardRangeSelectionEnd]
+  );
+  const editModeKeyHandler = react.useCallback(
+    (event) => {
+      const { key } = event;
+      switch (key) {
+        case "F2":
+        case "Enter":
+          startEditMode();
+          break;
+        case "Backspace":
+          startEditMode("");
+          break;
+        case "Escape":
+          if (editMode) {
+            cancelEditMode();
+            break;
+          } else {
+            return false;
+          }
+        default:
+          if (!editMode && !event.ctrlKey && !event.metaKey && !event.altKey && /^[\w\d ]$/.test(key)) {
+            startEditMode(key);
+          } else {
+            return false;
+          }
+      }
+      event.preventDefault();
+      event.stopPropagation();
+      return true;
+    },
+    [startEditMode, editMode, cancelEditMode]
+  );
+  const selectionKeyHandler = react.useCallback(
+    (event) => {
+      const { key } = event;
+      switch (key) {
+        case "Shift":
+          rangeSelection.onKeyboardRangeSelectionStart({
+            rowIdx: cursorRowIdx || 0,
+            colIdx: cursorColIdx || 0
+          });
+          break;
+        case " ":
+          if (focusedPart === "body") {
+            if (event.ctrlKey) {
+              if (cursorColIdx != void 0) {
+                rangeSelection.selectRange({
+                  start: { rowIdx: 0, colIdx: cursorColIdx },
+                  end: { rowIdx: sortedRowData.length, colIdx: cursorColIdx }
+                });
+              }
+            } else {
+              if (cursorRowIdx != void 0) {
+                selectRows({
+                  rowIndex: cursorRowIdx,
+                  isRange: false,
+                  incremental: true,
+                  unselectOtherRows: !event.shiftKey
+                });
+              }
+            }
+            break;
+          } else {
+            return false;
+          }
+        case "a":
+          if (event.ctrlKey || event.metaKey) {
+            rangeSelection.selectRange({
+              start: { rowIdx: 0, colIdx: 0 },
+              end: { rowIdx: sortedRowData.length, colIdx: cols.length }
+            });
+            selectAll();
+            return true;
+          } else {
+            return false;
+          }
+        default:
+          return false;
+      }
+      event.preventDefault();
+      event.stopPropagation();
+      return true;
+    },
+    [
+      rangeSelection.selectRange,
+      rangeSelection.onKeyboardRangeSelectionStart,
+      selectRows,
+      selectAll,
+      cursorColIdx,
+      cursorRowIdx,
+      sortedRowData.length,
+      cols.length,
+      focusedPart
+    ]
+  );
+  const clipboardKeyHandler = react.useCallback(
+    (event) => {
+      const { key } = event;
+      if (key === "c" && (event.ctrlKey || event.metaKey) && rangeSelection.selectedCellRange) {
+        const { start, end } = rangeSelection.selectedCellRange;
+        const c = (x, y) => x - y;
+        const [minRow, maxRow] = [start.rowIdx, end.rowIdx].sort(c);
+        const [minCol, maxCol] = [start.colIdx, end.colIdx].sort(c);
+        const text = [];
+        for (let r = minRow; r <= maxRow; ++r) {
+          const row = sortedRowData[r];
+          const rowText = [];
+          for (let c2 = minCol; c2 <= maxCol; ++c2) {
+            const col = cols[c2];
+            const cellValue = col.info.props.getValue(row);
+            rowText.push(cellValue);
+          }
+          text.push(rowText.join("	"));
+        }
+        navigator.clipboard.writeText(text.join("\n"));
+        event.preventDefault();
+        event.stopPropagation();
+        return true;
+      }
+      return false;
+    },
+    [rangeSelection.selectedCellRange]
+  );
+  const pageSize = Math.max(1, visRowRng.length - 1);
+  const navigationKeyHandler = react.useCallback(
+    (event) => {
+      const { key } = event;
+      switch (key) {
+        case "ArrowLeft":
+          moveCursor(focusedPart, cursorRowIdx, (cursorColIdx || 0) - 1);
+          break;
+        case "ArrowRight":
+          moveCursor(focusedPart, cursorRowIdx, (cursorColIdx || 0) + 1);
+          break;
+        case "ArrowUp":
+          if (cursorRowIdx === 0 && headerIsFocusable) {
+            moveCursor("header", 0, cursorColIdx);
+          } else {
+            moveCursor(focusedPart, (cursorRowIdx || 0) - 1, cursorColIdx);
+          }
+          break;
+        case "ArrowDown":
+          if (focusedPart === "header") {
+            moveCursor("body", 0, cursorColIdx);
+          } else {
+            moveCursor(focusedPart, (cursorRowIdx || 0) + 1, cursorColIdx);
+          }
+          break;
+        case "PageUp":
+          if (cursorRowIdx === 0 && headerIsFocusable) {
+            moveCursor("header", 0, cursorColIdx);
+          } else {
+            moveCursor(
+              focusedPart,
+              (cursorRowIdx || 0) - pageSize,
+              cursorColIdx
+            );
+          }
+          break;
+        case "PageDown":
+          if (focusedPart === "header") {
+            moveCursor("body", 0, cursorColIdx);
+          } else {
+            moveCursor(
+              focusedPart,
+              (cursorRowIdx || 0) + pageSize,
+              cursorColIdx
+            );
+          }
+          break;
+        case "Home":
+          if (!event.ctrlKey) {
+            moveCursor(focusedPart, cursorRowIdx, 0);
+          } else {
+            moveCursor(focusedPart, 0, 0);
+          }
+          break;
+        case "End":
+          if (!event.ctrlKey) {
+            moveCursor(focusedPart, cursorRowIdx, cols.length - 1);
+          } else {
+            moveCursor(focusedPart, sortedRowData.length - 1, cols.length - 1);
+          }
+          break;
+        case "Tab":
+          if (!event.ctrlKey && !event.metaKey && !event.altKey && editMode && cursorColIdx != null && cursorRowIdx != null) {
+            if (!event.shiftKey) {
+              if (cursorColIdx < cols.length - 1) {
+                moveCursor(focusedPart, cursorRowIdx, cursorColIdx + 1);
+              } else {
+                if (cursorRowIdx < sortedRowData.length - 1) {
+                  moveCursor(focusedPart, cursorRowIdx + 1, 0);
+                }
+              }
+            } else {
+              if (cursorColIdx > 0) {
+                moveCursor(focusedPart, cursorRowIdx, cursorColIdx - 1);
+              } else {
+                if (cursorRowIdx > 0) {
+                  moveCursor(focusedPart, cursorRowIdx - 1, cols.length - 1);
+                }
+              }
+            }
+          } else {
+            return false;
+          }
+          break;
+        case "Enter":
+          if (editMode && !event.ctrlKey && !event.metaKey && !event.altKey && !event.shiftKey) {
+            if (cursorRowIdx == void 0) {
+              moveCursor(focusedPart, 0, 0);
+            } else {
+              moveCursor(focusedPart, cursorRowIdx + 1, cursorColIdx);
+            }
+          } else {
+            return false;
+          }
+          break;
+        default:
+          return false;
+      }
+      event.preventDefault();
+      event.stopPropagation();
+      return true;
+    },
+    [
+      moveCursor,
+      cursorRowIdx,
+      cursorRowIdx,
+      cols.length,
+      sortedRowData.length,
+      headerIsFocusable,
+      pageSize
+    ]
+  );
+  const columnMoveKeyHandler = react.useCallback(
+    (event) => {
+      const { key } = event;
+      if (key === "Escape") {
+        onColumnMoveCancel();
+        event.preventDefault();
+        event.stopPropagation();
+        return true;
+      }
+      return false;
+    },
+    []
+  );
+  const onKeyDown = react.useCallback(
+    (event) => {
+      if (cursorColIdx != void 0 && cursorRowIdx != void 0) {
+        const column = cols[cursorColIdx];
+        if (column.info.props.onKeyDown) {
+          column.info.props.onKeyDown(event, cursorRowIdx);
+        }
+      }
+      if (!event.isPropagationStopped()) {
+        [
+          navigationKeyHandler,
+          clipboardKeyHandler,
+          selectionKeyHandler,
+          editModeKeyHandler,
+          columnMoveKeyHandler
+        ].find((handler) => {
+          return handler(event);
+        });
+      }
+    },
+    [
+      navigationKeyHandler,
+      clipboardKeyHandler,
+      selectionKeyHandler,
+      editModeKeyHandler,
+      columnMoveKeyHandler
+    ]
+  );
+  const selectionContext = react.useMemo(
+    () => ({
+      selRowIdxs,
+      selectRows,
+      isAllSelected,
+      isAnySelected,
+      selectAll,
+      unselectAll,
+      selectedCellRange: rangeSelection == null ? void 0 : rangeSelection.selectedCellRange
+    }),
+    [
+      selRowIdxs,
+      selectRows,
+      isAllSelected,
+      isAnySelected,
+      selectAll,
+      unselectAll,
+      rangeSelection == null ? void 0 : rangeSelection.selectedCellRange
+    ]
+  );
+  react.useEffect(() => {
+    if (onVisibleRowRangeChange) {
+      onVisibleRowRangeChange(visRowRng.start, visRowRng.end);
+    }
+  }, [onVisibleRowRangeChange, visRowRng]);
+  return /* @__PURE__ */ jsxRuntime.jsx(GridContext.GridContext.Provider, {
+    value: contextValue,
+    children: /* @__PURE__ */ jsxRuntime.jsx(LayoutContext.LayoutContext.Provider, {
+      value: layoutContext,
+      children: /* @__PURE__ */ jsxRuntime.jsx(SelectionContext.SelectionContext.Provider, {
+        value: selectionContext,
+        children: /* @__PURE__ */ jsxRuntime.jsx(ColumnDragContext.ColumnDragContext.Provider, {
+          value: columnDragContext,
+          children: /* @__PURE__ */ jsxRuntime.jsx(CursorContext.CursorContext.Provider, {
+            value: cursorContext,
+            children: /* @__PURE__ */ jsxRuntime.jsx(SizingContext.SizingContext.Provider, {
+              value: sizingContext,
+              children: /* @__PURE__ */ jsxRuntime.jsx(EditorContext.EditorContext.Provider, {
+                value: editorContext,
+                children: /* @__PURE__ */ jsxRuntime.jsx(ColumnDataContext.ColumnDataContext.Provider, {
+                  value: columnDataContext,
+                  children: /* @__PURE__ */ jsxRuntime.jsxs(ColumnSortContext.ColumnSortContext.Provider, {
+                    value: columnSortContext,
+                    children: [
+                      props.children,
+                      /* @__PURE__ */ jsxRuntime.jsxs("div", {
+                        className: clsx.clsx(
+                          withBaseName(),
+                          {
+                            [withBaseName("zebra")]: zebra,
+                            [withBaseName("columnSeparators")]: columnSeparators,
+                            [withBaseName("pinnedSeparators")]: pinnedSeparators,
+                            [withBaseName("primaryBackground")]: variant === "primary",
+                            [withBaseName("secondaryBackground")]: variant === "secondary"
+                          },
+                          className
+                        ),
+                        style: rootStyle,
+                        ref: rootRef,
+                        onKeyDown,
+                        onKeyUp,
+                        onMouseDown,
+                        onFocus,
+                        onBlur,
+                        "data-name": "grid-root",
+                        role: "grid",
+                        "aria-colcount": cols.length,
+                        "aria-rowcount": rowCount + headRowCount,
+                        "aria-multiselectable": rowSelectionMode === "multi",
+                        children: [
+                          /* @__PURE__ */ jsxRuntime.jsx(CellMeasure.CellMeasure, {
+                            setRowHeight
+                          }),
+                          /* @__PURE__ */ jsxRuntime.jsx(Scrollable.Scrollable, {
+                            resizeClient,
+                            scrollLeft,
+                            scrollTop,
+                            scrollSource,
+                            scroll,
+                            scrollerRef: scrollableRef,
+                            topRef,
+                            rightRef,
+                            bottomRef,
+                            leftRef,
+                            middleRef
+                          }),
+                          !hideHeader && leftCols.length > 0 && /* @__PURE__ */ jsxRuntime.jsx(TopLeftPart.TopLeftPart, {
+                            onWheel,
+                            columns: leftCols,
+                            columnGroups: leftGroups,
+                            rightShadow: isLeftRaised,
+                            bottomShadow: isHeaderRaised
+                          }),
+                          !hideHeader && /* @__PURE__ */ jsxRuntime.jsx(TopPart.TopPart, {
+                            columns: headVisibleColumns,
+                            columnGroups: visColGrps,
+                            topRef,
+                            onWheel,
+                            midGap,
+                            bottomShadow: isHeaderRaised
+                          }),
+                          !hideHeader && rightCols.length > 0 && /* @__PURE__ */ jsxRuntime.jsx(TopRightPart.TopRightPart, {
+                            onWheel,
+                            columns: rightCols,
+                            columnGroups: rightGroups,
+                            leftShadow: isRightRaised,
+                            bottomShadow: isHeaderRaised
+                          }),
+                          leftCols.length > 0 && /* @__PURE__ */ jsxRuntime.jsx(LeftPart.LeftPart, {
+                            leftRef,
+                            onWheel,
+                            columns: leftCols,
+                            rows,
+                            rightShadow: isLeftRaised,
+                            hoverOverRowKey: hoverRowKey,
+                            setHoverOverRowKey: setHoverRowKey,
+                            zebra,
+                            getRowValidationStatus
+                          }),
+                          /* @__PURE__ */ jsxRuntime.jsx(MiddlePart.MiddlePart, {
+                            middleRef,
+                            onWheel,
+                            columns: bodyVisibleColumns,
+                            rows,
+                            hoverOverRowKey: hoverRowKey,
+                            setHoverOverRowKey: setHoverRowKey,
+                            midGap,
+                            zebra,
+                            getRowValidationStatus
+                          }),
+                          rightCols.length > 0 && /* @__PURE__ */ jsxRuntime.jsx(RightPart.RightPart, {
+                            rightRef,
+                            onWheel,
+                            columns: rightCols,
+                            rows,
+                            leftShadow: isRightRaised,
+                            hoverOverRowKey: hoverRowKey,
+                            setHoverOverRowKey: setHoverRowKey,
+                            zebra,
+                            getRowValidationStatus
+                          }),
+                          /* @__PURE__ */ jsxRuntime.jsx(ColumnDropTarget.ColumnDropTarget, {
+                            x: activeTarget == null ? void 0 : activeTarget.x
+                          }),
+                          /* @__PURE__ */ jsxRuntime.jsx(ColumnGhost.ColumnGhost, {
+                            columns: cols,
+                            rows,
+                            dragState,
+                            zebra
+                          })
+                        ]
+                      })
+                    ]
+                  })
+                })
+              })
+            })
+          })
+        })
+      })
+    })
+  });
+};
+
+exports.Grid = Grid;
+exports.SortOrder = SortOrder;
+//# sourceMappingURL=Grid.js.map