@cube-dev/ui-kit 0.206.3 → 0.208.0

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

@@ -1 +1 @@
-{"version":3,"file":"use-column-order.js","names":["useControlledState","useState","useEvent","CubeResolvedColumn","CubeTableColumn","useTableStorage","applyColumnOrder","columns","T","order","length","present","Set","map","column","key","rank","Map","forEach","index","has","set","size","carried","sourceIndex","own","get","sort","a","b","entry","isColumnDraggable","Pick","isEnabled","isStructural","pin","isReorderable","getDraggableColumnKeys","filter","projectReorder","fullOrder","nextDraggable","draggable","next","cursor","slot","EMPTY_ORDER","UseColumnOrderOptions","columnOrder","defaultColumnOrder","onColumnOrderChange","storage","ReturnType","UseColumnOrderResult","reorder","useColumnOrder","t0","$","_c","t1","undefined","initial","storedOrder","setOrder","value","ordered","t2","_temp","t3","write","t4","_c"],"sources":["../../../../src/components/data/TableBase/use-column-order.ts"],"sourcesContent":["import { useControlledState } from '@react-stately/utils';\nimport { useState } from 'react';\n\nimport { useEvent } from '../../../_internal/hooks';\n\nimport type { CubeResolvedColumn, CubeTableColumn } from './types';\nimport type { useTableStorage } from './use-table-storage';\n\n/**\n * Reorders the source columns to match `order`.\n *\n * Rank-based rather than filter-then-concat, because `order` is routinely\n * *stale*: it was persisted or lifted into page state before the current\n * `columns` array existed. A column missing from it inherits the rank of the\n * nearest preceding known column plus a half step, so it lands immediately after\n * the neighbour it had in the source array instead of being swept to the end. A\n * new leading column keeps its lead.\n *\n * Applied to the SOURCE array, before `useTableColumns` — so hidden-column\n * filtering, structural injection, pinned hoisting and `aria-colindex` all still\n * happen downstream, and `columnOrder` can never fight `pin`.\n */\nexport function applyColumnOrder<T>(\n  columns: CubeTableColumn<T>[],\n  order?: readonly string[],\n): CubeTableColumn<T>[] {\n  if (!order?.length) return columns;\n\n  const present = new Set(columns.map((column) => column.key));\n  const rank = new Map<string, number>();\n\n  order.forEach((key, index) => {\n    // A key for a column that no longer exists is ignored rather than treated as\n    // a gap, and a duplicate keeps its first position.\n    if (present.has(key) && !rank.has(key)) rank.set(key, index);\n  });\n\n  if (!rank.size) return columns;\n\n  let carried = -1;\n\n  return columns\n    .map((column, sourceIndex) => {\n      const own = rank.get(column.key);\n\n      if (own != null) carried = own;\n\n      return { column, sourceIndex, rank: own ?? carried + 0.5 };\n    })\n    .sort((a, b) => a.rank - b.rank || a.sourceIndex - b.sourceIndex)\n    .map((entry) => entry.column);\n}\n\n/**\n * Whether a column can be picked up and moved.\n *\n * The single shared predicate: `DataTable` builds the draggable key list from\n * it and `TableView` decides which `<th>` is a drag source from it, so the two\n * cannot drift. A renderer disagreeing with the state behind it is exactly how\n * the drop indicator that never matched its selector happened.\n *\n * Pinned columns are excluded, for three reasons that all point the same way: a\n * pinned `<th>` is `position: sticky`, so under horizontal scroll its rect sits\n * on top of columns it is nowhere near and React Aria's drop-target binary\n * search goes wrong; `use-table-columns` hoists pinned columns to the edges\n * regardless of source order, so a cross-boundary drop would be undone\n * immediately; and `pin` is already the ordering authority there. What that buys\n * is a draggable set that is one contiguous, non-sticky run — every permutation\n * of which stays monotonic, which is what the delegate needs.\n */\nexport function isColumnDraggable<T>(\n  column: Pick<CubeResolvedColumn<T>, 'isStructural' | 'pin' | 'isReorderable'>,\n  isEnabled: boolean,\n): boolean {\n  return (\n    isEnabled &&\n    !column.isStructural &&\n    column.pin == null &&\n    (column.isReorderable ?? true)\n  );\n}\n\nexport function getDraggableColumnKeys<T>(\n  columns: readonly CubeResolvedColumn<T>[],\n  isEnabled: boolean,\n): string[] {\n  return columns\n    .filter((column) => isColumnDraggable(column, isEnabled))\n    .map((column) => column.key);\n}\n\n/**\n * Folds a permutation of the draggable subset back into the full order.\n *\n * Only the slots the draggable keys already occupy are rewritten, so a hidden\n * column, a pinned one, or one that opted out keeps its absolute index and\n * cannot be displaced by a drag it took no part in.\n *\n * The visible consequence, worth knowing: a hidden column between two draggable\n * ones keeps its slot rather than following a neighbour, so it may come back\n * between different columns than it left. Predictable beats clever.\n */\nexport function projectReorder(\n  fullOrder: readonly string[],\n  nextDraggable: readonly string[],\n): string[] {\n  const draggable = new Set(nextDraggable);\n  const next = [...fullOrder];\n  let cursor = 0;\n\n  for (let slot = 0; slot < next.length; slot++) {\n    if (draggable.has(next[slot])) next[slot] = nextDraggable[cursor++];\n  }\n\n  return next;\n}\n\nconst EMPTY_ORDER: string[] = [];\n\nexport interface UseColumnOrderOptions<T> {\n  columns: CubeTableColumn<T>[];\n  columnOrder?: string[];\n  defaultColumnOrder?: string[];\n  onColumnOrderChange?: (order: string[]) => void;\n  storage: ReturnType<typeof useTableStorage>;\n}\n\nexport interface UseColumnOrderResult<T> {\n  /** `columns`, reordered. Feed this to `useTableColumns`. */\n  columns: CubeTableColumn<T>[];\n  /** The full key list in its current order, including hidden and pinned keys. */\n  order: string[];\n  /** Takes the reordered DRAGGABLE keys and commits the full order. */\n  reorder: (nextDraggable: string[]) => void;\n}\n\nexport function useColumnOrder<T>({\n  columns,\n  columnOrder,\n  defaultColumnOrder,\n  onColumnOrderChange,\n  storage,\n}: UseColumnOrderOptions<T>): UseColumnOrderResult<T> {\n  // Seeded once, like `ownColumnWidths`: a controlled `columnOrder` belongs to\n  // the page, so restoring over it would fight the page's own source of truth.\n  const [storedOrder] = useState(() =>\n    columnOrder === undefined && storage.has('columnOrder')\n      ? storage.initial.columnOrder\n      : undefined,\n  );\n\n  // An empty array means \"no order\", which `applyColumnOrder` treats as a\n  // no-op — same shape `useTableSorts` uses for its own empty default, and it\n  // keeps `useControlledState` off the `undefined` overload.\n  const [order, setOrder] = useControlledState<string[]>(\n    columnOrder as string[],\n    defaultColumnOrder ?? storedOrder ?? EMPTY_ORDER,\n    onColumnOrderChange as (value: string[]) => void,\n  );\n\n  const ordered = applyColumnOrder(columns, order);\n\n  // Always the FULL source key list, in current order — so a key never drops out\n  // of persisted state just because its column happened to be hidden.\n  const fullOrder = ordered.map((column) => column.key);\n\n  const reorder = useEvent((nextDraggable: string[]) => {\n    const next = projectReorder(fullOrder, nextDraggable);\n\n    setOrder(next);\n\n    // Only what the table OWNS is persisted — a controlled order belongs to the\n    // page, and storing it would fight the page on the next mount. Same rule\n    // `handleColumnResizeEnd` follows for widths.\n    if (columnOrder === undefined) storage.write({ columnOrder: next });\n  });\n\n  return { columns: ordered, order: fullOrder, reorder };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAsBA,SAAgBM,iBACdC,SACAE,OACsB;CACtB,IAAI,CAACA,OAAOC,QAAQ,OAAOH;CAE3B,MAAMI,UAAU,IAAIC,IAAIL,QAAQM,KAAKC,WAAWA,OAAOC,GAAG,CAAC;CAC3D,MAAMC,uBAAO,IAAIC,IAAoB;CAErCR,MAAMS,SAASH,KAAKI,UAAU;EAG5B,IAAIR,QAAQS,IAAIL,GAAG,KAAK,CAACC,KAAKI,IAAIL,GAAG,GAAGC,KAAKK,IAAIN,KAAKI,KAAK;CAC7D,CAAC;CAED,IAAI,CAACH,KAAKM,MAAM,OAAOf;CAEvB,IAAIgB,UAAU;CAEd,OAAOhB,QACJM,KAAKC,QAAQU,gBAAgB;EAC5B,MAAMC,MAAMT,KAAKU,IAAIZ,OAAOC,GAAG;EAE/B,IAAIU,OAAO,MAAMF,UAAUE;EAE3B,OAAO;GAAEX;GAAQU;GAAaR,MAAMS,OAAOF,UAAU;EAAI;CAC3D,CAAC,CAAC,CACDI,MAAMC,GAAGC,MAAMD,EAAEZ,OAAOa,EAAEb,QAAQY,EAAEJ,cAAcK,EAAEL,WAAW,CAAC,CAChEX,KAAKiB,UAAUA,MAAMhB,MAAM;AAChC;;;;;;;;;;;;;;;;;;AAmBA,SAAgBiB,kBACdjB,QACAmB,WACS;CACT,OACEA,aACA,CAACnB,OAAOoB,gBACRpB,OAAOqB,OAAO,SACbrB,OAAOsB,iBAAiB;AAE7B;AAEA,SAAgBC,uBACd9B,SACA0B,WACU;CACV,OAAO1B,QACJ+B,QAAQxB,WAAWiB,kBAAkBjB,QAAQmB,SAAS,CAAC,CAAC,CACxDpB,KAAKC,WAAWA,OAAOC,GAAG;AAC/B;;;;;;;;;;;;AAaA,SAAgBwB,eACdC,WACAC,eACU;CACV,MAAMC,YAAY,IAAI9B,IAAI6B,aAAa;CACvC,MAAME,OAAO,CAAC,GAAGH,SAAS;CAC1B,IAAII,SAAS;CAEb,KAAK,IAAIC,OAAO,GAAGA,OAAOF,KAAKjC,QAAQmC,QACrC,IAAIH,UAAUtB,IAAIuB,KAAKE,KAAK,GAAGF,KAAKE,QAAQJ,cAAcG;CAG5D,OAAOD;AACT;AAEA,MAAMG,cAAwB,CAAA;AAmB9B,SAAOS,eAAAC,IAAA;CAAA,MAAAC,IAAAC,EAAA,EAAA;CAA2B,MAAA,EAAAnD,SAAAyC,aAAAC,oBAAAC,qBAAAC,YAAAK;CAMP,IAAAG;CAAA,IAAAF,EAAA,OAAAT,eAAAS,EAAA,OAAAN,SAAA;EAGMQ,WAC7BX,gBAAgBY,KAAAA,KAAaT,QAAO/B,IAAK,aAAa,IAClD+B,QAAOU,QAAQb,cADnBY,KAAAA;EAEaH,EAAA,KAAAT;EAAAS,EAAA,KAAAN;EAAAM,EAAA,KAAAE;CAAA,OAAAA,KAAAF,EAAA;CAHf,MAAA,CAAAK,eAAsB7D,SAAS0D,EAI/B;CAKA,MAAA,CAAAlD,OAAAsD,YAA0B/D,mBACxBgD,aACAC,sBAAAa,eAAAhB,aACAI,mBACF;CAAE,IAAAe;CAAA,IAAAC;CAAA,IAAAT,EAAA,OAAAlD,WAAAkD,EAAA,OAAAhD,OAAA;EAEFwD,UAAgB3D,iBAAiBC,SAASE,KAAK;EAI7ByD,KAAAD,QAAOpD,IAAKsD,KAAsB;EAACV,EAAA,KAAAlD;EAAAkD,EAAA,KAAAhD;EAAAgD,EAAA,KAAAQ;EAAAR,EAAA,KAAAS;CAAA,OAAA;EAAAD,UAAAR,EAAA;EAAAS,KAAAT,EAAA;CAAA;CAArD,MAAAjB,YAAkB0B;CAAoC,IAAAE;CAAA,IAAAX,EAAA,OAAAT,eAAAS,EAAA,OAAAjB,aAAAiB,EAAA,OAAAM,YAAAN,EAAA,QAAAN,SAAA;EAE7BiB,MAAA3B,kBAAA;GACvB,MAAAE,OAAaJ,eAAeC,WAAWC,aAAa;GAEpDsB,SAASpB,IAAI;GAKb,IAAIK,gBAAgBY,KAAAA,GAAWT,QAAOkB,MAAO,EAAArB,aAAeL,KAAK,CAAC;EAAE;EACrEc,EAAA,KAAAT;EAAAS,EAAA,KAAAjB;EAAAiB,EAAA,KAAAM;EAAAN,EAAA,MAAAN;EAAAM,EAAA,MAAAW;CAAA,OAAAA,KAAAX,EAAA;CATD,MAAAH,UAAgBpD,SAASkE,EASxB;CAAE,IAAAE;CAAA,IAAAb,EAAA,QAAAjB,aAAAiB,EAAA,QAAAQ,WAAAR,EAAA,QAAAH,SAAA;EAEIgB,KAAA;GAAA/D,SAAW0D;GAAOxD,OAAS+B;GAASc;EAAU;EAACG,EAAA,MAAAjB;EAAAiB,EAAA,MAAAQ;EAAAR,EAAA,MAAAH;EAAAG,EAAA,MAAAa;CAAA,OAAAA,KAAAb,EAAA;CAAA,OAA/Ca;AAA+C;AAzCjD,SAAAH,MAAArD,QAAA;CAAA,OA4BqCA,OAAMC;AAAI"}
+{"version":3,"file":"use-column-order.js","names":["useControlledState","useState","useEvent","CubeResolvedColumn","CubeTableColumn","useTableStorage","applyColumnOrder","columns","T","order","length","present","Set","map","column","key","rank","Map","forEach","index","has","set","size","carried","sourceIndex","own","get","sort","a","b","entry","isColumnDraggable","Pick","isEnabled","isStructural","pin","isReorderable","getDraggableColumnKeys","filter","projectReorder","fullOrder","nextDraggable","draggable","next","cursor","slot","EMPTY_ORDER","UseColumnOrderOptions","columnOrder","defaultColumnOrder","onColumnOrderChange","storage","ReturnType","UseColumnOrderResult","reorder","useColumnOrder","t0","$","_c","t1","undefined","initial","storedOrder","setOrder","value","ordered","t2","_temp","t3","write","t4","_c"],"sources":["../../../../src/components/data/TableBase/use-column-order.ts"],"sourcesContent":["import { useControlledState } from '@react-stately/utils';\nimport { useState } from 'react';\n\nimport { useEvent } from '../../../_internal/hooks/use-event';\n\nimport type { CubeResolvedColumn, CubeTableColumn } from './types';\nimport type { useTableStorage } from './use-table-storage';\n\n/**\n * Reorders the source columns to match `order`.\n *\n * Rank-based rather than filter-then-concat, because `order` is routinely\n * *stale*: it was persisted or lifted into page state before the current\n * `columns` array existed. A column missing from it inherits the rank of the\n * nearest preceding known column plus a half step, so it lands immediately after\n * the neighbour it had in the source array instead of being swept to the end. A\n * new leading column keeps its lead.\n *\n * Applied to the SOURCE array, before `useTableColumns` — so hidden-column\n * filtering, structural injection, pinned hoisting and `aria-colindex` all still\n * happen downstream, and `columnOrder` can never fight `pin`.\n */\nexport function applyColumnOrder<T>(\n  columns: CubeTableColumn<T>[],\n  order?: readonly string[],\n): CubeTableColumn<T>[] {\n  if (!order?.length) return columns;\n\n  const present = new Set(columns.map((column) => column.key));\n  const rank = new Map<string, number>();\n\n  order.forEach((key, index) => {\n    // A key for a column that no longer exists is ignored rather than treated as\n    // a gap, and a duplicate keeps its first position.\n    if (present.has(key) && !rank.has(key)) rank.set(key, index);\n  });\n\n  if (!rank.size) return columns;\n\n  let carried = -1;\n\n  return columns\n    .map((column, sourceIndex) => {\n      const own = rank.get(column.key);\n\n      if (own != null) carried = own;\n\n      return { column, sourceIndex, rank: own ?? carried + 0.5 };\n    })\n    .sort((a, b) => a.rank - b.rank || a.sourceIndex - b.sourceIndex)\n    .map((entry) => entry.column);\n}\n\n/**\n * Whether a column can be picked up and moved.\n *\n * The single shared predicate: `DataTable` builds the draggable key list from\n * it and `TableView` decides which `<th>` is a drag source from it, so the two\n * cannot drift. A renderer disagreeing with the state behind it is exactly how\n * the drop indicator that never matched its selector happened.\n *\n * Pinned columns are excluded, for three reasons that all point the same way: a\n * pinned `<th>` is `position: sticky`, so under horizontal scroll its rect sits\n * on top of columns it is nowhere near and React Aria's drop-target binary\n * search goes wrong; `use-table-columns` hoists pinned columns to the edges\n * regardless of source order, so a cross-boundary drop would be undone\n * immediately; and `pin` is already the ordering authority there. What that buys\n * is a draggable set that is one contiguous, non-sticky run — every permutation\n * of which stays monotonic, which is what the delegate needs.\n */\nexport function isColumnDraggable<T>(\n  column: Pick<CubeResolvedColumn<T>, 'isStructural' | 'pin' | 'isReorderable'>,\n  isEnabled: boolean,\n): boolean {\n  return (\n    isEnabled &&\n    !column.isStructural &&\n    column.pin == null &&\n    (column.isReorderable ?? true)\n  );\n}\n\nexport function getDraggableColumnKeys<T>(\n  columns: readonly CubeResolvedColumn<T>[],\n  isEnabled: boolean,\n): string[] {\n  return columns\n    .filter((column) => isColumnDraggable(column, isEnabled))\n    .map((column) => column.key);\n}\n\n/**\n * Folds a permutation of the draggable subset back into the full order.\n *\n * Only the slots the draggable keys already occupy are rewritten, so a hidden\n * column, a pinned one, or one that opted out keeps its absolute index and\n * cannot be displaced by a drag it took no part in.\n *\n * The visible consequence, worth knowing: a hidden column between two draggable\n * ones keeps its slot rather than following a neighbour, so it may come back\n * between different columns than it left. Predictable beats clever.\n */\nexport function projectReorder(\n  fullOrder: readonly string[],\n  nextDraggable: readonly string[],\n): string[] {\n  const draggable = new Set(nextDraggable);\n  const next = [...fullOrder];\n  let cursor = 0;\n\n  for (let slot = 0; slot < next.length; slot++) {\n    if (draggable.has(next[slot])) next[slot] = nextDraggable[cursor++];\n  }\n\n  return next;\n}\n\nconst EMPTY_ORDER: string[] = [];\n\nexport interface UseColumnOrderOptions<T> {\n  columns: CubeTableColumn<T>[];\n  columnOrder?: string[];\n  defaultColumnOrder?: string[];\n  onColumnOrderChange?: (order: string[]) => void;\n  storage: ReturnType<typeof useTableStorage>;\n}\n\nexport interface UseColumnOrderResult<T> {\n  /** `columns`, reordered. Feed this to `useTableColumns`. */\n  columns: CubeTableColumn<T>[];\n  /** The full key list in its current order, including hidden and pinned keys. */\n  order: string[];\n  /** Takes the reordered DRAGGABLE keys and commits the full order. */\n  reorder: (nextDraggable: string[]) => void;\n}\n\nexport function useColumnOrder<T>({\n  columns,\n  columnOrder,\n  defaultColumnOrder,\n  onColumnOrderChange,\n  storage,\n}: UseColumnOrderOptions<T>): UseColumnOrderResult<T> {\n  // Seeded once, like `ownColumnWidths`: a controlled `columnOrder` belongs to\n  // the page, so restoring over it would fight the page's own source of truth.\n  const [storedOrder] = useState(() =>\n    columnOrder === undefined && storage.has('columnOrder')\n      ? storage.initial.columnOrder\n      : undefined,\n  );\n\n  // An empty array means \"no order\", which `applyColumnOrder` treats as a\n  // no-op — same shape `useTableSorts` uses for its own empty default, and it\n  // keeps `useControlledState` off the `undefined` overload.\n  const [order, setOrder] = useControlledState<string[]>(\n    columnOrder as string[],\n    defaultColumnOrder ?? storedOrder ?? EMPTY_ORDER,\n    onColumnOrderChange as (value: string[]) => void,\n  );\n\n  const ordered = applyColumnOrder(columns, order);\n\n  // Always the FULL source key list, in current order — so a key never drops out\n  // of persisted state just because its column happened to be hidden.\n  const fullOrder = ordered.map((column) => column.key);\n\n  const reorder = useEvent((nextDraggable: string[]) => {\n    const next = projectReorder(fullOrder, nextDraggable);\n\n    setOrder(next);\n\n    // Only what the table OWNS is persisted — a controlled order belongs to the\n    // page, and storing it would fight the page on the next mount. Same rule\n    // `handleColumnResizeEnd` follows for widths.\n    if (columnOrder === undefined) storage.write({ columnOrder: next });\n  });\n\n  return { columns: ordered, order: fullOrder, reorder };\n}\n"],"mappings":"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"}

package/dist/components/data/TableBase/use-column-window.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.206.3 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.208.0 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { c } from "react/compiler-runtime";
 import { CONTAINER_STYLES } from "@tenphi/tasty";

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

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.206.3 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.208.0 | Cube Dev Team */
 import { c } from "react/compiler-runtime";
 import { useLayoutEffect, useState } from "react";
 //#region src/components/data/TableBase/use-container-width.ts

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

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.206.3 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.208.0 | Cube Dev Team */
 import { c } from "react/compiler-runtime";
 import { useLayoutEffect, useRef } from "react";
 /** Matches `DisplayTransition`'s check, which is the kit's existing precedent. */

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

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

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

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.206.3 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.208.0 | Cube Dev Team */
 import { c } from "react/compiler-runtime";
 /**
 * Every column's current width, so a resize can change exactly one of them.

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

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.206.3 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.208.0 | Cube Dev Team */
 import { useDebouncedValue } from "../../../_internal/hooks/use-debounced-value.js";
 import { getColumnText } from "./use-table-columns.js";
 import { c } from "react/compiler-runtime";

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

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

package/dist/components/data/TableBase/use-table-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[] | '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"}
+{"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/use-event';\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":"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"}

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

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.206.3 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.208.0 | 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";

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","_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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"}
+{"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/use-event';\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,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.206.3 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.208.0 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { sortRows } from "./use-table-sort.js";
 import { c } from "react/compiler-runtime";

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

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

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

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

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.206.3 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.208.0 | Cube Dev Team */
 import { refreshAutoTooltipsWithin } from "../../content/use-auto-tooltip.js";
 import { c } from "react/compiler-runtime";
 import { useEffect } from "react";

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

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.206.3 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.208.0 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { useI18n } from "../../../i18n/useI18n.js";
 import { c } from "react/compiler-runtime";

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","_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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"}
+{"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/use-event';\nimport { useI18n } from '../../../i18n/useI18n';\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":";;;;;;;;;;;;AAqCA,SAASkC,gBAAmBN,OAAmC;CAC7D,MAAMO,aAAaP,MAAMO;CACzB,IAAI,OAAQA,WAAmBC,gBAAgB,YAAY,OAAOR;CAElE,MAAMS,UAAUC,OAAOC,OAAOJ,UAAU;CACxCE,QAAQD,eAAeI,QAAa;EAClC,MAAMlB,OAAOa,WAAWM,QAAQD,GAAG;EACnC,OAAOlB,OAAOoB,MAAMC,KAAKrB,KAAKsB,UAAU,IAAI,CAAA;CAC9C;CAEA,OAAO;EAAE,GAAGhB;EAAOO,YAAYE;CAAQ;AACzC;AAEA,SAAOQ,kBAAAC,SAAA;CAAA,MAAAC,IAAAC,EAAA,EAAA;CAGL,MAAA,EAAApC,OAAAE,eAAAE,cAAAiC,wBAAAhC,qBAAAC,oBAAAE,cAAAC,cAAAE,UAAAG,cAUIoB;CACJ,MAAA,EAAAI,MAAc9C,QAAQ;CAAE,IAAA+C;CAAA,IAAAJ,EAAA,OAAAE,wBAAA;EAGtBE,KAAAF,2BAA2BG,KAAAA,IAA3BA,KAAAA,IAAA,IAEQnB,IAASgB,sBAAsB;EAACF,EAAA,KAAAE;EAAAF,EAAA,KAAAI;CAAA,OAAAA,KAAAJ,EAAA;CAH1C,MAAAM,gBACEF;CAEyC,IAAAG;CAAA,IAAAP,EAAA,OAAA9B,qBAAA;EACXqC,KAAArC,uBAAA,CAAA;EAAyB8B,EAAA,KAAA9B;EAAA8B,EAAA,KAAAO;CAAA,OAAAA,KAAAP,EAAA;CAAA,IAAAQ;CAAA,IAAAR,EAAA,OAAAO,IAAA;EAAtCC,KAAA,IAAItB,IAASqB,EAAyB;EAACP,EAAA,KAAAO;EAAAP,EAAA,KAAAQ;CAAA,OAAAA,KAAAR,EAAA;CAC1D,MAAA,CAAAU,kBAAAC,uBAAgD1D,mBAC9CqD,eACAG,EACF;CAAE,IAAAG;CAAA,IAAAZ,EAAA,OAAAU,oBAAAV,EAAA,OAAA7B,oBAAA;EAEFyC,wBAA8B,IAAI1B,IAAIwB,gBAAgB;EACtDvC,oBAAkB0C,SAAUpB,QAASmB,sBAAqBE,IAAKrB,GAAG,CAAC;EAACO,EAAA,KAAAU;EAAAV,EAAA,KAAA7B;EAAA6B,EAAA,KAAAY;CAAA,OAAAA,wBAAAZ,EAAA;CAAA,IAAAe;CAAA,IAAAf,EAAA,OAAAjC,iBAAAiC,EAAA,QAAAU,oBAAAV,EAAA,QAAAY,yBAAAZ,EAAA,QAAA7B,sBAAA6B,EAAA,QAAAxB,YAAAwB,EAAA,QAAAW,qBAAA;EAE9BI,MAAAC,SAAA;GACpC,IAAAC,aAA6B;GAC7B,IAAAC,WAAe;GAEf,KAAK,MAAAC,SAAaH,MAChB,IAAI,CAACJ,sBAAqBQ,IAAK3B,KAAG,GAAC;IACjCwB,aAAaxB;IACbyB,WAAWA;IACX;GAAM;GAIV,IAAID,cAAc,MACX;SAAA,MAAAI,SAAaT,uBAChB,IAAI,CAACI,KAAII,IAAK3B,KAAG,GAAC;KAChBwB,aAAaxB;KACbyB,WAAWA;KACX;IAAM;;GAKZ,IAAID,cAAc,MAAI;GAItB,IAAI,CAACC,YAAY/C,oBAAkBiD,IAAMH,UAAU,GAAC;GAEpD,MAAAK,WAAiB,IAAIpC,IAAIwB,gBAAgB;GACzC,IAAIQ,UAAUI,SAAQR,IAAKG,UAAU;QAChCK,SAAQC,OAAQN,UAAU;GAC/BN,oBAAoBW,QAAQ;GAE5B,MAAA/C,OAAaR,cAAayD,IAAKP,UAAU;GACzC,IAAI,CAAC1C,MAAI;GAETC,WAAW,CAAA,GAAI8C,QAAQ,GAAG;IAAAG,KACnBlD,KAAIkD;IAAIC,QACLnD,KAAIkB;IAAIkC,OACTpD,KAAIoD;IAAMC,WACNrD,KAAIqD;IAAUV;GAE3B,CAAC;EAAC;EACHlB,EAAA,KAAAjC;EAAAiC,EAAA,MAAAU;EAAAV,EAAA,MAAAY;EAAAZ,EAAA,MAAA7B;EAAA6B,EAAA,MAAAxB;EAAAwB,EAAA,MAAAW;EAAAX,EAAA,MAAAe;CAAA,OAAAA,KAAAf,EAAA;CA3CD,MAAA6B,uBAA6BzE,SAAS2D,EA2CrC;CAAE,IAAAe;CAAA,IAAA9B,EAAA,QAAA1B,cAAA;EAEyBwD,MAAAC,WAC1B,oBAAC,MAAD;GAEa,WAAAzD,aAAaC,MAAI;GAChB,YAAAA,OAAIyD;GAEf1D,UAAAA,aAAaC,MAAI;EALf,GACEA,OAAIkB,GADN;EAONO,EAAA,MAAA1B;EAAA0B,EAAA,MAAA8B;CAAA,OAAAA,KAAA9B,EAAA;CAIW,MAAAkC,KAZO9E,SAAS0E,EAYhBG;CAAiB,IAAAE;CAAA,IAAAnC,EAAA,QAAArB,aAAAqB,EAAA,QAAAG,GAAA;EASbgC,KAAAxD,aAAawB,EAAE,mBAAmB,OAAO;EAACH,EAAA,MAAArB;EAAAqB,EAAA,MAAAG;EAAAH,EAAA,MAAAmC;CAAA,OAAAA,KAAAnC,EAAA;CAAA,IAAAoC;CAAA,IAAApC,EAAA,QAAA3B,gBAAA2B,EAAA,QAAAY,yBAAAZ,EAAA,QAAA6B,wBAAA7B,EAAA,QAAAnC,SAAAmC,EAAA,QAAAkC,MAAAlC,EAAA,QAAAmC,IAAA;EAXxCC,KAAA;GAAAC,OACTxE;GAAKmE,UACFE;GAAiBI,eACZ;GAAerE,cAChB2C;GAAqB4B,kBACjBX;GAAoBxD;GAAAoE,kBAEpB;GAAcC,UAGtBC;GAAQ,cACJR;EAChB;EAACnC,EAAA,MAAA3B;EAAA2B,EAAA,MAAAY;EAAAZ,EAAA,MAAA6B;EAAA7B,EAAA,MAAAnC;EAAAmC,EAAA,MAAAkC;EAAAlC,EAAA,MAAAmC;EAAAnC,EAAA,MAAAoC;CAAA,OAAAA,KAAApC,EAAA;CAZD,MAAAlB,YAAkBsD;CAclB,MAAAQ,YAAkBzF,aAA+B2B,SAAS;CAAE,IAAAD;CAAA,IAAAgE;CAAA,IAAA7C,EAAA,QAAA4C,WAAA;EAC5D/D,QAAcM,gBAAgByD,SAAS;EAElBC,KAAAlD,MAAKC,KAAMf,MAAKO,WAAW0D,QAAS,IAAGC,UAC1DlE,MAAKO,WAAWM,QAASD,KAAG,CAC9B,CAAC,CAAAuD,OAAQC,MAA+D;EAACjD,EAAA,MAAA4C;EAAA5C,EAAA,MAAAnB;EAAAmB,EAAA,MAAA6C;CAAA,OAAA;EAAAhE,QAAAmB,EAAA;EAAA6C,KAAA7C,EAAA;CAAA;CAFzE,MAAAhB,eAAqB6D;CAEqD,IAAAK;CAAA,IAAAlD,EAAA,QAAAhB,cAAA;EAEnDkE,KAAAlE,aAAYmE,IAC5BC,MAAoB,CAAC,CAAAJ,OAClBK,MAAgD;EAACrD,EAAA,MAAAhB;EAAAgB,EAAA,MAAAkD;CAAA,OAAAA,KAAAlD,EAAA;CAF3D,MAAAf,iBAAuBiE;CAEqC,IAAAI;CAAA,IAAAtD,EAAA,QAAAlB,aAAAkB,EAAA,QAAAY,yBAAAZ,EAAA,QAAAnB,SAAAmB,EAAA,QAAAf,kBAAAe,EAAA,QAAAhB,cAAA;EAErDsE,MAAA;GAAAzE;GAAAC;GAAAE;GAAAC;GAAAhB,cAKS2C;EAChB;EAACZ,EAAA,MAAAlB;EAAAkB,EAAA,MAAAY;EAAAZ,EAAA,MAAAnB;EAAAmB,EAAA,MAAAf;EAAAe,EAAA,MAAAhB;EAAAgB,EAAA,MAAAsD;CAAA,OAAAA,MAAAtD,EAAA;CAAA,OANMsD;AAMN;AAnHI,SAAAD,OAAAE,QAAA;CAAA,OA2GyChF,UAAQ;AAAI;AA3GrD,SAAA6E,OAAAI,QAAA;CAAA,OA0GYjF,OAAIkF;AAAM;AA1GtB,SAAAR,OAAAS,QAAA;CAAA,OAuG8CnF,QAAIoF,SAAW;AAAM;AAvGnE,SAAAhB,QAAA,CAAA"}

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

@@ -1,6 +1,5 @@
 
 import { FieldBaseProps, ToggleSelectionProps } from "../../../shared/form.js";
-import "../../../shared/index.js";
 import { CubeTooltipProviderProps } from "../../overlays/Tooltip/TooltipProvider.js";
 import { FieldLayoutStyleProps } from "../../form/field-layout.js";
 import { CheckboxGroup as _CheckboxGroup, CubeCheckboxGroupProps } from "./CheckboxGroup.js";

package/dist/components/fields/Checkbox/Checkbox.js

@@ -1,17 +1,17 @@
-/** @license MIT | @cube-dev/ui-kit v0.206.3 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.208.0 | Cube Dev Team */
 import { mergeProps as mergeProps$1 } from "../../../utils/react/mergeProps.js";
-import { getDisabledElementProps, getInertInputProps } from "../../../utils/react/disabledProps.js";
 import { mergeRefs } from "../../../utils/react/useCombinedRefs.js";
 import { useFocus as useFocus$1 } from "../../../utils/react/interactions.js";
 import { useAutoTooltip } from "../../content/use-auto-tooltip.js";
 import { Icon } from "../../../icons/Icon.js";
+import { getDisabledElementProps, getInertInputProps } from "../../../utils/react/disabledProps.js";
 import { mergeTooltipFocusProps, splitTooltipTriggerProps } from "../../overlays/Tooltip/split-trigger-props.js";
 import { castNullableIsSelected } from "../../../utils/react/nullableValue.js";
 import { getValidationMods, resolveValidationProps } from "../../form/validation/resolve-validation-props.js";
 import { INLINE_LABEL_STYLES, LABEL_STYLES } from "../../form/Label.js";
-import { useFieldProps } from "../../form/Form/use-field/use-field-props.js";
 import { wrapWithField } from "../../form/wrapper.js";
 import { splitFieldLayout } from "../../form/field-layout.js";
+import { useFieldProps } from "../../form/Form/use-field/use-field-props.js";
 import { HiddenInput } from "../../HiddenInput.js";
 import { CheckboxGroupContext } from "./context.js";
 import { CheckboxGroup as _CheckboxGroup } from "./CheckboxGroup.js";