@rio-cloud/rio-uikit 2.2.1 → 2.3.0-beta.2

package/components/table/render/header/resolveHeaderCellStyle.js

@@ -0,0 +1,9 @@
+const t = (r, a, e) => ({
+  gridColumn: `${r.columnStart + (a ? 1 : 0)} / span ${r.colSpan}`,
+  gridRow: `${r.rowStart} / span ${r.rowSpan}`,
+  ...e
+});
+export {
+  t as resolveHeaderCellStyle
+};
+//# sourceMappingURL=resolveHeaderCellStyle.js.map

package/components/table/render/header/resolveHeaderCellStyle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveHeaderCellStyle.js","sources":["../../../../../src/components/table/render/header/resolveHeaderCellStyle.ts"],"sourcesContent":["import type { CSSProperties } from 'react';\n\nimport type { TableRowData } from '../../Table.types';\nimport type { HeaderColumn } from './TableHeader.types';\n\nexport const resolveHeaderCellStyle = (\n    column: HeaderColumn<TableRowData>,\n    showSelectionColumn?: boolean,\n    extraStyle?: CSSProperties\n) => ({\n    gridColumn: `${column.columnStart + (showSelectionColumn ? 1 : 0)} / span ${column.colSpan}`,\n    gridRow: `${column.rowStart} / span ${column.rowSpan}`,\n    ...extraStyle,\n});\n"],"names":["resolveHeaderCellStyle","column","showSelectionColumn","extraStyle"],"mappings":"AAKO,MAAMA,IAAyB,CAClCC,GACAC,GACAC,OACE;AAAA,EACF,YAAY,GAAGF,EAAO,eAAeC,IAAsB,IAAI,EAAE,WAAWD,EAAO,OAAO;AAAA,EAC1F,SAAS,GAAGA,EAAO,QAAQ,WAAWA,EAAO,OAAO;AAAA,EACpD,GAAGE;AACP;"}

package/components/table/runtime/shouldAnimateBodyRows.d.ts

@@ -0,0 +1,17 @@
+import { TableExpandedRowAnimation, TableRowAnimationProps, TableRowData } from '../Table.types';
+type ShouldAnimateBodyRowsOptions<RowType extends TableRowData> = {
+    rowAnimationProps?: TableRowAnimationProps<RowType>;
+    expandedRowAnimation?: TableExpandedRowAnimation;
+    hasExpandableRows?: boolean;
+    hasExpandedRows?: boolean;
+};
+/**
+ * Body rows only animate when the consumer explicitly opted into row animations
+ * or when expanded-row animations are enabled.
+ *
+ * Expanded rows need AnimatePresence to stay mounted before the first row is
+ * opened. Otherwise the first expanded row would mount together with the
+ * presence wrapper and skip its enter animation.
+ */
+export declare const shouldAnimateBodyRows: <RowType extends TableRowData>(options: ShouldAnimateBodyRowsOptions<RowType>) => boolean;
+export {};

package/components/table/runtime/shouldAnimateBodyRows.js

@@ -0,0 +1,5 @@
+const r = (e) => e.rowAnimationProps ? !0 : e.expandedRowAnimation === !1 ? !1 : e.hasExpandableRows === !0 || e.hasExpandedRows === !0;
+export {
+  r as shouldAnimateBodyRows
+};
+//# sourceMappingURL=shouldAnimateBodyRows.js.map

package/components/table/runtime/shouldAnimateBodyRows.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shouldAnimateBodyRows.js","sources":["../../../../src/components/table/runtime/shouldAnimateBodyRows.ts"],"sourcesContent":["import type { TableExpandedRowAnimation, TableRowAnimationProps, TableRowData } from '../Table.types';\n\ntype ShouldAnimateBodyRowsOptions<RowType extends TableRowData> = {\n    rowAnimationProps?: TableRowAnimationProps<RowType>;\n    expandedRowAnimation?: TableExpandedRowAnimation;\n    hasExpandableRows?: boolean;\n    hasExpandedRows?: boolean;\n};\n\n/**\n * Body rows only animate when the consumer explicitly opted into row animations\n * or when expanded-row animations are enabled.\n *\n * Expanded rows need AnimatePresence to stay mounted before the first row is\n * opened. Otherwise the first expanded row would mount together with the\n * presence wrapper and skip its enter animation.\n */\nexport const shouldAnimateBodyRows = <RowType extends TableRowData>(options: ShouldAnimateBodyRowsOptions<RowType>) => {\n    if (options.rowAnimationProps) {\n        return true;\n    }\n\n    if (options.expandedRowAnimation === false) {\n        return false;\n    }\n\n    return options.hasExpandableRows === true || options.hasExpandedRows === true;\n};\n"],"names":["shouldAnimateBodyRows","options"],"mappings":"AAiBO,MAAMA,IAAwB,CAA+BC,MAC5DA,EAAQ,oBACD,KAGPA,EAAQ,yBAAyB,KAC1B,KAGJA,EAAQ,sBAAsB,MAAQA,EAAQ,oBAAoB;"}

package/components/table/runtime/useRenderDraftState.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode, RefObject } from 'react';
+import { RenderBodyRow, RenderHeaderColumn, TableRenderDraft } from '../context/TableRenderContext';
+import { TableRowData } from '../Table.types';
+export type UseRenderDraftStateReturn<RowType extends TableRowData> = {
+    renderHeaderColumns: RenderHeaderColumn<RowType>[];
+    renderBodyRows: RenderBodyRow<RowType>[];
+    renderBodyMaxHeight?: string;
+    renderHasFooter: boolean;
+    renderHasFooterCells?: boolean;
+    renderHasExpandableRows?: boolean;
+    renderBodyRow: (row: RenderBodyRow<RowType>) => ReactNode;
+};
+export declare const useRenderDraftState: <RowType extends TableRowData>(renderDraftRef: RefObject<TableRenderDraft<RowType>>) => UseRenderDraftStateReturn<RowType>;
+export default useRenderDraftState;

package/components/table/runtime/useRenderDraftState.js

@@ -0,0 +1,80 @@
+import { useRef as v, useState as f, useLayoutEffect as B, useCallback as M } from "react";
+const h = (o) => `${o.kind}-${String(o.rowId)}`, S = [
+  "id",
+  "columnKey",
+  "width",
+  "mobileLabel",
+  "horizontalAlign",
+  "verticalAlign",
+  "headerClassName",
+  "hideOnMobile",
+  "sortable",
+  "draggable",
+  "resizeable",
+  "minResizeWidth",
+  "maxResizeWidth",
+  "row",
+  "colSpan",
+  "rowSpan"
+], E = ["rowId", "rowIndex", "kind", "disabled"], K = (o, r) => o.length === r.length && o.every((e, n) => {
+  const t = r[n];
+  return t !== void 0 && S.every((s) => e[s] === t[s]);
+}), I = (o, r) => o.length === r.length && o.every((e, n) => {
+  const t = r[n];
+  return t !== void 0 && E.every((s) => e[s] === t[s]);
+}), z = (o) => {
+  const r = /* @__PURE__ */ new Set();
+  return o.filter((e) => r.has(e.id) ? !1 : (r.add(e.id), !0));
+}, H = (o) => {
+  const r = /* @__PURE__ */ new Set();
+  return o.filter((e) => {
+    const n = `${e.kind}-${String(e.rowId)}`;
+    return r.has(n) ? !1 : (r.add(n), !0);
+  });
+}, g = (o) => new Map(o.map((r) => [h(r), r.render])), k = (o) => {
+  const r = v(/* @__PURE__ */ new Map()), [e, n] = f({
+    headerColumns: [],
+    bodyRows: [],
+    bodyMaxHeight: void 0,
+    hasFooter: !1,
+    hasFooterCells: void 0,
+    hasExpandableRows: void 0
+  });
+  B(() => {
+    const s = o.current;
+    if (!s)
+      return;
+    const d = z(s.headerColumns), a = H(s.bodyRows), l = a.map(({ render: $, ...F }) => F), p = g(a), R = s.bodyMaxHeight, i = s.hasFooter === !0, c = s.hasFooterCells, w = s.hasExpandableRows;
+    r.current = p;
+    const u = K(e.headerColumns, d) ? e.headerColumns : d, y = I(e.bodyRows, l) ? e.bodyRows : l, b = e.bodyMaxHeight === R ? e.bodyMaxHeight : R, x = e.hasFooter === i ? e.hasFooter : i, C = e.hasFooterCells === c ? e.hasFooterCells : c, m = e.hasExpandableRows === w ? e.hasExpandableRows : w;
+    e.headerColumns === u && e.bodyRows === y && e.bodyMaxHeight === b && e.hasFooter === x && e.hasFooterCells === C && e.hasExpandableRows === m || n({
+      headerColumns: u,
+      bodyRows: y,
+      bodyMaxHeight: b,
+      hasFooter: x,
+      hasFooterCells: C,
+      hasExpandableRows: m
+    });
+  });
+  const t = M(
+    (s) => {
+      const d = o.current;
+      return ((d ? g(H(d.bodyRows)) : void 0)?.get(h(s)) ?? r.current.get(h(s)))?.() ?? null;
+    },
+    [o]
+  );
+  return {
+    renderHeaderColumns: e.headerColumns,
+    renderBodyRows: e.bodyRows,
+    renderBodyMaxHeight: e.bodyMaxHeight,
+    renderHasFooter: e.hasFooter,
+    renderHasFooterCells: e.hasFooterCells,
+    renderHasExpandableRows: e.hasExpandableRows,
+    renderBodyRow: t
+  };
+};
+export {
+  k as default,
+  k as useRenderDraftState
+};
+//# sourceMappingURL=useRenderDraftState.js.map

package/components/table/runtime/useRenderDraftState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRenderDraftState.js","sources":["../../../../src/components/table/runtime/useRenderDraftState.ts"],"sourcesContent":["import { useCallback, useLayoutEffect, useRef, useState, type ReactNode, type RefObject } from 'react';\n\nimport type { RenderBodyRow, RenderHeaderColumn, TableRenderDraft } from '../context/TableRenderContext';\nimport type { TableRowData } from '../Table.types';\n\ntype RenderDraftState<RowType extends TableRowData> = {\n    headerColumns: RenderHeaderColumn<RowType>[];\n    bodyRows: RenderBodyRow<RowType>[];\n    bodyMaxHeight?: string;\n    hasFooter: boolean;\n    hasFooterCells?: boolean;\n    hasExpandableRows?: boolean;\n};\n\nconst getRenderBodyRowRendererKey = <RowType extends TableRowData>(\n    row: Pick<TableRenderDraft<RowType>['bodyRows'][number], 'kind' | 'rowId'>\n) => `${row.kind}-${String(row.rowId)}`;\n\nconst renderHeaderColumnComparisonKeys = [\n    'id',\n    'columnKey',\n    'width',\n    'mobileLabel',\n    'horizontalAlign',\n    'verticalAlign',\n    'headerClassName',\n    'hideOnMobile',\n    'sortable',\n    'draggable',\n    'resizeable',\n    'minResizeWidth',\n    'maxResizeWidth',\n    'row',\n    'colSpan',\n    'rowSpan',\n] as const satisfies ReadonlyArray<keyof RenderHeaderColumn<TableRowData>>;\n\nconst renderBodyRowComparisonKeys = ['rowId', 'rowIndex', 'kind', 'disabled'] as const satisfies ReadonlyArray<\n    keyof RenderBodyRow<TableRowData>\n>;\n\nconst haveSameRenderHeaderColumns = <RowType extends TableRowData>(\n    currentColumns: RenderHeaderColumn<RowType>[],\n    nextColumns: RenderHeaderColumn<RowType>[]\n) =>\n    currentColumns.length === nextColumns.length &&\n    currentColumns.every((currentColumn, index) => {\n        const nextColumn = nextColumns[index];\n\n        return (\n            nextColumn !== undefined &&\n            renderHeaderColumnComparisonKeys.every(key => currentColumn[key] === nextColumn[key])\n        );\n    });\n\nconst haveSameRenderBodyRows = <RowType extends TableRowData>(\n    currentRows: RenderBodyRow<RowType>[],\n    nextRows: RenderBodyRow<RowType>[]\n) =>\n    currentRows.length === nextRows.length &&\n    currentRows.every((currentRow, index) => {\n        const nextRow = nextRows[index];\n\n        return nextRow !== undefined && renderBodyRowComparisonKeys.every(key => currentRow[key] === nextRow[key]);\n    });\n\nconst dedupeRenderHeaderColumns = <RowType extends TableRowData>(headerColumns: RenderHeaderColumn<RowType>[]) => {\n    const seenColumnIds = new Set<string>();\n\n    return headerColumns.filter(column => {\n        if (seenColumnIds.has(column.id)) {\n            return false;\n        }\n\n        seenColumnIds.add(column.id);\n        return true;\n    });\n};\n\nconst dedupeRenderBodyRows = <RowType extends TableRowData>(bodyRows: TableRenderDraft<RowType>['bodyRows']) => {\n    const seenRowKeys = new Set<string>();\n\n    return bodyRows.filter(row => {\n        const rowKey = `${row.kind}-${String(row.rowId)}`;\n\n        if (seenRowKeys.has(rowKey)) {\n            return false;\n        }\n\n        seenRowKeys.add(rowKey);\n        return true;\n    });\n};\n\nconst createRenderBodyRowRendererMap = <RowType extends TableRowData>(\n    bodyRows: TableRenderDraft<RowType>['bodyRows']\n) => new Map(bodyRows.map(row => [getRenderBodyRowRendererKey(row), row.render] as const));\n\nexport type UseRenderDraftStateReturn<RowType extends TableRowData> = {\n    renderHeaderColumns: RenderHeaderColumn<RowType>[];\n    renderBodyRows: RenderBodyRow<RowType>[];\n    renderBodyMaxHeight?: string;\n    renderHasFooter: boolean;\n    renderHasFooterCells?: boolean;\n    renderHasExpandableRows?: boolean;\n    renderBodyRow: (row: RenderBodyRow<RowType>) => ReactNode;\n};\n\nexport const useRenderDraftState = <RowType extends TableRowData>(\n    renderDraftRef: RefObject<TableRenderDraft<RowType>>\n): UseRenderDraftStateReturn<RowType> => {\n    const bodyRowRenderersRef = useRef(new Map<string, () => ReactNode>());\n    const [renderDraftState, setRenderDraftState] = useState<RenderDraftState<RowType>>({\n        headerColumns: [],\n        bodyRows: [],\n        bodyMaxHeight: undefined,\n        hasFooter: false,\n        hasFooterCells: undefined,\n        hasExpandableRows: undefined,\n    });\n\n    useLayoutEffect(() => {\n        const draft = renderDraftRef.current;\n\n        if (!draft) {\n            return;\n        }\n\n        const nextHeaderColumns = dedupeRenderHeaderColumns(draft.headerColumns);\n        const nextBodyRowsWithRenderers = dedupeRenderBodyRows(draft.bodyRows);\n        const nextBodyRows = nextBodyRowsWithRenderers.map(({ render: _render, ...bodyRow }) => bodyRow);\n        const nextBodyRowRenderers = createRenderBodyRowRendererMap(nextBodyRowsWithRenderers);\n        const nextBodyMaxHeight = draft.bodyMaxHeight;\n        const nextHasFooter = draft.hasFooter === true;\n        const nextHasFooterCells = draft.hasFooterCells;\n        const nextHasExpandableRows = draft.hasExpandableRows;\n\n        // Keep render functions out of React state. The draft state only tracks structural row\n        // metadata, while the latest row render callbacks stay available via this ref.\n        bodyRowRenderersRef.current = nextBodyRowRenderers;\n\n        const resolvedHeaderColumns = haveSameRenderHeaderColumns(renderDraftState.headerColumns, nextHeaderColumns)\n            ? renderDraftState.headerColumns\n            : nextHeaderColumns;\n        const resolvedBodyRows = haveSameRenderBodyRows(renderDraftState.bodyRows, nextBodyRows)\n            ? renderDraftState.bodyRows\n            : nextBodyRows;\n        const resolvedBodyMaxHeight =\n            renderDraftState.bodyMaxHeight === nextBodyMaxHeight ? renderDraftState.bodyMaxHeight : nextBodyMaxHeight;\n        const resolvedHasFooter =\n            renderDraftState.hasFooter === nextHasFooter ? renderDraftState.hasFooter : nextHasFooter;\n        const resolvedHasFooterCells =\n            renderDraftState.hasFooterCells === nextHasFooterCells\n                ? renderDraftState.hasFooterCells\n                : nextHasFooterCells;\n        const resolvedHasExpandableRows =\n            renderDraftState.hasExpandableRows === nextHasExpandableRows\n                ? renderDraftState.hasExpandableRows\n                : nextHasExpandableRows;\n\n        // Avoid scheduling a layout-state update when the normalized draft did not\n        // actually change. This keeps the render/register cycle stable in StrictMode\n        // and prevents resize-reset flows from bouncing through nested updates.\n        if (\n            renderDraftState.headerColumns === resolvedHeaderColumns &&\n            renderDraftState.bodyRows === resolvedBodyRows &&\n            renderDraftState.bodyMaxHeight === resolvedBodyMaxHeight &&\n            renderDraftState.hasFooter === resolvedHasFooter &&\n            renderDraftState.hasFooterCells === resolvedHasFooterCells &&\n            renderDraftState.hasExpandableRows === resolvedHasExpandableRows\n        ) {\n            return;\n        }\n\n        setRenderDraftState({\n            headerColumns: resolvedHeaderColumns,\n            bodyRows: resolvedBodyRows,\n            bodyMaxHeight: resolvedBodyMaxHeight,\n            hasFooter: resolvedHasFooter,\n            hasFooterCells: resolvedHasFooterCells,\n            hasExpandableRows: resolvedHasExpandableRows,\n        });\n    });\n\n    const renderBodyRow = useCallback(\n        (row: RenderBodyRow<RowType>) => {\n            const draft = renderDraftRef.current;\n            const draftRowRenderers = draft\n                ? createRenderBodyRowRendererMap(dedupeRenderBodyRows(draft.bodyRows))\n                : undefined;\n            const rowRenderer =\n                draftRowRenderers?.get(getRenderBodyRowRendererKey(row)) ??\n                bodyRowRenderersRef.current.get(getRenderBodyRowRendererKey(row));\n\n            return rowRenderer?.() ?? null;\n        },\n        [renderDraftRef]\n    );\n\n    return {\n        renderHeaderColumns: renderDraftState.headerColumns,\n        renderBodyRows: renderDraftState.bodyRows,\n        renderBodyMaxHeight: renderDraftState.bodyMaxHeight,\n        renderHasFooter: renderDraftState.hasFooter,\n        renderHasFooterCells: renderDraftState.hasFooterCells,\n        renderHasExpandableRows: renderDraftState.hasExpandableRows,\n        renderBodyRow,\n    };\n};\n\nexport default useRenderDraftState;\n"],"names":["getRenderBodyRowRendererKey","row","renderHeaderColumnComparisonKeys","renderBodyRowComparisonKeys","haveSameRenderHeaderColumns","currentColumns","nextColumns","currentColumn","index","nextColumn","key","haveSameRenderBodyRows","currentRows","nextRows","currentRow","nextRow","dedupeRenderHeaderColumns","headerColumns","seenColumnIds","column","dedupeRenderBodyRows","bodyRows","seenRowKeys","rowKey","createRenderBodyRowRendererMap","useRenderDraftState","renderDraftRef","bodyRowRenderersRef","useRef","renderDraftState","setRenderDraftState","useState","useLayoutEffect","draft","nextHeaderColumns","nextBodyRowsWithRenderers","nextBodyRows","_render","bodyRow","nextBodyRowRenderers","nextBodyMaxHeight","nextHasFooter","nextHasFooterCells","nextHasExpandableRows","resolvedHeaderColumns","resolvedBodyRows","resolvedBodyMaxHeight","resolvedHasFooter","resolvedHasFooterCells","resolvedHasExpandableRows","renderBodyRow","useCallback"],"mappings":"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"}

package/components/table/runtime/useResolvedRenderColumns.d.ts

@@ -0,0 +1,43 @@
+import { RenderHeaderColumn } from '../context/TableRenderContext';
+import { useDraggableColumns } from '../layout/useDraggableColumns';
+import { useResizableColumns } from '../layout/useResizableColumns';
+import { TableColumnDefinition, TableProps, TableRowData } from '../Table.types';
+type UseResolvedRenderColumnsProps<RowType extends TableRowData> = {
+    columnOrder: TableProps<RowType>['columnOrder'];
+    onColumnOrderChange: TableProps<RowType>['onColumnOrderChange'];
+    onColumnResize: TableProps<RowType>['onColumnResize'];
+    renderHeaderColumns: RenderHeaderColumn<RowType>[];
+    viewType: TableProps<RowType>['viewType'];
+};
+export type UseResolvedRenderColumnsReturn<RowType extends TableRowData> = {
+    columnDefinitionsByKey: Map<string, TableColumnDefinition<RowType>>;
+    columnIndexByKey: Map<string, number>;
+    draggableColumnKeys?: string[];
+    draggableColumnsEnabled: boolean;
+    handleColumnDragEnd: ReturnType<typeof useDraggableColumns>['handleColumnDragEnd'];
+    handleColumnResizeReset: ReturnType<typeof useResizableColumns<RowType>>['handleColumnResizeReset'];
+    handleColumnResizeStart: ReturnType<typeof useResizableColumns<RowType>>['handleColumnResizeStart'];
+    lastResizableColumnKey?: string;
+    resettableColumnKeys: Set<string>;
+    renderLeafColumns: RenderHeaderColumn<RowType>[];
+    resizeColumnsEnabled: boolean;
+    resolvedRenderColumns: RenderHeaderColumn<RowType>[];
+    resizedColumns: ReturnType<typeof useResizableColumns<RowType>>['resizedColumns'];
+};
+/**
+ * Resolves the leaf-level table columns that drive layout and column behavior.
+ *
+ * Header registration can contain grouped header cells, multi-row headers, and
+ * other metadata that is useful for rendering, but drag, resize, sticky layout,
+ * and body/footer cell placement ultimately need a flat list of leaf columns.
+ *
+ * This hook therefore:
+ * - narrows registered header cells down to leaf columns with a stable `columnKey`
+ * - applies column reordering
+ * - applies resized widths
+ * - exposes a normalized column map for body/footer cell lookup
+ *
+ * `Table` uses this as the canonical column model for the rest of the render pass.
+ */
+declare const useResolvedRenderColumns: <RowType extends TableRowData>(props: UseResolvedRenderColumnsProps<RowType>) => UseResolvedRenderColumnsReturn<RowType>;
+export default useResolvedRenderColumns;

package/components/table/runtime/useResolvedRenderColumns.js

@@ -0,0 +1,113 @@
+import { useMemo as l } from "react";
+import { useDraggableColumns as x } from "../layout/useDraggableColumns.js";
+import { useResizableColumns as A } from "../layout/useResizableColumns.js";
+const B = (m) => {
+  const { columnOrder: g, onColumnOrderChange: C, onColumnResize: y, renderHeaderColumns: t, viewType: d } = m, i = l(
+    () => t.flatMap(
+      (e) => e.columnKey && e.colSpan === 1 ? [
+        {
+          ...e,
+          columnKey: e.columnKey
+        }
+      ] : []
+    ),
+    [t]
+  ), n = l(
+    () => i.map((e) => ({
+      key: e.columnKey,
+      label: e.columnKey,
+      mobileLabel: e.mobileLabel,
+      width: e.width,
+      minResizeWidth: e.minResizeWidth,
+      maxResizeWidth: e.maxResizeWidth,
+      draggable: e.draggable,
+      resizeable: e.resizeable,
+      horizontalAlign: e.horizontalAlign,
+      headerClassName: e.headerClassName,
+      hideOnMobile: e.hideOnMobile,
+      sortable: e.sortable
+    })),
+    [i]
+  ), o = d === "TABLE" && n.filter((e) => e.draggable === !0).length > 1, { draggableColumnKeys: R, handleColumnDragEnd: p, orderedColumns: b } = x({
+    columns: n,
+    columnOrder: g,
+    enabled: o,
+    onColumnOrderChange: C
+  }), h = d === "TABLE" && b.some((e) => e.resizeable === !0), {
+    handleColumnResizeReset: K,
+    handleColumnResizeStart: f,
+    lastResizableColumnKey: M,
+    resettableColumnKeys: W,
+    resizedColumns: r
+  } = A({
+    columns: b,
+    enabled: h,
+    onColumnResize: y
+  }), s = l(() => {
+    const e = new Map(i.map((a) => [a.columnKey, a]));
+    return r.flatMap((a) => {
+      const z = e.get(a.key);
+      return z ? [
+        {
+          ...z,
+          width: a.width,
+          minResizeWidth: a.minResizeWidth,
+          maxResizeWidth: a.maxResizeWidth,
+          draggable: a.draggable,
+          resizeable: a.resizeable,
+          horizontalAlign: a.horizontalAlign,
+          headerClassName: a.headerClassName,
+          hideOnMobile: a.hideOnMobile,
+          sortable: a.sortable
+        }
+      ] : [];
+    });
+  }, [i, r]), w = l(
+    () => new Map(
+      s.map((e) => [
+        e.columnKey,
+        {
+          key: e.columnKey,
+          label: e.label,
+          mobileLabel: e.mobileLabel,
+          icon: e.icon,
+          filter: e.filter,
+          hideLabel: e.hideLabel,
+          width: e.width,
+          minResizeWidth: e.minResizeWidth,
+          maxResizeWidth: e.maxResizeWidth,
+          draggable: e.draggable,
+          resizeable: e.resizeable,
+          horizontalAlign: e.horizontalAlign,
+          className: void 0,
+          headerClassName: e.headerClassName,
+          hideOnMobile: e.hideOnMobile,
+          sortable: e.sortable
+        }
+      ])
+    ),
+    [s]
+  ), L = l(
+    () => new Map(s.map((e, a) => [e.columnKey, a])),
+    [s]
+  );
+  return {
+    columnDefinitionsByKey: w,
+    columnIndexByKey: L,
+    draggableColumnKeys: R,
+    draggableColumnsEnabled: o,
+    handleColumnDragEnd: p,
+    handleColumnResizeReset: K,
+    handleColumnResizeStart: f,
+    lastResizableColumnKey: M,
+    resettableColumnKeys: W,
+    renderLeafColumns: i,
+    resizeColumnsEnabled: h,
+    resolvedRenderColumns: s,
+    resizedColumns: r
+  };
+};
+export {
+  B as default
+};
+//# sourceMappingURL=useResolvedRenderColumns.js.map

package/components/table/runtime/useResolvedRenderColumns.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useResolvedRenderColumns.js","sources":["../../../../src/components/table/runtime/useResolvedRenderColumns.ts"],"sourcesContent":["import { useMemo } from 'react';\n\nimport type { RenderHeaderColumn } from '../context/TableRenderContext';\nimport { useDraggableColumns } from '../layout/useDraggableColumns';\nimport { useResizableColumns } from '../layout/useResizableColumns';\nimport type { TableColumnDefinition, TableProps, TableRowData } from '../Table.types';\n\ntype UseResolvedRenderColumnsProps<RowType extends TableRowData> = {\n    columnOrder: TableProps<RowType>['columnOrder'];\n    onColumnOrderChange: TableProps<RowType>['onColumnOrderChange'];\n    onColumnResize: TableProps<RowType>['onColumnResize'];\n    renderHeaderColumns: RenderHeaderColumn<RowType>[];\n    viewType: TableProps<RowType>['viewType'];\n};\n\nexport type UseResolvedRenderColumnsReturn<RowType extends TableRowData> = {\n    columnDefinitionsByKey: Map<string, TableColumnDefinition<RowType>>;\n    columnIndexByKey: Map<string, number>;\n    draggableColumnKeys?: string[];\n    draggableColumnsEnabled: boolean;\n    handleColumnDragEnd: ReturnType<typeof useDraggableColumns>['handleColumnDragEnd'];\n    handleColumnResizeReset: ReturnType<typeof useResizableColumns<RowType>>['handleColumnResizeReset'];\n    handleColumnResizeStart: ReturnType<typeof useResizableColumns<RowType>>['handleColumnResizeStart'];\n    lastResizableColumnKey?: string;\n    resettableColumnKeys: Set<string>;\n    renderLeafColumns: RenderHeaderColumn<RowType>[];\n    resizeColumnsEnabled: boolean;\n    resolvedRenderColumns: RenderHeaderColumn<RowType>[];\n    resizedColumns: ReturnType<typeof useResizableColumns<RowType>>['resizedColumns'];\n};\n\n/**\n * Resolves the leaf-level table columns that drive layout and column behavior.\n *\n * Header registration can contain grouped header cells, multi-row headers, and\n * other metadata that is useful for rendering, but drag, resize, sticky layout,\n * and body/footer cell placement ultimately need a flat list of leaf columns.\n *\n * This hook therefore:\n * - narrows registered header cells down to leaf columns with a stable `columnKey`\n * - applies column reordering\n * - applies resized widths\n * - exposes a normalized column map for body/footer cell lookup\n *\n * `Table` uses this as the canonical column model for the rest of the render pass.\n */\nconst useResolvedRenderColumns = <RowType extends TableRowData>(\n    props: UseResolvedRenderColumnsProps<RowType>\n): UseResolvedRenderColumnsReturn<RowType> => {\n    const { columnOrder, onColumnOrderChange, onColumnResize, renderHeaderColumns, viewType } = props;\n\n    // Only leaf header cells represent actual data columns. Group headers span\n    // other columns and are part of the header layout, but not the column model\n    // used by body/footer cells or drag/resize behavior.\n    const renderLeafColumns = useMemo(\n        () =>\n            renderHeaderColumns.flatMap(column =>\n                column.columnKey && column.colSpan === 1\n                    ? [\n                          {\n                              ...column,\n                              columnKey: column.columnKey,\n                          },\n                      ]\n                    : []\n            ),\n        [renderHeaderColumns]\n    );\n\n    const baseRenderColumnDefinitions = useMemo(\n        () =>\n            renderLeafColumns.map(column => ({\n                key: column.columnKey,\n                label: column.columnKey,\n                mobileLabel: column.mobileLabel,\n                width: column.width,\n                minResizeWidth: column.minResizeWidth,\n                maxResizeWidth: column.maxResizeWidth,\n                draggable: column.draggable,\n                resizeable: column.resizeable,\n                horizontalAlign: column.horizontalAlign,\n                headerClassName: column.headerClassName,\n                hideOnMobile: column.hideOnMobile,\n                sortable: column.sortable,\n            })),\n        [renderLeafColumns]\n    );\n\n    const draggableColumnsEnabled =\n        viewType === 'TABLE' && baseRenderColumnDefinitions.filter(column => column.draggable === true).length > 1;\n    const { draggableColumnKeys, handleColumnDragEnd, orderedColumns } = useDraggableColumns({\n        columns: baseRenderColumnDefinitions,\n        columnOrder,\n        enabled: draggableColumnsEnabled,\n        onColumnOrderChange,\n    });\n\n    const resizeColumnsEnabled = viewType === 'TABLE' && orderedColumns.some(column => column.resizeable === true);\n    const {\n        handleColumnResizeReset,\n        handleColumnResizeStart,\n        lastResizableColumnKey,\n        resettableColumnKeys,\n        resizedColumns,\n    } = useResizableColumns({\n        columns: orderedColumns,\n        enabled: resizeColumnsEnabled,\n        onColumnResize,\n    });\n\n    // Merge reordered/resized column behavior back into the registered leaf\n    // columns so the rest of the table can render from one normalized shape.\n    const resolvedRenderColumns = useMemo(() => {\n        const renderColumnsByKey = new Map(renderLeafColumns.map(column => [column.columnKey, column] as const));\n\n        return resizedColumns.flatMap(column => {\n            const renderColumn = renderColumnsByKey.get(column.key);\n\n            return renderColumn\n                ? [\n                      {\n                          ...renderColumn,\n                          width: column.width,\n                          minResizeWidth: column.minResizeWidth,\n                          maxResizeWidth: column.maxResizeWidth,\n                          draggable: column.draggable,\n                          resizeable: column.resizeable,\n                          horizontalAlign: column.horizontalAlign,\n                          headerClassName: column.headerClassName,\n                          hideOnMobile: column.hideOnMobile,\n                          sortable: column.sortable,\n                      },\n                  ]\n                : [];\n        });\n    }, [renderLeafColumns, resizedColumns]);\n\n    // Body and footer cells resolve their column metadata by `columnKey`, so keep\n    // an efficient lookup map next to the ordered column array.\n    const columnDefinitionsByKey = useMemo(\n        () =>\n            new Map<string, TableColumnDefinition<RowType>>(\n                resolvedRenderColumns.map(column => [\n                    column.columnKey,\n                    {\n                        key: column.columnKey,\n                        label: column.label,\n                        mobileLabel: column.mobileLabel,\n                        icon: column.icon,\n                        filter: column.filter,\n                        hideLabel: column.hideLabel,\n                        width: column.width,\n                        minResizeWidth: column.minResizeWidth,\n                        maxResizeWidth: column.maxResizeWidth,\n                        draggable: column.draggable,\n                        resizeable: column.resizeable,\n                        horizontalAlign: column.horizontalAlign,\n                        className: undefined,\n                        headerClassName: column.headerClassName,\n                        hideOnMobile: column.hideOnMobile,\n                        sortable: column.sortable,\n                    },\n                ])\n            ),\n        [resolvedRenderColumns]\n    );\n    const columnIndexByKey = useMemo(\n        () => new Map(resolvedRenderColumns.map((column, index) => [column.columnKey, index] as const)),\n        [resolvedRenderColumns]\n    );\n\n    return {\n        columnDefinitionsByKey,\n        columnIndexByKey,\n        draggableColumnKeys,\n        draggableColumnsEnabled,\n        handleColumnDragEnd,\n        handleColumnResizeReset,\n        handleColumnResizeStart,\n        lastResizableColumnKey,\n        resettableColumnKeys,\n        renderLeafColumns,\n        resizeColumnsEnabled,\n        resolvedRenderColumns,\n        resizedColumns,\n    };\n};\n\nexport default useResolvedRenderColumns;\n"],"names":["useResolvedRenderColumns","props","columnOrder","onColumnOrderChange","onColumnResize","renderHeaderColumns","viewType","renderLeafColumns","useMemo","column","baseRenderColumnDefinitions","draggableColumnsEnabled","draggableColumnKeys","handleColumnDragEnd","orderedColumns","useDraggableColumns","resizeColumnsEnabled","handleColumnResizeReset","handleColumnResizeStart","lastResizableColumnKey","resettableColumnKeys","resizedColumns","useResizableColumns","resolvedRenderColumns","renderColumnsByKey","renderColumn","columnDefinitionsByKey","columnIndexByKey","index"],"mappings":"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"}

package/components/table/runtime/useResolvedRenderHeader.d.ts

@@ -0,0 +1,27 @@
+import { RenderHeaderColumn } from '../context/TableRenderContext';
+import { TableViewHeader } from '../model/tableView.types';
+import { TableRowData, TableSortDirection } from '../Table.types';
+type UseResolvedRenderHeaderProps<RowType extends TableRowData> = {
+    renderHeaderColumns: RenderHeaderColumn<RowType>[];
+    resolvedRenderColumns: RenderHeaderColumn<RowType>[];
+    sortBy?: string | string[];
+    sortDirection?: TableSortDirection;
+};
+/**
+ * Builds the normalized header layout from registered header cells and the
+ * already-resolved leaf columns.
+ *
+ * `useResolvedRenderColumns(...)` decides which columns actually exist after
+ * reorder/resize behavior. This hook takes that flat column model plus the
+ * registered header cells and computes the final header grid:
+ * - row count
+ * - column start positions
+ * - row/column spans
+ * - sortable state for the active sort key
+ * - `source` metadata for downstream header/cell consumers
+ *
+ * The result is a stable header view model that `TableHeader` can render
+ * without repeating placement logic.
+ */
+declare const useResolvedRenderHeader: <RowType extends TableRowData>(props: UseResolvedRenderHeaderProps<RowType>) => TableViewHeader<RowType> | undefined;
+export default useResolvedRenderHeader;

package/components/table/runtime/useResolvedRenderHeader.js

@@ -0,0 +1,67 @@
+import { useMemo as f } from "react";
+const z = (g) => {
+  const { renderHeaderColumns: i, resolvedRenderColumns: a, sortBy: l, sortDirection: h } = g;
+  return f(() => {
+    if (i.length === 0 || a.length === 0)
+      return;
+    const y = new Set(Array.isArray(l) ? l : l ? [l] : []), b = Math.max(...i.map((e) => e.row + e.rowSpan - 1), 1), d = Array.from({ length: b }, () => Array(a.length).fill(!1)), c = new Map(
+      a.map((e) => [e.columnKey, e])
+    ), m = new Map(
+      a.map((e, r) => [e.columnKey, r + 1])
+    ), w = (e, r) => {
+      for (let o = 1; o <= a.length - r + 1; o += 1)
+        if (d[e - 1]?.slice(o - 1, o - 1 + r).every((t) => !t))
+          return o;
+      return 1;
+    }, p = i.map((e) => {
+      const r = e.columnKey ? c.get(e.columnKey) : void 0, o = r?.columnKey ? {
+        key: r.columnKey,
+        label: r.label,
+        width: r.width,
+        mobileLabel: r.mobileLabel,
+        horizontalAlign: r.horizontalAlign,
+        headerClassName: r.headerClassName,
+        hideOnMobile: r.hideOnMobile,
+        sortable: r.sortable,
+        draggable: r.draggable,
+        resizeable: r.resizeable,
+        minResizeWidth: r.minResizeWidth,
+        maxResizeWidth: r.maxResizeWidth
+      } : void 0, n = r ? m.get(r.columnKey) ?? 1 : w(e.row, e.colSpan);
+      for (let t = e.row - 1; t < e.row - 1 + e.rowSpan; t += 1)
+        for (let s = n - 1; s < n - 1 + e.colSpan; s += 1)
+          d[t]?.[s] !== void 0 && (d[t][s] = !0);
+      return {
+        key: e.id,
+        columnKey: e.columnKey,
+        label: e.label,
+        icon: e.icon,
+        filter: e.filter,
+        hideLabel: e.hideLabel,
+        horizontalAlign: r?.horizontalAlign ?? e.horizontalAlign,
+        verticalAlign: r?.verticalAlign ?? e.verticalAlign,
+        className: void 0,
+        headerClassName: r?.headerClassName ?? e.headerClassName,
+        hideOnMobile: r?.hideOnMobile ?? e.hideOnMobile,
+        draggable: r?.draggable ?? e.draggable,
+        resizeable: r?.resizeable ?? e.resizeable,
+        sortable: r?.sortable ?? e.sortable,
+        sortDirection: e.columnKey && y.has(e.columnKey) ? h : void 0,
+        rowStart: e.row,
+        rowSpan: e.rowSpan,
+        columnStart: n,
+        colSpan: e.colSpan,
+        source: o
+      };
+    });
+    return {
+      rowCount: b,
+      totalColumnCount: a.length,
+      columns: p
+    };
+  }, [i, a, l, h]);
+};
+export {
+  z as default
+};
+//# sourceMappingURL=useResolvedRenderHeader.js.map

package/components/table/runtime/useResolvedRenderHeader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useResolvedRenderHeader.js","sources":["../../../../src/components/table/runtime/useResolvedRenderHeader.ts"],"sourcesContent":["import { useMemo } from 'react';\n\nimport type { RenderHeaderColumn } from '../context/TableRenderContext';\nimport type { TableViewHeader } from '../model/tableView.types';\nimport type { TableColumnDefinition, TableRowData, TableSortDirection } from '../Table.types';\n\ntype UseResolvedRenderHeaderProps<RowType extends TableRowData> = {\n    renderHeaderColumns: RenderHeaderColumn<RowType>[];\n    resolvedRenderColumns: RenderHeaderColumn<RowType>[];\n    sortBy?: string | string[];\n    sortDirection?: TableSortDirection;\n};\n\n/**\n * Builds the normalized header layout from registered header cells and the\n * already-resolved leaf columns.\n *\n * `useResolvedRenderColumns(...)` decides which columns actually exist after\n * reorder/resize behavior. This hook takes that flat column model plus the\n * registered header cells and computes the final header grid:\n * - row count\n * - column start positions\n * - row/column spans\n * - sortable state for the active sort key\n * - `source` metadata for downstream header/cell consumers\n *\n * The result is a stable header view model that `TableHeader` can render\n * without repeating placement logic.\n */\nconst useResolvedRenderHeader = <RowType extends TableRowData>(\n    props: UseResolvedRenderHeaderProps<RowType>\n): TableViewHeader<RowType> | undefined => {\n    const { renderHeaderColumns, resolvedRenderColumns, sortBy, sortDirection } = props;\n\n    return useMemo<TableViewHeader<RowType> | undefined>(() => {\n        if (renderHeaderColumns.length === 0 || resolvedRenderColumns.length === 0) {\n            return;\n        }\n\n        const sortedColumnKeys = new Set(Array.isArray(sortBy) ? sortBy : sortBy ? [sortBy] : []);\n        const rowCount = Math.max(...renderHeaderColumns.map(column => column.row + column.rowSpan - 1), 1);\n        const occupied = Array.from({ length: rowCount }, () => Array(resolvedRenderColumns.length).fill(false));\n        const resolvedRenderColumnsByKey = new Map(\n            resolvedRenderColumns.map(column => [column.columnKey, column] as const)\n        );\n        const columnStartByKey = new Map(\n            resolvedRenderColumns.map((column, index) => [column.columnKey, index + 1] as const)\n        );\n\n        // Group headers without a direct `columnKey` still need a column start.\n        // Find the next free slot by walking the occupied grid from left to right.\n        const findColumnStart = (rowStart: number, colSpan: number) => {\n            for (let candidate = 1; candidate <= resolvedRenderColumns.length - colSpan + 1; candidate += 1) {\n                const hasFreeSlot = occupied[rowStart - 1]\n                    ?.slice(candidate - 1, candidate - 1 + colSpan)\n                    .every(isUsed => !isUsed);\n\n                if (hasFreeSlot) {\n                    return candidate;\n                }\n            }\n\n            return 1;\n        };\n\n        const columns = renderHeaderColumns.map(column => {\n            const resolvedRenderColumn = column.columnKey\n                ? resolvedRenderColumnsByKey.get(column.columnKey)\n                : undefined;\n            const sourceColumnDefinition: TableColumnDefinition<RowType> | undefined = resolvedRenderColumn?.columnKey\n                ? {\n                      key: resolvedRenderColumn.columnKey,\n                      label: resolvedRenderColumn.label,\n                      width: resolvedRenderColumn.width,\n                      mobileLabel: resolvedRenderColumn.mobileLabel,\n                      horizontalAlign: resolvedRenderColumn.horizontalAlign,\n                      headerClassName: resolvedRenderColumn.headerClassName,\n                      hideOnMobile: resolvedRenderColumn.hideOnMobile,\n                      sortable: resolvedRenderColumn.sortable,\n                      draggable: resolvedRenderColumn.draggable,\n                      resizeable: resolvedRenderColumn.resizeable,\n                      minResizeWidth: resolvedRenderColumn.minResizeWidth,\n                      maxResizeWidth: resolvedRenderColumn.maxResizeWidth,\n                  }\n                : undefined;\n            const columnStart = resolvedRenderColumn\n                ? (columnStartByKey.get(resolvedRenderColumn.columnKey) ?? 1)\n                : findColumnStart(column.row, column.colSpan);\n\n            // Mark the occupied grid so following grouped header cells can find\n            // the next free placement slot in multi-row header layouts.\n            for (let rowIndex = column.row - 1; rowIndex < column.row - 1 + column.rowSpan; rowIndex += 1) {\n                for (\n                    let columnIndex = columnStart - 1;\n                    columnIndex < columnStart - 1 + column.colSpan;\n                    columnIndex += 1\n                ) {\n                    if (occupied[rowIndex]?.[columnIndex] !== undefined) {\n                        occupied[rowIndex][columnIndex] = true;\n                    }\n                }\n            }\n\n            return {\n                key: column.id,\n                columnKey: column.columnKey,\n                label: column.label,\n                icon: column.icon,\n                filter: column.filter,\n                hideLabel: column.hideLabel,\n                horizontalAlign: resolvedRenderColumn?.horizontalAlign ?? column.horizontalAlign,\n                verticalAlign: resolvedRenderColumn?.verticalAlign ?? column.verticalAlign,\n                className: undefined,\n                headerClassName: resolvedRenderColumn?.headerClassName ?? column.headerClassName,\n                hideOnMobile: resolvedRenderColumn?.hideOnMobile ?? column.hideOnMobile,\n                draggable: resolvedRenderColumn?.draggable ?? column.draggable,\n                resizeable: resolvedRenderColumn?.resizeable ?? column.resizeable,\n                sortable: resolvedRenderColumn?.sortable ?? column.sortable,\n                sortDirection: column.columnKey && sortedColumnKeys.has(column.columnKey) ? sortDirection : undefined,\n                rowStart: column.row,\n                rowSpan: column.rowSpan,\n                columnStart,\n                colSpan: column.colSpan,\n                source: sourceColumnDefinition,\n            };\n        });\n\n        return {\n            rowCount,\n            totalColumnCount: resolvedRenderColumns.length,\n            columns,\n        };\n    }, [renderHeaderColumns, resolvedRenderColumns, sortBy, sortDirection]);\n};\n\nexport default useResolvedRenderHeader;\n"],"names":["useResolvedRenderHeader","props","renderHeaderColumns","resolvedRenderColumns","sortBy","sortDirection","useMemo","sortedColumnKeys","rowCount","column","occupied","resolvedRenderColumnsByKey","columnStartByKey","index","findColumnStart","rowStart","colSpan","candidate","isUsed","columns","resolvedRenderColumn","sourceColumnDefinition","columnStart","rowIndex","columnIndex"],"mappings":"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"}

package/components/table/selection/useInternalTableSelectionState.d.ts

@@ -0,0 +1,17 @@
+import { RenderBodyRow } from '../context/TableRenderContext';
+import { TableRowData, TableRowId } from '../Table.types';
+type UseInternalTableSelectionStateOptions<RowType extends TableRowData> = {
+    bodyRows: RenderBodyRow<RowType>[];
+    selectedRowIds?: TableRowId[];
+    onSelectionChange?: (rowIds: TableRowId[]) => void;
+};
+type UseInternalTableSelectionStateReturn = {
+    currentSelectedRowIds: TableRowId[];
+    selectedRowIdSet: Set<TableRowId>;
+    isAllRowsSelected: boolean;
+    isSomeRowsSelected: boolean;
+    handleToggleAllSelection: () => void;
+    handleToggleRowSelection: (rowId: TableRowId) => void;
+};
+declare const useInternalTableSelectionState: <RowType extends TableRowData>(props: UseInternalTableSelectionStateOptions<RowType>) => UseInternalTableSelectionStateReturn;
+export default useInternalTableSelectionState;

package/components/table/selection/useInternalTableSelectionState.js

@@ -0,0 +1,28 @@
+import { useMemo as o } from "react";
+const f = (r) => {
+  const { bodyRows: c, selectedRowIds: w, onSelectionChange: n } = r, l = o(
+    () => c.filter((e) => e.kind === "data" && !e.disabled).map((e) => e.rowId),
+    [c]
+  ), d = o(() => new Set(l), [l]), t = w ?? [], a = o(() => new Set(t), [t]), S = o(
+    () => t.filter((e) => d.has(e)),
+    [t, d]
+  ), i = o(() => new Set(S), [S]), s = l.length > 0 && l.every((e) => i.has(e)), R = i.size > 0 && !s;
+  return {
+    currentSelectedRowIds: t,
+    selectedRowIdSet: a,
+    isAllRowsSelected: s,
+    isSomeRowsSelected: R,
+    handleToggleAllSelection: () => {
+      n?.(s ? [] : l);
+    },
+    handleToggleRowSelection: (e) => {
+      n && n(
+        a.has(e) ? t.filter((g) => g !== e) : [...t, e]
+      );
+    }
+  };
+};
+export {
+  f as default
+};
+//# sourceMappingURL=useInternalTableSelectionState.js.map

package/components/table/selection/useInternalTableSelectionState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInternalTableSelectionState.js","sources":["../../../../src/components/table/selection/useInternalTableSelectionState.ts"],"sourcesContent":["import { useMemo } from 'react';\n\nimport type { RenderBodyRow } from '../context/TableRenderContext';\nimport type { TableRowData, TableRowId } from '../Table.types';\n\ntype UseInternalTableSelectionStateOptions<RowType extends TableRowData> = {\n    bodyRows: RenderBodyRow<RowType>[];\n    selectedRowIds?: TableRowId[];\n    onSelectionChange?: (rowIds: TableRowId[]) => void;\n};\n\ntype UseInternalTableSelectionStateReturn = {\n    currentSelectedRowIds: TableRowId[];\n    selectedRowIdSet: Set<TableRowId>;\n    isAllRowsSelected: boolean;\n    isSomeRowsSelected: boolean;\n    handleToggleAllSelection: () => void;\n    handleToggleRowSelection: (rowId: TableRowId) => void;\n};\n\nconst useInternalTableSelectionState = <RowType extends TableRowData>(\n    props: UseInternalTableSelectionStateOptions<RowType>\n): UseInternalTableSelectionStateReturn => {\n    const { bodyRows, selectedRowIds, onSelectionChange } = props;\n\n    const selectableRowIds = useMemo(\n        () => bodyRows.filter(row => row.kind === 'data' && !row.disabled).map(row => row.rowId),\n        [bodyRows]\n    );\n    const selectableRowIdSet = useMemo(() => new Set(selectableRowIds), [selectableRowIds]);\n    const currentSelectedRowIds = selectedRowIds ?? [];\n    const selectedRowIdSet = useMemo(() => new Set(currentSelectedRowIds), [currentSelectedRowIds]);\n    const normalizedSelectedRowIds = useMemo(\n        () => currentSelectedRowIds.filter(rowId => selectableRowIdSet.has(rowId)),\n        [currentSelectedRowIds, selectableRowIdSet]\n    );\n    const normalizedSelectedRowIdSet = useMemo(() => new Set(normalizedSelectedRowIds), [normalizedSelectedRowIds]);\n\n    const isAllRowsSelected =\n        selectableRowIds.length > 0 && selectableRowIds.every(rowId => normalizedSelectedRowIdSet.has(rowId));\n    const isSomeRowsSelected = normalizedSelectedRowIdSet.size > 0 && !isAllRowsSelected;\n\n    const handleToggleAllSelection = () => {\n        onSelectionChange?.(isAllRowsSelected ? [] : selectableRowIds);\n    };\n\n    const handleToggleRowSelection = (rowId: TableRowId) => {\n        if (!onSelectionChange) {\n            return;\n        }\n\n        onSelectionChange(\n            selectedRowIdSet.has(rowId)\n                ? currentSelectedRowIds.filter(selectedRowId => selectedRowId !== rowId)\n                : [...currentSelectedRowIds, rowId]\n        );\n    };\n\n    return {\n        currentSelectedRowIds,\n        selectedRowIdSet,\n        isAllRowsSelected,\n        isSomeRowsSelected,\n        handleToggleAllSelection,\n        handleToggleRowSelection,\n    };\n};\n\nexport default useInternalTableSelectionState;\n"],"names":["useInternalTableSelectionState","props","bodyRows","selectedRowIds","onSelectionChange","selectableRowIds","useMemo","row","selectableRowIdSet","currentSelectedRowIds","selectedRowIdSet","normalizedSelectedRowIds","rowId","normalizedSelectedRowIdSet","isAllRowsSelected","isSomeRowsSelected","selectedRowId"],"mappings":";AAoBA,MAAMA,IAAiC,CACnCC,MACuC;AACvC,QAAM,EAAE,UAAAC,GAAU,gBAAAC,GAAgB,mBAAAC,EAAA,IAAsBH,GAElDI,IAAmBC;AAAA,IACrB,MAAMJ,EAAS,OAAO,CAAAK,MAAOA,EAAI,SAAS,UAAU,CAACA,EAAI,QAAQ,EAAE,IAAI,CAAAA,MAAOA,EAAI,KAAK;AAAA,IACvF,CAACL,CAAQ;AAAA,EAAA,GAEPM,IAAqBF,EAAQ,MAAM,IAAI,IAAID,CAAgB,GAAG,CAACA,CAAgB,CAAC,GAChFI,IAAwBN,KAAkB,CAAA,GAC1CO,IAAmBJ,EAAQ,MAAM,IAAI,IAAIG,CAAqB,GAAG,CAACA,CAAqB,CAAC,GACxFE,IAA2BL;AAAA,IAC7B,MAAMG,EAAsB,OAAO,OAASD,EAAmB,IAAII,CAAK,CAAC;AAAA,IACzE,CAACH,GAAuBD,CAAkB;AAAA,EAAA,GAExCK,IAA6BP,EAAQ,MAAM,IAAI,IAAIK,CAAwB,GAAG,CAACA,CAAwB,CAAC,GAExGG,IACFT,EAAiB,SAAS,KAAKA,EAAiB,MAAM,CAAAO,MAASC,EAA2B,IAAID,CAAK,CAAC,GAClGG,IAAqBF,EAA2B,OAAO,KAAK,CAACC;AAkBnE,SAAO;AAAA,IACH,uBAAAL;AAAA,IACA,kBAAAC;AAAA,IACA,mBAAAI;AAAA,IACA,oBAAAC;AAAA,IACA,0BArB6B,MAAM;AACnC,MAAAX,IAAoBU,IAAoB,CAAA,IAAKT,CAAgB;AAAA,IACjE;AAAA,IAoBI,0BAlB6B,CAACO,MAAsB;AACpD,MAAKR,KAILA;AAAA,QACIM,EAAiB,IAAIE,CAAK,IACpBH,EAAsB,OAAO,CAAAO,MAAiBA,MAAkBJ,CAAK,IACrE,CAAC,GAAGH,GAAuBG,CAAK;AAAA,MAAA;AAAA,IAE9C;AAAA,EAQI;AAER;"}

package/components/table/selection/useTableSelection.d.ts

@@ -0,0 +1,82 @@
+import { TableRowData, TableRowId } from '../Table.types';
+/**
+ * Configuration for `useTableSelection`.
+ */
+export type UseTableSelectionOptions<RowType extends TableRowData> = {
+    /**
+     * Data rows that participate in active-row and selection state.
+     */
+    rows: RowType[];
+    /**
+     * Optional key accessor used to derive stable row ids.
+     *
+     * If omitted, the row index is used as a fallback.
+     */
+    rowKey?: keyof RowType | ((row: RowType, rowIndex: number) => TableRowId);
+    /**
+     * Optional initially active row id.
+     */
+    initialActiveRowId?: TableRowId;
+    /**
+     * Optional initially selected row ids.
+     */
+    initialSelectedRowIds?: TableRowId[];
+};
+/**
+ * Selection and active-row state returned by `useTableSelection`.
+ */
+export type UseTableSelectionReturn = {
+    /**
+     * Currently active row id.
+     */
+    activeRowId?: TableRowId;
+    /**
+     * Currently selected row ids.
+     */
+    selectedRowIds: TableRowId[];
+    /**
+     * Whether at least one row is currently selected.
+     */
+    hasSelection: boolean;
+    /**
+     * Whether all current rows are selected.
+     */
+    isAllSelected: boolean;
+    /**
+     * Checks whether a given row id is currently selected.
+     */
+    isRowSelected: (rowId: TableRowId) => boolean;
+    /**
+     * Sets the current active row id.
+     */
+    setActiveRowId: (rowId: TableRowId | undefined) => void;
+    /**
+     * Replaces the current selection with the provided row ids.
+     */
+    setSelectedRowIds: (rowIds: TableRowId[]) => void;
+    /**
+     * Toggles selection state for a single row id.
+     */
+    toggleRowSelection: (rowId: TableRowId) => void;
+    /**
+     * Selects or deselects all current rows.
+     *
+     * If `shouldSelect` is omitted, the hook toggles based on the current
+     * all-selected state.
+     */
+    toggleAllSelection: (shouldSelect?: boolean) => void;
+    /**
+     * Clears the current selection.
+     */
+    clearSelection: () => void;
+};
+/**
+ * Small helper hook for controlled table demos and simple table integrations
+ * that need active-row state plus checkbox selection state.
+ *
+ * The hook derives stable row ids from `rows` and `rowKey`, keeps the active
+ * row and selection in sync when rows change, and provides convenience helpers
+ * for single-row and all-row toggling.
+ */
+declare const useTableSelection: <RowType extends TableRowData>(props: UseTableSelectionOptions<RowType>) => UseTableSelectionReturn;
+export default useTableSelection;