@lowdefy/blocks-table 0.0.0-experimental-20260929110023

package/dist/features/sorting/sortInSlices.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 yieldToMain from './yieldToMain.js';
+const RUN = 1024;
+function merge({ source, target, start, middle, end, compare }) {
+    let left = start;
+    let right = middle;
+    for(let i = start; i < end; i++){
+        if (left < middle && (right >= end || compare(source[left], source[right]) <= 0)) {
+            target[i] = source[left];
+            left += 1;
+        } else {
+            target[i] = source[right];
+            right += 1;
+        }
+    }
+}
+// A stable bottom-up merge sort that yields to the browser whenever a slice has run for
+// `budgetMs`, so sorting 100k strings with Intl.Collator never blocks the main thread for long.
+async function sortInSlices({ items, compare, budgetMs = 12 }) {
+    const count = items.length;
+    let source = items.slice();
+    let target = new Array(count);
+    let sliceStart = performance.now();
+    async function maybeYield() {
+        if (performance.now() - sliceStart < budgetMs) return;
+        await yieldToMain();
+        sliceStart = performance.now();
+    }
+    for(let start = 0; start < count; start += RUN){
+        const end = Math.min(start + RUN, count);
+        const run = source.slice(start, end).sort(compare);
+        for(let i = 0; i < run.length; i++)source[start + i] = run[i];
+        await maybeYield();
+    }
+    for(let width = RUN; width < count; width *= 2){
+        for(let start = 0; start < count; start += 2 * width){
+            const middle = Math.min(start + width, count);
+            const end = Math.min(start + 2 * width, count);
+            merge({
+                source,
+                target,
+                start,
+                middle,
+                end,
+                compare
+            });
+            await maybeYield();
+        }
+        [source, target] = [
+            target,
+            source
+        ];
+    }
+    return source;
+}
+export default sortInSlices;

package/dist/features/sorting/sortIndices.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.
+*/ // The display order of `count` rows as a Uint32Array of row indices, sorted over precomputed
+// Float64 keys per sort entry (`[{ keys, desc }]`) instead of row objects. Ties keep source
+// order, and empty values (NaN keys) sort last whichever the direction.
+function sortIndices({ count, entries }) {
+    const order = new Uint32Array(count);
+    for(let i = 0; i < count; i++)order[i] = i;
+    const entryCount = entries.length;
+    order.sort((a, b)=>{
+        for(let e = 0; e < entryCount; e++){
+            const { keys, desc } = entries[e];
+            const left = keys[a];
+            const right = keys[b];
+            if (left !== right) {
+                const leftEmpty = Number.isNaN(left);
+                const rightEmpty = Number.isNaN(right);
+                if (leftEmpty && rightEmpty) continue;
+                if (leftEmpty) return 1;
+                if (rightEmpty) return -1;
+                return desc ? right - left : left - right;
+            }
+        }
+        return a - b;
+    });
+    return order;
+}
+export default sortIndices;

package/dist/features/sorting/sortKeysCache.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.
+*/ // Sort keys only depend on the pre-sorted rows array and the column, so toggling direction or
+// adding a second sort column reuses keys already built for this data. Keyed weakly by the rows
+// array: new data drops its keys with it.
+const sortKeysCache = new WeakMap();
+export default sortKeysCache;

package/dist/features/sorting/sortRowModel.js

@@ -0,0 +1,84 @@
+/*
+  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 getSortKeys from './getSortKeys.js';
+import sortIndices from './sortIndices.js';
+// Sort keys are built for the core rows, whatever subset is sorted: a filtered subset (every
+// row still a core row) reads its keys through the rows' core index, so a filter change never
+// rebuilds a column's keys (a text column's collator ranking is the slow part). Rows that are
+// not core rows (grouped rows) get keys of their own.
+function getSubsetKeys({ table, rows }) {
+    const coreRows = table.getCoreRowModel().rows;
+    if (rows === coreRows) return {
+        keyRows: rows,
+        positions: null
+    };
+    const positions = new Uint32Array(rows.length);
+    for(let i = 0; i < rows.length; i++){
+        const row = rows[i];
+        if (coreRows[row.index] !== row) return {
+            keyRows: rows,
+            positions: null
+        };
+        positions[i] = row.index;
+    }
+    return {
+        keyRows: coreRows,
+        positions
+    };
+}
+// Sorts row indices over precomputed keys (the shared core's sort keys, see buildSortKeys)
+// instead of sorting row objects with a comparator that reads values on every call (D10.7).
+function sortRowModel(table) {
+    const preSorted = table.getPreSortedRowModel();
+    const sorting = table.atoms.sorting?.get();
+    const rows = preSorted.rows;
+    if (!rows.length || !sorting?.length) return preSorted;
+    const { keyRows, positions } = getSubsetKeys({
+        table,
+        rows
+    });
+    const entries = [];
+    sorting.forEach((sort)=>{
+        const column = table.getColumn(sort.id);
+        if (!column || !column.getCanSort()) return;
+        const columnKeys = getSortKeys({
+            rows: keyRows,
+            column
+        });
+        let keys = columnKeys;
+        if (positions !== null) {
+            keys = new Float64Array(rows.length);
+            for(let i = 0; i < rows.length; i++)keys[i] = columnKeys[positions[i]];
+        }
+        entries.push({
+            keys,
+            desc: sort.desc === true
+        });
+    });
+    if (!entries.length) return preSorted;
+    const count = rows.length;
+    const order = sortIndices({
+        count,
+        entries
+    });
+    const sortedRows = new Array(count);
+    for(let i = 0; i < count; i++)sortedRows[i] = rows[order[i]];
+    return {
+        rows: sortedRows,
+        flatRows: sortedRows,
+        rowsById: preSorted.rowsById
+    };
+}
+export default sortRowModel;

package/dist/features/sorting/sortingFeature.js

@@ -0,0 +1,62 @@
+/*
+  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 { rowSortingFeature } from '@tanstack/react-table';
+import createClearSort from './createClearSort.js';
+import createIndexSortedRowModel from './createIndexSortedRowModel.js';
+import createSetSort from './createSetSort.js';
+import createToggleSort from './createToggleSort.js';
+import getSortHeaderProps from './getSortHeaderProps.js';
+import handleSortClick from './handleSortClick.js';
+import initSorting from './initSorting.js';
+import SortIndicator from './SortIndicator.js';
+import sortingToValue from './sortingToValue.js';
+const sortingFeature = {
+    name: 'sorting',
+    tableFeatures: {
+        rowSortingFeature,
+        sortedRowModel: createIndexSortedRowModel()
+    },
+    viewKeys: [
+        'sort'
+    ],
+    slices: {
+        // Applied in a transition: the header click paints at once and the old order stays (dimmed)
+        // until the sorted rows land.
+        sorting: {
+            init: initSorting,
+            cause: 'sort',
+            transition: true
+        }
+    },
+    tableOptions: ()=>({
+            enableMultiSort: true,
+            enableSortingRemoval: true,
+            isMultiSortEvent: (event)=>event.shiftKey === true
+        }),
+    toValue: sortingToValue,
+    actions: {
+        toggleSort: createToggleSort,
+        setSort: createSetSort,
+        clearSort: createClearSort
+    },
+    headerParts: [
+        SortIndicator
+    ],
+    headerCellProps: getSortHeaderProps,
+    gridHandlers: {
+        click: handleSortClick
+    }
+};
+export default sortingFeature;

package/dist/features/sorting/sortingToValue.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.
+*/ function sortingToValue({ state }) {
+    return {
+        view: {
+            sort: state.sorting.map((sort)=>sort.desc ? {
+                    key: sort.id,
+                    desc: true
+                } : {
+                    key: sort.id
+                })
+        }
+    };
+}
+export default sortingToValue;

package/dist/features/sorting/toFloatSortKeys.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.
+*/ // Numeric row keys as Float64 sort keys, empty (null) keys as NaN.
+function toFloatSortKeys(rowKeys) {
+    const keys = new Float64Array(rowKeys.length);
+    for(let i = 0; i < rowKeys.length; i++){
+        const key = rowKeys[i];
+        keys[i] = key === null ? NaN : key;
+    }
+    return keys;
+}
+export default toFloatSortKeys;

package/dist/features/sorting/yieldToMain.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.
+*/ // Gives the browser a turn (input, paint) between slices of long work. A MessageChannel message
+// is not clamped the way nested setTimeout(0) calls are.
+function yieldToMain() {
+    return new Promise((resolve)=>{
+        const channel = new MessageChannel();
+        channel.port1.onmessage = ()=>{
+            channel.port1.close();
+            resolve();
+        };
+        channel.port2.postMessage(null);
+    });
+}
+export default yieldToMain;

package/dist/features/toolbar/ColumnTitle.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 { renderHtml } from '@lowdefy/block-utils';
+import htmlToText from '@lowdefy/blocks-antd/table/htmlToText.js';
+import getPlainTitle from '../filtering/getPlainTitle.js';
+// Column titles may be HTML; the toolbar shows them the way the header does. An empty title shows
+// the column's key-based label (getPlainTitle).
+function ColumnTitle({ api, column }) {
+    const html = String(column.title ?? '');
+    if (htmlToText(html).trim() === '') return getPlainTitle(column);
+    return renderHtml({
+        html,
+        methods: api.methods
+    });
+}
+export default ColumnTitle;

package/dist/features/toolbar/DensityToggle.js

@@ -0,0 +1,53 @@
+/*
+  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 { Button, Segmented } from 'antd';
+const OPTIONS = [
+    {
+        label: 'Compact',
+        value: 'compact'
+    },
+    {
+        label: 'Default',
+        value: 'default'
+    },
+    {
+        label: 'Comfortable',
+        value: 'comfortable'
+    }
+];
+// Row density, and the view's Wrap toggle (text-like columns wrap onto several lines).
+function DensityToggle({ api }) {
+    const { wrap } = api.state;
+    return /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement(Segmented, {
+        "aria-label": "Row density",
+        "data-lf-toolbar-density": "",
+        onChange: (density)=>api.updateSlice('density', ()=>density, {
+                cause: 'density'
+            }),
+        options: OPTIONS,
+        size: "small",
+        value: api.state.density
+    }), /*#__PURE__*/ React.createElement(Button, {
+        "aria-pressed": wrap,
+        "data-lf-toolbar-wrap": "",
+        onClick: ()=>api.updateSlice('wrap', (current)=>!current, {
+                cause: 'wrap'
+            }),
+        size: "small",
+        type: wrap ? 'primary' : 'default'
+    }, "Wrap"));
+}
+export default DensityToggle;

package/dist/features/toolbar/FilterButton.js

@@ -0,0 +1,56 @@
+/*
+  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, { Suspense } from 'react';
+import { Button, Popover } from 'antd';
+import countConditions from './countConditions.js';
+import LazyFilterBuilder from '../filtering/LazyFilterBuilder.js';
+import ToolbarCount from './ToolbarCount.js';
+import ToolbarIcon from './ToolbarIcon.js';
+// Opens the filter builder on the whole `view.filter`; the button counts its conditions. Edits go
+// through applyFiltering, the one filter write path.
+function FilterButton({ api }) {
+    const filter = api.state.filter ?? null;
+    const columns = api.config.columns.filter((column)=>column.filterable);
+    const content = /*#__PURE__*/ React.createElement("div", {
+        className: "lf-table-toolbar-popover",
+        "data-lf-toolbar-filter": ""
+    }, /*#__PURE__*/ React.createElement(Suspense, {
+        fallback: null
+    }, /*#__PURE__*/ React.createElement(LazyFilterBuilder, {
+        columns: columns,
+        condition: filter,
+        onChange: (condition)=>api.actions.applyFiltering({
+                filter: condition ?? null
+            }),
+        user: api.config.user
+    })));
+    return /*#__PURE__*/ React.createElement(Popover, {
+        content: content,
+        placement: "bottomLeft",
+        trigger: "click"
+    }, /*#__PURE__*/ React.createElement(Button, {
+        "data-lf-toolbar-button": "filter",
+        icon: /*#__PURE__*/ React.createElement(ToolbarIcon, {
+            api: api,
+            name: "filter"
+        }),
+        onFocus: LazyFilterBuilder.preload,
+        onPointerEnter: LazyFilterBuilder.preload,
+        size: "small"
+    }, "Filter", /*#__PURE__*/ React.createElement(ToolbarCount, {
+        count: countConditions(filter)
+    })));
+}
+export default FilterButton;

package/dist/features/toolbar/GroupButton.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 React from 'react';
+import { Button, Popover } from 'antd';
+import ToolbarCount from './ToolbarCount.js';
+import ToolbarIcon from './ToolbarIcon.js';
+import ToolbarList from './ToolbarList.js';
+// Group levels over the groupable columns, outermost first (grouping's setGroupKeys).
+function GroupButton({ api, groupable }) {
+    const keys = api.state.grouping;
+    const available = groupable.filter((column)=>!keys.includes(column.key));
+    const content = /*#__PURE__*/ React.createElement("div", {
+        className: "lf-table-toolbar-popover",
+        "data-lf-toolbar-group": ""
+    }, /*#__PURE__*/ React.createElement(ToolbarList, {
+        addLabel: "Group by",
+        api: api,
+        available: available,
+        emptyText: "No grouping",
+        keys: keys,
+        name: "group",
+        onChange: (next)=>api.actions.setGroupKeys(next)
+    }));
+    return /*#__PURE__*/ React.createElement(Popover, {
+        content: content,
+        placement: "bottomLeft",
+        trigger: "click"
+    }, /*#__PURE__*/ React.createElement(Button, {
+        "data-lf-toolbar-button": "group",
+        icon: /*#__PURE__*/ React.createElement(ToolbarIcon, {
+            api: api,
+            name: "list"
+        }),
+        size: "small"
+    }, "Group", /*#__PURE__*/ React.createElement(ToolbarCount, {
+        count: keys.length
+    })));
+}
+export default GroupButton;

package/dist/features/toolbar/OptionsQuickFilter.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 { Button, Checkbox, Popover } from 'antd';
+import ColumnTitle from './ColumnTitle.js';
+import getQuickFilterValues from './getQuickFilterValues.js';
+import setQuickFilterValues from './setQuickFilterValues.js';
+import ToolbarIcon from './ToolbarIcon.js';
+import useSyncedState from '../filtering/useSyncedState.js';
+// The checkbox list of an enum column's chip. Filter writes apply in a transition after the rows
+// are tested, so the checked values are local state (useSyncedState) that the committed filter
+// replaces when it changes from elsewhere.
+function OptionsQuickFilter({ api, column }) {
+    const { options } = column;
+    const [values, setValues] = useSyncedState({
+        value: getQuickFilterValues({
+            filter: api.state.filter,
+            key: column.key
+        }),
+        onChange: (next)=>api.actions.applyFiltering({
+                filter: (filter)=>setQuickFilterValues({
+                        filter,
+                        key: column.key,
+                        values: next
+                    })
+            })
+    });
+    const checked = options.map((option, index)=>values.includes(option.value) ? index : null).filter((index)=>index !== null);
+    const content = /*#__PURE__*/ React.createElement(Checkbox.Group, {
+        className: "lf-table-quick-filter-options",
+        "data-lf-quick-filter-options": column.key,
+        onChange: (indices)=>setValues(indices.map((index)=>options[index].value)),
+        options: options.map((option, index)=>({
+                label: option.label,
+                value: index
+            })),
+        value: checked
+    });
+    return /*#__PURE__*/ React.createElement(Popover, {
+        content: content,
+        placement: "bottomLeft",
+        trigger: "click"
+    }, /*#__PURE__*/ React.createElement(Button, {
+        className: "lf-table-quick-filter",
+        color: values.length > 0 ? 'primary' : 'default',
+        "data-active": values.length > 0 ? '' : undefined,
+        "data-lf-quick-filter": column.key,
+        size: "small",
+        variant: "outlined"
+    }, /*#__PURE__*/ React.createElement(ColumnTitle, {
+        api: api,
+        column: column
+    }), values.length > 0 ? /*#__PURE__*/ React.createElement("span", {
+        className: "lf-table-toolbar-count lf-table-quick-filter-count"
+    }, values.length) : null, /*#__PURE__*/ React.createElement(ToolbarIcon, {
+        api: api,
+        name: "chevron-down"
+    })));
+}
+export default OptionsQuickFilter;

package/dist/features/toolbar/QuickFilter.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 React from 'react';
+import { Button } from 'antd';
+import ColumnTitle from './ColumnTitle.js';
+import LazyColumnFilterPopover from '../filtering/LazyColumnFilterPopover.js';
+import OptionsQuickFilter from './OptionsQuickFilter.js';
+import ToolbarIcon from './ToolbarIcon.js';
+// A quick filter chip (HubSpot-style) for one column. Enum columns (with `options`, normalised by
+// the shared core) get a checkbox list that writes one `in` leaf through applyFiltering; other
+// columns open the column's own filter.
+function QuickFilter({ api, column }) {
+    if (column.options) return /*#__PURE__*/ React.createElement(OptionsQuickFilter, {
+        api: api,
+        column: column
+    });
+    return /*#__PURE__*/ React.createElement(Button, {
+        className: "lf-table-quick-filter",
+        "data-lf-quick-filter": column.key,
+        onClick: ()=>api.actions.openColumnFilter({
+                key: column.key
+            }),
+        onFocus: LazyColumnFilterPopover.preload,
+        onPointerEnter: LazyColumnFilterPopover.preload,
+        size: "small"
+    }, /*#__PURE__*/ React.createElement(ColumnTitle, {
+        api: api,
+        column: column
+    }), /*#__PURE__*/ React.createElement(ToolbarIcon, {
+        api: api,
+        name: "chevron-down"
+    }));
+}
+export default QuickFilter;