@cube-dev/ui-kit 0.182.0 → 0.183.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 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"}
+{"version":3,"file":"types.js","names":["Key","Styles","ReactNode","CubeItemProps","CubeTableSortDirection","CubeTableRowSize","CubeTableAlign","CubeTableRowSection","selectionRowKey","section","rowKey","CubeTableCellRange","fromRowKey","toRowKey","fromColumnKey","toColumnKey","CubeTableTreeRowState","level","parentKey","hasChildren","isExpanded","CubeTableRowExpandInfo","row","T","expanded","CubeTableLayoutProps","isAutoHeight","CubeTableTreeProps","getRowChildren","treeColumnKey","expandedKeys","defaultExpandedKeys","onExpand","keys","info","CubeTableSort","columnKey","direction","CubeTableCellContext","rowIndex","columnIndex","isSelected","isRowFocused","isDropTarget","tree","CubeTableRowContext","isFocused","CubeTableHeaderContext","sort","isSortable","isResizing","width","CubeTableColumnGroupHeader","key","title","CubeTableColumnHeader","icon","rightIcon","prefix","suffix","description","descriptionPlacement","tooltip","actions","autoHideActions","menu","menuTriggerProps","Record","menuProps","onMenuAction","action","theme","render","ctx","align","styles","CubeTableColumnTheme","CubeTableColumnColor","hue","saturation","fill","fillBand","text","CubeTableColumnColorScope","CubeTableColumn","header","isRowHeader","flex","minWidth","maxWidth","isResizable","isReorderable","pin","isHidden","getValue","format","value","compare","a","b","rowA","rowB","cellStyles","cellProps","color","colorScope","disallowSortRemoval","isSearchable","isCopyable","autoHeight","meta","CubeResolvedColumn","Omit","index","ariaColIndex","pinOffset","isPinEdge","isStructural","CubeTableColumnLayout","columns","pinnedStartWidth","pinnedEndWidth","totalWidth","isOverflowing","CubeTableLoadingIndicator","CubeTableSelectionMode","CubeTableSelectAllMode"],"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,SAAgBQ,gBACdC,SACAC,QACK;AACL,QAAOD,YAAY,SAASC,SAAS,GAAGD,QAAO,GAAIC"}

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

@@ -1 +1 @@
-{"version":3,"file":"use-cell-selection.js","names":[],"sources":["../../../../src/components/data/TableBase/use-cell-selection.ts"],"sourcesContent":["import { useControlledState } from '@react-stately/utils';\nimport { useCallback, useMemo, useRef } from 'react';\n\nimport { useEvent } from '../../../_internal/hooks';\n\nimport type { Key } from '@react-types/shared';\nimport type { CubeResolvedColumn, CubeTableCellRange } from './types';\n\nexport type CubeTableCellSelectionMode = 'none' | 'cell' | 'range';\n\nexport interface UseCellSelectionOptions<T> {\n  /** @default 'range' */\n  mode?: CubeTableCellSelectionMode;\n  columns: CubeResolvedColumn<T>[];\n  /**\n   * Every row a range can reach, in the order they appear on screen — pinned\n   * rows included. ag-grid excludes them (`!rowNode.rowPinned`), and we do not:\n   * a total is a figure like any other, and selecting a column of revenue only\n   * to have to copy its sum separately is the wrong trade.\n   *\n   * A pinned row is still not reachable by dragging THROUGH it — see\n   * `TableView`'s pointer handlers for why.\n   */\n  rows: readonly T[];\n  /**\n   * Parallel to `rows`. Supplied rather than derived, so it cannot disagree with\n   * the keys the renderer stamps on the cells — when the two drifted, every\n   * range silently resolved to nothing.\n   */\n  rowKeys: readonly Key[];\n  /**\n   * Vetoes individual cells. A pinned total's label cell is the motivating\n   * case: \"Total\" is a caption for the row, not a figure, and there is nothing\n   * useful to do with it selected.\n   *\n   * A vetoed cell cannot anchor or receive a range, never highlights, and copies\n   * as an empty field so a block spanning it keeps its shape.\n   */\n  isCellSelectable?: (row: T, rowKey: Key, columnKey: string) => boolean;\n  range?: CubeTableCellRange | null;\n  defaultRange?: CubeTableCellRange | null;\n  onRangeChange?: (range: CubeTableCellRange | null) => void;\n}\n\nconst cellKey = (rowKey: Key, columnKey: string) => `${rowKey}\u0000${columnKey}`;\n\n/**\n * Rectangular cell selection.\n *\n * A result grid is read by cell, not by row: the thing a user wants out of it is\n * a figure, or a block of figures to paste somewhere else. So a click selects a\n * cell, shift-click and drag grow a rectangle, and ⌘/Ctrl+C writes the rectangle\n * out as TSV.\n *\n * The range is stored as two corners rather than a set of keys, so it survives\n * sorting and paging the way a keyed row selection does — and normalizing it\n * against the CURRENT row and column order is what makes \"the block between\n * these two cells\" keep meaning that after a re-sort.\n *\n * Structural columns (the row number, the checkbox, the row-menu button) can\n * never enter a range: they are chrome, and copying them would put the grid's\n * own furniture into the user's spreadsheet.\n */\nexport function useCellSelection<T>({\n  mode = 'range',\n  columns,\n  rows,\n  rowKeys,\n  isCellSelectable,\n  range: rangeProp,\n  defaultRange,\n  onRangeChange,\n}: UseCellSelectionOptions<T>) {\n  const [range, setRange] = useControlledState<CubeTableCellRange | null>(\n    rangeProp as CubeTableCellRange | null,\n    defaultRange ?? null,\n    onRangeChange as (value: CubeTableCellRange | null) => void,\n  );\n\n  // The press that started a drag. A ref rather than state: it is written and\n  // read inside one pointer gesture, and re-rendering on every `pointerenter`\n  // would drop frames across a wide grid.\n  const anchorRef = useRef<CubeTableCellRange | null>(null);\n  const isDraggingRef = useRef(false);\n\n  const selectableColumns = useMemo(\n    () => columns.filter((column) => !column.isStructural),\n    [columns],\n  );\n\n  const isEnabled = mode !== 'none';\n\n  /**\n   * The range's corners resolved against the current order, as index bounds.\n   * `null` when either corner has scrolled out of the data — a range whose\n   * anchor no longer exists is not a range.\n   */\n  const bounds = useMemo(() => {\n    if (!isEnabled || !range) return null;\n\n    const rowFrom = rowKeys.indexOf(range.fromRowKey);\n    const rowTo = rowKeys.indexOf(range.toRowKey);\n    const colFrom = selectableColumns.findIndex(\n      (column) => column.key === range.fromColumnKey,\n    );\n    const colTo = selectableColumns.findIndex(\n      (column) => column.key === range.toColumnKey,\n    );\n\n    if (rowFrom === -1 || rowTo === -1 || colFrom === -1 || colTo === -1) {\n      return null;\n    }\n\n    return {\n      rowStart: Math.min(rowFrom, rowTo),\n      rowEnd: Math.max(rowFrom, rowTo),\n      colStart: Math.min(colFrom, colTo),\n      colEnd: Math.max(colFrom, colTo),\n    };\n  }, [isEnabled, range, rowKeys, selectableColumns]);\n\n  /**\n   * Every selected cell, precomputed. A range spanning a full page is tens of\n   * thousands of cells and every one of them asks whether it is selected on\n   * every render, so this has to be a lookup rather than four comparisons.\n   */\n  const selectedKeys = useMemo(() => {\n    const keys = new Set<string>();\n\n    if (!bounds) return keys;\n\n    for (let r = bounds.rowStart; r <= bounds.rowEnd; r++) {\n      for (let c = bounds.colStart; c <= bounds.colEnd; c++) {\n        const columnKey = selectableColumns[c].key;\n\n        if (isCellSelectable?.(rows[r], rowKeys[r], columnKey) === false) {\n          continue;\n        }\n\n        keys.add(cellKey(rowKeys[r], columnKey));\n      }\n    }\n\n    return keys;\n  }, [bounds, rows, rowKeys, selectableColumns, isCellSelectable]);\n\n  // `useCallback`, not `useEvent`: the renderer asks this DURING render, once\n  // per cell. `useEvent` keeps its closure current through a layout effect, so a\n  // render-time reader sees the PREVIOUS render's answer — the highlight then\n  // trails the selection by one commit and a cleared range stays painted.\n  const isSelected = useCallback(\n    (rowKey: Key, columnKey: string) =>\n      selectedKeys.has(cellKey(rowKey, columnKey)),\n    [selectedKeys],\n  );\n\n  const isSelectableColumn = useEvent((columnKey: string) =>\n    selectableColumns.some((column) => column.key === columnKey),\n  );\n\n  /**\n   * Whether a cell can take part at all — asked by the renderer before it wires\n   * up any pointer handler, so a vetoed cell is inert rather than merely\n   * unpainted.\n   */\n  const canSelectCell = useEvent((rowKey: Key, columnKey: string) => {\n    if (!isEnabled || !isSelectableColumn(columnKey)) return false;\n    if (!isCellSelectable) return true;\n\n    const index = rowKeys.indexOf(rowKey);\n\n    return index === -1 || isCellSelectable(rows[index], rowKey, columnKey);\n  });\n\n  const select = useEvent((rowKey: Key, columnKey: string) => {\n    if (!canSelectCell(rowKey, columnKey)) return;\n\n    const next: CubeTableCellRange = {\n      fromRowKey: rowKey,\n      toRowKey: rowKey,\n      fromColumnKey: columnKey,\n      toColumnKey: columnKey,\n    };\n\n    anchorRef.current = next;\n    setRange(next);\n  });\n\n  /** Grow the range from the standing anchor. Shift-click and drag both land here. */\n  const extendTo = useEvent((rowKey: Key, columnKey: string) => {\n    if (mode !== 'range' || !canSelectCell(rowKey, columnKey)) return;\n\n    // Shift-clicking with nothing selected yet behaves as a plain click, which\n    // is what every grid and every file manager does.\n    const anchor = anchorRef.current ?? range;\n\n    if (!anchor) {\n      select(rowKey, columnKey);\n\n      return;\n    }\n\n    setRange({\n      fromRowKey: anchor.fromRowKey,\n      toRowKey: rowKey,\n      fromColumnKey: anchor.fromColumnKey,\n      toColumnKey: columnKey,\n    });\n  });\n\n  const clear = useEvent(() => {\n    anchorRef.current = null;\n    if (range) setRange(null);\n  });\n\n  /**\n   * The selection as a grid of display strings, unescaped.\n   *\n   * A matrix rather than a formatted blob, because the clipboard needs the same\n   * block in two formats and re-parsing one to build the other does not\n   * survive contact with the data: a value carrying a tab is RFC-4180 quoted\n   * for the TSV, and splitting that back apart on tabs tore the cell in half.\n   * Both formats are built from this instead.\n   *\n   * Values come from the same display-text pipeline client sort and search use,\n   * so what lands on the clipboard is what was on screen: a formatted currency\n   * stays formatted, and a value with no text representation copies as empty\n   * rather than as `[object Object]`.\n   */\n  const getSelectionMatrix = useEvent(\n    (\n      getText: (\n        column: CubeResolvedColumn<T>,\n        row: T,\n        rowIndex: number,\n      ) => string,\n      getHeader?: (column: CubeResolvedColumn<T>) => string,\n    ) => {\n      if (!bounds) return [];\n\n      const cols = selectableColumns.slice(bounds.colStart, bounds.colEnd + 1);\n      const matrix: string[][] = [];\n\n      if (getHeader) matrix.push(cols.map((column) => getHeader(column)));\n\n      for (let r = bounds.rowStart; r <= bounds.rowEnd; r++) {\n        matrix.push(\n          cols.map((column) =>\n            selectedKeys.has(cellKey(rowKeys[r], column.key))\n              ? getText(column, rows[r], r)\n              : '',\n          ),\n        );\n      }\n\n      return matrix;\n    },\n  );\n\n  return {\n    mode,\n    isEnabled,\n    range: bounds ? range : null,\n    /** Cells in the range, for `aria-selected` and the highlight. */\n    isSelected,\n    /** `true` once the range covers more than one cell. */\n    hasRange: selectedKeys.size > 1,\n    cellCount: selectedKeys.size,\n    canSelectCell,\n    select,\n    extendTo,\n    clear,\n    getSelectionMatrix,\n    anchorRef,\n    isDraggingRef,\n  };\n}\n\n/**\n * The matrix as tab-separated values — the format Excel and Sheets both paste\n * as a grid rather than as one run of text.\n *\n * RFC-4180 quoting: a value carrying a tab or a newline would otherwise break\n * the grid apart on paste, one cell becoming two or one row becoming two.\n */\nexport function toTsv(matrix: string[][]) {\n  return matrix.map((row) => row.map(quote).join('\\t')).join('\\n');\n}\n\nfunction quote(value: string) {\n  if (!/[\\t\\n\\r\"]/.test(value)) return value;\n\n  return `\"${value.replace(/\"/g, '\"\"')}\"`;\n}\n"],"mappings":"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"}
+{"version":3,"file":"use-cell-selection.js","names":["useControlledState","useCallback","useMemo","useRef","useEvent","Key","CubeResolvedColumn","CubeTableCellRange","CubeTableCellSelectionMode","UseCellSelectionOptions","mode","columns","T","rows","rowKeys","isCellSelectable","row","rowKey","columnKey","range","defaultRange","onRangeChange","cellKey","useCellSelection","rangeProp","setRange","value","anchorRef","isDraggingRef","selectableColumns","filter","column","isStructural","isEnabled","bounds","rowFrom","indexOf","fromRowKey","rowTo","toRowKey","colFrom","findIndex","key","fromColumnKey","colTo","toColumnKey","rowStart","Math","min","rowEnd","max","colStart","colEnd","selectedKeys","keys","Set","r","c","add","isSelected","has","isSelectableColumn","some","canSelectCell","index","select","next","current","extendTo","anchor","clear","getSelectionMatrix","getText","rowIndex","getHeader","cols","slice","matrix","push","map","hasRange","size","cellCount","toTsv","quote","join","test","replace"],"sources":["../../../../src/components/data/TableBase/use-cell-selection.ts"],"sourcesContent":["import { useControlledState } from '@react-stately/utils';\nimport { useCallback, useMemo, useRef } from 'react';\n\nimport { useEvent } from '../../../_internal/hooks';\n\nimport type { Key } from '@react-types/shared';\nimport type { CubeResolvedColumn, CubeTableCellRange } from './types';\n\nexport type CubeTableCellSelectionMode = 'none' | 'cell' | 'range';\n\nexport interface UseCellSelectionOptions<T> {\n  /** @default 'range' */\n  mode?: CubeTableCellSelectionMode;\n  columns: CubeResolvedColumn<T>[];\n  /**\n   * Every row a range can reach, in the order they appear on screen — pinned\n   * rows included. ag-grid excludes them (`!rowNode.rowPinned`), and we do not:\n   * a total is a figure like any other, and selecting a column of revenue only\n   * to have to copy its sum separately is the wrong trade.\n   *\n   * A pinned row is still not reachable by dragging THROUGH it — see\n   * `TableView`'s pointer handlers for why.\n   */\n  rows: readonly T[];\n  /**\n   * Parallel to `rows`. Supplied rather than derived, so it cannot disagree with\n   * the keys the renderer stamps on the cells — when the two drifted, every\n   * range silently resolved to nothing.\n   */\n  rowKeys: readonly Key[];\n  /**\n   * Vetoes individual cells. A pinned total's label cell is the motivating\n   * case: \"Total\" is a caption for the row, not a figure, and there is nothing\n   * useful to do with it selected.\n   *\n   * A vetoed cell cannot anchor or receive a range, never highlights, and copies\n   * as an empty field so a block spanning it keeps its shape.\n   */\n  isCellSelectable?: (row: T, rowKey: Key, columnKey: string) => boolean;\n  range?: CubeTableCellRange | null;\n  defaultRange?: CubeTableCellRange | null;\n  onRangeChange?: (range: CubeTableCellRange | null) => void;\n}\n\nconst cellKey = (rowKey: Key, columnKey: string) => `${rowKey}\u0000${columnKey}`;\n\n/**\n * Rectangular cell selection.\n *\n * A result grid is read by cell, not by row: the thing a user wants out of it is\n * a figure, or a block of figures to paste somewhere else. So a click selects a\n * cell, shift-click and drag grow a rectangle, and ⌘/Ctrl+C writes the rectangle\n * out as TSV.\n *\n * The range is stored as two corners rather than a set of keys, so it survives\n * sorting and paging the way a keyed row selection does — and normalizing it\n * against the CURRENT row and column order is what makes \"the block between\n * these two cells\" keep meaning that after a re-sort.\n *\n * Structural columns (the row number, the checkbox, the row-menu button) can\n * never enter a range: they are chrome, and copying them would put the grid's\n * own furniture into the user's spreadsheet.\n */\nexport function useCellSelection<T>({\n  mode = 'range',\n  columns,\n  rows,\n  rowKeys,\n  isCellSelectable,\n  range: rangeProp,\n  defaultRange,\n  onRangeChange,\n}: UseCellSelectionOptions<T>) {\n  const [range, setRange] = useControlledState<CubeTableCellRange | null>(\n    rangeProp as CubeTableCellRange | null,\n    defaultRange ?? null,\n    onRangeChange as (value: CubeTableCellRange | null) => void,\n  );\n\n  // The press that started a drag. A ref rather than state: it is written and\n  // read inside one pointer gesture, and re-rendering on every `pointerenter`\n  // would drop frames across a wide grid.\n  const anchorRef = useRef<CubeTableCellRange | null>(null);\n  const isDraggingRef = useRef(false);\n\n  const selectableColumns = useMemo(\n    () => columns.filter((column) => !column.isStructural),\n    [columns],\n  );\n\n  const isEnabled = mode !== 'none';\n\n  /**\n   * The range's corners resolved against the current order, as index bounds.\n   * `null` when either corner has scrolled out of the data — a range whose\n   * anchor no longer exists is not a range.\n   */\n  const bounds = useMemo(() => {\n    if (!isEnabled || !range) return null;\n\n    const rowFrom = rowKeys.indexOf(range.fromRowKey);\n    const rowTo = rowKeys.indexOf(range.toRowKey);\n    const colFrom = selectableColumns.findIndex(\n      (column) => column.key === range.fromColumnKey,\n    );\n    const colTo = selectableColumns.findIndex(\n      (column) => column.key === range.toColumnKey,\n    );\n\n    if (rowFrom === -1 || rowTo === -1 || colFrom === -1 || colTo === -1) {\n      return null;\n    }\n\n    return {\n      rowStart: Math.min(rowFrom, rowTo),\n      rowEnd: Math.max(rowFrom, rowTo),\n      colStart: Math.min(colFrom, colTo),\n      colEnd: Math.max(colFrom, colTo),\n    };\n  }, [isEnabled, range, rowKeys, selectableColumns]);\n\n  /**\n   * Every selected cell, precomputed. A range spanning a full page is tens of\n   * thousands of cells and every one of them asks whether it is selected on\n   * every render, so this has to be a lookup rather than four comparisons.\n   */\n  const selectedKeys = useMemo(() => {\n    const keys = new Set<string>();\n\n    if (!bounds) return keys;\n\n    for (let r = bounds.rowStart; r <= bounds.rowEnd; r++) {\n      for (let c = bounds.colStart; c <= bounds.colEnd; c++) {\n        const columnKey = selectableColumns[c].key;\n\n        if (isCellSelectable?.(rows[r], rowKeys[r], columnKey) === false) {\n          continue;\n        }\n\n        keys.add(cellKey(rowKeys[r], columnKey));\n      }\n    }\n\n    return keys;\n  }, [bounds, rows, rowKeys, selectableColumns, isCellSelectable]);\n\n  // `useCallback`, not `useEvent`: the renderer asks this DURING render, once\n  // per cell. `useEvent` keeps its closure current through a layout effect, so a\n  // render-time reader sees the PREVIOUS render's answer — the highlight then\n  // trails the selection by one commit and a cleared range stays painted.\n  const isSelected = useCallback(\n    (rowKey: Key, columnKey: string) =>\n      selectedKeys.has(cellKey(rowKey, columnKey)),\n    [selectedKeys],\n  );\n\n  const isSelectableColumn = useEvent((columnKey: string) =>\n    selectableColumns.some((column) => column.key === columnKey),\n  );\n\n  /**\n   * Whether a cell can take part at all — asked by the renderer before it wires\n   * up any pointer handler, so a vetoed cell is inert rather than merely\n   * unpainted.\n   */\n  const canSelectCell = useEvent((rowKey: Key, columnKey: string) => {\n    if (!isEnabled || !isSelectableColumn(columnKey)) return false;\n    if (!isCellSelectable) return true;\n\n    const index = rowKeys.indexOf(rowKey);\n\n    return index === -1 || isCellSelectable(rows[index], rowKey, columnKey);\n  });\n\n  const select = useEvent((rowKey: Key, columnKey: string) => {\n    if (!canSelectCell(rowKey, columnKey)) return;\n\n    const next: CubeTableCellRange = {\n      fromRowKey: rowKey,\n      toRowKey: rowKey,\n      fromColumnKey: columnKey,\n      toColumnKey: columnKey,\n    };\n\n    anchorRef.current = next;\n    setRange(next);\n  });\n\n  /** Grow the range from the standing anchor. Shift-click and drag both land here. */\n  const extendTo = useEvent((rowKey: Key, columnKey: string) => {\n    if (mode !== 'range' || !canSelectCell(rowKey, columnKey)) return;\n\n    // Shift-clicking with nothing selected yet behaves as a plain click, which\n    // is what every grid and every file manager does.\n    const anchor = anchorRef.current ?? range;\n\n    if (!anchor) {\n      select(rowKey, columnKey);\n\n      return;\n    }\n\n    setRange({\n      fromRowKey: anchor.fromRowKey,\n      toRowKey: rowKey,\n      fromColumnKey: anchor.fromColumnKey,\n      toColumnKey: columnKey,\n    });\n  });\n\n  const clear = useEvent(() => {\n    anchorRef.current = null;\n    if (range) setRange(null);\n  });\n\n  /**\n   * The selection as a grid of display strings, unescaped.\n   *\n   * A matrix rather than a formatted blob, because the clipboard needs the same\n   * block in two formats and re-parsing one to build the other does not\n   * survive contact with the data: a value carrying a tab is RFC-4180 quoted\n   * for the TSV, and splitting that back apart on tabs tore the cell in half.\n   * Both formats are built from this instead.\n   *\n   * Values come from the same display-text pipeline client sort and search use,\n   * so what lands on the clipboard is what was on screen: a formatted currency\n   * stays formatted, and a value with no text representation copies as empty\n   * rather than as `[object Object]`.\n   */\n  const getSelectionMatrix = useEvent(\n    (\n      getText: (\n        column: CubeResolvedColumn<T>,\n        row: T,\n        rowIndex: number,\n      ) => string,\n      getHeader?: (column: CubeResolvedColumn<T>) => string,\n    ) => {\n      if (!bounds) return [];\n\n      const cols = selectableColumns.slice(bounds.colStart, bounds.colEnd + 1);\n      const matrix: string[][] = [];\n\n      if (getHeader) matrix.push(cols.map((column) => getHeader(column)));\n\n      for (let r = bounds.rowStart; r <= bounds.rowEnd; r++) {\n        matrix.push(\n          cols.map((column) =>\n            selectedKeys.has(cellKey(rowKeys[r], column.key))\n              ? getText(column, rows[r], r)\n              : '',\n          ),\n        );\n      }\n\n      return matrix;\n    },\n  );\n\n  return {\n    mode,\n    isEnabled,\n    range: bounds ? range : null,\n    /** Cells in the range, for `aria-selected` and the highlight. */\n    isSelected,\n    /** `true` once the range covers more than one cell. */\n    hasRange: selectedKeys.size > 1,\n    cellCount: selectedKeys.size,\n    canSelectCell,\n    select,\n    extendTo,\n    clear,\n    getSelectionMatrix,\n    anchorRef,\n    isDraggingRef,\n  };\n}\n\n/**\n * The matrix as tab-separated values — the format Excel and Sheets both paste\n * as a grid rather than as one run of text.\n *\n * RFC-4180 quoting: a value carrying a tab or a newline would otherwise break\n * the grid apart on paste, one cell becoming two or one row becoming two.\n */\nexport function toTsv(matrix: string[][]) {\n  return matrix.map((row) => row.map(quote).join('\\t')).join('\\n');\n}\n\nfunction quote(value: string) {\n  if (!/[\\t\\n\\r\"]/.test(value)) return value;\n\n  return `\"${value.replace(/\"/g, '\"\"')}\"`;\n}\n"],"mappings":"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"}

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

@@ -1,6 +1,7 @@
-/** @license MIT | @cube-dev/ui-kit v0.182.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.183.0 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
-import { useMemo, useState } from "react";
+import { c } from "react-compiler-runtime";
+import { useState } from "react";
 import { useControlledState } from "@react-stately/utils";
 
 //#region src/components/data/TableBase/use-column-order.ts
@@ -79,20 +80,63 @@ function projectReorder(fullOrder, nextDraggable) {
 	return next;
 }
 const EMPTY_ORDER = [];
-function useColumnOrder({ columns, columnOrder, defaultColumnOrder, onColumnOrderChange, storage }) {
-	const [storedOrder] = useState(() => columnOrder === void 0 && storage.has("columnOrder") ? storage.initial.columnOrder : void 0);
+function useColumnOrder(t0) {
+	const $ = c(17);
+	const { columns, columnOrder, defaultColumnOrder, onColumnOrderChange, storage } = t0;
+	let t1;
+	if ($[0] !== columnOrder || $[1] !== storage) {
+		t1 = () => columnOrder === void 0 && storage.has("columnOrder") ? storage.initial.columnOrder : void 0;
+		$[0] = columnOrder;
+		$[1] = storage;
+		$[2] = t1;
+	} else t1 = $[2];
+	const [storedOrder] = useState(t1);
 	const [order, setOrder] = useControlledState(columnOrder, defaultColumnOrder ?? storedOrder ?? EMPTY_ORDER, onColumnOrderChange);
-	const ordered = useMemo(() => applyColumnOrder(columns, order), [columns, order]);
-	const fullOrder = useMemo(() => ordered.map((column) => column.key), [ordered]);
-	return {
-		columns: ordered,
-		order: fullOrder,
-		reorder: useEvent((nextDraggable) => {
+	let t2;
+	if ($[3] !== columns || $[4] !== order) {
+		t2 = applyColumnOrder(columns, order);
+		$[3] = columns;
+		$[4] = order;
+		$[5] = t2;
+	} else t2 = $[5];
+	const ordered = t2;
+	let t3;
+	if ($[6] !== ordered) {
+		t3 = ordered.map(_temp);
+		$[6] = ordered;
+		$[7] = t3;
+	} else t3 = $[7];
+	const fullOrder = t3;
+	let t4;
+	if ($[8] !== columnOrder || $[9] !== fullOrder || $[10] !== setOrder || $[11] !== storage) {
+		t4 = (nextDraggable) => {
 			const next = projectReorder(fullOrder, nextDraggable);
 			setOrder(next);
 			if (columnOrder === void 0) storage.write({ columnOrder: next });
-		})
-	};
+		};
+		$[8] = columnOrder;
+		$[9] = fullOrder;
+		$[10] = setOrder;
+		$[11] = storage;
+		$[12] = t4;
+	} else t4 = $[12];
+	const reorder = useEvent(t4);
+	let t5;
+	if ($[13] !== fullOrder || $[14] !== ordered || $[15] !== reorder) {
+		t5 = {
+			columns: ordered,
+			order: fullOrder,
+			reorder
+		};
+		$[13] = fullOrder;
+		$[14] = ordered;
+		$[15] = reorder;
+		$[16] = t5;
+	} else t5 = $[16];
+	return t5;
+}
+function _temp(column) {
+	return column.key;
 }
 
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"use-column-order.js","names":[],"sources":["../../../../src/components/data/TableBase/use-column-order.ts"],"sourcesContent":["import { useControlledState } from '@react-stately/utils';\nimport { useMemo, useState } from 'react';\n\nimport { useEvent } from '../../../_internal/hooks';\n\nimport type { CubeResolvedColumn, CubeTableColumn } from './types';\nimport type { useTableStorage } from './use-table-storage';\n\n/**\n * Reorders the source columns to match `order`.\n *\n * Rank-based rather than filter-then-concat, because `order` is routinely\n * *stale*: it was persisted or lifted into page state before the current\n * `columns` array existed. A column missing from it inherits the rank of the\n * nearest preceding known column plus a half step, so it lands immediately after\n * the neighbour it had in the source array instead of being swept to the end. A\n * new leading column keeps its lead.\n *\n * Applied to the SOURCE array, before `useTableColumns` — so hidden-column\n * filtering, structural injection, pinned hoisting and `aria-colindex` all still\n * happen downstream, and `columnOrder` can never fight `pin`.\n */\nexport function applyColumnOrder<T>(\n  columns: CubeTableColumn<T>[],\n  order?: readonly string[],\n): CubeTableColumn<T>[] {\n  if (!order?.length) return columns;\n\n  const present = new Set(columns.map((column) => column.key));\n  const rank = new Map<string, number>();\n\n  order.forEach((key, index) => {\n    // A key for a column that no longer exists is ignored rather than treated as\n    // a gap, and a duplicate keeps its first position.\n    if (present.has(key) && !rank.has(key)) rank.set(key, index);\n  });\n\n  if (!rank.size) return columns;\n\n  let carried = -1;\n\n  return columns\n    .map((column, sourceIndex) => {\n      const own = rank.get(column.key);\n\n      if (own != null) carried = own;\n\n      return { column, sourceIndex, rank: own ?? carried + 0.5 };\n    })\n    .sort((a, b) => a.rank - b.rank || a.sourceIndex - b.sourceIndex)\n    .map((entry) => entry.column);\n}\n\n/**\n * Whether a column can be picked up and moved.\n *\n * The single shared predicate: `DataTable` builds the draggable key list from\n * it and `TableView` decides which `<th>` is a drag source from it, so the two\n * cannot drift. A renderer disagreeing with the state behind it is exactly how\n * the drop indicator that never matched its selector happened.\n *\n * Pinned columns are excluded, for three reasons that all point the same way: a\n * pinned `<th>` is `position: sticky`, so under horizontal scroll its rect sits\n * on top of columns it is nowhere near and React Aria's drop-target binary\n * search goes wrong; `use-table-columns` hoists pinned columns to the edges\n * regardless of source order, so a cross-boundary drop would be undone\n * immediately; and `pin` is already the ordering authority there. What that buys\n * is a draggable set that is one contiguous, non-sticky run — every permutation\n * of which stays monotonic, which is what the delegate needs.\n */\nexport function isColumnDraggable<T>(\n  column: Pick<CubeResolvedColumn<T>, 'isStructural' | 'pin' | 'isReorderable'>,\n  isEnabled: boolean,\n): boolean {\n  return (\n    isEnabled &&\n    !column.isStructural &&\n    column.pin == null &&\n    (column.isReorderable ?? true)\n  );\n}\n\nexport function getDraggableColumnKeys<T>(\n  columns: readonly CubeResolvedColumn<T>[],\n  isEnabled: boolean,\n): string[] {\n  return columns\n    .filter((column) => isColumnDraggable(column, isEnabled))\n    .map((column) => column.key);\n}\n\n/**\n * Folds a permutation of the draggable subset back into the full order.\n *\n * Only the slots the draggable keys already occupy are rewritten, so a hidden\n * column, a pinned one, or one that opted out keeps its absolute index and\n * cannot be displaced by a drag it took no part in.\n *\n * The visible consequence, worth knowing: a hidden column between two draggable\n * ones keeps its slot rather than following a neighbour, so it may come back\n * between different columns than it left. Predictable beats clever.\n */\nexport function projectReorder(\n  fullOrder: readonly string[],\n  nextDraggable: readonly string[],\n): string[] {\n  const draggable = new Set(nextDraggable);\n  const next = [...fullOrder];\n  let cursor = 0;\n\n  for (let slot = 0; slot < next.length; slot++) {\n    if (draggable.has(next[slot])) next[slot] = nextDraggable[cursor++];\n  }\n\n  return next;\n}\n\nconst EMPTY_ORDER: string[] = [];\n\nexport interface UseColumnOrderOptions<T> {\n  columns: CubeTableColumn<T>[];\n  columnOrder?: string[];\n  defaultColumnOrder?: string[];\n  onColumnOrderChange?: (order: string[]) => void;\n  storage: ReturnType<typeof useTableStorage>;\n}\n\nexport interface UseColumnOrderResult<T> {\n  /** `columns`, reordered. Feed this to `useTableColumns`. */\n  columns: CubeTableColumn<T>[];\n  /** The full key list in its current order, including hidden and pinned keys. */\n  order: string[];\n  /** Takes the reordered DRAGGABLE keys and commits the full order. */\n  reorder: (nextDraggable: string[]) => void;\n}\n\nexport function useColumnOrder<T>({\n  columns,\n  columnOrder,\n  defaultColumnOrder,\n  onColumnOrderChange,\n  storage,\n}: UseColumnOrderOptions<T>): UseColumnOrderResult<T> {\n  // Seeded once, like `ownColumnWidths`: a controlled `columnOrder` belongs to\n  // the page, so restoring over it would fight the page's own source of truth.\n  const [storedOrder] = useState(() =>\n    columnOrder === undefined && storage.has('columnOrder')\n      ? storage.initial.columnOrder\n      : undefined,\n  );\n\n  // An empty array means \"no order\", which `applyColumnOrder` treats as a\n  // no-op — same shape `useTableSorts` uses for its own empty default, and it\n  // keeps `useControlledState` off the `undefined` overload.\n  const [order, setOrder] = useControlledState<string[]>(\n    columnOrder as string[],\n    defaultColumnOrder ?? storedOrder ?? EMPTY_ORDER,\n    onColumnOrderChange as (value: string[]) => void,\n  );\n\n  const ordered = useMemo(\n    () => applyColumnOrder(columns, order),\n    [columns, order],\n  );\n\n  // Always the FULL source key list, in current order — so a key never drops out\n  // of persisted state just because its column happened to be hidden.\n  const fullOrder = useMemo(\n    () => ordered.map((column) => column.key),\n    [ordered],\n  );\n\n  const reorder = useEvent((nextDraggable: string[]) => {\n    const next = projectReorder(fullOrder, nextDraggable);\n\n    setOrder(next);\n\n    // Only what the table OWNS is persisted — a controlled order belongs to the\n    // page, and storing it would fight the page on the next mount. Same rule\n    // `handleColumnResizeEnd` follows for widths.\n    if (columnOrder === undefined) storage.write({ columnOrder: next });\n  });\n\n  return { columns: ordered, order: fullOrder, reorder };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,iBACd,SACA,OACsB;AACtB,KAAI,CAAC,OAAO,OAAQ,QAAO;CAE3B,MAAM,UAAU,IAAI,IAAI,QAAQ,KAAK,WAAW,OAAO,IAAI,CAAC;CAC5D,MAAM,uBAAO,IAAI,KAAqB;AAEtC,OAAM,SAAS,KAAK,UAAU;AAG5B,MAAI,QAAQ,IAAI,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,CAAE,MAAK,IAAI,KAAK,MAAM;GAC5D;AAEF,KAAI,CAAC,KAAK,KAAM,QAAO;CAEvB,IAAI,UAAU;AAEd,QAAO,QACJ,KAAK,QAAQ,gBAAgB;EAC5B,MAAM,MAAM,KAAK,IAAI,OAAO,IAAI;AAEhC,MAAI,OAAO,KAAM,WAAU;AAE3B,SAAO;GAAE;GAAQ;GAAa,MAAM,OAAO,UAAU;GAAK;GAC1D,CACD,MAAM,GAAG,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,YAAY,CAChE,KAAK,UAAU,MAAM,OAAO;;;;;;;;;;;;;;;;;;;AAoBjC,SAAgB,kBACd,QACA,WACS;AACT,QACE,aACA,CAAC,OAAO,gBACR,OAAO,OAAO,SACb,OAAO,iBAAiB;;AAI7B,SAAgB,uBACd,SACA,WACU;AACV,QAAO,QACJ,QAAQ,WAAW,kBAAkB,QAAQ,UAAU,CAAC,CACxD,KAAK,WAAW,OAAO,IAAI;;;;;;;;;;;;;AAchC,SAAgB,eACd,WACA,eACU;CACV,MAAM,YAAY,IAAI,IAAI,cAAc;CACxC,MAAM,OAAO,CAAC,GAAG,UAAU;CAC3B,IAAI,SAAS;AAEb,MAAK,IAAI,OAAO,GAAG,OAAO,KAAK,QAAQ,OACrC,KAAI,UAAU,IAAI,KAAK,MAAM,CAAE,MAAK,QAAQ,cAAc;AAG5D,QAAO;;AAGT,MAAM,cAAwB,EAAE;AAmBhC,SAAgB,eAAkB,EAChC,SACA,aACA,oBACA,qBACA,WACoD;CAGpD,MAAM,CAAC,eAAe,eACpB,gBAAgB,UAAa,QAAQ,IAAI,cAAc,GACnD,QAAQ,QAAQ,cAChB,OACL;CAKD,MAAM,CAAC,OAAO,YAAY,mBACxB,aACA,sBAAsB,eAAe,aACrC,oBACD;CAED,MAAM,UAAU,cACR,iBAAiB,SAAS,MAAM,EACtC,CAAC,SAAS,MAAM,CACjB;CAID,MAAM,YAAY,cACV,QAAQ,KAAK,WAAW,OAAO,IAAI,EACzC,CAAC,QAAQ,CACV;AAaD,QAAO;EAAE,SAAS;EAAS,OAAO;EAAW,SAX7B,UAAU,kBAA4B;GACpD,MAAM,OAAO,eAAe,WAAW,cAAc;AAErD,YAAS,KAAK;AAKd,OAAI,gBAAgB,OAAW,SAAQ,MAAM,EAAE,aAAa,MAAM,CAAC;IACnE;EAEoD"}
+{"version":3,"file":"use-column-order.js","names":["useControlledState","useMemo","useState","useEvent","CubeResolvedColumn","CubeTableColumn","useTableStorage","applyColumnOrder","columns","T","order","length","present","Set","map","column","key","rank","Map","forEach","index","has","set","size","carried","sourceIndex","own","get","sort","a","b","entry","isColumnDraggable","Pick","isEnabled","isStructural","pin","isReorderable","getDraggableColumnKeys","filter","projectReorder","fullOrder","nextDraggable","draggable","next","cursor","slot","EMPTY_ORDER","UseColumnOrderOptions","columnOrder","defaultColumnOrder","onColumnOrderChange","storage","ReturnType","UseColumnOrderResult","reorder","useColumnOrder","t0","$","_c","t1","undefined","initial","storedOrder","setOrder","value","t2","ordered","t3","_temp","t4","write","t5"],"sources":["../../../../src/components/data/TableBase/use-column-order.ts"],"sourcesContent":["import { useControlledState } from '@react-stately/utils';\nimport { useMemo, useState } from 'react';\n\nimport { useEvent } from '../../../_internal/hooks';\n\nimport type { CubeResolvedColumn, CubeTableColumn } from './types';\nimport type { useTableStorage } from './use-table-storage';\n\n/**\n * Reorders the source columns to match `order`.\n *\n * Rank-based rather than filter-then-concat, because `order` is routinely\n * *stale*: it was persisted or lifted into page state before the current\n * `columns` array existed. A column missing from it inherits the rank of the\n * nearest preceding known column plus a half step, so it lands immediately after\n * the neighbour it had in the source array instead of being swept to the end. A\n * new leading column keeps its lead.\n *\n * Applied to the SOURCE array, before `useTableColumns` — so hidden-column\n * filtering, structural injection, pinned hoisting and `aria-colindex` all still\n * happen downstream, and `columnOrder` can never fight `pin`.\n */\nexport function applyColumnOrder<T>(\n  columns: CubeTableColumn<T>[],\n  order?: readonly string[],\n): CubeTableColumn<T>[] {\n  if (!order?.length) return columns;\n\n  const present = new Set(columns.map((column) => column.key));\n  const rank = new Map<string, number>();\n\n  order.forEach((key, index) => {\n    // A key for a column that no longer exists is ignored rather than treated as\n    // a gap, and a duplicate keeps its first position.\n    if (present.has(key) && !rank.has(key)) rank.set(key, index);\n  });\n\n  if (!rank.size) return columns;\n\n  let carried = -1;\n\n  return columns\n    .map((column, sourceIndex) => {\n      const own = rank.get(column.key);\n\n      if (own != null) carried = own;\n\n      return { column, sourceIndex, rank: own ?? carried + 0.5 };\n    })\n    .sort((a, b) => a.rank - b.rank || a.sourceIndex - b.sourceIndex)\n    .map((entry) => entry.column);\n}\n\n/**\n * Whether a column can be picked up and moved.\n *\n * The single shared predicate: `DataTable` builds the draggable key list from\n * it and `TableView` decides which `<th>` is a drag source from it, so the two\n * cannot drift. A renderer disagreeing with the state behind it is exactly how\n * the drop indicator that never matched its selector happened.\n *\n * Pinned columns are excluded, for three reasons that all point the same way: a\n * pinned `<th>` is `position: sticky`, so under horizontal scroll its rect sits\n * on top of columns it is nowhere near and React Aria's drop-target binary\n * search goes wrong; `use-table-columns` hoists pinned columns to the edges\n * regardless of source order, so a cross-boundary drop would be undone\n * immediately; and `pin` is already the ordering authority there. What that buys\n * is a draggable set that is one contiguous, non-sticky run — every permutation\n * of which stays monotonic, which is what the delegate needs.\n */\nexport function isColumnDraggable<T>(\n  column: Pick<CubeResolvedColumn<T>, 'isStructural' | 'pin' | 'isReorderable'>,\n  isEnabled: boolean,\n): boolean {\n  return (\n    isEnabled &&\n    !column.isStructural &&\n    column.pin == null &&\n    (column.isReorderable ?? true)\n  );\n}\n\nexport function getDraggableColumnKeys<T>(\n  columns: readonly CubeResolvedColumn<T>[],\n  isEnabled: boolean,\n): string[] {\n  return columns\n    .filter((column) => isColumnDraggable(column, isEnabled))\n    .map((column) => column.key);\n}\n\n/**\n * Folds a permutation of the draggable subset back into the full order.\n *\n * Only the slots the draggable keys already occupy are rewritten, so a hidden\n * column, a pinned one, or one that opted out keeps its absolute index and\n * cannot be displaced by a drag it took no part in.\n *\n * The visible consequence, worth knowing: a hidden column between two draggable\n * ones keeps its slot rather than following a neighbour, so it may come back\n * between different columns than it left. Predictable beats clever.\n */\nexport function projectReorder(\n  fullOrder: readonly string[],\n  nextDraggable: readonly string[],\n): string[] {\n  const draggable = new Set(nextDraggable);\n  const next = [...fullOrder];\n  let cursor = 0;\n\n  for (let slot = 0; slot < next.length; slot++) {\n    if (draggable.has(next[slot])) next[slot] = nextDraggable[cursor++];\n  }\n\n  return next;\n}\n\nconst EMPTY_ORDER: string[] = [];\n\nexport interface UseColumnOrderOptions<T> {\n  columns: CubeTableColumn<T>[];\n  columnOrder?: string[];\n  defaultColumnOrder?: string[];\n  onColumnOrderChange?: (order: string[]) => void;\n  storage: ReturnType<typeof useTableStorage>;\n}\n\nexport interface UseColumnOrderResult<T> {\n  /** `columns`, reordered. Feed this to `useTableColumns`. */\n  columns: CubeTableColumn<T>[];\n  /** The full key list in its current order, including hidden and pinned keys. */\n  order: string[];\n  /** Takes the reordered DRAGGABLE keys and commits the full order. */\n  reorder: (nextDraggable: string[]) => void;\n}\n\nexport function useColumnOrder<T>({\n  columns,\n  columnOrder,\n  defaultColumnOrder,\n  onColumnOrderChange,\n  storage,\n}: UseColumnOrderOptions<T>): UseColumnOrderResult<T> {\n  // Seeded once, like `ownColumnWidths`: a controlled `columnOrder` belongs to\n  // the page, so restoring over it would fight the page's own source of truth.\n  const [storedOrder] = useState(() =>\n    columnOrder === undefined && storage.has('columnOrder')\n      ? storage.initial.columnOrder\n      : undefined,\n  );\n\n  // An empty array means \"no order\", which `applyColumnOrder` treats as a\n  // no-op — same shape `useTableSorts` uses for its own empty default, and it\n  // keeps `useControlledState` off the `undefined` overload.\n  const [order, setOrder] = useControlledState<string[]>(\n    columnOrder as string[],\n    defaultColumnOrder ?? storedOrder ?? EMPTY_ORDER,\n    onColumnOrderChange as (value: string[]) => void,\n  );\n\n  const ordered = useMemo(\n    () => applyColumnOrder(columns, order),\n    [columns, order],\n  );\n\n  // Always the FULL source key list, in current order — so a key never drops out\n  // of persisted state just because its column happened to be hidden.\n  const fullOrder = useMemo(\n    () => ordered.map((column) => column.key),\n    [ordered],\n  );\n\n  const reorder = useEvent((nextDraggable: string[]) => {\n    const next = projectReorder(fullOrder, nextDraggable);\n\n    setOrder(next);\n\n    // Only what the table OWNS is persisted — a controlled order belongs to the\n    // page, and storing it would fight the page on the next mount. Same rule\n    // `handleColumnResizeEnd` follows for widths.\n    if (columnOrder === undefined) storage.write({ columnOrder: next });\n  });\n\n  return { columns: ordered, order: fullOrder, reorder };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgBO,iBACdC,SACAE,OACsB;AACtB,KAAI,CAACA,OAAOC,OAAQ,QAAOH;CAE3B,MAAMI,UAAU,IAAIC,IAAIL,QAAQM,KAAKC,WAAWA,OAAOC,IAAI,CAAC;CAC5D,MAAMC,uBAAO,IAAIC,KAAqB;AAEtCR,OAAMS,SAASH,KAAKI,UAAU;AAG5B,MAAIR,QAAQS,IAAIL,IAAI,IAAI,CAACC,KAAKI,IAAIL,IAAI,CAAEC,MAAKK,IAAIN,KAAKI,MAAM;GAC5D;AAEF,KAAI,CAACH,KAAKM,KAAM,QAAOf;CAEvB,IAAIgB,UAAU;AAEd,QAAOhB,QACJM,KAAKC,QAAQU,gBAAgB;EAC5B,MAAMC,MAAMT,KAAKU,IAAIZ,OAAOC,IAAI;AAEhC,MAAIU,OAAO,KAAMF,WAAUE;AAE3B,SAAO;GAAEX;GAAQU;GAAaR,MAAMS,OAAOF,UAAU;GAAK;GAC1D,CACDI,MAAMC,GAAGC,MAAMD,EAAEZ,OAAOa,EAAEb,QAAQY,EAAEJ,cAAcK,EAAEL,YAAY,CAChEX,KAAKiB,UAAUA,MAAMhB,OAAO;;;;;;;;;;;;;;;;;;;AAoBjC,SAAgBiB,kBACdjB,QACAmB,WACS;AACT,QACEA,aACA,CAACnB,OAAOoB,gBACRpB,OAAOqB,OAAO,SACbrB,OAAOsB,iBAAiB;;AAI7B,SAAgBC,uBACd9B,SACA0B,WACU;AACV,QAAO1B,QACJ+B,QAAQxB,WAAWiB,kBAAkBjB,QAAQmB,UAAU,CAAC,CACxDpB,KAAKC,WAAWA,OAAOC,IAAI;;;;;;;;;;;;;AAchC,SAAgBwB,eACdC,WACAC,eACU;CACV,MAAMC,YAAY,IAAI9B,IAAI6B,cAAc;CACxC,MAAME,OAAO,CAAC,GAAGH,UAAU;CAC3B,IAAII,SAAS;AAEb,MAAK,IAAIC,OAAO,GAAGA,OAAOF,KAAKjC,QAAQmC,OACrC,KAAIH,UAAUtB,IAAIuB,KAAKE,MAAM,CAAEF,MAAKE,QAAQJ,cAAcG;AAG5D,QAAOD;;AAGT,MAAMG,cAAwB,EAAE;AAmBhC,SAAOS,eAAAC,IAAA;CAAA,MAAAC,IAAAC,EAAA,GAAA;CAA2B,MAAA,EAAAnD,SAAAyC,aAAAC,oBAAAC,qBAAAC,YAAAK;CAMP,IAAAG;AAAA,KAAAF,EAAA,OAAAT,eAAAS,EAAA,OAAAN,SAAA;AAGMQ,aAC7BX,gBAAgBY,UAAaT,QAAO/B,IAAK,cAE5B,GADT+B,QAAOU,QAAQb,cADnBY;AAEaH,IAAA,KAAAT;AAAAS,IAAA,KAAAN;AAAAM,IAAA,KAAAE;OAAAA,MAAAF,EAAA;CAHf,MAAA,CAAAK,eAAsB7D,SAAS0D,GAI9B;CAKD,MAAA,CAAAlD,OAAAsD,YAA0BhE,mBACxBiD,aACAC,sBAAAa,eAAAhB,aACAI,oBACD;CAAC,IAAAe;AAAA,KAAAR,EAAA,OAAAlD,WAAAkD,EAAA,OAAAhD,OAAA;AAGMwD,OAAA3D,iBAAiBC,SAASE,MAAM;AAAAgD,IAAA,KAAAlD;AAAAkD,IAAA,KAAAhD;AAAAgD,IAAA,KAAAQ;OAAAA,MAAAR,EAAA;CADxC,MAAAS,UACQD;CAEN,IAAAE;AAAA,KAAAV,EAAA,OAAAS,SAAA;AAKMC,OAAAD,QAAOrD,IAAKuD,MAAuB;AAAAX,IAAA,KAAAS;AAAAT,IAAA,KAAAU;OAAAA,MAAAV,EAAA;CAD3C,MAAAjB,YACQ2B;CAEN,IAAAE;AAAA,KAAAZ,EAAA,OAAAT,eAAAS,EAAA,OAAAjB,aAAAiB,EAAA,QAAAM,YAAAN,EAAA,QAAAN,SAAA;AAEuBkB,QAAA5B,kBAAA;GACvB,MAAAE,OAAaJ,eAAeC,WAAWC,cAAc;AAErDsB,YAASpB,KAAK;AAKd,OAAIK,gBAAgBY,OAAWT,SAAOmB,MAAO,EAAAtB,aAAeL,MAAM,CAAC;;AACpEc,IAAA,KAAAT;AAAAS,IAAA,KAAAjB;AAAAiB,IAAA,MAAAM;AAAAN,IAAA,MAAAN;AAAAM,IAAA,MAAAY;OAAAA,MAAAZ,EAAA;CATD,MAAAH,UAAgBpD,SAASmE,GASvB;CAAC,IAAAE;AAAA,KAAAd,EAAA,QAAAjB,aAAAiB,EAAA,QAAAS,WAAAT,EAAA,QAAAH,SAAA;AAEIiB,OAAA;GAAAhE,SAAW2D;GAAOzD,OAAS+B;GAASc;GAAW;AAAAG,IAAA,MAAAjB;AAAAiB,IAAA,MAAAS;AAAAT,IAAA,MAAAH;AAAAG,IAAA,MAAAc;OAAAA,MAAAd,EAAA;AAAA,QAA/Cc;;AA/CF,SAAAH,MAAAtD,QAAA;AAAA,QAgC2BA,OAAMC"}

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

@@ -1,4 +1,5 @@
-/** @license MIT | @cube-dev/ui-kit v0.182.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.183.0 | Cube Dev Team */
+import { c } from "react-compiler-runtime";
 import { useLayoutEffect, useState } from "react";
 
 //#region src/components/data/TableBase/use-container-width.ts
@@ -16,17 +17,30 @@ import { useLayoutEffect, useState } from "react";
 * min-width columns before they snap to their real size.
 */
 function useContainerWidth(element) {
+	const $ = c(3);
 	const [width, setWidth] = useState(null);
-	useLayoutEffect(() => {
-		if (!element || !(element instanceof Element)) return;
-		const measure = () => {
-			setWidth((current) => current === element.clientWidth ? current : element.clientWidth);
+	let t0;
+	let t1;
+	if ($[0] !== element) {
+		t0 = () => {
+			if (!element || !(element instanceof Element)) return;
+			const measure = () => {
+				setWidth((current) => current === element.clientWidth ? current : element.clientWidth);
+			};
+			measure();
+			const observer = new ResizeObserver(measure);
+			observer.observe(element);
+			return () => observer.disconnect();
 		};
-		measure();
-		const observer = new ResizeObserver(measure);
-		observer.observe(element);
-		return () => observer.disconnect();
-	}, [element]);
+		t1 = [element];
+		$[0] = element;
+		$[1] = t0;
+		$[2] = t1;
+	} else {
+		t0 = $[1];
+		t1 = $[2];
+	}
+	useLayoutEffect(t0, t1);
 	return width;
 }
 

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

@@ -1 +1 @@
-{"version":3,"file":"use-container-width.js","names":[],"sources":["../../../../src/components/data/TableBase/use-container-width.ts"],"sourcesContent":["import { useLayoutEffect, useState } from 'react';\n\n/**\n * Content-box width of the scroller, measured before paint and kept current\n * with a `ResizeObserver`.\n *\n * Takes the **element**, not a ref: in the virtualized path the scroller is\n * created by Virtuoso and handed over through a callback after mount, so a hook\n * that peeked at `ref.current` once would see `null` and never measure\n * anything — leaving every column unsized.\n *\n * `useLayoutEffect` rather than `useEffect` on purpose: column widths are\n * derived from this value, so measuring after paint would show one frame of\n * min-width columns before they snap to their real size.\n */\nexport function useContainerWidth(element: HTMLElement | null): number | null {\n  const [width, setWidth] = useState<number | null>(null);\n\n  useLayoutEffect(() => {\n    // Virtuoso's `scrollerRef` reports `HTMLElement | Window | null`, and\n    // `ResizeObserver.observe` throws on anything that is not an Element.\n    if (!element || !(element instanceof Element)) return;\n\n    const measure = () => {\n      // `clientWidth` excludes the vertical scrollbar, which is what we want:\n      // the columns must fit the content box, not the border box, or a\n      // scrollbar appearing would push the last column out and bring a\n      // horizontal scrollbar with it.\n      setWidth((current) =>\n        current === element.clientWidth ? current : element.clientWidth,\n      );\n    };\n\n    measure();\n\n    const observer = new ResizeObserver(measure);\n\n    observer.observe(element);\n\n    return () => observer.disconnect();\n  }, [element]);\n\n  return width;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAeA,SAAgB,kBAAkB,SAA4C;CAC5E,MAAM,CAAC,OAAO,YAAY,SAAwB,KAAK;AAEvD,uBAAsB;AAGpB,MAAI,CAAC,WAAW,EAAE,mBAAmB,SAAU;EAE/C,MAAM,gBAAgB;AAKpB,aAAU,YACR,YAAY,QAAQ,cAAc,UAAU,QAAQ,YACrD;;AAGH,WAAS;EAET,MAAM,WAAW,IAAI,eAAe,QAAQ;AAE5C,WAAS,QAAQ,QAAQ;AAEzB,eAAa,SAAS,YAAY;IACjC,CAAC,QAAQ,CAAC;AAEb,QAAO"}
+{"version":3,"file":"use-container-width.js","names":["useLayoutEffect","useState","useContainerWidth","element","$","_c","width","setWidth","t0","t1","Element","measure","current","clientWidth","observer","ResizeObserver","observe","disconnect"],"sources":["../../../../src/components/data/TableBase/use-container-width.ts"],"sourcesContent":["import { useLayoutEffect, useState } from 'react';\n\n/**\n * Content-box width of the scroller, measured before paint and kept current\n * with a `ResizeObserver`.\n *\n * Takes the **element**, not a ref: in the virtualized path the scroller is\n * created by Virtuoso and handed over through a callback after mount, so a hook\n * that peeked at `ref.current` once would see `null` and never measure\n * anything — leaving every column unsized.\n *\n * `useLayoutEffect` rather than `useEffect` on purpose: column widths are\n * derived from this value, so measuring after paint would show one frame of\n * min-width columns before they snap to their real size.\n */\nexport function useContainerWidth(element: HTMLElement | null): number | null {\n  const [width, setWidth] = useState<number | null>(null);\n\n  useLayoutEffect(() => {\n    // Virtuoso's `scrollerRef` reports `HTMLElement | Window | null`, and\n    // `ResizeObserver.observe` throws on anything that is not an Element.\n    if (!element || !(element instanceof Element)) return;\n\n    const measure = () => {\n      // `clientWidth` excludes the vertical scrollbar, which is what we want:\n      // the columns must fit the content box, not the border box, or a\n      // scrollbar appearing would push the last column out and bring a\n      // horizontal scrollbar with it.\n      setWidth((current) =>\n        current === element.clientWidth ? current : element.clientWidth,\n      );\n    };\n\n    measure();\n\n    const observer = new ResizeObserver(measure);\n\n    observer.observe(element);\n\n    return () => observer.disconnect();\n  }, [element]);\n\n  return width;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAeA,SAAOE,kBAAAC,SAAA;CAAA,MAAAC,IAAAC,EAAA,EAAA;CACL,MAAA,CAAAC,OAAAC,YAA0BN,SAAwB,KAAK;CAAC,IAAAO;CAAA,IAAAC;AAAA,KAAAL,EAAA,OAAAD,SAAA;AAExCK,aAAA;AAGd,OAAI,CAACL,WAAD,EAAcA,mBAAmBO,SAAQ;GAE7C,MAAAC,gBAAgB;AAKdJ,cAASK,YACPA,YAAYT,QAAOU,cAAnBD,UAA4CT,QAAOU,YACpD;;AAGHF,YAAS;GAET,MAAAG,WAAiB,IAAIC,eAAeJ,QAAQ;AAE5CG,YAAQE,QAASb,QAAQ;AAAA,gBAEZW,SAAQG,YAAa;;AACjCR,OAAA,CAACN,QAAQ;AAAAC,IAAA,KAAAD;AAAAC,IAAA,KAAAI;AAAAJ,IAAA,KAAAK;QAAA;AAAAD,OAAAJ,EAAA;AAAAK,OAAAL,EAAA;;AAtBZJ,iBAAgBQ,IAsBbC,GAAU;AAAA,QAENH"}

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

@@ -1,4 +1,5 @@
-/** @license MIT | @cube-dev/ui-kit v0.182.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.183.0 | Cube Dev Team */
+import { c } from "react-compiler-runtime";
 import { useLayoutEffect, useRef } from "react";
 
 //#region src/components/data/TableBase/use-row-move-animation.ts
@@ -32,57 +33,75 @@ function prefersReducedMotion() {
 * rather than viewport coordinates: it is relative to the scroller's content,
 * so it does not change as the content scrolls past.
 */
-function useRowMoveAnimation({ isEnabled, bodyRef, duration = ROW_MOVE_DURATION }) {
+function useRowMoveAnimation(t0) {
+	const $ = c(5);
+	const { isEnabled, bodyRef, duration: t1 } = t0;
+	const duration = t1 === void 0 ? ROW_MOVE_DURATION : t1;
 	const previousRef = useRef(null);
-	const previousOrderRef = useRef([]);
-	useLayoutEffect(() => {
-		const body = bodyRef.current;
-		if (!body) return;
-		const rows = Array.from(body.querySelectorAll("tr[data-element=\"Row\"][data-key]:not([data-pinned])"));
-		const next = /* @__PURE__ */ new Map();
-		for (const row of rows) next.set(row.dataset.key, row.offsetTop);
-		const previous = previousRef.current;
-		const previousOrder = previousOrderRef.current;
-		const nextOrder = rows.map((row) => row.dataset.key);
-		previousRef.current = next;
-		previousOrderRef.current = nextOrder;
-		if (!isEnabled || prefersReducedMotion() || !previous) return;
-		const stillHere = new Set(nextOrder);
-		const before = previousOrder.filter((key) => stillHere.has(key));
-		const after = nextOrder.filter((key) => previous.has(key));
-		if (!(before.length !== after.length || before.some((key, index) => key !== after[index]))) return;
-		const moved = [];
-		for (const row of rows) {
-			const from = previous.get(row.dataset.key);
-			if (from === void 0) continue;
-			const delta = from - next.get(row.dataset.key);
-			if (delta !== 0) moved.push({
-				row,
-				delta
-			});
-		}
-		if (!moved.length) return;
-		for (const { row, delta } of moved) {
-			row.style.transition = "none";
-			row.style.transform = `translateY(${delta}px)`;
-		}
-		body.offsetHeight;
-		for (const { row } of moved) {
-			row.style.transition = `transform ${duration}ms ease-out`;
-			row.style.transform = "";
-		}
-		const clear = () => {
-			for (const { row } of moved) {
-				row.style.transition = "";
-				row.style.transform = "";
+	let t2;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t2 = [];
+		$[0] = t2;
+	} else t2 = $[0];
+	const previousOrderRef = useRef(t2);
+	let t3;
+	if ($[1] !== bodyRef || $[2] !== duration || $[3] !== isEnabled) {
+		t3 = () => {
+			const body = bodyRef.current;
+			if (!body) return;
+			const rows = Array.from(body.querySelectorAll("tr[data-element=\"Row\"][data-key]:not([data-pinned])"));
+			const next = /* @__PURE__ */ new Map();
+			for (const row of rows) next.set(row.dataset.key, row.offsetTop);
+			const previous = previousRef.current;
+			const previousOrder = previousOrderRef.current;
+			const nextOrder = rows.map(_temp);
+			previousRef.current = next;
+			previousOrderRef.current = nextOrder;
+			if (!isEnabled || prefersReducedMotion() || !previous) return;
+			const stillHere = new Set(nextOrder);
+			const before = previousOrder.filter((key) => stillHere.has(key));
+			const after = nextOrder.filter((key_0) => previous.has(key_0));
+			if (!(before.length !== after.length || before.some((key_1, index) => key_1 !== after[index]))) return;
+			const moved = [];
+			for (const row_1 of rows) {
+				const from = previous.get(row_1.dataset.key);
+				if (from === void 0) continue;
+				const delta = from - next.get(row_1.dataset.key);
+				if (delta !== 0) moved.push({
+					row: row_1,
+					delta
+				});
 			}
+			if (!moved.length) return;
+			for (const { row: row_2, delta: delta_0 } of moved) {
+				row_2.style.transition = "none";
+				row_2.style.transform = `translateY(${delta_0}px)`;
+			}
+			for (const { row: row_3 } of moved) {
+				row_3.style.transition = `transform ${duration}ms ease-out`;
+				row_3.style.transform = "";
+			}
+			const clear = () => {
+				for (const { row: row_4 } of moved) {
+					row_4.style.transition = "";
+					row_4.style.transform = "";
+				}
+			};
+			const timer = setTimeout(clear, duration);
+			return () => {
+				clearTimeout(timer);
+				clear();
+			};
 		};
-		const timer = setTimeout(clear, duration);
-		return () => {
-			clearTimeout(timer);
-			clear();
-		};
-	});
+		$[1] = bodyRef;
+		$[2] = duration;
+		$[3] = isEnabled;
+		$[4] = t3;
+	} else t3 = $[4];
+	useLayoutEffect(t3);
+}
+function _temp(row_0) {
+	return row_0.dataset.key;
 }
 
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"use-row-move-animation.js","names":[],"sources":["../../../../src/components/data/TableBase/use-row-move-animation.ts"],"sourcesContent":["import { useLayoutEffect, useRef } from 'react';\n\nimport type { RefObject } from 'react';\n\n/** Matches ag-grid's row animation closely enough to feel familiar. */\nexport const ROW_MOVE_DURATION = 120;\n\nexport interface UseRowMoveAnimationOptions {\n  isEnabled: boolean;\n  /** The `<tbody>` the rows live in. */\n  bodyRef: RefObject<HTMLTableSectionElement | null>;\n  /** @default 120 */\n  duration?: number;\n}\n\n/** Matches `DisplayTransition`'s check, which is the kit's existing precedent. */\nfunction prefersReducedMotion() {\n  return (\n    typeof window !== 'undefined' &&\n    Boolean(window.matchMedia?.('(prefers-reduced-motion: reduce)')?.matches)\n  );\n}\n\n/**\n * Slides rows to their new positions when the order changes.\n *\n * FLIP: the previous commit's positions are the First, this commit's are the\n * Last, and each row is Inverted with a `translateY` back to where it was and\n * then Played to zero. The DOM is already correct the whole time — only the\n * paint is behind — so a test or a screen reader sees the new order\n * immediately, and nothing has to be delayed or double-rendered.\n *\n * Sorting a table otherwise teleports every row at once, and the eye has no way\n * to follow a particular one to where it went. The whole value is in tracking\n * one row, which is why this animates positions rather than cross-fading.\n *\n * **Only a reorder**, and only rows that were already on screen. If the rows\n * common to both commits are in the same relative order, nothing animates,\n * however much their positions moved — that is a relayout, not a reorder, and\n * it covers the initial mount (widths resolving, the virtualizer measuring, a\n * scrollbar appearing), a container resize, and a filter that only removes\n * rows.\n *\n * Scrolling is not movement either, and that falls out of measuring `offsetTop`\n * rather than viewport coordinates: it is relative to the scroller's content,\n * so it does not change as the content scrolls past.\n */\nexport function useRowMoveAnimation({\n  isEnabled,\n  bodyRef,\n  duration = ROW_MOVE_DURATION,\n}: UseRowMoveAnimationOptions) {\n  const previousRef = useRef<Map<string, number> | null>(null);\n  const previousOrderRef = useRef<string[]>([]);\n\n  // No dependency array: the previous positions have to be captured after every\n  // commit, because any of them may turn out to be the one a reorder starts\n  // from.\n  useLayoutEffect(() => {\n    const body = bodyRef.current;\n\n    if (!body) return;\n\n    const rows = Array.from(\n      body.querySelectorAll<HTMLTableRowElement>(\n        // Pinned rows are excluded by the selector rather than filtered later:\n        // they do not take part in the order, so they never move.\n        'tr[data-element=\"Row\"][data-key]:not([data-pinned])',\n      ),\n    );\n\n    // `offsetTop`, not `getBoundingClientRect()`: it is relative to the\n    // scroller, so scrolling does not read as movement. Otherwise every scroll\n    // tick would look like a reorder of the whole page.\n    const next = new Map<string, number>();\n\n    for (const row of rows) next.set(row.dataset.key!, row.offsetTop);\n\n    const previous = previousRef.current;\n    const previousOrder = previousOrderRef.current;\n    const nextOrder = rows.map((row) => row.dataset.key!);\n\n    previousRef.current = next;\n    previousOrderRef.current = nextOrder;\n\n    // Checked per commit rather than once: the setting can change mid-session,\n    // and the position bookkeeping above must keep running either way so the\n    // animation is correct the moment it is turned back on.\n    if (!isEnabled || prefersReducedMotion() || !previous) return;\n\n    // Animate a REORDER, never a relayout.\n    //\n    // Positions shift for all sorts of reasons that are not a row moving: the\n    // column widths resolving after the first measure, the virtualizer taking\n    // its measurements, a scrollbar appearing, a font landing, the container\n    // being resized. Every one of those happens on the second commit of a\n    // normal mount — so keying off \"an offset changed\" animated the table into\n    // existence on load, which is exactly what a load should not do.\n    //\n    // Comparing the order of the rows common to both commits answers the real\n    // question. A relayout leaves it identical; a sort does not.\n    const stillHere = new Set(nextOrder);\n    const before = previousOrder.filter((key) => stillHere.has(key));\n    const after = nextOrder.filter((key) => previous.has(key));\n    const isReorder =\n      before.length !== after.length ||\n      before.some((key, index) => key !== after[index]);\n\n    if (!isReorder) return;\n\n    const moved: { row: HTMLTableRowElement; delta: number }[] = [];\n\n    for (const row of rows) {\n      const from = previous.get(row.dataset.key!);\n\n      // A row that was not here before has nowhere to come from. Skipped rather\n      // than bailing on the whole batch: a virtualized window swaps some of its\n      // rows on every re-sort, and refusing to animate unless ALL of them are\n      // familiar means a virtualized grid — most result grids — never animates\n      // at all.\n      if (from === undefined) continue;\n\n      const delta = from - next.get(row.dataset.key!)!;\n\n      if (delta !== 0) moved.push({ row, delta });\n    }\n\n    if (!moved.length) return;\n\n    // Invert: put every moved row back where it was, with transitions off so\n    // this jump is not itself animated.\n    for (const { row, delta } of moved) {\n      row.style.transition = 'none';\n      row.style.transform = `translateY(${delta}px)`;\n    }\n\n    // Flush the inverted state into layout, so the browser has something to\n    // animate FROM. A forced reflow rather than `requestAnimationFrame`,\n    // deliberately: rAF does not fire in a hidden tab, and a sort that lands\n    // while the tab is in the background would leave every row frozen at its\n    // old position until the next reorder. One reflow, once per animation.\n    void body.offsetHeight;\n\n    // Play.\n    for (const { row } of moved) {\n      row.style.transition = `transform ${duration}ms ease-out`;\n      row.style.transform = '';\n    }\n\n    // Clear on arrival. A `transition` left inline would go on to animate\n    // transforms this hook never set — a dragged row, for one.\n    //\n    // A timer rather than `transitionend`, for the same reason the invert does\n    // not use `requestAnimationFrame`: in a hidden tab the transition never\n    // runs, so the event never fires and every animated row keeps its inline\n    // `transition` for the rest of the session. The duration is known exactly,\n    // so there is nothing to wait to be told.\n    const clear = () => {\n      for (const { row } of moved) {\n        row.style.transition = '';\n        row.style.transform = '';\n      }\n    };\n    const timer = setTimeout(clear, duration);\n\n    return () => {\n      // A reorder landing mid-animation starts over from wherever the rows are,\n      // so nothing may be left behind.\n      clearTimeout(timer);\n      clear();\n    };\n  });\n}\n"],"mappings":";;;;;AAKA,MAAa,oBAAoB;;AAWjC,SAAS,uBAAuB;AAC9B,QACE,OAAO,WAAW,eAClB,QAAQ,OAAO,aAAa,mCAAmC,EAAE,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;AA4B7E,SAAgB,oBAAoB,EAClC,WACA,SACA,WAAW,qBACkB;CAC7B,MAAM,cAAc,OAAmC,KAAK;CAC5D,MAAM,mBAAmB,OAAiB,EAAE,CAAC;AAK7C,uBAAsB;EACpB,MAAM,OAAO,QAAQ;AAErB,MAAI,CAAC,KAAM;EAEX,MAAM,OAAO,MAAM,KACjB,KAAK,iBAGH,wDACD,CACF;EAKD,MAAM,uBAAO,IAAI,KAAqB;AAEtC,OAAK,MAAM,OAAO,KAAM,MAAK,IAAI,IAAI,QAAQ,KAAM,IAAI,UAAU;EAEjE,MAAM,WAAW,YAAY;EAC7B,MAAM,gBAAgB,iBAAiB;EACvC,MAAM,YAAY,KAAK,KAAK,QAAQ,IAAI,QAAQ,IAAK;AAErD,cAAY,UAAU;AACtB,mBAAiB,UAAU;AAK3B,MAAI,CAAC,aAAa,sBAAsB,IAAI,CAAC,SAAU;EAavD,MAAM,YAAY,IAAI,IAAI,UAAU;EACpC,MAAM,SAAS,cAAc,QAAQ,QAAQ,UAAU,IAAI,IAAI,CAAC;EAChE,MAAM,QAAQ,UAAU,QAAQ,QAAQ,SAAS,IAAI,IAAI,CAAC;AAK1D,MAAI,EAHF,OAAO,WAAW,MAAM,UACxB,OAAO,MAAM,KAAK,UAAU,QAAQ,MAAM,OAAO,EAEnC;EAEhB,MAAM,QAAuD,EAAE;AAE/D,OAAK,MAAM,OAAO,MAAM;GACtB,MAAM,OAAO,SAAS,IAAI,IAAI,QAAQ,IAAK;AAO3C,OAAI,SAAS,OAAW;GAExB,MAAM,QAAQ,OAAO,KAAK,IAAI,IAAI,QAAQ,IAAK;AAE/C,OAAI,UAAU,EAAG,OAAM,KAAK;IAAE;IAAK;IAAO,CAAC;;AAG7C,MAAI,CAAC,MAAM,OAAQ;AAInB,OAAK,MAAM,EAAE,KAAK,WAAW,OAAO;AAClC,OAAI,MAAM,aAAa;AACvB,OAAI,MAAM,YAAY,cAAc,MAAM;;AAQ5C,EAAK,KAAK;AAGV,OAAK,MAAM,EAAE,SAAS,OAAO;AAC3B,OAAI,MAAM,aAAa,aAAa,SAAS;AAC7C,OAAI,MAAM,YAAY;;EAWxB,MAAM,cAAc;AAClB,QAAK,MAAM,EAAE,SAAS,OAAO;AAC3B,QAAI,MAAM,aAAa;AACvB,QAAI,MAAM,YAAY;;;EAG1B,MAAM,QAAQ,WAAW,OAAO,SAAS;AAEzC,eAAa;AAGX,gBAAa,MAAM;AACnB,UAAO;;GAET"}
+{"version":3,"file":"use-row-move-animation.js","names":["useLayoutEffect","useRef","RefObject","ROW_MOVE_DURATION","UseRowMoveAnimationOptions","isEnabled","bodyRef","HTMLTableSectionElement","duration","prefersReducedMotion","window","Boolean","matchMedia","matches","useRowMoveAnimation","t0","$","_c","t1","undefined","previousRef","t2","Symbol","for","previousOrderRef","t3","body","current","rows","Array","from","querySelectorAll","next","Map","row","set","dataset","key","offsetTop","previous","previousOrder","nextOrder","map","_temp","stillHere","Set","before","filter","has","after","key_0","isReorder","length","some","key_1","index","moved","row_1","get","delta","push","row_2","delta_0","style","transition","transform","row_3","clear","row_4","timer","setTimeout","clearTimeout","row_0"],"sources":["../../../../src/components/data/TableBase/use-row-move-animation.ts"],"sourcesContent":["import { useLayoutEffect, useRef } from 'react';\n\nimport type { RefObject } from 'react';\n\n/** Matches ag-grid's row animation closely enough to feel familiar. */\nexport const ROW_MOVE_DURATION = 120;\n\nexport interface UseRowMoveAnimationOptions {\n  isEnabled: boolean;\n  /** The `<tbody>` the rows live in. */\n  bodyRef: RefObject<HTMLTableSectionElement | null>;\n  /** @default 120 */\n  duration?: number;\n}\n\n/** Matches `DisplayTransition`'s check, which is the kit's existing precedent. */\nfunction prefersReducedMotion() {\n  return (\n    typeof window !== 'undefined' &&\n    Boolean(window.matchMedia?.('(prefers-reduced-motion: reduce)')?.matches)\n  );\n}\n\n/**\n * Slides rows to their new positions when the order changes.\n *\n * FLIP: the previous commit's positions are the First, this commit's are the\n * Last, and each row is Inverted with a `translateY` back to where it was and\n * then Played to zero. The DOM is already correct the whole time — only the\n * paint is behind — so a test or a screen reader sees the new order\n * immediately, and nothing has to be delayed or double-rendered.\n *\n * Sorting a table otherwise teleports every row at once, and the eye has no way\n * to follow a particular one to where it went. The whole value is in tracking\n * one row, which is why this animates positions rather than cross-fading.\n *\n * **Only a reorder**, and only rows that were already on screen. If the rows\n * common to both commits are in the same relative order, nothing animates,\n * however much their positions moved — that is a relayout, not a reorder, and\n * it covers the initial mount (widths resolving, the virtualizer measuring, a\n * scrollbar appearing), a container resize, and a filter that only removes\n * rows.\n *\n * Scrolling is not movement either, and that falls out of measuring `offsetTop`\n * rather than viewport coordinates: it is relative to the scroller's content,\n * so it does not change as the content scrolls past.\n */\nexport function useRowMoveAnimation({\n  isEnabled,\n  bodyRef,\n  duration = ROW_MOVE_DURATION,\n}: UseRowMoveAnimationOptions) {\n  const previousRef = useRef<Map<string, number> | null>(null);\n  const previousOrderRef = useRef<string[]>([]);\n\n  // No dependency array: the previous positions have to be captured after every\n  // commit, because any of them may turn out to be the one a reorder starts\n  // from.\n  useLayoutEffect(() => {\n    const body = bodyRef.current;\n\n    if (!body) return;\n\n    const rows = Array.from(\n      body.querySelectorAll<HTMLTableRowElement>(\n        // Pinned rows are excluded by the selector rather than filtered later:\n        // they do not take part in the order, so they never move.\n        'tr[data-element=\"Row\"][data-key]:not([data-pinned])',\n      ),\n    );\n\n    // `offsetTop`, not `getBoundingClientRect()`: it is relative to the\n    // scroller, so scrolling does not read as movement. Otherwise every scroll\n    // tick would look like a reorder of the whole page.\n    const next = new Map<string, number>();\n\n    for (const row of rows) next.set(row.dataset.key!, row.offsetTop);\n\n    const previous = previousRef.current;\n    const previousOrder = previousOrderRef.current;\n    const nextOrder = rows.map((row) => row.dataset.key!);\n\n    previousRef.current = next;\n    previousOrderRef.current = nextOrder;\n\n    // Checked per commit rather than once: the setting can change mid-session,\n    // and the position bookkeeping above must keep running either way so the\n    // animation is correct the moment it is turned back on.\n    if (!isEnabled || prefersReducedMotion() || !previous) return;\n\n    // Animate a REORDER, never a relayout.\n    //\n    // Positions shift for all sorts of reasons that are not a row moving: the\n    // column widths resolving after the first measure, the virtualizer taking\n    // its measurements, a scrollbar appearing, a font landing, the container\n    // being resized. Every one of those happens on the second commit of a\n    // normal mount — so keying off \"an offset changed\" animated the table into\n    // existence on load, which is exactly what a load should not do.\n    //\n    // Comparing the order of the rows common to both commits answers the real\n    // question. A relayout leaves it identical; a sort does not.\n    const stillHere = new Set(nextOrder);\n    const before = previousOrder.filter((key) => stillHere.has(key));\n    const after = nextOrder.filter((key) => previous.has(key));\n    const isReorder =\n      before.length !== after.length ||\n      before.some((key, index) => key !== after[index]);\n\n    if (!isReorder) return;\n\n    const moved: { row: HTMLTableRowElement; delta: number }[] = [];\n\n    for (const row of rows) {\n      const from = previous.get(row.dataset.key!);\n\n      // A row that was not here before has nowhere to come from. Skipped rather\n      // than bailing on the whole batch: a virtualized window swaps some of its\n      // rows on every re-sort, and refusing to animate unless ALL of them are\n      // familiar means a virtualized grid — most result grids — never animates\n      // at all.\n      if (from === undefined) continue;\n\n      const delta = from - next.get(row.dataset.key!)!;\n\n      if (delta !== 0) moved.push({ row, delta });\n    }\n\n    if (!moved.length) return;\n\n    // Invert: put every moved row back where it was, with transitions off so\n    // this jump is not itself animated.\n    for (const { row, delta } of moved) {\n      row.style.transition = 'none';\n      row.style.transform = `translateY(${delta}px)`;\n    }\n\n    // Flush the inverted state into layout, so the browser has something to\n    // animate FROM. A forced reflow rather than `requestAnimationFrame`,\n    // deliberately: rAF does not fire in a hidden tab, and a sort that lands\n    // while the tab is in the background would leave every row frozen at its\n    // old position until the next reorder. One reflow, once per animation.\n    void body.offsetHeight;\n\n    // Play.\n    for (const { row } of moved) {\n      row.style.transition = `transform ${duration}ms ease-out`;\n      row.style.transform = '';\n    }\n\n    // Clear on arrival. A `transition` left inline would go on to animate\n    // transforms this hook never set — a dragged row, for one.\n    //\n    // A timer rather than `transitionend`, for the same reason the invert does\n    // not use `requestAnimationFrame`: in a hidden tab the transition never\n    // runs, so the event never fires and every animated row keeps its inline\n    // `transition` for the rest of the session. The duration is known exactly,\n    // so there is nothing to wait to be told.\n    const clear = () => {\n      for (const { row } of moved) {\n        row.style.transition = '';\n        row.style.transform = '';\n      }\n    };\n    const timer = setTimeout(clear, duration);\n\n    return () => {\n      // A reorder landing mid-animation starts over from wherever the rows are,\n      // so nothing may be left behind.\n      clearTimeout(timer);\n      clear();\n    };\n  });\n}\n"],"mappings":";;;;;;AAKA,MAAaG,oBAAoB;;AAWjC,SAASM,uBAAuB;AAC9B,QACE,OAAOC,WAAW,eAClBC,QAAQD,OAAOE,aAAa,mCAAmC,EAAEC,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;AA4B7E,SAAOC,oBAAAC,IAAA;CAAA,MAAAC,IAAAC,EAAA,EAAA;CAA6B,MAAA,EAAAZ,WAAAC,SAAAE,UAAAU,OAAAH;CAGlC,MAAAP,WAAAU,OAAAC,SAAAhB,oBAAAe;CAEA,MAAAE,cAAoBnB,OAAmC,KAAK;CAAC,IAAAoB;AAAA,KAAAL,EAAA,OAAAM,OAAAC,IAAA,4BAAA,EAAA;AACnBF,OAAA,EAAE;AAAAL,IAAA,KAAAK;OAAAA,MAAAL,EAAA;CAA5C,MAAAQ,mBAAyBvB,OAAiBoB,GAAG;CAAC,IAAAI;AAAA,KAAAT,EAAA,OAAAV,WAAAU,EAAA,OAAAR,YAAAQ,EAAA,OAAAX,WAAA;AAK9BoB,aAAA;GACd,MAAAC,OAAapB,QAAOqB;AAEpB,OAAI,CAACD,KAAI;GAET,MAAAE,OAAaC,MAAKC,KAChBJ,KAAIK,iBAGF,wDAEJ,CAAC;GAKD,MAAAC,uBAAa,IAAIC,KAAqB;AAEtC,QAAK,MAAAC,OAAaN,KAAMI,MAAIG,IAAKD,IAAGE,QAAQC,KAAOH,IAAGI,UAAW;GAEjE,MAAAC,WAAiBnB,YAAWO;GAC5B,MAAAa,gBAAsBhB,iBAAgBG;GACtC,MAAAc,YAAkBb,KAAIc,IAAKC,MAA0B;AAErDvB,eAAWO,UAAWK;AACtBR,oBAAgBG,UAAWc;AAK3B,OAAI,CAACpC,aAAaI,sBAAmC,IAAjD,CAAyC8B,SAAQ;GAarD,MAAAK,YAAkB,IAAIC,IAAIJ,UAAU;GACpC,MAAAK,SAAeN,cAAaO,QAAQV,QAASO,UAASI,IAAKX,IAAI,CAAC;GAChE,MAAAY,QAAcR,UAASM,QAAQG,UAASX,SAAQS,IAAKX,MAAI,CAAC;AAK1D,OAAI,EAHFS,OAAMM,WAAYH,MAAKG,UACvBN,OAAMO,MAAMC,OAAAC,UAAgBlB,UAAQY,MAAMM,OAAO,EAErC;GAEd,MAAAC,QAA6D,EAAE;AAE/D,QAAK,MAAAC,SAAa7B,MAAI;IACpB,MAAAE,OAAaS,SAAQmB,IAAKxB,MAAGE,QAAQC,IAAM;AAO3C,QAAIP,SAASX,OAAW;IAExB,MAAAwC,QAAc7B,OAAOE,KAAI0B,IAAKxB,MAAGE,QAAQC,IAAO;AAEhD,QAAIsB,UAAU,EAAGH,OAAKI,KAAM;KAAA1B,KAAEA;KAAGyB;KAAS,CAAC;;AAG7C,OAAI,CAACH,MAAKJ,OAAO;AAIjB,QAAK,MAAA,EAAAlB,KAAA2B,OAAAF,OAAAG,aAAwBN,OAAK;AAChCtB,UAAG6B,MAAMC,aAAc;AACvB9B,UAAG6B,MAAME,YAAa,cAAcN,QAAK;;AAW3C,QAAK,MAAA,EAAAzB,KAAAgC,WAAiBV,OAAK;AACzBtB,UAAG6B,MAAMC,aAAc,aAAaxD,SAAQ;AAC5C0B,UAAG6B,MAAME,YAAa;;GAWxB,MAAAE,cAAc;AACZ,SAAK,MAAA,EAAAjC,KAAAkC,WAAiBZ,OAAK;AACzBtB,WAAG6B,MAAMC,aAAc;AACvB9B,WAAG6B,MAAME,YAAa;;;GAG1B,MAAAI,QAAcC,WAAWH,OAAO3D,SAAS;AAAC,gBAEnC;AAGL+D,iBAAaF,MAAM;AACnBF,WAAO;;;AAEVnD,IAAA,KAAAV;AAAAU,IAAA,KAAAR;AAAAQ,IAAA,KAAAX;AAAAW,IAAA,KAAAS;OAAAA,MAAAT,EAAA;AAjHDhB,iBAAgByB,GAiHd;;AA5HG,SAAAkB,MAAA6B,OAAA;AAAA,QAiCiCtC,MAAGE,QAAQC"}

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

@@ -1,4 +1,5 @@
-/** @license MIT | @cube-dev/ui-kit v0.182.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.183.0 | Cube Dev Team */
+import { c } from "react-compiler-runtime";
 import { useLayoutEffect, useState } from "react";
 
 //#region src/components/data/TableBase/use-scrollability.ts
@@ -21,26 +22,39 @@ const NONE = {
 * grew past its container.
 */
 function useScrollability(element) {
+	const $ = c(3);
 	const [state, setState] = useState(NONE);
-	useLayoutEffect(() => {
-		if (!element || !(element instanceof Element)) {
-			setState(NONE);
-			return;
-		}
-		const measure = () => {
-			const next = {
-				x: element.scrollWidth - element.clientWidth > 1,
-				y: element.scrollHeight - element.clientHeight > 1
+	let t0;
+	let t1;
+	if ($[0] !== element) {
+		t0 = () => {
+			if (!element || !(element instanceof Element)) {
+				setState(NONE);
+				return;
+			}
+			const measure = () => {
+				const next = {
+					x: element.scrollWidth - element.clientWidth > 1,
+					y: element.scrollHeight - element.clientHeight > 1
+				};
+				setState((current) => current.x === next.x && current.y === next.y ? current : next);
 			};
-			setState((current) => current.x === next.x && current.y === next.y ? current : next);
+			measure();
+			const observer = new ResizeObserver(measure);
+			observer.observe(element);
+			const content = element.firstElementChild;
+			if (content) observer.observe(content);
+			return () => observer.disconnect();
 		};
-		measure();
-		const observer = new ResizeObserver(measure);
-		observer.observe(element);
-		const content = element.firstElementChild;
-		if (content) observer.observe(content);
-		return () => observer.disconnect();
-	}, [element]);
+		t1 = [element];
+		$[0] = element;
+		$[1] = t0;
+		$[2] = t1;
+	} else {
+		t0 = $[1];
+		t1 = $[2];
+	}
+	useLayoutEffect(t0, t1);
 	return state;
 }