{"version":3,"sources":["jsdelivr-header.js","/npm/react-data-grid@7.0.0-beta.59/src/utils/colSpanUtils.ts","/npm/react-data-grid@7.0.0-beta.59/src/utils/domUtils.ts","/npm/react-data-grid@7.0.0-beta.59/src/utils/eventUtils.ts","/npm/react-data-grid@7.0.0-beta.59/src/utils/keyboardUtils.ts","/npm/react-data-grid@7.0.0-beta.59/src/utils/renderMeasuringCells.tsx","/npm/react-data-grid@7.0.0-beta.59/src/utils/selectedCellUtils.ts","/npm/react-data-grid@7.0.0-beta.59/src/style/cell.ts","/npm/react-data-grid@7.0.0-beta.59/src/utils/styleUtils.ts","/npm/react-data-grid@7.0.0-beta.59/src/utils/index.ts","/npm/react-data-grid@7.0.0-beta.59/src/cellRenderers/renderCheckbox.tsx","/npm/react-data-grid@7.0.0-beta.59/src/cellRenderers/renderToggleGroup.tsx","/npm/react-data-grid@7.0.0-beta.59/src/cellRenderers/renderValue.tsx","/npm/react-data-grid@7.0.0-beta.59/src/DataGridDefaultRenderersContext.ts","/npm/react-data-grid@7.0.0-beta.59/src/cellRenderers/SelectCellFormatter.tsx","/npm/react-data-grid@7.0.0-beta.59/src/hooks/useRowSelection.ts","/npm/react-data-grid@7.0.0-beta.59/src/Columns.tsx","/npm/react-data-grid@7.0.0-beta.59/src/renderHeaderCell.tsx","/npm/react-data-grid@7.0.0-beta.59/src/hooks/useCalculatedColumns.ts","/npm/react-data-grid@7.0.0-beta.59/src/hooks/useColumnWidths.ts","/npm/react-data-grid@7.0.0-beta.59/src/hooks/useGridDimensions.ts","/npm/react-data-grid@7.0.0-beta.59/src/hooks/useLatestFunc.ts","/npm/react-data-grid@7.0.0-beta.59/src/hooks/useRovingTabIndex.ts","/npm/react-data-grid@7.0.0-beta.59/src/hooks/useViewportColumns.ts","/npm/react-data-grid@7.0.0-beta.59/src/hooks/useViewportRows.ts","/npm/react-data-grid@7.0.0-beta.59/src/Cell.tsx","/npm/react-data-grid@7.0.0-beta.59/src/EditCell.tsx","/npm/react-data-grid@7.0.0-beta.59/src/GroupedColumnHeaderCell.tsx","/npm/react-data-grid@7.0.0-beta.59/src/HeaderCell.tsx","/npm/react-data-grid@7.0.0-beta.59/src/style/row.ts","/npm/react-data-grid@7.0.0-beta.59/src/HeaderRow.tsx","/npm/react-data-grid@7.0.0-beta.59/src/GroupedColumnHeaderRow.tsx","/npm/react-data-grid@7.0.0-beta.59/src/Row.tsx","/npm/react-data-grid@7.0.0-beta.59/src/ScrollToCell.tsx","/npm/react-data-grid@7.0.0-beta.59/src/sortStatus.tsx","/npm/react-data-grid@7.0.0-beta.59/src/style/core.ts","/npm/react-data-grid@7.0.0-beta.59/src/SummaryCell.tsx","/npm/react-data-grid@7.0.0-beta.59/src/SummaryRow.tsx","/npm/react-data-grid@7.0.0-beta.59/src/DataGrid.tsx","/npm/react-data-grid@7.0.0-beta.59/src/GroupCell.tsx","/npm/react-data-grid@7.0.0-beta.59/src/GroupRow.tsx","/npm/react-data-grid@7.0.0-beta.59/src/TreeDataGrid.tsx","/npm/react-data-grid@7.0.0-beta.59/src/editors/renderTextEditor.tsx"],"names":[],"mappings":"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","file":"/npm/react-data-grid@7.0.0-beta.59/lib/index.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/react-data-grid@7.0.0-beta.59/lib/index.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","import type { CalculatedColumn, ColSpanArgs } from '../types';\n\nexport function getColSpan<R, SR>(\n  column: CalculatedColumn<R, SR>,\n  lastFrozenColumnIndex: number,\n  args: ColSpanArgs<R, SR>\n): number | undefined {\n  const colSpan = typeof column.colSpan === 'function' ? column.colSpan(args) : 1;\n  if (\n    Number.isInteger(colSpan) &&\n    colSpan! > 1 &&\n    // ignore colSpan if it spans over both frozen and regular columns\n    (!column.frozen || column.idx + colSpan! - 1 <= lastFrozenColumnIndex)\n  ) {\n    return colSpan!;\n  }\n  return undefined;\n}\n","import type { Maybe } from '../types';\n\nexport function stopPropagation(event: React.SyntheticEvent) {\n  event.stopPropagation();\n}\n\nexport function scrollIntoView(element: Maybe<Element>, behavior: ScrollBehavior = 'instant') {\n  element?.scrollIntoView({ inline: 'nearest', block: 'nearest', behavior });\n}\n","import type { CellEvent } from '../types';\n\nexport function createCellEvent<E extends React.SyntheticEvent<HTMLDivElement>>(\n  event: E\n): CellEvent<E> {\n  let defaultPrevented = false;\n  const cellEvent = {\n    ...event,\n    preventGridDefault() {\n      defaultPrevented = true;\n    },\n    isGridDefaultPrevented() {\n      return defaultPrevented;\n    }\n  };\n\n  Object.setPrototypeOf(cellEvent, Object.getPrototypeOf(event));\n\n  return cellEvent;\n}\n","import type { Direction, Maybe } from '../types';\n\n// https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values\nconst nonInputKeys = new Set([\n  // Special keys\n  'Unidentified',\n  // Modifier keys\n  'Alt',\n  'AltGraph',\n  'CapsLock',\n  'Control',\n  'Fn',\n  'FnLock',\n  'Meta',\n  'NumLock',\n  'ScrollLock',\n  'Shift',\n  // Whitespace keys\n  'Tab',\n  // Navigation keys\n  'ArrowDown',\n  'ArrowLeft',\n  'ArrowRight',\n  'ArrowUp',\n  'End',\n  'Home',\n  'PageDown',\n  'PageUp',\n  // Editing\n  'Insert',\n  // UI keys\n  'ContextMenu',\n  'Escape',\n  'Pause',\n  'Play',\n  // Device keys\n  'PrintScreen',\n  // Function keys\n  'F1',\n  // 'F2', /!\\ specifically allowed, do not edit\n  'F3',\n  'F4',\n  'F5',\n  'F6',\n  'F7',\n  'F8',\n  'F9',\n  'F10',\n  'F11',\n  'F12'\n]);\n\nexport function isCtrlKeyHeldDown(e: React.KeyboardEvent): boolean {\n  return (e.ctrlKey || e.metaKey) && e.key !== 'Control';\n}\n\n// event.key may differ by keyboard input language, so we use event.keyCode instead\n// event.nativeEvent.code cannot be used either as it would break copy/paste for the DVORAK layout\nconst vKey = 86;\n\nexport function isDefaultCellInput(\n  event: React.KeyboardEvent<HTMLDivElement>,\n  isUserHandlingPaste: boolean\n): boolean {\n  // eslint-disable-next-line @typescript-eslint/no-deprecated\n  if (isCtrlKeyHeldDown(event) && (event.keyCode !== vKey || isUserHandlingPaste)) return false;\n  return !nonInputKeys.has(event.key);\n}\n\n/**\n * By default, the following navigation keys are enabled while an editor is open, under specific conditions:\n * - Tab:\n *   - The editor must be an <input>, a <textarea>, or a <select> element.\n *   - The editor element must be the only immediate child of the editor container/a label.\n */\nexport function onEditorNavigation({ key, target }: React.KeyboardEvent<HTMLDivElement>): boolean {\n  if (\n    key === 'Tab' &&\n    (target instanceof HTMLInputElement ||\n      target instanceof HTMLTextAreaElement ||\n      target instanceof HTMLSelectElement)\n  ) {\n    return (\n      target.closest('.rdg-editor-container')?.querySelectorAll('input, textarea, select')\n        .length === 1\n    );\n  }\n  return false;\n}\n\nexport function getLeftRightKey(direction: Maybe<Direction>) {\n  const isRtl = direction === 'rtl';\n\n  return {\n    leftKey: isRtl ? 'ArrowRight' : 'ArrowLeft',\n    rightKey: isRtl ? 'ArrowLeft' : 'ArrowRight'\n  } as const;\n}\n","import { css } from 'ecij';\n\nimport type { CalculatedColumn } from '../types';\n\nconst measuringCellClassname = css`\n  @layer rdg.MeasuringCell {\n    contain: strict;\n    grid-row: 1;\n    visibility: hidden;\n  }\n`;\n\nexport function renderMeasuringCells<R, SR>(viewportColumns: readonly CalculatedColumn<R, SR>[]) {\n  return viewportColumns.map(({ key, idx, minWidth, maxWidth }) => (\n    <div\n      key={key}\n      className={measuringCellClassname}\n      style={{ gridColumnStart: idx + 1, minWidth, maxWidth }}\n      data-measuring-cell-key={key}\n    />\n  ));\n}\n","import type {\n  CalculatedColumn,\n  CalculatedColumnParent,\n  CellNavigationMode,\n  Maybe,\n  Position\n} from '../types';\nimport { getColSpan } from './colSpanUtils';\n\ninterface IsSelectedCellEditableOpts<R, SR> {\n  selectedPosition: Position;\n  columns: readonly CalculatedColumn<R, SR>[];\n  rows: readonly R[];\n}\n\nexport function isSelectedCellEditable<R, SR>({\n  selectedPosition,\n  columns,\n  rows\n}: IsSelectedCellEditableOpts<R, SR>): boolean {\n  const column = columns[selectedPosition.idx];\n  const row = rows[selectedPosition.rowIdx];\n  return isCellEditableUtil(column, row);\n}\n\n// https://github.com/vercel/next.js/issues/56480\nexport function isCellEditableUtil<R, SR>(column: CalculatedColumn<R, SR>, row: R): boolean {\n  return (\n    column.renderEditCell != null &&\n    (typeof column.editable === 'function' ? column.editable(row) : column.editable) !== false\n  );\n}\n\ninterface GetNextSelectedCellPositionOpts<R, SR> {\n  moveUp: boolean;\n  moveNext: boolean;\n  cellNavigationMode: CellNavigationMode;\n  columns: readonly CalculatedColumn<R, SR>[];\n  colSpanColumns: readonly CalculatedColumn<R, SR>[];\n  rows: readonly R[];\n  topSummaryRows: Maybe<readonly SR[]>;\n  bottomSummaryRows: Maybe<readonly SR[]>;\n  minRowIdx: number;\n  mainHeaderRowIdx: number;\n  maxRowIdx: number;\n  currentPosition: Position;\n  nextPosition: Position;\n  lastFrozenColumnIndex: number;\n  isCellWithinBounds: (position: Position) => boolean;\n}\n\nfunction getSelectedCellColSpan<R, SR>({\n  rows,\n  topSummaryRows,\n  bottomSummaryRows,\n  rowIdx,\n  mainHeaderRowIdx,\n  lastFrozenColumnIndex,\n  column\n}: Pick<\n  GetNextSelectedCellPositionOpts<R, SR>,\n  'rows' | 'topSummaryRows' | 'bottomSummaryRows' | 'lastFrozenColumnIndex' | 'mainHeaderRowIdx'\n> & {\n  rowIdx: number;\n  column: CalculatedColumn<R, SR>;\n}) {\n  const topSummaryRowsCount = topSummaryRows?.length ?? 0;\n  if (rowIdx === mainHeaderRowIdx) {\n    return getColSpan(column, lastFrozenColumnIndex, { type: 'HEADER' });\n  }\n\n  if (\n    topSummaryRows &&\n    rowIdx > mainHeaderRowIdx &&\n    rowIdx <= topSummaryRowsCount + mainHeaderRowIdx\n  ) {\n    return getColSpan(column, lastFrozenColumnIndex, {\n      type: 'SUMMARY',\n      row: topSummaryRows[rowIdx + topSummaryRowsCount]\n    });\n  }\n\n  if (rowIdx >= 0 && rowIdx < rows.length) {\n    const row = rows[rowIdx];\n    return getColSpan(column, lastFrozenColumnIndex, { type: 'ROW', row });\n  }\n\n  if (bottomSummaryRows) {\n    return getColSpan(column, lastFrozenColumnIndex, {\n      type: 'SUMMARY',\n      row: bottomSummaryRows[rowIdx - rows.length]\n    });\n  }\n\n  return undefined;\n}\n\nexport function getNextSelectedCellPosition<R, SR>({\n  moveUp,\n  moveNext,\n  cellNavigationMode,\n  columns,\n  colSpanColumns,\n  rows,\n  topSummaryRows,\n  bottomSummaryRows,\n  minRowIdx,\n  mainHeaderRowIdx,\n  maxRowIdx,\n  currentPosition: { idx: currentIdx, rowIdx: currentRowIdx },\n  nextPosition,\n  lastFrozenColumnIndex,\n  isCellWithinBounds\n}: GetNextSelectedCellPositionOpts<R, SR>): Position {\n  let { idx: nextIdx, rowIdx: nextRowIdx } = nextPosition;\n  const columnsCount = columns.length;\n\n  const setColSpan = (moveNext: boolean) => {\n    // If a cell within the colspan range is selected then move to the\n    // previous or the next cell depending on the navigation direction\n    for (const column of colSpanColumns) {\n      const colIdx = column.idx;\n      if (colIdx > nextIdx) break;\n      const colSpan = getSelectedCellColSpan({\n        rows,\n        topSummaryRows,\n        bottomSummaryRows,\n        rowIdx: nextRowIdx,\n        mainHeaderRowIdx,\n        lastFrozenColumnIndex,\n        column\n      });\n\n      if (colSpan && nextIdx > colIdx && nextIdx < colSpan + colIdx) {\n        nextIdx = colIdx + (moveNext ? colSpan : 0);\n        break;\n      }\n    }\n  };\n\n  const getParentRowIdx = (parent: CalculatedColumnParent<R, SR>) => {\n    return parent.level + mainHeaderRowIdx;\n  };\n\n  const setHeaderGroupColAndRowSpan = () => {\n    if (moveNext) {\n      // find the parent at the same row level\n      const nextColumn = columns[nextIdx];\n      let parent = nextColumn.parent;\n      while (parent !== undefined) {\n        const parentRowIdx = getParentRowIdx(parent);\n        if (nextRowIdx === parentRowIdx) {\n          nextIdx = parent.idx + parent.colSpan;\n          break;\n        }\n        parent = parent.parent;\n      }\n    } else if (moveUp) {\n      // find the first reachable parent\n      const nextColumn = columns[nextIdx];\n      let parent = nextColumn.parent;\n      let found = false;\n      while (parent !== undefined) {\n        const parentRowIdx = getParentRowIdx(parent);\n        if (nextRowIdx >= parentRowIdx) {\n          nextIdx = parent.idx;\n          nextRowIdx = parentRowIdx;\n          found = true;\n          break;\n        }\n        parent = parent.parent;\n      }\n\n      // keep the current position if there is no parent matching the new row position\n      if (!found) {\n        nextIdx = currentIdx;\n        nextRowIdx = currentRowIdx;\n      }\n    }\n  };\n\n  if (isCellWithinBounds(nextPosition)) {\n    setColSpan(moveNext);\n\n    if (nextRowIdx < mainHeaderRowIdx) {\n      setHeaderGroupColAndRowSpan();\n    }\n  }\n\n  if (cellNavigationMode === 'CHANGE_ROW') {\n    const isAfterLastColumn = nextIdx === columnsCount;\n    const isBeforeFirstColumn = nextIdx === -1;\n\n    if (isAfterLastColumn) {\n      const isLastRow = nextRowIdx === maxRowIdx;\n      if (!isLastRow) {\n        nextIdx = 0;\n        nextRowIdx += 1;\n      }\n    } else if (isBeforeFirstColumn) {\n      const isFirstRow = nextRowIdx === minRowIdx;\n      if (!isFirstRow) {\n        nextRowIdx -= 1;\n        nextIdx = columnsCount - 1;\n      }\n      setColSpan(false);\n    }\n  }\n\n  if (nextRowIdx < mainHeaderRowIdx && nextIdx > -1 && nextIdx < columnsCount) {\n    // Find the last reachable parent for the new rowIdx\n    // This check is needed when navigating to a column\n    // that does not have a parent matching the new rowIdx\n    const nextColumn = columns[nextIdx];\n    let parent = nextColumn.parent;\n    const nextParentRowIdx = nextRowIdx;\n    nextRowIdx = mainHeaderRowIdx;\n    while (parent !== undefined) {\n      const parentRowIdx = getParentRowIdx(parent);\n      if (parentRowIdx >= nextParentRowIdx) {\n        nextRowIdx = parentRowIdx;\n        nextIdx = parent.idx;\n      }\n      parent = parent.parent;\n    }\n  }\n\n  return { idx: nextIdx, rowIdx: nextRowIdx };\n}\n\ninterface CanExitGridOpts {\n  maxColIdx: number;\n  minRowIdx: number;\n  maxRowIdx: number;\n  selectedPosition: Position;\n  shiftKey: boolean;\n}\n\nexport function canExitGrid({\n  maxColIdx,\n  minRowIdx,\n  maxRowIdx,\n  selectedPosition: { rowIdx, idx },\n  shiftKey\n}: CanExitGridOpts): boolean {\n  // Exit the grid if we're at the first or last cell of the grid\n  const atLastCellInRow = idx === maxColIdx;\n  const atFirstCellInRow = idx === 0;\n  const atLastRow = rowIdx === maxRowIdx;\n  const atFirstRow = rowIdx === minRowIdx;\n\n  return shiftKey ? atFirstCellInRow && atFirstRow : atLastCellInRow && atLastRow;\n}\n","import { css } from 'ecij';\n\nexport const cell = css`\n  @layer rdg.Cell {\n    /* max-content does not work with size containment\n     * dynamically switching between different containment styles incurs a heavy relayout penalty\n     * Chromium bug: at odd zoom levels or subpixel positioning,\n     * layout/paint/style containment can make cell borders disappear\n     *   https://issues.chromium.org/issues/40840864\n     */\n    position: relative; /* needed for absolute positioning to work */\n    padding-block: 0;\n    padding-inline: 8px;\n    border-inline-end: var(--rdg-border-width) solid var(--rdg-border-color);\n    border-block-end: var(--rdg-border-width) solid var(--rdg-border-color);\n    grid-row-start: var(--rdg-grid-row-start);\n    align-content: center;\n    background-color: inherit;\n\n    white-space: nowrap;\n    overflow: clip;\n    text-overflow: ellipsis;\n    outline: none;\n\n    &[aria-selected='true'] {\n      outline: var(--rdg-selection-width) solid var(--rdg-selection-color);\n      outline-offset: calc(var(--rdg-selection-width) * -1);\n    }\n  }\n`;\n\nexport const cellClassname = `rdg-cell ${cell}`;\n\nexport const cellFrozen = css`\n  @layer rdg.Cell {\n    position: sticky;\n    /* Should have a higher value than 0 to show up above unfrozen cells */\n    z-index: 1;\n\n    /* Add box-shadow on the last frozen cell */\n    &:nth-last-child(1 of &) {\n      box-shadow: var(--rdg-cell-frozen-box-shadow);\n    }\n  }\n`;\n\nexport const cellFrozenClassname = `rdg-cell-frozen ${cellFrozen}`;\n\nconst cellDragHandle = css`\n  @layer rdg.DragHandle {\n    --rdg-drag-handle-size: 8px;\n    z-index: 0;\n    cursor: move;\n    inline-size: var(--rdg-drag-handle-size);\n    block-size: var(--rdg-drag-handle-size);\n    background-color: var(--rdg-selection-color);\n    place-self: end;\n\n    &:hover {\n      --rdg-drag-handle-size: 16px;\n      border: 2px solid var(--rdg-selection-color);\n      background-color: var(--rdg-background-color);\n    }\n  }\n`;\n\nexport const cellDragHandleFrozenClassname = css`\n  @layer rdg.DragHandle {\n    z-index: 1;\n    position: sticky;\n  }\n`;\n\nexport const cellDragHandleClassname = `rdg-cell-drag-handle ${cellDragHandle}`;\n","import type { CSSProperties } from 'react';\n\nimport type { CalculatedColumn, CalculatedColumnOrColumnGroup, Maybe } from '../types';\nimport { cellClassname, cellFrozenClassname } from '../style/cell';\n\nexport function getRowStyle(rowIdx: number): CSSProperties {\n  return { '--rdg-grid-row-start': rowIdx };\n}\n\nexport function getHeaderCellStyle<R, SR>(\n  column: CalculatedColumnOrColumnGroup<R, SR>,\n  rowIdx: number,\n  rowSpan: number\n): React.CSSProperties {\n  const gridRowEnd = rowIdx + 1;\n  const paddingBlockStart = `calc(${rowSpan - 1} * var(--rdg-header-row-height))`;\n\n  if (column.parent === undefined) {\n    return {\n      insetBlockStart: 0,\n      gridRowStart: 1,\n      gridRowEnd,\n      paddingBlockStart\n    };\n  }\n\n  return {\n    insetBlockStart: `calc(${rowIdx - rowSpan} * var(--rdg-header-row-height))`,\n    gridRowStart: gridRowEnd - rowSpan,\n    gridRowEnd,\n    paddingBlockStart\n  };\n}\n\nexport function getCellStyle<R, SR>(\n  column: CalculatedColumn<R, SR>,\n  colSpan = 1\n): React.CSSProperties {\n  const index = column.idx + 1;\n  return {\n    gridColumnStart: index,\n    gridColumnEnd: index + colSpan,\n    insetInlineStart: column.frozen ? `var(--rdg-frozen-left-${column.idx})` : undefined\n  };\n}\n\ntype ClassValue = Maybe<string> | Record<string, boolean> | false;\n\nexport function classnames(...args: readonly ClassValue[]) {\n  let classname = '';\n\n  for (const arg of args) {\n    if (arg) {\n      if (typeof arg === 'string') {\n        classname += ` ${arg}`;\n      } else if (typeof arg === 'object') {\n        for (const key in arg) {\n          if (arg[key]) {\n            classname += ` ${key}`;\n          }\n        }\n      }\n    }\n  }\n\n  return classname.trimStart();\n}\n\nexport function getCellClassname<R, SR>(\n  column: CalculatedColumn<R, SR>,\n  ...extraClasses: readonly ClassValue[]\n): string {\n  return classnames(\n    cellClassname,\n    {\n      [cellFrozenClassname]: column.frozen\n    },\n    ...extraClasses\n  );\n}\n","import type { CalculatedColumn, CalculatedColumnOrColumnGroup, Maybe } from '../types';\n\nexport * from './colSpanUtils';\nexport * from './domUtils';\nexport * from './eventUtils';\nexport * from './keyboardUtils';\nexport * from './renderMeasuringCells';\nexport * from './selectedCellUtils';\nexport * from './styleUtils';\n\nexport const { min, max, floor, sign, abs } = Math;\n\nexport function assertIsValidKeyGetter<R, K extends React.Key>(\n  keyGetter: Maybe<(row: NoInfer<R>) => K>\n): asserts keyGetter is (row: R) => K {\n  if (typeof keyGetter !== 'function') {\n    throw new Error('Please specify the rowKeyGetter prop to use selection');\n  }\n}\n\nexport function clampColumnWidth<R, SR>(\n  width: number,\n  { minWidth, maxWidth }: CalculatedColumn<R, SR>\n): number {\n  width = max(width, minWidth);\n\n  // ignore maxWidth if it less than minWidth\n  if (typeof maxWidth === 'number' && maxWidth >= minWidth) {\n    return min(width, maxWidth);\n  }\n\n  return width;\n}\n\nexport function getHeaderCellRowSpan<R, SR>(\n  column: CalculatedColumnOrColumnGroup<R, SR>,\n  rowIdx: number\n) {\n  return column.parent === undefined ? rowIdx : column.level - column.parent.level;\n}\n","import { css } from 'ecij';\n\nimport type { RenderCheckboxProps } from '../types';\n\nconst checkbox = css`\n  @layer rdg.CheckboxInput {\n    display: block;\n    margin: auto;\n    inline-size: 20px;\n    block-size: 20px;\n\n    &:focus-visible {\n      outline: 2px solid var(--rdg-checkbox-focus-color);\n      outline-offset: -3px;\n    }\n\n    &:enabled {\n      cursor: pointer;\n    }\n  }\n`;\n\nconst checkboxClassname = `rdg-checkbox-input ${checkbox}`;\n\nexport function renderCheckbox({ onChange, indeterminate, ...props }: RenderCheckboxProps) {\n  function handleChange(e: React.ChangeEvent<HTMLInputElement>) {\n    onChange(e.target.checked, (e.nativeEvent as MouseEvent).shiftKey);\n  }\n\n  return (\n    <input\n      ref={(el) => {\n        if (el) {\n          el.indeterminate = indeterminate === true;\n        }\n      }}\n      type=\"checkbox\"\n      className={checkboxClassname}\n      onChange={handleChange}\n      {...props}\n    />\n  );\n}\n","import { css } from 'ecij';\n\nimport type { RenderGroupCellProps } from '../types';\n\nconst groupCellContent = css`\n  @layer rdg.GroupCellContent {\n    outline: none;\n  }\n`;\n\nconst groupCellContentClassname = `rdg-group-cell-content ${groupCellContent}`;\n\nconst caret = css`\n  @layer rdg.GroupCellCaret {\n    margin-inline-start: 4px;\n    stroke: currentColor;\n    stroke-width: 1.5px;\n    fill: transparent;\n    vertical-align: middle;\n\n    > path {\n      transition: d 0.1s;\n    }\n  }\n`;\n\nconst caretClassname = `rdg-caret ${caret}`;\n\nexport function renderToggleGroup<R, SR>(props: RenderGroupCellProps<R, SR>) {\n  return <ToggleGroup {...props} />;\n}\n\nexport function ToggleGroup<R, SR>({\n  groupKey,\n  isExpanded,\n  tabIndex,\n  toggleGroup\n}: RenderGroupCellProps<R, SR>) {\n  function handleKeyDown({ key }: React.KeyboardEvent<HTMLSpanElement>) {\n    if (key === 'Enter') {\n      toggleGroup();\n    }\n  }\n\n  const d = isExpanded ? 'M1 1 L 7 7 L 13 1' : 'M1 7 L 7 1 L 13 7';\n\n  return (\n    <span className={groupCellContentClassname} tabIndex={tabIndex} onKeyDown={handleKeyDown}>\n      {groupKey as string}\n      <svg viewBox=\"0 0 14 8\" width=\"14\" height=\"8\" className={caretClassname} aria-hidden>\n        <path d={d} />\n      </svg>\n    </span>\n  );\n}\n","import type { RenderCellProps } from '../types';\n\nexport function renderValue<R, SR>(props: RenderCellProps<R, SR>) {\n  try {\n    return props.row[props.column.key as keyof R] as React.ReactNode;\n  } catch {\n    return null;\n  }\n}\n","import { createContext, useContext } from 'react';\n\nimport type { Maybe, Renderers } from './types';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const DataGridDefaultRenderersContext = createContext<Maybe<Renderers<any, any>>>(undefined);\n\nexport function useDefaultRenderers<R, SR>(): Maybe<Renderers<R, SR>> {\n  return useContext(DataGridDefaultRenderersContext);\n}\n","import type { RenderCheckboxProps } from '../types';\nimport { useDefaultRenderers } from '../DataGridDefaultRenderersContext';\n\ntype SharedInputProps = Pick<\n  RenderCheckboxProps,\n  'disabled' | 'tabIndex' | 'aria-label' | 'aria-labelledby' | 'indeterminate' | 'onChange'\n>;\n\ninterface SelectCellFormatterProps extends SharedInputProps {\n  value: boolean;\n}\n\nexport function SelectCellFormatter({\n  value,\n  tabIndex,\n  indeterminate,\n  disabled,\n  onChange,\n  'aria-label': ariaLabel,\n  'aria-labelledby': ariaLabelledBy\n}: SelectCellFormatterProps) {\n  const renderCheckbox = useDefaultRenderers()!.renderCheckbox!;\n\n  return renderCheckbox({\n    'aria-label': ariaLabel,\n    'aria-labelledby': ariaLabelledBy,\n    tabIndex,\n    indeterminate,\n    disabled,\n    checked: value,\n    onChange\n  });\n}\n","import { createContext, useContext } from 'react';\n\nimport type { SelectHeaderRowEvent, SelectRowEvent } from '../types';\n\nexport interface RowSelectionContextValue {\n  readonly isRowSelected: boolean;\n  readonly isRowSelectionDisabled: boolean;\n}\n\nexport const RowSelectionContext = createContext<RowSelectionContextValue | undefined>(undefined);\n\nexport const RowSelectionChangeContext = createContext<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ((selectRowEvent: SelectRowEvent<any>) => void) | undefined\n>(undefined);\n\nexport function useRowSelection() {\n  const rowSelectionContext = useContext(RowSelectionContext);\n  const rowSelectionChangeContext = useContext(RowSelectionChangeContext);\n\n  if (rowSelectionContext === undefined || rowSelectionChangeContext === undefined) {\n    throw new Error('useRowSelection must be used within renderCell');\n  }\n\n  return {\n    isRowSelectionDisabled: rowSelectionContext.isRowSelectionDisabled,\n    isRowSelected: rowSelectionContext.isRowSelected,\n    onRowSelectionChange: rowSelectionChangeContext\n  };\n}\n\nexport interface HeaderRowSelectionContextValue {\n  readonly isRowSelected: boolean;\n  readonly isIndeterminate: boolean;\n}\n\nexport const HeaderRowSelectionContext = createContext<HeaderRowSelectionContextValue | undefined>(\n  undefined\n);\n\nexport const HeaderRowSelectionChangeContext = createContext<\n  ((selectRowEvent: SelectHeaderRowEvent) => void) | undefined\n>(undefined);\n\nexport function useHeaderRowSelection() {\n  const headerRowSelectionContext = useContext(HeaderRowSelectionContext);\n  const headerRowSelectionChangeContext = useContext(HeaderRowSelectionChangeContext);\n\n  if (headerRowSelectionContext === undefined || headerRowSelectionChangeContext === undefined) {\n    throw new Error('useHeaderRowSelection must be used within renderHeaderCell');\n  }\n\n  return {\n    isIndeterminate: headerRowSelectionContext.isIndeterminate,\n    isRowSelected: headerRowSelectionContext.isRowSelected,\n    onRowSelectionChange: headerRowSelectionChangeContext\n  };\n}\n","import { useHeaderRowSelection, useRowSelection } from './hooks/useRowSelection';\nimport type { Column, RenderCellProps, RenderGroupCellProps, RenderHeaderCellProps } from './types';\nimport { SelectCellFormatter } from './cellRenderers';\n\nexport const SELECT_COLUMN_KEY = 'rdg-select-column';\n\nfunction HeaderRenderer(props: RenderHeaderCellProps<unknown>) {\n  const { isIndeterminate, isRowSelected, onRowSelectionChange } = useHeaderRowSelection();\n\n  return (\n    <SelectCellFormatter\n      aria-label=\"Select All\"\n      tabIndex={props.tabIndex}\n      indeterminate={isIndeterminate}\n      value={isRowSelected}\n      onChange={(checked) => {\n        onRowSelectionChange({ checked: isIndeterminate ? false : checked });\n      }}\n    />\n  );\n}\n\nfunction SelectFormatter(props: RenderCellProps<unknown>) {\n  const { isRowSelectionDisabled, isRowSelected, onRowSelectionChange } = useRowSelection();\n\n  return (\n    <SelectCellFormatter\n      aria-label=\"Select\"\n      tabIndex={props.tabIndex}\n      disabled={isRowSelectionDisabled}\n      value={isRowSelected}\n      onChange={(checked, isShiftClick) => {\n        onRowSelectionChange({ row: props.row, checked, isShiftClick });\n      }}\n    />\n  );\n}\n\nfunction SelectGroupFormatter(props: RenderGroupCellProps<unknown>) {\n  const { isRowSelected, onRowSelectionChange } = useRowSelection();\n\n  return (\n    <SelectCellFormatter\n      aria-label=\"Select Group\"\n      tabIndex={props.tabIndex}\n      value={isRowSelected}\n      onChange={(checked) => {\n        onRowSelectionChange({ row: props.row, checked, isShiftClick: false });\n      }}\n    />\n  );\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const SelectColumn: Column<any, any> = {\n  key: SELECT_COLUMN_KEY,\n  name: '',\n  width: 35,\n  minWidth: 35,\n  maxWidth: 35,\n  resizable: false,\n  sortable: false,\n  frozen: true,\n  renderHeaderCell(props) {\n    return <HeaderRenderer {...props} />;\n  },\n  renderCell(props) {\n    return <SelectFormatter {...props} />;\n  },\n  renderGroupCell(props) {\n    return <SelectGroupFormatter {...props} />;\n  }\n};\n","import { css } from 'ecij';\n\nimport type { RenderHeaderCellProps } from './types';\nimport { useDefaultRenderers } from './DataGridDefaultRenderersContext';\n\nconst headerSortCellClassname = css`\n  @layer rdg.SortableHeaderCell {\n    display: flex;\n  }\n`;\n\nconst headerSortName = css`\n  @layer rdg.SortableHeaderCellName {\n    flex-grow: 1;\n    overflow: clip;\n    text-overflow: ellipsis;\n  }\n`;\n\nconst headerSortNameClassname = `rdg-header-sort-name ${headerSortName}`;\n\nexport default function renderHeaderCell<R, SR>({\n  column,\n  sortDirection,\n  priority\n}: RenderHeaderCellProps<R, SR>) {\n  if (!column.sortable) return column.name;\n\n  return (\n    <SortableHeaderCell sortDirection={sortDirection} priority={priority}>\n      {column.name}\n    </SortableHeaderCell>\n  );\n}\n\ntype SharedHeaderCellProps<R, SR> = Pick<\n  RenderHeaderCellProps<R, SR>,\n  'sortDirection' | 'priority'\n>;\n\ninterface SortableHeaderCellProps<R, SR> extends SharedHeaderCellProps<R, SR> {\n  children: React.ReactNode;\n}\n\nfunction SortableHeaderCell<R, SR>({\n  sortDirection,\n  priority,\n  children\n}: SortableHeaderCellProps<R, SR>) {\n  const renderSortStatus = useDefaultRenderers<R, SR>()!.renderSortStatus!;\n\n  return (\n    <span className={headerSortCellClassname}>\n      <span className={headerSortNameClassname}>{children}</span>\n      <span>{renderSortStatus({ sortDirection, priority })}</span>\n    </span>\n  );\n}\n","import { useMemo } from 'react';\n\nimport { clampColumnWidth, max, min } from '../utils';\nimport type { CalculatedColumn, CalculatedColumnParent, ColumnOrColumnGroup, Omit } from '../types';\nimport { renderValue } from '../cellRenderers';\nimport { SELECT_COLUMN_KEY } from '../Columns';\nimport type { DataGridProps } from '../DataGrid';\nimport renderHeaderCell from '../renderHeaderCell';\n\ntype Mutable<T> = {\n  -readonly [P in keyof T]: T[P] extends ReadonlyArray<infer V> ? Mutable<V>[] : T[P];\n};\n\ninterface WithParent<R, SR> {\n  readonly parent: MutableCalculatedColumnParent<R, SR> | undefined;\n}\n\ntype MutableCalculatedColumnParent<R, SR> = Omit<Mutable<CalculatedColumnParent<R, SR>>, 'parent'> &\n  WithParent<R, SR>;\ntype MutableCalculatedColumn<R, SR> = Omit<Mutable<CalculatedColumn<R, SR>>, 'parent'> &\n  WithParent<R, SR>;\n\ninterface ColumnMetric {\n  width: number;\n  left: number;\n}\n\nconst DEFAULT_COLUMN_WIDTH = 'auto';\nconst DEFAULT_COLUMN_MIN_WIDTH = 50;\n\ninterface CalculatedColumnsArgs<R, SR> {\n  rawColumns: readonly ColumnOrColumnGroup<R, SR>[];\n  defaultColumnOptions: DataGridProps<R, SR>['defaultColumnOptions'];\n  viewportWidth: number;\n  scrollLeft: number;\n  getColumnWidth: (column: CalculatedColumn<R, SR>) => string | number;\n  enableVirtualization: boolean;\n}\n\nexport function useCalculatedColumns<R, SR>({\n  rawColumns,\n  defaultColumnOptions,\n  getColumnWidth,\n  viewportWidth,\n  scrollLeft,\n  enableVirtualization\n}: CalculatedColumnsArgs<R, SR>) {\n  const defaultWidth = defaultColumnOptions?.width ?? DEFAULT_COLUMN_WIDTH;\n  const defaultMinWidth = defaultColumnOptions?.minWidth ?? DEFAULT_COLUMN_MIN_WIDTH;\n  const defaultMaxWidth = defaultColumnOptions?.maxWidth ?? undefined;\n  const defaultRenderCell = defaultColumnOptions?.renderCell ?? renderValue;\n  const defaultRenderHeaderCell = defaultColumnOptions?.renderHeaderCell ?? renderHeaderCell;\n  const defaultSortable = defaultColumnOptions?.sortable ?? false;\n  const defaultResizable = defaultColumnOptions?.resizable ?? false;\n  const defaultDraggable = defaultColumnOptions?.draggable ?? false;\n\n  const { columns, colSpanColumns, lastFrozenColumnIndex, headerRowsCount } = useMemo((): {\n    readonly columns: readonly CalculatedColumn<R, SR>[];\n    readonly colSpanColumns: readonly CalculatedColumn<R, SR>[];\n    readonly lastFrozenColumnIndex: number;\n    readonly headerRowsCount: number;\n  } => {\n    let lastFrozenColumnIndex = -1;\n    let headerRowsCount = 1;\n    const columns: MutableCalculatedColumn<R, SR>[] = [];\n\n    collectColumns(rawColumns, 1);\n\n    function collectColumns(\n      rawColumns: readonly ColumnOrColumnGroup<R, SR>[],\n      level: number,\n      parent?: MutableCalculatedColumnParent<R, SR>\n    ) {\n      for (const rawColumn of rawColumns) {\n        if ('children' in rawColumn) {\n          const calculatedColumnParent: MutableCalculatedColumnParent<R, SR> = {\n            name: rawColumn.name,\n            parent,\n            idx: -1,\n            colSpan: 0,\n            level: 0,\n            headerCellClass: rawColumn.headerCellClass\n          };\n\n          collectColumns(rawColumn.children, level + 1, calculatedColumnParent);\n          continue;\n        }\n\n        const frozen = rawColumn.frozen ?? false;\n\n        const column: MutableCalculatedColumn<R, SR> = {\n          ...rawColumn,\n          parent,\n          idx: 0,\n          level: 0,\n          frozen,\n          width: rawColumn.width ?? defaultWidth,\n          minWidth: rawColumn.minWidth ?? defaultMinWidth,\n          maxWidth: rawColumn.maxWidth ?? defaultMaxWidth,\n          sortable: rawColumn.sortable ?? defaultSortable,\n          resizable: rawColumn.resizable ?? defaultResizable,\n          draggable: rawColumn.draggable ?? defaultDraggable,\n          renderCell: rawColumn.renderCell ?? defaultRenderCell,\n          renderHeaderCell: rawColumn.renderHeaderCell ?? defaultRenderHeaderCell\n        };\n\n        columns.push(column);\n\n        if (frozen) {\n          lastFrozenColumnIndex++;\n        }\n\n        if (level > headerRowsCount) {\n          headerRowsCount = level;\n        }\n      }\n    }\n\n    columns.sort(({ key: aKey, frozen: frozenA }, { key: bKey, frozen: frozenB }) => {\n      // Sort select column first:\n      if (aKey === SELECT_COLUMN_KEY) return -1;\n      if (bKey === SELECT_COLUMN_KEY) return 1;\n\n      // Sort frozen columns second:\n      if (frozenA) {\n        if (frozenB) return 0;\n        return -1;\n      }\n      if (frozenB) return 1;\n\n      // TODO: sort columns to keep them grouped if they have a parent\n\n      // Sort other columns last:\n      return 0;\n    });\n\n    const colSpanColumns: CalculatedColumn<R, SR>[] = [];\n    columns.forEach((column, idx) => {\n      column.idx = idx;\n      updateColumnParent(column, idx, 0);\n\n      if (column.colSpan != null) {\n        colSpanColumns.push(column);\n      }\n    });\n\n    return {\n      columns,\n      colSpanColumns,\n      lastFrozenColumnIndex,\n      headerRowsCount\n    };\n  }, [\n    rawColumns,\n    defaultWidth,\n    defaultMinWidth,\n    defaultMaxWidth,\n    defaultRenderCell,\n    defaultRenderHeaderCell,\n    defaultResizable,\n    defaultSortable,\n    defaultDraggable\n  ]);\n\n  const { templateColumns, layoutCssVars, totalFrozenColumnWidth, columnMetrics } = useMemo((): {\n    templateColumns: readonly string[];\n    layoutCssVars: Readonly<Record<string, string>>;\n    totalFrozenColumnWidth: number;\n    columnMetrics: ReadonlyMap<CalculatedColumn<R, SR>, ColumnMetric>;\n  } => {\n    const columnMetrics = new Map<CalculatedColumn<R, SR>, ColumnMetric>();\n    let left = 0;\n    let totalFrozenColumnWidth = 0;\n    const templateColumns: string[] = [];\n\n    for (const column of columns) {\n      let width = getColumnWidth(column);\n\n      if (typeof width === 'number') {\n        width = clampColumnWidth(width, column);\n      } else {\n        // This is a placeholder width so we can continue to use virtualization.\n        // The actual value is set after the column is rendered\n        width = column.minWidth;\n      }\n      templateColumns.push(`${width}px`);\n      columnMetrics.set(column, { width, left });\n      left += width;\n    }\n\n    if (lastFrozenColumnIndex !== -1) {\n      const columnMetric = columnMetrics.get(columns[lastFrozenColumnIndex])!;\n      totalFrozenColumnWidth = columnMetric.left + columnMetric.width;\n    }\n\n    const layoutCssVars: Record<string, string> = {};\n\n    for (let i = 0; i <= lastFrozenColumnIndex; i++) {\n      const column = columns[i];\n      layoutCssVars[`--rdg-frozen-left-${column.idx}`] = `${columnMetrics.get(column)!.left}px`;\n    }\n\n    return { templateColumns, layoutCssVars, totalFrozenColumnWidth, columnMetrics };\n  }, [getColumnWidth, columns, lastFrozenColumnIndex]);\n\n  const [colOverscanStartIdx, colOverscanEndIdx] = useMemo((): [number, number] => {\n    if (!enableVirtualization) {\n      return [0, columns.length - 1];\n    }\n    // get the viewport's left side and right side positions for non-frozen columns\n    const viewportLeft = scrollLeft + totalFrozenColumnWidth;\n    const viewportRight = scrollLeft + viewportWidth;\n    // get first and last non-frozen column indexes\n    const lastColIdx = columns.length - 1;\n    const firstUnfrozenColumnIdx = min(lastFrozenColumnIndex + 1, lastColIdx);\n\n    // skip rendering non-frozen columns if the frozen columns cover the entire viewport\n    if (viewportLeft >= viewportRight) {\n      return [firstUnfrozenColumnIdx, firstUnfrozenColumnIdx];\n    }\n\n    // get the first visible non-frozen column index\n    let colVisibleStartIdx = firstUnfrozenColumnIdx;\n    while (colVisibleStartIdx < lastColIdx) {\n      const { left, width } = columnMetrics.get(columns[colVisibleStartIdx])!;\n      // if the right side of the columnn is beyond the left side of the available viewport,\n      // then it is the first column that's at least partially visible\n      if (left + width > viewportLeft) {\n        break;\n      }\n      colVisibleStartIdx++;\n    }\n\n    // get the last visible non-frozen column index\n    let colVisibleEndIdx = colVisibleStartIdx;\n    while (colVisibleEndIdx < lastColIdx) {\n      const { left, width } = columnMetrics.get(columns[colVisibleEndIdx])!;\n      // if the right side of the column is beyond or equal to the right side of the available viewport,\n      // then it the last column that's at least partially visible, as the previous column's right side is not beyond the viewport.\n      if (left + width >= viewportRight) {\n        break;\n      }\n      colVisibleEndIdx++;\n    }\n\n    const colOverscanStartIdx = max(firstUnfrozenColumnIdx, colVisibleStartIdx - 1);\n    const colOverscanEndIdx = min(lastColIdx, colVisibleEndIdx + 1);\n\n    return [colOverscanStartIdx, colOverscanEndIdx];\n  }, [\n    columnMetrics,\n    columns,\n    lastFrozenColumnIndex,\n    scrollLeft,\n    totalFrozenColumnWidth,\n    viewportWidth,\n    enableVirtualization\n  ]);\n\n  return {\n    columns,\n    colSpanColumns,\n    colOverscanStartIdx,\n    colOverscanEndIdx,\n    templateColumns,\n    layoutCssVars,\n    headerRowsCount,\n    lastFrozenColumnIndex,\n    totalFrozenColumnWidth\n  };\n}\n\nfunction updateColumnParent<R, SR>(\n  column: MutableCalculatedColumn<R, SR> | MutableCalculatedColumnParent<R, SR>,\n  index: number,\n  level: number\n) {\n  if (level < column.level) {\n    column.level = level;\n  }\n\n  if (column.parent !== undefined) {\n    const { parent } = column;\n    if (parent.idx === -1) {\n      parent.idx = index;\n    }\n    parent.colSpan += 1;\n    updateColumnParent(parent, index, level - 1);\n  }\n}\n","import { useLayoutEffect, useState } from 'react';\nimport { flushSync } from 'react-dom';\n\nimport type { CalculatedColumn, ColumnWidths, ResizedWidth } from '../types';\nimport type { DataGridProps } from '../DataGrid';\n\nexport function useColumnWidths<R, SR>(\n  columns: readonly CalculatedColumn<R, SR>[],\n  viewportColumns: readonly CalculatedColumn<R, SR>[],\n  templateColumns: readonly string[],\n  gridRef: React.RefObject<HTMLDivElement | null>,\n  gridWidth: number,\n  columnWidths: ColumnWidths,\n  onColumnWidthsChange: (columnWidths: ColumnWidths) => void,\n  onColumnResize: DataGridProps<R, SR>['onColumnResize'],\n  setColumnResizing: (isColumnResizing: boolean) => void\n) {\n  const [columnToAutoResize, setColumnToAutoResize] = useState<{\n    readonly key: string;\n    readonly width: ResizedWidth;\n  } | null>(null);\n  const [columnsToMeasureOnResize, setColumnsToMeasureOnResize] =\n    useState<ReadonlySet<string> | null>(null);\n  const [prevGridWidth, setPreviousGridWidth] = useState(gridWidth);\n  const columnsCanFlex: boolean = columns.length === viewportColumns.length;\n  const ignorePreviouslyMeasuredColumnsOnGridWidthChange =\n    // Allow columns to flex again when...\n    columnsCanFlex &&\n    // there is enough space for columns to flex and the grid was resized\n    gridWidth !== prevGridWidth;\n  const newTemplateColumns = [...templateColumns];\n  const columnsToMeasure: string[] = [];\n\n  for (const { key, idx, width } of viewportColumns) {\n    const columnWidth = columnWidths.get(key);\n    if (key === columnToAutoResize?.key) {\n      newTemplateColumns[idx] =\n        columnToAutoResize.width === 'max-content'\n          ? columnToAutoResize.width\n          : `${columnToAutoResize.width}px`;\n      columnsToMeasure.push(key);\n    } else if (\n      typeof width === 'string' &&\n      // If the column is resized by the user, we don't want to measure it again\n      columnWidth?.type !== 'resized' &&\n      (ignorePreviouslyMeasuredColumnsOnGridWidthChange ||\n        columnsToMeasureOnResize?.has(key) === true ||\n        columnWidth === undefined)\n    ) {\n      newTemplateColumns[idx] = width;\n      columnsToMeasure.push(key);\n    }\n  }\n\n  const gridTemplateColumns = newTemplateColumns.join(' ');\n\n  useLayoutEffect(updateMeasuredAndResizedWidths);\n\n  function updateMeasuredAndResizedWidths() {\n    setPreviousGridWidth(gridWidth);\n    if (columnsToMeasure.length === 0) return;\n\n    const newColumnWidths = new Map(columnWidths);\n    let hasChanges = false;\n\n    for (const key of columnsToMeasure) {\n      const measuredWidth = measureColumnWidth(gridRef, key);\n      hasChanges ||= measuredWidth !== columnWidths.get(key)?.width;\n      if (measuredWidth === undefined) {\n        newColumnWidths.delete(key);\n      } else {\n        newColumnWidths.set(key, { type: 'measured', width: measuredWidth });\n      }\n    }\n\n    if (columnToAutoResize !== null) {\n      const resizingKey = columnToAutoResize.key;\n      const oldWidth = columnWidths.get(resizingKey)?.width;\n      const newWidth = measureColumnWidth(gridRef, resizingKey);\n      if (newWidth !== undefined && oldWidth !== newWidth) {\n        hasChanges = true;\n        newColumnWidths.set(resizingKey, {\n          type: 'resized',\n          width: newWidth\n        });\n      }\n      setColumnToAutoResize(null);\n    }\n\n    if (hasChanges) {\n      onColumnWidthsChange(newColumnWidths);\n    }\n  }\n\n  function handleColumnResize(column: CalculatedColumn<R, SR>, nextWidth: ResizedWidth) {\n    const { key: resizingKey } = column;\n\n    flushSync(() => {\n      if (columnsCanFlex) {\n        // remeasure all the columns that can flex and are not resized by the user\n        const columnsToRemeasure = new Set<string>();\n        for (const { key, width } of viewportColumns) {\n          if (\n            resizingKey !== key &&\n            typeof width === 'string' &&\n            columnWidths.get(key)?.type !== 'resized'\n          ) {\n            columnsToRemeasure.add(key);\n          }\n        }\n\n        setColumnsToMeasureOnResize(columnsToRemeasure);\n      }\n\n      setColumnToAutoResize({\n        key: resizingKey,\n        width: nextWidth\n      });\n\n      setColumnResizing(typeof nextWidth === 'number');\n    });\n\n    setColumnsToMeasureOnResize(null);\n\n    if (onColumnResize) {\n      const previousWidth = columnWidths.get(resizingKey)?.width;\n      const newWidth =\n        typeof nextWidth === 'number' ? nextWidth : measureColumnWidth(gridRef, resizingKey);\n      if (newWidth !== undefined && newWidth !== previousWidth) {\n        onColumnResize(column, newWidth);\n      }\n    }\n  }\n\n  return {\n    gridTemplateColumns,\n    handleColumnResize\n  } as const;\n}\n\nfunction measureColumnWidth(gridRef: React.RefObject<HTMLDivElement | null>, key: string) {\n  const selector = `[data-measuring-cell-key=\"${CSS.escape(key)}\"]`;\n  const measuringCell = gridRef.current?.querySelector(selector);\n  return measuringCell?.getBoundingClientRect().width;\n}\n","import { useLayoutEffect, useRef, useState } from 'react';\nimport { flushSync } from 'react-dom';\n\nexport function useGridDimensions() {\n  const gridRef = useRef<HTMLDivElement>(null);\n  const [inlineSize, setInlineSize] = useState(1);\n  const [blockSize, setBlockSize] = useState(1);\n  const [horizontalScrollbarHeight, setHorizontalScrollbarHeight] = useState(0);\n\n  useLayoutEffect(() => {\n    const { ResizeObserver } = window;\n\n    // don't break in Node.js (SSR), jsdom, and browsers that don't support ResizeObserver\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n    if (ResizeObserver == null) return;\n\n    const { clientWidth, clientHeight, offsetWidth, offsetHeight } = gridRef.current!;\n    const { width, height } = gridRef.current!.getBoundingClientRect();\n    const initialHorizontalScrollbarHeight = offsetHeight - clientHeight;\n    const initialWidth = width - offsetWidth + clientWidth;\n    const initialHeight = height - initialHorizontalScrollbarHeight;\n\n    setInlineSize(initialWidth);\n    setBlockSize(initialHeight);\n    setHorizontalScrollbarHeight(initialHorizontalScrollbarHeight);\n\n    const resizeObserver = new ResizeObserver((entries) => {\n      const size = entries[0].contentBoxSize[0];\n      const { clientHeight, offsetHeight } = gridRef.current!;\n\n      // we use flushSync here to avoid flashing scrollbars\n      flushSync(() => {\n        setInlineSize(size.inlineSize);\n        setBlockSize(size.blockSize);\n        setHorizontalScrollbarHeight(offsetHeight - clientHeight);\n      });\n    });\n    resizeObserver.observe(gridRef.current!);\n\n    return () => {\n      resizeObserver.disconnect();\n    };\n  }, []);\n\n  return [gridRef, inlineSize, blockSize, horizontalScrollbarHeight] as const;\n}\n","import { useCallback, useLayoutEffect, useRef } from 'react';\n\nimport type { Maybe } from '../types';\n\n// https://reactjs.org/docs/hooks-faq.html#what-can-i-do-if-my-effect-dependencies-change-too-often\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function useLatestFunc<T extends Maybe<(...args: any[]) => any>>(fn: T): T {\n  const ref = useRef(fn);\n\n  useLayoutEffect(() => {\n    ref.current = fn;\n  });\n\n  const callbackFn = useCallback((...args: Parameters<NonNullable<T>>) => {\n    ref.current!(...args);\n  }, []);\n\n  // @ts-expect-error\n  return fn ? callbackFn : fn;\n}\n","import { useState } from 'react';\n\n// https://www.w3.org/WAI/ARIA/apg/practices/keyboard-interface/#kbd_general_within\nexport function useRovingTabIndex(isSelected: boolean) {\n  // https://www.w3.org/WAI/ARIA/apg/patterns/grid/#keyboardinteraction-settingfocusandnavigatinginsidecells\n  const [isChildFocused, setIsChildFocused] = useState(false);\n\n  if (isChildFocused && !isSelected) {\n    setIsChildFocused(false);\n  }\n\n  function onFocus(event: React.FocusEvent<HTMLDivElement>) {\n    // Do not steal focus if event originates from a focusable child\n    if (event.target === event.currentTarget) {\n      const elementToFocus = event.currentTarget.querySelector<Element & HTMLOrSVGElement>(\n        '[tabindex=\"0\"]'\n      );\n\n      // Focus cell content when available instead of the cell itself\n      if (elementToFocus !== null) {\n        elementToFocus.focus({ preventScroll: true });\n        setIsChildFocused(true);\n      } else {\n        setIsChildFocused(false);\n      }\n    } else {\n      setIsChildFocused(true);\n    }\n  }\n\n  const isFocusable = isSelected && !isChildFocused;\n\n  return {\n    tabIndex: isFocusable ? 0 : -1,\n    childTabIndex: isSelected ? 0 : -1,\n    onFocus: isSelected ? onFocus : undefined\n  };\n}\n","import { useMemo } from 'react';\n\nimport { getColSpan } from '../utils';\nimport type { CalculatedColumn, Maybe } from '../types';\n\ninterface ViewportColumnsArgs<R, SR> {\n  columns: readonly CalculatedColumn<R, SR>[];\n  colSpanColumns: readonly CalculatedColumn<R, SR>[];\n  rows: readonly R[];\n  topSummaryRows: Maybe<readonly SR[]>;\n  bottomSummaryRows: Maybe<readonly SR[]>;\n  colOverscanStartIdx: number;\n  colOverscanEndIdx: number;\n  lastFrozenColumnIndex: number;\n  rowOverscanStartIdx: number;\n  rowOverscanEndIdx: number;\n}\n\nexport function useViewportColumns<R, SR>({\n  columns,\n  colSpanColumns,\n  rows,\n  topSummaryRows,\n  bottomSummaryRows,\n  colOverscanStartIdx,\n  colOverscanEndIdx,\n  lastFrozenColumnIndex,\n  rowOverscanStartIdx,\n  rowOverscanEndIdx\n}: ViewportColumnsArgs<R, SR>) {\n  // find the column that spans over a column within the visible columns range and adjust colOverscanStartIdx\n  const startIdx = useMemo(() => {\n    if (colOverscanStartIdx === 0) return 0;\n\n    let startIdx = colOverscanStartIdx;\n\n    const updateStartIdx = (colIdx: number, colSpan: number | undefined) => {\n      if (colSpan !== undefined && colIdx + colSpan > colOverscanStartIdx) {\n        startIdx = colIdx;\n        return true;\n      }\n      return false;\n    };\n\n    for (const column of colSpanColumns) {\n      // check header row\n      const colIdx = column.idx;\n      if (colIdx >= startIdx) break;\n      if (updateStartIdx(colIdx, getColSpan(column, lastFrozenColumnIndex, { type: 'HEADER' }))) {\n        break;\n      }\n\n      // check viewport rows\n      for (let rowIdx = rowOverscanStartIdx; rowIdx <= rowOverscanEndIdx; rowIdx++) {\n        const row = rows[rowIdx];\n        if (\n          updateStartIdx(colIdx, getColSpan(column, lastFrozenColumnIndex, { type: 'ROW', row }))\n        ) {\n          break;\n        }\n      }\n\n      // check summary rows\n      if (topSummaryRows != null) {\n        for (const row of topSummaryRows) {\n          if (\n            updateStartIdx(\n              colIdx,\n              getColSpan(column, lastFrozenColumnIndex, { type: 'SUMMARY', row })\n            )\n          ) {\n            break;\n          }\n        }\n      }\n\n      if (bottomSummaryRows != null) {\n        for (const row of bottomSummaryRows) {\n          if (\n            updateStartIdx(\n              colIdx,\n              getColSpan(column, lastFrozenColumnIndex, { type: 'SUMMARY', row })\n            )\n          ) {\n            break;\n          }\n        }\n      }\n    }\n\n    return startIdx;\n  }, [\n    rowOverscanStartIdx,\n    rowOverscanEndIdx,\n    rows,\n    topSummaryRows,\n    bottomSummaryRows,\n    colOverscanStartIdx,\n    lastFrozenColumnIndex,\n    colSpanColumns\n  ]);\n\n  return useMemo((): readonly CalculatedColumn<R, SR>[] => {\n    const viewportColumns: CalculatedColumn<R, SR>[] = [];\n    for (let colIdx = 0; colIdx <= colOverscanEndIdx; colIdx++) {\n      const column = columns[colIdx];\n\n      if (colIdx < startIdx && !column.frozen) continue;\n      viewportColumns.push(column);\n    }\n\n    return viewportColumns;\n  }, [startIdx, colOverscanEndIdx, columns]);\n}\n","import { useMemo } from 'react';\n\nimport { floor, max, min } from '../utils';\n\ninterface ViewportRowsArgs<R> {\n  rows: readonly R[];\n  rowHeight: number | ((row: R) => number);\n  clientHeight: number;\n  scrollTop: number;\n  enableVirtualization: boolean;\n}\n\nexport function useViewportRows<R>({\n  rows,\n  rowHeight,\n  clientHeight,\n  scrollTop,\n  enableVirtualization\n}: ViewportRowsArgs<R>) {\n  const { totalRowHeight, gridTemplateRows, getRowTop, getRowHeight, findRowIdx } = useMemo(() => {\n    if (typeof rowHeight === 'number') {\n      return {\n        totalRowHeight: rowHeight * rows.length,\n        gridTemplateRows: ` repeat(${rows.length}, ${rowHeight}px)`,\n        getRowTop: (rowIdx: number) => rowIdx * rowHeight,\n        getRowHeight: () => rowHeight,\n        findRowIdx: (offset: number) => floor(offset / rowHeight)\n      };\n    }\n\n    // Calcule the height of all the rows upfront. This can cause performance issues\n    // and we can consider using a similar approach as react-window\n    // https://github.com/bvaughn/react-window/blob/b0a470cc264e9100afcaa1b78ed59d88f7914ad4/src/VariableSizeList.js#L68\n    let totalRowHeight = 0;\n    let gridTemplateRows = '';\n    let currentHeight: number | null = null;\n    let repeatCount = 0;\n\n    const rowPositions = rows.map((row, index) => {\n      const currentRowHeight = rowHeight(row);\n\n      const position = {\n        top: totalRowHeight,\n        height: currentRowHeight\n      };\n      totalRowHeight += currentRowHeight;\n\n      if (currentHeight === null) {\n        currentHeight = currentRowHeight;\n        repeatCount = 1;\n      } else if (currentHeight === currentRowHeight) {\n        // If the current row height is the same as the previous one, increment the repeat count\n        repeatCount++;\n      } else {\n        if (repeatCount > 1) {\n          gridTemplateRows += `repeat(${repeatCount}, ${currentHeight}px) `;\n        } else {\n          gridTemplateRows += `${currentHeight}px `;\n        }\n\n        currentHeight = currentRowHeight;\n        repeatCount = 1;\n      }\n\n      if (index === rows.length - 1) {\n        if (repeatCount > 1) {\n          gridTemplateRows += `repeat(${repeatCount}, ${currentHeight}px)`;\n        } else {\n          gridTemplateRows += `${currentHeight}px`;\n        }\n      }\n\n      return position;\n    });\n\n    const validateRowIdx = (rowIdx: number) => {\n      return max(0, min(rows.length - 1, rowIdx));\n    };\n\n    return {\n      totalRowHeight,\n      gridTemplateRows,\n      getRowTop: (rowIdx: number) => rowPositions[validateRowIdx(rowIdx)].top,\n      getRowHeight: (rowIdx: number) => rowPositions[validateRowIdx(rowIdx)].height,\n      findRowIdx(offset: number) {\n        let start = 0;\n        let end = rowPositions.length - 1;\n        while (start <= end) {\n          const middle = start + floor((end - start) / 2);\n          const currentOffset = rowPositions[middle].top;\n\n          if (currentOffset === offset) return middle;\n\n          if (currentOffset < offset) {\n            start = middle + 1;\n          } else if (currentOffset > offset) {\n            end = middle - 1;\n          }\n\n          if (start > end) return end;\n        }\n        return 0;\n      }\n    };\n  }, [rowHeight, rows]);\n\n  let rowOverscanStartIdx = 0;\n  let rowOverscanEndIdx = rows.length - 1;\n\n  if (enableVirtualization) {\n    const overscanThreshold = 4;\n    const rowVisibleStartIdx = findRowIdx(scrollTop);\n    const rowVisibleEndIdx = findRowIdx(scrollTop + clientHeight);\n    rowOverscanStartIdx = max(0, rowVisibleStartIdx - overscanThreshold);\n    rowOverscanEndIdx = min(rows.length - 1, rowVisibleEndIdx + overscanThreshold);\n  }\n\n  return {\n    rowOverscanStartIdx,\n    rowOverscanEndIdx,\n    totalRowHeight,\n    gridTemplateRows,\n    getRowTop,\n    getRowHeight,\n    findRowIdx\n  };\n}\n","import { memo, type MouseEvent } from 'react';\nimport { css } from 'ecij';\n\nimport { useRovingTabIndex } from './hooks';\nimport { createCellEvent, getCellClassname, getCellStyle, isCellEditableUtil } from './utils';\nimport type { CellMouseEventHandler, CellRendererProps } from './types';\n\nconst cellDraggedOver = css`\n  @layer rdg.Cell {\n    background-color: #ccccff;\n  }\n`;\n\nconst cellDraggedOverClassname = `rdg-cell-dragged-over ${cellDraggedOver}`;\n\nfunction Cell<R, SR>({\n  column,\n  colSpan,\n  isCellSelected,\n  isDraggedOver,\n  row,\n  rowIdx,\n  className,\n  onMouseDown,\n  onCellMouseDown,\n  onClick,\n  onCellClick,\n  onDoubleClick,\n  onCellDoubleClick,\n  onContextMenu,\n  onCellContextMenu,\n  onRowChange,\n  selectCell,\n  style,\n  ...props\n}: CellRendererProps<R, SR>) {\n  const { tabIndex, childTabIndex, onFocus } = useRovingTabIndex(isCellSelected);\n\n  const { cellClass } = column;\n  className = getCellClassname(\n    column,\n    {\n      [cellDraggedOverClassname]: isDraggedOver\n    },\n    typeof cellClass === 'function' ? cellClass(row) : cellClass,\n    className\n  );\n  const isEditable = isCellEditableUtil(column, row);\n\n  function selectCellWrapper(enableEditor?: boolean) {\n    selectCell({ rowIdx, idx: column.idx }, { enableEditor });\n  }\n\n  function handleMouseEvent(\n    event: React.MouseEvent<HTMLDivElement>,\n    eventHandler?: CellMouseEventHandler<R, SR>\n  ) {\n    let eventHandled = false;\n    if (eventHandler) {\n      const cellEvent = createCellEvent(event);\n      eventHandler({ rowIdx, row, column, selectCell: selectCellWrapper }, cellEvent);\n      eventHandled = cellEvent.isGridDefaultPrevented();\n    }\n    return eventHandled;\n  }\n\n  function handleMouseDown(event: MouseEvent<HTMLDivElement>) {\n    onMouseDown?.(event);\n    if (!handleMouseEvent(event, onCellMouseDown)) {\n      // select cell if the event is not prevented\n      selectCellWrapper();\n    }\n  }\n\n  function handleClick(event: MouseEvent<HTMLDivElement>) {\n    onClick?.(event);\n    handleMouseEvent(event, onCellClick);\n  }\n\n  function handleDoubleClick(event: MouseEvent<HTMLDivElement>) {\n    onDoubleClick?.(event);\n    if (!handleMouseEvent(event, onCellDoubleClick)) {\n      // go into edit mode if the event is not prevented\n      selectCellWrapper(true);\n    }\n  }\n\n  function handleContextMenu(event: MouseEvent<HTMLDivElement>) {\n    onContextMenu?.(event);\n    handleMouseEvent(event, onCellContextMenu);\n  }\n\n  function handleRowChange(newRow: R) {\n    onRowChange(column, newRow);\n  }\n\n  return (\n    <div\n      role=\"gridcell\"\n      aria-colindex={column.idx + 1} // aria-colindex is 1-based\n      aria-colspan={colSpan}\n      aria-selected={isCellSelected}\n      aria-readonly={!isEditable || undefined}\n      tabIndex={tabIndex}\n      className={className}\n      style={{\n        ...getCellStyle(column, colSpan),\n        ...style\n      }}\n      onClick={handleClick}\n      onMouseDown={handleMouseDown}\n      onDoubleClick={handleDoubleClick}\n      onContextMenu={handleContextMenu}\n      onFocus={onFocus}\n      {...props}\n    >\n      {column.renderCell({\n        column,\n        row,\n        rowIdx,\n        isCellEditable: isEditable,\n        tabIndex: childTabIndex,\n        onRowChange: handleRowChange\n      })}\n    </div>\n  );\n}\n\nconst CellComponent = memo(Cell) as <R, SR>(props: CellRendererProps<R, SR>) => React.JSX.Element;\n\nexport default CellComponent;\n\nexport function defaultRenderCell<R, SR>(key: React.Key, props: CellRendererProps<R, SR>) {\n  return <CellComponent key={key} {...props} />;\n}\n","import { useEffectEvent, useLayoutEffect, useRef } from 'react';\nimport { css } from 'ecij';\n\nimport { createCellEvent, getCellClassname, getCellStyle, onEditorNavigation } from './utils';\nimport type {\n  CellKeyboardEvent,\n  CellRendererProps,\n  EditCellKeyDownArgs,\n  Maybe,\n  Omit,\n  RenderEditCellProps\n} from './types';\n\ndeclare global {\n  const scheduler: Scheduler | undefined;\n}\n\ninterface Scheduler {\n  readonly postTask?: (\n    callback: () => void,\n    options?: {\n      priority?: 'user-blocking' | 'user-visible' | 'background';\n      signal?: AbortSignal;\n      delay?: number;\n    }\n  ) => Promise<unknown>;\n}\n\n/*\n * To check for outside `mousedown` events, we listen to all `mousedown` events at their birth,\n * i.e. on the window during the capture phase, and at their death, i.e. on the window during the bubble phase.\n *\n * We schedule a check at the birth of the event, cancel the check when the event reaches the \"inside\" container,\n * and trigger the \"outside\" callback when the event bubbles back up to the window.\n *\n * The event can be `stopPropagation()`ed halfway through, so they may not always bubble back up to the window,\n * so an alternative check must be used. The check must happen after the event can reach the \"inside\" container,\n * and not before it run to completion. `postTask`/`requestAnimationFrame` are the best way we know to achieve this.\n * Usually we want click event handlers from parent components to access the latest commited values,\n * so `mousedown` is used instead of `click`.\n *\n * We must also rely on React's event capturing/bubbling to handle elements rendered in a portal.\n */\n\nconst canUsePostTask = typeof scheduler === 'object' && typeof scheduler.postTask === 'function';\n\nconst cellEditing = css`\n  @layer rdg.EditCell {\n    padding: 0;\n  }\n`;\n\ntype SharedCellRendererProps<R, SR> = Pick<CellRendererProps<R, SR>, 'colSpan'>;\n\ninterface EditCellProps<R, SR>\n  extends\n    Omit<RenderEditCellProps<R, SR>, 'onRowChange' | 'onClose'>,\n    SharedCellRendererProps<R, SR> {\n  rowIdx: number;\n  onRowChange: (row: R, commitChanges: boolean, shouldFocusCell: boolean) => void;\n  closeEditor: (shouldFocusCell: boolean) => void;\n  navigate: (event: React.KeyboardEvent<HTMLDivElement>) => void;\n  onKeyDown: Maybe<(args: EditCellKeyDownArgs<R, SR>, event: CellKeyboardEvent) => void>;\n}\n\nexport default function EditCell<R, SR>({\n  column,\n  colSpan,\n  row,\n  rowIdx,\n  onRowChange,\n  closeEditor,\n  onKeyDown,\n  navigate\n}: EditCellProps<R, SR>) {\n  const captureEventRef = useRef<MouseEvent | undefined>(undefined);\n  const abortControllerRef = useRef<AbortController>(undefined);\n  const frameRequestRef = useRef<number>(undefined);\n  const commitOnOutsideClick = column.editorOptions?.commitOnOutsideClick ?? true;\n\n  // We need to prevent the `useLayoutEffect` from cleaning up between re-renders,\n  // as `onWindowCaptureMouseDown` might otherwise miss valid mousedown events.\n  // To that end we instead access the latest props via useLatestFunc.\n  const commitOnOutsideMouseDown = useEffectEvent(() => {\n    onClose(true, false);\n  });\n\n  useLayoutEffect(() => {\n    if (!commitOnOutsideClick) return;\n\n    function onWindowCaptureMouseDown(event: MouseEvent) {\n      captureEventRef.current = event;\n\n      if (canUsePostTask) {\n        const abortController = new AbortController();\n        const { signal } = abortController;\n        abortControllerRef.current = abortController;\n        // Use postTask to ensure that the event is not called in the middle of a React render\n        // and that it is called before the next paint.\n        scheduler\n          .postTask(commitOnOutsideMouseDown, {\n            priority: 'user-blocking',\n            signal\n          })\n          // ignore abort errors\n          .catch(() => {});\n      } else {\n        frameRequestRef.current = requestAnimationFrame(commitOnOutsideMouseDown);\n      }\n    }\n\n    function onWindowMouseDown(event: MouseEvent) {\n      if (captureEventRef.current === event) {\n        commitOnOutsideMouseDown();\n      }\n    }\n\n    addEventListener('mousedown', onWindowCaptureMouseDown, { capture: true });\n    addEventListener('mousedown', onWindowMouseDown);\n\n    return () => {\n      removeEventListener('mousedown', onWindowCaptureMouseDown, { capture: true });\n      removeEventListener('mousedown', onWindowMouseDown);\n      cancelTask();\n    };\n  }, [commitOnOutsideClick]);\n\n  function cancelTask() {\n    captureEventRef.current = undefined;\n    if (abortControllerRef.current !== undefined) {\n      abortControllerRef.current.abort();\n      abortControllerRef.current = undefined;\n    }\n    if (frameRequestRef.current !== undefined) {\n      cancelAnimationFrame(frameRequestRef.current);\n      frameRequestRef.current = undefined;\n    }\n  }\n\n  function handleKeyDown(event: React.KeyboardEvent<HTMLDivElement>) {\n    if (onKeyDown) {\n      const cellEvent = createCellEvent(event);\n      onKeyDown(\n        {\n          mode: 'EDIT',\n          row,\n          column,\n          rowIdx,\n          navigate() {\n            navigate(event);\n          },\n          onClose\n        },\n        cellEvent\n      );\n      if (cellEvent.isGridDefaultPrevented()) return;\n    }\n\n    if (event.key === 'Escape') {\n      // Discard changes\n      onClose();\n    } else if (event.key === 'Enter') {\n      onClose(true);\n    } else if (onEditorNavigation(event)) {\n      navigate(event);\n    }\n  }\n\n  function onClose(commitChanges = false, shouldFocusCell = true) {\n    if (commitChanges) {\n      onRowChange(row, true, shouldFocusCell);\n    } else {\n      closeEditor(shouldFocusCell);\n    }\n  }\n\n  function onEditorRowChange(row: R, commitChangesAndFocus = false) {\n    onRowChange(row, commitChangesAndFocus, commitChangesAndFocus);\n  }\n\n  const { cellClass } = column;\n  const className = getCellClassname(\n    column,\n    'rdg-editor-container',\n    !column.editorOptions?.displayCellContent && cellEditing,\n    typeof cellClass === 'function' ? cellClass(row) : cellClass\n  );\n\n  return (\n    <div\n      role=\"gridcell\"\n      aria-colindex={column.idx + 1} // aria-colindex is 1-based\n      aria-colspan={colSpan}\n      aria-selected\n      className={className}\n      style={getCellStyle(column, colSpan)}\n      onKeyDown={handleKeyDown}\n      onMouseDownCapture={cancelTask}\n    >\n      {column.renderEditCell != null && (\n        <>\n          {column.renderEditCell({\n            column,\n            row,\n            rowIdx,\n            onRowChange: onEditorRowChange,\n            onClose\n          })}\n          {column.editorOptions?.displayCellContent &&\n            column.renderCell({\n              column,\n              row,\n              rowIdx,\n              isCellEditable: true,\n              tabIndex: -1,\n              onRowChange: onEditorRowChange\n            })}\n        </>\n      )}\n    </div>\n  );\n}\n","import { useRovingTabIndex } from './hooks';\nimport { classnames, getHeaderCellRowSpan, getHeaderCellStyle } from './utils';\nimport type { CalculatedColumnParent } from './types';\nimport type { GroupedColumnHeaderRowProps } from './GroupedColumnHeaderRow';\nimport { cellClassname } from './style/cell';\n\ntype SharedGroupedColumnHeaderRowProps<R, SR> = Pick<\n  GroupedColumnHeaderRowProps<R, SR>,\n  'rowIdx' | 'selectCell'\n>;\n\ninterface GroupedColumnHeaderCellProps<R, SR> extends SharedGroupedColumnHeaderRowProps<R, SR> {\n  column: CalculatedColumnParent<R, SR>;\n  isCellSelected: boolean;\n}\n\nexport default function GroupedColumnHeaderCell<R, SR>({\n  column,\n  rowIdx,\n  isCellSelected,\n  selectCell\n}: GroupedColumnHeaderCellProps<R, SR>) {\n  const { tabIndex, onFocus } = useRovingTabIndex(isCellSelected);\n  const { colSpan } = column;\n  const rowSpan = getHeaderCellRowSpan(column, rowIdx);\n  const index = column.idx + 1;\n\n  function onMouseDown() {\n    selectCell({ idx: column.idx, rowIdx });\n  }\n\n  return (\n    <div\n      role=\"columnheader\"\n      aria-colindex={index}\n      aria-colspan={colSpan}\n      aria-rowspan={rowSpan}\n      aria-selected={isCellSelected}\n      tabIndex={tabIndex}\n      className={classnames(cellClassname, column.headerCellClass)}\n      style={{\n        ...getHeaderCellStyle(column, rowIdx, rowSpan),\n        gridColumnStart: index,\n        gridColumnEnd: index + colSpan\n      }}\n      onFocus={onFocus}\n      onMouseDown={onMouseDown}\n    >\n      {column.name}\n    </div>\n  );\n}\n","import { useRef, useState } from 'react';\nimport { flushSync } from 'react-dom';\nimport { css } from 'ecij';\n\nimport { useRovingTabIndex } from './hooks';\nimport {\n  clampColumnWidth,\n  getCellClassname,\n  getCellStyle,\n  getHeaderCellRowSpan,\n  getHeaderCellStyle,\n  getLeftRightKey,\n  isCtrlKeyHeldDown,\n  stopPropagation\n} from './utils';\nimport type { CalculatedColumn, SortColumn } from './types';\nimport type { HeaderRowProps } from './HeaderRow';\n\nconst cellSortableClassname = css`\n  @layer rdg.HeaderCell {\n    cursor: pointer;\n  }\n`;\n\nconst cellResizable = css`\n  @layer rdg.HeaderCell {\n    touch-action: none;\n  }\n`;\n\nconst cellResizableClassname = `rdg-cell-resizable ${cellResizable}`;\n\nconst resizeHandle = css`\n  @layer rdg.HeaderCell {\n    cursor: col-resize;\n    position: absolute;\n    inset-block-start: 0;\n    inset-inline-end: 0;\n    inset-block-end: 0;\n    inline-size: 10px;\n  }\n`;\n\nconst resizeHandleClassname = `rdg-resize-handle ${resizeHandle}`;\n\nconst cellDraggableClassname = 'rdg-cell-draggable';\n\nconst cellDragging = css`\n  @layer rdg.HeaderCell {\n    background-color: var(--rdg-header-draggable-background-color);\n  }\n`;\n\nconst cellDraggingClassname = `rdg-cell-dragging ${cellDragging}`;\n\nconst cellOver = css`\n  @layer rdg.HeaderCell {\n    background-color: var(--rdg-header-draggable-background-color);\n  }\n`;\n\nconst cellOverClassname = `rdg-cell-drag-over ${cellOver}`;\n\nconst dragImageClassname = css`\n  @layer rdg.HeaderCell {\n    border-radius: 4px;\n    width: fit-content;\n    outline: 2px solid hsl(207, 100%, 50%);\n    outline-offset: -2px;\n  }\n`;\n\ntype SharedHeaderRowProps<R, SR> = Pick<\n  HeaderRowProps<R, SR, React.Key>,\n  | 'sortColumns'\n  | 'onSortColumnsChange'\n  | 'selectCell'\n  | 'onColumnResize'\n  | 'onColumnResizeEnd'\n  | 'shouldFocusGrid'\n  | 'direction'\n  | 'onColumnsReorder'\n>;\n\nexport interface HeaderCellProps<R, SR> extends SharedHeaderRowProps<R, SR> {\n  column: CalculatedColumn<R, SR>;\n  colSpan: number | undefined;\n  rowIdx: number;\n  isCellSelected: boolean;\n  draggedColumnKey: string | undefined;\n  setDraggedColumnKey: (draggedColumnKey: string | undefined) => void;\n}\n\nexport default function HeaderCell<R, SR>({\n  column,\n  colSpan,\n  rowIdx,\n  isCellSelected,\n  onColumnResize,\n  onColumnResizeEnd,\n  onColumnsReorder,\n  sortColumns,\n  onSortColumnsChange,\n  selectCell,\n  shouldFocusGrid,\n  direction,\n  draggedColumnKey,\n  setDraggedColumnKey\n}: HeaderCellProps<R, SR>) {\n  const [isOver, setIsOver] = useState(false);\n  const dragImageRef = useRef<HTMLDivElement>(null);\n  const isDragging = draggedColumnKey === column.key;\n  const rowSpan = getHeaderCellRowSpan(column, rowIdx);\n  // set the tabIndex to 0 when there is no selected cell so grid can receive focus\n  const { tabIndex, childTabIndex, onFocus } = useRovingTabIndex(shouldFocusGrid || isCellSelected);\n  const sortIndex = sortColumns?.findIndex((sort) => sort.columnKey === column.key);\n  const sortColumn =\n    sortIndex !== undefined && sortIndex > -1 ? sortColumns![sortIndex] : undefined;\n  const sortDirection = sortColumn?.direction;\n  const priority = sortColumn !== undefined && sortColumns!.length > 1 ? sortIndex! + 1 : undefined;\n  const ariaSort =\n    sortDirection && !priority ? (sortDirection === 'ASC' ? 'ascending' : 'descending') : undefined;\n  const { sortable, resizable, draggable } = column;\n\n  const className = getCellClassname(column, column.headerCellClass, {\n    [cellSortableClassname]: sortable,\n    [cellResizableClassname]: resizable,\n    [cellDraggableClassname]: draggable,\n    [cellDraggingClassname]: isDragging,\n    [cellOverClassname]: isOver\n  });\n\n  function onSort(ctrlClick: boolean) {\n    if (onSortColumnsChange == null) return;\n    const { sortDescendingFirst } = column;\n    if (sortColumn === undefined) {\n      // not currently sorted\n      const nextSort: SortColumn = {\n        columnKey: column.key,\n        direction: sortDescendingFirst ? 'DESC' : 'ASC'\n      };\n      onSortColumnsChange(sortColumns && ctrlClick ? [...sortColumns, nextSort] : [nextSort]);\n    } else {\n      let nextSortColumn: SortColumn | undefined;\n      if (\n        (sortDescendingFirst === true && sortDirection === 'DESC') ||\n        (sortDescendingFirst !== true && sortDirection === 'ASC')\n      ) {\n        nextSortColumn = {\n          columnKey: column.key,\n          direction: sortDirection === 'ASC' ? 'DESC' : 'ASC'\n        };\n      }\n      if (ctrlClick) {\n        const nextSortColumns = [...sortColumns!];\n        if (nextSortColumn) {\n          // swap direction\n          nextSortColumns[sortIndex!] = nextSortColumn;\n        } else {\n          // remove sort\n          nextSortColumns.splice(sortIndex!, 1);\n        }\n        onSortColumnsChange(nextSortColumns);\n      } else {\n        onSortColumnsChange(nextSortColumn ? [nextSortColumn] : []);\n      }\n    }\n  }\n\n  function handleFocus(event: React.FocusEvent<HTMLDivElement>) {\n    onFocus?.(event);\n    if (shouldFocusGrid) {\n      // Select the first header cell if there is no selected cell\n      selectCell({ idx: 0, rowIdx });\n    }\n  }\n\n  function onMouseDown() {\n    selectCell({ idx: column.idx, rowIdx });\n  }\n\n  function onClick(event: React.MouseEvent<HTMLSpanElement>) {\n    if (sortable) {\n      onSort(event.ctrlKey || event.metaKey);\n    }\n  }\n\n  function onKeyDown(event: React.KeyboardEvent<HTMLSpanElement>) {\n    const { key } = event;\n    if (sortable && (key === ' ' || key === 'Enter')) {\n      // prevent scrolling\n      event.preventDefault();\n      onSort(event.ctrlKey || event.metaKey);\n    } else if (\n      resizable &&\n      isCtrlKeyHeldDown(event) &&\n      (key === 'ArrowLeft' || key === 'ArrowRight')\n    ) {\n      // prevent navigation\n      // TODO: check if we can use `preventDefault` instead\n      event.stopPropagation();\n      const { width } = event.currentTarget.getBoundingClientRect();\n      const { leftKey } = getLeftRightKey(direction);\n      const offset = key === leftKey ? -10 : 10;\n      const newWidth = clampColumnWidth(width + offset, column);\n      if (newWidth !== width) {\n        onColumnResize(column, newWidth);\n      }\n    }\n  }\n\n  function onDragStart(event: React.DragEvent<HTMLDivElement>) {\n    // need flushSync to make sure the drag image is rendered before the drag starts\n    flushSync(() => {\n      setDraggedColumnKey(column.key);\n    });\n    event.dataTransfer.setDragImage(dragImageRef.current!, 0, 0);\n    event.dataTransfer.dropEffect = 'move';\n  }\n\n  function onDragEnd() {\n    setDraggedColumnKey(undefined);\n  }\n\n  function onDragOver(event: React.DragEvent<HTMLDivElement>) {\n    // prevent default to allow drop\n    event.preventDefault();\n    event.dataTransfer.dropEffect = 'move';\n  }\n\n  function onDrop(event: React.DragEvent<HTMLDivElement>) {\n    setIsOver(false);\n    // prevent the browser from redirecting in some cases\n    event.preventDefault();\n    onColumnsReorder?.(draggedColumnKey!, column.key);\n  }\n\n  function onDragEnter(event: React.DragEvent<HTMLDivElement>) {\n    if (isEventPertinent(event)) {\n      setIsOver(true);\n    }\n  }\n\n  function onDragLeave(event: React.DragEvent<HTMLDivElement>) {\n    if (isEventPertinent(event)) {\n      setIsOver(false);\n    }\n  }\n\n  let dragTargetProps: React.ComponentProps<'div'> | undefined;\n  let dropTargetProps: React.ComponentProps<'div'> | undefined;\n  if (draggable) {\n    dragTargetProps = {\n      draggable: true,\n      onDragStart,\n      onDragEnd\n    };\n\n    if (draggedColumnKey !== undefined && draggedColumnKey !== column.key) {\n      dropTargetProps = {\n        onDragOver,\n        onDragEnter,\n        onDragLeave,\n        onDrop\n      };\n    }\n  }\n\n  const style: React.CSSProperties = {\n    ...getHeaderCellStyle(column, rowIdx, rowSpan),\n    ...getCellStyle(column, colSpan)\n  };\n\n  const content = column.renderHeaderCell({\n    column,\n    sortDirection,\n    priority,\n    tabIndex: childTabIndex\n  });\n\n  return (\n    <>\n      {isDragging && (\n        <div\n          ref={dragImageRef}\n          style={style}\n          className={getCellClassname(column, column.headerCellClass, dragImageClassname)}\n        >\n          {content}\n        </div>\n      )}\n      <div\n        role=\"columnheader\"\n        aria-colindex={column.idx + 1}\n        aria-colspan={colSpan}\n        aria-rowspan={rowSpan}\n        aria-selected={isCellSelected}\n        aria-sort={ariaSort}\n        tabIndex={tabIndex}\n        className={className}\n        style={style}\n        onMouseDown={onMouseDown}\n        onFocus={handleFocus}\n        onClick={onClick}\n        onKeyDown={onKeyDown}\n        {...dragTargetProps}\n        {...dropTargetProps}\n      >\n        {content}\n\n        {resizable && (\n          <ResizeHandle\n            direction={direction}\n            column={column}\n            onColumnResize={onColumnResize}\n            onColumnResizeEnd={onColumnResizeEnd}\n          />\n        )}\n      </div>\n    </>\n  );\n}\n\ntype ResizeHandleProps<R, SR> = Pick<\n  HeaderCellProps<R, SR>,\n  'direction' | 'column' | 'onColumnResize' | 'onColumnResizeEnd'\n>;\n\nfunction ResizeHandle<R, SR>({\n  direction,\n  column,\n  onColumnResize,\n  onColumnResizeEnd\n}: ResizeHandleProps<R, SR>) {\n  const resizingOffsetRef = useRef<number>(undefined);\n  const isRtl = direction === 'rtl';\n\n  function onPointerDown(event: React.PointerEvent<HTMLDivElement>) {\n    if (event.pointerType === 'mouse' && event.buttons !== 1) {\n      return;\n    }\n\n    // Fix column resizing on a draggable column in FF\n    event.preventDefault();\n\n    const { currentTarget, pointerId } = event;\n    currentTarget.setPointerCapture(pointerId);\n    const headerCell = currentTarget.parentElement!;\n    const { right, left } = headerCell.getBoundingClientRect();\n    resizingOffsetRef.current = isRtl ? event.clientX - left : right - event.clientX;\n  }\n\n  function onPointerMove(event: React.PointerEvent<HTMLDivElement>) {\n    const offset = resizingOffsetRef.current;\n    if (offset === undefined) return;\n    const { width, right, left } = event.currentTarget.parentElement!.getBoundingClientRect();\n    let newWidth = isRtl ? right + offset - event.clientX : event.clientX + offset - left;\n    newWidth = clampColumnWidth(newWidth, column);\n    if (width > 0 && newWidth !== width) {\n      onColumnResize(column, newWidth);\n    }\n  }\n\n  function onLostPointerCapture() {\n    onColumnResizeEnd();\n    resizingOffsetRef.current = undefined;\n  }\n\n  function onDoubleClick() {\n    onColumnResize(column, 'max-content');\n  }\n\n  return (\n    <div\n      aria-hidden\n      className={resizeHandleClassname}\n      onClick={stopPropagation}\n      onPointerDown={onPointerDown}\n      onPointerMove={onPointerMove}\n      // we are not using pointerup because it does not fire in some cases\n      // pointer down -> alt+tab -> pointer up over another window -> pointerup event not fired\n      onLostPointerCapture={onLostPointerCapture}\n      onDoubleClick={onDoubleClick}\n    />\n  );\n}\n\n// only accept pertinent drag events:\n// - ignore drag events going from the container to an element inside the container\n// - ignore drag events going from an element inside the container to the container\nfunction isEventPertinent(event: React.DragEvent) {\n  const relatedTarget = event.relatedTarget as HTMLElement | null;\n\n  return !event.currentTarget.contains(relatedTarget);\n}\n","import { css } from 'ecij';\n\nexport const row = css`\n  @layer rdg.Row {\n    display: contents;\n    background-color: var(--rdg-background-color);\n\n    &:hover {\n      background-color: var(--rdg-row-hover-background-color);\n    }\n\n    &[aria-selected='true'] {\n      background-color: var(--rdg-row-selected-background-color);\n\n      &:hover {\n        background-color: var(--rdg-row-selected-hover-background-color);\n      }\n    }\n  }\n`;\n\nexport const rowClassname = `rdg-row ${row}`;\n\nexport const rowSelected = css`\n  @layer rdg.FocusSink {\n    outline: 2px solid var(--rdg-selection-color);\n    outline-offset: -2px;\n  }\n`;\n\nexport const rowSelectedClassname = 'rdg-row-selected';\n\nexport const rowSelectedWithFrozenCell = css`\n  @layer rdg.FocusSink {\n    &::before {\n      content: '';\n      display: inline-block;\n      block-size: 100%;\n      position: sticky;\n      inset-inline-start: 0;\n      border-inline-start: 2px solid var(--rdg-selection-color);\n    }\n  }\n`;\n\nexport const topSummaryRowClassname = 'rdg-top-summary-row';\n\nexport const bottomSummaryRowClassname = 'rdg-bottom-summary-row';\n","import { memo, useState } from 'react';\nimport { css } from 'ecij';\n\nimport { classnames, getColSpan } from './utils';\nimport type { CalculatedColumn, Direction, Maybe, Position, ResizedWidth } from './types';\nimport type { DataGridProps } from './DataGrid';\nimport HeaderCell from './HeaderCell';\nimport { cell, cellFrozen } from './style/cell';\nimport { rowSelectedClassname } from './style/row';\n\ntype SharedDataGridProps<R, SR, K extends React.Key> = Pick<\n  DataGridProps<R, SR, K>,\n  'sortColumns' | 'onSortColumnsChange' | 'onColumnsReorder'\n>;\n\nexport interface HeaderRowProps<R, SR, K extends React.Key> extends SharedDataGridProps<R, SR, K> {\n  rowIdx: number;\n  columns: readonly CalculatedColumn<R, SR>[];\n  onColumnResize: (column: CalculatedColumn<R, SR>, width: ResizedWidth) => void;\n  onColumnResizeEnd: () => void;\n  selectCell: (position: Position) => void;\n  lastFrozenColumnIndex: number;\n  selectedCellIdx: number | undefined;\n  shouldFocusGrid: boolean;\n  direction: Direction;\n  headerRowClass: Maybe<string>;\n}\n\nconst headerRow = css`\n  @layer rdg.HeaderRow {\n    display: contents;\n    background-color: var(--rdg-header-background-color);\n    font-weight: bold;\n\n    & > .${cell} {\n      /* Should have a higher value than 1 to show up above regular cells and the focus sink */\n      z-index: 2;\n      position: sticky;\n    }\n\n    & > .${cellFrozen} {\n      z-index: 3;\n    }\n  }\n`;\n\nexport const headerRowClassname = `rdg-header-row ${headerRow}`;\n\nfunction HeaderRow<R, SR, K extends React.Key>({\n  headerRowClass,\n  rowIdx,\n  columns,\n  onColumnResize,\n  onColumnResizeEnd,\n  onColumnsReorder,\n  sortColumns,\n  onSortColumnsChange,\n  lastFrozenColumnIndex,\n  selectedCellIdx,\n  selectCell,\n  shouldFocusGrid,\n  direction\n}: HeaderRowProps<R, SR, K>) {\n  const [draggedColumnKey, setDraggedColumnKey] = useState<string>();\n\n  const cells = [];\n  for (let index = 0; index < columns.length; index++) {\n    const column = columns[index];\n    const colSpan = getColSpan(column, lastFrozenColumnIndex, { type: 'HEADER' });\n    if (colSpan !== undefined) {\n      index += colSpan - 1;\n    }\n\n    cells.push(\n      <HeaderCell<R, SR>\n        key={column.key}\n        column={column}\n        colSpan={colSpan}\n        rowIdx={rowIdx}\n        isCellSelected={selectedCellIdx === column.idx}\n        onColumnResize={onColumnResize}\n        onColumnResizeEnd={onColumnResizeEnd}\n        onColumnsReorder={onColumnsReorder}\n        onSortColumnsChange={onSortColumnsChange}\n        sortColumns={sortColumns}\n        selectCell={selectCell}\n        shouldFocusGrid={shouldFocusGrid && index === 0}\n        direction={direction}\n        draggedColumnKey={draggedColumnKey}\n        setDraggedColumnKey={setDraggedColumnKey}\n      />\n    );\n  }\n\n  return (\n    <div\n      role=\"row\"\n      aria-rowindex={rowIdx} // aria-rowindex is 1 based\n      className={classnames(\n        headerRowClassname,\n        {\n          [rowSelectedClassname]: selectedCellIdx === -1\n        },\n        headerRowClass\n      )}\n    >\n      {cells}\n    </div>\n  );\n}\n\nexport default memo(HeaderRow) as <R, SR, K extends React.Key>(\n  props: HeaderRowProps<R, SR, K>\n) => React.JSX.Element;\n","import { memo } from 'react';\n\nimport type { CalculatedColumn, CalculatedColumnParent, Position } from './types';\nimport GroupedColumnHeaderCell from './GroupedColumnHeaderCell';\nimport { headerRowClassname } from './HeaderRow';\n\nexport interface GroupedColumnHeaderRowProps<R, SR> {\n  rowIdx: number;\n  level: number;\n  columns: readonly CalculatedColumn<R, SR>[];\n  selectCell: (position: Position) => void;\n  selectedCellIdx: number | undefined;\n}\n\nfunction GroupedColumnHeaderRow<R, SR>({\n  rowIdx,\n  level,\n  columns,\n  selectedCellIdx,\n  selectCell\n}: GroupedColumnHeaderRowProps<R, SR>) {\n  const cells = [];\n  const renderedParents = new Set<CalculatedColumnParent<R, SR>>();\n\n  for (const column of columns) {\n    let { parent } = column;\n\n    if (parent === undefined) continue;\n\n    while (parent.level > level) {\n      if (parent.parent === undefined) break;\n      parent = parent.parent;\n    }\n\n    if (parent.level === level && !renderedParents.has(parent)) {\n      renderedParents.add(parent);\n      const { idx } = parent;\n      cells.push(\n        <GroupedColumnHeaderCell<R, SR>\n          key={idx}\n          column={parent}\n          rowIdx={rowIdx}\n          isCellSelected={selectedCellIdx === idx}\n          selectCell={selectCell}\n        />\n      );\n    }\n  }\n\n  return (\n    <div\n      role=\"row\"\n      aria-rowindex={rowIdx} // aria-rowindex is 1 based\n      className={headerRowClassname}\n    >\n      {cells}\n    </div>\n  );\n}\n\nexport default memo(GroupedColumnHeaderRow) as <R, SR>(\n  props: GroupedColumnHeaderRowProps<R, SR>\n) => React.JSX.Element;\n","import { memo, useMemo } from 'react';\n\nimport { RowSelectionContext, useLatestFunc, type RowSelectionContextValue } from './hooks';\nimport { classnames, getColSpan, getRowStyle } from './utils';\nimport type { CalculatedColumn, RenderRowProps } from './types';\nimport { useDefaultRenderers } from './DataGridDefaultRenderersContext';\nimport { rowClassname, rowSelectedClassname } from './style/row';\n\nfunction Row<R, SR>({\n  className,\n  rowIdx,\n  gridRowStart,\n  selectedCellIdx,\n  isRowSelectionDisabled,\n  isRowSelected,\n  draggedOverCellIdx,\n  lastFrozenColumnIndex,\n  row,\n  viewportColumns,\n  selectedCellEditor,\n  onCellMouseDown,\n  onCellClick,\n  onCellDoubleClick,\n  onCellContextMenu,\n  rowClass,\n  onRowChange,\n  selectCell,\n  style,\n  ...props\n}: RenderRowProps<R, SR>) {\n  const renderCell = useDefaultRenderers<R, SR>()!.renderCell!;\n\n  const handleRowChange = useLatestFunc((column: CalculatedColumn<R, SR>, newRow: R) => {\n    onRowChange(column, rowIdx, newRow);\n  });\n\n  className = classnames(\n    rowClassname,\n    `rdg-row-${rowIdx % 2 === 0 ? 'even' : 'odd'}`,\n    {\n      [rowSelectedClassname]: selectedCellIdx === -1\n    },\n    rowClass?.(row, rowIdx),\n    className\n  );\n\n  const cells = [];\n\n  for (let index = 0; index < viewportColumns.length; index++) {\n    const column = viewportColumns[index];\n    const { idx } = column;\n    const colSpan = getColSpan(column, lastFrozenColumnIndex, { type: 'ROW', row });\n    if (colSpan !== undefined) {\n      index += colSpan - 1;\n    }\n\n    const isCellSelected = selectedCellIdx === idx;\n\n    if (isCellSelected && selectedCellEditor) {\n      cells.push(selectedCellEditor);\n    } else {\n      cells.push(\n        renderCell(column.key, {\n          column,\n          colSpan,\n          row,\n          rowIdx,\n          isDraggedOver: draggedOverCellIdx === idx,\n          isCellSelected,\n          onCellMouseDown,\n          onCellClick,\n          onCellDoubleClick,\n          onCellContextMenu,\n          onRowChange: handleRowChange,\n          selectCell\n        })\n      );\n    }\n  }\n\n  const selectionValue = useMemo(\n    (): RowSelectionContextValue => ({ isRowSelected, isRowSelectionDisabled }),\n    [isRowSelectionDisabled, isRowSelected]\n  );\n\n  return (\n    <RowSelectionContext value={selectionValue}>\n      <div\n        role=\"row\"\n        className={className}\n        style={{\n          ...getRowStyle(gridRowStart),\n          ...style\n        }}\n        {...props}\n      >\n        {cells}\n      </div>\n    </RowSelectionContext>\n  );\n}\n\nconst RowComponent = memo(Row) as <R, SR>(props: RenderRowProps<R, SR>) => React.JSX.Element;\n\nexport default RowComponent;\n\nexport function defaultRenderRow<R, SR>(key: React.Key, props: RenderRowProps<R, SR>) {\n  return <RowComponent key={key} {...props} />;\n}\n","import { useLayoutEffect, useRef } from 'react';\n\nimport { scrollIntoView } from './utils';\n\nexport interface PartialPosition {\n  readonly idx?: number | undefined;\n  readonly rowIdx?: number | undefined;\n}\n\nexport default function ScrollToCell({\n  scrollToPosition: { idx, rowIdx },\n  gridRef,\n  setScrollToCellPosition\n}: {\n  scrollToPosition: PartialPosition;\n  gridRef: React.RefObject<HTMLDivElement | null>;\n  setScrollToCellPosition: (cell: null) => void;\n}) {\n  const ref = useRef<HTMLDivElement>(null);\n\n  useLayoutEffect(() => {\n    // scroll until the cell is completely visible\n    // this is needed if the grid has auto-sized columns\n    // setting the behavior to auto so it can be overridden\n    scrollIntoView(ref.current, 'auto');\n  });\n\n  useLayoutEffect(() => {\n    function removeScrollToCell() {\n      setScrollToCellPosition(null);\n    }\n\n    const observer = new IntersectionObserver(removeScrollToCell, {\n      root: gridRef.current!,\n      threshold: 1.0\n    });\n\n    observer.observe(ref.current!);\n\n    return () => {\n      observer.disconnect();\n    };\n  }, [gridRef, setScrollToCellPosition]);\n\n  return (\n    <div\n      ref={ref}\n      style={{\n        gridColumn: idx === undefined ? '1/-1' : idx + 1,\n        gridRow: rowIdx === undefined ? '1/-1' : rowIdx + 2\n      }}\n    />\n  );\n}\n","import { css } from 'ecij';\n\nimport type { RenderSortIconProps, RenderSortPriorityProps, RenderSortStatusProps } from './types';\n\nconst arrow = css`\n  @layer rdg.SortIcon {\n    fill: currentColor;\n\n    > path {\n      transition: d 0.1s;\n    }\n  }\n`;\n\nconst arrowClassname = `rdg-sort-arrow ${arrow}`;\n\nexport default function renderSortStatus({ sortDirection, priority }: RenderSortStatusProps) {\n  return (\n    <>\n      {renderSortIcon({ sortDirection })}\n      {renderSortPriority({ priority })}\n    </>\n  );\n}\n\nexport function renderSortIcon({ sortDirection }: RenderSortIconProps) {\n  if (sortDirection === undefined) return null;\n\n  return (\n    <svg viewBox=\"0 0 12 8\" width=\"12\" height=\"8\" className={arrowClassname} aria-hidden>\n      <path d={sortDirection === 'ASC' ? 'M0 8 6 0 12 8' : 'M0 0 6 8 12 0'} />\n    </svg>\n  );\n}\n\nexport function renderSortPriority({ priority }: RenderSortPriorityProps) {\n  return priority;\n}\n","import { css } from 'ecij';\n\nimport { cell } from './cell';\nimport { bottomSummaryRowClassname, row, topSummaryRowClassname } from './row';\n\nconst root = css`\n  @layer rdg.Defaults {\n    *,\n    *::before,\n    *::after {\n      box-sizing: inherit;\n    }\n  }\n\n  @layer rdg.Root {\n    --rdg-selection-width: 2px;\n    --rdg-selection-color: hsl(207, 75%, 66%);\n    --rdg-font-size: 14px;\n    --rdg-cell-frozen-box-shadow: 2px 0 5px -2px rgba(136, 136, 136, 0.3);\n    --rdg-border-width: 1px;\n    --rdg-summary-border-width: calc(var(--rdg-border-width) * 2);\n    --rdg-color: light-dark(#000, #ddd);\n    --rdg-border-color: light-dark(#ddd, #444);\n    --rdg-summary-border-color: light-dark(#aaa, #555);\n    --rdg-background-color: light-dark(hsl(0deg 0% 100%), hsl(0deg 0% 13%));\n    --rdg-header-background-color: light-dark(hsl(0deg 0% 97.5%), hsl(0deg 0% 10.5%));\n    --rdg-header-draggable-background-color: light-dark(hsl(0deg 0% 90.5%), hsl(0deg 0% 17.5%));\n    --rdg-row-hover-background-color: light-dark(hsl(0deg 0% 96%), hsl(0deg 0% 9%));\n    --rdg-row-selected-background-color: light-dark(hsl(207deg 76% 92%), hsl(207deg 76% 42%));\n    --rdg-row-selected-hover-background-color: light-dark(hsl(207deg 76% 88%), hsl(207deg 76% 38%));\n    --rdg-checkbox-focus-color: hsl(207deg 100% 69%);\n\n    &.rdg-dark {\n      --rdg-color-scheme: dark;\n    }\n\n    &.rdg-light {\n      --rdg-color-scheme: light;\n    }\n\n    color-scheme: var(--rdg-color-scheme, light dark);\n\n    &:dir(rtl) {\n      --rdg-cell-frozen-box-shadow: -2px 0 5px -2px rgba(136, 136, 136, 0.3);\n    }\n\n    display: grid;\n\n    accent-color: light-dark(hsl(207deg 100% 29%), hsl(207deg 100% 79%));\n\n    /* https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Positioning/Understanding_z_index/The_stacking_context */\n    /* We set a stacking context so internal elements don't render on top of external elements. */\n    /* size containment is not used as it could break \"width: min-content\" for example, and the grid would infinitely resize on Chromium browsers */\n    contain: content;\n    content-visibility: auto;\n    block-size: 350px;\n    border: 1px solid var(--rdg-border-color);\n    box-sizing: border-box;\n    overflow: auto;\n    background-color: var(--rdg-background-color);\n    color: var(--rdg-color);\n    font-size: var(--rdg-font-size);\n\n    /* needed on Firefox to fix scrollbars */\n    &::before {\n      content: '';\n      grid-column: 1/-1;\n      grid-row: 1/-1;\n    }\n\n    > :nth-last-child(1 of .${topSummaryRowClassname}) {\n      > .${cell} {\n        border-block-end: var(--rdg-summary-border-width) solid var(--rdg-summary-border-color);\n      }\n    }\n\n    > :nth-child(1 of .${bottomSummaryRowClassname}) {\n      > .${cell} {\n        border-block-start: var(--rdg-summary-border-width) solid var(--rdg-summary-border-color);\n      }\n    }\n  }\n`;\n\nexport const rootClassname = `rdg ${root}`;\n\nconst viewportDragging = css`\n  @layer rdg.Root {\n    user-select: none;\n\n    & .${row} {\n      cursor: move;\n    }\n  }\n`;\n\nexport const viewportDraggingClassname = `rdg-viewport-dragging ${viewportDragging}`;\n\nexport const focusSinkClassname = css`\n  @layer rdg.FocusSink {\n    grid-column: 1/-1;\n    pointer-events: none;\n    /* Should have a higher value than 1 to show up above regular frozen cells */\n    z-index: 1;\n  }\n`;\n\nexport const focusSinkHeaderAndSummaryClassname = css`\n  @layer rdg.FocusSink {\n    /* Should have a higher value than 3 to show up above header and summary rows */\n    z-index: 3;\n  }\n`;\n","import { memo } from 'react';\nimport { css } from 'ecij';\n\nimport { useRovingTabIndex } from './hooks';\nimport { getCellClassname, getCellStyle } from './utils';\nimport type { CellRendererProps } from './types';\n\nexport const summaryCellClassname = css`\n  @layer rdg.SummaryCell {\n    inset-block-start: var(--rdg-summary-row-top);\n    inset-block-end: var(--rdg-summary-row-bottom);\n  }\n`;\n\ntype SharedCellRendererProps<R, SR> = Pick<\n  CellRendererProps<R, SR>,\n  'rowIdx' | 'column' | 'colSpan' | 'isCellSelected' | 'selectCell'\n>;\n\ninterface SummaryCellProps<R, SR> extends SharedCellRendererProps<R, SR> {\n  row: SR;\n}\n\nfunction SummaryCell<R, SR>({\n  column,\n  colSpan,\n  row,\n  rowIdx,\n  isCellSelected,\n  selectCell\n}: SummaryCellProps<R, SR>) {\n  const { tabIndex, childTabIndex, onFocus } = useRovingTabIndex(isCellSelected);\n  const { summaryCellClass } = column;\n  const className = getCellClassname(\n    column,\n    summaryCellClassname,\n    typeof summaryCellClass === 'function' ? summaryCellClass(row) : summaryCellClass\n  );\n\n  function onMouseDown() {\n    selectCell({ rowIdx, idx: column.idx });\n  }\n\n  return (\n    <div\n      role=\"gridcell\"\n      aria-colindex={column.idx + 1}\n      aria-colspan={colSpan}\n      aria-selected={isCellSelected}\n      tabIndex={tabIndex}\n      className={className}\n      style={getCellStyle(column, colSpan)}\n      onMouseDown={onMouseDown}\n      onFocus={onFocus}\n    >\n      {column.renderSummaryCell?.({ column, row, tabIndex: childTabIndex })}\n    </div>\n  );\n}\n\nexport default memo(SummaryCell) as <R, SR>(props: SummaryCellProps<R, SR>) => React.JSX.Element;\n","import { memo } from 'react';\nimport { css } from 'ecij';\n\nimport { classnames, getColSpan, getRowStyle } from './utils';\nimport type { RenderRowProps } from './types';\nimport { cell, cellFrozen } from './style/cell';\nimport {\n  bottomSummaryRowClassname,\n  rowClassname,\n  rowSelectedClassname,\n  topSummaryRowClassname\n} from './style/row';\nimport SummaryCell from './SummaryCell';\n\ntype SharedRenderRowProps<R, SR> = Pick<\n  RenderRowProps<R, SR>,\n  'viewportColumns' | 'rowIdx' | 'gridRowStart' | 'selectCell'\n>;\n\ninterface SummaryRowProps<R, SR> extends SharedRenderRowProps<R, SR> {\n  'aria-rowindex': number;\n  row: SR;\n  top: number | undefined;\n  bottom: number | undefined;\n  lastFrozenColumnIndex: number;\n  selectedCellIdx: number | undefined;\n  isTop: boolean;\n}\n\nconst summaryRow = css`\n  @layer rdg.SummaryRow {\n    > .${cell} {\n      position: sticky;\n    }\n  }\n`;\n\nconst topSummaryRow = css`\n  @layer rdg.SummaryRow {\n    > .${cell} {\n      z-index: 2;\n    }\n\n    > .${cellFrozen} {\n      z-index: 3;\n    }\n  }\n`;\n\nconst summaryRowClassname = `rdg-summary-row ${summaryRow}`;\n\nfunction SummaryRow<R, SR>({\n  rowIdx,\n  gridRowStart,\n  row,\n  viewportColumns,\n  top,\n  bottom,\n  lastFrozenColumnIndex,\n  selectedCellIdx,\n  isTop,\n  selectCell,\n  'aria-rowindex': ariaRowIndex\n}: SummaryRowProps<R, SR>) {\n  const cells = [];\n  for (let index = 0; index < viewportColumns.length; index++) {\n    const column = viewportColumns[index];\n    const colSpan = getColSpan(column, lastFrozenColumnIndex, { type: 'SUMMARY', row });\n    if (colSpan !== undefined) {\n      index += colSpan - 1;\n    }\n\n    const isCellSelected = selectedCellIdx === column.idx;\n\n    cells.push(\n      <SummaryCell<R, SR>\n        key={column.key}\n        column={column}\n        colSpan={colSpan}\n        row={row}\n        rowIdx={rowIdx}\n        isCellSelected={isCellSelected}\n        selectCell={selectCell}\n      />\n    );\n  }\n\n  return (\n    <div\n      role=\"row\"\n      aria-rowindex={ariaRowIndex}\n      className={classnames(\n        rowClassname,\n        `rdg-row-${rowIdx % 2 === 0 ? 'even' : 'odd'}`,\n        summaryRowClassname,\n        {\n          [rowSelectedClassname]: selectedCellIdx === -1,\n          [`${topSummaryRowClassname} ${topSummaryRow}`]: isTop,\n          [bottomSummaryRowClassname]: !isTop\n        }\n      )}\n      style={{\n        ...getRowStyle(gridRowStart),\n        '--rdg-summary-row-top': top !== undefined ? `${top}px` : undefined,\n        '--rdg-summary-row-bottom': bottom !== undefined ? `${bottom}px` : undefined\n      }}\n    >\n      {cells}\n    </div>\n  );\n}\n\nexport default memo(SummaryRow) as <R, SR>(props: SummaryRowProps<R, SR>) => React.JSX.Element;\n","import {\n  useCallback,\n  useImperativeHandle,\n  useLayoutEffect,\n  useMemo,\n  useRef,\n  useState\n} from 'react';\nimport type { Key, KeyboardEvent } from 'react';\nimport { flushSync } from 'react-dom';\n\nimport {\n  HeaderRowSelectionChangeContext,\n  HeaderRowSelectionContext,\n  RowSelectionChangeContext,\n  useCalculatedColumns,\n  useColumnWidths,\n  useGridDimensions,\n  useLatestFunc,\n  useViewportColumns,\n  useViewportRows,\n  type HeaderRowSelectionContextValue\n} from './hooks';\nimport {\n  abs,\n  assertIsValidKeyGetter,\n  canExitGrid,\n  classnames,\n  createCellEvent,\n  getCellStyle,\n  getColSpan,\n  getLeftRightKey,\n  getNextSelectedCellPosition,\n  isCtrlKeyHeldDown,\n  isDefaultCellInput,\n  isSelectedCellEditable,\n  renderMeasuringCells,\n  scrollIntoView,\n  sign\n} from './utils';\nimport type {\n  CalculatedColumn,\n  CellClipboardEvent,\n  CellCopyArgs,\n  CellKeyboardEvent,\n  CellKeyDownArgs,\n  CellMouseEventHandler,\n  CellNavigationMode,\n  CellPasteArgs,\n  CellSelectArgs,\n  Column,\n  ColumnOrColumnGroup,\n  ColumnWidths,\n  Direction,\n  FillEvent,\n  Maybe,\n  Position,\n  Renderers,\n  RowsChangeData,\n  SelectCellOptions,\n  SelectHeaderRowEvent,\n  SelectRowEvent,\n  SortColumn\n} from './types';\nimport { defaultRenderCell } from './Cell';\nimport { renderCheckbox as defaultRenderCheckbox } from './cellRenderers';\nimport {\n  DataGridDefaultRenderersContext,\n  useDefaultRenderers\n} from './DataGridDefaultRenderersContext';\nimport EditCell from './EditCell';\nimport GroupedColumnHeaderRow from './GroupedColumnHeaderRow';\nimport HeaderRow from './HeaderRow';\nimport { defaultRenderRow } from './Row';\nimport type { PartialPosition } from './ScrollToCell';\nimport ScrollToCell from './ScrollToCell';\nimport { default as defaultRenderSortStatus } from './sortStatus';\nimport { cellDragHandleClassname, cellDragHandleFrozenClassname } from './style/cell';\nimport {\n  focusSinkClassname,\n  focusSinkHeaderAndSummaryClassname,\n  rootClassname,\n  viewportDraggingClassname\n} from './style/core';\nimport { rowSelected, rowSelectedWithFrozenCell } from './style/row';\nimport SummaryRow from './SummaryRow';\n\nexport interface SelectCellState extends Position {\n  readonly mode: 'SELECT';\n}\n\ninterface EditCellState<R> extends Position {\n  readonly mode: 'EDIT';\n  readonly row: R;\n  readonly originalRow: R;\n}\n\nexport type DefaultColumnOptions<R, SR> = Pick<\n  Column<R, SR>,\n  | 'renderCell'\n  | 'renderHeaderCell'\n  | 'width'\n  | 'minWidth'\n  | 'maxWidth'\n  | 'resizable'\n  | 'sortable'\n  | 'draggable'\n>;\n\nexport interface DataGridHandle {\n  element: HTMLDivElement | null;\n  scrollToCell: (position: PartialPosition) => void;\n  selectCell: (position: Position, options?: SelectCellOptions) => void;\n}\n\ntype SharedDivProps = Pick<\n  React.ComponentProps<'div'>,\n  | 'role'\n  | 'aria-label'\n  | 'aria-labelledby'\n  | 'aria-description'\n  | 'aria-describedby'\n  | 'aria-rowcount'\n  | 'className'\n  | 'style'\n>;\n\nexport interface DataGridProps<R, SR = unknown, K extends Key = Key> extends SharedDivProps {\n  ref?: Maybe<React.Ref<DataGridHandle>>;\n  /**\n   * Grid and data Props\n   */\n  /** An array of column definitions */\n  columns: readonly ColumnOrColumnGroup<NoInfer<R>, NoInfer<SR>>[];\n  /** A function called for each rendered row that should return a plain key/value pair object */\n  rows: readonly R[];\n  /** Rows pinned at the top of the grid for summary purposes */\n  topSummaryRows?: Maybe<readonly SR[]>;\n  /** Rows pinned at the bottom of the grid for summary purposes */\n  bottomSummaryRows?: Maybe<readonly SR[]>;\n  /** Function to return a unique key/identifier for each row */\n  rowKeyGetter?: Maybe<(row: NoInfer<R>) => K>;\n  /** Callback triggered when rows are changed */\n  onRowsChange?: Maybe<(rows: NoInfer<R>[], data: RowsChangeData<NoInfer<R>, NoInfer<SR>>) => void>;\n\n  /**\n   * Dimensions props\n   */\n  /**\n   * Height of each row in pixels\n   * @default 35\n   */\n  rowHeight?: Maybe<number | ((row: NoInfer<R>) => number)>;\n  /**\n   * Height of the header row in pixels\n   * @default 35\n   */\n  headerRowHeight?: Maybe<number>;\n  /**\n   * Height of each summary row in pixels\n   * @default 35\n   */\n  summaryRowHeight?: Maybe<number>;\n  /** A map of column widths */\n  columnWidths?: Maybe<ColumnWidths>;\n  /** Callback triggered when column widths change */\n  onColumnWidthsChange?: Maybe<(columnWidths: ColumnWidths) => void>;\n\n  /**\n   * Feature props\n   */\n  /** A set of selected row keys */\n  selectedRows?: Maybe<ReadonlySet<K>>;\n  /** Function to determine if row selection is disabled for a specific row */\n  isRowSelectionDisabled?: Maybe<(row: NoInfer<R>) => boolean>;\n  /** Callback triggered when the selection changes */\n  onSelectedRowsChange?: Maybe<(selectedRows: Set<NoInfer<K>>) => void>;\n  /** An array of sorted columns */\n  sortColumns?: Maybe<readonly SortColumn[]>;\n  /** Callback triggered when sorting changes */\n  onSortColumnsChange?: Maybe<(sortColumns: SortColumn[]) => void>;\n  /** Default options applied to all columns */\n  defaultColumnOptions?: Maybe<DefaultColumnOptions<NoInfer<R>, NoInfer<SR>>>;\n  onFill?: Maybe<(event: FillEvent<NoInfer<R>>) => NoInfer<R>>;\n\n  /**\n   * Event props\n   */\n  /** Callback triggered when a pointer becomes active in a cell */\n  onCellMouseDown?: CellMouseEventHandler<R, SR>;\n  /** Callback triggered when a cell is clicked */\n  onCellClick?: CellMouseEventHandler<R, SR>;\n  /** Callback triggered when a cell is double-clicked */\n  onCellDoubleClick?: CellMouseEventHandler<R, SR>;\n  /** Callback triggered when a cell is right-clicked */\n  onCellContextMenu?: CellMouseEventHandler<R, SR>;\n  /** Callback triggered when a key is pressed in a cell */\n  onCellKeyDown?: Maybe<\n    (args: CellKeyDownArgs<NoInfer<R>, NoInfer<SR>>, event: CellKeyboardEvent) => void\n  >;\n  /** Callback triggered when a cell's content is copied */\n  onCellCopy?: Maybe<\n    (args: CellCopyArgs<NoInfer<R>, NoInfer<SR>>, event: CellClipboardEvent) => void\n  >;\n  /** Callback triggered when content is pasted into a cell */\n  onCellPaste?: Maybe<\n    (args: CellPasteArgs<NoInfer<R>, NoInfer<SR>>, event: CellClipboardEvent) => NoInfer<R>\n  >;\n  /** Function called whenever cell selection is changed */\n  onSelectedCellChange?: Maybe<(args: CellSelectArgs<NoInfer<R>, NoInfer<SR>>) => void>;\n  /** Callback triggered when the grid is scrolled */\n  onScroll?: Maybe<(event: React.UIEvent<HTMLDivElement>) => void>;\n  /** Callback triggered when column is resized */\n  onColumnResize?: Maybe<(column: CalculatedColumn<R, SR>, width: number) => void>;\n  /** Callback triggered when columns are reordered */\n  onColumnsReorder?: Maybe<(sourceColumnKey: string, targetColumnKey: string) => void>;\n\n  /**\n   * Toggles and modes\n   */\n  /** @default true */\n  enableVirtualization?: Maybe<boolean>;\n\n  /**\n   * Miscellaneous\n   */\n  /** Custom renderers for cells, rows, and other components */\n  renderers?: Maybe<Renderers<NoInfer<R>, NoInfer<SR>>>;\n  /** Function to apply custom class names to rows */\n  rowClass?: Maybe<(row: NoInfer<R>, rowIdx: number) => Maybe<string>>;\n  /** Custom class name for the header row */\n  headerRowClass?: Maybe<string>;\n  /**\n   * Text direction of the grid ('ltr' or 'rtl')\n   * @default 'ltr'\n   */\n  direction?: Maybe<Direction>;\n  'data-testid'?: Maybe<string>;\n  'data-cy'?: Maybe<string>;\n}\n\n/**\n * Main API Component to render a data grid of rows and columns\n *\n * @example\n *\n * <DataGrid columns={columns} rows={rows} />\n */\nexport function DataGrid<R, SR = unknown, K extends Key = Key>(props: DataGridProps<R, SR, K>) {\n  const {\n    ref,\n    // Grid and data Props\n    columns: rawColumns,\n    rows,\n    topSummaryRows,\n    bottomSummaryRows,\n    rowKeyGetter,\n    onRowsChange,\n    // Dimensions props\n    rowHeight: rawRowHeight,\n    headerRowHeight: rawHeaderRowHeight,\n    summaryRowHeight: rawSummaryRowHeight,\n    columnWidths: columnWidthsRaw,\n    onColumnWidthsChange: onColumnWidthsChangeRaw,\n    // Feature props\n    selectedRows,\n    isRowSelectionDisabled,\n    onSelectedRowsChange,\n    sortColumns,\n    onSortColumnsChange,\n    defaultColumnOptions,\n    // Event props\n    onCellMouseDown,\n    onCellClick,\n    onCellDoubleClick,\n    onCellContextMenu,\n    onCellKeyDown,\n    onSelectedCellChange,\n    onScroll,\n    onColumnResize,\n    onColumnsReorder,\n    onFill,\n    onCellCopy,\n    onCellPaste,\n    // Toggles and modes\n    enableVirtualization: rawEnableVirtualization,\n    // Miscellaneous\n    renderers,\n    className,\n    style,\n    rowClass,\n    headerRowClass,\n    direction: rawDirection,\n    // ARIA\n    role: rawRole,\n    'aria-label': ariaLabel,\n    'aria-labelledby': ariaLabelledBy,\n    'aria-description': ariaDescription,\n    'aria-describedby': ariaDescribedBy,\n    'aria-rowcount': rawAriaRowCount,\n    'data-testid': testId,\n    'data-cy': dataCy\n  } = props;\n\n  /**\n   * defaults\n   */\n  const defaultRenderers = useDefaultRenderers<R, SR>();\n  const role = rawRole ?? 'grid';\n  const rowHeight = rawRowHeight ?? 35;\n  const headerRowHeight = rawHeaderRowHeight ?? (typeof rowHeight === 'number' ? rowHeight : 35);\n  const summaryRowHeight = rawSummaryRowHeight ?? (typeof rowHeight === 'number' ? rowHeight : 35);\n  const renderRow = renderers?.renderRow ?? defaultRenderers?.renderRow ?? defaultRenderRow;\n  const renderCell = renderers?.renderCell ?? defaultRenderers?.renderCell ?? defaultRenderCell;\n  const renderSortStatus =\n    renderers?.renderSortStatus ?? defaultRenderers?.renderSortStatus ?? defaultRenderSortStatus;\n  const renderCheckbox =\n    renderers?.renderCheckbox ?? defaultRenderers?.renderCheckbox ?? defaultRenderCheckbox;\n  const noRowsFallback = renderers?.noRowsFallback ?? defaultRenderers?.noRowsFallback;\n  const enableVirtualization = rawEnableVirtualization ?? true;\n  const direction = rawDirection ?? 'ltr';\n\n  /**\n   * states\n   */\n  const [scrollTop, setScrollTop] = useState(0);\n  const [scrollLeft, setScrollLeft] = useState(0);\n  const [columnWidthsInternal, setColumnWidthsInternal] = useState(\n    (): ColumnWidths => columnWidthsRaw ?? new Map()\n  );\n  const [isColumnResizing, setColumnResizing] = useState(false);\n  const [isDragging, setDragging] = useState(false);\n  const [draggedOverRowIdx, setDraggedOverRowIdx] = useState<number | undefined>(undefined);\n  const [scrollToPosition, setScrollToPosition] = useState<PartialPosition | null>(null);\n  const [shouldFocusCell, setShouldFocusCell] = useState(false);\n  const [previousRowIdx, setPreviousRowIdx] = useState(-1);\n\n  const isColumnWidthsControlled =\n    columnWidthsRaw != null && onColumnWidthsChangeRaw != null && !isColumnResizing;\n  const columnWidths = isColumnWidthsControlled ? columnWidthsRaw : columnWidthsInternal;\n  const onColumnWidthsChange = isColumnWidthsControlled\n    ? (columnWidths: ColumnWidths) => {\n        // we keep the internal state in sync with the prop but this prevents an extra render\n        setColumnWidthsInternal(columnWidths);\n        onColumnWidthsChangeRaw(columnWidths);\n      }\n    : setColumnWidthsInternal;\n\n  const getColumnWidth = useCallback(\n    (column: CalculatedColumn<R, SR>) => {\n      return columnWidths.get(column.key)?.width ?? column.width;\n    },\n    [columnWidths]\n  );\n\n  const [gridRef, gridWidth, gridHeight, horizontalScrollbarHeight] = useGridDimensions();\n  const {\n    columns,\n    colSpanColumns,\n    lastFrozenColumnIndex,\n    headerRowsCount,\n    colOverscanStartIdx,\n    colOverscanEndIdx,\n    templateColumns,\n    layoutCssVars,\n    totalFrozenColumnWidth\n  } = useCalculatedColumns({\n    rawColumns,\n    defaultColumnOptions,\n    getColumnWidth,\n    scrollLeft,\n    viewportWidth: gridWidth,\n    enableVirtualization\n  });\n\n  const topSummaryRowsCount = topSummaryRows?.length ?? 0;\n  const bottomSummaryRowsCount = bottomSummaryRows?.length ?? 0;\n  const summaryRowsCount = topSummaryRowsCount + bottomSummaryRowsCount;\n  const headerAndTopSummaryRowsCount = headerRowsCount + topSummaryRowsCount;\n  const groupedColumnHeaderRowsCount = headerRowsCount - 1;\n  const minRowIdx = -headerAndTopSummaryRowsCount;\n  const mainHeaderRowIdx = minRowIdx + groupedColumnHeaderRowsCount;\n  const maxRowIdx = rows.length + bottomSummaryRowsCount - 1;\n\n  const [selectedPosition, setSelectedPosition] = useState(\n    (): SelectCellState | EditCellState<R> => ({ idx: -1, rowIdx: minRowIdx - 1, mode: 'SELECT' })\n  );\n\n  /**\n   * refs\n   */\n  const focusSinkRef = useRef<HTMLDivElement>(null);\n\n  /**\n   * computed values\n   */\n  const isTreeGrid = role === 'treegrid';\n  const headerRowsHeight = headerRowsCount * headerRowHeight;\n  const summaryRowsHeight = summaryRowsCount * summaryRowHeight;\n  const clientHeight = gridHeight - headerRowsHeight - summaryRowsHeight;\n  const isSelectable = selectedRows != null && onSelectedRowsChange != null;\n  const { leftKey, rightKey } = getLeftRightKey(direction);\n  const ariaRowCount = rawAriaRowCount ?? headerRowsCount + rows.length + summaryRowsCount;\n\n  const defaultGridComponents = useMemo(\n    () => ({\n      renderCheckbox,\n      renderSortStatus,\n      renderCell\n    }),\n    [renderCheckbox, renderSortStatus, renderCell]\n  );\n\n  const headerSelectionValue = useMemo((): HeaderRowSelectionContextValue => {\n    // no rows to select = explicitely unchecked\n    let hasSelectedRow = false;\n    let hasUnselectedRow = false;\n\n    if (rowKeyGetter != null && selectedRows != null && selectedRows.size > 0) {\n      for (const row of rows) {\n        if (selectedRows.has(rowKeyGetter(row))) {\n          hasSelectedRow = true;\n        } else {\n          hasUnselectedRow = true;\n        }\n\n        if (hasSelectedRow && hasUnselectedRow) break;\n      }\n    }\n\n    return {\n      isRowSelected: hasSelectedRow && !hasUnselectedRow,\n      isIndeterminate: hasSelectedRow && hasUnselectedRow\n    };\n  }, [rows, selectedRows, rowKeyGetter]);\n\n  const {\n    rowOverscanStartIdx,\n    rowOverscanEndIdx,\n    totalRowHeight,\n    gridTemplateRows,\n    getRowTop,\n    getRowHeight,\n    findRowIdx\n  } = useViewportRows({\n    rows,\n    rowHeight,\n    clientHeight,\n    scrollTop,\n    enableVirtualization\n  });\n\n  const viewportColumns = useViewportColumns({\n    columns,\n    colSpanColumns,\n    colOverscanStartIdx,\n    colOverscanEndIdx,\n    lastFrozenColumnIndex,\n    rowOverscanStartIdx,\n    rowOverscanEndIdx,\n    rows,\n    topSummaryRows,\n    bottomSummaryRows\n  });\n\n  const { gridTemplateColumns, handleColumnResize } = useColumnWidths(\n    columns,\n    viewportColumns,\n    templateColumns,\n    gridRef,\n    gridWidth,\n    columnWidths,\n    onColumnWidthsChange,\n    onColumnResize,\n    setColumnResizing\n  );\n\n  const minColIdx = isTreeGrid ? -1 : 0;\n  const maxColIdx = columns.length - 1;\n  const selectedCellIsWithinSelectionBounds = isCellWithinSelectionBounds(selectedPosition);\n  const selectedCellIsWithinViewportBounds = isCellWithinViewportBounds(selectedPosition);\n  const scrollHeight =\n    headerRowHeight + totalRowHeight + summaryRowsHeight + horizontalScrollbarHeight;\n\n  /**\n   * The identity of the wrapper function is stable so it won't break memoization\n   */\n  const handleColumnResizeLatest = useLatestFunc(handleColumnResize);\n  const handleColumnResizeEndLatest = useLatestFunc(handleColumnResizeEnd);\n  const onColumnsReorderLastest = useLatestFunc(onColumnsReorder);\n  const onSortColumnsChangeLatest = useLatestFunc(onSortColumnsChange);\n  const onCellMouseDownLatest = useLatestFunc(onCellMouseDown);\n  const onCellClickLatest = useLatestFunc(onCellClick);\n  const onCellDoubleClickLatest = useLatestFunc(onCellDoubleClick);\n  const onCellContextMenuLatest = useLatestFunc(onCellContextMenu);\n  const selectHeaderRowLatest = useLatestFunc(selectHeaderRow);\n  const selectRowLatest = useLatestFunc(selectRow);\n  const handleFormatterRowChangeLatest = useLatestFunc(updateRow);\n  const selectCellLatest = useLatestFunc(selectCell);\n  const selectHeaderCellLatest = useLatestFunc(selectHeaderCell);\n\n  /**\n   * callbacks\n   */\n  const focusCell = useCallback(\n    (shouldScroll = true) => {\n      const cell = getCellToScroll(gridRef.current!);\n      if (cell === null) return;\n\n      if (shouldScroll) {\n        scrollIntoView(cell);\n      }\n\n      cell.focus({ preventScroll: true });\n    },\n    [gridRef]\n  );\n\n  /**\n   * effects\n   */\n  useLayoutEffect(() => {\n    if (shouldFocusCell) {\n      if (focusSinkRef.current !== null && selectedPosition.idx === -1) {\n        focusSinkRef.current.focus({ preventScroll: true });\n        scrollIntoView(focusSinkRef.current);\n      } else {\n        focusCell();\n      }\n      setShouldFocusCell(false);\n    }\n  }, [shouldFocusCell, focusCell, selectedPosition.idx]);\n\n  useImperativeHandle(\n    ref,\n    (): DataGridHandle => ({\n      element: gridRef.current,\n      scrollToCell({ idx, rowIdx }) {\n        const scrollToIdx =\n          idx !== undefined && idx > lastFrozenColumnIndex && idx < columns.length\n            ? idx\n            : undefined;\n        const scrollToRowIdx =\n          rowIdx !== undefined && isRowIdxWithinViewportBounds(rowIdx) ? rowIdx : undefined;\n\n        if (scrollToIdx !== undefined || scrollToRowIdx !== undefined) {\n          setScrollToPosition({ idx: scrollToIdx, rowIdx: scrollToRowIdx });\n        }\n      },\n      selectCell\n    })\n  );\n\n  /**\n   * event handlers\n   */\n  function selectHeaderRow(args: SelectHeaderRowEvent) {\n    if (!onSelectedRowsChange) return;\n\n    assertIsValidKeyGetter<R, K>(rowKeyGetter);\n\n    const newSelectedRows = new Set(selectedRows);\n    for (const row of rows) {\n      if (isRowSelectionDisabled?.(row) === true) continue;\n      const rowKey = rowKeyGetter(row);\n      if (args.checked) {\n        newSelectedRows.add(rowKey);\n      } else {\n        newSelectedRows.delete(rowKey);\n      }\n    }\n    onSelectedRowsChange(newSelectedRows);\n  }\n\n  function selectRow(args: SelectRowEvent<R>) {\n    if (!onSelectedRowsChange) return;\n\n    assertIsValidKeyGetter<R, K>(rowKeyGetter);\n    const { row, checked, isShiftClick } = args;\n    if (isRowSelectionDisabled?.(row) === true) return;\n    const newSelectedRows = new Set(selectedRows);\n    const rowKey = rowKeyGetter(row);\n    const rowIdx = rows.indexOf(row);\n    setPreviousRowIdx(rowIdx);\n\n    if (checked) {\n      newSelectedRows.add(rowKey);\n    } else {\n      newSelectedRows.delete(rowKey);\n    }\n\n    if (\n      isShiftClick &&\n      previousRowIdx !== -1 &&\n      previousRowIdx !== rowIdx &&\n      previousRowIdx < rows.length\n    ) {\n      const step = sign(rowIdx - previousRowIdx);\n      for (let i = previousRowIdx + step; i !== rowIdx; i += step) {\n        const row = rows[i];\n        if (isRowSelectionDisabled?.(row) === true) continue;\n        if (checked) {\n          newSelectedRows.add(rowKeyGetter(row));\n        } else {\n          newSelectedRows.delete(rowKeyGetter(row));\n        }\n      }\n    }\n\n    onSelectedRowsChange(newSelectedRows);\n  }\n\n  function handleKeyDown(event: KeyboardEvent<HTMLDivElement>) {\n    const { idx, rowIdx, mode } = selectedPosition;\n    if (mode === 'EDIT') return;\n\n    if (onCellKeyDown && isRowIdxWithinViewportBounds(rowIdx)) {\n      const row = rows[rowIdx];\n      const cellEvent = createCellEvent(event);\n      onCellKeyDown(\n        {\n          mode: 'SELECT',\n          row,\n          column: columns[idx],\n          rowIdx,\n          selectCell\n        },\n        cellEvent\n      );\n      if (cellEvent.isGridDefaultPrevented()) return;\n    }\n\n    if (!(event.target instanceof Element)) return;\n    const isCellEvent = event.target.closest('.rdg-cell') !== null;\n    const isRowEvent = isTreeGrid && event.target === focusSinkRef.current;\n    if (!isCellEvent && !isRowEvent) return;\n\n    switch (event.key) {\n      case 'ArrowUp':\n      case 'ArrowDown':\n      case 'ArrowLeft':\n      case 'ArrowRight':\n      case 'Tab':\n      case 'Home':\n      case 'End':\n      case 'PageUp':\n      case 'PageDown':\n        navigate(event);\n        break;\n      default:\n        handleCellInput(event);\n        break;\n    }\n  }\n\n  function handleScroll(event: React.UIEvent<HTMLDivElement>) {\n    const { scrollTop, scrollLeft } = event.currentTarget;\n    flushSync(() => {\n      setScrollTop(scrollTop);\n      // scrollLeft is nagative when direction is rtl\n      setScrollLeft(abs(scrollLeft));\n    });\n    onScroll?.(event);\n  }\n\n  function updateRow(column: CalculatedColumn<R, SR>, rowIdx: number, row: R) {\n    if (typeof onRowsChange !== 'function') return;\n    if (row === rows[rowIdx]) return;\n    const updatedRows = rows.with(rowIdx, row);\n    onRowsChange(updatedRows, {\n      indexes: [rowIdx],\n      column\n    });\n  }\n\n  function commitEditorChanges() {\n    if (selectedPosition.mode !== 'EDIT') return;\n    updateRow(columns[selectedPosition.idx], selectedPosition.rowIdx, selectedPosition.row);\n  }\n\n  function handleCellCopy(event: CellClipboardEvent) {\n    if (!selectedCellIsWithinViewportBounds) return;\n    const { idx, rowIdx } = selectedPosition;\n    onCellCopy?.({ row: rows[rowIdx], column: columns[idx] }, event);\n  }\n\n  function handleCellPaste(event: CellClipboardEvent) {\n    if (!onCellPaste || !onRowsChange || !isCellEditable(selectedPosition)) {\n      return;\n    }\n\n    const { idx, rowIdx } = selectedPosition;\n    const column = columns[idx];\n    const updatedRow = onCellPaste({ row: rows[rowIdx], column }, event);\n    updateRow(column, rowIdx, updatedRow);\n  }\n\n  function handleCellInput(event: KeyboardEvent<HTMLDivElement>) {\n    if (!selectedCellIsWithinViewportBounds) return;\n    const row = rows[selectedPosition.rowIdx];\n    const { key, shiftKey } = event;\n\n    // Select the row on Shift + Space\n    if (isSelectable && shiftKey && key === ' ') {\n      assertIsValidKeyGetter<R, K>(rowKeyGetter);\n      const rowKey = rowKeyGetter(row);\n      selectRow({ row, checked: !selectedRows.has(rowKey), isShiftClick: false });\n      // prevent scrolling\n      event.preventDefault();\n      return;\n    }\n\n    if (isCellEditable(selectedPosition) && isDefaultCellInput(event, onCellPaste != null)) {\n      setSelectedPosition(({ idx, rowIdx }) => ({\n        idx,\n        rowIdx,\n        mode: 'EDIT',\n        row,\n        originalRow: row\n      }));\n    }\n  }\n\n  function handleColumnResizeEnd() {\n    // This check is needed as double click on the resize handle triggers onPointerMove\n    if (isColumnResizing) {\n      onColumnWidthsChangeRaw?.(columnWidths);\n      setColumnResizing(false);\n    }\n  }\n\n  function handleDragHandlePointerDown(event: React.PointerEvent<HTMLDivElement>) {\n    // keep the focus on the cell\n    event.preventDefault();\n    if (event.pointerType === 'mouse' && event.buttons !== 1) {\n      return;\n    }\n    setDragging(true);\n    event.currentTarget.setPointerCapture(event.pointerId);\n  }\n\n  function handleDragHandlePointerMove(event: React.PointerEvent<HTMLDivElement>) {\n    // find dragged over row using the pointer position\n    const gridEl = gridRef.current!;\n    const headerAndTopSummaryRowsHeight = headerRowsHeight + topSummaryRowsCount * summaryRowHeight;\n    const offset =\n      scrollTop -\n      headerAndTopSummaryRowsHeight +\n      event.clientY -\n      gridEl.getBoundingClientRect().top;\n    const overRowIdx = findRowIdx(offset);\n    setDraggedOverRowIdx(overRowIdx);\n    const ariaRowIndex = headerAndTopSummaryRowsCount + overRowIdx + 1;\n    const el = gridEl.querySelector(\n      `:scope > [aria-rowindex=\"${ariaRowIndex}\"] > [aria-colindex=\"${selectedPosition.idx + 1}\"]`\n    );\n    scrollIntoView(el);\n  }\n\n  function handleDragHandleLostPointerCapture() {\n    setDragging(false);\n    if (draggedOverRowIdx === undefined) return;\n\n    const { rowIdx } = selectedPosition;\n    const [startRowIndex, endRowIndex] =\n      rowIdx < draggedOverRowIdx\n        ? [rowIdx + 1, draggedOverRowIdx + 1]\n        : [draggedOverRowIdx, rowIdx];\n    updateRows(startRowIndex, endRowIndex);\n    setDraggedOverRowIdx(undefined);\n  }\n\n  function handleDragHandleClick() {\n    // keep the focus on the cell but do not scroll\n    focusCell(false);\n  }\n\n  function handleDragHandleDoubleClick(event: React.MouseEvent<HTMLDivElement>) {\n    event.stopPropagation();\n    updateRows(selectedPosition.rowIdx + 1, rows.length);\n  }\n\n  function updateRows(startRowIdx: number, endRowIdx: number) {\n    if (onRowsChange == null) return;\n\n    const { rowIdx, idx } = selectedPosition;\n    const column = columns[idx];\n    const sourceRow = rows[rowIdx];\n    const updatedRows = [...rows];\n    const indexes: number[] = [];\n    for (let i = startRowIdx; i < endRowIdx; i++) {\n      if (isCellEditable({ rowIdx: i, idx })) {\n        const updatedRow = onFill!({ columnKey: column.key, sourceRow, targetRow: rows[i] });\n        if (updatedRow !== rows[i]) {\n          updatedRows[i] = updatedRow;\n          indexes.push(i);\n        }\n      }\n    }\n\n    if (indexes.length > 0) {\n      onRowsChange(updatedRows, { indexes, column });\n    }\n  }\n\n  /**\n   * utils\n   */\n  function isColIdxWithinSelectionBounds(idx: number) {\n    return idx >= minColIdx && idx <= maxColIdx;\n  }\n\n  function isRowIdxWithinViewportBounds(rowIdx: number) {\n    return rowIdx >= 0 && rowIdx < rows.length;\n  }\n\n  function isCellWithinSelectionBounds({ idx, rowIdx }: Position): boolean {\n    return rowIdx >= minRowIdx && rowIdx <= maxRowIdx && isColIdxWithinSelectionBounds(idx);\n  }\n\n  function isCellWithinEditBounds({ idx, rowIdx }: Position): boolean {\n    return isRowIdxWithinViewportBounds(rowIdx) && idx >= 0 && idx <= maxColIdx;\n  }\n\n  function isCellWithinViewportBounds({ idx, rowIdx }: Position): boolean {\n    return isRowIdxWithinViewportBounds(rowIdx) && isColIdxWithinSelectionBounds(idx);\n  }\n\n  function isCellEditable(position: Position): boolean {\n    return (\n      isCellWithinEditBounds(position) &&\n      isSelectedCellEditable({ columns, rows, selectedPosition: position })\n    );\n  }\n\n  function selectCell(position: Position, options?: SelectCellOptions): void {\n    if (!isCellWithinSelectionBounds(position)) return;\n    commitEditorChanges();\n\n    const samePosition = isSamePosition(selectedPosition, position);\n\n    if (options?.enableEditor && isCellEditable(position)) {\n      const row = rows[position.rowIdx];\n      setSelectedPosition({ ...position, mode: 'EDIT', row, originalRow: row });\n    } else if (samePosition) {\n      // Avoid re-renders if the selected cell state is the same\n      scrollIntoView(getCellToScroll(gridRef.current!));\n    } else {\n      setShouldFocusCell(options?.shouldFocusCell === true);\n      setSelectedPosition({ ...position, mode: 'SELECT' });\n    }\n\n    if (onSelectedCellChange && !samePosition) {\n      onSelectedCellChange({\n        rowIdx: position.rowIdx,\n        row: isRowIdxWithinViewportBounds(position.rowIdx) ? rows[position.rowIdx] : undefined,\n        column: columns[position.idx]\n      });\n    }\n  }\n\n  function selectHeaderCell({ idx, rowIdx }: Position): void {\n    selectCell({ rowIdx: minRowIdx + rowIdx - 1, idx });\n  }\n\n  function getNextPosition(key: string, ctrlKey: boolean, shiftKey: boolean): Position {\n    const { idx, rowIdx } = selectedPosition;\n    const isRowSelected = selectedCellIsWithinSelectionBounds && idx === -1;\n\n    switch (key) {\n      case 'ArrowUp':\n        return { idx, rowIdx: rowIdx - 1 };\n      case 'ArrowDown':\n        return { idx, rowIdx: rowIdx + 1 };\n      case leftKey:\n        return { idx: idx - 1, rowIdx };\n      case rightKey:\n        return { idx: idx + 1, rowIdx };\n      case 'Tab':\n        return { idx: idx + (shiftKey ? -1 : 1), rowIdx };\n      case 'Home':\n        // If row is selected then move focus to the first row\n        if (isRowSelected) return { idx, rowIdx: minRowIdx };\n        return { idx: 0, rowIdx: ctrlKey ? minRowIdx : rowIdx };\n      case 'End':\n        // If row is selected then move focus to the last row.\n        if (isRowSelected) return { idx, rowIdx: maxRowIdx };\n        return { idx: maxColIdx, rowIdx: ctrlKey ? maxRowIdx : rowIdx };\n      case 'PageUp': {\n        if (selectedPosition.rowIdx === minRowIdx) return selectedPosition;\n        const nextRowY = getRowTop(rowIdx) + getRowHeight(rowIdx) - clientHeight;\n        return { idx, rowIdx: nextRowY > 0 ? findRowIdx(nextRowY) : 0 };\n      }\n      case 'PageDown': {\n        if (selectedPosition.rowIdx >= rows.length) return selectedPosition;\n        const nextRowY = getRowTop(rowIdx) + clientHeight;\n        return { idx, rowIdx: nextRowY < totalRowHeight ? findRowIdx(nextRowY) : rows.length - 1 };\n      }\n      default:\n        return selectedPosition;\n    }\n  }\n\n  function navigate(event: KeyboardEvent<HTMLDivElement>) {\n    const { key, shiftKey } = event;\n    let cellNavigationMode: CellNavigationMode = 'NONE';\n    if (key === 'Tab') {\n      if (\n        canExitGrid({\n          shiftKey,\n          maxColIdx,\n          minRowIdx,\n          maxRowIdx,\n          selectedPosition\n        })\n      ) {\n        commitEditorChanges();\n        // Allow focus to leave the grid so the next control in the tab order can be focused\n        return;\n      }\n\n      cellNavigationMode = 'CHANGE_ROW';\n    }\n\n    // prevent scrolling and do not allow focus to leave\n    event.preventDefault();\n\n    const ctrlKey = isCtrlKeyHeldDown(event);\n    const nextPosition = getNextPosition(key, ctrlKey, shiftKey);\n    if (isSamePosition(selectedPosition, nextPosition)) return;\n\n    const nextSelectedCellPosition = getNextSelectedCellPosition({\n      moveUp: key === 'ArrowUp',\n      moveNext: key === rightKey || (key === 'Tab' && !shiftKey),\n      columns,\n      colSpanColumns,\n      rows,\n      topSummaryRows,\n      bottomSummaryRows,\n      minRowIdx,\n      mainHeaderRowIdx,\n      maxRowIdx,\n      lastFrozenColumnIndex,\n      cellNavigationMode,\n      currentPosition: selectedPosition,\n      nextPosition,\n      isCellWithinBounds: isCellWithinSelectionBounds\n    });\n\n    selectCell(nextSelectedCellPosition, { shouldFocusCell: true });\n  }\n\n  function getDraggedOverCellIdx(currentRowIdx: number): number | undefined {\n    if (draggedOverRowIdx === undefined) return;\n    const { rowIdx } = selectedPosition;\n\n    const isDraggedOver =\n      rowIdx < draggedOverRowIdx\n        ? rowIdx < currentRowIdx && currentRowIdx <= draggedOverRowIdx\n        : rowIdx > currentRowIdx && currentRowIdx >= draggedOverRowIdx;\n\n    return isDraggedOver ? selectedPosition.idx : undefined;\n  }\n\n  function getDragHandle() {\n    if (\n      onFill == null ||\n      selectedPosition.mode === 'EDIT' ||\n      !isCellWithinViewportBounds(selectedPosition)\n    ) {\n      return;\n    }\n\n    const { idx, rowIdx } = selectedPosition;\n    const column = columns[idx];\n    if (column.renderEditCell == null || column.editable === false) {\n      return;\n    }\n\n    const isLastRow = rowIdx === maxRowIdx;\n    const columnWidth = getColumnWidth(column);\n    const colSpan = column.colSpan?.({ type: 'ROW', row: rows[rowIdx] }) ?? 1;\n    const { insetInlineStart, ...style } = getCellStyle(column, colSpan);\n    const marginEnd = 'calc(var(--rdg-drag-handle-size) * -0.5 + 1px)';\n    const isLastColumn = column.idx + colSpan - 1 === maxColIdx;\n    const dragHandleStyle: React.CSSProperties = {\n      ...style,\n      gridRowStart: headerAndTopSummaryRowsCount + rowIdx + 1,\n      marginInlineEnd: isLastColumn ? undefined : marginEnd,\n      marginBlockEnd: isLastRow ? undefined : marginEnd,\n      insetInlineStart: insetInlineStart\n        ? `calc(${insetInlineStart} + ${columnWidth}px + var(--rdg-drag-handle-size) * -0.5 - 1px)`\n        : undefined\n    };\n\n    return (\n      <div\n        style={dragHandleStyle}\n        className={classnames(\n          cellDragHandleClassname,\n          column.frozen && cellDragHandleFrozenClassname\n        )}\n        onPointerDown={handleDragHandlePointerDown}\n        onPointerMove={isDragging ? handleDragHandlePointerMove : undefined}\n        onLostPointerCapture={isDragging ? handleDragHandleLostPointerCapture : undefined}\n        onClick={handleDragHandleClick}\n        onDoubleClick={handleDragHandleDoubleClick}\n      />\n    );\n  }\n\n  function getCellEditor(rowIdx: number) {\n    if (\n      !isCellWithinViewportBounds(selectedPosition) ||\n      selectedPosition.rowIdx !== rowIdx ||\n      selectedPosition.mode === 'SELECT'\n    ) {\n      return;\n    }\n\n    const { idx, row } = selectedPosition;\n    const column = columns[idx];\n    const colSpan = getColSpan(column, lastFrozenColumnIndex, { type: 'ROW', row });\n    const closeOnExternalRowChange = column.editorOptions?.closeOnExternalRowChange ?? true;\n\n    const closeEditor = (shouldFocusCell: boolean) => {\n      setShouldFocusCell(shouldFocusCell);\n      setSelectedPosition(({ idx, rowIdx }) => ({ idx, rowIdx, mode: 'SELECT' }));\n    };\n\n    const onRowChange = (row: R, commitChanges: boolean, shouldFocusCell: boolean) => {\n      if (commitChanges) {\n        // Prevents two issues when editor is closed by clicking on a different cell\n        //\n        // Otherwise commitEditorChanges may be called before the cell state is changed to\n        // SELECT and this results in onRowChange getting called twice.\n        flushSync(() => {\n          updateRow(column, selectedPosition.rowIdx, row);\n          closeEditor(shouldFocusCell);\n        });\n      } else {\n        setSelectedPosition((position) => ({ ...position, row }));\n      }\n    };\n\n    if (\n      closeOnExternalRowChange &&\n      rows[selectedPosition.rowIdx] !== selectedPosition.originalRow\n    ) {\n      // Discard changes if rows are updated from outside\n      closeEditor(false);\n    }\n\n    return (\n      <EditCell\n        key={column.key}\n        column={column}\n        colSpan={colSpan}\n        row={row}\n        rowIdx={rowIdx}\n        onRowChange={onRowChange}\n        closeEditor={closeEditor}\n        onKeyDown={onCellKeyDown}\n        navigate={navigate}\n      />\n    );\n  }\n\n  function getRowViewportColumns(rowIdx: number) {\n    // idx can be -1 if grouping is enabled\n    const selectedColumn = selectedPosition.idx === -1 ? undefined : columns[selectedPosition.idx];\n    if (\n      selectedColumn !== undefined &&\n      selectedPosition.rowIdx === rowIdx &&\n      !viewportColumns.includes(selectedColumn)\n    ) {\n      // Add the selected column to viewport columns if the cell is not within the viewport\n      return selectedPosition.idx > colOverscanEndIdx\n        ? [...viewportColumns, selectedColumn]\n        : [\n            ...viewportColumns.slice(0, lastFrozenColumnIndex + 1),\n            selectedColumn,\n            ...viewportColumns.slice(lastFrozenColumnIndex + 1)\n          ];\n    }\n    return viewportColumns;\n  }\n\n  function getViewportRows() {\n    const rowElements: React.ReactNode[] = [];\n\n    const { idx: selectedIdx, rowIdx: selectedRowIdx } = selectedPosition;\n\n    const startRowIdx =\n      selectedCellIsWithinViewportBounds && selectedRowIdx < rowOverscanStartIdx\n        ? rowOverscanStartIdx - 1\n        : rowOverscanStartIdx;\n    const endRowIdx =\n      selectedCellIsWithinViewportBounds && selectedRowIdx > rowOverscanEndIdx\n        ? rowOverscanEndIdx + 1\n        : rowOverscanEndIdx;\n\n    for (let viewportRowIdx = startRowIdx; viewportRowIdx <= endRowIdx; viewportRowIdx++) {\n      const isRowOutsideViewport =\n        viewportRowIdx === rowOverscanStartIdx - 1 || viewportRowIdx === rowOverscanEndIdx + 1;\n      const rowIdx = isRowOutsideViewport ? selectedRowIdx : viewportRowIdx;\n\n      let rowColumns = viewportColumns;\n      const selectedColumn = selectedIdx === -1 ? undefined : columns[selectedIdx];\n      if (selectedColumn !== undefined) {\n        if (isRowOutsideViewport) {\n          // if the row is outside the viewport then only render the selected cell\n          rowColumns = [selectedColumn];\n        } else {\n          // if the row is within the viewport and cell is not, add the selected column to viewport columns\n          rowColumns = getRowViewportColumns(rowIdx);\n        }\n      }\n\n      const row = rows[rowIdx];\n      const gridRowStart = headerAndTopSummaryRowsCount + rowIdx + 1;\n      let key: K | number = rowIdx;\n      let isRowSelected = false;\n      if (typeof rowKeyGetter === 'function') {\n        key = rowKeyGetter(row);\n        isRowSelected = selectedRows?.has(key) ?? false;\n      }\n\n      rowElements.push(\n        renderRow(key, {\n          // aria-rowindex is 1 based\n          'aria-rowindex': headerAndTopSummaryRowsCount + rowIdx + 1,\n          'aria-selected': isSelectable ? isRowSelected : undefined,\n          rowIdx,\n          row,\n          viewportColumns: rowColumns,\n          isRowSelectionDisabled: isRowSelectionDisabled?.(row) ?? false,\n          isRowSelected,\n          onCellMouseDown: onCellMouseDownLatest,\n          onCellClick: onCellClickLatest,\n          onCellDoubleClick: onCellDoubleClickLatest,\n          onCellContextMenu: onCellContextMenuLatest,\n          rowClass,\n          gridRowStart,\n          selectedCellIdx: selectedRowIdx === rowIdx ? selectedIdx : undefined,\n          draggedOverCellIdx: getDraggedOverCellIdx(rowIdx),\n          lastFrozenColumnIndex,\n          onRowChange: handleFormatterRowChangeLatest,\n          selectCell: selectCellLatest,\n          selectedCellEditor: getCellEditor(rowIdx)\n        })\n      );\n    }\n\n    return rowElements;\n  }\n\n  // Reset the positions if the current values are no longer valid. This can happen if a column or row is removed\n  if (selectedPosition.idx > maxColIdx || selectedPosition.rowIdx > maxRowIdx) {\n    setSelectedPosition({ idx: -1, rowIdx: minRowIdx - 1, mode: 'SELECT' });\n    setDraggedOverRowIdx(undefined);\n  }\n\n  // Keep the state and prop in sync\n  if (isColumnWidthsControlled && columnWidthsInternal !== columnWidthsRaw) {\n    setColumnWidthsInternal(columnWidthsRaw);\n  }\n\n  let templateRows = `repeat(${headerRowsCount}, ${headerRowHeight}px)`;\n  if (topSummaryRowsCount > 0) {\n    templateRows += ` repeat(${topSummaryRowsCount}, ${summaryRowHeight}px)`;\n  }\n  if (rows.length > 0) {\n    templateRows += gridTemplateRows;\n  }\n  if (bottomSummaryRowsCount > 0) {\n    templateRows += ` repeat(${bottomSummaryRowsCount}, ${summaryRowHeight}px)`;\n  }\n\n  const isGroupRowFocused =\n    selectedPosition.idx === -1 && selectedPosition.rowIdx !== minRowIdx - 1;\n\n  return (\n    <div\n      role={role}\n      aria-label={ariaLabel}\n      aria-labelledby={ariaLabelledBy}\n      aria-description={ariaDescription}\n      aria-describedby={ariaDescribedBy}\n      aria-multiselectable={isSelectable ? true : undefined}\n      aria-colcount={columns.length}\n      aria-rowcount={ariaRowCount}\n      // Scrollable containers without tabIndex are keyboard focusable in Chrome only if there is no focusable element inside\n      // whereas they are always focusable in Firefox. We need to set tabIndex to have a consistent behavior across browsers.\n      tabIndex={-1}\n      className={classnames(\n        rootClassname,\n        {\n          [viewportDraggingClassname]: isDragging\n        },\n        className\n      )}\n      style={{\n        ...style,\n        // set scrollPadding to correctly position non-sticky cells after scrolling\n        scrollPaddingInlineStart:\n          selectedPosition.idx > lastFrozenColumnIndex || scrollToPosition?.idx !== undefined\n            ? `${totalFrozenColumnWidth}px`\n            : undefined,\n        scrollPaddingBlock:\n          isRowIdxWithinViewportBounds(selectedPosition.rowIdx) ||\n          scrollToPosition?.rowIdx !== undefined\n            ? `${headerRowsHeight + topSummaryRowsCount * summaryRowHeight}px ${\n                bottomSummaryRowsCount * summaryRowHeight\n              }px`\n            : undefined,\n        gridTemplateColumns,\n        gridTemplateRows: templateRows,\n        '--rdg-header-row-height': `${headerRowHeight}px`,\n        '--rdg-scroll-height': `${scrollHeight}px`,\n        ...layoutCssVars\n      }}\n      dir={direction}\n      ref={gridRef}\n      onScroll={handleScroll}\n      onKeyDown={handleKeyDown}\n      onCopy={handleCellCopy}\n      onPaste={handleCellPaste}\n      data-testid={testId}\n      data-cy={dataCy}\n    >\n      <DataGridDefaultRenderersContext value={defaultGridComponents}>\n        <HeaderRowSelectionChangeContext value={selectHeaderRowLatest}>\n          <HeaderRowSelectionContext value={headerSelectionValue}>\n            {Array.from({ length: groupedColumnHeaderRowsCount }, (_, index) => (\n              <GroupedColumnHeaderRow\n                key={index}\n                rowIdx={index + 1}\n                level={-groupedColumnHeaderRowsCount + index}\n                columns={getRowViewportColumns(minRowIdx + index)}\n                selectedCellIdx={\n                  selectedPosition.rowIdx === minRowIdx + index ? selectedPosition.idx : undefined\n                }\n                selectCell={selectHeaderCellLatest}\n              />\n            ))}\n            <HeaderRow\n              headerRowClass={headerRowClass}\n              rowIdx={headerRowsCount}\n              columns={getRowViewportColumns(mainHeaderRowIdx)}\n              onColumnResize={handleColumnResizeLatest}\n              onColumnResizeEnd={handleColumnResizeEndLatest}\n              onColumnsReorder={onColumnsReorderLastest}\n              sortColumns={sortColumns}\n              onSortColumnsChange={onSortColumnsChangeLatest}\n              lastFrozenColumnIndex={lastFrozenColumnIndex}\n              selectedCellIdx={\n                selectedPosition.rowIdx === mainHeaderRowIdx ? selectedPosition.idx : undefined\n              }\n              selectCell={selectHeaderCellLatest}\n              shouldFocusGrid={!selectedCellIsWithinSelectionBounds}\n              direction={direction}\n            />\n          </HeaderRowSelectionContext>\n        </HeaderRowSelectionChangeContext>\n        {rows.length === 0 && noRowsFallback ? (\n          noRowsFallback\n        ) : (\n          <>\n            {topSummaryRows?.map((row, rowIdx) => {\n              const gridRowStart = headerRowsCount + 1 + rowIdx;\n              const summaryRowIdx = mainHeaderRowIdx + 1 + rowIdx;\n              const isSummaryRowSelected = selectedPosition.rowIdx === summaryRowIdx;\n              const top = headerRowsHeight + summaryRowHeight * rowIdx;\n\n              return (\n                <SummaryRow\n                  key={rowIdx}\n                  aria-rowindex={gridRowStart}\n                  rowIdx={summaryRowIdx}\n                  gridRowStart={gridRowStart}\n                  row={row}\n                  top={top}\n                  bottom={undefined}\n                  viewportColumns={getRowViewportColumns(summaryRowIdx)}\n                  lastFrozenColumnIndex={lastFrozenColumnIndex}\n                  selectedCellIdx={isSummaryRowSelected ? selectedPosition.idx : undefined}\n                  isTop\n                  selectCell={selectCellLatest}\n                />\n              );\n            })}\n            <RowSelectionChangeContext value={selectRowLatest}>\n              {getViewportRows()}\n            </RowSelectionChangeContext>\n            {bottomSummaryRows?.map((row, rowIdx) => {\n              const gridRowStart = headerAndTopSummaryRowsCount + rows.length + rowIdx + 1;\n              const summaryRowIdx = rows.length + rowIdx;\n              const isSummaryRowSelected = selectedPosition.rowIdx === summaryRowIdx;\n              const top =\n                clientHeight > totalRowHeight\n                  ? gridHeight - summaryRowHeight * (bottomSummaryRows.length - rowIdx)\n                  : undefined;\n              const bottom =\n                top === undefined\n                  ? summaryRowHeight * (bottomSummaryRows.length - 1 - rowIdx)\n                  : undefined;\n\n              return (\n                <SummaryRow\n                  aria-rowindex={ariaRowCount - bottomSummaryRowsCount + rowIdx + 1}\n                  key={rowIdx}\n                  rowIdx={summaryRowIdx}\n                  gridRowStart={gridRowStart}\n                  row={row}\n                  top={top}\n                  bottom={bottom}\n                  viewportColumns={getRowViewportColumns(summaryRowIdx)}\n                  lastFrozenColumnIndex={lastFrozenColumnIndex}\n                  selectedCellIdx={isSummaryRowSelected ? selectedPosition.idx : undefined}\n                  isTop={false}\n                  selectCell={selectCellLatest}\n                />\n              );\n            })}\n          </>\n        )}\n      </DataGridDefaultRenderersContext>\n\n      {getDragHandle()}\n\n      {/* render empty cells that span only 1 column so we can safely measure column widths, regardless of colSpan */}\n      {renderMeasuringCells(viewportColumns)}\n\n      {/* extra div is needed for row navigation in a treegrid */}\n      {isTreeGrid && (\n        <div\n          ref={focusSinkRef}\n          tabIndex={isGroupRowFocused ? 0 : -1}\n          className={classnames(focusSinkClassname, {\n            [focusSinkHeaderAndSummaryClassname]: !isRowIdxWithinViewportBounds(\n              selectedPosition.rowIdx\n            ),\n            [rowSelected]: isGroupRowFocused,\n            [rowSelectedWithFrozenCell]: isGroupRowFocused && lastFrozenColumnIndex !== -1\n          })}\n          style={{\n            gridRowStart: selectedPosition.rowIdx + headerAndTopSummaryRowsCount + 1\n          }}\n        />\n      )}\n\n      {scrollToPosition !== null && (\n        <ScrollToCell\n          scrollToPosition={scrollToPosition}\n          setScrollToCellPosition={setScrollToPosition}\n          gridRef={gridRef}\n        />\n      )}\n    </div>\n  );\n}\n\nfunction getCellToScroll(gridEl: HTMLDivElement) {\n  return gridEl.querySelector<HTMLDivElement>(':scope > [role=\"row\"] > [tabindex=\"0\"]');\n}\n\nfunction isSamePosition(p1: Position, p2: Position) {\n  return p1.idx === p2.idx && p1.rowIdx === p2.rowIdx;\n}\n","import { memo } from 'react';\n\nimport { useRovingTabIndex } from './hooks';\nimport { getCellClassname, getCellStyle } from './utils';\nimport type { CalculatedColumn, GroupRow } from './types';\n\ninterface GroupCellProps<R, SR> {\n  id: string;\n  groupKey: unknown;\n  childRows: readonly R[];\n  toggleGroup: (expandedGroupId: unknown) => void;\n  isExpanded: boolean;\n  column: CalculatedColumn<R, SR>;\n  row: GroupRow<R>;\n  isCellSelected: boolean;\n  groupColumnIndex: number;\n  isGroupByColumn: boolean;\n}\n\nfunction GroupCell<R, SR>({\n  id,\n  groupKey,\n  childRows,\n  isExpanded,\n  isCellSelected,\n  column,\n  row,\n  groupColumnIndex,\n  isGroupByColumn,\n  toggleGroup: toggleGroupWrapper\n}: GroupCellProps<R, SR>) {\n  const { tabIndex, childTabIndex, onFocus } = useRovingTabIndex(isCellSelected);\n\n  function toggleGroup() {\n    toggleGroupWrapper(id);\n  }\n\n  // Only make the cell clickable if the group level matches\n  const isLevelMatching = isGroupByColumn && groupColumnIndex === column.idx;\n\n  return (\n    <div\n      role=\"gridcell\"\n      aria-colindex={column.idx + 1}\n      aria-selected={isCellSelected}\n      tabIndex={tabIndex}\n      key={column.key}\n      className={getCellClassname(column)}\n      style={{\n        ...getCellStyle(column),\n        cursor: isLevelMatching ? 'pointer' : 'default'\n      }}\n      onMouseDown={(event) => {\n        // prevents clicking on the cell from stealing focus from focusSink\n        event.preventDefault();\n      }}\n      onClick={isLevelMatching ? toggleGroup : undefined}\n      onFocus={onFocus}\n    >\n      {(!isGroupByColumn || isLevelMatching) &&\n        column.renderGroupCell?.({\n          groupKey,\n          childRows,\n          column,\n          row,\n          isExpanded,\n          tabIndex: childTabIndex,\n          toggleGroup\n        })}\n    </div>\n  );\n}\n\nexport default memo(GroupCell) as <R, SR>(props: GroupCellProps<R, SR>) => React.JSX.Element;\n","import { memo, useMemo } from 'react';\nimport { css } from 'ecij';\n\nimport { RowSelectionContext, type RowSelectionContextValue } from './hooks';\nimport { classnames, getRowStyle } from './utils';\nimport type { BaseRenderRowProps, GroupRow } from './types';\nimport { SELECT_COLUMN_KEY } from './Columns';\nimport GroupCell from './GroupCell';\nimport { cell, cellFrozen } from './style/cell';\nimport { rowClassname, rowSelectedClassname } from './style/row';\n\nconst groupRow = css`\n  @layer rdg.GroupedRow {\n    &:not([aria-selected='true']) {\n      background-color: var(--rdg-header-background-color);\n    }\n\n    > .${cell}:not(:last-child, .${cellFrozen}),\n    > :nth-last-child(n + 2 of .${cellFrozen}) {\n      border-inline-end: none;\n    }\n  }\n`;\n\nconst groupRowClassname = `rdg-group-row ${groupRow}`;\n\ninterface GroupRowRendererProps<R, SR> extends BaseRenderRowProps<R, SR> {\n  row: GroupRow<R>;\n  groupBy: readonly string[];\n  toggleGroup: (expandedGroupId: unknown) => void;\n}\n\nfunction GroupedRow<R, SR>({\n  className,\n  row,\n  rowIdx,\n  viewportColumns,\n  selectedCellIdx,\n  isRowSelected,\n  selectCell,\n  gridRowStart,\n  groupBy,\n  toggleGroup,\n  isRowSelectionDisabled,\n  ...props\n}: GroupRowRendererProps<R, SR>) {\n  // Select is always the first column\n  const idx = viewportColumns[0].key === SELECT_COLUMN_KEY ? row.level + 1 : row.level;\n\n  function handleSelectGroup() {\n    selectCell({ rowIdx, idx: -1 }, { shouldFocusCell: true });\n  }\n\n  const selectionValue = useMemo(\n    (): RowSelectionContextValue => ({ isRowSelectionDisabled: false, isRowSelected }),\n    [isRowSelected]\n  );\n\n  return (\n    <RowSelectionContext value={selectionValue}>\n      <div\n        role=\"row\"\n        aria-level={row.level + 1} // aria-level is 1-based\n        aria-setsize={row.setSize}\n        aria-posinset={row.posInSet + 1} // aria-posinset is 1-based\n        aria-expanded={row.isExpanded}\n        className={classnames(\n          rowClassname,\n          groupRowClassname,\n          `rdg-row-${rowIdx % 2 === 0 ? 'even' : 'odd'}`,\n          selectedCellIdx === -1 && rowSelectedClassname,\n          className\n        )}\n        onMouseDown={handleSelectGroup}\n        style={getRowStyle(gridRowStart)}\n        {...props}\n      >\n        {viewportColumns.map((column) => (\n          <GroupCell\n            key={column.key}\n            id={row.id}\n            groupKey={row.groupKey}\n            childRows={row.childRows}\n            isExpanded={row.isExpanded}\n            isCellSelected={selectedCellIdx === column.idx}\n            column={column}\n            row={row}\n            groupColumnIndex={idx}\n            toggleGroup={toggleGroup}\n            isGroupByColumn={groupBy.includes(column.key)}\n          />\n        ))}\n      </div>\n    </RowSelectionContext>\n  );\n}\n\nexport default memo(GroupedRow) as <R, SR>(\n  props: GroupRowRendererProps<R, SR>\n) => React.JSX.Element;\n","import { useCallback, useMemo } from 'react';\nimport type { Key } from 'react';\n\nimport { useLatestFunc } from './hooks';\nimport { assertIsValidKeyGetter, getLeftRightKey } from './utils';\nimport type {\n  CellClipboardEvent,\n  CellCopyArgs,\n  CellKeyboardEvent,\n  CellKeyDownArgs,\n  CellPasteArgs,\n  Column,\n  GroupRow,\n  Maybe,\n  Omit,\n  RenderRowProps,\n  RowHeightArgs,\n  RowsChangeData\n} from './types';\nimport { renderToggleGroup } from './cellRenderers';\nimport { SELECT_COLUMN_KEY } from './Columns';\nimport { DataGrid } from './DataGrid';\nimport type { DataGridProps } from './DataGrid';\nimport { useDefaultRenderers } from './DataGridDefaultRenderersContext';\nimport GroupedRow from './GroupRow';\nimport { defaultRenderRow } from './Row';\n\nexport interface TreeDataGridProps<R, SR = unknown, K extends Key = Key> extends Omit<\n  DataGridProps<R, SR, K>,\n  'columns' | 'role' | 'aria-rowcount' | 'rowHeight' | 'onFill' | 'isRowSelectionDisabled'\n> {\n  columns: readonly Column<NoInfer<R>, NoInfer<SR>>[];\n  rowHeight?: Maybe<number | ((args: RowHeightArgs<NoInfer<R>>) => number)>;\n  groupBy: readonly string[];\n  rowGrouper: (\n    rows: readonly NoInfer<R>[],\n    columnKey: string\n  ) => Record<string, readonly NoInfer<R>[]>;\n  expandedGroupIds: ReadonlySet<unknown>;\n  onExpandedGroupIdsChange: (expandedGroupIds: Set<unknown>) => void;\n  groupIdGetter?: Maybe<(groupKey: string, parentId?: string) => string>;\n}\n\ntype GroupByDictionary<TRow> = Record<\n  string,\n  {\n    readonly childRows: readonly TRow[];\n    readonly childGroups: readonly TRow[] | Readonly<GroupByDictionary<TRow>>;\n    readonly startRowIndex: number;\n  }\n>;\n\nexport function TreeDataGrid<R, SR = unknown, K extends Key = Key>({\n  columns: rawColumns,\n  rows: rawRows,\n  rowHeight: rawRowHeight,\n  rowKeyGetter: rawRowKeyGetter,\n  onCellKeyDown: rawOnCellKeyDown,\n  onCellCopy: rawOnCellCopy,\n  onCellPaste: rawOnCellPaste,\n  onRowsChange,\n  selectedRows: rawSelectedRows,\n  onSelectedRowsChange: rawOnSelectedRowsChange,\n  renderers,\n  groupBy: rawGroupBy,\n  rowGrouper,\n  expandedGroupIds,\n  onExpandedGroupIdsChange,\n  groupIdGetter: rawGroupIdGetter,\n  ...props\n}: TreeDataGridProps<R, SR, K>) {\n  const defaultRenderers = useDefaultRenderers<R, SR>();\n  const rawRenderRow = renderers?.renderRow ?? defaultRenderers?.renderRow ?? defaultRenderRow;\n  const headerAndTopSummaryRowsCount = 1 + (props.topSummaryRows?.length ?? 0);\n  const { leftKey, rightKey } = getLeftRightKey(props.direction);\n  const toggleGroupLatest = useLatestFunc(toggleGroup);\n  const groupIdGetter = rawGroupIdGetter ?? defaultGroupIdGetter;\n\n  const { columns, groupBy } = useMemo(() => {\n    const columns = rawColumns.toSorted(({ key: aKey }, { key: bKey }) => {\n      // Sort select column first:\n      if (aKey === SELECT_COLUMN_KEY) return -1;\n      if (bKey === SELECT_COLUMN_KEY) return 1;\n\n      // Sort grouped columns second, following the groupBy order:\n      if (rawGroupBy.includes(aKey)) {\n        if (rawGroupBy.includes(bKey)) {\n          return rawGroupBy.indexOf(aKey) - rawGroupBy.indexOf(bKey);\n        }\n        return -1;\n      }\n      if (rawGroupBy.includes(bKey)) return 1;\n\n      // Sort other columns last:\n      return 0;\n    });\n\n    const groupBy: string[] = [];\n    for (const [index, column] of columns.entries()) {\n      if (rawGroupBy.includes(column.key)) {\n        groupBy.push(column.key);\n        columns[index] = {\n          ...column,\n          frozen: true,\n          renderCell: () => null,\n          renderGroupCell: column.renderGroupCell ?? renderToggleGroup,\n          editable: false\n        };\n      }\n    }\n\n    return { columns, groupBy };\n  }, [rawColumns, rawGroupBy]);\n\n  const [groupedRows, rowsCount] = useMemo(() => {\n    if (groupBy.length === 0) return [undefined, rawRows.length];\n\n    const groupRows = (\n      rows: readonly R[],\n      [groupByKey, ...remainingGroupByKeys]: readonly string[],\n      startRowIndex: number\n    ): [Readonly<GroupByDictionary<R>>, number] => {\n      let groupRowsCount = 0;\n      const groups: GroupByDictionary<R> = {};\n      for (const [key, childRows] of Object.entries(rowGrouper(rows, groupByKey))) {\n        // Recursively group each parent group\n        const [childGroups, childRowsCount] =\n          remainingGroupByKeys.length === 0\n            ? [childRows, childRows.length]\n            : groupRows(childRows, remainingGroupByKeys, startRowIndex + groupRowsCount + 1); // 1 for parent row\n        groups[key] = { childRows, childGroups, startRowIndex: startRowIndex + groupRowsCount };\n        groupRowsCount += childRowsCount + 1; // 1 for parent row\n      }\n\n      return [groups, groupRowsCount];\n    };\n\n    return groupRows(rawRows, groupBy, 0);\n  }, [groupBy, rowGrouper, rawRows]);\n\n  const [rows, isGroupRow] = useMemo((): [\n    ReadonlyArray<R | GroupRow<R>>,\n    (row: R | GroupRow<R>) => row is GroupRow<R>\n  ] => {\n    const allGroupRows = new Set<unknown>();\n    if (!groupedRows) return [rawRows, isGroupRow];\n\n    const flattenedRows: Array<R | GroupRow<R>> = [];\n\n    const expandGroup = (\n      rows: GroupByDictionary<R> | readonly R[],\n      parentId: string | undefined,\n      level: number\n    ): void => {\n      if (isReadonlyArray(rows)) {\n        flattenedRows.push(...rows);\n        return;\n      }\n      Object.keys(rows).forEach((groupKey, posInSet, keys) => {\n        const id = groupIdGetter(groupKey, parentId);\n        const isExpanded = expandedGroupIds.has(id);\n        const { childRows, childGroups, startRowIndex } = rows[groupKey];\n\n        const groupRow: GroupRow<R> = {\n          id,\n          parentId,\n          groupKey,\n          isExpanded,\n          childRows,\n          level,\n          posInSet,\n          startRowIndex,\n          setSize: keys.length\n        };\n        flattenedRows.push(groupRow);\n        allGroupRows.add(groupRow);\n\n        if (isExpanded) {\n          expandGroup(childGroups, id, level + 1);\n        }\n      });\n    };\n\n    expandGroup(groupedRows, undefined, 0);\n    return [flattenedRows, isGroupRow];\n\n    function isGroupRow(row: R | GroupRow<R>): row is GroupRow<R> {\n      return allGroupRows.has(row);\n    }\n  }, [expandedGroupIds, groupedRows, rawRows, groupIdGetter]);\n\n  const rowHeight = useMemo(() => {\n    if (typeof rawRowHeight === 'function') {\n      return (row: R | GroupRow<R>): number => {\n        if (isGroupRow(row)) {\n          return rawRowHeight({ type: 'GROUP', row });\n        }\n        return rawRowHeight({ type: 'ROW', row });\n      };\n    }\n\n    return rawRowHeight;\n  }, [isGroupRow, rawRowHeight]);\n\n  const getParentRowAndIndex = useCallback(\n    (row: R | GroupRow<R>) => {\n      const rowIdx = rows.indexOf(row);\n      for (let i = rowIdx - 1; i >= 0; i--) {\n        const parentRow = rows[i];\n        if (isGroupRow(parentRow) && (!isGroupRow(row) || row.parentId === parentRow.id)) {\n          return [parentRow, i] as const;\n        }\n      }\n\n      return undefined;\n    },\n    [isGroupRow, rows]\n  );\n\n  const rowKeyGetter = useCallback(\n    (row: R | GroupRow<R>) => {\n      if (isGroupRow(row)) {\n        return row.id;\n      }\n\n      if (typeof rawRowKeyGetter === 'function') {\n        return rawRowKeyGetter(row);\n      }\n\n      const parentRowAndIndex = getParentRowAndIndex(row);\n      if (parentRowAndIndex !== undefined) {\n        const { startRowIndex, childRows } = parentRowAndIndex[0];\n        const groupIndex = childRows.indexOf(row);\n        return startRowIndex + groupIndex + 1;\n      }\n\n      return rows.indexOf(row);\n    },\n    [getParentRowAndIndex, isGroupRow, rawRowKeyGetter, rows]\n  );\n\n  const selectedRows = useMemo((): Maybe<ReadonlySet<Key>> => {\n    if (rawSelectedRows == null) return null;\n\n    assertIsValidKeyGetter<R, K>(rawRowKeyGetter);\n\n    const selectedRows = new Set<Key>(rawSelectedRows);\n    for (const row of rows) {\n      if (isGroupRow(row)) {\n        // select parent row if all the children are selected\n        const isGroupRowSelected = row.childRows.every((cr) =>\n          rawSelectedRows.has(rawRowKeyGetter(cr))\n        );\n        if (isGroupRowSelected) {\n          selectedRows.add(row.id);\n        }\n      }\n    }\n\n    return selectedRows;\n  }, [isGroupRow, rawRowKeyGetter, rawSelectedRows, rows]);\n\n  function onSelectedRowsChange(newSelectedRows: Set<Key>) {\n    if (!rawOnSelectedRowsChange) return;\n\n    assertIsValidKeyGetter<R, K>(rawRowKeyGetter);\n\n    const newRawSelectedRows = new Set(rawSelectedRows);\n    for (const row of rows) {\n      const key = rowKeyGetter(row);\n      if (selectedRows?.has(key) && !newSelectedRows.has(key)) {\n        if (isGroupRow(row)) {\n          // select all children if the parent row is selected\n          for (const cr of row.childRows) {\n            newRawSelectedRows.delete(rawRowKeyGetter(cr));\n          }\n        } else {\n          newRawSelectedRows.delete(key as K);\n        }\n      } else if (!selectedRows?.has(key) && newSelectedRows.has(key)) {\n        if (isGroupRow(row)) {\n          // unselect all children if the parent row is unselected\n          for (const cr of row.childRows) {\n            newRawSelectedRows.add(rawRowKeyGetter(cr));\n          }\n        } else {\n          newRawSelectedRows.add(key as K);\n        }\n      }\n    }\n\n    rawOnSelectedRowsChange(newRawSelectedRows);\n  }\n\n  function handleKeyDown(args: CellKeyDownArgs<R, SR>, event: CellKeyboardEvent) {\n    rawOnCellKeyDown?.(args, event);\n    if (event.isGridDefaultPrevented()) return;\n\n    if (args.mode === 'EDIT') return;\n    const { column, rowIdx, selectCell } = args;\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n    const idx = column?.idx ?? -1;\n    const row = rows[rowIdx];\n\n    if (!isGroupRow(row)) return;\n    if (\n      idx === -1 &&\n      // Collapse the current group row if it is focused and is in expanded state\n      ((event.key === leftKey && row.isExpanded) ||\n        // Expand the current group row if it is focused and is in collapsed state\n        (event.key === rightKey && !row.isExpanded))\n    ) {\n      // prevent scrolling\n      event.preventDefault();\n      event.preventGridDefault();\n      toggleGroup(row.id);\n    }\n\n    // If a group row is focused, and it is collapsed, move to the parent group row (if there is one).\n    if (idx === -1 && event.key === leftKey && !row.isExpanded && row.level !== 0) {\n      const parentRowAndIndex = getParentRowAndIndex(row);\n      if (parentRowAndIndex !== undefined) {\n        event.preventGridDefault();\n        selectCell({ idx, rowIdx: parentRowAndIndex[1] });\n      }\n    }\n  }\n\n  // Prevent copy/paste on group rows\n  function handleCellCopy(\n    { row, column }: CellCopyArgs<NoInfer<R>, NoInfer<SR>>,\n    event: CellClipboardEvent\n  ) {\n    if (!isGroupRow(row)) {\n      rawOnCellCopy?.({ row, column }, event);\n    }\n  }\n\n  function handleCellPaste(\n    { row, column }: CellPasteArgs<NoInfer<R>, NoInfer<SR>>,\n    event: CellClipboardEvent\n  ) {\n    return isGroupRow(row) ? row : rawOnCellPaste!({ row, column }, event);\n  }\n\n  function handleRowsChange(updatedRows: R[], { indexes, column }: RowsChangeData<R, SR>) {\n    if (!onRowsChange) return;\n    const updatedRawRows = [...rawRows];\n    const rawIndexes: number[] = [];\n    for (const index of indexes) {\n      const rawIndex = rawRows.indexOf(rows[index] as R);\n      updatedRawRows[rawIndex] = updatedRows[index];\n      rawIndexes.push(rawIndex);\n    }\n    onRowsChange(updatedRawRows, {\n      indexes: rawIndexes,\n      column\n    });\n  }\n\n  function toggleGroup(groupId: unknown) {\n    const newExpandedGroupIds = new Set(expandedGroupIds);\n    if (newExpandedGroupIds.has(groupId)) {\n      newExpandedGroupIds.delete(groupId);\n    } else {\n      newExpandedGroupIds.add(groupId);\n    }\n    onExpandedGroupIdsChange(newExpandedGroupIds);\n  }\n\n  function renderRow(\n    key: Key,\n    {\n      row,\n      rowClass,\n      onCellMouseDown,\n      onCellClick,\n      onCellDoubleClick,\n      onCellContextMenu,\n      onRowChange,\n      lastFrozenColumnIndex,\n      draggedOverCellIdx,\n      selectedCellEditor,\n      ...rowProps\n    }: RenderRowProps<R, SR>\n  ) {\n    if (isGroupRow(row)) {\n      const { startRowIndex } = row;\n      return (\n        <GroupedRow\n          key={key}\n          {...rowProps}\n          aria-rowindex={headerAndTopSummaryRowsCount + startRowIndex + 1}\n          row={row}\n          groupBy={groupBy}\n          toggleGroup={toggleGroupLatest}\n        />\n      );\n    }\n\n    let ariaRowIndex = rowProps['aria-rowindex'];\n    const parentRowAndIndex = getParentRowAndIndex(row);\n    if (parentRowAndIndex !== undefined) {\n      const { startRowIndex, childRows } = parentRowAndIndex[0];\n      const groupIndex = childRows.indexOf(row);\n      ariaRowIndex = startRowIndex + headerAndTopSummaryRowsCount + groupIndex + 2;\n    }\n\n    return rawRenderRow(key, {\n      ...rowProps,\n      'aria-rowindex': ariaRowIndex,\n      row,\n      rowClass,\n      onCellMouseDown,\n      onCellClick,\n      onCellDoubleClick,\n      onCellContextMenu,\n      onRowChange,\n      lastFrozenColumnIndex,\n      draggedOverCellIdx,\n      selectedCellEditor\n    });\n  }\n\n  return (\n    <DataGrid<R, SR>\n      {...props}\n      role=\"treegrid\"\n      aria-rowcount={\n        rowsCount + 1 + (props.topSummaryRows?.length ?? 0) + (props.bottomSummaryRows?.length ?? 0)\n      }\n      columns={columns}\n      rows={rows as R[]} // TODO: check types\n      rowHeight={rowHeight}\n      rowKeyGetter={rowKeyGetter}\n      onRowsChange={handleRowsChange}\n      selectedRows={selectedRows}\n      onSelectedRowsChange={onSelectedRowsChange}\n      onCellKeyDown={handleKeyDown}\n      onCellCopy={handleCellCopy}\n      onCellPaste={rawOnCellPaste ? handleCellPaste : undefined}\n      renderers={{\n        ...renderers,\n        renderRow\n      }}\n    />\n  );\n}\n\nfunction defaultGroupIdGetter(groupKey: string, parentId: string | undefined) {\n  return parentId !== undefined ? `${parentId}__${groupKey}` : groupKey;\n}\n\nfunction isReadonlyArray(arr: unknown): arr is readonly unknown[] {\n  return Array.isArray(arr);\n}\n","import { css } from 'ecij';\n\nimport type { RenderEditCellProps } from '../types';\n\nconst textEditorInternalClassname = css`\n  @layer rdg.TextEditor {\n    appearance: none;\n\n    box-sizing: border-box;\n    inline-size: 100%;\n    block-size: 100%;\n    padding-block: 0;\n    padding-inline: 6px;\n    border: 2px solid #ccc;\n    vertical-align: top;\n    color: var(--rdg-color);\n    background-color: var(--rdg-background-color);\n\n    font-family: inherit;\n    font-size: var(--rdg-font-size);\n\n    &:focus {\n      border-color: var(--rdg-selection-color);\n      outline: none;\n    }\n\n    &::placeholder {\n      color: #999;\n      opacity: 1;\n    }\n  }\n`;\n\nexport const textEditorClassname = `rdg-text-editor ${textEditorInternalClassname}`;\n\nfunction autoFocusAndSelect(input: HTMLInputElement | null) {\n  input?.focus();\n  input?.select();\n}\n\nexport default function textTextEditor<TRow, TSummaryRow>({\n  row,\n  column,\n  onRowChange,\n  onClose\n}: RenderEditCellProps<TRow, TSummaryRow>) {\n  return (\n    <input\n      className={textEditorClassname}\n      ref={autoFocusAndSelect}\n      value={row[column.key as keyof TRow] as unknown as string}\n      onChange={(event) => onRowChange({ ...row, [column.key]: event.target.value })}\n      onBlur={() => onClose(true, false)}\n    />\n  );\n}\n"]}