@lowdefy/blocks-table 0.0.0-experimental-20260929110023

package/dist/features/pinning/pinningFeature.js

@@ -0,0 +1,33 @@
+/*
+  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 { columnPinningFeature } from '@tanstack/react-table';
+import initColumnPinning from './initColumnPinning.js';
+import pinningToViewColumn from './pinningToViewColumn.js';
+// Pinned columns render outside the column virtual range as position: sticky cells (D10.3); the
+// layout reads the start/end regions from TanStack's pinning state.
+const pinningFeature = {
+    name: 'pinning',
+    tableFeatures: {
+        columnPinningFeature
+    },
+    slices: {
+        columnPinning: {
+            init: initColumnPinning,
+            cause: 'columns'
+        }
+    },
+    toViewColumn: pinningToViewColumn
+};
+export default pinningFeature;

package/dist/features/pinning/pinningToViewColumn.js

@@ -0,0 +1,24 @@
+/*
+  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 pinningToViewColumn({ key, state }) {
+    if (state.columnPinning.start.includes(key)) return {
+        pinned: 'start'
+    };
+    if (state.columnPinning.end.includes(key)) return {
+        pinned: 'end'
+    };
+    return {};
+}
+export default pinningToViewColumn;

package/dist/features/queue/createAfterRowAction.js

@@ -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.
+*/ import findNextRowId from './findNextRowId.js';
+import isDataItem from '../../core/isDataItem.js';
+// Action `afterRowAction({ id, result })`, called when a row button, menu item or single-key
+// action fires. With `keyboard.next`, focus moves to the next row once the event's actions
+// finish (triage: act, and the next item is ready). The next row is picked before the actions
+// run: an action that removes the row from the list still lands on the row that followed it.
+function createAfterRowAction(api) {
+    return function afterRowAction({ id, result }) {
+        if (!api.config.keyboardNext) return;
+        const nextId = findNextRowId({
+            rows: api.rows,
+            id
+        });
+        const { col } = api.keyboard.activeCell;
+        Promise.resolve(result).then((outcome)=>{
+            if (outcome?.success === false) return;
+            const index = api.rows.findIndex((row)=>isDataItem(row) && row.id === nextId);
+            if (index === -1) return;
+            api.keyboard.moveTo({
+                row: index,
+                col
+            });
+        });
+    };
+}
+export default createAfterRowAction;

package/dist/features/queue/findNextRowId.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 isDataItem from '../../core/isDataItem.js';
+// The id of the data row after this one in the display list (group headers, detail rows and rows
+// not loaded yet skipped), or null.
+function findNextRowId({ rows, id }) {
+    const index = rows.findIndex((row)=>isDataItem(row) && row.id === id);
+    if (index === -1) return null;
+    for(let i = index + 1; i < rows.length; i++){
+        if (isDataItem(rows[i])) return rows[i].id;
+    }
+    return null;
+}
+export default findNextRowId;

package/dist/features/queue/findRowAction.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 { get, type } from '@lowdefy/helpers';
+import resolveControlField from '@lowdefy/blocks-antd/table/resolveControlField.js';
+import resolveControlFlag from '@lowdefy/blocks-antd/table/resolveControlFlag.js';
+const CONTROL_LISTS = {
+    buttons: 'buttons',
+    menu: 'items'
+};
+// The row button or menu item bound to a key (`key: 'a'`), resolved for one row: the first one
+// in column order that is shown and enabled for that row, with the event payload its click would
+// fire (D5).
+function findRowAction({ columns, key, row, rowKey }) {
+    for (const column of columns){
+        const listName = CONTROL_LISTS[column.type];
+        if (!listName) continue;
+        const controls = column.cell[listName];
+        if (!type.isArray(controls)) continue;
+        const value = get(row, column.field);
+        for(let index = 0; index < controls.length; index++){
+            const control = controls[index];
+            if (!type.isObject(control) || control.key !== key || !type.isString(control.eventName)) {
+                continue;
+            }
+            // `{ when }` flags are compiled with the columns (compileColumns); literal and `*Field`
+            // flags resolve without it.
+            const compiled = column.compiled?.[listName]?.[index] ?? {};
+            const flag = (name)=>resolveControlFlag({
+                    control,
+                    name,
+                    compiled: compiled[name],
+                    row,
+                    value
+                });
+            if (flag('hidden') === true || flag('disabled') === true) continue;
+            const described = {
+                eventName: control.eventName,
+                title: resolveControlField({
+                    control,
+                    name: 'title',
+                    row
+                })
+            };
+            const event = listName === 'buttons' ? {
+                row,
+                rowKey,
+                value,
+                button: described,
+                buttonIndex: index
+            } : {
+                row,
+                rowKey,
+                value,
+                item: described,
+                itemIndex: index
+            };
+            return {
+                name: control.eventName,
+                event
+            };
+        }
+    }
+    return null;
+}
+export default findRowAction;

package/dist/features/queue/handleRowActionKey.js

@@ -0,0 +1,44 @@
+/*
+  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 findRowAction from './findRowAction.js';
+// Single-key row actions (Linear-style): a button or menu item with `key: 'a'` fires when `a` is
+// pressed on its focused row. Only a bare key on the cell itself counts: a key typed into an
+// editor or control inside the cell belongs to it, and modified keys are shortcuts.
+function handleRowActionKey(event, api) {
+    if (event.metaKey || event.ctrlKey || event.altKey || event.key.length !== 1) return false;
+    const cell = event.target.closest('[data-lf-cell]');
+    if (!cell || cell !== event.target || !api.contains(cell)) return false;
+    const rowElement = cell.closest('[data-row-key]');
+    if (!rowElement) return false;
+    const id = rowElement.dataset.rowKey;
+    const tableRow = api.table.getCoreRowModel().rowsById[id];
+    if (!tableRow) return false;
+    const visible = api.config.columns.filter((column)=>api.state.columnVisibility[column.key] !== false);
+    const action = findRowAction({
+        columns: visible,
+        key: event.key,
+        row: tableRow.original,
+        rowKey: api.config.getKey(tableRow.original)
+    });
+    if (action === null) return false;
+    event.preventDefault();
+    const result = api.methods.triggerEvent(action);
+    api.actions.afterRowAction({
+        id,
+        result
+    });
+    return true;
+}
+export default handleRowActionKey;

package/dist/features/queue/queueFeature.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 createAfterRowAction from './createAfterRowAction.js';
+import handleRowActionKey from './handleRowActionKey.js';
+// Queue and triage behaviour (archetype G): single-key row actions and `keyboard.next`.
+const queueFeature = {
+    name: 'queue',
+    actions: {
+        afterRowAction: createAfterRowAction
+    },
+    gridHandlers: {
+        keydown: handleRowActionKey
+    }
+};
+export default queueFeature;

package/dist/features/selection/SelectAllHeader.js

@@ -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.
+*/ import React, { useEffect, useRef } from 'react';
+import getSelectAllState from './getSelectAllState.js';
+function ignoreChange() {}
+function SelectAllHeader({ api }) {
+    const ref = useRef(null);
+    const { checked, indeterminate } = getSelectAllState({
+        api
+    });
+    useEffect(()=>{
+        if (ref.current) ref.current.indeterminate = indeterminate;
+    }, [
+        indeterminate
+    ]);
+    if (api.config.rowSelection.type === 'radio') return null;
+    return /*#__PURE__*/ React.createElement("input", {
+        "aria-label": "Select all rows",
+        checked: checked,
+        className: "lf-table-checkbox",
+        "data-lf-select-all": "",
+        onChange: ignoreChange,
+        ref: ref,
+        tabIndex: -1,
+        type: "checkbox"
+    });
+}
+export default SelectAllHeader;

package/dist/features/selection/SelectCell.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.
+*/ import React from 'react';
+function ignoreChange() {}
+// A native input styled with antd tokens: an antd Checkbox per row would mount a CSS-in-JS hook
+// per visible row (tier-0 rule, D4/D10.4). The delegated click handler does the toggling.
+function SelectCell({ api, selected }) {
+    const inputType = api.config.rowSelection.type === 'radio' ? 'radio' : 'checkbox';
+    return /*#__PURE__*/ React.createElement("input", {
+        "aria-label": "Select row",
+        checked: selected,
+        className: "lf-table-checkbox",
+        onChange: ignoreChange,
+        tabIndex: -1,
+        type: inputType
+    });
+}
+export default SelectCell;

package/dist/features/selection/countSelectedRows.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.
+*/ // Counts against the filtered rows, the set the header checkbox selects (TanStack's select-all
+// toggles the pre-grouped rows, which come after filtering), so "all selected" means all the rows
+// the filter shows. In server mode filtering is manual, so these are the loaded rows; an
+// `{ all: true, except }` selection is told apart by `selectionMode` (getSelectAllState).
+function countSelectedRows({ api }) {
+    const { rows, rowsById } = api.table.getFilteredRowModel();
+    const selection = api.state.rowSelection;
+    let selectedCount = 0;
+    Object.keys(selection).forEach((id)=>{
+        if (selection[id] === true && rowsById[id]) selectedCount += 1;
+    });
+    return {
+        selectedCount,
+        total: rows.length
+    };
+}
+export default countSelectedRows;

package/dist/features/selection/createClearSelection.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.
+*/ function createClearSelection(api) {
+    return function clearSelection() {
+        api.selectionExcept.clear();
+        api.updateSlice('selectionMode', ()=>'keys', {
+            cause: 'select'
+        });
+        api.updateSlice('selectionView', ()=>null, {
+            cause: 'select'
+        });
+        api.updateSlice('rowSelection', ()=>({}), {
+            cause: 'select'
+        });
+    };
+}
+export default createClearSelection;

package/dist/features/selection/createToggleAllRowsSelected.js

@@ -0,0 +1,60 @@
+/*
+  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 countSelectedRows from './countSelectedRows.js';
+import getSelectAllState from './getSelectAllState.js';
+// The header checkbox selects every row the filter shows (or clears them when all are selected),
+// as their keys. In server mode most rows are not loaded, so it selects all rows the view matches
+// as `{ all: true, except: [], filter, search }`, which the server resolves. Client mode writes
+// that shape through the bulk bar's "Select all matching" (selectAllMatching) or from outside.
+function createToggleAllRowsSelected(api) {
+    return function toggleAllRowsSelected() {
+        if (api.config.rowSelection?.type === 'radio') return false;
+        if (api.config.server) {
+            const { checked } = getSelectAllState({
+                api
+            });
+            api.selectionExcept.clear();
+            const selection = {};
+            if (!checked) {
+                Object.keys(api.table.getCoreRowModel().rowsById).forEach((id)=>{
+                    selection[id] = true;
+                });
+            }
+            api.updateSlice('selectionMode', ()=>checked ? 'keys' : 'all', {
+                cause: 'select'
+            });
+            api.updateSlice('selectionView', ()=>checked ? null : {
+                    filter: api.state.filter,
+                    search: api.state.search
+                }, {
+                cause: 'select'
+            });
+            api.updateSlice('rowSelection', ()=>selection, {
+                cause: 'select'
+            });
+            return true;
+        }
+        const { selectedCount, total } = countSelectedRows({
+            api
+        });
+        const selectAll = total > 0 && selectedCount < total;
+        api.updateSlice('selectionMode', ()=>'keys', {
+            cause: 'select'
+        });
+        api.table.toggleAllRowsSelected(selectAll);
+        return true;
+    };
+}
+export default createToggleAllRowsSelected;

package/dist/features/selection/createToggleRowSelected.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 getRawRowKey from './getRawRowKey.js';
+// In an `{ all: true, except }` selection, a row cleared by the user joins `except` and a row
+// selected again leaves it. The exceptions are recorded here, where the user acts, rather than
+// inferred from unselected loaded rows: a row that has just loaded is not selected yet either.
+function recordExceptions({ api, ids, selected }) {
+    if (api.state.selectionMode !== 'all') return;
+    ids.forEach((rowId)=>{
+        if (selected) {
+            api.selectionExcept.set(rowId, getRawRowKey({
+                id: rowId,
+                api
+            }));
+        } else {
+            api.selectionExcept.delete(rowId);
+        }
+    });
+}
+// TanStack's row toggle never clears other rows, so radio (single) selection replaces the record.
+// With `rowSelection.cascade` in a tree, a row's descendants follow it.
+function createToggleRowSelected(api) {
+    return function toggleRowSelected({ id }) {
+        if (!api.config.rowSelection) return false;
+        const row = api.table.getRow(id, true);
+        if (!row) return false;
+        const selected = api.state.rowSelection[id] === true;
+        if (api.config.rowSelection.type === 'radio') {
+            api.updateSlice('rowSelection', ()=>selected ? {} : {
+                    [id]: true
+                }, {
+                cause: 'select'
+            });
+            return true;
+        }
+        if (api.config.rowSelection.cascade && api.tree) {
+            const ids = [
+                id,
+                ...api.tree.getDescendantIds(id)
+            ];
+            recordExceptions({
+                api,
+                ids,
+                selected
+            });
+            api.updateSlice('rowSelection', (previous)=>{
+                const next = {
+                    ...previous
+                };
+                ids.forEach((rowId)=>{
+                    if (selected) {
+                        delete next[rowId];
+                    } else {
+                        next[rowId] = true;
+                    }
+                });
+                return next;
+            }, {
+                cause: 'select'
+            });
+            return true;
+        }
+        recordExceptions({
+            api,
+            ids: [
+                id
+            ],
+            selected
+        });
+        row.toggleSelected();
+        return true;
+    };
+}
+export default createToggleRowSelected;

package/dist/features/selection/getRawRowKey.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.
+*/ // Row ids in TanStack state are strings; the value keeps the row key's own type (a numeric `id`
+// stays a number). Keys of rows that are not loaded (`preserve`) fall back to the key the value
+// supplied.
+function getRawRowKey({ id, api }) {
+    const row = api.table.getCoreRowModel().rowsById[id];
+    if (row) return api.config.getKey(row.original);
+    return api.foreignKeys.get(id) ?? id;
+}
+export default getRawRowKey;

package/dist/features/selection/getSelectAllExcept.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.
+*/ // The `except` keys of an `{ all: true, except }` selection: the rows the user cleared since
+// selecting all (recorded by toggleRowSelected), including rows that are not loaded now (server
+// mode evicts and reloads blocks), plus exceptions the value set from outside.
+function getSelectAllExcept({ api }) {
+    return [
+        ...api.selectionExcept.values()
+    ];
+}
+export default getSelectAllExcept;

package/dist/features/selection/getSelectAllState.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 countSelectedRows from './countSelectedRows.js';
+// The header checkbox state. In client mode it reflects the loaded rows. In server mode it is
+// checked only for an `{ all: true }` selection with no exceptions: selecting every loaded row
+// is not selecting every row.
+function getSelectAllState({ api }) {
+    const { selectedCount, total } = countSelectedRows({
+        api
+    });
+    if (!api.config.server) {
+        const checked = total > 0 && selectedCount === total;
+        return {
+            checked,
+            indeterminate: selectedCount > 0 && !checked
+        };
+    }
+    if (api.state.selectionMode !== 'all') {
+        return {
+            checked: false,
+            indeterminate: selectedCount > 0
+        };
+    }
+    const checked = api.selectionExcept.size === 0;
+    return {
+        checked,
+        indeterminate: !checked
+    };
+}
+export default getSelectAllState;