@lowdefy/blocks-table 0.0.0-experimental-20260929110023

package/dist/features/events/handlePointerDown.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.
+*/ function handlePointerDown(event, api) {
+    api.pointerStart = {
+        x: event.clientX,
+        y: event.clientY
+    };
+    return false;
+}
+export default handlePointerDown;

package/dist/features/events/handleRowClick.js

@@ -0,0 +1,57 @@
+/*
+  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 { get } from '@lowdefy/helpers';
+import isControlTarget from '@lowdefy/blocks-antd/table/isControlTarget.js';
+import getBodyTarget from './getBodyTarget.js';
+import isTextDrag from './isTextDrag.js';
+function handleRowClick(event, api) {
+    const target = getBodyTarget({
+        event,
+        api
+    });
+    if (!target) return false;
+    const { cell, row, rowElement } = target;
+    if (isControlTarget({
+        target: event.target,
+        container: rowElement
+    })) return false;
+    if (isTextDrag({
+        event,
+        api
+    })) return true;
+    if (cell && api.events.onCellClick) {
+        const col = api.layout.byKey.get(cell.dataset.colKey);
+        if (col && !col.special) {
+            api.methods.triggerEvent({
+                name: 'onCellClick',
+                event: {
+                    row: row.original,
+                    rowKey: api.config.getKey(row.original),
+                    column: {
+                        key: col.key,
+                        field: col.column.field
+                    },
+                    value: get(row.original, col.column.field)
+                }
+            });
+        }
+    }
+    api.actions.activateRow({
+        id: row.id,
+        event
+    });
+    return true;
+}
+export default handleRowClick;

package/dist/features/events/handleRowDoubleClick.js

@@ -0,0 +1,45 @@
+/*
+  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 isControlTarget from '@lowdefy/blocks-antd/table/isControlTarget.js';
+import getBodyTarget from './getBodyTarget.js';
+import getRowIndex from './getRowIndex.js';
+function handleRowDoubleClick(event, api) {
+    const target = getBodyTarget({
+        event,
+        api
+    });
+    if (!target) return false;
+    const { cell, row, rowElement } = target;
+    if (isControlTarget({
+        target: event.target,
+        container: rowElement
+    }) || cell?.dataset.lfSelectCell === '') {
+        return false;
+    }
+    const rowKey = api.config.getKey(row.original);
+    api.methods.triggerEvent({
+        name: 'onRowDoubleClick',
+        event: {
+            row: row.original,
+            rowKey,
+            index: getRowIndex({
+                api,
+                rowKey
+            })
+        }
+    });
+    return true;
+}
+export default handleRowDoubleClick;

package/dist/features/events/isTextDrag.js

@@ -0,0 +1,30 @@
+/*
+  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.
+*/ const DRAG_THRESHOLD = 4;
+// A click that ends a text selection (drag, or a selection inside the table) is not a row click,
+// so copying text out of a row never navigates.
+function isTextDrag({ event, api }) {
+    const start = api.pointerStart;
+    if (start) {
+        const distance = Math.abs(event.clientX - start.x) + Math.abs(event.clientY - start.y);
+        if (distance > DRAG_THRESHOLD) return true;
+    }
+    const selection = window.getSelection?.();
+    if (!selection || selection.isCollapsed || selection.toString() === '') return false;
+    const anchor = selection.anchorNode;
+    const element = anchor?.nodeType === 1 ? anchor : anchor?.parentElement;
+    return api.contains(element);
+}
+export default isTextDrag;

package/dist/features/events/openRowLink.js

@@ -0,0 +1,29 @@
+/*
+  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 { getHtmlEnhancements } from '@lowdefy/block-utils';
+import resolveLink from '@lowdefy/blocks-antd/table/resolveLink.js';
+// The client registers the same link function the Link action uses, so rowLink gets router
+// navigation, page input and new tabs exactly as a Link (and TableLight's rowLink) does.
+function openRowLink({ rowLink, row, newTab }) {
+    const link = resolveLink({
+        link: rowLink,
+        row
+    });
+    getHtmlEnhancements().link({
+        ...link,
+        newTab: newTab === true || link.newTab === true
+    });
+}
+export default openRowLink;

package/dist/features/expandable/DetailRow.js

@@ -0,0 +1,57 @@
+/*
+  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, useLayoutEffect, useRef } from 'react';
+import { renderHtml } from '@lowdefy/block-utils';
+// The expanded content of a row: the `expandable.template` HTML in one cell as wide as the
+// viewport (it stays put while the table scrolls sideways). Its height is its content's: the body
+// measures it after each window render like any measured item (`data-measure-key`), and it
+// reports again when its content resizes (images loading, fonts), so the rows below move.
+function DetailRow({ api, ariaRowIndex, displayIndex, item }) {
+    const ref = useRef(null);
+    useLayoutEffect(()=>{
+        const element = ref.current;
+        const observer = new ResizeObserver(()=>api.measureRows([
+                element
+            ]));
+        observer.observe(element);
+        return ()=>observer.disconnect();
+    }, [
+        api
+    ]);
+    const html = api.config.expandable.render({
+        row: item.original,
+        rowKey: api.config.getKey(item.original)
+    });
+    return /*#__PURE__*/ React.createElement("div", {
+        "aria-rowindex": ariaRowIndex,
+        className: "lf-table-detail",
+        "data-detail-for": item.parentId,
+        "data-measure-key": `detail:${item.key}`,
+        "data-row-index": displayIndex,
+        ref: ref,
+        role: "row"
+    }, /*#__PURE__*/ React.createElement("div", {
+        "aria-colspan": api.layout.cols.length,
+        className: "lf-table-detail-cell",
+        "data-col-index": "0",
+        "data-lf-cell": "",
+        role: "gridcell",
+        tabIndex: -1
+    }, renderHtml({
+        html,
+        methods: api.methods
+    })));
+}
+export default /*#__PURE__*/ memo(DetailRow);

package/dist/features/expandable/ExpandToggle.js

@@ -0,0 +1,34 @@
+/*
+  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 Chevron from '../../core/Chevron.js';
+// The expand chevron of an expandable row, in its first data cell. Rows that
+// `rowExpandable.when` excludes keep the space so the column stays aligned.
+function ExpandToggle({ item }) {
+    if (item.expandable === undefined) return null;
+    if (!item.expandable) return /*#__PURE__*/ React.createElement("span", {
+        className: "lf-table-toggle-spacer"
+    });
+    return /*#__PURE__*/ React.createElement("button", {
+        "aria-expanded": item.detailExpanded,
+        "aria-label": item.detailExpanded ? 'Collapse row details' : 'Expand row details',
+        className: "lf-table-toggle",
+        "data-expanded": item.detailExpanded ? '' : undefined,
+        "data-lf-expand-toggle": "",
+        tabIndex: -1,
+        type: "button"
+    }, /*#__PURE__*/ React.createElement(Chevron, null));
+}
+export default ExpandToggle;

package/dist/features/expandable/expandable.css

@@ -0,0 +1,40 @@
+/*
+  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.
+*/
+
+@layer components {
+  .lf-table-detail {
+    box-sizing: border-box;
+    width: var(--lf-total);
+    min-width: 100%;
+    background: color-mix(in srgb, var(--ant-color-text-base, #000) 2%, var(--lf-bg));
+    border-bottom: 1px solid var(--lf-border);
+  }
+
+  .lf-table-detail-cell {
+    position: sticky;
+    left: 0;
+    box-sizing: border-box;
+    width: var(--lf-viewport-w, 100%);
+    padding: var(--ant-padding-sm, 12px) var(--ant-padding, 16px);
+    overflow: auto;
+    white-space: normal;
+    outline: none;
+  }
+
+  .lf-table-detail-cell:focus-visible {
+    box-shadow: inset 0 0 0 2px var(--ant-color-primary, #1677ff);
+  }
+}

package/dist/features/expandable/expandableFeature.js

@@ -0,0 +1,34 @@
+/*
+  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 DetailRow from './DetailRow.js';
+import ExpandToggle from './ExpandToggle.js';
+import handleExpandClick from './handleExpandClick.js';
+import useExpandableItems from './useExpandableItems.js';
+import './expandable.css';
+// `expandable: { template, rowExpandable: { when } }`: a chevron in the first data column opens
+// a detail row below the row with the template's HTML. Expanded row keys are the value's
+// `expanded` (shared with tree rows). Lowdefy blocks inside detail rows are not supported yet.
+const expandableFeature = {
+    name: 'expandable',
+    useItems: useExpandableItems,
+    rowRenderers: {
+        detail: DetailRow
+    },
+    cellLead: ExpandToggle,
+    gridHandlers: {
+        click: handleExpandClick
+    }
+};
+export default expandableFeature;

package/dist/features/expandable/handleExpandClick.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.
+*/ function handleExpandClick(event, api) {
+    if (!api.config.expandable) return false;
+    const toggle = event.target.closest('[data-lf-expand-toggle]');
+    if (!toggle || !api.contains(toggle)) return false;
+    const rowElement = toggle.closest('[data-row-key]');
+    api.actions.toggleRowExpanded({
+        id: rowElement.dataset.rowKey
+    });
+    return true;
+}
+export default handleExpandClick;

package/dist/features/expandable/needsExpandable.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.
+*/ import { type } from '@lowdefy/helpers';
+// Expandable rows load when `expandable` is set (normalizeExpandable validates it).
+function needsExpandable({ properties }) {
+    return !type.isNone(properties.expandable);
+}
+export default needsExpandable;

package/dist/features/expandable/normalizeExpandable.js

@@ -0,0 +1,52 @@
+/*
+  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 { type } from '@lowdefy/helpers';
+import { nunjucksFunction } from '@lowdefy/nunjucks';
+import compileCondition from '@lowdefy/blocks-antd/table/compileCondition.js';
+// `expandable: { template, rowExpandable: { when } }`. The template is nunjucks (autoescaped, so
+// `| safe` is needed to insert HTML from a field), compiled once and rendered with
+// `{ row, rowKey }`; `rowExpandable.when` is a table condition tested against the row.
+function normalizeExpandable({ expandable, columns, user }) {
+    if (type.isNone(expandable)) return null;
+    if (!type.isObject(expandable)) {
+        throw new Error(`Table "expandable" must be an object. Received ${JSON.stringify(expandable)}.`);
+    }
+    if (!type.isString(expandable.template)) {
+        throw new Error(`Table "expandable" requires "template", a nunjucks HTML string. Received ${JSON.stringify(expandable.template)}.`);
+    }
+    const render = nunjucksFunction(expandable.template);
+    let isExpandable = ()=>true;
+    if (!type.isNone(expandable.rowExpandable)) {
+        const when = expandable.rowExpandable?.when;
+        if (!type.isObject(when)) {
+            throw new Error(`Table "expandable.rowExpandable" must be { when: Condition }. Received ${JSON.stringify(expandable.rowExpandable)}.`);
+        }
+        const columnsByKey = Object.fromEntries(columns.map((column)=>[
+                column.key,
+                column
+            ]));
+        const matches = compileCondition({
+            condition: when,
+            columnsByKey,
+            user
+        });
+        isExpandable = (row)=>matches(row);
+    }
+    return {
+        render,
+        isExpandable
+    };
+}
+export default normalizeExpandable;

package/dist/features/expandable/useExpandableItems.js

@@ -0,0 +1,101 @@
+/*
+  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 { useCallback, useMemo, useRef } from 'react';
+import getExpandedIds from '../expansion/getExpandedIds.js';
+import isDataItem from '../../core/isDataItem.js';
+function wrapRow({ item, cache, isExpandable, expandedIds }) {
+    const expandable = isExpandable(item.original);
+    const detailExpanded = expandable && expandedIds.has(item.id);
+    const cached = cache.get(item);
+    if (cached?.expandable === expandable && cached.detailExpanded === detailExpanded) return cached;
+    const base = item.kind ? item : {
+        kind: 'row',
+        id: item.id,
+        row: item,
+        original: item.original,
+        index: item.index
+    };
+    const wrapped = {
+        ...base,
+        expandable,
+        detailExpanded
+    };
+    cache.set(item, wrapped);
+    return wrapped;
+}
+function getDetail({ item, cache }) {
+    let detail = cache.get(item.row);
+    if (detail?.original !== item.original) {
+        detail = {
+            kind: 'detail',
+            key: item.id,
+            parentId: item.id,
+            original: item.original
+        };
+        cache.set(item.row, detail);
+    }
+    return detail;
+}
+// Rows get their expand state, and every expanded row is followed by a detail item rendered by
+// DetailRow. Detail rows are as high as their content: the window measures them (useRowOffsets);
+// `rowHeights` estimates an unmeasured one at three rows. Wrappers are cached per row, so
+// unchanged rows keep their memoised row component.
+function useExpandableItems({ config, rows, rowHeight, state }) {
+    const { expandable } = config;
+    const rowCache = useRef(new WeakMap());
+    const detailCache = useRef(new WeakMap());
+    const result = useMemo(()=>{
+        if (!expandable) return null;
+        const expandedIds = getExpandedIds(state.expanded);
+        const items = [];
+        let details = 0;
+        rows.forEach((item)=>{
+            if (!isDataItem(item)) {
+                items.push(item);
+                return;
+            }
+            const wrapped = wrapRow({
+                item,
+                cache: rowCache.current,
+                isExpandable: expandable.isExpandable,
+                expandedIds
+            });
+            items.push(wrapped);
+            if (!wrapped.detailExpanded) return;
+            items.push(getDetail({
+                item: wrapped,
+                cache: detailCache.current
+            }));
+            details += 1;
+        });
+        return {
+            items,
+            details
+        };
+    }, [
+        expandable,
+        rows,
+        state.expanded
+    ]);
+    const rowHeights = useCallback((item)=>item?.kind === 'detail' ? rowHeight * 3 : undefined, [
+        rowHeight
+    ]);
+    if (!result) return null;
+    return {
+        rows: result.items,
+        rowHeights: result.details > 0 ? rowHeights : undefined
+    };
+}
+export default useExpandableItems;

package/dist/features/expansion/createToggleRowExpanded.js

@@ -0,0 +1,52 @@
+/*
+  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 { type } from '@lowdefy/helpers';
+import getExpandedIds from './getExpandedIds.js';
+import rowNeedsChildren from '../tree/rowNeedsChildren.js';
+// Expands or collapses a row (a tree node or a row with a detail row), writes `expanded` to the
+// value and fires `onRowExpand { row, rowKey, expanded, needsChildren }`. `needsChildren` is true
+// when a lazy tree row is expanded before its children are in `data`. `expanded` omitted
+// toggles.
+function createToggleRowExpanded(api) {
+    return function toggleRowExpanded({ id, expanded }) {
+        const row = api.table.getRow(id, true);
+        if (!row) return false;
+        const rowKey = api.config.getKey(row.original);
+        const isExpanded = getExpandedIds(api.state.expanded).has(id);
+        const next = type.isBoolean(expanded) ? expanded : !isExpanded;
+        if (next === isExpanded) return true;
+        api.updateSlice('expanded', (previous)=>next ? [
+                ...previous,
+                rowKey
+            ] : previous.filter((key)=>String(key) !== id), {
+            cause: 'expand'
+        });
+        api.methods.triggerEvent({
+            name: 'onRowExpand',
+            event: {
+                row: row.original,
+                rowKey,
+                expanded: next,
+                needsChildren: next && rowNeedsChildren({
+                    api,
+                    id,
+                    row
+                })
+            }
+        });
+        return true;
+    };
+}
+export default createToggleRowExpanded;

package/dist/features/expansion/expansionFeature.js

@@ -0,0 +1,31 @@
+/*
+  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 createToggleRowExpanded from './createToggleRowExpanded.js';
+import initExpanded from './initExpanded.js';
+// Owns the `expanded` part of the value (row keys), shared by tree rows and expandable rows.
+// The core writes `state.expanded` into the value.
+const expansionFeature = {
+    name: 'expansion',
+    slices: {
+        expanded: {
+            init: initExpanded,
+            cause: 'expand'
+        }
+    },
+    actions: {
+        toggleRowExpanded: createToggleRowExpanded
+    }
+};
+export default expansionFeature;

package/dist/features/expansion/getExpandedIds.js

@@ -0,0 +1,26 @@
+/*
+  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.
+*/ const cache = new WeakMap();
+// The expanded row keys as a set of row ids (TanStack ids are strings), cached per `expanded`
+// array so every lookup in a render shares one set.
+function getExpandedIds(expanded) {
+    let ids = cache.get(expanded);
+    if (!ids) {
+        ids = new Set(expanded.map(String));
+        cache.set(expanded, ids);
+    }
+    return ids;
+}
+export default getExpandedIds;