@cube-dev/ui-kit 0.0.0-canary-34ce1a4 → 0.0.0-canary-7dc6906

package/docs/components/data/ItemTable.md

@@ -189,14 +189,6 @@ pivots, totals. Use `ListBox` when there is only one column.
 - **`defaultColumnWidths`** `Record<string, number>` — Initial widths.
 - **`onColumnResize`** `(columnKey, width, all) => void` — Fires once the
   gesture ends, not on every pixel.
-- **`columnContextMenu`** `boolean | 'context-only'` (default: `true`) — Where a
-  column's `header.menu` is exposed: a `⋮` trigger plus right-click and
-  Shift+F10, right-click only, or nowhere.
-- **`onColumnMenuAction`** `(action, columnKey) => void` — The pressed
-  `Menu.Item` key, as written. Fires for the reserved sort keys too, after the
-  table has applied them.
-- **`columnMenuTriggerProps`** `Record<string, any>` — Props for the `⋮` trigger.
-- **`columnMenuProps`** `Record<string, any>` — Props for the `Menu`.
 - **`storageKey`** `string` — Persists the table's own state under
   `cube-ui-kit:table:${storageKey}`. Controlled state is never stored — a
   controlled `pageSize` or `sort` belongs to the page, and restoring it would
@@ -233,7 +225,7 @@ interface CubeItemTableColumn<T> {
   cellProps?: (ctx) => Record<string, any> | undefined;
 
   align?: 'start' | 'center' | 'end';
-  isSortable?: boolean;     // opt in per column (default false)
+  isSortable?: boolean;
   isSearchable?: boolean;   // include in the built-in search (default true)
   isCopyable?: boolean;     // include in TSV copy (default true)
   autoHeight?: boolean;     // wrap text and let the row grow
@@ -413,11 +405,10 @@ search sets it for you.
 
 ### Sorting
 
-Sorting is **opt in, per column**: a table with no `isSortable` column has inert
-headers and `sortMode` resolves to `'off'`. Mark columns `isSortable` and
-clicking a header cycles `ascending → descending → unsorted`. The third state
-matters whenever the source order is meaningful, which is why it is the default
-cycle; set `disallowSortRemoval` on a column to reduce it to `asc ↔ desc`.
+Mark columns `isSortable` and clicking a header cycles
+`ascending → descending → unsorted`. The third state matters whenever the source
+order is meaningful, which is why it is the default cycle; set
+`disallowSortRemoval` on a column to reduce it to `asc ↔ desc`.
 
 ```jsx
 <ItemTable
@@ -431,29 +422,6 @@ cycle; set `disallowSortRemoval` on a column to reduce it to `asc ↔ desc`.
 />
 ```
 
-#### A fixed order the user cannot change
-
-For a list that arrives in a meaningful order — most of them — leave every column
-alone and pass the order you want. `sortMode="client"` keeps the engine sorting
-while the headers stay inert, so nothing is clickable and no header takes a tab
-stop:
-
-```jsx
-<ItemTable
-  data={rows}
-  columns={[{ key: 'name', title: 'Name' }]}
-  sortMode="client"
-  sort={{ columnKey: 'name', direction: 'asc' }}
-/>
-```
-
-The sorted column still carries `aria-sort`, so a screen reader announces the
-order even though the header cannot be operated. It is **not** drawn — the sort
-arrow belongs to the clickable affordance — so add your own marker through
-`header.suffix` if sighted users need to see which column the order follows.
-
-Data already in the right order needs none of this: pass it and set nothing.
-
 Client-side sorting compares raw `getValue` results — numerically for numbers,
 chronologically for dates — and falls back to a locale-aware collator over the
 column's display text, so a formatted column sorts the way it reads. `compare`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cube-dev/ui-kit",
-  "version": "0.0.0-canary-34ce1a4",
+  "version": "0.0.0-canary-7dc6906",
   "type": "module",
   "description": "UIKit for Cube Projects",
   "repository": {

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

@@ -1,115 +0,0 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-34ce1a4 | Cube Dev Team */
-import { mergeProps as mergeProps$1 } from "../../../utils/react/mergeProps.js";
-import { useEffect, useRef, useState } from "react";
-import { jsx, jsxs } from "react/jsx-runtime";
-import { useDraggableItem, useDropIndicator } from "react-aria";
-
-//#region src/components/data/TableBase/TableHeaderCell.tsx
-/**
-* Controls inside the header that own their own press, and must never start a
-* column drag.
-*
-* Drag-source resolution walks the DOM tree, not the React event path, so
-* `Item`'s `Actions` slot calling `stopPropagation` does nothing here — the
-* `<th>` is still the drag source as far as the browser is concerned. Only
-* `preventDefault` on `dragstart` stops it, which is what the capture handler
-* below does.
-*/
-const NO_DRAG_SELECTOR = "[data-element=\"Resizer\"], [data-element=\"Actions\"], a, button, input, select, textarea, [role=\"button\"], [role=\"menuitem\"]";
-function HeaderCell(props) {
-	const { cellProps, extra, children } = props;
-	return /* @__PURE__ */ jsx("th", {
-		...cellProps,
-		...extra,
-		children
-	});
-}
-/**
-* A header cell inside a collection that accepts drags.
-*
-* Split from the plain one so the drag hooks can be called unconditionally —
-* they are hooks, and whether a table reorders its columns is a prop.
-*/
-function DraggableHeaderCell(props) {
-	const { columnKey, hasAction, isLastDraggable, dragState, dropState } = props;
-	const { dragProps, isDragging } = useDraggableItem({
-		key: columnKey,
-		hasAction
-	}, dragState);
-	return /* @__PURE__ */ jsxs(HeaderCell, {
-		...props,
-		extra: {
-			...mergeProps$1(props.cellProps, dragProps, { onDragStartCapture: (event) => {
-				if (event.target?.closest?.(NO_DRAG_SELECTOR)) {
-					event.preventDefault();
-					event.stopPropagation();
-				}
-			} }),
-			"data-draggable": "",
-			"data-dragging": isDragging ? "" : void 0
-		},
-		children: [
-			/* @__PURE__ */ jsx(ColumnDropIndicator, {
-				columnKey,
-				dropPosition: "before",
-				dropState
-			}),
-			props.children,
-			isLastDraggable ? /* @__PURE__ */ jsx(ColumnDropIndicator, {
-				columnKey,
-				dropPosition: "after",
-				dropState
-			}) : null
-		]
-	});
-}
-function TableHeaderCell(props) {
-	return props.dragState && props.dropState ? /* @__PURE__ */ jsx(DraggableHeaderCell, { ...props }) : /* @__PURE__ */ jsx(HeaderCell, { ...props });
-}
-/**
-* The line showing where a dragged column would land.
-*
-* Lives INSIDE the `<th>`, absolutely positioned on one of its edges — a `<tr>`
-* may only contain `<th>`/`<td>`, so there is nowhere between two header cells
-* to put it. Being absolute also means mounting one cannot shift the layout,
-* which is the bug class the row indicator had to be careful about.
-*
-* `useDropIndicator` reports `isHidden` unless this is the active target, so a
-* table merely capable of reordering keeps its exact DOM until a drag starts.
-*/
-function ColumnDropIndicator({ columnKey, dropPosition, dropState }) {
-	const ref = useRef(null);
-	const { dropIndicatorProps, isHidden, isDropTarget } = useDropIndicator({ target: {
-		type: "item",
-		key: columnKey,
-		dropPosition
-	} }, dropState, ref);
-	/**
-	* Re-register the drop targets when the header's geometry changes.
-	*
-	* React Aria's `ListDropTargetDelegate` measures every `[data-key]` at the
-	* moment a drag starts. A column resized mid-drag — or a scrollbar appearing —
-	* leaves those rects stale, and the drop lands in the wrong place. Same trick
-	* `TabDropIndicator` uses.
-	*/
-	const [, forceUpdate] = useState(0);
-	useEffect(() => {
-		const row = ref.current?.closest("[data-element=\"HeadRow\"]");
-		if (!row || typeof ResizeObserver === "undefined") return;
-		const observer = new ResizeObserver(() => forceUpdate((n) => n + 1));
-		observer.observe(row);
-		return () => observer.disconnect();
-	}, []);
-	if (isHidden) return null;
-	return /* @__PURE__ */ jsx("div", {
-		...dropIndicatorProps,
-		ref,
-		"data-element": "ColumnDropIndicator",
-		"data-position": dropPosition,
-		"data-drop-target": isDropTarget ? "" : void 0
-	});
-}
-
-//#endregion
-export { TableHeaderCell };
-//# sourceMappingURL=TableHeaderCell.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"TableHeaderCell.js","names":["mergeProps"],"sources":["../../../../src/components/data/TableBase/TableHeaderCell.tsx"],"sourcesContent":["import { useEffect, useRef, useState } from 'react';\nimport { useDraggableItem, useDropIndicator } from 'react-aria';\n\nimport { mergeProps } from '../../../utils/react';\n\nimport type { ReactNode } from 'react';\nimport type {\n  DraggableCollectionState,\n  DroppableCollectionState,\n} from 'react-stately';\n\n/**\n * Controls inside the header that own their own press, and must never start a\n * column drag.\n *\n * Drag-source resolution walks the DOM tree, not the React event path, so\n * `Item`'s `Actions` slot calling `stopPropagation` does nothing here — the\n * `<th>` is still the drag source as far as the browser is concerned. Only\n * `preventDefault` on `dragstart` stops it, which is what the capture handler\n * below does.\n */\nconst NO_DRAG_SELECTOR =\n  '[data-element=\"Resizer\"], [data-element=\"Actions\"], a, button, input, select, textarea, [role=\"button\"], [role=\"menuitem\"]';\n\nexport interface TableHeaderCellProps {\n  columnKey: string;\n  /** Everything the renderer already computed: mods, ARIA, handlers, styles. */\n  cellProps: Record<string, any>;\n  /** Whether the header itself responds to Enter — i.e. it sorts. */\n  hasAction: boolean;\n  isLastDraggable: boolean;\n  dragState?: DraggableCollectionState;\n  dropState?: DroppableCollectionState;\n  children: ReactNode;\n}\n\nfunction HeaderCell(\n  props: TableHeaderCellProps & { extra?: Record<string, any> },\n) {\n  const { cellProps, extra, children } = props;\n\n  return (\n    <th {...cellProps} {...extra}>\n      {children}\n    </th>\n  );\n}\n\n/**\n * A header cell inside a collection that accepts drags.\n *\n * Split from the plain one so the drag hooks can be called unconditionally —\n * they are hooks, and whether a table reorders its columns is a prop.\n */\nfunction DraggableHeaderCell(props: TableHeaderCellProps) {\n  const { columnKey, hasAction, isLastDraggable, dragState, dropState } = props;\n\n  const { dragProps, isDragging } = useDraggableItem(\n    // `hasAction` re-gates React Aria's Enter/Space capture behind Alt, so plain\n    // Enter still reaches the header's own sort handler instead of starting a\n    // keyboard drag session.\n    { key: columnKey, hasAction },\n    dragState as DraggableCollectionState,\n  );\n\n  return (\n    <HeaderCell\n      {...props}\n      extra={{\n        // `dragProps` last for `draggable`, which is a value rather than a\n        // handler — `mergeProps` chains handlers but takes the later value. The\n        // sort `onClick` survives: `useDraggableItem` only deletes its own.\n        ...mergeProps(props.cellProps, dragProps, {\n          // Capture, so this runs before React Aria's own `onDragStart` on the\n          // same node and can cancel it.\n          onDragStartCapture: (event: any) => {\n            if ((event.target as HTMLElement)?.closest?.(NO_DRAG_SELECTOR)) {\n              event.preventDefault();\n              event.stopPropagation();\n            }\n          },\n        }),\n        'data-draggable': '',\n        'data-dragging': isDragging ? '' : undefined,\n      }}\n    >\n      <ColumnDropIndicator\n        columnKey={columnKey}\n        dropPosition=\"before\"\n        dropState={dropState as DroppableCollectionState}\n      />\n      {props.children}\n      {isLastDraggable ? (\n        <ColumnDropIndicator\n          columnKey={columnKey}\n          dropPosition=\"after\"\n          dropState={dropState as DroppableCollectionState}\n        />\n      ) : null}\n    </HeaderCell>\n  );\n}\n\nexport function TableHeaderCell(props: TableHeaderCellProps) {\n  return props.dragState && props.dropState ? (\n    <DraggableHeaderCell {...props} />\n  ) : (\n    <HeaderCell {...props} />\n  );\n}\n\ninterface ColumnDropIndicatorProps {\n  columnKey: string;\n  dropPosition: 'before' | 'after';\n  dropState: DroppableCollectionState;\n}\n\n/**\n * The line showing where a dragged column would land.\n *\n * Lives INSIDE the `<th>`, absolutely positioned on one of its edges — a `<tr>`\n * may only contain `<th>`/`<td>`, so there is nowhere between two header cells\n * to put it. Being absolute also means mounting one cannot shift the layout,\n * which is the bug class the row indicator had to be careful about.\n *\n * `useDropIndicator` reports `isHidden` unless this is the active target, so a\n * table merely capable of reordering keeps its exact DOM until a drag starts.\n */\nfunction ColumnDropIndicator({\n  columnKey,\n  dropPosition,\n  dropState,\n}: ColumnDropIndicatorProps) {\n  const ref = useRef<HTMLDivElement>(null);\n  const { dropIndicatorProps, isHidden, isDropTarget } = useDropIndicator(\n    { target: { type: 'item', key: columnKey, dropPosition } },\n    dropState,\n    ref,\n  );\n\n  /**\n   * Re-register the drop targets when the header's geometry changes.\n   *\n   * React Aria's `ListDropTargetDelegate` measures every `[data-key]` at the\n   * moment a drag starts. A column resized mid-drag — or a scrollbar appearing —\n   * leaves those rects stale, and the drop lands in the wrong place. Same trick\n   * `TabDropIndicator` uses.\n   */\n  const [, forceUpdate] = useState(0);\n\n  useEffect(() => {\n    const row = ref.current?.closest('[data-element=\"HeadRow\"]');\n\n    if (!row || typeof ResizeObserver === 'undefined') return;\n\n    const observer = new ResizeObserver(() => forceUpdate((n) => n + 1));\n\n    observer.observe(row);\n\n    return () => observer.disconnect();\n  }, []);\n\n  if (isHidden) return null;\n\n  return (\n    <div\n      {...dropIndicatorProps}\n      ref={ref}\n      data-element=\"ColumnDropIndicator\"\n      data-position={dropPosition}\n      data-drop-target={isDropTarget ? '' : undefined}\n    />\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAqBA,MAAM,mBACJ;AAcF,SAAS,WACP,OACA;CACA,MAAM,EAAE,WAAW,OAAO,aAAa;AAEvC,QACE,oBAAC;EAAG,GAAI;EAAW,GAAI;EACpB;GACE;;;;;;;;AAUT,SAAS,oBAAoB,OAA6B;CACxD,MAAM,EAAE,WAAW,WAAW,iBAAiB,WAAW,cAAc;CAExE,MAAM,EAAE,WAAW,eAAe,iBAIhC;EAAE,KAAK;EAAW;EAAW,EAC7B,UACD;AAED,QACE,qBAAC;EACC,GAAI;EACJ,OAAO;GAIL,GAAGA,aAAW,MAAM,WAAW,WAAW,EAGxC,qBAAqB,UAAe;AAClC,QAAK,MAAM,QAAwB,UAAU,iBAAiB,EAAE;AAC9D,WAAM,gBAAgB;AACtB,WAAM,iBAAiB;;MAG5B,CAAC;GACF,kBAAkB;GAClB,iBAAiB,aAAa,KAAK;GACpC;;GAED,oBAAC;IACY;IACX,cAAa;IACF;KACX;GACD,MAAM;GACN,kBACC,oBAAC;IACY;IACX,cAAa;IACF;KACX,GACA;;GACO;;AAIjB,SAAgB,gBAAgB,OAA6B;AAC3D,QAAO,MAAM,aAAa,MAAM,YAC9B,oBAAC,uBAAoB,GAAI,QAAS,GAElC,oBAAC,cAAW,GAAI,QAAS;;;;;;;;;;;;;AAqB7B,SAAS,oBAAoB,EAC3B,WACA,cACA,aAC2B;CAC3B,MAAM,MAAM,OAAuB,KAAK;CACxC,MAAM,EAAE,oBAAoB,UAAU,iBAAiB,iBACrD,EAAE,QAAQ;EAAE,MAAM;EAAQ,KAAK;EAAW;EAAc,EAAE,EAC1D,WACA,IACD;;;;;;;;;CAUD,MAAM,GAAG,eAAe,SAAS,EAAE;AAEnC,iBAAgB;EACd,MAAM,MAAM,IAAI,SAAS,QAAQ,6BAA2B;AAE5D,MAAI,CAAC,OAAO,OAAO,mBAAmB,YAAa;EAEnD,MAAM,WAAW,IAAI,qBAAqB,aAAa,MAAM,IAAI,EAAE,CAAC;AAEpE,WAAS,QAAQ,IAAI;AAErB,eAAa,SAAS,YAAY;IACjC,EAAE,CAAC;AAEN,KAAI,SAAU,QAAO;AAErB,QACE,oBAAC;EACC,GAAI;EACC;EACL,gBAAa;EACb,iBAAe;EACf,oBAAkB,eAAe,KAAK;GACtC"}

package/dist/components/data/TableBase/column-menu.d.ts

@@ -1,36 +0,0 @@
-
-import "./types.js";
-import { ReactNode } from "react";
-
-//#region src/components/data/TableBase/column-menu.d.ts
-/**
- * Menu keys the table itself honours.
- *
- * Sorting is the only capability the table owns, so it is the only thing that
- * can be a reserved key. `pin` and `hide` deliberately are not: `column.pin` and
- * `column.isHidden` are read-only declarative inputs with no controlled state
- * behind them, and reserving those keys would fix an API in string literals
- * before the state that backs it exists. They stay ordinary consumer keys and
- * are reported through `onColumnMenuAction` like anything else.
- */
-declare const COLUMN_MENU_SORT_KEYS: readonly ["sort-asc", "sort-desc", "clear-sort"];
-type CubeColumnMenuSortKey = (typeof COLUMN_MENU_SORT_KEYS)[number];
-/**
- * The reserved sort items, ready to drop into `header.menu`.
- *
- * ```tsx
- * header: { menu: <>{columnSortMenu()}<Menu.Item key="pin">Pin</Menu.Item></> }
- * ```
- *
- * Exists because `Menu.Item` requires `children` — it comes from react-stately's
- * `ItemProps` — so `<Menu.Item key="sort-asc" />` does not typecheck, and a
- * consumer filling the label in by hand would hardcode one language and lose the
- * translated one the table supplies. Passing `null` satisfies the type and reads
- * as "the table fills this in", which `processColumnMenuItems` then does.
- *
- * Hand-written keys still work — this is a convenience, not the only route.
- */
-declare function columnSortMenu(keys?: readonly CubeColumnMenuSortKey[]): ReactNode;
-//#endregion
-export { COLUMN_MENU_SORT_KEYS, CubeColumnMenuSortKey, columnSortMenu };
-//# sourceMappingURL=column-menu.d.ts.map

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

@@ -1,104 +0,0 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-34ce1a4 | Cube Dev Team */
-import { __Menu } from "../../actions/Menu/Menu.js";
-import { normalizeMenuAction } from "./row-menu.js";
-import { Children, cloneElement, isValidElement } from "react";
-import { jsx } from "react/jsx-runtime";
-
-//#region src/components/data/TableBase/column-menu.tsx
-/**
-* Menu keys the table itself honours.
-*
-* Sorting is the only capability the table owns, so it is the only thing that
-* can be a reserved key. `pin` and `hide` deliberately are not: `column.pin` and
-* `column.isHidden` are read-only declarative inputs with no controlled state
-* behind them, and reserving those keys would fix an API in string literals
-* before the state that backs it exists. They stay ordinary consumer keys and
-* are reported through `onColumnMenuAction` like anything else.
-*/
-const COLUMN_MENU_SORT_KEYS = [
-	"sort-asc",
-	"sort-desc",
-	"clear-sort"
-];
-function isColumnMenuSortKey(key) {
-	return COLUMN_MENU_SORT_KEYS.includes(key);
-}
-/** The direction a reserved key asks for. `clear-sort` asks for none. */
-const COLUMN_MENU_SORT_DIRECTION = {
-	"sort-asc": "asc",
-	"sort-desc": "desc",
-	"clear-sort": null
-};
-/**
-* Whether a reserved key would do nothing if pressed.
-*
-* Redundancy is signalled by disabling the item rather than by ticking the
-* active one. A tick would mean `isSelected`, which `MenuItem` only honours when
-* the whole `Menu` runs at `selectionMode !== 'none'` (`MenuItem.tsx:43`) — and
-* switching the menu into a selection mode would turn the consumer's own items
-* into radios too, and could be overridden from `menuProps`. Disabling is local
-* to the item and cannot leak.
-*/
-function isSortKeyRedundant(key, ctx) {
-	if (!ctx.isSortable) return true;
-	if (key === "clear-sort") return ctx.sort == null || ctx.disallowSortRemoval;
-	return ctx.sort === COLUMN_MENU_SORT_DIRECTION[key];
-}
-/**
-* Fills in default labels and disabled state for the reserved sort keys.
-*
-* `Children.forEach` rather than `Children.toArray`, because `toArray` rewrites
-* every key with a `.$` prefix — which breaks `selectedKeys` matching inside
-* `Menu`. Same reason `TabButton` does it this way.
-*
-* A label or an `isDisabled` the consumer wrote always wins; this only supplies
-* what was left out, so `<Menu.Item key="sort-asc" />` is the short form and
-* `<Menu.Item key="sort-asc">Oldest first</Menu.Item>` still says what it says.
-*/
-function processColumnMenuItems(children, ctx) {
-	const result = [];
-	Children.forEach(children, (child) => {
-		if (!isValidElement(child)) {
-			result.push(child);
-			return;
-		}
-		const element = child;
-		const childProps = element.props;
-		const key = element.key == null ? null : normalizeMenuAction(element.key);
-		if (key != null && isColumnMenuSortKey(key)) {
-			result.push(cloneElement(element, {
-				children: childProps.children ?? ctx.labels[key],
-				isDisabled: childProps.isDisabled ?? isSortKeyRedundant(key, ctx)
-			}));
-			return;
-		}
-		if (childProps.children != null && typeof childProps.children !== "string" && typeof childProps.children !== "number") {
-			result.push(cloneElement(element, { children: processColumnMenuItems(childProps.children, ctx) }));
-			return;
-		}
-		result.push(child);
-	});
-	return result;
-}
-/**
-* The reserved sort items, ready to drop into `header.menu`.
-*
-* ```tsx
-* header: { menu: <>{columnSortMenu()}<Menu.Item key="pin">Pin</Menu.Item></> }
-* ```
-*
-* Exists because `Menu.Item` requires `children` — it comes from react-stately's
-* `ItemProps` — so `<Menu.Item key="sort-asc" />` does not typecheck, and a
-* consumer filling the label in by hand would hardcode one language and lose the
-* translated one the table supplies. Passing `null` satisfies the type and reads
-* as "the table fills this in", which `processColumnMenuItems` then does.
-*
-* Hand-written keys still work — this is a convenience, not the only route.
-*/
-function columnSortMenu(keys = COLUMN_MENU_SORT_KEYS) {
-	return keys.map((key) => /* @__PURE__ */ jsx(__Menu.Item, { children: null }, key));
-}
-
-//#endregion
-export { COLUMN_MENU_SORT_DIRECTION, COLUMN_MENU_SORT_KEYS, columnSortMenu, isColumnMenuSortKey, processColumnMenuItems };
-//# sourceMappingURL=column-menu.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"column-menu.js","names":["Menu"],"sources":["../../../../src/components/data/TableBase/column-menu.tsx"],"sourcesContent":["import { Children, cloneElement, isValidElement } from 'react';\n\nimport { Menu } from '../../actions/Menu';\n\nimport { normalizeMenuAction } from './row-menu';\n\nimport type { ReactElement, ReactNode } from 'react';\nimport type { CubeTableSortDirection } from './types';\n\n/**\n * Menu keys the table itself honours.\n *\n * Sorting is the only capability the table owns, so it is the only thing that\n * can be a reserved key. `pin` and `hide` deliberately are not: `column.pin` and\n * `column.isHidden` are read-only declarative inputs with no controlled state\n * behind them, and reserving those keys would fix an API in string literals\n * before the state that backs it exists. They stay ordinary consumer keys and\n * are reported through `onColumnMenuAction` like anything else.\n */\nexport const COLUMN_MENU_SORT_KEYS = [\n  'sort-asc',\n  'sort-desc',\n  'clear-sort',\n] as const;\n\nexport type CubeColumnMenuSortKey = (typeof COLUMN_MENU_SORT_KEYS)[number];\n\nexport function isColumnMenuSortKey(key: string): key is CubeColumnMenuSortKey {\n  return (COLUMN_MENU_SORT_KEYS as readonly string[]).includes(key);\n}\n\n/** The direction a reserved key asks for. `clear-sort` asks for none. */\nexport const COLUMN_MENU_SORT_DIRECTION: Record<\n  CubeColumnMenuSortKey,\n  CubeTableSortDirection | null\n> = {\n  'sort-asc': 'asc',\n  'sort-desc': 'desc',\n  'clear-sort': null,\n};\n\nexport interface CubeColumnMenuContext {\n  isSortable: boolean;\n  /** This column's current direction, or `null` when it is unsorted. */\n  sort: CubeTableSortDirection | null;\n  disallowSortRemoval: boolean;\n  /** Default labels, so `TableView` owns the i18n lookup and this stays pure. */\n  labels: Record<CubeColumnMenuSortKey, string>;\n}\n\ninterface MenuItemLikeProps {\n  children?: ReactNode;\n  isDisabled?: boolean;\n}\n\n/**\n * Whether a reserved key would do nothing if pressed.\n *\n * Redundancy is signalled by disabling the item rather than by ticking the\n * active one. A tick would mean `isSelected`, which `MenuItem` only honours when\n * the whole `Menu` runs at `selectionMode !== 'none'` (`MenuItem.tsx:43`) — and\n * switching the menu into a selection mode would turn the consumer's own items\n * into radios too, and could be overridden from `menuProps`. Disabling is local\n * to the item and cannot leak.\n */\nfunction isSortKeyRedundant(\n  key: CubeColumnMenuSortKey,\n  ctx: CubeColumnMenuContext,\n): boolean {\n  if (!ctx.isSortable) return true;\n\n  if (key === 'clear-sort') {\n    return ctx.sort == null || ctx.disallowSortRemoval;\n  }\n\n  return ctx.sort === COLUMN_MENU_SORT_DIRECTION[key];\n}\n\n/**\n * Fills in default labels and disabled state for the reserved sort keys.\n *\n * `Children.forEach` rather than `Children.toArray`, because `toArray` rewrites\n * every key with a `.$` prefix — which breaks `selectedKeys` matching inside\n * `Menu`. Same reason `TabButton` does it this way.\n *\n * A label or an `isDisabled` the consumer wrote always wins; this only supplies\n * what was left out, so `<Menu.Item key=\"sort-asc\" />` is the short form and\n * `<Menu.Item key=\"sort-asc\">Oldest first</Menu.Item>` still says what it says.\n */\nexport function processColumnMenuItems(\n  children: ReactNode,\n  ctx: CubeColumnMenuContext,\n): ReactNode {\n  const result: ReactNode[] = [];\n\n  Children.forEach(children, (child) => {\n    if (!isValidElement(child)) {\n      result.push(child);\n\n      return;\n    }\n\n    const element = child as ReactElement<MenuItemLikeProps>;\n    const childProps = element.props;\n    const key = element.key == null ? null : normalizeMenuAction(element.key);\n\n    if (key != null && isColumnMenuSortKey(key)) {\n      result.push(\n        cloneElement(element, {\n          children: childProps.children ?? ctx.labels[key],\n          isDisabled: childProps.isDisabled ?? isSortKeyRedundant(key, ctx),\n        }),\n      );\n\n      return;\n    }\n\n    // A `Menu.Section` holds the items; recurse so a reserved key inside one is\n    // still resolved. Guarded on a non-text child so an ordinary item whose\n    // label happens to be an element is not walked for no reason.\n    if (\n      childProps.children != null &&\n      typeof childProps.children !== 'string' &&\n      typeof childProps.children !== 'number'\n    ) {\n      result.push(\n        cloneElement(element, {\n          children: processColumnMenuItems(childProps.children, ctx),\n        }),\n      );\n\n      return;\n    }\n\n    result.push(child);\n  });\n\n  // `Children.forEach` preserves order, and each entry keeps the key it was\n  // written with — so React still reconciles these by key, not by index.\n  return result;\n}\n\n/**\n * The reserved sort items, ready to drop into `header.menu`.\n *\n * ```tsx\n * header: { menu: <>{columnSortMenu()}<Menu.Item key=\"pin\">Pin</Menu.Item></> }\n * ```\n *\n * Exists because `Menu.Item` requires `children` — it comes from react-stately's\n * `ItemProps` — so `<Menu.Item key=\"sort-asc\" />` does not typecheck, and a\n * consumer filling the label in by hand would hardcode one language and lose the\n * translated one the table supplies. Passing `null` satisfies the type and reads\n * as \"the table fills this in\", which `processColumnMenuItems` then does.\n *\n * Hand-written keys still work — this is a convenience, not the only route.\n */\nexport function columnSortMenu(\n  keys: readonly CubeColumnMenuSortKey[] = COLUMN_MENU_SORT_KEYS,\n): ReactNode {\n  return keys.map((key) => <Menu.Item key={key}>{null}</Menu.Item>);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAmBA,MAAa,wBAAwB;CACnC;CACA;CACA;CACD;AAID,SAAgB,oBAAoB,KAA2C;AAC7E,QAAQ,sBAA4C,SAAS,IAAI;;;AAInE,MAAa,6BAGT;CACF,YAAY;CACZ,aAAa;CACb,cAAc;CACf;;;;;;;;;;;AA0BD,SAAS,mBACP,KACA,KACS;AACT,KAAI,CAAC,IAAI,WAAY,QAAO;AAE5B,KAAI,QAAQ,aACV,QAAO,IAAI,QAAQ,QAAQ,IAAI;AAGjC,QAAO,IAAI,SAAS,2BAA2B;;;;;;;;;;;;;AAcjD,SAAgB,uBACd,UACA,KACW;CACX,MAAM,SAAsB,EAAE;AAE9B,UAAS,QAAQ,WAAW,UAAU;AACpC,MAAI,CAAC,eAAe,MAAM,EAAE;AAC1B,UAAO,KAAK,MAAM;AAElB;;EAGF,MAAM,UAAU;EAChB,MAAM,aAAa,QAAQ;EAC3B,MAAM,MAAM,QAAQ,OAAO,OAAO,OAAO,oBAAoB,QAAQ,IAAI;AAEzE,MAAI,OAAO,QAAQ,oBAAoB,IAAI,EAAE;AAC3C,UAAO,KACL,aAAa,SAAS;IACpB,UAAU,WAAW,YAAY,IAAI,OAAO;IAC5C,YAAY,WAAW,cAAc,mBAAmB,KAAK,IAAI;IAClE,CAAC,CACH;AAED;;AAMF,MACE,WAAW,YAAY,QACvB,OAAO,WAAW,aAAa,YAC/B,OAAO,WAAW,aAAa,UAC/B;AACA,UAAO,KACL,aAAa,SAAS,EACpB,UAAU,uBAAuB,WAAW,UAAU,IAAI,EAC3D,CAAC,CACH;AAED;;AAGF,SAAO,KAAK,MAAM;GAClB;AAIF,QAAO;;;;;;;;;;;;;;;;;AAkBT,SAAgB,eACd,OAAyC,uBAC9B;AACX,QAAO,KAAK,KAAK,QAAQ,oBAACA,OAAK,kBAAgB,QAAN,IAAuB,CAAC"}

package/dist/components/data/TableBase/column-tint.js

@@ -1,168 +0,0 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-34ce1a4 | Cube Dev Team */
-import { getPaletteConfig } from "../../../tokens/palette-config.js";
-import { hashString } from "../../../tokens/color-theme.js";
-
-//#region src/components/data/TableBase/column-tint.ts
-const THEMES = new Set([
-	"primary",
-	"purple",
-	"success",
-	"danger",
-	"warning",
-	"note"
-]);
-const DEFAULT_SCOPE = [
-	"header",
-	"body",
-	"totals"
-];
-const EMPTY = {
-	slots: /* @__PURE__ */ new Map(),
-	scopes: /* @__PURE__ */ new Map(),
-	configs: [],
-	cellStyles: null,
-	headerCellStyles: null
-};
-/**
-* A theme name is only a theme name when the palette has one — otherwise the
-* string is a colour. `'note'` is a theme; `'#0ea5e9'` and `'red'` are colours.
-*/
-function isThemeName(value) {
-	return THEMES.has(value);
-}
-/**
-* The seed for a palette theme, read from the live palette config so a re-seeded
-* `success` hue moves the columns tinted with it.
-*
-* `primary` and `purple` are the brand itself, which is why they read `hue`
-* rather than a `themes` entry — the palette derives them from the brand hue too.
-*/
-function themeSeed(theme) {
-	const config = getPaletteConfig();
-	if (theme === "primary" || theme === "purple") return {
-		hue: config.hue,
-		saturation: config.saturation
-	};
-	return config.themes[theme];
-}
-/** Normalizes any spec into a theme config, or `null` for the manual form. */
-function tintConfig(color) {
-	if (typeof color === "string") return isThemeName(color) ? themeSeed(color) : { hue: color };
-	if ("fill" in color) return null;
-	return {
-		hue: color.hue,
-		saturation: color.saturation
-	};
-}
-/**
-* A stable identity for a spec, so two columns asking for the same colour share
-* one slot — and therefore one set of generated rules.
-*
-* For a derived spec that identity is the theme's own content hash, which makes it
-* shared across TABLES as well: the tokens are registered globally under the same
-* name. The manual form has no theme, so it is keyed on its literal values.
-*/
-function manualKey(paint) {
-	return `raw-${hashString(`${paint.fill}|${paint.fillBand}|${paint.text}|${paint.headerText}`)}`;
-}
-/**
-* Maps a table's columns onto tint slots and the style maps that paint them.
-*
-* Pure. The colour maths lives in `src/tokens/color-theme.ts`; this is only the
-* mapping from columns to `data-tint` values and tasty state maps.
-*/
-function buildColumnTints(columns, { resolveTheme }) {
-	const tinted = columns.filter((column) => !column.isStructural && column.color != null);
-	if (!tinted.length) return EMPTY;
-	const slots = /* @__PURE__ */ new Map();
-	const scopes = /* @__PURE__ */ new Map();
-	const configs = [];
-	const paints = /* @__PURE__ */ new Map();
-	for (const column of tinted) {
-		const color = column.color;
-		const config = tintConfig(color);
-		let slot;
-		let paint;
-		if (config) {
-			const theme = resolveTheme(config);
-			slot = theme.name;
-			paint = {
-				fill: theme.colors.surface,
-				fillBand: theme.colors["surface-2"],
-				text: theme.colors["surface-2-text"],
-				headerText: theme.colors["surface-2-text-soft"]
-			};
-			if (!paints.has(slot)) configs.push(config);
-		} else {
-			const manual = color;
-			paint = {
-				fill: manual.fill,
-				fillBand: manual.fillBand ?? manual.fill,
-				text: manual.text ?? "#row-text",
-				headerText: manual.text ?? "#row-text"
-			};
-			slot = manualKey(paint);
-		}
-		slots.set(column.key, slot);
-		scopes.set(column.key, column.colorScope ?? DEFAULT_SCOPE);
-		paints.set(slot, paint);
-	}
-	return {
-		slots,
-		scopes,
-		configs,
-		cellStyles: cellTintStyles(paints),
-		headerCellStyles: headerTintStyles(paints)
-	};
-}
-/**
-* `#cell-base` / `#cell-text` for the body.
-*
-* The band and the pinned-total fill share ONE grouped key rather than two
-* entries with the same value: tasty coalesces entries in a state map that
-* serialize identically, promotes them to the group's maximum priority and
-* negates them against everything below — which would silently turn the plain
-* tint branch into `false`. See `src/components/data/AGENTS.md`.
-*/
-function cellTintStyles(paints) {
-	const base = { "": "#row-base" };
-	const text = { "": "#row-text" };
-	for (const [slot, paint] of paints) {
-		base[`@own(tint=${slot})`] = paint.fill;
-		if (paint.fillBand !== paint.fill) base[`@own(tint=${slot}) & (@own(odd) | @own(pinned))`] = paint.fillBand;
-		text[`@own(tint=${slot})`] = paint.text;
-	}
-	return {
-		"#cell-base": base,
-		"#cell-text": text
-	};
-}
-/**
-* The header takes the deeper band unconditionally, mirroring how the neutral
-* header sits on `#surface-2` rather than `#surface`.
-*/
-function headerTintStyles(paints) {
-	const base = { "": "#row-base" };
-	const text = { "": "#row-text" };
-	for (const [slot, paint] of paints) {
-		base[`@own(tint=${slot})`] = paint.fillBand;
-		text[`@own(tint=${slot})`] = paint.headerText;
-	}
-	return {
-		"#cell-base": base,
-		"#cell-text": text
-	};
-}
-/**
-* The `data-tint` value for one part of a column, or `undefined` when the column
-* is untinted or its scope excludes that part.
-*/
-function tintSlot(tints, columnKey, scope) {
-	const slot = tints.slots.get(columnKey);
-	if (slot == null) return void 0;
-	return tints.scopes.get(columnKey)?.includes(scope) ? slot : void 0;
-}
-
-//#endregion
-export { buildColumnTints, tintSlot };
-//# sourceMappingURL=column-tint.js.map

package/dist/components/data/TableBase/column-tint.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"column-tint.js","names":[],"sources":["../../../../src/components/data/TableBase/column-tint.ts"],"sourcesContent":["import { hashString } from '../../../tokens/color-theme';\nimport { getPaletteConfig } from '../../../tokens/palette-config';\n\nimport type { Styles } from '@tenphi/tasty';\nimport type { ColorThemeConfig } from '../../../tokens/color-theme';\nimport type {\n  CubeResolvedColumn,\n  CubeTableColumnColor,\n  CubeTableColumnColorScope,\n  CubeTableColumnTheme,\n} from './types';\n\nconst THEMES = new Set<string>([\n  'primary',\n  'purple',\n  'success',\n  'danger',\n  'warning',\n  'note',\n]);\n\nconst DEFAULT_SCOPE: readonly CubeTableColumnColorScope[] = [\n  'header',\n  'body',\n  'totals',\n];\n\n/** The three paint values a tinted cell needs, as tasty colour strings. */\ninterface TintPaint {\n  fill: string;\n  fillBand: string;\n  text: string;\n  /** The header's text — muted, to match an untinted header. */\n  headerText: string;\n}\n\nexport interface ColumnTints {\n  /** `columnKey` → `data-tint` value. Absent means the column is not tinted. */\n  slots: Map<string, string>;\n  /** Which scopes each column's tint applies to. */\n  scopes: Map<string, readonly CubeTableColumnColorScope[]>;\n  /**\n   * Theme configs to register with `useColorTheme`, one per distinct derived\n   * spec. Empty when every column used the `{ fill, text }` escape hatch.\n   */\n  configs: ColorThemeConfig[];\n  /** Merge into `styles.Cell`. */\n  cellStyles: Styles | null;\n  /** Merge into `styles.HeaderCell`. */\n  headerCellStyles: Styles | null;\n}\n\nconst EMPTY: ColumnTints = {\n  slots: new Map(),\n  scopes: new Map(),\n  configs: [],\n  cellStyles: null,\n  headerCellStyles: null,\n};\n\n/**\n * A theme name is only a theme name when the palette has one — otherwise the\n * string is a colour. `'note'` is a theme; `'#0ea5e9'` and `'red'` are colours.\n */\nfunction isThemeName(value: string): value is CubeTableColumnTheme {\n  return THEMES.has(value);\n}\n\n/**\n * The seed for a palette theme, read from the live palette config so a re-seeded\n * `success` hue moves the columns tinted with it.\n *\n * `primary` and `purple` are the brand itself, which is why they read `hue`\n * rather than a `themes` entry — the palette derives them from the brand hue too.\n */\nfunction themeSeed(theme: CubeTableColumnTheme): {\n  hue: number;\n  saturation: number;\n} {\n  const config = getPaletteConfig();\n\n  if (theme === 'primary' || theme === 'purple') {\n    return { hue: config.hue, saturation: config.saturation };\n  }\n\n  return config.themes[theme];\n}\n\n/** Normalizes any spec into a theme config, or `null` for the manual form. */\nexport function tintConfig(\n  color: CubeTableColumnColor,\n): ColorThemeConfig | null {\n  if (typeof color === 'string') {\n    return isThemeName(color) ? themeSeed(color) : { hue: color };\n  }\n\n  if ('fill' in color) return null;\n\n  return { hue: color.hue, saturation: color.saturation };\n}\n\n/**\n * A stable identity for a spec, so two columns asking for the same colour share\n * one slot — and therefore one set of generated rules.\n *\n * For a derived spec that identity is the theme's own content hash, which makes it\n * shared across TABLES as well: the tokens are registered globally under the same\n * name. The manual form has no theme, so it is keyed on its literal values.\n */\nfunction manualKey(paint: TintPaint): string {\n  // Hashed, not literal: the values contain `#`, `.` and `|`, none of which\n  // survive being interpolated into a tasty `@own(tint=…)` state key.\n  return `raw-${hashString(\n    `${paint.fill}|${paint.fillBand}|${paint.text}|${paint.headerText}`,\n  )}`;\n}\n\nexport interface BuildColumnTintsOptions {\n  /**\n   * Resolves a derived spec to its theme. Injected rather than imported so the\n   * caller — which is a component and can run hooks — owns registration, and so\n   * this stays a pure function.\n   */\n  resolveTheme: (config: ColorThemeConfig) => {\n    name: string;\n    colors: Record<string, string>;\n  };\n}\n\n/**\n * Maps a table's columns onto tint slots and the style maps that paint them.\n *\n * Pure. The colour maths lives in `src/tokens/color-theme.ts`; this is only the\n * mapping from columns to `data-tint` values and tasty state maps.\n */\nexport function buildColumnTints<T>(\n  columns: readonly CubeResolvedColumn<T>[],\n  { resolveTheme }: BuildColumnTintsOptions,\n): ColumnTints {\n  const tinted = columns.filter(\n    (column) => !column.isStructural && column.color != null,\n  );\n\n  if (!tinted.length) return EMPTY;\n\n  const slots = new Map<string, string>();\n  const scopes = new Map<string, readonly CubeTableColumnColorScope[]>();\n  const configs: ColorThemeConfig[] = [];\n  const paints = new Map<string, TintPaint>();\n\n  for (const column of tinted) {\n    const color = column.color as CubeTableColumnColor;\n    const config = tintConfig(color);\n    let slot: string;\n    let paint: TintPaint;\n\n    if (config) {\n      const theme = resolveTheme(config);\n\n      slot = theme.name;\n      paint = {\n        fill: theme.colors.surface,\n        fillBand: theme.colors['surface-2'],\n        text: theme.colors['surface-2-text'],\n        headerText: theme.colors['surface-2-text-soft'],\n      };\n\n      if (!paints.has(slot)) configs.push(config);\n    } else {\n      const manual = color as {\n        fill: string;\n        fillBand?: string;\n        text?: string;\n      };\n\n      paint = {\n        fill: manual.fill,\n        // Without a band the column simply does not band — the caller asked for\n        // exactly these values, so inventing a second one would be a surprise.\n        fillBand: manual.fillBand ?? manual.fill,\n        text: manual.text ?? '#row-text',\n        // The manual form derives nothing, so the header takes the same text.\n        headerText: manual.text ?? '#row-text',\n      };\n      slot = manualKey(paint);\n    }\n\n    slots.set(column.key, slot);\n    scopes.set(column.key, column.colorScope ?? DEFAULT_SCOPE);\n    paints.set(slot, paint);\n  }\n\n  return {\n    slots,\n    scopes,\n    configs,\n    cellStyles: cellTintStyles(paints),\n    headerCellStyles: headerTintStyles(paints),\n  };\n}\n\n/**\n * `#cell-base` / `#cell-text` for the body.\n *\n * The band and the pinned-total fill share ONE grouped key rather than two\n * entries with the same value: tasty coalesces entries in a state map that\n * serialize identically, promotes them to the group's maximum priority and\n * negates them against everything below — which would silently turn the plain\n * tint branch into `false`. See `src/components/data/AGENTS.md`.\n */\nfunction cellTintStyles(paints: Map<string, TintPaint>): Styles {\n  const base: Record<string, string> = { '': '#row-base' };\n  const text: Record<string, string> = { '': '#row-text' };\n\n  for (const [slot, paint] of paints) {\n    base[`@own(tint=${slot})`] = paint.fill;\n    // Only worth a rule when it differs; an identical value here is exactly what\n    // the coalescing trap eats.\n    if (paint.fillBand !== paint.fill) {\n      base[`@own(tint=${slot}) & (@own(odd) | @own(pinned))`] = paint.fillBand;\n    }\n    text[`@own(tint=${slot})`] = paint.text;\n  }\n\n  return { '#cell-base': base, '#cell-text': text };\n}\n\n/**\n * The header takes the deeper band unconditionally, mirroring how the neutral\n * header sits on `#surface-2` rather than `#surface`.\n */\nfunction headerTintStyles(paints: Map<string, TintPaint>): Styles {\n  const base: Record<string, string> = { '': '#row-base' };\n  const text: Record<string, string> = { '': '#row-text' };\n\n  for (const [slot, paint] of paints) {\n    base[`@own(tint=${slot})`] = paint.fillBand;\n    text[`@own(tint=${slot})`] = paint.headerText;\n  }\n\n  return { '#cell-base': base, '#cell-text': text };\n}\n\n/**\n * The `data-tint` value for one part of a column, or `undefined` when the column\n * is untinted or its scope excludes that part.\n */\nexport function tintSlot(\n  tints: ColumnTints,\n  columnKey: string,\n  scope: CubeTableColumnColorScope,\n): string | undefined {\n  const slot = tints.slots.get(columnKey);\n\n  if (slot == null) return undefined;\n\n  return tints.scopes.get(columnKey)?.includes(scope) ? slot : undefined;\n}\n"],"mappings":"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"}

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

@@ -1,100 +0,0 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-34ce1a4 | Cube Dev Team */
-import { useEvent } from "../../../_internal/hooks/use-event.js";
-import { useMemo, 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`.
-*
-* Rank-based rather than filter-then-concat, because `order` is routinely
-* *stale*: it was persisted or lifted into page state before the current
-* `columns` array existed. A column missing from it inherits the rank of the
-* nearest preceding known column plus a half step, so it lands immediately after
-* the neighbour it had in the source array instead of being swept to the end. A
-* new leading column keeps its lead.
-*
-* Applied to the SOURCE array, before `useTableColumns` — so hidden-column
-* filtering, structural injection, pinned hoisting and `aria-colindex` all still
-* happen downstream, and `columnOrder` can never fight `pin`.
-*/
-function applyColumnOrder(columns, order) {
-	if (!order?.length) return columns;
-	const present = new Set(columns.map((column) => column.key));
-	const rank = /* @__PURE__ */ new Map();
-	order.forEach((key, index) => {
-		if (present.has(key) && !rank.has(key)) rank.set(key, index);
-	});
-	if (!rank.size) return columns;
-	let carried = -1;
-	return columns.map((column, sourceIndex) => {
-		const own = rank.get(column.key);
-		if (own != null) carried = own;
-		return {
-			column,
-			sourceIndex,
-			rank: own ?? carried + .5
-		};
-	}).sort((a, b) => a.rank - b.rank || a.sourceIndex - b.sourceIndex).map((entry) => entry.column);
-}
-/**
-* Whether a column can be picked up and moved.
-*
-* The single shared predicate: `DataTable` builds the draggable key list from
-* it and `TableView` decides which `<th>` is a drag source from it, so the two
-* cannot drift. A renderer disagreeing with the state behind it is exactly how
-* the drop indicator that never matched its selector happened.
-*
-* Pinned columns are excluded, for three reasons that all point the same way: a
-* pinned `<th>` is `position: sticky`, so under horizontal scroll its rect sits
-* on top of columns it is nowhere near and React Aria's drop-target binary
-* search goes wrong; `use-table-columns` hoists pinned columns to the edges
-* regardless of source order, so a cross-boundary drop would be undone
-* immediately; and `pin` is already the ordering authority there. What that buys
-* is a draggable set that is one contiguous, non-sticky run — every permutation
-* of which stays monotonic, which is what the delegate needs.
-*/
-function isColumnDraggable(column, isEnabled) {
-	return isEnabled && !column.isStructural && column.pin == null && (column.isReorderable ?? true);
-}
-function getDraggableColumnKeys(columns, isEnabled) {
-	return columns.filter((column) => isColumnDraggable(column, isEnabled)).map((column) => column.key);
-}
-/**
-* Folds a permutation of the draggable subset back into the full order.
-*
-* Only the slots the draggable keys already occupy are rewritten, so a hidden
-* column, a pinned one, or one that opted out keeps its absolute index and
-* cannot be displaced by a drag it took no part in.
-*
-* The visible consequence, worth knowing: a hidden column between two draggable
-* ones keeps its slot rather than following a neighbour, so it may come back
-* between different columns than it left. Predictable beats clever.
-*/
-function projectReorder(fullOrder, nextDraggable) {
-	const draggable = new Set(nextDraggable);
-	const next = [...fullOrder];
-	let cursor = 0;
-	for (let slot = 0; slot < next.length; slot++) if (draggable.has(next[slot])) next[slot] = nextDraggable[cursor++];
-	return next;
-}
-const EMPTY_ORDER = [];
-function useColumnOrder({ columns, columnOrder, defaultColumnOrder, onColumnOrderChange, storage }) {
-	const [storedOrder] = useState(() => columnOrder === void 0 && storage.has("columnOrder") ? storage.initial.columnOrder : void 0);
-	const [order, setOrder] = useControlledState(columnOrder, defaultColumnOrder ?? storedOrder ?? EMPTY_ORDER, onColumnOrderChange);
-	const ordered = useMemo(() => applyColumnOrder(columns, order), [columns, order]);
-	const fullOrder = useMemo(() => ordered.map((column) => column.key), [ordered]);
-	return {
-		columns: ordered,
-		order: fullOrder,
-		reorder: useEvent((nextDraggable) => {
-			const next = projectReorder(fullOrder, nextDraggable);
-			setOrder(next);
-			if (columnOrder === void 0) storage.write({ columnOrder: next });
-		})
-	};
-}
-
-//#endregion
-export { getDraggableColumnKeys, isColumnDraggable, useColumnOrder };
-//# sourceMappingURL=use-column-order.js.map