@cube-dev/ui-kit 0.197.0 → 0.198.0

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

@@ -1 +1 @@
-{"version":3,"file":"table-tree.js","names":["Key","TableTreeNode","key","row","T","parentKey","level","siblingIndex","siblingCount","sourceIndex","children","TableTreeModel","roots","byKey","Map","parentOf","childrenOf","duplicateKeys","cyclicKeys","buildTableTree","rows","getChildren","getKey","visiting","Set","visitingRows","visit","input","output","forEach","currentSourceIndex","has","push","node","length","set","add","delete","map","child","sortTableTree","nodes","compare","a","b","sorted","sort","FilteredTableTree","forcedExpandedKeys","filterTableTree","matches","cloneComplete","reindexTableTree","filter","flattenTableTree","expandedKeys","ReadonlySet","items","tableTreeDescendantKeys","isTableTreeDescendant","model","Pick","possibleDescendant","ancestor","parent","get"],"sources":["../../../../src/components/data/TableBase/table-tree.ts"],"sourcesContent":["import type { Key } from '@react-types/shared';\n\nexport interface TableTreeNode<T> {\n  key: Key;\n  row: T;\n  parentKey: Key | null;\n  level: number;\n  siblingIndex: number;\n  siblingCount: number;\n  sourceIndex: number;\n  children: TableTreeNode<T>[];\n}\n\nexport interface TableTreeModel<T> {\n  roots: TableTreeNode<T>[];\n  byKey: Map<Key, TableTreeNode<T>>;\n  parentOf: Map<Key, Key | null>;\n  childrenOf: Map<Key, Key[]>;\n  duplicateKeys: Key[];\n  cyclicKeys: Key[];\n}\n\n/** Build identity and parent/child indexes without modifying consumer rows. */\nexport function buildTableTree<T>(\n  rows: readonly T[],\n  getChildren: (row: T) => readonly T[] | undefined,\n  getKey: (row: T, sourceIndex: number) => Key,\n): TableTreeModel<T> {\n  const byKey = new Map<Key, TableTreeNode<T>>();\n  const parentOf = new Map<Key, Key | null>();\n  const childrenOf = new Map<Key, Key[]>();\n  const duplicateKeys: Key[] = [];\n  const cyclicKeys: Key[] = [];\n  const visiting = new Set<Key>();\n  const visitingRows = new Set<T>();\n  let sourceIndex = 0;\n\n  const visit = (\n    input: readonly T[],\n    parentKey: Key | null,\n    level: number,\n  ): TableTreeNode<T>[] => {\n    const output: TableTreeNode<T>[] = [];\n\n    input.forEach((row, siblingIndex) => {\n      const currentSourceIndex = sourceIndex++;\n      const key = getKey(row, currentSourceIndex);\n\n      if (visiting.has(key) || visitingRows.has(row)) {\n        cyclicKeys.push(key);\n        return;\n      }\n\n      if (byKey.has(key)) {\n        duplicateKeys.push(key);\n        return;\n      }\n\n      const node: TableTreeNode<T> = {\n        key,\n        row,\n        parentKey,\n        level,\n        siblingIndex,\n        siblingCount: input.length,\n        sourceIndex: currentSourceIndex,\n        children: [],\n      };\n\n      byKey.set(key, node);\n      parentOf.set(key, parentKey);\n      visiting.add(key);\n      visitingRows.add(row);\n      node.children = visit(getChildren(row) ?? [], key, level + 1);\n      visiting.delete(key);\n      visitingRows.delete(row);\n      childrenOf.set(\n        key,\n        node.children.map((child) => child.key),\n      );\n      output.push(node);\n    });\n\n    return output;\n  };\n\n  const roots = visit(rows, null, 0);\n\n  return {\n    roots,\n    byKey,\n    parentOf,\n    childrenOf,\n    duplicateKeys,\n    cyclicKeys,\n  };\n}\n\nexport function sortTableTree<T>(\n  nodes: readonly TableTreeNode<T>[],\n  compare: (a: TableTreeNode<T>, b: TableTreeNode<T>) => number,\n): TableTreeNode<T>[] {\n  const sorted = nodes\n    .map((node) => ({\n      ...node,\n      children: sortTableTree(node.children, compare),\n    }))\n    .sort(compare);\n\n  return sorted.map((node, siblingIndex) => ({\n    ...node,\n    siblingIndex,\n    siblingCount: sorted.length,\n  }));\n}\n\nexport interface FilteredTableTree<T> {\n  roots: TableTreeNode<T>[];\n  forcedExpandedKeys: Set<Key>;\n}\n\n/**\n * Keep matching rows, their ancestor paths, and the complete subtree of a row\n * that matches itself. Every retained branch is opened while filtering so a\n * match can never remain hidden behind a collapsed ancestor.\n */\nexport function filterTableTree<T>(\n  nodes: readonly TableTreeNode<T>[],\n  matches: (node: TableTreeNode<T>) => boolean,\n): FilteredTableTree<T> {\n  const forcedExpandedKeys = new Set<Key>();\n\n  const cloneComplete = (node: TableTreeNode<T>): TableTreeNode<T> => {\n    const children = node.children.map(cloneComplete);\n    if (children.length) forcedExpandedKeys.add(node.key);\n\n    return { ...node, children: reindexTableTree(children) };\n  };\n\n  const visit = (node: TableTreeNode<T>): TableTreeNode<T> | null => {\n    if (matches(node)) return cloneComplete(node);\n\n    const children = node.children\n      .map(visit)\n      .filter((child): child is TableTreeNode<T> => child != null);\n\n    if (!children.length) return null;\n\n    forcedExpandedKeys.add(node.key);\n    return { ...node, children: reindexTableTree(children) };\n  };\n\n  return {\n    roots: reindexTableTree(\n      nodes.map(visit).filter((node): node is TableTreeNode<T> => node != null),\n    ),\n    forcedExpandedKeys,\n  };\n}\n\n/** Re-number a transformed sibling collection for its rendered treegrid. */\nexport function reindexTableTree<T>(\n  nodes: readonly TableTreeNode<T>[],\n): TableTreeNode<T>[] {\n  return nodes.map((node, siblingIndex) => ({\n    ...node,\n    siblingIndex,\n    siblingCount: nodes.length,\n    children: reindexTableTree(node.children),\n  }));\n}\n\nexport function flattenTableTree<T>(\n  nodes: readonly TableTreeNode<T>[],\n  expandedKeys?: ReadonlySet<Key>,\n): TableTreeNode<T>[] {\n  const output: TableTreeNode<T>[] = [];\n\n  const visit = (items: readonly TableTreeNode<T>[]) => {\n    for (const node of items) {\n      output.push(node);\n      if (expandedKeys == null || expandedKeys.has(node.key)) {\n        visit(node.children);\n      }\n    }\n  };\n\n  visit(nodes);\n  return output;\n}\n\nexport function tableTreeDescendantKeys<T>(node: TableTreeNode<T>): Key[] {\n  return flattenTableTree(node.children).map((child) => child.key);\n}\n\nexport function isTableTreeDescendant<T>(\n  model: Pick<TableTreeModel<T>, 'parentOf'>,\n  possibleDescendant: Key,\n  ancestor: Key,\n) {\n  let parent = model.parentOf.get(possibleDescendant);\n\n  while (parent != null) {\n    if (parent === ancestor) return true;\n    parent = model.parentOf.get(parent);\n  }\n\n  return false;\n}\n"],"mappings":"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"}
+{"version":3,"file":"table-tree.js","names":["Key","TableTreeNode","key","row","T","parentKey","level","siblingIndex","siblingCount","sourceIndex","children","TableTreeModel","roots","byKey","Map","parentOf","childrenOf","duplicateKeys","cyclicKeys","buildTableTree","rows","getChildren","getKey","visiting","Set","visitingRows","visit","input","output","forEach","currentSourceIndex","has","push","node","length","set","add","delete","map","child","sortTableTree","nodes","compare","a","b","sorted","sort","FilteredTableTree","forcedExpandedKeys","filterTableTree","matches","cloneComplete","reindexTableTree","filter","flattenTableTree","expandedKeys","ReadonlySet","items","tableTreeDescendantKeys","isTableTreeDescendant","model","Pick","possibleDescendant","ancestor","parent","get"],"sources":["../../../../src/components/data/TableBase/table-tree.ts"],"sourcesContent":["import type { Key } from '@react-types/shared';\n\nexport interface TableTreeNode<T> {\n  key: Key;\n  row: T;\n  parentKey: Key | null;\n  level: number;\n  siblingIndex: number;\n  siblingCount: number;\n  sourceIndex: number;\n  children: TableTreeNode<T>[];\n}\n\nexport interface TableTreeModel<T> {\n  roots: TableTreeNode<T>[];\n  byKey: Map<Key, TableTreeNode<T>>;\n  parentOf: Map<Key, Key | null>;\n  childrenOf: Map<Key, Key[]>;\n  duplicateKeys: Key[];\n  cyclicKeys: Key[];\n}\n\n/** Build identity and parent/child indexes without modifying consumer rows. */\nexport function buildTableTree<T>(\n  rows: readonly T[],\n  getChildren: (row: T) => readonly T[] | undefined,\n  getKey: (row: T, sourceIndex: number) => Key,\n): TableTreeModel<T> {\n  const byKey = new Map<Key, TableTreeNode<T>>();\n  const parentOf = new Map<Key, Key | null>();\n  const childrenOf = new Map<Key, Key[]>();\n  const duplicateKeys: Key[] = [];\n  const cyclicKeys: Key[] = [];\n  const visiting = new Set<Key>();\n  const visitingRows = new Set<T>();\n  let sourceIndex = 0;\n\n  const visit = (\n    input: readonly T[],\n    parentKey: Key | null,\n    level: number,\n  ): TableTreeNode<T>[] => {\n    const output: TableTreeNode<T>[] = [];\n\n    input.forEach((row, siblingIndex) => {\n      const currentSourceIndex = sourceIndex++;\n      const key = getKey(row, currentSourceIndex);\n\n      if (visiting.has(key) || visitingRows.has(row)) {\n        cyclicKeys.push(key);\n        return;\n      }\n\n      if (byKey.has(key)) {\n        duplicateKeys.push(key);\n        return;\n      }\n\n      const node: TableTreeNode<T> = {\n        key,\n        row,\n        parentKey,\n        level,\n        siblingIndex,\n        siblingCount: input.length,\n        sourceIndex: currentSourceIndex,\n        children: [],\n      };\n\n      byKey.set(key, node);\n      parentOf.set(key, parentKey);\n      visiting.add(key);\n      visitingRows.add(row);\n      node.children = visit(getChildren(row) ?? [], key, level + 1);\n      visiting.delete(key);\n      visitingRows.delete(row);\n      childrenOf.set(\n        key,\n        node.children.map((child) => child.key),\n      );\n      output.push(node);\n    });\n\n    return output;\n  };\n\n  const roots = visit(rows, null, 0);\n\n  return {\n    roots,\n    byKey,\n    parentOf,\n    childrenOf,\n    duplicateKeys,\n    cyclicKeys,\n  };\n}\n\nexport function sortTableTree<T>(\n  nodes: readonly TableTreeNode<T>[],\n  compare: (a: TableTreeNode<T>, b: TableTreeNode<T>) => number,\n): TableTreeNode<T>[] {\n  const sorted = nodes\n    .map((node) => ({\n      ...node,\n      children: sortTableTree(node.children, compare),\n    }))\n    .sort(compare);\n\n  return sorted.map((node, siblingIndex) => ({\n    ...node,\n    siblingIndex,\n    siblingCount: sorted.length,\n  }));\n}\n\nexport interface FilteredTableTree<T> {\n  roots: TableTreeNode<T>[];\n  forcedExpandedKeys: Set<Key>;\n}\n\n/**\n * Keep matching rows, their ancestor paths, and the complete subtree of a row\n * that matches itself. Every retained branch is opened while filtering so a\n * match can never remain hidden behind a collapsed ancestor.\n */\nexport function filterTableTree<T>(\n  nodes: readonly TableTreeNode<T>[],\n  matches: (node: TableTreeNode<T>) => boolean,\n): FilteredTableTree<T> {\n  const forcedExpandedKeys = new Set<Key>();\n\n  const cloneComplete = (node: TableTreeNode<T>): TableTreeNode<T> => {\n    const children = node.children.map(cloneComplete);\n    if (children.length) forcedExpandedKeys.add(node.key);\n\n    return { ...node, children: reindexTableTree(children) };\n  };\n\n  const visit = (node: TableTreeNode<T>): TableTreeNode<T> | null => {\n    if (matches(node)) return cloneComplete(node);\n\n    const children = node.children\n      .map(visit)\n      .filter((child): child is TableTreeNode<T> => child != null);\n\n    if (!children.length) return null;\n\n    forcedExpandedKeys.add(node.key);\n    return { ...node, children: reindexTableTree(children) };\n  };\n\n  return {\n    roots: reindexTableTree(\n      nodes.map(visit).filter((node): node is TableTreeNode<T> => node != null),\n    ),\n    forcedExpandedKeys,\n  };\n}\n\n/** Re-number a transformed sibling collection for its rendered treegrid. */\nexport function reindexTableTree<T>(\n  nodes: readonly TableTreeNode<T>[],\n): TableTreeNode<T>[] {\n  return nodes.map((node, siblingIndex) => ({\n    ...node,\n    siblingIndex,\n    siblingCount: nodes.length,\n    children: reindexTableTree(node.children),\n  }));\n}\n\nexport function flattenTableTree<T>(\n  nodes: readonly TableTreeNode<T>[],\n  expandedKeys?: ReadonlySet<Key>,\n): TableTreeNode<T>[] {\n  const output: TableTreeNode<T>[] = [];\n\n  const visit = (items: readonly TableTreeNode<T>[]) => {\n    for (const node of items) {\n      output.push(node);\n      if (expandedKeys == null || expandedKeys.has(node.key)) {\n        visit(node.children);\n      }\n    }\n  };\n\n  visit(nodes);\n  return output;\n}\n\nexport function tableTreeDescendantKeys<T>(node: TableTreeNode<T>): Key[] {\n  return flattenTableTree(node.children).map((child) => child.key);\n}\n\nexport function isTableTreeDescendant<T>(\n  model: Pick<TableTreeModel<T>, 'parentOf'>,\n  possibleDescendant: Key,\n  ancestor: Key,\n) {\n  let parent = model.parentOf.get(possibleDescendant);\n\n  while (parent != null) {\n    if (parent === ancestor) return true;\n    parent = model.parentOf.get(parent);\n  }\n\n  return false;\n}\n"],"mappings":"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"}

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

@@ -1,12 +1,11 @@
 
 import "../../content/Item/index.js";
-import { CubeItemProps } from "../../content/Item/Item.js";
+import { CubeItemBaseProps as CubeItemProps } from "../../content/Item/Item.js";
 import { Styles } from "@tenphi/tasty";
 import { ReactNode } from "react";
 import { Key as Key$1 } from "@react-types/shared";
-
 //#region src/components/data/TableBase/types.d.ts
-type CubeTableSortDirection = 'asc' | 'desc';
+export type CubeTableSortDirection = 'asc' | 'desc';
 /**
  * Named row heights: 28px, 32px and 40px.
  *
@@ -14,23 +13,23 @@ type CubeTableSortDirection = 'asc' | 'desc';
  * but `rowSize` moves only the ROWS. `size` also drives the header, so reaching
  * for a denser body through it drags the header down too.
  */
-type CubeTableRowSize = 'small' | 'medium' | 'large';
-type CubeTableAlign = 'start' | 'center' | 'end';
-type CubeTableRowSection = 'body' | 'pinnedTop' | 'pinnedBottom';
-interface CubeTableCellRange {
+export type CubeTableRowSize = 'small' | 'medium' | 'large';
+export type CubeTableAlign = 'start' | 'center' | 'end';
+export type CubeTableRowSection = 'body' | 'pinnedTop' | 'pinnedBottom';
+export interface CubeTableCellRange {
   fromRowKey: Key$1;
   toRowKey: Key$1;
   fromColumnKey: string;
   toColumnKey: string;
 }
-interface CubeTableTreeRowState {
+export interface CubeTableTreeRowState {
   /** Zero-based depth in the hierarchy. */
   level: number;
   parentKey: Key$1 | null;
   hasChildren: boolean;
   isExpanded: boolean;
 }
-interface CubeTableRowExpandInfo<T = any> {
+export interface CubeTableRowExpandInfo<T = any> {
   row: T;
   rowKey: Key$1;
   level: number;
@@ -38,7 +37,7 @@ interface CubeTableRowExpandInfo<T = any> {
   expanded: boolean;
 }
 /** Shared root sizing contract used by both table adapters. */
-interface CubeTableLayoutProps {
+export interface CubeTableLayoutProps {
   /**
    * Shrink-wraps the frame to its rendered rows instead of filling the
    * available flex pane. This mode disables virtualization because there is no
@@ -49,7 +48,7 @@ interface CubeTableLayoutProps {
   isAutoHeight?: boolean;
 }
 /** Shared opt-in hierarchy contract used by both table adapters. */
-interface CubeTableTreeProps<T = any> {
+export interface CubeTableTreeProps<T = any> {
   /**
    * Returns a row's already-loaded children. Supplying this enables tree mode
    * and makes `data` the top-level row collection.
@@ -64,12 +63,12 @@ interface CubeTableTreeProps<T = any> {
   /** Called after a user expands or collapses a row. */
   onExpand?: (keys: Key$1[], info: CubeTableRowExpandInfo<T>) => void;
 }
-interface CubeTableSort {
+export interface CubeTableSort {
   /** `key` of the sorted column. */
   columnKey: string;
   direction: CubeTableSortDirection;
 }
-interface CubeTableCellContext<T = any> {
+export interface CubeTableCellContext<T = any> {
   row: T;
   rowKey: Key$1;
   rowIndex: number;
@@ -93,7 +92,7 @@ interface CubeTableCellContext<T = any> {
   /** Present only when `getRowChildren` enables tree mode. */
   tree?: CubeTableTreeRowState;
 }
-interface CubeTableRowContext<T = any> {
+export interface CubeTableRowContext<T = any> {
   row: T;
   rowKey: Key$1;
   rowIndex: number;
@@ -105,7 +104,7 @@ interface CubeTableRowContext<T = any> {
   /** Present only when `getRowChildren` enables tree mode. */
   tree?: CubeTableTreeRowState;
 }
-interface CubeTableHeaderContext {
+export interface CubeTableHeaderContext {
   columnKey: string;
   columnIndex: number;
   sort: CubeTableSortDirection | null;
@@ -119,7 +118,7 @@ interface CubeTableHeaderContext {
  * tooltip / suffix / actions for free; `menu` is mounted into that `Item`'s
  * `actions` slot behind a `⋮` trigger.
  */
-interface CubeTableColumnHeader {
+export interface CubeTableColumnHeader {
   icon?: CubeItemProps['icon'];
   rightIcon?: CubeItemProps['rightIcon'];
   prefix?: ReactNode;
@@ -172,7 +171,7 @@ interface CubeTableColumnHeader {
  * `special` is absent deliberately: it is a standalone `mode: 'fixed'` theme with
  * no tinted-surface ramp to borrow.
  */
-type CubeTableColumnTheme = 'primary' | 'purple' | 'success' | 'danger' | 'warning' | 'note';
+export type CubeTableColumnTheme = 'primary' | 'purple' | 'success' | 'danger' | 'warning' | 'note';
 /**
  * How a column is tinted.
  *
@@ -181,10 +180,16 @@ type CubeTableColumnTheme = 'primary' | 'purple' | 'success' | 'danger' | 'warni
  * a column stays readable in light, dark and high contrast without the caller
  * checking — which is the part hand-picked hex pairs get wrong.
  */
-type CubeTableColumnColor = /** A palette theme name. */CubeTableColumnTheme /** Any colour Glaze parses — hex, `rgb()`, `hsl()`, `okhsl()`, `oklch()`. */ | (string & {}) /** The seed said directly. `saturation` is 0–100. */ | {
+export type CubeTableColumnColor =
+/** A palette theme name. */
+CubeTableColumnTheme |
+/** Any colour Glaze parses — hex, `rgb()`, `hsl()`, `okhsl()`, `oklch()`. */
+(string & {}) |
+/** The seed said directly. `saturation` is 0–100. */
+{
   hue: number;
   saturation?: number;
-}
+} |
 /**
  * Full manual control, as tasty colour strings (`'#note-surface'`, `'#purple.10'`).
  *
@@ -192,7 +197,7 @@ type CubeTableColumnColor = /** A palette theme name. */CubeTableColumnTheme /**
  * hatch, and readability in every scheme becomes the caller's problem.
  * `fillBand` defaults to `fill`, which turns banding off for the column.
  */
-| {
+{
   fill: string;
   fillBand?: string;
   text?: string;
@@ -202,8 +207,8 @@ type CubeTableColumnColor = /** A palette theme name. */CubeTableColumnTheme /**
  *
  * @default ['header','body','totals']
  */
-type CubeTableColumnColorScope = 'header' | 'body' | 'totals';
-interface CubeTableColumn<T = any> {
+export type CubeTableColumnColorScope = 'header' | 'body' | 'totals';
+export interface CubeTableColumn<T = any> {
   /**
    * Column id. Also the default data path — dot notation is supported
    * (`'owner.name'`). Anything beyond a path needs `getValue`.
@@ -298,8 +303,8 @@ interface CubeTableColumn<T = any> {
  * - `skeleton` — discard the previous rows and show placeholders.
  * - `none` — no visuals beyond `aria-busy`; the page owns the indicator.
  */
-type CubeTableLoadingIndicator = 'overlay' | 'skeleton' | 'none';
-type CubeTableSelectionMode = 'none' | 'single' | 'multiple';
+export type CubeTableLoadingIndicator = 'overlay' | 'skeleton' | 'none';
+export type CubeTableSelectionMode = 'none' | 'single' | 'multiple';
 /**
  * What the header checkbox acts on.
  *
@@ -308,7 +313,6 @@ type CubeTableSelectionMode = 'none' | 'single' | 'multiple';
  * - `all` — emits the `'all'` sentinel, meaning "everything, including rows the
  *   client has not loaded". The consumer decides what that means for its query.
  */
-type CubeTableSelectAllMode = 'page' | 'filtered' | 'all';
+export type CubeTableSelectAllMode = 'page' | 'filtered' | 'all';
 //#endregion
-export { CubeTableAlign, CubeTableCellContext, CubeTableCellRange, CubeTableColumn, CubeTableColumnHeader, CubeTableHeaderContext, CubeTableLayoutProps, CubeTableLoadingIndicator, CubeTableRowContext, CubeTableRowExpandInfo, CubeTableRowSection, CubeTableRowSize, CubeTableSelectAllMode, CubeTableSelectionMode, CubeTableSort, CubeTableSortDirection, CubeTableTreeProps, CubeTableTreeRowState };
 //# sourceMappingURL=types.d.ts.map

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

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.197.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.198.0 | Cube Dev Team */
 //#region src/components/data/TableBase/types.ts
 /**
 * `asc | desc` rather than React Aria's `ascending | descending`: we do not use
@@ -25,7 +25,7 @@
 function selectionRowKey(section, rowKey) {
 	return section === "body" ? rowKey : `${section}:${rowKey}`;
 }
-
 //#endregion
 export { selectionRowKey };
+
 //# sourceMappingURL=types.js.map

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

@@ -1 +1 @@
-{"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  /**\n   * Tasty styles for this column's body cells: tokens (`#surface-text-soft-2`),\n   * units, presets, recipes and state maps all work, and a state key asks about\n   * the cell itself (`@own(pinned=bottom)`). They win over the table's own cell\n   * paint, its column tint and the table-level `cellStyles`.\n   *\n   * The function form runs per cell, so it can vary with `ctx` (the row, its\n   * section, its selection). Cells whose styles are equal share one class, so a\n   * function returning a few distinct objects costs a few classes, not one per\n   * cell.\n   */\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"}
+{"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' | 'purple' | 'success' | 'danger' | 'warning' | '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  /**\n   * Tasty styles for this column's body cells: tokens (`#surface-text-soft-2`),\n   * units, presets, recipes and state maps all work, and a state key asks about\n   * the cell itself (`@own(pinned=bottom)`). They win over the table's own cell\n   * paint, its column tint and the table-level `cellStyles`.\n   *\n   * The function form runs per cell, so it can vary with `ctx` (the row, its\n   * section, its selection). Cells whose styles are equal share one class, so a\n   * function returning a few distinct objects costs a few classes, not one per\n   * cell.\n   */\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;CACL,OAAOD,YAAY,SAASC,SAAS,GAAGD,QAAO,GAAIC;AACrD"}

package/dist/components/data/TableBase/use-cell-selection.d.ts

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

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

@@ -1 +1 @@
-{"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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"}
+{"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-menu.js

@@ -1,16 +1,15 @@
-/** @license MIT | @cube-dev/ui-kit v0.197.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.198.0 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { ItemAction } from "../../actions/ItemAction/ItemAction.js";
 import { useI18n } from "../../../i18n/useI18n.js";
-import { _MenuTrigger } from "../../actions/Menu/MenuTrigger.js";
-import { __Menu } from "../../actions/Menu/Menu.js";
+import { MenuTrigger as _MenuTrigger } from "../../actions/Menu/MenuTrigger.js";
+import { Menu as __Menu } from "../../actions/Menu/Menu.js";
 import { MoreIcon } from "../../../icons/MoreIcon.js";
 import { isMenuEmpty, normalizeMenuAction } from "./row-menu.js";
 import { COLUMN_MENU_SORT_DIRECTION, isColumnMenuSortKey, processColumnMenuItems } from "./column-menu.js";
 import { c } from "react/compiler-runtime";
 import { useState } from "react";
 import { jsx, jsxs } from "react/jsx-runtime";
-
 //#region src/components/data/TableBase/use-column-menu.tsx
 /**
 * A column's `header.menu`, on both of its surfaces: the `⋮` trigger in the
@@ -160,7 +159,7 @@ function useColumnMenu(options) {
 	} else t6 = $[30];
 	return t6;
 }
-
 //#endregion
 export { useColumnMenu };
+
 //# sourceMappingURL=use-column-menu.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"use-column-menu.js","names":["useState","useEvent","useI18n","MoreIcon","ItemAction","Menu","MenuTrigger","COLUMN_MENU_SORT_DIRECTION","isColumnMenuSortKey","processColumnMenuItems","isMenuEmpty","normalizeMenuAction","Key","KeyboardEvent","ReactKeyboardEvent","MouseEvent","ReactMouseEvent","ReactNode","UseContextMenuReturn","ColumnSortState","CubeColumnMenuContext","CubeResolvedColumn","CubeTableSortDirection","UseColumnMenuOptions","contextMenu","Pick","HTMLDivElement","columnContextMenu","columnMenuProps","Record","columnMenuTriggerProps","onColumnSortChange","columnKey","direction","onColumnMenuAction","action","useColumnMenu","options","$","_c","t","isContextOnly","openMenuColumnKey","setOpenMenuColumnKey","t0","resolveColumnMenu","column","isStructural","items","header","menu","t1","columnMenuContext","column_0","sort","isSortable","activeSort","disallowSortRemoval","labels","t2","columnMenuActionHandler","column_1","closeAfter","normalized","key","onMenuAction","close","t3","column_2","sort_0","event","items_0","preventDefault","stopPropagation","open","menuProps","children","onAction","undefined","nativeEvent","openColumnContextMenu","t4","openColumnMenuFromKeyboard","column_3","sort_1","event_0","t5","renderColumnMenuTrigger","column_4","items_1","sort_2","menuTriggerProps","t6"],"sources":["../../../../src/components/data/TableBase/use-column-menu.tsx"],"sourcesContent":["import { useState } from 'react';\n\nimport { useEvent } from '../../../_internal/hooks/use-event';\nimport { useI18n } from '../../../i18n/useI18n';\nimport { MoreIcon } from '../../../icons/MoreIcon';\nimport { ItemAction } from '../../actions/ItemAction/ItemAction';\nimport { Menu } from '../../actions/Menu/Menu';\nimport { MenuTrigger } from '../../actions/Menu/MenuTrigger';\n\nimport {\n  COLUMN_MENU_SORT_DIRECTION,\n  isColumnMenuSortKey,\n  processColumnMenuItems,\n} from './column-menu';\nimport { isMenuEmpty, normalizeMenuAction } from './row-menu';\n\nimport type { Key } from '@react-types/shared';\nimport type {\n  KeyboardEvent as ReactKeyboardEvent,\n  MouseEvent as ReactMouseEvent,\n  ReactNode,\n} from 'react';\nimport type { UseContextMenuReturn } from '../../actions/use-context-menu';\nimport type { ColumnSortState } from './column-header';\nimport type { CubeColumnMenuContext } from './column-menu';\nimport type { CubeResolvedColumn, CubeTableSortDirection } from './types';\n\nexport interface UseColumnMenuOptions {\n  /** The table's one context menu, shared with the row menu. */\n  contextMenu: Pick<\n    UseContextMenuReturn<HTMLDivElement, any>,\n    'open' | 'close'\n  >;\n  /** See `TableViewProps.columnContextMenu`. */\n  columnContextMenu: boolean | 'context-only';\n  columnMenuProps?: Record<string, any>;\n  columnMenuTriggerProps?: Record<string, any>;\n  onColumnSortChange?: (\n    columnKey: string,\n    direction: CubeTableSortDirection | null,\n  ) => void;\n  onColumnMenuAction?: (action: string, columnKey: string) => void;\n}\n\n/**\n * A column's `header.menu`, on both of its surfaces: the `⋮` trigger in the\n * header's actions slot, and the context menu a right-click or Shift+F10 opens.\n *\n * Both surfaces share the item resolution, the reserved sort keys and the\n * action dispatch here, so they cannot drift apart.\n */\nexport function useColumnMenu<T>(options: UseColumnMenuOptions) {\n  const {\n    contextMenu,\n    columnContextMenu,\n    columnMenuProps,\n    columnMenuTriggerProps,\n    onColumnSortChange,\n    onColumnMenuAction,\n  } = options;\n  const { t } = useI18n();\n  const isContextOnly = columnContextMenu === 'context-only';\n\n  /**\n   * The column whose menu is open, held for the whole table rather than per\n   * header cell.\n   *\n   * `renderHeaderCell` is a closure inside `TableView`, not a component of its\n   * own, so it cannot hold state — and only one column menu can be open at a\n   * time anyway. Controlled rather than letting `MenuTrigger` own it: Shift+F10\n   * has to be able to open it from the `<th>`, and the trigger is not a tab stop.\n   */\n  const [openMenuColumnKey, setOpenMenuColumnKey] = useState<string | null>(\n    null,\n  );\n\n  /** The column's menu items, or `null` when it has no menu on any surface. */\n  function resolveColumnMenu(column: CubeResolvedColumn<T>): ReactNode | null {\n    if (columnContextMenu === false || column.isStructural) return null;\n\n    const items = column.header?.menu;\n\n    return isMenuEmpty(items) ? null : items;\n  }\n\n  /** The reserved sort keys, labelled here so `column-menu.ts` stays pure. */\n  function columnMenuContext(\n    column: CubeResolvedColumn<T>,\n    sort: ColumnSortState,\n  ): CubeColumnMenuContext {\n    return {\n      isSortable: sort.isSortable,\n      sort: sort.activeSort?.direction ?? null,\n      disallowSortRemoval: column.disallowSortRemoval === true,\n      labels: {\n        'sort-asc': t('itemTable.sortAscending', 'Sort ascending'),\n        'sort-desc': t('itemTable.sortDescending', 'Sort descending'),\n        'clear-sort': t('itemTable.clearSort', 'Clear sort'),\n      },\n    };\n  }\n\n  function columnMenuActionHandler(\n    column: CubeResolvedColumn<T>,\n    closeAfter: boolean,\n  ) {\n    return (action: Key) => {\n      const normalized = normalizeMenuAction(action);\n\n      // The table's own keys are applied first, then the consumer hears about\n      // them anyway — so a key can be both understood here and observed there.\n      if (isColumnMenuSortKey(normalized)) {\n        onColumnSortChange?.(\n          column.key,\n          COLUMN_MENU_SORT_DIRECTION[normalized],\n        );\n      }\n\n      column.header?.onMenuAction?.(normalized);\n      onColumnMenuAction?.(normalized, column.key);\n\n      // `useContextMenu` leaves its popover open after an action; see\n      // `menuActionHandler` in `TableView`.\n      if (closeAfter) contextMenu.close();\n    };\n  }\n\n  const openColumnContextMenu = useEvent(\n    (\n      column: CubeResolvedColumn<T>,\n      sort: ColumnSortState,\n      event: ReactMouseEvent | ReactKeyboardEvent,\n    ) => {\n      const items = resolveColumnMenu(column);\n\n      if (items == null) return;\n\n      event.preventDefault();\n      // The Scroller listens for Shift+F10 too, for the row menu.\n      event.stopPropagation();\n      contextMenu.open(\n        {\n          ...columnMenuProps,\n          ...column.header?.menuProps,\n          children: processColumnMenuItems(\n            items,\n            columnMenuContext(column, sort),\n          ),\n          onAction: columnMenuActionHandler(column, true),\n        },\n        undefined,\n        'clientX' in event.nativeEvent\n          ? (event.nativeEvent as MouseEvent)\n          : undefined,\n      );\n    },\n  );\n\n  /**\n   * Shift+F10 on the header cell: the `⋮` trigger's own popover when there is\n   * a trigger, the context menu when `columnContextMenu` is `'context-only'`.\n   */\n  function openColumnMenuFromKeyboard(\n    column: CubeResolvedColumn<T>,\n    sort: ColumnSortState,\n    event: ReactKeyboardEvent,\n  ) {\n    if (isContextOnly) {\n      openColumnContextMenu(column, sort, event);\n\n      return;\n    }\n\n    event.preventDefault();\n    // The Scroller listens for Shift+F10 too, for the row menu.\n    event.stopPropagation();\n    setOpenMenuColumnKey(column.key);\n  }\n\n  /** The `⋮` trigger, or `null` when the menu is context-only or absent. */\n  function renderColumnMenuTrigger(\n    column: CubeResolvedColumn<T>,\n    items: ReactNode | null,\n    sort: ColumnSortState,\n  ) {\n    if (items == null || isContextOnly) return null;\n\n    const header = column.header;\n\n    return (\n      <MenuTrigger\n        isOpen={openMenuColumnKey === column.key}\n        // `bottom end`: the trigger sits at the column's trailing edge, so a\n        // start-aligned popover hangs off the table on the last column.\n        placement=\"bottom end\"\n        onOpenChange={(open) => setOpenMenuColumnKey(open ? column.key : null)}\n      >\n        <ItemAction\n          // The grid is one tab stop; the trigger is reached from the header\n          // cell with Shift+F10, matching the row menu.\n          tabIndex={-1}\n          icon={<MoreIcon />}\n          aria-label={t('itemTable.columnMenu', 'Column menu')}\n          {...columnMenuTriggerProps}\n          {...header?.menuTriggerProps}\n        />\n        <Menu\n          {...columnMenuProps}\n          {...header?.menuProps}\n          onAction={columnMenuActionHandler(column, false)}\n        >\n          {processColumnMenuItems(items, columnMenuContext(column, sort))}\n        </Menu>\n      </MenuTrigger>\n    );\n  }\n\n  return {\n    openMenuColumnKey,\n    resolveColumnMenu,\n    openColumnContextMenu,\n    openColumnMenuFromKeyboard,\n    renderColumnMenuTrigger,\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"use-column-menu.js","names":["useState","useEvent","useI18n","MoreIcon","ItemAction","Menu","MenuTrigger","COLUMN_MENU_SORT_DIRECTION","isColumnMenuSortKey","processColumnMenuItems","isMenuEmpty","normalizeMenuAction","Key","KeyboardEvent","ReactKeyboardEvent","MouseEvent","ReactMouseEvent","ReactNode","UseContextMenuReturn","ColumnSortState","CubeColumnMenuContext","CubeResolvedColumn","CubeTableSortDirection","UseColumnMenuOptions","contextMenu","Pick","HTMLDivElement","columnContextMenu","columnMenuProps","Record","columnMenuTriggerProps","onColumnSortChange","columnKey","direction","onColumnMenuAction","action","useColumnMenu","options","$","_c","t","isContextOnly","openMenuColumnKey","setOpenMenuColumnKey","t0","resolveColumnMenu","column","isStructural","items","header","menu","t1","columnMenuContext","column_0","sort","isSortable","activeSort","disallowSortRemoval","labels","t2","columnMenuActionHandler","column_1","closeAfter","normalized","key","onMenuAction","close","t3","column_2","sort_0","event","items_0","preventDefault","stopPropagation","open","menuProps","children","onAction","undefined","nativeEvent","openColumnContextMenu","t4","openColumnMenuFromKeyboard","column_3","sort_1","event_0","t5","renderColumnMenuTrigger","column_4","items_1","sort_2","menuTriggerProps","t6","_c","MenuTrigger","Menu"],"sources":["../../../../src/components/data/TableBase/use-column-menu.tsx"],"sourcesContent":["import { useState } from 'react';\n\nimport { useEvent } from '../../../_internal/hooks/use-event';\nimport { useI18n } from '../../../i18n/useI18n';\nimport { MoreIcon } from '../../../icons/MoreIcon';\nimport { ItemAction } from '../../actions/ItemAction/ItemAction';\nimport { Menu } from '../../actions/Menu/Menu';\nimport { MenuTrigger } from '../../actions/Menu/MenuTrigger';\n\nimport {\n  COLUMN_MENU_SORT_DIRECTION,\n  isColumnMenuSortKey,\n  processColumnMenuItems,\n} from './column-menu';\nimport { isMenuEmpty, normalizeMenuAction } from './row-menu';\n\nimport type { Key } from '@react-types/shared';\nimport type {\n  KeyboardEvent as ReactKeyboardEvent,\n  MouseEvent as ReactMouseEvent,\n  ReactNode,\n} from 'react';\nimport type { UseContextMenuReturn } from '../../actions/use-context-menu';\nimport type { ColumnSortState } from './column-header';\nimport type { CubeColumnMenuContext } from './column-menu';\nimport type { CubeResolvedColumn, CubeTableSortDirection } from './types';\n\nexport interface UseColumnMenuOptions {\n  /** The table's one context menu, shared with the row menu. */\n  contextMenu: Pick<\n    UseContextMenuReturn<HTMLDivElement, any>,\n    'open' | 'close'\n  >;\n  /** See `TableViewProps.columnContextMenu`. */\n  columnContextMenu: boolean | 'context-only';\n  columnMenuProps?: Record<string, any>;\n  columnMenuTriggerProps?: Record<string, any>;\n  onColumnSortChange?: (\n    columnKey: string,\n    direction: CubeTableSortDirection | null,\n  ) => void;\n  onColumnMenuAction?: (action: string, columnKey: string) => void;\n}\n\n/**\n * A column's `header.menu`, on both of its surfaces: the `⋮` trigger in the\n * header's actions slot, and the context menu a right-click or Shift+F10 opens.\n *\n * Both surfaces share the item resolution, the reserved sort keys and the\n * action dispatch here, so they cannot drift apart.\n */\nexport function useColumnMenu<T>(options: UseColumnMenuOptions) {\n  const {\n    contextMenu,\n    columnContextMenu,\n    columnMenuProps,\n    columnMenuTriggerProps,\n    onColumnSortChange,\n    onColumnMenuAction,\n  } = options;\n  const { t } = useI18n();\n  const isContextOnly = columnContextMenu === 'context-only';\n\n  /**\n   * The column whose menu is open, held for the whole table rather than per\n   * header cell.\n   *\n   * `renderHeaderCell` is a closure inside `TableView`, not a component of its\n   * own, so it cannot hold state — and only one column menu can be open at a\n   * time anyway. Controlled rather than letting `MenuTrigger` own it: Shift+F10\n   * has to be able to open it from the `<th>`, and the trigger is not a tab stop.\n   */\n  const [openMenuColumnKey, setOpenMenuColumnKey] = useState<string | null>(\n    null,\n  );\n\n  /** The column's menu items, or `null` when it has no menu on any surface. */\n  function resolveColumnMenu(column: CubeResolvedColumn<T>): ReactNode | null {\n    if (columnContextMenu === false || column.isStructural) return null;\n\n    const items = column.header?.menu;\n\n    return isMenuEmpty(items) ? null : items;\n  }\n\n  /** The reserved sort keys, labelled here so `column-menu.ts` stays pure. */\n  function columnMenuContext(\n    column: CubeResolvedColumn<T>,\n    sort: ColumnSortState,\n  ): CubeColumnMenuContext {\n    return {\n      isSortable: sort.isSortable,\n      sort: sort.activeSort?.direction ?? null,\n      disallowSortRemoval: column.disallowSortRemoval === true,\n      labels: {\n        'sort-asc': t('itemTable.sortAscending', 'Sort ascending'),\n        'sort-desc': t('itemTable.sortDescending', 'Sort descending'),\n        'clear-sort': t('itemTable.clearSort', 'Clear sort'),\n      },\n    };\n  }\n\n  function columnMenuActionHandler(\n    column: CubeResolvedColumn<T>,\n    closeAfter: boolean,\n  ) {\n    return (action: Key) => {\n      const normalized = normalizeMenuAction(action);\n\n      // The table's own keys are applied first, then the consumer hears about\n      // them anyway — so a key can be both understood here and observed there.\n      if (isColumnMenuSortKey(normalized)) {\n        onColumnSortChange?.(\n          column.key,\n          COLUMN_MENU_SORT_DIRECTION[normalized],\n        );\n      }\n\n      column.header?.onMenuAction?.(normalized);\n      onColumnMenuAction?.(normalized, column.key);\n\n      // `useContextMenu` leaves its popover open after an action; see\n      // `menuActionHandler` in `TableView`.\n      if (closeAfter) contextMenu.close();\n    };\n  }\n\n  const openColumnContextMenu = useEvent(\n    (\n      column: CubeResolvedColumn<T>,\n      sort: ColumnSortState,\n      event: ReactMouseEvent | ReactKeyboardEvent,\n    ) => {\n      const items = resolveColumnMenu(column);\n\n      if (items == null) return;\n\n      event.preventDefault();\n      // The Scroller listens for Shift+F10 too, for the row menu.\n      event.stopPropagation();\n      contextMenu.open(\n        {\n          ...columnMenuProps,\n          ...column.header?.menuProps,\n          children: processColumnMenuItems(\n            items,\n            columnMenuContext(column, sort),\n          ),\n          onAction: columnMenuActionHandler(column, true),\n        },\n        undefined,\n        'clientX' in event.nativeEvent\n          ? (event.nativeEvent as MouseEvent)\n          : undefined,\n      );\n    },\n  );\n\n  /**\n   * Shift+F10 on the header cell: the `⋮` trigger's own popover when there is\n   * a trigger, the context menu when `columnContextMenu` is `'context-only'`.\n   */\n  function openColumnMenuFromKeyboard(\n    column: CubeResolvedColumn<T>,\n    sort: ColumnSortState,\n    event: ReactKeyboardEvent,\n  ) {\n    if (isContextOnly) {\n      openColumnContextMenu(column, sort, event);\n\n      return;\n    }\n\n    event.preventDefault();\n    // The Scroller listens for Shift+F10 too, for the row menu.\n    event.stopPropagation();\n    setOpenMenuColumnKey(column.key);\n  }\n\n  /** The `⋮` trigger, or `null` when the menu is context-only or absent. */\n  function renderColumnMenuTrigger(\n    column: CubeResolvedColumn<T>,\n    items: ReactNode | null,\n    sort: ColumnSortState,\n  ) {\n    if (items == null || isContextOnly) return null;\n\n    const header = column.header;\n\n    return (\n      <MenuTrigger\n        isOpen={openMenuColumnKey === column.key}\n        // `bottom end`: the trigger sits at the column's trailing edge, so a\n        // start-aligned popover hangs off the table on the last column.\n        placement=\"bottom end\"\n        onOpenChange={(open) => setOpenMenuColumnKey(open ? column.key : null)}\n      >\n        <ItemAction\n          // The grid is one tab stop; the trigger is reached from the header\n          // cell with Shift+F10, matching the row menu.\n          tabIndex={-1}\n          icon={<MoreIcon />}\n          aria-label={t('itemTable.columnMenu', 'Column menu')}\n          {...columnMenuTriggerProps}\n          {...header?.menuTriggerProps}\n        />\n        <Menu\n          {...columnMenuProps}\n          {...header?.menuProps}\n          onAction={columnMenuActionHandler(column, false)}\n        >\n          {processColumnMenuItems(items, columnMenuContext(column, sort))}\n        </Menu>\n      </MenuTrigger>\n    );\n  }\n\n  return {\n    openMenuColumnKey,\n    resolveColumnMenu,\n    openColumnContextMenu,\n    openColumnMenuFromKeyboard,\n    renderColumnMenuTrigger,\n  };\n}\n"],"mappings":"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"}

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

@@ -1,9 +1,8 @@
-/** @license MIT | @cube-dev/ui-kit v0.197.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.198.0 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 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
 /**
 * Reorders the source columns to match `order`.
@@ -137,7 +136,7 @@ function useColumnOrder(t0) {
 function _temp(column) {
 	return column.key;
 }
-
 //#endregion
-export { getDraggableColumnKeys, isColumnDraggable, useColumnOrder };
+export { applyColumnOrder, getDraggableColumnKeys, isColumnDraggable, projectReorder, useColumnOrder };
+
 //# sourceMappingURL=use-column-order.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"use-column-order.js","names":["useControlledState","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","ordered","t2","_temp","t3","write","t4"],"sources":["../../../../src/components/data/TableBase/use-column-order.ts"],"sourcesContent":["import { useControlledState } from '@react-stately/utils';\nimport { 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 = applyColumnOrder(columns, order);\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 = ordered.map((column) => column.key);\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":"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"}
+{"version":3,"file":"use-column-order.js","names":["useControlledState","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","ordered","t2","_temp","t3","write","t4","_c"],"sources":["../../../../src/components/data/TableBase/use-column-order.ts"],"sourcesContent":["import { useControlledState } from '@react-stately/utils';\nimport { 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 = applyColumnOrder(columns, order);\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 = ordered.map((column) => column.key);\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":"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"}