@lowdefy/blocks-table 0.0.0-experimental-20260929110023

package/dist/core/LazyCell.js

@@ -0,0 +1,71 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import React, { useRef, useSyncExternalStore } from 'react';
+import { get } from '@lowdefy/helpers';
+import getCellText from '@lowdefy/blocks-antd/table/getCellText.js';
+import renderCell from '@lowdefy/blocks-antd/table/renderCell.js';
+import getCellFit from './getCellFit.js';
+// The cell's text in the column's cell layout: what a rich cell shows while the grid scrolls
+// fast. Buttons hold no text, so theirs is an empty cell.
+function renderPlaceholder({ col, original }) {
+    const { column } = col;
+    const text = column.type === 'buttons' ? null : getCellText({
+        column,
+        value: get(original, column.field),
+        row: original
+    });
+    return /*#__PURE__*/ React.createElement("div", {
+        className: column.compiled.className
+    }, text);
+}
+// A rich cell (lazyCellTypes.js) that mounts on demand. Any rich cell that comes into view while
+// the grid scrolls fast shows its text placeholder until the scroll settles, then renders in
+// full and stays (D10.4). `buttons` with `showOn: hover` mount only while their row is hovered or
+// holds keyboard focus, and not during a fast scroll (tier 1, D4): they are invisible otherwise.
+// Chip cells show the chips that fit their column (getCellFit), worked out again when it resizes.
+function LazyCell({ api, col, lead, original, rowKey }) {
+    const activity = api.cellActivity;
+    const rowId = String(rowKey);
+    const hoverOnly = col.column.type === 'buttons' && col.column.cell.showOn === 'hover';
+    const shownRef = useRef(false);
+    const active = useSyncExternalStore(activity.subscribe, ()=>{
+        const { state } = activity;
+        if (hoverOnly) {
+            // Rows pass under a still pointer while the grid scrolls: wait until it settles.
+            if (state.fastScrolling) return false;
+            return activity.noHover || state.hoveredRow === rowId || state.focusedRow === rowId;
+        }
+        return shownRef.current || !state.fastScrolling;
+    });
+    if (!active) return renderPlaceholder({
+        col,
+        original
+    });
+    shownRef.current = true;
+    return renderCell({
+        column: col.column,
+        row: original,
+        rowKey,
+        methods: api.methods,
+        components: api.components,
+        onEvent: api.onCellEvent,
+        fit: getCellFit({
+            api,
+            col,
+            lead
+        })
+    });
+}
+export default LazyCell;

package/dist/core/LoadingRows.js

@@ -0,0 +1,38 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import React from 'react';
+const SKELETON_ROWS = 5;
+function LoadingRows({ layout }) {
+    const rows = [];
+    for(let i = 0; i < SKELETON_ROWS; i++){
+        rows.push(/*#__PURE__*/ React.createElement("div", {
+            "aria-hidden": "true",
+            className: "lf-table-row",
+            key: i
+        }, layout.cols.map((col)=>/*#__PURE__*/ React.createElement("div", {
+                className: "lf-table-gridcell",
+                key: col.key,
+                style: {
+                    width: col.width
+                }
+            }, col.special ? null : /*#__PURE__*/ React.createElement("span", {
+                className: "lf-table-skeleton-bar"
+            })))));
+    }
+    return /*#__PURE__*/ React.createElement("div", {
+        className: "lf-table-body"
+    }, rows);
+}
+export default LoadingRows;

package/dist/core/RenderProbeContext.js

@@ -0,0 +1,19 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { createContext } from 'react';
+// Render counters for the benchmark page only (bench/app provides a value). Production pages never
+// provide one, so the rows and body only pay for a context read.
+const RenderProbeContext = /*#__PURE__*/ createContext(null);
+export default RenderProbeContext;

package/dist/core/Row.js

@@ -0,0 +1,98 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import React, { memo, useContext } from 'react';
+import { cn } from '@lowdefy/block-utils';
+import Cell from './Cell.js';
+import RenderProbeContext from './RenderProbeContext.js';
+function renderCells({ api, cols, activeCol, lead, leadIndex, original, selected }) {
+    return cols.map((col)=>/*#__PURE__*/ React.createElement(Cell, {
+            api: api,
+            col: col,
+            focused: activeCol === col.index,
+            key: col.key,
+            lead: col.index === leadIndex ? lead : undefined,
+            original: original,
+            selected: selected
+        }));
+}
+// Wrapped row items (tree rows, expandable rows) get the features' lead elements in their first
+// data cell; plain rows render none.
+function renderLead({ api, item }) {
+    if (!item) return undefined;
+    return api.features.cellLeads.map((Lead, index)=>/*#__PURE__*/ React.createElement(Lead, {
+            api: api,
+            item: item,
+            key: index
+        }));
+}
+// Memoised by row key and row object: with data diffed by key, an update to one row of 100k
+// re-renders that one row. Rows never receive their TanStack row object, whose identity changes
+// whenever the row model rebuilds. `rowRules` classes and styles come from the row object, so they
+// are worked out here, inside the memo. The row element carries `lf-table-row`, the class the
+// shared cell styles reveal `showOn: hover` buttons from (the row holds its pinned cells too, so
+// CSS hover covers the whole row).
+function Row({ activeCol, api, ariaRowIndex, centerCols, className, displayIndex, endCols, item, leadIndex, measured, offset, original, rowId, selectable, selected, startCols, style }) {
+    const probe = useContext(RenderProbeContext);
+    probe?.row(rowId);
+    const positioned = offset !== undefined;
+    const lead = renderLead({
+        api,
+        item
+    });
+    const cellArgs = {
+        api,
+        activeCol,
+        lead,
+        leadIndex,
+        original,
+        selected
+    };
+    const ruled = api.config.rowRules === null ? null : api.config.rowRules(original);
+    let rowStyle = style;
+    if (ruled?.style) rowStyle = {
+        ...style ?? {},
+        ...ruled.style
+    };
+    if (positioned) rowStyle = {
+        ...rowStyle ?? {},
+        transform: `translateY(${offset}px)`
+    };
+    return /*#__PURE__*/ React.createElement("div", {
+        "aria-expanded": item?.hasChildren || item?.expandable ? item.expanded === true || item.detailExpanded === true : undefined,
+        "aria-level": item?.depth === undefined ? undefined : item.depth + 1,
+        "aria-rowindex": ariaRowIndex,
+        "aria-selected": selectable ? selected : undefined,
+        className: cn(className, ruled?.className),
+        "data-measure-key": measured ? rowId : undefined,
+        "data-measured": measured ? '' : undefined,
+        "data-positioned": positioned ? '' : undefined,
+        "data-row-index": displayIndex,
+        "data-row-key": rowId,
+        role: "row",
+        style: rowStyle
+    }, renderCells({
+        ...cellArgs,
+        cols: startCols
+    }), /*#__PURE__*/ React.createElement("div", {
+        className: "lf-table-center"
+    }, renderCells({
+        ...cellArgs,
+        cols: centerCols
+    })), renderCells({
+        ...cellArgs,
+        cols: endCols
+    }));
+}
+export default /*#__PURE__*/ memo(Row);

package/dist/core/SkeletonRow.js

@@ -0,0 +1,42 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import React, { memo } from 'react';
+// A row that is not loaded yet (server mode): the row's box with a skeleton bar per data cell,
+// so fast scrolling shows placeholders instead of blank space.
+function SkeletonRow({ ariaRowIndex, centerCols, className, displayIndex, endCols, startCols }) {
+    const renderCells = (cols)=>cols.map((col)=>/*#__PURE__*/ React.createElement("div", {
+                className: "lf-table-gridcell",
+                "data-col-index": col.index,
+                "data-lf-cell": "",
+                "data-pinned": col.region === 'center' ? undefined : col.region,
+                key: col.key,
+                role: "gridcell",
+                style: col.style,
+                tabIndex: -1
+            }, col.special ? null : /*#__PURE__*/ React.createElement("span", {
+                className: "lf-table-skeleton-bar"
+            })));
+    return /*#__PURE__*/ React.createElement("div", {
+        "aria-busy": "true",
+        "aria-rowindex": ariaRowIndex,
+        className: className,
+        "data-row-index": displayIndex,
+        "data-skeleton": "",
+        role: "row"
+    }, renderCells(startCols), /*#__PURE__*/ React.createElement("div", {
+        className: "lf-table-center"
+    }, renderCells(centerCols)), renderCells(endCols));
+}
+export default /*#__PURE__*/ memo(SkeletonRow);

package/dist/core/SummaryRow.js

@@ -0,0 +1,86 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import React from 'react';
+import AGGREGATE_LABELS from '@lowdefy/blocks-antd/table/aggregateLabels.js';
+import getSummaryLabel from './getSummaryLabel.js';
+// The label is the full one when it fits beside the value, else its short form, else none
+// (getSummaryLabel, measured without DOM reads); the full label and value are the title.
+function renderSummary({ api, col, entry }) {
+    const label = AGGREGATE_LABELS[entry.fn];
+    const text = entry.text === '' ? '—' : entry.text;
+    const measure = api.textMeasure;
+    const shown = getSummaryLabel({
+        fn: entry.fn,
+        measure,
+        text,
+        width: col.width - measure.cellInset
+    });
+    return /*#__PURE__*/ React.createElement("span", {
+        className: "lf-table-summary",
+        "data-aggregate": entry.fn,
+        title: `${label} ${text}`
+    }, shown === null ? null : /*#__PURE__*/ React.createElement("span", {
+        className: "lf-table-summary-label"
+    }, shown), /*#__PURE__*/ React.createElement("span", {
+        className: "lf-table-summary-value"
+    }, text));
+}
+function renderCells({ api, cols, summary }) {
+    return cols.map((col)=>{
+        const entry = col.special ? undefined : summary.get(col.key);
+        return /*#__PURE__*/ React.createElement("div", {
+            className: "lf-table-gridcell",
+            "data-align": col.column?.align,
+            "data-col-key": col.key,
+            "data-pinned": col.region === 'center' ? undefined : col.region,
+            "data-pinned-edge": col.pinnedEdge ? '' : undefined,
+            key: col.key,
+            role: "gridcell",
+            style: col.style
+        }, entry ? renderSummary({
+            api,
+            col,
+            entry
+        }) : null);
+    });
+}
+// The summary footer row (D15: on when a column declares `aggregate`), sticky at the bottom of the
+// scroller so it stays in view and scrolls sideways with the columns. Same markup and labels as
+// TableLight's summary row.
+function SummaryRow({ api, ariaRowIndex, centerCols, layout, summary }) {
+    return /*#__PURE__*/ React.createElement("div", {
+        className: "lf-table-footer",
+        role: "rowgroup"
+    }, /*#__PURE__*/ React.createElement("div", {
+        "aria-rowindex": ariaRowIndex,
+        className: "lf-table-row lf-table-summary-row",
+        role: "row"
+    }, renderCells({
+        api,
+        cols: layout.start,
+        summary
+    }), /*#__PURE__*/ React.createElement("div", {
+        className: "lf-table-center"
+    }, renderCells({
+        api,
+        cols: centerCols,
+        summary
+    })), renderCells({
+        api,
+        cols: layout.end,
+        summary
+    })));
+}
+export default SummaryRow;

package/dist/core/TableRoot.js

@@ -0,0 +1,195 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import React, { useMemo, useRef } from 'react';
+import { useTable } from '@tanstack/react-table';
+import createApi from './createApi.js';
+import createFeatureActions from './createFeatureActions.js';
+import createKeyIndex from './createKeyIndex.js';
+import createSliceHandlers from './createSliceHandlers.js';
+import densityHeights from './densityHeights.js';
+import Grid from './Grid.js';
+import stabilizeData from './stabilizeData.js';
+import useFeatureData from './useFeatureData.js';
+import useFeatureFragments from './useFeatureFragments.js';
+import useFeatureItems from './useFeatureItems.js';
+import useFeatureMethods from './useFeatureMethods.js';
+import useFeatureRows from './useFeatureRows.js';
+import useForeignKeys from './useForeignKeys.js';
+import useSummary from './useSummary.js';
+import useTableConfig from './useTableConfig.js';
+import useTableState from './useTableState.js';
+import './table.css';
+// The table core: config, data, TanStack state and the feature fragments, composed into the
+// window component. `rowWindowStrategy` is a benchmark-only prop (the Lowdefy client never passes
+// it) that switches the row window to TanStack Virtual's per-row positioning. `input` is set by
+// TableInput only: `{ changes, methods }`, its value (a changeset over `data`) and the engine
+// methods that write it.
+//
+// The data pipeline, in order (ARCHITECTURE.md, "Data path"):
+// 1. source (`useData` hooks): `properties.data`, or server mode's loaded block rows; a
+//    `childrenField` tree is flattened here.
+// 2. key diff (`stabilizeData`): unchanged rows keep their object identity across data changes.
+// 3. row overlays (`useRows` hooks): client transactions, then editing's optimistic overlay or
+//    TableInput's changeset.
+// 4. TanStack: filter and sort (manual in server mode), selection, row lookup.
+// 5. display list (`useItems` hooks): server items, client groups, tree rows, expandable detail
+//    rows, the current page; with the items' height estimates when they are not one row high.
+// 6. window (Grid, virtualization): the rendered range of the display list, and the row offsets
+//    when heights differ (measured rows, detail rows).
+function TableRoot({ basePath, blockId, classNames = {}, components, content = {}, events = {}, features, input, loading, methods, pageId, properties, rowWindowStrategy, styles = {}, value }) {
+    const config = useTableConfig({
+        properties
+    });
+    const apiRef = useRef(null);
+    if (apiRef.current === null) {
+        apiRef.current = createApi({
+            features
+        });
+        createFeatureActions(apiRef.current);
+    }
+    const api = apiRef.current;
+    const sourceData = useFeatureData({
+        api,
+        config,
+        properties
+    });
+    const previousData = useRef(null);
+    const stable = useMemo(()=>stabilizeData({
+            data: sourceData,
+            previous: previousData.current,
+            getKey: config.getKey,
+            rowVersionField: config.rowVersionField
+        }), [
+        sourceData,
+        config.getKey,
+        config.rowVersionField
+    ]);
+    previousData.current = stable;
+    // Row events report a row's index in the source rows (`data`), before any overlay.
+    api.getSourceIndex = useMemo(()=>createKeyIndex({
+            rows: stable.rows,
+            getKey: config.getKey
+        }), [
+        stable.rows,
+        config.getKey
+    ]);
+    const data = useFeatureRows({
+        api,
+        config,
+        input,
+        properties,
+        rows: stable.rows
+    });
+    const { isPending, loadValue, setSliceSilently, state, updateSlice } = useTableState({
+        api,
+        config,
+        data,
+        methods,
+        properties,
+        value
+    });
+    const sliceHandlers = useMemo(()=>createSliceHandlers({
+            sliceDefinitions: features.sliceDefinitions,
+            updateSlice
+        }), [
+        updateSlice
+    ]);
+    const tableOptions = useMemo(()=>Object.assign({}, ...features.list.map((feature)=>feature.tableOptions?.({
+                config
+            }) ?? {})), [
+        config
+    ]);
+    const table = useTable({
+        ...tableOptions,
+        ...sliceHandlers,
+        columns: config.columnDefs,
+        data,
+        features: features.tanstackFeatures,
+        getRowId: config.getId,
+        state
+    });
+    Object.assign(api, {
+        basePath,
+        blockId,
+        components,
+        config,
+        content,
+        events,
+        input,
+        loadValue,
+        methods,
+        pageId,
+        properties,
+        setSliceSilently,
+        state,
+        table,
+        updateSlice,
+        value
+    });
+    useForeignKeys({
+        api,
+        selected: value?.selected
+    });
+    useFeatureMethods({
+        api,
+        methods
+    });
+    const rowHeight = config.rowHeight ?? densityHeights[state.density];
+    const headerHeight = Math.min(Math.max(rowHeight, 32), 48);
+    // Before the fragments, so a fragment (the pager) renders with this render's display list.
+    const { dataRows, rowHeights, rows } = useFeatureItems({
+        api,
+        config,
+        rowHeight,
+        rows: table.getRowModel().rows,
+        state,
+        table
+    });
+    api.dataRows = dataRows;
+    const fragments = useFeatureFragments({
+        api,
+        config,
+        data,
+        state,
+        table
+    });
+    const { leadingColumns, regions } = fragments;
+    const summary = useSummary({
+        api,
+        config,
+        state,
+        table
+    });
+    return /*#__PURE__*/ React.createElement(Grid, {
+        api: api,
+        blockId: blockId,
+        classNames: classNames,
+        clickable: Boolean(config.rowLink || events.onRowClick),
+        config: config,
+        headerHeight: headerHeight,
+        isPending: isPending || fragments.pending,
+        leadingColumns: leadingColumns,
+        loading: loading === true || properties.loading === true || fragments.loading,
+        regions: regions,
+        rowHeight: rowHeight,
+        rowHeights: rowHeights,
+        rows: rows,
+        state: state,
+        strategy: rowWindowStrategy,
+        styles: styles,
+        summary: summary
+    });
+}
+export default TableRoot;

package/dist/core/aggregateShortLabels.js

@@ -0,0 +1,25 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ // Short forms of the summary footer's aggregate labels, for columns too narrow for the full label
+// (AGGREGATE_LABELS). Labels already short (Min, Max) have none and keep their full form.
+const AGGREGATE_SHORT_LABELS = {
+    sum: 'Σ',
+    avg: 'Avg',
+    count: '#',
+    countDistinct: 'Uniq',
+    earliest: 'First',
+    latest: 'Last'
+};
+export default AGGREGATE_SHORT_LABELS;

package/dist/core/applyLayoutVars.js

@@ -0,0 +1,22 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ // Writes a layout's CSS variables straight to the root element: the resize drag path, which must
+// not render React.
+function applyLayoutVars({ element, layout }) {
+    Object.entries(layout.vars).forEach(([name, value])=>{
+        element.style.setProperty(name, value);
+    });
+}
+export default applyLayoutVars;

package/dist/core/buildGroupSegments.js

@@ -0,0 +1,36 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ // Runs of adjacent layout columns under the same header group at `level` (null for columns with
+// no group that deep, and for special columns). Columns reordered away from their group make a
+// second run, so a group always sits over its own columns.
+function buildGroupSegments({ cols, level, ancestorsByKey }) {
+    const segments = [];
+    cols.forEach((col)=>{
+        const node = col.special ? null : ancestorsByKey.get(col.key)?.[level] ?? null;
+        const last = segments[segments.length - 1];
+        if (last && last.node === node) {
+            last.cols.push(col);
+            return;
+        }
+        segments.push({
+            node,
+            cols: [
+                col
+            ]
+        });
+    });
+    return segments;
+}
+export default buildGroupSegments;

package/dist/core/collectBodyOverlays.js

@@ -0,0 +1,20 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ // Components rendered once between the header and the body rows, inside the scroll canvas, when
+// there are rows (the sticky group header). Each receives the grid's row and layout props.
+function collectBodyOverlays(features) {
+    return features.filter((feature)=>feature.bodyOverlay).map((feature)=>feature.bodyOverlay);
+}
+export default collectBodyOverlays;