@lowdefy/blocks-table 0.0.0-experimental-20260929110023

package/dist/features/editing/RowControlsCell.js

@@ -0,0 +1,89 @@
+/*
+  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, { useSyncExternalStore } from 'react';
+function GripIcon() {
+    return /*#__PURE__*/ React.createElement("svg", {
+        "aria-hidden": "true",
+        fill: "currentColor",
+        height: "14",
+        viewBox: "0 0 10 16",
+        width: "9"
+    }, /*#__PURE__*/ React.createElement("circle", {
+        cx: "2.5",
+        cy: "3",
+        r: "1.5"
+    }), /*#__PURE__*/ React.createElement("circle", {
+        cx: "7.5",
+        cy: "3",
+        r: "1.5"
+    }), /*#__PURE__*/ React.createElement("circle", {
+        cx: "2.5",
+        cy: "8",
+        r: "1.5"
+    }), /*#__PURE__*/ React.createElement("circle", {
+        cx: "7.5",
+        cy: "8",
+        r: "1.5"
+    }), /*#__PURE__*/ React.createElement("circle", {
+        cx: "2.5",
+        cy: "13",
+        r: "1.5"
+    }), /*#__PURE__*/ React.createElement("circle", {
+        cx: "7.5",
+        cy: "13",
+        r: "1.5"
+    }));
+}
+function DeleteIcon() {
+    return /*#__PURE__*/ React.createElement("svg", {
+        "aria-hidden": "true",
+        fill: "none",
+        height: "14",
+        stroke: "currentColor",
+        strokeLinecap: "round",
+        strokeWidth: "2",
+        viewBox: "0 0 24 24",
+        width: "14"
+    }, /*#__PURE__*/ React.createElement("path", {
+        d: "M18 6 6 18M6 6l12 12"
+    }));
+}
+// The leading row controls: the drag handle (`rowDrag`, Table and TableInput) and TableInput's
+// delete button (`rowActions.delete`). Plain DOM like every tier-0 cell; the delegated handlers
+// do the work. Only the handle's disabled state is live (a sorted, filtered or grouped table
+// cannot reorder; the tooltip says why), through a store, so a sort re-renders these cells and
+// not the rows.
+function RowControlsCell({ api }) {
+    const { options, reorderBlock } = api.editing;
+    const blocked = useSyncExternalStore(reorderBlock.subscribe, reorderBlock.get);
+    return /*#__PURE__*/ React.createElement("span", {
+        className: "lf-table-row-controls"
+    }, options.rowDrag ? /*#__PURE__*/ React.createElement("span", {
+        "aria-disabled": blocked ? true : undefined,
+        "aria-label": "Drag to reorder",
+        className: "lf-table-drag-handle",
+        "data-lf-drag-handle": "",
+        role: "button",
+        title: blocked ?? 'Drag to reorder (Alt+Shift+Arrow keys)'
+    }, /*#__PURE__*/ React.createElement(GripIcon, null)) : null, options.deleteButton ? /*#__PURE__*/ React.createElement("button", {
+        "aria-label": "Delete row",
+        className: "lf-table-row-delete",
+        "data-lf-row-delete": "",
+        tabIndex: -1,
+        title: "Delete row",
+        type: "button"
+    }, /*#__PURE__*/ React.createElement(DeleteIcon, null)) : null);
+}
+export default RowControlsCell;

package/dist/features/editing/RowControlsHeader.js

@@ -0,0 +1,18 @@
+/*
+  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 RowControlsHeader() {
+    return null;
+}
+export default RowControlsHeader;

package/dist/features/editing/SelectedTag.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 React from 'react';
+function keepFocus(event) {
+    event.preventDefault();
+    event.stopPropagation();
+}
+// A picked value in the tags editor (antd Select `tagRender`): the value's chip as the cell shows
+// it, with a remove button, instead of antd's own tag around the chip.
+function SelectedTag({ closable, label, onClose }) {
+    return /*#__PURE__*/ React.createElement("span", {
+        className: "lf-table-editor-tag",
+        onMouseDown: keepFocus
+    }, label, closable ? /*#__PURE__*/ React.createElement("button", {
+        "aria-label": "Remove",
+        className: "lf-table-editor-tag-remove",
+        onClick: onClose,
+        type: "button"
+    }, "×") : null);
+}
+export default SelectedTag;

package/dist/features/editing/addChangeRow.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.
+*/ // A row added in TableInput: `{ rowKey, ...fields }` at the end of `added` (and of `order`, when a
+// move recorded one).
+function addChangeRow({ changes, rowKey, fields }) {
+    const next = {
+        ...changes,
+        added: [
+            ...changes.added,
+            {
+                rowKey,
+                ...fields
+            }
+        ]
+    };
+    if (changes.order) next.order = [
+        ...changes.order,
+        rowKey
+    ];
+    return next;
+}
+export default addChangeRow;

package/dist/features/editing/applyChangeUpdates.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 setChangeField from './setChangeField.js';
+// Many cell writes (a paste) folded into one changeset, so they are one value write and one undo
+// step. `updates` is [{ rowKey, field, value }]; `dataByKey` maps a row key (as a string) to its
+// unchanged data row, and has no entry for rows added in the table.
+function applyChangeUpdates({ changes, updates, dataByKey }) {
+    return updates.reduce((current, { rowKey, field, value })=>setChangeField({
+            changes: current,
+            rowKey,
+            field,
+            value,
+            dataRow: dataByKey.get(String(rowKey))
+        }), changes);
+}
+export default applyChangeUpdates;

package/dist/features/editing/applyChanges.js

@@ -0,0 +1,90 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { get, serializer, set, type } from '@lowdefy/helpers';
+import reorderByKeys from './reorderByKeys.js';
+import sortByPosition from './sortByPosition.js';
+function patchRow({ row, patch, position, positionField, cache }) {
+    const cached = cache.get(row);
+    if (cached && cached.patch === patch && cached.position === position) return cached.result;
+    const result = serializer.copy(row);
+    Object.entries(patch ?? {}).forEach(([field, value])=>set(result, field, serializer.copy(value)));
+    if (!type.isUndefined(position)) set(result, positionField, position);
+    cache.set(row, {
+        patch,
+        position,
+        result
+    });
+    return result;
+}
+function addedRow({ entry, keyField, cache }) {
+    const cached = cache.get(entry);
+    if (cached) return cached;
+    const { rowKey, ...fields } = entry;
+    const result = serializer.copy(fields);
+    if (type.isNone(get(result, keyField))) set(result, keyField, rowKey);
+    cache.set(entry, result);
+    return result;
+}
+// The rows TableInput shows: `data` with its changeset applied. Removed rows leave, updated rows
+// are copies with the changed fields set at their dot paths, added rows follow the data (with
+// their key in the key field), and moves reorder (by `order`, or by the position field when
+// positions changed). `data` is never written. Untouched rows keep their identity, and `cache`
+// (a WeakMap owned by the table) keeps a touched row's copy while its patch object is the same,
+// so an edit re-renders the rows it changed and no others.
+function applyChanges({ rows, changes, getKey, keyField, positionField, cache }) {
+    const { added, moved, order, removed, updated } = changes;
+    const hasMoves = Boolean(moved) && Object.keys(moved).length > 0;
+    if (Object.keys(updated).length === 0 && removed.length === 0 && added.length === 0 && !hasMoves && !order) {
+        return rows;
+    }
+    const removedKeys = new Set(removed.map(String));
+    let result = [];
+    rows.forEach((row)=>{
+        const key = String(getKey(row));
+        if (removedKeys.has(key)) return;
+        const patch = updated[key];
+        const position = hasMoves && positionField ? moved[key] : undefined;
+        if (!patch && type.isUndefined(position)) {
+            result.push(row);
+            return;
+        }
+        result.push(patchRow({
+            row,
+            patch,
+            position,
+            positionField,
+            cache
+        }));
+    });
+    added.forEach((entry)=>result.push(addedRow({
+            entry,
+            keyField,
+            cache
+        })));
+    if (order) {
+        result = reorderByKeys({
+            rows: result,
+            order,
+            getKey
+        });
+    } else if (positionField && (hasMoves || added.length > 0)) {
+        result = sortByPosition({
+            rows: result,
+            positionField
+        });
+    }
+    return result;
+}
+export default applyChanges;

package/dist/features/editing/applyMoveOverlay.js

@@ -0,0 +1,44 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { serializer, set } from '@lowdefy/helpers';
+import reorderByKeys from './reorderByKeys.js';
+import sortByPosition from './sortByPosition.js';
+// Table's optimistic row move (the onRowMove cycle, like onCellEdit's overlay): while the event
+// runs, and after it succeeded until `data` changes, the rows show in the moved order. With a
+// position field the moved rows get their new positions (on copies) and the rows are ordered by
+// it; without one they follow the move's key order. `data` is the array the move was made on.
+// Copies are mapped to their data rows in `sources`, as the cell overlay's are.
+function applyMoveOverlay({ rows, move, data, getKey, positionField, sources }) {
+    if (!move || !move.hasValue) return rows;
+    if (move.status !== 'saving' && move.source !== data) return rows;
+    if (!positionField) return reorderByKeys({
+        rows,
+        order: move.order,
+        getKey
+    });
+    const positioned = rows.map((row)=>{
+        const position = move.positions[String(getKey(row))];
+        if (position === undefined) return row;
+        const copy = serializer.copy(row);
+        set(copy, positionField, position);
+        sources.set(copy, sources.get(row) ?? row);
+        return copy;
+    });
+    return sortByPosition({
+        rows: positioned,
+        positionField
+    });
+}
+export default applyMoveOverlay;

package/dist/features/editing/applyMoveToChanges.js

@@ -0,0 +1,66 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { get, serializer, set } from '@lowdefy/helpers';
+function applyPositions({ changes, positions, positionField, dataByKey }) {
+    const moved = {
+        ...changes.moved ?? {}
+    };
+    let added = changes.added;
+    Object.entries(positions).forEach(([key, position])=>{
+        const addedIndex = added.findIndex((entry)=>String(entry.rowKey) === key);
+        if (addedIndex !== -1) {
+            // An added row carries its position in its own entry, like its other fields.
+            added = added.slice();
+            const entry = serializer.copy(added[addedIndex]);
+            set(entry, positionField, position);
+            added[addedIndex] = entry;
+            return;
+        }
+        const dataRow = dataByKey.get(key);
+        if (dataRow !== undefined && get(dataRow, positionField) === position) {
+            delete moved[key];
+        } else {
+            moved[key] = position;
+        }
+    });
+    const next = {
+        ...changes,
+        added
+    };
+    if (Object.keys(moved).length > 0) {
+        next.moved = moved;
+    } else {
+        delete next.moved;
+    }
+    return next;
+}
+// A TableInput row move as a new changeset. With `positionField` the new positions go in
+// `moved` (a data row moved back to its original position leaves it); without one, `order`
+// records the full key order.
+function applyMoveToChanges({ changes, move, positionField, dataByKey }) {
+    if (positionField) {
+        return applyPositions({
+            changes,
+            positions: move.positions,
+            positionField,
+            dataByKey
+        });
+    }
+    return {
+        ...changes,
+        order: move.order
+    };
+}
+export default applyMoveToChanges;

package/dist/features/editing/applyOverlay.js

@@ -0,0 +1,41 @@
+/*
+  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 { serializer, set } from '@lowdefy/helpers';
+// The optimistic overlay (D8) over `data`: rows with an edit that is saving, or saved and not yet
+// replaced by new data, are shown as copies with the edited values in. `data` itself is never
+// written. A saved edit stops applying once its row in `data` is a different object than the one
+// it was made on: the data has caught up (or moved on). `sources` maps each copy back to its data
+// row, so the next edit of the same row records the data row, not the copy.
+function applyOverlay({ rows, overlay, getKey, sources }) {
+    if (overlay.size === 0) return rows;
+    const byRow = new Map();
+    overlay.forEach((entry)=>{
+        if (!entry.hasValue) return;
+        if (!byRow.has(entry.rowKey)) byRow.set(entry.rowKey, []);
+        byRow.get(entry.rowKey).push(entry);
+    });
+    if (byRow.size === 0) return rows;
+    return rows.map((row)=>{
+        const entries = byRow.get(String(getKey(row)));
+        if (!entries) return row;
+        const live = entries.filter((entry)=>entry.status === 'saving' || entry.source === row);
+        if (live.length === 0) return row;
+        const copy = serializer.copy(row);
+        live.forEach((entry)=>set(copy, entry.field, serializer.copy(entry.value)));
+        sources.set(copy, row);
+        return copy;
+    });
+}
+export default applyOverlay;

package/dist/features/editing/coerceCellValue.js

@@ -0,0 +1,187 @@
+/*
+  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 matchOption from './matchOption.js';
+import toDateValue from './toDateValue.js';
+const TRUE_TEXTS = new Set([
+    'true',
+    'yes',
+    'y',
+    '1',
+    'on',
+    'checked',
+    '✓',
+    '✔'
+]);
+const FALSE_TEXTS = new Set([
+    'false',
+    'no',
+    'n',
+    '0',
+    'off',
+    'unchecked'
+]);
+function coerceNumber({ spec, text }) {
+    const trimmed = text.trim();
+    if (trimmed === '') return {
+        value: null
+    };
+    const isPercentText = trimmed.endsWith('%');
+    // Copied cells carry their display format: grouping separators, currency symbols, a % sign.
+    const cleaned = trimmed.replace(/[\s,_%]/g, '').replace(/^[^\d+\-.]+/, '');
+    const number = cleaned === '' ? NaN : Number(cleaned);
+    if (Number.isNaN(number)) return {
+        error: `"${text}" is not a number.`
+    };
+    if (spec.type === 'percent' && isPercentText) return {
+        value: number / 100
+    };
+    return {
+        value: number
+    };
+}
+function coerceRating({ spec, text }) {
+    const result = coerceNumber({
+        spec,
+        text
+    });
+    if (result.error || result.value === null) return result;
+    const rounded = Math.round(result.value);
+    if (rounded < 0 || rounded > spec.max) {
+        return {
+            error: `"${text}" is not a rating from 0 to ${spec.max}.`
+        };
+    }
+    return {
+        value: rounded
+    };
+}
+function coerceDate({ spec, text, previous }) {
+    const trimmed = text.trim();
+    if (trimmed === '') return {
+        value: null
+    };
+    const parsed = dayjs(trimmed);
+    if (!parsed.isValid()) return {
+        error: `"${text}" is not a date.`
+    };
+    return {
+        value: toDateValue({
+            date: parsed,
+            kind: spec.kind,
+            previous
+        })
+    };
+}
+function coerceBoolean({ text }) {
+    const lowered = text.trim().toLowerCase();
+    if (lowered === '') return {
+        value: null
+    };
+    if (TRUE_TEXTS.has(lowered)) return {
+        value: true
+    };
+    if (FALSE_TEXTS.has(lowered)) return {
+        value: false
+    };
+    return {
+        error: `"${text}" is not true or false.`
+    };
+}
+function coerceSelect({ spec, text }) {
+    if (text.trim() === '') return {
+        value: null
+    };
+    if (!spec.options) return {
+        value: text.trim()
+    };
+    const option = matchOption({
+        options: spec.options,
+        text
+    });
+    if (!option) return {
+        error: `"${text}" is not one of the options.`
+    };
+    return {
+        value: option.value
+    };
+}
+function coerceMultiSelect({ spec, text }) {
+    const parts = text.split(/[,;]/).map((part)=>part.trim()).filter((part)=>part !== '');
+    if (!spec.options) return {
+        value: parts
+    };
+    const values = [];
+    for (const part of parts){
+        const option = matchOption({
+            options: spec.options,
+            text: part
+        });
+        if (!option) return {
+            error: `"${part}" is not one of the options.`
+        };
+        values.push(option.value);
+    }
+    return {
+        value: values
+    };
+}
+// A pasted text as the column's value type. Returns `{ value }`, or `{ error }` with a message
+// when the text does not fit the column (a word in a number column, an unknown option).
+function coerceCellValue({ spec, text, previous }) {
+    const source = String(text ?? '');
+    switch(spec.kind){
+        case 'text':
+            return {
+                value: source
+            };
+        case 'number':
+            return coerceNumber({
+                spec,
+                text: source
+            });
+        case 'rating':
+            return coerceRating({
+                spec,
+                text: source
+            });
+        case 'date':
+        case 'datetime':
+            return coerceDate({
+                spec,
+                text: source,
+                previous
+            });
+        case 'boolean':
+            return coerceBoolean({
+                text: source
+            });
+        case 'select':
+            return coerceSelect({
+                spec,
+                text: source
+            });
+        case 'multiSelect':
+            return coerceMultiSelect({
+                spec,
+                text: source
+            });
+        default:
+            return {
+                error: 'This column is not editable.'
+            };
+    }
+}
+export default coerceCellValue;

package/dist/features/editing/collectRawColumns.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 { type } from '@lowdefy/helpers';
+// The leaf column configs as written, by column key (header groups flattened). Editing reads
+// `editable: { when }`, `required` and `default` from here: the normalised column model keeps
+// only the keys every table feature shares.
+function collectRawColumns({ columns, byKey = new Map() }) {
+    (columns ?? []).forEach((entry)=>{
+        const column = type.isString(entry) ? {
+            key: entry
+        } : entry;
+        if (!type.isObject(column)) return;
+        if (type.isArray(column.children)) {
+            collectRawColumns({
+                columns: column.children,
+                byKey
+            });
+            return;
+        }
+        const key = column.key ?? column.field;
+        if (type.isNone(key)) return;
+        byKey.set(String(key), column);
+    });
+    return byKey;
+}
+export default collectRawColumns;