@versini/ui-datagrid 4.2.12 → 4.2.13

package/dist/DataGridInfinite/index.js

@@ -1,5 +1,5 @@
 /*!
-  @versini/ui-datagrid v4.2.12
+  @versini/ui-datagrid v4.2.13
   © 2026 gizmette.com
 */
 
@@ -9,136 +9,38 @@ import { useContext, useEffect, useImperativeHandle, useLayoutEffect, useMemo, u
 import { DataGridContext } from "../8.js";
 import { CellWrapper } from "../7.js";
 import { getBodyClass, useColumnMeasurement } from "../u.js";
-
-
-
-
-
-
-
-
-
-
-
 const DEFAULT_OVERSCAN = 8;
 const DEFAULT_ESTIMATED_ROW_HEIGHT = 44;
 const DEFAULT_COMPACT_ESTIMATED_ROW_HEIGHT = 29;
-/**
- * Fallback used to restore the normal window after a smooth jump when the
- * browser does not fire `scrollend` (e.g. Safari < 17.4) or the target was
- * already centered.
- */ const JUMP_SETTLE_FALLBACK_MS = 1000;
-/**
- * A smooth jump animates reliably over a short hop, but a long one outruns the
- * animation budget and races react-virtual's mid-flight measurement, landing
- * unpredictably. Past this many rows of reach we jump instantly instead — it
- * lands exactly (no animation to race) at the cost of the glide.
- */ const FAR_JUMP_THRESHOLD = 30;
-/**
- * A virtualized DataGrid body for large datasets.
- *
- * Only the rows near the viewport stay mounted (windowing via
- * `@tanstack/react-virtual`), so the DOM stays small and scrolling stays smooth
- * at any row count. Rows are rendered in normal grid flow between two full-span
- * spacer elements, so `columns`/subgrid (including intrinsic `auto` tracks)
- * keep working without any consumer change. The virtualizer windows against the
- * DataGrid's own scroll container (created by `maxHeight` or a sticky
- * header/footer), or the page (window scroll) when the grid has neither.
- *
- * Because off-screen rows are removed from the DOM, the grid exposes
- * `aria-rowcount`/`aria-rowindex` and keeps keyboard focus on the grid if a
- * focused row recycles out. Browser find-in-page and uncontrolled per-row state
- * do not persist across recycling (inherent to DOM virtualization).
- *
- * @example
- * ```tsx
- * <DataGrid maxHeight="400px" stickyHeader>
- *   <DataGridHeader caption={`Showing ${reached} of ${data.length}`}>
- *     <DataGridRow>
- *       <DataGridCell>Name</DataGridCell>
- *     </DataGridRow>
- *   </DataGridHeader>
- *
- *   <DataGridInfiniteBody data={largeData} estimatedRowHeight={56}>
- *     {(row) => (
- *       <DataGridRow key={row.id}>
- *         <DataGridCell>{row.name}</DataGridCell>
- *       </DataGridRow>
- *     )}
- *   </DataGridInfiniteBody>
- * </DataGrid>
- * ```
- *
- */ function DataGridInfiniteBody({ data = [], children: renderRow, overscan = DEFAULT_OVERSCAN, estimatedRowHeight, onVisibleCountChange, className, noData = false, noDataText, ref }) {
+const JUMP_SETTLE_FALLBACK_MS = 1000;
+const FAR_JUMP_THRESHOLD = 30;
+function DataGridInfiniteBody({ data = [], children: renderRow, overscan = DEFAULT_OVERSCAN, estimatedRowHeight, onVisibleCountChange, className, noData = false, noDataText, ref }) {
     const ctx = useContext(DataGridContext);
     const bodyRef = useRef(null);
-    /**
-	 * A zero-height grid item at the list start. The display:contents body has no
-	 * box, so we measure this real element to find the list's scroll-margin.
-	 */ const sentinelRef = useRef(null);
+    const sentinelRef = useRef(null);
     const totalItems = data.length;
     const headerRows = ctx.headerRows ?? 0;
     const footerRows = ctx.footerRows ?? 0;
-    /**
-	 * Default the row-height estimate from the grid's density when the consumer
-	 * doesn't set it: `compact` rows are much shorter (~29px vs ~44px), and an
-	 * estimate far from the real height hurts scrollbar accuracy and
-	 * scrollToIndex.
-	 */ const resolvedEstimatedRowHeight = estimatedRowHeight ?? (ctx.compact ? DEFAULT_COMPACT_ESTIMATED_ROW_HEIGHT : DEFAULT_ESTIMATED_ROW_HEIGHT);
+    const resolvedEstimatedRowHeight = estimatedRowHeight ?? (ctx.compact ? DEFAULT_COMPACT_ESTIMATED_ROW_HEIGHT : DEFAULT_ESTIMATED_ROW_HEIGHT);
     const [scrollMargin, setScrollMargin] = useState(0);
-    /**
-	 * Widen-window jump-to-row state. A default (`"smooth"`) `scrollToIndex` first
-	 * widens the virtualized window (`jump.overscan`) so every row between the
-	 * current view and the target is mounted with real, laid-out heights, then the
-	 * layout effect scrolls to the real target element and restores the window
-	 * once the scroll settles.
-	 *
-	 * `instant` is set for a far jump (reach past `FAR_JUMP_THRESHOLD`); the
-	 * effect then jumps instantly rather than animating (it also forces instant
-	 * for a `prefers-reduced-motion` user, but that is read live in the effect,
-	 * not stored here). Scrolling over real rows always lands exactly; the
-	 * animation is what raced react-virtual's mid-flight measurement over a long
-	 * distance, so far jumps drop it. A direct jump (`behavior: "instant"`) skips
-	 * this state entirely and delegates to the virtualizer (see `scrollToIndex`
-	 * below).
-	 *
-	 * `seq` makes every request a fresh object: two jumps that happen to compute
-	 * the same `overscan` still re-run the jump effect (a plain number would be a
-	 * no-op setState and the second jump would be dropped). `handledSeqRef`
-	 * records the last seq the effect acted on, so it scrolls once per request.
-	 *
-	 */ const [jump, setJump] = useState(null);
+    const [jump, setJump] = useState(null);
     const jumpSeqRef = useRef(0);
     const handledSeqRef = useRef(-1);
-    /**
-	 * The scroll target is provided by the parent DataGrid: its internal bounded
-	 * scroller (sticky / maxHeight), or the page (window scroll) when it owns
-	 * none. This avoids fragile DOM-walking that can mistake an unbounded
-	 * `overflow-x:auto` wrapper for a real vertical scroller.
-	 */ const useWindow = ctx.pageScroll === true;
+    const useWindow = true === ctx.pageScroll;
     const scrollEl = useWindow ? null : ctx.scrollContainer ?? null;
-    const resolved = useWindow || scrollEl !== null;
-    /**
-	 * Measure the list's offset within the scroller (= sticky-header padding /
-	 * inline-header height / page offset). Keeps the window origin correct.
-	 */ useLayoutEffect(()=>{
-        if (!resolved || noData) {
-            return;
-        }
+    const resolved = useWindow || null !== scrollEl;
+    useLayoutEffect(()=>{
+        if (!resolved || noData) return;
         const compute = ()=>{
             const node = sentinelRef.current;
-            if (!node) {
-                return;
-            }
+            if (!node) return;
             const top = node.getBoundingClientRect().top;
             const next = useWindow ? Math.max(0, Math.round(top + window.scrollY)) : Math.max(0, Math.round(top - scrollEl.getBoundingClientRect().top + scrollEl.scrollTop));
             setScrollMargin((prev)=>prev === next ? prev : next);
         };
         compute();
         const target = useWindow ? document.documentElement : scrollEl;
-        if (!target) {
-            return;
-        }
+        if (!target) return;
         const observer = new ResizeObserver(compute);
         observer.observe(target);
         return ()=>observer.disconnect();
@@ -148,18 +50,8 @@ const DEFAULT_COMPACT_ESTIMATED_ROW_HEIGHT = 29;
         scrollEl,
         noData
     ]);
-    /**
-	 * Keep the element scroller's `scroll-padding-top` equal to the header height
-	 * (`scrollMargin`). A smooth jump centers via native `scrollIntoView`, which
-	 * otherwise centers in the full box and lands the row half a header-height too
-	 * high under a sticky header; the inset shrinks the centering region to the
-	 * visible area. Declared here (not mutated per-jump) so it is not call-order
-	 * dependent, and the previous inline value is restored on cleanup so the grid
-	 * never permanently overrides a consumer's own `scroll-padding-top`.
-	 */ useLayoutEffect(()=>{
-        if (!scrollEl) {
-            return;
-        }
+    useLayoutEffect(()=>{
+        if (!scrollEl) return;
         const previous = scrollEl.style.scrollPaddingTop;
         scrollEl.style.scrollPaddingTop = `${scrollMargin}px`;
         return ()=>{
@@ -171,112 +63,47 @@ const DEFAULT_COMPACT_ESTIMATED_ROW_HEIGHT = 29;
     ]);
     const virtualizer = useVirtualizer({
         count: totalItems,
-        /**
-		 * In window mode the scroll element IS `window` (the window observers read
-		 * window.innerHeight / window.scrollY off it); cast bridges the type since
-		 * useVirtualizer's element constraint excludes Window.
-		 */ getScrollElement: ()=>useWindow ? typeof window !== "undefined" ? window : null : scrollEl,
+        getScrollElement: ()=>useWindow ? "u" > typeof window ? window : null : scrollEl,
         estimateSize: ()=>resolvedEstimatedRowHeight,
-        /**
-		 * While a jump is in flight, `jump.overscan` widens the window to mount the
-		 * rows along the path; otherwise the consumer's (or default) overscan.
-		 */ overscan: jump?.overscan ?? overscan,
+        overscan: jump?.overscan ?? overscan,
         scrollMargin,
-        /**
-		 * Direct jumps center via the virtualizer (`scrollToIndex` with align
-		 * "center"). Like the sticky-header inset on the smooth path, the row must
-		 * center in the visible area below the header, not the full box.
-		 * react-virtual shifts the target offset by `scrollPaddingStart` and then
-		 * centers, so half the header height lands the row at the visible center.
-		 * (The smooth path uses CSS `scroll-padding-top`, which shrinks the centering
-		 * box instead, so that one takes the full header height — hence the /2
-		 * asymmetry.)
-		 */ scrollPaddingStart: scrollMargin / 2,
-        // React 19: let React batch the scroll-driven updates natively.
+        scrollPaddingStart: scrollMargin / 2,
         useFlushSync: false,
-        /**
-		 * Window vs element observers are selected to match getScrollElement; the
-		 * casts bridge the Element|Window union react-virtual can't narrow here.
-		 */ observeElementRect: useWindow ? observeWindowRect : observeElementRect,
+        observeElementRect: useWindow ? observeWindowRect : observeElementRect,
         observeElementOffset: useWindow ? observeWindowOffset : observeElementOffset,
         scrollToFn: useWindow ? windowScroll : elementScroll,
-        /**
-		 * Window mode: seed the offset from the live scroll position (mirrors
-		 * useWindowVirtualizer). Without this, on mount the virtualizer's offset is
-		 * 0, so it scrolls an already-scrolled page to the top and computes the wrong
-		 * initial window.
-		 */ initialOffset: useWindow ? ()=>typeof window !== "undefined" ? window.scrollY : 0 : undefined
+        initialOffset: useWindow ? ()=>"u" > typeof window ? window.scrollY : 0 : void 0
     });
     const virtualItems = virtualizer.getVirtualItems();
     const totalSize = virtualizer.getTotalSize();
     const lastVisibleIndex = virtualItems.length > 0 ? virtualItems[virtualItems.length - 1].index : -1;
-    /**
-	 * Dev-only: warn about scroll-container setups that silently break
-	 * virtualization — windowing against the page while a bounded ancestor is
-	 * actually the scroller (only the first screen renders), or an internal
-	 * scroller that isn't height-bounded (every row mounts). Runs after paint so
-	 * the measurements are real; stripped from production builds.
-	 */ useEffect(()=>{
-        /**
-		 * Treat a missing `process` (a non-Node runtime whose bundler didn't replace
-		 * this expression) as production, so reading NODE_ENV can never throw.
-		 */ const isProduction = typeof process === "undefined" || process.env.NODE_ENV === "production";
-        if (isProduction || noData || totalItems === 0 || typeof window === "undefined") {
-            return;
-        }
+    useEffect(()=>{
+        const isProduction = "u" < typeof process || "production" === process.env.NODE_ENV;
+        if (isProduction || noData || 0 === totalItems || "u" < typeof window) return;
         if (useWindow) {
             let el = bodyRef.current?.parentElement ?? null;
             while(el && el !== document.body && el !== document.documentElement){
                 const { overflowY } = getComputedStyle(el);
-                if ((overflowY === "auto" || overflowY === "scroll") && el.scrollHeight > el.clientHeight) {
-                    console.warn("[DataGridInfiniteBody] Virtualizing against the page (window scroll), but " + "the grid is inside a scrollable container, so only the first screen of " + "rows will render. Set `maxHeight` on the DataGrid to scroll inside it.");
+                if (("auto" === overflowY || "scroll" === overflowY) && el.scrollHeight > el.clientHeight) {
+                    console.warn("[DataGridInfiniteBody] Virtualizing against the page (window scroll), but the grid is inside a scrollable container, so only the first screen of rows will render. Set `maxHeight` on the DataGrid to scroll inside it.");
                     break;
                 }
                 el = el.parentElement;
             }
-        } else if (scrollEl && scrollEl.clientHeight > window.innerHeight && scrollEl.scrollHeight <= scrollEl.clientHeight + 1) {
-            console.warn("[DataGridInfiniteBody] The scroll container is not height-bounded, so every " + "row mounts and virtualization has no effect. Set `maxHeight` on the DataGrid.");
-        }
+        } else if (scrollEl && scrollEl.clientHeight > window.innerHeight && scrollEl.scrollHeight <= scrollEl.clientHeight + 1) console.warn("[DataGridInfiniteBody] The scroll container is not height-bounded, so every row mounts and virtualization has no effect. Set `maxHeight` on the DataGrid.");
     }, [
         useWindow,
         scrollEl,
         noData,
         totalItems
     ]);
-    /**
-	 * Expose scrollToIndex via ref. Works for any index, mounted or not.
-	 *
-	 * A direct jump (`behavior: "instant"`/`"auto"`) delegates straight to the
-	 * virtualizer: it scrolls to the target's estimated offset and mounts only the
-	 * window around it — lightweight, but the landing is only as accurate as
-	 * `estimatedRowHeight` (the rows above stay estimated).
-	 *
-	 * A default (`"smooth"`) jump instead widens the window to mount every row
-	 * from the current view to the target with real heights, so it lands exactly.
-	 * The layout effect then animates a near jump, or — past `FAR_JUMP_THRESHOLD`
-	 * — jumps instantly (a long animation races the virtualizer's mid-flight
-	 * measurement and strands the jump short).
-	 *
-	 */ useImperativeHandle(ref, ()=>({
+    useImperativeHandle(ref, ()=>({
             scrollToIndex: (index, options)=>{
-                if (index < 0 || index >= totalItems) {
-                    console.warn(`scrollToIndex: index ${index} is out of bounds${totalItems === 0 ? " (the grid is empty)" : ` (0-${totalItems - 1})`}`);
-                    return;
-                }
+                if (index < 0 || index >= totalItems) return void console.warn(`scrollToIndex: index ${index} is out of bounds${0 === totalItems ? " (the grid is empty)" : ` (0-${totalItems - 1})`}`);
                 const behavior = options?.behavior ?? "smooth";
-                if (behavior !== "smooth") {
-                    /**
-					 * If a widened smooth jump is still in flight, cancel it so its (possibly
-					 * large) path window doesn't stay mounted until its own settle. Safe
-					 * unconditionally: `setJump(null)` no-ops when there is no pending jump.
-					 */ setJump(null);
-                    /**
-					 * Direct jump: delegate to the virtualizer with an explicit "instant".
-					 * Forwarding "auto" instead would defer to the scroller's CSS
-					 * `scroll-behavior` — under a global `scroll-behavior: smooth` that
-					 * animates through the un-widened window (the very stutter the smooth path
-					 * exists to avoid), breaking the documented "jumps directly" contract.
-					 */ virtualizer.scrollToIndex(index, {
+                if ("smooth" !== behavior) {
+                    setJump(null);
+                    virtualizer.scrollToIndex(index, {
                         align: "center",
                         behavior: "instant"
                     });
@@ -285,14 +112,7 @@ const DEFAULT_COMPACT_ESTIMATED_ROW_HEIGHT = 29;
                 const items = virtualizer.getVirtualItems();
                 const first = items.length > 0 ? items[0].index : 0;
                 const last = items.length > 0 ? items[items.length - 1].index : 0;
-                /**
-				 * Overscan is symmetric, so widen by the larger gap to either edge of the
-				 * current window; that guarantees the target (and the rows between) mount.
-				 * The jump effect scrolls once they render, then restores the normal
-				 * window. A jump reaching past `FAR_JUMP_THRESHOLD` lands instantly (a long
-				 * smooth animation races the virtualizer's mid-flight measurement and
-				 * strands the jump short).
-				 */ const reach = Math.max(index - first, last - index, 0);
+                const reach = Math.max(index - first, last - index, 0);
                 jumpSeqRef.current += 1;
                 setJump({
                     index,
@@ -306,46 +126,18 @@ const DEFAULT_COMPACT_ESTIMATED_ROW_HEIGHT = 29;
         virtualizer,
         overscan
     ]);
-    /**
-	 * Perform a pending jump once the widened window has mounted the target row
-	 * (react-virtual recomputes the window synchronously, so it is mounted in the
-	 * commit that follows the `jump` change), then restore the normal window.
-	 *
-	 * Two flavors:
-	 * - **Instant** (far jump or reduced motion): scroll instantly, measure the
-	 *   path rows so the window-collapse keeps their real heights (not the
-	 *   estimate, which would shift the target), then collapse — all synchronously.
-	 *   No animation means nothing races the measurement, so it lands exactly.
-	 * - **Smooth** (near jump): animate, and collapse once the scroll settles
-	 *   (`scrollend`, or the timeout fallback for the no-op / unsupported case). A
-	 *   short hop finishes before measurement can interfere, so it stays exact.
-	 *
-	 */ useLayoutEffect(()=>{
-        if (jump === null || handledSeqRef.current === jump.seq) {
-            return;
-        }
+    useLayoutEffect(()=>{
+        if (null === jump || handledSeqRef.current === jump.seq) return;
         handledSeqRef.current = jump.seq;
         const rowEl = bodyRef.current?.querySelector(`[data-index="${jump.index}"]`);
-        if (!rowEl) {
-            /**
-			 * The widened window should always mount the target; if it somehow did not,
-			 * don't stay stuck in widened mode — restore the normal window so later
-			 * jumps aren't dropped.
-			 */ setJump(null);
-            return;
-        }
-        const reduceMotion = typeof window !== "undefined" && !!window.matchMedia?.("(prefers-reduced-motion: reduce)").matches;
+        if (!rowEl) return void setJump(null);
+        const reduceMotion = "u" > typeof window && !!window.matchMedia?.("(prefers-reduced-motion: reduce)").matches;
         if (jump.instant || reduceMotion) {
             rowEl.scrollIntoView({
                 behavior: "instant",
                 block: "center"
             });
-            /**
-			 * Cache the path rows' real heights before the window collapses, so the rows
-			 * above the target don't fall back to `estimatedRowHeight` and shift it.
-			 * Safe to do synchronously here: the instant scroll has already landed, so
-			 * there is no in-flight animation for the measurement to disturb.
-			 */ bodyRef.current?.querySelectorAll("[data-index]").forEach((el)=>virtualizer.measureElement(el));
+            bodyRef.current?.querySelectorAll("[data-index]").forEach((el)=>virtualizer.measureElement(el));
             setJump(null);
             return;
         }
@@ -353,7 +145,7 @@ const DEFAULT_COMPACT_ESTIMATED_ROW_HEIGHT = 29;
             behavior: "smooth",
             block: "center"
         });
-        const scroller = useWindow ? typeof window !== "undefined" ? window : null : scrollEl;
+        const scroller = useWindow ? "u" > typeof window ? window : null : scrollEl;
         const settle = ()=>setJump(null);
         scroller?.addEventListener("scrollend", settle, {
             once: true
@@ -369,10 +161,7 @@ const DEFAULT_COMPACT_ESTIMATED_ROW_HEIGHT = 29;
         scrollEl,
         virtualizer
     ]);
-    /**
-	 * Report a monotonic high-water mark via onVisibleCountChange: the furthest
-	 * row index reached + 1 (resets when the dataset length changes).
-	 */ const highWaterRef = useRef(0);
+    const highWaterRef = useRef(0);
     const prevTotalRef = useRef(totalItems);
     useEffect(()=>{
         if (prevTotalRef.current !== totalItems) {
@@ -389,17 +178,10 @@ const DEFAULT_COMPACT_ESTIMATED_ROW_HEIGHT = 29;
         totalItems,
         onVisibleCountChange
     ]);
-    /**
-	 * Report the total row count to the grid for aria-rowcount (header + body +
-	 * footer rows), and clear it when this body unmounts. Empty/noData grids
-	 * report nothing, so they render no aria-rowcount and no focus sentinel.
-	 */ useEffect(()=>{
-        if (noData || totalItems === 0) {
-            ctx.setRowCount?.(undefined);
-            return;
-        }
+    useEffect(()=>{
+        if (noData || 0 === totalItems) return void ctx.setRowCount?.(void 0);
         ctx.setRowCount?.(totalItems + headerRows + footerRows);
-        return ()=>ctx.setRowCount?.(undefined);
+        return ()=>ctx.setRowCount?.(void 0);
     }, [
         noData,
         totalItems,
@@ -407,11 +189,7 @@ const DEFAULT_COMPACT_ESTIMATED_ROW_HEIGHT = 29;
         footerRows,
         ctx.setRowCount
     ]);
-    /**
-	 * Focus preservation: when a focused per-row control recycles out of the DOM,
-	 * focus would fall to document.body. Track the focused row index; if it
-	 * unmounts and focus drops to the body, move focus to the grid sentinel.
-	 */ const focusedIndexRef = useRef(null);
+    const focusedIndexRef = useRef(null);
     useLayoutEffect(()=>{
         const body = bodyRef.current;
         const active = document.activeElement;
@@ -420,42 +198,34 @@ const DEFAULT_COMPACT_ESTIMATED_ROW_HEIGHT = 29;
             focusedIndexRef.current = rowEl ? Number(rowEl.getAttribute("data-index")) : null;
             return;
         }
-        if (focusedIndexRef.current !== null && (active === document.body || active === null) && body && !body.querySelector(`[data-index="${focusedIndexRef.current}"]`)) {
-            ctx.focusGrid?.();
-        }
+        if (null !== focusedIndexRef.current && (active === document.body || null === active) && body && !body.querySelector(`[data-index="${focusedIndexRef.current}"]`)) ctx.focusGrid?.();
         focusedIndexRef.current = null;
     });
-    /**
-	 * Context value for body rows (shared base; per-row fields added below).
-	 */ const bodyContextBase = useMemo(()=>({
+    const bodyContextBase = useMemo(()=>({
             ...ctx,
             cellWrapper: CellWrapper.BODY
         }), [
         ctx
     ]);
-    /**
-	 * Measure column widths for sticky header/footer sync. Re-key on the first
-	 * mounted row so the sticky header re-syncs as the window (and the auto-column
-	 * width) slides.
-	 */ useColumnMeasurement(bodyRef, virtualItems[0]?.index, noData);
+    useColumnMeasurement(bodyRef, virtualItems[0]?.index, noData);
     const bodyClass = getBodyClass(className);
     const paddingTop = virtualItems.length > 0 ? Math.max(0, virtualItems[0].start - scrollMargin) : 0;
     const paddingBottom = virtualItems.length > 0 ? Math.max(0, totalSize - virtualItems[virtualItems.length - 1].end) : 0;
-    return /*#__PURE__*/ jsx(DataGridContext.Provider, {
+    return jsx(DataGridContext.Provider, {
         value: {
             ...ctx,
             cellWrapper: CellWrapper.BODY
         },
-        children: /*#__PURE__*/ jsx("div", {
+        children: jsx("div", {
             ref: bodyRef,
             role: "rowgroup",
             className: bodyClass,
-            children: noData ? /*#__PURE__*/ jsx("div", {
+            children: noData ? jsx("div", {
                 role: "row",
                 style: {
                     gridColumn: "1 / -1"
                 },
-                children: /*#__PURE__*/ jsx("div", {
+                children: jsx("div", {
                     role: "gridcell",
                     style: {
                         textAlign: "center",
@@ -463,9 +233,9 @@ const DEFAULT_COMPACT_ESTIMATED_ROW_HEIGHT = 29;
                     },
                     children: noDataText ?? "No Data"
                 })
-            }) : /*#__PURE__*/ jsxs(Fragment, {
+            }) : jsxs(Fragment, {
                 children: [
-                    /*#__PURE__*/ jsx("div", {
+                    jsx("div", {
                         ref: sentinelRef,
                         "aria-hidden": "true",
                         style: {
@@ -473,14 +243,14 @@ const DEFAULT_COMPACT_ESTIMATED_ROW_HEIGHT = 29;
                             height: 0
                         }
                     }),
-                    paddingTop > 0 && /*#__PURE__*/ jsx("div", {
+                    paddingTop > 0 && jsx("div", {
                         "aria-hidden": "true",
                         style: {
                             gridColumn: "1 / -1",
                             height: paddingTop
                         }
                     }),
-                    virtualItems.map((vItem)=>/*#__PURE__*/ jsx(DataGridContext.Provider, {
+                    virtualItems.map((vItem)=>jsx(DataGridContext.Provider, {
                             value: {
                                 ...bodyContextBase,
                                 isLastRow: vItem.index === totalItems - 1,
@@ -490,7 +260,7 @@ const DEFAULT_COMPACT_ESTIMATED_ROW_HEIGHT = 29;
                             },
                             children: renderRow(data[vItem.index], vItem.index)
                         }, vItem.key)),
-                    paddingBottom > 0 && /*#__PURE__*/ jsx("div", {
+                    paddingBottom > 0 && jsx("div", {
                         "aria-hidden": "true",
                         style: {
                             gridColumn: "1 / -1",
@@ -502,7 +272,4 @@ const DEFAULT_COMPACT_ESTIMATED_ROW_HEIGHT = 29;
         })
     });
 }
-
-
-
 export { DataGridInfiniteBody };

package/dist/DataGridRow/index.js

@@ -1,5 +1,5 @@
 /*!
-  @versini/ui-datagrid v4.2.12
+  @versini/ui-datagrid v4.2.13
   © 2026 gizmette.com
 */
 
@@ -8,73 +8,29 @@ import react from "react";
 import { DataGridContext } from "../8.js";
 import { CellWrapper } from "../7.js";
 import { getRowClasses } from "../y.js";
-
-
-
-
-
-
-
-
-/* =============================================================================
- * DataGridRow
- * ========================================================================== */ const DataGridRow = ({ className, children, active, style: userStyle, ...rest })=>{
-    // Count the number of direct children to determine column count.
+const DataGridRow = ({ className, children, active, style: userStyle, ...rest })=>{
     const columnCount = react.Children.count(children);
-    return /*#__PURE__*/ jsx(DataGridContext.Consumer, {
+    return jsx(DataGridContext.Consumer, {
         children: ({ mode, cellWrapper, stickyHeader, stickyFooter, columns, measuredColumnWidths, isLastRow, ariaRowIndex, dataIndex, measureRowElement })=>{
-            /**
-				 * Determine if this row is inside a sticky header/footer. Sticky elements
-				 * are absolutely positioned and outside the main grid flow, so they can't
-				 * use subgrid.
-				 */ const isInStickyHeader = cellWrapper === CellWrapper.HEADER && stickyHeader;
+            const isInStickyHeader = cellWrapper === CellWrapper.HEADER && stickyHeader;
             const isInStickyFooter = cellWrapper === CellWrapper.FOOTER && stickyFooter;
             const isInStickyContext = isInStickyHeader || isInStickyFooter;
-            /**
-				 * When columns are provided AND the row is inside the grid flow (not in a
-				 * sticky header/footer), use CSS subgrid to inherit the column sizing from
-				 * the parent grid.
-				 *
-				 * For sticky headers/footers, use measured pixel widths from the body if
-				 * available. This syncs the header/footer columns with the body columns
-				 * since absolutely positioned elements can't use subgrid.
-				 *
-				 * When columns are not provided, fall back to the original behavior where
-				 * each row defines its own equal-width columns.
-				 *
-				 */ let rowStyle;
-            if (columns) {
-                if (isInStickyContext) {
-                    /**
-						 * Sticky elements can't use subgrid. Use measured widths from body if
-						 * available for perfect alignment. Also check that widths are valid
-						 * (non-zero) - in test environments or before layout, measurements may be
-						 * zero.
-						 */ const hasValidMeasurements = measuredColumnWidths && measuredColumnWidths.length === columns.length && measuredColumnWidths.some((w)=>w > 0);
-                    if (hasValidMeasurements) {
-                        rowStyle = {
-                            gridTemplateColumns: measuredColumnWidths.map((w)=>`${w}px`).join(" ")
-                        };
-                    } else {
-                        // Fallback to explicit template while measurements are pending.
-                        rowStyle = {
-                            gridTemplateColumns: columns.join(" ")
-                        };
-                    }
-                } else {
-                    // Normal flow: use subgrid to inherit from parent grid.
-                    rowStyle = {
-                        gridColumn: "1 / -1",
-                        gridTemplateColumns: "subgrid"
-                    };
-                }
-            } else {
-                // No columns prop: use equal-width columns.
-                rowStyle = {
-                    gridTemplateColumns: `repeat(${columnCount}, minmax(0, 1fr))`
+            let rowStyle;
+            if (columns) if (isInStickyContext) {
+                const hasValidMeasurements = measuredColumnWidths && measuredColumnWidths.length === columns.length && measuredColumnWidths.some((w)=>w > 0);
+                rowStyle = hasValidMeasurements ? {
+                    gridTemplateColumns: measuredColumnWidths.map((w)=>`${w}px`).join(" ")
+                } : {
+                    gridTemplateColumns: columns.join(" ")
                 };
-            }
-            return /*#__PURE__*/ jsx("div", {
+            } else rowStyle = {
+                gridColumn: "1 / -1",
+                gridTemplateColumns: "subgrid"
+            };
+            else rowStyle = {
+                gridTemplateColumns: `repeat(${columnCount}, minmax(0, 1fr))`
+            };
+            return jsx("div", {
                 ref: measureRowElement,
                 role: "row",
                 className: getRowClasses({
@@ -89,7 +45,7 @@ import { getRowClasses } from "../y.js";
                     ...rowStyle,
                     ...userStyle
                 },
-                "data-active": active || undefined,
+                "data-active": active || void 0,
                 "data-index": dataIndex,
                 "aria-rowindex": ariaRowIndex,
                 ...rest,
@@ -98,7 +54,4 @@ import { getRowClasses } from "../y.js";
         }
     });
 };
-
-
-
 export { DataGridRow };