@cube-dev/ui-kit 0.181.0 → 0.183.0

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

@@ -1,7 +1,7 @@
-/** @license MIT | @cube-dev/ui-kit v0.181.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.183.0 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { compareByColumn } from "./use-table-sort.js";
-import { useMemo } from "react";
+import { c } from "react-compiler-runtime";
 import { useControlledState } from "@react-stately/utils";
 import { useCollator } from "@react-aria/i18n";
 
@@ -19,117 +19,184 @@ const EMPTY = [];
 * 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"
-	});
+function useTableSorts(t0) {
+	const $ = c(31);
+	const { columns, rows, mode, sorts: sortsProp, defaultSorts, onSortsChange } = t0;
+	let t1;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t1 = {
+			numeric: true,
+			sensitivity: "base"
+		};
+		$[0] = t1;
+	} else t1 = $[0];
+	const collator = useCollator(t1);
 	const [sorts, setSorts] = useControlledState(sortsProp, defaultSorts ?? EMPTY, onSortsChange);
-	const hasSortableColumn = columns.some((column) => column.isSortable);
+	const hasSortableColumn = columns.some(_temp);
 	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);
-	});
-	/**
-	* Set one column's direction outright instead of advancing the cycle.
-	*
-	* The column menu's `sort-desc` has to reach `desc` in one step. Reaching it
-	* by calling `toggleSort` twice cannot work here: under `disallowSortRemoval`
-	* the cycle never leaves `asc`/`desc`, and a column that was unsorted would
-	* be appended and then re-read, so every intermediate state is observable.
-	*
-	* Precedence is preserved — an already-sorted column keeps its slot, and a
-	* newly sorted one is appended as the least significant, the same rule
-	* `toggleSort` follows.
-	*/
-	const setColumnSort = useEvent((columnKey, direction) => {
-		const column = columns.find((entry) => entry.key === columnKey);
-		if (!column || !isSortable(column)) return;
-		const index = sorts.findIndex((entry) => entry.columnKey === columnKey);
-		if (direction == null) {
-			if (index === -1 || column.disallowSortRemoval) return;
+	let t2;
+	if ($[1] !== resolvedMode) {
+		t2 = (column_0) => resolvedMode !== "off" && column_0.isSortable === true;
+		$[1] = resolvedMode;
+		$[2] = t2;
+	} else t2 = $[2];
+	const isSortable = useEvent(t2);
+	let t3;
+	if ($[3] !== columns || $[4] !== isSortable || $[5] !== setSorts || $[6] !== sorts) {
+		t3 = (columnKey) => {
+			const column_1 = columns.find((entry) => entry.key === columnKey);
+			if (!column_1 || !isSortable(column_1)) return;
+			const index = sorts.findIndex((entry_0) => entry_0.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_1.disallowSortRemoval) {
+				next[index] = {
+					columnKey,
+					direction: "asc"
+				};
+				setSorts(next);
+				return;
+			}
 			next.splice(index, 1);
 			setSorts(next);
-			return;
-		}
-		if (index === -1) {
-			setSorts([...sorts, {
-				columnKey,
+		};
+		$[3] = columns;
+		$[4] = isSortable;
+		$[5] = setSorts;
+		$[6] = sorts;
+		$[7] = t3;
+	} else t3 = $[7];
+	const toggleSort = useEvent(t3);
+	let t4;
+	if ($[8] !== columns || $[9] !== isSortable || $[10] !== setSorts || $[11] !== sorts) {
+		t4 = (columnKey_0, direction) => {
+			const column_2 = columns.find((entry_1) => entry_1.key === columnKey_0);
+			if (!column_2 || !isSortable(column_2)) return;
+			const index_0 = sorts.findIndex((entry_2) => entry_2.columnKey === columnKey_0);
+			if (direction == null) {
+				if (index_0 === -1 || column_2.disallowSortRemoval) return;
+				const next_0 = [...sorts];
+				next_0.splice(index_0, 1);
+				setSorts(next_0);
+				return;
+			}
+			if (index_0 === -1) {
+				setSorts([...sorts, {
+					columnKey: columnKey_0,
+					direction
+				}]);
+				return;
+			}
+			if (sorts[index_0].direction === direction) return;
+			const next_1 = [...sorts];
+			next_1[index_0] = {
+				columnKey: columnKey_0,
 				direction
-			}]);
-			return;
-		}
-		if (sorts[index].direction === direction) return;
-		const next = [...sorts];
-		next[index] = {
-			columnKey,
-			direction
+			};
+			setSorts(next_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);
+		$[8] = columns;
+		$[9] = isSortable;
+		$[10] = setSorts;
+		$[11] = sorts;
+		$[12] = t4;
+	} else t4 = $[12];
+	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((entry) => entry.row);
-		}, [
-			resolvedMode,
+			}).map(_temp4);
+		}
+		$[13] = collator;
+		$[14] = columns;
+		$[15] = resolvedMode;
+		$[16] = rows;
+		$[17] = sorts;
+		$[18] = t5;
+	} 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];
+	const sortRank = useEvent(t6);
+	let t7;
+	if ($[23] !== isSortable || $[24] !== resolvedMode || $[25] !== setColumnSort || $[26] !== sortRank || $[27] !== sortedRows || $[28] !== sorts || $[29] !== toggleSort) {
+		t7 = {
 			sorts,
-			rows,
-			columns,
-			collator
-		]),
-		toggleSort,
-		setColumnSort,
-		isSortable,
-		sortRank: useEvent((columnKey) => sorts.findIndex((entry) => entry.columnKey === columnKey) + 1),
-		mode: resolvedMode
+			sortedRows,
+			toggleSort,
+			setColumnSort,
+			isSortable,
+			sortRank,
+			mode: resolvedMode
+		};
+		$[23] = isSortable;
+		$[24] = resolvedMode;
+		$[25] = setColumnSort;
+		$[26] = sortRank;
+		$[27] = sortedRows;
+		$[28] = sorts;
+		$[29] = toggleSort;
+		$[30] = t7;
+	} else t7 = $[30];
+	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;
+}
 
 //#endregion
 export { useTableSorts };

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

@@ -1 +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 {\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":";;;;;;;;AAuBA,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;;;;;;;;;;;;;CAcF,MAAM,gBAAgB,UACnB,WAAmB,cAA6C;EAC/D,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,aAAa,MAAM;AAGrB,OAAI,UAAU,MAAM,OAAO,oBAAqB;GAEhD,MAAM,OAAO,CAAC,GAAG,MAAM;AAEvB,QAAK,OAAO,OAAO,EAAE;AACrB,YAAS,KAAK;AAEd;;AAGF,MAAI,UAAU,IAAI;AAChB,YAAS,CAAC,GAAG,OAAO;IAAE;IAAW;IAAW,CAAC,CAAC;AAE9C;;AAGF,MAAI,MAAM,OAAO,cAAc,UAAW;EAE1C,MAAM,OAAO,CAAC,GAAG,MAAM;AAEvB,OAAK,SAAS;GAAE;GAAW;GAAW;AACtC,WAAS,KAAK;GAEjB;AAmDD,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;EACA,UAbe,UACd,cACC,MAAM,WAAW,UAAU,MAAM,cAAc,UAAU,GAAG,EAC/D;EAWC,MAAM;EACP"}
+{"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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"}

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

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.181.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.183.0 | Cube Dev Team */
 import { useCallback, useRef, useState } from "react";
 
 //#region src/components/data/TableBase/use-table-storage.ts
@@ -52,7 +52,7 @@ function useTableStorage(storageKey, persist = DEFAULT_PERSIST_KEYS) {
 	}, [storageKey]);
 	return {
 		initial: storageKey ? initial : {},
-		has: (key) => !!storageKey && persist.includes(key),
+		has: (key_0) => !!storageKey && persist.includes(key_0),
 		write
 	};
 }

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

@@ -1 +1 @@
-{"version":3,"file":"use-table-storage.js","names":[],"sources":["../../../../src/components/data/TableBase/use-table-storage.ts"],"sourcesContent":["import { useCallback, useRef, useState } from 'react';\n\nimport type { CubeTableSort } from './types';\n\n/**\n * Namespaced so a `storageKey` cannot collide with whatever else the host app\n * keeps in `localStorage`, and so the kit's own stored shape can be migrated or\n * cleared as a group later.\n */\nconst PREFIX = 'cube-ui-kit:table:';\n\nexport type CubeTablePersistKey =\n  | 'pageSize'\n  | 'columnWidths'\n  | 'columnOrder'\n  | 'sort';\n\nexport interface CubeTableStoredState {\n  pageSize?: number;\n  sort?: CubeTableSort | null;\n  columnWidths?: Record<string, number>;\n  /** Every column key in order, including hidden and pinned ones. */\n  columnOrder?: string[];\n}\n\nexport const DEFAULT_PERSIST_KEYS: CubeTablePersistKey[] = [\n  'pageSize',\n  'columnWidths',\n  // A column layout the user arranged by hand is the same kind of state as the\n  // widths they dragged — losing it on reload would be as surprising.\n  'columnOrder',\n];\n\nfunction read(storageKey: string | undefined): CubeTableStoredState {\n  // No `storageKey` means the feature is off; no `window` means SSR. Both are\n  // normal, not errors.\n  if (!storageKey || typeof window === 'undefined') return {};\n\n  try {\n    const raw = window.localStorage.getItem(PREFIX + storageKey);\n\n    if (!raw) return {};\n\n    const parsed = JSON.parse(raw);\n\n    // Anything could be under that key — a hand-edited value, a stale shape\n    // from an older version. A non-object is simply ignored.\n    return parsed && typeof parsed === 'object' ? parsed : {};\n  } catch {\n    // Private mode, a disabled store, or malformed JSON. Persistence is a\n    // convenience; losing it must never take the table down with it.\n    return {};\n  }\n}\n\n/**\n * Persists the parts of the table's own state that a user expects to survive a\n * reload. Only state the table *owns* is stored: a controlled `pageSize` or\n * `sort` belongs to the page, so restoring it would fight the page's own source\n * of truth.\n *\n * Returns the state read at mount — a one-shot snapshot, deliberately, so a\n * second table sharing the key cannot yank this one's page size mid-session.\n */\nexport function useTableStorage(\n  storageKey: string | undefined,\n  persist: CubeTablePersistKey[] = DEFAULT_PERSIST_KEYS,\n) {\n  const [initial] = useState(() => read(storageKey));\n  const persistRef = useRef(persist);\n\n  persistRef.current = persist;\n\n  const write = useCallback(\n    (patch: CubeTableStoredState) => {\n      if (!storageKey || typeof window === 'undefined') return;\n\n      const allowed = persistRef.current;\n      const entries = Object.entries(patch).filter(([key]) =>\n        allowed.includes(key as CubeTablePersistKey),\n      );\n\n      if (!entries.length) return;\n\n      try {\n        const next = {\n          ...read(storageKey),\n          ...Object.fromEntries(entries),\n        };\n\n        window.localStorage.setItem(PREFIX + storageKey, JSON.stringify(next));\n      } catch {\n        // Quota exceeded or a disabled store — nothing to do but carry on.\n      }\n    },\n    [storageKey],\n  );\n\n  return {\n    initial: storageKey ? initial : {},\n    /** `true` when this key is persisted, so callers can skip the work. */\n    has: (key: CubeTablePersistKey) => !!storageKey && persist.includes(key),\n    write,\n  };\n}\n"],"mappings":";;;;;;;;;AASA,MAAM,SAAS;AAgBf,MAAa,uBAA8C;CACzD;CACA;CAGA;CACD;AAED,SAAS,KAAK,YAAsD;AAGlE,KAAI,CAAC,cAAc,OAAO,WAAW,YAAa,QAAO,EAAE;AAE3D,KAAI;EACF,MAAM,MAAM,OAAO,aAAa,QAAQ,SAAS,WAAW;AAE5D,MAAI,CAAC,IAAK,QAAO,EAAE;EAEnB,MAAM,SAAS,KAAK,MAAM,IAAI;AAI9B,SAAO,UAAU,OAAO,WAAW,WAAW,SAAS,EAAE;SACnD;AAGN,SAAO,EAAE;;;;;;;;;;;;AAab,SAAgB,gBACd,YACA,UAAiC,sBACjC;CACA,MAAM,CAAC,WAAW,eAAe,KAAK,WAAW,CAAC;CAClD,MAAM,aAAa,OAAO,QAAQ;AAElC,YAAW,UAAU;CAErB,MAAM,QAAQ,aACX,UAAgC;AAC/B,MAAI,CAAC,cAAc,OAAO,WAAW,YAAa;EAElD,MAAM,UAAU,WAAW;EAC3B,MAAM,UAAU,OAAO,QAAQ,MAAM,CAAC,QAAQ,CAAC,SAC7C,QAAQ,SAAS,IAA2B,CAC7C;AAED,MAAI,CAAC,QAAQ,OAAQ;AAErB,MAAI;GACF,MAAM,OAAO;IACX,GAAG,KAAK,WAAW;IACnB,GAAG,OAAO,YAAY,QAAQ;IAC/B;AAED,UAAO,aAAa,QAAQ,SAAS,YAAY,KAAK,UAAU,KAAK,CAAC;UAChE;IAIV,CAAC,WAAW,CACb;AAED,QAAO;EACL,SAAS,aAAa,UAAU,EAAE;EAElC,MAAM,QAA6B,CAAC,CAAC,cAAc,QAAQ,SAAS,IAAI;EACxE;EACD"}
+{"version":3,"file":"use-table-storage.js","names":["useCallback","useRef","useState","CubeTableSort","PREFIX","CubeTablePersistKey","CubeTableStoredState","pageSize","sort","columnWidths","Record","columnOrder","DEFAULT_PERSIST_KEYS","read","storageKey","window","raw","localStorage","getItem","parsed","JSON","parse","useTableStorage","persist","initial","persistRef","current","write","patch","allowed","entries","Object","filter","key","includes","length","next","fromEntries","setItem","stringify","has"],"sources":["../../../../src/components/data/TableBase/use-table-storage.ts"],"sourcesContent":["import { useCallback, useRef, useState } from 'react';\n\nimport type { CubeTableSort } from './types';\n\n/**\n * Namespaced so a `storageKey` cannot collide with whatever else the host app\n * keeps in `localStorage`, and so the kit's own stored shape can be migrated or\n * cleared as a group later.\n */\nconst PREFIX = 'cube-ui-kit:table:';\n\nexport type CubeTablePersistKey =\n  | 'pageSize'\n  | 'columnWidths'\n  | 'columnOrder'\n  | 'sort';\n\nexport interface CubeTableStoredState {\n  pageSize?: number;\n  sort?: CubeTableSort | null;\n  columnWidths?: Record<string, number>;\n  /** Every column key in order, including hidden and pinned ones. */\n  columnOrder?: string[];\n}\n\nexport const DEFAULT_PERSIST_KEYS: CubeTablePersistKey[] = [\n  'pageSize',\n  'columnWidths',\n  // A column layout the user arranged by hand is the same kind of state as the\n  // widths they dragged — losing it on reload would be as surprising.\n  'columnOrder',\n];\n\nfunction read(storageKey: string | undefined): CubeTableStoredState {\n  // No `storageKey` means the feature is off; no `window` means SSR. Both are\n  // normal, not errors.\n  if (!storageKey || typeof window === 'undefined') return {};\n\n  try {\n    const raw = window.localStorage.getItem(PREFIX + storageKey);\n\n    if (!raw) return {};\n\n    const parsed = JSON.parse(raw);\n\n    // Anything could be under that key — a hand-edited value, a stale shape\n    // from an older version. A non-object is simply ignored.\n    return parsed && typeof parsed === 'object' ? parsed : {};\n  } catch {\n    // Private mode, a disabled store, or malformed JSON. Persistence is a\n    // convenience; losing it must never take the table down with it.\n    return {};\n  }\n}\n\n/**\n * Persists the parts of the table's own state that a user expects to survive a\n * reload. Only state the table *owns* is stored: a controlled `pageSize` or\n * `sort` belongs to the page, so restoring it would fight the page's own source\n * of truth.\n *\n * Returns the state read at mount — a one-shot snapshot, deliberately, so a\n * second table sharing the key cannot yank this one's page size mid-session.\n */\nexport function useTableStorage(\n  storageKey: string | undefined,\n  persist: CubeTablePersistKey[] = DEFAULT_PERSIST_KEYS,\n) {\n  const [initial] = useState(() => read(storageKey));\n  const persistRef = useRef(persist);\n\n  persistRef.current = persist;\n\n  const write = useCallback(\n    (patch: CubeTableStoredState) => {\n      if (!storageKey || typeof window === 'undefined') return;\n\n      const allowed = persistRef.current;\n      const entries = Object.entries(patch).filter(([key]) =>\n        allowed.includes(key as CubeTablePersistKey),\n      );\n\n      if (!entries.length) return;\n\n      try {\n        const next = {\n          ...read(storageKey),\n          ...Object.fromEntries(entries),\n        };\n\n        window.localStorage.setItem(PREFIX + storageKey, JSON.stringify(next));\n      } catch {\n        // Quota exceeded or a disabled store — nothing to do but carry on.\n      }\n    },\n    [storageKey],\n  );\n\n  return {\n    initial: storageKey ? initial : {},\n    /** `true` when this key is persisted, so callers can skip the work. */\n    has: (key: CubeTablePersistKey) => !!storageKey && persist.includes(key),\n    write,\n  };\n}\n"],"mappings":";;;;;;;;;AASA,MAAMI,SAAS;AAgBf,MAAaQ,uBAA8C;CACzD;CACA;CAGA;CACD;AAED,SAASC,KAAKC,YAAsD;AAGlE,KAAI,CAACA,cAAc,OAAOC,WAAW,YAAa,QAAO,EAAE;AAE3D,KAAI;EACF,MAAMC,MAAMD,OAAOE,aAAaC,QAAQd,SAASU,WAAW;AAE5D,MAAI,CAACE,IAAK,QAAO,EAAE;EAEnB,MAAMG,SAASC,KAAKC,MAAML,IAAI;AAI9B,SAAOG,UAAU,OAAOA,WAAW,WAAWA,SAAS,EAAE;SACnD;AAGN,SAAO,EAAE;;;;;;;;;;;;AAab,SAAgBG,gBACdR,YACAS,UAAiCX,sBACjC;CACA,MAAM,CAACY,WAAWtB,eAAeW,KAAKC,WAAW,CAAC;CAClD,MAAMW,aAAaxB,OAAOsB,QAAQ;AAElCE,YAAWC,UAAUH;CAErB,MAAMI,QAAQ3B,aACX4B,UAAgC;AAC/B,MAAI,CAACd,cAAc,OAAOC,WAAW,YAAa;EAElD,MAAMc,UAAUJ,WAAWC;EAC3B,MAAMI,UAAUC,OAAOD,QAAQF,MAAM,CAACI,QAAQ,CAACC,SAC7CJ,QAAQK,SAASD,IACnB,CAAC;AAED,MAAI,CAACH,QAAQK,OAAQ;AAErB,MAAI;GACF,MAAMC,OAAO;IACX,GAAGvB,KAAKC,WAAW;IACnB,GAAGiB,OAAOM,YAAYP,QAAO;IAC9B;AAEDf,UAAOE,aAAaqB,QAAQlC,SAASU,YAAYM,KAAKmB,UAAUH,KAAK,CAAC;UAChE;IAIV,CAACtB,WACH,CAAC;AAED,QAAO;EACLU,SAASV,aAAaU,UAAU,EAAE;EAElCgB,MAAMP,UAA6B,CAAC,CAACnB,cAAcS,QAAQW,SAASD,MAAI;EACxEN;EACD"}