niuma-ui 1.3.9 → 2.0.0

package/dist/components/table/src/composables/useRsTableCore.js

@@ -0,0 +1,164 @@
+import { resolveTableRowHeight, resolveTableSize } from "../utils/table-utils.js";
+import { resolveBuiltinTableFeatures } from "../features/table-features.js";
+import { useRsTable } from "./useRsTable.js";
+import { useRsTableColumns } from "./useRsTableColumns.js";
+import { useRsTableEngine } from "./useRsTableEngine.js";
+import { useRsTableScrollLayout } from "./useRsTableScrollLayout.js";
+import { useRsTableSelectionSource } from "./useRsTableSelectionSource.js";
+import { flattenVisibleCountRough, useRsTableVirtual } from "./useRsTableVirtual.js";
+import { computed, onUnmounted, watch } from "vue";
+//#region src/components/table/src/composables/useRsTableCore.ts
+/**
+* RsTable 内核装配（Columns + Engine + Scroll + Virtual + Analytics + Features）。
+*
+* 性能约定：
+* - data / columns 仅按引用浅层失效，不做 deep watch
+* - Feature 按 id + setup 引用签名重绑，避免无关 props 抖动拆掉图表订阅
+* - 行派生（dataRows / viewRows / keyMap）单次遍历 tableEntries
+*
+* 不负责：列宽拖拽 DOM、列虚拟（依赖 resize 快照）、编辑/右键交互、模板。
+*/
+/**
+* 装配表格内核状态。
+*/
+function useRsTableCore(options) {
+	const treeModeEarly = computed(() => Boolean(options.treeConfig()));
+	const treeExpandColumnKeyEarly = computed(() => {
+		const tree = options.treeConfig();
+		if (!tree) return null;
+		return tree.expandColumnKey ?? options.columns()[0]?.key ?? null;
+	});
+	const treeFixExpandColumnEarly = computed(() => options.treeConfig()?.fixExpandColumn !== false);
+	const columnsApi = useRsTableColumns({
+		columns: () => options.columns(),
+		columnOrder: () => options.columnOrder(),
+		defaultColumnOrder: options.defaultColumnOrder,
+		columnFilters: () => options.columnFilters(),
+		defaultColumnFilters: options.defaultColumnFilters,
+		initialColumnWidths: () => options.initialColumnWidths(),
+		resizable: () => options.resizable(),
+		columnLayout: () => options.columnLayout(),
+		treeMode: treeModeEarly,
+		treeFixExpandColumn: treeFixExpandColumnEarly,
+		treeExpandColumnKey: treeExpandColumnKeyEarly,
+		emit: options.emit
+	});
+	const resolvedSize = computed(() => resolveTableSize(options.compact() ?? false, options.size() ?? "md"));
+	const engine = useRsTableEngine({
+		data: () => options.data(),
+		displayColumns: () => columnsApi.displayColumns.value,
+		rowKey: () => options.rowKey(),
+		sort: () => options.sort(),
+		defaultSort: options.defaultSort,
+		sorts: () => options.sorts(),
+		defaultSorts: options.defaultSorts,
+		multiSort: () => options.multiSort(),
+		remoteSort: () => options.remoteSort(),
+		filterText: () => options.filterText(),
+		filterKeys: () => options.filterKeys(),
+		columnFilters: () => columnsApi.columnFiltersState.value,
+		groupBy: () => options.groupBy(),
+		groupLabel: () => options.groupLabel(),
+		treeConfig: () => options.treeConfig(),
+		expandable: () => options.expandable(),
+		rowExpandable: () => options.rowExpandable(),
+		selectedRowKeys: () => options.selectedRowKeys(),
+		defaultSelectedRowKeys: options.defaultSelectedRowKeys,
+		expandedRowKeys: () => options.expandedRowKeys(),
+		defaultExpandedRowKeys: options.defaultExpandedRowKeys,
+		rowSelectable: () => options.rowSelectable(),
+		size: resolvedSize,
+		emit: options.emit
+	});
+	/** 树表阈值粗算：不构建完整 entries，避免与 virtual 循环依赖 */
+	const tableEntriesForThreshold = computed(() => {
+		if (!options.treeConfig()) return options.data().length;
+		return flattenVisibleCountRough(options.data(), engine.expandedKeySet.value, {
+			childrenField: engine.treeChildrenField.value,
+			isLeafField: engine.treeIsLeafField.value,
+			lazy: engine.treeLazy.value,
+			rowKey: options.rowKey()
+		});
+	});
+	const scroll = useRsTableScrollLayout({
+		height: () => options.height(),
+		layoutActive: () => options.layoutActive(),
+		viewKey: () => options.viewKey()
+	});
+	const fixedRowHeight = computed(() => resolveTableRowHeight(resolvedSize.value, options.rowHeight()));
+	const virtual = useRsTableVirtual({
+		dataLength: () => options.data().length,
+		treeMode: engine.treeMode,
+		tableEntriesForThreshold,
+		virtual: () => options.virtual(),
+		virtualAutoThreshold: () => options.virtualAutoThreshold(),
+		fill: () => options.fill(),
+		infinite: () => options.infinite(),
+		virtualOnInfinite: () => options.virtualOnInfinite(),
+		overscan: () => options.overscan(),
+		expandRowHeight: () => options.expandRowHeight(),
+		scrollTop: scroll.scrollTop,
+		viewportHeight: scroll.viewportHeight,
+		fixedRowHeight,
+		tableEntries: () => engine.tableEntries.value
+	});
+	const analyticsSource = useRsTableSelectionSource({
+		viewRows: engine.viewRows,
+		selectedRows: engine.selectedRows
+	});
+	const tableSurface = useRsTable();
+	/** 列是否可筛选：只跟 columns 引用走，避免每次访问 .some */
+	const hasFilterableColumn = computed(() => options.columns().some((c) => c.filterable));
+	const builtinFeatureIds = computed(() => resolveBuiltinTableFeatures({
+		selectable: options.selectable(),
+		filterable: hasFilterableColumn.value,
+		virtual: options.virtual() === false ? false : options.virtual() ?? "auto",
+		editable: options.editable(),
+		tree: Boolean(options.treeConfig()),
+		contextMenu: options.contextMenu() !== false,
+		summary: options.summaryFeatureEnabled()
+	}));
+	/**
+	* Feature 重绑签名：builtin id 集合 + 实例 feature 的 id/setup 引用。
+	* 不监听 data/viewRows，避免滚动/选中拆掉 analytics 订阅。
+	*/
+	const featureBindSignature = computed(() => {
+		const extras = options.features() ?? [];
+		return [
+			builtinFeatureIds.value.join("\0"),
+			extras.length,
+			...extras.map((f) => f.id),
+			...extras.map((f) => f.setup)
+		];
+	});
+	let disposeTableFeatures = null;
+	watch(featureBindSignature, () => {
+		disposeTableFeatures?.();
+		disposeTableFeatures = tableSurface.bindFeatures({
+			builtinIds: builtinFeatureIds.value,
+			instanceFeatures: options.features() ?? null,
+			getViewRows: () => engine.viewRows.value,
+			getSelectedRows: () => engine.selectedRows.value,
+			getAnalyticsSnapshot: () => analyticsSource.getSnapshot(),
+			subscribeAnalytics: (listener) => analyticsSource.subscribe(listener)
+		});
+	}, { immediate: true });
+	onUnmounted(() => {
+		disposeTableFeatures?.();
+		disposeTableFeatures = null;
+	});
+	return {
+		resolvedSize,
+		fixedRowHeight,
+		tableEntriesForThreshold,
+		...columnsApi,
+		...engine,
+		...scroll,
+		...virtual,
+		analyticsSource,
+		tableSurface,
+		builtinFeatureIds
+	};
+}
+//#endregion
+export { useRsTableCore };

package/dist/components/table/src/composables/useRsTableEditActions.d.ts

@@ -0,0 +1,129 @@
+/**
+ * RsTable 编辑动作层：单元格提交、键盘导航、粘贴、行提交/回滚。
+ *
+ * 职责边界：
+ * - 做：编排 useTableEdit 状态机与业务 emit
+ * - 不做：草稿 Map 本身（useTableEdit）；虚拟滚动卸载行后草稿仍由 staged/editing 保留
+ *
+ * 性能约定：可编辑单元格列表仅在导航时构建，不在每次渲染扫描全表。
+ */
+import type { useTableEdit } from './useTableEdit';
+import { type RsTableCellNavigateDirection } from '../utils/table-edit-utils';
+import type { RsTableColumn, RsTableRowData, RsTableRowEntry } from '../utils/table-utils';
+type TableEditApi = ReturnType<typeof useTableEdit>;
+export interface UseRsTableEditActionsOptions<T extends RsTableRowData> {
+    tableEdit: TableEditApi;
+    editable: () => boolean;
+    editTrigger: () => 'click' | 'dblclick';
+    editKeyboard: () => boolean;
+    editUndo: () => boolean;
+    editPaste: () => boolean;
+    editBatch: () => boolean;
+    allowNull: () => boolean;
+    rowCommit: () => boolean;
+    selectable: () => boolean;
+    selectionType: () => string;
+    selectedRowKeys: () => string[];
+    displayColumns: () => RsTableColumn<T>[];
+    dataRows: () => Array<Extract<RsTableRowEntry<T>, {
+        type: 'row';
+    }>>;
+    rowKeyFor: (entry: Extract<RsTableRowEntry<T>, {
+        type: 'row';
+    }>) => string;
+    rowPending?: (row: T, index: number) => boolean;
+    applyRowClickHighlight: (rowKey: string) => void;
+    onRowClick: (entry: RsTableRowEntry<T>, event?: MouseEvent) => void;
+    onRowDblclick: (entry: RsTableRowEntry<T>, event?: MouseEvent) => void;
+    emit: {
+        cellView: (row: T, column: RsTableColumn<T>, index: number) => void;
+        cellEditStart: (row: T, column: RsTableColumn<T>, index: number) => void;
+        cellEditDialog: (row: T, column: RsTableColumn<T>, index: number, draft: string) => void;
+        cellEditCommit: (row: T, column: RsTableColumn<T>, index: number, value: unknown, previous: unknown) => void;
+        cellEditCancel: (row: T, column: RsTableColumn<T>, index: number) => void;
+        cellEditInvalid: (row: T, column: RsTableColumn<T>, index: number, message: string, value: unknown) => void;
+        cellEditBatchCommit: (column: RsTableColumn<T>, changes: Array<{
+            row: T;
+            index: number;
+            value: unknown;
+            previous: unknown;
+        }>) => void;
+        cellEditUndo: (entry: {
+            items: Array<{
+                rowKey: string;
+                colKey: string;
+                rowIndex: number;
+                previous: unknown;
+                next: unknown;
+            }>;
+        }) => void;
+        cellEditRedo: (entry: {
+            items: Array<{
+                rowKey: string;
+                colKey: string;
+                rowIndex: number;
+                previous: unknown;
+                next: unknown;
+            }>;
+        }) => void;
+        cellEditReject: (row: T, index: number, reason?: string) => void;
+        rowEditCommit: (row: T, index: number, changes: Array<{
+            colKey: string;
+            value: unknown;
+            previous: unknown;
+        }>) => void;
+        rowEditRollback: (row: T, index: number) => void;
+    };
+}
+/**
+ * 编辑交互 API。
+ */
+export declare function useRsTableEditActions<T extends RsTableRowData>(options: UseRsTableEditActionsOptions<T>): {
+    resolveColumnByKey: (colKey: string) => RsTableColumn<T> | undefined;
+    findRowEntryByKey: (rowKey: string) => Extract<RsTableRowEntry<T>, {
+        type: "row";
+    }> | undefined;
+    onCellStartEdit: (entry: Extract<RsTableRowEntry<T>, {
+        type: "row";
+    }>, colKey: string) => void;
+    onCellUpdateDraft: (_entry: Extract<RsTableRowEntry<T>, {
+        type: "row";
+    }>, _colKey: string, value: string) => void;
+    onCellCancelEdit: (entry: Extract<RsTableRowEntry<T>, {
+        type: "row";
+    }>, colKey: string) => void;
+    onCellCommitEdit: (entry: Extract<RsTableRowEntry<T>, {
+        type: "row";
+    }>, colKey: string, rawText: string, commitOptions?: {
+        navigate?: RsTableCellNavigateDirection;
+        skipUndo?: boolean;
+        skipBatch?: boolean;
+    }) => Promise<boolean>;
+    onCellNavigate: (entry: Extract<RsTableRowEntry<T>, {
+        type: "row";
+    }>, colKey: string, direction: RsTableCellNavigateDirection) => Promise<void>;
+    onCellClick: (entry: RsTableRowEntry<T>, colKey: string, event?: MouseEvent) => void;
+    onCellDblclick: (entry: RsTableRowEntry<T>, colKey: string, event?: MouseEvent) => void;
+    onEditUndo: () => void;
+    onEditRedo: () => void;
+    onTableKeydown: (event: KeyboardEvent) => void;
+    onTablePaste: (event: ClipboardEvent) => void;
+    rejectRowEdit: (rowKey: string, reason?: string) => void;
+    onRowCommitEdit: (entry: Extract<RsTableRowEntry<T>, {
+        type: "row";
+    }>) => Promise<void>;
+    onRowRollbackEdit: (entry: Extract<RsTableRowEntry<T>, {
+        type: "row";
+    }>) => void;
+    isExternalRowPending: (entry: Extract<RsTableRowEntry<T>, {
+        type: "row";
+    }>) => boolean;
+    rowEditPending: (entry: Extract<RsTableRowEntry<T>, {
+        type: "row";
+    }>) => boolean;
+    onGutterCommit: (entry: Extract<RsTableRowEntry<T>, {
+        type: "row";
+    }>) => void;
+};
+export type RsTableEditActionsApi<T extends RsTableRowData> = ReturnType<typeof useRsTableEditActions<T>>;
+export {};

package/dist/components/table/src/composables/useRsTableEditActions.js

@@ -0,0 +1,376 @@
+import { isBooleanToggleColumn, isCellValueChanged, isColumnEditable, isColumnNullable, isRowEditPending, listBatchColumnTargets, navigateEditableCell, nullToEditText, parseCellEditInput, parseClipboardGrid, resolveCellEditText, resolveColumnEditTrigger, resolveColumnEditorOptions, resolveColumnRawValue, validateCellValueAsync } from "../utils/table-edit-utils.js";
+//#region src/components/table/src/composables/useRsTableEditActions.ts
+/**
+* 编辑交互 API。
+*/
+function useRsTableEditActions(options) {
+	const { tableEdit, emit } = options;
+	function resolveColumnByKey(colKey) {
+		return options.displayColumns().find((column) => column.key === colKey);
+	}
+	function findRowEntryByKey(rowKey) {
+		return options.dataRows().find((item) => options.rowKeyFor(item) === rowKey);
+	}
+	/** 仅导航时调用；勿在模板渲染路径扫描 */
+	function buildEditableCellList() {
+		const result = [];
+		for (const entry of options.dataRows()) {
+			const rowKey = options.rowKeyFor(entry);
+			for (const column of options.displayColumns()) {
+				if (!isColumnEditable(column, entry.row, entry.rowIndex, options.editable())) continue;
+				result.push({
+					rowKey,
+					colKey: column.key,
+					rowIndex: entry.rowIndex
+				});
+			}
+		}
+		return result;
+	}
+	function onCellStartEdit(entry, colKey) {
+		const column = resolveColumnByKey(colKey);
+		if (!column) return;
+		if (isBooleanToggleColumn(column)) return;
+		if (!isColumnEditable(column, entry.row, entry.rowIndex, options.editable())) return;
+		const key = options.rowKeyFor(entry);
+		const initialText = resolveCellEditText(entry.row, column, entry.rowIndex, tableEdit.getDraft(key, colKey));
+		if (resolveColumnEditorOptions(column, entry.row, entry.rowIndex).presentation === "dialog") {
+			emit.cellEditDialog(entry.row, column, entry.rowIndex, initialText);
+			return;
+		}
+		tableEdit.startEdit({
+			rowKey: key,
+			colKey,
+			rowIndex: entry.rowIndex
+		}, initialText);
+		emit.cellEditStart(entry.row, column, entry.rowIndex);
+	}
+	function onCellUpdateDraft(_entry, _colKey, value) {
+		tableEdit.updateDraft(value);
+	}
+	function onCellCancelEdit(entry, colKey) {
+		const column = resolveColumnByKey(colKey);
+		tableEdit.cancelEdit();
+		if (column) emit.cellEditCancel(entry.row, column, entry.rowIndex);
+	}
+	function moveEditFocus(entry, colKey, direction, startEditNext) {
+		if (!options.editKeyboard()) return;
+		const next = navigateEditableCell(buildEditableCellList(), options.rowKeyFor(entry), colKey, direction, options.displayColumns().length || 1);
+		if (!next) return;
+		const nextEntry = findRowEntryByKey(next.rowKey);
+		if (!nextEntry) return;
+		tableEdit.setFocusCell(next);
+		options.applyRowClickHighlight(next.rowKey);
+		if (startEditNext) {
+			const column = resolveColumnByKey(next.colKey);
+			if (column && isBooleanToggleColumn(column)) return;
+			onCellStartEdit(nextEntry, next.colKey);
+		}
+	}
+	async function onCellCommitEdit(entry, colKey, rawText, commitOptions) {
+		const column = resolveColumnByKey(colKey);
+		if (!column) return false;
+		const allowNull = isColumnNullable(column, options.allowNull());
+		const parsed = parseCellEditInput(rawText, entry.row, column, entry.rowIndex, { allowNull });
+		const rowKey = options.rowKeyFor(entry);
+		tableEdit.setValidating(rowKey, colKey, true);
+		let error = null;
+		try {
+			error = await validateCellValueAsync(parsed, entry.row, column, entry.rowIndex);
+		} finally {
+			tableEdit.setValidating(rowKey, colKey, false);
+		}
+		if (error) {
+			tableEdit.updateDraft(rawText);
+			tableEdit.setCellError(rowKey, colKey, error);
+			emit.cellEditInvalid(entry.row, column, entry.rowIndex, error, parsed);
+			return false;
+		}
+		tableEdit.clearCellError(rowKey, colKey);
+		const targets = options.editBatch() && options.selectable() && options.selectionType() !== "radio" && !options.rowCommit() && !commitOptions?.skipBatch ? listBatchColumnTargets({
+			rows: options.dataRows().map((item) => ({
+				row: item.row,
+				rowIndex: item.rowIndex,
+				rowKey: options.rowKeyFor(item)
+			})),
+			column,
+			tableEditable: options.editable(),
+			selectedKeys: options.selectedRowKeys(),
+			anchorRowKey: rowKey
+		}) : [{
+			row: entry.row,
+			rowIndex: entry.rowIndex,
+			rowKey
+		}];
+		if (options.rowCommit()) {
+			const previous = resolveColumnRawValue(entry.row, column, entry.rowIndex);
+			if (!isCellValueChanged(previous, parsed)) {
+				tableEdit.unstageCell(rowKey, colKey);
+				tableEdit.cancelEdit();
+				if (commitOptions?.navigate) moveEditFocus(entry, colKey, commitOptions.navigate, false);
+				return true;
+			}
+			tableEdit.stageCell({
+				rowKey,
+				colKey,
+				rowIndex: entry.rowIndex,
+				draft: rawText,
+				original: previous
+			});
+			if (commitOptions?.navigate) moveEditFocus(entry, colKey, commitOptions.navigate, true);
+			return true;
+		}
+		tableEdit.cancelEdit();
+		const undoItems = [];
+		const batchChanges = [];
+		for (const target of targets) {
+			const previous = resolveColumnRawValue(target.row, column, target.rowIndex);
+			if (!isCellValueChanged(previous, parsed)) continue;
+			undoItems.push({
+				rowKey: target.rowKey,
+				colKey,
+				rowIndex: target.rowIndex,
+				previous,
+				next: parsed
+			});
+			batchChanges.push({
+				row: target.row,
+				index: target.rowIndex,
+				value: parsed,
+				previous
+			});
+			emit.cellEditCommit(target.row, column, target.rowIndex, parsed, previous);
+		}
+		if (batchChanges.length > 1) emit.cellEditBatchCommit(column, batchChanges);
+		if (!commitOptions?.skipUndo && options.editUndo() && undoItems.length) tableEdit.pushUndo({ items: undoItems });
+		if (commitOptions?.navigate) moveEditFocus(entry, colKey, commitOptions.navigate, true);
+		return true;
+	}
+	async function onCellNavigate(entry, colKey, direction) {
+		const draft = tableEdit.editingDraft.value;
+		await onCellCommitEdit(entry, colKey, draft, { navigate: direction });
+	}
+	function onCellClick(entry, colKey, event) {
+		if (entry.type !== "row") return;
+		options.onRowClick(entry, event);
+		if (!resolveColumnByKey(colKey)) return;
+		tableEdit.setFocusCell({
+			rowKey: options.rowKeyFor(entry),
+			colKey,
+			rowIndex: entry.rowIndex
+		});
+	}
+	function onCellDblclick(entry, colKey, event) {
+		if (entry.type !== "row") return;
+		const column = resolveColumnByKey(colKey);
+		if (column && options.editable() && resolveColumnEditTrigger(column, options.editTrigger()) === "dblclick" && isColumnEditable(column, entry.row, entry.rowIndex, options.editable()) && !isBooleanToggleColumn(column)) {
+			onCellStartEdit(entry, colKey);
+			return;
+		}
+		if (column) emit.cellView(entry.row, column, entry.rowIndex);
+		options.onRowDblclick(entry, event);
+	}
+	function applyUndoRedoValue(entry, colKey, value) {
+		const column = resolveColumnByKey(colKey);
+		if (!column) return;
+		const previous = resolveColumnRawValue(entry.row, column, entry.rowIndex);
+		emit.cellEditCommit(entry.row, column, entry.rowIndex, value, previous);
+	}
+	function onEditUndo() {
+		if (!options.editUndo()) return;
+		const entry = tableEdit.undo();
+		if (!entry) return;
+		for (const item of entry.items) {
+			const rowEntry = findRowEntryByKey(item.rowKey);
+			if (!rowEntry) continue;
+			applyUndoRedoValue(rowEntry, item.colKey, item.previous);
+		}
+		emit.cellEditUndo(entry);
+	}
+	function onEditRedo() {
+		if (!options.editUndo()) return;
+		const entry = tableEdit.redo();
+		if (!entry) return;
+		for (const item of entry.items) {
+			const rowEntry = findRowEntryByKey(item.rowKey);
+			if (!rowEntry) continue;
+			applyUndoRedoValue(rowEntry, item.colKey, item.next);
+		}
+		emit.cellEditRedo(entry);
+	}
+	function coerceBooleanFromRow(entry, column) {
+		const raw = resolveColumnRawValue(entry.row, column, entry.rowIndex);
+		if (raw == null) return false;
+		if (typeof raw === "boolean") return raw;
+		return String(raw).toLowerCase() === "true" || raw === 1 || raw === "1";
+	}
+	function onTableKeydown(event) {
+		if (!options.editable() || !options.editKeyboard()) return;
+		if (event.target?.closest("input, textarea, select, [contenteditable=\"true\"]")) {
+			if ((event.ctrlKey || event.metaKey) && event.key.toLowerCase() === "z" && !event.shiftKey) {
+				if (!tableEdit.editingCell.value) {
+					event.preventDefault();
+					onEditUndo();
+				}
+			}
+			if ((event.ctrlKey || event.metaKey) && (event.key.toLowerCase() === "y" || event.key.toLowerCase() === "z" && event.shiftKey)) {
+				if (!tableEdit.editingCell.value) {
+					event.preventDefault();
+					onEditRedo();
+				}
+			}
+			return;
+		}
+		if ((event.ctrlKey || event.metaKey) && event.key.toLowerCase() === "z" && !event.shiftKey) {
+			event.preventDefault();
+			onEditUndo();
+			return;
+		}
+		if ((event.ctrlKey || event.metaKey) && (event.key.toLowerCase() === "y" || event.key.toLowerCase() === "z" && event.shiftKey)) {
+			event.preventDefault();
+			onEditRedo();
+			return;
+		}
+		const focus = tableEdit.focusCell.value;
+		if (!focus) return;
+		const entry = findRowEntryByKey(focus.rowKey);
+		if (!entry) return;
+		const column = resolveColumnByKey(focus.colKey);
+		if (!column) return;
+		if (event.key === "F2" || event.key === "Enter") {
+			event.preventDefault();
+			if (isBooleanToggleColumn(column)) {
+				const next = !coerceBooleanFromRow(entry, column);
+				onCellCommitEdit(entry, focus.colKey, next ? "true" : "false");
+				return;
+			}
+			onCellStartEdit(entry, focus.colKey);
+			return;
+		}
+		if (event.key === "Escape") {
+			event.preventDefault();
+			tableEdit.cancelEdit();
+			return;
+		}
+		if (event.key === "Delete" || event.key === "Backspace") {
+			if (!isColumnEditable(column, entry.row, entry.rowIndex, options.editable())) return;
+			event.preventDefault();
+			const allowNull = isColumnNullable(column, options.allowNull());
+			onCellCommitEdit(entry, focus.colKey, allowNull ? nullToEditText() : "");
+			return;
+		}
+		if (event.key === "Tab") {
+			event.preventDefault();
+			moveEditFocus(entry, focus.colKey, event.shiftKey ? "prev" : "next", false);
+		}
+	}
+	function onTablePaste(event) {
+		if (!options.editable() || !options.editPaste()) return;
+		if (tableEdit.editingCell.value) return;
+		const focus = tableEdit.focusCell.value;
+		if (!focus) return;
+		const text = event.clipboardData?.getData("text/plain");
+		if (!text) return;
+		const grid = parseClipboardGrid(text);
+		if (!grid.length) return;
+		event.preventDefault();
+		if (!findRowEntryByKey(focus.rowKey)) return;
+		const rows = options.dataRows();
+		const startRowPos = rows.findIndex((item) => options.rowKeyFor(item) === focus.rowKey);
+		const cols = options.displayColumns();
+		const startColIndex = cols.findIndex((column) => column.key === focus.colKey);
+		if (startRowPos < 0 || startColIndex < 0) return;
+		for (let r = 0; r < grid.length; r += 1) {
+			const rowEntry = rows[startRowPos + r];
+			if (!rowEntry) break;
+			const line = grid[r] ?? [];
+			for (let c = 0; c < line.length; c += 1) {
+				const column = cols[startColIndex + c];
+				if (!column) break;
+				if (!isColumnEditable(column, rowEntry.row, rowEntry.rowIndex, options.editable())) continue;
+				onCellCommitEdit(rowEntry, column.key, line[c] ?? "");
+			}
+		}
+	}
+	function rejectRowEdit(rowKey, reason) {
+		const entry = findRowEntryByKey(rowKey);
+		tableEdit.rollbackRow(rowKey);
+		if (entry) emit.cellEditReject(entry.row, entry.rowIndex, reason);
+	}
+	async function onRowCommitEdit(entry) {
+		const rowKey = options.rowKeyFor(entry);
+		const editing = tableEdit.editingCell.value;
+		if (editing?.rowKey === rowKey) {
+			if (!await onCellCommitEdit(entry, editing.colKey, tableEdit.editingDraft.value)) return;
+		}
+		const staged = tableEdit.commitRow(rowKey);
+		if (!staged.length) return;
+		const changes = staged.map((item) => {
+			const column = resolveColumnByKey(item.colKey);
+			const allowNull = column ? isColumnNullable(column, options.allowNull()) : options.allowNull();
+			const value = column ? parseCellEditInput(item.draft, entry.row, column, entry.rowIndex, { allowNull }) : item.draft;
+			return {
+				colKey: item.colKey,
+				value,
+				previous: item.original
+			};
+		});
+		emit.rowEditCommit(entry.row, entry.rowIndex, changes);
+	}
+	function isExternalRowPending(entry) {
+		return Boolean(options.rowPending?.(entry.row, entry.rowIndex));
+	}
+	function onRowRollbackEdit(entry) {
+		if (!options.rowCommit() && isExternalRowPending(entry)) {
+			emit.rowEditRollback(entry.row, entry.rowIndex);
+			return;
+		}
+		tableEdit.rollbackRow(options.rowKeyFor(entry));
+		emit.rowEditRollback(entry.row, entry.rowIndex);
+	}
+	function rowEditPending(entry) {
+		if (isExternalRowPending(entry)) return true;
+		return isRowEditPending(options.rowKeyFor(entry), entry.row, entry.rowIndex, {
+			isRowDirty: tableEdit.isRowDirty,
+			editingCell: tableEdit.editingCell.value,
+			editingDraft: tableEdit.editingDraft.value,
+			resolveColumn: resolveColumnByKey
+		});
+	}
+	function onGutterCommit(entry) {
+		if (options.rowCommit()) {
+			onRowCommitEdit(entry);
+			return;
+		}
+		if (isExternalRowPending(entry)) {
+			emit.rowEditCommit(entry.row, entry.rowIndex, []);
+			return;
+		}
+		const editing = tableEdit.editingCell.value;
+		if (editing?.rowKey !== options.rowKeyFor(entry)) return;
+		onCellCommitEdit(entry, editing.colKey, tableEdit.editingDraft.value);
+	}
+	return {
+		resolveColumnByKey,
+		findRowEntryByKey,
+		onCellStartEdit,
+		onCellUpdateDraft,
+		onCellCancelEdit,
+		onCellCommitEdit,
+		onCellNavigate,
+		onCellClick,
+		onCellDblclick,
+		onEditUndo,
+		onEditRedo,
+		onTableKeydown,
+		onTablePaste,
+		rejectRowEdit,
+		onRowCommitEdit,
+		onRowRollbackEdit,
+		isExternalRowPending,
+		rowEditPending,
+		onGutterCommit
+	};
+}
+//#endregion
+export { useRsTableEditActions };