@cube-dev/ui-kit 0.163.0 → 0.165.0

package/dist/components/data/TableBase/table-tree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-tree.js","names":[],"sources":["../../../../src/components/data/TableBase/table-tree.ts"],"sourcesContent":["import type { Key } from '@react-types/shared';\n\nexport interface TableTreeNode<T> {\n  key: Key;\n  row: T;\n  parentKey: Key | null;\n  level: number;\n  siblingIndex: number;\n  siblingCount: number;\n  sourceIndex: number;\n  children: TableTreeNode<T>[];\n}\n\nexport interface TableTreeModel<T> {\n  roots: TableTreeNode<T>[];\n  byKey: Map<Key, TableTreeNode<T>>;\n  parentOf: Map<Key, Key | null>;\n  childrenOf: Map<Key, Key[]>;\n  duplicateKeys: Key[];\n  cyclicKeys: Key[];\n}\n\n/** Build identity and parent/child indexes without modifying consumer rows. */\nexport function buildTableTree<T>(\n  rows: readonly T[],\n  getChildren: (row: T) => readonly T[] | undefined,\n  getKey: (row: T, sourceIndex: number) => Key,\n): TableTreeModel<T> {\n  const byKey = new Map<Key, TableTreeNode<T>>();\n  const parentOf = new Map<Key, Key | null>();\n  const childrenOf = new Map<Key, Key[]>();\n  const duplicateKeys: Key[] = [];\n  const cyclicKeys: Key[] = [];\n  const visiting = new Set<Key>();\n  const visitingRows = new Set<T>();\n  let sourceIndex = 0;\n\n  const visit = (\n    input: readonly T[],\n    parentKey: Key | null,\n    level: number,\n  ): TableTreeNode<T>[] => {\n    const output: TableTreeNode<T>[] = [];\n\n    input.forEach((row, siblingIndex) => {\n      const currentSourceIndex = sourceIndex++;\n      const key = getKey(row, currentSourceIndex);\n\n      if (visiting.has(key) || visitingRows.has(row)) {\n        cyclicKeys.push(key);\n        return;\n      }\n\n      if (byKey.has(key)) {\n        duplicateKeys.push(key);\n        return;\n      }\n\n      const node: TableTreeNode<T> = {\n        key,\n        row,\n        parentKey,\n        level,\n        siblingIndex,\n        siblingCount: input.length,\n        sourceIndex: currentSourceIndex,\n        children: [],\n      };\n\n      byKey.set(key, node);\n      parentOf.set(key, parentKey);\n      visiting.add(key);\n      visitingRows.add(row);\n      node.children = visit(getChildren(row) ?? [], key, level + 1);\n      visiting.delete(key);\n      visitingRows.delete(row);\n      childrenOf.set(\n        key,\n        node.children.map((child) => child.key),\n      );\n      output.push(node);\n    });\n\n    return output;\n  };\n\n  const roots = visit(rows, null, 0);\n\n  return {\n    roots,\n    byKey,\n    parentOf,\n    childrenOf,\n    duplicateKeys,\n    cyclicKeys,\n  };\n}\n\nexport function sortTableTree<T>(\n  nodes: readonly TableTreeNode<T>[],\n  compare: (a: TableTreeNode<T>, b: TableTreeNode<T>) => number,\n): TableTreeNode<T>[] {\n  const sorted = nodes\n    .map((node) => ({\n      ...node,\n      children: sortTableTree(node.children, compare),\n    }))\n    .sort(compare);\n\n  return sorted.map((node, siblingIndex) => ({\n    ...node,\n    siblingIndex,\n    siblingCount: sorted.length,\n  }));\n}\n\nexport interface FilteredTableTree<T> {\n  roots: TableTreeNode<T>[];\n  forcedExpandedKeys: Set<Key>;\n}\n\n/**\n * Keep matching rows, their ancestor paths, and the complete subtree of a row\n * that matches itself. Every retained branch is opened while filtering so a\n * match can never remain hidden behind a collapsed ancestor.\n */\nexport function filterTableTree<T>(\n  nodes: readonly TableTreeNode<T>[],\n  matches: (node: TableTreeNode<T>) => boolean,\n): FilteredTableTree<T> {\n  const forcedExpandedKeys = new Set<Key>();\n\n  const cloneComplete = (node: TableTreeNode<T>): TableTreeNode<T> => {\n    const children = node.children.map(cloneComplete);\n    if (children.length) forcedExpandedKeys.add(node.key);\n\n    return { ...node, children: reindexTableTree(children) };\n  };\n\n  const visit = (node: TableTreeNode<T>): TableTreeNode<T> | null => {\n    if (matches(node)) return cloneComplete(node);\n\n    const children = node.children\n      .map(visit)\n      .filter((child): child is TableTreeNode<T> => child != null);\n\n    if (!children.length) return null;\n\n    forcedExpandedKeys.add(node.key);\n    return { ...node, children: reindexTableTree(children) };\n  };\n\n  return {\n    roots: reindexTableTree(\n      nodes.map(visit).filter((node): node is TableTreeNode<T> => node != null),\n    ),\n    forcedExpandedKeys,\n  };\n}\n\n/** Re-number a transformed sibling collection for its rendered treegrid. */\nexport function reindexTableTree<T>(\n  nodes: readonly TableTreeNode<T>[],\n): TableTreeNode<T>[] {\n  return nodes.map((node, siblingIndex) => ({\n    ...node,\n    siblingIndex,\n    siblingCount: nodes.length,\n    children: reindexTableTree(node.children),\n  }));\n}\n\nexport function flattenTableTree<T>(\n  nodes: readonly TableTreeNode<T>[],\n  expandedKeys?: ReadonlySet<Key>,\n): TableTreeNode<T>[] {\n  const output: TableTreeNode<T>[] = [];\n\n  const visit = (items: readonly TableTreeNode<T>[]) => {\n    for (const node of items) {\n      output.push(node);\n      if (expandedKeys == null || expandedKeys.has(node.key)) {\n        visit(node.children);\n      }\n    }\n  };\n\n  visit(nodes);\n  return output;\n}\n\nexport function tableTreeDescendantKeys<T>(node: TableTreeNode<T>): Key[] {\n  return flattenTableTree(node.children).map((child) => child.key);\n}\n\nexport function isTableTreeDescendant<T>(\n  model: Pick<TableTreeModel<T>, 'parentOf'>,\n  possibleDescendant: Key,\n  ancestor: Key,\n) {\n  let parent = model.parentOf.get(possibleDescendant);\n\n  while (parent != null) {\n    if (parent === ancestor) return true;\n    parent = model.parentOf.get(parent);\n  }\n\n  return false;\n}\n"],"mappings":";;;AAuBA,SAAgB,eACd,MACA,aACA,QACmB;CACnB,MAAM,wBAAQ,IAAI,KAA4B;CAC9C,MAAM,2BAAW,IAAI,KAAsB;CAC3C,MAAM,6BAAa,IAAI,KAAiB;CACxC,MAAM,gBAAuB,EAAE;CAC/B,MAAM,aAAoB,EAAE;CAC5B,MAAM,2BAAW,IAAI,KAAU;CAC/B,MAAM,+BAAe,IAAI,KAAQ;CACjC,IAAI,cAAc;CAElB,MAAM,SACJ,OACA,WACA,UACuB;EACvB,MAAM,SAA6B,EAAE;AAErC,QAAM,SAAS,KAAK,iBAAiB;GACnC,MAAM,qBAAqB;GAC3B,MAAM,MAAM,OAAO,KAAK,mBAAmB;AAE3C,OAAI,SAAS,IAAI,IAAI,IAAI,aAAa,IAAI,IAAI,EAAE;AAC9C,eAAW,KAAK,IAAI;AACpB;;AAGF,OAAI,MAAM,IAAI,IAAI,EAAE;AAClB,kBAAc,KAAK,IAAI;AACvB;;GAGF,MAAM,OAAyB;IAC7B;IACA;IACA;IACA;IACA;IACA,cAAc,MAAM;IACpB,aAAa;IACb,UAAU,EAAE;IACb;AAED,SAAM,IAAI,KAAK,KAAK;AACpB,YAAS,IAAI,KAAK,UAAU;AAC5B,YAAS,IAAI,IAAI;AACjB,gBAAa,IAAI,IAAI;AACrB,QAAK,WAAW,MAAM,YAAY,IAAI,IAAI,EAAE,EAAE,KAAK,QAAQ,EAAE;AAC7D,YAAS,OAAO,IAAI;AACpB,gBAAa,OAAO,IAAI;AACxB,cAAW,IACT,KACA,KAAK,SAAS,KAAK,UAAU,MAAM,IAAI,CACxC;AACD,UAAO,KAAK,KAAK;IACjB;AAEF,SAAO;;AAKT,QAAO;EACL,OAHY,MAAM,MAAM,MAAM,EAAE;EAIhC;EACA;EACA;EACA;EACA;EACD;;AAGH,SAAgB,cACd,OACA,SACoB;CACpB,MAAM,SAAS,MACZ,KAAK,UAAU;EACd,GAAG;EACH,UAAU,cAAc,KAAK,UAAU,QAAQ;EAChD,EAAE,CACF,KAAK,QAAQ;AAEhB,QAAO,OAAO,KAAK,MAAM,kBAAkB;EACzC,GAAG;EACH;EACA,cAAc,OAAO;EACtB,EAAE;;;;;;;AAaL,SAAgB,gBACd,OACA,SACsB;CACtB,MAAM,qCAAqB,IAAI,KAAU;CAEzC,MAAM,iBAAiB,SAA6C;EAClE,MAAM,WAAW,KAAK,SAAS,IAAI,cAAc;AACjD,MAAI,SAAS,OAAQ,oBAAmB,IAAI,KAAK,IAAI;AAErD,SAAO;GAAE,GAAG;GAAM,UAAU,iBAAiB,SAAS;GAAE;;CAG1D,MAAM,SAAS,SAAoD;AACjE,MAAI,QAAQ,KAAK,CAAE,QAAO,cAAc,KAAK;EAE7C,MAAM,WAAW,KAAK,SACnB,IAAI,MAAM,CACV,QAAQ,UAAqC,SAAS,KAAK;AAE9D,MAAI,CAAC,SAAS,OAAQ,QAAO;AAE7B,qBAAmB,IAAI,KAAK,IAAI;AAChC,SAAO;GAAE,GAAG;GAAM,UAAU,iBAAiB,SAAS;GAAE;;AAG1D,QAAO;EACL,OAAO,iBACL,MAAM,IAAI,MAAM,CAAC,QAAQ,SAAmC,QAAQ,KAAK,CAC1E;EACD;EACD;;;AAIH,SAAgB,iBACd,OACoB;AACpB,QAAO,MAAM,KAAK,MAAM,kBAAkB;EACxC,GAAG;EACH;EACA,cAAc,MAAM;EACpB,UAAU,iBAAiB,KAAK,SAAS;EAC1C,EAAE;;AAGL,SAAgB,iBACd,OACA,cACoB;CACpB,MAAM,SAA6B,EAAE;CAErC,MAAM,SAAS,UAAuC;AACpD,OAAK,MAAM,QAAQ,OAAO;AACxB,UAAO,KAAK,KAAK;AACjB,OAAI,gBAAgB,QAAQ,aAAa,IAAI,KAAK,IAAI,CACpD,OAAM,KAAK,SAAS;;;AAK1B,OAAM,MAAM;AACZ,QAAO;;AAOT,SAAgB,sBACd,OACA,oBACA,UACA;CACA,IAAI,SAAS,MAAM,SAAS,IAAI,mBAAmB;AAEnD,QAAO,UAAU,MAAM;AACrB,MAAI,WAAW,SAAU,QAAO;AAChC,WAAS,MAAM,SAAS,IAAI,OAAO;;AAGrC,QAAO"}

package/dist/components/data/TableBase/types.d.ts

@@ -23,6 +23,47 @@ interface CubeTableCellRange {
   fromColumnKey: string;
   toColumnKey: string;
 }
+interface CubeTableTreeRowState {
+  /** Zero-based depth in the hierarchy. */
+  level: number;
+  parentKey: Key$1 | null;
+  hasChildren: boolean;
+  isExpanded: boolean;
+}
+interface CubeTableRowExpandInfo<T = any> {
+  row: T;
+  rowKey: Key$1;
+  level: number;
+  parentKey: Key$1 | null;
+  expanded: boolean;
+}
+/** Shared root sizing contract used by both table adapters. */
+interface CubeTableLayoutProps {
+  /**
+   * Shrink-wraps the frame to its rendered rows instead of filling the
+   * available flex pane. This mode disables virtualization because there is no
+   * bounded vertical viewport to virtualize against.
+   *
+   * @default false
+   */
+  isAutoHeight?: boolean;
+}
+/** Shared opt-in hierarchy contract used by both table adapters. */
+interface CubeTableTreeProps<T = any> {
+  /**
+   * Returns a row's already-loaded children. Supplying this enables tree mode
+   * and makes `data` the top-level row collection.
+   */
+  getRowChildren?: (row: T) => readonly T[] | undefined;
+  /** Column that owns the indentation and disclosure control. */
+  treeColumnKey?: string;
+  /** Controlled expanded row keys. */
+  expandedKeys?: Key$1[];
+  /** Initially expanded row keys. */
+  defaultExpandedKeys?: Key$1[];
+  /** Called after a user expands or collapses a row. */
+  onExpand?: (keys: Key$1[], info: CubeTableRowExpandInfo<T>) => void;
+}
 interface CubeTableSort {
   /** `key` of the sorted column. */
   columnKey: string;
@@ -49,6 +90,8 @@ interface CubeTableCellContext<T = any> {
    */
   isRowFocused?: boolean;
   isDropTarget?: boolean;
+  /** Present only when `getRowChildren` enables tree mode. */
+  tree?: CubeTableTreeRowState;
 }
 interface CubeTableRowContext<T = any> {
   row: T;
@@ -59,6 +102,8 @@ interface CubeTableRowContext<T = any> {
   /** Not yet wired — always absent. See `CubeTableCellContext` for why. */
   isFocused?: boolean;
   isDropTarget?: boolean;
+  /** Present only when `getRowChildren` enables tree mode. */
+  tree?: CubeTableTreeRowState;
 }
 interface CubeTableHeaderContext {
   columnKey: string;
@@ -254,5 +299,5 @@ type CubeTableSelectionMode = 'none' | 'single' | 'multiple';
  */
 type CubeTableSelectAllMode = 'page' | 'filtered' | 'all';
 //#endregion
-export { CubeTableAlign, CubeTableCellContext, CubeTableCellRange, CubeTableColumn, CubeTableColumnHeader, CubeTableHeaderContext, CubeTableLoadingIndicator, CubeTableRowContext, CubeTableRowSection, CubeTableRowSize, CubeTableSelectAllMode, CubeTableSelectionMode, CubeTableSort, CubeTableSortDirection };
+export { CubeTableAlign, CubeTableCellContext, CubeTableCellRange, CubeTableColumn, CubeTableColumnHeader, CubeTableHeaderContext, CubeTableLayoutProps, CubeTableLoadingIndicator, CubeTableRowContext, CubeTableRowExpandInfo, CubeTableRowSection, CubeTableRowSize, CubeTableSelectAllMode, CubeTableSelectionMode, CubeTableSort, CubeTableSortDirection, CubeTableTreeProps, CubeTableTreeRowState };
 //# sourceMappingURL=types.d.ts.map

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

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.163.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.165.0 | Cube Dev Team */
 //#region src/components/data/TableBase/types.ts
 /**
 * `asc | desc` rather than React Aria's `ascending | descending`: we do not use

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-cell-selection.d.ts

@@ -1,4 +1,3 @@
 
 import "./types.js";
-import "react";
 import { Key as Key$1 } from "@react-types/shared";

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

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.163.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.165.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.163.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.165.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.163.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.165.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.163.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.165.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.163.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.165.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.163.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.165.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.163.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.165.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]
 	};
 }