@cube-dev/ui-kit 0.156.0 → 0.157.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-table-columns.js","names":[],"sources":["../../../../src/components/data/TableBase/use-table-columns.ts"],"sourcesContent":["import { useMemo } from 'react';\n\nimport type {\n  CubeResolvedColumn,\n  CubeTableColumn,\n  CubeTableColumnLayout,\n} from './types';\n\n/** @default when a column declares neither `width` nor `minWidth`. */\nexport const DEFAULT_MIN_WIDTH = 150;\n\n/**\n * Reads `key` as a data path. A plain key is a single property lookup; dots\n * walk nested objects (`'owner.name'`). Anything richer belongs in `getValue`.\n */\nexport function readPath(row: any, path: string): unknown {\n  if (row == null) return undefined;\n  if (!path.includes('.')) return row[path];\n\n  let current: any = row;\n\n  for (const part of path.split('.')) {\n    if (current == null) return undefined;\n    current = current[part];\n  }\n\n  return current;\n}\n\n/** Only the value-pipeline members, so both raw and resolved columns fit. */\ntype ValueColumn<T> = Pick<CubeTableColumn<T>, 'key' | 'getValue' | 'format'>;\n\nexport function getColumnValue<T>(\n  column: ValueColumn<T>,\n  row: T,\n  rowIndex: number,\n): unknown {\n  return column.getValue\n    ? column.getValue(row, rowIndex)\n    : readPath(row, column.key);\n}\n\n/**\n * Display text for a cell — what client sort, client search and TSV copy all\n * operate on. Deliberately NOT the rendered output: `render` may return\n * arbitrary React, and stringifying that is how cloud's filter ended up\n * matching `\"[object Object]\"` against the query `\"object\"`.\n *\n * Returns `null` when the column cannot produce text, so callers can skip it\n * rather than coerce a non-primitive.\n */\nexport function getColumnText<T>(\n  column: ValueColumn<T>,\n  row: T,\n  rowIndex: number,\n): string | null {\n  const value = getColumnValue(column, row, rowIndex);\n\n  if (column.format) return column.format(value, row, rowIndex);\n  if (value == null) return '';\n\n  const type = typeof value;\n\n  if (type === 'string') return value as string;\n  if (type === 'number' || type === 'boolean' || type === 'bigint') {\n    return String(value);\n  }\n  if (value instanceof Date) return value.toISOString();\n\n  return null;\n}\n\nfunction clamp(value: number, min: number, max: number | null): number {\n  return Math.min(Math.max(value, min), max ?? Number.POSITIVE_INFINITY);\n}\n\nexport interface UseTableColumnsOptions<T> {\n  columns: CubeTableColumn<T>[];\n  /** Content-box width of the scroller, or `null` before the first measure. */\n  containerWidth: number | null;\n  /** User-resized widths, keyed by column key. Wins over `column.width`. */\n  columnWidths?: Record<string, number>;\n  /** Extra leading columns owned by the table (selection, drag handle). */\n  leadingColumns?: CubeTableColumn<T>[];\n  /** Extra trailing columns owned by the table (row menu). */\n  trailingColumns?: CubeTableColumn<T>[];\n}\n\n/**\n * Normalizes the public column list into resolved leaves: visual order, ARIA\n * indices, pixel widths, and sticky offsets for pinned columns.\n *\n * Width resolution mirrors ag-grid's `fitGridWidth`: fixed columns take their\n * width, the remainder is split across flex columns by weight, and each result\n * is clamped to `[minWidth, maxWidth]`. Clamping perturbs the sum, so the\n * residual is redistributed across the still-unclamped columns until it\n * settles. When even the minimums do not fit, every column takes its minimum\n * and the table scrolls horizontally.\n */\nexport function useTableColumns<T>({\n  columns,\n  containerWidth,\n  columnWidths,\n  leadingColumns,\n  trailingColumns,\n}: UseTableColumnsOptions<T>): CubeTableColumnLayout<T> {\n  return useMemo(() => {\n    const visible = [\n      ...(leadingColumns ?? []),\n      ...columns,\n      ...(trailingColumns ?? []),\n    ].filter((column) => !column.isHidden);\n\n    // Pinned columns lead and trail regardless of their position in the source\n    // array, so `aria-colindex` and DOM order agree and nothing needs CSS\n    // `order:` to be reshuffled.\n    const ordered = [\n      ...visible.filter((c) => c.pin === 'start'),\n      ...visible.filter((c) => !c.pin),\n      ...visible.filter((c) => c.pin === 'end'),\n    ];\n\n    const structuralKeys = new Set(\n      [...(leadingColumns ?? []), ...(trailingColumns ?? [])].map((c) => c.key),\n    );\n\n    const specs = ordered.map((column) => {\n      const isStructural = structuralKeys.has(column.key);\n      const explicit = columnWidths?.[column.key] ?? column.width;\n      const minWidth =\n        column.minWidth ??\n        (explicit != null ? explicit : isStructural ? 0 : DEFAULT_MIN_WIDTH);\n\n      return {\n        column,\n        isStructural,\n        fixed: explicit ?? null,\n        minWidth,\n        maxWidth: column.maxWidth ?? null,\n        flex: explicit != null ? null : column.flex ?? 1,\n      };\n    });\n\n    const resolved = new Map<string, number>();\n    let isOverflowing = false;\n\n    if (containerWidth != null && containerWidth > 0) {\n      const fixedTotal = specs.reduce((sum, s) => sum + (s.fixed ?? 0), 0);\n      const flexSpecs = specs.filter((s) => s.fixed == null);\n      const minTotal = specs.reduce(\n        (sum, s) => sum + (s.fixed ?? s.minWidth),\n        0,\n      );\n\n      if (minTotal > containerWidth) {\n        isOverflowing = true;\n        for (const spec of specs) {\n          resolved.set(spec.column.key, spec.fixed ?? spec.minWidth);\n        }\n      } else {\n        let remaining = containerWidth - fixedTotal;\n        let pool = flexSpecs;\n\n        // Each pass assigns proportional widths, freezes whatever hit a bound,\n        // and re-splits the leftover among the rest.\n        while (pool.length > 0) {\n          const totalFlex = pool.reduce((sum, s) => sum + (s.flex ?? 1), 0);\n          const nextPool: typeof pool = [];\n          let consumed = 0;\n\n          for (const spec of pool) {\n            const ideal = (remaining * (spec.flex ?? 1)) / (totalFlex || 1);\n            const clamped = clamp(ideal, spec.minWidth, spec.maxWidth);\n\n            if (clamped !== ideal) {\n              resolved.set(spec.column.key, clamped);\n              consumed += clamped;\n            } else {\n              nextPool.push(spec);\n            }\n          }\n\n          if (nextPool.length === pool.length) {\n            // Nothing was clamped this pass — the proportional split stands.\n            const totalLeft = nextPool.reduce(\n              (sum, s) => sum + (s.flex ?? 1),\n              0,\n            );\n            for (const spec of nextPool) {\n              resolved.set(\n                spec.column.key,\n                (remaining * (spec.flex ?? 1)) / (totalLeft || 1),\n              );\n            }\n            break;\n          }\n\n          remaining -= consumed;\n          pool = nextPool;\n        }\n\n        for (const spec of specs) {\n          if (spec.fixed != null) resolved.set(spec.column.key, spec.fixed);\n        }\n      }\n    }\n\n    let pinnedStartWidth = 0;\n    let pinnedEndWidth = 0;\n\n    const out: CubeResolvedColumn<T>[] = specs.map((spec, index) => ({\n      ...spec.column,\n      index,\n      ariaColIndex: index + 1,\n      width: resolved.get(spec.column.key) ?? null,\n      minWidth: spec.minWidth,\n      maxWidth: spec.maxWidth,\n      flex: spec.flex,\n      align: spec.column.align ?? 'start',\n      pinOffset: null,\n      isPinEdge: false,\n      isStructural: spec.isStructural,\n    }));\n\n    // Sticky offsets accumulate inwards from each edge.\n    for (const column of out) {\n      if (column.pin !== 'start') continue;\n      column.pinOffset = pinnedStartWidth;\n      pinnedStartWidth += column.width ?? column.minWidth;\n    }\n\n    for (let i = out.length - 1; i >= 0; i--) {\n      const column = out[i];\n      if (column.pin !== 'end') continue;\n      column.pinOffset = pinnedEndWidth;\n      pinnedEndWidth += column.width ?? column.minWidth;\n    }\n\n    const lastPinnedStart = out.filter((c) => c.pin === 'start').at(-1);\n    const firstPinnedEnd = out.find((c) => c.pin === 'end');\n\n    if (lastPinnedStart) lastPinnedStart.isPinEdge = true;\n    if (firstPinnedEnd) firstPinnedEnd.isPinEdge = true;\n\n    const totalWidth = out.every((c) => c.width != null)\n      ? out.reduce((sum, c) => sum + (c.width ?? 0), 0)\n      : null;\n\n    return {\n      columns: out,\n      pinnedStartWidth,\n      pinnedEndWidth,\n      totalWidth,\n      isOverflowing,\n    };\n  }, [columns, containerWidth, columnWidths, leadingColumns, trailingColumns]);\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,64 @@
+/** @license MIT | @cube-dev/ui-kit v0.157.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";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { useControlledState } from "@react-stately/utils";
+
+//#region src/components/data/TableBase/use-table-search.ts
+/**
+* Default matcher: a case-insensitive substring test against each searchable
+* column's **display text**.
+*
+* Deliberately not the raw value. Cloud's filter tested
+* `String(row[column.key])`, which meant a column rendering `owner.profile.name`
+* was unsearchable, and an object-valued column stringified to
+* `"[object Object]"` — so the query "object" matched every row with a nested
+* value. `getColumnText` returns `null` for anything it cannot honestly turn
+* into text, and those columns are skipped rather than coerced.
+*/
+function defaultMatcher(columns, row, rowIndex, query) {
+	return columns.some((column) => {
+		if (column.isSearchable === false) return false;
+		const text = getColumnText(column, row, rowIndex);
+		return text != null && text.toLowerCase().includes(query);
+	});
+}
+function useTableSearch({ columns, rows, mode = "client", value, defaultValue, onChange, delay = 500, filter }) {
+	const [committed, setCommitted] = useControlledState(value, defaultValue ?? "", onChange);
+	const [draft, setDraft] = useState(committed);
+	const debounced = useDebouncedValue(draft, delay);
+	const pushedRef = useRef(committed);
+	useEffect(() => {
+		if (committed === pushedRef.current) return;
+		pushedRef.current = committed;
+		setDraft(committed);
+	}, [committed]);
+	useEffect(() => {
+		if (debounced === pushedRef.current) return;
+		pushedRef.current = debounced;
+		setCommitted(debounced);
+	}, [debounced]);
+	const searchValue = draft;
+	const query = debounced.trim().toLowerCase();
+	return {
+		searchValue,
+		setSearchValue: useEvent((next) => setDraft(next)),
+		query,
+		searchedRows: useMemo(() => {
+			if (mode !== "client" || !query) return rows;
+			return rows.filter((row, index) => filter ? filter(row, query) : defaultMatcher(columns, row, index, query));
+		}, [
+			mode,
+			query,
+			rows,
+			columns,
+			filter
+		]),
+		isFiltered: query.length > 0
+	};
+}
+
+//#endregion
+export { useTableSearch };
+//# sourceMappingURL=use-table-search.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-table-search.js","names":[],"sources":["../../../../src/components/data/TableBase/use-table-search.ts"],"sourcesContent":["import { useControlledState } from '@react-stately/utils';\nimport { useEffect, useMemo, useRef, useState } from 'react';\n\nimport { useDebouncedValue, useEvent } from '../../../_internal/hooks';\n\nimport { getColumnText } from './use-table-columns';\n\nimport type { CubeTableColumn } from './types';\n\nexport type CubeTableSearchMode = 'client' | 'server';\n\nexport interface UseTableSearchOptions<T> {\n  columns: CubeTableColumn<T>[];\n  rows: readonly T[];\n  /** @default 'client' */\n  mode?: CubeTableSearchMode;\n  value?: string;\n  defaultValue?: string;\n  onChange?: (value: string) => void;\n  /** Debounces the filter AND the callback, in both modes. @default 500 */\n  delay?: number;\n  /** Replaces the default matcher in client mode. */\n  filter?: (row: T, query: string) => boolean;\n}\n\nexport interface UseTableSearchResult<T> {\n  /** The immediate term — what the input shows. */\n  searchValue: string;\n  setSearchValue: (value: string) => void;\n  /** The debounced term — what the filter and the callback act on. */\n  query: string;\n  /** Filtered in client mode; the original array otherwise. */\n  searchedRows: readonly T[];\n  /** `true` when a non-empty term is narrowing the data. */\n  isFiltered: boolean;\n}\n\n/**\n * Default matcher: a case-insensitive substring test against each searchable\n * column's **display text**.\n *\n * Deliberately not the raw value. Cloud's filter tested\n * `String(row[column.key])`, which meant a column rendering `owner.profile.name`\n * was unsearchable, and an object-valued column stringified to\n * `\"[object Object]\"` — so the query \"object\" matched every row with a nested\n * value. `getColumnText` returns `null` for anything it cannot honestly turn\n * into text, and those columns are skipped rather than coerced.\n */\nfunction defaultMatcher<T>(\n  columns: CubeTableColumn<T>[],\n  row: T,\n  rowIndex: number,\n  query: string,\n): boolean {\n  return columns.some((column) => {\n    if (column.isSearchable === false) return false;\n\n    const text = getColumnText(column, row, rowIndex);\n\n    return text != null && text.toLowerCase().includes(query);\n  });\n}\n\nexport function useTableSearch<T>({\n  columns,\n  rows,\n  mode = 'client',\n  value,\n  defaultValue,\n  onChange,\n  delay = 500,\n  filter,\n}: UseTableSearchOptions<T>): UseTableSearchResult<T> {\n  const [committed, setCommitted] = useControlledState<string>(\n    value as string,\n    defaultValue ?? '',\n    onChange as (v: string) => void,\n  );\n\n  // What the input shows, updated on every keystroke. The committed value —\n  // the one `onChange` reports and the filter runs on — trails it by `delay`.\n  //\n  // Two separate values rather than one, because `useControlledState` calls\n  // `onChange` the moment it is set: routing keystrokes straight into it fired\n  // a request per character in `searchMode=\"server\"`, which is the thing the\n  // debounce exists to prevent. Debouncing the input itself instead would make\n  // typing lag, so the split is the point.\n  const [draft, setDraft] = useState(committed);\n  const debounced = useDebouncedValue(draft, delay);\n\n  // What we last pushed outward, so the sync below can tell a genuine external\n  // change from the echo of our own debounce.\n  const pushedRef = useRef(committed);\n\n  // A controlled `searchValue` changing from OUTSIDE — a cleared filter, a\n  // restored URL — wins over whatever is half-typed.\n  //\n  // The echo has to be filtered out or this reverts the input mid-word: with a\n  // short delay the debounce commits letter 1 while letter 2 is already typed,\n  // and syncing unconditionally puts letter 1 back. At `searchDelay={0}` that\n  // happens on every keystroke and nothing longer than one character can ever\n  // be typed.\n  useEffect(() => {\n    if (committed === pushedRef.current) return;\n\n    pushedRef.current = committed;\n    setDraft(committed);\n  }, [committed]);\n\n  useEffect(() => {\n    if (debounced === pushedRef.current) return;\n\n    pushedRef.current = debounced;\n    setCommitted(debounced);\n    // `committed` is deliberately not a dependency: reacting to it here would\n    // fight the effect above and push a stale draft back out.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [debounced]);\n\n  const searchValue = draft;\n  const query = debounced.trim().toLowerCase();\n\n  const setSearchValue = useEvent((next: string) => setDraft(next));\n\n  const searchedRows = useMemo(() => {\n    if (mode !== 'client' || !query) return rows;\n\n    return rows.filter((row, index) =>\n      filter ? filter(row, query) : defaultMatcher(columns, row, index, query),\n    );\n  }, [mode, query, rows, columns, filter]);\n\n  return {\n    searchValue,\n    setSearchValue,\n    query,\n    searchedRows,\n    isFiltered: query.length > 0,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAgDA,SAAS,eACP,SACA,KACA,UACA,OACS;AACT,QAAO,QAAQ,MAAM,WAAW;AAC9B,MAAI,OAAO,iBAAiB,MAAO,QAAO;EAE1C,MAAM,OAAO,cAAc,QAAQ,KAAK,SAAS;AAEjD,SAAO,QAAQ,QAAQ,KAAK,aAAa,CAAC,SAAS,MAAM;GACzD;;AAGJ,SAAgB,eAAkB,EAChC,SACA,MACA,OAAO,UACP,OACA,cACA,UACA,QAAQ,KACR,UACoD;CACpD,MAAM,CAAC,WAAW,gBAAgB,mBAChC,OACA,gBAAgB,IAChB,SACD;CAUD,MAAM,CAAC,OAAO,YAAY,SAAS,UAAU;CAC7C,MAAM,YAAY,kBAAkB,OAAO,MAAM;CAIjD,MAAM,YAAY,OAAO,UAAU;AAUnC,iBAAgB;AACd,MAAI,cAAc,UAAU,QAAS;AAErC,YAAU,UAAU;AACpB,WAAS,UAAU;IAClB,CAAC,UAAU,CAAC;AAEf,iBAAgB;AACd,MAAI,cAAc,UAAU,QAAS;AAErC,YAAU,UAAU;AACpB,eAAa,UAAU;IAItB,CAAC,UAAU,CAAC;CAEf,MAAM,cAAc;CACpB,MAAM,QAAQ,UAAU,MAAM,CAAC,aAAa;AAY5C,QAAO;EACL;EACA,gBAZqB,UAAU,SAAiB,SAAS,KAAK,CAAC;EAa/D;EACA,cAZmB,cAAc;AACjC,OAAI,SAAS,YAAY,CAAC,MAAO,QAAO;AAExC,UAAO,KAAK,QAAQ,KAAK,UACvB,SAAS,OAAO,KAAK,MAAM,GAAG,eAAe,SAAS,KAAK,OAAO,MAAM,CACzE;KACA;GAAC;GAAM;GAAO;GAAM;GAAS;GAAO,CAAC;EAOtC,YAAY,MAAM,SAAS;EAC5B"}

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

@@ -0,0 +1,4 @@
+
+import "./types.js";
+import { SelectionManager } from "@react-stately/selection";
+import { Key } from "@react-types/shared";

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

@@ -0,0 +1,233 @@
+/** @license MIT | @cube-dev/ui-kit v0.157.1 | Cube Dev Team */
+import { useEvent } from "../../../_internal/hooks/use-event.js";
+import { RowCollection } from "./RowCollection.js";
+import { useCallback, useMemo, useRef } from "react";
+import { useMultipleSelectionState } from "react-stately";
+import { SelectionManager } from "@react-stately/selection";
+
+//#region src/components/data/TableBase/use-table-selection.ts
+/**
+* Reserved key for the checkbox column. Prefixed so it cannot collide with a
+* real data key, and structural so the value pipeline, sorting and search all
+* skip it.
+*/
+const SELECTION_COLUMN_KEY = "__cube-selection__";
+/** Reserved key for the row-number column. Structural, like the checkbox. */
+const ROW_NUMBER_COLUMN_KEY = "__cube-row-number__";
+/** Square-ish, so the checkbox sits centred without stealing content width. */
+const SELECTION_COLUMN_WIDTH = {
+	xsmall: 32,
+	small: 36,
+	medium: 44,
+	large: 48,
+	xlarge: 52
+};
+function toSelection(keys) {
+	if (keys === void 0) return void 0;
+	return keys === "all" ? "all" : new Set(keys);
+}
+function useTableSelection(options) {
+	const { rows, filteredRows, getRowKey, selectionMode, selectedKeys: selectedKeysProp, defaultSelectedKeys, onSelectionChange, selectAllMode, isRowSelectable, disabledKeys } = options;
+	const isEnabled = selectionMode !== "none";
+	/**
+	* Two distinct notions of "not available", deliberately kept apart:
+	*
+	* - `disabledKeys` — the row is inert. Not focusable, not interactive. This
+	*   is React Aria's standard meaning.
+	* - `isRowSelectable` — the row is fully interactive, only its checkbox is
+	*   inert. This is what Cloud's tables do today.
+	*
+	* A `SelectionManager` has one `disabledBehavior`, so it gets the union under
+	* `'selection'` (neither kind can be selected) and the hard-disabled set is
+	* tracked separately for focus and interaction.
+	*/
+	const hardDisabledKeys = useMemo(() => new Set(disabledKeys ?? []), [disabledKeys]);
+	const unselectableKeys = useMemo(() => {
+		const keys = new Set(hardDisabledKeys);
+		if (isRowSelectable) filteredRows.forEach((row, index) => {
+			if (!isRowSelectable(row)) keys.add(getRowKey(row, index));
+		});
+		return keys;
+	}, [
+		hardDisabledKeys,
+		isRowSelectable,
+		filteredRows,
+		getRowKey
+	]);
+	const collection = useMemo(() => new RowCollection(rows, getRowKey, unselectableKeys), [
+		rows,
+		getRowKey,
+		unselectableKeys
+	]);
+	const rowByKey = useMemo(() => {
+		const map = /* @__PURE__ */ new Map();
+		filteredRows.forEach((row, index) => map.set(getRowKey(row, index), row));
+		rows.forEach((row, index) => map.set(getRowKey(row, index), row));
+		return map;
+	}, [
+		rows,
+		filteredRows,
+		getRowKey
+	]);
+	const rowByKeyRef = useRef(rowByKey);
+	rowByKeyRef.current = rowByKey;
+	/**
+	* Where a shift-range starts, and how far it currently reaches.
+	*
+	* React Aria's `SelectionManager.extendSelection` keeps this on the `Selection`
+	* object itself (`selectedKeys.anchorKey`), which cannot survive our public
+	* API: `selectedKeys` is `Key[]`, and `useMultipleSelectionState` rebuilds
+	* whatever it is given with `new Selection(value)` — a constructor that only
+	* copies the anchor when the input is already a `Selection`, a class no
+	* package exports. A controlled table would silently reset the anchor to the
+	* clicked row and turn every shift-click into a plain toggle.
+	*
+	* So the range is computed here instead, over `RowCollection`'s index. The
+	* semantics match `extendSelection` exactly: the previous range is removed
+	* before the new one is added, so shift-clicking back shrinks the range
+	* rather than leaving the overshoot selected.
+	*/
+	const anchorRef = useRef(null);
+	const extentRef = useRef(null);
+	const handleSelectionChange = useEvent((keys) => {
+		if (!onSelectionChange) return;
+		if (keys === "all") {
+			onSelectionChange("all", [...rowByKeyRef.current.values()]);
+			return;
+		}
+		const list = [...keys];
+		onSelectionChange(list, list.map((key) => rowByKeyRef.current.get(key)).filter((row) => row !== void 0));
+	});
+	const state = useMultipleSelectionState({
+		selectionMode,
+		selectedKeys: useMemo(() => toSelection(selectedKeysProp), [selectedKeysProp]),
+		defaultSelectedKeys: useMemo(() => toSelection(defaultSelectedKeys), [defaultSelectedKeys]),
+		disabledKeys: unselectableKeys,
+		disabledBehavior: "selection",
+		onSelectionChange: handleSelectionChange
+	});
+	const selectionManager = useMemo(() => new SelectionManager(collection, state), [collection, state]);
+	const selectedKeys = state.selectedKeys;
+	const isAll = selectedKeys === "all";
+	const canSelect = useCallback((key) => isEnabled && !unselectableKeys.has(key), [isEnabled, unselectableKeys]);
+	const isSelected = useCallback((key) => isAll ? canSelect(key) : selectedKeys.has(key), [
+		isAll,
+		selectedKeys,
+		canSelect
+	]);
+	/** Keys the header checkbox acts on, which is what `selectAllMode` decides. */
+	const scopeKeys = useMemo(() => {
+		if (!isEnabled || selectionMode === "single") return [];
+		return (selectAllMode === "page" ? rows : filteredRows).map((row, index) => getRowKey(row, index)).filter((key) => !unselectableKeys.has(key));
+	}, [
+		isEnabled,
+		selectionMode,
+		selectAllMode,
+		rows,
+		filteredRows,
+		getRowKey,
+		unselectableKeys
+	]);
+	const selectAllState = useMemo(() => {
+		if (isAll) return "all";
+		if (!scopeKeys.length) return "none";
+		const set = selectedKeys;
+		let count = 0;
+		for (const key of scopeKeys) if (set.has(key)) count++;
+		return count === 0 ? "none" : count === scopeKeys.length ? "all" : "some";
+	}, [
+		isAll,
+		selectedKeys,
+		scopeKeys
+	]);
+	const toggleSelectAll = useEvent(() => {
+		anchorRef.current = null;
+		extentRef.current = null;
+		if (selectAllState === "all") {
+			state.setSelectedKeys(/* @__PURE__ */ new Set());
+			return;
+		}
+		if (selectAllMode === "all") {
+			state.setSelectedKeys("all");
+			return;
+		}
+		const next = new Set(isAll ? [] : selectedKeys);
+		scopeKeys.forEach((key) => next.add(key));
+		state.setSelectedKeys(next);
+	});
+	const clearSelection = useEvent(() => {
+		anchorRef.current = null;
+		extentRef.current = null;
+		state.setSelectedKeys(/* @__PURE__ */ new Set());
+	});
+	/**
+	* Shift held on the press that produced this change. `Checkbox` reports only
+	* the next value, so the modifier is captured from the pointer/key event on
+	* the cell and read back here.
+	*/
+	const shiftRef = useRef(false);
+	const captureShift = useCallback((event) => {
+		shiftRef.current = event.shiftKey;
+	}, []);
+	/** Selectable keys between two rows, inclusive, in either direction. */
+	const keysBetween = useCallback((from, to) => {
+		const fromIndex = collection.indexOf(from);
+		const toIndex = collection.indexOf(to);
+		if (fromIndex < 0 || toIndex < 0) return [];
+		const [lo, hi] = fromIndex <= toIndex ? [fromIndex, toIndex] : [toIndex, fromIndex];
+		const all = collection.getKeys();
+		const range = [];
+		for (let i = lo; i <= hi; i++) range.push(all[i]);
+		return range;
+	}, [collection]);
+	const toggleRow = useEvent((key) => {
+		if (!canSelect(key)) return;
+		if (selectionMode === "single") {
+			state.setSelectedKeys(isSelected(key) ? /* @__PURE__ */ new Set() : new Set([key]));
+			return;
+		}
+		const anchor = anchorRef.current;
+		if (shiftRef.current && anchor != null && collection.indexOf(anchor) >= 0) {
+			const next = new Set(isAll ? scopeKeys : selectedKeys);
+			if (extentRef.current != null) keysBetween(anchor, extentRef.current).forEach((k) => next.delete(k));
+			keysBetween(anchor, key).forEach((k) => {
+				if (canSelect(k)) next.add(k);
+			});
+			extentRef.current = key;
+			state.setSelectedKeys(next);
+			return;
+		}
+		anchorRef.current = key;
+		extentRef.current = null;
+		selectionManager.toggleSelection(key);
+	});
+	const selectedRows = useMemo(() => {
+		if (isAll) return [...rowByKey.values()];
+		return [...selectedKeys].map((key) => rowByKey.get(key)).filter((row) => row !== void 0);
+	}, [
+		isAll,
+		selectedKeys,
+		rowByKey
+	]);
+	return {
+		isEnabled,
+		selectionMode,
+		selectionManager,
+		collection,
+		isSelected,
+		canSelect,
+		isRowDisabled: useCallback((key) => hardDisabledKeys.has(key), [hardDisabledKeys]),
+		toggleRow,
+		captureShift,
+		selectAllState,
+		toggleSelectAll,
+		clearSelection,
+		selectedRows,
+		selectedCount: isAll ? rowByKey.size : selectedKeys.size,
+		selectedKeys: isAll ? "all" : [...selectedKeys]
+	};
+}
+
+//#endregion
+export { ROW_NUMBER_COLUMN_KEY, SELECTION_COLUMN_KEY, SELECTION_COLUMN_WIDTH, useTableSelection };
+//# sourceMappingURL=use-table-selection.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-table-selection.js","names":[],"sources":["../../../../src/components/data/TableBase/use-table-selection.ts"],"sourcesContent":["import { SelectionManager } from '@react-stately/selection';\nimport { useCallback, useMemo, useRef } from 'react';\nimport { useMultipleSelectionState } from 'react-stately';\n\nimport { useEvent } from '../../../_internal/hooks';\n\nimport { RowCollection } from './RowCollection';\n\nimport type { Key, Selection } from '@react-types/shared';\nimport type { CubeTableSelectAllMode, CubeTableSelectionMode } from './types';\n\n/**\n * Reserved key for the checkbox column. Prefixed so it cannot collide with a\n * real data key, and structural so the value pipeline, sorting and search all\n * skip it.\n */\nexport const SELECTION_COLUMN_KEY = '__cube-selection__';\n\n/** Reserved key for the row-number column. Structural, like the checkbox. */\nexport const ROW_NUMBER_COLUMN_KEY = '__cube-row-number__';\n\n/** Square-ish, so the checkbox sits centred without stealing content width. */\nexport const SELECTION_COLUMN_WIDTH: Record<string, number> = {\n  xsmall: 32,\n  small: 36,\n  medium: 44,\n  large: 48,\n  xlarge: 52,\n};\n\nexport interface UseTableSelectionOptions<T> {\n  /** Rows currently on screen — one page, or everything when unpaginated. */\n  rows: readonly T[];\n  /**\n   * Every row passing the current search/filter, across pages. Only differs\n   * from `rows` under client pagination, and only `selectAllMode=\"filtered\"`\n   * reads it.\n   */\n  filteredRows: readonly T[];\n  getRowKey: (row: T, index: number) => Key;\n  selectionMode: CubeTableSelectionMode;\n  selectedKeys?: Key[] | 'all';\n  defaultSelectedKeys?: Key[] | 'all';\n  onSelectionChange?: (keys: Key[] | 'all', rows: T[]) => void;\n  selectAllMode: CubeTableSelectAllMode;\n  isRowSelectable?: (row: T) => boolean;\n  disabledKeys?: Key[];\n}\n\nexport type CubeTableSelectAllState = 'none' | 'some' | 'all';\n\nfunction toSelection(keys: Key[] | 'all' | undefined): Selection | undefined {\n  if (keys === undefined) return undefined;\n\n  return keys === 'all' ? 'all' : new Set(keys);\n}\n\nexport function useTableSelection<T>(options: UseTableSelectionOptions<T>) {\n  const {\n    rows,\n    filteredRows,\n    getRowKey,\n    selectionMode,\n    selectedKeys: selectedKeysProp,\n    defaultSelectedKeys,\n    onSelectionChange,\n    selectAllMode,\n    isRowSelectable,\n    disabledKeys,\n  } = options;\n\n  const isEnabled = selectionMode !== 'none';\n\n  /**\n   * Two distinct notions of \"not available\", deliberately kept apart:\n   *\n   * - `disabledKeys` — the row is inert. Not focusable, not interactive. This\n   *   is React Aria's standard meaning.\n   * - `isRowSelectable` — the row is fully interactive, only its checkbox is\n   *   inert. This is what Cloud's tables do today.\n   *\n   * A `SelectionManager` has one `disabledBehavior`, so it gets the union under\n   * `'selection'` (neither kind can be selected) and the hard-disabled set is\n   * tracked separately for focus and interaction.\n   */\n  const hardDisabledKeys = useMemo(\n    () => new Set(disabledKeys ?? []),\n    [disabledKeys],\n  );\n\n  const unselectableKeys = useMemo(() => {\n    const keys = new Set(hardDisabledKeys);\n\n    if (isRowSelectable) {\n      // Scanned over the filtered set, not just the page: a select-all that\n      // reaches beyond the page must respect it there too.\n      filteredRows.forEach((row, index) => {\n        if (!isRowSelectable(row)) keys.add(getRowKey(row, index));\n      });\n    }\n\n    return keys;\n  }, [hardDisabledKeys, isRowSelectable, filteredRows, getRowKey]);\n\n  const collection = useMemo(\n    () => new RowCollection(rows, getRowKey, unselectableKeys),\n    [rows, getRowKey, unselectableKeys],\n  );\n\n  const rowByKey = useMemo(() => {\n    const map = new Map<Key, T>();\n\n    // The page first, then the wider filtered set, so a key present in both\n    // resolves to the row the user can actually see.\n    filteredRows.forEach((row, index) => map.set(getRowKey(row, index), row));\n    rows.forEach((row, index) => map.set(getRowKey(row, index), row));\n\n    return map;\n  }, [rows, filteredRows, getRowKey]);\n\n  const rowByKeyRef = useRef(rowByKey);\n\n  rowByKeyRef.current = rowByKey;\n\n  /**\n   * Where a shift-range starts, and how far it currently reaches.\n   *\n   * React Aria's `SelectionManager.extendSelection` keeps this on the `Selection`\n   * object itself (`selectedKeys.anchorKey`), which cannot survive our public\n   * API: `selectedKeys` is `Key[]`, and `useMultipleSelectionState` rebuilds\n   * whatever it is given with `new Selection(value)` — a constructor that only\n   * copies the anchor when the input is already a `Selection`, a class no\n   * package exports. A controlled table would silently reset the anchor to the\n   * clicked row and turn every shift-click into a plain toggle.\n   *\n   * So the range is computed here instead, over `RowCollection`'s index. The\n   * semantics match `extendSelection` exactly: the previous range is removed\n   * before the new one is added, so shift-clicking back shrinks the range\n   * rather than leaving the overshoot selected.\n   */\n  const anchorRef = useRef<Key | null>(null);\n  const extentRef = useRef<Key | null>(null);\n\n  const handleSelectionChange = useEvent((keys: Selection) => {\n    if (!onSelectionChange) return;\n\n    if (keys === 'all') {\n      // The sentinel means \"everything, including rows the client has not\n      // loaded\", so the row list can only ever be what is loaded.\n      onSelectionChange('all', [...rowByKeyRef.current.values()]);\n\n      return;\n    }\n\n    const list = [...keys];\n\n    onSelectionChange(\n      list,\n      list\n        .map((key) => rowByKeyRef.current.get(key))\n        .filter((row): row is T => row !== undefined),\n    );\n  });\n\n  const controlledSelection = useMemo(\n    () => toSelection(selectedKeysProp),\n    [selectedKeysProp],\n  );\n  const defaultSelection = useMemo(\n    () => toSelection(defaultSelectedKeys),\n    [defaultSelectedKeys],\n  );\n\n  const state = useMultipleSelectionState({\n    selectionMode,\n    selectedKeys: controlledSelection,\n    defaultSelectedKeys: defaultSelection,\n    disabledKeys: unselectableKeys,\n    disabledBehavior: 'selection',\n    onSelectionChange: handleSelectionChange,\n  });\n\n  const selectionManager = useMemo(\n    () => new SelectionManager(collection, state),\n    [collection, state],\n  );\n\n  const selectedKeys = state.selectedKeys;\n  const isAll = selectedKeys === 'all';\n\n  const canSelect = useCallback(\n    (key: Key) => isEnabled && !unselectableKeys.has(key),\n    [isEnabled, unselectableKeys],\n  );\n\n  const isSelected = useCallback(\n    (key: Key) =>\n      isAll ? canSelect(key) : (selectedKeys as Set<Key>).has(key),\n    [isAll, selectedKeys, canSelect],\n  );\n\n  /** Keys the header checkbox acts on, which is what `selectAllMode` decides. */\n  const scopeKeys = useMemo(() => {\n    if (!isEnabled || selectionMode === 'single') return [];\n\n    const source = selectAllMode === 'page' ? rows : filteredRows;\n\n    return source\n      .map((row, index) => getRowKey(row, index))\n      .filter((key) => !unselectableKeys.has(key));\n  }, [\n    isEnabled,\n    selectionMode,\n    selectAllMode,\n    rows,\n    filteredRows,\n    getRowKey,\n    unselectableKeys,\n  ]);\n\n  const selectAllState: CubeTableSelectAllState = useMemo(() => {\n    if (isAll) return 'all';\n    if (!scopeKeys.length) return 'none';\n\n    const set = selectedKeys as Set<Key>;\n    let count = 0;\n\n    for (const key of scopeKeys) if (set.has(key)) count++;\n\n    return count === 0 ? 'none' : count === scopeKeys.length ? 'all' : 'some';\n  }, [isAll, selectedKeys, scopeKeys]);\n\n  const toggleSelectAll = useEvent(() => {\n    anchorRef.current = null;\n    extentRef.current = null;\n\n    if (selectAllState === 'all') {\n      // Clearing drops the whole selection, not just the scope: leaving keys\n      // selected on other pages after the user clicked an unchecked-looking\n      // box is the kind of thing nobody discovers until they delete something.\n      state.setSelectedKeys(new Set());\n\n      return;\n    }\n\n    if (selectAllMode === 'all') {\n      state.setSelectedKeys('all');\n\n      return;\n    }\n\n    const next = new Set(isAll ? [] : (selectedKeys as Set<Key>));\n\n    scopeKeys.forEach((key) => next.add(key));\n    state.setSelectedKeys(next);\n  });\n\n  const clearSelection = useEvent(() => {\n    anchorRef.current = null;\n    extentRef.current = null;\n    state.setSelectedKeys(new Set());\n  });\n\n  /**\n   * Shift held on the press that produced this change. `Checkbox` reports only\n   * the next value, so the modifier is captured from the pointer/key event on\n   * the cell and read back here.\n   */\n  const shiftRef = useRef(false);\n\n  const captureShift = useCallback((event: { shiftKey: boolean }) => {\n    shiftRef.current = event.shiftKey;\n  }, []);\n\n  /** Selectable keys between two rows, inclusive, in either direction. */\n  const keysBetween = useCallback(\n    (from: Key, to: Key) => {\n      const fromIndex = collection.indexOf(from);\n      const toIndex = collection.indexOf(to);\n\n      if (fromIndex < 0 || toIndex < 0) return [];\n\n      const [lo, hi] =\n        fromIndex <= toIndex ? [fromIndex, toIndex] : [toIndex, fromIndex];\n      const all = collection.getKeys();\n      const range: Key[] = [];\n\n      for (let i = lo; i <= hi; i++) range.push(all[i]);\n\n      return range;\n    },\n    [collection],\n  );\n\n  const toggleRow = useEvent((key: Key) => {\n    if (!canSelect(key)) return;\n\n    if (selectionMode === 'single') {\n      state.setSelectedKeys(isSelected(key) ? new Set() : new Set([key]));\n\n      return;\n    }\n\n    const anchor = anchorRef.current;\n\n    if (shiftRef.current && anchor != null && collection.indexOf(anchor) >= 0) {\n      const next = new Set(isAll ? scopeKeys : (selectedKeys as Set<Key>));\n\n      // Drop the range this shift-click supersedes before drawing the new one,\n      // so clicking back toward the anchor shrinks the selection.\n      if (extentRef.current != null) {\n        keysBetween(anchor, extentRef.current).forEach((k) => next.delete(k));\n      }\n\n      keysBetween(anchor, key).forEach((k) => {\n        if (canSelect(k)) next.add(k);\n      });\n\n      extentRef.current = key;\n      state.setSelectedKeys(next);\n\n      return;\n    }\n\n    anchorRef.current = key;\n    extentRef.current = null;\n    selectionManager.toggleSelection(key);\n  });\n\n  const selectedRows = useMemo(() => {\n    if (isAll) return [...rowByKey.values()];\n\n    return [...(selectedKeys as Set<Key>)]\n      .map((key) => rowByKey.get(key))\n      .filter((row): row is T => row !== undefined);\n  }, [isAll, selectedKeys, rowByKey]);\n\n  return {\n    isEnabled,\n    selectionMode,\n    selectionManager,\n    collection,\n    isSelected,\n    canSelect,\n    isRowDisabled: useCallback(\n      (key: Key) => hardDisabledKeys.has(key),\n      [hardDisabledKeys],\n    ),\n    toggleRow,\n    captureShift,\n    selectAllState,\n    toggleSelectAll,\n    clearSelection,\n    selectedRows,\n    selectedCount: isAll ? rowByKey.size : (selectedKeys as Set<Key>).size,\n    selectedKeys: (isAll ? 'all' : [...(selectedKeys as Set<Key>)]) as\n      | Key[]\n      | 'all',\n  };\n}\n\nexport type CubeTableSelectionState<T> = ReturnType<\n  typeof useTableSelection<T>\n>;\n"],"mappings":"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"}

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

@@ -0,0 +1,91 @@
+/** @license MIT | @cube-dev/ui-kit v0.157.1 | Cube Dev Team */
+import { useEvent } from "../../../_internal/hooks/use-event.js";
+import { getColumnText, getColumnValue } from "./use-table-columns.js";
+import { useMemo } from "react";
+import { useCollator } from "react-aria";
+import { useControlledState } from "@react-stately/utils";
+
+//#region src/components/data/TableBase/use-table-sort.ts
+/**
+* Sort state plus, in client mode, the reordered rows.
+*
+* The cycle is tri-state — `asc → desc → unsorted` — matching ag-grid's default
+* `sortingOrder`, because losing the ability to get back to the source order is
+* a real loss when the source order is meaningful. `disallowSortRemoval` on a
+* column reduces it to `asc ↔ desc`.
+*/
+function useTableSort({ columns, rows, mode, sort: sortProp, defaultSort, onSortChange }) {
+	const collator = useCollator({
+		numeric: true,
+		sensitivity: "base"
+	});
+	const [sort, setSort] = useControlledState(sortProp, defaultSort ?? null, onSortChange);
+	const hasSortableColumn = columns.some((column) => column.isSortable);
+	const resolvedMode = mode ?? (hasSortableColumn ? "client" : "off");
+	const isSortable = useEvent((column) => resolvedMode !== "off" && column.isSortable === true);
+	const toggleSort = useEvent((columnKey) => {
+		const column = columns.find((entry) => entry.key === columnKey);
+		if (!column || !isSortable(column)) return;
+		if (sort?.columnKey !== columnKey) {
+			setSort({
+				columnKey,
+				direction: "asc"
+			});
+			return;
+		}
+		if (sort.direction === "asc") {
+			setSort({
+				columnKey,
+				direction: "desc"
+			});
+			return;
+		}
+		setSort(column.disallowSortRemoval ? {
+			columnKey,
+			direction: "asc"
+		} : null);
+	});
+	return {
+		sort,
+		sortedRows: useMemo(() => {
+			if (resolvedMode !== "client" || !sort) return rows;
+			const column = columns.find((entry) => entry.key === sort.columnKey);
+			if (!column) return rows;
+			const direction = sort.direction === "asc" ? 1 : -1;
+			return rows.map((row, index) => ({
+				row,
+				index
+			})).sort((a, b) => {
+				const result = compareByColumn(column, collator, a.row, a.index, b.row, b.index);
+				return result !== 0 ? result * direction : a.index - b.index;
+			}).map((entry) => entry.row);
+		}, [
+			resolvedMode,
+			sort,
+			rows,
+			columns,
+			collator
+		]),
+		toggleSort,
+		isSortable,
+		mode: resolvedMode
+	};
+}
+function compareByColumn(column, collator, rowA, indexA, rowB, indexB) {
+	const valueA = getColumnValue(column, rowA, indexA);
+	const valueB = getColumnValue(column, rowB, indexB);
+	if (column.compare) return column.compare(valueA, valueB, rowA, rowB);
+	if (valueA == null && valueB == null) return 0;
+	if (valueA == null) return -1;
+	if (valueB == null) return 1;
+	if (typeof valueA === "number" && typeof valueB === "number") return valueA - valueB;
+	if (typeof valueA === "boolean" && typeof valueB === "boolean") return Number(valueA) - Number(valueB);
+	if (valueA instanceof Date && valueB instanceof Date) return valueA.getTime() - valueB.getTime();
+	const textA = getColumnText(column, rowA, indexA) ?? String(valueA);
+	const textB = getColumnText(column, rowB, indexB) ?? String(valueB);
+	return collator.compare(textA, textB);
+}
+
+//#endregion
+export { compareByColumn, useTableSort };
+//# sourceMappingURL=use-table-sort.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-table-sort.js","names":[],"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 { CubeTableColumn, CubeTableSort } 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  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  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 { sort, sortedRows, toggleSort, isSortable, mode: resolvedMode };\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":";;;;;;;;;;;;;;;;AA8CA,SAAgB,aAAgB,EAC9B,SACA,MACA,MACA,MAAM,UACN,aACA,gBACgD;CAGhD,MAAM,WAAW,YAAY;EAAE,SAAS;EAAM,aAAa;EAAQ,CAAC;CAEpE,MAAM,CAAC,MAAM,WAAW,mBACtB,UACA,eAAe,MACf,aACD;CAED,MAAM,oBAAoB,QAAQ,MAAM,WAAW,OAAO,WAAW;CACrE,MAAM,eACJ,SAAS,oBAAoB,WAAW;CAE1C,MAAM,aAAa,UAChB,WACC,iBAAiB,SAAS,OAAO,eAAe,KACnD;CAED,MAAM,aAAa,UAAU,cAAsB;EACjD,MAAM,SAAS,QAAQ,MAAM,UAAU,MAAM,QAAQ,UAAU;AAE/D,MAAI,CAAC,UAAU,CAAC,WAAW,OAAO,CAAE;AAEpC,MAAI,MAAM,cAAc,WAAW;AACjC,WAAQ;IAAE;IAAW,WAAW;IAAO,CAAC;AAExC;;AAGF,MAAI,KAAK,cAAc,OAAO;AAC5B,WAAQ;IAAE;IAAW,WAAW;IAAQ,CAAC;AAEzC;;AAGF,UACE,OAAO,sBAAsB;GAAE;GAAW,WAAW;GAAO,GAAG,KAChE;GACD;AAkCF,QAAO;EAAE;EAAM,YAhCI,cAAc;AAC/B,OAAI,iBAAiB,YAAY,CAAC,KAAM,QAAO;GAE/C,MAAM,SAAS,QAAQ,MAAM,UAAU,MAAM,QAAQ,KAAK,UAAU;AAEpE,OAAI,CAAC,OAAQ,QAAO;GAEpB,MAAM,YAAY,KAAK,cAAc,QAAQ,IAAI;AAKjD,UAAO,KACJ,KAAK,KAAK,WAAW;IAAE;IAAK;IAAO,EAAE,CACrC,MAAM,GAAG,MAAM;IACd,MAAM,SAAS,gBACb,QACA,UACA,EAAE,KACF,EAAE,OACF,EAAE,KACF,EAAE,MACH;AAED,WAAO,WAAW,IAAI,SAAS,YAAY,EAAE,QAAQ,EAAE;KACvD,CACD,KAAK,UAAU,MAAM,IAAI;KAC3B;GAAC;GAAc;GAAM;GAAM;GAAS;GAAS,CAAC;EAKtB;EAAY;EAAY,MAAM;EAAc;;AAGzE,SAAgB,gBACd,QACA,UACA,MACA,QACA,MACA,QACQ;CACR,MAAM,SAAS,eAAe,QAAQ,MAAM,OAAO;CACnD,MAAM,SAAS,eAAe,QAAQ,MAAM,OAAO;AAEnD,KAAI,OAAO,QAAS,QAAO,OAAO,QAAQ,QAAQ,QAAQ,MAAM,KAAK;AAIrE,KAAI,UAAU,QAAQ,UAAU,KAAM,QAAO;AAC7C,KAAI,UAAU,KAAM,QAAO;AAC3B,KAAI,UAAU,KAAM,QAAO;AAE3B,KAAI,OAAO,WAAW,YAAY,OAAO,WAAW,SAClD,QAAO,SAAS;AAElB,KAAI,OAAO,WAAW,aAAa,OAAO,WAAW,UACnD,QAAO,OAAO,OAAO,GAAG,OAAO,OAAO;AAExC,KAAI,kBAAkB,QAAQ,kBAAkB,KAC9C,QAAO,OAAO,SAAS,GAAG,OAAO,SAAS;CAK5C,MAAM,QAAQ,cAAc,QAAQ,MAAM,OAAO,IAAI,OAAO,OAAO;CACnE,MAAM,QAAQ,cAAc,QAAQ,MAAM,OAAO,IAAI,OAAO,OAAO;AAEnE,QAAO,SAAS,QAAQ,OAAO,MAAM"}

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

@@ -0,0 +1,97 @@
+/** @license MIT | @cube-dev/ui-kit v0.157.1 | Cube Dev Team */
+import { useEvent } from "../../../_internal/hooks/use-event.js";
+import { compareByColumn } from "./use-table-sort.js";
+import { useMemo } from "react";
+import { useControlledState } from "@react-stately/utils";
+import { useCollator } from "@react-aria/i18n";
+
+//#region src/components/data/TableBase/use-table-sorts.ts
+const EMPTY = [];
+/**
+* Multi-column sorting.
+*
+* `ItemTable` sorts by one column, which is right for a list. An analytical
+* grid is routinely ordered by one dimension and then another, and Cloud's
+* reports send an array of sorts to the query — so the order of the array is
+* the sort precedence, and it has to survive round-tripping.
+*
+* Clicking a header cycles that column `asc → desc → off` exactly as the single
+* version does; the difference is that it edits its entry in place rather than
+* replacing the whole sort, so the other columns keep their precedence.
+*/
+function useTableSorts({ columns, rows, mode, sorts: sortsProp, defaultSorts, onSortsChange }) {
+	const collator = useCollator({
+		numeric: true,
+		sensitivity: "base"
+	});
+	const [sorts, setSorts] = useControlledState(sortsProp, defaultSorts ?? EMPTY, onSortsChange);
+	const hasSortableColumn = columns.some((column) => column.isSortable);
+	const resolvedMode = mode ?? (hasSortableColumn ? "client" : "off");
+	const isSortable = useEvent((column) => resolvedMode !== "off" && column.isSortable === true);
+	const toggleSort = useEvent((columnKey) => {
+		const column = columns.find((entry) => entry.key === columnKey);
+		if (!column || !isSortable(column)) return;
+		const index = sorts.findIndex((entry) => entry.columnKey === columnKey);
+		if (index === -1) {
+			setSorts([...sorts, {
+				columnKey,
+				direction: "asc"
+			}]);
+			return;
+		}
+		const next = [...sorts];
+		if (next[index].direction === "asc") {
+			next[index] = {
+				columnKey,
+				direction: "desc"
+			};
+			setSorts(next);
+			return;
+		}
+		if (column.disallowSortRemoval) {
+			next[index] = {
+				columnKey,
+				direction: "asc"
+			};
+			setSorts(next);
+			return;
+		}
+		next.splice(index, 1);
+		setSorts(next);
+	});
+	return {
+		sorts,
+		sortedRows: useMemo(() => {
+			if (resolvedMode !== "client" || !sorts.length) return rows;
+			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
+			})).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);
+		}, [
+			resolvedMode,
+			sorts,
+			rows,
+			columns,
+			collator
+		]),
+		toggleSort,
+		isSortable,
+		sortRank: useEvent((columnKey) => sorts.findIndex((entry) => entry.columnKey === columnKey) + 1),
+		mode: resolvedMode
+	};
+}
+
+//#endregion
+export { useTableSorts };
+//# sourceMappingURL=use-table-sorts.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-table-sorts.js","names":[],"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 { CubeTableColumn, CubeTableSort } 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  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    isSortable,\n    sortRank,\n    mode: resolvedMode,\n  };\n}\n"],"mappings":";;;;;;;;AAmBA,MAAM,QAAyB,EAAE;;;;;;;;;;;;;AAcjC,SAAgB,cAAiB,EAC/B,SACA,MACA,MACA,OAAO,WACP,cACA,iBAC0B;CAC1B,MAAM,WAAW,YAAY;EAAE,SAAS;EAAM,aAAa;EAAQ,CAAC;CAEpE,MAAM,CAAC,OAAO,YAAY,mBACxB,WACA,gBAAgB,OAChB,cACD;CAED,MAAM,oBAAoB,QAAQ,MAAM,WAAW,OAAO,WAAW;CACrE,MAAM,eAAe,SAAS,oBAAoB,WAAW;CAE7D,MAAM,aAAa,UAChB,WACC,iBAAiB,SAAS,OAAO,eAAe,KACnD;CAED,MAAM,aAAa,UAAU,cAAsB;EACjD,MAAM,SAAS,QAAQ,MAAM,UAAU,MAAM,QAAQ,UAAU;AAE/D,MAAI,CAAC,UAAU,CAAC,WAAW,OAAO,CAAE;EAEpC,MAAM,QAAQ,MAAM,WAAW,UAAU,MAAM,cAAc,UAAU;AAEvE,MAAI,UAAU,IAAI;AAGhB,YAAS,CAAC,GAAG,OAAO;IAAE;IAAW,WAAW;IAAO,CAAC,CAAC;AAErD;;EAGF,MAAM,OAAO,CAAC,GAAG,MAAM;AAEvB,MAAI,KAAK,OAAO,cAAc,OAAO;AACnC,QAAK,SAAS;IAAE;IAAW,WAAW;IAAQ;AAC9C,YAAS,KAAK;AAEd;;AAGF,MAAI,OAAO,qBAAqB;AAC9B,QAAK,SAAS;IAAE;IAAW,WAAW;IAAO;AAC7C,YAAS,KAAK;AAEd;;AAGF,OAAK,OAAO,OAAO,EAAE;AACrB,WAAS,KAAK;GACd;AAmDF,QAAO;EACL;EACA,YAnDiB,cAAc;AAC/B,OAAI,iBAAiB,YAAY,CAAC,MAAM,OAAQ,QAAO;GAEvD,MAAM,SAAS,MACZ,KAAK,UAAU;IACd;IACA,QAAQ,QAAQ,MAAM,UAAU,MAAM,QAAQ,KAAK,UAAU;IAC9D,EAAE,CACF,QACE,UACC,MAAM,UAAU,KACnB;AAEH,OAAI,CAAC,OAAO,OAAQ,QAAO;AAK3B,UAAO,KACJ,KAAK,KAAK,WAAW;IAAE;IAAK;IAAO,EAAE,CACrC,MAAM,GAAG,MAAM;AACd,SAAK,MAAM,EAAE,MAAM,YAAY,QAAQ;KACrC,MAAM,SAAS,gBACb,QACA,UACA,EAAE,KACF,EAAE,OACF,EAAE,KACF,EAAE,MACH;AAED,SAAI,WAAW,EACb,QAAO,UAAU,KAAK,cAAc,QAAQ,IAAI;;AAIpD,WAAO,EAAE,QAAQ,EAAE;KACnB,CACD,KAAK,UAAU,MAAM,IAAI;KAC3B;GAAC;GAAc;GAAO;GAAM;GAAS;GAAS,CAAC;EAahD;EACA;EACA,UAZe,UACd,cACC,MAAM,WAAW,UAAU,MAAM,cAAc,UAAU,GAAG,EAC/D;EAUC,MAAM;EACP"}

package/dist/components/data/TableBase/use-table-storage.d.ts

@@ -0,0 +1,8 @@
+
+import "./types.js";
+
+//#region src/components/data/TableBase/use-table-storage.d.ts
+type CubeTablePersistKey = 'pageSize' | 'columnWidths' | 'sort';
+//#endregion
+export { CubeTablePersistKey };
+//# sourceMappingURL=use-table-storage.d.ts.map