@cube-dev/ui-kit 0.185.3 → 0.186.1

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

@@ -1 +1 @@
-{"version":3,"file":"use-column-order.js","names":["useControlledState","useMemo","useState","useEvent","CubeResolvedColumn","CubeTableColumn","useTableStorage","applyColumnOrder","columns","T","order","length","present","Set","map","column","key","rank","Map","forEach","index","has","set","size","carried","sourceIndex","own","get","sort","a","b","entry","isColumnDraggable","Pick","isEnabled","isStructural","pin","isReorderable","getDraggableColumnKeys","filter","projectReorder","fullOrder","nextDraggable","draggable","next","cursor","slot","EMPTY_ORDER","UseColumnOrderOptions","columnOrder","defaultColumnOrder","onColumnOrderChange","storage","ReturnType","UseColumnOrderResult","reorder","useColumnOrder","t0","$","_c","t1","undefined","initial","storedOrder","setOrder","value","t2","ordered","t3","_temp","t4","write","t5"],"sources":["../../../../src/components/data/TableBase/use-column-order.ts"],"sourcesContent":["import { useControlledState } from '@react-stately/utils';\nimport { useMemo, useState } from 'react';\n\nimport { useEvent } from '../../../_internal/hooks';\n\nimport type { CubeResolvedColumn, CubeTableColumn } from './types';\nimport type { useTableStorage } from './use-table-storage';\n\n/**\n * Reorders the source columns to match `order`.\n *\n * Rank-based rather than filter-then-concat, because `order` is routinely\n * *stale*: it was persisted or lifted into page state before the current\n * `columns` array existed. A column missing from it inherits the rank of the\n * nearest preceding known column plus a half step, so it lands immediately after\n * the neighbour it had in the source array instead of being swept to the end. A\n * new leading column keeps its lead.\n *\n * Applied to the SOURCE array, before `useTableColumns` — so hidden-column\n * filtering, structural injection, pinned hoisting and `aria-colindex` all still\n * happen downstream, and `columnOrder` can never fight `pin`.\n */\nexport function applyColumnOrder<T>(\n  columns: CubeTableColumn<T>[],\n  order?: readonly string[],\n): CubeTableColumn<T>[] {\n  if (!order?.length) return columns;\n\n  const present = new Set(columns.map((column) => column.key));\n  const rank = new Map<string, number>();\n\n  order.forEach((key, index) => {\n    // A key for a column that no longer exists is ignored rather than treated as\n    // a gap, and a duplicate keeps its first position.\n    if (present.has(key) && !rank.has(key)) rank.set(key, index);\n  });\n\n  if (!rank.size) return columns;\n\n  let carried = -1;\n\n  return columns\n    .map((column, sourceIndex) => {\n      const own = rank.get(column.key);\n\n      if (own != null) carried = own;\n\n      return { column, sourceIndex, rank: own ?? carried + 0.5 };\n    })\n    .sort((a, b) => a.rank - b.rank || a.sourceIndex - b.sourceIndex)\n    .map((entry) => entry.column);\n}\n\n/**\n * Whether a column can be picked up and moved.\n *\n * The single shared predicate: `DataTable` builds the draggable key list from\n * it and `TableView` decides which `<th>` is a drag source from it, so the two\n * cannot drift. A renderer disagreeing with the state behind it is exactly how\n * the drop indicator that never matched its selector happened.\n *\n * Pinned columns are excluded, for three reasons that all point the same way: a\n * pinned `<th>` is `position: sticky`, so under horizontal scroll its rect sits\n * on top of columns it is nowhere near and React Aria's drop-target binary\n * search goes wrong; `use-table-columns` hoists pinned columns to the edges\n * regardless of source order, so a cross-boundary drop would be undone\n * immediately; and `pin` is already the ordering authority there. What that buys\n * is a draggable set that is one contiguous, non-sticky run — every permutation\n * of which stays monotonic, which is what the delegate needs.\n */\nexport function isColumnDraggable<T>(\n  column: Pick<CubeResolvedColumn<T>, 'isStructural' | 'pin' | 'isReorderable'>,\n  isEnabled: boolean,\n): boolean {\n  return (\n    isEnabled &&\n    !column.isStructural &&\n    column.pin == null &&\n    (column.isReorderable ?? true)\n  );\n}\n\nexport function getDraggableColumnKeys<T>(\n  columns: readonly CubeResolvedColumn<T>[],\n  isEnabled: boolean,\n): string[] {\n  return columns\n    .filter((column) => isColumnDraggable(column, isEnabled))\n    .map((column) => column.key);\n}\n\n/**\n * Folds a permutation of the draggable subset back into the full order.\n *\n * Only the slots the draggable keys already occupy are rewritten, so a hidden\n * column, a pinned one, or one that opted out keeps its absolute index and\n * cannot be displaced by a drag it took no part in.\n *\n * The visible consequence, worth knowing: a hidden column between two draggable\n * ones keeps its slot rather than following a neighbour, so it may come back\n * between different columns than it left. Predictable beats clever.\n */\nexport function projectReorder(\n  fullOrder: readonly string[],\n  nextDraggable: readonly string[],\n): string[] {\n  const draggable = new Set(nextDraggable);\n  const next = [...fullOrder];\n  let cursor = 0;\n\n  for (let slot = 0; slot < next.length; slot++) {\n    if (draggable.has(next[slot])) next[slot] = nextDraggable[cursor++];\n  }\n\n  return next;\n}\n\nconst EMPTY_ORDER: string[] = [];\n\nexport interface UseColumnOrderOptions<T> {\n  columns: CubeTableColumn<T>[];\n  columnOrder?: string[];\n  defaultColumnOrder?: string[];\n  onColumnOrderChange?: (order: string[]) => void;\n  storage: ReturnType<typeof useTableStorage>;\n}\n\nexport interface UseColumnOrderResult<T> {\n  /** `columns`, reordered. Feed this to `useTableColumns`. */\n  columns: CubeTableColumn<T>[];\n  /** The full key list in its current order, including hidden and pinned keys. */\n  order: string[];\n  /** Takes the reordered DRAGGABLE keys and commits the full order. */\n  reorder: (nextDraggable: string[]) => void;\n}\n\nexport function useColumnOrder<T>({\n  columns,\n  columnOrder,\n  defaultColumnOrder,\n  onColumnOrderChange,\n  storage,\n}: UseColumnOrderOptions<T>): UseColumnOrderResult<T> {\n  // Seeded once, like `ownColumnWidths`: a controlled `columnOrder` belongs to\n  // the page, so restoring over it would fight the page's own source of truth.\n  const [storedOrder] = useState(() =>\n    columnOrder === undefined && storage.has('columnOrder')\n      ? storage.initial.columnOrder\n      : undefined,\n  );\n\n  // An empty array means \"no order\", which `applyColumnOrder` treats as a\n  // no-op — same shape `useTableSorts` uses for its own empty default, and it\n  // keeps `useControlledState` off the `undefined` overload.\n  const [order, setOrder] = useControlledState<string[]>(\n    columnOrder as string[],\n    defaultColumnOrder ?? storedOrder ?? EMPTY_ORDER,\n    onColumnOrderChange as (value: string[]) => void,\n  );\n\n  const ordered = useMemo(\n    () => applyColumnOrder(columns, order),\n    [columns, order],\n  );\n\n  // Always the FULL source key list, in current order — so a key never drops out\n  // of persisted state just because its column happened to be hidden.\n  const fullOrder = useMemo(\n    () => ordered.map((column) => column.key),\n    [ordered],\n  );\n\n  const reorder = useEvent((nextDraggable: string[]) => {\n    const next = projectReorder(fullOrder, nextDraggable);\n\n    setOrder(next);\n\n    // Only what the table OWNS is persisted — a controlled order belongs to the\n    // page, and storing it would fight the page on the next mount. Same rule\n    // `handleColumnResizeEnd` follows for widths.\n    if (columnOrder === undefined) storage.write({ columnOrder: next });\n  });\n\n  return { columns: ordered, order: fullOrder, reorder };\n}\n"],"mappings":"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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"],"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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"}

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

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.185.3 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.186.1 | Cube Dev Team */
 import { c } from "react-compiler-runtime";
 import { useLayoutEffect, useState } from "react";
 

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

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.185.3 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.186.1 | Cube Dev Team */
 import { c } from "react-compiler-runtime";
 import { useLayoutEffect, useRef } from "react";
 

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

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.185.3 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.186.1 | Cube Dev Team */
 import { c } from "react-compiler-runtime";
 import { useLayoutEffect, useState } from "react";
 

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

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

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

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.185.3 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.186.1 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { useDebouncedValue } from "../../../_internal/hooks/use-debounced-value.js";
 import { getColumnText } from "./use-table-columns.js";

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

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.185.3 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.186.1 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { RowCollection } from "./RowCollection.js";
 import { useCallback, useMemo, useRef } from "react";

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

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.185.3 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.186.1 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { getColumnText, getColumnValue } from "./use-table-columns.js";
 import { c } from "react-compiler-runtime";
@@ -15,7 +15,7 @@ import { useControlledState } from "@react-stately/utils";
 * column reduces it to `asc ↔ desc`.
 */
 function useTableSort(t0) {
-	const $ = c(28);
+	const $ = c(26);
 	const { columns, rows, mode, sort: sortProp, defaultSort, onSortChange } = t0;
 	let t1;
 	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
@@ -92,28 +92,7 @@ function useTableSort(t0) {
 	const setColumnSort = useEvent(t4);
 	let t5;
 	if ($[13] !== collator || $[14] !== columns || $[15] !== resolvedMode || $[16] !== rows || $[17] !== sort) {
-		bb0: {
-			if (resolvedMode !== "client" || !sort) {
-				t5 = rows;
-				break bb0;
-			}
-			let t6;
-			if ($[19] !== sort) {
-				t6 = (entry_1) => entry_1.key === sort.columnKey;
-				$[19] = sort;
-				$[20] = t6;
-			} else t6 = $[20];
-			const column_3 = columns.find(t6);
-			if (!column_3) {
-				t5 = rows;
-				break bb0;
-			}
-			const direction_0 = sort.direction === "asc" ? 1 : -1;
-			t5 = rows.map(_temp2).sort((a, b) => {
-				const result = compareByColumn(column_3, collator, a.row, a.index, b.row, b.index);
-				return result !== 0 ? result * direction_0 : a.index - b.index;
-			}).map(_temp3);
-		}
+		t5 = resolvedMode === "client" && sort ? sortRows(rows, [sort], columns, collator) : rows;
 		$[13] = collator;
 		$[14] = columns;
 		$[15] = resolvedMode;
@@ -123,7 +102,7 @@ function useTableSort(t0) {
 	} else t5 = $[18];
 	const sortedRows = t5;
 	let t6;
-	if ($[21] !== isSortable || $[22] !== resolvedMode || $[23] !== setColumnSort || $[24] !== sort || $[25] !== sortedRows || $[26] !== toggleSort) {
+	if ($[19] !== isSortable || $[20] !== resolvedMode || $[21] !== setColumnSort || $[22] !== sort || $[23] !== sortedRows || $[24] !== toggleSort) {
 		t6 = {
 			sort,
 			sortedRows,
@@ -132,27 +111,44 @@ function useTableSort(t0) {
 			isSortable,
 			mode: resolvedMode
 		};
-		$[21] = isSortable;
-		$[22] = resolvedMode;
-		$[23] = setColumnSort;
-		$[24] = sort;
-		$[25] = sortedRows;
-		$[26] = toggleSort;
-		$[27] = t6;
-	} else t6 = $[27];
+		$[19] = isSortable;
+		$[20] = resolvedMode;
+		$[21] = setColumnSort;
+		$[22] = sort;
+		$[23] = sortedRows;
+		$[24] = toggleSort;
+		$[25] = t6;
+	} else t6 = $[25];
 	return t6;
 }
-function _temp3(entry_2) {
-	return entry_2.row;
+/**
+* `rows` ordered by `sorts`, the first sort taking precedence. Sorts naming a
+* column the table does not have are skipped, and `rows` itself comes back when
+* none is left.
+*
+* `map`/`sort`/`map` rather than sorting in place: `rows` is the caller's array
+* and `Array.prototype.sort` mutates. Carrying the original index also makes the
+* sort stable across engines, including when every sort ties.
+*/
+function _temp(column) {
+	return column.isSortable;
 }
-function _temp2(row, index) {
-	return {
+function sortRows(rows, sorts, columns, collator) {
+	const active = sorts.map((sort) => ({
+		sort,
+		column: columns.find((entry) => entry.key === sort.columnKey)
+	})).filter((entry) => entry.column != null);
+	if (!active.length) return rows;
+	return rows.map((row, index) => ({
 		row,
 		index
-	};
-}
-function _temp(column) {
-	return column.isSortable;
+	})).sort((a, b) => {
+		for (const { sort, column } of active) {
+			const result = compareByColumn(column, collator, a.row, a.index, b.row, b.index);
+			if (result !== 0) return result * (sort.direction === "asc" ? 1 : -1);
+		}
+		return a.index - b.index;
+	}).map((entry) => entry.row);
 }
 function compareByColumn(column, collator, rowA, indexA, rowB, indexB) {
 	const valueA = getColumnValue(column, rowA, indexA);
@@ -170,5 +166,5 @@ function compareByColumn(column, collator, rowA, indexA, rowB, indexB) {
 }
 
 //#endregion
-export { compareByColumn, useTableSort };
+export { compareByColumn, sortRows, useTableSort };
 //# sourceMappingURL=use-table-sort.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"use-table-sort.js","names":["useControlledState","useMemo","useCollator","useEvent","getColumnText","getColumnValue","CubeTableColumn","CubeTableSort","CubeTableSortDirection","CubeTableSortMode","UseTableSortOptions","columns","T","rows","mode","sort","defaultSort","onSortChange","UseTableSortResult","sortedRows","toggleSort","columnKey","setColumnSort","direction","isSortable","column","useTableSort","t0","$","_c","sortProp","t1","Symbol","for","numeric","sensitivity","collator","setSort","value","hasSortableColumn","some","_temp","resolvedMode","t2","column_0","t3","column_1","find","entry","key","disallowSortRemoval","t4","columnKey_0","column_2","entry_0","t5","bb0","t6","entry_1","column_3","direction_0","map","_temp2","a","b","result","compareByColumn","row","index","_temp3","entry_2","Intl","Collator","rowA","indexA","rowB","indexB","valueA","valueB","compare","Number","Date","getTime","textA","String","textB"],"sources":["../../../../src/components/data/TableBase/use-table-sort.ts"],"sourcesContent":["import { useControlledState } from '@react-stately/utils';\nimport { useMemo } from 'react';\nimport { useCollator } from 'react-aria';\n\nimport { useEvent } from '../../../_internal/hooks';\n\nimport { getColumnText, getColumnValue } from './use-table-columns';\n\nimport type {\n  CubeTableColumn,\n  CubeTableSort,\n  CubeTableSortDirection,\n} from './types';\n\nexport type CubeTableSortMode = 'client' | 'server' | 'off';\n\nexport interface UseTableSortOptions<T> {\n  columns: CubeTableColumn<T>[];\n  rows: readonly T[];\n  /** @default 'client' when any column is sortable, else 'off' */\n  mode?: CubeTableSortMode;\n  sort?: CubeTableSort | null;\n  defaultSort?: CubeTableSort | null;\n  onSortChange?: (sort: CubeTableSort | null) => void;\n}\n\nexport interface UseTableSortResult<T> {\n  sort: CubeTableSort | null;\n  /** `rows` reordered in client mode; the original array otherwise. */\n  sortedRows: readonly T[];\n  /** Advances a column through the sort cycle. */\n  toggleSort: (columnKey: string) => void;\n  /**\n   * Sets a column's direction outright. `null` clears it.\n   *\n   * For the column menu's reserved sort keys, which have to reach a specific\n   * direction in one step rather than cycling to it.\n   */\n  setColumnSort: (\n    columnKey: string,\n    direction: CubeTableSortDirection | null,\n  ) => void;\n  isSortable: (column: CubeTableColumn<T>) => boolean;\n  /**\n   * The mode after defaulting. The renderer needs this exact answer to decide\n   * whether a header is clickable, and deriving it a second time at the call\n   * site is how `DataTable` ended up sorting on `defaultSorts` but ignoring\n   * every click.\n   */\n  mode: CubeTableSortMode;\n}\n\n/**\n * Sort state plus, in client mode, the reordered rows.\n *\n * The cycle is tri-state — `asc → desc → unsorted` — matching ag-grid's default\n * `sortingOrder`, because losing the ability to get back to the source order is\n * a real loss when the source order is meaningful. `disallowSortRemoval` on a\n * column reduces it to `asc ↔ desc`.\n */\nexport function useTableSort<T>({\n  columns,\n  rows,\n  mode,\n  sort: sortProp,\n  defaultSort,\n  onSortChange,\n}: UseTableSortOptions<T>): UseTableSortResult<T> {\n  // A collator gives locale-correct, case-insensitive ordering — \"Ä\" sorts next\n  // to \"A\" rather than after \"Z\", which a raw `<` comparison gets wrong.\n  const collator = useCollator({ numeric: true, sensitivity: 'base' });\n\n  const [sort, setSort] = useControlledState<CubeTableSort | null>(\n    sortProp as CubeTableSort | null,\n    defaultSort ?? null,\n    onSortChange as (value: CubeTableSort | null) => void,\n  );\n\n  const hasSortableColumn = columns.some((column) => column.isSortable);\n  const resolvedMode: CubeTableSortMode =\n    mode ?? (hasSortableColumn ? 'client' : 'off');\n\n  const isSortable = useEvent(\n    (column: CubeTableColumn<T>) =>\n      resolvedMode !== 'off' && column.isSortable === true,\n  );\n\n  const toggleSort = useEvent((columnKey: string) => {\n    const column = columns.find((entry) => entry.key === columnKey);\n\n    if (!column || !isSortable(column)) return;\n\n    if (sort?.columnKey !== columnKey) {\n      setSort({ columnKey, direction: 'asc' });\n\n      return;\n    }\n\n    if (sort.direction === 'asc') {\n      setSort({ columnKey, direction: 'desc' });\n\n      return;\n    }\n\n    setSort(\n      column.disallowSortRemoval ? { columnKey, direction: 'asc' } : null,\n    );\n  });\n\n  /**\n   * Set the column's direction outright instead of advancing the cycle — see\n   * `use-table-sorts.ts` for why the column menu cannot reuse `toggleSort`.\n   */\n  const setColumnSort = useEvent(\n    (columnKey: string, direction: CubeTableSortDirection | null) => {\n      const column = columns.find((entry) => entry.key === columnKey);\n\n      if (!column || !isSortable(column)) return;\n\n      if (direction == null) {\n        // Clearing a column that is not the sorted one is a no-op rather than a\n        // reset, and `disallowSortRemoval` refuses the clear outright.\n        if (sort?.columnKey !== columnKey || column.disallowSortRemoval) return;\n\n        setSort(null);\n\n        return;\n      }\n\n      if (sort?.columnKey === columnKey && sort.direction === direction) return;\n\n      setSort({ columnKey, direction });\n    },\n  );\n\n  const sortedRows = useMemo(() => {\n    if (resolvedMode !== 'client' || !sort) return rows;\n\n    const column = columns.find((entry) => entry.key === sort.columnKey);\n\n    if (!column) return rows;\n\n    const direction = sort.direction === 'asc' ? 1 : -1;\n\n    // `map`/`sort`/`map` rather than sorting in place: `rows` is the caller's\n    // array and `Array.prototype.sort` mutates. Carrying the original index also\n    // makes the sort stable across engines.\n    return rows\n      .map((row, index) => ({ row, index }))\n      .sort((a, b) => {\n        const result = compareByColumn(\n          column,\n          collator,\n          a.row,\n          a.index,\n          b.row,\n          b.index,\n        );\n\n        return result !== 0 ? result * direction : a.index - b.index;\n      })\n      .map((entry) => entry.row);\n  }, [resolvedMode, sort, rows, columns, collator]);\n\n  // The resolved mode is returned rather than left for the caller to derive\n  // again: the renderer needs the same answer to decide whether a header is\n  // clickable, and two independent derivations drift.\n  return {\n    sort,\n    sortedRows,\n    toggleSort,\n    setColumnSort,\n    isSortable,\n    mode: resolvedMode,\n  };\n}\n\nexport function compareByColumn<T>(\n  column: CubeTableColumn<T>,\n  collator: Intl.Collator,\n  rowA: T,\n  indexA: number,\n  rowB: T,\n  indexB: number,\n): number {\n  const valueA = getColumnValue(column, rowA, indexA);\n  const valueB = getColumnValue(column, rowB, indexB);\n\n  if (column.compare) return column.compare(valueA, valueB, rowA, rowB);\n\n  // Nullish always sorts first, then gets flipped with the direction. Mixing\n  // them into the value comparison instead produces an unstable order.\n  if (valueA == null && valueB == null) return 0;\n  if (valueA == null) return -1;\n  if (valueB == null) return 1;\n\n  if (typeof valueA === 'number' && typeof valueB === 'number') {\n    return valueA - valueB;\n  }\n  if (typeof valueA === 'boolean' && typeof valueB === 'boolean') {\n    return Number(valueA) - Number(valueB);\n  }\n  if (valueA instanceof Date && valueB instanceof Date) {\n    return valueA.getTime() - valueB.getTime();\n  }\n\n  // Fall back to display text, so a column with a `format` sorts the way it\n  // reads rather than the way it is stored.\n  const textA = getColumnText(column, rowA, indexA) ?? String(valueA);\n  const textB = getColumnText(column, rowB, indexB) ?? String(valueB);\n\n  return collator.compare(textA, textB);\n}\n"],"mappings":"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"}
+{"version":3,"file":"use-table-sort.js","names":["useControlledState","useCollator","useEvent","getColumnText","getColumnValue","CubeTableColumn","CubeTableSort","CubeTableSortDirection","CubeTableSortMode","UseTableSortOptions","columns","T","rows","mode","sort","defaultSort","onSortChange","UseTableSortResult","sortedRows","toggleSort","columnKey","setColumnSort","direction","isSortable","column","useTableSort","t0","$","_c","sortProp","t1","Symbol","for","numeric","sensitivity","collator","setSort","value","hasSortableColumn","some","_temp","resolvedMode","t2","column_0","t3","column_1","find","entry","key","disallowSortRemoval","t4","columnKey_0","column_2","entry_0","t5","sortRows","t6","sorts","Intl","Collator","active","map","filter","length","row","index","a","b","result","compareByColumn","rowA","indexA","rowB","indexB","valueA","valueB","compare","Number","Date","getTime","textA","String","textB"],"sources":["../../../../src/components/data/TableBase/use-table-sort.ts"],"sourcesContent":["import { useControlledState } from '@react-stately/utils';\nimport { useCollator } from 'react-aria';\n\nimport { useEvent } from '../../../_internal/hooks';\n\nimport { getColumnText, getColumnValue } from './use-table-columns';\n\nimport type {\n  CubeTableColumn,\n  CubeTableSort,\n  CubeTableSortDirection,\n} from './types';\n\nexport type CubeTableSortMode = 'client' | 'server' | 'off';\n\nexport interface UseTableSortOptions<T> {\n  columns: CubeTableColumn<T>[];\n  rows: readonly T[];\n  /** @default 'client' when any column is sortable, else 'off' */\n  mode?: CubeTableSortMode;\n  sort?: CubeTableSort | null;\n  defaultSort?: CubeTableSort | null;\n  onSortChange?: (sort: CubeTableSort | null) => void;\n}\n\nexport interface UseTableSortResult<T> {\n  sort: CubeTableSort | null;\n  /** `rows` reordered in client mode; the original array otherwise. */\n  sortedRows: readonly T[];\n  /** Advances a column through the sort cycle. */\n  toggleSort: (columnKey: string) => void;\n  /**\n   * Sets a column's direction outright. `null` clears it.\n   *\n   * For the column menu's reserved sort keys, which have to reach a specific\n   * direction in one step rather than cycling to it.\n   */\n  setColumnSort: (\n    columnKey: string,\n    direction: CubeTableSortDirection | null,\n  ) => void;\n  isSortable: (column: CubeTableColumn<T>) => boolean;\n  /**\n   * The mode after defaulting. The renderer needs this exact answer to decide\n   * whether a header is clickable, and deriving it a second time at the call\n   * site is how `DataTable` ended up sorting on `defaultSorts` but ignoring\n   * every click.\n   */\n  mode: CubeTableSortMode;\n}\n\n/**\n * Sort state plus, in client mode, the reordered rows.\n *\n * The cycle is tri-state — `asc → desc → unsorted` — matching ag-grid's default\n * `sortingOrder`, because losing the ability to get back to the source order is\n * a real loss when the source order is meaningful. `disallowSortRemoval` on a\n * column reduces it to `asc ↔ desc`.\n */\nexport function useTableSort<T>({\n  columns,\n  rows,\n  mode,\n  sort: sortProp,\n  defaultSort,\n  onSortChange,\n}: UseTableSortOptions<T>): UseTableSortResult<T> {\n  // A collator gives locale-correct, case-insensitive ordering — \"Ä\" sorts next\n  // to \"A\" rather than after \"Z\", which a raw `<` comparison gets wrong.\n  const collator = useCollator({ numeric: true, sensitivity: 'base' });\n\n  const [sort, setSort] = useControlledState<CubeTableSort | null>(\n    sortProp as CubeTableSort | null,\n    defaultSort ?? null,\n    onSortChange as (value: CubeTableSort | null) => void,\n  );\n\n  const hasSortableColumn = columns.some((column) => column.isSortable);\n  const resolvedMode: CubeTableSortMode =\n    mode ?? (hasSortableColumn ? 'client' : 'off');\n\n  const isSortable = useEvent(\n    (column: CubeTableColumn<T>) =>\n      resolvedMode !== 'off' && column.isSortable === true,\n  );\n\n  const toggleSort = useEvent((columnKey: string) => {\n    const column = columns.find((entry) => entry.key === columnKey);\n\n    if (!column || !isSortable(column)) return;\n\n    if (sort?.columnKey !== columnKey) {\n      setSort({ columnKey, direction: 'asc' });\n\n      return;\n    }\n\n    if (sort.direction === 'asc') {\n      setSort({ columnKey, direction: 'desc' });\n\n      return;\n    }\n\n    setSort(\n      column.disallowSortRemoval ? { columnKey, direction: 'asc' } : null,\n    );\n  });\n\n  /**\n   * Set the column's direction outright instead of advancing the cycle — see\n   * `use-table-sorts.ts` for why the column menu cannot reuse `toggleSort`.\n   */\n  const setColumnSort = useEvent(\n    (columnKey: string, direction: CubeTableSortDirection | null) => {\n      const column = columns.find((entry) => entry.key === columnKey);\n\n      if (!column || !isSortable(column)) return;\n\n      if (direction == null) {\n        // Clearing a column that is not the sorted one is a no-op rather than a\n        // reset, and `disallowSortRemoval` refuses the clear outright.\n        if (sort?.columnKey !== columnKey || column.disallowSortRemoval) return;\n\n        setSort(null);\n\n        return;\n      }\n\n      if (sort?.columnKey === columnKey && sort.direction === direction) return;\n\n      setSort({ columnKey, direction });\n    },\n  );\n\n  const sortedRows =\n    resolvedMode === 'client' && sort\n      ? sortRows(rows, [sort], columns, collator)\n      : rows;\n\n  // The resolved mode is returned rather than left for the caller to derive\n  // again: the renderer needs the same answer to decide whether a header is\n  // clickable, and two independent derivations drift.\n  return {\n    sort,\n    sortedRows,\n    toggleSort,\n    setColumnSort,\n    isSortable,\n    mode: resolvedMode,\n  };\n}\n\n/**\n * `rows` ordered by `sorts`, the first sort taking precedence. Sorts naming a\n * column the table does not have are skipped, and `rows` itself comes back when\n * none is left.\n *\n * `map`/`sort`/`map` rather than sorting in place: `rows` is the caller's array\n * and `Array.prototype.sort` mutates. Carrying the original index also makes the\n * sort stable across engines, including when every sort ties.\n */\nexport function sortRows<T>(\n  rows: readonly T[],\n  sorts: readonly CubeTableSort[],\n  columns: CubeTableColumn<T>[],\n  collator: Intl.Collator,\n): readonly T[] {\n  const active = sorts\n    .map((sort) => ({\n      sort,\n      column: columns.find((entry) => entry.key === sort.columnKey),\n    }))\n    .filter(\n      (entry): entry is { sort: CubeTableSort; column: CubeTableColumn<T> } =>\n        entry.column != null,\n    );\n\n  if (!active.length) return rows;\n\n  return rows\n    .map((row, index) => ({ row, index }))\n    .sort((a, b) => {\n      for (const { sort, column } of active) {\n        const result = compareByColumn(\n          column,\n          collator,\n          a.row,\n          a.index,\n          b.row,\n          b.index,\n        );\n\n        if (result !== 0) {\n          return result * (sort.direction === 'asc' ? 1 : -1);\n        }\n      }\n\n      return a.index - b.index;\n    })\n    .map((entry) => entry.row);\n}\n\nexport function compareByColumn<T>(\n  column: CubeTableColumn<T>,\n  collator: Intl.Collator,\n  rowA: T,\n  indexA: number,\n  rowB: T,\n  indexB: number,\n): number {\n  const valueA = getColumnValue(column, rowA, indexA);\n  const valueB = getColumnValue(column, rowB, indexB);\n\n  if (column.compare) return column.compare(valueA, valueB, rowA, rowB);\n\n  // Nullish always sorts first, then gets flipped with the direction. Mixing\n  // them into the value comparison instead produces an unstable order.\n  if (valueA == null && valueB == null) return 0;\n  if (valueA == null) return -1;\n  if (valueB == null) return 1;\n\n  if (typeof valueA === 'number' && typeof valueB === 'number') {\n    return valueA - valueB;\n  }\n  if (typeof valueA === 'boolean' && typeof valueB === 'boolean') {\n    return Number(valueA) - Number(valueB);\n  }\n  if (valueA instanceof Date && valueB instanceof Date) {\n    return valueA.getTime() - valueB.getTime();\n  }\n\n  // Fall back to display text, so a column with a `format` sorts the way it\n  // reads rather than the way it is stored.\n  const textA = getColumnText(column, rowA, indexA) ?? String(valueA);\n  const textB = getColumnText(column, rowB, indexB) ?? String(valueB);\n\n  return collator.compare(textA, textB);\n}\n"],"mappings":";;;;;;;;;;;;;;;;AA2DA,SAAOyB,aAAAC,IAAA;CAAA,MAAAC,IAAAC,EAAA,GAAA;CAAyB,MAAA,EAAAlB,SAAAE,MAAAC,MAAAC,MAAAe,UAAAd,aAAAC,iBAAAU;CAOP,IAAAI;AAAA,KAAAH,EAAA,OAAAI,OAAAC,IAAA,4BAAA,EAAA;AAGMF,OAAA;GAAAG,SAAW;GAAIC,aAAe;GAAQ;AAAAP,IAAA,KAAAG;OAAAA,MAAAH,EAAA;CAAnE,MAAAQ,WAAiBlC,YAAY6B,GAAuC;CAEpE,MAAA,CAAAhB,MAAAsB,WAAwBpC,mBACtB6B,UACAd,eAAA,MACAC,aACD;CAED,MAAAsB,oBAA0B5B,QAAO6B,KAAMC,MAA8B;CACrE,MAAAC,eACE5B,SAASyB,oBAAA,WAAA;CAAsC,IAAAI;AAAA,KAAAf,EAAA,OAAAc,cAAA;AAG/CC,QAAAC,aACEF,iBAAiB,SAASjB,SAAMD,eAAgB;AAAII,IAAA,KAAAc;AAAAd,IAAA,KAAAe;OAAAA,MAAAf,EAAA;CAFxD,MAAAJ,aAAmBrB,SACjBwC,GAED;CAAC,IAAAE;AAAA,KAAAjB,EAAA,OAAAjB,WAAAiB,EAAA,OAAAJ,cAAAI,EAAA,OAAAS,WAAAT,EAAA,OAAAb,MAAA;AAE0B8B,QAAAxB,cAAA;GAC1B,MAAAyB,WAAenC,QAAOoC,MAAMC,UAAWA,MAAKC,QAAS5B,UAAU;AAE/D,OAAI,CAACI,YAAD,CAAYD,WAAWC,SAAO,CAAA;AAElC,OAAIV,MAAIM,cAAgBA,WAAS;AAC/BgB,YAAQ;KAAAhB;KAAAE,WAAwB;KAAO,CAAC;AAAA;;AAK1C,OAAIR,KAAIQ,cAAe,OAAK;AAC1Bc,YAAQ;KAAAhB;KAAAE,WAAwB;KAAQ,CAAC;AAAA;;AAK3Cc,WACEZ,SAAMyB,sBAAN;IAAA7B;IAAAE,WAAqD;IAAc,GAAnE,KACD;;AACFK,IAAA,KAAAjB;AAAAiB,IAAA,KAAAJ;AAAAI,IAAA,KAAAS;AAAAT,IAAA,KAAAb;AAAAa,IAAA,KAAAiB;OAAAA,MAAAjB,EAAA;CApBD,MAAAR,aAAmBjB,SAAS0C,GAoB1B;CAAC,IAAAM;AAAA,KAAAvB,EAAA,OAAAjB,WAAAiB,EAAA,OAAAJ,cAAAI,EAAA,QAAAS,WAAAT,EAAA,QAAAb,MAAA;AAODoC,QAAAC,aAAA7B,cAAA;GACE,MAAA8B,WAAe1C,QAAOoC,MAAMO,YAAWN,QAAKC,QAAS5B,YAAU;AAE/D,OAAI,CAACI,YAAD,CAAYD,WAAWC,SAAO,CAAA;AAElC,OAAIF,aAAa,MAAI;AAGnB,QAAIR,MAAIM,cAAgBA,eAAaI,SAAMyB,oBAAoB;AAE/Db,YAAQ,KAAK;AAAA;;AAKf,OAAItB,MAAIM,cAAgBA,eAAaN,KAAIQ,cAAeA,UAAS;AAEjEc,WAAQ;IAAAhB,WAAEA;IAASE;IAAa,CAAC;;AAClCK,IAAA,KAAAjB;AAAAiB,IAAA,KAAAJ;AAAAI,IAAA,MAAAS;AAAAT,IAAA,MAAAb;AAAAa,IAAA,MAAAuB;OAAAA,MAAAvB,EAAA;CAnBH,MAAAN,gBAAsBnB,SACpBgD,GAmBD;CAAC,IAAAI;AAAA,KAAA3B,EAAA,QAAAQ,YAAAR,EAAA,QAAAjB,WAAAiB,EAAA,QAAAc,gBAAAd,EAAA,QAAAf,QAAAe,EAAA,QAAAb,MAAA;AAGAwC,OAAAb,iBAAiB,YAAjB3B,OACIyC,SAAS3C,MAAM,CAACE,KAAK,EAAEJ,SAASyB,SAC5B,GAFRvB;AAEQe,IAAA,MAAAQ;AAAAR,IAAA,MAAAjB;AAAAiB,IAAA,MAAAc;AAAAd,IAAA,MAAAf;AAAAe,IAAA,MAAAb;AAAAa,IAAA,MAAA2B;OAAAA,MAAA3B,EAAA;CAHV,MAAAT,aACEoC;CAES,IAAAE;AAAA,KAAA7B,EAAA,QAAAJ,cAAAI,EAAA,QAAAc,gBAAAd,EAAA,QAAAN,iBAAAM,EAAA,QAAAb,QAAAa,EAAA,QAAAT,cAAAS,EAAA,QAAAR,YAAA;AAKJqC,OAAA;GAAA1C;GAAAI;GAAAC;GAAAE;GAAAE;GAAAV,MAMC4B;GACP;AAAAd,IAAA,MAAAJ;AAAAI,IAAA,MAAAc;AAAAd,IAAA,MAAAN;AAAAM,IAAA,MAAAb;AAAAa,IAAA,MAAAT;AAAAS,IAAA,MAAAR;AAAAQ,IAAA,MAAA6B;OAAAA,MAAA7B,EAAA;AAAA,QAPM6B;;;;;;;;;;;AAnFF,SAAAhB,MAAAhB,QAAA;AAAA,QAkB8CA,OAAMD;;AAoF3D,SAAgBgC,SACd3C,MACA6C,OACA/C,SACAyB,UACc;CACd,MAAMyB,SAASH,MACZI,KAAK/C,UAAU;EACdA;EACAU,QAAQd,QAAQoC,MAAMC,UAAUA,MAAMC,QAAQlC,KAAKM,UAAS;EAC7D,EAAE,CACF0C,QACEf,UACCA,MAAMvB,UAAU,KACnB;AAEH,KAAI,CAACoC,OAAOG,OAAQ,QAAOnD;AAE3B,QAAOA,KACJiD,KAAKG,KAAKC,WAAW;EAAED;EAAKC;EAAO,EAAE,CACrCnD,MAAMoD,GAAGC,MAAM;AACd,OAAK,MAAM,EAAErD,MAAMU,YAAYoC,QAAQ;GACrC,MAAMQ,SAASC,gBACb7C,QACAW,UACA+B,EAAEF,KACFE,EAAED,OACFE,EAAEH,KACFG,EAAEF,MACH;AAED,OAAIG,WAAW,EACb,QAAOA,UAAUtD,KAAKQ,cAAc,QAAQ,IAAI;;AAIpD,SAAO4C,EAAED,QAAQE,EAAEF;GACnB,CACDJ,KAAKd,UAAUA,MAAMiB,IAAI;;AAG9B,SAAgBK,gBACd7C,QACAW,UACAmC,MACAC,QACAC,MACAC,QACQ;CACR,MAAMC,SAAStE,eAAeoB,QAAQ8C,MAAMC,OAAO;CACnD,MAAMI,SAASvE,eAAeoB,QAAQgD,MAAMC,OAAO;AAEnD,KAAIjD,OAAOoD,QAAS,QAAOpD,OAAOoD,QAAQF,QAAQC,QAAQL,MAAME,KAAK;AAIrE,KAAIE,UAAU,QAAQC,UAAU,KAAM,QAAO;AAC7C,KAAID,UAAU,KAAM,QAAO;AAC3B,KAAIC,UAAU,KAAM,QAAO;AAE3B,KAAI,OAAOD,WAAW,YAAY,OAAOC,WAAW,SAClD,QAAOD,SAASC;AAElB,KAAI,OAAOD,WAAW,aAAa,OAAOC,WAAW,UACnD,QAAOE,OAAOH,OAAO,GAAGG,OAAOF,OAAO;AAExC,KAAID,kBAAkBI,QAAQH,kBAAkBG,KAC9C,QAAOJ,OAAOK,SAAS,GAAGJ,OAAOI,SAAS;CAK5C,MAAMC,QAAQ7E,cAAcqB,QAAQ8C,MAAMC,OAAO,IAAIU,OAAOP,OAAO;CACnE,MAAMQ,QAAQ/E,cAAcqB,QAAQgD,MAAMC,OAAO,IAAIQ,OAAON,OAAO;AAEnE,QAAOxC,SAASyC,QAAQI,OAAOE,MAAM"}

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

@@ -1,6 +1,6 @@
-/** @license MIT | @cube-dev/ui-kit v0.185.3 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.186.1 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
-import { compareByColumn } from "./use-table-sort.js";
+import { sortRows } from "./use-table-sort.js";
 import { c } from "react-compiler-runtime";
 import { useControlledState } from "@react-stately/utils";
 import { useCollator } from "@react-aria/i18n";
@@ -20,7 +20,7 @@ const EMPTY = [];
 * replacing the whole sort, so the other columns keep their precedence.
 */
 function useTableSorts(t0) {
-	const $ = c(31);
+	const $ = c(29);
 	const { columns, rows, mode, sorts: sortsProp, defaultSorts, onSortsChange } = t0;
 	let t1;
 	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
@@ -118,33 +118,7 @@ function useTableSorts(t0) {
 	const setColumnSort = useEvent(t4);
 	let t5;
 	if ($[13] !== collator || $[14] !== columns || $[15] !== resolvedMode || $[16] !== rows || $[17] !== sorts) {
-		bb0: {
-			if (resolvedMode !== "client" || !sorts.length) {
-				t5 = rows;
-				break bb0;
-			}
-			let t6;
-			if ($[19] !== columns) {
-				t6 = (sort) => ({
-					sort,
-					column: columns.find((entry_3) => entry_3.key === sort.columnKey)
-				});
-				$[19] = columns;
-				$[20] = t6;
-			} else t6 = $[20];
-			const active = sorts.map(t6).filter(_temp2);
-			if (!active.length) {
-				t5 = rows;
-				break bb0;
-			}
-			t5 = rows.map(_temp3).sort((a, b) => {
-				for (const { sort: sort_0, column: column_3 } of active) {
-					const result = compareByColumn(column_3, collator, a.row, a.index, b.row, b.index);
-					if (result !== 0) return result * (sort_0.direction === "asc" ? 1 : -1);
-				}
-				return a.index - b.index;
-			}).map(_temp4);
-		}
+		t5 = resolvedMode === "client" ? sortRows(rows, sorts, columns, collator) : rows;
 		$[13] = collator;
 		$[14] = columns;
 		$[15] = resolvedMode;
@@ -154,14 +128,14 @@ function useTableSorts(t0) {
 	} else t5 = $[18];
 	const sortedRows = t5;
 	let t6;
-	if ($[21] !== sorts) {
-		t6 = (columnKey_1) => sorts.findIndex((entry_6) => entry_6.columnKey === columnKey_1) + 1;
-		$[21] = sorts;
-		$[22] = t6;
-	} else t6 = $[22];
+	if ($[19] !== sorts) {
+		t6 = (columnKey_1) => sorts.findIndex((entry_3) => entry_3.columnKey === columnKey_1) + 1;
+		$[19] = sorts;
+		$[20] = t6;
+	} else t6 = $[20];
 	const sortRank = useEvent(t6);
 	let t7;
-	if ($[23] !== isSortable || $[24] !== resolvedMode || $[25] !== setColumnSort || $[26] !== sortRank || $[27] !== sortedRows || $[28] !== sorts || $[29] !== toggleSort) {
+	if ($[21] !== isSortable || $[22] !== resolvedMode || $[23] !== setColumnSort || $[24] !== sortRank || $[25] !== sortedRows || $[26] !== sorts || $[27] !== toggleSort) {
 		t7 = {
 			sorts,
 			sortedRows,
@@ -171,29 +145,17 @@ function useTableSorts(t0) {
 			sortRank,
 			mode: resolvedMode
 		};
-		$[23] = isSortable;
-		$[24] = resolvedMode;
-		$[25] = setColumnSort;
-		$[26] = sortRank;
-		$[27] = sortedRows;
-		$[28] = sorts;
-		$[29] = toggleSort;
-		$[30] = t7;
-	} else t7 = $[30];
+		$[21] = isSortable;
+		$[22] = resolvedMode;
+		$[23] = setColumnSort;
+		$[24] = sortRank;
+		$[25] = sortedRows;
+		$[26] = sorts;
+		$[27] = toggleSort;
+		$[28] = t7;
+	} else t7 = $[28];
 	return t7;
 }
-function _temp4(entry_5) {
-	return entry_5.row;
-}
-function _temp3(row, index_1) {
-	return {
-		row,
-		index: index_1
-	};
-}
-function _temp2(entry_4) {
-	return entry_4.column != null;
-}
 function _temp(column) {
 	return column.isSortable;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"use-table-sorts.js","names":["useCollator","useControlledState","useMemo","useEvent","compareByColumn","CubeTableColumn","CubeTableSort","CubeTableSortDirection","UseTableSortsOptions","columns","T","rows","mode","sorts","defaultSorts","onSortsChange","EMPTY","useTableSorts","t0","$","_c","sortsProp","t1","Symbol","for","numeric","sensitivity","collator","setSorts","value","hasSortableColumn","some","_temp","resolvedMode","t2","column_0","column","isSortable","t3","columnKey","column_1","find","entry","key","index","findIndex","entry_0","direction","next","disallowSortRemoval","splice","toggleSort","t4","columnKey_0","column_2","entry_1","index_0","entry_2","next_0","next_1","setColumnSort","t5","bb0","length","t6","sort","entry_3","active","map","filter","_temp2","_temp3","a","b","sort_0","column_3","result","row","_temp4","sortedRows","columnKey_1","entry_6","sortRank","t7","entry_5","index_1","entry_4"],"sources":["../../../../src/components/data/TableBase/use-table-sorts.ts"],"sourcesContent":["import { useCollator } from '@react-aria/i18n';\nimport { useControlledState } from '@react-stately/utils';\nimport { useMemo } from 'react';\n\nimport { useEvent } from '../../../_internal/hooks';\n\nimport { compareByColumn } from './use-table-sort';\n\nimport type {\n  CubeTableColumn,\n  CubeTableSort,\n  CubeTableSortDirection,\n} from './types';\n\nexport interface UseTableSortsOptions<T> {\n  columns: CubeTableColumn<T>[];\n  rows: readonly T[];\n  mode?: 'client' | 'server' | 'off';\n  sorts?: CubeTableSort[];\n  defaultSorts?: CubeTableSort[];\n  onSortsChange?: (sorts: CubeTableSort[]) => void;\n}\n\nconst EMPTY: CubeTableSort[] = [];\n\n/**\n * Multi-column sorting.\n *\n * `ItemTable` sorts by one column, which is right for a list. An analytical\n * grid is routinely ordered by one dimension and then another, and Cloud's\n * reports send an array of sorts to the query — so the order of the array is\n * the sort precedence, and it has to survive round-tripping.\n *\n * Clicking a header cycles that column `asc → desc → off` exactly as the single\n * version does; the difference is that it edits its entry in place rather than\n * replacing the whole sort, so the other columns keep their precedence.\n */\nexport function useTableSorts<T>({\n  columns,\n  rows,\n  mode,\n  sorts: sortsProp,\n  defaultSorts,\n  onSortsChange,\n}: UseTableSortsOptions<T>) {\n  const collator = useCollator({ numeric: true, sensitivity: 'base' });\n\n  const [sorts, setSorts] = useControlledState<CubeTableSort[]>(\n    sortsProp as CubeTableSort[],\n    defaultSorts ?? EMPTY,\n    onSortsChange as (value: CubeTableSort[]) => void,\n  );\n\n  const hasSortableColumn = columns.some((column) => column.isSortable);\n  const resolvedMode = mode ?? (hasSortableColumn ? 'client' : 'off');\n\n  const isSortable = useEvent(\n    (column: CubeTableColumn<T>) =>\n      resolvedMode !== 'off' && column.isSortable === true,\n  );\n\n  const toggleSort = useEvent((columnKey: string) => {\n    const column = columns.find((entry) => entry.key === columnKey);\n\n    if (!column || !isSortable(column)) return;\n\n    const index = sorts.findIndex((entry) => entry.columnKey === columnKey);\n\n    if (index === -1) {\n      // Appended, not prepended: a newly sorted column is the least\n      // significant, so the ordering the user already established still leads.\n      setSorts([...sorts, { columnKey, direction: 'asc' }]);\n\n      return;\n    }\n\n    const next = [...sorts];\n\n    if (next[index].direction === 'asc') {\n      next[index] = { columnKey, direction: 'desc' };\n      setSorts(next);\n\n      return;\n    }\n\n    if (column.disallowSortRemoval) {\n      next[index] = { columnKey, direction: 'asc' };\n      setSorts(next);\n\n      return;\n    }\n\n    next.splice(index, 1);\n    setSorts(next);\n  });\n\n  /**\n   * Set one column's direction outright instead of advancing the cycle.\n   *\n   * The column menu's `sort-desc` has to reach `desc` in one step. Reaching it\n   * by calling `toggleSort` twice cannot work here: under `disallowSortRemoval`\n   * the cycle never leaves `asc`/`desc`, and a column that was unsorted would\n   * be appended and then re-read, so every intermediate state is observable.\n   *\n   * Precedence is preserved — an already-sorted column keeps its slot, and a\n   * newly sorted one is appended as the least significant, the same rule\n   * `toggleSort` follows.\n   */\n  const setColumnSort = useEvent(\n    (columnKey: string, direction: CubeTableSortDirection | null) => {\n      const column = columns.find((entry) => entry.key === columnKey);\n\n      if (!column || !isSortable(column)) return;\n\n      const index = sorts.findIndex((entry) => entry.columnKey === columnKey);\n\n      if (direction == null) {\n        // `disallowSortRemoval` means the column is never *left* unsorted, so an\n        // explicit clear is refused too rather than quietly re-sorting.\n        if (index === -1 || column.disallowSortRemoval) return;\n\n        const next = [...sorts];\n\n        next.splice(index, 1);\n        setSorts(next);\n\n        return;\n      }\n\n      if (index === -1) {\n        setSorts([...sorts, { columnKey, direction }]);\n\n        return;\n      }\n\n      if (sorts[index].direction === direction) return;\n\n      const next = [...sorts];\n\n      next[index] = { columnKey, direction };\n      setSorts(next);\n    },\n  );\n\n  const sortedRows = useMemo(() => {\n    if (resolvedMode !== 'client' || !sorts.length) return rows;\n\n    const active = sorts\n      .map((sort) => ({\n        sort,\n        column: columns.find((entry) => entry.key === sort.columnKey),\n      }))\n      .filter(\n        (entry): entry is { sort: CubeTableSort; column: CubeTableColumn<T> } =>\n          entry.column != null,\n      );\n\n    if (!active.length) return rows;\n\n    // Not sorted in place: `rows` belongs to the caller and `sort` mutates.\n    // The original index is carried so the result is stable when every sort\n    // ties.\n    return rows\n      .map((row, index) => ({ row, index }))\n      .sort((a, b) => {\n        for (const { sort, column } of active) {\n          const result = compareByColumn(\n            column,\n            collator,\n            a.row,\n            a.index,\n            b.row,\n            b.index,\n          );\n\n          if (result !== 0) {\n            return result * (sort.direction === 'asc' ? 1 : -1);\n          }\n        }\n\n        return a.index - b.index;\n      })\n      .map((entry) => entry.row);\n  }, [resolvedMode, sorts, rows, columns, collator]);\n\n  /** Where a column sits in the precedence, 1-based. `0` when unsorted. */\n  const sortRank = useEvent(\n    (columnKey: string) =>\n      sorts.findIndex((entry) => entry.columnKey === columnKey) + 1,\n  );\n\n  // Returned for the same reason as the single-column hook: the renderer needs\n  // this exact answer to decide whether a header is clickable.\n  return {\n    sorts,\n    sortedRows,\n    toggleSort,\n    setColumnSort,\n    isSortable,\n    sortRank,\n    mode: resolvedMode,\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"use-table-sorts.js","names":["useCollator","useControlledState","useEvent","sortRows","CubeTableColumn","CubeTableSort","CubeTableSortDirection","UseTableSortsOptions","columns","T","rows","mode","sorts","defaultSorts","onSortsChange","EMPTY","useTableSorts","t0","$","_c","sortsProp","t1","Symbol","for","numeric","sensitivity","collator","setSorts","value","hasSortableColumn","some","_temp","resolvedMode","t2","column_0","column","isSortable","t3","columnKey","column_1","find","entry","key","index","findIndex","entry_0","direction","next","disallowSortRemoval","splice","toggleSort","t4","columnKey_0","column_2","entry_1","index_0","entry_2","next_0","next_1","setColumnSort","t5","sortedRows","t6","columnKey_1","entry_3","sortRank","t7"],"sources":["../../../../src/components/data/TableBase/use-table-sorts.ts"],"sourcesContent":["import { useCollator } from '@react-aria/i18n';\nimport { useControlledState } from '@react-stately/utils';\n\nimport { useEvent } from '../../../_internal/hooks';\n\nimport { sortRows } from './use-table-sort';\n\nimport type {\n  CubeTableColumn,\n  CubeTableSort,\n  CubeTableSortDirection,\n} from './types';\n\nexport interface UseTableSortsOptions<T> {\n  columns: CubeTableColumn<T>[];\n  rows: readonly T[];\n  mode?: 'client' | 'server' | 'off';\n  sorts?: CubeTableSort[];\n  defaultSorts?: CubeTableSort[];\n  onSortsChange?: (sorts: CubeTableSort[]) => void;\n}\n\nconst EMPTY: CubeTableSort[] = [];\n\n/**\n * Multi-column sorting.\n *\n * `ItemTable` sorts by one column, which is right for a list. An analytical\n * grid is routinely ordered by one dimension and then another, and Cloud's\n * reports send an array of sorts to the query — so the order of the array is\n * the sort precedence, and it has to survive round-tripping.\n *\n * Clicking a header cycles that column `asc → desc → off` exactly as the single\n * version does; the difference is that it edits its entry in place rather than\n * replacing the whole sort, so the other columns keep their precedence.\n */\nexport function useTableSorts<T>({\n  columns,\n  rows,\n  mode,\n  sorts: sortsProp,\n  defaultSorts,\n  onSortsChange,\n}: UseTableSortsOptions<T>) {\n  const collator = useCollator({ numeric: true, sensitivity: 'base' });\n\n  const [sorts, setSorts] = useControlledState<CubeTableSort[]>(\n    sortsProp as CubeTableSort[],\n    defaultSorts ?? EMPTY,\n    onSortsChange as (value: CubeTableSort[]) => void,\n  );\n\n  const hasSortableColumn = columns.some((column) => column.isSortable);\n  const resolvedMode = mode ?? (hasSortableColumn ? 'client' : 'off');\n\n  const isSortable = useEvent(\n    (column: CubeTableColumn<T>) =>\n      resolvedMode !== 'off' && column.isSortable === true,\n  );\n\n  const toggleSort = useEvent((columnKey: string) => {\n    const column = columns.find((entry) => entry.key === columnKey);\n\n    if (!column || !isSortable(column)) return;\n\n    const index = sorts.findIndex((entry) => entry.columnKey === columnKey);\n\n    if (index === -1) {\n      // Appended, not prepended: a newly sorted column is the least\n      // significant, so the ordering the user already established still leads.\n      setSorts([...sorts, { columnKey, direction: 'asc' }]);\n\n      return;\n    }\n\n    const next = [...sorts];\n\n    if (next[index].direction === 'asc') {\n      next[index] = { columnKey, direction: 'desc' };\n      setSorts(next);\n\n      return;\n    }\n\n    if (column.disallowSortRemoval) {\n      next[index] = { columnKey, direction: 'asc' };\n      setSorts(next);\n\n      return;\n    }\n\n    next.splice(index, 1);\n    setSorts(next);\n  });\n\n  /**\n   * Set one column's direction outright instead of advancing the cycle.\n   *\n   * The column menu's `sort-desc` has to reach `desc` in one step. Reaching it\n   * by calling `toggleSort` twice cannot work here: under `disallowSortRemoval`\n   * the cycle never leaves `asc`/`desc`, and a column that was unsorted would\n   * be appended and then re-read, so every intermediate state is observable.\n   *\n   * Precedence is preserved — an already-sorted column keeps its slot, and a\n   * newly sorted one is appended as the least significant, the same rule\n   * `toggleSort` follows.\n   */\n  const setColumnSort = useEvent(\n    (columnKey: string, direction: CubeTableSortDirection | null) => {\n      const column = columns.find((entry) => entry.key === columnKey);\n\n      if (!column || !isSortable(column)) return;\n\n      const index = sorts.findIndex((entry) => entry.columnKey === columnKey);\n\n      if (direction == null) {\n        // `disallowSortRemoval` means the column is never *left* unsorted, so an\n        // explicit clear is refused too rather than quietly re-sorting.\n        if (index === -1 || column.disallowSortRemoval) return;\n\n        const next = [...sorts];\n\n        next.splice(index, 1);\n        setSorts(next);\n\n        return;\n      }\n\n      if (index === -1) {\n        setSorts([...sorts, { columnKey, direction }]);\n\n        return;\n      }\n\n      if (sorts[index].direction === direction) return;\n\n      const next = [...sorts];\n\n      next[index] = { columnKey, direction };\n      setSorts(next);\n    },\n  );\n\n  const sortedRows =\n    resolvedMode === 'client' ? sortRows(rows, sorts, columns, collator) : rows;\n\n  /** Where a column sits in the precedence, 1-based. `0` when unsorted. */\n  const sortRank = useEvent(\n    (columnKey: string) =>\n      sorts.findIndex((entry) => entry.columnKey === columnKey) + 1,\n  );\n\n  // Returned for the same reason as the single-column hook: the renderer needs\n  // this exact answer to decide whether a header is clickable.\n  return {\n    sorts,\n    sortedRows,\n    toggleSort,\n    setColumnSort,\n    isSortable,\n    sortRank,\n    mode: resolvedMode,\n  };\n}\n"],"mappings":"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"}

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

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

package/dist/components/data/TableBase/use-table-tree-state.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.185.3 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.186.1 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { useI18n } from "../../../i18n/useI18n.js";
 import { c } from "react-compiler-runtime";
@@ -7,8 +7,25 @@ import { Item, useTreeState } from "react-stately";
 import { useControlledState } from "@react-stately/utils";
 
 //#region src/components/data/TableBase/use-table-tree-state.tsx
+/**
+* Current React Stately's legacy TreeCollection omits `getChildren`, while
+* `useTreeItem` needs it for level/set-size/expanded metadata.
+*/
+function withGetChildren(state) {
+	const collection = state.collection;
+	if (typeof collection.getChildren === "function") return state;
+	const patched = Object.create(collection);
+	patched.getChildren = (key) => {
+		const node = collection.getItem(key);
+		return node ? Array.from(node.childNodes) : [];
+	};
+	return {
+		...state,
+		collection: patched
+	};
+}
 function useTableTreeState(options) {
-	const $ = c(43);
+	const $ = c(39);
 	const { roots, allNodesByKey, expandedKeys: controlledExpandedKeys, defaultExpandedKeys, forcedExpandedKeys, disabledKeys, getTextValue, onExpand, ariaLabel } = options;
 	const { t } = useI18n();
 	let t0;
@@ -31,15 +48,14 @@ function useTableTreeState(options) {
 		$[5] = t2;
 	} else t2 = $[5];
 	const [baseExpandedKeys, setBaseExpandedKeys] = useControlledState(controlledSet, t2);
-	let keys;
+	let effectiveExpandedKeys;
 	if ($[6] !== baseExpandedKeys || $[7] !== forcedExpandedKeys) {
-		keys = new Set(baseExpandedKeys);
-		forcedExpandedKeys?.forEach((key) => keys.add(key));
+		effectiveExpandedKeys = new Set(baseExpandedKeys);
+		forcedExpandedKeys?.forEach((key) => effectiveExpandedKeys.add(key));
 		$[6] = baseExpandedKeys;
 		$[7] = forcedExpandedKeys;
-		$[8] = keys;
-	} else keys = $[8];
-	const effectiveExpandedKeys = keys;
+		$[8] = effectiveExpandedKeys;
+	} else effectiveExpandedKeys = $[8];
 	let t3;
 	if ($[9] !== allNodesByKey || $[10] !== baseExpandedKeys || $[11] !== effectiveExpandedKeys || $[12] !== forcedExpandedKeys || $[13] !== onExpand || $[14] !== setBaseExpandedKeys) {
 		t3 = (next) => {
@@ -123,56 +139,28 @@ function useTableTreeState(options) {
 	} else t7 = $[27];
 	const ariaProps = t7;
 	const baseState = useTreeState(ariaProps);
+	let state;
 	let t8;
-	bb0: {
-		const collection = baseState.collection;
-		if (typeof collection.getChildren === "function") {
-			t8 = baseState;
-			break bb0;
-		}
-		let patched;
-		if ($[28] !== collection) {
-			patched = Object.create(collection);
-			patched.getChildren = (key_2) => {
-				const node_1 = collection.getItem(key_2);
-				return node_1 ? Array.from(node_1.childNodes) : [];
-			};
-			$[28] = collection;
-			$[29] = patched;
-		} else patched = $[29];
-		let t9;
-		if ($[30] !== baseState || $[31] !== patched) {
-			t9 = {
-				...baseState,
-				collection: patched
-			};
-			$[30] = baseState;
-			$[31] = patched;
-			$[32] = t9;
-		} else t9 = $[32];
-		t8 = t9;
+	if ($[28] !== baseState) {
+		state = withGetChildren(baseState);
+		t8 = Array.from(state.collection.getKeys(), (key_2) => state.collection.getItem(key_2)).filter(_temp2);
+		$[28] = baseState;
+		$[29] = state;
+		$[30] = t8;
+	} else {
+		state = $[29];
+		t8 = $[30];
 	}
-	const state = t8;
-	let output;
-	if ($[33] !== state.collection) {
-		output = [];
-		for (const key_3 of state.collection.getKeys()) {
-			const node_2 = state.collection.getItem(key_3);
-			if (node_2?.type === "item") output.push(node_2);
-		}
-		$[33] = state.collection;
-		$[34] = output;
-	} else output = $[34];
-	const visibleNodes = output;
+	const visibleNodes = t8;
 	let t9;
-	if ($[35] !== visibleNodes) {
-		t9 = visibleNodes.map(_temp2).filter(_temp3);
-		$[35] = visibleNodes;
-		$[36] = t9;
-	} else t9 = $[36];
+	if ($[31] !== visibleNodes) {
+		t9 = visibleNodes.map(_temp3).filter(_temp4);
+		$[31] = visibleNodes;
+		$[32] = t9;
+	} else t9 = $[32];
 	const visibleEntries = t9;
 	let t10;
-	if ($[37] !== ariaProps || $[38] !== effectiveExpandedKeys || $[39] !== state || $[40] !== visibleEntries || $[41] !== visibleNodes) {
+	if ($[33] !== ariaProps || $[34] !== effectiveExpandedKeys || $[35] !== state || $[36] !== visibleEntries || $[37] !== visibleNodes) {
 		t10 = {
 			state,
 			ariaProps,
@@ -180,20 +168,23 @@ function useTableTreeState(options) {
 			visibleEntries,
 			expandedKeys: effectiveExpandedKeys
 		};
-		$[37] = ariaProps;
-		$[38] = effectiveExpandedKeys;
-		$[39] = state;
-		$[40] = visibleEntries;
-		$[41] = visibleNodes;
-		$[42] = t10;
-	} else t10 = $[42];
+		$[33] = ariaProps;
+		$[34] = effectiveExpandedKeys;
+		$[35] = state;
+		$[36] = visibleEntries;
+		$[37] = visibleNodes;
+		$[38] = t10;
+	} else t10 = $[38];
 	return t10;
 }
-function _temp3(node_4) {
-	return node_4 != null;
+function _temp4(node_3) {
+	return node_3 != null;
+}
+function _temp3(node_2) {
+	return node_2.value;
 }
-function _temp2(node_3) {
-	return node_3.value;
+function _temp2(node_1) {
+	return node_1?.type === "item";
 }
 function _temp() {}