pixelize-design-library 3.0.1-beta.1 → 3.1.0

package/dist/esm/Components/Table/components/TableActions.js

@@ -0,0 +1,72 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React, { forwardRef, useEffect, useId, useLayoutEffect, useRef, useState } from "react";
+import { Button, IconButton, Popover, PopoverAnchor, PopoverBody, PopoverContent, Portal, VStack, } from "@chakra-ui/react";
+import { EllipsisVertical, ExternalLink, Pencil, Trash2 } from "lucide-react";
+import { useCustomTheme } from "../../../Theme/useCustomTheme.js";
+import { raisedRule } from "../../../Theme/tokens/builders/surfaceRaised.js";
+const assignRef = (ref, value) => {
+    if (typeof ref === "function")
+        ref(value);
+    else if (ref)
+        ref.current = value;
+};
+const TriggerAnchor = forwardRef(({ target }, ref) => {
+    useLayoutEffect(() => {
+        assignRef(ref, target.current);
+        return () => assignRef(ref, null);
+    }, [ref, target]);
+    return null;
+});
+TriggerAnchor.displayName = "TriggerAnchor";
+const TableActions = React.memo(({ row }) => {
+    var _a;
+    const [isOpen, setIsOpen] = useState(false);
+    const ref = useRef(null);
+    const triggerRef = useRef(null);
+    const popoverId = useId();
+    const theme = useCustomTheme();
+    useEffect(() => {
+        if (!isOpen)
+            return;
+        const trigger = triggerRef.current;
+        const closeAll = () => setIsOpen(false);
+        const handleClickOutside = (event) => {
+            if (ref.current && !ref.current.contains(event.target)) {
+                setIsOpen(false);
+            }
+        };
+        window.addEventListener("close-all-popovers", closeAll);
+        document.addEventListener("click", handleClickOutside);
+        return () => {
+            window.removeEventListener("close-all-popovers", closeAll);
+            document.removeEventListener("click", handleClickOutside);
+            requestAnimationFrame(() => {
+                if (document.activeElement === document.body)
+                    trigger === null || trigger === void 0 ? void 0 : trigger.focus({ preventScroll: true });
+            });
+        };
+    }, [isOpen]);
+    const handleOpen = () => {
+        window.dispatchEvent(new Event("close-all-popovers")); // close others
+        setIsOpen(true);
+    };
+    const handleClose = () => setIsOpen(false);
+    // ✅ if row itself is missing, render nothing
+    if (!row)
+        return null;
+    return (_jsxs("div", { ref: ref, children: [_jsx(IconButton, { ref: triggerRef, id: `popover-trigger-${popoverId}`, "aria-label": "Actions", "aria-haspopup": "dialog", "aria-expanded": isOpen, "aria-controls": `popover-content-${popoverId}`, color: theme.colors.text[900], icon: _jsx(EllipsisVertical, { size: 17 }), size: "sm", p: 0, variant: "ghost", _hover: { transform: "scale(1.2)" }, onClick: () => (isOpen ? handleClose() : handleOpen()) }), isOpen && (_jsxs(Popover, { id: popoverId, placement: "bottom-start", isOpen: true, onClose: handleClose, closeOnBlur: false, returnFocusOnClose: false, children: [_jsx(PopoverAnchor, { children: _jsx(TriggerAnchor, { target: triggerRef }) }), _jsx(Portal, { children: _jsx(PopoverContent, { w: "auto", minW: "100px", boxShadow: "lg", p: 0, zIndex: 999, bg: theme.colors.surfaceRaised, children: _jsx(PopoverBody, { p: 0, m: 0, children: _jsxs(VStack, { align: "stretch", spacing: 1, p: 0, m: 0, children: [row.onLink && (_jsxs(Button, { size: "sm", variant: "ghost", justifyContent: "flex-start", borderBottom: `1px solid ${raisedRule(theme.colors)}`, borderRadius: 0, gap: 2, onClick: () => {
+                                                var _a;
+                                                (_a = row.onLink) === null || _a === void 0 ? void 0 : _a.call(row, row);
+                                                handleClose();
+                                            }, children: [_jsx(ExternalLink, { size: 17 }), " View"] })), row.onEdit && (_jsxs(Button, { size: "sm", variant: "ghost", justifyContent: "flex-start", gap: 2, borderBottom: `1px solid ${raisedRule(theme.colors)}`, borderRadius: 0, onClick: () => {
+                                                var _a;
+                                                (_a = row.onEdit) === null || _a === void 0 ? void 0 : _a.call(row, row);
+                                                handleClose();
+                                            }, children: [_jsx(Pencil, { size: 17 }), " Edit"] })), row.actions && ((_a = row === null || row === void 0 ? void 0 : row.actions) === null || _a === void 0 ? void 0 : _a.call(row)), row.onDelete && (_jsxs(Button, { size: "sm", variant: "ghost", justifyContent: "flex-start", colorScheme: "red", gap: 2, borderRadius: 0, onClick: () => {
+                                                var _a;
+                                                (_a = row.onDelete) === null || _a === void 0 ? void 0 : _a.call(row, row);
+                                                handleClose();
+                                            }, children: [_jsx(Trash2, { size: 17 }), " Delete"] })), !row.onLink && !row.onEdit && !row.onDelete && !row.actions && (_jsx(Button, { size: "sm", variant: "ghost", isDisabled: true, justifyContent: "center", children: "No actions" }))] }) }) }) })] }))] }));
+});
+TableActions.displayName = "TableActions";
+export default TableActions;

package/dist/esm/Components/Table/components/TableBody.js

@@ -0,0 +1,454 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, IconButton, Spinner, Td, Tr } from "@chakra-ui/react";
+import React, { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
+import { flushSync } from "react-dom";
+import { normalizeTableCellValue, buildTablePalette, pickTableColor } from "../../../Utils/table.js";
+import { useCustomTheme } from "../../../Theme/useCustomTheme.js";
+import { LOADING_PLACEHOLDER_COLUMNS, TableBodyLoading } from "./TableLoading.js";
+import TableActions from "./TableActions.js";
+import { ChevronDown, ChevronRight } from "lucide-react";
+import CheckBox from "../../Checkbox/Checkbox.js";
+import TableGroupRow from "./TableGroupRow.js";
+import { useTableVariant } from "../variants/TableVariantContext.js";
+import { resolvePillInk } from "../variants/pillInk.js";
+import EmptyState from "../../EmptyState/EmptyState.js";
+import { DENSITY_ROWS, EMPTY_STATE_HEIGHT, GROUP_HEADER_HEIGHT } from "./rowMetrics.js";
+import { columnLabelText, isPrimitiveLabel } from "../columnLabel.js";
+import { transitionFor } from "../../../Theme/tokens/primitives/motion.js";
+import { reducedMotionSx } from "../../../Theme/chakra/motion.js";
+import { DETAIL_SLOT_PX, RowDetailRow, RowDetailToggle, detailDomIds } from "./rowDetail.js";
+import { useRowMeasurer } from "./rowMeasurer.js";
+import { BORDER_WIDTHS } from "../../../Theme/tokens/primitives/borderWidths.js";
+import { onActivationKey } from "../../Common/activationKey.js";
+import { rowFocusRingSx } from "./rowFocusRing.js";
+const getRowId = (row) => row.id;
+const getRowContent = (row) => typeof row.content === "function"
+    ? row.content
+    : undefined;
+// Smallest index i in [0, total] where offsets[i+1] > target; offsets is sorted.
+export const findFirstVisibleIndex = (offsets, total, target) => {
+    let lo = 0;
+    let hi = total;
+    while (lo < hi) {
+        const mid = (lo + hi) >>> 1;
+        if (offsets[mid + 1] <= target) {
+            lo = mid + 1;
+        }
+        else {
+            hi = mid;
+        }
+    }
+    return lo;
+};
+// Monday-style status cell: the whole cell is filled with the status color and
+// the label is centered in whichever of white/black clears AA against that fill —
+// the fill can be a consumer hex we can't know in advance is light or dark.
+const BLEED_JUSTIFY = {
+    start: "flex-start",
+    center: "center",
+    end: "flex-end",
+};
+const StatusCell = ({ value, onSolid, align, }) => (_jsx(Box, { display: "flex", alignItems: "center", justifyContent: BLEED_JUSTIFY[align !== null && align !== void 0 ? align : "center"], w: "100%", h: "100%", px: "0.5rem", fontSize: "0.75rem", fontWeight: 600, color: onSolid, textAlign: align !== null && align !== void 0 ? align : "center", whiteSpace: "nowrap", overflow: "hidden", textOverflow: "ellipsis", children: value }));
+// Studio's status cell: a contained chip on the tone's soft rung. Same tone pair
+// the group header already uses, so an override hex behaves identically in both.
+const StatusPill = ({ value, soft, ink, radius, }) => (_jsx(Box, { display: "inline-flex", alignItems: "center", maxW: "100%", px: "0.5rem", py: "0.125rem", borderRadius: radius, bg: soft, color: ink, fontSize: "0.75rem", fontWeight: 600, whiteSpace: "nowrap", overflow: "hidden", textOverflow: "ellipsis", children: value }));
+const EMPTY_HOVER = {};
+const NO_OFFSETS = [];
+const TableRow = React.memo(({ row, rowIndex, isChecked, isExpanded, isContent, isLink, isCheckbox, isLoading, isActionFreeze, columns, leftOffsets, noBorders, freezedBgColor, freezedTextColor, theme, borderStyle, selectedBg, selectedFrozenBg, hoverStyle, rowHeight, cellPy, palette, accentColor, isStriped, rowDetail, isDetailOpen = false, detailLeft = 0, detailColSpan = 0, ariaRowIndex, handleCheckbox, onRowClick, toggleRowExpansion, measurer, }) => {
+    const mainRowRef = useRef(null);
+    const expandedRowRef = useRef(null);
+    const detailRowRef = useRef(null);
+    const hasContent = !!getRowContent(row);
+    const detailNode = rowDetail ? rowDetail.render(row) : null;
+    const hasDetail = detailNode !== null && detailNode !== undefined;
+    const detailOpen = isDetailOpen && hasDetail;
+    const rowId = getRowId(row);
+    const detailIds = rowDetail ? detailDomIds(rowDetail.idPrefix, rowId) : null;
+    const expandedOpen = isExpanded && hasContent;
+    useLayoutEffect(() => {
+        if (!measurer)
+            return;
+        const parts = [mainRowRef.current, expandedOpen ? expandedRowRef.current : null, detailOpen ? detailRowRef.current : null];
+        return measurer.track(rowId, parts.filter((el) => el !== null));
+    }, [measurer, rowId, expandedOpen, detailOpen]);
+    const handleCellClick = useCallback((header) => {
+        if (!header.node && onRowClick) {
+            onRowClick(row, {
+                label: isPrimitiveLabel(header.label) ? header.label : columnLabelText(header),
+                id: header.id,
+            });
+        }
+    }, [row, onRowClick]);
+    const keyboardHeader = onRowClick && !isLoading ? columns.find((c) => !c.isHidden && !c.node) : undefined;
+    const handleRowKeyDown = useCallback((event) => {
+        if (event.target !== event.currentTarget || event.repeat || !keyboardHeader)
+            return;
+        onActivationKey(() => handleCellClick(keyboardHeader))(event);
+    }, [keyboardHeader, handleCellClick]);
+    const variant = useTableVariant();
+    const firstDataColIndex = columns.findIndex((c) => !c.isHidden);
+    const accentSx = accentColor ? `inset 3px 0 0 ${accentColor}` : undefined;
+    // A selected row earns the leading bar only where a group accent isn't already
+    // claiming that edge — the group's identity is the scarcer signal.
+    const leadSx = variant.row.showSelectedBar && isChecked && !accentColor
+        ? `inset 3px 0 0 ${variant.row.selectedBarColor}`
+        : accentSx;
+    const restsOnIndex = variant.slot.rest === "index";
+    const rowSx = {
+        ...(keyboardHeader ? rowFocusRingSx(theme.colors) : {}),
+        ...(variant.row.hoverScope === "row"
+            ? { "&:hover > td[data-hoverable='true']": { backgroundColor: variant.row.hoverBg } }
+            : {}),
+        // opacity, not display: a hidden-by-display checkbox leaves the a11y tree and
+        // cannot be tabbed to, so `:focus-within` would never fire to bring it back.
+        ...(restsOnIndex
+            ? {
+                "& .table-slot-box": { opacity: isChecked ? 1 : 0 },
+                "& .table-slot-index": { opacity: isChecked ? 0 : 1 },
+                "&:hover .table-slot-box, &:focus-within .table-slot-box": { opacity: 1 },
+                "&:hover .table-slot-index, &:focus-within .table-slot-index": { opacity: 0 },
+                "@media (pointer: coarse)": {
+                    "& .table-slot-box": { opacity: 1 },
+                    "& .table-slot-index": { opacity: 0 },
+                },
+            }
+            : {}),
+    };
+    // Pinned/frozen columns get a tinted, opaque background so the frozen pane reads
+    // as one piece with its header (and so sticky cells cover scrolling content).
+    const frozenCellBg = freezedBgColor !== null && freezedBgColor !== void 0 ? freezedBgColor : theme.colors.table.hover[100];
+    const cellStyles = row.cellStyle;
+    const rowStyle = row.rowStyle;
+    const chromeHoverable = rowStyle ? "false" : "true";
+    const rowContent = getRowContent(row);
+    const restBg = isStriped ? variant.row.stripeBg : theme.colors.background[50];
+    return (_jsxs(React.Fragment, { children: [_jsxs(Tr, { ref: mainRowRef, "aria-rowindex": ariaRowIndex, tabIndex: keyboardHeader ? 0 : undefined, onKeyDown: keyboardHeader ? handleRowKeyDown : undefined, opacity: isLoading ? 0.4 : 1, pointerEvents: isLoading ? "none" : "auto", transition: transitionFor(["opacity"], "base"), sx: { ...rowSx, ...reducedMotionSx() }, children: [isContent && (_jsx(Td, { w: "6", p: 0, fontSize: "sm", background: isChecked ? selectedFrozenBg : frozenCellBg, color: freezedTextColor, position: "sticky", borderBottom: borderStyle, boxShadow: leadSx, boxSizing: "border-box", "data-hoverable": chromeHoverable, left: "0px", zIndex: 1, className: "columns sticky-columns", children: hasContent && (_jsx(IconButton, { "aria-label": isExpanded ? "Collapse row" : "Expand row", color: theme.colors.textMuted, icon: isExpanded ? (_jsx(ChevronDown, {})) : (_jsx(ChevronRight, {})), _hover: { transform: "scale(1.1)" }, size: "sm", onClick: () => toggleRowExpansion(rowIndex), variant: "ghost" })) })), isCheckbox && (_jsx(Td, { w: variant.slot.width, minW: variant.slot.width, px: variant.slot.centered ? 0 : undefined, textAlign: variant.slot.centered ? "center" : undefined, fontSize: "sm", fontWeight: 600, color: theme.colors.background[50], textTransform: "capitalize", background: isChecked ? selectedFrozenBg : frozenCellBg, position: "sticky", borderBottom: borderStyle, boxShadow: !isContent ? leadSx : undefined, "data-hoverable": chromeHoverable, boxSizing: "border-box", left: "0px", zIndex: 1, className: "columns sticky-columns", children: _jsxs(Box, { display: restsOnIndex ? "grid" : undefined, placeItems: "center", children: [restsOnIndex && (_jsx(Box, { as: "span", className: "table-slot-index", gridArea: "1 / 1", color: variant.slot.indexInk, fontSize: "0.6875rem", fontWeight: 500, transition: transitionFor(["opacity"]), sx: { fontVariantNumeric: "tabular-nums", ...reducedMotionSx() }, children: rowIndex + 1 })), _jsx(Box, { as: "span", className: restsOnIndex ? "table-slot-box" : undefined, gridArea: restsOnIndex ? "1 / 1" : undefined, display: "flex", alignItems: "center", justifyContent: "center", transition: transitionFor(["opacity"]), sx: reducedMotionSx(), children: _jsx(CheckBox, { "aria-label": `Select row ${rowIndex + 1}`, onChange: () => handleCheckbox(getRowId(row)), isChecked: isChecked }) })] }) })), rowDetail && detailIds && (_jsx(Td, { w: `${DETAIL_SLOT_PX}px`, minW: `${DETAIL_SLOT_PX}px`, maxW: `${DETAIL_SLOT_PX}px`, p: 0, textAlign: "center", background: isChecked ? selectedFrozenBg : frozenCellBg, position: "sticky", borderBottom: borderStyle, boxShadow: !isContent && !isCheckbox ? leadSx : undefined, "data-hoverable": chromeHoverable, boxSizing: "border-box", left: `${detailLeft}px`, zIndex: 1, className: "columns sticky-columns", children: hasDetail && (_jsx(RowDetailToggle, { isOpen: detailOpen, detailId: detailIds.detailId, color: theme.colors.textMuted, theme: theme, onToggle: () => rowDetail.toggle(getRowId(row)) })) })), columns.map((header, headerIndex) => {
+                        var _a, _b, _c, _d;
+                        if (header.isHidden)
+                            return null;
+                        const isFrozen = header.isFreeze;
+                        const isFirstDataCell = !isContent && !isCheckbox && !rowDetail && headerIndex === firstDataColIndex;
+                        const isStatus = header.type === "status" && !header.node;
+                        const rawStatus = String((_a = row[header.id]) !== null && _a !== void 0 ? _a : "");
+                        const statusColor = isStatus
+                            ? (_c = (_b = header.statusPalette) === null || _b === void 0 ? void 0 : _b[rawStatus]) !== null && _c !== void 0 ? _c : pickTableColor(rawStatus, palette, (_d = header.statusColors) === null || _d === void 0 ? void 0 : _d[rawStatus], theme)
+                            : null;
+                        const isBleed = variant.cells.statusFill === "bleed" && !!statusColor;
+                        const bleedBg = statusColor === null || statusColor === void 0 ? void 0 : statusColor.soft;
+                        const bleedInk = statusColor === null || statusColor === void 0 ? void 0 : statusColor.text;
+                        const canHover = !isBleed && !((cellStyles === null || cellStyles === void 0 ? void 0 : cellStyles[header.id]) || rowStyle);
+                        return (_jsx(Td, { maxWidth: 500, minWidth: 120, height: `${rowHeight}px`, py: isBleed ? 0 : cellPy, px: isBleed ? 0 : undefined, id: hasDetail && headerIndex === firstDataColIndex ? detailIds === null || detailIds === void 0 ? void 0 : detailIds.cellId : undefined, onClick: () => handleCellClick(header), fontSize: "sm", fontWeight: 400, position: isFrozen ? "sticky" : undefined, left: isFrozen ? `${leftOffsets[headerIndex]}px` : undefined, zIndex: isFrozen ? 1 : 0, background: isBleed ? bleedBg : isChecked ? (isFrozen ? selectedFrozenBg : selectedBg) : isFrozen ? frozenCellBg : restBg, textAlign: isBleed ? undefined : header.align, textOverflow: "ellipsis", boxShadow: isFirstDataCell ? leadSx : undefined, borderBottom: noBorders
+                                ? "none"
+                                : `${BORDER_WIDTHS.hairline} solid ${isFrozen || isChecked
+                                    ? variant.row.frozenRuleColor
+                                    : variant.row.ruleColor}`, className: `columns ${isFrozen ? "sticky-columns" : "scrollable-columns"}`, boxSizing: "border-box", color: isBleed ? bleedInk : variant.cells.ink, "data-hoverable": canHover ? "true" : "false", _hover: variant.row.hoverScope === "row" || !canHover
+                                ? EMPTY_HOVER
+                                : hoverStyle, children: isBleed ? (_jsx(StatusCell, { value: normalizeTableCellValue(row[header.id]), onSolid: bleedInk, align: header.align })) : isStatus && statusColor ? (_jsx(StatusPill, { value: normalizeTableCellValue(row[header.id]), soft: statusColor.soft, ink: resolvePillInk(statusColor.text, statusColor.soft, theme.colors.background[50]), radius: variant.cells.pillRadius })) : (_jsx(Box, { display: "block", overflow: "hidden", whiteSpace: "normal", overflowWrap: "break-word", children: normalizeTableCellValue(header.node ? header.node(row) : row[header.id]) })) }, headerIndex + 1));
+                    }), isLink && (_jsx(Td, { w: 2, p: 0, fontSize: "sm", background: isChecked ? (isActionFreeze ? selectedFrozenBg : selectedBg) : isActionFreeze ? frozenCellBg : restBg, color: freezedTextColor, position: isActionFreeze ? "sticky" : "relative", borderBottom: borderStyle, boxSizing: "border-box", right: 0, zIndex: 1, className: `columns sticky-columns${isActionFreeze ? "-right" : ""}`, children: (row.onLink || row.onEdit || row.onDelete) ? (_jsx(TableActions, { row: row })) : null }))] }), rowContent && isExpanded && (_jsx(Tr, { ref: expandedRowRef, children: _jsx(Td, { colSpan: columns.length +
+                        (isCheckbox ? 1 : 0) +
+                        (isContent ? 1 : 0) +
+                        (isLink ? 1 : 0), p: 2, children: _jsx(Box, { p: 2, bg: theme.colors.background[50], borderRadius: "lg", children: rowContent(row) }) }) })), detailOpen && detailIds && (_jsx(RowDetailRow, { ref: detailRowRef, id: detailIds.detailId, labelledBy: detailIds.cellId, colSpan: detailColSpan, bg: theme.colors.backgroundColor.secondary, borderColor: variant.row.ruleColor, noBorders: noBorders, children: detailNode }))] }));
+});
+const isStructuredEmpty = (value) => !!value && typeof value === "object" && !React.isValidElement(value);
+const TableEmpty = ({ emptyState }) => {
+    const structured = isStructuredEmpty(emptyState) ? emptyState : undefined;
+    const iconNode = structured === null || structured === void 0 ? void 0 : structured.icon;
+    const icon = useMemo(() => (iconNode ? () => _jsx(_Fragment, { children: iconNode }) : undefined), [iconNode]);
+    if (emptyState && !structured)
+        return _jsx(_Fragment, { children: emptyState });
+    return (_jsx(EmptyState, { size: "sm", minH: `${EMPTY_STATE_HEIGHT}px`, title: structured === null || structured === void 0 ? void 0 : structured.title, description: structured === null || structured === void 0 ? void 0 : structured.description, icon: icon }));
+};
+const TableBody = ({ data, isCheckbox, columns, startRow, rowsPerPage, columnWidths, slotWidth, freezedBgColor, freezedTextColor, noBorders, handleCheckbox, selections, isLoading, onRowClick, isContent, isLink, isActionFreeze, loadingSkeletonRows, scrollContainerRef, density, stripe = false, accentColors, groups, onAddItem, emptyState, rowDetail, expandedIds, }) => {
+    var _a;
+    const theme = useCustomTheme();
+    const variant = useTableVariant();
+    const [expandedRows, setExpandedRows] = useState(new Set());
+    const [collapsedGroups, setCollapsedGroups] = useState(new Set());
+    const toggleGroup = useCallback((value) => {
+        setCollapsedGroups((prev) => {
+            const next = new Set(prev);
+            if (next.has(value)) {
+                next.delete(value);
+            }
+            else {
+                next.add(value);
+            }
+            return next;
+        });
+    }, []);
+    const selectionsSet = useMemo(() => new Set(selections), [selections]);
+    const palette = useMemo(() => buildTablePalette(theme), [theme]);
+    const { height: rowHeight, py: cellPy } = DENSITY_ROWS[density !== null && density !== void 0 ? density : "normal"];
+    // Windowing: only rows inside the viewport (+ overscan) mount; spacer rows (not transforms)
+    // reserve the rest so sticky header/frozen columns keep working. Rows report measured heights.
+    const ROW_HEIGHT = rowHeight;
+    const OVERSCAN = 6;
+    const VIRTUALIZE_THRESHOLD = 30;
+    const ESTIMATED_EXPAND = 120; // assumed extra height for an expanded-but-not-yet-measured row
+    const detailWidth = rowDetail ? DETAIL_SLOT_PX : 0;
+    const detailLeft = isCheckbox ? slotWidth : 0;
+    const shouldVirtualize = data.length > VIRTUALIZE_THRESHOLD;
+    // Grouped mode has no pager, so it virtualizes too (when no expandable rows):
+    // group headers + rows form one flat sequence that we window over.
+    const groupRowCount = groups ? groups.reduce((n, g) => n + g.rows.length, 0) : 0;
+    const groupVirtualize = !!groups && !isContent && groupRowCount > VIRTUALIZE_THRESHOLD;
+    const [scrollTop, setScrollTop] = useState(0);
+    const [viewportH, setViewportH] = useState(0);
+    // Measured row heights keyed by row id (stable across scroll/paging).
+    const [measuredHeights, setMeasuredHeights] = useState(new Map());
+    // NOTE: flushSync lands the batch before paint, as the old per-row layout effect did.
+    const applyHeights = useCallback((heights) => {
+        flushSync(() => setMeasuredHeights((prev) => {
+            let next = prev;
+            heights.forEach((h, id) => {
+                if (next.get(id) === h)
+                    return;
+                if (next === prev)
+                    next = new Map(prev);
+                next.set(id, h);
+            });
+            return next;
+        }));
+    }, []);
+    const measurer = useRowMeasurer(applyHeights);
+    useEffect(() => {
+        const el = scrollContainerRef === null || scrollContainerRef === void 0 ? void 0 : scrollContainerRef.current;
+        if (!el || !(shouldVirtualize || groupVirtualize))
+            return;
+        let rafId = null;
+        const onScroll = () => {
+            if (rafId != null)
+                return;
+            rafId = requestAnimationFrame(() => {
+                rafId = null;
+                setScrollTop(el.scrollTop);
+            });
+        };
+        const measure = () => setViewportH(el.clientHeight);
+        measure();
+        setScrollTop(el.scrollTop);
+        el.addEventListener("scroll", onScroll, { passive: true });
+        window.addEventListener("resize", measure);
+        return () => {
+            el.removeEventListener("scroll", onScroll);
+            window.removeEventListener("resize", measure);
+            if (rafId != null)
+                cancelAnimationFrame(rafId);
+        };
+    }, [scrollContainerRef, shouldVirtualize, groupVirtualize, data.length, groupRowCount]);
+    // Reset only on a real page change, never merely from the virtualization
+    // threshold flipping or rows being appended (infinite scroll/load-more).
+    const sliceKey = `${startRow}|${rowsPerPage}`;
+    const prevSliceKeyRef = useRef(sliceKey);
+    useEffect(() => {
+        const changed = prevSliceKeyRef.current !== sliceKey;
+        prevSliceKeyRef.current = sliceKey;
+        if (!changed)
+            return;
+        const el = scrollContainerRef === null || scrollContainerRef === void 0 ? void 0 : scrollContainerRef.current;
+        if (el)
+            el.scrollTop = 0;
+        setScrollTop(0);
+    }, [sliceKey, scrollContainerRef]);
+    const total = data.length;
+    // Prefix-sum offsets using measured heights (exact for rendered rows) and
+    // estimates for not-yet-measured rows (ROW_HEIGHT, + ESTIMATED_EXPAND if expanded).
+    // Independent of scrollTop, so scrolling reuses it instead of rebuilding it.
+    const offsets = useMemo(() => {
+        if (!shouldVirtualize || groups)
+            return null;
+        const acc = new Array(total + 1);
+        acc[0] = 0;
+        for (let i = 0; i < total; i++) {
+            const id = getRowId(data[i]);
+            const measured = measuredHeights.get(id);
+            const h = measured != null
+                ? measured
+                : ROW_HEIGHT +
+                    (expandedRows.has(startRow + i) || (expandedIds === null || expandedIds === void 0 ? void 0 : expandedIds.has(id)) ? ESTIMATED_EXPAND : 0);
+            acc[i + 1] = acc[i] + h;
+        }
+        return acc;
+    }, [shouldVirtualize, groups, total, data, measuredHeights, expandedRows, expandedIds, startRow, ROW_HEIGHT, ESTIMATED_EXPAND]);
+    let firstIndex = 0;
+    let lastIndex = total;
+    let topPad = 0;
+    let bottomPad = 0;
+    if (shouldVirtualize && offsets) {
+        const vh = viewportH || 500;
+        const totalH = offsets[total];
+        const top = scrollTop - OVERSCAN * ROW_HEIGHT;
+        const bottom = scrollTop + vh + OVERSCAN * ROW_HEIGHT;
+        firstIndex = findFirstVisibleIndex(offsets, total, top);
+        lastIndex = firstIndex;
+        while (lastIndex < total && offsets[lastIndex] < bottom)
+            lastIndex++;
+        if (lastIndex < firstIndex)
+            lastIndex = firstIndex;
+        topPad = offsets[firstIndex];
+        bottomPad = totalH - offsets[lastIndex];
+    }
+    const visibleRows = shouldVirtualize ? data.slice(firstIndex, lastIndex) : data;
+    // Consumers pass a fresh closure each render; the ref keeps memoized rows valid.
+    const onRowClickRef = useRef(onRowClick);
+    onRowClickRef.current = onRowClick;
+    const handleRowClick = useCallback((row, header) => {
+        var _a;
+        (_a = onRowClickRef.current) === null || _a === void 0 ? void 0 : _a.call(onRowClickRef, row, header);
+    }, []);
+    const rowClickHandler = onRowClick ? handleRowClick : undefined;
+    const toggleRowExpansion = useCallback((rowIndex) => {
+        setExpandedRows((prev) => {
+            const newSet = new Set(prev);
+            if (newSet.has(rowIndex)) {
+                newSet.delete(rowIndex);
+            }
+            else {
+                newSet.add(rowIndex);
+            }
+            return newSet;
+        });
+    }, []);
+    const totalVisibleColumns = useMemo(() => columns.filter((o) => !o.isHidden).length +
+        (isCheckbox ? 1 : 0) +
+        (isContent ? 1 : 0) +
+        (rowDetail ? 1 : 0) +
+        (isLink ? 1 : 0), [columns, isCheckbox, isContent, isLink, rowDetail]);
+    const hasFrozenColumn = useMemo(() => columns.some((column) => column.isFreeze), [columns]);
+    const leftOffsets = useMemo(() => {
+        if (!hasFrozenColumn)
+            return NO_OFFSETS;
+        const checkboxOffset = (isCheckbox ? slotWidth : 0) + detailWidth;
+        return columnWidths.map((_, idx) => columnWidths.slice(0, idx).reduce((sum, w) => sum + w, 0) + checkboxOffset);
+    }, [hasFrozenColumn, columnWidths, isCheckbox, slotWidth, detailWidth]);
+    const borderStyle = useMemo(() => noBorders ? "none" : `${BORDER_WIDTHS.hairline} solid ${variant.row.ruleColor}`, [noBorders, variant.row.ruleColor]);
+    // Selected-row tint applied per-cell (NOT a blanket `& td` override) so status
+    // cells keep their solid color + white text instead of white-on-tint.
+    const selectedBg = variant.row.selectedBg;
+    // Sticky/frozen cells overlay scrolling content, so their selected background
+    // must be OPAQUE — paint the (translucent) tint over an opaque base.
+    const selectedFrozenBg = `linear-gradient(0deg, ${selectedBg}, ${selectedBg}), ${theme.colors.background[50]}`;
+    // Dark mode lifts the hover fill to `table.hover[500]`; `[300]` sits ~1.2:1 from the canvas.
+    // No ink flip needed — see `tableRowHoverStyle.ts`.
+    const hoverStyle = useMemo(() => ({ backgroundColor: variant.row.hoverBg }), [variant.row.hoverBg]);
+    // Flatten groups → one sequence of header/row items so it can be windowed.
+    // Independent of scrollTop, so scrolling reuses it instead of re-flattening.
+    const groupItems = useMemo(() => {
+        if (!groups)
+            return null;
+        const list = [];
+        for (const g of groups) {
+            list.push({ kind: "header", g });
+            if (!collapsedGroups.has(g.value)) {
+                g.rows.forEach((row, pos) => list.push({ kind: "row", g, row, pos }));
+            }
+        }
+        return list;
+    }, [groups, collapsedGroups]);
+    const groupMetrics = useMemo(() => {
+        if (!groupItems || !groupVirtualize)
+            return null;
+        const heights = groupItems.map((it) => {
+            var _a;
+            if (it.kind === "header")
+                return GROUP_HEADER_HEIGHT;
+            if (!rowDetail)
+                return rowHeight;
+            const id = getRowId(it.row);
+            return (_a = measuredHeights.get(id)) !== null && _a !== void 0 ? _a : rowHeight + ((expandedIds === null || expandedIds === void 0 ? void 0 : expandedIds.has(id)) ? ESTIMATED_EXPAND : 0);
+        });
+        const offsets = [];
+        let acc = 0;
+        for (const h of heights) {
+            offsets.push(acc);
+            acc += h;
+        }
+        return { heights, offsets, totalH: acc };
+    }, [groupItems, groupVirtualize, rowHeight, rowDetail, measuredHeights, expandedIds, ESTIMATED_EXPAND]);
+    // Clamp scrollTop back when a shorter data set leaves it past the new content height.
+    useEffect(() => {
+        const totalH = shouldVirtualize && offsets ? offsets[total] : groupVirtualize && groupMetrics ? groupMetrics.totalH : null;
+        if (totalH == null)
+            return;
+        const maxScrollTop = Math.max(0, totalH - viewportH);
+        if (scrollTop > maxScrollTop) {
+            const el = scrollContainerRef === null || scrollContainerRef === void 0 ? void 0 : scrollContainerRef.current;
+            if (el)
+                el.scrollTop = maxScrollTop;
+            setScrollTop(maxScrollTop);
+        }
+    }, [shouldVirtualize, offsets, total, groupVirtualize, groupMetrics, viewportH, scrollTop, scrollContainerRef]);
+    // Prune measured heights for rows no longer in data so the map stays bounded.
+    useEffect(() => {
+        setMeasuredHeights((prev) => {
+            if (prev.size === 0)
+                return prev;
+            const ids = new Set(data.map(getRowId));
+            let changed = false;
+            const next = new Map();
+            prev.forEach((h, id) => {
+                if (ids.has(id)) {
+                    next.set(id, h);
+                }
+                else {
+                    changed = true;
+                }
+            });
+            return changed ? next : prev;
+        });
+    }, [data]);
+    if (isLoading && data.length === 0) {
+        const dataColumns = columns.filter((o) => !o.isHidden).length;
+        const cells = [
+            ...(isContent ? ["blank"] : []),
+            ...(isCheckbox ? ["checkbox"] : []),
+            ...(rowDetail ? ["blank"] : []),
+            ...Array.from({ length: dataColumns || LOADING_PLACEHOLDER_COLUMNS }, () => "bar"),
+            ...(isLink ? ["blank"] : []),
+        ];
+        return (_jsx(TableBodyLoading, { noOfColumns: cells.length, cells: cells, borderColor: variant.row.ruleColor, rowsCount: typeof loadingSkeletonRows === "number" ? loadingSkeletonRows : 4, rowHeight: rowHeight }));
+    }
+    if (!isLoading && data.length === 0) {
+        return (_jsx(Tr, { backgroundColor: theme.colors.background[50], children: _jsx(Td, { colSpan: totalVisibleColumns, p: 0, border: "none", children: _jsx(TableEmpty, { emptyState: emptyState }) }) }));
+    }
+    // --- Monday-style grouped board render (virtualized when large) -----------
+    if (groups) {
+        const items = groupItems !== null && groupItems !== void 0 ? groupItems : [];
+        let firstI = 0;
+        let lastI = items.length;
+        let gTopPad = 0;
+        let gBottomPad = 0;
+        if (groupVirtualize && groupMetrics) {
+            const { heights, offsets, totalH } = groupMetrics;
+            const vh = viewportH || 500;
+            const top = scrollTop - OVERSCAN * rowHeight;
+            const bottom = scrollTop + vh + OVERSCAN * rowHeight;
+            firstI = items.findIndex((_, i) => offsets[i] + heights[i] > top);
+            if (firstI < 0)
+                firstI = items.length;
+            lastI = items.length;
+            for (let i = firstI; i < items.length; i++) {
+                if (offsets[i] > bottom) {
+                    lastI = i;
+                    break;
+                }
+            }
+            gTopPad = (_a = offsets[firstI]) !== null && _a !== void 0 ? _a : 0;
+            gBottomPad = totalH - (lastI > firstI ? offsets[lastI - 1] + heights[lastI - 1] : gTopPad);
+        }
+        const windowItems = groupVirtualize ? items.slice(firstI, lastI) : items;
+        return (_jsxs(_Fragment, { children: [gTopPad > 0 && (_jsx("tr", { "aria-hidden": "true", style: { height: gTopPad }, children: _jsx("td", { colSpan: totalVisibleColumns, style: { padding: 0, border: "none", height: gTopPad } }) })), windowItems.map((it, k) => {
+                    var _a;
+                    return it.kind === "header" ? (_jsx(TableGroupRow, { label: it.g.label, value: it.g.value, count: it.g.rows.length, color: it.g.color, collapsed: collapsedGroups.has(it.g.value), colSpan: totalVisibleColumns, ariaRowIndex: firstI + k + 2, onToggle: () => toggleGroup(it.g.value), onAddItem: onAddItem }, `h-${it.g.value}`)) : (_jsx(TableRow, { row: it.row, rowIndex: firstI + k, isChecked: selectionsSet.has(getRowId(it.row)), isExpanded: expandedRows.has(firstI + k), isContent: isContent, isLink: isLink, isCheckbox: isCheckbox, isLoading: isLoading, isActionFreeze: isActionFreeze, columns: columns, leftOffsets: leftOffsets, noBorders: noBorders, freezedBgColor: freezedBgColor, freezedTextColor: freezedTextColor, theme: theme, borderStyle: borderStyle, selectedBg: selectedBg, selectedFrozenBg: selectedFrozenBg, hoverStyle: hoverStyle, rowHeight: rowHeight, cellPy: cellPy, palette: palette, accentColor: it.g.color.solid, isStriped: stripe && it.pos % 2 === 1, rowDetail: rowDetail, isDetailOpen: !!(expandedIds === null || expandedIds === void 0 ? void 0 : expandedIds.has(getRowId(it.row))), detailLeft: rowDetail ? detailLeft : 0, detailColSpan: totalVisibleColumns, ariaRowIndex: firstI + k + 2, handleCheckbox: handleCheckbox, onRowClick: rowClickHandler, toggleRowExpansion: toggleRowExpansion, measurer: groupVirtualize && rowDetail ? measurer : undefined }, (_a = getRowId(it.row)) !== null && _a !== void 0 ? _a : `r-${firstI + k}`));
+                }), gBottomPad > 0 && (_jsx("tr", { "aria-hidden": "true", style: { height: gBottomPad }, children: _jsx("td", { colSpan: totalVisibleColumns, style: { padding: 0, border: "none", height: gBottomPad } }) }))] }));
+    }
+    return (_jsxs(_Fragment, { children: [isLoading && data.length > 0 && (_jsx(Tr, { children: _jsx(Td, { colSpan: totalVisibleColumns, p: 0, border: "none", position: "relative", height: 0, children: _jsx(Box, { position: "absolute", top: 4, left: "50%", transform: "translateX(-50%)", zIndex: 10, children: _jsx(Spinner, { size: "sm", color: theme.colors.accentText }) }) }) })), shouldVirtualize && topPad > 0 && (_jsx("tr", { "aria-hidden": "true", style: { height: topPad }, children: _jsx("td", { colSpan: totalVisibleColumns, style: { padding: 0, border: "none", height: topPad } }) })), visibleRows.map((row, i) => {
+                var _a;
+                const index = firstIndex + i;
+                const rowIndex = startRow + index;
+                const isExpanded = expandedRows.has(rowIndex);
+                const isChecked = selectionsSet.has(getRowId(row));
+                return (_jsx(TableRow, { row: row, rowIndex: rowIndex, isChecked: isChecked, isExpanded: isExpanded, isContent: isContent, isLink: isLink, isCheckbox: isCheckbox, isLoading: isLoading, isActionFreeze: isActionFreeze, columns: columns, leftOffsets: leftOffsets, noBorders: noBorders, freezedBgColor: freezedBgColor, freezedTextColor: freezedTextColor, theme: theme, borderStyle: borderStyle, selectedBg: selectedBg, selectedFrozenBg: selectedFrozenBg, hoverStyle: hoverStyle, rowHeight: rowHeight, cellPy: cellPy, palette: palette, accentColor: accentColors === null || accentColors === void 0 ? void 0 : accentColors[getRowId(row)], isStriped: stripe && index % 2 === 1, rowDetail: rowDetail, isDetailOpen: !!(expandedIds === null || expandedIds === void 0 ? void 0 : expandedIds.has(getRowId(row))), detailLeft: rowDetail ? detailLeft : 0, detailColSpan: totalVisibleColumns, ariaRowIndex: index + 2, handleCheckbox: handleCheckbox, onRowClick: rowClickHandler, toggleRowExpansion: toggleRowExpansion, measurer: shouldVirtualize ? measurer : undefined }, (_a = getRowId(row)) !== null && _a !== void 0 ? _a : rowIndex));
+            }), shouldVirtualize && bottomPad > 0 && (_jsx("tr", { "aria-hidden": "true", style: { height: bottomPad }, children: _jsx("td", { colSpan: totalVisibleColumns, style: { padding: 0, border: "none", height: bottomPad } }) }))] }));
+};
+export default TableBody;

package/dist/esm/Components/Table/components/TableGroupRow.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Flex, IconButton, Td, Text, Tr } from "@chakra-ui/react";
+import { ChevronDown, ChevronRight, Plus } from "lucide-react";
+import { useCustomTheme } from "../../../Theme/useCustomTheme.js";
+import { BORDER_WIDTHS } from "../../../Theme/tokens/primitives/borderWidths.js";
+/** Monday-style colored, collapsible group header row. */
+export const TableGroupRow = ({ label, value, count, color, collapsed, colSpan, ariaRowIndex, onToggle, onAddItem, }) => {
+    const theme = useCustomTheme();
+    return (_jsx(Tr, { "aria-rowindex": ariaRowIndex, children: _jsx(Td, { colSpan: colSpan, p: 0, border: "none", children: _jsxs(Flex, { align: "center", gap: 2, px: 3, py: 2, bg: color.soft, boxShadow: `inset 4px 0 0 ${color.solid}`, borderBottom: `${BORDER_WIDTHS.hairline} solid ${theme.colors.boxborder[200]}`, children: [_jsx(IconButton, { "aria-label": collapsed ? "Expand group" : "Collapse group", size: "xs", variant: "ghost", color: color.text, onClick: onToggle, icon: collapsed ? _jsx(ChevronRight, { size: 16 }) : _jsx(ChevronDown, { size: 16 }) }), _jsx(Text, { fontSize: "0.8125rem", fontWeight: 700, color: color.text, isTruncated: true, maxW: "20rem", children: label }), _jsx(Box, { as: "span", fontSize: "0.6875rem", fontWeight: 600, color: color.text, bg: theme.colors.background[50], borderRadius: "full", px: "0.5rem", py: "px", children: count }), onAddItem && (_jsxs(Flex, { as: "button", type: "button", align: "center", gap: 1, ml: "auto", px: 2, py: 1, borderRadius: "lg", fontSize: "0.75rem", fontWeight: 500, color: theme.colors.text[500], _hover: { bg: theme.colors.background[50], color: color.text }, onClick: () => onAddItem(value), children: [_jsx(Plus, { size: 14 }), " Add item"] }))] }) }) }));
+};
+export default TableGroupRow;