ensis-ui 0.0.0-stage → 3.0.0

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

@@ -0,0 +1,176 @@
+import { makeCellKey } from "../context/table-keys.js";
+import { ref, shallowRef } from "vue";
+//#region src/components/table/src/composables/useTableEdit.ts
+function useTableEdit(options) {
+	const editingCell = ref(null);
+	const editingDraft = ref("");
+	const focusCell = ref(null);
+	const stagedMap = shallowRef(/* @__PURE__ */ new Map());
+	const errorMap = shallowRef(/* @__PURE__ */ new Map());
+	const validatingMap = shallowRef(/* @__PURE__ */ new Map());
+	const undoStack = shallowRef([]);
+	const redoStack = shallowRef([]);
+	function isEditing(rowKey, colKey) {
+		const active = editingCell.value;
+		return active?.rowKey === rowKey && active.colKey === colKey;
+	}
+	function isFocused(rowKey, colKey) {
+		const active = focusCell.value;
+		return active?.rowKey === rowKey && active.colKey === colKey;
+	}
+	function getDraft(rowKey, colKey) {
+		const staged = stagedMap.value.get(makeCellKey(rowKey, colKey));
+		if (staged) return staged.draft;
+		if (isEditing(rowKey, colKey)) return editingDraft.value;
+	}
+	function isDirty(rowKey, colKey) {
+		return stagedMap.value.has(makeCellKey(rowKey, colKey));
+	}
+	function getRowStagedCells(rowKey) {
+		return [...stagedMap.value.values()].filter((item) => item.rowKey === rowKey);
+	}
+	function isRowDirty(rowKey) {
+		return getRowStagedCells(rowKey).length > 0;
+	}
+	function getCellError(rowKey, colKey) {
+		return errorMap.value.get(makeCellKey(rowKey, colKey));
+	}
+	function setCellError(rowKey, colKey, message) {
+		const key = makeCellKey(rowKey, colKey);
+		const next = new Map(errorMap.value);
+		if (!message) next.delete(key);
+		else next.set(key, message);
+		errorMap.value = next;
+	}
+	function clearCellError(rowKey, colKey) {
+		setCellError(rowKey, colKey, null);
+	}
+	function isValidating(rowKey, colKey) {
+		return validatingMap.value.get(makeCellKey(rowKey, colKey)) === true;
+	}
+	function setValidating(rowKey, colKey, value) {
+		const key = makeCellKey(rowKey, colKey);
+		const next = new Map(validatingMap.value);
+		if (!value) next.delete(key);
+		else next.set(key, true);
+		validatingMap.value = next;
+	}
+	function startEdit(cell, initialText) {
+		if (!options.enabled()) return;
+		editingCell.value = cell;
+		focusCell.value = cell;
+		const staged = stagedMap.value.get(makeCellKey(cell.rowKey, cell.colKey));
+		editingDraft.value = staged?.draft ?? initialText;
+		clearCellError(cell.rowKey, cell.colKey);
+	}
+	function updateDraft(text) {
+		if (!editingCell.value) return;
+		editingDraft.value = text;
+	}
+	function cancelEdit() {
+		editingCell.value = null;
+		editingDraft.value = "";
+	}
+	function cancelAll() {
+		editingCell.value = null;
+		editingDraft.value = "";
+		stagedMap.value = /* @__PURE__ */ new Map();
+		errorMap.value = /* @__PURE__ */ new Map();
+		validatingMap.value = /* @__PURE__ */ new Map();
+	}
+	function setFocusCell(cell) {
+		focusCell.value = cell;
+	}
+	function stageCell(cell) {
+		const key = makeCellKey(cell.rowKey, cell.colKey);
+		const next = new Map(stagedMap.value);
+		next.set(key, cell);
+		stagedMap.value = next;
+		clearCellError(cell.rowKey, cell.colKey);
+		if (editingCell.value?.rowKey === cell.rowKey && editingCell.value.colKey === cell.colKey) {
+			editingCell.value = null;
+			editingDraft.value = "";
+		}
+	}
+	function removeStagedKeys(keys) {
+		if (!keys.length) return;
+		const next = new Map(stagedMap.value);
+		for (const key of keys) next.delete(key);
+		stagedMap.value = next;
+	}
+	function unstageCell(rowKey, colKey) {
+		removeStagedKeys([makeCellKey(rowKey, colKey)]);
+	}
+	function rollbackRow(rowKey) {
+		removeStagedKeys([...stagedMap.value.keys()].filter((key) => key.startsWith(`${rowKey}:`)));
+		const errNext = new Map(errorMap.value);
+		for (const key of [...errNext.keys()]) if (key.startsWith(`${rowKey}:`)) errNext.delete(key);
+		errorMap.value = errNext;
+		if (editingCell.value?.rowKey === rowKey) cancelEdit();
+	}
+	function commitRow(rowKey) {
+		const changes = getRowStagedCells(rowKey);
+		rollbackRow(rowKey);
+		return changes;
+	}
+	function normalizeUndo(entry) {
+		if ("items" in entry) return entry;
+		return { items: [entry] };
+	}
+	function pushUndo(entry) {
+		const limit = options.undoLimit?.() ?? 50;
+		undoStack.value = [...undoStack.value, normalizeUndo(entry)].slice(-Math.max(1, limit));
+		redoStack.value = [];
+	}
+	function undo() {
+		const stack = undoStack.value;
+		if (!stack.length) return null;
+		const entry = stack[stack.length - 1];
+		undoStack.value = stack.slice(0, -1);
+		redoStack.value = [...redoStack.value, entry];
+		return entry;
+	}
+	function redo() {
+		const stack = redoStack.value;
+		if (!stack.length) return null;
+		const entry = stack[stack.length - 1];
+		redoStack.value = stack.slice(0, -1);
+		undoStack.value = [...undoStack.value, entry];
+		return entry;
+	}
+	return {
+		editingCell,
+		editingDraft,
+		focusCell,
+		stagedMap,
+		errorMap,
+		validatingMap,
+		undoStack,
+		redoStack,
+		isEditing,
+		isFocused,
+		getDraft,
+		isDirty,
+		isRowDirty,
+		getCellError,
+		setCellError,
+		clearCellError,
+		isValidating,
+		setValidating,
+		getRowStagedCells,
+		startEdit,
+		updateDraft,
+		cancelEdit,
+		cancelAll,
+		setFocusCell,
+		stageCell,
+		unstageCell,
+		rollbackRow,
+		commitRow,
+		pushUndo,
+		undo,
+		redo
+	};
+}
+//#endregion
+export { useTableEdit };

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

@@ -0,0 +1,14 @@
+import { type ComputedRef } from 'vue';
+export declare function useTableRowHighlight(options: {
+    enabled: () => boolean;
+    highlightRowOnClick: () => boolean;
+    isControlled: () => boolean;
+    highlightedRowKey: () => string | undefined;
+    defaultHighlightedRowKey: () => string | undefined;
+    onUpdate: (value: string | undefined) => void;
+}): {
+    highlightedKey: ComputedRef<string | undefined>;
+    setHighlightedKey: (value: string | undefined) => void;
+    isHighlighted: (rowKey: string) => boolean;
+    applyRowClickHighlight: (rowKey: string) => void;
+};

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

@@ -0,0 +1,35 @@
+import { computed, ref } from "vue";
+//#region src/components/table/src/composables/useTableRowHighlight.ts
+function useTableRowHighlight(options) {
+	const internalHighlightedKey = ref(options.defaultHighlightedRowKey());
+	const highlightedKey = computed({
+		get: () => options.isControlled() ? options.highlightedRowKey() : internalHighlightedKey.value,
+		set: (value) => {
+			if (options.isControlled()) {
+				options.onUpdate(value);
+				return;
+			}
+			internalHighlightedKey.value = value;
+			options.onUpdate(value);
+		}
+	});
+	function setHighlightedKey(value) {
+		highlightedKey.value = value;
+	}
+	function isHighlighted(rowKey) {
+		if (!options.enabled()) return false;
+		return highlightedKey.value === rowKey;
+	}
+	function applyRowClickHighlight(rowKey) {
+		if (!options.enabled() || !options.highlightRowOnClick()) return;
+		setHighlightedKey(rowKey);
+	}
+	return {
+		highlightedKey,
+		setHighlightedKey,
+		isHighlighted,
+		applyRowClickHighlight
+	};
+}
+//#endregion
+export { useTableRowHighlight };

package/dist/components/table/src/context/rs-table-module-registry.d.ts

@@ -0,0 +1,37 @@
+/**
+ * RsTable 模块注册表（对标 AG Grid ModuleRegistry）。
+ *
+ * - 全局 register：所有表格实例默认挂载（同页多表会共享这些模块）
+ * - 实例 props.features：仅该实例；同 id 覆盖全局
+ * - 不改内核渲染；模块通过 Feature.setup 订阅/贡献
+ * - 多表隔离要点：选中/编辑/ViewContext 仍是实例私有；仅 Registry 是全局点
+ */
+import type { RsTableFeature } from '../features/table-features';
+import type { RsTableRowData } from '../utils/table-utils';
+/**
+ * 全局模块注册表。
+ *
+ * @example
+ * ```ts
+ * RsTableModuleRegistry.register(
+ *   createAnalyticsTableFeature({ onSnapshot: (s) => syncCharts(s) }),
+ * )
+ * ```
+ */
+export declare const RsTableModuleRegistry: {
+    /**
+     * 注册全局 feature（幂等：同 id 覆盖）。
+     */
+    register<T extends RsTableRowData>(feature: RsTableFeature<T>): void;
+    /** 按 id 注销全局模块 */
+    unregister(id: string): void;
+    /** 清空（测试用） */
+    clear(): void;
+    /** 当前全局模块快照（浅拷贝） */
+    getModules<T extends RsTableRowData = object>(): RsTableFeature<T>[];
+    listIds(): string[];
+};
+/**
+ * 合并全局模块 + 实例 features（实例同 id 覆盖全局）。
+ */
+export declare function resolveInstanceFeatures<T extends RsTableRowData>(instanceFeatures?: RsTableFeature<T>[] | null): RsTableFeature<T>[];

package/dist/components/table/src/context/rs-table-module-registry.js

@@ -0,0 +1,51 @@
+//#region src/components/table/src/context/rs-table-module-registry.ts
+var globalModules = [];
+/**
+* 全局模块注册表。
+*
+* @example
+* ```ts
+* RsTableModuleRegistry.register(
+*   createAnalyticsTableFeature({ onSnapshot: (s) => syncCharts(s) }),
+* )
+* ```
+*/
+var RsTableModuleRegistry = {
+	/**
+	* 注册全局 feature（幂等：同 id 覆盖）。
+	*/
+	register(feature) {
+		const id = feature.id;
+		const idx = globalModules.findIndex((item) => item.id === id);
+		const next = feature;
+		if (idx >= 0) globalModules[idx] = next;
+		else globalModules.push(next);
+	},
+	/** 按 id 注销全局模块 */
+	unregister(id) {
+		const idx = globalModules.findIndex((item) => item.id === id);
+		if (idx >= 0) globalModules.splice(idx, 1);
+	},
+	/** 清空（测试用） */
+	clear() {
+		globalModules.length = 0;
+	},
+	/** 当前全局模块快照（浅拷贝） */
+	getModules() {
+		return [...globalModules];
+	},
+	listIds() {
+		return globalModules.map((item) => item.id);
+	}
+};
+/**
+* 合并全局模块 + 实例 features（实例同 id 覆盖全局）。
+*/
+function resolveInstanceFeatures(instanceFeatures) {
+	const map = /* @__PURE__ */ new Map();
+	for (const feature of RsTableModuleRegistry.getModules()) map.set(feature.id, feature);
+	for (const feature of instanceFeatures ?? []) map.set(feature.id, feature);
+	return [...map.values()];
+}
+//#endregion
+export { RsTableModuleRegistry, resolveInstanceFeatures };

package/dist/components/table/src/context/rs-table-view-context.d.ts

@@ -0,0 +1,218 @@
+/**
+ * RsTable 视图上下文（provide/inject）。
+ *
+ * 多表隔离（关键）：
+ * - 每个 RsTable 实例在自身 setup 内 provide，子树 inject 最近祖先
+ * - 同页多表互不影响：A 的 Header/Body 不会读到 B 的 view
+ * - 禁止把 view 存到模块级单例；instanceId 仅用于诊断
+ *
+ * 对比：RsTableModuleRegistry 是进程级全局（同 AG Grid ModuleRegistry），
+ * 会作用于所有实例；实例专属能力请用 props.features。
+ */
+import { type InjectionKey } from 'vue';
+import type { CSSProperties } from 'vue';
+import type { RsTableColumn, RsTableRowData, RsTableRowDropPosition, RsTableRowEntry, RsTableRowKey, RsTableSelectionType } from '../utils/table-utils';
+import type { RsTableCellEditFocusMode, RsTableCellEditTrigger, RsTableCellNavigateDirection } from '../utils/table-edit-utils';
+export declare const RS_TABLE_VIEW_KEY: InjectionKey<RsTableViewContext>;
+/** 视图层内联样式（Vue CSSProperties 或普通字符串字典） */
+export type RsTableViewStyle = CSSProperties | Record<string, string> | undefined;
+export type RsTableHeaderLabels = {
+    selectAll: string;
+    index: string;
+    rowStatus: string;
+    dragColumn: string;
+    filterColumn: string;
+    filterPlaceholder: string;
+    filterClear: string;
+    filterApply: string;
+};
+export type RsTableBodyLabels = {
+    loading: string;
+    empty: string;
+    loadingMore: string;
+    dragRow: string;
+    expandRow: string;
+    collapseRow: string;
+    selectRow: string;
+    rowCommit: string;
+    rowRollback: string;
+    gutterCommit: string;
+};
+type RowEntry<T extends RsTableRowData> = Extract<RsTableRowEntry<T>, {
+    type: 'row';
+}>;
+/**
+ * 视图只读状态 + 事件处理。
+ * 状态字段经 getter 暴露，子组件 render 访问时收集依赖；多表各自刷新、互不串扰。
+ */
+export interface RsTableViewContext<T extends RsTableRowData = RsTableRowData> {
+    readonly instanceId: string;
+    readonly useFixedColumnLayout: boolean;
+    readonly showRowDragHandle: boolean;
+    readonly detailExpandable: boolean;
+    readonly showSelectColumn: boolean;
+    readonly showEditGutterColumn: boolean;
+    readonly showIndexColumn: boolean;
+    readonly showRowStatusColumn: boolean;
+    readonly columnPadLeft: number;
+    readonly columnPadRight: number;
+    readonly visibleDataColumns: RsTableColumn<T>[];
+    readonly prefixWidths: {
+        drag: number;
+        expand: number;
+        select: number;
+        status: number;
+    };
+    readonly resolvedGutterWidth: number;
+    readonly resolvedIndexWidth: number;
+    resolvedDataColumnWidth: (key: string, fallback?: number | string) => number;
+    readonly isRadioSelection: boolean;
+    readonly selectAllState: 'checked' | 'indeterminate' | 'unchecked';
+    readonly columnDraggable: boolean;
+    readonly resizable: boolean;
+    readonly multiSort: boolean;
+    readonly columnFiltersState: Record<string, string>;
+    readonly dragColumnKey: string | null;
+    readonly dropColumnKey: string | null;
+    readonly dragLeadHeaderStyle: RsTableViewStyle;
+    readonly expandLeadHeaderStyle: RsTableViewStyle;
+    readonly selectLeadHeaderStyle: RsTableViewStyle;
+    readonly gutterLeadHeaderStyle: RsTableViewStyle;
+    readonly indexLeadHeaderStyle: RsTableViewStyle;
+    readonly columnHeaderStyleMap: Map<string, Record<string, string> | undefined>;
+    readonly headerLabels: RsTableHeaderLabels;
+    columnFilterValue: (key: string) => string;
+    isColumnFilterActive: (filters: Record<string, string>, key: string) => boolean;
+    sortOrderFor: (key: string) => string | null | undefined;
+    sortPriorityFor: (key: string) => number;
+    sortIconName: (key: string) => string;
+    onToggleSelectAll: () => void;
+    onColumnDragOver: (key: string, event: DragEvent) => void;
+    onColumnDrop: (key: string, event: DragEvent) => void;
+    onColumnDragStart: (key: string, event: DragEvent) => void;
+    onColumnDragEnd: () => void;
+    updateColumnFilter: (key: string, value: string) => void;
+    onHeaderClick: (column: RsTableColumn<T>) => void;
+    onResizeStart: (key: string, event: MouseEvent) => void;
+    onHeaderPointerOver: (event: PointerEvent) => void;
+    onHeaderPointerOut: (event: PointerEvent) => void;
+    readonly loading: boolean;
+    readonly hasData: boolean;
+    readonly loadingMore: boolean;
+    readonly infinite: boolean;
+    readonly bodyColspan: number;
+    readonly emptyContentStyle: RsTableViewStyle;
+    readonly virtualScrollEnabled: boolean;
+    readonly virtualSlice: {
+        paddingTop: number;
+        paddingBottom: number;
+    };
+    readonly visibleEntries: RsTableRowEntry<T>[];
+    readonly rowKey: RsTableRowKey<T> | undefined;
+    readonly treeMode: boolean;
+    readonly treeIndentPx: number;
+    readonly treeExpandColumnKey: string | null;
+    readonly treeLoadingKeySet: Set<string>;
+    readonly striped: boolean;
+    readonly selectionType: RsTableSelectionType;
+    readonly editable: boolean;
+    readonly editTrigger: RsTableCellEditTrigger;
+    readonly rowCommit: boolean;
+    readonly allowNull: boolean;
+    readonly editFocusMode: RsTableCellEditFocusMode;
+    readonly nullLabel: string;
+    readonly dragLeadStyle: Record<string, string>;
+    readonly expandLeadStyle: Record<string, string>;
+    readonly selectLeadStyle: Record<string, string>;
+    readonly indexLeadStyle: Record<string, string>;
+    readonly gutterLeadStyle: Record<string, string>;
+    readonly columnTdClassMap: Map<string, string[]>;
+    readonly columnStyleMap: Map<string, Record<string, string> | undefined>;
+    readonly dragRowKeys: string[];
+    readonly dropRowTargetKey: string | null;
+    readonly dropRowPosition: RsTableRowDropPosition | null;
+    readonly activeEditCellKey: string;
+    readonly activeFocusCellKey: string;
+    readonly activeErrorMapSize: number;
+    readonly activeValidatingMapSize: number;
+    readonly stagedMapSize: number;
+    readonly editingDraft: string;
+    readonly editingCell: {
+        rowKey: string;
+        colKey: string;
+    } | null;
+    readonly focusCell: {
+        rowKey: string;
+        colKey: string;
+    } | null;
+    readonly bodyLabels: RsTableBodyLabels;
+    rowKeyFor: (entry: RowEntry<T>) => string;
+    isRowSelected: (entry: RowEntry<T>) => boolean;
+    isRowIndeterminate: (entry: RowEntry<T>) => boolean;
+    isRowExpanded: (entry: RowEntry<T>) => boolean;
+    isHighlighted: (rowKey: string) => boolean;
+    rowEditPending: (entry: RowEntry<T>) => boolean;
+    isExternalRowPending: (entry: RowEntry<T>) => boolean;
+    treeDepthOf: (entry: RowEntry<T>) => number;
+    canExpandRow: (entry: RowEntry<T>) => boolean;
+    canSelectRow: (entry: RowEntry<T>) => boolean;
+    isRowDragByRow: (entry: RowEntry<T>) => boolean;
+    isRowDragging: (entry: RowEntry<T>) => boolean;
+    isRowDropTarget: (entry: RowEntry<T>) => boolean;
+    isRowDirty: (rowKey: string) => boolean;
+    hasColumnSlot: (key: string) => boolean;
+    hasEditSlot: (key: string) => boolean;
+    cellTooltipEnabled: (column: RsTableColumn<T>, rowIndex: number) => boolean;
+    cellTooltipMode: (column: RsTableColumn<T>, rowIndex: number) => string | undefined;
+    cellTooltipText: (column: RsTableColumn<T>, row: T, rowIndex: number) => string | undefined;
+    cellTooltipFallbackTitle: (column: RsTableColumn<T>, row: T, rowIndex: number) => string | undefined;
+    getCellDraft: (rowKey: string, colKey: string) => string | undefined;
+    isCellDirty: (rowKey: string, colKey: string) => boolean;
+    getCellError: (rowKey: string, colKey: string) => string | undefined;
+    isCellValidating: (rowKey: string, colKey: string) => boolean;
+    onBodyPointerOver: (event: PointerEvent) => void;
+    onBodyPointerOut: (event: PointerEvent) => void;
+    onRowClick: (entry: RowEntry<T>, event: MouseEvent) => void;
+    onRowSelectMouseDown: (event: MouseEvent) => void;
+    onCellClick: (entry: RowEntry<T>, colKey: string, event: MouseEvent) => void;
+    onCellDblclick: (entry: RowEntry<T>, colKey: string, event: MouseEvent) => void;
+    onCellContextmenu: (entry: RowEntry<T>, colKey: string, event: MouseEvent) => void;
+    onRowDblclick: (entry: RowEntry<T>, event: MouseEvent) => void;
+    onRowContextmenu: (entry: RowEntry<T>, event: MouseEvent) => void;
+    onRowDragOver: (entry: RowEntry<T>, event: DragEvent) => void;
+    onRowDragLeave: (event: DragEvent) => void;
+    onRowDrop: (entry: RowEntry<T>, event: DragEvent) => void;
+    onRowDragStart: (entry: RowEntry<T>, event: DragEvent) => void;
+    onRowDragEnd: () => void;
+    onToggleExpand: (entry: RowEntry<T>) => void;
+    onToggleSelect: (entry: RowEntry<T>) => void;
+    onCellStartEdit: (entry: RowEntry<T>, colKey: string) => void;
+    onCellCommit: (entry: RowEntry<T>, colKey: string, value: string) => void;
+    onCellCancel: (entry: RowEntry<T>, colKey: string) => void;
+    onCellUpdateDraft: (entry: RowEntry<T>, colKey: string, value: string) => void;
+    onCellNavigate: (entry: RowEntry<T>, colKey: string, direction: RsTableCellNavigateDirection) => void;
+    onRowCommit: (entry: RowEntry<T>) => void;
+    onRowRollback: (entry: RowEntry<T>) => void;
+    onGutterCommit: (entry: RowEntry<T>) => void;
+}
+/**
+ * 显式区分 state getters 与 handlers，避免把零参 handler 误当成状态 getter。
+ */
+export declare function createRsTableViewContext<T extends RsTableRowData>(parts: {
+    state: {
+        [K in keyof RsTableViewContext<T>]?: () => RsTableViewContext<T>[K];
+    };
+    handlers: {
+        [K in keyof RsTableViewContext<T>]?: RsTableViewContext<T>[K];
+    };
+}): RsTableViewContext<T>;
+/** 在 RsTable 内 provide（每个实例调用一次） */
+export declare function provideRsTableView<T extends RsTableRowData>(ctx: RsTableViewContext<T>): void;
+/**
+ * 子视图 inject；必须在某个 RsTable 子树内。
+ * 多表场景下自动绑定到最近的表格实例。
+ */
+export declare function useRsTableView<T extends RsTableRowData = RsTableRowData>(): RsTableViewContext<T>;
+/** 测试用：重置 instance 序号 */
+export declare function resetRsTableViewInstanceSeqForTest(): void;
+export {};

package/dist/components/table/src/context/rs-table-view-context.js

@@ -0,0 +1,47 @@
+import { inject, provide } from "vue";
+//#region src/components/table/src/context/rs-table-view-context.ts
+/**
+* RsTable 视图上下文（provide/inject）。
+*
+* 多表隔离（关键）：
+* - 每个 RsTable 实例在自身 setup 内 provide，子树 inject 最近祖先
+* - 同页多表互不影响：A 的 Header/Body 不会读到 B 的 view
+* - 禁止把 view 存到模块级单例；instanceId 仅用于诊断
+*
+* 对比：RsTableModuleRegistry 是进程级全局（同 AG Grid ModuleRegistry），
+* 会作用于所有实例；实例专属能力请用 props.features。
+*/
+/** 每实例递增，仅诊断用，不参与业务逻辑 */
+var viewInstanceSeq = 0;
+var RS_TABLE_VIEW_KEY = Symbol("rsTableView");
+/**
+* 显式区分 state getters 与 handlers，避免把零参 handler 误当成状态 getter。
+*/
+function createRsTableViewContext(parts) {
+	const ctx = { instanceId: `rs-table-view-${++viewInstanceSeq}` };
+	for (const [key, getter] of Object.entries(parts.state)) {
+		if (!getter) continue;
+		Object.defineProperty(ctx, key, {
+			enumerable: true,
+			configurable: true,
+			get: getter
+		});
+	}
+	for (const [key, fn] of Object.entries(parts.handlers)) if (fn !== void 0) ctx[key] = fn;
+	return ctx;
+}
+/** 在 RsTable 内 provide（每个实例调用一次） */
+function provideRsTableView(ctx) {
+	provide(RS_TABLE_VIEW_KEY, ctx);
+}
+/**
+* 子视图 inject；必须在某个 RsTable 子树内。
+* 多表场景下自动绑定到最近的表格实例。
+*/
+function useRsTableView() {
+	const ctx = inject(RS_TABLE_VIEW_KEY, null);
+	if (!ctx) throw new Error("[RsTable] useRsTableView() 必须在 RsTable 子树内调用（每表独立 provide，多表互不串扰）");
+	return ctx;
+}
+//#endregion
+export { RS_TABLE_VIEW_KEY, createRsTableViewContext, provideRsTableView, useRsTableView };

package/dist/components/table/src/context/table-keys.d.ts

@@ -0,0 +1,5 @@
+export declare function makeCellKey(rowKey: string, colKey: string): string;
+export declare function parseCellKey(cellKey: string): {
+    rowKey: string;
+    colKey: string;
+};

package/dist/components/table/src/context/table-keys.js

@@ -0,0 +1,6 @@
+//#region src/components/table/src/context/table-keys.ts
+function makeCellKey(rowKey, colKey) {
+	return `${rowKey}:${colKey}`;
+}
+//#endregion
+export { makeCellKey };

package/dist/components/table/src/createRsTableEditEmitBridge.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 将 Vue emit 适配为 useRsTableEditActions 所需的 edit emit 袋。
+ */
+import type { EmitFn } from 'vue';
+import type { RsTableEmits } from './rs-table-props';
+import type { RsTableRowData } from './utils/table-utils';
+import type { UseRsTableEditActionsOptions } from './composables/useRsTableEditActions';
+type EditEmitBag<T extends RsTableRowData> = UseRsTableEditActionsOptions<T>['emit'];
+/**
+ * 创建编辑 emit 桥（避免 RsTable 内联一长串箭头函数）。
+ *
+ * 入参用 Vue `EmitFn<RsTableEmits>`，与 `defineEmits` 产物对齐；
+ * 勿用手写 overload 接口承接（交叉重载在参数位逆变，会报 cellView ̸∈ update:columnOrder）。
+ */
+export declare function createRsTableEditEmitBridge<T extends RsTableRowData>(emit: EmitFn<RsTableEmits<T>>): EditEmitBag<T>;
+export {};

package/dist/components/table/src/createRsTableEditEmitBridge.js

@@ -0,0 +1,25 @@
+//#region src/components/table/src/createRsTableEditEmitBridge.ts
+/**
+* 创建编辑 emit 桥（避免 RsTable 内联一长串箭头函数）。
+*
+* 入参用 Vue `EmitFn<RsTableEmits>`，与 `defineEmits` 产物对齐；
+* 勿用手写 overload 接口承接（交叉重载在参数位逆变，会报 cellView ̸∈ update:columnOrder）。
+*/
+function createRsTableEditEmitBridge(emit) {
+	return {
+		cellView: (row, column, index) => emit("cellView", row, column, index),
+		cellEditStart: (row, column, index) => emit("cellEditStart", row, column, index),
+		cellEditDialog: (row, column, index, draft) => emit("cellEditDialog", row, column, index, draft),
+		cellEditCommit: (row, column, index, value, previous) => emit("cellEditCommit", row, column, index, value, previous),
+		cellEditCancel: (row, column, index) => emit("cellEditCancel", row, column, index),
+		cellEditInvalid: (row, column, index, message, value) => emit("cellEditInvalid", row, column, index, message, value),
+		cellEditBatchCommit: (column, changes) => emit("cellEditBatchCommit", column, changes),
+		cellEditUndo: (entry) => emit("cellEditUndo", entry),
+		cellEditRedo: (entry) => emit("cellEditRedo", entry),
+		cellEditReject: (row, index, reason) => emit("cellEditReject", row, index, reason),
+		rowEditCommit: (row, index, changes) => emit("rowEditCommit", row, index, changes),
+		rowEditRollback: (row, index) => emit("rowEditRollback", row, index)
+	};
+}
+//#endregion
+export { createRsTableEditEmitBridge };