@rio-cloud/rio-uikit 2.3.0-beta.1 → 2.3.0-beta.3

package/components/table/render/header/TableHeaderDragOverlay.d.ts

@@ -1,13 +1,14 @@
+import { TableRowData } from '../../Table.types';
 import { HeaderColumn } from './TableHeader.types';
-type TableHeaderDragOverlayProps<RowType extends Record<string, unknown>> = {
-    column?: HeaderColumn<RowType>;
+type TableHeaderDragOverlayProps = {
+    column?: HeaderColumn<TableRowData>;
     header: NonNullable<{
-        columns: HeaderColumn<RowType>[];
+        columns: HeaderColumn<TableRowData>[];
         rowCount: number;
         totalColumnCount: number;
     }>;
     showSelectionColumn?: boolean;
     width?: number;
 };
-declare const TableHeaderDragOverlay: <RowType extends Record<string, unknown>>(props: TableHeaderDragOverlayProps<RowType>) => import("react/jsx-runtime").JSX.Element | null;
+declare const TableHeaderDragOverlay: (props: TableHeaderDragOverlayProps) => import("react/jsx-runtime").JSX.Element | null;
 export default TableHeaderDragOverlay;

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

@@ -1 +1 @@
-{"version":3,"file":"TableHeaderDragOverlay.js","sources":["../../../../../src/components/table/render/header/TableHeaderDragOverlay.tsx"],"sourcesContent":["import classNames from '../../../../utils/classNames';\nimport TableHeaderCellContent from './TableHeaderCellContent';\nimport { resolveHeaderCellClassName } from './resolveHeaderCellClassName';\nimport type { HeaderColumn } from './TableHeader.types';\n\ntype TableHeaderDragOverlayProps<RowType extends Record<string, unknown>> = {\n    column?: HeaderColumn<RowType>;\n    header: NonNullable<{ columns: HeaderColumn<RowType>[]; rowCount: number; totalColumnCount: number }>;\n    showSelectionColumn?: boolean;\n    width?: number;\n};\n\nconst TableHeaderDragOverlay = <RowType extends Record<string, unknown>>(\n    props: TableHeaderDragOverlayProps<RowType>\n) => {\n    const { column, header, showSelectionColumn, width } = props;\n\n    if (!column) {\n        return null;\n    }\n\n    return (\n        <div\n            className={classNames(\n                resolveHeaderCellClassName(column, header, {\n                    isDraggable: true,\n                    isResizable: false,\n                }),\n                'table-head-cell-drag-overlay'\n            )}\n            data-column={column.columnKey ?? String(column.key)}\n            role='presentation'\n            style={{ width }}\n        >\n            <TableHeaderCellContent\n                column={column}\n                header={header}\n                isResizable={false}\n                showSelectionColumn={showSelectionColumn}\n            />\n        </div>\n    );\n};\n\nexport default TableHeaderDragOverlay;\n"],"names":["TableHeaderDragOverlay","props","column","header","showSelectionColumn","width","jsx","classNames","resolveHeaderCellClassName","TableHeaderCellContent"],"mappings":";;;;AAYA,MAAMA,IAAyB,CAC3BC,MACC;AACD,QAAM,EAAE,QAAAC,GAAQ,QAAAC,GAAQ,qBAAAC,GAAqB,OAAAC,MAAUJ;AAEvD,SAAKC,IAKD,gBAAAI;AAAA,IAAC;AAAA,IAAA;AAAA,MACG,WAAWC;AAAA,QACPC,EAA2BN,GAAQC,GAAQ;AAAA,UACvC,aAAa;AAAA,UACb,aAAa;AAAA,QAAA,CAChB;AAAA,QACD;AAAA,MAAA;AAAA,MAEJ,eAAaD,EAAO,aAAa,OAAOA,EAAO,GAAG;AAAA,MAClD,MAAK;AAAA,MACL,OAAO,EAAE,OAAAG,EAAA;AAAA,MAET,UAAA,gBAAAC;AAAA,QAACG;AAAA,QAAA;AAAA,UACG,QAAAP;AAAA,UACA,QAAAC;AAAA,UACA,aAAa;AAAA,UACb,qBAAAC;AAAA,QAAA;AAAA,MAAA;AAAA,IACJ;AAAA,EAAA,IArBG;AAwBf;"}
+{"version":3,"file":"TableHeaderDragOverlay.js","sources":["../../../../../src/components/table/render/header/TableHeaderDragOverlay.tsx"],"sourcesContent":["import classNames from '../../../../utils/classNames';\nimport TableHeaderCellContent from './TableHeaderCellContent';\nimport { resolveHeaderCellClassName } from './resolveHeaderCellClassName';\nimport type { TableRowData } from '../../Table.types';\nimport type { HeaderColumn } from './TableHeader.types';\n\ntype TableHeaderDragOverlayProps = {\n    column?: HeaderColumn<TableRowData>;\n    header: NonNullable<{ columns: HeaderColumn<TableRowData>[]; rowCount: number; totalColumnCount: number }>;\n    showSelectionColumn?: boolean;\n    width?: number;\n};\n\nconst TableHeaderDragOverlay = (props: TableHeaderDragOverlayProps) => {\n    const { column, header, showSelectionColumn, width } = props;\n\n    if (!column) {\n        return null;\n    }\n\n    return (\n        <div\n            className={classNames(\n                resolveHeaderCellClassName(column, header, {\n                    isDraggable: true,\n                    isResizable: false,\n                }),\n                'table-head-cell-drag-overlay'\n            )}\n            data-column={column.columnKey ?? String(column.key)}\n            role='presentation'\n            style={{ width }}\n        >\n            <TableHeaderCellContent\n                column={column}\n                header={header}\n                isResizable={false}\n                showSelectionColumn={showSelectionColumn}\n            />\n        </div>\n    );\n};\n\nexport default TableHeaderDragOverlay;\n"],"names":["TableHeaderDragOverlay","props","column","header","showSelectionColumn","width","jsx","classNames","resolveHeaderCellClassName","TableHeaderCellContent"],"mappings":";;;;AAaA,MAAMA,IAAyB,CAACC,MAAuC;AACnE,QAAM,EAAE,QAAAC,GAAQ,QAAAC,GAAQ,qBAAAC,GAAqB,OAAAC,MAAUJ;AAEvD,SAAKC,IAKD,gBAAAI;AAAA,IAAC;AAAA,IAAA;AAAA,MACG,WAAWC;AAAA,QACPC,EAA2BN,GAAQC,GAAQ;AAAA,UACvC,aAAa;AAAA,UACb,aAAa;AAAA,QAAA,CAChB;AAAA,QACD;AAAA,MAAA;AAAA,MAEJ,eAAaD,EAAO,aAAa,OAAOA,EAAO,GAAG;AAAA,MAClD,MAAK;AAAA,MACL,OAAO,EAAE,OAAAG,EAAA;AAAA,MAET,UAAA,gBAAAC;AAAA,QAACG;AAAA,QAAA;AAAA,UACG,QAAAP;AAAA,UACA,QAAAC;AAAA,UACA,aAAa;AAAA,UACb,qBAAAC;AAAA,QAAA;AAAA,MAAA;AAAA,IACJ;AAAA,EAAA,IArBG;AAwBf;"}

package/components/table/render/header/TableStaticHeaderCell.d.ts

@@ -1,3 +1,4 @@
+import { TableRowData } from '../../Table.types';
 import { SharedHeaderCellProps } from './TableHeader.types';
-declare const TableStaticHeaderCell: <RowType extends Record<string, unknown>>(props: SharedHeaderCellProps<RowType>) => import("react/jsx-runtime").JSX.Element;
+declare const TableStaticHeaderCell: (props: SharedHeaderCellProps<TableRowData>) => import("react/jsx-runtime").JSX.Element;
 export default TableStaticHeaderCell;

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

@@ -1,36 +1,50 @@
-import { jsxs as n, jsx as l } from "react/jsx-runtime";
-import s from "../../../../utils/classNames.js";
-import d from "./TableHeaderCellContent.js";
-import c from "./TableHeaderCellResizeHandle.js";
+import { jsxs as C, jsx as i } from "react/jsx-runtime";
+import S from "../../../../utils/classNames.js";
+import f from "./TableHeaderCellContent.js";
+import h from "./TableHeaderCellResizeHandle.js";
 import { resolveAriaSort as p } from "./resolveAriaSort.js";
-import { resolveHeaderCellClassName as S } from "./resolveHeaderCellClassName.js";
-import { resolveHeaderCellStyle as f } from "./resolveHeaderCellStyle.js";
-import { resolveAriaSpan as o, resolveAriaColIndex as C } from "../../shared/resolveTableAria.js";
-const y = (r) => {
-  const { column: e, header: i, hideWhileDragging: t, isResizable: m, showSelectionColumn: a } = r;
-  return /* @__PURE__ */ n(
+import { resolveHeaderCellClassName as y } from "./resolveHeaderCellClassName.js";
+import { resolveHeaderCellStyle as g } from "./resolveHeaderCellStyle.js";
+import { resolveAriaSpan as n, resolveAriaColIndex as k } from "../../shared/resolveTableAria.js";
+const N = (o) => {
+  const {
+    column: e,
+    header: l,
+    hideWhileDragging: m,
+    htmlAttributes: s,
+    isResizable: c,
+    showSelectionColumn: t,
+    stickyLeftColumnCount: u,
+    stickyRightColumnCount: d
+  } = o, r = u ?? 0, a = d ?? 0;
+  return /* @__PURE__ */ C(
     "div",
     {
-      className: s(
-        S(e, i, { isResizable: m }),
-        t && "table-head-cell-drag-placeholder"
+      ...s,
+      className: S(
+        y(e, l, {
+          isResizable: c,
+          isStickyLeftColumn: r > 0 && e.columnStart <= r,
+          isStickyRightColumn: a > 0 && e.columnStart + e.colSpan - 1 > l.totalColumnCount - a
+        }),
+        m && "table-head-cell-drag-placeholder"
       ),
       "data-column": e.columnKey ?? String(e.key),
       role: "columnheader",
-      "aria-colindex": C(e.columnStart, a),
-      "aria-colspan": o(e.colSpan),
+      "aria-colindex": k(e.columnStart, t),
+      "aria-colspan": n(e.colSpan),
       "aria-rowindex": e.rowStart,
-      "aria-rowspan": o(e.rowSpan),
+      "aria-rowspan": n(e.rowSpan),
       "aria-sort": p(e),
-      style: f(e, a),
+      style: g(e, t),
       children: [
-        /* @__PURE__ */ l(d, { ...r }),
-        /* @__PURE__ */ l(c, { ...r })
+        /* @__PURE__ */ i(f, { ...o }),
+        /* @__PURE__ */ i(h, { ...o })
       ]
     }
   );
 };
 export {
-  y as default
+  N as default
 };
 //# sourceMappingURL=TableStaticHeaderCell.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"TableStaticHeaderCell.js","sources":["../../../../../src/components/table/render/header/TableStaticHeaderCell.tsx"],"sourcesContent":["import classNames from '../../../../utils/classNames';\nimport TableHeaderCellContent from './TableHeaderCellContent';\nimport TableHeaderCellResizeHandle from './TableHeaderCellResizeHandle';\nimport { resolveAriaSort } from './resolveAriaSort';\nimport { resolveHeaderCellClassName } from './resolveHeaderCellClassName';\nimport { resolveHeaderCellStyle } from './resolveHeaderCellStyle';\nimport type { SharedHeaderCellProps } from './TableHeader.types';\nimport { resolveAriaColIndex, resolveAriaSpan } from '../../shared/resolveTableAria';\n\nconst TableStaticHeaderCell = <RowType extends Record<string, unknown>>(props: SharedHeaderCellProps<RowType>) => {\n    const { column, header, hideWhileDragging, isResizable, showSelectionColumn } = props;\n\n    return (\n        <div\n            className={classNames(\n                resolveHeaderCellClassName(column, header, { isResizable }),\n                hideWhileDragging && 'table-head-cell-drag-placeholder'\n            )}\n            data-column={column.columnKey ?? String(column.key)}\n            role='columnheader'\n            aria-colindex={resolveAriaColIndex(column.columnStart, showSelectionColumn)}\n            aria-colspan={resolveAriaSpan(column.colSpan)}\n            aria-rowindex={column.rowStart}\n            aria-rowspan={resolveAriaSpan(column.rowSpan)}\n            aria-sort={resolveAriaSort(column)}\n            style={resolveHeaderCellStyle(column, showSelectionColumn)}\n        >\n            <TableHeaderCellContent {...props} />\n            <TableHeaderCellResizeHandle {...props} />\n        </div>\n    );\n};\n\nexport default TableStaticHeaderCell;\n"],"names":["TableStaticHeaderCell","props","column","header","hideWhileDragging","isResizable","showSelectionColumn","jsxs","classNames","resolveHeaderCellClassName","resolveAriaColIndex","resolveAriaSpan","resolveAriaSort","resolveHeaderCellStyle","jsx","TableHeaderCellContent","TableHeaderCellResizeHandle"],"mappings":";;;;;;;;AASA,MAAMA,IAAwB,CAA0CC,MAA0C;AAC9G,QAAM,EAAE,QAAAC,GAAQ,QAAAC,GAAQ,mBAAAC,GAAmB,aAAAC,GAAa,qBAAAC,MAAwBL;AAEhF,SACI,gBAAAM;AAAA,IAAC;AAAA,IAAA;AAAA,MACG,WAAWC;AAAA,QACPC,EAA2BP,GAAQC,GAAQ,EAAE,aAAAE,GAAa;AAAA,QAC1DD,KAAqB;AAAA,MAAA;AAAA,MAEzB,eAAaF,EAAO,aAAa,OAAOA,EAAO,GAAG;AAAA,MAClD,MAAK;AAAA,MACL,iBAAeQ,EAAoBR,EAAO,aAAaI,CAAmB;AAAA,MAC1E,gBAAcK,EAAgBT,EAAO,OAAO;AAAA,MAC5C,iBAAeA,EAAO;AAAA,MACtB,gBAAcS,EAAgBT,EAAO,OAAO;AAAA,MAC5C,aAAWU,EAAgBV,CAAM;AAAA,MACjC,OAAOW,EAAuBX,GAAQI,CAAmB;AAAA,MAEzD,UAAA;AAAA,QAAA,gBAAAQ,EAACC,GAAA,EAAwB,GAAGd,GAAO;AAAA,QACnC,gBAAAa,EAACE,GAAA,EAA6B,GAAGf,EAAA,CAAO;AAAA,MAAA;AAAA,IAAA;AAAA,EAAA;AAGpD;"}
+{"version":3,"file":"TableStaticHeaderCell.js","sources":["../../../../../src/components/table/render/header/TableStaticHeaderCell.tsx"],"sourcesContent":["import classNames from '../../../../utils/classNames';\nimport type { TableRowData } from '../../Table.types';\nimport TableHeaderCellContent from './TableHeaderCellContent';\nimport TableHeaderCellResizeHandle from './TableHeaderCellResizeHandle';\nimport { resolveAriaSort } from './resolveAriaSort';\nimport { resolveHeaderCellClassName } from './resolveHeaderCellClassName';\nimport { resolveHeaderCellStyle } from './resolveHeaderCellStyle';\nimport type { SharedHeaderCellProps } from './TableHeader.types';\nimport { resolveAriaColIndex, resolveAriaSpan } from '../../shared/resolveTableAria';\n\nconst TableStaticHeaderCell = (props: SharedHeaderCellProps<TableRowData>) => {\n    const {\n        column,\n        header,\n        hideWhileDragging,\n        htmlAttributes,\n        isResizable,\n        showSelectionColumn,\n        stickyLeftColumnCount,\n        stickyRightColumnCount,\n    } = props;\n\n    const stickyLeftColumns = stickyLeftColumnCount ?? 0;\n    const stickyRightColumns = stickyRightColumnCount ?? 0;\n\n    return (\n        <div\n            {...htmlAttributes}\n            className={classNames(\n                resolveHeaderCellClassName(column, header, {\n                    isResizable,\n                    isStickyLeftColumn: stickyLeftColumns > 0 && column.columnStart <= stickyLeftColumns,\n                    isStickyRightColumn:\n                        stickyRightColumns > 0 &&\n                        column.columnStart + column.colSpan - 1 > header.totalColumnCount - stickyRightColumns,\n                }),\n                hideWhileDragging && 'table-head-cell-drag-placeholder'\n            )}\n            data-column={column.columnKey ?? String(column.key)}\n            role='columnheader'\n            aria-colindex={resolveAriaColIndex(column.columnStart, showSelectionColumn)}\n            aria-colspan={resolveAriaSpan(column.colSpan)}\n            aria-rowindex={column.rowStart}\n            aria-rowspan={resolveAriaSpan(column.rowSpan)}\n            aria-sort={resolveAriaSort(column)}\n            style={resolveHeaderCellStyle(column, showSelectionColumn)}\n        >\n            <TableHeaderCellContent {...props} />\n            <TableHeaderCellResizeHandle {...props} />\n        </div>\n    );\n};\n\nexport default TableStaticHeaderCell;\n"],"names":["TableStaticHeaderCell","props","column","header","hideWhileDragging","htmlAttributes","isResizable","showSelectionColumn","stickyLeftColumnCount","stickyRightColumnCount","stickyLeftColumns","stickyRightColumns","jsxs","classNames","resolveHeaderCellClassName","resolveAriaColIndex","resolveAriaSpan","resolveAriaSort","resolveHeaderCellStyle","jsx","TableHeaderCellContent","TableHeaderCellResizeHandle"],"mappings":";;;;;;;;AAUA,MAAMA,IAAwB,CAACC,MAA+C;AAC1E,QAAM;AAAA,IACF,QAAAC;AAAA,IACA,QAAAC;AAAA,IACA,mBAAAC;AAAA,IACA,gBAAAC;AAAA,IACA,aAAAC;AAAA,IACA,qBAAAC;AAAA,IACA,uBAAAC;AAAA,IACA,wBAAAC;AAAA,EAAA,IACAR,GAEES,IAAoBF,KAAyB,GAC7CG,IAAqBF,KAA0B;AAErD,SACI,gBAAAG;AAAA,IAAC;AAAA,IAAA;AAAA,MACI,GAAGP;AAAA,MACJ,WAAWQ;AAAA,QACPC,EAA2BZ,GAAQC,GAAQ;AAAA,UACvC,aAAAG;AAAA,UACA,oBAAoBI,IAAoB,KAAKR,EAAO,eAAeQ;AAAA,UACnE,qBACIC,IAAqB,KACrBT,EAAO,cAAcA,EAAO,UAAU,IAAIC,EAAO,mBAAmBQ;AAAA,QAAA,CAC3E;AAAA,QACDP,KAAqB;AAAA,MAAA;AAAA,MAEzB,eAAaF,EAAO,aAAa,OAAOA,EAAO,GAAG;AAAA,MAClD,MAAK;AAAA,MACL,iBAAea,EAAoBb,EAAO,aAAaK,CAAmB;AAAA,MAC1E,gBAAcS,EAAgBd,EAAO,OAAO;AAAA,MAC5C,iBAAeA,EAAO;AAAA,MACtB,gBAAcc,EAAgBd,EAAO,OAAO;AAAA,MAC5C,aAAWe,EAAgBf,CAAM;AAAA,MACjC,OAAOgB,EAAuBhB,GAAQK,CAAmB;AAAA,MAEzD,UAAA;AAAA,QAAA,gBAAAY,EAACC,GAAA,EAAwB,GAAGnB,GAAO;AAAA,QACnC,gBAAAkB,EAACE,GAAA,EAA6B,GAAGpB,EAAA,CAAO;AAAA,MAAA;AAAA,IAAA;AAAA,EAAA;AAGpD;"}

package/components/table/render/header/resolveAriaSort.d.ts

@@ -1,2 +1,3 @@
+import { TableRowData } from '../../Table.types';
 import { HeaderColumn } from './TableHeader.types';
-export declare const resolveAriaSort: <RowType extends Record<string, unknown>>(column: HeaderColumn<RowType>) => "none" | "ascending" | "descending" | undefined;
+export declare const resolveAriaSort: (column: HeaderColumn<TableRowData>) => "none" | "ascending" | "descending" | undefined;

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

@@ -1 +1 @@
-{"version":3,"file":"resolveAriaSort.js","sources":["../../../../../src/components/table/render/header/resolveAriaSort.ts"],"sourcesContent":["import type { HeaderColumn } from './TableHeader.types';\n\nexport const resolveAriaSort = <RowType extends Record<string, unknown>>(column: HeaderColumn<RowType>) => {\n    if (!column.sortable) {\n        return;\n    }\n\n    if (column.sortDirection === 'asc') {\n        return 'ascending';\n    }\n\n    if (column.sortDirection === 'desc') {\n        return 'descending';\n    }\n\n    return 'none';\n};\n"],"names":["resolveAriaSort","column"],"mappings":"AAEO,MAAMA,IAAkB,CAA0CC,MAAkC;AACvG,MAAKA,EAAO;AAIZ,WAAIA,EAAO,kBAAkB,QAClB,cAGPA,EAAO,kBAAkB,SAClB,eAGJ;AACX;"}
+{"version":3,"file":"resolveAriaSort.js","sources":["../../../../../src/components/table/render/header/resolveAriaSort.ts"],"sourcesContent":["import type { TableRowData } from '../../Table.types';\nimport type { HeaderColumn } from './TableHeader.types';\n\nexport const resolveAriaSort = (column: HeaderColumn<TableRowData>) => {\n    if (!column.sortable) {\n        return;\n    }\n\n    if (column.sortDirection === 'asc') {\n        return 'ascending';\n    }\n\n    if (column.sortDirection === 'desc') {\n        return 'descending';\n    }\n\n    return 'none';\n};\n"],"names":["resolveAriaSort","column"],"mappings":"AAGO,MAAMA,IAAkB,CAACC,MAAuC;AACnE,MAAKA,EAAO;AAIZ,WAAIA,EAAO,kBAAkB,QAClB,cAGPA,EAAO,kBAAkB,SAClB,eAGJ;AACX;"}

package/components/table/render/header/resolveHeaderCellClassName.d.ts

@@ -1,10 +1,13 @@
+import { TableRowData } from '../../Table.types';
 import { HeaderColumn } from './TableHeader.types';
-export declare const resolveHeaderCellClassName: <RowType extends Record<string, unknown>>(column: HeaderColumn<RowType>, header: NonNullable<{
-    columns: HeaderColumn<RowType>[];
+export declare const resolveHeaderCellClassName: (column: HeaderColumn<TableRowData>, header: NonNullable<{
+    columns: HeaderColumn<TableRowData>[];
     rowCount: number;
     totalColumnCount: number;
 }>, options: {
     isDraggable?: boolean;
     isDragging?: boolean;
     isResizable: boolean;
+    isStickyLeftColumn?: boolean;
+    isStickyRightColumn?: boolean;
 }) => string;

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

@@ -1,22 +1,24 @@
-import s from "../../../../utils/classNames.js";
-import { getVerticalAlignClassName as o, getHorizontalAlignClassName as b } from "../../shared/getAlignClassName.js";
-const h = (e, a, l) => {
-  const { isDraggable: t, isDragging: r, isResizable: i } = l;
-  return s(
+import b from "../../../../utils/classNames.js";
+import { getVerticalAlignClassName as d, getHorizontalAlignClassName as g } from "../../shared/getAlignClassName.js";
+const n = (e, l, a) => {
+  const { isDraggable: t, isDragging: i, isResizable: r, isStickyLeftColumn: s, isStickyRightColumn: o } = a;
+  return b(
     "table-head-cell",
     e.sortable && "table-head-cell-sortable",
     t && "table-head-cell-draggable",
-    r && "table-head-cell-dragging",
-    i && "table-head-cell-resizable",
-    e.columnStart + e.colSpan - 1 < a.totalColumnCount && "table-head-cell-has-column-divider",
-    e.rowStart + e.rowSpan - 1 < a.rowCount && "table-head-cell-has-row-divider",
-    b(e.horizontalAlign),
-    o(e.verticalAlign),
+    i && "table-head-cell-dragging",
+    r && "table-head-cell-resizable",
+    s && "table-head-cell-sticky-left-column",
+    o && "table-head-cell-sticky-right-column",
+    e.columnStart + e.colSpan - 1 < l.totalColumnCount && "table-head-cell-has-column-divider",
+    e.rowStart + e.rowSpan - 1 < l.rowCount && "table-head-cell-has-row-divider",
+    g(e.horizontalAlign),
+    d(e.verticalAlign),
     e.hideOnMobile && "table-hide-mobile",
     e.headerClassName
   );
 };
 export {
-  h as resolveHeaderCellClassName
+  n as resolveHeaderCellClassName
 };
 //# sourceMappingURL=resolveHeaderCellClassName.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"resolveHeaderCellClassName.js","sources":["../../../../../src/components/table/render/header/resolveHeaderCellClassName.ts"],"sourcesContent":["import classNames from '../../../../utils/classNames';\nimport { getHorizontalAlignClassName, getVerticalAlignClassName } from '../../shared/getAlignClassName';\nimport type { HeaderColumn } from './TableHeader.types';\n\nexport const resolveHeaderCellClassName = <RowType extends Record<string, unknown>>(\n    column: HeaderColumn<RowType>,\n    header: NonNullable<{ columns: HeaderColumn<RowType>[]; rowCount: number; totalColumnCount: number }>,\n    options: {\n        isDraggable?: boolean;\n        isDragging?: boolean;\n        isResizable: boolean;\n    }\n) => {\n    const { isDraggable, isDragging, isResizable } = options;\n\n    return classNames(\n        'table-head-cell',\n        column.sortable && 'table-head-cell-sortable',\n        isDraggable && 'table-head-cell-draggable',\n        isDragging && 'table-head-cell-dragging',\n        isResizable && 'table-head-cell-resizable',\n        column.columnStart + column.colSpan - 1 < header.totalColumnCount && 'table-head-cell-has-column-divider',\n        column.rowStart + column.rowSpan - 1 < header.rowCount && 'table-head-cell-has-row-divider',\n        getHorizontalAlignClassName(column.horizontalAlign),\n        getVerticalAlignClassName(column.verticalAlign),\n        column.hideOnMobile && 'table-hide-mobile',\n        column.headerClassName\n    );\n};\n"],"names":["resolveHeaderCellClassName","column","header","options","isDraggable","isDragging","isResizable","classNames","getHorizontalAlignClassName","getVerticalAlignClassName"],"mappings":";;AAIO,MAAMA,IAA6B,CACtCC,GACAC,GACAC,MAKC;AACD,QAAM,EAAE,aAAAC,GAAa,YAAAC,GAAY,aAAAC,EAAA,IAAgBH;AAEjD,SAAOI;AAAA,IACH;AAAA,IACAN,EAAO,YAAY;AAAA,IACnBG,KAAe;AAAA,IACfC,KAAc;AAAA,IACdC,KAAe;AAAA,IACfL,EAAO,cAAcA,EAAO,UAAU,IAAIC,EAAO,oBAAoB;AAAA,IACrED,EAAO,WAAWA,EAAO,UAAU,IAAIC,EAAO,YAAY;AAAA,IAC1DM,EAA4BP,EAAO,eAAe;AAAA,IAClDQ,EAA0BR,EAAO,aAAa;AAAA,IAC9CA,EAAO,gBAAgB;AAAA,IACvBA,EAAO;AAAA,EAAA;AAEf;"}
+{"version":3,"file":"resolveHeaderCellClassName.js","sources":["../../../../../src/components/table/render/header/resolveHeaderCellClassName.ts"],"sourcesContent":["import classNames from '../../../../utils/classNames';\nimport { getHorizontalAlignClassName, getVerticalAlignClassName } from '../../shared/getAlignClassName';\nimport type { TableRowData } from '../../Table.types';\nimport type { HeaderColumn } from './TableHeader.types';\n\nexport const resolveHeaderCellClassName = (\n    column: HeaderColumn<TableRowData>,\n    header: NonNullable<{ columns: HeaderColumn<TableRowData>[]; rowCount: number; totalColumnCount: number }>,\n    options: {\n        isDraggable?: boolean;\n        isDragging?: boolean;\n        isResizable: boolean;\n        isStickyLeftColumn?: boolean;\n        isStickyRightColumn?: boolean;\n    }\n) => {\n    const { isDraggable, isDragging, isResizable, isStickyLeftColumn, isStickyRightColumn } = options;\n\n    return classNames(\n        'table-head-cell',\n        column.sortable && 'table-head-cell-sortable',\n        isDraggable && 'table-head-cell-draggable',\n        isDragging && 'table-head-cell-dragging',\n        isResizable && 'table-head-cell-resizable',\n        isStickyLeftColumn && 'table-head-cell-sticky-left-column',\n        isStickyRightColumn && 'table-head-cell-sticky-right-column',\n        column.columnStart + column.colSpan - 1 < header.totalColumnCount && 'table-head-cell-has-column-divider',\n        column.rowStart + column.rowSpan - 1 < header.rowCount && 'table-head-cell-has-row-divider',\n        getHorizontalAlignClassName(column.horizontalAlign),\n        getVerticalAlignClassName(column.verticalAlign),\n        column.hideOnMobile && 'table-hide-mobile',\n        column.headerClassName\n    );\n};\n"],"names":["resolveHeaderCellClassName","column","header","options","isDraggable","isDragging","isResizable","isStickyLeftColumn","isStickyRightColumn","classNames","getHorizontalAlignClassName","getVerticalAlignClassName"],"mappings":";;AAKO,MAAMA,IAA6B,CACtCC,GACAC,GACAC,MAOC;AACD,QAAM,EAAE,aAAAC,GAAa,YAAAC,GAAY,aAAAC,GAAa,oBAAAC,GAAoB,qBAAAC,MAAwBL;AAE1F,SAAOM;AAAA,IACH;AAAA,IACAR,EAAO,YAAY;AAAA,IACnBG,KAAe;AAAA,IACfC,KAAc;AAAA,IACdC,KAAe;AAAA,IACfC,KAAsB;AAAA,IACtBC,KAAuB;AAAA,IACvBP,EAAO,cAAcA,EAAO,UAAU,IAAIC,EAAO,oBAAoB;AAAA,IACrED,EAAO,WAAWA,EAAO,UAAU,IAAIC,EAAO,YAAY;AAAA,IAC1DQ,EAA4BT,EAAO,eAAe;AAAA,IAClDU,EAA0BV,EAAO,aAAa;AAAA,IAC9CA,EAAO,gBAAgB;AAAA,IACvBA,EAAO;AAAA,EAAA;AAEf;"}

package/components/table/render/header/resolveHeaderCellStyle.d.ts

@@ -1,6 +1,7 @@
 import { CSSProperties } from 'react';
+import { TableRowData } from '../../Table.types';
 import { HeaderColumn } from './TableHeader.types';
-export declare const resolveHeaderCellStyle: <RowType extends Record<string, unknown>>(column: HeaderColumn<RowType>, showSelectionColumn?: boolean, extraStyle?: CSSProperties) => {
+export declare const resolveHeaderCellStyle: (column: HeaderColumn<TableRowData>, showSelectionColumn?: boolean, extraStyle?: CSSProperties) => {
     accentColor?: import("csstype").Property.AccentColor | undefined;
     alignContent?: import("csstype").Property.AlignContent | undefined;
     alignItems?: import("csstype").Property.AlignItems | undefined;

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

@@ -1 +1 @@
-{"version":3,"file":"resolveHeaderCellStyle.js","sources":["../../../../../src/components/table/render/header/resolveHeaderCellStyle.ts"],"sourcesContent":["import type { CSSProperties } from 'react';\n\nimport type { HeaderColumn } from './TableHeader.types';\n\nexport const resolveHeaderCellStyle = <RowType extends Record<string, unknown>>(\n    column: HeaderColumn<RowType>,\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":"AAIO,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;"}
+{"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>;
+    renderDataColumns: RenderHeaderColumn<RowType>[];
+    resizeColumnsEnabled: boolean;
+    resolvedRenderColumns: RenderHeaderColumn<RowType>[];
+    resizedColumns: ReturnType<typeof useResizableColumns<RowType>>['resizedColumns'];
+};
+/**
+ * Resolves the actual data 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 actual data columns.
+ *
+ * This hook therefore:
+ * - narrows registered header cells down to single-column data headers 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 A } from "../layout/useDraggableColumns.js";
+import { useResizableColumns as L } 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 } = A({
+    columns: n,
+    columnOrder: g,
+    enabled: o,
+    onColumnOrderChange: C
+  }), h = d === "TABLE" && b.some((e) => e.resizeable === !0), {
+    handleColumnResizeReset: K,
+    handleColumnResizeStart: M,
+    lastResizableColumnKey: W,
+    resettableColumnKeys: f,
+    resizedColumns: r
+  } = L({
+    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]
+  ), x = l(
+    () => new Map(s.map((e, a) => [e.columnKey, a])),
+    [s]
+  );
+  return {
+    columnDefinitionsByKey: w,
+    columnIndexByKey: x,
+    draggableColumnKeys: R,
+    draggableColumnsEnabled: o,
+    handleColumnDragEnd: p,
+    handleColumnResizeReset: K,
+    handleColumnResizeStart: M,
+    lastResizableColumnKey: W,
+    resettableColumnKeys: f,
+    renderDataColumns: 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    renderDataColumns: RenderHeaderColumn<RowType>[];\n    resizeColumnsEnabled: boolean;\n    resolvedRenderColumns: RenderHeaderColumn<RowType>[];\n    resizedColumns: ReturnType<typeof useResizableColumns<RowType>>['resizedColumns'];\n};\n\n/**\n * Resolves the actual data 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 actual data columns.\n *\n * This hook therefore:\n * - narrows registered header cells down to single-column data headers 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 single-column 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 renderDataColumns = 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            renderDataColumns.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        [renderDataColumns]\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 data\n    // columns so the rest of the table can render from one normalized shape.\n    const resolvedRenderColumns = useMemo(() => {\n        const renderColumnsByKey = new Map(renderDataColumns.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    }, [renderDataColumns, 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        renderDataColumns,\n        resizeColumnsEnabled,\n        resolvedRenderColumns,\n        resizedColumns,\n    };\n};\n\nexport default useResolvedRenderColumns;\n"],"names":["useResolvedRenderColumns","props","columnOrder","onColumnOrderChange","onColumnResize","renderHeaderColumns","viewType","renderDataColumns","useMemo","column","baseRenderColumnDefinitions","draggableColumnsEnabled","draggableColumnKeys","handleColumnDragEnd","orderedColumns","useDraggableColumns","resizeColumnsEnabled","handleColumnResizeReset","handleColumnResizeStart","lastResizableColumnKey","resettableColumnKeys","resizedColumns","useResizableColumns","resolvedRenderColumns","renderColumnsByKey","renderColumn","columnDefinitionsByKey","columnIndexByKey","index"],"mappings":";;;AA8CA,MAAMA,IAA2B,CAC7BC,MAC0C;AAC1C,QAAM,EAAE,aAAAC,GAAa,qBAAAC,GAAqB,gBAAAC,GAAgB,qBAAAC,GAAqB,UAAAC,MAAaL,GAKtFM,IAAoBC;AAAA,IACtB,MACIH,EAAoB;AAAA,MAAQ,CAAAI,MACxBA,EAAO,aAAaA,EAAO,YAAY,IACjC;AAAA,QACI;AAAA,UACI,GAAGA;AAAA,UACH,WAAWA,EAAO;AAAA,QAAA;AAAA,MACtB,IAEJ,CAAA;AAAA,IAAC;AAAA,IAEf,CAACJ,CAAmB;AAAA,EAAA,GAGlBK,IAA8BF;AAAA,IAChC,MACID,EAAkB,IAAI,CAAAE,OAAW;AAAA,MAC7B,KAAKA,EAAO;AAAA,MACZ,OAAOA,EAAO;AAAA,MACd,aAAaA,EAAO;AAAA,MACpB,OAAOA,EAAO;AAAA,MACd,gBAAgBA,EAAO;AAAA,MACvB,gBAAgBA,EAAO;AAAA,MACvB,WAAWA,EAAO;AAAA,MAClB,YAAYA,EAAO;AAAA,MACnB,iBAAiBA,EAAO;AAAA,MACxB,iBAAiBA,EAAO;AAAA,MACxB,cAAcA,EAAO;AAAA,MACrB,UAAUA,EAAO;AAAA,IAAA,EACnB;AAAA,IACN,CAACF,CAAiB;AAAA,EAAA,GAGhBI,IACFL,MAAa,WAAWI,EAA4B,OAAO,OAAUD,EAAO,cAAc,EAAI,EAAE,SAAS,GACvG,EAAE,qBAAAG,GAAqB,qBAAAC,GAAqB,gBAAAC,EAAA,IAAmBC,EAAoB;AAAA,IACrF,SAASL;AAAA,IACT,aAAAR;AAAA,IACA,SAASS;AAAA,IACT,qBAAAR;AAAA,EAAA,CACH,GAEKa,IAAuBV,MAAa,WAAWQ,EAAe,KAAK,CAAAL,MAAUA,EAAO,eAAe,EAAI,GACvG;AAAA,IACF,yBAAAQ;AAAA,IACA,yBAAAC;AAAA,IACA,wBAAAC;AAAA,IACA,sBAAAC;AAAA,IACA,gBAAAC;AAAA,EAAA,IACAC,EAAoB;AAAA,IACpB,SAASR;AAAA,IACT,SAASE;AAAA,IACT,gBAAAZ;AAAA,EAAA,CACH,GAIKmB,IAAwBf,EAAQ,MAAM;AACxC,UAAMgB,IAAqB,IAAI,IAAIjB,EAAkB,IAAI,CAAAE,MAAU,CAACA,EAAO,WAAWA,CAAM,CAAU,CAAC;AAEvG,WAAOY,EAAe,QAAQ,CAAAZ,MAAU;AACpC,YAAMgB,IAAeD,EAAmB,IAAIf,EAAO,GAAG;AAEtD,aAAOgB,IACD;AAAA,QACI;AAAA,UACI,GAAGA;AAAA,UACH,OAAOhB,EAAO;AAAA,UACd,gBAAgBA,EAAO;AAAA,UACvB,gBAAgBA,EAAO;AAAA,UACvB,WAAWA,EAAO;AAAA,UAClB,YAAYA,EAAO;AAAA,UACnB,iBAAiBA,EAAO;AAAA,UACxB,iBAAiBA,EAAO;AAAA,UACxB,cAAcA,EAAO;AAAA,UACrB,UAAUA,EAAO;AAAA,QAAA;AAAA,MACrB,IAEJ,CAAA;AAAA,IACV,CAAC;AAAA,EACL,GAAG,CAACF,GAAmBc,CAAc,CAAC,GAIhCK,IAAyBlB;AAAA,IAC3B,MACI,IAAI;AAAA,MACAe,EAAsB,IAAI,CAAAd,MAAU;AAAA,QAChCA,EAAO;AAAA,QACP;AAAA,UACI,KAAKA,EAAO;AAAA,UACZ,OAAOA,EAAO;AAAA,UACd,aAAaA,EAAO;AAAA,UACpB,MAAMA,EAAO;AAAA,UACb,QAAQA,EAAO;AAAA,UACf,WAAWA,EAAO;AAAA,UAClB,OAAOA,EAAO;AAAA,UACd,gBAAgBA,EAAO;AAAA,UACvB,gBAAgBA,EAAO;AAAA,UACvB,WAAWA,EAAO;AAAA,UAClB,YAAYA,EAAO;AAAA,UACnB,iBAAiBA,EAAO;AAAA,UACxB,WAAW;AAAA,UACX,iBAAiBA,EAAO;AAAA,UACxB,cAAcA,EAAO;AAAA,UACrB,UAAUA,EAAO;AAAA,QAAA;AAAA,MACrB,CACH;AAAA,IAAA;AAAA,IAET,CAACc,CAAqB;AAAA,EAAA,GAEpBI,IAAmBnB;AAAA,IACrB,MAAM,IAAI,IAAIe,EAAsB,IAAI,CAACd,GAAQmB,MAAU,CAACnB,EAAO,WAAWmB,CAAK,CAAU,CAAC;AAAA,IAC9F,CAACL,CAAqB;AAAA,EAAA;AAG1B,SAAO;AAAA,IACH,wBAAAG;AAAA,IACA,kBAAAC;AAAA,IACA,qBAAAf;AAAA,IACA,yBAAAD;AAAA,IACA,qBAAAE;AAAA,IACA,yBAAAI;AAAA,IACA,yBAAAC;AAAA,IACA,wBAAAC;AAAA,IACA,sBAAAC;AAAA,IACA,mBAAAb;AAAA,IACA,sBAAAS;AAAA,IACA,uBAAAO;AAAA,IACA,gBAAAF;AAAA,EAAA;AAER;"}

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 data 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;