@lowdefy/blocks-table 0.0.0-experimental-20260929110023

package/dist/features/filtering/ValueEditor.js

@@ -0,0 +1,210 @@
+/*
+  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 { DatePicker, Select, Space, Tag } from 'antd';
+import { get, type } from '@lowdefy/helpers';
+import CELL_TYPE_FAMILIES from '@lowdefy/blocks-antd/table/cellTypeFamilies.js';
+import DraftInput from './DraftInput.js';
+import DraftInputNumber from './DraftInputNumber.js';
+import formatFilterDate from './formatFilterDate.js';
+import getValueShape from './getValueShape.js';
+import parseFilterDate from './parseFilterDate.js';
+import RelativeDateEditor from './RelativeDateEditor.js';
+const BOOLEAN_OPTIONS = [
+    {
+        value: true,
+        label: 'true'
+    },
+    {
+        value: false,
+        label: 'false'
+    }
+];
+function UserValue({ path, user, onClear }) {
+    const resolved = get(user, path);
+    const title = type.isNone(resolved) ? path : `${path}: ${resolved}`;
+    return /*#__PURE__*/ React.createElement(Tag, {
+        closable: true,
+        onClose: onClear,
+        title: title
+    }, "Current user");
+}
+function RangeNumbers({ value, onChange, size }) {
+    const [from, to] = type.isArray(value) ? value : [
+        null,
+        null
+    ];
+    return /*#__PURE__*/ React.createElement(Space.Compact, {
+        size: size
+    }, /*#__PURE__*/ React.createElement(DraftInputNumber, {
+        "aria-label": "From",
+        onChange: (next)=>onChange([
+                next ?? null,
+                to ?? null
+            ]),
+        placeholder: "From",
+        value: from
+    }), /*#__PURE__*/ React.createElement(DraftInputNumber, {
+        "aria-label": "To",
+        onChange: (next)=>onChange([
+                from ?? null,
+                next ?? null
+            ]),
+        placeholder: "To",
+        value: to
+    }));
+}
+function RangeDates({ column, value, onChange, size }) {
+    const [from, to] = type.isArray(value) ? value : [
+        null,
+        null
+    ];
+    return /*#__PURE__*/ React.createElement(DatePicker.RangePicker, {
+        allowEmpty: [
+            true,
+            true
+        ],
+        onChange: (dates)=>onChange([
+                formatFilterDate({
+                    column,
+                    date: dates?.[0],
+                    edge: 'start'
+                }),
+                formatFilterDate({
+                    column,
+                    date: dates?.[1],
+                    edge: 'end'
+                })
+            ]),
+        size: size,
+        value: [
+            parseFilterDate(from),
+            parseFilterDate(to)
+        ]
+    });
+}
+// The value input for one condition, by the operator's value shape and the column's type family.
+function ValueEditor({ column, op, value, onChange, user, size = 'small' }) {
+    const shape = getValueShape(op);
+    if (shape === 'none') return null;
+    if (type.isObject(value) && type.isString(value.$user)) {
+        return /*#__PURE__*/ React.createElement(UserValue, {
+            onClear: ()=>onChange(undefined),
+            path: value.$user,
+            user: user
+        });
+    }
+    const family = CELL_TYPE_FAMILIES[column.type];
+    // Columns come normalised by the shared core: options are [{ value, label, ... }].
+    const { options } = column;
+    const selectOptions = options?.map((option)=>({
+            value: option.value,
+            label: option.label
+        }));
+    if (shape === 'relative') {
+        return /*#__PURE__*/ React.createElement(RelativeDateEditor, {
+            onChange: onChange,
+            size: size,
+            value: value
+        });
+    }
+    if (shape === 'range') {
+        if (family === 'date') {
+            return /*#__PURE__*/ React.createElement(RangeDates, {
+                column: column,
+                onChange: onChange,
+                size: size,
+                value: value
+            });
+        }
+        return /*#__PURE__*/ React.createElement(RangeNumbers, {
+            onChange: onChange,
+            size: size,
+            value: value
+        });
+    }
+    if (shape === 'list') {
+        return /*#__PURE__*/ React.createElement(Select, {
+            "aria-label": "Values",
+            className: "lf-filter-value",
+            mode: selectOptions ? 'multiple' : 'tags',
+            onChange: (next)=>onChange(next.length ? next : undefined),
+            optionFilterProp: "label",
+            options: selectOptions,
+            placeholder: "Values",
+            size: size,
+            tokenSeparators: selectOptions ? undefined : [
+                ','
+            ],
+            value: type.isArray(value) ? value : []
+        });
+    }
+    if (selectOptions && (op === 'eq' || op === 'ne')) {
+        return /*#__PURE__*/ React.createElement(Select, {
+            "aria-label": "Value",
+            className: "lf-filter-value",
+            onChange: onChange,
+            optionFilterProp: "label",
+            options: selectOptions,
+            placeholder: "Value",
+            showSearch: true,
+            size: size,
+            value: value
+        });
+    }
+    if (family === 'boolean') {
+        return /*#__PURE__*/ React.createElement(Select, {
+            "aria-label": "Value",
+            className: "lf-filter-value",
+            onChange: onChange,
+            options: BOOLEAN_OPTIONS,
+            placeholder: "Value",
+            size: size,
+            value: value
+        });
+    }
+    if (family === 'number') {
+        return /*#__PURE__*/ React.createElement(DraftInputNumber, {
+            "aria-label": "Value",
+            className: "lf-filter-value",
+            onChange: onChange,
+            placeholder: "Value",
+            size: size,
+            value: value
+        });
+    }
+    if (family === 'date') {
+        return /*#__PURE__*/ React.createElement(DatePicker, {
+            "aria-label": "Value",
+            className: "lf-filter-value",
+            onChange: (date)=>onChange(formatFilterDate({
+                    column,
+                    date,
+                    edge: op === 'after' ? 'end' : 'start'
+                }) ?? undefined),
+            size: size,
+            value: parseFilterDate(value)
+        });
+    }
+    return /*#__PURE__*/ React.createElement(DraftInput, {
+        "aria-label": "Value",
+        className: "lf-filter-value",
+        onChange: onChange,
+        placeholder: "Value",
+        size: size,
+        value: value
+    });
+}
+export default ValueEditor;

package/dist/features/filtering/buildColumnFilter.js

@@ -0,0 +1,95 @@
+/*
+  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 isEmptyValue from '@lowdefy/blocks-antd/table/isEmptyValue.js';
+function buildNumber({ key, min, max }) {
+    const hasMin = !isEmptyValue(min);
+    const hasMax = !isEmptyValue(max);
+    if (hasMin && hasMax) return {
+        key,
+        op: 'between',
+        value: [
+            min,
+            max
+        ]
+    };
+    if (hasMin) return {
+        key,
+        op: 'gte',
+        value: min
+    };
+    if (hasMax) return {
+        key,
+        op: 'lte',
+        value: max
+    };
+    return null;
+}
+function buildDate({ key, state }) {
+    if (state.mode === 'relative') return {
+        key,
+        op: 'within',
+        value: state.relative
+    };
+    if (isEmptyValue(state.from) && isEmptyValue(state.to)) return null;
+    // An open end stays null: `between` treats a missing bound as unbounded.
+    return {
+        key,
+        op: 'between',
+        value: [
+            state.from ?? null,
+            state.to ?? null
+        ]
+    };
+}
+// The condition the simple column filter writes for its state, or null for "no filter".
+function buildColumnFilter({ kind, key, state }) {
+    switch(kind){
+        case 'options':
+            return state.selected.length ? {
+                key,
+                op: 'in',
+                value: state.selected
+            } : null;
+        case 'text':
+            if (state.op === 'empty' || state.op === 'notEmpty') return {
+                key,
+                op: state.op
+            };
+            return isEmptyValue(state.value) ? null : {
+                key,
+                op: state.op,
+                value: state.value
+            };
+        case 'number':
+            return buildNumber({
+                key,
+                min: state.min,
+                max: state.max
+            });
+        case 'date':
+            return buildDate({
+                key,
+                state
+            });
+        default:
+            if (!type.isString(state.choice) || state.choice === 'any') return null;
+            return {
+                key,
+                op: state.choice
+            };
+    }
+}
+export default buildColumnFilter;

package/dist/features/filtering/changeLeafOperator.js

@@ -0,0 +1,46 @@
+/*
+  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 defaultRelativeDate from './defaultRelativeDate.js';
+import getValueShape from './getValueShape.js';
+// A new operator keeps the value when it has the same shape, turns a scalar into a one-item list
+// (and back), and otherwise starts empty.
+function changeLeafOperator({ leaf, op }) {
+    const from = getValueShape(leaf.op);
+    const to = getValueShape(op);
+    const next = {
+        key: leaf.key,
+        op
+    };
+    if (to === 'none') return next;
+    if (to === 'relative') {
+        next.value = from === 'relative' ? leaf.value : defaultRelativeDate;
+        return next;
+    }
+    if (from === to) {
+        if (!type.isUndefined(leaf.value)) next.value = leaf.value;
+        return next;
+    }
+    if (from === 'scalar' && to === 'list' && !type.isNone(leaf.value) && leaf.value !== '') {
+        next.value = [
+            leaf.value
+        ];
+    }
+    if (from === 'list' && to === 'scalar' && type.isArray(leaf.value) && leaf.value.length > 0) {
+        next.value = leaf.value[0];
+    }
+    return next;
+}
+export default changeLeafOperator;

package/dist/features/filtering/createApplyFiltering.js

@@ -0,0 +1,78 @@
+/*
+  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 getSearchColumns from './getSearchColumns.js';
+import isServerMode from './isServerMode.js';
+import prepareFilterResult from './prepareFilterResult.js';
+import pruneCondition from './pruneCondition.js';
+function resolveFilter({ filter, current }) {
+    if (filter === undefined) return current;
+    if (typeof filter === 'function') return filter(current);
+    return filter;
+}
+// Action `applyFiltering({ filter, search })`, the one write path for `view.filter` and
+// `view.search` from inside the table (methods, column filters, the toolbar). `filter` is a
+// condition, null, or an updater of the current condition; `search` is text or null; either may
+// be left out. The rows are tested first in time slices (prepareFilterResult, the table marked
+// pending), then the state applies in a transition and the row model reads the prepared result.
+// Edits build on the latest requested filter rather than the committed one, which lags while a
+// transition is pending, and only the latest call applies when calls overlap.
+function createApplyFiltering(api) {
+    let latest = 0;
+    return function applyFiltering({ filter, search }) {
+        const current = api.filtering.target ?? {
+            filter: api.state.filter,
+            search: api.state.search
+        };
+        const next = {
+            filter: resolveFilter({
+                filter,
+                current: current.filter
+            }),
+            search: search === undefined ? current.search : search
+        };
+        api.filtering.target = next;
+        latest += 1;
+        const call = latest;
+        function apply() {
+            const filterChanged = next.filter !== api.state.filter;
+            const searchChanged = next.search !== api.state.search;
+            if (filterChanged) api.updateSlice('filter', ()=>next.filter);
+            if (searchChanged) api.updateSlice('search', ()=>next.search);
+            // Nothing to commit means nothing will catch up with the request: drop it now.
+            if (!filterChanged && !searchChanged) api.filtering.target = null;
+        }
+        if (isServerMode(api.config)) {
+            apply();
+            return;
+        }
+        const root = api.rootRef.current;
+        root?.setAttribute('data-pending', '');
+        prepareFilterResult({
+            rows: api.table.getPreFilteredRowModel().rows,
+            condition: pruneCondition(next.filter),
+            search: next.search,
+            context: api.table.options.lowdefyFiltering,
+            searchColumns: getSearchColumns({
+                columns: api.config.columns,
+                columnVisibility: api.state.columnVisibility
+            })
+        }).then(()=>{
+            if (call !== latest) return;
+            root?.removeAttribute('data-pending');
+            apply();
+        });
+    };
+}
+export default createApplyFiltering;

package/dist/features/filtering/createClearFilters.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.
+*/ // Block method `clearFilters()`: removes every filter condition. The search stays; clear it with
+// `setSearch(null)`.
+function createClearFilters(api) {
+    return function clearFilters() {
+        api.actions.applyFiltering({
+            filter: null
+        });
+    };
+}
+export default createClearFilters;

package/dist/features/filtering/createCloseColumnFilter.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.
+*/ import focusHeaderControl from '../headerMenu/focusHeaderControl.js';
+// Action `closeColumnFilter({ restoreFocus })`: closes the popover; after Escape, focus returns to
+// the column's menu button (or its header cell) so keyboard users stay where they were.
+function createCloseColumnFilter(api) {
+    return function closeColumnFilter({ restoreFocus } = {}) {
+        const key = api.columnFilter.openKey;
+        api.columnFilter.setOpenKey(null);
+        if (restoreFocus && key !== null) focusHeaderControl({
+            api,
+            key
+        });
+    };
+}
+export default createCloseColumnFilter;

package/dist/features/filtering/createConditionFilteredRowModel.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 { tableMemo } from '@tanstack/react-table';
+import filterRowModel from './filterRowModel.js';
+// TanStack's `filteredRowModel` slot, the first stage after the core rows (filter, then sort).
+// It recomputes only when the rows, the filter or the search change (and, while searching, the
+// visible columns), so an unchanged filter never re-runs.
+function createConditionFilteredRowModel() {
+    return function getFilteredRowModel(table) {
+        return tableMemo({
+            feature: 'columnFilteringFeature',
+            table,
+            fnName: 'table.getFilteredRowModel',
+            memoDeps: ()=>{
+                const { filter, search } = table.options.state;
+                return [
+                    table.getPreFilteredRowModel(),
+                    filter,
+                    search,
+                    search ? table.atoms.columnVisibility.get() : null,
+                    table.options.lowdefyFiltering
+                ];
+            },
+            fn: ()=>filterRowModel(table)
+        });
+    };
+}
+export default createConditionFilteredRowModel;

package/dist/features/filtering/createDefaultLeaf.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 { type } from '@lowdefy/helpers';
+import getOperators from '@lowdefy/blocks-antd/table/getOperators.js';
+import defaultRelativeDate from './defaultRelativeDate.js';
+// A new filter condition for a column: `in` for columns with options (pick values), otherwise the
+// type's first operator. It has no value yet, so it filters nothing until one is chosen.
+function createDefaultLeaf({ column }) {
+    const operators = getOperators(column.type);
+    let op = operators[0];
+    if (!type.isNone(column.options) && operators.includes('in')) op = 'in';
+    const leaf = {
+        key: column.key,
+        op
+    };
+    if (op === 'within') leaf.value = defaultRelativeDate;
+    return leaf;
+}
+export default createDefaultLeaf;

package/dist/features/filtering/createOpenColumnFilter.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.
+*/ // Action `openColumnFilter({ key })`: opens the filter popover under a column's header. The
+// popover state lives in the filtering feature's hook (useFilteringState).
+function createOpenColumnFilter(api) {
+    return function openColumnFilter({ key }) {
+        const column = api.config.columns.find((entry)=>entry.key === key);
+        if (!column.filterable) return false;
+        api.columnFilter.setOpenKey(key);
+        return true;
+    };
+}
+export default createOpenColumnFilter;

package/dist/features/filtering/createRowTest.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.
+*/ import compileCondition from '@lowdefy/blocks-antd/table/compileCondition.js';
+import createSearchMatcher from './createSearchMatcher.js';
+// The filter and the search as one row test, or null when neither constrains anything.
+function createRowTest({ condition, search, context, searchColumns }) {
+    const matchesSearch = createSearchMatcher({
+        search,
+        columns: searchColumns
+    });
+    const matchesFilter = condition === null ? null : compileCondition({
+        condition,
+        columnsByKey: context.columnsByKey,
+        user: context.user
+    });
+    if (matchesFilter === null) return matchesSearch;
+    if (matchesSearch === null) return matchesFilter;
+    return (row)=>matchesFilter(row) && matchesSearch(row);
+}
+export default createRowTest;

package/dist/features/filtering/createSearchMatcher.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 getSearchText from './getSearchText.js';
+// `view.search` as a row test: case-insensitive, every word must appear in the display text of
+// one of the searched columns (the same rule MongoDBTableQuery applies in server mode). Null when
+// there is nothing to search for.
+function createSearchMatcher({ search, columns }) {
+    if (!type.isString(search) || columns.length === 0) return null;
+    const words = search.trim().toLowerCase().split(/\s+/).filter(Boolean);
+    if (words.length === 0) return null;
+    return function matchesSearch(row) {
+        const text = getSearchText({
+            columns,
+            row
+        });
+        for(let i = 0; i < words.length; i++){
+            if (!text.includes(words[i])) return false;
+        }
+        return true;
+    };
+}
+export default createSearchMatcher;

package/dist/features/filtering/createSetFilter.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';
+// Block method `setFilter(condition)`: replaces `view.filter` (a Condition, or null to clear).
+function createSetFilter(api) {
+    return function setFilter(condition) {
+        if (!type.isNone(condition) && !type.isObject(condition)) {
+            throw new Error(`Table setFilter requires a condition object or null. Received ${JSON.stringify(condition)}.`);
+        }
+        api.actions.applyFiltering({
+            filter: condition ?? null
+        });
+    };
+}
+export default createSetFilter;