@lowdefy/blocks-table 0.0.0-experimental-20260929110023

package/dist/features/selection/handleSelectionClick.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.
+*/ function handleSelectionClick(event, api) {
+    if (!api.config.rowSelection) return false;
+    const all = event.target.closest('[data-lf-select-all]');
+    if (all && api.contains(all)) {
+        api.actions.toggleAllRowsSelected();
+        return true;
+    }
+    const cell = event.target.closest('[data-lf-select-cell]');
+    if (!cell || !api.contains(cell)) return false;
+    const rowEl = cell.closest('[data-row-key]');
+    api.actions.toggleRowSelected({
+        id: rowEl.dataset.rowKey
+    });
+    return true;
+}
+export default handleSelectionClick;

package/dist/features/selection/initRowSelection.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 isSelectAllValue from './isSelectAllValue.js';
+// Accepts both value shapes: `rowKey[]`, and `{ all: true, except: rowKey[] }` (every loaded row
+// except those keys; the shape server mode needs, where not every row is loaded).
+function initRowSelection({ value, rows, getKey }) {
+    const selected = value?.selected;
+    const selection = {};
+    if (isSelectAllValue(selected)) {
+        const except = new Set((selected.except ?? []).map(String));
+        rows.forEach((row)=>{
+            const id = String(getKey(row));
+            if (!except.has(id)) selection[id] = true;
+        });
+        return selection;
+    }
+    if (!type.isArray(selected)) return selection;
+    selected.forEach((key)=>{
+        if (!type.isNone(key)) selection[String(key)] = true;
+    });
+    return selection;
+}
+export default initRowSelection;

package/dist/features/selection/initSelectionMode.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 isSelectAllValue from './isSelectAllValue.js';
+function initSelectionMode({ value }) {
+    return isSelectAllValue(value?.selected) ? 'all' : 'keys';
+}
+export default initSelectionMode;

package/dist/features/selection/initSelectionView.js

@@ -0,0 +1,35 @@
+/*
+  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 initFilter from '../filtering/initFilter.js';
+import initSearch from '../filtering/initSearch.js';
+import isSelectAllValue from './isSelectAllValue.js';
+// The filter and search an `{ all: true }` selection matches: the value's own (written with the
+// selection), else the view's (an `{ all: true, except }` set from outside without them).
+function initSelectionView({ value, defaultView }) {
+    const selected = value?.selected;
+    if (!isSelectAllValue(selected)) return null;
+    return {
+        filter: type.isUndefined(selected.filter) ? initFilter({
+            value,
+            defaultView
+        }) : selected.filter,
+        search: type.isUndefined(selected.search) ? initSearch({
+            value,
+            defaultView
+        }) : selected.search
+    };
+}
+export default initSelectionView;

package/dist/features/selection/isSelectAllValue.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 { type } from '@lowdefy/helpers';
+function isSelectAllValue(selected) {
+    return type.isObject(selected) && selected.all === true;
+}
+export default isSelectAllValue;

package/dist/features/selection/isSelectionViewCurrent.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.
+*/ // Whether the view's filter and search are still the ones an `{ all: true }` selection was made
+// with. Conditions are plain data; config markers (`~k`) are not enumerable.
+function isSelectionViewCurrent({ state }) {
+    const { selectionView } = state;
+    if (selectionView === null) return true;
+    return JSON.stringify(selectionView.filter ?? null) === JSON.stringify(state.filter ?? null) && (selectionView.search ?? null) === (state.search ?? null);
+}
+export default isSelectionViewCurrent;

package/dist/features/selection/notifySelectionChange.js

@@ -0,0 +1,32 @@
+/*
+  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.
+*/ // onSelectionChange carries the selection and, in client mode, the selected row objects.
+function notifySelectionChange({ cause, value, api }) {
+    if (cause !== 'select') return;
+    const rowsById = api.table.getCoreRowModel().rowsById;
+    const selection = api.state.rowSelection;
+    const rows = [];
+    Object.keys(selection).forEach((id)=>{
+        if (selection[id] === true && rowsById[id]) rows.push(rowsById[id].original);
+    });
+    api.methods.triggerEvent({
+        name: 'onSelectionChange',
+        event: {
+            selected: value.selected,
+            rows
+        }
+    });
+}
+export default notifySelectionChange;

package/dist/features/selection/pruneRowSelection.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.
+*/ // Without `preserve`, keys of rows that are no longer in `data` are dropped on the next selection
+// change (antd's behaviour without preserveSelectedRowKeys), not the moment data changes.
+function pruneRowSelection({ next, api }) {
+    if (api.config.rowSelection?.preserve === true) return next;
+    const rowsById = api.table.getCoreRowModel().rowsById;
+    const pruned = {};
+    Object.keys(next).forEach((id)=>{
+        if (next[id] === true && rowsById[id]) pruned[id] = true;
+    });
+    return pruned;
+}
+export default pruneRowSelection;

package/dist/features/selection/selectionFeature.js

@@ -0,0 +1,69 @@
+/*
+  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 { rowSelectionFeature } from '@tanstack/react-table';
+import createClearSelection from './createClearSelection.js';
+import createToggleAllRowsSelected from './createToggleAllRowsSelected.js';
+import createToggleRowSelected from './createToggleRowSelected.js';
+import handleSelectionClick from './handleSelectionClick.js';
+import initRowSelection from './initRowSelection.js';
+import initSelectionMode from './initSelectionMode.js';
+import initSelectionView from './initSelectionView.js';
+import notifySelectionChange from './notifySelectionChange.js';
+import pruneRowSelection from './pruneRowSelection.js';
+import selectionToValue from './selectionToValue.js';
+import useSelection from './useSelection.js';
+// `rowSelection` is TanStack's selection record (row id -> true); `selectionMode` is Lowdefy's
+// own slice ('keys' | 'all') that decides which value shape the selection is written back in;
+// `selectionView` is the filter and search an 'all' selection matches (null otherwise).
+const selectionFeature = {
+    name: 'selection',
+    tableFeatures: {
+        rowSelectionFeature
+    },
+    slices: {
+        rowSelection: {
+            init: initRowSelection,
+            cause: 'select',
+            normalize: pruneRowSelection
+        },
+        selectionMode: {
+            init: initSelectionMode,
+            cause: 'select'
+        },
+        selectionView: {
+            init: initSelectionView,
+            cause: 'select'
+        }
+    },
+    tableOptions: ({ config })=>({
+            enableRowSelection: Boolean(config.rowSelection),
+            enableMultiRowSelection: config.rowSelection?.type !== 'radio'
+        }),
+    toValue: selectionToValue,
+    onCommit: notifySelectionChange,
+    actions: {
+        clearSelection: createClearSelection,
+        toggleRowSelected: createToggleRowSelected,
+        toggleAllRowsSelected: createToggleAllRowsSelected
+    },
+    methods: {
+        clearSelection: createClearSelection
+    },
+    gridHandlers: {
+        click: handleSelectionClick
+    },
+    useFeature: useSelection
+};
+export default selectionFeature;

package/dist/features/selection/selectionToValue.js

@@ -0,0 +1,48 @@
+/*
+  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 getRawRowKey from './getRawRowKey.js';
+import getSelectAllExcept from './getSelectAllExcept.js';
+function selectionToValue({ state, api }) {
+    const selection = state.rowSelection;
+    const rowsById = api.table.getCoreRowModel().rowsById;
+    // An all selection describes itself, so it can be resolved on the server from the value alone:
+    // every row the filter and search match, except `except`.
+    if (state.selectionMode === 'all') {
+        return {
+            selected: {
+                all: true,
+                except: getSelectAllExcept({
+                    api
+                }),
+                filter: state.selectionView?.filter ?? null,
+                search: state.selectionView?.search ?? null
+            }
+        };
+    }
+    const preserve = api.config.rowSelection?.preserve === true;
+    const selected = [];
+    Object.keys(selection).forEach((id)=>{
+        if (selection[id] !== true) return;
+        if (!preserve && !rowsById[id]) return;
+        selected.push(getRawRowKey({
+            id,
+            api
+        }));
+    });
+    return {
+        selected
+    };
+}
+export default selectionToValue;

package/dist/features/selection/useSelection.js

@@ -0,0 +1,77 @@
+/*
+  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 } from 'react';
+import isSelectionViewCurrent from './isSelectionViewCurrent.js';
+import SelectAllHeader from './SelectAllHeader.js';
+import SelectCell from './SelectCell.js';
+const SELECT_COLUMN_WIDTH = 40;
+// While the selection is `{ all: true, except }`, rows that appear in later data and match the
+// view are selected too: "all matching" means every row the filter and search match, not the rows
+// that happened to be loaded. Client-side that is the filtered rows; in server mode the server
+// matches, so every loaded row counts. Rows in `except` stay out when their block is loaded again
+// (server mode).
+function useSelection(ctx) {
+    const { api, data, state } = ctx;
+    const enabled = Boolean(ctx.config.rowSelection);
+    const previousRowsById = useRef(null);
+    useEffect(()=>{
+        const rowsById = api.table.getCoreRowModel().rowsById;
+        const previous = previousRowsById.current;
+        previousRowsById.current = rowsById;
+        if (!previous || state.selectionMode !== 'all') return;
+        const matching = api.config.server ? rowsById : api.table.getFilteredRowModel().rowsById;
+        const added = Object.keys(rowsById).filter((id)=>!previous[id] && matching[id] && !api.selectionExcept.has(id));
+        if (!added.length) return;
+        api.setSliceSilently('rowSelection', (selection)=>{
+            const next = {
+                ...selection
+            };
+            added.forEach((id)=>{
+                next[id] = true;
+            });
+            return next;
+        });
+    }, [
+        data
+    ]);
+    // An all selection belongs to the filter and search it was made with: the rows another filter
+    // matches are a different set, so changing either (from the table or the value) clears it.
+    useEffect(()=>{
+        if (state.selectionMode !== 'all' || isSelectionViewCurrent({
+            state
+        })) return;
+        api.actions.clearSelection();
+    }, [
+        state.filter,
+        state.search,
+        state.selectionMode,
+        state.selectionView
+    ]);
+    const leadingColumns = useMemo(()=>enabled ? [
+            {
+                key: '__select',
+                special: 'select',
+                width: SELECT_COLUMN_WIDTH,
+                Header: SelectAllHeader,
+                Cell: SelectCell
+            }
+        ] : [], [
+        enabled
+    ]);
+    return {
+        leadingColumns
+    };
+}
+export default useSelection;

package/dist/features/serverData/buildServerItems.js

@@ -0,0 +1,109 @@
+/*
+  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 getListKey from './getListKey.js';
+import toGroupIdentity from '../grouping/toGroupIdentity.js';
+function getGroupItem({ entry, groupPath, depth, columnKey, collapsed, cache }) {
+    const cached = cache.get(entry);
+    if (cached?.collapsed === collapsed && cached.depth === depth) return cached;
+    const path = [
+        ...groupPath,
+        entry.key
+    ];
+    const item = {
+        kind: 'group',
+        key: getListKey(path),
+        depth,
+        columnKey,
+        value: entry.key,
+        empty: toGroupIdentity(entry.key) === null,
+        count: entry.count,
+        aggregates: entry.aggregates ?? {},
+        collapsed,
+        groupPath: path
+    };
+    cache.set(entry, item);
+    return item;
+}
+// The display list of a server view: the root list's rows, or its groups with each expanded
+// group followed by its own list (groups of the next level, or leaf rows), depth first. Rows not
+// loaded yet are `undefined` holes (skeleton rows); a child list whose size is not known yet
+// shows one. Group items have the client grouping's shape (flattenGroups: `kind: 'group'`, key,
+// depth, columnKey, value, empty, count, aggregates, collapsed) and render with its group row,
+// plus `groupPath`, the group values that name the group's own list; they have no leaf range
+// (`start`, `end`), since the rows are on the server. Server groups start collapsed. `segments`
+// records which list rows each run of items shows, which is how a visible range maps to the
+// blocks to load.
+function buildServerItems({ blockCache, groupKeys, expandedGroups, rowsById, getId, itemCache }) {
+    const { blockSize } = blockCache;
+    const items = [];
+    const segments = [];
+    function emitList(groupPath) {
+        const depth = groupPath.length;
+        const listKey = getListKey(groupPath);
+        const total = blockCache.getTotal(listKey);
+        let count = total;
+        if (count === null) count = depth === 0 || blockCache.getError(listKey) ? 0 : 1;
+        const isGroupLevel = depth < groupKeys.length;
+        let segment = null;
+        for(let blockStart = 0; blockStart < count; blockStart += blockSize){
+            const block = blockCache.getBlock(listKey, blockStart / blockSize);
+            const blockRows = block?.rows;
+            const blockEnd = Math.min(count, blockStart + blockSize);
+            for(let i = blockStart; i < blockEnd; i++){
+                if (segment === null) {
+                    segment = {
+                        itemStart: items.length,
+                        length: 0,
+                        listKey,
+                        groupPath,
+                        listStart: i
+                    };
+                    segments.push(segment);
+                }
+                segment.length += 1;
+                const entry = blockRows?.[i - blockStart];
+                if (entry === undefined) {
+                    items.push(undefined);
+                } else if (!isGroupLevel) {
+                    items.push(rowsById[getId(entry)]);
+                } else {
+                    const collapsed = !expandedGroups.has(getListKey([
+                        ...groupPath,
+                        entry.key
+                    ]));
+                    const item = getGroupItem({
+                        entry,
+                        groupPath,
+                        depth,
+                        columnKey: groupKeys[depth],
+                        collapsed,
+                        cache: itemCache
+                    });
+                    items.push(item);
+                    if (!collapsed) {
+                        segment = null;
+                        emitList(item.groupPath);
+                    }
+                }
+            }
+        }
+    }
+    emitList([]);
+    return {
+        items,
+        segments
+    };
+}
+export default buildServerItems;