@robot-admin/naive-ui-components 0.3.0

package/dist/C_Table2.js

@@ -0,0 +1,3009 @@
+import { n as __require } from "./chunk.js";
+import { t as C_Icon_default } from "./C_Icon2.js";
+import { t as export_helper_default } from "./export-helper.js";
+import { t as C_Form_default } from "./C_Form2.js";
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createTextVNode, createVNode, defineComponent, h, isRef, mergeProps, nextTick, normalizeClass, normalizeStyle, onBeforeUnmount, onMounted, openBlock, ref, renderList, renderSlot, resolveDynamicComponent, toDisplayString, unref, watch, watchEffect, withCtx } from "vue";
+import { NButton, NDatePicker, NDropdown, NInput, NInputNumber, NSelect, NSpace, NSwitch, useDialog, useMessage } from "naive-ui";
+import html2canvas from "html2canvas";
+import { NButton as NButton$1, NButtonGroup as NButtonGroup$1, NCheckbox as NCheckbox$1, NDataTable, NDrawer as NDrawer$1, NDrawerContent as NDrawerContent$1, NDropdown as NDropdown$1, NInput as NInput$1, NModal as NModal$1, NPagination as NPagination$1, NSpace as NSpace$1, NSpin as NSpin$1, NSwitch as NSwitch$1, NTag as NTag$1, NText as NText$1, NTooltip as NTooltip$1, useMessage as useMessage$1 } from "naive-ui/es";
+import printJS from "print-js";
+
+//#region src/components/C_Table/composables/useTableConfig.ts
+const EDIT_DISABLED = {
+	editable: false,
+	editMode: "none",
+	showRowActions: false,
+	modalTitle: "编辑数据",
+	modalWidth: 600
+};
+const resolveEdit = (edit) => {
+	if (edit === false || edit === void 0) return EDIT_DISABLED;
+	if (edit === true) return {
+		editable: true,
+		editMode: "modal",
+		showRowActions: true,
+		modalTitle: "编辑数据",
+		modalWidth: 600
+	};
+	return {
+		editable: edit.enabled !== false && edit.mode !== "none",
+		editMode: edit.mode || "modal",
+		showRowActions: edit.showRowActions !== false && edit.mode !== "none",
+		modalTitle: edit.modalTitle || "编辑数据",
+		modalWidth: edit.modalWidth || 600
+	};
+};
+const resolveExpand = (expand) => {
+	if (!expand) return {
+		expandable: false,
+		defaultExpandedKeys: void 0,
+		onLoadExpandData: void 0,
+		renderExpandContent: void 0,
+		rowExpandable: void 0
+	};
+	if (expand === true) return {
+		expandable: true,
+		defaultExpandedKeys: void 0,
+		onLoadExpandData: void 0,
+		renderExpandContent: void 0,
+		rowExpandable: void 0
+	};
+	return {
+		expandable: expand.enabled !== false,
+		defaultExpandedKeys: expand.defaultExpandedKeys,
+		onLoadExpandData: expand.onLoadData,
+		renderExpandContent: expand.renderContent,
+		rowExpandable: expand.rowExpandable
+	};
+};
+const resolveSelection = (selection) => {
+	if (!selection) return {
+		enableSelection: false,
+		defaultCheckedKeys: void 0,
+		rowCheckable: void 0,
+		maxSelection: void 0,
+		enableChildSelection: false,
+		childRowCheckable: void 0,
+		enableParentChildLink: false,
+		parentChildLinkMode: "loose"
+	};
+	if (selection === true) return {
+		enableSelection: true,
+		defaultCheckedKeys: void 0,
+		rowCheckable: void 0,
+		maxSelection: void 0,
+		enableChildSelection: false,
+		childRowCheckable: void 0,
+		enableParentChildLink: false,
+		parentChildLinkMode: "loose"
+	};
+	const child = selection.childSelection || {};
+	const link = selection.parentChildLink || {};
+	return {
+		enableSelection: selection.enabled !== false,
+		defaultCheckedKeys: selection.defaultCheckedKeys,
+		rowCheckable: selection.rowCheckable,
+		maxSelection: selection.maxSelection,
+		enableChildSelection: child.enabled || false,
+		childRowCheckable: child.childRowCheckable,
+		enableParentChildLink: link.enabled || false,
+		parentChildLinkMode: link.mode || "loose"
+	};
+};
+const resolvePagination = (pagination) => {
+	const defaults = {
+		enabled: true,
+		page: 1,
+		pageSize: 10,
+		showSizePicker: true,
+		showQuickJumper: true,
+		pageSizes: [
+			10,
+			20,
+			50,
+			100
+		],
+		simple: false,
+		size: "medium"
+	};
+	if (pagination === false) return { pagination: null };
+	if (pagination === true || pagination === void 0) return { pagination: defaults };
+	return { pagination: {
+		...defaults,
+		...pagination
+	} };
+};
+const resolveDynamicRows = (dynamicRows) => {
+	if (!dynamicRows) return { dynamicRows: void 0 };
+	if (dynamicRows === true) return { dynamicRows: {
+		enableRadioSelection: true,
+		enableAdd: true,
+		enableInsert: true,
+		enableDelete: true,
+		enableCopy: true,
+		enableMove: true,
+		enablePrint: true
+	} };
+	return { dynamicRows };
+};
+const DISPLAY_DEFAULTS = {
+	striped: true,
+	bordered: true,
+	singleLine: true,
+	size: "medium",
+	maxHeight: void 0,
+	scrollX: void 0,
+	columnWidth: 180
+};
+/** 解析 display 配置，合并默认值 */
+function resolveDisplay(display) {
+	if (!display) return { ...DISPLAY_DEFAULTS };
+	return {
+		striped: display.striped ?? DISPLAY_DEFAULTS.striped,
+		bordered: display.bordered ?? DISPLAY_DEFAULTS.bordered,
+		singleLine: display.singleLine ?? DISPLAY_DEFAULTS.singleLine,
+		size: display.size ?? DISPLAY_DEFAULTS.size,
+		maxHeight: display.maxHeight,
+		scrollX: display.scrollX,
+		columnWidth: display.columnWidth ?? DISPLAY_DEFAULTS.columnWidth
+	};
+}
+const resolveToolbar = (toolbar) => ({
+	showToolbar: toolbar?.show !== false,
+	enableColumnSettings: toolbar?.columnSettings !== false
+});
+/**
+* 将 config 单一对象解析为内部扁平化配置
+*/
+function resolveConfig(config = {}) {
+	return {
+		...resolveEdit(config.edit),
+		...resolveExpand(config.expand),
+		...resolveSelection(config.selection),
+		...resolvePagination(config.pagination),
+		...resolveDynamicRows(config.dynamicRows),
+		...resolveDisplay(config.display),
+		...resolveToolbar(config.toolbar)
+	};
+}
+const createEditModeChecker = (config) => ({
+	isNonEditable: (column) => !config.editable || column.editable === false || config.editMode === "none",
+	isRowEditMode: () => ["row", "both"].includes(config.editMode),
+	isCellEditMode: () => ["cell", "both"].includes(config.editMode)
+});
+
+//#endregion
+//#region src/components/C_Table/composables/useRowEdit.ts
+/**
+* 可编辑行组合函数，提供表格整行的编辑功能
+*/
+function useRowEdit(options) {
+	const editingRowKey = ref(null);
+	const editingData = ref({});
+	/**
+	* 检查指定行是否正在编辑状态
+	*/
+	const isEditingRow = (rowKey) => {
+		return editingRowKey.value === rowKey;
+	};
+	/**
+	* 根据rowKey实时查找最新的行数据
+	*/
+	const findRowData = (rowKey) => {
+		const currentData = options.data();
+		if (!currentData || !Array.isArray(currentData)) return null;
+		return currentData.find((row) => options.rowKey(row) === rowKey);
+	};
+	/**
+	* 开始编辑指定行，将原始数据复制到编辑缓存中
+	*/
+	const startEditRow = (rowKey) => {
+		const rowData = findRowData(rowKey);
+		if (!rowData) return;
+		editingRowKey.value = rowKey;
+		editingData.value[rowKey] = { ...rowData };
+	};
+	/**
+	* 取消当前行编辑，调用取消回调并清理编辑状态
+	*/
+	const cancelEditRow = async () => {
+		if (!editingRowKey.value) return;
+		const currentData = options.data();
+		if (!currentData || !Array.isArray(currentData)) return;
+		const rowIndex = currentData.findIndex((row) => options.rowKey(row) === editingRowKey.value);
+		if (rowIndex > -1) await options.onCancel?.(currentData[rowIndex], rowIndex);
+		editingRowKey.value = null;
+		editingData.value = {};
+	};
+	/**
+	* 保存当前行编辑，调用保存回调并清理编辑状态
+	*/
+	const saveEditRow = async () => {
+		if (!editingRowKey.value) return;
+		const rowKey = editingRowKey.value;
+		const currentData = options.data();
+		if (!currentData || !Array.isArray(currentData)) return;
+		const rowIndex = currentData.findIndex((row) => options.rowKey(row) === rowKey);
+		if (rowIndex === -1) return;
+		const updatedData = editingData.value[rowKey];
+		if (!updatedData) return;
+		await options.onSave?.(updatedData, rowIndex);
+		editingRowKey.value = null;
+		editingData.value = {};
+		return {
+			updatedData,
+			rowIndex
+		};
+	};
+	/**
+	* 获取指定行的编辑中数据
+	*/
+	const getEditingRowData = (rowKey) => {
+		return editingData.value[rowKey];
+	};
+	/**
+	* 更新指定行编辑中的字段值
+	*/
+	const updateEditingRowData = (rowKey, field, value) => {
+		if (!editingData.value[rowKey]) return;
+		editingData.value[rowKey][field] = value;
+	};
+	return {
+		editingRowKey,
+		isEditingRow,
+		startEditRow,
+		cancelEditRow,
+		saveEditRow,
+		getEditingRowData,
+		updateEditingRowData,
+		findRowData
+	};
+}
+
+//#endregion
+//#region src/components/C_Table/composables/useCellEdit.ts
+/**
+* 可编辑单元格组合函数，提供表格单元格的编辑功能
+*/
+function useCellEdit(options) {
+	const editingCell = ref({
+		rowKey: null,
+		columnKey: null
+	});
+	const editingData = ref({});
+	/**
+	* 检查指定单元格是否正在编辑状态
+	*/
+	const isEditingCell = (rowKey, columnKey) => {
+		return editingCell.value.rowKey === rowKey && editingCell.value.columnKey === columnKey;
+	};
+	/**
+	* 根据rowKey实时查找最新的行数据
+	*/
+	const findRowData = (rowKey) => {
+		const currentData = options.data();
+		if (!currentData || !Array.isArray(currentData)) return null;
+		return currentData.find((row) => options.rowKey(row) === rowKey);
+	};
+	/**
+	* 开始编辑指定单元格，将原值存储到编辑缓存中
+	*/
+	const startEditCell = (rowKey, columnKey) => {
+		const rowData = findRowData(rowKey);
+		if (!rowData) return;
+		editingCell.value = {
+			rowKey,
+			columnKey
+		};
+		editingData.value[`${rowKey}-${columnKey}`] = rowData[columnKey];
+	};
+	/**
+	* 保存当前编辑的单元格，调用保存回调并清理编辑状态
+	*/
+	const saveEditCell = async () => {
+		const { rowKey, columnKey } = editingCell.value;
+		if (!rowKey || !columnKey) return;
+		const currentData = options.data();
+		if (!currentData || !Array.isArray(currentData)) return;
+		const rowIndex = currentData.findIndex((row) => options.rowKey(row) === rowKey);
+		if (rowIndex === -1) return;
+		const cellKey = `${rowKey}-${columnKey}`;
+		const newValue = editingData.value[cellKey];
+		const updatedData = {
+			...currentData[rowIndex],
+			[columnKey]: newValue
+		};
+		await options.onSave?.(updatedData, rowIndex, columnKey);
+		editingCell.value = {
+			rowKey: null,
+			columnKey: null
+		};
+		delete editingData.value[cellKey];
+		return {
+			updatedData,
+			rowIndex,
+			columnKey
+		};
+	};
+	/**
+	* 取消当前单元格编辑，清理编辑状态和缓存数据
+	*/
+	const cancelEditCell = () => {
+		const { rowKey, columnKey } = editingCell.value;
+		if (rowKey && columnKey) delete editingData.value[`${rowKey}-${columnKey}`];
+		editingCell.value = {
+			rowKey: null,
+			columnKey: null
+		};
+	};
+	/**
+	* 获取指定单元格的编辑中数值
+	*/
+	const getEditingCellValue = (rowKey, columnKey) => {
+		return editingData.value[`${rowKey}-${columnKey}`];
+	};
+	/**
+	* 更新指定单元格的编辑中数值
+	*/
+	const updateEditingCellValue = (rowKey, columnKey, value) => {
+		editingData.value[`${rowKey}-${columnKey}`] = value;
+	};
+	return {
+		editingCell,
+		isEditingCell,
+		startEditCell,
+		saveEditCell,
+		cancelEditCell,
+		getEditingCellValue,
+		updateEditingCellValue,
+		findRowData
+	};
+}
+
+//#endregion
+//#region src/components/C_Table/composables/useModalEdit.ts
+/**
+* 模态框编辑组合函数，提供弹窗形式的数据编辑功能
+*/
+function useModalEdit(options) {
+	const isModalVisible = ref(false);
+	const editingRowKey = ref(null);
+	const editingData = ref({});
+	/**
+	* 计算属性：获取当前编辑行的索引
+	*/
+	const editingRowIndex = computed(() => {
+		if (!editingRowKey.value) return -1;
+		const currentData = options.data();
+		if (!currentData || !Array.isArray(currentData)) return -1;
+		return currentData.findIndex((row) => options.rowKey(row) === editingRowKey.value);
+	});
+	/**
+	* 重置编辑状态
+	*/
+	const resetEditingState = () => {
+		editingRowKey.value = null;
+		editingData.value = {};
+	};
+	/**
+	* 开始编辑指定行
+	*/
+	const startEdit = (rowKey) => {
+		console.log("🚀 开始编辑:", rowKey);
+		const currentData = options.data();
+		if (!currentData || !Array.isArray(currentData)) {
+			console.warn("数据源为空或不是数组");
+			return;
+		}
+		const rowIndex = currentData.findIndex((row) => options.rowKey(row) === rowKey);
+		if (rowIndex === -1) {
+			console.warn("未找到对应的行数据:", rowKey);
+			return;
+		}
+		const rowData = currentData[rowIndex];
+		console.log("找到行数据:", rowData);
+		editingRowKey.value = rowKey;
+		editingData.value = JSON.parse(JSON.stringify(rowData));
+		console.log("编辑数据已准备:", editingData.value);
+		isModalVisible.value = true;
+	};
+	/**
+	* 保存编辑
+	*/
+	const saveEdit = async (formData) => {
+		const dataToSave = formData || editingData.value;
+		const currentIndex = editingRowIndex.value;
+		console.log("💾 保存编辑:", {
+			rowKey: editingRowKey.value,
+			index: currentIndex,
+			data: dataToSave
+		});
+		if (currentIndex === -1) {
+			console.warn("无法找到编辑行的索引");
+			return;
+		}
+		try {
+			await options.onSave?.(dataToSave, currentIndex);
+			isModalVisible.value = false;
+			resetEditingState();
+			console.log("✅ 保存成功");
+		} catch (error) {
+			console.error("❌ 保存失败:", error);
+			throw error;
+		}
+	};
+	/**
+	* 取消编辑
+	*/
+	const cancelEdit = async () => {
+		console.log("🚫 取消编辑");
+		try {
+			const currentIndex = editingRowIndex.value;
+			if (editingRowKey.value && currentIndex > -1) {
+				const currentData = options.data();
+				if (currentData && currentData[currentIndex]) await options.onCancel?.(currentData[currentIndex], currentIndex);
+			}
+		} finally {
+			isModalVisible.value = false;
+			resetEditingState();
+		}
+	};
+	/**
+	* 更新编辑数据
+	*/
+	const updateEditingData = (data) => {
+		editingData.value = { ...data };
+	};
+	/**
+	* 获取当前编辑的行数据
+	*/
+	const getEditingRowData = (rowKey) => {
+		if (editingRowKey.value === rowKey) return editingData.value;
+		return null;
+	};
+	/**
+	* 检查是否正在编辑指定行
+	*/
+	const isEditingRow = (rowKey) => {
+		return editingRowKey.value === rowKey && isModalVisible.value;
+	};
+	return {
+		isModalVisible,
+		editingData,
+		editingRowKey,
+		editingRowIndex,
+		startEdit,
+		saveEdit,
+		cancelEdit,
+		updateEditingData,
+		resetEditingState,
+		isEditingRow,
+		getEditingRowData
+	};
+}
+
+//#endregion
+//#region src/components/C_Table/composables/useTableExpand.ts
+const useExpandState = (options) => {
+	return {
+		expandedKeys: ref([...options.defaultExpandedKeys || []]),
+		expandDataMap: ref(/* @__PURE__ */ new Map()),
+		loadingMap: ref(/* @__PURE__ */ new Map()),
+		checkedKeys: options.enableSelection ? ref([...options.defaultCheckedKeys || []]) : ref([]),
+		childSelections: options.enableChildSelection ? ref(/* @__PURE__ */ new Map()) : ref(/* @__PURE__ */ new Map())
+	};
+};
+const useDataUtils = (options) => {
+	const data = computed(() => unref(options.data));
+	const getRowKey = options.rowKey;
+	const getChildRowKey = options.childRowKey || ((child) => child.id);
+	const findRow = (key) => data.value.find((row) => getRowKey(row) === key);
+	return {
+		data,
+		getRowKey,
+		getChildRowKey,
+		findRow,
+		isRowExpandable: options.rowExpandable || (() => true),
+		isRowCheckable: options.rowCheckable || (() => true),
+		isChildRowCheckable: options.childRowCheckable || (() => true)
+	};
+};
+const useExpandLogic = (state, utils, options) => {
+	const loadData = async (row) => {
+		if (!options.onLoadData) return [];
+		const key = utils.getRowKey(row);
+		const existingData = state.expandDataMap.value.get(key);
+		if (existingData) return existingData;
+		state.loadingMap.value.set(key, true);
+		try {
+			const result = await options.onLoadData(row) || [];
+			state.expandDataMap.value.set(key, result);
+			if (options.enableChildSelection && !state.childSelections.value.has(key)) state.childSelections.value.set(key, []);
+			return result;
+		} catch (error) {
+			console.error("加载展开数据失败:", error);
+			return [];
+		} finally {
+			state.loadingMap.value.set(key, false);
+		}
+	};
+	const handleRowExpand = async (row, expanded) => {
+		const key = utils.getRowKey(row);
+		if (expanded) {
+			await loadData(row);
+			if (!state.expandedKeys.value.includes(key)) state.expandedKeys.value = [...state.expandedKeys.value, key];
+		} else state.expandedKeys.value = state.expandedKeys.value.filter((k) => k !== key);
+		options.onExpandChange?.(state.expandedKeys.value);
+	};
+	const expandAll = async () => {
+		const expandableRows = utils.data.value.filter(utils.isRowExpandable);
+		await Promise.allSettled(expandableRows.map(loadData));
+		state.expandedKeys.value = expandableRows.map(utils.getRowKey);
+		options.onExpandChange?.(state.expandedKeys.value);
+	};
+	const collapseAll = () => {
+		state.expandedKeys.value = [];
+		state.childSelections.value.clear();
+		options.onExpandChange?.(state.expandedKeys.value);
+	};
+	const handleExpandChange = async (keys) => {
+		const newExpandedKeys = keys.filter((key) => !state.expandedKeys.value.includes(key));
+		const collapsedKeys = state.expandedKeys.value.filter((key) => !keys.includes(key));
+		await Promise.all(newExpandedKeys.map(async (key) => {
+			const row = utils.findRow(key);
+			if (row) await loadData(row);
+		}));
+		for (const key of collapsedKeys) state.childSelections.value.delete(key);
+		state.expandedKeys.value = keys;
+		options.onExpandChange?.(keys);
+	};
+	return {
+		loadData,
+		handleRowExpand,
+		expandAll,
+		collapseAll,
+		handleExpandChange
+	};
+};
+const useSelectionLogic = (state, utils, options) => {
+	const selectableRows = computed(() => utils.data.value.filter(utils.isRowCheckable));
+	const selectedRowsCount = computed(() => state.checkedKeys.value.length);
+	const selectAll = () => {
+		if (!options.enableSelection) return;
+		const keys = selectableRows.value.map(utils.getRowKey);
+		const finalKeys = options.maxSelection ? keys.slice(0, options.maxSelection) : keys;
+		state.checkedKeys.value = finalKeys;
+		const selectedRows = selectableRows.value.filter((row) => finalKeys.includes(utils.getRowKey(row)));
+		options.onSelectionChange?.(finalKeys, selectedRows, state.childSelections.value);
+	};
+	const clearSelection = () => {
+		if (!options.enableSelection) return;
+		state.checkedKeys.value = [];
+		options.onSelectionChange?.([], [], state.childSelections.value);
+	};
+	const handleSelectionChange = (keys) => {
+		if (!options.enableSelection) return;
+		state.checkedKeys.value = keys;
+		const selectedRows = utils.data.value.filter((row) => keys.includes(utils.getRowKey(row)));
+		options.onSelectionChange?.(keys, selectedRows, state.childSelections.value);
+	};
+	return {
+		selectAll,
+		clearSelection,
+		handleSelectionChange,
+		selectedRowsCount,
+		selectableRows
+	};
+};
+const useParentChildLink = (state, options) => {
+	const isLinkEnabled = Boolean(options.enableParentChildLink && options.enableSelection && options.enableChildSelection);
+	const handleParentChildLink = (parentKey, selectedChildKeys, totalChildren) => {
+		if (!isLinkEnabled) return;
+		const shouldSelectParent = options.parentChildLinkMode === "strict" ? selectedChildKeys.length === totalChildren && totalChildren > 0 : selectedChildKeys.length > 0;
+		const currentKeys = [...state.checkedKeys.value];
+		const isParentSelected = currentKeys.includes(parentKey);
+		if (shouldSelectParent && !isParentSelected) state.checkedKeys.value = [...currentKeys, parentKey];
+		else if (!shouldSelectParent && isParentSelected) state.checkedKeys.value = currentKeys.filter((k) => k !== parentKey);
+	};
+	return {
+		handleParentChildLink,
+		isLinkEnabled
+	};
+};
+const useChildSelectionLogic = (state, utils, parentChildLink, options) => {
+	const totalChildSelections = computed(() => {
+		if (!options.enableChildSelection) return 0;
+		return Array.from(state.childSelections.value.values()).reduce((total, keys) => total + keys.length, 0);
+	});
+	const clearAllSelections = () => {
+		state.checkedKeys.value = [];
+		state.childSelections.value.clear();
+		options.onSelectionChange?.([], [], state.childSelections.value);
+	};
+	const handleChildSelectionChange = (parentKey, childKeys) => {
+		if (!options.enableChildSelection) return;
+		state.childSelections.value.set(parentKey, childKeys);
+		const expandData = state.expandDataMap.value.get(parentKey) || [];
+		const selectedChildren = expandData.filter((child) => childKeys.includes(utils.getChildRowKey(child)));
+		options.onChildSelectionChange?.(parentKey, childKeys, selectedChildren);
+		if (parentChildLink.isLinkEnabled) parentChildLink.handleParentChildLink(parentKey, childKeys, expandData.length);
+	};
+	return {
+		totalChildSelections,
+		clearAllSelections,
+		handleChildSelectionChange
+	};
+};
+const createChildSelectionState = (parentKey, state, utils, childLogic, options) => {
+	if (!options.enableChildSelection) return void 0;
+	const selectedKeys = state.childSelections.value.get(parentKey) || [];
+	const expandData = state.expandDataMap.value.get(parentKey) || [];
+	const parent = utils.findRow(parentKey);
+	if (!parent) return void 0;
+	const checkableChildren = expandData.filter((child) => utils.isChildRowCheckable(child, parent));
+	return {
+		selectedKeys,
+		isAllChecked: checkableChildren.length > 0 && checkableChildren.every((child) => selectedKeys.includes(utils.getChildRowKey(child))),
+		selectAll: () => {
+			const allKeys = checkableChildren.map((child) => utils.getChildRowKey(child));
+			childLogic.handleChildSelectionChange(parentKey, allKeys);
+		},
+		clearAll: () => {
+			childLogic.handleChildSelectionChange(parentKey, []);
+		}
+	};
+};
+const createLoadingView = () => {
+	return h("div", { class: "flex justify-center items-center py-8" }, [h(NSpin$1, { size: "small" }), h("span", { class: "ml-2 text-gray-500" }, "加载中...")]);
+};
+const createEmptyView = () => {
+	return h("div", { class: "text-center py-8 text-gray-400" }, "暂无数据");
+};
+const createDefaultColumns = (expandData) => {
+	if (!expandData.length) return [];
+	const firstItem = expandData[0];
+	if (!firstItem || typeof firstItem !== "object") return [];
+	return [{
+		title: "序号",
+		key: "_index",
+		width: 60,
+		render: (_, index) => index + 1
+	}, ...Object.keys(firstItem).filter((key) => !["id", "key"].includes(key)).map((key) => ({
+		key,
+		title: key.charAt(0).toUpperCase() + key.slice(1),
+		width: 120,
+		ellipsis: { tooltip: true }
+	}))];
+};
+const createDefaultTable = (key, expandData, childSelection, utils, childLogic, options) => {
+	const columns = [];
+	if (options.enableChildSelection) columns.push({
+		type: "selection",
+		multiple: true
+	});
+	columns.push(...createDefaultColumns(expandData));
+	return h("div", { class: "p-4 bg-gray-50" }, [h("div", { class: "mb-2 text-sm text-gray-600" }, `详细信息 (${expandData.length} 条)`), h(NDataTable, {
+		data: expandData,
+		columns,
+		size: "small",
+		striped: true,
+		checkedRowKeys: childSelection?.selectedKeys || [],
+		rowKey: (row) => utils.getChildRowKey(row),
+		onUpdateCheckedRowKeys: options.enableChildSelection ? (keys) => {
+			childLogic.handleChildSelectionChange(key, keys);
+		} : void 0
+	})]);
+};
+const useRenderer = (state, utils, childLogic, expandLogic, options) => {
+	const renderExpandContent = (row) => {
+		const key = utils.getRowKey(row);
+		const expandData = state.expandDataMap.value.get(key) || [];
+		const loading = state.loadingMap.value.get(key) || false;
+		if (!expandData.length && !loading && state.expandedKeys.value.includes(key)) nextTick(() => {
+			expandLogic.loadData(row);
+		});
+		const childSelection = createChildSelectionState(key, state, utils, childLogic, options);
+		if (options.renderContent) return options.renderContent(row, expandData, loading, childSelection);
+		if (loading) return createLoadingView();
+		if (!expandData.length) return createEmptyView();
+		return createDefaultTable(key, expandData, childSelection, utils, childLogic, options);
+	};
+	const getTableColumns = (originalColumns) => {
+		return originalColumns.map((column) => {
+			if (column.type === "selection" && options.enableSelection) return {
+				type: "selection",
+				disabled: (row) => !utils.isRowCheckable(row),
+				multiple: !options.maxSelection || options.maxSelection > 1
+			};
+			if (column.type === "expand" && (options.onLoadData || options.renderContent)) return {
+				type: "expand",
+				expandable: utils.isRowExpandable,
+				renderExpand: renderExpandContent
+			};
+			return column;
+		});
+	};
+	return { getTableColumns };
+};
+function useTableExpand(options) {
+	const state = useExpandState(options);
+	const utils = useDataUtils(options);
+	const expandLogic = useExpandLogic(state, utils, options);
+	const selectionLogic = useSelectionLogic(state, utils, options);
+	const childLogic = useChildSelectionLogic(state, utils, useParentChildLink(state, options), options);
+	const renderer = useRenderer(state, utils, childLogic, expandLogic, options);
+	if (options.onSelectionChange && options.enableSelection) watchEffect(() => {
+		if (!options.onSelectionChange) return;
+		const selectedRows = utils.data.value.filter((row) => state.checkedKeys.value.includes(utils.getRowKey(row)));
+		const hasSelection = state.checkedKeys.value.length > 0;
+		const hasData = utils.data.value.length > 0;
+		if (hasSelection || !hasData) options.onSelectionChange(state.checkedKeys.value, selectedRows, state.childSelections.value);
+	});
+	const expandRow = async (key) => {
+		if (state.expandedKeys.value.includes(key)) return;
+		const row = utils.findRow(key);
+		if (!row) return;
+		await expandLogic.loadData(row);
+		state.expandedKeys.value = [...state.expandedKeys.value, key];
+		options.onExpandChange?.(state.expandedKeys.value, row, true);
+	};
+	const initializeData = async () => {
+		const keysToLoad = options.defaultExpandedKeys || [];
+		if (keysToLoad.length === 0) return;
+		const loadPromises = keysToLoad.map(async (key) => {
+			const row = utils.findRow(key);
+			if (row && !state.expandDataMap.value.has(key)) await expandLogic.loadData(row);
+		});
+		await Promise.allSettled(loadPromises);
+	};
+	if (options.defaultExpandedKeys?.length) nextTick(initializeData);
+	return {
+		expandedKeys: state.expandedKeys,
+		checkedKeys: state.checkedKeys,
+		childSelections: state.childSelections,
+		selectedRowsCount: selectionLogic.selectedRowsCount,
+		totalChildSelections: childLogic.totalChildSelections,
+		expandAll: expandLogic.expandAll,
+		collapseAll: expandLogic.collapseAll,
+		expandRow,
+		handleExpandChange: expandLogic.handleExpandChange,
+		selectAll: selectionLogic.selectAll,
+		clearSelection: selectionLogic.clearSelection,
+		clearAllSelections: childLogic.clearAllSelections,
+		handleSelectionChange: selectionLogic.handleSelectionChange,
+		getTableColumns: renderer.getTableColumns,
+		expandDataMap: state.expandDataMap,
+		loadingMap: state.loadingMap
+	};
+}
+
+//#endregion
+//#region src/components/C_Table/composables/usePrintWatermark.ts
+const DEFAULT_WATERMARK = {
+	text: "Robot Admin",
+	textSize: 16,
+	textColor: "rgba(128, 128, 128, 0.3)",
+	font: "Microsoft JhengHei",
+	opacity: .3,
+	rotate: -20,
+	position: "repeat",
+	xGap: 200,
+	yGap: 120
+};
+const DEFAULT_CAPTURE = {
+	scale: 1,
+	quality: .92,
+	format: "png",
+	backgroundColor: "#ffffff",
+	logging: false,
+	allowTaint: true,
+	useCORS: true
+};
+const DEFAULT_PRINT = {
+	orientation: "portrait",
+	paperSize: "A4",
+	margin: "10mm 10mm 0 10mm",
+	style: "@page { margin: 10mm 10mm 0 10mm; } @media print { body { margin: 0; } }",
+	header: "",
+	footer: "",
+	showModal: false,
+	modalMessage: "正在准备打印...",
+	onLoadingStart: () => {},
+	onLoadingEnd: () => {},
+	onPrintDialogClose: () => {}
+};
+function drawCenterWatermark(ctx, width, height, config) {
+	ctx.save();
+	ctx.translate(width / 2, height / 2);
+	ctx.rotate(config.rotate * Math.PI / 180);
+	ctx.fillText(config.text, 0, 0);
+	ctx.restore();
+}
+function drawCornerWatermark(ctx, width, height, config) {
+	const offset = 50;
+	[
+		[offset, offset],
+		[width - offset, offset],
+		[offset, height - offset],
+		[width - offset, height - offset]
+	].forEach(([x, y]) => {
+		ctx.save();
+		ctx.translate(x, y);
+		ctx.rotate(config.rotate * Math.PI / 180);
+		ctx.fillText(config.text, 0, 0);
+		ctx.restore();
+	});
+}
+function drawDiagonalWatermark(ctx, width, height, config) {
+	const diagonal = Math.sqrt(width * width + height * height);
+	const centerX = width / 2;
+	const centerY = height / 2;
+	ctx.save();
+	ctx.translate(centerX, centerY);
+	ctx.rotate(Math.atan2(height, width));
+	const count = Math.floor(diagonal / config.xGap);
+	const start = -diagonal / 2;
+	for (let i = 0; i <= count; i++) {
+		const x = start + i * config.xGap;
+		ctx.fillText(config.text, x, 0);
+	}
+	ctx.restore();
+}
+function drawRepeatWatermark(ctx, width, height, config) {
+	const cols = Math.ceil(width / config.xGap) + 1;
+	const rows = Math.ceil(height / config.yGap) + 1;
+	for (let row = 0; row < rows; row++) for (let col = 0; col < cols; col++) {
+		const x = col * config.xGap + config.xGap / 2;
+		const y = row * config.yGap + config.yGap / 2;
+		ctx.save();
+		ctx.translate(x, y);
+		ctx.rotate(config.rotate * Math.PI / 180);
+		ctx.fillText(config.text, 0, 0);
+		ctx.restore();
+	}
+}
+function drawWatermark(canvas, config) {
+	const ctx = canvas.getContext("2d");
+	if (!ctx) return canvas;
+	const finalConfig = {
+		...DEFAULT_WATERMARK,
+		...config
+	};
+	const { width, height } = canvas;
+	ctx.save();
+	ctx.globalAlpha = finalConfig.opacity;
+	ctx.font = `${finalConfig.textSize}px ${finalConfig.font}`;
+	ctx.fillStyle = finalConfig.textColor;
+	ctx.textAlign = "center";
+	ctx.textBaseline = "middle";
+	const drawFunctions = {
+		center: drawCenterWatermark,
+		corner: drawCornerWatermark,
+		diagonal: drawDiagonalWatermark,
+		repeat: drawRepeatWatermark
+	};
+	(drawFunctions[finalConfig.position] || drawFunctions.repeat)(ctx, width, height, finalConfig);
+	ctx.restore();
+	return canvas;
+}
+async function captureElement(element, config = {}) {
+	const finalConfig = {
+		...DEFAULT_CAPTURE,
+		...config
+	};
+	return await html2canvas(element, {
+		logging: finalConfig.logging,
+		scale: finalConfig.scale,
+		allowTaint: finalConfig.allowTaint,
+		useCORS: finalConfig.useCORS,
+		backgroundColor: finalConfig.backgroundColor,
+		onclone: (clonedDoc) => {
+			const clonedElement = clonedDoc.body;
+			clonedElement.style.transform = "scale(1)";
+		}
+	});
+}
+function canvasToDataURL(canvas, format = "png", quality = .92) {
+	const mimeType = `image/${format}`;
+	return format === "png" ? canvas.toDataURL(mimeType) : canvas.toDataURL(mimeType, quality);
+}
+function downloadCanvas(canvas, filename = `screenshot-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.png`, format = "png") {
+	const dataURL = canvasToDataURL(canvas, format);
+	const link = document.createElement("a");
+	link.download = filename;
+	link.href = dataURL;
+	document.body.appendChild(link);
+	link.click();
+	document.body.removeChild(link);
+}
+let focusInterval = null;
+function startFocusKeep() {
+	focusInterval = setInterval(() => {
+		window.dispatchEvent(new Event("focus"));
+	}, 500);
+}
+function stopFocusKeep() {
+	if (focusInterval) {
+		clearInterval(focusInterval);
+		focusInterval = null;
+	}
+}
+function printImage(imageDataURL, config = {}) {
+	const finalConfig = {
+		...DEFAULT_PRINT,
+		...config
+	};
+	return new Promise((resolve, reject) => {
+		try {
+			startFocusKeep();
+			finalConfig.onLoadingStart?.();
+			printJS({
+				printable: imageDataURL,
+				type: "image",
+				style: finalConfig.style,
+				showModal: finalConfig.showModal,
+				modalMessage: finalConfig.modalMessage,
+				onLoadingEnd: finalConfig.onLoadingEnd,
+				onPrintDialogClose: () => {
+					stopFocusKeep();
+					finalConfig.onPrintDialogClose?.();
+					resolve();
+				}
+			});
+		} catch (error) {
+			stopFocusKeep();
+			reject(error);
+		}
+	});
+}
+function calculateMergedCanvasSize(canvases, orientation, spacing) {
+	let totalWidth = 0;
+	let totalHeight = 0;
+	canvases.forEach((canvas) => {
+		const { width, height } = canvas;
+		if (orientation === "horizontal") {
+			totalWidth += width;
+			totalHeight = Math.max(totalHeight, height);
+		} else {
+			totalWidth = Math.max(totalWidth, width);
+			totalHeight += height;
+		}
+	});
+	const spacingTotal = (canvases.length - 1) * spacing;
+	if (orientation === "horizontal") totalWidth += spacingTotal;
+	else totalHeight += spacingTotal;
+	return {
+		totalWidth,
+		totalHeight
+	};
+}
+function createMergedCanvas(canvases, options) {
+	const { orientation, spacing, backgroundColor, totalWidth, totalHeight } = options;
+	const mergedCanvas = document.createElement("canvas");
+	mergedCanvas.width = totalWidth;
+	mergedCanvas.height = totalHeight;
+	const ctx = mergedCanvas.getContext("2d");
+	if (!ctx) throw new Error("无法创建画布上下文");
+	ctx.fillStyle = backgroundColor;
+	ctx.fillRect(0, 0, totalWidth, totalHeight);
+	let currentX = 0;
+	let currentY = 0;
+	canvases.forEach((canvas) => {
+		ctx.drawImage(canvas, currentX, currentY);
+		if (orientation === "horizontal") currentX += canvas.width + spacing;
+		else currentY += canvas.height + spacing;
+	});
+	return mergedCanvas;
+}
+function validateAndGetMergeOptions(elements, mergeOptions, message) {
+	if (!elements.length) {
+		message.warning("没有要打印的元素");
+		return null;
+	}
+	return {
+		orientation: mergeOptions.orientation || "vertical",
+		spacing: mergeOptions.spacing || 20,
+		backgroundColor: mergeOptions.backgroundColor || "#ffffff"
+	};
+}
+async function captureAndMergeCanvas(elements, options, validatedOptions, updateProgress) {
+	const { orientation, spacing, backgroundColor } = validatedOptions;
+	updateProgress(10);
+	const canvases = await Promise.all(elements.map((element) => captureElement(element, options.capture)));
+	updateProgress(50);
+	const { totalWidth, totalHeight } = calculateMergedCanvasSize(canvases, orientation, spacing);
+	updateProgress(60);
+	return createMergedCanvas(canvases, {
+		orientation,
+		spacing,
+		backgroundColor,
+		totalWidth,
+		totalHeight
+	});
+}
+async function addWatermarkAndPrint(mergedCanvas, options, elementsCount, updateProgress, message) {
+	updateProgress(70);
+	if (options.watermark) drawWatermark(mergedCanvas, options.watermark);
+	updateProgress(90);
+	await printImage(canvasToDataURL(mergedCanvas, options.capture?.format, options.capture?.quality), options.print);
+	updateProgress(100);
+	message.success(`合并打印完成，共合并 ${elementsCount} 个元素`);
+}
+function usePrintWatermark() {
+	let message;
+	try {
+		const { useMessage: _useMessage } = __require("naive-ui");
+		message = _useMessage();
+	} catch {
+		message = {
+			success: (msg) => console.log("[PrintWatermark]", msg),
+			error: (msg) => console.error("[PrintWatermark]", msg),
+			warning: (msg) => console.warn("[PrintWatermark]", msg)
+		};
+	}
+	const loading = ref(false);
+	const progress = ref(0);
+	const updateProgress = (value) => {
+		progress.value = Math.max(0, Math.min(100, value));
+	};
+	const captureWithWatermark = async (element, options = {}) => {
+		try {
+			updateProgress(0);
+			updateProgress(30);
+			const canvas = await captureElement(element, options.capture);
+			updateProgress(60);
+			if (options.watermark) drawWatermark(canvas, options.watermark);
+			updateProgress(90);
+			const dataURL = canvasToDataURL(canvas, options.capture?.format || "png", options.capture?.quality || .92);
+			updateProgress(100);
+			return dataURL;
+		} catch (error) {
+			console.error("截图失败:", error);
+			throw new Error(`截图失败: ${error instanceof Error ? error.message : "未知错误"}`);
+		}
+	};
+	const printWithWatermark = async (element, options = {}) => {
+		loading.value = true;
+		updateProgress(0);
+		try {
+			await nextTick();
+			const imageDataURL = await captureWithWatermark(element, options);
+			updateProgress(95);
+			await printImage(imageDataURL, options.print);
+			updateProgress(100);
+			message.success("打印完成");
+		} catch (error) {
+			console.error("打印失败:", error);
+			message.error(`打印失败: ${error instanceof Error ? error.message : "未知错误"}`);
+			throw error;
+		} finally {
+			loading.value = false;
+			updateProgress(0);
+		}
+	};
+	const downloadScreenshot = async (element, filename, options = {}) => {
+		loading.value = true;
+		try {
+			await nextTick();
+			const canvas = await captureElement(element, options.capture);
+			if (options.watermark) drawWatermark(canvas, options.watermark);
+			const format = options.capture?.format || "png";
+			const defaultFilename = `screenshot-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace(/:/g, "-")}.${format}`;
+			downloadCanvas(canvas, filename || defaultFilename, format);
+			message.success("下载完成");
+		} catch (error) {
+			console.error("下载失败:", error);
+			message.error("下载失败");
+			throw error;
+		} finally {
+			loading.value = false;
+		}
+	};
+	const quickPrint = async (element, watermarkText = "Robot Admin") => {
+		return printWithWatermark(element, { watermark: {
+			text: watermarkText,
+			position: "repeat",
+			textColor: "rgba(128, 128, 128, 0.3)"
+		} });
+	};
+	const batchCapture = async (elements, options = {}) => {
+		const total = elements.length;
+		updateProgress(10);
+		const capturePromises = elements.map(async (element, index) => {
+			const url = await captureWithWatermark(element, options);
+			updateProgress(10 + (index + 1) / total * 70);
+			return url;
+		});
+		return Promise.all(capturePromises);
+	};
+	const serialPrint = async (imageUrls, printConfig = {}) => {
+		await imageUrls.reduce(async (prevPromise, imageUrl, index) => {
+			await prevPromise;
+			await printImage(imageUrl, printConfig);
+			if (index < imageUrls.length - 1) await new Promise((resolve) => {
+				setTimeout(() => resolve(), 1e3);
+			});
+		}, Promise.resolve());
+	};
+	const batchPrint = async (elements, options = {}) => {
+		if (!elements.length) {
+			message.warning("没有要打印的元素");
+			return;
+		}
+		loading.value = true;
+		try {
+			updateProgress(0);
+			const imageUrls = await batchCapture(elements, options);
+			updateProgress(80);
+			await serialPrint(imageUrls, options.print);
+			updateProgress(100);
+			message.success(`批量打印完成，共 ${elements.length} 个元素`);
+		} catch (error) {
+			console.error("批量打印失败:", error);
+			message.error("批量打印失败");
+			throw error;
+		} finally {
+			loading.value = false;
+			updateProgress(0);
+		}
+	};
+	const mergePrint = async (elements, options = {}, mergeOptions = {}) => {
+		const validatedOptions = validateAndGetMergeOptions(elements, mergeOptions, message);
+		if (!validatedOptions) return;
+		loading.value = true;
+		try {
+			await addWatermarkAndPrint(await captureAndMergeCanvas(elements, options, validatedOptions, updateProgress), options, elements.length, updateProgress, message);
+		} catch (error) {
+			console.error("合并打印失败:", error);
+			message.error("合并打印失败");
+			throw error;
+		} finally {
+			loading.value = false;
+			updateProgress(0);
+		}
+	};
+	const createPreset = (name, options) => {
+		return {
+			use: (element) => printWithWatermark(element, options),
+			download: (element, filename) => downloadScreenshot(element, filename, options)
+		};
+	};
+	return {
+		loading,
+		progress,
+		captureWithWatermark,
+		printWithWatermark,
+		downloadScreenshot,
+		quickPrint,
+		batchCapture,
+		batchPrint,
+		mergePrint,
+		createPreset,
+		updateProgress,
+		utils: {
+			captureElement,
+			drawWatermark,
+			canvasToDataURL,
+			downloadCanvas,
+			printImage
+		}
+	};
+}
+const printPresets = {
+	table: {
+		watermark: {
+			text: "Robot Admin - 数据表格",
+			position: "repeat",
+			textColor: "rgba(100, 100, 100, 0.25)",
+			textSize: 14,
+			xGap: 250,
+			yGap: 120
+		},
+		capture: { scale: 1.2 },
+		print: {
+			orientation: "landscape",
+			style: "@page { margin: 8mm; } body { font-family: Arial, sans-serif; }"
+		}
+	},
+	form: {
+		watermark: {
+			text: "Robot Admin - 表单数据",
+			position: "diagonal",
+			textColor: "rgba(150, 150, 150, 0.2)",
+			textSize: 16
+		},
+		print: { orientation: "portrait" }
+	},
+	report: {
+		watermark: {
+			text: "Robot Admin - 机密报告",
+			position: "center",
+			textColor: "rgba(200, 50, 50, 0.15)",
+			textSize: 24
+		},
+		capture: {
+			quality: .95,
+			format: "png"
+		}
+	}
+};
+
+//#endregion
+//#region src/components/C_Table/composables/useDynamicRow.ts
+/** 生成唯一ID */
+function generateUniqueId() {
+	return `row_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+}
+/** 获取行键值 */
+function getRowKey(row, rowKey) {
+	return typeof rowKey === "function" ? rowKey(row) : row[rowKey];
+}
+/** 创建新行数据 */
+function createNewRow(defaultRowData, rowKey) {
+	const newRow = defaultRowData?.() || {};
+	const keyField = typeof rowKey === "string" ? rowKey : "id";
+	return {
+		...newRow,
+		[keyField]: generateUniqueId()
+	};
+}
+/**
+* 表格动态行操作功能组合
+*/
+function useDynamicRows(data, options = {}) {
+	const message = useMessage$1();
+	const finalOptions = {
+		rowKey: "id",
+		enableRadioSelection: true,
+		enableAdd: true,
+		enableInsert: true,
+		enableDelete: true,
+		enableCopy: true,
+		enableMove: true,
+		enablePrint: true,
+		confirmDelete: true,
+		deleteConfirmText: "确定要删除选中的行吗？此操作不可撤销。",
+		printPreset: "table",
+		printTargetSelector: ".c-table-wrapper",
+		defaultRowData: () => ({}),
+		...options
+	};
+	const selectedRowKey = ref(null);
+	const deleteConfirmVisible = ref(false);
+	const selectedRowData = computed(() => {
+		if (selectedRowKey.value === null) return null;
+		return data.value.find((row) => getRowKey(row, finalOptions.rowKey) === selectedRowKey.value) || null;
+	});
+	const selectedRowIndex = computed(() => {
+		if (!selectedRowData.value) return -1;
+		return data.value.findIndex((row) => row === selectedRowData.value);
+	});
+	const canMoveUp = computed(() => selectedRowIndex.value > 0);
+	const canMoveDown = computed(() => selectedRowIndex.value >= 0 && selectedRowIndex.value < data.value.length - 1);
+	const { loading: printLoading, progress: printProgress, printWithWatermark, downloadScreenshot, quickPrint } = usePrintWatermark();
+	/** 获取打印配置选项 */
+	const getPrintOptions = () => {
+		if (finalOptions.printOptions) return finalOptions.printOptions;
+		const baseConfig = printPresets[finalOptions.printPreset || "table"];
+		if (finalOptions.printWatermarkText && baseConfig.watermark) return {
+			...baseConfig,
+			watermark: {
+				...baseConfig.watermark,
+				text: finalOptions.printWatermarkText
+			}
+		};
+		return baseConfig;
+	};
+	/** 更新表格数据 */
+	const updateData = (newData) => {
+		data.value = newData;
+		finalOptions.onRowChange?.(newData);
+	};
+	/** 添加新行到表格末尾 */
+	const addRow = () => {
+		if (!finalOptions.enableAdd) return;
+		const newRow = createNewRow(finalOptions.defaultRowData, finalOptions.rowKey);
+		updateData([...data.value, newRow]);
+		finalOptions.onRowAdd?.(newRow);
+		message.success("添加行成功");
+	};
+	/** 在选中行后插入新行 */
+	const insertRow = () => {
+		if (!finalOptions.enableInsert || !selectedRowData.value) {
+			message.warning("请先选择一行数据");
+			return;
+		}
+		const newRow = createNewRow(finalOptions.defaultRowData, finalOptions.rowKey);
+		const newData = [...data.value];
+		newData.splice(selectedRowIndex.value + 1, 0, newRow);
+		updateData(newData);
+		finalOptions.onRowAdd?.(newRow);
+		message.success("插入行成功");
+	};
+	/** 删除选中的行 */
+	const deleteRow = () => {
+		if (!finalOptions.enableDelete || !selectedRowData.value) {
+			message.warning("请先选择要删除的行");
+			return;
+		}
+		if (finalOptions.confirmDelete) deleteConfirmVisible.value = true;
+		else confirmDeleteFn();
+	};
+	/** 确认删除操作 */
+	const confirmDeleteFn = () => {
+		if (!selectedRowData.value) return;
+		const deletedRow = selectedRowData.value;
+		const deletedIndex = selectedRowIndex.value;
+		updateData(data.value.filter((_, index) => index !== deletedIndex));
+		selectedRowKey.value = null;
+		finalOptions.onSelectionChange?.(null, null);
+		finalOptions.onRowDelete?.(deletedRow, deletedIndex);
+		message.success("删除行成功");
+		deleteConfirmVisible.value = false;
+	};
+	/** 复制选中的行 */
+	const copyRow = () => {
+		if (!finalOptions.enableCopy || !selectedRowData.value) {
+			message.warning("请先选择要复制的行");
+			return;
+		}
+		const originalRow = selectedRowData.value;
+		const keyField = typeof finalOptions.rowKey === "string" ? finalOptions.rowKey : "id";
+		const { [keyField]: _originalKey, ...rowData } = originalRow;
+		const newRow = {
+			...rowData,
+			[keyField]: generateUniqueId()
+		};
+		updateData([...data.value, newRow]);
+		finalOptions.onRowCopy?.(originalRow, newRow);
+		message.success("复制行成功");
+	};
+	/** 将选中行向上移动 */
+	const moveRowUp = () => {
+		if (!finalOptions.enableMove || !canMoveUp.value) return;
+		const currentIndex = selectedRowIndex.value;
+		const newData = [...data.value];
+		const movingRow = newData[currentIndex];
+		[newData[currentIndex], newData[currentIndex - 1]] = [newData[currentIndex - 1], newData[currentIndex]];
+		updateData(newData);
+		finalOptions.onRowMove?.(movingRow, currentIndex, currentIndex - 1);
+		message.success("行已上移");
+	};
+	/** 将选中行向下移动 */
+	const moveRowDown = () => {
+		if (!finalOptions.enableMove || !canMoveDown.value) return;
+		const currentIndex = selectedRowIndex.value;
+		const newData = [...data.value];
+		const movingRow = newData[currentIndex];
+		[newData[currentIndex], newData[currentIndex + 1]] = [newData[currentIndex + 1], newData[currentIndex]];
+		updateData(newData);
+		finalOptions.onRowMove?.(movingRow, currentIndex, currentIndex + 1);
+		message.success("行已下移");
+	};
+	/** 选中指定行 */
+	const selectRow = (key) => {
+		const row = data.value.find((row) => getRowKey(row, finalOptions.rowKey) === key);
+		if (row) {
+			selectedRowKey.value = key;
+			finalOptions.onSelectionChange?.(key, row);
+		}
+	};
+	/** 清空选择状态 */
+	const clearSelection = () => {
+		selectedRowKey.value = null;
+		finalOptions.onSelectionChange?.(null, null);
+	};
+	/** 处理打印操作 */
+	const handlePrint = async (elementRef) => {
+		if (!elementRef.value) {
+			message.error("打印元素未找到");
+			return;
+		}
+		const printOptions = getPrintOptions();
+		await printWithWatermark(elementRef.value, printOptions);
+	};
+	/** 处理下载操作 */
+	const handleDownload = async (elementRef, filename) => {
+		if (!elementRef.value) {
+			message.error("下载元素未找到");
+			return;
+		}
+		const printOptions = getPrintOptions();
+		await downloadScreenshot(elementRef.value, filename, printOptions);
+	};
+	/** 处理快速打印操作 */
+	const handleQuickPrint = async (elementRef) => {
+		if (!elementRef.value) {
+			message.error("打印元素未找到");
+			return;
+		}
+		const watermarkText = finalOptions.printWatermarkText || "Robot Admin";
+		await quickPrint(elementRef.value, watermarkText);
+	};
+	/** 增强表格列配置，添加单选列 */
+	const enhanceColumns = (columns) => {
+		const enhancedColumns = [...columns];
+		if (finalOptions.enableRadioSelection) enhancedColumns.unshift({
+			key: "_radio_selection",
+			title: "选择",
+			width: 80,
+			align: "center",
+			editable: false,
+			render: (rowData) => {
+				const rowKeyVal = getRowKey(rowData, finalOptions.rowKey);
+				return h("div", { class: "flex justify-center" }, [h("input", {
+					type: "radio",
+					name: "table-radio-selection",
+					checked: selectedRowKey.value === rowKeyVal,
+					class: "cursor-pointer accent-blue-500 scale-110",
+					onChange: (e) => {
+						if (e.target.checked) selectRow(rowKeyVal);
+					}
+				})]);
+			}
+		});
+		return enhancedColumns;
+	};
+	/** 渲染工具栏 */
+	const renderToolbar = () => {
+		const buttons = [];
+		if (finalOptions.enablePrint) buttons.push(h(NButton$1, {
+			loading: printLoading.value,
+			type: "primary",
+			ghost: true,
+			onClick: async () => {
+				try {
+					const tableElement = document.querySelector(finalOptions.printTargetSelector);
+					if (tableElement) await handlePrint(ref(tableElement));
+					else console.warn("未找到表格容器元素");
+				} catch (error) {
+					console.error("打印失败:", error);
+				}
+			}
+		}, {
+			icon: () => h(C_Icon_default, {
+				name: "mdi:printer",
+				title: "打印"
+			}),
+			default: () => "打印"
+		}));
+		const rowButtons = [];
+		if (finalOptions.enableAdd) rowButtons.push(h(NButton$1, {
+			onClick: addRow,
+			type: "primary"
+		}, {
+			icon: () => h(C_Icon_default, {
+				name: "mdi:plus",
+				title: "增行"
+			}),
+			default: () => "增行"
+		}));
+		if (finalOptions.enableInsert) rowButtons.push(h(NTooltip$1, { disabled: !!selectedRowData.value }, {
+			trigger: () => h(NButton$1, {
+				onClick: insertRow,
+				disabled: !selectedRowData.value,
+				type: "primary",
+				ghost: true
+			}, {
+				icon: () => h(C_Icon_default, {
+					name: "mdi:table-row-plus-after",
+					title: "插行"
+				}),
+				default: () => "插行"
+			}),
+			default: () => "请先选择一行数据"
+		}));
+		if (finalOptions.enableDelete) rowButtons.push(h(NTooltip$1, { disabled: !!selectedRowData.value }, {
+			trigger: () => h(NButton$1, {
+				onClick: deleteRow,
+				disabled: !selectedRowData.value,
+				type: "error",
+				ghost: true
+			}, {
+				icon: () => h(C_Icon_default, {
+					name: "mdi:delete",
+					title: "删除行"
+				}),
+				default: () => "删除行"
+			}),
+			default: () => "请先选择要删除的行"
+		}));
+		if (finalOptions.enableCopy) rowButtons.push(h(NTooltip$1, { disabled: !!selectedRowData.value }, {
+			trigger: () => h(NButton$1, {
+				onClick: copyRow,
+				disabled: !selectedRowData.value,
+				type: "info",
+				ghost: true
+			}, {
+				icon: () => h(C_Icon_default, {
+					name: "mdi:content-copy",
+					title: "复制行"
+				}),
+				default: () => "复制行"
+			}),
+			default: () => "请先选择要复制的行"
+		}));
+		if (finalOptions.enableMove) rowButtons.push(h(NTooltip$1, { disabled: canMoveUp.value }, {
+			trigger: () => h(NButton$1, {
+				onClick: moveRowUp,
+				disabled: !canMoveUp.value,
+				type: "warning",
+				ghost: true
+			}, {
+				icon: () => h(C_Icon_default, {
+					name: "mdi:arrow-up",
+					title: "上移"
+				}),
+				default: () => "上移"
+			}),
+			default: () => !selectedRowData.value ? "请先选择数据" : "已经是第一行"
+		}), h(NTooltip$1, { disabled: canMoveDown.value }, {
+			trigger: () => h(NButton$1, {
+				onClick: moveRowDown,
+				disabled: !canMoveDown.value,
+				type: "warning",
+				ghost: true
+			}, {
+				icon: () => h(C_Icon_default, {
+					name: "mdi:arrow-down",
+					title: "下移"
+				}),
+				default: () => "下移"
+			}),
+			default: () => !selectedRowData.value ? "请先选择数据" : "已经是最后一行"
+		}));
+		if (rowButtons.length > 0) buttons.push(h(NButtonGroup$1, {}, () => rowButtons));
+		return h("div", { class: "dynamic-rows-toolbar mb-4 flex justify-end" }, [h(NSpace$1, {}, () => buttons)]);
+	};
+	/** 渲染删除确认模态框 */
+	const renderConfirmModal = () => {
+		return h(NModal$1, {
+			show: deleteConfirmVisible.value,
+			"onUpdate:show": (show) => {
+				deleteConfirmVisible.value = show;
+			},
+			preset: "dialog",
+			title: "确认删除",
+			content: finalOptions.deleteConfirmText,
+			positiveText: "确认删除",
+			negativeText: "取消",
+			onPositiveClick: confirmDeleteFn
+		});
+	};
+	onBeforeUnmount(() => {
+		selectedRowKey.value = null;
+		deleteConfirmVisible.value = false;
+	});
+	return {
+		selectedRowKey,
+		selectedRowData,
+		selectedRowIndex,
+		canMoveUp,
+		canMoveDown,
+		deleteConfirmVisible,
+		printLoading,
+		printProgress,
+		addRow,
+		insertRow,
+		deleteRow,
+		confirmDelete: confirmDeleteFn,
+		copyRow,
+		moveRowUp,
+		moveRowDown,
+		selectRow,
+		clearSelection,
+		handlePrint,
+		handleDownload,
+		handleQuickPrint,
+		enhanceColumns,
+		renderToolbar,
+		renderConfirmModal
+	};
+}
+
+//#endregion
+//#region src/components/C_Table/composables/useTableManager.ts
+/**
+* 表格统一状态管理器
+*/
+function useTableManager(params) {
+	const { config, data, rowKey, emit } = params;
+	/** 创建事件处理器集合 */
+	const createEventHandlers = () => ({
+		onSave: async (rowData, rowIndex, columnKey) => {
+			if (!rowData || rowIndex < 0 || rowIndex >= data().length) return;
+			const newData = [...data()];
+			newData[rowIndex] = {
+				...newData[rowIndex],
+				...rowData
+			};
+			emit("update:data", newData);
+			await nextTick();
+			emit("save", newData[rowIndex], rowIndex, columnKey);
+		},
+		onCancel: (rowData, rowIndex) => {
+			emit("cancel", rowData, rowIndex);
+		},
+		onExpandChange: (keys, row, expanded) => {
+			emit("expand-change", keys, row, expanded);
+		},
+		onSelectionChange: (checkedKeys, checkedRows, childSelections) => {
+			emit("selection-change", checkedKeys, checkedRows, childSelections);
+		},
+		onChildSelectionChange: (parentKey, childKeys, childRows) => {
+			emit("child-selection-change", parentKey, childKeys, childRows);
+		},
+		onRowChange: (data) => {
+			emit("update:data", data);
+			config.dynamicRows?.onRowChange?.(data);
+		},
+		onRowSelectionChange: (selectedKey, selectedRow) => {
+			emit("row-selection-change", selectedKey, selectedRow);
+			config.dynamicRows?.onSelectionChange?.(selectedKey, selectedRow);
+		},
+		onRowAdd: (newRow) => {
+			emit("row-add", newRow);
+			config.dynamicRows?.onRowAdd?.(newRow);
+		},
+		onRowDelete: (deletedRow, index) => {
+			emit("row-delete", deletedRow, index);
+			config.dynamicRows?.onRowDelete?.(deletedRow, index);
+		},
+		onRowCopy: (originalRow, newRow) => {
+			emit("row-copy", originalRow, newRow);
+			config.dynamicRows?.onRowCopy?.(originalRow, newRow);
+		},
+		onRowMove: (row, fromIndex, toIndex) => {
+			emit("row-move", row, fromIndex, toIndex);
+			config.dynamicRows?.onRowMove?.(row, fromIndex, toIndex);
+		}
+	});
+	const eventHandlers = createEventHandlers();
+	/** 初始化编辑功能状态 */
+	const initEditStates = () => {
+		return {
+			rowEdit: useRowEdit({
+				data,
+				rowKey,
+				onSave: eventHandlers.onSave,
+				onCancel: eventHandlers.onCancel
+			}),
+			cellEdit: useCellEdit({
+				data,
+				rowKey,
+				onSave: eventHandlers.onSave
+			}),
+			modalEdit: useModalEdit({
+				data,
+				rowKey,
+				onSave: eventHandlers.onSave,
+				onCancel: eventHandlers.onCancel
+			})
+		};
+	};
+	/** 初始化展开功能状态 */
+	const initExpandState = () => {
+		if (!(config.expandable || config.enableSelection || config.enableChildSelection)) return null;
+		return useTableExpand({
+			data: computed(() => data()),
+			rowKey,
+			childRowKey: (child) => child.id,
+			defaultExpandedKeys: config.defaultExpandedKeys,
+			onLoadData: config.onLoadExpandData,
+			renderContent: config.renderExpandContent,
+			rowExpandable: config.rowExpandable,
+			enableSelection: config.enableSelection,
+			defaultCheckedKeys: config.defaultCheckedKeys,
+			rowCheckable: config.rowCheckable,
+			maxSelection: config.maxSelection,
+			enableChildSelection: config.enableChildSelection,
+			childRowCheckable: config.childRowCheckable,
+			enableParentChildLink: config.enableParentChildLink,
+			parentChildLinkMode: config.parentChildLinkMode,
+			onExpandChange: eventHandlers.onExpandChange,
+			onSelectionChange: eventHandlers.onSelectionChange,
+			onChildSelectionChange: eventHandlers.onChildSelectionChange
+		});
+	};
+	/** 初始化动态行功能状态 */
+	const initDynamicRowsState = () => {
+		if (!config.dynamicRows) return null;
+		const dynamicOptions = {
+			...config.dynamicRows,
+			onRowChange: eventHandlers.onRowChange,
+			onSelectionChange: eventHandlers.onRowSelectionChange,
+			onRowAdd: eventHandlers.onRowAdd,
+			onRowDelete: eventHandlers.onRowDelete,
+			onRowCopy: eventHandlers.onRowCopy,
+			onRowMove: eventHandlers.onRowMove
+		};
+		return useDynamicRows(computed(() => data()), dynamicOptions);
+	};
+	const editStates = initEditStates();
+	const expandState = initExpandState();
+	const dynamicRowsState = initDynamicRowsState();
+	/** 创建统一的状态管理器 */
+	const createStateManager = () => {
+		return {
+			edit: {
+				start(rowKey, columnKey) {
+					const mode = config.editMode;
+					if (mode === "modal") editStates.modalEdit.startEdit(rowKey);
+					else if (mode === "cell" && columnKey) editStates.cellEdit.startEditCell(rowKey, columnKey);
+					else if (mode === "row" || mode === "both") editStates.rowEdit.startEditRow(rowKey);
+				},
+				cancel() {
+					if (editStates.modalEdit.isModalVisible.value) editStates.modalEdit.cancelEdit();
+					else if (editStates.cellEdit.editingCell.value.rowKey) editStates.cellEdit.cancelEditCell();
+					else if (editStates.rowEdit.editingRowKey.value) editStates.rowEdit.cancelEditRow();
+				},
+				async save() {
+					if (editStates.modalEdit.isModalVisible.value) await editStates.modalEdit.saveEdit();
+					else if (editStates.cellEdit.editingCell.value.rowKey) await editStates.cellEdit.saveEditCell();
+					else if (editStates.rowEdit.editingRowKey.value) await editStates.rowEdit.saveEditRow();
+				},
+				isEditing(rowKey, columnKey) {
+					if (config.editMode === "modal") return editStates.modalEdit.isEditingRow(rowKey);
+					if (columnKey) return editStates.cellEdit.isEditingCell(rowKey, columnKey);
+					return editStates.rowEdit.isEditingRow(rowKey);
+				},
+				getEditingData() {
+					if (editStates.modalEdit.isModalVisible.value) return editStates.modalEdit.editingData;
+					if (editStates.rowEdit.editingRowKey.value) return editStates.rowEdit.getEditingRowData(editStates.rowEdit.editingRowKey.value);
+					return null;
+				}
+			},
+			expand: {
+				async row(rowKey) {
+					if (expandState) {
+						const currentKeys = [...expandState.expandedKeys.value];
+						if (!currentKeys.includes(rowKey)) {
+							currentKeys.push(rowKey);
+							expandState.handleExpandChange(currentKeys);
+						}
+					}
+				},
+				collapse(rowKey) {
+					if (expandState) {
+						const currentKeys = expandState.expandedKeys.value.filter((key) => key !== rowKey);
+						expandState.handleExpandChange(currentKeys);
+					}
+				},
+				async toggle(rowKey) {
+					if (expandState?.expandedKeys.value.includes(rowKey)) this.collapse(rowKey);
+					else await this.row(rowKey);
+				},
+				async all() {
+					await expandState?.expandAll();
+				},
+				collapseAll() {
+					expandState?.collapseAll();
+				},
+				isExpanded(rowKey) {
+					return expandState?.expandedKeys.value.includes(rowKey) ?? false;
+				}
+			},
+			selection: {
+				select(rowKey) {
+					if (expandState?.checkedKeys.value && !expandState.checkedKeys.value.includes(rowKey)) {
+						const newKeys = [...expandState.checkedKeys.value, rowKey];
+						expandState.handleSelectionChange(newKeys);
+					}
+				},
+				unselect(rowKey) {
+					if (expandState?.checkedKeys.value) {
+						const newKeys = expandState.checkedKeys.value.filter((key) => key !== rowKey);
+						expandState.handleSelectionChange(newKeys);
+					}
+				},
+				all() {
+					expandState?.selectAll();
+				},
+				clear() {
+					expandState?.clearSelection();
+				},
+				isSelected(rowKey) {
+					return expandState?.checkedKeys.value.includes(rowKey) ?? false;
+				},
+				getSelected() {
+					if (!expandState?.checkedKeys.value) return [];
+					return data().filter((row) => expandState.checkedKeys.value.includes(rowKey(row)));
+				}
+			},
+			childSelection: {
+				select(parentKey, childKey) {
+					if (expandState?.childSelections.value) {
+						const current = expandState.childSelections.value.get(parentKey) || [];
+						if (!current.includes(childKey)) {
+							const newSelection = [...current, childKey];
+							expandState.childSelections.value.set(parentKey, newSelection);
+							emit("child-selection-change", parentKey, newSelection, []);
+						}
+					}
+				},
+				unselect(parentKey, childKey) {
+					if (expandState?.childSelections.value) {
+						const newSelection = (expandState.childSelections.value.get(parentKey) || []).filter((k) => k !== childKey);
+						expandState.childSelections.value.set(parentKey, newSelection);
+						emit("child-selection-change", parentKey, newSelection, []);
+					}
+				},
+				selectAll(parentKey) {
+					if (expandState?.childSelections.value && expandState.expandDataMap?.value) {
+						const expandData = expandState.expandDataMap.value.get(parentKey) || [];
+						const allChildKeys = expandData.map((child) => child.id);
+						expandState.childSelections.value.set(parentKey, allChildKeys);
+						emit("child-selection-change", parentKey, allChildKeys, expandData);
+					}
+				},
+				clear(parentKey) {
+					if (expandState?.childSelections.value) {
+						expandState.childSelections.value.set(parentKey, []);
+						emit("child-selection-change", parentKey, [], []);
+					}
+				},
+				getSelected(parentKey) {
+					if (!expandState?.childSelections.value || !expandState.expandDataMap?.value) return [];
+					const selectedKeys = expandState.childSelections.value.get(parentKey) || [];
+					return (expandState.expandDataMap.value.get(parentKey) || []).filter((child) => selectedKeys.includes(child.id));
+				}
+			},
+			dynamicRows: {
+				add() {
+					dynamicRowsState?.addRow();
+				},
+				insert() {
+					dynamicRowsState?.insertRow();
+				},
+				delete() {
+					dynamicRowsState?.deleteRow();
+				},
+				copy() {
+					dynamicRowsState?.copyRow();
+				},
+				moveUp() {
+					dynamicRowsState?.moveRowUp();
+				},
+				moveDown() {
+					dynamicRowsState?.moveRowDown();
+				},
+				clearSelection() {
+					dynamicRowsState?.clearSelection();
+				},
+				getSelected() {
+					return dynamicRowsState?.selectedRowData.value || null;
+				},
+				async print(elementRef) {
+					if (dynamicRowsState && elementRef) await dynamicRowsState.handlePrint(ref(elementRef));
+				},
+				async download(elementRef, filename) {
+					if (dynamicRowsState && elementRef) await dynamicRowsState.handleDownload(ref(elementRef), filename);
+				}
+			},
+			clearAllSelections() {
+				expandState?.clearAllSelections();
+			}
+		};
+	};
+	return {
+		editStates,
+		expandState,
+		dynamicRowsState,
+		stateManager: createStateManager(),
+		expandedKeys: computed(() => expandState?.expandedKeys.value ?? []),
+		checkedKeys: computed(() => expandState?.checkedKeys.value ?? []),
+		eventHandlers
+	};
+}
+
+//#endregion
+//#region src/components/C_Table/composables/usePagination.ts
+const DEFAULT_PAGINATION_CONFIG = {
+	enabled: true,
+	page: 1,
+	pageSize: 10,
+	showSizePicker: true,
+	showQuickJumper: true,
+	pageSizes: [
+		10,
+		20,
+		50,
+		100
+	],
+	simple: false,
+	size: "medium"
+};
+function usePagination(options) {
+	const { data, config, emit } = options;
+	const currentPage = ref(1);
+	const currentPageSize = ref(10);
+	const dataSource = computed(() => {
+		if (typeof data === "function") return data() || [];
+		return unref(data) || [];
+	});
+	/** 分页后的数据 */
+	const paginatedData = computed(() => {
+		if (!config.value?.enabled) return dataSource.value;
+		const start = (currentPage.value - 1) * currentPageSize.value;
+		const end = start + currentPageSize.value;
+		return dataSource.value.slice(start, end);
+	});
+	/** 分页配置对象 */
+	const paginationConfig = computed(() => {
+		if (!config.value?.enabled) return null;
+		return {
+			page: currentPage.value,
+			pageSize: currentPageSize.value,
+			itemCount: dataSource.value.length,
+			showSizePicker: config.value.showSizePicker ?? DEFAULT_PAGINATION_CONFIG.showSizePicker,
+			showQuickJumper: config.value.showQuickJumper ?? DEFAULT_PAGINATION_CONFIG.showQuickJumper,
+			pageSizes: config.value.pageSizes ?? DEFAULT_PAGINATION_CONFIG.pageSizes,
+			simple: config.value.simple ?? DEFAULT_PAGINATION_CONFIG.simple,
+			size: config.value.size ?? DEFAULT_PAGINATION_CONFIG.size,
+			prefix: (info) => `共 ${info.itemCount} 条`,
+			suffix: (info) => `第 ${info.startIndex + 1}-${info.endIndex} 条`,
+			"onUpdate:page": handlePageChange,
+			"onUpdate:pageSize": handlePageSizeChange
+		};
+	});
+	/** 页码变化处理 */
+	const handlePageChange = (page) => {
+		currentPage.value = page;
+		emit?.("pagination-change", page, currentPageSize.value);
+	};
+	/** 页面大小变化处理 */
+	const handlePageSizeChange = (pageSize) => {
+		currentPageSize.value = pageSize;
+		currentPage.value = 1;
+		emit?.("pagination-change", 1, pageSize);
+	};
+	/** 重置到第一页 */
+	const resetToFirstPage = () => {
+		if (currentPage.value !== 1) handlePageChange(1);
+	};
+	/** 获取总页数 */
+	const getTotalPages = () => {
+		if (!config.value?.enabled || currentPageSize.value === 0) return 1;
+		return Math.ceil(dataSource.value.length / currentPageSize.value);
+	};
+	/** 初始化分页配置 */
+	watchEffect(() => {
+		if (config.value?.enabled) {
+			currentPage.value = config.value.page ?? DEFAULT_PAGINATION_CONFIG.page;
+			currentPageSize.value = config.value.pageSize ?? DEFAULT_PAGINATION_CONFIG.pageSize;
+		}
+	});
+	/** 监听数据变化，确保分页状态正确 */
+	watch(() => dataSource.value.length, (newLength) => {
+		if (config.value?.enabled && currentPage.value > 1) {
+			const maxPage = Math.ceil(newLength / currentPageSize.value);
+			if (currentPage.value > maxPage) currentPage.value = Math.max(1, maxPage);
+		}
+	});
+	return {
+		currentPage,
+		currentPageSize,
+		paginatedData,
+		paginationConfig,
+		handlePageChange,
+		handlePageSizeChange,
+		resetToFirstPage,
+		getTotalPages
+	};
+}
+
+//#endregion
+//#region src/components/C_Table/composables/useTableActions.ts
+/**
+* 表格操作Hook
+*/
+function useTableActions(options) {
+	const { actions, config, tableManager, rowKey, emit, onViewDetail } = options;
+	const message = useMessage();
+	const dialog = useDialog();
+	const isActionEnabled = (key) => actions.value?.[key] !== false;
+	const isValidApiFunction = (action) => {
+		return action !== false && typeof action === "function";
+	};
+	const extractApiResponseData = (response) => {
+		if (response && typeof response === "object" && "data" in response) return response.data;
+		return response;
+	};
+	const createButton = (icon, title, type = "primary", onClick) => h(NButton, {
+		size: "small",
+		type,
+		quaternary: true,
+		onClick
+	}, () => [h(C_Icon_default, {
+		name: icon,
+		size: 14,
+		title
+	})]);
+	const handleEdit = (row, _index) => {
+		const rowKeyValue = rowKey(row);
+		const editAction = actions.value?.edit;
+		if (config.value.editMode === "modal") tableManager.editStates.modalEdit.startEdit(rowKeyValue, { ...row }, editAction);
+		else tableManager.editStates.rowEdit.startEditRow(rowKeyValue, editAction);
+	};
+	const executeDelete = async (deleteAction, row, index) => {
+		try {
+			await deleteAction(row, index);
+			message.success("删除成功");
+			emit("row-delete", row, index);
+		} catch (error) {
+			console.error("删除失败:", error);
+			message.error("删除失败");
+			throw error;
+		}
+	};
+	const handleDelete = (row, index) => {
+		const deleteAction = actions.value?.delete;
+		if (!isValidApiFunction(deleteAction)) return;
+		dialog.warning({
+			title: "确认删除",
+			content: "确定要删除这条记录吗？",
+			positiveText: "确定",
+			negativeText: "取消",
+			onPositiveClick: () => executeDelete(deleteAction, row, index)
+		});
+	};
+	const handleDetail = async (row, index) => {
+		const detailAction = actions.value?.detail;
+		if (!isValidApiFunction(detailAction)) {
+			onViewDetail?.(row);
+			return;
+		}
+		try {
+			const detailData = extractApiResponseData(await detailAction(row, index));
+			onViewDetail?.(detailData || row);
+		} catch (error) {
+			console.error("获取详情失败:", error);
+			message.error("获取详情失败");
+			onViewDetail?.(row);
+		}
+	};
+	const renderRowEditButtons = (rowKeyValue) => {
+		if (tableManager.editStates.rowEdit.isEditingRow(rowKeyValue)) return [createButton("mdi:check", "保存", "primary", () => tableManager.editStates.rowEdit.saveEditRow()), createButton("mdi:close", "取消", "default", () => tableManager.editStates.rowEdit.cancelEditRow())];
+		return [createButton("mdi:pencil", "编辑", "warning", () => tableManager.editStates.rowEdit.startEditRow(rowKeyValue))];
+	};
+	const renderBasicActions = (row, index) => {
+		const buttons = [];
+		if (isActionEnabled("detail")) buttons.push(createButton("mdi:eye", "详情", "info", () => handleDetail(row, index)));
+		if (config.value.editMode === "modal" && (isActionEnabled("edit") || config.value.editable)) buttons.push(createButton("mdi:pencil", "编辑", "warning", () => handleEdit(row, index)));
+		if (isActionEnabled("delete")) buttons.push(createButton("mdi:delete", "删除", "error", () => handleDelete(row, index)));
+		return buttons;
+	};
+	const renderCustomDropdown = (row, index) => {
+		const customActions = actions.value?.custom;
+		if (!customActions?.length) return null;
+		const visibleActions = customActions.filter((action) => action.show ? action.show(row, index) : true);
+		if (!visibleActions.length) return null;
+		return h(NDropdown, {
+			options: visibleActions.map((action) => {
+				const label = typeof action.label === "function" ? action.label(row, index) : action.label;
+				const icon = typeof action.icon === "function" ? action.icon(row, index) : action.icon;
+				return {
+					label,
+					key: action.key,
+					icon: () => h(C_Icon_default, {
+						name: icon,
+						size: 14
+					}),
+					disabled: action.disabled?.(row, index) || false
+				};
+			}),
+			onSelect: (key) => {
+				const action = visibleActions.find((a) => a.key === key);
+				if (action) try {
+					action.onClick(row, index);
+				} catch (error) {
+					console.error(`操作"${action.label}"执行失败:`, error);
+					message.error(`${action.label}失败`);
+				}
+			}
+		}, () => createButton("mdi:dots-horizontal", "更多操作", "default", () => {}));
+	};
+	const renderActions = (row, index) => {
+		if (actions.value?.render) return actions.value.render(row, index);
+		const rowKeyValue = rowKey(row);
+		const isRowEditMode = ["row", "both"].includes(config.value.editMode);
+		if (isRowEditMode && tableManager.editStates.rowEdit.isEditingRow(rowKeyValue)) return h(NSpace, {
+			size: 2,
+			wrap: false
+		}, () => renderRowEditButtons(rowKeyValue));
+		const allButtons = [...isRowEditMode ? renderRowEditButtons(rowKeyValue) : [], ...renderBasicActions(row, index)];
+		const dropdown = renderCustomDropdown(row, index);
+		if (dropdown) allButtons.push(dropdown);
+		return h(NSpace, {
+			size: 2,
+			wrap: false
+		}, () => allButtons);
+	};
+	return {
+		renderActions,
+		isActionEnabled
+	};
+}
+
+//#endregion
+//#region src/components/C_Table/data.ts
+const EDIT_COMPONENTS = {
+	number: NInputNumber,
+	switch: NSwitch,
+	input: NInput,
+	email: NInput,
+	mobile: NInput,
+	date: (props) => h(NDatePicker, {
+		...props,
+		type: "date",
+		format: "yyyy-MM-dd"
+	}),
+	select: (props) => h(NSelect, {
+		...props,
+		options: props.options || []
+	}),
+	textarea: (props) => h(NInput, {
+		...props,
+		type: "textarea",
+		rows: 3
+	})
+};
+const EDIT_TO_FORM_TYPE = {
+	number: "inputNumber",
+	date: "datePicker",
+	textarea: "textarea",
+	select: "select",
+	switch: "switch"
+};
+/**
+* 根据可编辑列配置自动生成表单选项（用于编辑弹窗）
+*/
+const generateFormOptions = (columns) => columns.map((column) => {
+	const rules = column.required ? [{
+		required: true,
+		message: `请输入${column.title}`,
+		trigger: ["blur", "input"],
+		validator: async (_, value) => {
+			if (!value && value !== 0 && value !== false) throw new Error(`请输入${column.title}`);
+		}
+	}] : [];
+	return {
+		prop: column.key,
+		label: column.title || column.key,
+		type: EDIT_TO_FORM_TYPE[column.editType || "input"] || "input",
+		placeholder: `请输入${column.title}`,
+		rules,
+		attrs: column.editProps || {},
+		layout: { span: 1 },
+		show: true
+	};
+});
+
+//#endregion
+//#region src/components/C_Table/composables/useTableColumns.ts
+/**
+* 渲染编辑组件（行编辑/单元格编辑通用）
+*/
+function renderEditComponent(column, value, onUpdate) {
+	if (column.editRender) return column.editRender(value, {}, 0);
+	const col = column;
+	const componentProps = {
+		value,
+		"onUpdate:value": onUpdate,
+		placeholder: `请输入${col.title ?? ""}`,
+		style: { width: "100%" },
+		...column.editProps
+	};
+	return h(EDIT_COMPONENTS[column.editType || "input"] || EDIT_COMPONENTS.input, componentProps);
+}
+/**
+* 渲染只读单元格
+*/
+function renderDisplayCell(column, rowData, rowIndex, value) {
+	return column.render ? column.render(rowData, rowIndex) ?? String(value ?? "") : String(value ?? "");
+}
+/**
+* 渲染编辑中的单元格（带保存/取消按钮）
+*/
+function renderEditingCell(column, value, onUpdate, onSave, onCancel) {
+	const actionBtn = (name, title, onClick) => h("button", {
+		class: `cell-action-btn cell-action-${name}`,
+		title,
+		type: "button",
+		onClick: (e) => {
+			e.stopPropagation();
+			e.preventDefault();
+			onClick(e);
+		}
+	}, [h(C_Icon_default, {
+		name: `mdi:${name === "save" ? "check" : "close"}`,
+		title: name === "save" ? "保存" : "取消",
+		size: 12
+	})]);
+	return h("div", { class: "cell-editing-container" }, [h("div", { class: "cell-editing-input" }, [renderEditComponent(column, value, onUpdate)]), h("div", { class: "cell-editing-actions" }, [actionBtn("save", "保存", onSave), actionBtn("cancel", "取消", onCancel)])]);
+}
+/**
+* 渲染可编辑单元格（显示值 + 编辑图标）
+*/
+function renderEditableCell(column, rowData, rowIndex, value, onStartEdit) {
+	return h("div", { class: "cell-edit-wrapper" }, [h("span", { class: "cell-value" }, column.render ? column.render(rowData, rowIndex) ?? String(value ?? "") : String(value ?? "")), h(C_Icon_default, {
+		name: "mdi:square-edit-outline",
+		title: "编辑",
+		class: "cell-edit-icon",
+		size: 14,
+		clickable: true,
+		onClick: (e) => {
+			e.stopPropagation();
+			onStartEdit();
+		}
+	})]);
+}
+/**
+* 表格列处理引擎
+*/
+function useTableColumns(options) {
+	const { rawColumns, config, columnWidth, rowKey, tableManager, actionsRenderer, editModeChecker } = options;
+	const reactiveColumns = ref([]);
+	const showSettingsPanel = ref(false);
+	/** 同步外部列配置到响应式状态 */
+	const syncColumns = (newColumns) => {
+		const existingActions = reactiveColumns.value.find((col) => col.key === "_actions");
+		reactiveColumns.value = [...newColumns, existingActions || {
+			key: "_actions",
+			title: "操作",
+			width: 180,
+			editable: false,
+			visible: true,
+			fixed: "right"
+		}];
+	};
+	watch(rawColumns, (cols) => {
+		if (cols?.length) syncColumns(cols);
+	}, {
+		deep: true,
+		immediate: true
+	});
+	/** 单元格编辑模式渲染 */
+	const renderCellEdit = (column, rowData, rowIndex, rowKeyVal) => {
+		const colKey = column.key ?? "";
+		const value = rowData[colKey];
+		const { isEditingCell, getEditingCellValue, updateEditingCellValue, saveEditCell, cancelEditCell, startEditCell } = tableManager.editStates.cellEdit;
+		if (isEditingCell(rowKeyVal, colKey)) return renderEditingCell(column, getEditingCellValue(rowKeyVal, colKey) ?? value, (val) => updateEditingCellValue(rowKeyVal, colKey, val), () => saveEditCell(), () => cancelEditCell());
+		return renderEditableCell(column, rowData, rowIndex, value, () => startEditCell(rowKeyVal, colKey));
+	};
+	/** 统一单元格渲染入口 */
+	const renderCell = (column, rowData, rowIndex) => {
+		const colKey = column.key ?? "";
+		const value = rowData[colKey];
+		const key = rowKey(rowData);
+		const checker = editModeChecker.value;
+		if (checker.isNonEditable(column)) return renderDisplayCell(column, rowData, rowIndex, value);
+		if (checker.isRowEditMode() && tableManager.editStates.rowEdit.isEditingRow(key)) return renderEditComponent(column, tableManager.editStates.rowEdit.getEditingRowData(key)?.[colKey] ?? value, (val) => tableManager.editStates.rowEdit.updateEditingRowData(key, colKey, val));
+		if (checker.isCellEditMode()) return renderCellEdit(column, rowData, rowIndex, key);
+		return renderDisplayCell(column, rowData, rowIndex, value);
+	};
+	const getColWidth = (col) => {
+		const w = col.width || columnWidth || 180;
+		return typeof w === "number" ? w : 180;
+	};
+	/** 序号列 */
+	const mapIndexColumn = (column) => {
+		const col = column;
+		return {
+			key: "_index",
+			title: col.title || "序号",
+			width: typeof (col.width || 50) === "number" ? col.width || 50 : 50,
+			titleAlign: "center",
+			align: "center",
+			render: (_, index) => index + 1,
+			fixed: column.fixed
+		};
+	};
+	/** 普通数据列 */
+	const mapRegularColumn = (column) => {
+		const col = column;
+		const base = {
+			...col,
+			width: getColWidth(column),
+			titleAlign: col.titleAlign || "center",
+			align: col.align || "center",
+			render: column.render || ((rowData, rowIndex) => renderCell(column, rowData, rowIndex))
+		};
+		if (column.fixed) base.fixed = column.fixed;
+		if (column.resizable && typeof base.width === "number") {
+			base.resizable = true;
+			base.minWidth = column.minWidth || 80;
+			base.maxWidth = column.maxWidth || 500;
+		}
+		return base;
+	};
+	const computedColumns = computed(() => {
+		let cols = reactiveColumns.value.filter((c) => {
+			const col = c;
+			return col.visible !== false && col.key !== "_actions";
+		}).map((c) => {
+			return c.type === "index" ? mapIndexColumn(c) : mapRegularColumn(c);
+		});
+		if (tableManager.dynamicRowsState) cols = tableManager.dynamicRowsState.enhanceColumns(cols);
+		if (tableManager.expandState && (config.value.expandable || config.value.enableSelection)) cols = tableManager.expandState.getTableColumns(cols);
+		const actionsMeta = reactiveColumns.value.find((c) => c.key === "_actions");
+		cols.push({
+			key: "_actions",
+			title: "操作",
+			align: "center",
+			titleAlign: "center",
+			render: actionsRenderer,
+			fixed: actionsMeta?.fixed
+		});
+		return cols;
+	});
+	const computedScrollX = computed(() => {
+		if (options.scrollX !== void 0) return options.scrollX;
+		if (!reactiveColumns.value.some((c) => {
+			const col = c;
+			return col.fixed && col.visible !== false;
+		})) return void 0;
+		return reactiveColumns.value.filter((c) => c.visible !== false).reduce((sum, c) => sum + getColWidth(c), 0) + 200;
+	});
+	const handleColumnChange = (columns) => {
+		reactiveColumns.value = columns.map((col) => {
+			const c = col;
+			return {
+				...col,
+				visible: c.visible !== false,
+				fixed: col.fixed,
+				width: c.width || columnWidth,
+				align: c.align || "center",
+				titleAlign: c.titleAlign || "center"
+			};
+		});
+	};
+	return {
+		reactiveColumns,
+		showSettingsPanel,
+		computedColumns,
+		computedScrollX,
+		handleColumnChange
+	};
+}
+
+//#endregion
+//#region src/components/C_Table/components/ColumnSettings/data.ts
+/** 固定列下拉选项 */
+const getFixedOptions = (column) => [
+	{
+		label: column.fixed ? "✓ 取消固定" : "不固定",
+		key: "none",
+		disabled: !column.fixed
+	},
+	{
+		label: column.fixed === "left" ? "✓ 固定左侧" : "固定左侧",
+		key: "left",
+		disabled: false
+	},
+	{
+		label: column.fixed === "right" ? "✓ 固定右侧" : "固定右侧",
+		key: "right",
+		disabled: false
+	}
+];
+/** 不可操作的特殊列 key */
+const SPECIAL_COLUMN_KEYS = ["_actions"];
+/** 不可拖拽的列 type */
+const SPECIAL_COLUMN_TYPES = ["selection", "expand"];
+/** 判断是否为特殊列（不可调宽、不可拖拽） */
+const isSpecialColumn = (column) => SPECIAL_COLUMN_KEYS.includes(column.key) || SPECIAL_COLUMN_TYPES.includes(column.type);
+
+//#endregion
+//#region src/components/C_Table/components/ColumnSettings/index.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1$1 = { class: "column-management-tab" };
+const _hoisted_2$1 = { class: "search-row" };
+const _hoisted_3$1 = { class: "resizable-control" };
+const _hoisted_4$1 = { class: "top-actions-bar" };
+const _hoisted_5 = { class: "stats-info" };
+const _hoisted_6 = { class: "quick-actions" };
+const _hoisted_7 = [
+	"draggable",
+	"onDragstart",
+	"onDragover",
+	"onDrop"
+];
+const _hoisted_8 = { class: "column-info" };
+const _hoisted_9 = { class: "column-controls" };
+const _hoisted_10 = { class: "column-details" };
+const _hoisted_11 = { class: "column-actions" };
+const _hoisted_12 = { class: "drag-controls" };
+var index_vue_vue_type_script_setup_true_lang_default$1 = /* @__PURE__ */ defineComponent({
+	name: "ColumnSettings",
+	__name: "index",
+	props: { columns: {} },
+	emits: ["change"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const localColumns = ref([...props.columns]);
+		const searchText = ref("");
+		const listRef = ref();
+		const draggedIndex = ref(null);
+		const dragOverIndex = ref(null);
+		const enableResizable = ref(false);
+		onMounted(() => {
+			enableResizable.value = localColumns.value.some((col) => col.resizable === true);
+		});
+		const filteredColumns = computed(() => {
+			if (!searchText.value) return localColumns.value;
+			const search = searchText.value.toLowerCase();
+			return localColumns.value.filter((col) => col.title?.toLowerCase().includes(search) || col.key.toLowerCase().includes(search));
+		});
+		const visibleCount = computed(() => localColumns.value.filter((col) => col.visible !== false).length);
+		const totalCount = computed(() => localColumns.value.length);
+		const setAllColumnsVisible = (visible) => {
+			localColumns.value.forEach((col) => {
+				if (col.key !== "_actions") col.visible = visible;
+			});
+			applyChanges();
+		};
+		const selectAll = () => setAllColumnsVisible(true);
+		const selectNone = () => setAllColumnsVisible(false);
+		const findOriginalIndex = (filteredIndex) => {
+			const column = filteredColumns.value[filteredIndex];
+			return localColumns.value.findIndex((col) => col.key === column.key);
+		};
+		const updateColumnProperty = (index, updater) => {
+			const originalIndex = findOriginalIndex(index);
+			if (originalIndex !== -1) {
+				updater(localColumns.value[originalIndex]);
+				applyChanges();
+			}
+		};
+		const toggleColumnVisibility = (index, visible) => {
+			updateColumnProperty(index, (col) => {
+				col.visible = visible;
+			});
+		};
+		const handleFixedSelect = (index, value) => {
+			updateColumnProperty(index, (col) => {
+				col.fixed = value === "none" ? void 0 : value;
+			});
+		};
+		const applyChanges = () => emit("change", [...localColumns.value]);
+		const resetColumns = () => {
+			localColumns.value = [...props.columns];
+			applyChanges();
+		};
+		const handleResizableChange = (value) => {
+			localColumns.value.forEach((col) => {
+				if (!isSpecialColumn(col)) {
+					col.resizable = value;
+					if (value) {
+						col.minWidth = col.minWidth || 80;
+						col.maxWidth = col.maxWidth || 500;
+					}
+				}
+			});
+			applyChanges();
+		};
+		const moveColumn = (fromIndex, toIndex) => {
+			const originalFromIndex = findOriginalIndex(fromIndex);
+			const originalToIndex = findOriginalIndex(toIndex);
+			if (originalFromIndex !== -1 && originalToIndex !== -1) {
+				const [movedColumn] = localColumns.value.splice(originalFromIndex, 1);
+				localColumns.value.splice(originalToIndex, 0, movedColumn);
+				applyChanges();
+			}
+		};
+		const handleDragStart = (index, event) => {
+			if (filteredColumns.value[index].key === "_actions") {
+				event.preventDefault();
+				return;
+			}
+			draggedIndex.value = index;
+			if (event.dataTransfer) event.dataTransfer.effectAllowed = "move";
+		};
+		const handleDragOver = (index, event) => {
+			event.preventDefault();
+			if (draggedIndex.value === null || filteredColumns.value[index].key === "_actions") return;
+			dragOverIndex.value = index;
+			if (event.dataTransfer) event.dataTransfer.dropEffect = "move";
+		};
+		const handleDrop = (toIndex) => {
+			if (draggedIndex.value === null || filteredColumns.value[toIndex].key === "_actions") return;
+			moveColumn(draggedIndex.value, toIndex);
+			draggedIndex.value = null;
+			dragOverIndex.value = null;
+		};
+		const handleDragEnd = () => {
+			draggedIndex.value = null;
+			dragOverIndex.value = null;
+		};
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", _hoisted_1$1, [
+				createCommentVNode(" 搜索框和列宽调整开关 "),
+				createElementVNode("div", _hoisted_2$1, [createVNode(unref(NInput$1), {
+					value: searchText.value,
+					"onUpdate:value": _cache[0] || (_cache[0] = ($event) => searchText.value = $event),
+					placeholder: "搜索列名...",
+					clearable: "",
+					class: "search-input"
+				}, {
+					prefix: withCtx(() => [createVNode(C_Icon_default, { name: "mdi:magnify" })]),
+					_: 1
+				}, 8, ["value"]), createElementVNode("div", _hoisted_3$1, [
+					createVNode(C_Icon_default, {
+						name: "mdi:arrow-split-vertical",
+						size: "14",
+						title: enableResizable.value ? "开启后可拖拽列边界调整宽度" : "允许调整列宽"
+					}, null, 8, ["title"]),
+					createVNode(unref(NText$1), { style: {
+						fontSize: "12px",
+						marginLeft: "4px"
+					} }, {
+						default: withCtx(() => _cache[2] || (_cache[2] = [createTextVNode(" 列宽调整 ", -1)])),
+						_: 1,
+						__: [2]
+					}),
+					createVNode(unref(NSwitch$1), {
+						value: enableResizable.value,
+						"onUpdate:value": [_cache[1] || (_cache[1] = ($event) => enableResizable.value = $event), handleResizableChange],
+						size: "small",
+						style: { "margin-left": "6px" }
+					}, null, 8, ["value"])
+				])]),
+				createCommentVNode(" 顶部操作栏：统计信息和快捷操作按钮 "),
+				createElementVNode("div", _hoisted_4$1, [createElementVNode("div", _hoisted_5, [createVNode(unref(NText$1), {
+					depth: "3",
+					style: { fontSize: "13px" }
+				}, {
+					default: withCtx(() => [createTextVNode(" 已选 " + toDisplayString(visibleCount.value) + " / 总共 " + toDisplayString(totalCount.value) + " 列 ", 1)]),
+					_: 1
+				})]), createElementVNode("div", _hoisted_6, [createVNode(unref(NSpace$1), { size: 6 }, {
+					default: withCtx(() => [
+						createVNode(unref(NButton$1), {
+							size: "tiny",
+							onClick: selectAll
+						}, {
+							default: withCtx(() => _cache[3] || (_cache[3] = [createTextVNode(" 全选 ", -1)])),
+							_: 1,
+							__: [3]
+						}),
+						createVNode(unref(NButton$1), {
+							size: "tiny",
+							onClick: selectNone
+						}, {
+							default: withCtx(() => _cache[4] || (_cache[4] = [createTextVNode(" 全不选 ", -1)])),
+							_: 1,
+							__: [4]
+						}),
+						createVNode(unref(NButton$1), {
+							size: "tiny",
+							onClick: resetColumns
+						}, {
+							default: withCtx(() => _cache[5] || (_cache[5] = [createTextVNode(" 重置 ", -1)])),
+							_: 1,
+							__: [5]
+						})
+					]),
+					_: 1
+				})])]),
+				createCommentVNode(" 列列表 "),
+				createElementVNode("div", {
+					ref_key: "listRef",
+					ref: listRef,
+					class: "column-list"
+				}, [(openBlock(true), createElementBlock(Fragment, null, renderList(filteredColumns.value, (column, index) => {
+					return openBlock(), createElementBlock("div", {
+						key: column.key,
+						class: normalizeClass(["column-item", {
+							disabled: column.key === "_actions",
+							"fixed-left": column.fixed === "left",
+							"fixed-right": column.fixed === "right"
+						}]),
+						draggable: column.key !== "_actions",
+						onDragstart: ($event) => handleDragStart(index, $event),
+						onDragover: ($event) => handleDragOver(index, $event),
+						onDragend: handleDragEnd,
+						onDrop: ($event) => handleDrop(index)
+					}, [createElementVNode("div", _hoisted_8, [createElementVNode("div", _hoisted_9, [createVNode(C_Icon_default, {
+						name: "mdi:drag",
+						size: "16",
+						class: normalizeClass(["drag-handle", { disabled: column.key === "_actions" }])
+					}, null, 8, ["class"]), createVNode(unref(NCheckbox$1), {
+						checked: column.visible !== false,
+						disabled: column.key === "_actions",
+						"onUpdate:checked": (value) => toggleColumnVisibility(index, value)
+					}, null, 8, [
+						"checked",
+						"disabled",
+						"onUpdate:checked"
+					])]), createElementVNode("div", _hoisted_10, [createVNode(unref(NSpace$1), {
+						align: "center",
+						size: 6
+					}, {
+						default: withCtx(() => [
+							createVNode(unref(NText$1), {
+								strong: "",
+								style: { fontSize: "13px" }
+							}, {
+								default: withCtx(() => [createTextVNode(toDisplayString(column.title || column.key), 1)]),
+								_: 2
+							}, 1024),
+							column.fixed === "left" ? (openBlock(), createBlock(unref(NTag$1), {
+								key: 0,
+								size: "tiny",
+								type: "info"
+							}, {
+								default: withCtx(() => _cache[6] || (_cache[6] = [createTextVNode(" 左固定 ", -1)])),
+								_: 1,
+								__: [6]
+							})) : createCommentVNode("v-if", true),
+							column.fixed === "right" ? (openBlock(), createBlock(unref(NTag$1), {
+								key: 1,
+								size: "tiny",
+								type: "warning"
+							}, {
+								default: withCtx(() => _cache[7] || (_cache[7] = [createTextVNode(" 右固定 ", -1)])),
+								_: 1,
+								__: [7]
+							})) : createCommentVNode("v-if", true)
+						]),
+						_: 2
+					}, 1024), createVNode(unref(NText$1), {
+						depth: "3",
+						style: { fontSize: "11px" }
+					}, {
+						default: withCtx(() => [createTextVNode(toDisplayString(column.key), 1)]),
+						_: 2
+					}, 1024)])]), createElementVNode("div", _hoisted_11, [createElementVNode("div", _hoisted_12, [createVNode(C_Icon_default, {
+						name: "mdi:chevron-up",
+						size: "14",
+						title: "上移",
+						clickable: index !== 0,
+						class: normalizeClass({ disabled: index === 0 }),
+						onClick: ($event) => index !== 0 && moveColumn(index, index - 1)
+					}, null, 8, [
+						"clickable",
+						"class",
+						"onClick"
+					]), createVNode(C_Icon_default, {
+						name: "mdi:chevron-down",
+						size: "14",
+						title: "下移",
+						clickable: index !== filteredColumns.value.length - 1,
+						class: normalizeClass({ disabled: index === filteredColumns.value.length - 1 }),
+						onClick: ($event) => index !== filteredColumns.value.length - 1 && moveColumn(index, index + 1)
+					}, null, 8, [
+						"clickable",
+						"class",
+						"onClick"
+					])]), createVNode(unref(NDropdown$1), {
+						options: unref(getFixedOptions)(column),
+						onSelect: (value) => handleFixedSelect(index, value)
+					}, {
+						default: withCtx(() => [createVNode(C_Icon_default, {
+							name: "mdi:pin",
+							size: "14",
+							title: "固定列",
+							clickable: "",
+							style: normalizeStyle({ color: column.fixed ? "var(--n-primary-color)" : void 0 })
+						}, null, 8, ["style"])]),
+						_: 2
+					}, 1032, ["options", "onSelect"])])], 42, _hoisted_7);
+				}), 128))], 512)
+			]);
+		};
+	}
+});
+
+//#endregion
+//#region src/components/C_Table/components/ColumnSettings/index.vue
+var ColumnSettings_default = /* @__PURE__ */ export_helper_default(index_vue_vue_type_script_setup_true_lang_default$1, [["__scopeId", "data-v-80dbeb1b"]]);
+
+//#endregion
+//#region src/components/C_Table/index.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1 = { class: "c-table-wrapper" };
+const _hoisted_2 = {
+	key: 1,
+	class: "table-toolbar"
+};
+const _hoisted_3 = { class: "toolbar-left" };
+const _hoisted_4 = { class: "toolbar-right" };
+var index_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	name: "C_Table",
+	inheritAttrs: false,
+	__name: "index",
+	props: {
+		columns: {},
+		data: {},
+		loading: { default: false },
+		rowKey: {
+			type: Function,
+			default: (row) => row.id
+		},
+		config: { default: () => ({}) },
+		crud: {}
+	},
+	emits: [
+		"pagination-change",
+		"row-delete",
+		"expand-change",
+		"selection-change",
+		"child-selection-change",
+		"parent-child-link-change",
+		"update:data",
+		"save",
+		"cancel",
+		"row-add",
+		"row-copy",
+		"row-move",
+		"row-selection-change",
+		"view-detail",
+		"column-change"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		/** 包装 emit：在触发事件的同时自动调用 crud 对应的方法 */
+		const bridgedEmit = (event, ...args) => {
+			emit(event, ...args);
+			if (!props.crud) return;
+			({
+				save: props.crud.save,
+				cancel: props.crud.handleCancel,
+				"pagination-change": props.crud.handlePaginationChange,
+				"row-delete": props.crud.handleRowDelete,
+				"view-detail": props.crud.detail?.show
+			})[event]?.(...args);
+		};
+		/** 合并 crud 返回的 actions/pagination 到用户 config */
+		const effectiveConfig = computed(() => {
+			if (!props.crud) return props.config || {};
+			const fromCrud = {};
+			if (props.crud.actions) fromCrud.actions = props.crud.actions.value;
+			if (props.crud.pagination) fromCrud.pagination = props.crud.pagination.value;
+			return {
+				...fromCrud,
+				...props.config
+			};
+		});
+		const effectiveColumns = computed(() => props.columns ?? props.crud?.columns.value ?? []);
+		const resolved = computed(() => resolveConfig(effectiveConfig.value));
+		const editModeChecker = computed(() => createEditModeChecker(resolved.value));
+		const unwrapRef = (val) => val && typeof val === "object" && "value" in val ? val.value : val;
+		const normalizedData = computed(() => unwrapRef(props.data) ?? props.crud?.data.value ?? []);
+		const normalizedLoading = computed(() => unwrapRef(props.loading) ?? props.crud?.loading.value ?? false);
+		const pagination = usePagination({
+			data: normalizedData,
+			config: computed(() => resolved.value.pagination),
+			emit: bridgedEmit
+		});
+		const tableManager = useTableManager({
+			config: resolved.value,
+			data: () => normalizedData.value,
+			rowKey: props.rowKey,
+			emit: bridgedEmit
+		});
+		const tableActions = useTableActions({
+			actions: computed(() => effectiveConfig.value.actions || {}),
+			config: resolved,
+			tableManager,
+			rowKey: props.rowKey,
+			emit: bridgedEmit,
+			onViewDetail: (data) => bridgedEmit("view-detail", data)
+		});
+		const columnState = useTableColumns({
+			rawColumns: effectiveColumns,
+			config: resolved,
+			columnWidth: resolved.value.columnWidth,
+			scrollX: resolved.value.scrollX,
+			rowKey: props.rowKey,
+			tableManager,
+			actionsRenderer: tableActions.renderActions,
+			editModeChecker
+		});
+		const { showSettingsPanel, reactiveColumns, computedColumns, computedScrollX } = columnState;
+		const tableRef = ref();
+		const computedTableProps = computed(() => ({
+			striped: resolved.value.striped,
+			bordered: resolved.value.bordered,
+			singleLine: resolved.value.singleLine,
+			size: resolved.value.size,
+			maxHeight: resolved.value.maxHeight
+		}));
+		const editFormRef = ref();
+		const modalSubmitLoading = ref(false);
+		const localEditingData = ref({});
+		const modalVisible = computed({
+			get: () => tableManager.editStates.modalEdit.isModalVisible.value,
+			set: (val) => {
+				tableManager.editStates.modalEdit.isModalVisible.value = val;
+			}
+		});
+		const editableColumns = computed(() => effectiveColumns.value.filter((col) => col.editable !== false));
+		const formKey = computed(() => `edit-form-${tableManager.editStates.modalEdit.editingRowKey.value || "new"}`);
+		const formOptions = computed(() => generateFormOptions(editableColumns.value));
+		watch(() => tableManager.editStates.modalEdit.editingData.value, (newData) => {
+			if (newData && Object.keys(newData).length > 0) localEditingData.value = JSON.parse(JSON.stringify(newData));
+		}, {
+			immediate: true,
+			deep: true
+		});
+		let modalCloseTimer = null;
+		watch(modalVisible, (visible) => {
+			if (!visible) modalCloseTimer = setTimeout(() => {
+				localEditingData.value = {};
+				modalCloseTimer = null;
+			}, 300);
+		});
+		const handleModalSave = async () => {
+			if (!editFormRef.value) return;
+			modalSubmitLoading.value = true;
+			try {
+				await editFormRef.value.validate();
+				await tableManager.editStates.modalEdit.saveEdit(localEditingData.value);
+			} catch {} finally {
+				modalSubmitLoading.value = false;
+			}
+		};
+		const handleModalCancel = () => {
+			localEditingData.value = {};
+			tableManager.editStates.modalEdit.cancelEdit();
+		};
+		const onColumnSettingsChange = (columns) => {
+			columnState.handleColumnChange(columns);
+			emit("column-change", columnState.reactiveColumns.value);
+		};
+		const { edit, expand, selection, dynamicRows } = tableManager.stateManager;
+		const exposedApi = {
+			startEdit: edit.start,
+			expandAll: expand.all,
+			collapseAll: expand.collapseAll,
+			selectAll: selection.all,
+			clearSelection: selection.clear,
+			clearAllSelections: tableManager.stateManager.clearAllSelections,
+			clearRowSelection: dynamicRows?.clearSelection,
+			resetToFirstPage: pagination.resetToFirstPage,
+			getSelectedRows: selection.getSelected,
+			getEditingData: edit.getEditingData,
+			isEditing: edit.isEditing,
+			isExpanded: expand.isExpanded,
+			getManager: () => tableManager.stateManager
+		};
+		__expose(exposedApi);
+		onMounted(() => {
+			const crudRef = props.crud?.tableRef;
+			if (crudRef) crudRef.value = exposedApi;
+		});
+		onBeforeUnmount(() => {
+			if (modalCloseTimer) clearTimeout(modalCloseTimer);
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", _hoisted_1, [
+				createCommentVNode(" 动态行工具栏 "),
+				unref(tableManager).dynamicRowsState ? (openBlock(), createBlock(resolveDynamicComponent(unref(tableManager).dynamicRowsState.renderToolbar()), { key: 0 })) : createCommentVNode("v-if", true),
+				createCommentVNode(" 表格工具栏 "),
+				resolved.value.showToolbar ? (openBlock(), createElementBlock("div", _hoisted_2, [createElementVNode("div", _hoisted_3, [renderSlot(_ctx.$slots, "toolbar-left", {}, void 0, true)]), createElementVNode("div", _hoisted_4, [renderSlot(_ctx.$slots, "toolbar-right", {}, void 0, true), resolved.value.enableColumnSettings ? (openBlock(), createBlock(C_Icon_default, {
+					key: 0,
+					name: "mdi:cog",
+					size: "18",
+					title: "表格设置",
+					clickable: "",
+					class: "column-settings-btn",
+					onClick: _cache[0] || (_cache[0] = ($event) => showSettingsPanel.value = true)
+				})) : createCommentVNode("v-if", true)])])) : createCommentVNode("v-if", true),
+				createCommentVNode(" 表格主体 "),
+				createVNode(unref(NDataTable), mergeProps({
+					ref_key: "tableRef",
+					ref: tableRef
+				}, {
+					...computedTableProps.value,
+					..._ctx.$attrs
+				}, {
+					columns: unref(computedColumns),
+					data: normalizedData.value,
+					loading: normalizedLoading.value,
+					"row-key": _ctx.rowKey,
+					"expanded-row-keys": unref(tableManager).expandedKeys.value,
+					"checked-row-keys": unref(tableManager).checkedKeys.value,
+					"onUpdate:expandedRowKeys": unref(tableManager).expandState?.handleExpandChange,
+					"onUpdate:checkedRowKeys": unref(tableManager).expandState?.handleSelectionChange,
+					"scroll-x": unref(computedScrollX),
+					style: { "width": "100%" }
+				}), null, 16, [
+					"columns",
+					"data",
+					"loading",
+					"row-key",
+					"expanded-row-keys",
+					"checked-row-keys",
+					"onUpdate:expandedRowKeys",
+					"onUpdate:checkedRowKeys",
+					"scroll-x"
+				]),
+				createCommentVNode(" 分页 "),
+				unref(pagination).paginationConfig.value ? (openBlock(), createBlock(unref(NPagination$1), mergeProps({ key: 2 }, unref(pagination).paginationConfig.value, { class: "pagination-wrapper" }), null, 16)) : createCommentVNode("v-if", true),
+				createCommentVNode(" 编辑弹窗 "),
+				resolved.value.editMode === "modal" || resolved.value.editMode === "both" ? (openBlock(), createBlock(unref(NModal$1), {
+					key: 3,
+					show: modalVisible.value,
+					"onUpdate:show": _cache[2] || (_cache[2] = ($event) => modalVisible.value = $event),
+					title: resolved.value.modalTitle,
+					width: resolved.value.modalWidth,
+					preset: "card",
+					"mask-closable": false,
+					"close-on-esc": false,
+					class: "w60%",
+					closable: false
+				}, {
+					action: withCtx(() => [createVNode(unref(NSpace$1), { justify: "end" }, {
+						default: withCtx(() => [createVNode(unref(NButton$1), { onClick: handleModalCancel }, {
+							default: withCtx(() => _cache[4] || (_cache[4] = [createTextVNode("取消", -1)])),
+							_: 1,
+							__: [4]
+						}), createVNode(unref(NButton$1), {
+							type: "primary",
+							loading: modalSubmitLoading.value,
+							onClick: handleModalSave
+						}, {
+							default: withCtx(() => _cache[5] || (_cache[5] = [createTextVNode(" 保存 ", -1)])),
+							_: 1,
+							__: [5]
+						}, 8, ["loading"])]),
+						_: 1
+					})]),
+					default: withCtx(() => [modalVisible.value && formOptions.value.length ? (openBlock(), createBlock(C_Form_default, {
+						ref_key: "editFormRef",
+						ref: editFormRef,
+						key: formKey.value,
+						modelValue: localEditingData.value,
+						"onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => localEditingData.value = $event),
+						options: formOptions.value,
+						config: {
+							layout: "grid",
+							grid: {
+								cols: 2,
+								xGap: 16,
+								yGap: 16
+							},
+							showActions: false
+						}
+					}, null, 8, ["modelValue", "options"])) : createCommentVNode("v-if", true)]),
+					_: 1
+				}, 8, [
+					"show",
+					"title",
+					"width"
+				])) : createCommentVNode("v-if", true),
+				createCommentVNode(" 动态行确认删除弹窗 "),
+				unref(tableManager).dynamicRowsState ? (openBlock(), createBlock(resolveDynamicComponent(unref(tableManager).dynamicRowsState.renderConfirmModal()), { key: 4 })) : createCommentVNode("v-if", true),
+				createCommentVNode(" 列设置抽屉 "),
+				createVNode(unref(NDrawer$1), {
+					show: unref(showSettingsPanel),
+					"onUpdate:show": _cache[3] || (_cache[3] = ($event) => isRef(showSettingsPanel) ? showSettingsPanel.value = $event : null),
+					width: 420,
+					placement: "right",
+					"mask-closable": true
+				}, {
+					default: withCtx(() => [createVNode(unref(NDrawerContent$1), {
+						title: "列设置",
+						closable: ""
+					}, {
+						default: withCtx(() => [createVNode(ColumnSettings_default, {
+							columns: unref(reactiveColumns),
+							onChange: onColumnSettingsChange
+						}, null, 8, ["columns"])]),
+						_: 1
+					})]),
+					_: 1
+				}, 8, ["show"])
+			]);
+		};
+	}
+});
+
+//#endregion
+//#region src/components/C_Table/index.vue
+var C_Table_default = /* @__PURE__ */ export_helper_default(index_vue_vue_type_script_setup_true_lang_default, [["__scopeId", "data-v-cbdb9723"]]);
+
+//#endregion
+export { useTableManager as a, usePrintWatermark as c, useCellEdit as d, useRowEdit as f, usePagination as i, useTableExpand as l, resolveConfig as m, useTableColumns as n, useDynamicRows as o, createEditModeChecker as p, useTableActions as r, printPresets as s, C_Table_default as t, useModalEdit as u };
+//# sourceMappingURL=C_Table2.js.map