@lowdefy/blocks-table 0.0.0-experimental-20260929110023

package/dist/features/sorting/buildSortKeys.js

@@ -0,0 +1,52 @@
+/*
+  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 compareSortKeys from '@lowdefy/blocks-antd/table/compareSortKeys.js';
+import collectSortKeys from './collectSortKeys.js';
+import isNumericSortType from './isNumericSortType.js';
+import rankSortKeys from './rankSortKeys.js';
+import toFloatSortKeys from './toFloatSortKeys.js';
+function readNumericKeys({ rows, accessor, getSortKey }) {
+    const keys = new Float64Array(rows.length);
+    for(let i = 0; i < rows.length; i++){
+        const key = getSortKey(accessor(rows[i].original));
+        keys[i] = key === null ? NaN : key;
+    }
+    return keys;
+}
+// Precomputes one Float64 sort key per row, so the sort itself only compares numbers (D10.7).
+// The keys come from the shared column core's `createSortKeyGetter` and text ranks from its
+// `compareSortKeys`, so the index sort orders rows exactly as `createComparator({ column, desc })`
+// does, empty values last in both directions (NaN keys). This is the synchronous path;
+// prepareSortKeys builds the same keys in time slices ahead of a header click.
+function buildSortKeys({ rows, accessor, getSortKey, columnType }) {
+    if (isNumericSortType(columnType)) {
+        return readNumericKeys({
+            rows,
+            accessor,
+            getSortKey
+        });
+    }
+    const { rowKeys, distinct, numeric } = collectSortKeys({
+        rows,
+        accessor,
+        getSortKey
+    });
+    if (numeric) return toFloatSortKeys(rowKeys);
+    return rankSortKeys({
+        rowKeys,
+        ordered: distinct.sort(compareSortKeys)
+    });
+}
+export default buildSortKeys;

package/dist/features/sorting/collectSortKeys.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 createSortKeyCollector from './createSortKeyCollector.js';
+// Every row's sort key and the distinct keys, in one pass (see createSortKeyCollector).
+function collectSortKeys({ rows, accessor, getSortKey }) {
+    const collector = createSortKeyCollector({
+        count: rows.length,
+        getSortKey
+    });
+    collector.collect({
+        rows,
+        accessor,
+        start: 0,
+        end: rows.length
+    });
+    return collector.result();
+}
+export default collectSortKeys;

package/dist/features/sorting/createClearSort.js

@@ -0,0 +1,21 @@
+/*
+  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 `clearSort({ key })`: removes one column from the sort.
+function createClearSort(api) {
+    return function clearSort({ key }) {
+        api.updateSlice('sorting', (sorting)=>sorting.filter((entry)=>entry.id !== key));
+    };
+}
+export default createClearSort;

package/dist/features/sorting/createIndexSortedRowModel.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 { tableMemo } from '@tanstack/react-table';
+import sortRowModel from './sortRowModel.js';
+// Drop-in replacement for TanStack's createSortedRowModel(): same slot, same memo inputs, a typed
+// index sort underneath. Nested sub-rows are not sorted yet; tree data arrives with its module.
+function createIndexSortedRowModel() {
+    return function getSortedRowModel(table) {
+        return tableMemo({
+            feature: 'rowSortingFeature',
+            table,
+            fnName: 'table.getSortedRowModel',
+            memoDeps: ()=>[
+                    table.atoms.sorting?.get(),
+                    table.getPreSortedRowModel()
+                ],
+            fn: ()=>sortRowModel(table)
+        });
+    };
+}
+export default createIndexSortedRowModel;

package/dist/features/sorting/createSetSort.js

@@ -0,0 +1,43 @@
+/*
+  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 prepareSortKeys from './prepareSortKeys.js';
+// Action `setSort({ key, desc })`: sorts by one column in the given direction (the header menu's
+// Sort ascending / descending), replacing any multi-sort. Keys are prepared first, as for a
+// header click.
+function createSetSort(api) {
+    return function setSort({ key, desc }) {
+        const column = api.table.getColumn(key);
+        if (!column || !column.getCanSort()) return false;
+        const apply = ()=>api.updateSlice('sorting', ()=>[
+                    {
+                        id: key,
+                        desc: desc === true
+                    }
+                ]);
+        // Keys are built for the core rows (sortRowModel reads filtered subsets through them).
+        const rows = api.table.getCoreRowModel().rows;
+        const root = api.rootRef.current;
+        root?.setAttribute('data-pending', '');
+        prepareSortKeys({
+            rows,
+            column
+        }).then(()=>{
+            root?.removeAttribute('data-pending');
+            apply();
+        });
+        return true;
+    };
+}
+export default createSetSort;

package/dist/features/sorting/createSortKeyCollector.js

@@ -0,0 +1,59 @@
+/*
+  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';
+// Collects each row's sort key from the shared column core's key getter (null for an empty
+// value) and the distinct non-null keys, a range of rows at a time, so a large column can be read
+// in time slices. The getter runs once per distinct primitive value, so low-cardinality columns
+// (statuses, dates, owners) cost one key per value, not per row. `numeric` is true when every key
+// is a number (numbers, dates, booleans, enums whose values all have options): those keys order
+// the rows as they are, without ranking.
+function createSortKeyCollector({ count, getSortKey }) {
+    const rowKeys = new Array(count);
+    const byValue = new Map();
+    const distinct = new Set();
+    let numeric = true;
+    function collect({ rows, accessor, start, end }) {
+        for(let i = start; i < end; i++){
+            const value = accessor(rows[i].original);
+            let key;
+            if (type.isPrimitive(value)) {
+                key = byValue.get(value);
+                if (key === undefined) {
+                    key = getSortKey(value);
+                    byValue.set(value, key);
+                }
+            } else {
+                key = getSortKey(value);
+            }
+            rowKeys[i] = key;
+            if (key !== null) {
+                distinct.add(key);
+                if (numeric && !type.isNumber(key)) numeric = false;
+            }
+        }
+    }
+    function result() {
+        return {
+            rowKeys,
+            distinct: Array.from(distinct),
+            numeric
+        };
+    }
+    return {
+        collect,
+        result
+    };
+}
+export default createSortKeyCollector;

package/dist/features/sorting/createToggleSort.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 prepareSortKeys from './prepareSortKeys.js';
+// Header sort. When the next order needs keys this data does not have yet, they are prepared
+// first (in slices for big text columns) with the table marked pending, then the sort applies in a
+// transition. Removing a sort needs no keys and applies at once.
+function createToggleSort(api) {
+    return function toggleSort({ key, multi }) {
+        const column = api.table.getColumn(key);
+        if (!column || !column.getCanSort()) return false;
+        const apply = ()=>column.toggleSorting(undefined, multi === true);
+        if (column.getNextSortingOrder() === false) {
+            apply();
+            return true;
+        }
+        // Keys are built for the core rows (sortRowModel reads filtered subsets through them).
+        const rows = api.table.getCoreRowModel().rows;
+        const root = api.rootRef.current;
+        root?.setAttribute('data-pending', '');
+        prepareSortKeys({
+            rows,
+            column
+        }).then(()=>{
+            root?.removeAttribute('data-pending');
+            apply();
+        });
+        return true;
+    };
+}
+export default createToggleSort;

package/dist/features/sorting/getCachedSortKeys.js

@@ -0,0 +1,19 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import sortKeysCache from './sortKeysCache.js';
+function getCachedSortKeys({ rows, columnId }) {
+    return sortKeysCache.get(rows)?.get(columnId);
+}
+export default getCachedSortKeys;

package/dist/features/sorting/getSortHeaderProps.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.
+*/ function getSortHeaderProps({ col, state }) {
+    if (!col.column?.sortable) return {};
+    const sort = state.sorting.find((entry)=>entry.id === col.key);
+    let ariaSort = 'none';
+    if (sort) ariaSort = sort.desc ? 'descending' : 'ascending';
+    return {
+        'aria-sort': ariaSort,
+        'data-sortable': ''
+    };
+}
+export default getSortHeaderProps;

package/dist/features/sorting/getSortKeys.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 buildSortKeys from './buildSortKeys.js';
+import getCachedSortKeys from './getCachedSortKeys.js';
+import setCachedSortKeys from './setCachedSortKeys.js';
+function getSortKeys({ rows, column }) {
+    const cached = getCachedSortKeys({
+        rows,
+        columnId: column.id
+    });
+    if (cached) return cached;
+    const { accessor, getSortKey, column: definition } = column.columnDef.meta;
+    const keys = buildSortKeys({
+        rows,
+        accessor,
+        getSortKey,
+        columnType: definition.type
+    });
+    setCachedSortKeys({
+        rows,
+        columnId: column.id,
+        keys
+    });
+    return keys;
+}
+export default getSortKeys;

package/dist/features/sorting/handleSortClick.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.
+*/ // Header click sorts; Shift+click adds the column to a multi-sort. The cycle is ascending,
+// descending, then off (antd's default sort directions).
+function handleSortClick(event, api) {
+    const cell = event.target.closest('[data-lf-header]');
+    if (!cell || !api.contains(cell) || cell.dataset.special) return false;
+    if (event.target.closest('[data-lf-resize]')) return true;
+    if (api.takeSuppressedClick()) return true;
+    return api.actions.toggleSort({
+        key: cell.dataset.colKey,
+        multi: event.shiftKey
+    });
+}
+export default handleSortClick;

package/dist/features/sorting/initSorting.js

@@ -0,0 +1,37 @@
+/*
+  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 pickViewPart from '../../core/pickViewPart.js';
+function initSorting({ value, defaultView, config }) {
+    const sort = pickViewPart({
+        value,
+        defaultView,
+        key: 'sort'
+    });
+    if (!type.isArray(sort)) return [];
+    const seen = new Set();
+    const sorting = [];
+    sort.forEach((entry)=>{
+        const column = config.columnsByKey.get(entry?.key);
+        if (!column || !column.sortable || seen.has(entry.key)) return;
+        seen.add(entry.key);
+        sorting.push({
+            id: entry.key,
+            desc: entry.desc === true
+        });
+    });
+    return sorting;
+}
+export default initSorting;

package/dist/features/sorting/isNumericSortType.js

@@ -0,0 +1,21 @@
+/*
+  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 CELL_TYPE_FAMILIES from '@lowdefy/blocks-antd/table/cellTypeFamilies.js';
+// Number-family columns (number, currency, percent, progress, rating) are usually all distinct,
+// so their keys are read per row without the distinct-value pass.
+function isNumericSortType(columnType) {
+    return CELL_TYPE_FAMILIES[columnType ?? 'text'] === 'number';
+}
+export default isNumericSortType;

package/dist/features/sorting/prepareSortKeys.js

@@ -0,0 +1,92 @@
+/*
+  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 compareSortKeys from '@lowdefy/blocks-antd/table/compareSortKeys.js';
+import createSortKeyCollector from './createSortKeyCollector.js';
+import getCachedSortKeys from './getCachedSortKeys.js';
+import getSortKeys from './getSortKeys.js';
+import isNumericSortType from './isNumericSortType.js';
+import rankSortKeys from './rankSortKeys.js';
+import setCachedSortKeys from './setCachedSortKeys.js';
+import sortInSlices from './sortInSlices.js';
+import toFloatSortKeys from './toFloatSortKeys.js';
+import yieldToMain from './yieldToMain.js';
+// Below this many rows (or distinct text keys) the synchronous build is fast enough to run at once.
+const SLICED_THRESHOLD = 5000;
+const CHUNK_ROWS = 5000;
+const BUDGET_MS = 12;
+async function collectInSlices({ rows, accessor, getSortKey }) {
+    const collector = createSortKeyCollector({
+        count: rows.length,
+        getSortKey
+    });
+    // The header click paints (the table dims) before the first slice runs.
+    await yieldToMain();
+    let sliceStart = performance.now();
+    for(let start = 0; start < rows.length; start += CHUNK_ROWS){
+        collector.collect({
+            rows,
+            accessor,
+            start,
+            end: Math.min(rows.length, start + CHUNK_ROWS)
+        });
+        if (performance.now() - sliceStart >= BUDGET_MS) {
+            await yieldToMain();
+            sliceStart = performance.now();
+        }
+    }
+    return collector.result();
+}
+// Builds a column's sort keys before its sort is applied, in time slices for large non-numeric
+// columns (reading 100k values and the collator sort of their distinct strings are the steps that
+// can exceed the D10 blocking budget). Resolves once the keys are cached for `rows`; they equal
+// buildSortKeys' keys.
+async function prepareSortKeys({ rows, column }) {
+    if (getCachedSortKeys({
+        rows,
+        columnId: column.id
+    })) return;
+    const { accessor, getSortKey, column: definition } = column.columnDef.meta;
+    if (isNumericSortType(definition.type) || rows.length < SLICED_THRESHOLD) {
+        getSortKeys({
+            rows,
+            column
+        });
+        return;
+    }
+    const { rowKeys, distinct, numeric } = await collectInSlices({
+        rows,
+        accessor,
+        getSortKey
+    });
+    let keys;
+    if (numeric) {
+        keys = toFloatSortKeys(rowKeys);
+    } else {
+        const ordered = distinct.length < SLICED_THRESHOLD ? distinct.sort(compareSortKeys) : await sortInSlices({
+            items: distinct,
+            compare: compareSortKeys
+        });
+        keys = rankSortKeys({
+            rowKeys,
+            ordered
+        });
+    }
+    setCachedSortKeys({
+        rows,
+        columnId: column.id,
+        keys
+    });
+}
+export default prepareSortKeys;

package/dist/features/sorting/rankSortKeys.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 compareSortKeys from '@lowdefy/blocks-antd/table/compareSortKeys.js';
+// Float64 sort keys from row keys and the distinct keys in ascending order (sorted with
+// compareSortKeys). Keys the shared comparator calls equal (text that differs only in case or
+// accents) share a rank; empty (null) keys are NaN.
+function rankSortKeys({ rowKeys, ordered }) {
+    const ranks = new Map();
+    let rank = 0;
+    for(let i = 0; i < ordered.length; i++){
+        if (i > 0 && compareSortKeys(ordered[i - 1], ordered[i]) !== 0) rank += 1;
+        ranks.set(ordered[i], rank);
+    }
+    const keys = new Float64Array(rowKeys.length);
+    for(let i = 0; i < rowKeys.length; i++){
+        const key = rowKeys[i];
+        keys[i] = key === null ? NaN : ranks.get(key);
+    }
+    return keys;
+}
+export default rankSortKeys;

package/dist/features/sorting/setCachedSortKeys.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 sortKeysCache from './sortKeysCache.js';
+function setCachedSortKeys({ rows, columnId, keys }) {
+    let byColumn = sortKeysCache.get(rows);
+    if (!byColumn) {
+        byColumn = new Map();
+        sortKeysCache.set(rows, byColumn);
+    }
+    byColumn.set(columnId, keys);
+}
+export default setCachedSortKeys;