@cube-dev/ui-kit 0.0.0-canary-e76eb3e → 0.0.0-canary-01fea9d

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

@@ -1,233 +0,0 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-e76eb3e | 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

@@ -1 +0,0 @@
-{"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

@@ -1,91 +0,0 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-e76eb3e | 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

@@ -1 +0,0 @@
-{"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

@@ -1,97 +0,0 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-e76eb3e | 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

@@ -1 +0,0 @@
-{"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

@@ -1,8 +0,0 @@
-
-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

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

@@ -1,58 +0,0 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-e76eb3e | Cube Dev Team */
-import { useCallback, useRef, useState } from "react";
-
-//#region src/components/data/TableBase/use-table-storage.ts
-/**
-* Namespaced so a `storageKey` cannot collide with whatever else the host app
-* keeps in `localStorage`, and so the kit's own stored shape can be migrated or
-* cleared as a group later.
-*/
-const PREFIX = "cube-ui-kit:table:";
-const DEFAULT_PERSIST_KEYS = ["pageSize", "columnWidths"];
-function read(storageKey) {
-	if (!storageKey || typeof window === "undefined") return {};
-	try {
-		const raw = window.localStorage.getItem(PREFIX + storageKey);
-		if (!raw) return {};
-		const parsed = JSON.parse(raw);
-		return parsed && typeof parsed === "object" ? parsed : {};
-	} catch {
-		return {};
-	}
-}
-/**
-* Persists the parts of the table's own state that a user expects to survive a
-* reload. Only state the table *owns* is stored: a controlled `pageSize` or
-* `sort` belongs to the page, so restoring it would fight the page's own source
-* of truth.
-*
-* Returns the state read at mount — a one-shot snapshot, deliberately, so a
-* second table sharing the key cannot yank this one's page size mid-session.
-*/
-function useTableStorage(storageKey, persist = DEFAULT_PERSIST_KEYS) {
-	const [initial] = useState(() => read(storageKey));
-	const persistRef = useRef(persist);
-	persistRef.current = persist;
-	const write = useCallback((patch) => {
-		if (!storageKey || typeof window === "undefined") return;
-		const allowed = persistRef.current;
-		const entries = Object.entries(patch).filter(([key]) => allowed.includes(key));
-		if (!entries.length) return;
-		try {
-			const next = {
-				...read(storageKey),
-				...Object.fromEntries(entries)
-			};
-			window.localStorage.setItem(PREFIX + storageKey, JSON.stringify(next));
-		} catch {}
-	}, [storageKey]);
-	return {
-		initial: storageKey ? initial : {},
-		has: (key) => !!storageKey && persist.includes(key),
-		write
-	};
-}
-
-//#endregion
-export { useTableStorage };
-//# sourceMappingURL=use-table-storage.js.map

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

@@ -1 +0,0 @@
-{"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 = 'pageSize' | 'columnWidths' | 'sort';\n\nexport interface CubeTableStoredState {\n  pageSize?: number;\n  sort?: CubeTableSort | null;\n  columnWidths?: Record<string, number>;\n}\n\nexport const DEFAULT_PERSIST_KEYS: CubeTablePersistKey[] = [\n  'pageSize',\n  'columnWidths',\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;AAUf,MAAa,uBAA8C,CACzD,YACA,eACD;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"}

package/dist/components/data/index.d.ts

@@ -1,10 +0,0 @@
-
-import { CubeTableAlign, CubeTableCellContext, CubeTableColumn, CubeTableColumnHeader, CubeTableHeaderContext, CubeTableRowContext, CubeTableRowSection, CubeTableSort, CubeTableSortDirection } from "./TableBase/types.js";
-import { CubeDataTableColumn, CubeDataTableProps } from "./DataTable/types.js";
-import { _DataTable } from "./DataTable/DataTable.js";
-import "./DataTable/index.js";
-import { CubeTableRowRenderProps } from "./TableBase/TableView.js";
-import { CubeItemTableColumn, CubeItemTableProps } from "./ItemTable/types.js";
-import { _ItemTable } from "./ItemTable/ItemTable.js";
-import "./ItemTable/index.js";
-import "./TableBase/index.js";

package/dist/components/fields/ColorPicker/ColorPickerPanel.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ColorPickerPanel.js","names":["Slider","Radio"],"sources":["../../../../src/components/fields/ColorPicker/ColorPickerPanel.tsx"],"sourcesContent":["import { Styles, tasty } from '@tenphi/tasty';\nimport { useMemo } from 'react';\n\nimport { useEvent } from '../../../_internal';\nimport { Radio } from '../RadioGroup';\nimport { Slider } from '../Slider';\n\nimport {\n  CHANNELS,\n  COLOR_SPACE_HINTS,\n  COLOR_SPACE_LABELS,\n  COLOR_SPACES,\n  ColorChannel,\n  ColorSpace,\n} from './channels';\nimport {\n  ColorFormat,\n  ColorValue,\n  formatColor,\n  getContrastingColor,\n  toHex,\n} from './color';\n\nconst PanelElement = tasty({\n  qa: 'ColorPickerPanel',\n  styles: {\n    display: 'grid',\n    flow: 'row',\n    gap: '1x',\n    padding: '1x',\n    width: '34x',\n  },\n});\n\nconst PreviewElement = tasty({\n  qa: 'ColorPreview',\n  styles: {\n    display: 'grid',\n    placeItems: 'center',\n    height: '6x',\n    radius: true,\n    preset: 's4',\n    fill: '(#color-picker, #clear)',\n    color: '(#color-picker-contrast, #dark)',\n    shadow: 'inset 0 0 0 1bw #dark.1',\n  },\n});\n\nconst ChannelsElement = tasty({\n  styles: {\n    display: 'grid',\n    gridColumns: 'max-content 1sf max-content',\n    placeItems: 'center stretch',\n    gap: '1x',\n  },\n});\n\nconst ChannelLabelElement = tasty({\n  styles: {\n    preset: 'c2',\n    color: '#dark-03',\n    textAlign: 'center',\n    width: '2x',\n  },\n});\n\nconst ChannelTrackElement = tasty({\n  styles: {\n    display: 'grid',\n    placeItems: 'center stretch',\n  },\n});\n\nconst ChannelValueElement = tasty({\n  styles: {\n    preset: 's4',\n    color: '#dark-02',\n    textAlign: 'right',\n    whiteSpace: 'nowrap',\n    width: '5.5x',\n  },\n});\n\n/**\n * The gradient reaches the track through a plain custom property so the track\n * keeps a single cached style rule. A color picker moves its channels\n * continuously, and a fresh `styles` object per frame would emit a fresh CSS\n * rule per frame.\n */\nconst TRACK_STYLES: Styles = {\n  height: '1x',\n  top: '.5x',\n  radius: '1r',\n  fill: '#clear',\n  image: '$channel-gradient',\n  shadow: 'inset 0 0 0 1bw #dark.1',\n  Fill: false,\n};\n\n/** A ring keeps the thumb visible wherever it sits on its own gradient. */\nconst THUMB_STYLES: Styles = {\n  shadow: '0 0 0 2bw #surface, 0 0 0 3bw #dark.2',\n};\n\nconst THUMB_TOKENS = { '#slider-thumb': '(#color-picker, #surface)' };\n\nconst SPACE_STYLES: Styles = { width: '100%' };\nconst TAB_STYLES: Styles = { flexGrow: 1 };\n\nexport interface ColorPickerPanelProps {\n  color: ColorValue;\n  space: ColorSpace;\n  isDisabled?: boolean;\n  /** Notation used for the preview caption. */\n  previewFormat: ColorFormat;\n  onChange: (color: ColorValue) => void;\n  onSpaceChange: (space: ColorSpace) => void;\n}\n\ninterface ChannelRowProps {\n  channel: ColorChannel;\n  color: ColorValue;\n  isDisabled?: boolean;\n  onChange: (color: ColorValue) => void;\n}\n\nfunction ChannelRow({ channel, color, isDisabled, onChange }: ChannelRowProps) {\n  const max = channel.max(color);\n\n  const handleChange = useEvent((value: number) => {\n    onChange(channel.apply(color, value));\n  });\n\n  return (\n    <>\n      <ChannelLabelElement aria-hidden=\"true\">\n        {channel.label}\n      </ChannelLabelElement>\n      <ChannelTrackElement\n        style={{\n          '--channel-gradient': `linear-gradient(to right, ${channel.stops(\n            color,\n          )})`,\n        }}\n      >\n        <Slider\n          aria-label={channel.title}\n          value={Math.min(channel.value(color), max)}\n          minValue={channel.min}\n          maxValue={max}\n          step={channel.step}\n          isDisabled={isDisabled}\n          trackStyles={TRACK_STYLES}\n          thumbStyles={THUMB_STYLES}\n          thumbTokens={THUMB_TOKENS}\n          onChange={handleChange}\n        />\n      </ChannelTrackElement>\n      <ChannelValueElement>{channel.display(color)}</ChannelValueElement>\n    </>\n  );\n}\n\n/**\n * The popover body of `ColorPicker`: a preview, a switch between the three\n * color concepts, and one gradient slider per channel of the active one.\n */\nexport function ColorPickerPanel(props: ColorPickerPanelProps) {\n  const { color, space, isDisabled, previewFormat, onChange, onSpaceChange } =\n    props;\n\n  const colorTokens = useMemo(\n    () => ({\n      '--color-picker-color': toHex(color),\n      '--color-picker-contrast-color': getContrastingColor(color),\n    }),\n    [color],\n  );\n\n  const handleSpaceChange = useEvent((value: string) => {\n    onSpaceChange(value as ColorSpace);\n  });\n\n  return (\n    <PanelElement style={colorTokens}>\n      <PreviewElement>{formatColor(color, previewFormat)}</PreviewElement>\n      <Radio.Tabs\n        aria-label=\"Color space\"\n        value={space}\n        isDisabled={isDisabled}\n        styles={SPACE_STYLES}\n        onChange={handleSpaceChange}\n      >\n        {COLOR_SPACES.map((item) => (\n          <Radio\n            key={item}\n            value={item}\n            aria-label={COLOR_SPACE_LABELS[item]}\n            tooltip={COLOR_SPACE_HINTS[item]}\n            styles={TAB_STYLES}\n          >\n            {COLOR_SPACE_LABELS[item]}\n          </Radio>\n        ))}\n      </Radio.Tabs>\n      <ChannelsElement>\n        {CHANNELS[space].map((channel) => (\n          <ChannelRow\n            key={`${space}-${channel.label}`}\n            channel={channel}\n            color={color}\n            isDisabled={isDisabled}\n            onChange={onChange}\n          />\n        ))}\n      </ChannelsElement>\n    </PanelElement>\n  );\n}\n"],"mappings":";;;;;;;;;;;AAuBA,MAAM,eAAe,MAAM;CACzB,IAAI;CACJ,QAAQ;EACN,SAAS;EACT,MAAM;EACN,KAAK;EACL,SAAS;EACT,OAAO;EACR;CACF,CAAC;AAEF,MAAM,iBAAiB,MAAM;CAC3B,IAAI;CACJ,QAAQ;EACN,SAAS;EACT,YAAY;EACZ,QAAQ;EACR,QAAQ;EACR,QAAQ;EACR,MAAM;EACN,OAAO;EACP,QAAQ;EACT;CACF,CAAC;AAEF,MAAM,kBAAkB,MAAM,EAC5B,QAAQ;CACN,SAAS;CACT,aAAa;CACb,YAAY;CACZ,KAAK;CACN,EACF,CAAC;AAEF,MAAM,sBAAsB,MAAM,EAChC,QAAQ;CACN,QAAQ;CACR,OAAO;CACP,WAAW;CACX,OAAO;CACR,EACF,CAAC;AAEF,MAAM,sBAAsB,MAAM,EAChC,QAAQ;CACN,SAAS;CACT,YAAY;CACb,EACF,CAAC;AAEF,MAAM,sBAAsB,MAAM,EAChC,QAAQ;CACN,QAAQ;CACR,OAAO;CACP,WAAW;CACX,YAAY;CACZ,OAAO;CACR,EACF,CAAC;;;;;;;AAQF,MAAM,eAAuB;CAC3B,QAAQ;CACR,KAAK;CACL,QAAQ;CACR,MAAM;CACN,OAAO;CACP,QAAQ;CACR,MAAM;CACP;;AAGD,MAAM,eAAuB,EAC3B,QAAQ,yCACT;AAED,MAAM,eAAe,EAAE,iBAAiB,6BAA6B;AAErE,MAAM,eAAuB,EAAE,OAAO,QAAQ;AAC9C,MAAM,aAAqB,EAAE,UAAU,GAAG;AAmB1C,SAAS,WAAW,EAAE,SAAS,OAAO,YAAY,YAA6B;CAC7E,MAAM,MAAM,QAAQ,IAAI,MAAM;CAE9B,MAAM,eAAe,UAAU,UAAkB;AAC/C,WAAS,QAAQ,MAAM,OAAO,MAAM,CAAC;GACrC;AAEF,QACE;EACE,oBAAC;GAAoB,eAAY;aAC9B,QAAQ;IACW;EACtB,oBAAC;GACC,OAAO,EACL,sBAAsB,6BAA6B,QAAQ,MACzD,MACD,CAAC,IACH;aAED,oBAACA;IACC,cAAY,QAAQ;IACpB,OAAO,KAAK,IAAI,QAAQ,MAAM,MAAM,EAAE,IAAI;IAC1C,UAAU,QAAQ;IAClB,UAAU;IACV,MAAM,QAAQ;IACF;IACZ,aAAa;IACb,aAAa;IACb,aAAa;IACb,UAAU;KACV;IACkB;EACtB,oBAAC,iCAAqB,QAAQ,QAAQ,MAAM,GAAuB;KAClE;;;;;;AAQP,SAAgB,iBAAiB,OAA8B;CAC7D,MAAM,EAAE,OAAO,OAAO,YAAY,eAAe,UAAU,kBACzD;CAEF,MAAM,cAAc,eACX;EACL,wBAAwB,MAAM,MAAM;EACpC,iCAAiC,oBAAoB,MAAM;EAC5D,GACD,CAAC,MAAM,CACR;CAED,MAAM,oBAAoB,UAAU,UAAkB;AACpD,gBAAc,MAAoB;GAClC;AAEF,QACE,qBAAC;EAAa,OAAO;;GACnB,oBAAC,4BAAgB,YAAY,OAAO,cAAc,GAAkB;GACpE,oBAACC,QAAM;IACL,cAAW;IACX,OAAO;IACK;IACZ,QAAQ;IACR,UAAU;cAET,aAAa,KAAK,SACjB,oBAACA;KAEC,OAAO;KACP,cAAY,mBAAmB;KAC/B,SAAS,kBAAkB;KAC3B,QAAQ;eAEP,mBAAmB;OANf,KAOC,CACR;KACS;GACb,oBAAC,6BACE,SAAS,OAAO,KAAK,YACpB,oBAAC;IAEU;IACF;IACK;IACF;MAJL,GAAG,MAAM,GAAG,QAAQ,QAKzB,CACF,GACc;;GACL"}

package/dist/components/fields/ColorPicker/channels.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"channels.js","names":[],"sources":["../../../../src/components/fields/ColorPicker/channels.ts"],"sourcesContent":["import {\n  ColorValue,\n  fromOkhst,\n  fromOklch,\n  fromRgb,\n  isAchromatic,\n  maxChroma,\n  normalizeHue,\n  toHex,\n  toOkhst,\n  toOklch,\n  toRgb,\n} from './color';\n\n/**\n * The three color concepts the popover can be driven by. They all edit the\n * same canonical value — only the axes the user manipulates differ.\n */\nexport const COLOR_SPACES = ['hst', 'lch', 'rgb'] as const;\n\nexport type ColorSpace = (typeof COLOR_SPACES)[number];\n\nexport const COLOR_SPACE_LABELS: Record<ColorSpace, string> = {\n  hst: 'HST',\n  lch: 'LCH',\n  rgb: 'RGB',\n};\n\nexport const COLOR_SPACE_HINTS: Record<ColorSpace, string> = {\n  hst: 'OKHST — hue, saturation, tone',\n  lch: 'OKLCH — lightness, chroma, hue',\n  rgb: 'sRGB — red, green, blue',\n};\n\nexport interface ColorChannel {\n  /** Single-letter axis name shown next to the slider. */\n  label: string;\n  /** Accessible name for the slider. */\n  title: string;\n  min: number;\n  step: number;\n  /** The upper bound. Chroma is gamut-bound, so it depends on the color. */\n  max: (color: ColorValue) => number;\n  value: (color: ColorValue) => number;\n  /** The color this channel produces when moved to `value`. */\n  apply: (color: ColorValue, value: number) => ColorValue;\n  /** Comma-separated gradient stops describing the channel's whole range. */\n  stops: (color: ColorValue) => string;\n  /** Human-readable rendering of the current channel value. */\n  display: (color: ColorValue) => string;\n}\n\nconst constant = (value: number) => () => value;\n\nfunction round(value: number, precision = 2): number {\n  const factor = 10 ** precision;\n\n  return Math.round(value * factor) / factor;\n}\n\n/**\n * `count` evenly spaced gradient stops, always as hex. Perceptual channels are\n * not linear in sRGB, so a two-stop gradient would misrepresent them —\n * sampling the real conversion keeps the track honest. Hex (rather than an\n * `okhsl()` string) because the gradient reaches the DOM as a raw custom\n * property, without passing through Tasty's color functions.\n */\nfunction ramp(count: number, at: (position: number) => ColorValue): string {\n  return Array.from({ length: count }, (_, index) =>\n    toHex(at(index / (count - 1))),\n  ).join(', ');\n}\n\n/**\n * The hue strip is drawn at full saturation and a fixed OKHSL lightness, which\n * keeps it perceptually even instead of spiking at yellow the way a CSS-HSL\n * rainbow does. Its own saturation and tone stay fixed: the strip is the same\n * in HST and in LCH, where `H` means the same thing.\n */\nconst HUE_STOPS = ramp(25, (position) => ({\n  h: position * 360,\n  s: 1,\n  l: 0.6,\n}));\n\nconst hueChannel: ColorChannel = {\n  label: 'H',\n  title: 'Hue',\n  min: 0,\n  // 360° is the same angle as 0°, so the last usable stop is 359 — the range\n  // `HueSlider` exposes as well.\n  max: constant(359),\n  step: 1,\n  value: (color) => round(color.h, 1),\n  apply: (color, value) => ({ ...color, h: normalizeHue(value) }),\n  stops: () => HUE_STOPS,\n  display: (color) => `${Math.round(color.h)}°`,\n};\n\nconst saturationChannel: ColorChannel = {\n  label: 'S',\n  title: 'Saturation',\n  min: 0,\n  max: constant(100),\n  step: 1,\n  value: (color) => round(color.s * 100, 1),\n  apply: (color, value) => ({ ...color, s: value / 100 }),\n  stops: (color) => ramp(7, (position) => ({ ...color, s: position })),\n  display: (color) => `${Math.round(color.s * 100)}%`,\n};\n\nconst toneChannel: ColorChannel = {\n  label: 'T',\n  title: 'Tone',\n  min: 0,\n  max: constant(100),\n  step: 1,\n  value: (color) => round(toOkhst(color).t * 100, 1),\n  apply: (color, value) =>\n    fromOkhst({ h: color.h, s: color.s, t: value / 100 }),\n  stops: (color) =>\n    ramp(7, (position) => fromOkhst({ h: color.h, s: color.s, t: position })),\n  display: (color) => `${Math.round(toOkhst(color).t * 100)}%`,\n};\n\nconst lightnessChannel: ColorChannel = {\n  label: 'L',\n  title: 'Lightness',\n  min: 0,\n  max: constant(100),\n  step: 1,\n  value: (color) => round(toOklch(color).l * 100, 1),\n  apply: (color, value) => {\n    const { c, h } = toOklch(color);\n\n    return fromOklch({ l: value / 100, c, h });\n  },\n  stops: (color) => {\n    const { c, h } = toOklch(color);\n\n    return ramp(7, (position) => fromOklch({ l: position, c, h }));\n  },\n  display: (color) => `${Math.round(toOklch(color).l * 100)}%`,\n};\n\nconst chromaChannel: ColorChannel = {\n  label: 'C',\n  title: 'Chroma',\n  min: 0,\n  // Chroma has no fixed ceiling: how far it can go depends on how far the sRGB\n  // gamut reaches at the current lightness and hue. Never zero, so the slider\n  // always has a range to divide by.\n  max: (color) => Math.max(round(maxChroma(color.h, color.l), 4), 0.001),\n  step: 0.001,\n  value: (color) => round(toOklch(color).c, 4),\n  apply: (color, value) => {\n    const { l, h } = toOklch(color);\n\n    return fromOklch({ l, c: value, h });\n  },\n  stops: (color) => {\n    const { l, h } = toOklch(color);\n    const limit = maxChroma(color.h, color.l);\n\n    return ramp(7, (position) => fromOklch({ l, c: position * limit, h }));\n  },\n  display: (color) => toOklch(color).c.toFixed(3),\n};\n\nfunction rgbChannel(\n  key: 'r' | 'g' | 'b',\n  label: string,\n  title: string,\n): ColorChannel {\n  const at = (color: ColorValue, value: number) =>\n    fromRgb({ ...toRgb(color), [key]: value });\n\n  return {\n    label,\n    title,\n    min: 0,\n    max: constant(255),\n    step: 1,\n    value: (color) => toRgb(color)[key],\n    apply: (color, value) => {\n      const next = at(color, value);\n\n      // A gray has no hue of its own, and the conversion invents one. Keeping\n      // the authored hue means switching back to HST or LCH resumes where the\n      // user left off.\n      return isAchromatic(next) ? { ...next, h: color.h } : next;\n    },\n    // An sRGB channel is linear in the space CSS interpolates gradients in, so\n    // the two ends describe the whole ramp exactly.\n    stops: (color) => ramp(2, (position) => at(color, position * 255)),\n    display: (color) => `${toRgb(color)[key]}`,\n  };\n}\n\nexport const CHANNELS: Record<ColorSpace, ColorChannel[]> = {\n  hst: [hueChannel, saturationChannel, toneChannel],\n  lch: [lightnessChannel, chromaChannel, hueChannel],\n  rgb: [\n    rgbChannel('r', 'R', 'Red'),\n    rgbChannel('g', 'G', 'Green'),\n    rgbChannel('b', 'B', 'Blue'),\n  ],\n};\n"],"mappings":"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"}

package/dist/components/fields/ColorPicker/color.d.ts

@@ -1,15 +0,0 @@
-
-import "@tenphi/glaze";
-
-//#region src/components/fields/ColorPicker/color.d.ts
-/**
- * Every color format the picker can read and write.
- *
- * `okhsl` and `okhst` are Glaze / Tasty spaces rather than native CSS ones,
- * but Tasty parses both, so the produced strings are usable as style values.
- */
-declare const COLOR_FORMATS: readonly ["hex", "rgb", "hsl", "okhsl", "okhst", "oklch"];
-type ColorFormat = (typeof COLOR_FORMATS)[number];
-//#endregion
-export { COLOR_FORMATS, ColorFormat };
-//# sourceMappingURL=color.d.ts.map