20:I[81711,["/_next/static/immutable/chunks/2-qohhr5u8ik9.js","/_next/static/immutable/chunks/04cal6eduh2fl.js","/_next/static/immutable/chunks/1jxhx4sj05nm2.js","/_next/static/immutable/chunks/1zmiag7vsyrp-.js"],"ChangelogSidebar"] 21:Tea5,### Minor Changes - bedd76c: `infiniteScroll`: loads more rows as the user scrolls near the bottom of the grid's body, in place of `paginated`'s page-by-page navigation. ```tsx ``` `hasMore` and `onLoadMore` are required; `isLoadingMore` suppresses further calls while a load is in flight; `rootMargin` (default `"200px"`) tunes how early it fires relative to the grid's own scrollable body; `loadingTemplate` replaces the built-in "Loading more…" row. Mutually exclusive with `paginated` — setting both logs a dev-time `console.error` and only `paginated` takes effect. Independent of `virtualized`, though pairing the two is the recommended combination for a dataset that grows without bound. - bedd76c: `height`: bounds the row area to a fixed size, independently scrollable — the group-by bar, header, footer, and pager stay outside it and always visible. ```tsx ``` A number is pixels; a string is passed through as a CSS length (e.g. `"60vh"`). Omitted, the body's height stays content-driven, exactly as before this prop existed. Breaking: the header, body, and footer now render as three separate ``s — `.gridkit-data-grid-header`, the body's own (wrapped in a new `.gridkit-data-grid-body` scroll container), and `.gridkit-data-grid-footer` — inside a new `.gridkit-data-grid-tables` wrapper `

` that now carries `role="grid"`/`"treegrid"` and the grid's other grid-level ARIA attributes. Previously all three sat inside one `

`, which itself carried that role. This only matters to a consumer whose own CSS or tests reach into the grid's raw table structure (unsupported usage, but possible) — every cell-level role, and everything reachable through `DataGridApi`, is unchanged. One exception: `DataGridApi.table` now points at the body's `

` specifically (the one holding ``) rather than a single table that also held the header and footer. - bedd76c: `virtualized`: renders only the rows near the current scroll position rather than every row at once, for a dataset too large to mount in full. Requires `height` to be set — a body with no bounded height has no viewport to window rows against, and a dev-time `console.error` fires if `virtualized` is on without it. ```tsx ``` Row height is measured per row rather than assumed uniform, so `.is-wrapped` cells and group header/summary rows (which differ in height from data rows) lay out correctly. Two new props tune it: `overscan` (rows rendered outside the visible range on each side, default `4`) and `estimatedRowHeight` (the assumed height for a row never yet measured, default `40`) — both meaningful only with `virtualized` on. `scrollToRow` and keyboard navigation (arrow keys, `Home`/`End`, `Ctrl+Home`/`Ctrl+End`) both work correctly when their target row isn't currently mounted: they scroll it into range first, using measured heights where known, then correct the exact position once it mounts and is measured. Fully orthogonal to `paginated` and `groupBy` — combinable with either, though virtualizing an already-small paginated page is low-value. `@gridkitjs/core` gains `visibleRange` (plus its `RowHeights`/`VisibleRange` types) — the pure range math `virtualized` is built on. Not something most consumers need directly; it's exported for the same reason `paginateRows` is. ### Patch Changes - Updated dependencies [bedd76c] - @gridkitjs/core@0.10.022:T1fdc,### Minor Changes - 6e8189b: Aggregates: compute a subtotal per group and a grand total over the whole filtered/grouped dataset. ```ts ; ``` - `aggregates` is a plain controlled prop — `AggregateState`, an array of `{ columnId, fn, id?, alignment? }` specs. Unlike `sort`/`filter`/`groupBy`/`pagination`, there is no built-in UI to add or remove an aggregate interactively, so there's no `defaultAggregates`/`onAggregatesChange` pair. - `groupAggregateDisplay` chooses how a group's own subtotal renders: `"inline"` (the default) keeps it as text in the group header, next to its leaf-row count; `"row"` instead renders a dedicated row after that group's last visible entry, with each aggregate's value in the ``, outside `aria-rowcount`) renders below the body whenever `aggregates` is non-empty, regardless of `groupAggregateDisplay`. - `ColumnDefinition.footerTemplate` renders a column's own aggregate result in place of its plain formatted value, in the grand-total footer and — under `groupAggregateDisplay: "row"` — a group's own summary row. - A group's summary row is presentational: it occupies a real row slot (`aria-rowindex` counts it, same as a header or data row) but the arrow keys step over it rather than landing a tab stop there, and it never splits from its own group across a page boundary. - Aggregates are always computed over the full dataset, never scoped to the current page — composed ahead of pagination in the render pipeline, so a group's subtotal reads identically regardless of which page currently shows it. - `DataGridApi` gains `getAggregates()` for the grand total; a specific group's own results are read off `getDisplayRows()`, which now returns rows carrying a populated `aggregates` field. Depends on `@gridkitjs/core`'s new aggregate primitives (`computeAggregates`/`withGroupAggregates`) — see that package's own changelog entry, including the additive `aggregates` field it adds to `ResolvedGroupRow`. - 6e8189b: `pager.template` — a render prop that replaces the built-in pager's markup entirely, called on every render where pagination-relevant state changed. Also exports the new `PagerTemplateContext` type. As a side effect, `pager={{ template: () => null }}` is now the documented way to suppress the built-in pager while keeping `paginated` row-windowing and the imperative API active — previously there was no way to do that short of turning `paginated` off entirely. - 6e8189b: Opt-in numbered pager: `pager={{ variant: "numbered" }}` swaps the built-in pager's "Page X of Y" display for `[Prev][1][2][3]…[n][Next]` page buttons. `pager.boundaryCount` (default `1`) and `pager.siblingCount` (default `1`) control how many pages are always shown at each end and around the current page. Default stays `"compact"` — today's Prev/status/Next — so no existing consumer's rendered output changes. - 6e8189b: `DataGridProps.pageSizeOptions` is now grouped under a `pager` config object, so future pager presentation options (a variant, a custom template) can land without another breaking rename: ```diff ; ``` - 6e8189b: Pagination: split the grid's rows into pages, respecting group boundaries. ```ts persist(pagination)} />; ``` - `paginated` turns pagination on; `defaultPagination`/`onPaginationChange` are the uncontrolled page/page-size pair and its change callback, mirroring `defaultColumnSort`/`onColumnSortChange`. Pagination always composes after filtering, sorting, and grouping — a page is a window onto the finished result. When grouping is also active, a page's unit is a top-level group, never a leaf row, so a group is never split across a page boundary. - Turning `paginated` on renders a minimal, semantically-classed pager below the grid (Previous/Next, a page display, and — with `pager.sizeOptions` — a page-size select). Style it via `@gridkitjs/theme-tailwind` or your own CSS. - `DataGridApi` gains `getPagination()`, `getPageCount()`, `goToPage()`, `nextPage()`, `previousPage()`, and `setPageSize()`. - Filtering, sorting, or changing the group-by stack resets to the first page, so a user is never silently stranded on a page a smaller result set no longer has. Depends on `@gridkitjs/core`'s new pagination primitives (`paginateRows` and friends) — see that package's own changelog entry, including the `datasetIndex` field this adds to `ResolvedRow`/`ResolvedGroupRow`/`CellTemplateContext`. Breaking: `aria-rowindex` on a rendered row is now built from that row's absolute dataset position rather than its rendered position — the two only diverge once `paginated` is on, but the change applies unconditionally. `GridGroupRow`'s exported prop shape (if consumed directly, which is not the supported path) drops `rowIndex` in favor of `datasetIndex`. - 6e8189b: `DataGridApi` gains `subscribe(listener)`, a read/notify channel for reacting to grid state without polling the imperative getters — not a second, imperative-only way to drive that state. It's the primitive the new `use*State` hooks (added in following changes) are built on with `useSyncExternalStore`; most consumers should reach for one of those instead of calling `subscribe` directly. - 6e8189b: New `useAggregateState(gridRef)` hook: the grand-total aggregate results, read reactively off a mounted `DataGridComponent`'s `ref`, for a summary footer or bar living outside the grid's own DOM. Read-only, and updates even on changes with no dedicated `on*Change` prop of their own — a filter/sort/regroup altering the grand total. - 6e8189b: New `useColumnSizingState(gridRef)` and `useColumnOrderState(gridRef)` hooks: column widths and column order, read reactively off a mounted `DataGridComponent`'s `ref`. Read-only — sizing and order stay uncontrolled via `defaultColumnSizing`/`defaultColumnOrder` and the grid's own resize/reorder handles. - 6e8189b: New `useColumnSortState(gridRef)` hook: the grid's active sort, read reactively off a mounted `DataGridComponent`'s `ref`, for a sort indicator living outside the grid's own DOM. Read-only — `DataGridApi` has no sort-mutating action. - 6e8189b: New `useGroupByState(gridRef)` hook: reactive group-by and group-expansion state read off a mounted `DataGridComponent`'s `ref`, with `expandAllGroups`/`collapseAllGroups` actions, for a custom group-by UI living outside the grid's own DOM. - 6e8189b: New `usePaginationState(gridRef)` hook: reactive pagination state and actions (`goToPage`, `nextPage`, `previousPage`, `setPageSize`) read off a mounted `DataGridComponent`'s `ref`, for building a pager entirely outside the grid's own DOM. Updates on every pagination change, including the silent page-0 reset a filter/sort/regroup triggers. - 6e8189b: New `useSelectionState(gridRef)` hook: row, column, and cell selection read together as one reactive concern off a mounted `DataGridComponent`'s `ref`, with `clearSelection`/`selectAllRows` actions, for a "N rows selected" toolbar living outside the grid's own DOM. ### Patch Changes - Updated dependencies [6e8189b] - Updated dependencies [6e8189b] - Updated dependencies [6e8189b] - @gridkitjs/core@0.9.023:T1032,### Minor Changes - 388def3: Drag a column header into the group-by bar to add it to the grouping, and drag chips within the bar to reorder the stack. ```ts ; ``` - `groupByDraggableColumns` (grid-level) / `ColumnDefinition.groupByDraggable` (per-column) let a header be dragged straight into the group-by bar, independent of `groupableColumns` — a column can be groupable via its header's click/keyboard toggle, via this drag, both, or neither. Dropped at a specific point among the bar's existing chips, it's inserted there, not appended. A column already in the group-by stack rejects its own header dragged back toward the bar — a `not-allowed` cursor and a muted outline in place of the usual accent one — since repositioning an existing level is the chip's job, not the header's. - Chips in the group-by bar are now draggable to reorder the stack, and each chip is its own focusable stop — focus one and press `Ctrl+ArrowLeft`/ `Ctrl+ArrowRight` to move it, mirroring a column header's own reorder shortcut. - `groupToggleIconColumns` (grid-level) / `ColumnDefinition.groupToggleIcon` (per-column) hide a groupable header's group-toggle icon without touching its capability — `Alt+ArrowDown` keeps working with the icon hidden. - `groupByBarVisibility` (`"always" | "auto" | "never"`, default `"auto"`) controls when the group-by bar renders, decoupled from `groupableColumns`. `"auto"` shows it once `groupBy` is non-empty, or while a header drag eligible to drop into it is in progress, so there's a drop target even from a fully empty grouping. **Breaking**: the group-by bar's visibility no longer follows `groupableColumns` — it's governed by the new `groupByBarVisibility` alone. A grid grouping purely programmatically (`defaultGroupBy` with `groupableColumns` off) previously showed no bar; under the new `"auto"` default it now does once `groupBy` is non-empty. Pass `groupByBarVisibility="never"` to keep the previous behavior. Internally, `useColumnDrag`'s pointer-drag mechanics are extracted into a new, reusable `useDragReorder` hook shared with the group-by bar's own chip dragging — no change to any existing public API. - 388def3: Row grouping: stack one or more columns into nested, collapsible groups. ```ts persist(groupBy)} />; ``` - `groupableColumns` (grid-level) / `ColumnDefinition.groupable` (per-column) turn on each header's group toggle — click its icon, or focus the header and press `Alt+ArrowDown`, to add or remove that column from the group-by stack. A group-by bar above the grid lists the active stack as removable chips. - `defaultGroupBy`/`onGroupByChange` and `defaultGroupExpansion`/ `onGroupExpansionChange` for the uncontrolled group-by stack and its collapsed/expanded state. Click a group header, or focus it and press `Space`/`Enter`, to toggle it. - `DataGridApi` gains `getGroupBy()`, `getGroupExpansion()`, `getDisplayRows()` (`getRows()`'s data regrouped, with group headers interleaved), and `expandAllGroups()`/`collapseAllGroups()`. `getRows()` itself is unchanged — it still returns the flat, ungrouped rows, exactly as before. - The grid's `role` switches from `"grid"` to the WAI-ARIA `"treegrid"` pattern whenever `groupBy` is non-empty, with `aria-expanded`/`aria-level`/ `aria-posinset`/`aria-setsize` on each group header row. An ungrouped grid is unaffected — `role="grid"` stays exactly as it was. Depends on `@gridkitjs/core`'s new grouping primitives (`groupRows` and friends) — see that package's own changelog entry. ### Patch Changes - Updated dependencies [388def3] - Updated dependencies [388def3] - @gridkitjs/core@0.8.024:T1076,### Minor Changes - ac7695f: `DataGrid` accessibility fixes, closing gaps found auditing it against the WAI-ARIA grid pattern: - Selecting a cell now announces it (e.g. "name, row 2, selected") via the grid's existing live region. Previously a grid configured with only cell selection gave a screen-reader user no feedback at all when selecting a cell — unlike row and column selection, which already announced counts. - New keyboard shortcut: `Alt+Enter` on a focused, resizable column header sizes that column to its content — the keyboard equivalent of double-clicking its resize handle. Advertised via `aria-keyshortcuts` alongside the existing resize/reorder/sort shortcuts, so `buildKeyShortcuts` (`@gridkitjs/core`) now includes `Alt+Enter` in its output for a resizable column. - Header `` with `table-layout: fixed`, which is what makes a width exact. Cell content that does not fit its column is truncated with an ellipsis instead of wrapping. ### Patch Changes - Updated dependencies [e0f5b59] - Updated dependencies [401a2cc] - Updated dependencies [a3db97e] - Updated dependencies [45e492c] - @gridkitjs/core@0.1.028:T60d,### Minor Changes - bedd76c: `virtualized`: renders only the rows near the current scroll position rather than every row at once, for a dataset too large to mount in full. Requires `height` to be set — a body with no bounded height has no viewport to window rows against, and a dev-time `console.error` fires if `virtualized` is on without it. ```tsx ``` Row height is measured per row rather than assumed uniform, so `.is-wrapped` cells and group header/summary rows (which differ in height from data rows) lay out correctly. Two new props tune it: `overscan` (rows rendered outside the visible range on each side, default `4`) and `estimatedRowHeight` (the assumed height for a row never yet measured, default `40`) — both meaningful only with `virtualized` on. `scrollToRow` and keyboard navigation (arrow keys, `Home`/`End`, `Ctrl+Home`/`Ctrl+End`) both work correctly when their target row isn't currently mounted: they scroll it into range first, using measured heights where known, then correct the exact position once it mounts and is measured. Fully orthogonal to `paginated` and `groupBy` — combinable with either, though virtualizing an already-small paginated page is low-value. `@gridkitjs/core` gains `visibleRange` (plus its `RowHeights`/`VisibleRange` types) — the pure range math `virtualized` is built on. Not something most consumers need directly; it's exported for the same reason `paginateRows` is.29:Tb6e,### Minor Changes - 6e8189b: Aggregate functions: `computeAggregates` reduces rows through built-in reducers (`sum`, `avg`, `min`, `max`, `count`, `countDistinct`) or a custom `AggregateFn`, and `withGroupAggregates` attaches each group's own subtotal to its header — or, with `display: "row"`, appends a `ResolvedGroupSummaryRow` carrying the same results as its own entry in the display list. `AggregateSpec.alignment` overrides that aggregate's own cell alignment, falling back to its column's own `alignment` when omitted. New exports: `computeAggregates`, `withGroupAggregates`, and the types `AggregateFn`/`AggregateSpec`/`AggregateState`/`AggregateResults`/`BuiltInAggregate`/`FooterTemplateContext`/`GroupAggregateDisplay`/`ResolvedGroupSummaryRow`. Every aggregate — built-in or custom — is always computed from the full leaf-row set in scope, never combined from already-computed child results, so a non-associative aggregate (a custom "distinct count", for example) is never silently wrong at a nested group level. A collapsed group's subtotal is recomputed the same way, independent of its own collapse state. Under `display: "row"`, a group's own summary row is inserted immediately after its last visible entry at every nesting level, never splits from its group across a page boundary (`paginateRows` treats it as part of the same unit), and never receives a keyboard tab stop — `nextFocusForKey` takes a new optional `isSkippableRow` predicate so `ArrowUp`/`ArrowDown`/`PageUp`/`PageDown`/`Ctrl+End` step over it. Breaking: `ResolvedGroupRow` gains a required `aggregates: AggregateResults` field (empty when no aggregates are active), and `DisplayRow` widens to include the new `ResolvedGroupSummaryRow` variant — a caller doing an exhaustive `"kind" in entry` check now needs to also narrow on `entry.kind` to tell a group header apart from a summary row. `ColumnDefinition` gains an optional `footerTemplate` for rendering a column's own aggregate result. - 6e8189b: Pagination primitives: `paginateRows` slices a `DisplayRow[]` into pages, treating a top-level group and its whole subtree as one unit so a page never splits a group. New exports: `paginateRows`, and the types `PaginationState`/`PaginationChangeEvent`. Breaking: `ResolvedRow`/`ResolvedGroupRow`/`CellTemplateContext` gain a required `datasetIndex` field — a row's absolute position in the whole filtered/sorted/grouped dataset, distinct from `rowIndex` (which is scoped to what's currently rendered — the page, once pagination is in use). A caller constructing either of these directly, or reading a template context, needs to account for the new field. - 6e8189b: New export: `paginationWindow(currentPage, pageCount, options?)`, the boundary + sibling windowing logic behind a numbered pager — which page numbers to show and where to collapse a gap into a `PaginationWindowEntry` `"ellipsis"` entry.2a:T50d,### Minor Changes - 388def3: `moveGroupByBefore`/`movesGroupBy` — the group-by counterpart of `moveColumnBefore`/`movesColumn`, positioning a column within `GroupByState` in front of another, or inserting it fresh if it isn't grouped yet. Backs the new drag-a-header-into-the-group-by-bar and drag-a-chip-to-reorder interactions in `@gridkitjs/react`. `ColumnDefinition` gains `groupByDraggable` (whether a column's header may be dragged into the group-by bar) and `groupToggleIcon` (whether a groupable header shows its group-toggle icon), mirroring `sortable`/`reorderable`. `ColumnResolveOptions`/`ResolvedColumn` gain the matching `groupByDraggable` field. - 388def3: Row grouping primitives: `groupRows` reshapes filtered/sorted rows into a flat, depth-first list of group headers and data rows, stacked outer-to-inner by a `GroupByState`. New exports: `groupRows`, `groupRowId`, `toggleGroupExpansion`, `expandAllGroups`, `collapseAllGroups`, and the types `GroupByState`/`GroupByEntry`/`GroupByEvent`/`GroupExpansionState`/`GroupExpansionEvent`/`ResolvedGroupRow`/`DisplayRow`. `ColumnDefinition` gains a `groupable` field, mirroring `sortable`. Breaking: `KeyShortcutCapabilities` (consumed by `buildKeyShortcuts`) gains a required `groupable: boolean` field.2b:Ta7d,### Minor Changes - ac7695f: `DataGrid` accessibility fixes, closing gaps found auditing it against the WAI-ARIA grid pattern: - Selecting a cell now announces it (e.g. "name, row 2, selected") via the grid's existing live region. Previously a grid configured with only cell selection gave a screen-reader user no feedback at all when selecting a cell — unlike row and column selection, which already announced counts. - New keyboard shortcut: `Alt+Enter` on a focused, resizable column header sizes that column to its content — the keyboard equivalent of double-clicking its resize handle. Advertised via `aria-keyshortcuts` alongside the existing resize/reorder/sort shortcuts, so `buildKeyShortcuts` (`@gridkitjs/core`) now includes `Alt+Enter` in its output for a resizable column. - Header `` with `table-layout: fixed`, which is what makes a width exact. Cell content that does not fit its column is truncated with an ellipsis instead of wrapping.2f:T577,### Minor Changes - f30a2a9: A focus ring on the focused header or body cell, drawn in `--gridkit-accent`. The grid is one tab stop with the arrow keys moving within it, so the ring is the only sign of where that stop is. Two new hooks for the styles to target: `.gridkit-sr-only`, which hides the grid's live region visually while leaving it in the accessibility tree, and `.header-cell.is-reorderable` for the grab affordance — every header is focusable now, so a `tabindex` no longer picks out the ones that drag. - 4a92413: Styles for a selected row, column or cell, on two new palette tokens: `--gridkit-selected`, and `--gridkit-selected-strong` for one that is also hovered — hover already claims `--gridkit-surface-muted`, so without a second token a selected row would lose its highlight under the pointer. New classes the stylesheet targets: `is-selected` on a row, header cell or body cell, and `selectable-rows` / `selectable-columns` / `selectable-cells` on the grid itself. The last three enable rather than disable, the opposite of `no-hover-*` — hover is on by default and selection is off, so each class follows its own default. A grid that opts into row or cell selection also stops its cells' text being drag-selected, or a Shift-click meant to take a range of rows would smear the browser's own highlight across every cell it crossed.5:["$","div",null,{"className":"mx-auto w-full px-6 lg:px-8 grid max-w-7xl gap-10 py-12 lg:grid-cols-[220px_1fr] lg:gap-16 lg:py-16","children":[["$","aside",null,{"className":"lg:sticky lg:top-24 lg:self-start","children":["$","$L20",null,{"sections":[{"slug":"react","title":"@gridkitjs/react","repoPath":"packages/react/CHANGELOG.md","versions":[{"version":"0.9.0","content":"$21"},{"version":"0.8.0","content":"$22"},{"version":"0.7.0","content":"$23"},{"version":"0.6.0","content":"$24"},{"version":"0.5.0","content":"$25"},{"version":"0.4.0","content":"$26"},{"version":"0.3.1","content":"### Patch Changes\n\n- Updated dependencies [375c736]\n - @gridkitjs/core@0.4.0"},{"version":"0.3.0","content":"### Minor Changes\n\n- 1e112a6: `ColumnDefinition`'s new `wrap`, `headerClassName`, and `cellClassName`\n fields now render: `wrap.header`/`wrap.cells` add an `is-wrapped` class to\n that column's `th`/`td` (rendered by `@gridkitjs/theme-tailwind` as\n `white-space: normal`), and `headerClassName`/`cellClassName` are appended\n to the same elements as-is.\n\n### Patch Changes\n\n- Updated dependencies [1e112a6]\n - @gridkitjs/core@0.3.0"},{"version":"0.2.0","content":"### Minor Changes\n\n- 7f0645b: `DataGrid` can reorder its columns by drag and drop. Set `reorderableColumns`\n to let the user drag a header to a new position; a column may opt out with\n `reorderable: false` on its definition. Dragging a header anywhere on the cell\n starts the move, a copy of the header follows the pointer, and the side of the\n header the pointer is nearer to decides whether the column lands before or\n after it.\n\n Order is uncontrolled and mirrors sizing: `defaultColumnOrder` sets the order\n to start in, and `onColumnOrderChange` reports each drop that changes it. A\n focused header also moves with `Ctrl+ArrowLeft` / `Ctrl+ArrowRight`.\n\n Turning `reorderableColumns` off stops further dragging but leaves an order the\n user already made in place.\n\n### Patch Changes\n\n- Updated dependencies [7f0645b]\n - @gridkitjs/core@0.2.0"},{"version":"0.1.0","content":"$27"}]},{"slug":"core","title":"@gridkitjs/core","repoPath":"packages/core/CHANGELOG.md","versions":[{"version":"0.10.0","content":"$28"},{"version":"0.9.0","content":"$29"},{"version":"0.8.0","content":"$2a"},{"version":"0.7.0","content":"$2b"},{"version":"0.6.0","content":"$2c"},{"version":"0.5.0","content":"$2d"},{"version":"0.4.0","content":"### Minor Changes\n\n- 375c736: `fitColumnsToWidth` now shrinks unsized columns toward their `minWidth` when\n they exceed the available width, instead of leaving them at their full size\n and relying on the viewport to scroll. A `resizeMode=\"fit\"` grid now fills a\n narrow container in both directions; it still scrolls if every column is\n already at its `minWidth` (or user-resized) and the total still doesn't fit."},{"version":"0.3.0","content":"### Minor Changes\n\n- 1e112a6: Columns take a `wrap` option — `{ header?: boolean; cells?: boolean }` — and\n two escape-hatch class fields, `headerClassName` and `cellClassName`.\n\n `wrap` lets a column's header and/or cell text wrap onto multiple lines\n instead of the grid's default single line with an ellipsis; it's off by\n default, so existing grids render unchanged. `headerClassName`/\n `cellClassName` are appended to a column's `th`/`td` as-is — nothing in this\n package reads them — for styling a single column that no other prop covers."},{"version":"0.2.0","content":"### Minor Changes\n\n- 7f0645b: Column ordering, as the framework-agnostic half of drag-and-drop reordering.\n `applyColumnOrder(columns, order)` permutes a column list by a\n `ColumnOrderState` — an array of column ids that need not name every column,\n so one it omits keeps its position among the definitions and follows those it\n lists. `moveColumnBefore(order, movedId, beforeId)` produces the new order,\n returning the array it was given when the move changes nothing, and\n `resolveDropBefore(order, targetId, side)` turns a `\"before\"`/`\"after\"` hit\n into the id to move in front of, and `movesColumn(order, movedId, beforeId)`\n answers whether such a move would rearrange anything — the two gaps either\n side of a column are drops that change nothing, so an adapter asks this before\n offering one as a target.\n\n Columns also take a `reorderable` flag, resolved by `resolveColumnWidths` from\n the new `reorderable` option in the same way as `resizable` and surfaced on\n `ResolvedColumn`."},{"version":"0.1.0","content":"$2e"}]},{"slug":"theme-tailwind","title":"@gridkitjs/theme-tailwind","repoPath":"packages/theme-tailwind/CHANGELOG.md","versions":[{"version":"0.7.0","content":"### Minor Changes\n\n- bedd76c: `.grid-loading-cell`: styles `@gridkitjs/react`'s new `infiniteScroll` loading row — centered, muted text, matching the grand-total footer's own cell padding. The row is `aria-hidden` and outside `aria-rowcount`, so this is a purely visual cue.\n- bedd76c: `.gridkit-data-grid-body`: the row area's scroll container, styled to honor `@gridkitjs/react`'s new `height` prop (`overflow-y: auto`, height driven by the prop or `auto` when it's unset). No `position: sticky` is added for the header or footer — splitting them into their own tables already keeps them out of the region that scrolls, so there's nothing to stick. Add your own CSS targeting `.gridkit-data-grid-header`/`.gridkit-data-grid-footer` for a divider or shadow at the seam."},{"version":"0.6.0","content":"### Minor Changes\n\n- 6e8189b: Styles for aggregates (`@gridkitjs/react`'s new `aggregates` prop): `.group-aggregates`/`.group-aggregate` for a group header's inline subtotal (`groupAggregateDisplay: \"inline\"`), `.grid-group-summary-row`/`.grid-group-summary-cell` for a group's own summary row (`groupAggregateDisplay: \"row\"`), and `.grid-footer`/`.grid-footer-cell` for the grand-total footer — including each one's `borders-*` variants.\n- 6e8189b: Styles for the built-in pager's numbered variant (`@gridkitjs/react`'s `pager.variant: \"numbered\"`): `.grid-pager-button[aria-current=\"page\"]` for the active page, and `.grid-pager-ellipsis`.\n- 6e8189b: Styles for the new built-in pager (`@gridkitjs/react`'s `paginated` prop): `.gridkit-grid-pager`, `.grid-pager-button`, `.grid-pager-status`, and `.grid-pager-page-size`."},{"version":"0.5.0","content":"### Minor Changes\n\n- 388def3: Styles for dragging a header into the group-by bar and reordering its chips:\n drop indicators on chips, a dashed drag-target outline on the bar itself, a\n `not-allowed` cursor and muted outline for a header already in the group-by\n stack dragged back toward it, a grab cursor and drag ghost for chips, and an\n empty-bar placeholder shown only when at least one column is draggable into\n it.\n- 388def3: Styles for `@gridkitjs/react`'s new row grouping: the group header row, its\n expand/collapse toggle, each groupable column header's group icon, and the\n group-by bar and its removable chips."},{"version":"0.4.0","content":"### Minor Changes\n\n- a01c851: The stylesheet no longer registers its own `@custom-variant dark` — it now\n follows whatever `dark:` variant your app's own Tailwind build already\n resolves to, so it never conflicts with an app that configures its own\n (a class, a `data-` attribute, or anything else). Out of the box, with\n nothing customized, a grid now follows the OS `prefers-color-scheme`\n instead of a `.dark` class.\n\n To keep the previous class-toggle behavior, declare it yourself, same as any\n Tailwind v4 app would:\n\n ```css\n @import \"tailwindcss\";\n @custom-variant dark (&:where(.dark, .dark *));\n @import \"@gridkitjs/theme-tailwind/styles.css\";\n ```\n\n Also new: `.gridkit-light` / `.gridkit-dark`, which pin a grid to one palette\n regardless of the ambient `dark:` state. Put either on any ancestor of the\n grid, including the grid's own root, to force a single grid's theme\n independent of the app around it."},{"version":"0.3.2","content":"### Patch Changes\n\n- 29f2c39: The last row's cells no longer draw a bottom border under `borders-horizontal` or `borders-all` — previously it rendered as a stray extra edge below the table."},{"version":"0.3.1","content":"### Patch Changes\n\n- 26adc6f: Added multi-column stacked sorting. A header's sort toggle cycles a column\n through ascending, descending, and off; Shift-click adds or updates a column\n in the stack instead of replacing it, sorted in priority order. Configure\n with `sortableColumns` / `column.sortable`, seed with `defaultColumnSort`,\n and listen with `onColumnSortChange`."},{"version":"0.3.0","content":"$2f"},{"version":"0.2.3","content":"### Patch Changes\n\n- a157b54: Fixed `borders=\"all\"` still drawing a left-edge line on the first column. The table-level `box-shadow` meant to repaint that stripped edge didn't align with `border-collapse: collapse` and left a stray line behind; the outer left/right edges are now simply left unset on the first/last cell, with nothing repainting them."},{"version":"0.2.2","content":"### Patch Changes\n\n- 7dcffc9: A column with `wrap` enabled now breaks a word longer than the column instead\n of overflowing it — `white-space: normal` alone only breaks at spaces, so a\n long unbroken token (a URL, a long identifier) previously spilled past the\n column's fixed width."},{"version":"0.2.1","content":"### Patch Changes\n\n- 76c62b1: Fix the grid overflowing its viewport by 1px under `borders=\"all\"`. The first\n column's left border had no neighbour to collapse with, so it added a pixel\n the width calculations didn't account for — under `resizeMode=\"fit\"` this\n clipped the last column's border and, in narrow layouts, its content."},{"version":"0.2.0","content":"### Minor Changes\n\n- 1e112a6: Styles the new `is-wrapped` state `@gridkitjs/react` adds for a column with\n `wrap.header`/`wrap.cells` set: `overflow: visible`, `text-overflow: clip`,\n and `white-space: normal` in place of the grid's default single-line\n ellipsis, on just that column's header and/or cells."},{"version":"0.1.0","content":"### Minor Changes\n\n- 7f0645b: Styles for column reordering. A header being dragged goes half-opaque and a\n copy of it trails the pointer, while the gap the column would drop into takes\n an accent line — drawn on the leading edge of the column after the gap, or the\n trailing edge of the last one. A reorderable header also takes a `grab` cursor\n and stops its label being selected mid-drag."}]}]}]}],"$L30"]}] 6:["$","div",null,{"children":[["$","h1",null,{"className":"text-site-ink text-3xl font-semibold tracking-tight","children":"Changelog"}],["$","p",null,{"className":"text-site-ink-muted mt-3 max-w-2xl text-lg","children":"What shipped and when, straight from each package's CHANGELOG.md."}],["$","div",null,{"className":"mt-10 grid gap-6 sm:grid-cols-2 lg:grid-cols-3","children":["$L31","$L32","$L33"]}],["$","p",null,{"className":"text-site-ink-muted mt-10 text-sm","children":["Looking for reference docs?"," ","$L34"]}]]}]

` for its own column, aligned the same way the grand-total footer's cells are. - A footer or `"row"`-mode summary cell aligns the same way its column's own data cells do, unless `AggregateSpec.alignment` overrides it for that specific aggregate — e.g. centering a `count` under an otherwise right-aligned currency column. When two specs share a column and disagree, the first one in `aggregates` wins for that shared cell. - A grand-total footer (a `
` cells now set `role="columnheader"` explicitly, matching the explicit `role="gridcell"`/`role="row"` already set on body cells and rows, rather than relying on `	`'s implicit role mapping inside a `role="grid"` table. - Body `	` cells now set `aria-keyshortcuts="Space Enter"` when cell selection is enabled, matching the shortcuts header cells already advertise. - ac7695f: `Borders` and `HoverableConfig` — the types behind `DataGridComponent`'s `borders` and `hoverable` props — are now exported from `@gridkitjs/react`. - ac7695f: `DataGridComponent` accepts a `ref` prop typed `Ref>`. The handle exposes the grid's live column sizing/order/sort, row/column/cell selection, resolved rows/columns, and the focused cell, plus `focusCell`, `clearSelection`, `selectAllRows`, `scrollToRow`, and `scrollToColumn`. ### Patch Changes - ac7695f: Internal refactor of `DataGrid`'s implementation: pointer-drag lifecycles (column resize, column reorder), "compute next state, bail if unchanged, persist, notify" selection/sort commits, conditional class-name and ARIA attribute construction, keyboard select-intent handling, and a couple of `useMemo`-derived lookup structures now go through shared internal helpers instead of five-plus near-duplicate copies. No public API or rendered behavior changes for a correct caller. One deliberate exception: `useColumnResize`'s `commit` was already missing the bail-if-unchanged guard the other commit-style call sites have, so its `"move"`-phase `onColumnResize` calls during a drag pinned against a min/max clamp were left as-is (still firing on every pointer move) rather than silently gaining a new guard — kept out of the shared `commitIfChanged` helper on purpose, with a comment at the call site. - ac7695f: `@gridkitjs/core` now exports pure grid logic that previously lived only inside `@gridkitjs/react`'s `DataGrid` hooks, so a future non-React binding (or any consumer working directly against `core`) can reuse it instead of reimplementing it: - `clampFocus`, `nextFocusForKey`, `HEADER_ROW`, and the `GridFocus`/ `NavigationModifiers` types — the header/body focus-navigation state machine. - `intentOf` and `applySelectionIntent`, plus the `SelectIntent` type — reading a click or key press's modifiers into an intent, and applying it to a `SelectionState`. - `resolveRows`, `resolveColumns`, and `resolveCell` — resolving selected ids back to the row/column/cell records behind them, dropping any id whose row or column no longer exists. - `resolveKeyboardDropTarget` — the `beforeId` a keyboard column-reorder nudge produces, matching the pointer-drag drop path already in `moveColumnBefore`. - `buildKeyShortcuts` (and the `KeyShortcutCapabilities` type) — the `aria-keyshortcuts` string for a column header. - `revertColumnSize` — the sizing-state merge a cancelled resize reverts to. `@gridkitjs/react`'s `DataGrid` hooks (`useGridNavigation`, `useGridSelection`, `useColumnDrag`, `useColumnResize`) and `GridHeader` now call these instead of defining them locally. No behavior change for a correct caller — this is the same logic, moved. - Updated dependencies [ac7695f] - Updated dependencies [ac7695f] - @gridkitjs/core@0.7.025:T766,### Minor Changes - 26adc6f: Added filtering infrastructure: `FilterState`/`FilterEntry` — a discriminated union of a `%`-wildcard text query, a typed exact-value match (type-scoped: a number never matches a string column), a custom predicate, or a nested `GroupFilterEntry` for AND/OR composition — ANDed together across top-level entries. Added the core `filterRows` / `setColumnFilter` / `clearAllFilters` / `filterQueryFor` / `matchesQuery` functions, and `resolveShownRows`, which composes filtering and sorting. Seed a grid's filter with `defaultFilter` on `DataGridComponent`. No header or toolbar UI ships yet — pre-filter `dataSource` yourself with the exported functions, or seed `defaultFilter`, until it does. - 26adc6f: Added multi-column stacked sorting. A header's sort toggle cycles a column through ascending, descending, and off; Shift-click adds or updates a column in the stack instead of replacing it, sorted in priority order. Configure with `sortableColumns` / `column.sortable`, seed with `defaultColumnSort`, and listen with `onColumnSortChange`. ### Patch Changes - 26adc6f: Fixed a bug where cancelling a column drag with `Escape` could discard another column's width if that column was resized via keyboard while the drag was still in progress. The cancelled column now reverts on its own, leaving concurrent changes to other columns intact. - 26adc6f: Fixed a spurious `onColumnResize` "end" event firing when a resize handle's pointer is released with no intervening move — including each of the two clicks that make up a double-click. - 26adc6f: Fixed `sizeToContent` (double-click a resize handle) measuring the header's own label as if it were a data cell when the grid has no rows, instead of correctly doing nothing. - Updated dependencies [26adc6f] - Updated dependencies [26adc6f] - @gridkitjs/core@0.6.026:Tce9,### Minor Changes - f30a2a9: The grid is now an ARIA grid a keyboard can navigate. It carries `role="grid"` with row and column counts and indices, headers carry `scope="col"`, and one roving tab stop moves cell to cell under the arrow keys, Home, End, Ctrl+Home, Ctrl+End and the page keys. Two changes to what a keyboard already did: - Tab now passes the whole grid, entering it once instead of stopping on every resize handle. The handles have left the tab order — a widget under `role="grid"` has one tab stop, and a grid of twenty columns previously had twenty. - Keyboard resize moved to `Alt+ArrowLeft` / `Alt+ArrowRight` on the focused header, from the bare arrows on its handle, which the grid now needs for navigation. `Ctrl+ArrowLeft` / `Ctrl+ArrowRight` still reorder. `label` and `labelledBy` give the grid its accessible name, without which a screen reader announces only "grid": ```tsx ``` Reorders and resizes are announced through a live region, so a change with only a visual cue is no longer silent. - f92198e: `DataGridComponent` takes `getRowId`, giving each row a stable identity for state keyed by it. Rows are keyed by it rather than by their array position, and `cellTemplate` receives it as `rowId` alongside a `selected` flag. ```tsx row.Id} /> ``` Without it a row is identified by its position, which is enough for a static grid — so nothing has to change — but ties row state to where a row sits rather than to the row itself. - 4a92413: Rows, columns and cells can be selected. `selectable` says which and how many of each — off by default, since selection claims the click: ```tsx row.Id} selectable={{ rows: "multiple", columns: "multiple", cells: "single" }} onRowSelect={({ row }) => console.log(row.row.Name)} onRowSelectionChange={({ added, removed, selected }) => persist(selected)} /> ``` A cell takes `false \| "single"` rather than a mode of its own — it addresses one value, so there is no range to take. Click replaces, Ctrl-click toggles and Shift-click takes a range; from the keyboard, Space toggles the focused row or column, Enter replaces, `Ctrl+A` takes every row and Escape lets them all go. Rows and cells report `aria-selected`, and the grid `aria-multiselectable`. Thirteen callbacks report it — `onRowSelect`, `onRowsSelect`, `onRowDeselect`, `onRowsDeselect` and `onRowSelectionChange`, the same five for columns, and `onCellSelect` / `onCellDeselect` / `onCellSelectionChange`. Each carries the resolved row, column or cell value rather than a bare id, and all of them are fanned out from one diff, so no two can disagree about what an interaction did. `defaultRowSelection`, `defaultColumnSelection` and `defaultCellSelection` set the starting state. Give `getRowId` alongside `selectable` for data that sorts, filters or pages: without it a row is identified by its position, so a re-sort leaves the same positions selected under different rows. ### Patch Changes - Updated dependencies [f92198e] - @gridkitjs/core@0.5.027:T1138,### Minor Changes - e0f5b59: Columns take `headerTemplate` in place of `header`, and a new `cellTemplate` renders a column's cells. `{ field: "Id", header: "#" }` becomes `{ field: "Id", headerTemplate: "#" }`. `cellTemplate` receives `{ value, row, rowIndex }` and returns whatever the adapter renders — in React, `cellTemplate: ({ value }) => {value}`. `value` is the cell's own value read off the field path, so a template that only formats it never repeats the path. A column without one renders the raw value as before. - 401a2cc: Address nested fields with `"Parent.Child"` paths, and derive columns from data `ColumnDefinition["field"]` now autocompletes one level of nesting via the new `FieldPath` type, while still accepting any string so a path the type cannot see is never a hard error. `defineColumnsFromRows` derives a column per field across a set of rows, in first-seen order and without duplicates. `ColumnDefinition` takes a second type parameter for what a header renders to. It defaults to `string` in `@gridkitjs/core`, which stays framework-agnostic; `@gridkitjs/react` exports a `ColumnDefinition` alias bound to `ReactNode`, so a header callback can return JSX. This replaces the untyped `Function`. - a3db97e: Resolve a column's label, resizability and alignment in core `ResolvedColumn` gains `label`, `resizable` and `alignment`, so it now describes a column completely rather than only its width. `resolveColumnWidths` decides all three: a header is resolved eagerly or by calling it, falling back to a label read off the field path; `resizable` takes the column's own setting over the grid's; alignment falls back to the column's type. A second framework adapter renders identically without repeating any of it. `resolveColumnWidths` takes a `ColumnResolveOptions` object as its third argument in place of the size defaults — `{ sizes: { width: 60 } }` where it was `{ width: 60 }` — since the grid-level defaults are no longer only sizes. `resolveColumnLabel`, `alignmentForType` and `KEYBOARD_STEP` are exported for adapters that resolve columns themselves. Columns that set a numeric `type` without an explicit `alignment` now align right, matching columns inferred from data — previously only the inferred ones did. Numeric alignment covers `decimal`, `currency` and `percent` alongside `number`. A column with `header: ""` now renders an empty header instead of falling back to its field name. - 45e492c: Size, resize and auto-fit columns `ColumnDefinition` gains `width`, `minWidth`, `maxWidth` and `resizable`, plus an optional `id` that state is keyed by and that defaults to `field`. Every width calculation lives in `@gridkitjs/core` — `resolveColumnWidths` applies the precedence (sizing state, then the column, then the default) and clamps; `beginColumnResize`/`applyColumnResize` turn a pointer position into a width; `fitColumnsToWidth` distributes a container's width across columns. A future adapter for another framework inherits all of it. `DataGridComponent` takes `resizableColumns`, `resizeMode`, `onColumnResize` and two sizing props that read alike but differ: `defaultColumnSizing` sets the starting width of specific columns, keyed by id, while `columnSizeDefaults` sets the width and bounds used for any column that does not size itself. Columns can be dragged by their right edge, resized with the arrow keys, and sized to their content by double-clicking the handle. `resizeMode` chooses what a resize does to the other columns. Under the default `"fit"`, columns fill the grid: auto-fit leaves those the user has sized alone and shares the remaining width between the rest, so a column giving up space hands it to its neighbours. Under `"fixed"`, every column keeps its own width — a resize moves one column and nothing else, and the grid scrolls or leaves a gap to suit. The grid now renders inside a scrolling wrapper and sizes its columns through a `
` cells now set `role="columnheader"` explicitly, matching the explicit `role="gridcell"`/`role="row"` already set on body cells and rows, rather than relying on `	`'s implicit role mapping inside a `role="grid"` table. - Body `	` cells now set `aria-keyshortcuts="Space Enter"` when cell selection is enabled, matching the shortcuts header cells already advertise. - ac7695f: `@gridkitjs/core` now exports pure grid logic that previously lived only inside `@gridkitjs/react`'s `DataGrid` hooks, so a future non-React binding (or any consumer working directly against `core`) can reuse it instead of reimplementing it: - `clampFocus`, `nextFocusForKey`, `HEADER_ROW`, and the `GridFocus`/ `NavigationModifiers` types — the header/body focus-navigation state machine. - `intentOf` and `applySelectionIntent`, plus the `SelectIntent` type — reading a click or key press's modifiers into an intent, and applying it to a `SelectionState`. - `resolveRows`, `resolveColumns`, and `resolveCell` — resolving selected ids back to the row/column/cell records behind them, dropping any id whose row or column no longer exists. - `resolveKeyboardDropTarget` — the `beforeId` a keyboard column-reorder nudge produces, matching the pointer-drag drop path already in `moveColumnBefore`. - `buildKeyShortcuts` (and the `KeyShortcutCapabilities` type) — the `aria-keyshortcuts` string for a column header. - `revertColumnSize` — the sizing-state merge a cancelled resize reverts to. `@gridkitjs/react`'s `DataGrid` hooks (`useGridNavigation`, `useGridSelection`, `useColumnDrag`, `useColumnResize`) and `GridHeader` now call these instead of defining them locally. No behavior change for a correct caller — this is the same logic, moved.2c:T450,### Minor Changes - 26adc6f: Added filtering infrastructure: `FilterState`/`FilterEntry` — a discriminated union of a `%`-wildcard text query, a typed exact-value match (type-scoped: a number never matches a string column), a custom predicate, or a nested `GroupFilterEntry` for AND/OR composition — ANDed together across top-level entries. Added the core `filterRows` / `setColumnFilter` / `clearAllFilters` / `filterQueryFor` / `matchesQuery` functions, and `resolveShownRows`, which composes filtering and sorting. Seed a grid's filter with `defaultFilter` on `DataGridComponent`. No header or toolbar UI ships yet — pre-filter `dataSource` yourself with the exported functions, or seed `defaultFilter`, until it does. - 26adc6f: Added multi-column stacked sorting. A header's sort toggle cycles a column through ascending, descending, and off; Shift-click adds or updates a column in the stack instead of replacing it, sorted in priority order. Configure with `sortableColumns` / `column.sortable`, seed with `defaultColumnSort`, and listen with `onColumnSortChange`.2d:T44d,### Minor Changes - f92198e: Selection primitives, ahead of the grid wiring them up. `toggleSelection`, `selectOnly`, `selectRange`, `selectAll` and `clearSelection` transform an ordered `SelectionState` of ids under a `SelectionMode` of `false \| "single" \| "multiple"`; `selectCell` and `toggleCellSelection` do the same for the single `CellSelectionState`. Each returns its input by reference when nothing changed, as `moveColumnBefore` does, so a caller can skip a render and an event on that alone. `diffSelection` reports what one transition added and removed. `resolveRowId(row, index, getRowId?)` settles a row's identity, the counterpart to `getColumnId` — falling back to the row's position when no `getRowId` is given, which is enough for a static grid but ties row state to where a row sits rather than to the row. `CellTemplateContext` gains `rowId` and `selected`, so a template can key off its row or style itself to match the selection: ```ts cellTemplate: ({ value, rowId, selected }) => selected ? {value} : value; ```2e:T1086,### Minor Changes - e0f5b59: Columns take `headerTemplate` in place of `header`, and a new `cellTemplate` renders a column's cells. `{ field: "Id", header: "#" }` becomes `{ field: "Id", headerTemplate: "#" }`. `cellTemplate` receives `{ value, row, rowIndex }` and returns whatever the adapter renders — in React, `cellTemplate: ({ value }) => {value}`. `value` is the cell's own value read off the field path, so a template that only formats it never repeats the path. A column without one renders the raw value as before. - 401a2cc: Address nested fields with `"Parent.Child"` paths, and derive columns from data `ColumnDefinition["field"]` now autocompletes one level of nesting via the new `FieldPath` type, while still accepting any string so a path the type cannot see is never a hard error. `defineColumnsFromRows` derives a column per field across a set of rows, in first-seen order and without duplicates. `ColumnDefinition` takes a second type parameter for what a header renders to. It defaults to `string` in `@gridkitjs/core`, which stays framework-agnostic; `@gridkitjs/react` exports a `ColumnDefinition` alias bound to `ReactNode`, so a header callback can return JSX. This replaces the untyped `Function`. - a3db97e: Resolve a column's label, resizability and alignment in core `ResolvedColumn` gains `label`, `resizable` and `alignment`, so it now describes a column completely rather than only its width. `resolveColumnWidths` decides all three: a header is resolved eagerly or by calling it, falling back to a label read off the field path; `resizable` takes the column's own setting over the grid's; alignment falls back to the column's type. A second framework adapter renders identically without repeating any of it. `resolveColumnWidths` takes a `ColumnResolveOptions` object as its third argument in place of the size defaults — `{ sizes: { width: 60 } }` where it was `{ width: 60 }` — since the grid-level defaults are no longer only sizes. `resolveColumnLabel`, `alignmentForType` and `KEYBOARD_STEP` are exported for adapters that resolve columns themselves. Columns that set a numeric `type` without an explicit `alignment` now align right, matching columns inferred from data — previously only the inferred ones did. Numeric alignment covers `decimal`, `currency` and `percent` alongside `number`. A column with `header: ""` now renders an empty header instead of falling back to its field name. - 45e492c: Size, resize and auto-fit columns `ColumnDefinition` gains `width`, `minWidth`, `maxWidth` and `resizable`, plus an optional `id` that state is keyed by and that defaults to `field`. Every width calculation lives in `@gridkitjs/core` — `resolveColumnWidths` applies the precedence (sizing state, then the column, then the default) and clamps; `beginColumnResize`/`applyColumnResize` turn a pointer position into a width; `fitColumnsToWidth` distributes a container's width across columns. A future adapter for another framework inherits all of it. `DataGridComponent` takes `resizableColumns`, `resizeMode`, `onColumnResize` and two sizing props that read alike but differ: `defaultColumnSizing` sets the starting width of specific columns, keyed by id, while `columnSizeDefaults` sets the width and bounds used for any column that does not size itself. Columns can be dragged by their right edge, resized with the arrow keys, and sized to their content by double-clicking the handle. `resizeMode` chooses what a resize does to the other columns. Under the default `"fit"`, columns fill the grid: auto-fit leaves those the user has sized alone and shares the remaining width between the rest, so a column giving up space hands it to its neighbours. Under `"fixed"`, every column keeps its own width — a resize moves one column and nothing else, and the grid scrolls or leaves a gap to suit. The grid now renders inside a scrolling wrapper and sizes its columns through a `