@lowdefy/blocks-table 0.0.0-experimental-20260929110023

package/dist/features/editing/handleRowControlsClick.js

@@ -0,0 +1,29 @@
+/*
+  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 { ROW_CONTROLS_KEY } from './rowControlsColumn.js';
+// Clicks in the row controls column are the controls': the delete button removes the row, and
+// no click there selects the row or fires onRowClick (the end of a drag is a click too).
+function handleRowControlsClick(event, api) {
+    const cell = event.target.closest(`[data-lf-cell][data-col-key="${ROW_CONTROLS_KEY}"]`);
+    if (!cell || !api.contains(cell)) return false;
+    if (event.target.closest('[data-lf-row-delete]')) {
+        const rowElement = cell.closest('[data-row-key]');
+        if (rowElement) api.actions.deleteRow({
+            rowId: rowElement.dataset.rowKey
+        });
+    }
+    return true;
+}
+export default handleRowControlsClick;

package/dist/features/editing/handleRowDragPointerDown.js

@@ -0,0 +1,95 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ const EDGE = 24;
+const SCROLL_STEP = 16;
+function getGap({ api, clientY }) {
+    const scroller = api.scrollerRef.current;
+    const rect = scroller.getBoundingClientRect();
+    const y = clientY - rect.top + scroller.scrollTop - api.headerHeight;
+    return Math.min(Math.max(Math.round(y / api.rowHeight), 0), api.rows.length);
+}
+function autoScroll({ api, clientY }) {
+    const scroller = api.scrollerRef.current;
+    const rect = scroller.getBoundingClientRect();
+    if (clientY < rect.top + api.headerHeight + EDGE) scroller.scrollTop -= SCROLL_STEP;
+    if (clientY > rect.bottom - EDGE) scroller.scrollTop += SCROLL_STEP;
+}
+// Row drag reorder (`rowDrag`). The drag itself never renders React: a drop indicator line is
+// moved in the canvas and the dragged row is marked with an attribute, the way column resize
+// previews its widths. The move happens once, on drop. Esc cancels.
+function handleRowDragPointerDown(event, api) {
+    const handle = event.target.closest('[data-lf-drag-handle]');
+    if (!handle || !api.contains(handle)) return false;
+    event.preventDefault();
+    if (event.button !== 0 || api.editing.reorderBlock.get()) return true;
+    const rowElement = handle.closest('[data-row-key]');
+    const canvas = api.scrollerRef.current?.querySelector('.lf-table-canvas');
+    if (!rowElement || !canvas) return true;
+    const rowId = rowElement.dataset.rowKey;
+    api.actions.cancelEdit({
+        refocus: false
+    });
+    const indicator = document.createElement('div');
+    indicator.className = 'lf-table-drop-indicator';
+    canvas.appendChild(indicator);
+    rowElement.setAttribute('data-lf-dragging', '');
+    let gap = null;
+    function place(clientY) {
+        gap = getGap({
+            api,
+            clientY
+        });
+        indicator.style.transform = `translateY(${api.headerHeight + gap * api.rowHeight - 1}px)`;
+    }
+    function end() {
+        window.removeEventListener('pointermove', onMove);
+        window.removeEventListener('pointerup', onUp);
+        window.removeEventListener('pointercancel', onCancel);
+        window.removeEventListener('keydown', onKeyDown, true);
+        indicator.remove();
+        rowElement.removeAttribute('data-lf-dragging');
+    }
+    function onMove(moveEvent) {
+        autoScroll({
+            api,
+            clientY: moveEvent.clientY
+        });
+        place(moveEvent.clientY);
+    }
+    function onUp(upEvent) {
+        place(upEvent.clientY);
+        end();
+        api.actions.moveRow({
+            rowId,
+            gap
+        });
+    }
+    function onCancel() {
+        end();
+    }
+    function onKeyDown(keyEvent) {
+        if (keyEvent.key !== 'Escape') return;
+        keyEvent.preventDefault();
+        keyEvent.stopPropagation();
+        end();
+    }
+    place(event.clientY);
+    window.addEventListener('pointermove', onMove);
+    window.addEventListener('pointerup', onUp);
+    window.addEventListener('pointercancel', onCancel);
+    window.addEventListener('keydown', onKeyDown, true);
+    return true;
+}
+export default handleRowDragPointerDown;

package/dist/features/editing/isCellEditable.js

@@ -0,0 +1,20 @@
+/*
+  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 isCellEditable({ spec, row, value }) {
+    if (!spec?.editable) return false;
+    if (spec.when === null) return true;
+    return spec.when(row, value) === true;
+}
+export default isCellEditable;

package/dist/features/editing/isPrintableKey.js

@@ -0,0 +1,22 @@
+/*
+  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 key that types a character (not a shortcut, not a navigation key): typing it into a focused
+// editable cell opens the editor seeded with it, as in a spreadsheet.
+function isPrintableKey(event) {
+    if (event.ctrlKey || event.metaKey || event.altKey) return false;
+    if (event.isComposing) return false;
+    return typeof event.key === 'string' && event.key.length === 1;
+}
+export default isPrintableKey;

package/dist/features/editing/isSameTargets.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.
+*/ function isSameTargets(a, b) {
+    if (a.length !== b.length) return false;
+    return a.every((target, i)=>target.id === b[i].id && target.element === b[i].element && target.status === b[i].status && target.message === b[i].message);
+}
+export default isSameTargets;

package/dist/features/editing/matchOption.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.
+*/ // The option a pasted text names, by value or by label, ignoring case: copying a tag cell gives
+// its label, so pasting it back must find the same option.
+function matchOption({ options, text }) {
+    const wanted = String(text).trim().toLowerCase();
+    return options.find((option)=>String(option.value).toLowerCase() === wanted) ?? options.find((option)=>String(option.label).toLowerCase() === wanted) ?? null;
+}
+export default matchOption;

package/dist/features/editing/needsEditing.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.
+*/ import { type } from '@lowdefy/helpers';
+import someColumnConfig from '../../core/someColumnConfig.js';
+// Editing loads for TableInput, and for a Table with an editable column or row drag.
+function needsEditing({ input, properties }) {
+    if (input === true) return true;
+    if (properties.rowDrag === true || type.isObject(properties.rowDrag)) return true;
+    return someColumnConfig({
+        properties,
+        test: (column)=>column.editable === true || type.isObject(column.editable)
+    });
+}
+export default needsEditing;

package/dist/features/editing/normalizeChanges.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 createEmptyChanges from './createEmptyChanges.js';
+function isComplete(value) {
+    return type.isObject(value.updated) && type.isArray(value.added) && type.isArray(value.removed);
+}
+// TableInput's value as a complete changeset:
+//   { updated: { [rowKey]: { [field]: value } }, added: [{ rowKey, ...row }], removed: [rowKey],
+//     moved?: { [rowKey]: position }, order?: [rowKey] }
+// A complete value is returned as it is, so the value the table wrote keeps its identity (undo
+// compares by identity). A partial value set from outside is filled in; anything else is empty.
+function normalizeChanges(value) {
+    if (!type.isObject(value)) return createEmptyChanges();
+    if (isComplete(value)) return value;
+    const changes = {
+        updated: type.isObject(value.updated) ? value.updated : {},
+        added: type.isArray(value.added) ? value.added : [],
+        removed: type.isArray(value.removed) ? value.removed : []
+    };
+    if (type.isObject(value.moved)) changes.moved = value.moved;
+    if (type.isArray(value.order)) changes.order = value.order;
+    return changes;
+}
+export default normalizeChanges;

package/dist/features/editing/positionBetween.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 { type } from '@lowdefy/helpers';
+export const POSITION_STEP = 1024;
+const MIN_GAP = 1e-6;
+// A row's position between two neighbours' (fractional indexing): the midpoint, one step past
+// the only neighbour at either end, or the first step in an empty list. Null when there is no
+// room (the gap is below MIN_GAP, the neighbours are out of order, or a neighbour has no numeric
+// position): the caller renumbers the list then.
+function positionBetween({ before, after } = {}) {
+    if (type.isUndefined(before) && type.isUndefined(after)) return POSITION_STEP;
+    if (type.isUndefined(before)) return type.isNumber(after) ? after - POSITION_STEP : null;
+    if (type.isUndefined(after)) return type.isNumber(before) ? before + POSITION_STEP : null;
+    if (!type.isNumber(before) || !type.isNumber(after)) return null;
+    if (after - before < MIN_GAP) return null;
+    return (before + after) / 2;
+}
+export default positionBetween;

package/dist/features/editing/pruneOverlay.js

@@ -0,0 +1,39 @@
+/*
+  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.
+*/ // Drops settled overlay entries (saved or failed) whose row changed in `data` or left it. An edit
+// still saving stays: its result decides. Returns `overlay` itself when nothing was dropped, so a
+// data change with nothing to prune does not re-render.
+function pruneOverlay({ overlay, rows, getKey }) {
+    if (overlay.size === 0) return overlay;
+    const wanted = new Set();
+    overlay.forEach((entry)=>{
+        if (entry.status !== 'saving') wanted.add(entry.rowKey);
+    });
+    if (wanted.size === 0) return overlay;
+    const current = new Map();
+    rows.forEach((row)=>{
+        const key = String(getKey(row));
+        if (wanted.has(key)) current.set(key, row);
+    });
+    let next = overlay;
+    overlay.forEach((entry, id)=>{
+        if (entry.status === 'saving') return;
+        if (current.get(entry.rowKey) === entry.source) return;
+        if (next === overlay) next = new Map(overlay);
+        next.delete(id);
+    });
+    return next;
+}
+export default pruneOverlay;

package/dist/features/editing/removeChangeRow.js

@@ -0,0 +1,48 @@
+/*
+  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 withoutKey(object, key) {
+    if (!object || !Object.hasOwn(object, key)) return object;
+    const next = {
+        ...object
+    };
+    delete next[key];
+    return next;
+}
+// A row deleted in TableInput. A row added in the table just leaves `added`; a data row joins
+// `removed` (by its raw key) and its pending updates and move are dropped.
+function removeChangeRow({ changes, rowKey }) {
+    const key = String(rowKey);
+    const next = {
+        ...changes
+    };
+    if (changes.order) next.order = changes.order.filter((item)=>String(item) !== key);
+    if (changes.added.some((entry)=>String(entry.rowKey) === key)) {
+        next.added = changes.added.filter((entry)=>String(entry.rowKey) !== key);
+        return next;
+    }
+    if (!changes.removed.some((item)=>String(item) === key)) {
+        next.removed = [
+            ...changes.removed,
+            rowKey
+        ];
+    }
+    next.updated = withoutKey(changes.updated, key);
+    if (changes.moved) {
+        next.moved = withoutKey(changes.moved, key);
+        if (Object.keys(next.moved).length === 0) delete next.moved;
+    }
+    return next;
+}
+export default removeChangeRow;

package/dist/features/editing/reorderByKeys.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.
+*/ // Rows in the order of a key list (a move without a position field). Rows the list does not
+// name (rows that arrived after the move) follow, in their own order.
+function reorderByKeys({ rows, order, getKey }) {
+    const rank = new Map(order.map((key, index)=>[
+            String(key),
+            index
+        ]));
+    return rows.map((row, index)=>({
+            row,
+            index,
+            rank: rank.get(String(getKey(row)))
+        })).sort((a, b)=>{
+        const aRanked = a.rank !== undefined;
+        const bRanked = b.rank !== undefined;
+        if (aRanked && bRanked) return a.rank - b.rank;
+        if (aRanked !== bRanked) return aRanked ? -1 : 1;
+        return a.index - b.index;
+    }).map((item)=>item.row);
+}
+export default reorderByKeys;

package/dist/features/editing/rowControlsColumn.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 RowControlsCell from './RowControlsCell.js';
+import RowControlsHeader from './RowControlsHeader.js';
+export const ROW_CONTROLS_KEY = '__row';
+export const ROW_CONTROLS_SPECIAL = 'row';
+const HANDLE_WIDTH = 20;
+const DELETE_WIDTH = 26;
+const PADDING = 8;
+// The leading special column for TableInput's row controls, sized to the controls it holds.
+function rowControlsColumn({ rowDrag, deleteButton }) {
+    const width = PADDING + (rowDrag ? HANDLE_WIDTH : 0) + (deleteButton ? DELETE_WIDTH : 0);
+    return {
+        key: ROW_CONTROLS_KEY,
+        special: ROW_CONTROLS_SPECIAL,
+        width,
+        Header: RowControlsHeader,
+        Cell: RowControlsCell
+    };
+}
+export default rowControlsColumn;

package/dist/features/editing/setChangeField.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 { get, serializer, set } from '@lowdefy/helpers';
+import valuesEqual from './valuesEqual.js';
+function setAddedField({ changes, key, field, value }) {
+    let found = false;
+    const added = changes.added.map((entry)=>{
+        if (String(entry.rowKey) !== key) return entry;
+        found = true;
+        const next = serializer.copy(entry);
+        set(next, field, serializer.copy(value));
+        return next;
+    });
+    return found ? {
+        ...changes,
+        added
+    } : changes;
+}
+// One cell edit as a new changeset. For a row added in the table, the field is set in its
+// `added` entry. For a data row, `updated[rowKey][field]` holds the new value under the column's
+// dot path (`'address.city'`, a MongoDB $set key); a value equal to the data row's original
+// removes the field again, and the row's entry when it is empty, so an edit that is undone by
+// hand leaves no change behind. `dataRow` is the unchanged row from `data`, or undefined for an
+// added row.
+function setChangeField({ changes, rowKey, field, value, dataRow }) {
+    const key = String(rowKey);
+    if (dataRow === undefined) return setAddedField({
+        changes,
+        key,
+        field,
+        value
+    });
+    const current = changes.updated[key] ?? {};
+    let patch;
+    if (valuesEqual(value, get(dataRow, field))) {
+        if (!Object.hasOwn(current, field)) return changes;
+        patch = {
+            ...current
+        };
+        delete patch[field];
+    } else {
+        patch = {
+            ...current,
+            [field]: serializer.copy(value)
+        };
+    }
+    const updated = {
+        ...changes.updated
+    };
+    if (Object.keys(patch).length > 0) {
+        updated[key] = patch;
+    } else {
+        delete updated[key];
+    }
+    return {
+        ...changes,
+        updated
+    };
+}
+export default setChangeField;

package/dist/features/editing/setRowField.js

@@ -0,0 +1,23 @@
+/*
+  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';
+// A copy of the row with one field (a dot path) set. Rows can be frozen engine state, and the
+// same row object may be shared by an undo snapshot, so a row is never written in place.
+function setRowField({ row, field, value }) {
+    const next = serializer.copy(row ?? {});
+    set(next, field, serializer.copy(value));
+    return next;
+}
+export default setRowField;

package/dist/features/editing/sortByPosition.js

@@ -0,0 +1,31 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { get, type } from '@lowdefy/helpers';
+// Rows in `positionField` order, for showing moved rows where their new position puts them.
+// Stable, so rows with equal or missing positions keep their data order (missing last).
+function sortByPosition({ rows, positionField }) {
+    return rows.map((row, index)=>({
+            row,
+            index,
+            position: get(row, positionField)
+        })).sort((a, b)=>{
+        const aNumber = type.isNumber(a.position);
+        const bNumber = type.isNumber(b.position);
+        if (aNumber && bNumber && a.position !== b.position) return a.position - b.position;
+        if (aNumber !== bNumber) return aNumber ? -1 : 1;
+        return a.index - b.index;
+    }).map((item)=>item.row);
+}
+export default sortByPosition;

package/dist/features/editing/toDateValue.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 dayjs from 'dayjs';
+import utc from 'dayjs/plugin/utc.js';
+import { type } from '@lowdefy/helpers';
+dayjs.extend(utc);
+const DAY_STRING = /^\d{4}-\d{2}-\d{2}$/;
+// The stored value for a picked date. A `date` is a calendar day: stored as UTC midnight, the
+// same Date the DateSelector block writes. The previous value's shape is kept, so a column of
+// 'YYYY-MM-DD' strings stays strings and a column of ISO strings stays ISO strings.
+function toDateValue({ date, kind, previous }) {
+    if (type.isNone(date)) return null;
+    const picked = dayjs(date);
+    if (!picked.isValid()) return null;
+    if (kind === 'date') {
+        const day = picked.format('YYYY-MM-DD');
+        if (type.isString(previous) && DAY_STRING.test(previous)) return day;
+        const utcDay = dayjs.utc(day).toDate();
+        if (type.isString(previous)) return utcDay.toISOString();
+        return utcDay;
+    }
+    const instant = picked.toDate();
+    if (type.isString(previous)) return instant.toISOString();
+    return instant;
+}
+export default toDateValue;