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

package/dist/components/data/TableBase/types.d.ts

@@ -1,161 +0,0 @@
-
-import "../../content/Item/index.js";
-import { CubeItemProps } from "../../content/Item/Item.js";
-import { Styles } from "@tenphi/tasty";
-import { ReactNode } from "react";
-import { Key as Key$1 } from "@react-types/shared";
-
-//#region src/components/data/TableBase/types.d.ts
-type CubeTableSortDirection = 'asc' | 'desc';
-type CubeTableAlign = 'start' | 'center' | 'end';
-type CubeTableRowSection = 'body' | 'pinnedTop' | 'pinnedBottom';
-/**
- * `asc | desc` rather than React Aria's `ascending | descending`: we do not use
- * `useTableState`, so there is no `SortDescriptor` interop to preserve, and
- * every consumer and server query parameter already speaks `asc|desc`.
- * `aria-sort` is a one-line map in the header cell.
- */
-/**
- * A rectangular block of cells, stored as two opposite corners.
- *
- * Corners rather than a set of keys so the selection survives a re-sort or a
- * page change the way a keyed row selection does: "the block between these two
- * cells" is re-resolved against the current order every render.
- */
-interface CubeTableCellRange {
-  fromRowKey: Key$1;
-  toRowKey: Key$1;
-  fromColumnKey: string;
-  toColumnKey: string;
-}
-interface CubeTableSort {
-  /** `key` of the sorted column. */
-  columnKey: string;
-  direction: CubeTableSortDirection;
-}
-interface CubeTableCellContext<T = any> {
-  row: T;
-  rowKey: Key$1;
-  rowIndex: number;
-  columnKey: string;
-  columnIndex: number;
-  section: CubeTableRowSection;
-  isSelected: boolean;
-  isRowFocused: boolean;
-  isDropTarget: boolean;
-}
-interface CubeTableRowContext<T = any> {
-  row: T;
-  rowKey: Key$1;
-  rowIndex: number;
-  section: CubeTableRowSection;
-  isSelected: boolean;
-  isFocused: boolean;
-  isDropTarget: boolean;
-}
-interface CubeTableHeaderContext {
-  columnKey: string;
-  columnIndex: number;
-  sort: CubeTableSortDirection | null;
-  isSortable: boolean;
-  isResizing: boolean;
-  width: number | null;
-}
-/**
- * Rich header content. Every slot maps 1:1 onto the `Item` rendered inside the
- * header `<th>`, so a header gets icon / description / tooltip / suffix /
- * actions for free.
- */
-interface CubeTableColumnHeader {
-  icon?: CubeItemProps['icon'];
-  rightIcon?: CubeItemProps['rightIcon'];
-  prefix?: ReactNode;
-  suffix?: ReactNode;
-  description?: ReactNode;
-  descriptionPlacement?: CubeItemProps['descriptionPlacement'];
-  /** `true` = auto tooltip when the label is truncated. */
-  tooltip?: CubeItemProps['tooltip'];
-  actions?: ReactNode;
-  /** Hide `actions` until hover/focus. @default true */
-  autoHideActions?: boolean;
-  theme?: CubeItemProps['theme'];
-  /** Full takeover of the header cell's content. Overrides `title` and every slot. */
-  render?: (ctx: CubeTableHeaderContext) => ReactNode;
-  /** Overrides `column.align` for the header only. */
-  align?: CubeTableAlign;
-  styles?: Styles;
-}
-interface CubeTableColumn<T = any> {
-  /**
-   * Column id. Also the default data path — dot notation is supported
-   * (`'owner.name'`). Anything beyond a path needs `getValue`.
-   */
-  key: string;
-  /** Header label. Shorthand for `header` with no extra slots. */
-  title?: ReactNode;
-  header?: CubeTableColumnHeader;
-  /**
-   * Renders `<th scope="row">` instead of `<td>`, names the row for screen
-   * readers, and hosts the `rowLink` anchor. Defaults to the first
-   * non-structural column when a row link is present.
-   */
-  isRowHeader?: boolean;
-  /** Fixed width in px. Mutually exclusive with `flex`. */
-  width?: number;
-  /** Weight for the leftover space. @default 1 when `width` is unset */
-  flex?: number;
-  /** @default 150 */
-  minWidth?: number;
-  maxWidth?: number;
-  /** Inherits the table's `isResizable`. */
-  isResizable?: boolean;
-  /** Stick to the start/end edge during horizontal scroll. */
-  pin?: 'start' | 'end';
-  /** Hide without losing width or order state. */
-  isHidden?: boolean;
-  /** @default (row) => get(row, key) */
-  getValue?: (row: T, rowIndex: number) => unknown;
-  /** Raw value → display text. Feeds client sort, client search and TSV copy. */
-  format?: (value: any, row: T, rowIndex: number) => string;
-  /** Client-side comparator over raw `getValue` results. */
-  compare?: (a: any, b: any, rowA: T, rowB: T) => number;
-  /** A returned string is wrapped in a truncating `TextItem`. */
-  render?: (value: any, row: T, rowIndex: number, ctx: CubeTableCellContext<T>) => ReactNode;
-  cellStyles?: Styles | ((ctx: CubeTableCellContext<T>) => Styles | undefined);
-  cellProps?: (ctx: CubeTableCellContext<T>) => Record<string, any> | undefined;
-  align?: CubeTableAlign;
-  /** @default true unless the table's `sortMode` is `'off'` */
-  isSortable?: boolean;
-  /** Two-state cycling (asc ↔ desc), never back to unsorted. @default false */
-  disallowSortRemoval?: boolean;
-  /** Include in the built-in client search. @default true */
-  isSearchable?: boolean;
-  /** Include in TSV copy. @default true */
-  isCopyable?: boolean;
-  /** Wrap text and let the row grow to fit. */
-  autoHeight?: boolean;
-  /** Consumer-owned bag. Never reaches the DOM. */
-  meta?: Record<string, unknown>;
-}
-/**
- * How a refresh over an existing result is presented.
- *
- * - `overlay` — keep the previous rows visible, dimmed, behind a spinner. A
- *   server page or a re-sort never blanks the table.
- * - `skeleton` — discard the previous rows and show placeholders.
- * - `none` — no visuals beyond `aria-busy`; the page owns the indicator.
- */
-type CubeTableLoadingIndicator = 'overlay' | 'skeleton' | 'none';
-type CubeTableSelectionMode = 'none' | 'single' | 'multiple';
-/**
- * What the header checkbox acts on.
- *
- * - `page` — the rows on the current page.
- * - `filtered` — every row passing the current search/filter, across pages.
- * - `all` — emits the `'all'` sentinel, meaning "everything, including rows the
- *   client has not loaded". The consumer decides what that means for its query.
- */
-type CubeTableSelectAllMode = 'page' | 'filtered' | 'all';
-//#endregion
-export { CubeTableAlign, CubeTableCellContext, CubeTableCellRange, CubeTableColumn, CubeTableColumnHeader, CubeTableHeaderContext, CubeTableLoadingIndicator, CubeTableRowContext, CubeTableRowSection, CubeTableSelectAllMode, CubeTableSelectionMode, CubeTableSort, CubeTableSortDirection };
-//# sourceMappingURL=types.d.ts.map

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

@@ -1,3 +0,0 @@
-
-import "./types.js";
-import { Key as Key$1 } from "@react-types/shared";

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

@@ -1 +0,0 @@
-{"version":3,"file":"use-cell-selection.js","names":[],"sources":["../../../../src/components/data/TableBase/use-cell-selection.ts"],"sourcesContent":["import { useControlledState } from '@react-stately/utils';\nimport { useCallback, useMemo, useRef } from 'react';\n\nimport { useEvent } from '../../../_internal/hooks';\n\nimport type { Key } from '@react-types/shared';\nimport type { CubeResolvedColumn, CubeTableCellRange } from './types';\n\nexport type CubeTableCellSelectionMode = 'none' | 'cell' | 'range';\n\nexport interface UseCellSelectionOptions<T> {\n  /** @default 'range' */\n  mode?: CubeTableCellSelectionMode;\n  columns: CubeResolvedColumn<T>[];\n  /**\n   * Every row a range can reach, in the order they appear on screen — pinned\n   * rows included. ag-grid excludes them (`!rowNode.rowPinned`), and we do not:\n   * a total is a figure like any other, and selecting a column of revenue only\n   * to have to copy its sum separately is the wrong trade.\n   *\n   * A pinned row is still not reachable by dragging THROUGH it — see\n   * `TableView`'s pointer handlers for why.\n   */\n  rows: readonly T[];\n  /**\n   * Parallel to `rows`. Supplied rather than derived, so it cannot disagree with\n   * the keys the renderer stamps on the cells — when the two drifted, every\n   * range silently resolved to nothing.\n   */\n  rowKeys: readonly Key[];\n  /**\n   * Vetoes individual cells. A pinned total's label cell is the motivating\n   * case: \"Total\" is a caption for the row, not a figure, and there is nothing\n   * useful to do with it selected.\n   *\n   * A vetoed cell cannot anchor or receive a range, never highlights, and copies\n   * as an empty field so a block spanning it keeps its shape.\n   */\n  isCellSelectable?: (row: T, rowKey: Key, columnKey: string) => boolean;\n  range?: CubeTableCellRange | null;\n  defaultRange?: CubeTableCellRange | null;\n  onRangeChange?: (range: CubeTableCellRange | null) => void;\n}\n\nconst cellKey = (rowKey: Key, columnKey: string) => `${rowKey}\u0000${columnKey}`;\n\n/**\n * Rectangular cell selection.\n *\n * A result grid is read by cell, not by row: the thing a user wants out of it is\n * a figure, or a block of figures to paste somewhere else. So a click selects a\n * cell, shift-click and drag grow a rectangle, and ⌘/Ctrl+C writes the rectangle\n * out as TSV.\n *\n * The range is stored as two corners rather than a set of keys, so it survives\n * sorting and paging the way a keyed row selection does — and normalizing it\n * against the CURRENT row and column order is what makes \"the block between\n * these two cells\" keep meaning that after a re-sort.\n *\n * Structural columns (the row number, the checkbox, the row-menu button) can\n * never enter a range: they are chrome, and copying them would put the grid's\n * own furniture into the user's spreadsheet.\n */\nexport function useCellSelection<T>({\n  mode = 'range',\n  columns,\n  rows,\n  rowKeys,\n  isCellSelectable,\n  range: rangeProp,\n  defaultRange,\n  onRangeChange,\n}: UseCellSelectionOptions<T>) {\n  const [range, setRange] = useControlledState<CubeTableCellRange | null>(\n    rangeProp as CubeTableCellRange | null,\n    defaultRange ?? null,\n    onRangeChange as (value: CubeTableCellRange | null) => void,\n  );\n\n  // The press that started a drag. A ref rather than state: it is written and\n  // read inside one pointer gesture, and re-rendering on every `pointerenter`\n  // would drop frames across a wide grid.\n  const anchorRef = useRef<CubeTableCellRange | null>(null);\n  const isDraggingRef = useRef(false);\n\n  const selectableColumns = useMemo(\n    () => columns.filter((column) => !column.isStructural),\n    [columns],\n  );\n\n  const isEnabled = mode !== 'none';\n\n  /**\n   * The range's corners resolved against the current order, as index bounds.\n   * `null` when either corner has scrolled out of the data — a range whose\n   * anchor no longer exists is not a range.\n   */\n  const bounds = useMemo(() => {\n    if (!isEnabled || !range) return null;\n\n    const rowFrom = rowKeys.indexOf(range.fromRowKey);\n    const rowTo = rowKeys.indexOf(range.toRowKey);\n    const colFrom = selectableColumns.findIndex(\n      (column) => column.key === range.fromColumnKey,\n    );\n    const colTo = selectableColumns.findIndex(\n      (column) => column.key === range.toColumnKey,\n    );\n\n    if (rowFrom === -1 || rowTo === -1 || colFrom === -1 || colTo === -1) {\n      return null;\n    }\n\n    return {\n      rowStart: Math.min(rowFrom, rowTo),\n      rowEnd: Math.max(rowFrom, rowTo),\n      colStart: Math.min(colFrom, colTo),\n      colEnd: Math.max(colFrom, colTo),\n    };\n  }, [isEnabled, range, rowKeys, selectableColumns]);\n\n  /**\n   * Every selected cell, precomputed. A range spanning a full page is tens of\n   * thousands of cells and every one of them asks whether it is selected on\n   * every render, so this has to be a lookup rather than four comparisons.\n   */\n  const selectedKeys = useMemo(() => {\n    const keys = new Set<string>();\n\n    if (!bounds) return keys;\n\n    for (let r = bounds.rowStart; r <= bounds.rowEnd; r++) {\n      for (let c = bounds.colStart; c <= bounds.colEnd; c++) {\n        const columnKey = selectableColumns[c].key;\n\n        if (isCellSelectable?.(rows[r], rowKeys[r], columnKey) === false) {\n          continue;\n        }\n\n        keys.add(cellKey(rowKeys[r], columnKey));\n      }\n    }\n\n    return keys;\n  }, [bounds, rows, rowKeys, selectableColumns, isCellSelectable]);\n\n  // `useCallback`, not `useEvent`: the renderer asks this DURING render, once\n  // per cell. `useEvent` keeps its closure current through a layout effect, so a\n  // render-time reader sees the PREVIOUS render's answer — the highlight then\n  // trails the selection by one commit and a cleared range stays painted.\n  const isSelected = useCallback(\n    (rowKey: Key, columnKey: string) =>\n      selectedKeys.has(cellKey(rowKey, columnKey)),\n    [selectedKeys],\n  );\n\n  const isSelectableColumn = useEvent((columnKey: string) =>\n    selectableColumns.some((column) => column.key === columnKey),\n  );\n\n  /**\n   * Whether a cell can take part at all — asked by the renderer before it wires\n   * up any pointer handler, so a vetoed cell is inert rather than merely\n   * unpainted.\n   */\n  const canSelectCell = useEvent((rowKey: Key, columnKey: string) => {\n    if (!isEnabled || !isSelectableColumn(columnKey)) return false;\n    if (!isCellSelectable) return true;\n\n    const index = rowKeys.indexOf(rowKey);\n\n    return index === -1 || isCellSelectable(rows[index], rowKey, columnKey);\n  });\n\n  const select = useEvent((rowKey: Key, columnKey: string) => {\n    if (!canSelectCell(rowKey, columnKey)) return;\n\n    const next: CubeTableCellRange = {\n      fromRowKey: rowKey,\n      toRowKey: rowKey,\n      fromColumnKey: columnKey,\n      toColumnKey: columnKey,\n    };\n\n    anchorRef.current = next;\n    setRange(next);\n  });\n\n  /** Grow the range from the standing anchor. Shift-click and drag both land here. */\n  const extendTo = useEvent((rowKey: Key, columnKey: string) => {\n    if (mode !== 'range' || !canSelectCell(rowKey, columnKey)) return;\n\n    // Shift-clicking with nothing selected yet behaves as a plain click, which\n    // is what every grid and every file manager does.\n    const anchor = anchorRef.current ?? range;\n\n    if (!anchor) {\n      select(rowKey, columnKey);\n\n      return;\n    }\n\n    setRange({\n      fromRowKey: anchor.fromRowKey,\n      toRowKey: rowKey,\n      fromColumnKey: anchor.fromColumnKey,\n      toColumnKey: columnKey,\n    });\n  });\n\n  const clear = useEvent(() => {\n    anchorRef.current = null;\n    if (range) setRange(null);\n  });\n\n  /**\n   * The selection as tab-separated values — the format Excel and Sheets both\n   * paste as a grid rather than as one run of text.\n   *\n   * Values come from the same display-text pipeline client sort and search use,\n   * so what lands on the clipboard is what was on screen: a formatted currency\n   * stays formatted, and a value with no text representation copies as empty\n   * rather than as `[object Object]`.\n   */\n  const getSelectionText = useEvent(\n    (\n      getText: (\n        column: CubeResolvedColumn<T>,\n        row: T,\n        rowIndex: number,\n      ) => string,\n      getHeader?: (column: CubeResolvedColumn<T>) => string,\n    ) => {\n      if (!bounds) return '';\n\n      const cols = selectableColumns.slice(bounds.colStart, bounds.colEnd + 1);\n      const lines: string[] = [];\n\n      if (getHeader) {\n        lines.push(cols.map((column) => quote(getHeader(column))).join('\\t'));\n      }\n\n      for (let r = bounds.rowStart; r <= bounds.rowEnd; r++) {\n        lines.push(\n          cols\n            .map((column) =>\n              selectedKeys.has(cellKey(rowKeys[r], column.key))\n                ? quote(getText(column, rows[r], r))\n                : '',\n            )\n            .join('\\t'),\n        );\n      }\n\n      return lines.join('\\n');\n    },\n  );\n\n  return {\n    mode,\n    isEnabled,\n    range: bounds ? range : null,\n    /** Cells in the range, for `aria-selected` and the highlight. */\n    isSelected,\n    /** `true` once the range covers more than one cell. */\n    hasRange: selectedKeys.size > 1,\n    cellCount: selectedKeys.size,\n    canSelectCell,\n    select,\n    extendTo,\n    clear,\n    getSelectionText,\n    anchorRef,\n    isDraggingRef,\n  };\n}\n\n/**\n * RFC-4180 quoting, tab-delimited.\n *\n * A value carrying a tab or a newline would otherwise break the grid apart on\n * paste — one cell becoming two, or one row becoming two.\n */\nfunction quote(value: string) {\n  if (!/[\\t\\n\\r\"]/.test(value)) return value;\n\n  return `\"${value.replace(/\"/g, '\"\"')}\"`;\n}\n"],"mappings":"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"}

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

@@ -1,35 +0,0 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-e76eb3e | Cube Dev Team */
-import { useLayoutEffect, useState } from "react";
-
-//#region src/components/data/TableBase/use-container-width.ts
-/**
-* Content-box width of the scroller, measured before paint and kept current
-* with a `ResizeObserver`.
-*
-* Takes the **element**, not a ref: in the virtualized path the scroller is
-* created by Virtuoso and handed over through a callback after mount, so a hook
-* that peeked at `ref.current` once would see `null` and never measure
-* anything — leaving every column unsized.
-*
-* `useLayoutEffect` rather than `useEffect` on purpose: column widths are
-* derived from this value, so measuring after paint would show one frame of
-* min-width columns before they snap to their real size.
-*/
-function useContainerWidth(element) {
-	const [width, setWidth] = useState(null);
-	useLayoutEffect(() => {
-		if (!element || !(element instanceof Element)) return;
-		const measure = () => {
-			setWidth((current) => current === element.clientWidth ? current : element.clientWidth);
-		};
-		measure();
-		const observer = new ResizeObserver(measure);
-		observer.observe(element);
-		return () => observer.disconnect();
-	}, [element]);
-	return width;
-}
-
-//#endregion
-export { useContainerWidth };
-//# sourceMappingURL=use-container-width.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"use-container-width.js","names":[],"sources":["../../../../src/components/data/TableBase/use-container-width.ts"],"sourcesContent":["import { useLayoutEffect, useState } from 'react';\n\n/**\n * Content-box width of the scroller, measured before paint and kept current\n * with a `ResizeObserver`.\n *\n * Takes the **element**, not a ref: in the virtualized path the scroller is\n * created by Virtuoso and handed over through a callback after mount, so a hook\n * that peeked at `ref.current` once would see `null` and never measure\n * anything — leaving every column unsized.\n *\n * `useLayoutEffect` rather than `useEffect` on purpose: column widths are\n * derived from this value, so measuring after paint would show one frame of\n * min-width columns before they snap to their real size.\n */\nexport function useContainerWidth(element: HTMLElement | null): number | null {\n  const [width, setWidth] = useState<number | null>(null);\n\n  useLayoutEffect(() => {\n    // Virtuoso's `scrollerRef` reports `HTMLElement | Window | null`, and\n    // `ResizeObserver.observe` throws on anything that is not an Element.\n    if (!element || !(element instanceof Element)) return;\n\n    const measure = () => {\n      // `clientWidth` excludes the vertical scrollbar, which is what we want:\n      // the columns must fit the content box, not the border box, or a\n      // scrollbar appearing would push the last column out and bring a\n      // horizontal scrollbar with it.\n      setWidth((current) =>\n        current === element.clientWidth ? current : element.clientWidth,\n      );\n    };\n\n    measure();\n\n    const observer = new ResizeObserver(measure);\n\n    observer.observe(element);\n\n    return () => observer.disconnect();\n  }, [element]);\n\n  return width;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAeA,SAAgB,kBAAkB,SAA4C;CAC5E,MAAM,CAAC,OAAO,YAAY,SAAwB,KAAK;AAEvD,uBAAsB;AAGpB,MAAI,CAAC,WAAW,EAAE,mBAAmB,SAAU;EAE/C,MAAM,gBAAgB;AAKpB,aAAU,YACR,YAAY,QAAQ,cAAc,UAAU,QAAQ,YACrD;;AAGH,WAAS;EAET,MAAM,WAAW,IAAI,eAAe,QAAQ;AAE5C,WAAS,QAAQ,QAAQ;AAEzB,eAAa,SAAS,YAAY;IACjC,CAAC,QAAQ,CAAC;AAEb,QAAO"}

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

@@ -1,49 +0,0 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-e76eb3e | Cube Dev Team */
-import { useLayoutEffect, useState } from "react";
-
-//#region src/components/data/TableBase/use-scrollability.ts
-const NONE = {
-	x: false,
-	y: false
-};
-/**
-* Whether the scroller can actually scroll, per axis.
-*
-* This exists for `overscroll-behavior`. `contain` is what stops a horizontal
-* swipe at the scroll edge from triggering browser back-navigation, but Chrome
-* applies it to any element with `overflow: auto` — including one whose content
-* fits. The wheel event is then swallowed by a scroller with nothing to scroll,
-* and the page behind it will not move. So the containment has to be scoped to
-* the axis that is genuinely scrollable, which means measuring.
-*
-* Both the scroller and its content are observed: the scroller's own box does
-* not change when rows are added, so observing it alone would miss a table that
-* grew past its container.
-*/
-function useScrollability(element) {
-	const [state, setState] = useState(NONE);
-	useLayoutEffect(() => {
-		if (!element || !(element instanceof Element)) {
-			setState(NONE);
-			return;
-		}
-		const measure = () => {
-			const next = {
-				x: element.scrollWidth - element.clientWidth > 1,
-				y: element.scrollHeight - element.clientHeight > 1
-			};
-			setState((current) => current.x === next.x && current.y === next.y ? current : next);
-		};
-		measure();
-		const observer = new ResizeObserver(measure);
-		observer.observe(element);
-		const content = element.firstElementChild;
-		if (content) observer.observe(content);
-		return () => observer.disconnect();
-	}, [element]);
-	return state;
-}
-
-//#endregion
-export { useScrollability };
-//# sourceMappingURL=use-scrollability.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"use-scrollability.js","names":[],"sources":["../../../../src/components/data/TableBase/use-scrollability.ts"],"sourcesContent":["import { useLayoutEffect, useState } from 'react';\n\nexport interface CubeScrollability {\n  x: boolean;\n  y: boolean;\n}\n\nconst NONE: CubeScrollability = { x: false, y: false };\n\n/**\n * Whether the scroller can actually scroll, per axis.\n *\n * This exists for `overscroll-behavior`. `contain` is what stops a horizontal\n * swipe at the scroll edge from triggering browser back-navigation, but Chrome\n * applies it to any element with `overflow: auto` — including one whose content\n * fits. The wheel event is then swallowed by a scroller with nothing to scroll,\n * and the page behind it will not move. So the containment has to be scoped to\n * the axis that is genuinely scrollable, which means measuring.\n *\n * Both the scroller and its content are observed: the scroller's own box does\n * not change when rows are added, so observing it alone would miss a table that\n * grew past its container.\n */\nexport function useScrollability(\n  element: HTMLElement | null,\n): CubeScrollability {\n  const [state, setState] = useState<CubeScrollability>(NONE);\n\n  useLayoutEffect(() => {\n    // Matches `useContainerWidth`: a scroller handed over by a callback ref can\n    // be null, and `observe` throws on anything that is not an Element.\n    if (!element || !(element instanceof Element)) {\n      setState(NONE);\n\n      return;\n    }\n\n    const measure = () => {\n      // A 1px tolerance: sub-pixel layout regularly leaves `scrollHeight` a\n      // fraction above `clientHeight` on a table that visibly does not scroll,\n      // and trapping the wheel over that fraction is the exact bug this avoids.\n      const next = {\n        x: element.scrollWidth - element.clientWidth > 1,\n        y: element.scrollHeight - element.clientHeight > 1,\n      };\n\n      setState((current) =>\n        current.x === next.x && current.y === next.y ? current : next,\n      );\n    };\n\n    measure();\n\n    const observer = new ResizeObserver(measure);\n\n    observer.observe(element);\n\n    const content = element.firstElementChild;\n\n    if (content) observer.observe(content);\n\n    return () => observer.disconnect();\n  }, [element]);\n\n  return state;\n}\n"],"mappings":";;;;AAOA,MAAM,OAA0B;CAAE,GAAG;CAAO,GAAG;CAAO;;;;;;;;;;;;;;;AAgBtD,SAAgB,iBACd,SACmB;CACnB,MAAM,CAAC,OAAO,YAAY,SAA4B,KAAK;AAE3D,uBAAsB;AAGpB,MAAI,CAAC,WAAW,EAAE,mBAAmB,UAAU;AAC7C,YAAS,KAAK;AAEd;;EAGF,MAAM,gBAAgB;GAIpB,MAAM,OAAO;IACX,GAAG,QAAQ,cAAc,QAAQ,cAAc;IAC/C,GAAG,QAAQ,eAAe,QAAQ,eAAe;IAClD;AAED,aAAU,YACR,QAAQ,MAAM,KAAK,KAAK,QAAQ,MAAM,KAAK,IAAI,UAAU,KAC1D;;AAGH,WAAS;EAET,MAAM,WAAW,IAAI,eAAe,QAAQ;AAE5C,WAAS,QAAQ,QAAQ;EAEzB,MAAM,UAAU,QAAQ;AAExB,MAAI,QAAS,UAAS,QAAQ,QAAQ;AAEtC,eAAa,SAAS,YAAY;IACjC,CAAC,QAAQ,CAAC;AAEb,QAAO"}

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

@@ -1,2 +0,0 @@
-
-import "./types.js";

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

@@ -1,166 +0,0 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-e76eb3e | Cube Dev Team */
-import { useMemo } from "react";
-
-//#region src/components/data/TableBase/use-table-columns.ts
-/** @default when a column declares neither `width` nor `minWidth`. */
-const DEFAULT_MIN_WIDTH = 150;
-/**
-* Reads `key` as a data path. A plain key is a single property lookup; dots
-* walk nested objects (`'owner.name'`). Anything richer belongs in `getValue`.
-*/
-function readPath(row, path) {
-	if (row == null) return void 0;
-	if (!path.includes(".")) return row[path];
-	let current = row;
-	for (const part of path.split(".")) {
-		if (current == null) return void 0;
-		current = current[part];
-	}
-	return current;
-}
-function getColumnValue(column, row, rowIndex) {
-	return column.getValue ? column.getValue(row, rowIndex) : readPath(row, column.key);
-}
-/**
-* Display text for a cell — what client sort, client search and TSV copy all
-* operate on. Deliberately NOT the rendered output: `render` may return
-* arbitrary React, and stringifying that is how cloud's filter ended up
-* matching `"[object Object]"` against the query `"object"`.
-*
-* Returns `null` when the column cannot produce text, so callers can skip it
-* rather than coerce a non-primitive.
-*/
-function getColumnText(column, row, rowIndex) {
-	const value = getColumnValue(column, row, rowIndex);
-	if (column.format) return column.format(value, row, rowIndex);
-	if (value == null) return "";
-	const type = typeof value;
-	if (type === "string") return value;
-	if (type === "number" || type === "boolean" || type === "bigint") return String(value);
-	if (value instanceof Date) return value.toISOString();
-	return null;
-}
-function clamp(value, min, max) {
-	return Math.min(Math.max(value, min), max ?? Number.POSITIVE_INFINITY);
-}
-/**
-* Normalizes the public column list into resolved leaves: visual order, ARIA
-* indices, pixel widths, and sticky offsets for pinned columns.
-*
-* Width resolution mirrors ag-grid's `fitGridWidth`: fixed columns take their
-* width, the remainder is split across flex columns by weight, and each result
-* is clamped to `[minWidth, maxWidth]`. Clamping perturbs the sum, so the
-* residual is redistributed across the still-unclamped columns until it
-* settles. When even the minimums do not fit, every column takes its minimum
-* and the table scrolls horizontally.
-*/
-function useTableColumns({ columns, containerWidth, columnWidths, leadingColumns, trailingColumns }) {
-	return useMemo(() => {
-		const visible = [
-			...leadingColumns ?? [],
-			...columns,
-			...trailingColumns ?? []
-		].filter((column) => !column.isHidden);
-		const ordered = [
-			...visible.filter((c) => c.pin === "start"),
-			...visible.filter((c) => !c.pin),
-			...visible.filter((c) => c.pin === "end")
-		];
-		const structuralKeys = new Set([...leadingColumns ?? [], ...trailingColumns ?? []].map((c) => c.key));
-		const specs = ordered.map((column) => {
-			const isStructural = structuralKeys.has(column.key);
-			const explicit = columnWidths?.[column.key] ?? column.width;
-			const minWidth = column.minWidth ?? (explicit != null ? explicit : isStructural ? 0 : DEFAULT_MIN_WIDTH);
-			return {
-				column,
-				isStructural,
-				fixed: explicit ?? null,
-				minWidth,
-				maxWidth: column.maxWidth ?? null,
-				flex: explicit != null ? null : column.flex ?? 1
-			};
-		});
-		const resolved = /* @__PURE__ */ new Map();
-		let isOverflowing = false;
-		if (containerWidth != null && containerWidth > 0) {
-			const fixedTotal = specs.reduce((sum, s) => sum + (s.fixed ?? 0), 0);
-			const flexSpecs = specs.filter((s) => s.fixed == null);
-			if (specs.reduce((sum, s) => sum + (s.fixed ?? s.minWidth), 0) > containerWidth) {
-				isOverflowing = true;
-				for (const spec of specs) resolved.set(spec.column.key, spec.fixed ?? spec.minWidth);
-			} else {
-				let remaining = containerWidth - fixedTotal;
-				let pool = flexSpecs;
-				while (pool.length > 0) {
-					const totalFlex = pool.reduce((sum, s) => sum + (s.flex ?? 1), 0);
-					const nextPool = [];
-					let consumed = 0;
-					for (const spec of pool) {
-						const ideal = remaining * (spec.flex ?? 1) / (totalFlex || 1);
-						const clamped = clamp(ideal, spec.minWidth, spec.maxWidth);
-						if (clamped !== ideal) {
-							resolved.set(spec.column.key, clamped);
-							consumed += clamped;
-						} else nextPool.push(spec);
-					}
-					if (nextPool.length === pool.length) {
-						const totalLeft = nextPool.reduce((sum, s) => sum + (s.flex ?? 1), 0);
-						for (const spec of nextPool) resolved.set(spec.column.key, remaining * (spec.flex ?? 1) / (totalLeft || 1));
-						break;
-					}
-					remaining -= consumed;
-					pool = nextPool;
-				}
-				for (const spec of specs) if (spec.fixed != null) resolved.set(spec.column.key, spec.fixed);
-			}
-		}
-		let pinnedStartWidth = 0;
-		let pinnedEndWidth = 0;
-		const out = specs.map((spec, index) => ({
-			...spec.column,
-			index,
-			ariaColIndex: index + 1,
-			width: resolved.get(spec.column.key) ?? null,
-			minWidth: spec.minWidth,
-			maxWidth: spec.maxWidth,
-			flex: spec.flex,
-			align: spec.column.align ?? "start",
-			pinOffset: null,
-			isPinEdge: false,
-			isStructural: spec.isStructural
-		}));
-		for (const column of out) {
-			if (column.pin !== "start") continue;
-			column.pinOffset = pinnedStartWidth;
-			pinnedStartWidth += column.width ?? column.minWidth;
-		}
-		for (let i = out.length - 1; i >= 0; i--) {
-			const column = out[i];
-			if (column.pin !== "end") continue;
-			column.pinOffset = pinnedEndWidth;
-			pinnedEndWidth += column.width ?? column.minWidth;
-		}
-		const lastPinnedStart = out.filter((c) => c.pin === "start").at(-1);
-		const firstPinnedEnd = out.find((c) => c.pin === "end");
-		if (lastPinnedStart) lastPinnedStart.isPinEdge = true;
-		if (firstPinnedEnd) firstPinnedEnd.isPinEdge = true;
-		const totalWidth = out.every((c) => c.width != null) ? out.reduce((sum, c) => sum + (c.width ?? 0), 0) : null;
-		return {
-			columns: out,
-			pinnedStartWidth,
-			pinnedEndWidth,
-			totalWidth,
-			isOverflowing
-		};
-	}, [
-		columns,
-		containerWidth,
-		columnWidths,
-		leadingColumns,
-		trailingColumns
-	]);
-}
-
-//#endregion
-export { getColumnText, getColumnValue, useTableColumns };
-//# sourceMappingURL=use-table-columns.js.map

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

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

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"use-table-search.js","names":[],"sources":["../../../../src/components/data/TableBase/use-table-search.ts"],"sourcesContent":["import { useControlledState } from '@react-stately/utils';\nimport { useMemo } from 'react';\n\nimport { useDebouncedValue, useEvent } from '../../../_internal/hooks';\n\nimport { getColumnText } from './use-table-columns';\n\nimport type { CubeTableColumn } from './types';\n\nexport type CubeTableSearchMode = 'client' | 'server';\n\nexport interface UseTableSearchOptions<T> {\n  columns: CubeTableColumn<T>[];\n  rows: readonly T[];\n  /** @default 'client' */\n  mode?: CubeTableSearchMode;\n  value?: string;\n  defaultValue?: string;\n  onChange?: (value: string) => void;\n  /** Debounces the filter AND the callback, in both modes. @default 500 */\n  delay?: number;\n  /** Replaces the default matcher in client mode. */\n  filter?: (row: T, query: string) => boolean;\n}\n\nexport interface UseTableSearchResult<T> {\n  /** The immediate term — what the input shows. */\n  searchValue: string;\n  setSearchValue: (value: string) => void;\n  /** The debounced term — what the filter and the callback act on. */\n  query: string;\n  /** Filtered in client mode; the original array otherwise. */\n  searchedRows: readonly T[];\n  /** `true` when a non-empty term is narrowing the data. */\n  isFiltered: boolean;\n}\n\n/**\n * Default matcher: a case-insensitive substring test against each searchable\n * column's **display text**.\n *\n * Deliberately not the raw value. Cloud's filter tested\n * `String(row[column.key])`, which meant a column rendering `owner.profile.name`\n * was unsearchable, and an object-valued column stringified to\n * `\"[object Object]\"` — so the query \"object\" matched every row with a nested\n * value. `getColumnText` returns `null` for anything it cannot honestly turn\n * into text, and those columns are skipped rather than coerced.\n */\nfunction defaultMatcher<T>(\n  columns: CubeTableColumn<T>[],\n  row: T,\n  rowIndex: number,\n  query: string,\n): boolean {\n  return columns.some((column) => {\n    if (column.isSearchable === false) return false;\n\n    const text = getColumnText(column, row, rowIndex);\n\n    return text != null && text.toLowerCase().includes(query);\n  });\n}\n\nexport function useTableSearch<T>({\n  columns,\n  rows,\n  mode = 'client',\n  value,\n  defaultValue,\n  onChange,\n  delay = 500,\n  filter,\n}: UseTableSearchOptions<T>): UseTableSearchResult<T> {\n  const [searchValue, setSearchState] = useControlledState<string>(\n    value as string,\n    defaultValue ?? '',\n    onChange as (v: string) => void,\n  );\n\n  // The input stays immediate; only the work is debounced. Cloud debounced the\n  // server callback but ran the client filter on every keystroke.\n  const query = useDebouncedValue(searchValue, delay).trim().toLowerCase();\n\n  const setSearchValue = useEvent((next: string) => setSearchState(next));\n\n  const searchedRows = useMemo(() => {\n    if (mode !== 'client' || !query) return rows;\n\n    return rows.filter((row, index) =>\n      filter ? filter(row, query) : defaultMatcher(columns, row, index, query),\n    );\n  }, [mode, query, rows, columns, filter]);\n\n  return {\n    searchValue,\n    setSearchValue,\n    query,\n    searchedRows,\n    isFiltered: query.length > 0,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAgDA,SAAS,eACP,SACA,KACA,UACA,OACS;AACT,QAAO,QAAQ,MAAM,WAAW;AAC9B,MAAI,OAAO,iBAAiB,MAAO,QAAO;EAE1C,MAAM,OAAO,cAAc,QAAQ,KAAK,SAAS;AAEjD,SAAO,QAAQ,QAAQ,KAAK,aAAa,CAAC,SAAS,MAAM;GACzD;;AAGJ,SAAgB,eAAkB,EAChC,SACA,MACA,OAAO,UACP,OACA,cACA,UACA,QAAQ,KACR,UACoD;CACpD,MAAM,CAAC,aAAa,kBAAkB,mBACpC,OACA,gBAAgB,IAChB,SACD;CAID,MAAM,QAAQ,kBAAkB,aAAa,MAAM,CAAC,MAAM,CAAC,aAAa;AAYxE,QAAO;EACL;EACA,gBAZqB,UAAU,SAAiB,eAAe,KAAK,CAAC;EAarE;EACA,cAZmB,cAAc;AACjC,OAAI,SAAS,YAAY,CAAC,MAAO,QAAO;AAExC,UAAO,KAAK,QAAQ,KAAK,UACvB,SAAS,OAAO,KAAK,MAAM,GAAG,eAAe,SAAS,KAAK,OAAO,MAAM,CACzE;KACA;GAAC;GAAM;GAAO;GAAM;GAAS;GAAO,CAAC;EAOtC,YAAY,MAAM,SAAS;EAC5B"}

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

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