@lowdefy/blocks-table 0.0.0-experimental-20260929110023

package/dist/features/filtering/parseColumnFilter.js

@@ -0,0 +1,128 @@
+/*
+  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 getGroupOperator from './getGroupOperator.js';
+import textFilterOperators from './textFilterOperators.js';
+function parseOptions(leaf) {
+    if (leaf.op === 'in' && type.isArray(leaf.value)) return {
+        selected: leaf.value
+    };
+    return null;
+}
+function parseText(leaf) {
+    if (!textFilterOperators.includes(leaf.op)) return null;
+    return {
+        op: leaf.op,
+        value: leaf.value
+    };
+}
+function parseNumber(leaf) {
+    if (leaf.op === 'between' && type.isArray(leaf.value)) {
+        return {
+            min: leaf.value[0] ?? null,
+            max: leaf.value[1] ?? null
+        };
+    }
+    if (leaf.op === 'gte') return {
+        min: leaf.value,
+        max: null
+    };
+    if (leaf.op === 'lte') return {
+        min: null,
+        max: leaf.value
+    };
+    return null;
+}
+function parseDate(leaf) {
+    if (leaf.op === 'between' && type.isArray(leaf.value)) {
+        return {
+            mode: 'range',
+            from: leaf.value[0] ?? null,
+            to: leaf.value[1] ?? null
+        };
+    }
+    if (leaf.op === 'within' && type.isObject(leaf.value)) {
+        return {
+            mode: 'relative',
+            relative: leaf.value
+        };
+    }
+    return null;
+}
+function parseChoice({ leaf, choices }) {
+    return choices.includes(leaf.op) ? {
+        choice: leaf.op
+    } : null;
+}
+const EMPTY_STATES = {
+    options: {
+        selected: []
+    },
+    text: {
+        op: 'contains',
+        value: undefined
+    },
+    number: {
+        min: null,
+        max: null
+    },
+    date: {
+        mode: 'range',
+        from: null,
+        to: null
+    },
+    boolean: {
+        choice: 'any'
+    },
+    presence: {
+        choice: 'any'
+    }
+};
+// The simple column filter's state from the column's conditions in `view.filter`, or null when
+// they need the advanced builder (several conditions, a group, an operator the simple editor
+// does not offer).
+function parseColumnFilter({ kind, conditions }) {
+    if (conditions.length === 0) return EMPTY_STATES[kind];
+    if (conditions.length > 1) return null;
+    const leaf = conditions[0];
+    if (getGroupOperator(leaf) !== null) return null;
+    switch(kind){
+        case 'options':
+            return parseOptions(leaf);
+        case 'text':
+            return parseText(leaf);
+        case 'number':
+            return parseNumber(leaf);
+        case 'date':
+            return parseDate(leaf);
+        case 'boolean':
+            return parseChoice({
+                leaf,
+                choices: [
+                    'isTrue',
+                    'isFalse'
+                ]
+            });
+        default:
+            return parseChoice({
+                leaf,
+                choices: [
+                    'empty',
+                    'notEmpty'
+                ]
+            });
+    }
+}
+export default parseColumnFilter;

package/dist/features/filtering/parseFilterDate.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.
+*/ import dayjs from 'dayjs';
+import { type } from '@lowdefy/helpers';
+import isEmptyValue from '@lowdefy/blocks-antd/table/isEmptyValue.js';
+// A filter date value as the dayjs object antd pickers take; null when empty or unreadable.
+function parseFilterDate(value) {
+    if (isEmptyValue(value) || type.isObject(value)) return null;
+    const date = dayjs(value);
+    return date.isValid() ? date : null;
+}
+export default parseFilterDate;

package/dist/features/filtering/prepareFilterResult.js

@@ -0,0 +1,63 @@
+/*
+  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 createRowTest from './createRowTest.js';
+import getFilterResultKey from './getFilterResultKey.js';
+import getFilterResults from './getFilterResults.js';
+import yieldToMain from '../sorting/yieldToMain.js';
+// Tests every row against a filter and search before they apply, yielding to the browser every
+// `budgetMs`, so no filter (a nested condition over 100k rows, the first search formatting every
+// searched cell) blocks input or paint. The flags are cached for the filtered row model, which
+// then only gathers the kept rows. A search that extends an earlier one under the same filter
+// (typing on) only tests the rows the earlier one kept.
+async function prepareFilterResult({ rows, condition, search, context, searchColumns }) {
+    const test = createRowTest({
+        condition,
+        search,
+        context,
+        searchColumns
+    });
+    if (test === null) return;
+    const results = getFilterResults({
+        rows,
+        context,
+        searchColumns
+    });
+    const { key, filterKey, searchKey } = getFilterResultKey({
+        condition,
+        search
+    });
+    if (results.get(key)) return;
+    const candidates = results.narrowest({
+        filterKey,
+        searchKey
+    });
+    const flags = new Uint8Array(rows.length);
+    const budgetMs = 12;
+    let sliceStart = performance.now();
+    for(let i = 0; i < rows.length; i++){
+        if (candidates !== null && candidates[i] === 0) continue;
+        if (test(rows[i].original)) flags[i] = 1;
+        if ((i & 31) === 0 && performance.now() - sliceStart >= budgetMs) {
+            await yieldToMain();
+            sliceStart = performance.now();
+        }
+    }
+    results.set(key, {
+        filterKey,
+        searchKey,
+        flags
+    });
+}
+export default prepareFilterResult;

package/dist/features/filtering/pruneCondition.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 getGroupOperator from './getGroupOperator.js';
+import isCompleteLeaf from './isCompleteLeaf.js';
+// The part of a view filter that constrains rows: incomplete leaves and the groups they leave
+// empty are dropped, so a filter that is being built shows every row until it says something.
+// Malformed groups pass through unchanged, for compileCondition to report.
+function pruneCondition(condition) {
+    if (!type.isObject(condition)) return null;
+    const operator = getGroupOperator(condition);
+    if (operator === null) {
+        return isCompleteLeaf(condition) ? condition : null;
+    }
+    const list = condition[operator];
+    if (!type.isArray(list)) return condition;
+    const children = list.map(pruneCondition).filter((child)=>child !== null);
+    if (children.length === 0) return null;
+    return {
+        [operator]: children
+    };
+}
+export default pruneCondition;

package/dist/features/filtering/setColumnFilter.js

@@ -0,0 +1,51 @@
+/*
+  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 getTopLevelConditions from './getTopLevelConditions.js';
+import isColumnCondition from './isColumnCondition.js';
+// Replaces one column's conditions in a view filter. The filter is a top-level `and`: the
+// column's existing conditions are removed and `condition` (a leaf or a group; the items of an
+// `and` group are spread) takes the place of the first of them, so editing a column filter keeps
+// its position. Conditions that mix columns are kept. No conditions left means no filter (null).
+function setColumnFilter({ filter, key, condition }) {
+    const existing = getTopLevelConditions(filter);
+    let added = [];
+    if (type.isObject(condition)) {
+        added = type.isArray(condition.and) ? condition.and : [
+            condition
+        ];
+    }
+    const items = [];
+    let inserted = false;
+    existing.forEach((item)=>{
+        if (!isColumnCondition({
+            condition: item,
+            key
+        })) {
+            items.push(item);
+            return;
+        }
+        if (!inserted) {
+            items.push(...added);
+            inserted = true;
+        }
+    });
+    if (!inserted) items.push(...added);
+    if (items.length === 0) return null;
+    return {
+        and: items
+    };
+}
+export default setColumnFilter;

package/dist/features/filtering/textFilterOperators.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.
+*/ // The operators the simple text filter offers, in menu order.
+const textFilterOperators = [
+    'contains',
+    'notContains',
+    'startsWith',
+    'endsWith',
+    'eq',
+    'ne',
+    'empty',
+    'notEmpty'
+];
+export default textFilterOperators;

package/dist/features/filtering/toRootGroup.js

@@ -0,0 +1,34 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { type } from '@lowdefy/helpers';
+import getGroupOperator from './getGroupOperator.js';
+// The filter builder always edits a group: no filter is an empty `and`, a single leaf is an
+// `and` of that leaf.
+function toRootGroup(condition) {
+    if (!type.isObject(condition)) return {
+        and: []
+    };
+    const operator = getGroupOperator(condition);
+    if (operator === null) return {
+        and: [
+            condition
+        ]
+    };
+    if (!type.isArray(condition[operator])) return {
+        and: []
+    };
+    return condition;
+}
+export default toRootGroup;

package/dist/features/filtering/useDraft.js

@@ -0,0 +1,65 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { useCallback, useEffect, useRef, useState } from 'react';
+function same(a, b) {
+    return JSON.stringify(a ?? null) === JSON.stringify(b ?? null);
+}
+// A typed value that applies after a pause (or at once on flush: Enter, blur, unmount), so a
+// 100k-row filter is not re-run and committed on every keystroke. A new value from outside
+// (SetState, another editor) replaces the draft.
+function useDraft({ value, onChange, delay = 300 }) {
+    const [draft, setDraftState] = useState(value);
+    const sent = useRef(value);
+    const pending = useRef({
+        draft: value,
+        onChange,
+        timer: null
+    });
+    pending.current.onChange = onChange;
+    useEffect(()=>{
+        if (same(value, sent.current)) return;
+        sent.current = value;
+        pending.current.draft = value;
+        setDraftState(value);
+    }, [
+        value
+    ]);
+    const flush = useCallback(()=>{
+        const current = pending.current;
+        clearTimeout(current.timer);
+        current.timer = null;
+        if (same(current.draft, sent.current)) return;
+        sent.current = current.draft;
+        current.onChange(current.draft);
+    }, []);
+    const setDraft = useCallback((next)=>{
+        pending.current.draft = next;
+        setDraftState(next);
+        clearTimeout(pending.current.timer);
+        pending.current.timer = setTimeout(flush, delay);
+    }, [
+        delay,
+        flush
+    ]);
+    useEffect(()=>flush, [
+        flush
+    ]);
+    return {
+        draft,
+        setDraft,
+        flush
+    };
+}
+export default useDraft;

package/dist/features/filtering/useFilteringState.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 { useState } from 'react';
+// Block-level UI state of the filtering feature: which column's filter popover is open, and the
+// latest requested filter and search while they are prepared and applied (applyFiltering). The
+// request is dropped once the committed state has caught up with it.
+function useFilteringState({ api, state }) {
+    const [openKey, setOpenKey] = useState(null);
+    api.columnFilter = {
+        openKey,
+        setOpenKey
+    };
+    const target = api.filtering?.target ?? null;
+    const caughtUp = target !== null && target.filter === state.filter && target.search === state.search;
+    api.filtering = {
+        target: caughtUp ? null : target
+    };
+    return null;
+}
+export default useFilteringState;

package/dist/features/filtering/useSyncedState.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 { useRef, useState } from 'react';
+function same(a, b) {
+    return JSON.stringify(a ?? null) === JSON.stringify(b ?? null);
+}
+// Local state for an editor whose value round-trips through the table. Filter writes apply in a
+// transition, so the committed value can lag several edits behind; an editor that re-read it
+// after each edit would build the next edit on a stale condition. The editor keeps its own state
+// and writes through `onChange`; a value that arrives from outside (SetState, another editor)
+// replaces it.
+function useSyncedState({ value, onChange }) {
+    const [local, setLocal] = useState(value);
+    const sent = useRef(value);
+    const [seen, setSeen] = useState(value);
+    if (!same(seen, value)) {
+        setSeen(value);
+        if (!same(value, sent.current)) {
+            sent.current = value;
+            setLocal(value);
+        }
+    }
+    function update(next) {
+        sent.current = next;
+        setLocal(next);
+        onChange(next);
+    }
+    return [
+        local,
+        update
+    ];
+}
+export default useSyncedState;

package/dist/features/grouping/GroupCell.js

@@ -0,0 +1,72 @@
+/*
+  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 AGGREGATE_LABELS from '@lowdefy/blocks-antd/table/aggregateLabels.js';
+import getAggregateText from '@lowdefy/blocks-antd/table/getAggregateText.js';
+import GroupCheckbox from './GroupCheckbox.js';
+function renderContent({ api, col, item, selectionCount }) {
+    if (col.special === 'select') {
+        if (!selectionCount) return null;
+        return /*#__PURE__*/ React.createElement(GroupCheckbox, {
+            selected: selectionCount.selected,
+            total: selectionCount.total
+        });
+    }
+    if (col.special) return null;
+    const fn = api.grouping.aggregateFns.get(col.key);
+    if (!fn) return null;
+    const text = getAggregateText({
+        fn,
+        value: item.aggregates[col.key],
+        column: col.column
+    });
+    return /*#__PURE__*/ React.createElement("span", {
+        className: "lf-table-group-aggregate",
+        "data-aggregate": fn
+    }, /*#__PURE__*/ React.createElement("span", {
+        className: "lf-table-group-aggregate-fn"
+    }, AGGREGATE_LABELS[fn]), /*#__PURE__*/ React.createElement("span", {
+        className: "lf-table-group-aggregate-value"
+    }, text));
+}
+// One cell of a group header row, on the same layout column as the data cells below it, so the
+// group's aggregates line up under their columns and keyboard navigation crosses group rows like
+// any other. In the sticky overlay (a copy of a real row) the cells are not focus targets.
+function GroupCell({ api, col, focused, item, overlay, selectionCount }) {
+    const selectCell = col.special === 'select' && Boolean(selectionCount);
+    let tabIndex;
+    if (!overlay) tabIndex = focused ? 0 : -1;
+    return /*#__PURE__*/ React.createElement("div", {
+        "aria-colindex": overlay ? undefined : col.ariaIndex,
+        className: col.special ? 'lf-table-gridcell lf-table-select' : 'lf-table-gridcell',
+        "data-align": col.column?.align,
+        "data-col-index": col.index,
+        "data-col-key": col.key,
+        "data-focused": focused ? '' : undefined,
+        "data-lf-cell": overlay ? undefined : '',
+        "data-lf-group-select": selectCell ? '' : undefined,
+        "data-pinned": col.region === 'center' ? undefined : col.region,
+        "data-pinned-edge": col.pinnedEdge ? '' : undefined,
+        role: overlay ? undefined : 'gridcell',
+        style: col.style,
+        tabIndex: tabIndex
+    }, renderContent({
+        api,
+        col,
+        item,
+        selectionCount
+    }));
+}
+export default GroupCell;

package/dist/features/grouping/GroupCheckbox.js

@@ -0,0 +1,38 @@
+/*
+  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';
+function ignoreChange() {}
+// The group's checkbox: checked when every leaf row is selected, indeterminate when some are.
+// The delegated click handler does the toggling.
+function GroupCheckbox({ selected, total }) {
+    const ref = useRef(null);
+    const checked = total > 0 && selected === total;
+    const indeterminate = selected > 0 && !checked;
+    useEffect(()=>{
+        if (ref.current) ref.current.indeterminate = indeterminate;
+    }, [
+        indeterminate
+    ]);
+    return /*#__PURE__*/ React.createElement("input", {
+        "aria-label": "Select group rows",
+        checked: checked,
+        className: "lf-table-checkbox",
+        onChange: ignoreChange,
+        ref: ref,
+        tabIndex: -1,
+        type: "checkbox"
+    });
+}
+export default GroupCheckbox;