@cube-dev/ui-kit 0.164.0 → 0.166.0

package/dist/components/data/TableBase/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","names":[],"sources":["../../../../src/components/data/TableBase/types.ts"],"sourcesContent":["import type { Key } from '@react-types/shared';\nimport type { Styles } from '@tenphi/tasty';\nimport type { ReactNode } from 'react';\nimport type { CubeItemProps } from '../../content/Item';\n\nexport type CubeTableSortDirection = 'asc' | 'desc';\n/**\n * Named row heights: 28px, 32px and 40px.\n *\n * A subset of the kit's size scale, and the same three steps `size` would give —\n * but `rowSize` moves only the ROWS. `size` also drives the header, so reaching\n * for a denser body through it drags the header down too.\n */\nexport type CubeTableRowSize = 'small' | 'medium' | 'large';\nexport type CubeTableAlign = 'start' | 'center' | 'end';\nexport type CubeTableRowSection = 'body' | 'pinnedTop' | 'pinnedBottom';\n\n/**\n * `asc | desc` rather than React Aria's `ascending | descending`: we do not use\n * `useTableState`, so there is no `SortDescriptor` interop to preserve, and\n * every consumer and server query parameter already speaks `asc|desc`.\n * `aria-sort` is a one-line map in the header cell.\n */\n/**\n * A rectangular block of cells, stored as two opposite corners.\n *\n * Corners rather than a set of keys so the selection survives a re-sort or a\n * page change the way a keyed row selection does: \"the block between these two\n * cells\" is re-resolved against the current order every render.\n */\n/**\n * The key a cell range identifies a row by.\n *\n * Not the consumer's row key: a pinned total is commonly the SAME record at the\n * top and the bottom (`id: 'total'`), and one flat key space collapsed the two\n * into whichever `indexOf` found first — so a range aimed at the footer total\n * resolved against the header one. The section is part of the identity here,\n * and only here; `ctx.rowKey` stays the consumer's own.\n */\nexport function selectionRowKey(\n  section: CubeTableRowSection,\n  rowKey: Key,\n): Key {\n  return section === 'body' ? rowKey : `${section}:${rowKey}`;\n}\n\nexport interface CubeTableCellRange {\n  fromRowKey: Key;\n  toRowKey: Key;\n  fromColumnKey: string;\n  toColumnKey: string;\n}\n\nexport interface CubeTableSort {\n  /** `key` of the sorted column. */\n  columnKey: string;\n  direction: CubeTableSortDirection;\n}\n\n/* ── render contexts ─────────────────────────────────────────────────────── */\n\nexport interface CubeTableCellContext<T = any> {\n  row: T;\n  rowKey: Key;\n  rowIndex: number;\n  columnKey: string;\n  columnIndex: number;\n  section: CubeTableRowSection;\n  /** Whether the ROW is selected, matching `isRowFocused` below. */\n  isSelected: boolean;\n  /**\n   * Not yet wired — always absent.\n   *\n   * Optional rather than `boolean`, because there is nowhere honest to compute\n   * them from where this context is built. Focus lives in the DOM, and drop\n   * state comes out of `useDropIndicator`, a hook that can only run inside the\n   * row component — so populating either means moving the `render` / `cellStyles`\n   * call sites into `TableRow`. Declaring them required and passing `false`\n   * would just be a documented lie.\n   */\n  isRowFocused?: boolean;\n  isDropTarget?: boolean;\n}\n\nexport interface CubeTableRowContext<T = any> {\n  row: T;\n  rowKey: Key;\n  rowIndex: number;\n  section: CubeTableRowSection;\n  isSelected: boolean;\n  /** Not yet wired — always absent. See `CubeTableCellContext` for why. */\n  isFocused?: boolean;\n  isDropTarget?: boolean;\n}\n\nexport interface CubeTableHeaderContext {\n  columnKey: string;\n  columnIndex: number;\n  sort: CubeTableSortDirection | null;\n  isSortable: boolean;\n  isResizing: boolean;\n  width: number | null;\n}\n\n/* ── column ──────────────────────────────────────────────────────────────── */\n\n/**\n * Rich header content. Every slot except `menu` maps 1:1 onto the `Item`\n * rendered inside the header `<th>`, so a header gets icon / description /\n * tooltip / suffix / actions for free; `menu` is mounted into that `Item`'s\n * `actions` slot behind a `⋮` trigger.\n */\nexport interface CubeTableColumnHeader {\n  icon?: CubeItemProps['icon'];\n  rightIcon?: CubeItemProps['rightIcon'];\n  prefix?: ReactNode;\n  suffix?: ReactNode;\n  description?: ReactNode;\n  descriptionPlacement?: CubeItemProps['descriptionPlacement'];\n  /** `true` = auto tooltip when the label is truncated. */\n  tooltip?: CubeItemProps['tooltip'];\n  actions?: ReactNode;\n  /** Hide `actions` until hover/focus. @default true */\n  autoHideActions?: boolean;\n  /**\n   * A column menu, opened from a `⋮` trigger in the header's actions slot and —\n   * unless the table says otherwise — by right-click or Shift+F10.\n   *\n   * `Menu.Item` children. Opaque: the table mounts the node and reports the\n   * pressed key back through `onColumnMenuAction`, so what a \"pin\" or a \"drill\n   * down\" means stays in the consuming app. The exception is the reserved sort\n   * keys (`sort-asc`, `sort-desc`, `clear-sort`), which the table labels,\n   * disables when redundant, and applies itself before telling the consumer.\n   *\n   * An empty menu renders no trigger at all, rather than one that opens nothing.\n   * Ignored when `header.render` takes the cell over.\n   */\n  menu?: ReactNode;\n  /** Props for the `⋮` trigger. Merged over the table's `columnMenuTriggerProps`. */\n  menuTriggerProps?: Record<string, any>;\n  /** Props for the `Menu`. Merged over the table's `columnMenuProps`. */\n  menuProps?: Record<string, any>;\n  /** Called before the table-level `onColumnMenuAction`. */\n  onMenuAction?: (action: string) => void;\n  theme?: CubeItemProps['theme'];\n  /**\n   * Full takeover of the header cell's content. Overrides `title` and every\n   * slot — including `actions` and `menu`, which are simply not rendered. A\n   * takeover that wants a menu owns the trigger too.\n   */\n  render?: (ctx: CubeTableHeaderContext) => ReactNode;\n  /** Overrides `column.align` for the header only. */\n  align?: CubeTableAlign;\n  styles?: Styles;\n}\n\n/* ── column colour ───────────────────────────────────────────────────────── */\n\n/**\n * A palette theme a column can borrow its tint from.\n *\n * Resolved through the same runtime generator as a custom colour, seeded from the\n * theme's own hue and saturation in `palette-config` — so it tracks a re-seeded\n * palette, and it gets the banding step the palette itself does not define.\n *\n * `special` is absent deliberately: it is a standalone `mode: 'fixed'` theme with\n * no tinted-surface ramp to borrow.\n */\nexport type CubeTableColumnTheme =\n  | 'primary'\n  | 'purple'\n  | 'success'\n  | 'danger'\n  | 'warning'\n  | 'note';\n\n/**\n * How a column is tinted.\n *\n * Every form but the last is *derived*: only a hue and a saturation are kept, and\n * the tone ramp plus an `AA`/`AAA` text floor are re-solved per colour scheme. So\n * a column stays readable in light, dark and high contrast without the caller\n * checking — which is the part hand-picked hex pairs get wrong.\n */\nexport type CubeTableColumnColor =\n  /** A palette theme name. */\n  | CubeTableColumnTheme\n  /** Any colour Glaze parses — hex, `rgb()`, `hsl()`, `okhsl()`, `oklch()`. */\n  | (string & {})\n  /** The seed said directly. `saturation` is 0–100. */\n  | { hue: number; saturation?: number }\n  /**\n   * Full manual control, as tasty colour strings (`'#note-surface'`, `'#purple.10'`).\n   *\n   * Nothing is derived and nothing is contrast-checked — this is the escape\n   * hatch, and readability in every scheme becomes the caller's problem.\n   * `fillBand` defaults to `fill`, which turns banding off for the column.\n   */\n  | { fill: string; fillBand?: string; text?: string };\n\n/**\n * Which parts of a column `color` reaches.\n *\n * @default ['header','body','totals']\n */\nexport type CubeTableColumnColorScope = 'header' | 'body' | 'totals';\n\nexport interface CubeTableColumn<T = any> {\n  /**\n   * Column id. Also the default data path — dot notation is supported\n   * (`'owner.name'`). Anything beyond a path needs `getValue`.\n   */\n  key: string;\n  /** Header label. Shorthand for `header` with no extra slots. */\n  title?: ReactNode;\n  header?: CubeTableColumnHeader;\n  /**\n   * Renders `<th scope=\"row\">` instead of `<td>`, names the row for screen\n   * readers, and hosts the `rowLink` anchor. Defaults to the first\n   * non-structural column when a row link is present.\n   */\n  isRowHeader?: boolean;\n\n  /* sizing */\n  /** Fixed width in px. Mutually exclusive with `flex`. */\n  width?: number;\n  /** Weight for the leftover space. @default 1 when `width` is unset */\n  flex?: number;\n  /** @default 150 */\n  minWidth?: number;\n  maxWidth?: number;\n  /** Inherits the table's `isResizable`. */\n  isResizable?: boolean;\n  /**\n   * Inherits the table's `isColumnReorderable`; `false` pins this column in\n   * place while the others still move around it.\n   */\n  isReorderable?: boolean;\n  /** Stick to the start/end edge during horizontal scroll. */\n  pin?: 'start' | 'end';\n  /** Hide without losing width or order state. */\n  isHidden?: boolean;\n\n  /* value pipeline */\n  /** @default (row) => get(row, key) */\n  getValue?: (row: T, rowIndex: number) => unknown;\n  /** Raw value → display text. Feeds client sort, client search and TSV copy. */\n  format?: (value: any, row: T, rowIndex: number) => string;\n  /** Client-side comparator over raw `getValue` results. */\n  compare?: (a: any, b: any, rowA: T, rowB: T) => number;\n\n  /* rendering */\n  /** A returned string is wrapped in a truncating `TextItem`. */\n  render?: (\n    value: any,\n    row: T,\n    rowIndex: number,\n    ctx: CubeTableCellContext<T>,\n  ) => ReactNode;\n  cellStyles?: Styles | ((ctx: CubeTableCellContext<T>) => Styles | undefined);\n  cellProps?: (ctx: CubeTableCellContext<T>) => Record<string, any> | undefined;\n\n  /**\n   * Tints the column — header, cells and pinned totals — with an adaptive fill\n   * and a text colour solved to stay readable on it in every scheme.\n   *\n   * Row banding survives: the tint carries its own band one tone step away, so\n   * the stripe still reads down the column instead of being painted over.\n   */\n  color?: CubeTableColumnColor;\n  /** Narrows what `color` reaches. @default ['header','body','totals'] */\n  colorScope?: readonly CubeTableColumnColorScope[];\n\n  /* behaviour */\n  align?: CubeTableAlign;\n  /**\n   * Opt IN, per column — a table is not sortable until at least one column says\n   * so, and `sortMode` then defaults to `'client'`.\n   *\n   * (This read `@default true` for a long time, which was never what the code\n   * did: `TableView` requires `isSortable === true` before a header becomes a\n   * control at all.)\n   *\n   * @default false\n   */\n  isSortable?: boolean;\n  /** Two-state cycling (asc ↔ desc), never back to unsorted. @default false */\n  disallowSortRemoval?: boolean;\n  /** Include in the built-in client search. @default true */\n  isSearchable?: boolean;\n  /** Include in TSV copy. @default true */\n  isCopyable?: boolean;\n  /** Wrap text and let the row grow to fit. */\n  autoHeight?: boolean;\n\n  /** Consumer-owned bag. Never reaches the DOM. */\n  meta?: Record<string, unknown>;\n}\n\n/* ── resolved layout (internal, but exported for adapters) ───────────────── */\n\nexport interface CubeResolvedColumn<T = any>\n  // `width`, `minWidth`, `maxWidth`, `flex` and `align` are all resolved here,\n  // so they narrow from optional to definite and must be replaced, not extended.\n  extends Omit<\n    CubeTableColumn<T>,\n    'width' | 'minWidth' | 'maxWidth' | 'flex' | 'align'\n  > {\n  /** Position among the visible leaf columns, 0-based. */\n  index: number;\n  /** `aria-colindex`, 1-based and document-absolute. */\n  ariaColIndex: number;\n  /** Resolved pixel width, or `null` while the container is unmeasured. */\n  width: number | null;\n  minWidth: number;\n  maxWidth: number | null;\n  flex: number | null;\n  align: CubeTableAlign;\n  /** Cumulative sticky offset in px for a pinned column. */\n  pinOffset: number | null;\n  /** `true` for the last pinned-start / first pinned-end column. */\n  isPinEdge: boolean;\n  /** Structural columns (selection, drag handle, row menu) never enter sorting,\n   *  search, copy, or the value pipeline. */\n  isStructural: boolean;\n}\n\nexport interface CubeTableColumnLayout<T = any> {\n  columns: CubeResolvedColumn<T>[];\n  pinnedStartWidth: number;\n  pinnedEndWidth: number;\n  /** Sum of resolved widths, or `null` while unmeasured. */\n  totalWidth: number | null;\n  /** `true` when the columns cannot fit and the table scrolls horizontally. */\n  isOverflowing: boolean;\n}\n\n/**\n * How a refresh over an existing result is presented.\n *\n * - `overlay` — keep the previous rows visible, dimmed, behind a spinner. A\n *   server page or a re-sort never blanks the table.\n * - `skeleton` — discard the previous rows and show placeholders.\n * - `none` — no visuals beyond `aria-busy`; the page owns the indicator.\n */\nexport type CubeTableLoadingIndicator = 'overlay' | 'skeleton' | 'none';\n\nexport type CubeTableSelectionMode = 'none' | 'single' | 'multiple';\n\n/**\n * What the header checkbox acts on.\n *\n * - `page` — the rows on the current page.\n * - `filtered` — every row passing the current search/filter, across pages.\n * - `all` — emits the `'all'` sentinel, meaning \"everything, including rows the\n *   client has not loaded\". The consumer decides what that means for its query.\n */\nexport type CubeTableSelectAllMode = 'page' | 'filtered' | 'all';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,gBACd,SACA,QACK;AACL,QAAO,YAAY,SAAS,SAAS,GAAG,QAAQ,GAAG"}
+{"version":3,"file":"types.js","names":[],"sources":["../../../../src/components/data/TableBase/types.ts"],"sourcesContent":["import type { Key } from '@react-types/shared';\nimport type { Styles } from '@tenphi/tasty';\nimport type { ReactNode } from 'react';\nimport type { CubeItemProps } from '../../content/Item';\n\nexport type CubeTableSortDirection = 'asc' | 'desc';\n/**\n * Named row heights: 28px, 32px and 40px.\n *\n * A subset of the kit's size scale, and the same three steps `size` would give —\n * but `rowSize` moves only the ROWS. `size` also drives the header, so reaching\n * for a denser body through it drags the header down too.\n */\nexport type CubeTableRowSize = 'small' | 'medium' | 'large';\nexport type CubeTableAlign = 'start' | 'center' | 'end';\nexport type CubeTableRowSection = 'body' | 'pinnedTop' | 'pinnedBottom';\n\n/**\n * `asc | desc` rather than React Aria's `ascending | descending`: we do not use\n * `useTableState`, so there is no `SortDescriptor` interop to preserve, and\n * every consumer and server query parameter already speaks `asc|desc`.\n * `aria-sort` is a one-line map in the header cell.\n */\n/**\n * A rectangular block of cells, stored as two opposite corners.\n *\n * Corners rather than a set of keys so the selection survives a re-sort or a\n * page change the way a keyed row selection does: \"the block between these two\n * cells\" is re-resolved against the current order every render.\n */\n/**\n * The key a cell range identifies a row by.\n *\n * Not the consumer's row key: a pinned total is commonly the SAME record at the\n * top and the bottom (`id: 'total'`), and one flat key space collapsed the two\n * into whichever `indexOf` found first — so a range aimed at the footer total\n * resolved against the header one. The section is part of the identity here,\n * and only here; `ctx.rowKey` stays the consumer's own.\n */\nexport function selectionRowKey(\n  section: CubeTableRowSection,\n  rowKey: Key,\n): Key {\n  return section === 'body' ? rowKey : `${section}:${rowKey}`;\n}\n\nexport interface CubeTableCellRange {\n  fromRowKey: Key;\n  toRowKey: Key;\n  fromColumnKey: string;\n  toColumnKey: string;\n}\n\nexport interface CubeTableTreeRowState {\n  /** Zero-based depth in the hierarchy. */\n  level: number;\n  parentKey: Key | null;\n  hasChildren: boolean;\n  isExpanded: boolean;\n}\n\nexport interface CubeTableRowExpandInfo<T = any> {\n  row: T;\n  rowKey: Key;\n  level: number;\n  parentKey: Key | null;\n  expanded: boolean;\n}\n\n/** Shared root sizing contract used by both table adapters. */\nexport interface CubeTableLayoutProps {\n  /**\n   * Shrink-wraps the frame to its rendered rows instead of filling the\n   * available flex pane. This mode disables virtualization because there is no\n   * bounded vertical viewport to virtualize against.\n   *\n   * @default false\n   */\n  isAutoHeight?: boolean;\n}\n\n/** Shared opt-in hierarchy contract used by both table adapters. */\nexport interface CubeTableTreeProps<T = any> {\n  /**\n   * Returns a row's already-loaded children. Supplying this enables tree mode\n   * and makes `data` the top-level row collection.\n   */\n  getRowChildren?: (row: T) => readonly T[] | undefined;\n  /** Column that owns the indentation and disclosure control. */\n  treeColumnKey?: string;\n  /** Controlled expanded row keys. */\n  expandedKeys?: Key[];\n  /** Initially expanded row keys. */\n  defaultExpandedKeys?: Key[];\n  /** Called after a user expands or collapses a row. */\n  onExpand?: (keys: Key[], info: CubeTableRowExpandInfo<T>) => void;\n}\n\nexport interface CubeTableSort {\n  /** `key` of the sorted column. */\n  columnKey: string;\n  direction: CubeTableSortDirection;\n}\n\n/* ── render contexts ─────────────────────────────────────────────────────── */\n\nexport interface CubeTableCellContext<T = any> {\n  row: T;\n  rowKey: Key;\n  rowIndex: number;\n  columnKey: string;\n  columnIndex: number;\n  section: CubeTableRowSection;\n  /** Whether the ROW is selected, matching `isRowFocused` below. */\n  isSelected: boolean;\n  /**\n   * Not yet wired — always absent.\n   *\n   * Optional rather than `boolean`, because there is nowhere honest to compute\n   * them from where this context is built. Focus lives in the DOM, and drop\n   * state comes out of `useDropIndicator`, a hook that can only run inside the\n   * row component — so populating either means moving the `render` / `cellStyles`\n   * call sites into `TableRow`. Declaring them required and passing `false`\n   * would just be a documented lie.\n   */\n  isRowFocused?: boolean;\n  isDropTarget?: boolean;\n  /** Present only when `getRowChildren` enables tree mode. */\n  tree?: CubeTableTreeRowState;\n}\n\nexport interface CubeTableRowContext<T = any> {\n  row: T;\n  rowKey: Key;\n  rowIndex: number;\n  section: CubeTableRowSection;\n  isSelected: boolean;\n  /** Not yet wired — always absent. See `CubeTableCellContext` for why. */\n  isFocused?: boolean;\n  isDropTarget?: boolean;\n  /** Present only when `getRowChildren` enables tree mode. */\n  tree?: CubeTableTreeRowState;\n}\n\nexport interface CubeTableHeaderContext {\n  columnKey: string;\n  columnIndex: number;\n  sort: CubeTableSortDirection | null;\n  isSortable: boolean;\n  isResizing: boolean;\n  width: number | null;\n}\n\n/** Presentational path entry used to build multi-row column headers. */\nexport interface CubeTableColumnGroupHeader {\n  key: string;\n  title?: ReactNode;\n}\n\n/* ── column ──────────────────────────────────────────────────────────────── */\n\n/**\n * Rich header content. Every slot except `menu` maps 1:1 onto the `Item`\n * rendered inside the header `<th>`, so a header gets icon / description /\n * tooltip / suffix / actions for free; `menu` is mounted into that `Item`'s\n * `actions` slot behind a `⋮` trigger.\n */\nexport interface CubeTableColumnHeader {\n  icon?: CubeItemProps['icon'];\n  rightIcon?: CubeItemProps['rightIcon'];\n  prefix?: ReactNode;\n  suffix?: ReactNode;\n  description?: ReactNode;\n  descriptionPlacement?: CubeItemProps['descriptionPlacement'];\n  /** `true` = auto tooltip when the label is truncated. */\n  tooltip?: CubeItemProps['tooltip'];\n  actions?: ReactNode;\n  /** Hide `actions` until hover/focus. @default true */\n  autoHideActions?: boolean;\n  /**\n   * A column menu, opened from a `⋮` trigger in the header's actions slot and —\n   * unless the table says otherwise — by right-click or Shift+F10.\n   *\n   * `Menu.Item` children. Opaque: the table mounts the node and reports the\n   * pressed key back through `onColumnMenuAction`, so what a \"pin\" or a \"drill\n   * down\" means stays in the consuming app. The exception is the reserved sort\n   * keys (`sort-asc`, `sort-desc`, `clear-sort`), which the table labels,\n   * disables when redundant, and applies itself before telling the consumer.\n   *\n   * An empty menu renders no trigger at all, rather than one that opens nothing.\n   * Ignored when `header.render` takes the cell over.\n   */\n  menu?: ReactNode;\n  /** Props for the `⋮` trigger. Merged over the table's `columnMenuTriggerProps`. */\n  menuTriggerProps?: Record<string, any>;\n  /** Props for the `Menu`. Merged over the table's `columnMenuProps`. */\n  menuProps?: Record<string, any>;\n  /** Called before the table-level `onColumnMenuAction`. */\n  onMenuAction?: (action: string) => void;\n  theme?: CubeItemProps['theme'];\n  /**\n   * Full takeover of the header cell's content. Overrides `title` and every\n   * slot — including `actions` and `menu`, which are simply not rendered. A\n   * takeover that wants a menu owns the trigger too.\n   */\n  render?: (ctx: CubeTableHeaderContext) => ReactNode;\n  /** Overrides `column.align` for the header only. */\n  align?: CubeTableAlign;\n  styles?: Styles;\n}\n\n/* ── column colour ───────────────────────────────────────────────────────── */\n\n/**\n * A palette theme a column can borrow its tint from.\n *\n * Resolved through the same runtime generator as a custom colour, seeded from the\n * theme's own hue and saturation in `palette-config` — so it tracks a re-seeded\n * palette, and it gets the banding step the palette itself does not define.\n *\n * `special` is absent deliberately: it is a standalone `mode: 'fixed'` theme with\n * no tinted-surface ramp to borrow.\n */\nexport type CubeTableColumnTheme =\n  | 'primary'\n  | 'purple'\n  | 'success'\n  | 'danger'\n  | 'warning'\n  | 'note';\n\n/**\n * How a column is tinted.\n *\n * Every form but the last is *derived*: only a hue and a saturation are kept, and\n * the tone ramp plus an `AA`/`AAA` text floor are re-solved per colour scheme. So\n * a column stays readable in light, dark and high contrast without the caller\n * checking — which is the part hand-picked hex pairs get wrong.\n */\nexport type CubeTableColumnColor =\n  /** A palette theme name. */\n  | CubeTableColumnTheme\n  /** Any colour Glaze parses — hex, `rgb()`, `hsl()`, `okhsl()`, `oklch()`. */\n  | (string & {})\n  /** The seed said directly. `saturation` is 0–100. */\n  | { hue: number; saturation?: number }\n  /**\n   * Full manual control, as tasty colour strings (`'#note-surface'`, `'#purple.10'`).\n   *\n   * Nothing is derived and nothing is contrast-checked — this is the escape\n   * hatch, and readability in every scheme becomes the caller's problem.\n   * `fillBand` defaults to `fill`, which turns banding off for the column.\n   */\n  | { fill: string; fillBand?: string; text?: string };\n\n/**\n * Which parts of a column `color` reaches.\n *\n * @default ['header','body','totals']\n */\nexport type CubeTableColumnColorScope = 'header' | 'body' | 'totals';\n\nexport interface CubeTableColumn<T = any> {\n  /**\n   * Column id. Also the default data path — dot notation is supported\n   * (`'owner.name'`). Anything beyond a path needs `getValue`.\n   */\n  key: string;\n  /** Header label. Shorthand for `header` with no extra slots. */\n  title?: ReactNode;\n  header?: CubeTableColumnHeader;\n  /**\n   * Renders `<th scope=\"row\">` instead of `<td>`, names the row for screen\n   * readers, and hosts the `rowLink` anchor. Defaults to the first\n   * non-structural column when a row link is present.\n   */\n  isRowHeader?: boolean;\n\n  /* sizing */\n  /** Fixed width in px. Mutually exclusive with `flex`. */\n  width?: number;\n  /** Weight for the leftover space. @default 1 when `width` is unset */\n  flex?: number;\n  /** @default 150 */\n  minWidth?: number;\n  maxWidth?: number;\n  /** Inherits the table's `isResizable`. */\n  isResizable?: boolean;\n  /**\n   * Inherits the table's `isColumnReorderable`; `false` pins this column in\n   * place while the others still move around it.\n   */\n  isReorderable?: boolean;\n  /** Stick to the start/end edge during horizontal scroll. */\n  pin?: 'start' | 'end';\n  /** Hide without losing width or order state. */\n  isHidden?: boolean;\n\n  /* value pipeline */\n  /** @default (row) => get(row, key) */\n  getValue?: (row: T, rowIndex: number) => unknown;\n  /** Raw value → display text. Feeds client sort, client search and TSV copy. */\n  format?: (value: any, row: T, rowIndex: number) => string;\n  /** Client-side comparator over raw `getValue` results. */\n  compare?: (a: any, b: any, rowA: T, rowB: T) => number;\n\n  /* rendering */\n  /** A returned string is wrapped in a truncating `TextItem`. */\n  render?: (\n    value: any,\n    row: T,\n    rowIndex: number,\n    ctx: CubeTableCellContext<T>,\n  ) => ReactNode;\n  cellStyles?: Styles | ((ctx: CubeTableCellContext<T>) => Styles | undefined);\n  cellProps?: (ctx: CubeTableCellContext<T>) => Record<string, any> | undefined;\n\n  /**\n   * Tints the column — header, cells and pinned totals — with an adaptive fill\n   * and a text colour solved to stay readable on it in every scheme.\n   *\n   * Row banding survives: the tint carries its own band one tone step away, so\n   * the stripe still reads down the column instead of being painted over.\n   */\n  color?: CubeTableColumnColor;\n  /** Narrows what `color` reaches. @default ['header','body','totals'] */\n  colorScope?: readonly CubeTableColumnColorScope[];\n\n  /* behaviour */\n  align?: CubeTableAlign;\n  /**\n   * Opt IN, per column — a table is not sortable until at least one column says\n   * so, and `sortMode` then defaults to `'client'`.\n   *\n   * (This read `@default true` for a long time, which was never what the code\n   * did: `TableView` requires `isSortable === true` before a header becomes a\n   * control at all.)\n   *\n   * @default false\n   */\n  isSortable?: boolean;\n  /** Two-state cycling (asc ↔ desc), never back to unsorted. @default false */\n  disallowSortRemoval?: boolean;\n  /** Include in the built-in client search. @default true */\n  isSearchable?: boolean;\n  /** Include in TSV copy. @default true */\n  isCopyable?: boolean;\n  /** Wrap text and let the row grow to fit. */\n  autoHeight?: boolean;\n\n  /** Consumer-owned bag. Never reaches the DOM. */\n  meta?: Record<string, unknown>;\n}\n\n/* ── resolved layout (internal, but exported for adapters) ───────────────── */\n\nexport interface CubeResolvedColumn<T = any>\n  // `width`, `minWidth`, `maxWidth`, `flex` and `align` are all resolved here,\n  // so they narrow from optional to definite and must be replaced, not extended.\n  extends Omit<\n    CubeTableColumn<T>,\n    'width' | 'minWidth' | 'maxWidth' | 'flex' | 'align'\n  > {\n  /** Position among the visible leaf columns, 0-based. */\n  index: number;\n  /** `aria-colindex`, 1-based and document-absolute. */\n  ariaColIndex: number;\n  /** Resolved pixel width, or `null` while the container is unmeasured. */\n  width: number | null;\n  minWidth: number;\n  maxWidth: number | null;\n  flex: number | null;\n  align: CubeTableAlign;\n  /** Cumulative sticky offset in px for a pinned column. */\n  pinOffset: number | null;\n  /** `true` for the last pinned-start / first pinned-end column. */\n  isPinEdge: boolean;\n  /** Structural columns (selection, drag handle, row menu) never enter sorting,\n   *  search, copy, or the value pipeline. */\n  isStructural: boolean;\n}\n\nexport interface CubeTableColumnLayout<T = any> {\n  columns: CubeResolvedColumn<T>[];\n  pinnedStartWidth: number;\n  pinnedEndWidth: number;\n  /** Sum of resolved widths, or `null` while unmeasured. */\n  totalWidth: number | null;\n  /** `true` when the columns cannot fit and the table scrolls horizontally. */\n  isOverflowing: boolean;\n}\n\n/**\n * How a refresh over an existing result is presented.\n *\n * - `overlay` — keep the previous rows visible, dimmed, behind a spinner. A\n *   server page or a re-sort never blanks the table.\n * - `skeleton` — discard the previous rows and show placeholders.\n * - `none` — no visuals beyond `aria-busy`; the page owns the indicator.\n */\nexport type CubeTableLoadingIndicator = 'overlay' | 'skeleton' | 'none';\n\nexport type CubeTableSelectionMode = 'none' | 'single' | 'multiple';\n\n/**\n * What the header checkbox acts on.\n *\n * - `page` — the rows on the current page.\n * - `filtered` — every row passing the current search/filter, across pages.\n * - `all` — emits the `'all'` sentinel, meaning \"everything, including rows the\n *   client has not loaded\". The consumer decides what that means for its query.\n */\nexport type CubeTableSelectAllMode = 'page' | 'filtered' | 'all';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,gBACd,SACA,QACK;AACL,QAAO,YAAY,SAAS,SAAS,GAAG,QAAQ,GAAG"}

package/dist/components/data/TableBase/use-column-order.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.164.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.166.0 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { useMemo, useState } from "react";
 import { useControlledState } from "@react-stately/utils";

package/dist/components/data/TableBase/use-container-width.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.164.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.166.0 | Cube Dev Team */
 import { useLayoutEffect, useState } from "react";
 
 //#region src/components/data/TableBase/use-container-width.ts

package/dist/components/data/TableBase/use-row-move-animation.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.164.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.166.0 | Cube Dev Team */
 import { useLayoutEffect, useRef } from "react";
 
 //#region src/components/data/TableBase/use-row-move-animation.ts

package/dist/components/data/TableBase/use-scrollability.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.164.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.166.0 | Cube Dev Team */
 import { useLayoutEffect, useState } from "react";
 
 //#region src/components/data/TableBase/use-scrollability.ts

package/dist/components/data/TableBase/use-table-columns.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.164.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.166.0 | Cube Dev Team */
 import { useMemo } from "react";
 
 //#region src/components/data/TableBase/use-table-columns.ts

package/dist/components/data/TableBase/use-table-search.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.164.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.166.0 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { useDebouncedValue } from "../../../_internal/hooks/use-debounced-value.js";
 import { getColumnText } from "./use-table-columns.js";
@@ -17,7 +17,7 @@ import { useControlledState } from "@react-stately/utils";
 * value. `getColumnText` returns `null` for anything it cannot honestly turn
 * into text, and those columns are skipped rather than coerced.
 */
-function defaultMatcher(columns, row, rowIndex, query) {
+function matchesTableSearch(columns, row, rowIndex, query) {
 	return columns.some((column) => {
 		if (column.isSearchable === false) return false;
 		const text = getColumnText(column, row, rowIndex);
@@ -47,7 +47,7 @@ function useTableSearch({ columns, rows, mode = "client", value, defaultValue, o
 		query,
 		searchedRows: useMemo(() => {
 			if (mode !== "client" || !query) return rows;
-			return rows.filter((row, index) => filter ? filter(row, query) : defaultMatcher(columns, row, index, query));
+			return rows.filter((row, index) => filter ? filter(row, query) : matchesTableSearch(columns, row, index, query));
 		}, [
 			mode,
 			query,
@@ -60,5 +60,5 @@ function useTableSearch({ columns, rows, mode = "client", value, defaultValue, o
 }
 
 //#endregion
-export { useTableSearch };
+export { matchesTableSearch, useTableSearch };
 //# sourceMappingURL=use-table-search.js.map

package/dist/components/data/TableBase/use-table-search.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-table-search.js","names":[],"sources":["../../../../src/components/data/TableBase/use-table-search.ts"],"sourcesContent":["import { useControlledState } from '@react-stately/utils';\nimport { useEffect, useMemo, useRef, useState } from 'react';\n\nimport { useDebouncedValue, useEvent } from '../../../_internal/hooks';\n\nimport { getColumnText } from './use-table-columns';\n\nimport type { CubeTableColumn } from './types';\n\nexport type CubeTableSearchMode = 'client' | 'server';\n\nexport interface UseTableSearchOptions<T> {\n  columns: CubeTableColumn<T>[];\n  rows: readonly T[];\n  /** @default 'client' */\n  mode?: CubeTableSearchMode;\n  value?: string;\n  defaultValue?: string;\n  onChange?: (value: string) => void;\n  /** Debounces the filter AND the callback, in both modes. @default 500 */\n  delay?: number;\n  /** Replaces the default matcher in client mode. */\n  filter?: (row: T, query: string) => boolean;\n}\n\nexport interface UseTableSearchResult<T> {\n  /** The immediate term — what the input shows. */\n  searchValue: string;\n  setSearchValue: (value: string) => void;\n  /** The debounced term — what the filter and the callback act on. */\n  query: string;\n  /** Filtered in client mode; the original array otherwise. */\n  searchedRows: readonly T[];\n  /** `true` when a non-empty term is narrowing the data. */\n  isFiltered: boolean;\n}\n\n/**\n * Default matcher: a case-insensitive substring test against each searchable\n * column's **display text**.\n *\n * Deliberately not the raw value. Cloud's filter tested\n * `String(row[column.key])`, which meant a column rendering `owner.profile.name`\n * was unsearchable, and an object-valued column stringified to\n * `\"[object Object]\"` — so the query \"object\" matched every row with a nested\n * value. `getColumnText` returns `null` for anything it cannot honestly turn\n * into text, and those columns are skipped rather than coerced.\n */\nfunction defaultMatcher<T>(\n  columns: CubeTableColumn<T>[],\n  row: T,\n  rowIndex: number,\n  query: string,\n): boolean {\n  return columns.some((column) => {\n    if (column.isSearchable === false) return false;\n\n    const text = getColumnText(column, row, rowIndex);\n\n    return text != null && text.toLowerCase().includes(query);\n  });\n}\n\nexport function useTableSearch<T>({\n  columns,\n  rows,\n  mode = 'client',\n  value,\n  defaultValue,\n  onChange,\n  delay = 500,\n  filter,\n}: UseTableSearchOptions<T>): UseTableSearchResult<T> {\n  const [committed, setCommitted] = useControlledState<string>(\n    value as string,\n    defaultValue ?? '',\n    onChange as (v: string) => void,\n  );\n\n  // What the input shows, updated on every keystroke. The committed value —\n  // the one `onChange` reports and the filter runs on — trails it by `delay`.\n  //\n  // Two separate values rather than one, because `useControlledState` calls\n  // `onChange` the moment it is set: routing keystrokes straight into it fired\n  // a request per character in `searchMode=\"server\"`, which is the thing the\n  // debounce exists to prevent. Debouncing the input itself instead would make\n  // typing lag, so the split is the point.\n  const [draft, setDraft] = useState(committed);\n  const debounced = useDebouncedValue(draft, delay);\n\n  // What we last pushed outward, so the sync below can tell a genuine external\n  // change from the echo of our own debounce.\n  const pushedRef = useRef(committed);\n\n  // A controlled `searchValue` changing from OUTSIDE — a cleared filter, a\n  // restored URL — wins over whatever is half-typed.\n  //\n  // The echo has to be filtered out or this reverts the input mid-word: with a\n  // short delay the debounce commits letter 1 while letter 2 is already typed,\n  // and syncing unconditionally puts letter 1 back. At `searchDelay={0}` that\n  // happens on every keystroke and nothing longer than one character can ever\n  // be typed.\n  useEffect(() => {\n    if (committed === pushedRef.current) return;\n\n    pushedRef.current = committed;\n    setDraft(committed);\n  }, [committed]);\n\n  useEffect(() => {\n    if (debounced === pushedRef.current) return;\n\n    pushedRef.current = debounced;\n    setCommitted(debounced);\n    // `committed` is deliberately not a dependency: reacting to it here would\n    // fight the effect above and push a stale draft back out.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [debounced]);\n\n  const searchValue = draft;\n  const query = debounced.trim().toLowerCase();\n\n  const setSearchValue = useEvent((next: string) => setDraft(next));\n\n  const searchedRows = useMemo(() => {\n    if (mode !== 'client' || !query) return rows;\n\n    return rows.filter((row, index) =>\n      filter ? filter(row, query) : defaultMatcher(columns, row, index, query),\n    );\n  }, [mode, query, rows, columns, filter]);\n\n  return {\n    searchValue,\n    setSearchValue,\n    query,\n    searchedRows,\n    isFiltered: query.length > 0,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAgDA,SAAS,eACP,SACA,KACA,UACA,OACS;AACT,QAAO,QAAQ,MAAM,WAAW;AAC9B,MAAI,OAAO,iBAAiB,MAAO,QAAO;EAE1C,MAAM,OAAO,cAAc,QAAQ,KAAK,SAAS;AAEjD,SAAO,QAAQ,QAAQ,KAAK,aAAa,CAAC,SAAS,MAAM;GACzD;;AAGJ,SAAgB,eAAkB,EAChC,SACA,MACA,OAAO,UACP,OACA,cACA,UACA,QAAQ,KACR,UACoD;CACpD,MAAM,CAAC,WAAW,gBAAgB,mBAChC,OACA,gBAAgB,IAChB,SACD;CAUD,MAAM,CAAC,OAAO,YAAY,SAAS,UAAU;CAC7C,MAAM,YAAY,kBAAkB,OAAO,MAAM;CAIjD,MAAM,YAAY,OAAO,UAAU;AAUnC,iBAAgB;AACd,MAAI,cAAc,UAAU,QAAS;AAErC,YAAU,UAAU;AACpB,WAAS,UAAU;IAClB,CAAC,UAAU,CAAC;AAEf,iBAAgB;AACd,MAAI,cAAc,UAAU,QAAS;AAErC,YAAU,UAAU;AACpB,eAAa,UAAU;IAItB,CAAC,UAAU,CAAC;CAEf,MAAM,cAAc;CACpB,MAAM,QAAQ,UAAU,MAAM,CAAC,aAAa;AAY5C,QAAO;EACL;EACA,gBAZqB,UAAU,SAAiB,SAAS,KAAK,CAAC;EAa/D;EACA,cAZmB,cAAc;AACjC,OAAI,SAAS,YAAY,CAAC,MAAO,QAAO;AAExC,UAAO,KAAK,QAAQ,KAAK,UACvB,SAAS,OAAO,KAAK,MAAM,GAAG,eAAe,SAAS,KAAK,OAAO,MAAM,CACzE;KACA;GAAC;GAAM;GAAO;GAAM;GAAS;GAAO,CAAC;EAOtC,YAAY,MAAM,SAAS;EAC5B"}
+{"version":3,"file":"use-table-search.js","names":[],"sources":["../../../../src/components/data/TableBase/use-table-search.ts"],"sourcesContent":["import { useControlledState } from '@react-stately/utils';\nimport { useEffect, useMemo, useRef, useState } from 'react';\n\nimport { useDebouncedValue, useEvent } from '../../../_internal/hooks';\n\nimport { getColumnText } from './use-table-columns';\n\nimport type { CubeTableColumn } from './types';\n\nexport type CubeTableSearchMode = 'client' | 'server';\n\nexport interface UseTableSearchOptions<T> {\n  columns: CubeTableColumn<T>[];\n  rows: readonly T[];\n  /** @default 'client' */\n  mode?: CubeTableSearchMode;\n  value?: string;\n  defaultValue?: string;\n  onChange?: (value: string) => void;\n  /** Debounces the filter AND the callback, in both modes. @default 500 */\n  delay?: number;\n  /** Replaces the default matcher in client mode. */\n  filter?: (row: T, query: string) => boolean;\n}\n\nexport interface UseTableSearchResult<T> {\n  /** The immediate term — what the input shows. */\n  searchValue: string;\n  setSearchValue: (value: string) => void;\n  /** The debounced term — what the filter and the callback act on. */\n  query: string;\n  /** Filtered in client mode; the original array otherwise. */\n  searchedRows: readonly T[];\n  /** `true` when a non-empty term is narrowing the data. */\n  isFiltered: boolean;\n}\n\n/**\n * Default matcher: a case-insensitive substring test against each searchable\n * column's **display text**.\n *\n * Deliberately not the raw value. Cloud's filter tested\n * `String(row[column.key])`, which meant a column rendering `owner.profile.name`\n * was unsearchable, and an object-valued column stringified to\n * `\"[object Object]\"` — so the query \"object\" matched every row with a nested\n * value. `getColumnText` returns `null` for anything it cannot honestly turn\n * into text, and those columns are skipped rather than coerced.\n */\nexport function matchesTableSearch<T>(\n  columns: CubeTableColumn<T>[],\n  row: T,\n  rowIndex: number,\n  query: string,\n): boolean {\n  return columns.some((column) => {\n    if (column.isSearchable === false) return false;\n\n    const text = getColumnText(column, row, rowIndex);\n\n    return text != null && text.toLowerCase().includes(query);\n  });\n}\n\nexport function useTableSearch<T>({\n  columns,\n  rows,\n  mode = 'client',\n  value,\n  defaultValue,\n  onChange,\n  delay = 500,\n  filter,\n}: UseTableSearchOptions<T>): UseTableSearchResult<T> {\n  const [committed, setCommitted] = useControlledState<string>(\n    value as string,\n    defaultValue ?? '',\n    onChange as (v: string) => void,\n  );\n\n  // What the input shows, updated on every keystroke. The committed value —\n  // the one `onChange` reports and the filter runs on — trails it by `delay`.\n  //\n  // Two separate values rather than one, because `useControlledState` calls\n  // `onChange` the moment it is set: routing keystrokes straight into it fired\n  // a request per character in `searchMode=\"server\"`, which is the thing the\n  // debounce exists to prevent. Debouncing the input itself instead would make\n  // typing lag, so the split is the point.\n  const [draft, setDraft] = useState(committed);\n  const debounced = useDebouncedValue(draft, delay);\n\n  // What we last pushed outward, so the sync below can tell a genuine external\n  // change from the echo of our own debounce.\n  const pushedRef = useRef(committed);\n\n  // A controlled `searchValue` changing from OUTSIDE — a cleared filter, a\n  // restored URL — wins over whatever is half-typed.\n  //\n  // The echo has to be filtered out or this reverts the input mid-word: with a\n  // short delay the debounce commits letter 1 while letter 2 is already typed,\n  // and syncing unconditionally puts letter 1 back. At `searchDelay={0}` that\n  // happens on every keystroke and nothing longer than one character can ever\n  // be typed.\n  useEffect(() => {\n    if (committed === pushedRef.current) return;\n\n    pushedRef.current = committed;\n    setDraft(committed);\n  }, [committed]);\n\n  useEffect(() => {\n    if (debounced === pushedRef.current) return;\n\n    pushedRef.current = debounced;\n    setCommitted(debounced);\n    // `committed` is deliberately not a dependency: reacting to it here would\n    // fight the effect above and push a stale draft back out.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [debounced]);\n\n  const searchValue = draft;\n  const query = debounced.trim().toLowerCase();\n\n  const setSearchValue = useEvent((next: string) => setDraft(next));\n\n  const searchedRows = useMemo(() => {\n    if (mode !== 'client' || !query) return rows;\n\n    return rows.filter((row, index) =>\n      filter\n        ? filter(row, query)\n        : matchesTableSearch(columns, row, index, query),\n    );\n  }, [mode, query, rows, columns, filter]);\n\n  return {\n    searchValue,\n    setSearchValue,\n    query,\n    searchedRows,\n    isFiltered: query.length > 0,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAgDA,SAAgB,mBACd,SACA,KACA,UACA,OACS;AACT,QAAO,QAAQ,MAAM,WAAW;AAC9B,MAAI,OAAO,iBAAiB,MAAO,QAAO;EAE1C,MAAM,OAAO,cAAc,QAAQ,KAAK,SAAS;AAEjD,SAAO,QAAQ,QAAQ,KAAK,aAAa,CAAC,SAAS,MAAM;GACzD;;AAGJ,SAAgB,eAAkB,EAChC,SACA,MACA,OAAO,UACP,OACA,cACA,UACA,QAAQ,KACR,UACoD;CACpD,MAAM,CAAC,WAAW,gBAAgB,mBAChC,OACA,gBAAgB,IAChB,SACD;CAUD,MAAM,CAAC,OAAO,YAAY,SAAS,UAAU;CAC7C,MAAM,YAAY,kBAAkB,OAAO,MAAM;CAIjD,MAAM,YAAY,OAAO,UAAU;AAUnC,iBAAgB;AACd,MAAI,cAAc,UAAU,QAAS;AAErC,YAAU,UAAU;AACpB,WAAS,UAAU;IAClB,CAAC,UAAU,CAAC;AAEf,iBAAgB;AACd,MAAI,cAAc,UAAU,QAAS;AAErC,YAAU,UAAU;AACpB,eAAa,UAAU;IAItB,CAAC,UAAU,CAAC;CAEf,MAAM,cAAc;CACpB,MAAM,QAAQ,UAAU,MAAM,CAAC,aAAa;AAc5C,QAAO;EACL;EACA,gBAdqB,UAAU,SAAiB,SAAS,KAAK,CAAC;EAe/D;EACA,cAdmB,cAAc;AACjC,OAAI,SAAS,YAAY,CAAC,MAAO,QAAO;AAExC,UAAO,KAAK,QAAQ,KAAK,UACvB,SACI,OAAO,KAAK,MAAM,GAClB,mBAAmB,SAAS,KAAK,OAAO,MAAM,CACnD;KACA;GAAC;GAAM;GAAO;GAAM;GAAS;GAAO,CAAC;EAOtC,YAAY,MAAM,SAAS;EAC5B"}

package/dist/components/data/TableBase/use-table-selection.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.164.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.166.0 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { RowCollection } from "./RowCollection.js";
 import { useCallback, useMemo, useRef } from "react";
@@ -26,8 +26,58 @@ function toSelection(keys) {
 	if (keys === void 0) return void 0;
 	return keys === "all" ? "all" : new Set(keys);
 }
+function deriveTreeSelection(source, rootKeys, childrenOf, isEligible) {
+	const checked = new Set(source);
+	const indeterminate = /* @__PURE__ */ new Set();
+	const visit = (key) => {
+		const children = childrenOf.get(key) ?? [];
+		const eligible = isEligible(key);
+		if (eligible && source.has(key)) checked.add(key);
+		if (!children.length) {
+			const selected = eligible && checked.has(key);
+			if (!eligible) checked.delete(key);
+			return {
+				all: !eligible || selected,
+				any: selected,
+				eligible
+			};
+		}
+		let all = true;
+		let any = false;
+		let hasEligible = false;
+		for (const child of children) {
+			const result = visit(child);
+			if (result.eligible) hasEligible = true;
+			if (!result.all) all = false;
+			if (result.any) any = true;
+		}
+		if (!eligible) {
+			checked.delete(key);
+			indeterminate.delete(key);
+		} else if (hasEligible && all) {
+			checked.add(key);
+			indeterminate.delete(key);
+		} else if (hasEligible && any) {
+			checked.delete(key);
+			indeterminate.add(key);
+		} else if (hasEligible) {
+			checked.delete(key);
+			indeterminate.delete(key);
+		} else if (!checked.has(key)) indeterminate.delete(key);
+		return {
+			all: !eligible || checked.has(key) && all,
+			any: any || checked.has(key),
+			eligible: eligible || hasEligible
+		};
+	};
+	rootKeys.forEach((key) => visit(key));
+	return {
+		checked,
+		indeterminate
+	};
+}
 function useTableSelection(options) {
-	const { rows, filteredRows, getRowKey, selectionMode, selectedKeys: selectedKeysProp, defaultSelectedKeys, onSelectionChange, selectAllMode, isRowSelectable, disabledKeys } = options;
+	const { rows, rowKeys, pageRows = rows, pageRowKeys, filteredRows, filteredRowKeys, getRowKey, selectionMode, selectedKeys: selectedKeysProp, defaultSelectedKeys, onSelectionChange, selectAllMode, isRowSelectable, disabledKeys, tree } = options;
 	const isEnabled = selectionMode !== "none";
 	/**
 	* Two distinct notions of "not available", deliberately kept apart:
@@ -45,28 +95,32 @@ function useTableSelection(options) {
 	const unselectableKeys = useMemo(() => {
 		const keys = new Set(hardDisabledKeys);
 		if (isRowSelectable) filteredRows.forEach((row, index) => {
-			if (!isRowSelectable(row)) keys.add(getRowKey(row, index));
+			if (!isRowSelectable(row)) keys.add(filteredRowKeys?.[index] ?? getRowKey(row, index));
 		});
 		return keys;
 	}, [
 		hardDisabledKeys,
 		isRowSelectable,
 		filteredRows,
+		filteredRowKeys,
 		getRowKey
 	]);
-	const collection = useMemo(() => new RowCollection(rows, getRowKey, unselectableKeys), [
+	const visibleGetRowKey = useCallback((row, index) => rowKeys?.[index] ?? getRowKey(row, index), [rowKeys, getRowKey]);
+	const collection = useMemo(() => new RowCollection(rows, visibleGetRowKey, unselectableKeys), [
 		rows,
-		getRowKey,
+		visibleGetRowKey,
 		unselectableKeys
 	]);
 	const rowByKey = useMemo(() => {
 		const map = /* @__PURE__ */ new Map();
-		filteredRows.forEach((row, index) => map.set(getRowKey(row, index), row));
-		rows.forEach((row, index) => map.set(getRowKey(row, index), row));
+		filteredRows.forEach((row, index) => map.set(filteredRowKeys?.[index] ?? getRowKey(row, index), row));
+		rows.forEach((row, index) => map.set(rowKeys?.[index] ?? getRowKey(row, index), row));
 		return map;
 	}, [
 		rows,
+		rowKeys,
 		filteredRows,
+		filteredRowKeys,
 		getRowKey
 	]);
 	const rowByKeyRef = useRef(rowByKey);
@@ -109,35 +163,59 @@ function useTableSelection(options) {
 	const selectionManager = useMemo(() => new SelectionManager(collection, state), [collection, state]);
 	const selectedKeys = state.selectedKeys;
 	const isAll = selectedKeys === "all";
-	const canSelect = useCallback((key) => isEnabled && !unselectableKeys.has(key), [isEnabled, unselectableKeys]);
-	const isSelected = useCallback((key) => isAll ? canSelect(key) : selectedKeys.has(key), [
+	const isCascade = tree?.behavior === "cascade" && selectionMode === "multiple";
+	const derivedSelection = useMemo(() => {
+		if (isAll) return {
+			checked: new Set([...rowByKey.keys()].filter((key) => !unselectableKeys.has(key))),
+			indeterminate: /* @__PURE__ */ new Set()
+		};
+		if (!isCascade || !tree) return {
+			checked: new Set(selectedKeys),
+			indeterminate: /* @__PURE__ */ new Set()
+		};
+		return deriveTreeSelection(selectedKeys, tree.rootKeys, tree.childrenOf, (key) => !unselectableKeys.has(key));
+	}, [
 		isAll,
+		isCascade,
 		selectedKeys,
+		tree,
+		rowByKey,
+		unselectableKeys
+	]);
+	const canSelect = useCallback((key) => isEnabled && !unselectableKeys.has(key), [isEnabled, unselectableKeys]);
+	const isSelected = useCallback((key) => isAll ? canSelect(key) : derivedSelection.checked.has(key), [
+		isAll,
+		derivedSelection,
 		canSelect
 	]);
+	const isIndeterminate = useCallback((key) => derivedSelection.indeterminate.has(key), [derivedSelection]);
 	/** Keys the header checkbox acts on, which is what `selectAllMode` decides. */
 	const scopeKeys = useMemo(() => {
 		if (!isEnabled || selectionMode === "single") return [];
-		return (selectAllMode === "page" ? rows : filteredRows).map((row, index) => getRowKey(row, index)).filter((key) => !unselectableKeys.has(key));
+		const source = selectAllMode === "page" ? pageRows : filteredRows;
+		const sourceKeys = selectAllMode === "page" ? pageRowKeys : filteredRowKeys;
+		return source.map((row, index) => sourceKeys?.[index] ?? getRowKey(row, index)).filter((key) => !unselectableKeys.has(key));
 	}, [
 		isEnabled,
 		selectionMode,
 		selectAllMode,
-		rows,
+		pageRows,
+		pageRowKeys,
 		filteredRows,
+		filteredRowKeys,
 		getRowKey,
 		unselectableKeys
 	]);
 	const selectAllState = useMemo(() => {
 		if (isAll) return "all";
 		if (!scopeKeys.length) return "none";
-		const set = selectedKeys;
+		const set = derivedSelection.checked;
 		let count = 0;
 		for (const key of scopeKeys) if (set.has(key)) count++;
 		return count === 0 ? "none" : count === scopeKeys.length ? "all" : "some";
 	}, [
 		isAll,
-		selectedKeys,
+		derivedSelection,
 		scopeKeys
 	]);
 	const toggleSelectAll = useEvent(() => {
@@ -151,9 +229,9 @@ function useTableSelection(options) {
 			state.setSelectedKeys("all");
 			return;
 		}
-		const next = new Set(isAll ? [] : selectedKeys);
+		const next = new Set(isAll ? [] : derivedSelection.checked);
 		scopeKeys.forEach((key) => next.add(key));
-		state.setSelectedKeys(next);
+		state.setSelectedKeys(isCascade && tree ? deriveTreeSelection(next, tree.rootKeys, tree.childrenOf, (key) => !unselectableKeys.has(key)).checked : next);
 	});
 	const clearSelection = useEvent(() => {
 		anchorRef.current = null;
@@ -186,27 +264,48 @@ function useTableSelection(options) {
 			state.setSelectedKeys(isSelected(key) ? /* @__PURE__ */ new Set() : new Set([key]));
 			return;
 		}
+		const applyCascade = (set, target, value) => {
+			if (!canSelect(target)) return;
+			if (value) set.add(target);
+			else {
+				set.delete(target);
+				if (isCascade && tree) {
+					let parent = tree.parentOf.get(target);
+					while (parent != null) {
+						set.delete(parent);
+						parent = tree.parentOf.get(parent);
+					}
+				}
+			}
+			if (!isCascade || !tree) return;
+			(tree.childrenOf.get(target) ?? []).forEach((child) => applyCascade(set, child, value));
+		};
+		const normalizeCascade = (set) => isCascade && tree ? deriveTreeSelection(set, tree.rootKeys, tree.childrenOf, (candidate) => !unselectableKeys.has(candidate)).checked : set;
 		const anchor = anchorRef.current;
 		if (shiftRef.current && anchor != null && collection.indexOf(anchor) >= 0) {
-			const next = new Set(isAll ? scopeKeys : selectedKeys);
-			if (extentRef.current != null) keysBetween(anchor, extentRef.current).forEach((k) => next.delete(k));
+			const next = new Set(isAll ? scopeKeys : derivedSelection.checked);
+			if (extentRef.current != null) keysBetween(anchor, extentRef.current).forEach((k) => applyCascade(next, k, false));
 			keysBetween(anchor, key).forEach((k) => {
-				if (canSelect(k)) next.add(k);
+				applyCascade(next, k, true);
 			});
 			extentRef.current = key;
-			state.setSelectedKeys(next);
+			state.setSelectedKeys(normalizeCascade(next));
 			return;
 		}
 		anchorRef.current = key;
 		extentRef.current = null;
-		selectionManager.toggleSelection(key);
+		if (isCascade) {
+			const next = new Set(derivedSelection.checked);
+			applyCascade(next, key, !derivedSelection.checked.has(key));
+			state.setSelectedKeys(normalizeCascade(next));
+		} else selectionManager.toggleSelection(key);
 	});
 	const selectedRows = useMemo(() => {
 		if (isAll) return [...rowByKey.values()];
-		return [...selectedKeys].map((key) => rowByKey.get(key)).filter((row) => row !== void 0);
+		return [...derivedSelection.checked].map((key) => rowByKey.get(key)).filter((row) => row !== void 0);
 	}, [
 		isAll,
-		selectedKeys,
+		derivedSelection,
 		rowByKey
 	]);
 	return {
@@ -215,6 +314,7 @@ function useTableSelection(options) {
 		selectionManager,
 		collection,
 		isSelected,
+		isIndeterminate,
 		canSelect,
 		isRowDisabled: useCallback((key) => hardDisabledKeys.has(key), [hardDisabledKeys]),
 		toggleRow,
@@ -223,8 +323,8 @@ function useTableSelection(options) {
 		toggleSelectAll,
 		clearSelection,
 		selectedRows,
-		selectedCount: isAll ? rowByKey.size : selectedKeys.size,
-		selectedKeys: isAll ? "all" : [...selectedKeys]
+		selectedCount: isAll ? rowByKey.size : derivedSelection.checked.size,
+		selectedKeys: isAll ? "all" : [...derivedSelection.checked]
 	};
 }
 

package/dist/components/data/TableBase/use-table-selection.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-table-selection.js","names":[],"sources":["../../../../src/components/data/TableBase/use-table-selection.ts"],"sourcesContent":["import { SelectionManager } from '@react-stately/selection';\nimport { useCallback, useMemo, useRef } from 'react';\nimport { useMultipleSelectionState } from 'react-stately';\n\nimport { useEvent } from '../../../_internal/hooks';\n\nimport { RowCollection } from './RowCollection';\n\nimport type { Key, Selection } from '@react-types/shared';\nimport type { CubeTableSelectAllMode, CubeTableSelectionMode } from './types';\n\n/**\n * Reserved key for the checkbox column. Prefixed so it cannot collide with a\n * real data key, and structural so the value pipeline, sorting and search all\n * skip it.\n */\nexport const SELECTION_COLUMN_KEY = '__cube-selection__';\n\n/** Reserved key for the row-number column. Structural, like the checkbox. */\nexport const ROW_NUMBER_COLUMN_KEY = '__cube-row-number__';\n\n/** Square-ish, so the checkbox sits centred without stealing content width. */\nexport const SELECTION_COLUMN_WIDTH: Record<string, number> = {\n  xsmall: 32,\n  small: 36,\n  medium: 44,\n  large: 48,\n  xlarge: 52,\n};\n\nexport interface UseTableSelectionOptions<T> {\n  /** Rows currently on screen — one page, or everything when unpaginated. */\n  rows: readonly T[];\n  /**\n   * Every row passing the current search/filter, across pages. Only differs\n   * from `rows` under client pagination, and only `selectAllMode=\"filtered\"`\n   * reads it.\n   */\n  filteredRows: readonly T[];\n  getRowKey: (row: T, index: number) => Key;\n  selectionMode: CubeTableSelectionMode;\n  selectedKeys?: Key[] | 'all';\n  defaultSelectedKeys?: Key[] | 'all';\n  onSelectionChange?: (keys: Key[] | 'all', rows: T[]) => void;\n  selectAllMode: CubeTableSelectAllMode;\n  isRowSelectable?: (row: T) => boolean;\n  disabledKeys?: Key[];\n}\n\nexport type CubeTableSelectAllState = 'none' | 'some' | 'all';\n\nfunction toSelection(keys: Key[] | 'all' | undefined): Selection | undefined {\n  if (keys === undefined) return undefined;\n\n  return keys === 'all' ? 'all' : new Set(keys);\n}\n\nexport function useTableSelection<T>(options: UseTableSelectionOptions<T>) {\n  const {\n    rows,\n    filteredRows,\n    getRowKey,\n    selectionMode,\n    selectedKeys: selectedKeysProp,\n    defaultSelectedKeys,\n    onSelectionChange,\n    selectAllMode,\n    isRowSelectable,\n    disabledKeys,\n  } = options;\n\n  const isEnabled = selectionMode !== 'none';\n\n  /**\n   * Two distinct notions of \"not available\", deliberately kept apart:\n   *\n   * - `disabledKeys` — the row is inert. Not focusable, not interactive. This\n   *   is React Aria's standard meaning.\n   * - `isRowSelectable` — the row is fully interactive, only its checkbox is\n   *   inert. This is what Cloud's tables do today.\n   *\n   * A `SelectionManager` has one `disabledBehavior`, so it gets the union under\n   * `'selection'` (neither kind can be selected) and the hard-disabled set is\n   * tracked separately for focus and interaction.\n   */\n  const hardDisabledKeys = useMemo(\n    () => new Set(disabledKeys ?? []),\n    [disabledKeys],\n  );\n\n  const unselectableKeys = useMemo(() => {\n    const keys = new Set(hardDisabledKeys);\n\n    if (isRowSelectable) {\n      // Scanned over the filtered set, not just the page: a select-all that\n      // reaches beyond the page must respect it there too.\n      filteredRows.forEach((row, index) => {\n        if (!isRowSelectable(row)) keys.add(getRowKey(row, index));\n      });\n    }\n\n    return keys;\n  }, [hardDisabledKeys, isRowSelectable, filteredRows, getRowKey]);\n\n  const collection = useMemo(\n    () => new RowCollection(rows, getRowKey, unselectableKeys),\n    [rows, getRowKey, unselectableKeys],\n  );\n\n  const rowByKey = useMemo(() => {\n    const map = new Map<Key, T>();\n\n    // The page first, then the wider filtered set, so a key present in both\n    // resolves to the row the user can actually see.\n    filteredRows.forEach((row, index) => map.set(getRowKey(row, index), row));\n    rows.forEach((row, index) => map.set(getRowKey(row, index), row));\n\n    return map;\n  }, [rows, filteredRows, getRowKey]);\n\n  const rowByKeyRef = useRef(rowByKey);\n\n  rowByKeyRef.current = rowByKey;\n\n  /**\n   * Where a shift-range starts, and how far it currently reaches.\n   *\n   * React Aria's `SelectionManager.extendSelection` keeps this on the `Selection`\n   * object itself (`selectedKeys.anchorKey`), which cannot survive our public\n   * API: `selectedKeys` is `Key[]`, and `useMultipleSelectionState` rebuilds\n   * whatever it is given with `new Selection(value)` — a constructor that only\n   * copies the anchor when the input is already a `Selection`, a class no\n   * package exports. A controlled table would silently reset the anchor to the\n   * clicked row and turn every shift-click into a plain toggle.\n   *\n   * So the range is computed here instead, over `RowCollection`'s index. The\n   * semantics match `extendSelection` exactly: the previous range is removed\n   * before the new one is added, so shift-clicking back shrinks the range\n   * rather than leaving the overshoot selected.\n   */\n  const anchorRef = useRef<Key | null>(null);\n  const extentRef = useRef<Key | null>(null);\n\n  const handleSelectionChange = useEvent((keys: Selection) => {\n    if (!onSelectionChange) return;\n\n    if (keys === 'all') {\n      // The sentinel means \"everything, including rows the client has not\n      // loaded\", so the row list can only ever be what is loaded.\n      onSelectionChange('all', [...rowByKeyRef.current.values()]);\n\n      return;\n    }\n\n    const list = [...keys];\n\n    onSelectionChange(\n      list,\n      list\n        .map((key) => rowByKeyRef.current.get(key))\n        .filter((row): row is T => row !== undefined),\n    );\n  });\n\n  const controlledSelection = useMemo(\n    () => toSelection(selectedKeysProp),\n    [selectedKeysProp],\n  );\n  const defaultSelection = useMemo(\n    () => toSelection(defaultSelectedKeys),\n    [defaultSelectedKeys],\n  );\n\n  const state = useMultipleSelectionState({\n    selectionMode,\n    selectedKeys: controlledSelection,\n    defaultSelectedKeys: defaultSelection,\n    disabledKeys: unselectableKeys,\n    disabledBehavior: 'selection',\n    onSelectionChange: handleSelectionChange,\n  });\n\n  const selectionManager = useMemo(\n    () => new SelectionManager(collection, state),\n    [collection, state],\n  );\n\n  const selectedKeys = state.selectedKeys;\n  const isAll = selectedKeys === 'all';\n\n  const canSelect = useCallback(\n    (key: Key) => isEnabled && !unselectableKeys.has(key),\n    [isEnabled, unselectableKeys],\n  );\n\n  const isSelected = useCallback(\n    (key: Key) =>\n      isAll ? canSelect(key) : (selectedKeys as Set<Key>).has(key),\n    [isAll, selectedKeys, canSelect],\n  );\n\n  /** Keys the header checkbox acts on, which is what `selectAllMode` decides. */\n  const scopeKeys = useMemo(() => {\n    if (!isEnabled || selectionMode === 'single') return [];\n\n    const source = selectAllMode === 'page' ? rows : filteredRows;\n\n    return source\n      .map((row, index) => getRowKey(row, index))\n      .filter((key) => !unselectableKeys.has(key));\n  }, [\n    isEnabled,\n    selectionMode,\n    selectAllMode,\n    rows,\n    filteredRows,\n    getRowKey,\n    unselectableKeys,\n  ]);\n\n  const selectAllState: CubeTableSelectAllState = useMemo(() => {\n    if (isAll) return 'all';\n    if (!scopeKeys.length) return 'none';\n\n    const set = selectedKeys as Set<Key>;\n    let count = 0;\n\n    for (const key of scopeKeys) if (set.has(key)) count++;\n\n    return count === 0 ? 'none' : count === scopeKeys.length ? 'all' : 'some';\n  }, [isAll, selectedKeys, scopeKeys]);\n\n  const toggleSelectAll = useEvent(() => {\n    anchorRef.current = null;\n    extentRef.current = null;\n\n    if (selectAllState === 'all') {\n      // Clearing drops the whole selection, not just the scope: leaving keys\n      // selected on other pages after the user clicked an unchecked-looking\n      // box is the kind of thing nobody discovers until they delete something.\n      state.setSelectedKeys(new Set());\n\n      return;\n    }\n\n    if (selectAllMode === 'all') {\n      state.setSelectedKeys('all');\n\n      return;\n    }\n\n    const next = new Set(isAll ? [] : (selectedKeys as Set<Key>));\n\n    scopeKeys.forEach((key) => next.add(key));\n    state.setSelectedKeys(next);\n  });\n\n  const clearSelection = useEvent(() => {\n    anchorRef.current = null;\n    extentRef.current = null;\n    state.setSelectedKeys(new Set());\n  });\n\n  /**\n   * Shift held on the press that produced this change. `Checkbox` reports only\n   * the next value, so the modifier is captured from the pointer/key event on\n   * the cell and read back here.\n   */\n  const shiftRef = useRef(false);\n\n  const captureShift = useCallback((event: { shiftKey: boolean }) => {\n    shiftRef.current = event.shiftKey;\n  }, []);\n\n  /** Selectable keys between two rows, inclusive, in either direction. */\n  const keysBetween = useCallback(\n    (from: Key, to: Key) => {\n      const fromIndex = collection.indexOf(from);\n      const toIndex = collection.indexOf(to);\n\n      if (fromIndex < 0 || toIndex < 0) return [];\n\n      const [lo, hi] =\n        fromIndex <= toIndex ? [fromIndex, toIndex] : [toIndex, fromIndex];\n      const all = collection.getKeys();\n      const range: Key[] = [];\n\n      for (let i = lo; i <= hi; i++) range.push(all[i]);\n\n      return range;\n    },\n    [collection],\n  );\n\n  const toggleRow = useEvent((key: Key) => {\n    if (!canSelect(key)) return;\n\n    if (selectionMode === 'single') {\n      state.setSelectedKeys(isSelected(key) ? new Set() : new Set([key]));\n\n      return;\n    }\n\n    const anchor = anchorRef.current;\n\n    if (shiftRef.current && anchor != null && collection.indexOf(anchor) >= 0) {\n      const next = new Set(isAll ? scopeKeys : (selectedKeys as Set<Key>));\n\n      // Drop the range this shift-click supersedes before drawing the new one,\n      // so clicking back toward the anchor shrinks the selection.\n      if (extentRef.current != null) {\n        keysBetween(anchor, extentRef.current).forEach((k) => next.delete(k));\n      }\n\n      keysBetween(anchor, key).forEach((k) => {\n        if (canSelect(k)) next.add(k);\n      });\n\n      extentRef.current = key;\n      state.setSelectedKeys(next);\n\n      return;\n    }\n\n    anchorRef.current = key;\n    extentRef.current = null;\n    selectionManager.toggleSelection(key);\n  });\n\n  const selectedRows = useMemo(() => {\n    if (isAll) return [...rowByKey.values()];\n\n    return [...(selectedKeys as Set<Key>)]\n      .map((key) => rowByKey.get(key))\n      .filter((row): row is T => row !== undefined);\n  }, [isAll, selectedKeys, rowByKey]);\n\n  return {\n    isEnabled,\n    selectionMode,\n    selectionManager,\n    collection,\n    isSelected,\n    canSelect,\n    isRowDisabled: useCallback(\n      (key: Key) => hardDisabledKeys.has(key),\n      [hardDisabledKeys],\n    ),\n    toggleRow,\n    captureShift,\n    selectAllState,\n    toggleSelectAll,\n    clearSelection,\n    selectedRows,\n    selectedCount: isAll ? rowByKey.size : (selectedKeys as Set<Key>).size,\n    selectedKeys: (isAll ? 'all' : [...(selectedKeys as Set<Key>)]) as\n      | Key[]\n      | 'all',\n  };\n}\n\nexport type CubeTableSelectionState<T> = ReturnType<\n  typeof useTableSelection<T>\n>;\n"],"mappings":"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"}
+{"version":3,"file":"use-table-selection.js","names":[],"sources":["../../../../src/components/data/TableBase/use-table-selection.ts"],"sourcesContent":["import { SelectionManager } from '@react-stately/selection';\nimport { useCallback, useMemo, useRef } from 'react';\nimport { useMultipleSelectionState } from 'react-stately';\n\nimport { useEvent } from '../../../_internal/hooks';\n\nimport { RowCollection } from './RowCollection';\n\nimport type { Key, Selection } from '@react-types/shared';\nimport type { CubeTableSelectAllMode, CubeTableSelectionMode } from './types';\n\n/**\n * Reserved key for the checkbox column. Prefixed so it cannot collide with a\n * real data key, and structural so the value pipeline, sorting and search all\n * skip it.\n */\nexport const SELECTION_COLUMN_KEY = '__cube-selection__';\n\n/** Reserved key for the row-number column. Structural, like the checkbox. */\nexport const ROW_NUMBER_COLUMN_KEY = '__cube-row-number__';\n\n/** Square-ish, so the checkbox sits centred without stealing content width. */\nexport const SELECTION_COLUMN_WIDTH: Record<string, number> = {\n  xsmall: 32,\n  small: 36,\n  medium: 44,\n  large: 48,\n  xlarge: 52,\n};\n\nexport interface UseTableSelectionOptions<T> {\n  /** Rows currently on screen — one page, or everything when unpaginated. */\n  rows: readonly T[];\n  /** Stable keys parallel to `rows`, used by tree mode. */\n  rowKeys?: readonly Key[];\n  /** Full current-page subtree; defaults to `rows`. */\n  pageRows?: readonly T[];\n  /** Stable keys parallel to `pageRows`. */\n  pageRowKeys?: readonly Key[];\n  /**\n   * Every row passing the current search/filter, across pages. Only differs\n   * from `rows` under client pagination, and only `selectAllMode=\"filtered\"`\n   * reads it.\n   */\n  filteredRows: readonly T[];\n  /** Stable keys parallel to `filteredRows`. */\n  filteredRowKeys?: readonly Key[];\n  getRowKey: (row: T, index: number) => Key;\n  selectionMode: CubeTableSelectionMode;\n  selectedKeys?: Key[] | 'all';\n  defaultSelectedKeys?: Key[] | 'all';\n  onSelectionChange?: (keys: Key[] | 'all', rows: T[]) => void;\n  selectAllMode: CubeTableSelectAllMode;\n  isRowSelectable?: (row: T) => boolean;\n  disabledKeys?: Key[];\n  tree?: {\n    rootKeys: readonly Key[];\n    childrenOf: ReadonlyMap<Key, readonly Key[]>;\n    parentOf: ReadonlyMap<Key, Key | null>;\n    behavior: 'cascade' | 'independent';\n  };\n}\n\nexport type CubeTableSelectAllState = 'none' | 'some' | 'all';\n\nfunction toSelection(keys: Key[] | 'all' | undefined): Selection | undefined {\n  if (keys === undefined) return undefined;\n\n  return keys === 'all' ? 'all' : new Set(keys);\n}\n\nfunction deriveTreeSelection(\n  source: ReadonlySet<Key>,\n  rootKeys: readonly Key[],\n  childrenOf: ReadonlyMap<Key, readonly Key[]>,\n  isEligible: (key: Key) => boolean,\n) {\n  const checked = new Set(source);\n  const indeterminate = new Set<Key>();\n\n  const visit = (\n    key: Key,\n  ): { all: boolean; any: boolean; eligible: boolean } => {\n    const children = childrenOf.get(key) ?? [];\n    const eligible = isEligible(key);\n    const explicitlySelected = eligible && source.has(key);\n\n    if (explicitlySelected) checked.add(key);\n\n    if (!children.length) {\n      const selected = eligible && checked.has(key);\n      if (!eligible) checked.delete(key);\n      return { all: !eligible || selected, any: selected, eligible };\n    }\n\n    let all = true;\n    let any = false;\n    let hasEligible = false;\n\n    for (const child of children) {\n      const result = visit(child);\n      if (result.eligible) hasEligible = true;\n      if (!result.all) all = false;\n      if (result.any) any = true;\n    }\n\n    if (!eligible) {\n      checked.delete(key);\n      indeterminate.delete(key);\n    } else if (hasEligible && all) {\n      checked.add(key);\n      indeterminate.delete(key);\n    } else if (hasEligible && any) {\n      checked.delete(key);\n      indeterminate.add(key);\n    } else if (hasEligible) {\n      // Branch keys in the public set are a normalized reflection of their\n      // descendants, not an enduring wildcard. This matters when a search\n      // hid siblings: restoring the full tree must not make those siblings\n      // selected merely because the filtered parent had been checked.\n      checked.delete(key);\n      indeterminate.delete(key);\n    } else if (!checked.has(key)) {\n      indeterminate.delete(key);\n    }\n\n    return {\n      all: !eligible || (checked.has(key) && all),\n      any: any || checked.has(key),\n      eligible: eligible || hasEligible,\n    };\n  };\n\n  rootKeys.forEach((key) => visit(key));\n  return { checked, indeterminate };\n}\n\nexport function useTableSelection<T>(options: UseTableSelectionOptions<T>) {\n  const {\n    rows,\n    rowKeys,\n    pageRows = rows,\n    pageRowKeys,\n    filteredRows,\n    filteredRowKeys,\n    getRowKey,\n    selectionMode,\n    selectedKeys: selectedKeysProp,\n    defaultSelectedKeys,\n    onSelectionChange,\n    selectAllMode,\n    isRowSelectable,\n    disabledKeys,\n    tree,\n  } = options;\n\n  const isEnabled = selectionMode !== 'none';\n\n  /**\n   * Two distinct notions of \"not available\", deliberately kept apart:\n   *\n   * - `disabledKeys` — the row is inert. Not focusable, not interactive. This\n   *   is React Aria's standard meaning.\n   * - `isRowSelectable` — the row is fully interactive, only its checkbox is\n   *   inert. This is what Cloud's tables do today.\n   *\n   * A `SelectionManager` has one `disabledBehavior`, so it gets the union under\n   * `'selection'` (neither kind can be selected) and the hard-disabled set is\n   * tracked separately for focus and interaction.\n   */\n  const hardDisabledKeys = useMemo(\n    () => new Set(disabledKeys ?? []),\n    [disabledKeys],\n  );\n\n  const unselectableKeys = useMemo(() => {\n    const keys = new Set(hardDisabledKeys);\n\n    if (isRowSelectable) {\n      // Scanned over the filtered set, not just the page: a select-all that\n      // reaches beyond the page must respect it there too.\n      filteredRows.forEach((row, index) => {\n        if (!isRowSelectable(row)) {\n          keys.add(filteredRowKeys?.[index] ?? getRowKey(row, index));\n        }\n      });\n    }\n\n    return keys;\n  }, [\n    hardDisabledKeys,\n    isRowSelectable,\n    filteredRows,\n    filteredRowKeys,\n    getRowKey,\n  ]);\n\n  const visibleGetRowKey = useCallback(\n    (row: T, index: number) => rowKeys?.[index] ?? getRowKey(row, index),\n    [rowKeys, getRowKey],\n  );\n\n  const collection = useMemo(\n    () => new RowCollection(rows, visibleGetRowKey, unselectableKeys),\n    [rows, visibleGetRowKey, unselectableKeys],\n  );\n\n  const rowByKey = useMemo(() => {\n    const map = new Map<Key, T>();\n\n    // The page first, then the wider filtered set, so a key present in both\n    // resolves to the row the user can actually see.\n    filteredRows.forEach((row, index) =>\n      map.set(filteredRowKeys?.[index] ?? getRowKey(row, index), row),\n    );\n    rows.forEach((row, index) =>\n      map.set(rowKeys?.[index] ?? getRowKey(row, index), row),\n    );\n\n    return map;\n  }, [rows, rowKeys, filteredRows, filteredRowKeys, getRowKey]);\n\n  const rowByKeyRef = useRef(rowByKey);\n\n  rowByKeyRef.current = rowByKey;\n\n  /**\n   * Where a shift-range starts, and how far it currently reaches.\n   *\n   * React Aria's `SelectionManager.extendSelection` keeps this on the `Selection`\n   * object itself (`selectedKeys.anchorKey`), which cannot survive our public\n   * API: `selectedKeys` is `Key[]`, and `useMultipleSelectionState` rebuilds\n   * whatever it is given with `new Selection(value)` — a constructor that only\n   * copies the anchor when the input is already a `Selection`, a class no\n   * package exports. A controlled table would silently reset the anchor to the\n   * clicked row and turn every shift-click into a plain toggle.\n   *\n   * So the range is computed here instead, over `RowCollection`'s index. The\n   * semantics match `extendSelection` exactly: the previous range is removed\n   * before the new one is added, so shift-clicking back shrinks the range\n   * rather than leaving the overshoot selected.\n   */\n  const anchorRef = useRef<Key | null>(null);\n  const extentRef = useRef<Key | null>(null);\n\n  const handleSelectionChange = useEvent((keys: Selection) => {\n    if (!onSelectionChange) return;\n\n    if (keys === 'all') {\n      // The sentinel means \"everything, including rows the client has not\n      // loaded\", so the row list can only ever be what is loaded.\n      onSelectionChange('all', [...rowByKeyRef.current.values()]);\n\n      return;\n    }\n\n    const list = [...keys];\n\n    onSelectionChange(\n      list,\n      list\n        .map((key) => rowByKeyRef.current.get(key))\n        .filter((row): row is T => row !== undefined),\n    );\n  });\n\n  const controlledSelection = useMemo(\n    () => toSelection(selectedKeysProp),\n    [selectedKeysProp],\n  );\n  const defaultSelection = useMemo(\n    () => toSelection(defaultSelectedKeys),\n    [defaultSelectedKeys],\n  );\n\n  const state = useMultipleSelectionState({\n    selectionMode,\n    selectedKeys: controlledSelection,\n    defaultSelectedKeys: defaultSelection,\n    disabledKeys: unselectableKeys,\n    disabledBehavior: 'selection',\n    onSelectionChange: handleSelectionChange,\n  });\n\n  const selectionManager = useMemo(\n    () => new SelectionManager(collection, state),\n    [collection, state],\n  );\n\n  const selectedKeys = state.selectedKeys;\n  const isAll = selectedKeys === 'all';\n  const isCascade =\n    tree?.behavior === 'cascade' && selectionMode === 'multiple';\n\n  const derivedSelection = useMemo(() => {\n    if (isAll) {\n      return {\n        checked: new Set(\n          [...rowByKey.keys()].filter((key) => !unselectableKeys.has(key)),\n        ),\n        indeterminate: new Set<Key>(),\n      };\n    }\n\n    if (!isCascade || !tree) {\n      return {\n        checked: new Set(selectedKeys as Set<Key>),\n        indeterminate: new Set<Key>(),\n      };\n    }\n\n    return deriveTreeSelection(\n      selectedKeys as Set<Key>,\n      tree.rootKeys,\n      tree.childrenOf,\n      (key) => !unselectableKeys.has(key),\n    );\n  }, [isAll, isCascade, selectedKeys, tree, rowByKey, unselectableKeys]);\n\n  const canSelect = useCallback(\n    (key: Key) => isEnabled && !unselectableKeys.has(key),\n    [isEnabled, unselectableKeys],\n  );\n\n  const isSelected = useCallback(\n    (key: Key) => (isAll ? canSelect(key) : derivedSelection.checked.has(key)),\n    [isAll, derivedSelection, canSelect],\n  );\n\n  const isIndeterminate = useCallback(\n    (key: Key) => derivedSelection.indeterminate.has(key),\n    [derivedSelection],\n  );\n\n  /** Keys the header checkbox acts on, which is what `selectAllMode` decides. */\n  const scopeKeys = useMemo(() => {\n    if (!isEnabled || selectionMode === 'single') return [];\n\n    const source = selectAllMode === 'page' ? pageRows : filteredRows;\n    const sourceKeys = selectAllMode === 'page' ? pageRowKeys : filteredRowKeys;\n\n    return source\n      .map((row, index) => sourceKeys?.[index] ?? getRowKey(row, index))\n      .filter((key) => !unselectableKeys.has(key));\n  }, [\n    isEnabled,\n    selectionMode,\n    selectAllMode,\n    pageRows,\n    pageRowKeys,\n    filteredRows,\n    filteredRowKeys,\n    getRowKey,\n    unselectableKeys,\n  ]);\n\n  const selectAllState: CubeTableSelectAllState = useMemo(() => {\n    if (isAll) return 'all';\n    if (!scopeKeys.length) return 'none';\n\n    const set = derivedSelection.checked;\n    let count = 0;\n\n    for (const key of scopeKeys) if (set.has(key)) count++;\n\n    return count === 0 ? 'none' : count === scopeKeys.length ? 'all' : 'some';\n  }, [isAll, derivedSelection, scopeKeys]);\n\n  const toggleSelectAll = useEvent(() => {\n    anchorRef.current = null;\n    extentRef.current = null;\n\n    if (selectAllState === 'all') {\n      // Clearing drops the whole selection, not just the scope: leaving keys\n      // selected on other pages after the user clicked an unchecked-looking\n      // box is the kind of thing nobody discovers until they delete something.\n      state.setSelectedKeys(new Set());\n\n      return;\n    }\n\n    if (selectAllMode === 'all') {\n      state.setSelectedKeys('all');\n\n      return;\n    }\n\n    const next = new Set(isAll ? [] : derivedSelection.checked);\n\n    scopeKeys.forEach((key) => next.add(key));\n    state.setSelectedKeys(\n      isCascade && tree\n        ? deriveTreeSelection(\n            next,\n            tree.rootKeys,\n            tree.childrenOf,\n            (key) => !unselectableKeys.has(key),\n          ).checked\n        : next,\n    );\n  });\n\n  const clearSelection = useEvent(() => {\n    anchorRef.current = null;\n    extentRef.current = null;\n    state.setSelectedKeys(new Set());\n  });\n\n  /**\n   * Shift held on the press that produced this change. `Checkbox` reports only\n   * the next value, so the modifier is captured from the pointer/key event on\n   * the cell and read back here.\n   */\n  const shiftRef = useRef(false);\n\n  const captureShift = useCallback((event: { shiftKey: boolean }) => {\n    shiftRef.current = event.shiftKey;\n  }, []);\n\n  /** Selectable keys between two rows, inclusive, in either direction. */\n  const keysBetween = useCallback(\n    (from: Key, to: Key) => {\n      const fromIndex = collection.indexOf(from);\n      const toIndex = collection.indexOf(to);\n\n      if (fromIndex < 0 || toIndex < 0) return [];\n\n      const [lo, hi] =\n        fromIndex <= toIndex ? [fromIndex, toIndex] : [toIndex, fromIndex];\n      const all = collection.getKeys();\n      const range: Key[] = [];\n\n      for (let i = lo; i <= hi; i++) range.push(all[i]);\n\n      return range;\n    },\n    [collection],\n  );\n\n  const toggleRow = useEvent((key: Key) => {\n    if (!canSelect(key)) return;\n\n    if (selectionMode === 'single') {\n      state.setSelectedKeys(isSelected(key) ? new Set() : new Set([key]));\n\n      return;\n    }\n\n    const applyCascade = (set: Set<Key>, target: Key, value: boolean) => {\n      if (!canSelect(target)) return;\n      if (value) set.add(target);\n      else {\n        set.delete(target);\n\n        // A checked ancestor in the normalized public key set means its whole\n        // branch is selected. Remove that derived marker before normalizing a\n        // partial deselection, or it would immediately select the child again.\n        if (isCascade && tree) {\n          let parent = tree.parentOf.get(target);\n          while (parent != null) {\n            set.delete(parent);\n            parent = tree.parentOf.get(parent);\n          }\n        }\n      }\n      if (!isCascade || !tree) return;\n      (tree.childrenOf.get(target) ?? []).forEach((child) =>\n        applyCascade(set, child, value),\n      );\n    };\n\n    const normalizeCascade = (set: Set<Key>) =>\n      isCascade && tree\n        ? deriveTreeSelection(\n            set,\n            tree.rootKeys,\n            tree.childrenOf,\n            (candidate) => !unselectableKeys.has(candidate),\n          ).checked\n        : set;\n\n    const anchor = anchorRef.current;\n\n    if (shiftRef.current && anchor != null && collection.indexOf(anchor) >= 0) {\n      const next = new Set(isAll ? scopeKeys : derivedSelection.checked);\n\n      // Drop the range this shift-click supersedes before drawing the new one,\n      // so clicking back toward the anchor shrinks the selection.\n      if (extentRef.current != null) {\n        keysBetween(anchor, extentRef.current).forEach((k) =>\n          applyCascade(next, k, false),\n        );\n      }\n\n      keysBetween(anchor, key).forEach((k) => {\n        applyCascade(next, k, true);\n      });\n\n      extentRef.current = key;\n      state.setSelectedKeys(normalizeCascade(next));\n\n      return;\n    }\n\n    anchorRef.current = key;\n    extentRef.current = null;\n    if (isCascade) {\n      const next = new Set(derivedSelection.checked);\n      applyCascade(next, key, !derivedSelection.checked.has(key));\n      state.setSelectedKeys(normalizeCascade(next));\n    } else {\n      selectionManager.toggleSelection(key);\n    }\n  });\n\n  const selectedRows = useMemo(() => {\n    if (isAll) return [...rowByKey.values()];\n\n    return [...derivedSelection.checked]\n      .map((key) => rowByKey.get(key))\n      .filter((row): row is T => row !== undefined);\n  }, [isAll, derivedSelection, rowByKey]);\n\n  return {\n    isEnabled,\n    selectionMode,\n    selectionManager,\n    collection,\n    isSelected,\n    isIndeterminate,\n    canSelect,\n    isRowDisabled: useCallback(\n      (key: Key) => hardDisabledKeys.has(key),\n      [hardDisabledKeys],\n    ),\n    toggleRow,\n    captureShift,\n    selectAllState,\n    toggleSelectAll,\n    clearSelection,\n    selectedRows,\n    selectedCount: isAll ? rowByKey.size : derivedSelection.checked.size,\n    selectedKeys: (isAll ? 'all' : [...derivedSelection.checked]) as\n      | Key[]\n      | 'all',\n  };\n}\n\nexport type CubeTableSelectionState<T> = ReturnType<\n  typeof useTableSelection<T>\n>;\n"],"mappings":"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"}

package/dist/components/data/TableBase/use-table-sort.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.164.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.166.0 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { getColumnText, getColumnValue } from "./use-table-columns.js";
 import { useMemo } from "react";

package/dist/components/data/TableBase/use-table-sorts.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.164.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.166.0 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { compareByColumn } from "./use-table-sort.js";
 import { useMemo } from "react";

package/dist/components/data/TableBase/use-table-storage.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.164.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.166.0 | Cube Dev Team */
 import { useCallback, useRef, useState } from "react";
 
 //#region src/components/data/TableBase/use-table-storage.ts