@cube-dev/ui-kit 0.197.0 → 0.198.1

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

@@ -1 +1 @@
-{"version":3,"file":"use-table-selection.js","names":["SelectionManager","useCallback","useMemo","useRef","useMultipleSelectionState","useEvent","RowCollection","Key","Selection","CubeTableSelectAllMode","CubeTableSelectionMode","SELECTION_COLUMN_KEY","ROW_NUMBER_COLUMN_KEY","SELECTION_COLUMN_WIDTH","Record","xsmall","small","medium","large","xlarge","UseTableSelectionOptions","rows","T","rowKeys","pageRows","pageRowKeys","filteredRows","filteredRowKeys","getRowKey","row","index","selectionMode","selectedKeys","defaultSelectedKeys","onSelectionChange","keys","selectAllMode","isRowSelectable","disabledKeys","tree","rootKeys","childrenOf","ReadonlyMap","parentOf","behavior","CubeTableSelectAllState","toSelection","undefined","Set","deriveTreeSelection","source","ReadonlySet","isEligible","key","checked","indeterminate","visit","all","any","eligible","children","get","explicitlySelected","has","add","length","selected","delete","hasEligible","child","result","forEach","useTableSelection","options","selectedKeysProp","isEnabled","hardDisabledKeys","unselectableKeys","visibleGetRowKey","collection","rowByKey","map","Map","set","rowByKeyRef","current","anchorRef","extentRef","handleSelectionChange","values","list","filter","controlledSelection","defaultSelection","state","disabledBehavior","selectionManager","isAll","isCascade","derivedSelection","canSelect","isSelected","isIndeterminate","scopeKeys","sourceKeys","selectAllState","count","toggleSelectAll","setSelectedKeys","next","clearSelection","shiftRef","captureShift","event","shiftKey","keysBetween","from","to","fromIndex","indexOf","toIndex","lo","hi","getKeys","range","i","push","toggleRow","applyCascade","target","value","parent","normalizeCascade","candidate","anchor","k","toggleSelection","selectedRows","isRowDisabled","selectedCount","size","CubeTableSelectionState","ReturnType"],"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  /** Stable keys parallel to `rows`, used by tree mode. */\n  rowKeys?: readonly Key[];\n  /** Full current-page subtree; defaults to `rows`. */\n  pageRows?: readonly T[];\n  /** Stable keys parallel to `pageRows`. */\n  pageRowKeys?: readonly Key[];\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  /** Stable keys parallel to `filteredRows`. */\n  filteredRowKeys?: readonly Key[];\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  tree?: {\n    rootKeys: readonly Key[];\n    childrenOf: ReadonlyMap<Key, readonly Key[]>;\n    parentOf: ReadonlyMap<Key, Key | null>;\n    behavior: 'cascade' | 'independent';\n  };\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\nfunction deriveTreeSelection(\n  source: ReadonlySet<Key>,\n  rootKeys: readonly Key[],\n  childrenOf: ReadonlyMap<Key, readonly Key[]>,\n  isEligible: (key: Key) => boolean,\n) {\n  const checked = new Set(source);\n  const indeterminate = new Set<Key>();\n\n  const visit = (\n    key: Key,\n  ): { all: boolean; any: boolean; eligible: boolean } => {\n    const children = childrenOf.get(key) ?? [];\n    const eligible = isEligible(key);\n    const explicitlySelected = eligible && source.has(key);\n\n    if (explicitlySelected) checked.add(key);\n\n    if (!children.length) {\n      const selected = eligible && checked.has(key);\n      if (!eligible) checked.delete(key);\n      return { all: !eligible || selected, any: selected, eligible };\n    }\n\n    let all = true;\n    let any = false;\n    let hasEligible = false;\n\n    for (const child of children) {\n      const result = visit(child);\n      if (result.eligible) hasEligible = true;\n      if (!result.all) all = false;\n      if (result.any) any = true;\n    }\n\n    if (!eligible) {\n      checked.delete(key);\n      indeterminate.delete(key);\n    } else if (hasEligible && all) {\n      checked.add(key);\n      indeterminate.delete(key);\n    } else if (hasEligible && any) {\n      checked.delete(key);\n      indeterminate.add(key);\n    } else if (hasEligible) {\n      // Branch keys in the public set are a normalized reflection of their\n      // descendants, not an enduring wildcard. This matters when a search\n      // hid siblings: restoring the full tree must not make those siblings\n      // selected merely because the filtered parent had been checked.\n      checked.delete(key);\n      indeterminate.delete(key);\n    } else if (!checked.has(key)) {\n      indeterminate.delete(key);\n    }\n\n    return {\n      all: !eligible || (checked.has(key) && all),\n      any: any || checked.has(key),\n      eligible: eligible || hasEligible,\n    };\n  };\n\n  rootKeys.forEach((key) => visit(key));\n  return { checked, indeterminate };\n}\n\nexport function useTableSelection<T>(options: UseTableSelectionOptions<T>) {\n  const {\n    rows,\n    rowKeys,\n    pageRows = rows,\n    pageRowKeys,\n    filteredRows,\n    filteredRowKeys,\n    getRowKey,\n    selectionMode,\n    selectedKeys: selectedKeysProp,\n    defaultSelectedKeys,\n    onSelectionChange,\n    selectAllMode,\n    isRowSelectable,\n    disabledKeys,\n    tree,\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)) {\n          keys.add(filteredRowKeys?.[index] ?? getRowKey(row, index));\n        }\n      });\n    }\n\n    return keys;\n  }, [\n    hardDisabledKeys,\n    isRowSelectable,\n    filteredRows,\n    filteredRowKeys,\n    getRowKey,\n  ]);\n\n  const visibleGetRowKey = useCallback(\n    (row: T, index: number) => rowKeys?.[index] ?? getRowKey(row, index),\n    [rowKeys, getRowKey],\n  );\n\n  const collection = useMemo(\n    () => new RowCollection(rows, visibleGetRowKey, unselectableKeys),\n    [rows, visibleGetRowKey, 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) =>\n      map.set(filteredRowKeys?.[index] ?? getRowKey(row, index), row),\n    );\n    rows.forEach((row, index) =>\n      map.set(rowKeys?.[index] ?? getRowKey(row, index), row),\n    );\n\n    return map;\n  }, [rows, rowKeys, filteredRows, filteredRowKeys, 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  const isCascade =\n    tree?.behavior === 'cascade' && selectionMode === 'multiple';\n\n  const derivedSelection = useMemo(() => {\n    if (isAll) {\n      return {\n        checked: new Set(\n          [...rowByKey.keys()].filter((key) => !unselectableKeys.has(key)),\n        ),\n        indeterminate: new Set<Key>(),\n      };\n    }\n\n    if (!isCascade || !tree) {\n      return {\n        checked: new Set(selectedKeys as Set<Key>),\n        indeterminate: new Set<Key>(),\n      };\n    }\n\n    return deriveTreeSelection(\n      selectedKeys as Set<Key>,\n      tree.rootKeys,\n      tree.childrenOf,\n      (key) => !unselectableKeys.has(key),\n    );\n  }, [isAll, isCascade, selectedKeys, tree, rowByKey, unselectableKeys]);\n\n  const canSelect = useCallback(\n    (key: Key) => isEnabled && !unselectableKeys.has(key),\n    [isEnabled, unselectableKeys],\n  );\n\n  const isSelected = useCallback(\n    (key: Key) => (isAll ? canSelect(key) : derivedSelection.checked.has(key)),\n    [isAll, derivedSelection, canSelect],\n  );\n\n  const isIndeterminate = useCallback(\n    (key: Key) => derivedSelection.indeterminate.has(key),\n    [derivedSelection],\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' ? pageRows : filteredRows;\n    const sourceKeys = selectAllMode === 'page' ? pageRowKeys : filteredRowKeys;\n\n    return source\n      .map((row, index) => sourceKeys?.[index] ?? getRowKey(row, index))\n      .filter((key) => !unselectableKeys.has(key));\n  }, [\n    isEnabled,\n    selectionMode,\n    selectAllMode,\n    pageRows,\n    pageRowKeys,\n    filteredRows,\n    filteredRowKeys,\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 = derivedSelection.checked;\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, derivedSelection, 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 ? [] : derivedSelection.checked);\n\n    scopeKeys.forEach((key) => next.add(key));\n    state.setSelectedKeys(\n      isCascade && tree\n        ? deriveTreeSelection(\n            next,\n            tree.rootKeys,\n            tree.childrenOf,\n            (key) => !unselectableKeys.has(key),\n          ).checked\n        : next,\n    );\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 applyCascade = (set: Set<Key>, target: Key, value: boolean) => {\n      if (!canSelect(target)) return;\n      if (value) set.add(target);\n      else {\n        set.delete(target);\n\n        // A checked ancestor in the normalized public key set means its whole\n        // branch is selected. Remove that derived marker before normalizing a\n        // partial deselection, or it would immediately select the child again.\n        if (isCascade && tree) {\n          let parent = tree.parentOf.get(target);\n          while (parent != null) {\n            set.delete(parent);\n            parent = tree.parentOf.get(parent);\n          }\n        }\n      }\n      if (!isCascade || !tree) return;\n      (tree.childrenOf.get(target) ?? []).forEach((child) =>\n        applyCascade(set, child, value),\n      );\n    };\n\n    const normalizeCascade = (set: Set<Key>) =>\n      isCascade && tree\n        ? deriveTreeSelection(\n            set,\n            tree.rootKeys,\n            tree.childrenOf,\n            (candidate) => !unselectableKeys.has(candidate),\n          ).checked\n        : set;\n\n    const anchor = anchorRef.current;\n\n    if (shiftRef.current && anchor != null && collection.indexOf(anchor) >= 0) {\n      const next = new Set(isAll ? scopeKeys : derivedSelection.checked);\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) =>\n          applyCascade(next, k, false),\n        );\n      }\n\n      keysBetween(anchor, key).forEach((k) => {\n        applyCascade(next, k, true);\n      });\n\n      extentRef.current = key;\n      state.setSelectedKeys(normalizeCascade(next));\n\n      return;\n    }\n\n    anchorRef.current = key;\n    extentRef.current = null;\n    if (isCascade) {\n      const next = new Set(derivedSelection.checked);\n      applyCascade(next, key, !derivedSelection.checked.has(key));\n      state.setSelectedKeys(normalizeCascade(next));\n    } else {\n      selectionManager.toggleSelection(key);\n    }\n  });\n\n  const selectedRows = useMemo(() => {\n    if (isAll) return [...rowByKey.values()];\n\n    return [...derivedSelection.checked]\n      .map((key) => rowByKey.get(key))\n      .filter((row): row is T => row !== undefined);\n  }, [isAll, derivedSelection, rowByKey]);\n\n  return {\n    isEnabled,\n    selectionMode,\n    selectionManager,\n    collection,\n    isSelected,\n    isIndeterminate,\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 : derivedSelection.checked.size,\n    selectedKeys: (isAll ? 'all' : [...derivedSelection.checked]) as\n      | Key[]\n      | 'all',\n  };\n}\n\nexport type CubeTableSelectionState<T> = ReturnType<\n  typeof useTableSelection<T>\n>;\n"],"mappings":"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"}
+{"version":3,"file":"use-table-selection.js","names":["SelectionManager","useCallback","useMemo","useRef","useMultipleSelectionState","useEvent","RowCollection","Key","Selection","CubeTableSelectAllMode","CubeTableSelectionMode","SELECTION_COLUMN_KEY","ROW_NUMBER_COLUMN_KEY","SELECTION_COLUMN_WIDTH","Record","xsmall","small","medium","large","xlarge","UseTableSelectionOptions","rows","T","rowKeys","pageRows","pageRowKeys","filteredRows","filteredRowKeys","getRowKey","row","index","selectionMode","selectedKeys","defaultSelectedKeys","onSelectionChange","keys","selectAllMode","isRowSelectable","disabledKeys","tree","rootKeys","childrenOf","ReadonlyMap","parentOf","behavior","CubeTableSelectAllState","toSelection","undefined","Set","deriveTreeSelection","source","ReadonlySet","isEligible","key","checked","indeterminate","visit","all","any","eligible","children","get","explicitlySelected","has","add","length","selected","delete","hasEligible","child","result","forEach","useTableSelection","options","selectedKeysProp","isEnabled","hardDisabledKeys","unselectableKeys","visibleGetRowKey","collection","rowByKey","map","Map","set","rowByKeyRef","current","anchorRef","extentRef","handleSelectionChange","values","list","filter","controlledSelection","defaultSelection","state","disabledBehavior","selectionManager","isAll","isCascade","derivedSelection","canSelect","isSelected","isIndeterminate","scopeKeys","sourceKeys","selectAllState","count","toggleSelectAll","setSelectedKeys","next","clearSelection","shiftRef","captureShift","event","shiftKey","keysBetween","from","to","fromIndex","indexOf","toIndex","lo","hi","getKeys","range","i","push","toggleRow","applyCascade","target","value","parent","normalizeCascade","candidate","anchor","k","toggleSelection","selectedRows","isRowDisabled","selectedCount","size","CubeTableSelectionState","ReturnType"],"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  /** Stable keys parallel to `rows`, used by tree mode. */\n  rowKeys?: readonly Key[];\n  /** Full current-page subtree; defaults to `rows`. */\n  pageRows?: readonly T[];\n  /** Stable keys parallel to `pageRows`. */\n  pageRowKeys?: readonly Key[];\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  /** Stable keys parallel to `filteredRows`. */\n  filteredRowKeys?: readonly Key[];\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  tree?: {\n    rootKeys: readonly Key[];\n    childrenOf: ReadonlyMap<Key, readonly Key[]>;\n    parentOf: ReadonlyMap<Key, Key | null>;\n    behavior: 'cascade' | 'independent';\n  };\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\nfunction deriveTreeSelection(\n  source: ReadonlySet<Key>,\n  rootKeys: readonly Key[],\n  childrenOf: ReadonlyMap<Key, readonly Key[]>,\n  isEligible: (key: Key) => boolean,\n) {\n  const checked = new Set(source);\n  const indeterminate = new Set<Key>();\n\n  const visit = (\n    key: Key,\n  ): { all: boolean; any: boolean; eligible: boolean } => {\n    const children = childrenOf.get(key) ?? [];\n    const eligible = isEligible(key);\n    const explicitlySelected = eligible && source.has(key);\n\n    if (explicitlySelected) checked.add(key);\n\n    if (!children.length) {\n      const selected = eligible && checked.has(key);\n      if (!eligible) checked.delete(key);\n      return { all: !eligible || selected, any: selected, eligible };\n    }\n\n    let all = true;\n    let any = false;\n    let hasEligible = false;\n\n    for (const child of children) {\n      const result = visit(child);\n      if (result.eligible) hasEligible = true;\n      if (!result.all) all = false;\n      if (result.any) any = true;\n    }\n\n    if (!eligible) {\n      checked.delete(key);\n      indeterminate.delete(key);\n    } else if (hasEligible && all) {\n      checked.add(key);\n      indeterminate.delete(key);\n    } else if (hasEligible && any) {\n      checked.delete(key);\n      indeterminate.add(key);\n    } else if (hasEligible) {\n      // Branch keys in the public set are a normalized reflection of their\n      // descendants, not an enduring wildcard. This matters when a search\n      // hid siblings: restoring the full tree must not make those siblings\n      // selected merely because the filtered parent had been checked.\n      checked.delete(key);\n      indeterminate.delete(key);\n    } else if (!checked.has(key)) {\n      indeterminate.delete(key);\n    }\n\n    return {\n      all: !eligible || (checked.has(key) && all),\n      any: any || checked.has(key),\n      eligible: eligible || hasEligible,\n    };\n  };\n\n  rootKeys.forEach((key) => visit(key));\n  return { checked, indeterminate };\n}\n\nexport function useTableSelection<T>(options: UseTableSelectionOptions<T>) {\n  const {\n    rows,\n    rowKeys,\n    pageRows = rows,\n    pageRowKeys,\n    filteredRows,\n    filteredRowKeys,\n    getRowKey,\n    selectionMode,\n    selectedKeys: selectedKeysProp,\n    defaultSelectedKeys,\n    onSelectionChange,\n    selectAllMode,\n    isRowSelectable,\n    disabledKeys,\n    tree,\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)) {\n          keys.add(filteredRowKeys?.[index] ?? getRowKey(row, index));\n        }\n      });\n    }\n\n    return keys;\n  }, [\n    hardDisabledKeys,\n    isRowSelectable,\n    filteredRows,\n    filteredRowKeys,\n    getRowKey,\n  ]);\n\n  const visibleGetRowKey = useCallback(\n    (row: T, index: number) => rowKeys?.[index] ?? getRowKey(row, index),\n    [rowKeys, getRowKey],\n  );\n\n  const collection = useMemo(\n    () => new RowCollection(rows, visibleGetRowKey, unselectableKeys),\n    [rows, visibleGetRowKey, 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) =>\n      map.set(filteredRowKeys?.[index] ?? getRowKey(row, index), row),\n    );\n    rows.forEach((row, index) =>\n      map.set(rowKeys?.[index] ?? getRowKey(row, index), row),\n    );\n\n    return map;\n  }, [rows, rowKeys, filteredRows, filteredRowKeys, 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  const isCascade =\n    tree?.behavior === 'cascade' && selectionMode === 'multiple';\n\n  const derivedSelection = useMemo(() => {\n    if (isAll) {\n      return {\n        checked: new Set(\n          [...rowByKey.keys()].filter((key) => !unselectableKeys.has(key)),\n        ),\n        indeterminate: new Set<Key>(),\n      };\n    }\n\n    if (!isCascade || !tree) {\n      return {\n        checked: new Set(selectedKeys as Set<Key>),\n        indeterminate: new Set<Key>(),\n      };\n    }\n\n    return deriveTreeSelection(\n      selectedKeys as Set<Key>,\n      tree.rootKeys,\n      tree.childrenOf,\n      (key) => !unselectableKeys.has(key),\n    );\n  }, [isAll, isCascade, selectedKeys, tree, rowByKey, unselectableKeys]);\n\n  const canSelect = useCallback(\n    (key: Key) => isEnabled && !unselectableKeys.has(key),\n    [isEnabled, unselectableKeys],\n  );\n\n  const isSelected = useCallback(\n    (key: Key) => (isAll ? canSelect(key) : derivedSelection.checked.has(key)),\n    [isAll, derivedSelection, canSelect],\n  );\n\n  const isIndeterminate = useCallback(\n    (key: Key) => derivedSelection.indeterminate.has(key),\n    [derivedSelection],\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' ? pageRows : filteredRows;\n    const sourceKeys = selectAllMode === 'page' ? pageRowKeys : filteredRowKeys;\n\n    return source\n      .map((row, index) => sourceKeys?.[index] ?? getRowKey(row, index))\n      .filter((key) => !unselectableKeys.has(key));\n  }, [\n    isEnabled,\n    selectionMode,\n    selectAllMode,\n    pageRows,\n    pageRowKeys,\n    filteredRows,\n    filteredRowKeys,\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 = derivedSelection.checked;\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, derivedSelection, 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 ? [] : derivedSelection.checked);\n\n    scopeKeys.forEach((key) => next.add(key));\n    state.setSelectedKeys(\n      isCascade && tree\n        ? deriveTreeSelection(\n            next,\n            tree.rootKeys,\n            tree.childrenOf,\n            (key) => !unselectableKeys.has(key),\n          ).checked\n        : next,\n    );\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 applyCascade = (set: Set<Key>, target: Key, value: boolean) => {\n      if (!canSelect(target)) return;\n      if (value) set.add(target);\n      else {\n        set.delete(target);\n\n        // A checked ancestor in the normalized public key set means its whole\n        // branch is selected. Remove that derived marker before normalizing a\n        // partial deselection, or it would immediately select the child again.\n        if (isCascade && tree) {\n          let parent = tree.parentOf.get(target);\n          while (parent != null) {\n            set.delete(parent);\n            parent = tree.parentOf.get(parent);\n          }\n        }\n      }\n      if (!isCascade || !tree) return;\n      (tree.childrenOf.get(target) ?? []).forEach((child) =>\n        applyCascade(set, child, value),\n      );\n    };\n\n    const normalizeCascade = (set: Set<Key>) =>\n      isCascade && tree\n        ? deriveTreeSelection(\n            set,\n            tree.rootKeys,\n            tree.childrenOf,\n            (candidate) => !unselectableKeys.has(candidate),\n          ).checked\n        : set;\n\n    const anchor = anchorRef.current;\n\n    if (shiftRef.current && anchor != null && collection.indexOf(anchor) >= 0) {\n      const next = new Set(isAll ? scopeKeys : derivedSelection.checked);\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) =>\n          applyCascade(next, k, false),\n        );\n      }\n\n      keysBetween(anchor, key).forEach((k) => {\n        applyCascade(next, k, true);\n      });\n\n      extentRef.current = key;\n      state.setSelectedKeys(normalizeCascade(next));\n\n      return;\n    }\n\n    anchorRef.current = key;\n    extentRef.current = null;\n    if (isCascade) {\n      const next = new Set(derivedSelection.checked);\n      applyCascade(next, key, !derivedSelection.checked.has(key));\n      state.setSelectedKeys(normalizeCascade(next));\n    } else {\n      selectionManager.toggleSelection(key);\n    }\n  });\n\n  const selectedRows = useMemo(() => {\n    if (isAll) return [...rowByKey.values()];\n\n    return [...derivedSelection.checked]\n      .map((key) => rowByKey.get(key))\n      .filter((row): row is T => row !== undefined);\n  }, [isAll, derivedSelection, rowByKey]);\n\n  return {\n    isEnabled,\n    selectionMode,\n    selectionManager,\n    collection,\n    isSelected,\n    isIndeterminate,\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 : derivedSelection.checked.size,\n    selectedKeys: (isAll ? 'all' : [...derivedSelection.checked]) as\n      Key[] | 'all',\n  };\n}\n\nexport type CubeTableSelectionState<T> = ReturnType<\n  typeof useTableSelection<T>\n>;\n"],"mappings":";;;;;;;;;;;;AAgBA,MAAaW,uBAAuB;;AAGpC,MAAaC,wBAAwB;;AAGrC,MAAaC,yBAAiD;CAC5DE,QAAQ;CACRC,OAAO;CACPC,QAAQ;CACRC,OAAO;CACPC,QAAQ;AACV;AAqCA,SAAS2B,YAAYX,MAAwD;CAC3E,IAAIA,SAASY,KAAAA,GAAW,OAAOA,KAAAA;CAE/B,OAAOZ,SAAS,QAAQ,QAAQ,IAAIa,IAAIb,IAAI;AAC9C;AAEA,SAASc,oBACPC,QACAV,UACAC,YACAW,YACA;CACA,MAAME,UAAU,IAAIN,IAAIE,MAAM;CAC9B,MAAMK,gCAAgB,IAAIP,IAAS;CAEnC,MAAMQ,SACJH,QACsD;EACtD,MAAMO,WAAWnB,WAAWoB,IAAIR,GAAG,KAAK,CAAA;EACxC,MAAMM,WAAWP,WAAWC,GAAG;EAG/B,IAF2BM,YAAYT,OAAOa,IAAIV,GAAG,GAE7BC,QAAQU,IAAIX,GAAG;EAEvC,IAAI,CAACO,SAASK,QAAQ;GACpB,MAAMC,WAAWP,YAAYL,QAAQS,IAAIV,GAAG;GAC5C,IAAI,CAACM,UAAUL,QAAQa,OAAOd,GAAG;GACjC,OAAO;IAAEI,KAAK,CAACE,YAAYO;IAAUR,KAAKQ;IAAUP;GAAS;EAC/D;EAEA,IAAIF,MAAM;EACV,IAAIC,MAAM;EACV,IAAIU,cAAc;EAElB,KAAK,MAAMC,SAAST,UAAU;GAC5B,MAAMU,SAASd,MAAMa,KAAK;GAC1B,IAAIC,OAAOX,UAAUS,cAAc;GACnC,IAAI,CAACE,OAAOb,KAAKA,MAAM;GACvB,IAAIa,OAAOZ,KAAKA,MAAM;EACxB;EAEA,IAAI,CAACC,UAAU;GACbL,QAAQa,OAAOd,GAAG;GAClBE,cAAcY,OAAOd,GAAG;EAC1B,OAAO,IAAIe,eAAeX,KAAK;GAC7BH,QAAQU,IAAIX,GAAG;GACfE,cAAcY,OAAOd,GAAG;EAC1B,OAAO,IAAIe,eAAeV,KAAK;GAC7BJ,QAAQa,OAAOd,GAAG;GAClBE,cAAcS,IAAIX,GAAG;EACvB,OAAO,IAAIe,aAAa;GAKtBd,QAAQa,OAAOd,GAAG;GAClBE,cAAcY,OAAOd,GAAG;EAC1B,OAAO,IAAI,CAACC,QAAQS,IAAIV,GAAG,GACzBE,cAAcY,OAAOd,GAAG;EAG1B,OAAO;GACLI,KAAK,CAACE,YAAaL,QAAQS,IAAIV,GAAG,KAAKI;GACvCC,KAAKA,OAAOJ,QAAQS,IAAIV,GAAG;GAC3BM,UAAUA,YAAYS;EACxB;CACF;CAEA5B,SAAS+B,SAASlB,QAAQG,MAAMH,GAAG,CAAC;CACpC,OAAO;EAAEC;EAASC;CAAc;AAClC;AAEA,SAAgBiB,kBAAqBC,SAAsC;CACzE,MAAM,EACJpD,MACAE,SACAC,WAAWH,MACXI,aACAC,cACAC,iBACAC,WACAG,eACAC,cAAc0C,kBACdzC,qBACAC,mBACAE,eACAC,iBACAC,cACAC,SACEkC;CAEJ,MAAME,YAAY5C,kBAAkB;;;;;;;;;;;;;CAcpC,MAAM6C,mBAAmB1E,cACjB,IAAI8C,IAAIV,gBAAgB,CAAA,CAAE,GAChC,CAACA,YAAY,CACf;CAEA,MAAMuC,mBAAmB3E,cAAc;EACrC,MAAMiC,OAAO,IAAIa,IAAI4B,gBAAgB;EAErC,IAAIvC,iBAGFX,aAAa6C,SAAS1C,KAAKC,UAAU;GACnC,IAAI,CAACO,gBAAgBR,GAAG,GACtBM,KAAK6B,IAAIrC,kBAAkBG,UAAUF,UAAUC,KAAKC,KAAK,CAAC;EAE9D,CAAC;EAGH,OAAOK;CACT,GAAG;EACDyC;EACAvC;EACAX;EACAC;EACAC;CAAS,CACV;CAED,MAAMkD,mBAAmB7E,aACtB4B,OAAQC,YAAkBP,UAAUO,YAAUF,UAAUC,OAAKC,OAAK,GACnE,CAACP,SAASK,SAAS,CACrB;CAEA,MAAMmD,aAAa7E,cACX,IAAII,cAAce,MAAMyD,kBAAkBD,gBAAgB,GAChE;EAACxD;EAAMyD;EAAkBD;CAAgB,CAC3C;CAEA,MAAMG,WAAW9E,cAAc;EAC7B,MAAM+E,sBAAM,IAAIC,IAAY;EAI5BxD,aAAa6C,SAAS1C,OAAKC,YACzBmD,IAAIE,IAAIxD,kBAAkBG,YAAUF,UAAUC,OAAKC,OAAK,GAAGD,KAAG,CAChE;EACAR,KAAKkD,SAAS1C,OAAKC,YACjBmD,IAAIE,IAAI5D,UAAUO,YAAUF,UAAUC,OAAKC,OAAK,GAAGD,KAAG,CACxD;EAEA,OAAOoD;CACT,GAAG;EAAC5D;EAAME;EAASG;EAAcC;EAAiBC;CAAS,CAAC;CAE5D,MAAMwD,cAAcjF,OAAO6E,QAAQ;CAEnCI,YAAYC,UAAUL;;;;;;;;;;;;;;;;;CAkBtB,MAAMM,YAAYnF,OAAmB,IAAI;CACzC,MAAMoF,YAAYpF,OAAmB,IAAI;CAEzC,MAAMqF,wBAAwBnF,UAAU8B,WAAoB;EAC1D,IAAI,CAACD,mBAAmB;EAExB,IAAIC,WAAS,OAAO;GAGlBD,kBAAkB,OAAO,CAAC,GAAGkD,YAAYC,QAAQI,OAAO,CAAC,CAAC;GAE1D;EACF;EAEA,MAAMC,OAAO,CAAC,GAAGvD,MAAI;EAErBD,kBACEwD,MACAA,KACGT,KAAK5B,QAAQ+B,YAAYC,QAAQxB,IAAIR,GAAG,CAAC,CAAC,CAC1CsC,QAAQ9D,UAAkBA,UAAQkB,KAAAA,CAAS,CAChD;CACF,CAAC;CAED,MAAM6C,sBAAsB1F,cACpB4C,YAAY4B,gBAAgB,GAClC,CAACA,gBAAgB,CACnB;CACA,MAAMmB,mBAAmB3F,cACjB4C,YAAYb,mBAAmB,GACrC,CAACA,mBAAmB,CACtB;CAEA,MAAM6D,QAAQ1F,0BAA0B;EACtC2B;EACAC,cAAc4D;EACd3D,qBAAqB4D;EACrBvD,cAAcuC;EACdkB,kBAAkB;EAClB7D,mBAAmBsD;CACrB,CAAC;CAED,MAAMQ,mBAAmB9F,cACjB,IAAIF,iBAAiB+E,YAAYe,KAAK,GAC5C,CAACf,YAAYe,KAAK,CACpB;CAEA,MAAM9D,eAAe8D,MAAM9D;CAC3B,MAAMiE,QAAQjE,iBAAiB;CAC/B,MAAMkE,YACJ3D,MAAMK,aAAa,aAAab,kBAAkB;CAEpD,MAAMoE,mBAAmBjG,cAAc;EACrC,IAAI+F,OACF,OAAO;GACL3C,SAAS,IAAIN,IACX,CAAC,GAAGgC,SAAS7C,KAAK,CAAC,CAAC,CAACwD,QAAQtC,UAAQ,CAACwB,iBAAiBd,IAAIV,KAAG,CAAC,CACjE;GACAE,+BAAe,IAAIP,IAAS;EAC9B;EAGF,IAAI,CAACkD,aAAa,CAAC3D,MACjB,OAAO;GACLe,SAAS,IAAIN,IAAIhB,YAAwB;GACzCuB,+BAAe,IAAIP,IAAS;EAC9B;EAGF,OAAOC,oBACLjB,cACAO,KAAKC,UACLD,KAAKE,aACJY,UAAQ,CAACwB,iBAAiBd,IAAIV,KAAG,CACpC;CACF,GAAG;EAAC4C;EAAOC;EAAWlE;EAAcO;EAAMyC;EAAUH;CAAgB,CAAC;CAErE,MAAMuB,YAAYnG,aACfoD,UAAasB,aAAa,CAACE,iBAAiBd,IAAIV,KAAG,GACpD,CAACsB,WAAWE,gBAAgB,CAC9B;CAEA,MAAMwB,aAAapG,aAChBoD,UAAc4C,QAAQG,UAAU/C,KAAG,IAAI8C,iBAAiB7C,QAAQS,IAAIV,KAAG,GACxE;EAAC4C;EAAOE;EAAkBC;CAAS,CACrC;CAEA,MAAME,kBAAkBrG,aACrBoD,UAAa8C,iBAAiB5C,cAAcQ,IAAIV,KAAG,GACpD,CAAC8C,gBAAgB,CACnB;;CAGA,MAAMI,YAAYrG,cAAc;EAC9B,IAAI,CAACyE,aAAa5C,kBAAkB,UAAU,OAAO,CAAA;EAErD,MAAMmB,SAASd,kBAAkB,SAASZ,WAAWE;EACrD,MAAM8E,aAAapE,kBAAkB,SAASX,cAAcE;EAE5D,OAAOuB,OACJ+B,KAAKpD,OAAKC,YAAU0E,aAAa1E,YAAUF,UAAUC,OAAKC,OAAK,CAAC,CAAC,CACjE6D,QAAQtC,UAAQ,CAACwB,iBAAiBd,IAAIV,KAAG,CAAC;CAC/C,GAAG;EACDsB;EACA5C;EACAK;EACAZ;EACAC;EACAC;EACAC;EACAC;EACAiD;CAAgB,CACjB;CAED,MAAM4B,iBAA0CvG,cAAc;EAC5D,IAAI+F,OAAO,OAAO;EAClB,IAAI,CAACM,UAAUtC,QAAQ,OAAO;EAE9B,MAAMkB,MAAMgB,iBAAiB7C;EAC7B,IAAIoD,QAAQ;EAEZ,KAAK,MAAMrD,SAAOkD,WAAW,IAAIpB,IAAIpB,IAAIV,KAAG,GAAGqD;EAE/C,OAAOA,UAAU,IAAI,SAASA,UAAUH,UAAUtC,SAAS,QAAQ;CACrE,GAAG;EAACgC;EAAOE;EAAkBI;CAAS,CAAC;CAEvC,MAAMI,kBAAkBtG,eAAe;EACrCiF,UAAUD,UAAU;EACpBE,UAAUF,UAAU;EAEpB,IAAIoB,mBAAmB,OAAO;GAI5BX,MAAMc,gCAAgB,IAAI5D,IAAI,CAAC;GAE/B;EACF;EAEA,IAAIZ,kBAAkB,OAAO;GAC3B0D,MAAMc,gBAAgB,KAAK;GAE3B;EACF;EAEA,MAAMC,OAAO,IAAI7D,IAAIiD,QAAQ,CAAA,IAAKE,iBAAiB7C,OAAO;EAE1DiD,UAAUhC,SAASlB,UAAQwD,KAAK7C,IAAIX,KAAG,CAAC;EACxCyC,MAAMc,gBACJV,aAAa3D,OACTU,oBACE4D,MACAtE,KAAKC,UACLD,KAAKE,aACJY,UAAQ,CAACwB,iBAAiBd,IAAIV,KAAG,CACpC,CAAC,CAACC,UACFuD,IACN;CACF,CAAC;CAED,MAAMC,iBAAiBzG,eAAe;EACpCiF,UAAUD,UAAU;EACpBE,UAAUF,UAAU;EACpBS,MAAMc,gCAAgB,IAAI5D,IAAI,CAAC;CACjC,CAAC;;;;;;CAOD,MAAM+D,WAAW5G,OAAO,KAAK;CAE7B,MAAM6G,eAAe/G,aAAagH,UAAiC;EACjEF,SAAS1B,UAAU4B,MAAMC;CAC3B,GAAG,CAAA,CAAE;;CAGL,MAAMC,cAAclH,aACjBmH,MAAWC,OAAY;EACtB,MAAMC,YAAYvC,WAAWwC,QAAQH,IAAI;EACzC,MAAMI,UAAUzC,WAAWwC,QAAQF,EAAE;EAErC,IAAIC,YAAY,KAAKE,UAAU,GAAG,OAAO,CAAA;EAEzC,MAAM,CAACC,IAAIC,MACTJ,aAAaE,UAAU,CAACF,WAAWE,OAAO,IAAI,CAACA,SAASF,SAAS;EACnE,MAAM7D,MAAMsB,WAAW4C,QAAQ;EAC/B,MAAMC,QAAe,CAAA;EAErB,KAAK,IAAIC,IAAIJ,IAAII,KAAKH,IAAIG,KAAKD,MAAME,KAAKrE,IAAIoE,EAAE;EAEhD,OAAOD;CACT,GACA,CAAC7C,UAAU,CACb;CAEA,MAAMgD,YAAY1H,UAAUgD,UAAa;EACvC,IAAI,CAAC+C,UAAU/C,KAAG,GAAG;EAErB,IAAItB,kBAAkB,UAAU;GAC9B+D,MAAMc,gBAAgBP,WAAWhD,KAAG,oBAAI,IAAIL,IAAI,oBAAI,IAAIA,IAAI,CAACK,KAAG,CAAC,CAAC;GAElE;EACF;EAEA,MAAM2E,gBAAgB7C,OAAe8C,QAAaC,UAAmB;GACnE,IAAI,CAAC9B,UAAU6B,MAAM,GAAG;GACxB,IAAIC,OAAO/C,MAAInB,IAAIiE,MAAM;QACpB;IACH9C,MAAIhB,OAAO8D,MAAM;IAKjB,IAAI/B,aAAa3D,MAAM;KACrB,IAAI4F,SAAS5F,KAAKI,SAASkB,IAAIoE,MAAM;KACrC,OAAOE,UAAU,MAAM;MACrBhD,MAAIhB,OAAOgE,MAAM;MACjBA,SAAS5F,KAAKI,SAASkB,IAAIsE,MAAM;KACnC;IACF;GACF;GACA,IAAI,CAACjC,aAAa,CAAC3D,MAAM;GACzB,CAACA,KAAKE,WAAWoB,IAAIoE,MAAM,KAAK,CAAA,EAAA,CAAI1D,SAASF,UAC3C2D,aAAa7C,OAAKd,OAAO6D,KAAK,CAChC;EACF;EAEA,MAAME,oBAAoBjD,UACxBe,aAAa3D,OACTU,oBACEkC,OACA5C,KAAKC,UACLD,KAAKE,aACJ4F,cAAc,CAACxD,iBAAiBd,IAAIsE,SAAS,CAChD,CAAC,CAAC/E,UACF6B;EAEN,MAAMmD,SAAShD,UAAUD;EAEzB,IAAI0B,SAAS1B,WAAWiD,UAAU,QAAQvD,WAAWwC,QAAQe,MAAM,KAAK,GAAG;GACzE,MAAMzB,SAAO,IAAI7D,IAAIiD,QAAQM,YAAYJ,iBAAiB7C,OAAO;GAIjE,IAAIiC,UAAUF,WAAW,MACvB8B,YAAYmB,QAAQ/C,UAAUF,OAAO,CAAC,CAACd,SAASgE,MAC9CP,aAAanB,QAAM0B,GAAG,KAAK,CAC7B;GAGFpB,YAAYmB,QAAQjF,KAAG,CAAC,CAACkB,SAASgE,QAAM;IACtCP,aAAanB,QAAM0B,KAAG,IAAI;GAC5B,CAAC;GAEDhD,UAAUF,UAAUhC;GACpByC,MAAMc,gBAAgBwB,iBAAiBvB,MAAI,CAAC;GAE5C;EACF;EAEAvB,UAAUD,UAAUhC;EACpBkC,UAAUF,UAAU;EACpB,IAAIa,WAAW;GACb,MAAMW,SAAO,IAAI7D,IAAImD,iBAAiB7C,OAAO;GAC7C0E,aAAanB,QAAMxD,OAAK,CAAC8C,iBAAiB7C,QAAQS,IAAIV,KAAG,CAAC;GAC1DyC,MAAMc,gBAAgBwB,iBAAiBvB,MAAI,CAAC;EAC9C,OACEb,iBAAiBwC,gBAAgBnF,KAAG;CAExC,CAAC;CAED,MAAMoF,eAAevI,cAAc;EACjC,IAAI+F,OAAO,OAAO,CAAC,GAAGjB,SAASS,OAAO,CAAC;EAEvC,OAAO,CAAC,GAAGU,iBAAiB7C,OAAO,CAAC,CACjC2B,KAAK5B,WAAQ2B,SAASnB,IAAIR,MAAG,CAAC,CAAC,CAC/BsC,QAAQ9D,UAAkBA,UAAQkB,KAAAA,CAAS;CAChD,GAAG;EAACkD;EAAOE;EAAkBnB;CAAQ,CAAC;CAEtC,OAAO;EACLL;EACA5C;EACAiE;EACAjB;EACAsB;EACAC;EACAF;EACAsC,eAAezI,aACZoD,WAAauB,iBAAiBb,IAAIV,MAAG,GACtC,CAACuB,gBAAgB,CACnB;EACAmD;EACAf;EACAP;EACAE;EACAG;EACA2B;EACAE,eAAe1C,QAAQjB,SAAS4D,OAAOzC,iBAAiB7C,QAAQsF;EAChE5G,cAAeiE,QAAQ,QAAQ,CAAC,GAAGE,iBAAiB7C,OAAO;CAE7D;AACF"}

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

@@ -1,10 +1,9 @@
-/** @license MIT | @cube-dev/ui-kit v0.197.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.198.1 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { getColumnText, getColumnValue } from "./use-table-columns.js";
 import { c } from "react/compiler-runtime";
 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.
@@ -164,7 +163,7 @@ function compareByColumn(column, collator, rowA, indexA, rowB, indexB) {
 	const textB = getColumnText(column, rowB, indexB) ?? String(valueB);
 	return collator.compare(textA, textB);
 }
-
 //#endregion
 export { compareByColumn, sortRows, useTableSort };
+
 //# sourceMappingURL=use-table-sort.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"use-table-sort.js","names":["useControlledState","useCollator","useEvent","getColumnText","getColumnValue","CubeTableColumn","CubeTableSort","CubeTableSortDirection","CubeTableSortMode","UseTableSortOptions","columns","T","rows","mode","sort","defaultSort","onSortChange","UseTableSortResult","sortedRows","toggleSort","columnKey","setColumnSort","direction","isSortable","column","useTableSort","t0","$","_c","sortProp","t1","Symbol","for","numeric","sensitivity","collator","setSort","value","hasSortableColumn","some","_temp","resolvedMode","t2","column_0","t3","column_1","find","entry","key","disallowSortRemoval","t4","columnKey_0","column_2","entry_0","t5","sortRows","t6","sorts","Intl","Collator","active","map","filter","length","row","index","a","b","result","compareByColumn","rowA","indexA","rowB","indexB","valueA","valueB","compare","Number","Date","getTime","textA","String","textB"],"sources":["../../../../src/components/data/TableBase/use-table-sort.ts"],"sourcesContent":["import { useControlledState } from '@react-stately/utils';\nimport { useCollator } from 'react-aria';\n\nimport { useEvent } from '../../../_internal/hooks';\n\nimport { getColumnText, getColumnValue } from './use-table-columns';\n\nimport type {\n  CubeTableColumn,\n  CubeTableSort,\n  CubeTableSortDirection,\n} from './types';\n\nexport type CubeTableSortMode = 'client' | 'server' | 'off';\n\nexport interface UseTableSortOptions<T> {\n  columns: CubeTableColumn<T>[];\n  rows: readonly T[];\n  /** @default 'client' when any column is sortable, else 'off' */\n  mode?: CubeTableSortMode;\n  sort?: CubeTableSort | null;\n  defaultSort?: CubeTableSort | null;\n  onSortChange?: (sort: CubeTableSort | null) => void;\n}\n\nexport interface UseTableSortResult<T> {\n  sort: CubeTableSort | null;\n  /** `rows` reordered in client mode; the original array otherwise. */\n  sortedRows: readonly T[];\n  /** Advances a column through the sort cycle. */\n  toggleSort: (columnKey: string) => void;\n  /**\n   * Sets a column's direction outright. `null` clears it.\n   *\n   * For the column menu's reserved sort keys, which have to reach a specific\n   * direction in one step rather than cycling to it.\n   */\n  setColumnSort: (\n    columnKey: string,\n    direction: CubeTableSortDirection | null,\n  ) => void;\n  isSortable: (column: CubeTableColumn<T>) => boolean;\n  /**\n   * The mode after defaulting. The renderer needs this exact answer to decide\n   * whether a header is clickable, and deriving it a second time at the call\n   * site is how `DataTable` ended up sorting on `defaultSorts` but ignoring\n   * every click.\n   */\n  mode: CubeTableSortMode;\n}\n\n/**\n * Sort state plus, in client mode, the reordered rows.\n *\n * The cycle is tri-state — `asc → desc → unsorted` — matching ag-grid's default\n * `sortingOrder`, because losing the ability to get back to the source order is\n * a real loss when the source order is meaningful. `disallowSortRemoval` on a\n * column reduces it to `asc ↔ desc`.\n */\nexport function useTableSort<T>({\n  columns,\n  rows,\n  mode,\n  sort: sortProp,\n  defaultSort,\n  onSortChange,\n}: UseTableSortOptions<T>): UseTableSortResult<T> {\n  // A collator gives locale-correct, case-insensitive ordering — \"Ä\" sorts next\n  // to \"A\" rather than after \"Z\", which a raw `<` comparison gets wrong.\n  const collator = useCollator({ numeric: true, sensitivity: 'base' });\n\n  const [sort, setSort] = useControlledState<CubeTableSort | null>(\n    sortProp as CubeTableSort | null,\n    defaultSort ?? null,\n    onSortChange as (value: CubeTableSort | null) => void,\n  );\n\n  const hasSortableColumn = columns.some((column) => column.isSortable);\n  const resolvedMode: CubeTableSortMode =\n    mode ?? (hasSortableColumn ? 'client' : 'off');\n\n  const isSortable = useEvent(\n    (column: CubeTableColumn<T>) =>\n      resolvedMode !== 'off' && column.isSortable === true,\n  );\n\n  const toggleSort = useEvent((columnKey: string) => {\n    const column = columns.find((entry) => entry.key === columnKey);\n\n    if (!column || !isSortable(column)) return;\n\n    if (sort?.columnKey !== columnKey) {\n      setSort({ columnKey, direction: 'asc' });\n\n      return;\n    }\n\n    if (sort.direction === 'asc') {\n      setSort({ columnKey, direction: 'desc' });\n\n      return;\n    }\n\n    setSort(\n      column.disallowSortRemoval ? { columnKey, direction: 'asc' } : null,\n    );\n  });\n\n  /**\n   * Set the column's direction outright instead of advancing the cycle — see\n   * `use-table-sorts.ts` for why the column menu cannot reuse `toggleSort`.\n   */\n  const setColumnSort = useEvent(\n    (columnKey: string, direction: CubeTableSortDirection | null) => {\n      const column = columns.find((entry) => entry.key === columnKey);\n\n      if (!column || !isSortable(column)) return;\n\n      if (direction == null) {\n        // Clearing a column that is not the sorted one is a no-op rather than a\n        // reset, and `disallowSortRemoval` refuses the clear outright.\n        if (sort?.columnKey !== columnKey || column.disallowSortRemoval) return;\n\n        setSort(null);\n\n        return;\n      }\n\n      if (sort?.columnKey === columnKey && sort.direction === direction) return;\n\n      setSort({ columnKey, direction });\n    },\n  );\n\n  const sortedRows =\n    resolvedMode === 'client' && sort\n      ? sortRows(rows, [sort], columns, collator)\n      : rows;\n\n  // The resolved mode is returned rather than left for the caller to derive\n  // again: the renderer needs the same answer to decide whether a header is\n  // clickable, and two independent derivations drift.\n  return {\n    sort,\n    sortedRows,\n    toggleSort,\n    setColumnSort,\n    isSortable,\n    mode: resolvedMode,\n  };\n}\n\n/**\n * `rows` ordered by `sorts`, the first sort taking precedence. Sorts naming a\n * column the table does not have are skipped, and `rows` itself comes back when\n * none is left.\n *\n * `map`/`sort`/`map` rather than sorting in place: `rows` is the caller's array\n * and `Array.prototype.sort` mutates. Carrying the original index also makes the\n * sort stable across engines, including when every sort ties.\n */\nexport function sortRows<T>(\n  rows: readonly T[],\n  sorts: readonly CubeTableSort[],\n  columns: CubeTableColumn<T>[],\n  collator: Intl.Collator,\n): readonly T[] {\n  const active = sorts\n    .map((sort) => ({\n      sort,\n      column: columns.find((entry) => entry.key === sort.columnKey),\n    }))\n    .filter(\n      (entry): entry is { sort: CubeTableSort; column: CubeTableColumn<T> } =>\n        entry.column != null,\n    );\n\n  if (!active.length) return rows;\n\n  return rows\n    .map((row, index) => ({ row, index }))\n    .sort((a, b) => {\n      for (const { sort, column } of active) {\n        const result = compareByColumn(\n          column,\n          collator,\n          a.row,\n          a.index,\n          b.row,\n          b.index,\n        );\n\n        if (result !== 0) {\n          return result * (sort.direction === 'asc' ? 1 : -1);\n        }\n      }\n\n      return a.index - b.index;\n    })\n    .map((entry) => entry.row);\n}\n\nexport function compareByColumn<T>(\n  column: CubeTableColumn<T>,\n  collator: Intl.Collator,\n  rowA: T,\n  indexA: number,\n  rowB: T,\n  indexB: number,\n): number {\n  const valueA = getColumnValue(column, rowA, indexA);\n  const valueB = getColumnValue(column, rowB, indexB);\n\n  if (column.compare) return column.compare(valueA, valueB, rowA, rowB);\n\n  // Nullish always sorts first, then gets flipped with the direction. Mixing\n  // them into the value comparison instead produces an unstable order.\n  if (valueA == null && valueB == null) return 0;\n  if (valueA == null) return -1;\n  if (valueB == null) return 1;\n\n  if (typeof valueA === 'number' && typeof valueB === 'number') {\n    return valueA - valueB;\n  }\n  if (typeof valueA === 'boolean' && typeof valueB === 'boolean') {\n    return Number(valueA) - Number(valueB);\n  }\n  if (valueA instanceof Date && valueB instanceof Date) {\n    return valueA.getTime() - valueB.getTime();\n  }\n\n  // Fall back to display text, so a column with a `format` sorts the way it\n  // reads rather than the way it is stored.\n  const textA = getColumnText(column, rowA, indexA) ?? String(valueA);\n  const textB = getColumnText(column, rowB, indexB) ?? String(valueB);\n\n  return collator.compare(textA, textB);\n}\n"],"mappings":"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"}
+{"version":3,"file":"use-table-sort.js","names":["useControlledState","useCollator","useEvent","getColumnText","getColumnValue","CubeTableColumn","CubeTableSort","CubeTableSortDirection","CubeTableSortMode","UseTableSortOptions","columns","T","rows","mode","sort","defaultSort","onSortChange","UseTableSortResult","sortedRows","toggleSort","columnKey","setColumnSort","direction","isSortable","column","useTableSort","t0","$","_c","sortProp","t1","Symbol","for","numeric","sensitivity","collator","setSort","value","hasSortableColumn","some","_temp","resolvedMode","t2","column_0","t3","column_1","find","entry","key","disallowSortRemoval","t4","columnKey_0","column_2","entry_0","t5","sortRows","t6","sorts","Intl","Collator","active","map","filter","length","row","index","a","b","result","compareByColumn","rowA","indexA","rowB","indexB","valueA","valueB","compare","Number","Date","getTime","textA","String","textB","_c"],"sources":["../../../../src/components/data/TableBase/use-table-sort.ts"],"sourcesContent":["import { useControlledState } from '@react-stately/utils';\nimport { useCollator } from 'react-aria';\n\nimport { useEvent } from '../../../_internal/hooks';\n\nimport { getColumnText, getColumnValue } from './use-table-columns';\n\nimport type {\n  CubeTableColumn,\n  CubeTableSort,\n  CubeTableSortDirection,\n} from './types';\n\nexport type CubeTableSortMode = 'client' | 'server' | 'off';\n\nexport interface UseTableSortOptions<T> {\n  columns: CubeTableColumn<T>[];\n  rows: readonly T[];\n  /** @default 'client' when any column is sortable, else 'off' */\n  mode?: CubeTableSortMode;\n  sort?: CubeTableSort | null;\n  defaultSort?: CubeTableSort | null;\n  onSortChange?: (sort: CubeTableSort | null) => void;\n}\n\nexport interface UseTableSortResult<T> {\n  sort: CubeTableSort | null;\n  /** `rows` reordered in client mode; the original array otherwise. */\n  sortedRows: readonly T[];\n  /** Advances a column through the sort cycle. */\n  toggleSort: (columnKey: string) => void;\n  /**\n   * Sets a column's direction outright. `null` clears it.\n   *\n   * For the column menu's reserved sort keys, which have to reach a specific\n   * direction in one step rather than cycling to it.\n   */\n  setColumnSort: (\n    columnKey: string,\n    direction: CubeTableSortDirection | null,\n  ) => void;\n  isSortable: (column: CubeTableColumn<T>) => boolean;\n  /**\n   * The mode after defaulting. The renderer needs this exact answer to decide\n   * whether a header is clickable, and deriving it a second time at the call\n   * site is how `DataTable` ended up sorting on `defaultSorts` but ignoring\n   * every click.\n   */\n  mode: CubeTableSortMode;\n}\n\n/**\n * Sort state plus, in client mode, the reordered rows.\n *\n * The cycle is tri-state — `asc → desc → unsorted` — matching ag-grid's default\n * `sortingOrder`, because losing the ability to get back to the source order is\n * a real loss when the source order is meaningful. `disallowSortRemoval` on a\n * column reduces it to `asc ↔ desc`.\n */\nexport function useTableSort<T>({\n  columns,\n  rows,\n  mode,\n  sort: sortProp,\n  defaultSort,\n  onSortChange,\n}: UseTableSortOptions<T>): UseTableSortResult<T> {\n  // A collator gives locale-correct, case-insensitive ordering — \"Ä\" sorts next\n  // to \"A\" rather than after \"Z\", which a raw `<` comparison gets wrong.\n  const collator = useCollator({ numeric: true, sensitivity: 'base' });\n\n  const [sort, setSort] = useControlledState<CubeTableSort | null>(\n    sortProp as CubeTableSort | null,\n    defaultSort ?? null,\n    onSortChange as (value: CubeTableSort | null) => void,\n  );\n\n  const hasSortableColumn = columns.some((column) => column.isSortable);\n  const resolvedMode: CubeTableSortMode =\n    mode ?? (hasSortableColumn ? 'client' : 'off');\n\n  const isSortable = useEvent(\n    (column: CubeTableColumn<T>) =>\n      resolvedMode !== 'off' && column.isSortable === true,\n  );\n\n  const toggleSort = useEvent((columnKey: string) => {\n    const column = columns.find((entry) => entry.key === columnKey);\n\n    if (!column || !isSortable(column)) return;\n\n    if (sort?.columnKey !== columnKey) {\n      setSort({ columnKey, direction: 'asc' });\n\n      return;\n    }\n\n    if (sort.direction === 'asc') {\n      setSort({ columnKey, direction: 'desc' });\n\n      return;\n    }\n\n    setSort(\n      column.disallowSortRemoval ? { columnKey, direction: 'asc' } : null,\n    );\n  });\n\n  /**\n   * Set the column's direction outright instead of advancing the cycle — see\n   * `use-table-sorts.ts` for why the column menu cannot reuse `toggleSort`.\n   */\n  const setColumnSort = useEvent(\n    (columnKey: string, direction: CubeTableSortDirection | null) => {\n      const column = columns.find((entry) => entry.key === columnKey);\n\n      if (!column || !isSortable(column)) return;\n\n      if (direction == null) {\n        // Clearing a column that is not the sorted one is a no-op rather than a\n        // reset, and `disallowSortRemoval` refuses the clear outright.\n        if (sort?.columnKey !== columnKey || column.disallowSortRemoval) return;\n\n        setSort(null);\n\n        return;\n      }\n\n      if (sort?.columnKey === columnKey && sort.direction === direction) return;\n\n      setSort({ columnKey, direction });\n    },\n  );\n\n  const sortedRows =\n    resolvedMode === 'client' && sort\n      ? sortRows(rows, [sort], columns, collator)\n      : rows;\n\n  // The resolved mode is returned rather than left for the caller to derive\n  // again: the renderer needs the same answer to decide whether a header is\n  // clickable, and two independent derivations drift.\n  return {\n    sort,\n    sortedRows,\n    toggleSort,\n    setColumnSort,\n    isSortable,\n    mode: resolvedMode,\n  };\n}\n\n/**\n * `rows` ordered by `sorts`, the first sort taking precedence. Sorts naming a\n * column the table does not have are skipped, and `rows` itself comes back when\n * none is left.\n *\n * `map`/`sort`/`map` rather than sorting in place: `rows` is the caller's array\n * and `Array.prototype.sort` mutates. Carrying the original index also makes the\n * sort stable across engines, including when every sort ties.\n */\nexport function sortRows<T>(\n  rows: readonly T[],\n  sorts: readonly CubeTableSort[],\n  columns: CubeTableColumn<T>[],\n  collator: Intl.Collator,\n): readonly T[] {\n  const active = sorts\n    .map((sort) => ({\n      sort,\n      column: columns.find((entry) => entry.key === sort.columnKey),\n    }))\n    .filter(\n      (entry): entry is { sort: CubeTableSort; column: CubeTableColumn<T> } =>\n        entry.column != null,\n    );\n\n  if (!active.length) return rows;\n\n  return rows\n    .map((row, index) => ({ row, index }))\n    .sort((a, b) => {\n      for (const { sort, column } of active) {\n        const result = compareByColumn(\n          column,\n          collator,\n          a.row,\n          a.index,\n          b.row,\n          b.index,\n        );\n\n        if (result !== 0) {\n          return result * (sort.direction === 'asc' ? 1 : -1);\n        }\n      }\n\n      return a.index - b.index;\n    })\n    .map((entry) => entry.row);\n}\n\nexport function compareByColumn<T>(\n  column: CubeTableColumn<T>,\n  collator: Intl.Collator,\n  rowA: T,\n  indexA: number,\n  rowB: T,\n  indexB: number,\n): number {\n  const valueA = getColumnValue(column, rowA, indexA);\n  const valueB = getColumnValue(column, rowB, indexB);\n\n  if (column.compare) return column.compare(valueA, valueB, rowA, rowB);\n\n  // Nullish always sorts first, then gets flipped with the direction. Mixing\n  // them into the value comparison instead produces an unstable order.\n  if (valueA == null && valueB == null) return 0;\n  if (valueA == null) return -1;\n  if (valueB == null) return 1;\n\n  if (typeof valueA === 'number' && typeof valueB === 'number') {\n    return valueA - valueB;\n  }\n  if (typeof valueA === 'boolean' && typeof valueB === 'boolean') {\n    return Number(valueA) - Number(valueB);\n  }\n  if (valueA instanceof Date && valueB instanceof Date) {\n    return valueA.getTime() - valueB.getTime();\n  }\n\n  // Fall back to display text, so a column with a `format` sorts the way it\n  // reads rather than the way it is stored.\n  const textA = getColumnText(column, rowA, indexA) ?? String(valueA);\n  const textB = getColumnText(column, rowB, indexB) ?? String(valueB);\n\n  return collator.compare(textA, textB);\n}\n"],"mappings":"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"}

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

@@ -1,10 +1,9 @@
-/** @license MIT | @cube-dev/ui-kit v0.197.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.198.1 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { sortRows } from "./use-table-sort.js";
 import { c } from "react/compiler-runtime";
 import { useControlledState } from "@react-stately/utils";
 import { useCollator } from "@react-aria/i18n";
-
 //#region src/components/data/TableBase/use-table-sorts.ts
 const EMPTY = [];
 /**
@@ -159,7 +158,7 @@ function useTableSorts(t0) {
 function _temp(column) {
 	return column.isSortable;
 }
-
 //#endregion
 export { useTableSorts };
+
 //# sourceMappingURL=use-table-sorts.js.map

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

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

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

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

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

@@ -1,6 +1,5 @@
-/** @license MIT | @cube-dev/ui-kit v0.197.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.198.1 | 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
@@ -52,11 +51,12 @@ function useTableStorage(storageKey, persist = DEFAULT_PERSIST_KEYS) {
 	}, [storageKey]);
 	return {
 		initial: storageKey ? initial : {},
+		/** `true` when this key is persisted, so callers can skip the work. */
 		has: (key_0) => !!storageKey && persist.includes(key_0),
 		write
 	};
 }
-
 //#endregion
-export { useTableStorage };
+export { DEFAULT_PERSIST_KEYS, useTableStorage };
+
 //# sourceMappingURL=use-table-storage.js.map

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

@@ -1 +1 @@
-{"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"}
+{"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' | 'columnWidths' | 'columnOrder' | '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;AAaf,MAAaQ,uBAA8C;CACzD;CACA;CAGA;AAAa;AAGf,SAASC,KAAKC,YAAsD;CAGlE,IAAI,CAACA,cAAc,OAAOC,WAAW,aAAa,OAAO,CAAC;CAE1D,IAAI;EACF,MAAMC,MAAMD,OAAOE,aAAaC,QAAQd,SAASU,UAAU;EAE3D,IAAI,CAACE,KAAK,OAAO,CAAC;EAElB,MAAMG,SAASC,KAAKC,MAAML,GAAG;EAI7B,OAAOG,UAAU,OAAOA,WAAW,WAAWA,SAAS,CAAC;CAC1D,QAAQ;EAGN,OAAO,CAAC;CACV;AACF;;;;;;;;;;AAWA,SAAgBG,gBACdR,YACAS,UAAiCX,sBACjC;CACA,MAAM,CAACY,WAAWtB,eAAeW,KAAKC,UAAU,CAAC;CACjD,MAAMW,aAAaxB,OAAOsB,OAAO;CAEjCE,WAAWC,UAAUH;CAErB,MAAMI,QAAQ3B,aACX4B,UAAgC;EAC/B,IAAI,CAACd,cAAc,OAAOC,WAAW,aAAa;EAElD,MAAMc,UAAUJ,WAAWC;EAC3B,MAAMI,UAAUC,OAAOD,QAAQF,KAAK,CAAC,CAACI,QAAQ,CAACC,SAC7CJ,QAAQK,SAASD,GAA0B,CAC7C;EAEA,IAAI,CAACH,QAAQK,QAAQ;EAErB,IAAI;GACF,MAAMC,OAAO;IACX,GAAGvB,KAAKC,UAAU;IAClB,GAAGiB,OAAOM,YAAYP,OAAO;GAC/B;GAEAf,OAAOE,aAAaqB,QAAQlC,SAASU,YAAYM,KAAKmB,UAAUH,IAAI,CAAC;EACvE,QAAQ,CACN;CAEJ,GACA,CAACtB,UAAU,CACb;CAEA,OAAO;EACLU,SAASV,aAAaU,UAAU,CAAC;;EAEjCgB,MAAMP,UAA6B,CAAC,CAACnB,cAAcS,QAAQW,SAASD,KAAG;EACvEN;CACF;AACF"}

package/dist/components/data/TableBase/use-table-tooltip-refresh.js

@@ -1,10 +1,9 @@
-/** @license MIT | @cube-dev/ui-kit v0.197.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.198.1 | Cube Dev Team */
 import { refreshAutoTooltipsWithin } from "../../content/use-auto-tooltip.js";
 import { c } from "react/compiler-runtime";
 import { useEffect } from "react";
-
 //#region src/components/data/TableBase/use-table-tooltip-refresh.ts
-const APPEARANCE_ELEMENTS = new Set([
+const APPEARANCE_ELEMENTS = /* @__PURE__ */ new Set([
 	"Scroller",
 	"Table",
 	"Head",
@@ -75,7 +74,7 @@ function useTableTooltipRefresh(scroller, isScrolling, onAppearanceChange, onRes
 	} else t2 = $[10];
 	useEffect(t1, t2);
 }
-
 //#endregion
 export { useTableTooltipRefresh };
+
 //# sourceMappingURL=use-table-tooltip-refresh.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"use-table-tooltip-refresh.js","names":["useEffect","refreshAutoTooltipsWithin","APPEARANCE_ELEMENTS","Set","useTableTooltipRefresh","scroller","isScrolling","onAppearanceChange","onRest","$","_c","t0","parentElement","root","t1","root_0","refresh","window","addEventListener","passive","observer","MutationObserver","records","some","t2","target","contains","HTMLElement","has","dataset","element","document","fonts","observe","attributes","subtree","parent","disconnect","removeEventListener"],"sources":["../../../../src/components/data/TableBase/use-table-tooltip-refresh.ts"],"sourcesContent":["import { useEffect } from 'react';\n\nimport { refreshAutoTooltipsWithin } from '../../content/use-auto-tooltip';\n\n// These elements own inherited table typography and its state selectors.\nconst APPEARANCE_ELEMENTS = new Set([\n  'Scroller',\n  'Table',\n  'Head',\n  'HeadRow',\n  'HeaderCell',\n  'HeaderGroupCell',\n  'Body',\n  'Row',\n  'Cell',\n]);\n\nexport function useTableTooltipRefresh(\n  scroller: HTMLDivElement | null,\n  isScrolling: boolean,\n  onAppearanceChange?: () => void,\n  onRest?: () => void,\n) {\n  // A commit can change inherited appearance without changing the box or\n  // font-set size. Refresh at rest, including the commit that settles scroll.\n  useEffect(() => {\n    const root = scroller?.parentElement;\n    if (root && !isScrolling) {\n      onAppearanceChange?.();\n      // Range buffers settle here, separately from mid-gesture appearance.\n      onRest?.();\n      refreshAutoTooltipsWithin(root);\n    }\n  });\n\n  useEffect(() => {\n    const root = scroller?.parentElement;\n    if (!root) return;\n\n    const refresh = () => {\n      onAppearanceChange?.();\n      refreshAutoTooltipsWithin(root);\n    };\n    window.addEventListener('resize', refresh, { passive: true });\n    const observer = new MutationObserver((records) => {\n      if (\n        records.some(\n          ({ target }) =>\n            target === root ||\n            !root.contains(target) ||\n            (target instanceof HTMLElement &&\n              APPEARANCE_ELEMENTS.has(target.dataset.element ?? '')),\n        )\n      ) {\n        // One scan per delivery also covers sibling/state selector changes.\n        // Spacer height and tooltip-trigger mutations need no refresh.\n        refresh();\n      }\n    });\n    document.fonts?.addEventListener('loadingdone', refresh);\n    observer.observe(root, { attributes: true, subtree: true });\n    for (\n      let parent = root.parentElement;\n      parent;\n      parent = parent.parentElement\n    ) {\n      observer.observe(parent, { attributes: true });\n    }\n    return () => {\n      observer.disconnect();\n      window.removeEventListener('resize', refresh);\n      document.fonts?.removeEventListener('loadingdone', refresh);\n    };\n  }, [onAppearanceChange, scroller]);\n}\n"],"mappings":";;;;;;AAKA,MAAME,sBAAsB,IAAIC,IAAI;CAClC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;AAEF,SAAOC,uBAAAC,UAAAC,aAAAC,oBAAAC,QAAA;CAAA,MAAAC,IAAAC,EAAA,GAAA;CAAA,IAAAC;AAAA,KAAAF,EAAA,OAAAH,eAAAG,EAAA,OAAAF,sBAAAE,EAAA,OAAAD,UAAAC,EAAA,OAAAJ,UAAAO,eAAA;AAQKD,aAAA;GACR,MAAAE,OAAaR,UAAQO;AACrB,OAAIC,QAAA,CAASP,aAAW;AACtBC,0BAAsB;AAEtBC,cAAU;AACVP,8BAA0BY,KAAK;;;AAElCJ,IAAA,KAAAH;AAAAG,IAAA,KAAAF;AAAAE,IAAA,KAAAD;AAAAC,IAAA,KAAAJ,UAAAO;AAAAH,IAAA,KAAAE;OAAAA,MAAAF,EAAA;AARDT,WAAUW,GAQR;CAAA,IAAAG;AAAA,KAAAL,EAAA,OAAAF,sBAAAE,EAAA,OAAAJ,UAAAO,eAAA;AAEQE,aAAA;GACR,MAAAC,SAAaV,UAAQO;AACrB,OAAI,CAACC,OAAI;GAET,MAAAG,gBAAgB;AACdT,0BAAsB;AACtBN,8BAA0BY,OAAK;;AAEjCI,UAAMC,iBAAkB,UAAUF,SAAS,EAAAG,SAAW,MAAM,CAAC;GAC7D,MAAAC,WAAiB,IAAIC,kBAAiBC,YAAA;AACpC,QACEA,QAAOC,MACLC,OAAA;KAAC,MAAA,EAAAC,WAAAD;AAAU,YACTC,WAAWZ,UAAX,CACCA,OAAIa,SAAUD,OAEyC,IADvDA,kBAAkBE,eACjBzB,oBAAmB0B,IAAKH,OAAMI,QAAQC,WAAd,GAA8B;MAC3D,CAIDd,UAAS;KAEX;AACFe,YAAQC,OAAwBd,iBAAC,eAAeF,QAAQ;AACxDI,YAAQa,QAASpB,QAAM;IAAAqB,YAAc;IAAIC,SAAW;IAAM,CAAC;AAC3D,QAAA,IAAAC,SACevB,OAAID,eACjBwB,QAFFA,SAGWA,OAAMxB,cAEfQ,UAAQa,QAASG,QAAQ,EAAAF,YAAc,MAAM,CAAC;AAC/C,gBACM;AACLd,aAAQiB,YAAa;AACrBpB,WAAMqB,oBAAqB,UAAUtB,QAAQ;AAC7Ce,aAAQC,OAA2BM,oBAAC,eAAetB,QAAQ;;;AAE9DP,IAAA,KAAAF;AAAAE,IAAA,KAAAJ,UAAAO;AAAAH,IAAA,KAAAK;OAAAA,MAAAL,EAAA;CAAA,IAAAe;AAAA,KAAAf,EAAA,OAAAF,sBAAAE,EAAA,OAAAJ,UAAA;AAAEmB,OAAA,CAACjB,oBAAoBF,SAAS;AAAAI,IAAA,KAAAF;AAAAE,IAAA,KAAAJ;AAAAI,IAAA,MAAAe;OAAAA,MAAAf,EAAA;AAtCjCT,WAAUc,IAsCPU,GAA+B"}
+{"version":3,"file":"use-table-tooltip-refresh.js","names":["useEffect","refreshAutoTooltipsWithin","APPEARANCE_ELEMENTS","Set","useTableTooltipRefresh","scroller","isScrolling","onAppearanceChange","onRest","$","_c","t0","parentElement","root","t1","root_0","refresh","window","addEventListener","passive","observer","MutationObserver","records","some","t2","target","contains","HTMLElement","has","dataset","element","document","fonts","observe","attributes","subtree","parent","disconnect","removeEventListener","_c"],"sources":["../../../../src/components/data/TableBase/use-table-tooltip-refresh.ts"],"sourcesContent":["import { useEffect } from 'react';\n\nimport { refreshAutoTooltipsWithin } from '../../content/use-auto-tooltip';\n\n// These elements own inherited table typography and its state selectors.\nconst APPEARANCE_ELEMENTS = new Set([\n  'Scroller',\n  'Table',\n  'Head',\n  'HeadRow',\n  'HeaderCell',\n  'HeaderGroupCell',\n  'Body',\n  'Row',\n  'Cell',\n]);\n\nexport function useTableTooltipRefresh(\n  scroller: HTMLDivElement | null,\n  isScrolling: boolean,\n  onAppearanceChange?: () => void,\n  onRest?: () => void,\n) {\n  // A commit can change inherited appearance without changing the box or\n  // font-set size. Refresh at rest, including the commit that settles scroll.\n  useEffect(() => {\n    const root = scroller?.parentElement;\n    if (root && !isScrolling) {\n      onAppearanceChange?.();\n      // Range buffers settle here, separately from mid-gesture appearance.\n      onRest?.();\n      refreshAutoTooltipsWithin(root);\n    }\n  });\n\n  useEffect(() => {\n    const root = scroller?.parentElement;\n    if (!root) return;\n\n    const refresh = () => {\n      onAppearanceChange?.();\n      refreshAutoTooltipsWithin(root);\n    };\n    window.addEventListener('resize', refresh, { passive: true });\n    const observer = new MutationObserver((records) => {\n      if (\n        records.some(\n          ({ target }) =>\n            target === root ||\n            !root.contains(target) ||\n            (target instanceof HTMLElement &&\n              APPEARANCE_ELEMENTS.has(target.dataset.element ?? '')),\n        )\n      ) {\n        // One scan per delivery also covers sibling/state selector changes.\n        // Spacer height and tooltip-trigger mutations need no refresh.\n        refresh();\n      }\n    });\n    document.fonts?.addEventListener('loadingdone', refresh);\n    observer.observe(root, { attributes: true, subtree: true });\n    for (\n      let parent = root.parentElement;\n      parent;\n      parent = parent.parentElement\n    ) {\n      observer.observe(parent, { attributes: true });\n    }\n    return () => {\n      observer.disconnect();\n      window.removeEventListener('resize', refresh);\n      document.fonts?.removeEventListener('loadingdone', refresh);\n    };\n  }, [onAppearanceChange, scroller]);\n}\n"],"mappings":";;;;;AAKA,MAAME,sCAAsB,IAAIC,IAAI;CAClC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AAAM,CACP;AAED,SAAOC,uBAAAC,UAAAC,aAAAC,oBAAAC,QAAA;CAAA,MAAAC,IAAAC,EAAA,EAAA;CAAA,IAAAC;CAAA,IAAAF,EAAA,OAAAH,eAAAG,EAAA,OAAAF,sBAAAE,EAAA,OAAAD,UAAAC,EAAA,OAAAJ,UAAAO,eAAA;EAQKD,WAAA;GACR,MAAAE,OAAaR,UAAQO;GACrB,IAAIC,QAAA,CAASP,aAAW;IACtBC,qBAAqB;IAErBC,SAAS;IACTP,0BAA0BY,IAAI;GAAC;EAChC;EACFJ,EAAA,KAAAH;EAAAG,EAAA,KAAAF;EAAAE,EAAA,KAAAD;EAAAC,EAAA,KAAAJ,UAAAO;EAAAH,EAAA,KAAAE;CAAA,OAAAA,KAAAF,EAAA;CARDT,UAAUW,EAQT;CAAC,IAAAG;CAAA,IAAAL,EAAA,OAAAF,sBAAAE,EAAA,OAAAJ,UAAAO,eAAA;EAEQE,WAAA;GACR,MAAAC,SAAaV,UAAQO;GACrB,IAAI,CAACC,QAAI;GAET,MAAAG,gBAAgB;IACdT,qBAAqB;IACrBN,0BAA0BY,MAAI;GAAC;GAEjCI,OAAMC,iBAAkB,UAAUF,SAAS,EAAAG,SAAW,KAAK,CAAC;GAC5D,MAAAC,WAAiB,IAAIC,kBAAiBC,YAAA;IACpC,IACEA,QAAOC,MACLC,OAAA;KAAC,MAAA,EAAAC,WAAAD;KAAU,OACTC,WAAWZ,UAAX,CACCA,OAAIa,SAAUD,MAAM,KACpBA,kBAAkBE,eACjBzB,oBAAmB0B,IAAKH,OAAMI,QAAQC,WAAd,EAA4B;IAAE,CAC5D,GAIAd,QAAQ;GACT,CACF;GACDe,SAAQC,OAAwBd,iBAAC,eAAeF,OAAO;GACvDI,SAAQa,QAASpB,QAAM;IAAAqB,YAAc;IAAIC,SAAW;GAAK,CAAC;GAC1D,KAAA,IAAAC,SACevB,OAAID,eACjBwB,QAFFA,SAGWA,OAAMxB,eAEfQ,SAAQa,QAASG,QAAQ,EAAAF,YAAc,KAAK,CAAC;GAC9C,aACM;IACLd,SAAQiB,WAAY;IACpBpB,OAAMqB,oBAAqB,UAAUtB,OAAO;IAC5Ce,SAAQC,OAA2BM,oBAAC,eAAetB,OAAO;GAAC;EAC5D;EACFP,EAAA,KAAAF;EAAAE,EAAA,KAAAJ,UAAAO;EAAAH,EAAA,KAAAK;CAAA,OAAAA,KAAAL,EAAA;CAAA,IAAAe;CAAA,IAAAf,EAAA,OAAAF,sBAAAE,EAAA,OAAAJ,UAAA;EAAEmB,KAAA,CAACjB,oBAAoBF,QAAQ;EAACI,EAAA,KAAAF;EAAAE,EAAA,KAAAJ;EAAAI,EAAA,MAAAe;CAAA,OAAAA,KAAAf,EAAA;CAtCjCT,UAAUc,IAsCPU,EAA8B;AAAC"}

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

@@ -1,11 +1,10 @@
-/** @license MIT | @cube-dev/ui-kit v0.197.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.198.1 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { useI18n } from "../../../i18n/useI18n.js";
 import { c } from "react/compiler-runtime";
 import { jsx } from "react/jsx-runtime";
 import { Item, useTreeState } from "react-stately";
 import { useControlledState } from "@react-stately/utils";
-
 //#region src/components/data/TableBase/use-table-tree-state.tsx
 /**
 * Current React Stately's legacy TreeCollection omits `getChildren`, while
@@ -187,7 +186,7 @@ function _temp2(node_1) {
 	return node_1?.type === "item";
 }
 function _temp() {}
-
 //#endregion
 export { useTableTreeState };
+
 //# sourceMappingURL=use-table-tree-state.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"use-table-tree-state.js","names":["useControlledState","Item","useTreeState","useEvent","useI18n","Key","Node","ReactElement","TreeState","TableTreeNode","CubeTableRowExpandInfo","UseTableTreeStateOptions","roots","T","allNodesByKey","Map","expandedKeys","defaultExpandedKeys","forcedExpandedKeys","ReadonlySet","disabledKeys","getTextValue","node","onExpand","keys","info","ariaLabel","TableTreeStateResult","state","ariaProps","Record","visibleNodes","visibleEntries","Set","withGetChildren","collection","getChildren","patched","Object","create","key","getItem","Array","from","childNodes","useTableTreeState","options","$","_c","controlledExpandedKeys","t","t0","undefined","controlledSet","t1","t2","defaultSet","baseExpandedKeys","setBaseExpandedKeys","effectiveExpandedKeys","forEach","add","t3","next","toggledKey","expanded","key_0","has","key_1","nextBase","delete","get","row","rowKey","level","parentKey","handleExpandedChange","t4","node_0","children","renderItem","t5","t6","t7","items","selectionMode","const","onExpandedChange","disabledBehavior","onAction","_temp","baseState","t8","getKeys","key_2","filter","_temp2","t9","map","_temp3","_temp4","t10","node_3","node_2","value","node_1","type"],"sources":["../../../../src/components/data/TableBase/use-table-tree-state.tsx"],"sourcesContent":["import { useControlledState } from '@react-stately/utils';\nimport { Item, useTreeState } from 'react-stately';\n\nimport { useEvent } from '../../../_internal/hooks';\nimport { useI18n } from '../../../i18n';\n\nimport type { Key, Node } from '@react-types/shared';\nimport type { ReactElement } from 'react';\nimport type { TreeState } from 'react-stately';\nimport type { TableTreeNode } from './table-tree';\nimport type { CubeTableRowExpandInfo } from './types';\n\nexport interface UseTableTreeStateOptions<T> {\n  roots: TableTreeNode<T>[];\n  allNodesByKey: Map<Key, TableTreeNode<T>>;\n  expandedKeys?: Key[];\n  defaultExpandedKeys?: Key[];\n  forcedExpandedKeys?: ReadonlySet<Key>;\n  disabledKeys?: Key[];\n  getTextValue: (node: TableTreeNode<T>) => string;\n  onExpand?: (keys: Key[], info: CubeTableRowExpandInfo<T>) => void;\n  ariaLabel?: string;\n}\n\nexport interface TableTreeStateResult<T> {\n  state: TreeState<TableTreeNode<T>>;\n  /** Props consumed by `useTree` on the actual `<table>`. */\n  ariaProps: Record<string, any>;\n  visibleNodes: Node<TableTreeNode<T>>[];\n  visibleEntries: TableTreeNode<T>[];\n  expandedKeys: Set<Key>;\n}\n\n/**\n * Current React Stately's legacy TreeCollection omits `getChildren`, while\n * `useTreeItem` needs it for level/set-size/expanded metadata.\n */\nfunction withGetChildren<T>(state: TreeState<T>): TreeState<T> {\n  const collection = state.collection;\n  if (typeof (collection as any).getChildren === 'function') return state;\n\n  const patched = Object.create(collection);\n  patched.getChildren = (key: Key) => {\n    const node = collection.getItem(key);\n    return node ? Array.from(node.childNodes) : [];\n  };\n\n  return { ...state, collection: patched };\n}\n\nexport function useTableTreeState<T>(\n  options: UseTableTreeStateOptions<T>,\n): TableTreeStateResult<T> {\n  const {\n    roots,\n    allNodesByKey,\n    expandedKeys: controlledExpandedKeys,\n    defaultExpandedKeys,\n    forcedExpandedKeys,\n    disabledKeys,\n    getTextValue,\n    onExpand,\n    ariaLabel,\n  } = options;\n  const { t } = useI18n();\n\n  const controlledSet =\n    controlledExpandedKeys === undefined\n      ? undefined\n      : new Set<Key>(controlledExpandedKeys);\n  const defaultSet = new Set<Key>(defaultExpandedKeys ?? []);\n  const [baseExpandedKeys, setBaseExpandedKeys] = useControlledState<Set<Key>>(\n    controlledSet as Set<Key>,\n    defaultSet,\n  );\n\n  const effectiveExpandedKeys = new Set(baseExpandedKeys);\n  forcedExpandedKeys?.forEach((key) => effectiveExpandedKeys.add(key));\n\n  const handleExpandedChange = useEvent((next: Set<Key>) => {\n    let toggledKey: Key | null = null;\n    let expanded = false;\n\n    for (const key of next) {\n      if (!effectiveExpandedKeys.has(key)) {\n        toggledKey = key;\n        expanded = true;\n        break;\n      }\n    }\n\n    if (toggledKey == null) {\n      for (const key of effectiveExpandedKeys) {\n        if (!next.has(key)) {\n          toggledKey = key;\n          expanded = false;\n          break;\n        }\n      }\n    }\n\n    if (toggledKey == null) return;\n\n    // Search-owned expansions are derived and cannot be collapsed until the\n    // search clears. Crucially, they never leak into the consumer's state.\n    if (!expanded && forcedExpandedKeys?.has(toggledKey)) return;\n\n    const nextBase = new Set(baseExpandedKeys);\n    if (expanded) nextBase.add(toggledKey);\n    else nextBase.delete(toggledKey);\n    setBaseExpandedKeys(nextBase);\n\n    const node = allNodesByKey.get(toggledKey);\n    if (!node) return;\n\n    onExpand?.([...nextBase], {\n      row: node.row,\n      rowKey: node.key,\n      level: node.level,\n      parentKey: node.parentKey,\n      expanded,\n    });\n  });\n\n  const renderItem = useEvent(\n    (node: TableTreeNode<T>): ReactElement => (\n      <Item\n        key={node.key}\n        textValue={getTextValue(node)}\n        childItems={node.children}\n      >\n        {getTextValue(node)}\n      </Item>\n    ),\n  );\n\n  const ariaProps = {\n    items: roots,\n    children: renderItem as any,\n    selectionMode: 'none' as const,\n    expandedKeys: effectiveExpandedKeys,\n    onExpandedChange: handleExpandedChange,\n    disabledKeys,\n    disabledBehavior: 'all' as const,\n    // Prevent `useTreeItem` from treating a row press as an implicit toggle.\n    // Tables keep row activation and expansion as separate interactions.\n    onAction: () => {},\n    'aria-label': ariaLabel ?? t('itemTable.table', 'Table'),\n  };\n\n  const baseState = useTreeState<TableTreeNode<T>>(ariaProps);\n  const state = withGetChildren(baseState);\n\n  const visibleNodes = Array.from(state.collection.getKeys(), (key) =>\n    state.collection.getItem(key),\n  ).filter((node): node is Node<TableTreeNode<T>> => node?.type === 'item');\n\n  const visibleEntries = visibleNodes\n    .map((node) => node.value)\n    .filter((node): node is TableTreeNode<T> => node != null);\n\n  return {\n    state,\n    ariaProps,\n    visibleNodes,\n    visibleEntries,\n    expandedKeys: effectiveExpandedKeys,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;AAqCA,SAASkC,gBAAmBN,OAAmC;CAC7D,MAAMO,aAAaP,MAAMO;AACzB,KAAI,OAAQA,WAAmBC,gBAAgB,WAAY,QAAOR;CAElE,MAAMS,UAAUC,OAAOC,OAAOJ,WAAW;AACzCE,SAAQD,eAAeI,QAAa;EAClC,MAAMlB,OAAOa,WAAWM,QAAQD,IAAI;AACpC,SAAOlB,OAAOoB,MAAMC,KAAKrB,KAAKsB,WAAW,GAAG,EAAE;;AAGhD,QAAO;EAAE,GAAGhB;EAAOO,YAAYE;EAAS;;AAG1C,SAAOQ,kBAAAC,SAAA;CAAA,MAAAC,IAAAC,EAAA,GAAA;CAGL,MAAA,EAAApC,OAAAE,eAAAE,cAAAiC,wBAAAhC,qBAAAC,oBAAAE,cAAAC,cAAAE,UAAAG,cAUIoB;CACJ,MAAA,EAAAI,MAAc9C,SAAS;CAAC,IAAA+C;AAAA,KAAAJ,EAAA,OAAAE,wBAAA;AAGtBE,OAAAF,2BAA2BG,SAA3BA,SAAA,IAEQnB,IAASgB,uBAAuB;AAAAF,IAAA,KAAAE;AAAAF,IAAA,KAAAI;OAAAA,MAAAJ,EAAA;CAH1C,MAAAM,gBACEF;CAEyC,IAAAG;AAAA,KAAAP,EAAA,OAAA9B,qBAAA;AACXqC,OAAArC,uBAAA,EAAyB;AAAA8B,IAAA,KAAA9B;AAAA8B,IAAA,KAAAO;OAAAA,MAAAP,EAAA;CAAA,IAAAQ;AAAA,KAAAR,EAAA,OAAAO,IAAA;AAAtCC,OAAA,IAAItB,IAASqB,GAA0B;AAAAP,IAAA,KAAAO;AAAAP,IAAA,KAAAQ;OAAAA,MAAAR,EAAA;CAC1D,MAAA,CAAAU,kBAAAC,uBAAgD1D,mBAC9CqD,eAFiBE,GAIlB;CAAC,IAAAI;AAAA,KAAAZ,EAAA,OAAAU,oBAAAV,EAAA,OAAA7B,oBAAA;AAEFyC,0BAA8B,IAAI1B,IAAIwB,iBAAiB;AACvDvC,sBAAkB0C,SAAUpB,QAASmB,sBAAqBE,IAAKrB,IAAI,CAAC;AAAAO,IAAA,KAAAU;AAAAV,IAAA,KAAA7B;AAAA6B,IAAA,KAAAY;OAAAA,yBAAAZ,EAAA;CAAA,IAAAe;AAAA,KAAAf,EAAA,OAAAjC,iBAAAiC,EAAA,QAAAU,oBAAAV,EAAA,QAAAY,yBAAAZ,EAAA,QAAA7B,sBAAA6B,EAAA,QAAAxB,YAAAwB,EAAA,QAAAW,qBAAA;AAE9BI,QAAAC,SAAA;GACpC,IAAAC,aAA6B;GAC7B,IAAAC,WAAe;AAEf,QAAK,MAAAC,SAAaH,KAChB,KAAI,CAACJ,sBAAqBQ,IAAK3B,MAAI,EAAA;AACjCwB,iBAAaxB;AACbyB,eAAWA;AACX;;AAIJ,OAAID,cAAc,MAChB;SAAK,MAAAI,SAAaT,sBAChB,KAAI,CAACI,KAAII,IAAK3B,MAAI,EAAA;AAChBwB,kBAAaxB;AACbyB,gBAAWA;AACX;;;AAKN,OAAID,cAAc,KAAI;AAItB,OAAI,CAACC,YAAY/C,oBAAkBiD,IAAMH,WAAW,CAAA;GAEpD,MAAAK,WAAiB,IAAIpC,IAAIwB,iBAAiB;AAC1C,OAAIQ,SAAUI,UAAQR,IAAKG,WAAW;OACjCK,UAAQC,OAAQN,WAAW;AAChCN,uBAAoBW,SAAS;GAE7B,MAAA/C,OAAaR,cAAayD,IAAKP,WAAW;AAC1C,OAAI,CAAC1C,KAAI;AAETC,cAAW,CAAA,GAAI8C,SAAS,EAAE;IAAAG,KACnBlD,KAAIkD;IAAIC,QACLnD,KAAIkB;IAAIkC,OACTpD,KAAIoD;IAAMC,WACNrD,KAAIqD;IAAUV;IAE1B,CAAC;;AACHlB,IAAA,KAAAjC;AAAAiC,IAAA,MAAAU;AAAAV,IAAA,MAAAY;AAAAZ,IAAA,MAAA7B;AAAA6B,IAAA,MAAAxB;AAAAwB,IAAA,MAAAW;AAAAX,IAAA,MAAAe;OAAAA,MAAAf,EAAA;CA3CD,MAAA6B,uBAA6BzE,SAAS2D,GA2CpC;CAAC,IAAAe;AAAA,KAAA9B,EAAA,QAAA1B,cAAA;AAGDwD,QAAAC,WACE,oBAAC;GAEY,WAAAzD,aAAaC,OAAI;GAChB,YAAAA,OAAIyD;aAEf1D,aAAaC,OAAI;KAJbA,OAAIkB,IAMZ;AAAAO,IAAA,MAAA1B;AAAA0B,IAAA,MAAA8B;OAAAA,MAAA9B,EAAA;CAKS,MAAAkC,KAdO9E,SACjB0E,GASD;CAI4B,IAAAK;AAAA,KAAAnC,EAAA,QAAArB,aAAAqB,EAAA,QAAAG,GAAA;AASbgC,OAAAxD,aAAawB,EAAE,mBAAmB,QAAQ;AAAAH,IAAA,MAAArB;AAAAqB,IAAA,MAAAG;AAAAH,IAAA,MAAAmC;OAAAA,MAAAnC,EAAA;CAAA,IAAAoC;AAAA,KAAApC,EAAA,QAAA3B,gBAAA2B,EAAA,QAAAY,yBAAAZ,EAAA,QAAA6B,wBAAA7B,EAAA,QAAAnC,SAAAmC,EAAA,QAAAkC,MAAAlC,EAAA,QAAAmC,IAAA;AAXxCC,OAAA;GAAAC,OACTxE;GAAKmE,UACFE;GAAiBI,eACZ;GAAerE,cAChB2C;GAAqB4B,kBACjBX;GAAoBxD;GAAAoE,kBAEpB;GAAcC,UAGtBC;GAAQ,cACJR;GACf;AAAAnC,IAAA,MAAA3B;AAAA2B,IAAA,MAAAY;AAAAZ,IAAA,MAAA6B;AAAA7B,IAAA,MAAAnC;AAAAmC,IAAA,MAAAkC;AAAAlC,IAAA,MAAAmC;AAAAnC,IAAA,MAAAoC;OAAAA,MAAApC,EAAA;CAZD,MAAAlB,YAAkBsD;CAclB,MAAAQ,YAAkBzF,aAA+B2B,UAAU;CAAC,IAAAD;CAAA,IAAAgE;AAAA,KAAA7C,EAAA,QAAA4C,WAAA;AAC5D/D,UAAcM,gBAAgByD,UAAU;AAEnBC,OAAAlD,MAAKC,KAAMf,MAAKO,WAAW0D,SAAU,GAAEC,UAC1DlE,MAAKO,WAAWM,QAASD,MAC3B,CAAC,CAAAuD,OAAQC,OAAgE;AAAAjD,IAAA,MAAA4C;AAAA5C,IAAA,MAAAnB;AAAAmB,IAAA,MAAA6C;QAAA;AAAAhE,UAAAmB,EAAA;AAAA6C,OAAA7C,EAAA;;CAFzE,MAAAhB,eAAqB6D;CAEqD,IAAAK;AAAA,KAAAlD,EAAA,QAAAhB,cAAA;AAEnDkE,OAAAlE,aAAYmE,IAC5BC,OAAqB,CAAAJ,OAClBK,OAAiD;AAAArD,IAAA,MAAAhB;AAAAgB,IAAA,MAAAkD;OAAAA,MAAAlD,EAAA;CAF3D,MAAAf,iBAAuBiE;CAEqC,IAAAI;AAAA,KAAAtD,EAAA,QAAAlB,aAAAkB,EAAA,QAAAY,yBAAAZ,EAAA,QAAAnB,SAAAmB,EAAA,QAAAf,kBAAAe,EAAA,QAAAhB,cAAA;AAErDsE,QAAA;GAAAzE;GAAAC;GAAAE;GAAAC;GAAAhB,cAKS2C;GACf;AAAAZ,IAAA,MAAAlB;AAAAkB,IAAA,MAAAY;AAAAZ,IAAA,MAAAnB;AAAAmB,IAAA,MAAAf;AAAAe,IAAA,MAAAhB;AAAAgB,IAAA,MAAAsD;OAAAA,OAAAtD,EAAA;AAAA,QANMsD;;AA/GF,SAAAD,OAAAE,QAAA;AAAA,QA6GyChF,UAAQ;;AA7GjD,SAAA6E,OAAAI,QAAA;AAAA,QA4GYjF,OAAIkF;;AA5GhB,SAAAR,OAAAS,QAAA;AAAA,QAyG8CnF,QAAIoF,SAAW;;AAzG7D,SAAAhB,QAAA"}
+{"version":3,"file":"use-table-tree-state.js","names":["useControlledState","Item","useTreeState","useEvent","useI18n","Key","Node","ReactElement","TreeState","TableTreeNode","CubeTableRowExpandInfo","UseTableTreeStateOptions","roots","T","allNodesByKey","Map","expandedKeys","defaultExpandedKeys","forcedExpandedKeys","ReadonlySet","disabledKeys","getTextValue","node","onExpand","keys","info","ariaLabel","TableTreeStateResult","state","ariaProps","Record","visibleNodes","visibleEntries","Set","withGetChildren","collection","getChildren","patched","Object","create","key","getItem","Array","from","childNodes","useTableTreeState","options","$","_c","controlledExpandedKeys","t","t0","undefined","controlledSet","t1","t2","defaultSet","baseExpandedKeys","setBaseExpandedKeys","effectiveExpandedKeys","forEach","add","t3","next","toggledKey","expanded","key_0","has","key_1","nextBase","delete","get","row","rowKey","level","parentKey","handleExpandedChange","t4","node_0","children","renderItem","t5","t6","t7","items","selectionMode","const","onExpandedChange","disabledBehavior","onAction","_temp","baseState","t8","getKeys","key_2","filter","_temp2","t9","map","_temp3","_temp4","t10","node_3","node_2","value","node_1","type","_c","defaultSet"],"sources":["../../../../src/components/data/TableBase/use-table-tree-state.tsx"],"sourcesContent":["import { useControlledState } from '@react-stately/utils';\nimport { Item, useTreeState } from 'react-stately';\n\nimport { useEvent } from '../../../_internal/hooks';\nimport { useI18n } from '../../../i18n';\n\nimport type { Key, Node } from '@react-types/shared';\nimport type { ReactElement } from 'react';\nimport type { TreeState } from 'react-stately';\nimport type { TableTreeNode } from './table-tree';\nimport type { CubeTableRowExpandInfo } from './types';\n\nexport interface UseTableTreeStateOptions<T> {\n  roots: TableTreeNode<T>[];\n  allNodesByKey: Map<Key, TableTreeNode<T>>;\n  expandedKeys?: Key[];\n  defaultExpandedKeys?: Key[];\n  forcedExpandedKeys?: ReadonlySet<Key>;\n  disabledKeys?: Key[];\n  getTextValue: (node: TableTreeNode<T>) => string;\n  onExpand?: (keys: Key[], info: CubeTableRowExpandInfo<T>) => void;\n  ariaLabel?: string;\n}\n\nexport interface TableTreeStateResult<T> {\n  state: TreeState<TableTreeNode<T>>;\n  /** Props consumed by `useTree` on the actual `<table>`. */\n  ariaProps: Record<string, any>;\n  visibleNodes: Node<TableTreeNode<T>>[];\n  visibleEntries: TableTreeNode<T>[];\n  expandedKeys: Set<Key>;\n}\n\n/**\n * Current React Stately's legacy TreeCollection omits `getChildren`, while\n * `useTreeItem` needs it for level/set-size/expanded metadata.\n */\nfunction withGetChildren<T>(state: TreeState<T>): TreeState<T> {\n  const collection = state.collection;\n  if (typeof (collection as any).getChildren === 'function') return state;\n\n  const patched = Object.create(collection);\n  patched.getChildren = (key: Key) => {\n    const node = collection.getItem(key);\n    return node ? Array.from(node.childNodes) : [];\n  };\n\n  return { ...state, collection: patched };\n}\n\nexport function useTableTreeState<T>(\n  options: UseTableTreeStateOptions<T>,\n): TableTreeStateResult<T> {\n  const {\n    roots,\n    allNodesByKey,\n    expandedKeys: controlledExpandedKeys,\n    defaultExpandedKeys,\n    forcedExpandedKeys,\n    disabledKeys,\n    getTextValue,\n    onExpand,\n    ariaLabel,\n  } = options;\n  const { t } = useI18n();\n\n  const controlledSet =\n    controlledExpandedKeys === undefined\n      ? undefined\n      : new Set<Key>(controlledExpandedKeys);\n  const defaultSet = new Set<Key>(defaultExpandedKeys ?? []);\n  const [baseExpandedKeys, setBaseExpandedKeys] = useControlledState<Set<Key>>(\n    controlledSet as Set<Key>,\n    defaultSet,\n  );\n\n  const effectiveExpandedKeys = new Set(baseExpandedKeys);\n  forcedExpandedKeys?.forEach((key) => effectiveExpandedKeys.add(key));\n\n  const handleExpandedChange = useEvent((next: Set<Key>) => {\n    let toggledKey: Key | null = null;\n    let expanded = false;\n\n    for (const key of next) {\n      if (!effectiveExpandedKeys.has(key)) {\n        toggledKey = key;\n        expanded = true;\n        break;\n      }\n    }\n\n    if (toggledKey == null) {\n      for (const key of effectiveExpandedKeys) {\n        if (!next.has(key)) {\n          toggledKey = key;\n          expanded = false;\n          break;\n        }\n      }\n    }\n\n    if (toggledKey == null) return;\n\n    // Search-owned expansions are derived and cannot be collapsed until the\n    // search clears. Crucially, they never leak into the consumer's state.\n    if (!expanded && forcedExpandedKeys?.has(toggledKey)) return;\n\n    const nextBase = new Set(baseExpandedKeys);\n    if (expanded) nextBase.add(toggledKey);\n    else nextBase.delete(toggledKey);\n    setBaseExpandedKeys(nextBase);\n\n    const node = allNodesByKey.get(toggledKey);\n    if (!node) return;\n\n    onExpand?.([...nextBase], {\n      row: node.row,\n      rowKey: node.key,\n      level: node.level,\n      parentKey: node.parentKey,\n      expanded,\n    });\n  });\n\n  const renderItem = useEvent((node: TableTreeNode<T>): ReactElement => (\n    <Item\n      key={node.key}\n      textValue={getTextValue(node)}\n      childItems={node.children}\n    >\n      {getTextValue(node)}\n    </Item>\n  ));\n\n  const ariaProps = {\n    items: roots,\n    children: renderItem as any,\n    selectionMode: 'none' as const,\n    expandedKeys: effectiveExpandedKeys,\n    onExpandedChange: handleExpandedChange,\n    disabledKeys,\n    disabledBehavior: 'all' as const,\n    // Prevent `useTreeItem` from treating a row press as an implicit toggle.\n    // Tables keep row activation and expansion as separate interactions.\n    onAction: () => {},\n    'aria-label': ariaLabel ?? t('itemTable.table', 'Table'),\n  };\n\n  const baseState = useTreeState<TableTreeNode<T>>(ariaProps);\n  const state = withGetChildren(baseState);\n\n  const visibleNodes = Array.from(state.collection.getKeys(), (key) =>\n    state.collection.getItem(key),\n  ).filter((node): node is Node<TableTreeNode<T>> => node?.type === 'item');\n\n  const visibleEntries = visibleNodes\n    .map((node) => node.value)\n    .filter((node): node is TableTreeNode<T> => node != null);\n\n  return {\n    state,\n    ariaProps,\n    visibleNodes,\n    visibleEntries,\n    expandedKeys: effectiveExpandedKeys,\n  };\n}\n"],"mappings":"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"}

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

@@ -1,11 +1,12 @@
 
 import { CubeTableAlign, CubeTableCellContext, CubeTableColumn, CubeTableColumnHeader, CubeTableHeaderContext, CubeTableLayoutProps, CubeTableRowContext, CubeTableRowExpandInfo, CubeTableRowSection, CubeTableRowSize, CubeTableSort, CubeTableSortDirection, CubeTableTreeProps, CubeTableTreeRowState } from "./TableBase/types.js";
 import { CubeDataTableColumn, CubeDataTableColumnDefinition, CubeDataTableColumnGroup, CubeDataTableProps } from "./DataTable/types.js";
-import { _DataTable } from "./DataTable/DataTable.js";
+import { DataTable as _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 as _ItemTable, ItemTableComponent } from "./ItemTable/ItemTable.js";
 import "./ItemTable/index.js";
 import { COLUMN_MENU_SORT_KEYS, CubeColumnMenuSortKey, columnSortMenu } from "./TableBase/column-menu.js";
-import "./TableBase/index.js";
+import "./TableBase/index.js";
+export { COLUMN_MENU_SORT_KEYS, type CubeColumnMenuSortKey, type CubeDataTableColumn, type CubeDataTableColumnDefinition, type CubeDataTableColumnGroup, type CubeDataTableProps, type CubeItemTableColumn, type CubeItemTableProps, type CubeTableAlign, type CubeTableCellContext, type CubeTableColumn, type CubeTableColumnHeader, type CubeTableHeaderContext, type CubeTableLayoutProps, type CubeTableRowContext, type CubeTableRowExpandInfo, type CubeTableRowRenderProps, type CubeTableRowSection, type CubeTableRowSize, type CubeTableSort, type CubeTableSortDirection, type CubeTableTreeProps, type CubeTableTreeRowState, _DataTable as DataTable, _ItemTable as ItemTable, type ItemTableComponent, columnSortMenu };

package/dist/components/fields/Checkbox/Checkbox.d.ts

@@ -2,14 +2,11 @@
 import { FieldBaseProps, ToggleSelectionProps } from "../../../shared/form.js";
 import "../../../shared/index.js";
 import { CubeTooltipProviderProps } from "../../overlays/Tooltip/TooltipProvider.js";
-import { CubeCheckboxGroupProps, _CheckboxGroup } from "./CheckboxGroup.js";
+import { CheckboxGroup as _CheckboxGroup, CubeCheckboxGroupProps } from "./CheckboxGroup.js";
 import { BaseProps, ContainerStyleProps, Styles } from "@tenphi/tasty";
-import * as react from "react";
 import { AriaCheckboxProps, useCheckbox } from "react-aria";
-import * as _react_types_shared0 from "@react-types/shared";
-
 //#region src/components/fields/Checkbox/Checkbox.d.ts
-interface CubeCheckboxProps extends BaseProps, ContainerStyleProps, Omit<AriaCheckboxProps, 'form' | 'name'>, ToggleSelectionProps, FieldBaseProps<boolean | null | undefined> {
+export interface CubeCheckboxProps extends BaseProps, ContainerStyleProps, Omit<AriaCheckboxProps, 'form' | 'name'>, ToggleSelectionProps, FieldBaseProps<boolean | null | undefined> {
   inputStyles?: Styles;
   isIndeterminate?: boolean;
   value?: string;
@@ -21,17 +18,17 @@ interface CubeCheckboxProps extends BaseProps, ContainerStyleProps, Omit<AriaChe
    */
   tooltip?: string | Omit<CubeTooltipProviderProps, 'children'>;
 }
-declare let __Checkbox: react.ForwardRefExoticComponent<Omit<CubeCheckboxProps, "isSelected" | "defaultSelected"> & {
+declare let __Checkbox: import("react").ForwardRefExoticComponent<Omit<CubeCheckboxProps, "isSelected" | "defaultSelected"> & {
   isSelected?: any;
   defaultSelected?: any;
-} & react.RefAttributes<_react_types_shared0.FocusableRefValue<HTMLElement, HTMLElement>>> & {
+} & import("react").RefAttributes<import("@react-types/shared").FocusableRefValue<HTMLElement, HTMLElement>>> & {
   Group: typeof _CheckboxGroup;
 } & {
-  Group: react.ForwardRefExoticComponent<Omit<CubeCheckboxGroupProps, "value" | "defaultValue"> & {
+  Group: import("react").ForwardRefExoticComponent<Omit<CubeCheckboxGroupProps, "value" | "defaultValue"> & {
     value?: any;
     defaultValue?: any;
-  } & react.RefAttributes<unknown>>;
+  } & import("react").RefAttributes<unknown>>;
 };
 //#endregion
-export { type AriaCheckboxProps, CubeCheckboxProps, __Checkbox, useCheckbox };
+export { type AriaCheckboxProps, __Checkbox as Checkbox, useCheckbox };
 //# sourceMappingURL=Checkbox.d.ts.map