@lowdefy/blocks-table 0.0.0-experimental-20260929110023

package/dist/features/views/readPersistedView.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 { type } from '@lowdefy/helpers';
+import decodeViewParam from './decodeViewParam.js';
+import getStorageKey from './getStorageKey.js';
+function readStored({ persist }) {
+    if (persist.storage === 'url') {
+        return decodeViewParam(new URLSearchParams(window.location.search).get(persist.key));
+    }
+    // A private window, blocked site data or a malformed entry means no persisted view, never an
+    // error.
+    try {
+        const text = window.localStorage.getItem(getStorageKey(persist.key));
+        if (type.isNone(text)) return null;
+        const payload = JSON.parse(text);
+        return type.isObject(payload) ? payload : null;
+    } catch  {
+        return null;
+    }
+}
+// The persisted payload `{ view, activeView }`, or null.
+function readPersistedView({ persist }) {
+    if (type.isNone(persist)) return null;
+    const payload = readStored({
+        persist
+    });
+    if (type.isNone(payload)) return null;
+    return {
+        view: type.isObject(payload.view) ? payload.view : {},
+        activeView: type.isString(payload.activeView) ? payload.activeView : null
+    };
+}
+export default readPersistedView;

package/dist/features/views/sanitizePersistedView.js

@@ -0,0 +1,49 @@
+/*
+  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 viewKeys from './viewKeys.js';
+const KNOWN_KEYS = new Set(viewKeys);
+// A stored view comes from an older config or a hand-edited URL. The brief's fallback rules apply:
+// unknown view keys are dropped, column entries for columns that no longer exist are dropped, and
+// declared columns missing from a stored column layout are appended hidden. A view without
+// `columns` keeps following the configured layout.
+function sanitizePersistedView({ view, columnKeys }) {
+    if (!type.isObject(view)) return null;
+    const sanitized = {};
+    Object.keys(view).forEach((key)=>{
+        if (KNOWN_KEYS.has(key)) sanitized[key] = view[key];
+    });
+    if (!type.isArray(view.columns)) {
+        delete sanitized.columns;
+        return sanitized;
+    }
+    const declared = new Set(columnKeys);
+    const seen = new Set();
+    const columns = [];
+    view.columns.forEach((entry)=>{
+        if (!type.isObject(entry) || !declared.has(entry.key) || seen.has(entry.key)) return;
+        seen.add(entry.key);
+        columns.push(entry);
+    });
+    columnKeys.forEach((key)=>{
+        if (!seen.has(key)) columns.push({
+            key,
+            hidden: true
+        });
+    });
+    sanitized.columns = columns;
+    return sanitized;
+}
+export default sanitizePersistedView;

package/dist/features/views/stableStringify.js

@@ -0,0 +1,27 @@
+/*
+  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';
+// JSON with object keys sorted, so two views that differ only in key order compare equal.
+function stableStringify(value) {
+    if (type.isArray(value)) {
+        return `[${value.map((item)=>stableStringify(item ?? null)).join(',')}]`;
+    }
+    if (type.isObject(value)) {
+        const entries = Object.keys(value).filter((key)=>!type.isUndefined(value[key])).sort().map((key)=>`${JSON.stringify(key)}:${stableStringify(value[key])}`);
+        return `{${entries.join(',')}}`;
+    }
+    return JSON.stringify(value ?? null);
+}
+export default stableStringify;

package/dist/features/views/useViews.js

@@ -0,0 +1,136 @@
+/*
+  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 { useEffect, useMemo, useRef, useState } from 'react';
+import { type } from '@lowdefy/helpers';
+import compactView from './compactView.js';
+import createViewsApi from './createViewsApi.js';
+import findActiveView from './findActiveView.js';
+import getViewKey from './getViewKey.js';
+import getViewSliceDeps from './getViewSliceDeps.js';
+import isViewDirty from './isViewDirty.js';
+import normalizeViews from './normalizeViews.js';
+import readMountPayload from './readMountPayload.js';
+import useStableConfig from '../../core/useStableConfig.js';
+import writePersistedView from './writePersistedView.js';
+// Saved views (D7) and view persistence (D6). The active view is block UI state: it starts from
+// the persisted payload, then `activeView`, then the first view, and follows `activeView` when the
+// app changes it. The current view is compared with the active saved view for the dirty strip,
+// and written to storage after every view change.
+function useViews({ api, config, state }) {
+    const viewsConfig = useStableConfig(api.properties.views);
+    const views = useMemo(()=>normalizeViews(viewsConfig), [
+        viewsConfig
+    ]);
+    const activeProp = api.properties.activeView;
+    // By key: an object id (`{ _oid }`) is a new object every time the engine evaluates it.
+    const activePropKey = type.isNone(activeProp) ? null : getViewKey(activeProp);
+    const { persist } = config;
+    const enabled = views.length > 0 || persist !== null;
+    const mount = useRef(null);
+    if (mount.current === null) {
+        const payload = readMountPayload({
+            config
+        });
+        const mountedActive = findActiveView({
+            views,
+            id: payload?.activeView ?? activeProp
+        });
+        mount.current = {
+            activeId: payload?.activeView ?? activeProp ?? null,
+            // Views that load after mount (from a request) load the active one, unless the table
+            // mounted with a value of its own or a persisted view.
+            pendingLoad: type.isNone(api.value) && payload === null && mountedActive === null
+        };
+    }
+    const [activeId, setActiveId] = useState(mount.current.activeId);
+    const pendingLoad = useRef(mount.current.pendingLoad);
+    const lastActiveProp = useRef(activePropKey);
+    const active = useMemo(()=>findActiveView({
+            views,
+            id: activeId
+        }), [
+        views,
+        activeId
+    ]);
+    const viewDeps = getViewSliceDeps(state);
+    const currentView = useMemo(()=>enabled ? api.getValue().view : null, [
+        enabled,
+        ...viewDeps
+    ]);
+    const defaults = useMemo(()=>enabled ? api.resolveValue(null).view : null, [
+        enabled,
+        config
+    ]);
+    const savedView = useMemo(()=>active === null ? null : api.resolveValue({
+            view: active.view
+        }).view, [
+        active,
+        config
+    ]);
+    const dirty = savedView !== null && isViewDirty({
+        current: currentView,
+        saved: savedView,
+        defaults
+    });
+    const viewsApi = createViewsApi({
+        api,
+        active,
+        currentView,
+        dirty,
+        setActiveId,
+        views
+    });
+    api.views = viewsApi;
+    useEffect(()=>{
+        if (lastActiveProp.current === activePropKey) return;
+        lastActiveProp.current = activePropKey;
+        pendingLoad.current = true;
+        setActiveId(activeProp ?? null);
+    }, [
+        activePropKey
+    ]);
+    useEffect(()=>{
+        if (!pendingLoad.current || active === null) return;
+        pendingLoad.current = false;
+        if (dirty) viewsApi.load(active);
+    }, [
+        active
+    ]);
+    const lastWritten = useRef(null);
+    useEffect(()=>{
+        if (persist === null) return;
+        const payload = {
+            view: compactView({
+                view: currentView,
+                defaults
+            }),
+            activeView: active?.key ?? null
+        };
+        const json = JSON.stringify(payload);
+        if (json === lastWritten.current) return;
+        lastWritten.current = json;
+        writePersistedView({
+            persist,
+            payload
+        });
+    }, [
+        currentView,
+        active,
+        defaults,
+        persist
+    ]);
+    return null;
+}
+export default useViews;

package/dist/features/views/viewKeys.js

@@ -0,0 +1,28 @@
+/*
+  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.
+*/ // The parts of a table view (design D6). Stored and loaded views keep only these.
+const viewKeys = [
+    'columns',
+    'sort',
+    'filter',
+    'search',
+    'group',
+    'collapsedGroups',
+    'aggregates',
+    'density',
+    'wrap',
+    'pageSize'
+];
+export default viewKeys;

package/dist/features/views/viewsFeature.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.
+*/ import mountViewValue from './mountViewValue.js';
+import notifyViewSelect from './notifyViewSelect.js';
+import useViews from './useViews.js';
+// Saved views and view persistence. `mountValue` supplies the view a table mounts with when it
+// has no value: the persisted view, else the active saved view.
+const viewsFeature = {
+    name: 'views',
+    mountValue: mountViewValue,
+    onCommit: notifyViewSelect,
+    useFeature: useViews
+};
+export default viewsFeature;

package/dist/features/views/writePersistedView.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 { type } from '@lowdefy/helpers';
+import encodeViewParam from './encodeViewParam.js';
+import getStorageKey from './getStorageKey.js';
+function isEmptyPayload(payload) {
+    return Object.keys(payload.view).length === 0 && type.isNone(payload.activeView);
+}
+// Writes the payload `{ view, activeView }`. The URL is replaced, never pushed: a view tweak is
+// not a navigation, so Back still leaves the page.
+function writePersistedView({ persist, payload }) {
+    if (persist.storage === 'url') {
+        const url = new URL(window.location.href);
+        if (isEmptyPayload(payload)) {
+            url.searchParams.delete(persist.key);
+        } else {
+            url.searchParams.set(persist.key, encodeViewParam(payload));
+        }
+        if (url.href !== window.location.href) {
+            window.history.replaceState(window.history.state, '', url.href);
+        }
+        return;
+    }
+    try {
+        window.localStorage.setItem(getStorageKey(persist.key), JSON.stringify(payload));
+    } catch  {
+    // Blocked or full storage: the view lives for the session only.
+    }
+}
+export default writePersistedView;

package/dist/features/virtualization/computeRowOffsets.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.
+*/ // Each display item's top offset in the body, and the body height last (`rows.length + 1`
+// entries), for lists whose items are not all one row high: `heightOf(item, index)` gives an
+// item's measured height or estimate, undefined for one row.
+function computeRowOffsets({ rows, rowHeight, heightOf }) {
+    const count = rows.length;
+    const offsets = new Float64Array(count + 1);
+    let top = 0;
+    for(let i = 0; i < count; i++){
+        offsets[i] = top;
+        top += heightOf(rows[i], i) ?? rowHeight;
+    }
+    offsets[count] = top;
+    return offsets;
+}
+export default computeRowOffsets;

package/dist/features/virtualization/computeWindow.js

@@ -0,0 +1,92 @@
+/*
+  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 firstIndexAbove from './firstIndexAbove.js';
+// Centre columns rendered beyond each edge of the viewport (MUI's column buffer).
+const COLUMN_OVERSCAN_PX = 150;
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+function fixedRowRange({ rowCount, rowHeight, top, bottom }) {
+    const rowStart = clamp(Math.floor(top / rowHeight), 0, rowCount);
+    const rowEnd = clamp(Math.ceil(bottom / rowHeight), rowStart, rowCount);
+    return {
+        rowStart,
+        rowEnd
+    };
+}
+// With `rowOffsets` (each item's top, and the total height last): the first item whose bottom is
+// below `top`, up to the first item whose top is below `bottom`.
+function offsetRowRange({ rowOffsets: offsets, rowCount, top, bottom }) {
+    const rowStart = clamp(firstIndexAbove({
+        offsets: offsets.subarray(1),
+        value: top
+    }), 0, rowCount);
+    const rowEnd = clamp(firstIndexAbove({
+        offsets: offsets.subarray(0, rowCount),
+        value: bottom
+    }), rowStart, rowCount);
+    return {
+        rowStart,
+        rowEnd
+    };
+}
+// The rendered row and centre-column ranges for a scroll position. Row overscan is measured in
+// pixels and leans in the scroll direction: one body height ahead, a quarter behind (D10.3).
+// `rowOffsets` (see useRowOffsets) replaces the fixed row height when items differ in height.
+function computeWindow({ direction, headerHeight, layout, rowCount, rowHeight, rowOffsets, scrollLeft, scrollTop, viewportHeight, viewportWidth, virtualColumns, virtualRows }) {
+    let rowStart = 0;
+    let rowEnd = rowCount;
+    if (virtualRows) {
+        const bodyHeight = Math.max(rowHeight, viewportHeight - headerHeight);
+        const lead = bodyHeight;
+        const trail = Math.round(bodyHeight / 4);
+        let before = trail;
+        let after = trail;
+        if (direction < 0) before = lead;
+        if (direction > 0) after = lead;
+        const bounds = {
+            rowCount,
+            top: scrollTop - before,
+            bottom: scrollTop + bodyHeight + after
+        };
+        ({ rowStart, rowEnd } = rowOffsets ? offsetRowRange({
+            rowOffsets,
+            ...bounds
+        }) : fixedRowRange({
+            rowHeight,
+            ...bounds
+        }));
+    }
+    let colStart = 0;
+    let colEnd = layout.center.length;
+    if (virtualColumns && colEnd > 0) {
+        const centerViewport = Math.max(0, viewportWidth - layout.startWidth - layout.endWidth);
+        colStart = firstIndexAbove({
+            offsets: layout.centerEnds,
+            value: scrollLeft - COLUMN_OVERSCAN_PX
+        });
+        colEnd = Math.max(colStart, firstIndexAbove({
+            offsets: layout.centerStarts,
+            value: scrollLeft + centerViewport + COLUMN_OVERSCAN_PX
+        }));
+    }
+    return {
+        colEnd,
+        colStart,
+        rowEnd,
+        rowStart
+    };
+}
+export default computeWindow;

package/dist/features/virtualization/createScrollToRow.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.
+*/ import { type } from '@lowdefy/helpers';
+import scrollToCell from './scrollToCell.js';
+import isDataItem from '../../core/isDataItem.js';
+// Block method `scrollToRow({ rowKey, align })`; returns false when no loaded row has that key.
+function createScrollToRow(api) {
+    return function scrollToRow({ rowKey, align } = {}) {
+        if (type.isNone(rowKey)) {
+            throw new Error('scrollToRow requires "rowKey".');
+        }
+        const id = String(rowKey);
+        const index = api.rows.findIndex((row)=>isDataItem(row) && row.id === id);
+        if (index === -1) return false;
+        scrollToCell({
+            api,
+            row: index,
+            col: -1,
+            align: align ?? 'center'
+        });
+        return true;
+    };
+}
+export default createScrollToRow;

package/dist/features/virtualization/firstIndexAbove.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.
+*/ // Binary search over ascending offsets: the first index whose offset is greater than `value`
+// (or `offsets.length`).
+function firstIndexAbove({ offsets, value }) {
+    let low = 0;
+    let high = offsets.length;
+    while(low < high){
+        const mid = low + high >>> 1;
+        if (offsets[mid] > value) {
+            high = mid;
+        } else {
+            low = mid + 1;
+        }
+    }
+    return low;
+}
+export default firstIndexAbove;

package/dist/features/virtualization/getMeasureKey.js

@@ -0,0 +1,23 @@
+/*
+  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 isDataItem from '../../core/isDataItem.js';
+// The key a display item's measured height is cached under (its element's `data-measure-key`):
+// the row id for data rows, `kind:key` for other items, null for a row that is not loaded yet.
+function getMeasureKey(item) {
+    if (item === undefined) return null;
+    if (isDataItem(item)) return item.id;
+    return `${item.kind}:${item.key}`;
+}
+export default getMeasureKey;

package/dist/features/virtualization/isMeasuredColumn.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.
+*/ // Wrapped text and multi-line ellipsis make rows as tall as their content (D10.1).
+function isMeasuredColumn(col) {
+    if (col.special) return false;
+    return col.column.wrap === true || col.column.ellipsis > 1;
+}
+export default isMeasuredColumn;

package/dist/features/virtualization/isSameRange.js

@@ -0,0 +1,18 @@
+/*
+  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 isSameRange(a, b) {
+    return a.rowStart === b.rowStart && a.rowEnd === b.rowEnd && a.colStart === b.colStart && a.colEnd === b.colEnd;
+}
+export default isSameRange;

package/dist/features/virtualization/positionedRowsFeature.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.
+*/ import usePositionedRows from './usePositionedRows.js';
+// The benchmark's comparison strategy (`rowWindowStrategy: 'positioned'`), with TanStack Virtual,
+// loaded only when a table is mounted with it; the Lowdefy client never sets it.
+const positionedRowsFeature = {
+    name: 'positionedRows',
+    useGridFeature: usePositionedRows
+};
+export default positionedRowsFeature;