@lowdefy/blocks-table 0.0.0-experimental-20260929110023

package/dist/features/editing/editingFeature.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 createAddRow from './createAddRow.js';
+import createCancelEdit from './createCancelEdit.js';
+import createCommitEdit from './createCommitEdit.js';
+import createDeleteRow from './createDeleteRow.js';
+import createMoveRow from './createMoveRow.js';
+import createResetChanges from './createResetChanges.js';
+import createSaveCellEdit from './createSaveCellEdit.js';
+import createSaveRowMove from './createSaveRowMove.js';
+import createStartEdit from './createStartEdit.js';
+import createStepHistory from './createStepHistory.js';
+import createWriteCell from './createWriteCell.js';
+import createWriteChanges from './createWriteChanges.js';
+import handleEditDoubleClick from './handleEditDoubleClick.js';
+import handleEditKeyDown from './handleEditKeyDown.js';
+import handleRowControlsClick from './handleRowControlsClick.js';
+import handleRowDragPointerDown from './handleRowDragPointerDown.js';
+import useEditingData from './useEditingData.js';
+import useEditingFragments from './useEditingFragments.js';
+import useEditingGrid from './useEditingGrid.js';
+// Cell editing (D8) and row reorder for Table and TableInput. Table edits and moves are events:
+// onCellEdit / onRowMove are awaited while the table shows the change optimistically (keyed by
+// row key, never by writing `data`). TableInput records edits, added and deleted rows and moves
+// in its value, a changeset over `data`, with undo/redo. Placed before selection, keyboard and
+// events: its keys (Enter, F2, typing) and double-click win over row activation, and clicks on
+// the row controls never select.
+const editingFeature = {
+    name: 'editing',
+    useRows: useEditingData,
+    useFeature: useEditingFragments,
+    useGridFeature: useEditingGrid,
+    actions: {
+        addRow: createAddRow,
+        cancelEdit: createCancelEdit,
+        commitEdit: createCommitEdit,
+        deleteRow: createDeleteRow,
+        moveRow: createMoveRow,
+        resetChanges: createResetChanges,
+        saveCellEdit: createSaveCellEdit,
+        saveRowMove: createSaveRowMove,
+        startEdit: createStartEdit,
+        stepHistory: createStepHistory,
+        writeCell: createWriteCell,
+        writeChanges: createWriteChanges
+    },
+    gridHandlers: {
+        click: handleRowControlsClick,
+        dblclick: handleEditDoubleClick,
+        keydown: handleEditKeyDown,
+        pointerdown: handleRowDragPointerDown
+    }
+};
+export default editingFeature;

package/dist/features/editing/findCellByKey.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.
+*/ // The rendered body cell of a row (by row id, which is the row key as a string) and column, or
+// null when it is outside the rendered window. Editing addresses cells by key, never by display
+// index, so a sort or a new row between two renders cannot retarget an edit.
+function findCellByKey({ api, rowId, colKey }) {
+    const scroller = api.scrollerRef.current;
+    if (!scroller) return null;
+    return scroller.querySelector(`.lf-table-body [data-row-key="${CSS.escape(rowId)}"] [data-lf-cell][data-col-key="${CSS.escape(colKey)}"]`);
+}
+export default findCellByKey;

package/dist/features/editing/findInvalidCells.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 { get } from '@lowdefy/helpers';
+import validateCellValue from './validateCellValue.js';
+const EMPTY = new Map();
+// TableInput's inline validation: every cell whose value fails its column's `required` or
+// `validate`, as rowKey -> (columnKey -> message). Only columns with checks are visited.
+function findInvalidCells({ rows, specs, getKey }) {
+    const checked = [
+        ...specs.values()
+    ].filter((spec)=>spec.required || spec.validate.length > 0);
+    if (checked.length === 0) return EMPTY;
+    const invalid = new Map();
+    rows.forEach((row)=>{
+        checked.forEach((spec)=>{
+            const message = validateCellValue({
+                spec,
+                row,
+                value: get(row, spec.field)
+            });
+            if (message === null) return;
+            const key = String(getKey(row));
+            if (!invalid.has(key)) invalid.set(key, new Map());
+            invalid.get(key).set(spec.key, message);
+        });
+    });
+    return invalid;
+}
+export default findInvalidCells;

package/dist/features/editing/findNextEditableCell.js

@@ -0,0 +1,54 @@
+/*
+  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 isCellEditable from './isCellEditable.js';
+import isDataItem from '../../core/isDataItem.js';
+// Tab / Shift+Tab from an editor: the next editable cell in display order, along the row and
+// then on to the next row (the previous one for -1). Row-level `editable.when` is tested per
+// row. Returns { rowIndex, colIndex, rowId, colKey } or null at the end of the table.
+function findNextEditableCell({ rows, cols, specs, rowIndex, colIndex, direction }) {
+    let r = rowIndex;
+    let c = colIndex;
+    const total = rows.length * cols.length;
+    for(let step = 0; step < total; step++){
+        c += direction;
+        if (c >= cols.length) {
+            c = 0;
+            r += 1;
+        } else if (c < 0) {
+            c = cols.length - 1;
+            r -= 1;
+        }
+        if (r < 0 || r >= rows.length) return null;
+        const col = cols[c];
+        if (col.special) continue;
+        const row = rows[r];
+        if (!isDataItem(row)) continue;
+        const spec = specs.get(col.key);
+        if (isCellEditable({
+            spec,
+            row: row.original,
+            value: col.accessor(row.original)
+        })) {
+            return {
+                rowIndex: r,
+                colIndex: c,
+                rowId: row.id,
+                colKey: col.key
+            };
+        }
+    }
+    return null;
+}
+export default findNextEditableCell;

package/dist/features/editing/focusCell.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 findCellByKey from './findCellByKey.js';
+// Returns keyboard focus to a cell after its editor closes; the keyboard feature's focus handler
+// makes it the active cell again, so arrows continue from where the edit was.
+function focusCell({ api, rowId, colKey }) {
+    const cell = findCellByKey({
+        api,
+        rowId,
+        colKey
+    });
+    cell?.focus({
+        preventScroll: true
+    });
+}
+export default focusCell;

package/dist/features/editing/fromDateValue.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 dayjs from 'dayjs';
+import utc from 'dayjs/plugin/utc.js';
+import { type } from '@lowdefy/helpers';
+dayjs.extend(utc);
+// The picker value for a stored date. A `date` Date is read as its UTC calendar day (see
+// toDateValue), shown as that day in the browser's zone so the picker highlights the right day.
+function fromDateValue({ value, kind }) {
+    if (type.isNone(value) || value === '') return null;
+    if (kind === 'date' && type.isDate(value)) {
+        return dayjs(dayjs.utc(value).format('YYYY-MM-DD'));
+    }
+    const parsed = dayjs(value);
+    return parsed.isValid() ? parsed : null;
+}
+export default fromDateValue;

package/dist/features/editing/fromEditorDraft.js

@@ -0,0 +1,45 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { type } from '@lowdefy/helpers';
+import toDateValue from './toDateValue.js';
+// The cell value an editor's draft commits (the inverse of toEditorDraft).
+function fromEditorDraft({ spec, draft, previous }) {
+    switch(spec.kind){
+        case 'text':
+            return type.isNone(draft) ? '' : String(draft);
+        case 'number':
+            if (type.isNone(draft) || draft === '') return null;
+            if (spec.type === 'percent') return Math.round(Number(draft) / 100 * 1e10) / 1e10;
+            return Number(draft);
+        case 'date':
+        case 'datetime':
+            return toDateValue({
+                date: draft,
+                kind: spec.kind,
+                previous
+            });
+        case 'boolean':
+            return draft === true;
+        case 'select':
+            return type.isNone(draft) ? null : draft;
+        case 'multiSelect':
+            return type.isArray(draft) ? draft : [];
+        case 'rating':
+            return type.isNone(draft) ? null : Number(draft);
+        default:
+            return draft;
+    }
+}
+export default fromEditorDraft;

package/dist/features/editing/generateRowKey.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.
+*/ let counter = 0;
+// A key for a row added in the browser. It only has to be unique within the table's value;
+// crypto.randomUUID is missing on insecure origins (plain http on a LAN address).
+function generateRowKey() {
+    if (typeof window.crypto?.randomUUID === 'function') {
+        return window.crypto.randomUUID();
+    }
+    counter += 1;
+    return `row_${Date.now().toString(36)}_${counter.toString(36)}`;
+}
+export default generateRowKey;

package/dist/features/editing/getDataGap.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 isDataItem from '../../core/isDataItem.js';
+// A drop gap in the displayed list (`api.rows`: the current page, detail rows included) as a gap
+// in every data row in display order (`api.dataRows`): the index of the first data row at or
+// after it, or one past the last data row before it. A gap stays within the page, so a row
+// dragged (or moved with the keys) past the page's edge lands at that edge.
+function getDataGap({ api, gap }) {
+    const clamped = Math.min(Math.max(gap, 0), api.rows.length);
+    const next = api.rows.slice(clamped).find(isDataItem);
+    if (next !== undefined) return api.dataRows.findIndex((row)=>row.id === next.id);
+    const previous = api.rows.slice(0, clamped).findLast(isDataItem);
+    if (previous !== undefined) return api.dataRows.findIndex((row)=>row.id === previous.id) + 1;
+    return 0;
+}
+export default getDataGap;

package/dist/features/editing/getEditOptions.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 { type } from '@lowdefy/helpers';
+function getPositionField(rowDrag) {
+    if (!type.isObject(rowDrag)) return null;
+    return type.isString(rowDrag.positionField) ? rowDrag.positionField : null;
+}
+// The row-level editing options. Row drag works on both blocks (Table saves a move through
+// onRowMove, TableInput records it in its changeset); adding and deleting rows is TableInput's.
+function getEditOptions({ input, properties }) {
+    const rowDrag = properties.rowDrag === true || type.isObject(properties.rowDrag);
+    return {
+        addRow: Boolean(input) && properties.addRow === true,
+        addRowText: type.isString(properties.addRowText) ? properties.addRowText : null,
+        deleteButton: Boolean(input) && properties.rowActions?.delete === true,
+        deleteRows: Boolean(input) && properties.deleteRows === true,
+        positionField: rowDrag ? getPositionField(properties.rowDrag) : null,
+        rowDrag
+    };
+}
+export default getEditOptions;

package/dist/features/editing/getEditorKind.js

@@ -0,0 +1,36 @@
+/*
+  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 editor a cell type edits with (D8). Types without an editor (link, people, relation, json,
+// image, html, progress, avatar, buttons, menu) are never editable, even with `editable: true`.
+const EDITOR_KINDS = {
+    text: 'text',
+    email: 'text',
+    phone: 'text',
+    url: 'text',
+    number: 'number',
+    currency: 'number',
+    percent: 'number',
+    date: 'date',
+    datetime: 'datetime',
+    boolean: 'boolean',
+    tag: 'select',
+    status: 'select',
+    tags: 'multiSelect',
+    rating: 'rating'
+};
+function getEditorKind(cellType) {
+    return EDITOR_KINDS[cellType] ?? null;
+}
+export default getEditorKind;

package/dist/features/editing/getEventError.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.
+*/ const FALLBACK_MESSAGE = 'The change was not saved.';
+// The failure message of a `triggerEvent` result, or null when the event succeeded. A failed
+// action chain resolves (it does not reject) with `success: false` and `error` holding the thrown
+// `{ error, action, index }`; the message the user should see is that inner error's. A bounced
+// (debounced) event is not a failure: a later trigger carries the change.
+function getEventError(result) {
+    if (result?.success !== false) return null;
+    return result.error?.error?.message ?? result.error?.message ?? FALLBACK_MESSAGE;
+}
+export default getEventError;

package/dist/features/editing/getKeyField.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 { get, type } from '@lowdefy/helpers';
+// The field that holds a row's key, where an added row shows its temporary key: `rowKey`, else
+// the default key field the data uses (`_id` before `id`, as the row key getter reads them).
+function getKeyField({ rowKey, rows }) {
+    if (type.isString(rowKey)) return rowKey;
+    if ((rows ?? []).some((row)=>!type.isNone(get(row, '_id')))) return '_id';
+    return 'id';
+}
+export default getKeyField;

package/dist/features/editing/getReorderBlock.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.
+*/ // Why rows cannot be reordered right now, or null when they can. A move is placed between the
+// row's display neighbours, which are its neighbours in the saved order only while the table
+// shows the data order: no grouping, no client filter, and no sort except ascending by the
+// position field itself.
+function getReorderBlock({ config, data, positionField, state, table }) {
+    // Server rows and tree rows have no single saved order the display neighbours come from.
+    if (config.server) return 'Rows cannot be reordered in server mode.';
+    if (config.tree) return 'Rows cannot be reordered in a tree.';
+    if ((state.grouping?.length ?? 0) > 0) return 'Rows cannot be reordered while grouped.';
+    if (table.getRowModel().rows.length !== data.length) {
+        return 'Clear the filter to reorder rows.';
+    }
+    const sorting = state.sorting ?? [];
+    if (sorting.length === 0) return null;
+    const positionColumn = positionField ? config.columns.find((column)=>column.field === positionField) : null;
+    const byPosition = Boolean(positionColumn) && sorting.length === 1 && sorting[0].id === positionColumn.key && sorting[0].desc !== true;
+    return byPosition ? null : 'Clear the sort to reorder rows.';
+}
+export default getReorderBlock;

package/dist/features/editing/handleEditDoubleClick.js

@@ -0,0 +1,34 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import isControlTarget from '@lowdefy/blocks-antd/table/isControlTarget.js';
+// Double-click on an editable cell opens its editor; the double-click is the edit's, not
+// onRowDoubleClick's. Double-clicks inside an open editor (selecting a word) stay the editor's.
+function handleEditDoubleClick(event, api) {
+    if (!api.editing?.enabled) return false;
+    if (event.target.closest('[data-lf-editor]')) return true;
+    const cell = event.target.closest('[data-lf-cell]');
+    if (!cell || !api.contains(cell) || cell.dataset.special) return false;
+    const rowElement = cell.closest('[data-row-key]');
+    if (!rowElement) return false;
+    if (isControlTarget({
+        target: event.target,
+        container: cell
+    })) return false;
+    return api.actions.startEdit({
+        rowId: rowElement.dataset.rowKey,
+        colKey: cell.dataset.colKey
+    });
+}
+export default handleEditDoubleClick;

package/dist/features/editing/handleEditKeyDown.js

@@ -0,0 +1,123 @@
+/*
+  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 isPrintableKey from './isPrintableKey.js';
+import { ROW_CONTROLS_SPECIAL } from './rowControlsColumn.js';
+function handleInputKeys({ event, api, rowElement, rowIndex, cell }) {
+    const modified = event.ctrlKey || event.metaKey;
+    const key = event.key.toLowerCase();
+    if (modified && key === 'z') {
+        event.preventDefault();
+        api.actions.stepHistory({
+            direction: event.shiftKey ? 'redo' : 'undo'
+        });
+        return true;
+    }
+    if (event.ctrlKey && !event.metaKey && key === 'y') {
+        event.preventDefault();
+        api.actions.stepHistory({
+            direction: 'redo'
+        });
+        return true;
+    }
+    if (!modified && api.editing.options.deleteRows && (event.key === 'Delete' || event.key === 'Backspace')) {
+        event.preventDefault();
+        const col = Number(cell.dataset.colIndex);
+        if (api.actions.deleteRow({
+            rowId: rowElement.dataset.rowKey
+        })) {
+            api.keyboard?.moveTo({
+                row: rowIndex,
+                col
+            });
+        }
+        return true;
+    }
+    return false;
+}
+// Alt+Shift+ArrowUp/Down moves the focused row one place (`rowDrag`), the keyboard way to drag;
+// focus stays on the moved row.
+function handleMoveKeys({ event, api, rowElement, rowIndex, cell }) {
+    if (!api.editing.options.rowDrag || !event.altKey || !event.shiftKey) return false;
+    if (event.key !== 'ArrowUp' && event.key !== 'ArrowDown') return false;
+    event.preventDefault();
+    const up = event.key === 'ArrowUp';
+    const gap = up ? rowIndex - 1 : rowIndex + 2;
+    const move = api.actions.moveRow({
+        rowId: rowElement.dataset.rowKey,
+        gap
+    });
+    // The move's indices are in the whole list; the row moved one place in the display.
+    if (move) {
+        api.keyboard?.moveTo({
+            row: up ? rowIndex - 1 : rowIndex + 1,
+            col: Number(cell.dataset.colIndex)
+        });
+    }
+    return true;
+}
+// Keys on a focused cell (not inside an open editor, whose own handler keeps its keys): Enter or
+// F2 opens the editor, a printable key opens it seeded with that character (D8, D11). With
+// `rowDrag`, Alt+Shift+Arrow moves the row. TableInput adds undo/redo and, with `deleteRows`,
+// Delete on a focused row. Runs before the keyboard feature, so Enter on an editable cell edits
+// instead of activating the row.
+function handleEditKeyDown(event, api) {
+    if (!api.editing?.enabled || !api.editing.layer) return false;
+    const cell = event.target.closest('[data-lf-cell]');
+    if (!cell || !api.contains(cell) || event.target !== cell) return false;
+    const rowElement = cell.closest('[data-row-index]');
+    const rowIndex = Number(rowElement.dataset.rowIndex);
+    if (rowIndex < 0) {
+        // The row controls header has nothing to activate (and no column to sort).
+        if (cell.dataset.special !== ROW_CONTROLS_SPECIAL) return false;
+        return event.key === 'Enter' || event.key === ' ';
+    }
+    if (handleMoveKeys({
+        event,
+        api,
+        rowElement,
+        rowIndex,
+        cell
+    })) return true;
+    if (api.editing.input && handleInputKeys({
+        event,
+        api,
+        rowElement,
+        rowIndex,
+        cell
+    })) {
+        return true;
+    }
+    if (cell.dataset.special) return false;
+    const rowId = rowElement.dataset.rowKey;
+    const colKey = cell.dataset.colKey;
+    if (event.key === 'Enter' || event.key === 'F2') {
+        if (!api.actions.startEdit({
+            rowId,
+            colKey
+        })) return false;
+        event.preventDefault();
+        return true;
+    }
+    if (!isPrintableKey(event)) return false;
+    if (event.key === ' ' && api.config.rowSelection) return false;
+    if (!api.actions.startEdit({
+        rowId,
+        colKey,
+        seed: event.key
+    })) return false;
+    event.preventDefault();
+    return true;
+}
+export default handleEditKeyDown;