qidian-vue-ui 2.3.2 → 2.3.3

package/dist/components/service/table/index.vue2.mjs

@@ -0,0 +1,3407 @@
+import './index.css'
+import { defineComponent, mergeDefaults, useCssVars, computed, ref, useSlots, useTemplateRef, shallowRef, inject, getCurrentInstance, reactive, createVNode, unref, watch, nextTick, onMounted, onActivated, onDeactivated, onBeforeUnmount, withDirectives, createBlock, openBlock, resolveDynamicComponent, mergeProps, isRef, createSlots, withCtx, renderList, renderSlot, normalizeProps, guardReactiveProps, h, render } from "vue";
+import { useVModels, useElementSize, useElementBounding, useIntersectionObserver } from "../../../node_modules/.pnpm/@vueuse_core@14.2.0_vue@3.5.26_typescript@5.9.3_/node_modules/@vueuse/core/dist/index.mjs";
+import { useActivated, useTimer, isEmpty, useServicePagination, easyCopy, suspectedWrapperPromise, getScrollEl, createExposeProxy, resizeDirective, to } from "qidian-shared";
+import { LoadingIcon, AddRectangleIcon, MinusRectangleIcon } from "tdesign-icons-vue-next";
+import { EnhancedTable, Table, Empty } from "tdesign-vue-next";
+import { validate } from "tdesign-vue-next/es/form/utils/form-model.mjs";
+import { useModal } from "../../../hooks/useModal.mjs";
+import { useUICsl, getTransformOffset } from "../../../utils/tools.mjs";
+import { useConfig } from "../../config-provider/useConfig.mjs";
+import { getQdFormComponentName, resolveQdFormItemOptions } from "../../form/utils.mjs";
+import { serializeTsv, serializeCellHtml, parseTsv, parseCellHtml } from "./clipboard.mjs";
+import { mergeColumnsWithCache, applySizeCompensation } from "./columnsCompensation.mjs";
+import QdServiceTableEditCell from "./edit-cell.mjs";
+import QdServiceTableFilterItem from "./filter-item.mjs";
+import { QD_TABLE_BLANK_FILTER_VALUE, qdServiceTableTreeConfig, qdServiceTableProps, getSortParams } from "./props.mjs";
+import { useReadonly } from "../../../hooks/useReadonly.mjs";
+import { useDisabled } from "../../../hooks/useDisabled.mjs";
+import { PROVIDE_FORM_ADD_BEFORE_SUBMIT_QUEUE } from "../../form/config.mjs";
+import get from "../../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/get.mjs";
+import _sfc_main$1 from "../../config-renderer/index.vue.mjs";
+import set from "../../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/set.mjs";
+import QdForm from "../../form/index.vue.mjs";
+const CELL_DRAG_SCROLL_EDGE_PX = 24;
+const CELL_DRAG_SCROLL_MAX_SPEED_PX = 14;
+const cellDragInteractiveSelector = "button, a, label, .t-tag, .t-checkbox, .t-radio, .t-switch, .t-input, .t-select";
+const popupLayerSelector = ".t-select-input--popup-visible, .t-popup__content, .t-dialog, .t-drawer, .t-image-viewer, .qd-multi-file-viewer";
+const editableElementSelector = 'input, textarea, select, [contenteditable="true"], .ql-editor';
+const defaultMinWidth = 80;
+const defaultVirtualScrollBufferSize = 2;
+const defaultXVirtualScrollThreshold = 20;
+const defaultVirtualScrollUpdateInterval = 16;
+const minVirtualScrollUpdateInterval = 8;
+const scrollRestoreMaxAttempts = 4;
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "QdServiceTable"
+  },
+  __name: "index",
+  props: /* @__PURE__ */ mergeDefaults({
+    columns: {},
+    rowKey: {},
+    size: {},
+    widthCompensation: {
+      type: Boolean
+    },
+    selectType: {},
+    activeRowType: {
+      type: [String, Boolean]
+    },
+    cellSelectable: {
+      type: Boolean
+    },
+    cellClipboard: {
+      type: Boolean
+    },
+    onCellCopy: {
+      type: Function
+    },
+    onCellPaste: {
+      type: Function
+    },
+    reserveSelectedRowOnFilter: {
+      type: Boolean
+    },
+    headerBg: {
+      type: Boolean
+    },
+    showFilterResult: {
+      type: Boolean
+    },
+    searchData: {},
+    emptyText: {},
+    emptyImage: {
+      type: [Boolean, String]
+    },
+    readonly: {
+      type: Boolean
+    },
+    lazyForm: {
+      type: Boolean
+    },
+    editCellValidationBlock: {},
+    scroll: {},
+    tree: {},
+    loadingWithData: {
+      type: Boolean
+    },
+    disableHorizontalScroll: {
+      type: Boolean
+    },
+    beforeDragSort: {
+      type: Function
+    },
+    expandedTreeNodes: {},
+    defaultExpandedTreeNodes: {},
+    treeExpandAndFoldIcon: {},
+    onAbnormalDragSort: {
+      type: Function
+    },
+    onExpandedTreeNodesChange: {
+      type: Function
+    },
+    onTreeExpandChange: {
+      type: Function
+    },
+    asyncLoading: {},
+    columnController: {},
+    columnControllerVisible: {
+      type: Boolean
+    },
+    defaultColumnControllerVisible: {
+      type: Boolean
+    },
+    displayColumns: {},
+    defaultDisplayColumns: {},
+    dragSort: {},
+    dragSortOptions: {},
+    editableCellState: {
+      type: Function
+    },
+    editableRowKeys: {},
+    expandIcon: {
+      type: Boolean
+    },
+    expandOnRowClick: {
+      type: Boolean
+    },
+    expandedRow: {},
+    expandedRowKeys: {},
+    defaultExpandedRowKeys: {},
+    filterIcon: {},
+    filterRow: {},
+    filterValue: {},
+    defaultFilterValue: {},
+    hideSortTips: {
+      type: Boolean
+    },
+    indeterminateSelectedRowKeys: {},
+    multipleSort: {
+      type: Boolean
+    },
+    reserveSelectedRowOnPaginate: {
+      type: Boolean
+    },
+    rowSelectionAllowUncheck: {
+      type: Boolean
+    },
+    rowSelectionType: {},
+    selectOnRowClick: {
+      type: Boolean
+    },
+    selectedRowKeys: {},
+    defaultSelectedRowKeys: {},
+    showSortColumnBgColor: {
+      type: Boolean
+    },
+    sort: {},
+    defaultSort: {},
+    sortIcon: {},
+    sortOnRowDraggable: {
+      type: Boolean
+    },
+    onAsyncLoadingClick: {
+      type: Function
+    },
+    onCellClick: {
+      type: Function
+    },
+    onChange: {
+      type: Function
+    },
+    onColumnChange: {
+      type: Function
+    },
+    onColumnControllerVisibleChange: {
+      type: Function
+    },
+    onDataChange: {
+      type: Function
+    },
+    onDisplayColumnsChange: {
+      type: Function
+    },
+    onDragSort: {
+      type: Function
+    },
+    onExpandChange: {
+      type: Function
+    },
+    onFilterChange: {
+      type: Function
+    },
+    onRowEdit: {
+      type: Function
+    },
+    onRowValidate: {
+      type: Function
+    },
+    onSelectChange: {
+      type: Function
+    },
+    onSortChange: {
+      type: Function
+    },
+    onValidate: {
+      type: Function
+    },
+    activeRowKeys: {},
+    defaultActiveRowKeys: {},
+    allowResizeColumnWidth: {
+      type: Boolean
+    },
+    attach: {
+      type: [String, Function]
+    },
+    bordered: {
+      type: Boolean
+    },
+    bottomContent: {},
+    cellEmptyContent: {},
+    data: {},
+    disableDataPage: {
+      type: Boolean
+    },
+    disableSpaceInactiveRow: {
+      type: Boolean
+    },
+    empty: {},
+    firstFullRow: {},
+    fixedRows: {},
+    footData: {},
+    footerAffixProps: {},
+    footerAffixedBottom: {
+      type: [Boolean, Object]
+    },
+    footerSummary: {},
+    headerAffixProps: {},
+    headerAffixedTop: {
+      type: [Boolean, Object]
+    },
+    height: {},
+    horizontalScrollAffixedBottom: {
+      type: [Boolean, Object]
+    },
+    hover: {
+      type: Boolean
+    },
+    keyboardRowHover: {
+      type: Boolean
+    },
+    lastFullRow: {},
+    loading: {
+      type: Boolean
+    },
+    loadingProps: {},
+    locale: {},
+    maxHeight: {},
+    paginationAffixedBottom: {
+      type: [Boolean, Object]
+    },
+    resizable: {
+      type: Boolean
+    },
+    rowAttributes: {
+      type: [Object, Function, Array]
+    },
+    rowClassName: {
+      type: [Object, Array, String, Function]
+    },
+    rowspanAndColspan: {
+      type: Function
+    },
+    rowspanAndColspanInFooter: {
+      type: Function
+    },
+    showHeader: {
+      type: Boolean
+    },
+    stripe: {
+      type: Boolean
+    },
+    tableContentWidth: {},
+    tableLayout: {},
+    topContent: {},
+    verticalAlign: {},
+    onActiveChange: {
+      type: Function
+    },
+    onActiveRowAction: {
+      type: Function
+    },
+    onColumnResizeChange: {
+      type: Function
+    },
+    onPageChange: {
+      type: Function
+    },
+    onRowClick: {
+      type: Function
+    },
+    onRowDblclick: {
+      type: Function
+    },
+    onRowMousedown: {
+      type: Function
+    },
+    onRowMouseenter: {
+      type: Function
+    },
+    onRowMouseleave: {
+      type: Function
+    },
+    onRowMouseover: {
+      type: Function
+    },
+    onRowMouseup: {
+      type: Function
+    },
+    onScroll: {
+      type: Function
+    },
+    onScrollX: {
+      type: Function
+    },
+    onScrollY: {
+      type: Function
+    },
+    cacheKey: {
+      type: [String, Function]
+    },
+    cacheTime: {},
+    pollingInterval: {},
+    onBefore: {
+      type: Function
+    },
+    onAfter: {
+      type: Function
+    },
+    onSuccess: {
+      type: Function
+    },
+    onError: {
+      type: Function
+    },
+    service: {
+      type: Function
+    },
+    manual: {
+      type: Boolean
+    },
+    transformParams: {
+      type: Function
+    },
+    transformRes: {
+      type: Function
+    },
+    pagination: {}
+  }, qdServiceTableProps),
+  emits: ["update:data", "update:selectedRowKeys", "update:activeRowKeys", "update:columnControllerVisible", "update:displayColumns", "update:expandedRowKeys", "update:filterValue", "update:sort", "update:searchData", "update:expandedTreeNodes"],
+  setup(__props, {
+    expose: __expose,
+    emit: __emit
+  }) {
+    useCssVars((_ctx) => ({
+      "v1a629129": affixedHeaderTransform.value,
+      "v2aeb1ade": expandedRowWidth.value
+    }));
+    const props = __props;
+    const emit = __emit;
+    const {
+      data,
+      selectedRowKeys,
+      activeRowKeys,
+      columnControllerVisible,
+      displayColumns,
+      expandedRowKeys,
+      filterValue,
+      sort,
+      searchData,
+      expandedTreeNodes
+    } = useVModels(props, emit, {
+      passive: true
+    });
+    const innerSort = ref(getDefaultSort());
+    const reSort = computed({
+      get: () => sort.value ?? innerSort.value,
+      set: (value) => {
+        innerSort.value = normalizeSort(value);
+        sort.value = innerSort.value;
+      }
+    });
+    const vResize = resizeDirective;
+    const vHorizontalWheel = {
+      mounted(el) {
+        el.addEventListener("wheel", handleHorizontalWheel, {
+          passive: false
+        });
+      },
+      unmounted(el) {
+        el.removeEventListener("wheel", handleHorizontalWheel);
+      }
+    };
+    const slots = useSlots();
+    const {
+      t,
+      size: globalComponentSize
+    } = useConfig("crud");
+    const {
+      t: formT
+    } = useConfig("form");
+    const {
+      t: tableT
+    } = useConfig("table");
+    const {
+      msg,
+      msgError
+    } = useModal();
+    const csl = useUICsl("QdServiceTable");
+    const tdReadonly = useReadonly();
+    const tdDisabled = useDisabled();
+    const tableReadonly = computed(() => tdReadonly.value || tdDisabled.value);
+    const tableRef = useTemplateRef("table");
+    const treeLoadIds = ref([]);
+    const editingCells = shallowRef([]);
+    const activeEditingCell = shallowRef();
+    const autofocusEditingCell = shallowRef();
+    const selectedCell = shallowRef();
+    const selectedCells = shallowRef([]);
+    const selectedCellAnchor = shallowRef();
+    const copiedCells = shallowRef([]);
+    const handledSelectionEvents = /* @__PURE__ */ new WeakSet();
+    const selectionExcludedColKeys = /* @__PURE__ */ new Set(["expand", "drag"]);
+    let cellDragState = null;
+    const isCellDragSelecting = ref(false);
+    let suppressNextCellClick = false;
+    let dragScrollRafId = 0;
+    const dragCellCache = /* @__PURE__ */ new WeakMap();
+    const editingCellValidationErrors = shallowRef(/* @__PURE__ */ new Map());
+    const expandedRowProxyMap = /* @__PURE__ */ new WeakMap();
+    let dataChangePending = false;
+    const {
+      activated
+    } = useActivated();
+    const formItemColumns = computed(() => flattenFormItemColumns(props.columns || []));
+    const editableColumns = computed(() => flattenEditableColumns(props.columns || []));
+    const reCellSelectable = computed(() => props.cellSelectable ?? false);
+    const rowClickSelectsRows = computed(() => {
+      if (props.selectOnRowClick !== void 0) return props.selectOnRowClick;
+      if (props.onRowClick) return false;
+      return !props.expandOnRowClick && !props.tree?.expandTreeNodeOnClick;
+    });
+    const parentAddBeforeSubmitQueue = inject(PROVIDE_FORM_ADD_BEFORE_SUBMIT_QUEUE, void 0);
+    const beforeSubmitQueueMap = /* @__PURE__ */ new Map();
+    const editingCellValidationVersions = /* @__PURE__ */ new Map();
+    const editingCellUpdateFns = /* @__PURE__ */ new Map();
+    parentAddBeforeSubmitQueue?.(async () => {
+      const context = await submitTableData({
+        showErrorMessage: false
+      });
+      return {
+        success: context.validateResult,
+        message: context.firstError
+      };
+    });
+    function notifyDataChange() {
+      if (dataChangePending) return;
+      dataChangePending = true;
+      queueMicrotask(() => {
+        dataChangePending = false;
+        data.value = [...data.value];
+      });
+    }
+    function concealVirtualScrollIndex(rows) {
+      if (props.scroll?.type !== "virtual") return rows;
+      rows.forEach((row) => {
+        const descriptor = Object.getOwnPropertyDescriptor(row, "VIRTUAL_SCROLL_INDEX");
+        if (descriptor && !descriptor.enumerable) return;
+        Object.defineProperty(row, "VIRTUAL_SCROLL_INDEX", {
+          configurable: true,
+          enumerable: false,
+          value: descriptor?.value,
+          writable: true
+        });
+      });
+      return rows;
+    }
+    function isExpandedRowProxyable(value) {
+      if (!value || typeof value !== "object") return false;
+      if (Array.isArray(value)) return true;
+      const prototype = Object.getPrototypeOf(value);
+      return prototype === Object.prototype || prototype === null;
+    }
+    function getExpandedRowProxy(row) {
+      const sourceRow = data.value.find((item) => getRowValue(item) === getRowValue(row)) ?? row;
+      const cached = expandedRowProxyMap.get(sourceRow);
+      if (cached) return cached;
+      const proxies = /* @__PURE__ */ new WeakMap();
+      function wrap(target) {
+        if (!isExpandedRowProxyable(target)) return target;
+        const cachedProxy = proxies.get(target);
+        if (cachedProxy) return cachedProxy;
+        const proxy2 = new Proxy(target, {
+          get(currentTarget, key, receiver) {
+            return wrap(Reflect.get(currentTarget, key, receiver));
+          },
+          set(currentTarget, key, value, receiver) {
+            const previous = Reflect.get(currentTarget, key, receiver);
+            const result = Reflect.set(currentTarget, key, value, receiver);
+            if (result && !Object.is(previous, value)) notifyDataChange();
+            return result;
+          },
+          deleteProperty(currentTarget, key) {
+            const hadKey = Reflect.has(currentTarget, key);
+            const result = Reflect.deleteProperty(currentTarget, key);
+            if (result && hadKey) notifyDataChange();
+            return result;
+          }
+        });
+        proxies.set(target, proxy2);
+        return proxy2;
+      }
+      const proxy = wrap(sourceRow);
+      expandedRowProxyMap.set(sourceRow, proxy);
+      return proxy;
+    }
+    function resolveForwardedSlotProps(name, slotProps) {
+      if (name !== "expandedRow" || !slotProps.row) return slotProps;
+      return {
+        ...slotProps,
+        row: getExpandedRowProxy(slotProps.row)
+      };
+    }
+    const isVirtualScroll = computed(() => props.scroll?.type === "virtual");
+    const currentInstance = getCurrentInstance();
+    const offscreenAppContext = currentInstance ? {
+      ...currentInstance.appContext,
+      provides: Reflect.get(currentInstance, "provides")
+    } : null;
+    let offscreenChain = Promise.resolve();
+    let offscreenContainer = null;
+    let offscreenVNode = null;
+    let offscreenInstance = null;
+    const scrollRecord = {
+      top: 0,
+      left: 0,
+      bottom: false
+    };
+    let scrollRestoreRafId = 0;
+    const outsideScrollEl = ref(null);
+    const tableHeaderEl = ref(null);
+    const tableContentEl = ref(null);
+    const tableContentVisible = ref(false);
+    const headerAffixedNeeded = ref(false);
+    const horizontalScrollAffixed = ref(false);
+    const {
+      width: tableContentWidth
+    } = useElementSize(tableContentEl);
+    const outsideScrollRect = reactive(useElementBounding(outsideScrollEl));
+    const expandedRowWidth = computed(() => {
+      const observedWidth = tableContentWidth.value;
+      const width = observedWidth > 0 ? tableContentEl.value?.clientWidth ?? observedWidth : 0;
+      return width > 0 ? `${width}px` : "auto";
+    });
+    const affixBottomOffset = ref(0);
+    const {
+      timer: probeDelayTimer,
+      clearTimer: clearProbeDelayTimer
+    } = useTimer();
+    const {
+      timer: affixFallbackTimer,
+      clearTimer: clearAffixFallbackTimer
+    } = useTimer();
+    let probeRafId = 0;
+    let affixRefreshRafId = 0;
+    let animatingAncestorCleanup = null;
+    const adaptedColumns = computed(() => {
+      const columns = wrapColumns(props.columns || []);
+      const selectType = props.selectType;
+      if (!selectType) return columns;
+      const selectIdx = columns.findIndex((item) => item.type === "single" || item.type === "multiple");
+      const defaultSelect = {
+        colKey: "row-select",
+        type: selectType,
+        align: "center",
+        fixed: "left",
+        width: 50
+      };
+      if (selectIdx > -1) {
+        columns[selectIdx] = {
+          ...defaultSelect,
+          ...columns[selectIdx]
+        };
+      } else {
+        columns.unshift(defaultSelect);
+      }
+      return columns;
+    });
+    const leafColumns = computed(() => {
+      const result = [];
+      function visit(items) {
+        for (const column of items) {
+          if (column.children?.length) {
+            visit(column.children);
+            continue;
+          }
+          result.push(column);
+        }
+      }
+      visit(adaptedColumns.value);
+      return result;
+    });
+    const displayData = computed(() => {
+      if (props.onFilterChange) return data.value;
+      if (props.service && props.pagination !== false) return data.value;
+      const activeFilters = getActiveFilterEntries();
+      if (!activeFilters.length) return data.value;
+      return data.value.filter((row) => activeFilters.every(({
+        colKey,
+        type,
+        value
+      }) => {
+        const rowValue = get(row, colKey);
+        if (type === "input") {
+          return String(rowValue ?? "").toLowerCase().includes(String(value).toLowerCase());
+        }
+        if (Array.isArray(value)) {
+          return value.includes(rowValue) || isEmpty(rowValue) && value.includes(QD_TABLE_BLANK_FILTER_VALUE);
+        }
+        if (value === QD_TABLE_BLANK_FILTER_VALUE) return isEmpty(rowValue);
+        return rowValue === value;
+      }));
+    });
+    const rowspanData = shallowRef();
+    const tdesignData = computed(() => concealVirtualScrollIndex(props.rowspanAndColspan && rowspanData.value ? rowspanData.value : displayData.value));
+    const {
+      stop: tableContentStop,
+      pause: tableContentPause,
+      resume: tableContentResume
+    } = useIntersectionObserver(tableContentEl, ([entry]) => {
+      tableContentVisible.value = entry?.isIntersecting || false;
+      updateHeaderAffixedNeeded();
+      updateHorizontalScrollAffixed();
+    }, {
+      root: outsideScrollEl
+    });
+    const affixedHeaderTransform = ref("none");
+    const affixBaseEl = computed(() => outsideScrollEl.value || tableRef.value?.$el);
+    const reProps = computed(() => {
+      const {
+        service,
+        manual,
+        transformParams,
+        transformRes,
+        pagination,
+        cacheKey,
+        cacheTime,
+        pollingInterval,
+        onBefore,
+        onAfter,
+        onSuccess,
+        onError,
+        loadingWithData,
+        loading: loading2,
+        data: data2,
+        selectedRowKeys: selectedRowKeys2,
+        activeRowKeys: _activeRowKeys,
+        columnControllerVisible: columnControllerVisible2,
+        displayColumns: displayColumns2,
+        expandedRowKeys: expandedRowKeys2,
+        filterValue: inFilterValue,
+        sort: sort2,
+        searchData: _searchData,
+        expandedTreeNodes: expandedTreeNodes2,
+        emptyText,
+        emptyImage: _emptyImage,
+        readonly: _readonly,
+        lazyForm: _lazyForm,
+        scroll,
+        selectOnRowClick,
+        reserveSelectedRowOnFilter: _reserveSelectedRowOnFilter,
+        expandOnRowClick,
+        tree,
+        onScroll,
+        onCellClick,
+        onRowClick,
+        size,
+        widthCompensation,
+        onColumnResizeChange,
+        bordered,
+        headerAffixedTop,
+        showFilterResult,
+        horizontalScrollAffixedBottom,
+        ...tableOptions
+      } = props;
+      const {
+        virtualUpdateInterval,
+        ...scrollOptions
+      } = scroll ?? {};
+      const reScroll = scroll?.type === "virtual" ? {
+        bufferSize: defaultVirtualScrollBufferSize,
+        ...scroll.xVirtual === true ? {
+          threshold: defaultXVirtualScrollThreshold
+        } : {},
+        virtualUpdateInterval: Math.max(minVirtualScrollUpdateInterval, virtualUpdateInterval ?? defaultVirtualScrollUpdateInterval),
+        ...scrollOptions
+      } : scroll;
+      const reTableOptions = tableOptions;
+      const onValidate = reTableOptions.onValidate;
+      const onRowValidate = reTableOptions.onRowValidate;
+      const onFilterChange = reTableOptions.onFilterChange;
+      const onSelectChange = reTableOptions.onSelectChange;
+      reTableOptions.onSelectChange = (value, context) => {
+        if (props.activeRowType && props.selectOnRowClick !== false) activeRowKeys.value = [...value];
+        onSelectChange?.(value, context);
+      };
+      reTableOptions.onColumnResizeChange = (context) => {
+        if (props.widthCompensation) {
+          const prevWidths = {};
+          autoWidthColumns.value?.forEach((col) => {
+            const width = Number(col.width);
+            if (Number.isFinite(width)) prevWidths[col.colKey] = width;
+          });
+          applyResizedWidthsToStore(context.columnsWidth, prevWidths);
+        }
+        onColumnResizeChange?.(context);
+      };
+      reTableOptions.onValidate = (context) => {
+        replaceTableValidationErrors(context.result);
+        onValidate?.(context);
+      };
+      reTableOptions.onRowValidate = (context) => {
+        syncCellValidationErrors(context.result);
+        onRowValidate?.(context);
+      };
+      reTableOptions.onFilterChange = (value, context) => {
+        if (filterValue) filterValue.value = value;
+        onFilterChange?.(value, context);
+        if (onFilterChange) {
+          syncSelectedRowsAfterFilter([]);
+          return;
+        }
+        if (!service || pagination === false) {
+          syncSelectedRowsAfterFilter(displayData.value);
+          return;
+        }
+        syncSelectedRowsAfterFilter([]);
+        changeCurrent(1);
+      };
+      const expandedRow = reTableOptions.expandedRow;
+      if (expandedRow) {
+        reTableOptions.expandedRow = (h2, context) => expandedRow(h2, {
+          ...context,
+          row: getExpandedRowProxy(context.row)
+        });
+      }
+      let reTransformRes = transformRes;
+      const reTree = tree ? {
+        ...tree,
+        ...easyCopy(qdServiceTableTreeConfig)
+      } : tree;
+      if (reTree?.lazyLoad) {
+        reTransformRes = async (res) => {
+          let temp;
+          if (transformRes) {
+            const [trErr, trRes] = await suspectedWrapperPromise(transformRes(res));
+            if (trErr) throw trErr;
+            temp = trRes;
+          } else {
+            temp = res;
+          }
+          temp.records.forEach((item) => {
+            if (item.children) return;
+            item.children = true;
+          });
+          return temp;
+        };
+        if (!tableOptions.treeExpandAndFoldIcon) {
+          reTableOptions.treeExpandAndFoldIcon = (h2, {
+            row,
+            type
+          }) => {
+            const children = row.children;
+            if (treeLoadIds.value.includes(row.id) && children === true) {
+              return createVNode(LoadingIcon, {
+                "style": {
+                  color: "var(--td-brand-color)"
+                }
+              }, null);
+            }
+            if (children === true && row.__qdTreeLoaded) {
+              return createVNode(AddRectangleIcon, {
+                "style": {
+                  color: "transparent",
+                  cursor: "default"
+                }
+              }, null);
+            }
+            return type === "expand" ? createVNode(AddRectangleIcon, null, null) : createVNode(MinusRectangleIcon, null, null);
+          };
+        }
+        if (!tableOptions.onExpandedTreeNodesChange) {
+          reTableOptions.onExpandedTreeNodesChange = async (currentExpandedTreeNodes, options) => {
+            const {
+              row,
+              rowState
+            } = options;
+            if (!service || !row || !rowState) return;
+            const {
+              level
+            } = rowState;
+            const {
+              __qdTreeLoaded
+            } = row;
+            const {
+              maxLevel
+            } = reTree;
+            const id = row[props.rowKey || qdServiceTableProps.rowKey];
+            if (treeLoadIds.value.includes(id) || __qdTreeLoaded || isEmpty(level) || !isEmpty(maxLevel) && level >= maxLevel) {
+              return;
+            }
+            treeLoadIds.value.push(id);
+            tableRef.value?.setData(id, {
+              ...row,
+              __qdTreeLoaded: true
+            });
+            const {
+              transformParams: transformParams2,
+              transformRes: transformRes2
+            } = reTree;
+            const currentParams = options;
+            let serviceParams = currentParams;
+            if (transformParams2) {
+              const [tpErr, tpRes] = await suspectedWrapperPromise(transformParams2(currentParams));
+              if (tpErr) {
+                removeTreeLoadId(id);
+                throw tpErr;
+              }
+              serviceParams = tpRes;
+            }
+            const [serviceErr, serviceRes] = await suspectedWrapperPromise(service(serviceParams));
+            if (serviceErr) {
+              removeTreeLoadId(id);
+              throw serviceErr;
+            }
+            let temp;
+            if (transformRes2) {
+              const [trErr, trRes] = await suspectedWrapperPromise(transformRes2(serviceRes, options));
+              if (trErr) {
+                removeTreeLoadId(id);
+                throw trErr;
+              }
+              temp = trRes;
+            } else {
+              temp = serviceRes;
+            }
+            removeTreeLoadId(id);
+            if (!temp.records) temp.records = [];
+            if (isEmpty(temp.total)) temp.total = temp.records.length;
+            if (!temp.records.length) return;
+            const childrenKey = reTree.childrenKey || qdServiceTableTreeConfig.childrenKey;
+            tableRef.value?.setData(id, {
+              ...row,
+              __qdTreeLoaded: true,
+              [childrenKey]: []
+            });
+            tableRef.value?.appendTo(id, temp.records.map((item) => {
+              if (item.children) return item;
+              return {
+                ...item,
+                [childrenKey]: isEmpty(maxLevel) ? true : level + 1 < maxLevel
+              };
+            }));
+          };
+        }
+      }
+      const reOnScroll = (params) => {
+        onScroll?.(params);
+        const target = params.e.target;
+        if (!target) return;
+        if (!activated.value) return;
+        const {
+          scrollTop,
+          scrollLeft,
+          scrollHeight,
+          clientHeight
+        } = target;
+        scrollRecord.top = scrollTop;
+        scrollRecord.left = scrollLeft;
+        scrollRecord.bottom = !isVirtualScroll.value && Math.abs(scrollHeight - clientHeight - scrollTop) <= 1;
+      };
+      const reOnCellClick = (context) => {
+        handleCellClick(context);
+        onCellClick?.(context);
+      };
+      const hasFormItemColumns = formItemColumns.value.length > 0;
+      const callerEditableCellState = reTableOptions.editableCellState;
+      const reEditableCellState = tableReadonly.value ? () => false : hasFormItemColumns ? (context) => {
+        const column = context.col;
+        if (!column.formItem) {
+          if (callerEditableCellState) return callerEditableCellState(context);
+          if (column.edit?.keepEditMode || column.edit?.defaultEditable) return true;
+          return isEditingCell(context.row, column.colKey);
+        }
+        return !resolveFormItemLazy(column) || isEditingCell(context.row, column.colKey);
+      } : callerEditableCellState;
+      const reEditableRowKeys = tableReadonly.value ? [] : hasFormItemColumns ? (data2 || []).map((row) => getRowValue(row)) : reTableOptions.editableRowKeys;
+      const {
+        offsetBottom: horizontalScrollOffsetBottom = 0,
+        onFixedChange: onHorizontalScrollFixedChange,
+        ...horizontalScrollAffixProps
+      } = typeof horizontalScrollAffixedBottom === "object" ? horizontalScrollAffixedBottom : {};
+      const reHorizontalScrollAffixedBottom = horizontalScrollAffixedBottom === false ? false : {
+        container: () => outsideScrollEl.value ?? getScrollEl(tableRef.value?.$el) ?? window,
+        ...horizontalScrollAffixProps,
+        offsetBottom: horizontalScrollOffsetBottom + affixBottomOffset.value,
+        onFixedChange: (...args) => {
+          const [affixed, context] = args;
+          onHorizontalScrollFixedChange?.(affixed, context);
+          requestAnimationFrame(updateHorizontalScrollAffixed);
+          if (!affixed) return;
+          applyAffixedTransform();
+          const animatingNode = findAnimatingTransformAncestor(affixBaseEl.value);
+          if (!animatingNode) return;
+          animatingNode.addEventListener("transitionend", triggerAffixedRefresh, {
+            once: true
+          });
+          animatingNode.addEventListener("animationend", triggerAffixedRefresh, {
+            once: true
+          });
+        }
+      };
+      const headerAffixOptions = typeof headerAffixedTop === "boolean" ? {} : headerAffixedTop ?? {};
+      const {
+        onFixedChange,
+        ...headerAffixProps
+      } = headerAffixOptions;
+      const reHeaderAffixedTop = headerAffixedTop && headerAffixedNeeded.value ? {
+        container: () => outsideScrollEl.value ?? getScrollEl(tableRef.value?.$el) ?? window,
+        ...headerAffixProps,
+        onFixedChange: (...args) => {
+          const [affixed, context] = args;
+          onFixedChange?.(affixed, context);
+          if (!affixed) return;
+          applyAffixedTransform();
+          const animatingNode = findAnimatingTransformAncestor(affixBaseEl.value);
+          if (!animatingNode) return;
+          animatingNode.addEventListener("transitionend", triggerAffixedRefresh, {
+            once: true
+          });
+          animatingNode.addEventListener("animationend", triggerAffixedRefresh, {
+            once: true
+          });
+        }
+      } : false;
+      const reSize = size ?? tableT("size") ?? "small";
+      const paginationValue = unref(pagination);
+      const globalPagination = tableT("pagination");
+      const reServicePagination = paginationValue === false ? false : {
+        ...globalPagination,
+        ...paginationValue,
+        pageSize: paginationValue?.pageSize ?? globalPagination?.pageSize ?? 10,
+        pageSizeOptions: paginationValue?.pageSizeOptions ?? globalPagination?.pageSizeOptions ?? [5, 10, 20, 50, 100]
+      };
+      const servicePagination = reServicePagination;
+      return {
+        loadingWithData,
+        columns: compensatedColumns.value,
+        emptyText,
+        size: reSize,
+        tableOptions: {
+          ...reTableOptions,
+          filterRow: showFilterResult ? reTableOptions.filterRow : null,
+          // 行高亮随单元格选中统一驱动（syncSelectedRowKeysFromCells 同步 activeRowKeys），
+          // 置空关闭 TDesign 行点击/键盘的原生高亮，避免双重写入打架
+          activeRowType: "",
+          // 行选中由单元格选中驱动或业务自控，TDesign 行点击 toggle 一律关闭
+          selectOnRowClick: false,
+          expandOnRowClick,
+          tree: reTree,
+          editableCellState: reEditableCellState,
+          editableRowKeys: reEditableRowKeys,
+          scroll: reScroll,
+          onScroll: reOnScroll,
+          onCellClick: reOnCellClick,
+          onRowClick,
+          size: reSize === "mini" ? "small" : reSize,
+          headerAffixedTop: reHeaderAffixedTop,
+          horizontalScrollAffixedBottom: reHorizontalScrollAffixedBottom,
+          bordered: bordered ?? tableT("bordered") ?? true
+        },
+        externalLoad: loading2,
+        serviceOptions: {
+          service,
+          manual,
+          transformParams: transformServiceParams,
+          transformRes: reTransformRes,
+          pagination: servicePagination,
+          cacheKey,
+          cacheTime,
+          pollingInterval,
+          onBefore,
+          onAfter,
+          onSuccess,
+          onError
+        },
+        models: {
+          data: data2,
+          selectedRowKeys: selectedRowKeys2,
+          activeRowKeys: _activeRowKeys,
+          columnControllerVisible: columnControllerVisible2,
+          displayColumns: displayColumns2,
+          expandedRowKeys: expandedRowKeys2,
+          filterValue: inFilterValue,
+          sort: sort2,
+          expandedTreeNodes: expandedTreeNodes2
+        }
+      };
+    });
+    const compensationTableSize = computed(() => props.size ?? tableT("size") ?? "small");
+    const compensationGlobalSize = computed(() => globalComponentSize.value ?? "medium");
+    const widthCompensationStore = shallowRef({
+      columns: []
+    });
+    const columnsFingerprint = computed(() => JSON.stringify(props.columns));
+    watch(columnsFingerprint, () => {
+      widthCompensationStore.value = {
+        columns: []
+      };
+    });
+    function syncWidthCompensation() {
+      if (!props.widthCompensation) {
+        if (widthCompensationStore.value.columns.length) widthCompensationStore.value = {
+          columns: []
+        };
+        return;
+      }
+      const prev = widthCompensationStore.value;
+      const next = applySizeCompensation(prev, adaptedColumns.value, compensationTableSize.value, compensationGlobalSize.value);
+      if (next === prev) return;
+      widthCompensationStore.value = next;
+    }
+    watch([compensationTableSize, compensationGlobalSize, () => props.widthCompensation, columnsFingerprint], syncWidthCompensation, {
+      immediate: true
+    });
+    const compensatedColumns = computed(() => {
+      if (!props.widthCompensation) return adaptedColumns.value;
+      return mergeColumnsWithCache(adaptedColumns.value, widthCompensationStore.value.columns);
+    });
+    function applyResizedWidthsToStore(columnsWidth, prevWidths) {
+      const store = widthCompensationStore.value;
+      let hasChanged = false;
+      const columns = mergeColumnsWithCache(adaptedColumns.value, store.columns).map((col) => {
+        const reCol = {
+          colKey: col.colKey,
+          hidden: void 0,
+          width: col.width,
+          minWidth: col.minWidth,
+          fixed: col.fixed
+        };
+        const width = columnsWidth[col.colKey];
+        const prev = prevWidths[col.colKey];
+        if (width === void 0 || prev === void 0 || Math.abs(width - prev) < 0.5) return reCol;
+        hasChanged = true;
+        return {
+          ...reCol,
+          width,
+          minWidth: void 0
+        };
+      });
+      if (hasChanged) widthCompensationStore.value = {
+        ...store,
+        columns
+      };
+    }
+    const autoWidthColumns = computed(() => {
+      const observedWidth = tableContentWidth.value;
+      const containerWidth = observedWidth > 0 ? (tableContentEl.value?.clientWidth ?? observedWidth) - 1 : 0;
+      const columns = reProps.value.columns;
+      const noWidthCols = columns.filter((c) => isEmpty(c.width));
+      const fixedWidth = columns.filter((c) => !isEmpty(c.width)).reduce((sum, c) => sum + Number(c.width), 0);
+      if (containerWidth <= 0 || !noWidthCols.length) return columns;
+      const expandIconWidth = reProps.value.tableOptions.expandedRow && reProps.value.tableOptions.expandIcon !== false ? 46 : 0;
+      const availableWidth = containerWidth - expandIconWidth;
+      const bodyMinWidth = fixedWidth + noWidthCols.reduce((sum, c) => sum + (!isEmpty(c.minWidth) ? Number(c.minWidth) : defaultMinWidth), 0);
+      const totalFlexWidth = availableWidth - bodyMinWidth;
+      const allColumnsWidth = noWidthCols.reduce((sum, c) => sum + (!isEmpty(c.minWidth) ? Number(c.minWidth) : defaultMinWidth), 0);
+      const flexWidthPerPixel = totalFlexWidth > 0 && allColumnsWidth > 0 ? totalFlexWidth / allColumnsWidth : 0;
+      return columns.map((item) => {
+        if (!isEmpty(item.width)) return item;
+        const base = !isEmpty(item.minWidth) ? Number(item.minWidth) : defaultMinWidth;
+        const width = base + base * flexWidthPerPixel;
+        return {
+          ...item,
+          width
+        };
+      });
+    });
+    watch([reSort, () => props.columns, () => searchData.value?.orderByColumn, () => searchData.value?.isAsc], syncSearchDataSort, {
+      immediate: true,
+      flush: "sync"
+    });
+    const {
+      firstLoad,
+      manualTriggerLoad,
+      loading,
+      current,
+      pageSize,
+      total,
+      changeCurrent,
+      changePageSize,
+      changePagination,
+      runAsync,
+      run,
+      cancel,
+      refresh,
+      refreshAsync,
+      setPollingInterval
+    } = useServicePagination({
+      ...reProps.value.serviceOptions,
+      onSuccess: async (res) => {
+        data.value = res.list;
+        if (reProps.value.tableOptions.tree?.defaultExpandAll) {
+          tableRef.value?.foldAll();
+          nextTick(() => {
+            tableRef.value?.expandAll();
+          });
+        }
+        reProps.value.serviceOptions.onSuccess?.(res);
+      }
+    });
+    const reOnSortChange = (sortValue, options) => {
+      reProps.value.tableOptions.onSortChange?.(sortValue, options);
+      if (typeof options.col.sorter === "function") return;
+      changeCurrent(1);
+    };
+    const tableLoad = computed(() => {
+      const {
+        externalLoad,
+        loadingWithData
+      } = reProps.value;
+      if (externalLoad) return true;
+      if (!data.value?.length && firstLoad.value) return true;
+      if (manualTriggerLoad.value) {
+        if (data.value?.length) {
+          if (loadingWithData) return true;
+          return false;
+        }
+        return true;
+      }
+      return false;
+    });
+    const rePagination = computed(() => {
+      const {
+        service,
+        pagination
+      } = reProps.value.serviceOptions;
+      const paginationValue = unref(pagination);
+      if (!service || paginationValue === false) {
+        return void 0;
+      }
+      const pageSizeOptions = [...paginationValue?.pageSizeOptions ?? []];
+      const requiredPageSizes = [paginationValue?.pageSize ?? pageSize.value, pageSize.value];
+      requiredPageSizes.forEach((requiredPageSize) => {
+        const hasPageSize = pageSizeOptions.some((option) => typeof option === "number" ? option === requiredPageSize : option.value === requiredPageSize);
+        if (!hasPageSize) pageSizeOptions.push(requiredPageSize);
+      });
+      pageSizeOptions.sort((a, b) => {
+        const aValue = typeof a === "number" ? a : a.value;
+        const bValue = typeof b === "number" ? b : b.value;
+        return aValue - bValue;
+      });
+      return {
+        current: current.value,
+        pageSize: pageSize.value,
+        total: total.value,
+        pageSizeOptions,
+        onCurrentChange: changeCurrent,
+        onPageSizeChange: changePageSize
+      };
+    });
+    function adjustScrollWhenTreeExpanded() {
+      if (!reProps.value.tableOptions.tree) return;
+      nextTick(() => {
+        const scrollEl = tableContentEl.value;
+        if (!scrollEl) return;
+        const maxTop = Math.max(scrollEl.scrollHeight - scrollEl.clientHeight, 0);
+        if (scrollEl.scrollTop > maxTop) {
+          scrollEl.scrollTop = maxTop;
+          scrollRecord.top = maxTop;
+          scrollRecord.left = scrollEl.scrollLeft;
+        }
+      });
+    }
+    function normalizeSort(value) {
+      const sortList = Array.isArray(value) ? value : value ? [value] : [];
+      if (props.multipleSort) return sortList;
+      return sortList[0];
+    }
+    function getDefaultSort() {
+      if (props.defaultSort) return normalizeSort(props.defaultSort);
+      return props.multipleSort ? [] : void 0;
+    }
+    function isLocalSortColumn(sortBy) {
+      function findColumn(columns) {
+        for (const column of columns) {
+          if (column.colKey === sortBy) return column;
+          const child = column.children ? findColumn(column.children) : void 0;
+          if (child) return child;
+        }
+      }
+      return typeof findColumn(props.columns ?? [])?.sorter === "function";
+    }
+    function getRemoteSort(value) {
+      const sortList = Array.isArray(value) ? value : value ? [value] : [];
+      const remoteSortList = sortList.filter((item) => !isLocalSortColumn(item.sortBy));
+      return Array.isArray(value) ? remoteSortList : remoteSortList[0];
+    }
+    async function transformServiceParams(params) {
+      const mergedParams = {
+        ...params,
+        ...searchData.value,
+        ...getActiveFilterParams()
+      };
+      if (props.transformParams) return props.transformParams(mergedParams);
+      return mergedParams;
+    }
+    function syncSearchDataSort() {
+      const sortParams = getSortParams(getRemoteSort(reSort.value));
+      const current2 = searchData.value;
+      if (!current2) return;
+      if (sortParams.orderByColumn) {
+        if (current2.orderByColumn !== sortParams.orderByColumn) {
+          current2.orderByColumn = sortParams.orderByColumn;
+        }
+        if (current2.isAsc !== sortParams.isAsc) {
+          current2.isAsc = sortParams.isAsc;
+        }
+        return;
+      }
+      if ("orderByColumn" in current2) delete current2.orderByColumn;
+      if ("isAsc" in current2) delete current2.isAsc;
+    }
+    function removeTreeLoadId(id) {
+      const index = treeLoadIds.value.findIndex((item) => item === id);
+      if (index === -1) return;
+      treeLoadIds.value.splice(index, 1);
+    }
+    function flattenFormItemColumns(columns) {
+      const result = [];
+      let colIndex = 0;
+      function visit(items) {
+        for (const column of items) {
+          if (column.children?.length) {
+            visit(column.children);
+            continue;
+          }
+          if (column.formItem) result.push({
+            column,
+            colIndex
+          });
+          colIndex += 1;
+        }
+      }
+      visit(columns);
+      return result;
+    }
+    function flattenEditableColumns(columns) {
+      const result = [];
+      let colIndex = 0;
+      function visit(items) {
+        for (const column of items) {
+          if (column.children?.length) {
+            visit(column.children);
+            continue;
+          }
+          if (column.formItem || column.edit?.rules) result.push({
+            column,
+            colIndex
+          });
+          colIndex += 1;
+        }
+      }
+      visit(columns);
+      return result;
+    }
+    function getRowValue(row) {
+      return get(row, props.rowKey || qdServiceTableProps.rowKey);
+    }
+    function syncSelectedRowsAfterFilter(rows) {
+      if (props.reserveSelectedRowOnFilter || !selectedRowKeys.value.length) return;
+      const rowValues = new Set(rows.map(getRowValue));
+      const nextSelectedRowKeys = selectedRowKeys.value.filter((value) => rowValues.has(value));
+      if (nextSelectedRowKeys.length === selectedRowKeys.value.length) return;
+      selectedRowKeys.value = nextSelectedRowKeys;
+    }
+    function getCellKey(row, colKey) {
+      return `${String(getRowValue(row))}__${String(colKey)}`;
+    }
+    function syncCellValidationErrors(results) {
+      if (!results.length) return;
+      const nextErrors = new Map(editingCellValidationErrors.value);
+      for (const result of results) {
+        const rowValue = getRowValue(result.row);
+        const colKey = String(result.col.colKey);
+        const rowErrors = new Map(nextErrors.get(rowValue));
+        if (result.errorList.length) rowErrors.set(colKey, result.errorList);
+        else rowErrors.delete(colKey);
+        if (rowErrors.size) nextErrors.set(rowValue, rowErrors);
+        else nextErrors.delete(rowValue);
+      }
+      editingCellValidationErrors.value = nextErrors;
+    }
+    function replaceTableValidationErrors(result) {
+      const nextErrors = /* @__PURE__ */ new Map();
+      for (const row of data.value) {
+        const rowValue = getRowValue(row);
+        const rowErrors = /* @__PURE__ */ new Map();
+        for (const {
+          column
+        } of editableColumns.value) {
+          const colKey = String(column.colKey);
+          const errors = result[getCellKey(row, colKey)] ?? result[`${String(rowValue)}_${colKey}`];
+          if (errors?.length) rowErrors.set(colKey, errors);
+        }
+        if (rowErrors.size) nextErrors.set(rowValue, rowErrors);
+      }
+      editingCellValidationErrors.value = nextErrors;
+    }
+    function replaceRowValidationErrors(rowValue, results) {
+      const nextErrors = new Map(editingCellValidationErrors.value);
+      const rowErrors = /* @__PURE__ */ new Map();
+      for (const result of results) {
+        if (!result.errorList.length) continue;
+        rowErrors.set(String(result.col.colKey), result.errorList);
+      }
+      if (rowErrors.size) nextErrors.set(rowValue, rowErrors);
+      else nextErrors.delete(rowValue);
+      editingCellValidationErrors.value = nextErrors;
+    }
+    function clearValidateData() {
+      tableRef.value?.clearValidateData();
+      editingCellValidationErrors.value = /* @__PURE__ */ new Map();
+    }
+    function pruneCellValidationErrors(rows) {
+      const currentErrors = editingCellValidationErrors.value;
+      if (!currentErrors.size) return;
+      const validColKeys = new Set(editableColumns.value.map(({
+        column
+      }) => String(column.colKey)));
+      const validErrorRows = /* @__PURE__ */ new Set();
+      for (const row of rows) {
+        const rowValue = getRowValue(row);
+        if (!currentErrors.has(rowValue)) continue;
+        validErrorRows.add(rowValue);
+        if (validErrorRows.size === currentErrors.size) break;
+      }
+      let changed = false;
+      const nextErrors = /* @__PURE__ */ new Map();
+      for (const [rowValue, rowErrors] of currentErrors) {
+        if (!validErrorRows.has(rowValue)) {
+          changed = true;
+          continue;
+        }
+        const validRowErrors = new Map([...rowErrors].filter(([colKey]) => validColKeys.has(colKey)));
+        if (validRowErrors.size !== rowErrors.size) changed = true;
+        if (validRowErrors.size) nextErrors.set(rowValue, validRowErrors);
+      }
+      if (!changed) return;
+      editingCellValidationErrors.value = nextErrors;
+    }
+    function isSameEditingCell(first, second) {
+      return getRowValue(first.row) === getRowValue(second.row) && first.colKey === second.colKey;
+    }
+    function findEditingCell(row, colKey) {
+      return editingCells.value.find((item) => isSameEditingCell(item, {
+        row,
+        colKey
+      }));
+    }
+    function isEditingCell(row, colKey) {
+      return !!findEditingCell(row, colKey);
+    }
+    function isSelectedCell(row, colKey) {
+      return selectedCells.value.some((item) => getRowValue(item.row) === getRowValue(row) && item.colKey === colKey);
+    }
+    function isSelectedCellAt(rowIndex, colIndex) {
+      const row = data.value[rowIndex];
+      const column = leafColumns.value[colIndex];
+      if (!row || !column) return false;
+      return isSelectedCell(row, column.colKey);
+    }
+    function isCopiedCell(row, colKey) {
+      return copiedCells.value.some((item) => getRowValue(item.row) === getRowValue(row) && item.colKey === colKey);
+    }
+    function isCopiedCellAt(rowIndex, colIndex) {
+      const row = data.value[rowIndex];
+      const column = leafColumns.value[colIndex];
+      if (!row || !column) return false;
+      return isCopiedCell(row, column.colKey);
+    }
+    function hasSelectionModifier(event) {
+      return !!event && (event.metaKey || event.ctrlKey || event.shiftKey);
+    }
+    function expandSelectedCellRange(anchor, target) {
+      if (!target.colKey || !anchor.colKey) return [target];
+      const columns = leafColumns.value;
+      const fromCol = columns.findIndex((col) => col.colKey === anchor.colKey);
+      const toCol = columns.findIndex((col) => col.colKey === target.colKey);
+      const rows = data.value;
+      const fromRow = rows.findIndex((row) => getRowValue(row) === getRowValue(anchor.row));
+      const toRow = rows.findIndex((row) => getRowValue(row) === getRowValue(target.row));
+      if (fromCol < 0 || toCol < 0 || fromRow < 0 || toRow < 0) return [target];
+      const [rowStart, rowEnd] = fromRow <= toRow ? [fromRow, toRow] : [toRow, fromRow];
+      const [colStart, colEnd] = fromCol <= toCol ? [fromCol, toCol] : [toCol, fromCol];
+      const colKeys = columns.slice(colStart, colEnd + 1).map((col) => col.colKey);
+      return rows.slice(rowStart, rowEnd + 1).flatMap((row) => colKeys.map((colKey) => ({
+        row,
+        colKey
+      })));
+    }
+    function isRowSelectDisabled(row, rowIndex) {
+      const selectColumn = adaptedColumns.value.find((col) => col.type === "single" || col.type === "multiple");
+      if (!selectColumn) return false;
+      const context = {
+        row,
+        rowIndex
+      };
+      const disabled = typeof selectColumn.disabled === "function" ? selectColumn.disabled(context) : selectColumn.disabled;
+      const checkProps = typeof selectColumn.checkProps === "function" ? selectColumn.checkProps(context) : selectColumn.checkProps;
+      return !!disabled || !!checkProps?.disabled;
+    }
+    function syncSelectedRowKeysFromCells() {
+      const rowKeys = [];
+      const checkableRowKeys = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (const item of selectedCells.value) {
+        const rowValue = getRowValue(item.row);
+        if (seen.has(rowValue)) continue;
+        seen.add(rowValue);
+        rowKeys.push(rowValue);
+        const rowIndex = data.value.findIndex((row) => getRowValue(row) === rowValue);
+        if (!isRowSelectDisabled(rowIndex >= 0 ? data.value[rowIndex] : item.row, rowIndex)) {
+          checkableRowKeys.push(rowValue);
+        }
+      }
+      if (rowClickSelectsRows.value) selectedRowKeys.value = checkableRowKeys;
+      if (props.activeRowType) activeRowKeys.value = rowKeys;
+    }
+    function pruneDisabledSelectedRows(newData) {
+      if (!selectedRowKeys.value.length) return;
+      const next = selectedRowKeys.value.filter((key) => {
+        const rowIndex = newData.findIndex((row) => getRowValue(row) === key);
+        if (rowIndex < 0) return true;
+        return !isRowSelectDisabled(newData[rowIndex], rowIndex);
+      });
+      if (next.length === selectedRowKeys.value.length) return;
+      selectedRowKeys.value = next;
+    }
+    function isCellSelectableColumn(column) {
+      if (selectionExcludedColKeys.has(String(column.colKey))) return false;
+      if (column.type === "single" || column.type === "multiple") return false;
+      return column.cellSelectable ?? String(column.colKey) !== "operation";
+    }
+    function emitRowSelectChange(clickedRow, type) {
+      if (!rowClickSelectsRows.value) return;
+      const rowKeys = [...selectedRowKeys.value];
+      const selectedRowData = rowKeys.map((key) => data.value.find((row) => getRowValue(row) === key)).filter((row) => !!row);
+      props.onSelectChange?.(rowKeys, {
+        selectedRowData,
+        currentRowKey: String(getRowValue(clickedRow)),
+        currentRowData: clickedRow,
+        type
+      });
+    }
+    function applyCellSelection(cell, event) {
+      const column = leafColumns.value.find((col) => col.colKey === cell.colKey);
+      if (!column || !isCellSelectableColumn(column)) return;
+      const wasSelected = selectedRowKeys.value.includes(getRowValue(cell.row));
+      if (event?.metaKey || event?.ctrlKey) {
+        const exists = selectedCells.value.some((item) => isSameEditingCell(item, cell));
+        const rest = selectedCells.value.filter((item) => !isSameEditingCell(item, cell));
+        const prevRows = new Set(selectedCells.value.map((item) => getRowValue(item.row)));
+        const next = exists ? rest : [...rest, cell];
+        const nextRows = new Set(next.map((item) => getRowValue(item.row)));
+        selectedCells.value = next;
+        selectedCell.value = next.at(-1);
+        selectedCellAnchor.value = cell;
+        const singleRowSelect = props.selectType === "single";
+        const clickedRowValue = getRowValue(cell.row);
+        if (rowClickSelectsRows.value) {
+          if (singleRowSelect) {
+            selectedRowKeys.value = [clickedRowValue];
+          } else {
+            const nextKeys = new Set(selectedRowKeys.value);
+            for (const rowValue of nextRows) {
+              if (prevRows.has(rowValue)) continue;
+              const rowIndex = data.value.findIndex((row) => getRowValue(row) === rowValue);
+              if (rowIndex >= 0 && !isRowSelectDisabled(data.value[rowIndex], rowIndex)) {
+                nextKeys.add(rowValue);
+              }
+            }
+            for (const rowValue of prevRows) {
+              if (!nextRows.has(rowValue)) nextKeys.delete(rowValue);
+            }
+            selectedRowKeys.value = [...nextKeys];
+          }
+        }
+        if (props.activeRowType) {
+          if (singleRowSelect) {
+            activeRowKeys.value = [clickedRowValue];
+          } else {
+            const nextActive = new Set(activeRowKeys.value);
+            for (const rowValue of nextRows) nextActive.add(rowValue);
+            for (const rowValue of prevRows) {
+              if (!nextRows.has(rowValue)) nextActive.delete(rowValue);
+            }
+            activeRowKeys.value = [...nextActive];
+          }
+        }
+        emitRowSelectChange(cell.row, wasSelected ? "uncheck" : "check");
+        return;
+      }
+      if (event?.shiftKey && selectedCellAnchor.value) {
+        document.getSelection()?.removeAllRanges();
+        selectedCells.value = expandSelectedCellRange(selectedCellAnchor.value, cell);
+        selectedCell.value = cell;
+        syncSelectedRowKeysFromCells();
+        emitRowSelectChange(cell.row, wasSelected ? "uncheck" : "check");
+        return;
+      }
+      selectedCells.value = [cell];
+      selectedCell.value = cell;
+      selectedCellAnchor.value = cell;
+      syncSelectedRowKeysFromCells();
+      emitRowSelectChange(cell.row, wasSelected ? "uncheck" : "check");
+    }
+    function computeCellRect(anchor, target) {
+      if (!target.colKey || !anchor.colKey) return null;
+      const columns = leafColumns.value;
+      const fromCol = columns.findIndex((col) => col.colKey === anchor.colKey);
+      const toCol = columns.findIndex((col) => col.colKey === target.colKey);
+      const rows = data.value;
+      const fromRow = rows.findIndex((row) => getRowValue(row) === getRowValue(anchor.row));
+      const toRow = rows.findIndex((row) => getRowValue(row) === getRowValue(target.row));
+      if (fromCol < 0 || toCol < 0 || fromRow < 0 || toRow < 0) return null;
+      const [rowStart, rowEnd] = fromRow <= toRow ? [fromRow, toRow] : [toRow, fromRow];
+      const [colStart, colEnd] = fromCol <= toCol ? [fromCol, toCol] : [toCol, fromCol];
+      return {
+        rowStart,
+        rowEnd,
+        colStart,
+        colEnd
+      };
+    }
+    function isSameCellRect(a, b) {
+      return a.rowStart === b.rowStart && a.rowEnd === b.rowEnd && a.colStart === b.colStart && a.colEnd === b.colEnd;
+    }
+    function resolveCellFromPoint(x, y) {
+      const element = document.elementFromPoint(x, y);
+      const td = element instanceof Element ? element.closest("td[data-qd-col-key]") : null;
+      if (!(td instanceof HTMLTableCellElement)) return null;
+      if (dragCellCache.has(td)) return dragCellCache.get(td) ?? null;
+      const rowKey = td.dataset.qdRowKey;
+      const column = leafColumns.value.find((col) => String(col.colKey) === td.dataset.qdColKey);
+      const row = data.value.find((item) => rowKey !== void 0 && String(getRowValue(item)) === rowKey);
+      if (!row || !column || !isCellSelectableColumn(column)) return null;
+      const cell = {
+        row,
+        colKey: column.colKey
+      };
+      dragCellCache.set(td, cell);
+      return cell;
+    }
+    function handleCellDragMousedown(event, cell, column) {
+      if (!activated.value || !reCellSelectable.value) return;
+      if (event.button !== 0 || !cell.colKey) return;
+      if (!isCellSelectableColumn(column)) return;
+      const target = event.target;
+      if (!(target instanceof Element)) return;
+      if (isEditableOrPopupTarget(target)) return;
+      if (target.closest(cellDragInteractiveSelector)) return;
+      if (hasSelectionModifier(event)) return;
+      event.preventDefault();
+      cellDragState = {
+        anchorCell: cell,
+        lastTargetCell: cell,
+        lastRect: null,
+        moved: false,
+        textAnchor: resolveTextPointFromEvent(event.clientX, event.clientY),
+        clientX: event.clientX,
+        clientY: event.clientY
+      };
+      document.addEventListener("mousemove", handleCellDragMousemove);
+      document.addEventListener("mouseup", handleCellDragMouseup);
+      document.addEventListener("mouseleave", handleCellDragCancel);
+      window.addEventListener("blur", handleCellDragCancel);
+      startCellDragScrollLoop();
+    }
+    function handleCellDragMousemove(event) {
+      const state = cellDragState;
+      if (!state || !activated.value) return;
+      state.clientX = event.clientX;
+      state.clientY = event.clientY;
+      updateDragSelection(event.clientX, event.clientY);
+    }
+    function updateDragSelection(x, y) {
+      const state = cellDragState;
+      if (!state) return;
+      const target = resolveCellFromPoint(x, y);
+      if (!target) return;
+      if (!state.moved && isSameEditingCell(target, state.anchorCell)) {
+        updateCellTextSelection(x, y, state);
+        return;
+      }
+      if (!state.moved) {
+        document.getSelection()?.removeAllRanges();
+        state.moved = true;
+        isCellDragSelecting.value = true;
+      }
+      state.lastTargetCell = target;
+      const rect = computeCellRect(state.anchorCell, target);
+      if (!rect || state.lastRect && isSameCellRect(state.lastRect, rect)) return;
+      state.lastRect = rect;
+      selectedCells.value = expandSelectedCellRange(state.anchorCell, target);
+      selectedCell.value = target;
+      selectedCellAnchor.value = state.anchorCell;
+      syncSelectedRowKeysFromCells();
+    }
+    function updateCellTextSelection(x, y, state) {
+      if (!state.textAnchor) return;
+      const focus = resolveTextPointFromEvent(x, y);
+      if (!focus) return;
+      document.getSelection()?.setBaseAndExtent(state.textAnchor.node, state.textAnchor.offset, focus.node, focus.offset);
+    }
+    function resolveTextPointFromEvent(x, y) {
+      const position = document.caretPositionFromPoint?.(x, y);
+      if (position) return {
+        node: position.offsetNode,
+        offset: position.offset
+      };
+      const range = document.caretRangeFromPoint(x, y);
+      if (!range) return null;
+      return {
+        node: range.startContainer,
+        offset: range.startOffset
+      };
+    }
+    function handleCellDragMouseup() {
+      const state = cellDragState;
+      if (!state) return;
+      const {
+        moved,
+        anchorCell,
+        lastTargetCell
+      } = state;
+      teardownCellDrag();
+      if (!moved) return;
+      suppressNextCellClick = true;
+      setTimeout(() => {
+        suppressNextCellClick = false;
+      }, 0);
+      selectedCell.value = lastTargetCell;
+      selectedCellAnchor.value = anchorCell;
+      emitRowSelectChange(lastTargetCell.row, "check");
+      document.getSelection()?.removeAllRanges();
+    }
+    function handleCellDragCancel() {
+      if (!cellDragState) return;
+      teardownCellDrag();
+    }
+    function teardownCellDrag() {
+      cellDragState = null;
+      isCellDragSelecting.value = false;
+      stopCellDragScrollLoop();
+      document.removeEventListener("mousemove", handleCellDragMousemove);
+      document.removeEventListener("mouseup", handleCellDragMouseup);
+      document.removeEventListener("mouseleave", handleCellDragCancel);
+      window.removeEventListener("blur", handleCellDragCancel);
+    }
+    function startCellDragScrollLoop() {
+      if (dragScrollRafId) return;
+      const tick = () => {
+        dragScrollRafId = requestAnimationFrame(tick);
+        const state = cellDragState;
+        const scrollEl = getCurrentTableContentEl();
+        if (!state || !scrollEl) return;
+        const rect = scrollEl.getBoundingClientRect();
+        const dx = resolveDragScrollDelta(rect.left, rect.right, state.clientX, scrollEl.scrollLeft, scrollEl.scrollWidth);
+        const dy = resolveDragScrollDelta(rect.top, rect.bottom, state.clientY, scrollEl.scrollTop, scrollEl.scrollHeight);
+        if (!dx && !dy) return;
+        scrollEl.scrollLeft += dx;
+        scrollEl.scrollTop += dy;
+        updateDragSelection(state.clientX, state.clientY);
+      };
+      dragScrollRafId = requestAnimationFrame(tick);
+    }
+    function stopCellDragScrollLoop() {
+      if (!dragScrollRafId) return;
+      cancelAnimationFrame(dragScrollRafId);
+      dragScrollRafId = 0;
+    }
+    function resolveDragScrollDelta(start, end, pointer, current2, total2) {
+      let delta = 0;
+      if (current2 > 0) {
+        const distance = pointer - start;
+        if (distance <= CELL_DRAG_SCROLL_EDGE_PX) delta -= resolveDragScrollSpeed(distance);
+      }
+      if (current2 < total2) {
+        const distance = end - pointer;
+        if (distance <= CELL_DRAG_SCROLL_EDGE_PX) delta += resolveDragScrollSpeed(distance);
+      }
+      return delta;
+    }
+    function resolveDragScrollSpeed(distance) {
+      const ratio = Math.max(0, Math.min(1, 1 - distance / CELL_DRAG_SCROLL_EDGE_PX));
+      return Math.round(CELL_DRAG_SCROLL_MAX_SPEED_PX * ratio);
+    }
+    function resolveCellText(row, colKey) {
+      const value = get(row, colKey);
+      if (value === void 0 || value === null) return "";
+      return String(value).replace(/[\t\n\r]/g, " ");
+    }
+    function resolveSelectedCells() {
+      if (selectedCells.value.length) return selectedCells.value;
+      return selectedCell.value ? [selectedCell.value] : [];
+    }
+    function resolveSelectedCellGrid() {
+      const positions = [];
+      const columns = leafColumns.value;
+      for (const cell of resolveSelectedCells()) {
+        if (!cell.colKey) continue;
+        const colIdx = columns.findIndex((col) => col.colKey === cell.colKey);
+        const rowIdx = data.value.findIndex((row) => getRowValue(row) === getRowValue(cell.row));
+        if (colIdx < 0 || rowIdx < 0) continue;
+        positions.push({
+          rowIdx,
+          colIdx
+        });
+      }
+      if (!positions.length) return null;
+      positions.sort((first, second) => first.rowIdx - second.rowIdx || first.colIdx - second.colIdx);
+      const rows = data.value;
+      const rowStart = positions[0].rowIdx;
+      const rowEnd = positions.at(-1).rowIdx;
+      const colStart = Math.min(...positions.map((item) => item.colIdx));
+      const colEnd = Math.max(...positions.map((item) => item.colIdx));
+      const selectedTds = getCurrentTableContentEl()?.querySelectorAll("td.qd-service-table__selected-cell");
+      const domTds = selectedTds && selectedTds.length === positions.length ? selectedTds : null;
+      const valueGrid = [];
+      const labelGrid = [];
+      const cells = [];
+      let tdIndex = 0;
+      for (let rowIdx = rowStart; rowIdx <= rowEnd; rowIdx++) {
+        const row = rows[rowIdx];
+        const rowValues = [];
+        const rowLabels = [];
+        for (let colIdx = colStart; colIdx <= colEnd; colIdx++) {
+          const position = positions.find((item) => item.rowIdx === rowIdx && item.colIdx === colIdx);
+          const column = columns[colIdx];
+          if (!position) {
+            rowValues.push(null);
+            rowLabels.push("");
+            continue;
+          }
+          cells.push({
+            row,
+            colKey: String(column.colKey)
+          });
+          const colKey = String(column.colKey);
+          rowValues.push(resolveCellText(row, colKey));
+          if (column.transformCopy) {
+            const custom = column.transformCopy({
+              row,
+              rowIndex: rowIdx,
+              column,
+              value: get(row, colKey)
+            });
+            if (custom !== void 0) {
+              rowValues[rowValues.length - 1] = normalizeCellText(custom);
+              rowLabels.push(normalizeCellText(custom));
+              continue;
+            }
+          }
+          if (domTds) {
+            const td = domTds[tdIndex++];
+            if (!td.querySelector(".qd-service-table__cell-editor, .t-table__cell--wrap")) {
+              rowLabels.push(normalizeCellText(td.textContent));
+              continue;
+            }
+          }
+          rowLabels.push(resolveCellLabelByRender(column, row) ?? rowValues.at(-1));
+        }
+        valueGrid.push(rowValues);
+        labelGrid.push(rowLabels);
+      }
+      return {
+        valueGrid,
+        labelGrid,
+        cells
+      };
+    }
+    function resolveCellLabelByRender(column, row) {
+      const context = {
+        row,
+        col: column,
+        colIndex: -1,
+        rowIndex: -1,
+        type: "cell"
+      };
+      const result = typeof column.cell === "function" ? column.cell(h, context) : typeof column.render === "function" ? column.render(h, context) : void 0;
+      return typeof result === "string" ? normalizeCellText(result) : void 0;
+    }
+    function normalizeCellText(text) {
+      return (text ?? "").replace(/[\t\n\r]/g, " ").trim();
+    }
+    async function copySelectedCells() {
+      const selection = resolveSelectedCellGrid();
+      if (!selection) return false;
+      const plain = serializeTsv(selection.labelGrid);
+      const valueText = serializeTsv(selection.valueGrid);
+      const html = serializeCellHtml(selection.valueGrid.map((rowValues, rowIdx) => rowValues.map((value, colIdx) => ({
+        label: selection.labelGrid[rowIdx][colIdx],
+        value: value ?? "",
+        hole: value === null
+      }))));
+      const [error] = await to(writeClipboard(plain, html));
+      if (error) {
+        csl.warn("单元格复制失败", error);
+        return false;
+      }
+      copiedCells.value = selection.cells;
+      props.onCellCopy?.({
+        text: plain,
+        valueText,
+        cells: selection.cells
+      });
+      return true;
+    }
+    async function writeClipboard(plain, html) {
+      const ClipboardItemCtor = globalThis.ClipboardItem;
+      if (navigator.clipboard && ClipboardItemCtor && html) {
+        await navigator.clipboard.write([new ClipboardItemCtor({
+          "text/plain": new Blob([plain], {
+            type: "text/plain"
+          }),
+          "text/html": new Blob([html], {
+            type: "text/html"
+          })
+        })]);
+        return;
+      }
+      if (navigator.clipboard) {
+        await navigator.clipboard.writeText(plain);
+        return;
+      }
+      const container = document.createElement("div");
+      container.contentEditable = "true";
+      container.style.position = "fixed";
+      container.style.opacity = "0";
+      container.textContent = plain;
+      document.body.appendChild(container);
+      const range = document.createRange();
+      range.selectNodeContents(container);
+      const selection = document.getSelection();
+      selection?.removeAllRanges();
+      selection?.addRange(range);
+      const handleCopy = (event) => {
+        event.clipboardData?.setData("text/plain", plain);
+        if (html) event.clipboardData?.setData("text/html", html);
+        event.preventDefault();
+      };
+      document.addEventListener("copy", handleCopy);
+      const copied = document.execCommand("copy");
+      document.removeEventListener("copy", handleCopy);
+      selection?.removeAllRanges();
+      container.remove();
+      if (!copied) throw new Error("[QdServiceTable.writeClipboard] execCommand 复制剪贴板失败");
+    }
+    function canCopySelectedCells(target) {
+      if (!props.cellClipboard || !reCellSelectable.value) return false;
+      if (!selectedCell.value && !selectedCells.value.length) return false;
+      if (isEditableOrPopupTarget(target)) return false;
+      return !document.getSelection()?.toString();
+    }
+    function isPasteTargetCell(column, row) {
+      if (!isCellSelectableColumn(column)) return false;
+      if (column.formItem) return resolveFormItemIfRender(column, row);
+      return !!column.edit;
+    }
+    function writeCellPasteValue(row, colKey, value) {
+      const updateEditedCellValue = editingCellUpdateFns.get(getCellKey(row, colKey));
+      if (updateEditedCellValue) {
+        updateEditedCellValue({
+          isUpdateCurrentRow: true,
+          [colKey]: value
+        });
+        updateEditedCellValue(value);
+      }
+      set(row, colKey, value);
+    }
+    function applyCellPaste(text, html) {
+      const plainGrid = parseTsv(text);
+      const htmlGrid = parseCellHtml(html ?? "");
+      const grid = htmlGrid ?? plainGrid;
+      const anchorCells = resolveSelectedCells();
+      if (!grid.length || !anchorCells.length) return {
+        written: 0,
+        skipped: 0
+      };
+      const columns = leafColumns.value;
+      const rows = data.value;
+      const anchors = anchorCells.map((cell) => ({
+        rowIdx: rows.findIndex((row) => getRowValue(row) === getRowValue(cell.row)),
+        colIdx: columns.findIndex((col) => col.colKey === cell.colKey)
+      })).filter((item) => item.rowIdx >= 0 && item.colIdx >= 0);
+      if (!anchors.length) {
+        msg("粘贴位置已失效，请重新选中单元格后粘贴");
+        return {
+          written: 0,
+          skipped: 0
+        };
+      }
+      const anchorRowIdx = Math.min(...anchors.map((item) => item.rowIdx));
+      const anchorColIdx = Math.min(...anchors.map((item) => item.colIdx));
+      const written = [];
+      let skipped = 0;
+      const singleCell = grid.length === 1 && grid[0].length === 1;
+      const plan = singleCell ? anchors.map(({
+        rowIdx,
+        colIdx
+      }) => ({
+        rowIndex: rowIdx,
+        row: rows[rowIdx],
+        column: columns[colIdx],
+        value: grid[0][0],
+        htmlValue: htmlGrid?.[0]?.[0],
+        label: plainGrid[0]?.[0] ?? ""
+      })) : grid.flatMap((gridRow, rowOffset) => gridRow.map((value, colOffset) => ({
+        rowIndex: anchorRowIdx + rowOffset,
+        row: rows[anchorRowIdx + rowOffset],
+        column: columns[anchorColIdx + colOffset],
+        value,
+        htmlValue: htmlGrid?.[rowOffset]?.[colOffset],
+        label: plainGrid[rowOffset]?.[colOffset] ?? ""
+      })));
+      for (const {
+        rowIndex,
+        row,
+        column,
+        value,
+        htmlValue,
+        label
+      } of plan) {
+        if (!row || !column) continue;
+        if (value === null) {
+          skipped++;
+          continue;
+        }
+        if (!isPasteTargetCell(column, row)) {
+          skipped++;
+          continue;
+        }
+        const colKey = String(column.colKey);
+        const writtenValue = column.transformPaste ? column.transformPaste({
+          row,
+          rowIndex,
+          column,
+          value: htmlValue ?? void 0,
+          label
+        }) : value;
+        writeCellPasteValue(row, colKey, writtenValue);
+        written.push({
+          row,
+          colKey,
+          value: writtenValue
+        });
+      }
+      if (!written.length) {
+        msg("当前选中的单元格不可编辑，无法粘贴");
+        return {
+          written: 0,
+          skipped
+        };
+      }
+      if (!singleCell) {
+        const maxRowIdx = Math.min(anchorRowIdx + grid.length - 1, rows.length - 1);
+        const maxColIdx = Math.min(anchorColIdx + grid[0].length - 1, columns.length - 1);
+        const cells = [];
+        for (let rowIdx = anchorRowIdx; rowIdx <= maxRowIdx; rowIdx++) {
+          for (let colIdx = anchorColIdx; colIdx <= maxColIdx; colIdx++) {
+            const row = rows[rowIdx];
+            const column = columns[colIdx];
+            if (!row || !column) continue;
+            if (grid[rowIdx - anchorRowIdx][colIdx - anchorColIdx] === null) continue;
+            cells.push({
+              row,
+              colKey: String(column.colKey)
+            });
+          }
+        }
+        if (cells.length) {
+          selectedCells.value = cells;
+          selectedCell.value = cells.at(-1);
+          selectedCellAnchor.value = cells[0];
+          syncSelectedRowKeysFromCells();
+        }
+      }
+      notifyDataChange();
+      setTimeout(() => {
+        void validateTableData({
+          showErrorMessage: false,
+          scrollToFirstError: false
+        });
+      }, 0);
+      props.onCellPaste?.({
+        text: serializeTsv(grid),
+        written,
+        skipped
+      });
+      return {
+        written: written.length,
+        skipped
+      };
+    }
+    function resolveFormItemLazy(column) {
+      const formItem = column.formItem;
+      if (!formItem) return false;
+      if (formItem.lazy !== void 0) return formItem.lazy;
+      if (/upload|switch|radio|checkbox/.test(getQdFormComponentName(formItem.component))) {
+        return false;
+      }
+      return props.lazyForm;
+    }
+    function resolveFormItemIfRender(column, row) {
+      const formItem = column.formItem;
+      const ifRender = formItem?.ifRender;
+      if (!formItem || isEmpty(ifRender)) return true;
+      if (typeof ifRender === "function" && ifRender.__qdCompute) {
+        return ifRender(row, formItem.crudMode);
+      }
+      return ifRender !== false;
+    }
+    function resolveFormItemVirtualRender(column) {
+      const formItem = column.formItem;
+      if (!formItem) return false;
+      if (formItem.virtualValidateRender !== void 0) return formItem.virtualValidateRender;
+      if (getQdFormComponentName(formItem.component).includes("upload")) return true;
+      return false;
+    }
+    function shouldRenderVirtualFormItem(column, row) {
+      if (!resolveFormItemVirtualRender(column)) return false;
+      if (column.formItem?.virtualValidateRender !== void 0) return true;
+      if (!getQdFormComponentName(column.formItem?.component).includes("upload")) return true;
+      const filesModel = column.formItem?.component?.vModelFiles;
+      if (typeof filesModel !== "string") return true;
+      const files = get(row, filesModel);
+      return Array.isArray(files) && files.some((file) => file.status !== "success");
+    }
+    function removeEditingCell(target) {
+      editingCells.value = editingCells.value.filter((item) => !isSameEditingCell(item, target));
+      editingCellUpdateFns.delete(getCellKey(target.row, target.colKey));
+      clearAutofocusEditingCell(target);
+      if (!activeEditingCell.value || !isSameEditingCell(activeEditingCell.value, target)) return;
+      activeEditingCell.value = editingCells.value.at(-1);
+    }
+    function clearAutofocusEditingCell(target) {
+      if (!autofocusEditingCell.value || !isSameEditingCell(autofocusEditingCell.value, target)) {
+        return;
+      }
+      autofocusEditingCell.value = void 0;
+    }
+    let suppressEnterCellKey = null;
+    function shouldBlockEditingCellExit(results) {
+      const block = props.editCellValidationBlock;
+      if (block === "none") return false;
+      return results?.some((item) => {
+        if (item.result !== false) return false;
+        const type = item.type === "warning" ? "warning" : "error";
+        return block === "all" || block === type;
+      }) ?? false;
+    }
+    async function exitEditingCell(target) {
+      const cellKey = getCellKey(target.row, target.colKey);
+      const version = (editingCellValidationVersions.get(cellKey) ?? 0) + 1;
+      editingCellValidationVersions.set(cellKey, version);
+      const {
+        result = {}
+      } = await tableRef.value?.validateTableData() ?? {};
+      if (version !== editingCellValidationVersions.get(cellKey)) return;
+      if (!isEditingCell(target.row, target.colKey)) return;
+      if (shouldBlockEditingCellExit(result[cellKey])) return;
+      editingCellValidationVersions.delete(cellKey);
+      removeEditingCell(target);
+      suppressEnterCellKey = cellKey;
+      setTimeout(() => {
+        if (suppressEnterCellKey === cellKey) suppressEnterCellKey = null;
+      }, 0);
+    }
+    function enterEditingCell(target, autofocus = true) {
+      if (tableReadonly.value) return;
+      const currentActiveCell = activeEditingCell.value;
+      if (currentActiveCell && !isSameEditingCell(currentActiveCell, target)) {
+        clearAutofocusEditingCell(currentActiveCell);
+        void exitEditingCell(currentActiveCell);
+      }
+      const editingCell = findEditingCell(target.row, target.colKey);
+      if (!editingCell) editingCells.value = [...editingCells.value, target];
+      activeEditingCell.value = editingCell ?? target;
+      if (autofocus) autofocusEditingCell.value = activeEditingCell.value;
+    }
+    async function exitAllEditingCells() {
+      for (const editingCell of [...editingCells.value]) {
+        await exitEditingCell(editingCell);
+      }
+    }
+    function exitActiveEditingCell() {
+      if (!activeEditingCell.value) return;
+      void exitEditingCell(activeEditingCell.value);
+    }
+    function handleCellClick(context) {
+      if (suppressNextCellClick) return;
+      const column = context.col;
+      const cell = {
+        row: context.row,
+        colKey: column.colKey
+      };
+      if (!handledSelectionEvents.has(context.e)) applyCellSelection(cell, context.e);
+      if (hasSelectionModifier(context.e)) return;
+      if (tableReadonly.value) return;
+      if (column.formItem) {
+        const editingCell = findEditingCell(context.row, column.colKey);
+        if (editingCell) enterEditingCell(editingCell, false);
+        else exitActiveEditingCell();
+        return;
+      }
+      if (!column.edit || column.edit.keepEditMode || column.edit.defaultEditable) {
+        exitActiveEditingCell();
+        return;
+      }
+      enterEditingCell({
+        row: context.row,
+        colKey: column.colKey
+      });
+    }
+    function renderDisplayCell(vueH, column, context) {
+      if (typeof column.cell === "function") return column.cell(vueH, context);
+      const colKey = String(column.colKey);
+      if (slots[colKey]) return slots[colKey]?.(context);
+      if (typeof column.cell === "string" && slots[column.cell]) {
+        return slots[column.cell]?.(context);
+      }
+      if (typeof column.render === "function") {
+        return column.render(vueH, {
+          ...context,
+          type: "cell"
+        });
+      }
+      const value = get(context.row, colKey);
+      if (value !== void 0 && value !== "" && value !== null) return value;
+      const emptyContent = props.cellEmptyContent;
+      if (typeof emptyContent === "function") return emptyContent(vueH, context);
+      if (emptyContent !== void 0) return emptyContent;
+      if (slots.cellEmptyContent) return slots.cellEmptyContent(context);
+      return slots["cell-empty-content"]?.(context) ?? value;
+    }
+    function isEditableOrPopupTarget(target) {
+      if (!(target instanceof Element)) return false;
+      return !!target.closest(editableElementSelector) || !!target.closest(popupLayerSelector);
+    }
+    function handleDocumentKeydown(event) {
+      if (!activated.value) return;
+      if (event.defaultPrevented) return;
+      if (event.key === "Escape") {
+        if (cellDragState) handleCellDragCancel();
+        handleSelectionClearKeydown(event.target);
+        return;
+      }
+      if ((event.metaKey || event.ctrlKey) && !event.altKey && !event.shiftKey && event.key.toLowerCase() === "c" && canCopySelectedCells(event.target)) {
+        event.preventDefault();
+        void copySelectedCells();
+      }
+    }
+    function handleSelectionClearKeydown(target) {
+      if (!activeEditingCell.value && !selectedCell.value && !selectedCells.value.length && !copiedCells.value.length) return;
+      if (target instanceof Element && target.closest(popupLayerSelector)) {
+        return;
+      }
+      if (copiedCells.value.length) {
+        copiedCells.value = [];
+        return;
+      }
+      const hasCellSelection = !!selectedCell.value || selectedCells.value.length > 0;
+      selectedCell.value = void 0;
+      selectedCells.value = [];
+      if (hasCellSelection) {
+        selectedRowKeys.value = [];
+        if (props.activeRowType) activeRowKeys.value = [];
+      }
+      exitActiveEditingCell();
+    }
+    function handleDocumentPaste(event) {
+      if (!activated.value) return;
+      if (!selectedCell.value && !selectedCells.value.length) return;
+      if (!props.cellClipboard || !reCellSelectable.value) return;
+      if (tableReadonly.value) return;
+      if (isEditableOrPopupTarget(event.target)) return;
+      const text = event.clipboardData?.getData("text/plain");
+      if (!text) return;
+      event.preventDefault();
+      const result = applyCellPaste(text, event.clipboardData?.getData("text/html"));
+      if (result.written > 0) copiedCells.value = [];
+    }
+    function handleDocumentClick(event) {
+      if (suppressNextCellClick) return;
+      if (!activated.value) return;
+      if (!editingCells.value.length && !selectedCell.value && !selectedCells.value.length) return;
+      const hasVisibleDialog = Array.from(document.querySelectorAll(".t-dialog")).some((element) => element.getClientRects().length);
+      const hasVisibleDrawer = Array.from(document.querySelectorAll(".t-drawer")).some((element) => element.classList.contains("t-drawer--open") || element.getAnimations({
+        subtree: true
+      }).some((animation) => animation.playState === "running"));
+      if (hasVisibleDialog || hasVisibleDrawer) return;
+      const insideInteractiveArea = event.composedPath().some((target) => target instanceof Element && target.matches("td, .t-popup, .qd-dialog, .t-dialog, .t-drawer, .t-image-viewer, .qd-multi-file-viewer, [data-popper-placement]"));
+      if (insideInteractiveArea) return;
+      selectedCell.value = void 0;
+      selectedCells.value = [];
+      void exitAllEditingCells();
+    }
+    function getFirstValidationError(results) {
+      return results[0]?.errorList.find((item) => !item.result && item.message)?.message;
+    }
+    function resolveValidationResults(result) {
+      const results = [];
+      for (const [rowIndex, row] of data.value.entries()) {
+        for (const {
+          column,
+          colIndex
+        } of editableColumns.value) {
+          if (!column.colKey) continue;
+          const errorList = result[getCellKey(row, column.colKey)];
+          if (!errorList?.length) continue;
+          results.push({
+            row,
+            rowIndex,
+            col: column,
+            colIndex,
+            value: get(row, column.colKey),
+            editedRow: row,
+            errorList
+          });
+        }
+      }
+      return results;
+    }
+    async function showFirstValidationError(results, params) {
+      const firstError = results[0];
+      const message = getFirstValidationError(results);
+      if (!firstError || !message) return;
+      const column = firstError.col;
+      const shouldLocateFirstError = params?.scrollToFirstError !== false;
+      if (shouldLocateFirstError) {
+        tableRef.value?.scrollToElement({
+          index: firstError.rowIndex,
+          top: tableHeaderEl.value?.clientHeight ?? 0
+        });
+        await nextTick();
+        setTimeout(async () => {
+          if (resolveFormItemLazy(column)) {
+            enterEditingCell({
+              row: firstError.row,
+              colKey: column.colKey
+            });
+            await nextTick();
+          }
+          tableRef.value?.scrollColumnIntoView(String(column.colKey));
+        });
+      }
+      await nextTick();
+      if (params?.showErrorMessage) msgError(message);
+    }
+    function resolveColumnRules(editRules, row) {
+      if (!editRules) return void 0;
+      if (typeof editRules !== "function") return editRules;
+      return editRules({
+        row
+      });
+    }
+    function buildOffscreenForm(rows, renderVirtualComponents) {
+      const formData = {};
+      const fields = [];
+      const items = [];
+      for (const row of rows) {
+        for (const {
+          column
+        } of editableColumns.value) {
+          if (!column.formItem && !column.edit?.rules || !column.colKey) continue;
+          if (!resolveFormItemIfRender(column, row)) continue;
+          const formItem = column.formItem;
+          const label = typeof column.title === "string" ? column.title : "";
+          const shouldRender = renderVirtualComponents && shouldRenderVirtualFormItem(column, row);
+          const resolved = resolveQdFormItemOptions({
+            formItem: {
+              ...formItem ?? {},
+              rules: formItem?.rules ?? resolveColumnRules(column.edit?.rules, row)
+            },
+            context: row,
+            label,
+            t: formT
+          });
+          if (!resolved.rules.length && !shouldRender) continue;
+          const name = getCellKey(row, column.colKey);
+          Object.defineProperty(formData, name, {
+            configurable: true,
+            enumerable: true,
+            get: () => get(row, column.colKey),
+            set: (value) => set(row, column.colKey, value)
+          });
+          if (resolved.rules.length) fields.push({
+            name,
+            rules: resolved.rules
+          });
+          if (shouldRender) {
+            const submitFormItem = {
+              ...formItem ?? {}
+            };
+            delete submitFormItem.required;
+            delete submitFormItem.rules;
+            items.push({
+              name,
+              label,
+              ...submitFormItem,
+              context: row
+            });
+          }
+        }
+      }
+      return {
+        fields,
+        formData,
+        items
+      };
+    }
+    function serializeOffscreen(task) {
+      const run2 = offscreenChain.then(task, task);
+      offscreenChain = run2.then(() => void 0, () => void 0);
+      return run2;
+    }
+    async function mountOffscreenForm(formData, items) {
+      unmountOffscreenForm();
+      const container = document.createElement("div");
+      container.setAttribute("aria-hidden", "true");
+      Object.assign(container.style, {
+        position: "fixed",
+        top: "0",
+        left: "-99999px",
+        width: "1px",
+        height: "1px",
+        overflow: "hidden",
+        opacity: "0",
+        pointerEvents: "none"
+      });
+      document.body.appendChild(container);
+      const vnode = h(QdForm, {
+        data: formData,
+        items
+      });
+      vnode.appContext = offscreenAppContext;
+      render(vnode, container);
+      offscreenContainer = container;
+      offscreenVNode = vnode;
+      offscreenInstance = vnode.component?.exposed;
+      await nextTick();
+      await nextTick();
+    }
+    function unmountOffscreenForm() {
+      if (offscreenVNode && offscreenContainer) {
+        render(null, offscreenContainer);
+        offscreenContainer.remove();
+      }
+      offscreenVNode = null;
+      offscreenContainer = null;
+      offscreenInstance = null;
+    }
+    async function validateRowsViaOffscreenRules(rows) {
+      const {
+        fields,
+        formData
+      } = buildOffscreenForm(rows, false);
+      const result = {};
+      await Promise.all(fields.map(async ({
+        name,
+        rules
+      }) => {
+        const ruleResults = await validate(get(formData, name), rules, {
+          formData,
+          name
+        });
+        if (ruleResults.some((item) => item.result !== true)) result[name] = ruleResults;
+      }));
+      return result;
+    }
+    async function runOffscreenBeforeSubmit(rows) {
+      const {
+        formData,
+        items
+      } = buildOffscreenForm(rows, true);
+      if (!items.length) return {
+        success: true,
+        message: ""
+      };
+      try {
+        await mountOffscreenForm(formData, items);
+        const submitContext = await offscreenInstance.submit({
+          showErrorMessage: false
+        });
+        return {
+          success: submitContext.validateResult === true,
+          message: submitContext.firstError ?? ""
+        };
+      } finally {
+        unmountOffscreenForm();
+      }
+    }
+    async function validateTableViaOffscreenForm() {
+      return validateRowsViaOffscreenRules(data.value);
+    }
+    async function validateSingleRowViaOffscreenForm(rowValue) {
+      const row = data.value.find((item) => getRowValue(item) === rowValue);
+      if (!row) return [];
+      const result = await validateRowsViaOffscreenRules([row]);
+      return resolveValidationResults(result);
+    }
+    async function submitTableViaOffscreenForm(params, showErrorMessage) {
+      const queueResult = await runOffscreenBeforeSubmit(data.value);
+      if (!queueResult.success) {
+        if (showErrorMessage && queueResult.message) msgError(queueResult.message);
+        return {
+          result: {},
+          results: [],
+          validateResult: false,
+          firstError: queueResult.message,
+          showErrorMessage,
+          tableData: easyCopy(data.value)
+        };
+      }
+      const result = await validateRowsViaOffscreenRules(data.value);
+      const cellResults = resolveValidationResults(result);
+      if (cellResults.length) await showFirstValidationError(cellResults, {
+        ...params,
+        showErrorMessage
+      });
+      return {
+        result,
+        results: cellResults,
+        validateResult: !cellResults.length,
+        firstError: getFirstValidationError(cellResults),
+        showErrorMessage,
+        tableData: easyCopy(data.value)
+      };
+    }
+    async function submitSingleRowViaOffscreenForm(row, params, showErrorMessage) {
+      if (!row) {
+        return {
+          result: [],
+          trigger: "parent",
+          validateResult: false,
+          showErrorMessage,
+          rowData: void 0
+        };
+      }
+      const queueResult = await runOffscreenBeforeSubmit([row]);
+      const rowData = easyCopy(row);
+      if (!queueResult.success) {
+        if (showErrorMessage && queueResult.message) msgError(queueResult.message);
+        return {
+          result: [],
+          trigger: "parent",
+          validateResult: false,
+          firstError: queueResult.message,
+          showErrorMessage,
+          rowData
+        };
+      }
+      const result = await validateRowsViaOffscreenRules([row]);
+      const cellResults = resolveValidationResults(result);
+      await showFirstValidationError(cellResults, {
+        ...params,
+        showErrorMessage
+      });
+      return {
+        result: cellResults,
+        trigger: "parent",
+        validateResult: !cellResults.length,
+        firstError: getFirstValidationError(cellResults),
+        showErrorMessage,
+        rowData
+      };
+    }
+    async function validateTableData(params) {
+      const result = isVirtualScroll.value ? await serializeOffscreen(() => validateTableViaOffscreenForm()) : (await tableRef.value?.validateTableData())?.result ?? {};
+      if (isVirtualScroll.value) {
+        replaceTableValidationErrors(result);
+        props.onValidate?.({
+          result
+        });
+      }
+      const cellResults = resolveValidationResults(result);
+      const context = {
+        result,
+        results: cellResults,
+        validateResult: !cellResults.length,
+        firstError: getFirstValidationError(cellResults)
+      };
+      await showFirstValidationError(cellResults, params);
+      return context;
+    }
+    async function validateRowData(rowValue, params) {
+      const result = isVirtualScroll.value ? await serializeOffscreen(() => validateSingleRowViaOffscreenForm(rowValue)) : (await tableRef.value?.validateRowData(rowValue))?.result ?? [];
+      if (isVirtualScroll.value) {
+        replaceRowValidationErrors(rowValue, result);
+        props.onRowValidate?.({
+          result,
+          trigger: "parent"
+        });
+      }
+      const context = {
+        result,
+        trigger: "parent",
+        validateResult: !result.length,
+        firstError: getFirstValidationError(result)
+      };
+      await showFirstValidationError(result, params);
+      return context;
+    }
+    function registerBeforeSubmitQueue(rowValue, item) {
+      const queue = beforeSubmitQueueMap.get(rowValue) ?? /* @__PURE__ */ new Set();
+      queue.add(item);
+      beforeSubmitQueueMap.set(rowValue, queue);
+      return () => {
+        queue.delete(item);
+        if (!queue.size) beforeSubmitQueueMap.delete(rowValue);
+      };
+    }
+    async function runBeforeSubmitQueue(rowValue) {
+      const queue = rowValue === void 0 ? Array.from(beforeSubmitQueueMap.values()).flatMap((items) => Array.from(items)) : Array.from(beforeSubmitQueueMap.get(rowValue) ?? []);
+      for (const item of queue) {
+        const [error, result] = await suspectedWrapperPromise(item());
+        if (error) return {
+          success: false,
+          message: error.message
+        };
+        if (result === false) return {
+          success: false,
+          message: ""
+        };
+        if (typeof result === "object" && !result.success) {
+          return {
+            success: false,
+            message: result.message ?? ""
+          };
+        }
+      }
+      return {
+        success: true,
+        message: ""
+      };
+    }
+    async function submitTableData(params) {
+      const showErrorMessage = params?.showErrorMessage ?? true;
+      if (isVirtualScroll.value) {
+        return serializeOffscreen(() => submitTableViaOffscreenForm(params, showErrorMessage));
+      }
+      const queueResult = await runBeforeSubmitQueue();
+      if (!queueResult.success) {
+        if (showErrorMessage && queueResult.message) msgError(queueResult.message);
+        return {
+          result: {},
+          results: [],
+          validateResult: false,
+          firstError: queueResult.message,
+          showErrorMessage,
+          tableData: easyCopy(data.value)
+        };
+      }
+      const validateContext = await validateTableData({
+        ...params,
+        showErrorMessage
+      });
+      return {
+        ...validateContext,
+        showErrorMessage,
+        tableData: easyCopy(data.value)
+      };
+    }
+    async function submitRowData(rowValue, params) {
+      const showErrorMessage = params?.showErrorMessage ?? true;
+      const row = data.value.find((item) => getRowValue(item) === rowValue);
+      if (isVirtualScroll.value) {
+        return serializeOffscreen(() => submitSingleRowViaOffscreenForm(row, params, showErrorMessage));
+      }
+      const queueResult = await runBeforeSubmitQueue(rowValue);
+      if (!queueResult.success) {
+        if (showErrorMessage && queueResult.message) msgError(queueResult.message);
+        return {
+          result: [],
+          trigger: "parent",
+          validateResult: false,
+          firstError: queueResult.message,
+          showErrorMessage,
+          rowData: row ? easyCopy(row) : void 0
+        };
+      }
+      const validateContext = await validateRowData(rowValue, {
+        ...params,
+        showErrorMessage
+      });
+      return {
+        ...validateContext,
+        showErrorMessage,
+        rowData: row ? easyCopy(row) : void 0
+      };
+    }
+    function isActiveFilterValue(value) {
+      if (Array.isArray(value)) return value.length > 0;
+      return value !== void 0 && value !== null && value !== "";
+    }
+    function getActiveFilterParams() {
+      return Object.fromEntries(Object.entries(filterValue?.value ?? {}).filter(([, value]) => isActiveFilterValue(value)));
+    }
+    function getFilterColumns(columns) {
+      return columns.flatMap((column) => column.children ? getFilterColumns(column.children) : column.colKey ? [column] : []);
+    }
+    function getActiveFilterEntries() {
+      const values = filterValue?.value ?? {};
+      return getFilterColumns(props.columns || []).flatMap((column) => {
+        if (!column.colKey) return [];
+        const value = values[column.colKey];
+        if (!isActiveFilterValue(value)) return [];
+        const filterItem = column.filterItem === true ? {} : column.filterItem;
+        const type = column.filter?.type ?? (filterItem?.component ? void 0 : filterItem?.type);
+        return [{
+          colKey: column.colKey,
+          type,
+          value
+        }];
+      });
+    }
+    function resolveFilterOptions(column, configuredOptions, reuseCell = true) {
+      const counts = /* @__PURE__ */ new Map();
+      const firstRows = /* @__PURE__ */ new Map();
+      let blankCount = 0;
+      const colKey = column.colKey;
+      data.value.forEach((row, rowIndex) => {
+        const value = colKey ? get(row, colKey) : void 0;
+        if (isEmpty(value)) {
+          blankCount += 1;
+          return;
+        }
+        if (typeof value !== "string" && typeof value !== "number") return;
+        counts.set(value, (counts.get(value) ?? 0) + 1);
+        if (!firstRows.has(value)) firstRows.set(value, {
+          row,
+          rowIndex
+        });
+      });
+      if (configuredOptions) {
+        const options2 = configuredOptions.map((option) => ({
+          ...option,
+          count: option.count ?? counts.get(option.value) ?? 0
+        }));
+        const blankOption = options2.find((option) => option.value === QD_TABLE_BLANK_FILTER_VALUE);
+        if (blankOption) {
+          blankOption.count = blankCount;
+        } else if (blankCount) {
+          options2.unshift({
+            label: tableT("filterItemBlankText"),
+            value: QD_TABLE_BLANK_FILTER_VALUE,
+            count: blankCount
+          });
+        }
+        return options2;
+      }
+      const colIndex = getFilterColumns(props.columns || []).indexOf(column);
+      const options = [...counts].map(([value, count]) => {
+        const firstRow = firstRows.get(value);
+        return {
+          label: String(value),
+          value,
+          count,
+          ...reuseCell && firstRow ? {
+            render: () => renderDisplayCell(h, column, {
+              ...firstRow,
+              col: column,
+              colIndex
+            })
+          } : {}
+        };
+      });
+      if (blankCount) {
+        options.unshift({
+          label: tableT("filterItemBlankText"),
+          value: QD_TABLE_BLANK_FILTER_VALUE,
+          count: blankCount
+        });
+      }
+      return options;
+    }
+    function createConfigFilterComponent(component) {
+      return /* @__PURE__ */ defineComponent({
+        inheritAttrs: false,
+        setup(_, {
+          attrs
+        }) {
+          return () => {
+            const filterAttrs = Object.fromEntries(Object.entries(attrs).filter(([, value]) => value !== void 0));
+            return h(_sfc_main$1, {
+              config: component,
+              ...filterAttrs,
+              class: ["qd-service-table-filter-custom", filterAttrs.class]
+            });
+          };
+        }
+      });
+    }
+    function resolveColumnFilter(column, filterItem, filter) {
+      const config = filterItem === true ? {} : filterItem;
+      const {
+        component,
+        options,
+        reuseCell = true,
+        type = "multiple",
+        props: filterProps,
+        ...filterOptions
+      } = config;
+      let generatedFilter;
+      if (component) {
+        generatedFilter = {
+          resetValue: "",
+          showConfirmAndReset: true,
+          ...filterOptions,
+          props: filterProps,
+          component: createConfigFilterComponent(component)
+        };
+      } else if (type === "input") {
+        generatedFilter = {
+          resetValue: "",
+          showConfirmAndReset: true,
+          ...filterOptions,
+          props: {
+            placeholder: tableT("filterItemInputPlaceholder"),
+            ...filterProps,
+            class: "qd-service-table-filter-input"
+          },
+          type
+        };
+      } else {
+        const resolvedOptions = resolveFilterOptions(column, options, reuseCell);
+        generatedFilter = {
+          resetValue: type === "multiple" ? [] : "",
+          showConfirmAndReset: true,
+          ...filterOptions,
+          list: resolvedOptions,
+          props: {
+            ...filterProps,
+            options: resolvedOptions,
+            type
+          },
+          component: QdServiceTableFilterItem,
+          confirmDisabled: (value) => value === null,
+          ...!options && reuseCell ? {
+            renderFilterValue: (_h, {
+              value
+            }) => {
+              const values = Array.isArray(value) ? value : [value];
+              return values.map((item, index) => {
+                const option = resolvedOptions.find((option2) => option2.value === item);
+                const content = option?.render?.() ?? option?.label ?? String(item);
+                return [index ? "，" : null, h("span", {
+                  class: "qd-service-table-filter-item__cell",
+                  inert: true
+                }, [content])];
+              });
+            }
+          } : {}
+        };
+      }
+      const resolvedFilter = {
+        ...generatedFilter,
+        ...filter,
+        props: {
+          ...generatedFilter.props,
+          ...filter?.props
+        }
+      };
+      if (resolvedFilter.component === QdServiceTableFilterItem) {
+        resolvedFilter.props = {
+          ...resolvedFilter.props,
+          showConfirmAndReset: resolvedFilter.showConfirmAndReset !== false
+        };
+      }
+      return resolvedFilter;
+    }
+    function wrapColumns(columns) {
+      return columns.map((column) => {
+        const {
+          children,
+          edit,
+          filter,
+          filterItem,
+          formItem,
+          ...tableColumn
+        } = column;
+        const reColumn = {
+          ...tableColumn,
+          // 解除 TDesign 默认 600px 拖拽上限；业务显式配置仍优先生效
+          // minWidth 80 与 TDesign DEFAULT_MIN_WIDTH 一致，仅满足类型必填
+          resize: {
+            minWidth: 80,
+            maxWidth: Number.MAX_SAFE_INTEGER,
+            ...tableColumn.resize
+          },
+          ...!tableReadonly.value && edit ? {
+            edit
+          } : {},
+          ...filterItem ? {
+            filter: resolveColumnFilter(column, filterItem, filter)
+          } : {
+            filter
+          },
+          ...formItem ? {
+            formItem
+          } : {},
+          ...children ? {
+            children: wrapColumns(children)
+          } : {}
+        };
+        const columnClassName = reColumn.className === void 0 ? [] : Array.isArray(reColumn.className) ? reColumn.className : [reColumn.className];
+        const selectedCellClass = (context) => {
+          if (context.type !== "td" || !reCellSelectable.value) return "";
+          if (!isSelectedCell(context.row, column.colKey)) return "";
+          const rowIndex = data.value.findIndex((item) => getRowValue(item) === getRowValue(context.row));
+          const colIndex = leafColumns.value.findIndex((col) => col.colKey === column.colKey);
+          const classes = ["qd-service-table__selected-cell"];
+          if (!isSelectedCellAt(rowIndex - 1, colIndex)) classes.push("qd-service-table__selected-bt");
+          if (!isSelectedCellAt(rowIndex + 1, colIndex)) classes.push("qd-service-table__selected-bb");
+          if (!isSelectedCellAt(rowIndex, colIndex - 1)) classes.push("qd-service-table__selected-bl");
+          if (!isSelectedCellAt(rowIndex, colIndex + 1)) classes.push("qd-service-table__selected-br");
+          return classes.join(" ");
+        };
+        const copiedCellClass = (context) => {
+          if (context.type !== "td" || !isCopiedCell(context.row, column.colKey)) return "";
+          const rowIndex = data.value.findIndex((item) => getRowValue(item) === getRowValue(context.row));
+          const colIndex = leafColumns.value.findIndex((col) => col.colKey === column.colKey);
+          const classes = ["qd-service-table__copied-cell"];
+          if (!isCopiedCellAt(rowIndex - 1, colIndex)) classes.push("qd-service-table__copied-bt");
+          if (!isCopiedCellAt(rowIndex + 1, colIndex)) classes.push("qd-service-table__copied-bb");
+          if (!isCopiedCellAt(rowIndex, colIndex - 1)) classes.push("qd-service-table__copied-bl");
+          if (!isCopiedCellAt(rowIndex, colIndex + 1)) classes.push("qd-service-table__copied-br");
+          return classes.join(" ");
+        };
+        const finalizeColumn = (col) => {
+          const previousAttrs = col.attrs;
+          col.attrs = (context) => {
+            const baseAttrs = typeof previousAttrs === "function" ? previousAttrs(context) : previousAttrs;
+            if (context.type !== "td") return baseAttrs;
+            return {
+              ...baseAttrs,
+              // 拖选反查用：表头/表尾/横向虚拟占位列不带标记，closest 直接排除
+              "data-qd-col-key": String(column.colKey),
+              "data-qd-row-key": String(getRowValue(context.row)),
+              onMousedownCapture: (event) => {
+                handleCellDragMousedown(event, {
+                  row: context.row,
+                  colKey: column.colKey
+                }, column);
+              },
+              onClickCapture: (event) => {
+                if (suppressNextCellClick) return;
+                handledSelectionEvents.add(event);
+                applyCellSelection({
+                  row: context.row,
+                  colKey: column.colKey
+                }, event);
+              }
+            };
+          };
+          return col;
+        };
+        if (tableReadonly.value || !formItem) {
+          if (!children && formItemColumns.value.length) {
+            reColumn.className = [...columnClassName, selectedCellClass, copiedCellClass, (context) => context.type === "td" ? "qd-service-table__non-editable-col" : ""];
+          } else if (!children) {
+            reColumn.className = [...columnClassName, selectedCellClass, copiedCellClass];
+          }
+          return finalizeColumn(reColumn);
+        }
+        const columnAttrs = column.attrs;
+        reColumn.attrs = (context) => {
+          const attrs = typeof columnAttrs === "function" ? columnAttrs(context) : columnAttrs;
+          const onDblclick = attrs?.onDblclick;
+          return {
+            ...attrs,
+            onDblclick: (event) => {
+              if (typeof onDblclick === "function") onDblclick(event);
+              if (event.defaultPrevented || tableReadonly.value || !resolveFormItemLazy(column)) {
+                return;
+              }
+              enterEditingCell({
+                row: context.row,
+                colKey: column.colKey
+              });
+            }
+          };
+        };
+        reColumn.className = [...columnClassName, "qd-service-table__form-item-col", selectedCellClass, copiedCellClass, (context) => context.type === "td" && !resolveFormItemIfRender(column, context.row) ? "qd-service-table__non-editable-col" : ""];
+        const generatedEdit = {
+          component: QdServiceTableEditCell,
+          showEditIcon: false,
+          validateTrigger: "change",
+          rules: (context) => resolveQdFormItemOptions({
+            formItem,
+            context: context.row,
+            label: typeof column.title === "string" ? column.title : "",
+            t: formT
+          }).rules,
+          props: (context) => {
+            const rowValue = getRowValue(context.row);
+            const row = context.row;
+            const cellContext = {
+              ...context,
+              row
+            };
+            const colKey = column.colKey;
+            editingCellUpdateFns.set(getCellKey(row, colKey), context.updateEditedCellValue);
+            return {
+              row,
+              rowValue,
+              colKey: String(colKey),
+              formItem,
+              label: column.title,
+              sourceRow: props.data?.find((item) => getRowValue(item) === rowValue) ?? data.value.find((item) => getRowValue(item) === rowValue) ?? row,
+              updateEditedCellValue: context.updateEditedCellValue,
+              notifyDataChange,
+              getHorizontalScroll: () => getCurrentTableContentEl()?.scrollLeft,
+              setHorizontalScroll: (scrollLeft) => {
+                const scrollEl = getCurrentTableContentEl();
+                if (!scrollEl || scrollEl.scrollLeft === scrollLeft) return;
+                scrollEl.scrollLeft = scrollLeft;
+              },
+              lazy: resolveFormItemLazy(column),
+              active: !!activeEditingCell.value && isSameEditingCell(activeEditingCell.value, {
+                row,
+                colKey
+              }),
+              autofocus: !!autofocusEditingCell.value && isSameEditingCell(autofocusEditingCell.value, {
+                row,
+                colKey
+              }),
+              validationErrors: editingCellValidationErrors.value.get(getRowValue(row))?.get(String(colKey)),
+              renderCell: () => renderDisplayCell(h, column, cellContext),
+              activate: () => {
+                if (suppressEnterCellKey === getCellKey(row, colKey)) return;
+                enterEditingCell({
+                  row,
+                  colKey
+                });
+              },
+              consumeAutofocus: () => clearAutofocusEditingCell({
+                row,
+                colKey
+              }),
+              registerBeforeSubmit: registerBeforeSubmitQueue
+            };
+          }
+        };
+        const explicitEdit = edit;
+        const generatedProps = generatedEdit.props;
+        reColumn.edit = {
+          ...generatedEdit,
+          ...explicitEdit,
+          props: (context) => ({
+            ...typeof generatedProps === "function" ? generatedProps(context) : generatedProps,
+            ...typeof explicitEdit?.props === "function" ? explicitEdit.props(context) : explicitEdit?.props
+          })
+        };
+        return finalizeColumn(reColumn);
+      });
+    }
+    function getCurrentTableContentEl() {
+      const rootEl = tableRef.value?.$el ?? currentInstance?.proxy?.$el;
+      if (!(rootEl instanceof HTMLElement)) return tableContentEl.value;
+      return rootEl.querySelector(".t-table__content") ?? tableContentEl.value;
+    }
+    function clearEditingState() {
+      editingCells.value = [];
+      activeEditingCell.value = void 0;
+      autofocusEditingCell.value = void 0;
+      editingCellUpdateFns.clear();
+    }
+    function setScrollElTo(position = scrollRecord) {
+      const scrollEl = getCurrentTableContentEl();
+      if (!scrollEl) return;
+      const {
+        scrollTop,
+        scrollLeft
+      } = scrollEl;
+      const {
+        left
+      } = position;
+      const top = position.bottom && !isVirtualScroll.value ? Math.max(scrollEl.scrollHeight - scrollEl.clientHeight, 0) : position.top;
+      if (top === scrollTop && left === scrollLeft) return;
+      scrollEl.scrollTo({
+        top,
+        left
+      });
+    }
+    function cancelScrollRestore() {
+      if (!scrollRestoreRafId) return;
+      cancelAnimationFrame(scrollRestoreRafId);
+      scrollRestoreRafId = 0;
+    }
+    function scheduleScrollRestore(position, attempts = scrollRestoreMaxAttempts) {
+      scrollRestoreRafId = requestAnimationFrame(() => {
+        scrollRestoreRafId = 0;
+        if (!activated.value) return;
+        setScrollElTo(position);
+        if (attempts <= 1) return;
+        scheduleScrollRestore(position, attempts - 1);
+      });
+    }
+    async function triggerAffixedRefresh() {
+      if (!outsideScrollEl.value) return;
+      outsideScrollEl.value.scrollTo({
+        top: outsideScrollEl.value.scrollTop + 1
+      });
+      await nextTick();
+      outsideScrollEl.value.scrollTo({
+        top: outsideScrollEl.value.scrollTop - 1
+      });
+    }
+    function getAllColKeys(cols) {
+      if (!cols) return [];
+      return cols.reduce((keys, col) => {
+        if (col.children && col.children.length > 0) {
+          keys.push(...getAllColKeys(col.children));
+        } else if (col.colKey) {
+          keys.push(col.colKey);
+        }
+        return keys;
+      }, []);
+    }
+    function refreshAffixedMetrics() {
+      outsideScrollRect.update();
+    }
+    function updateHeaderAffixedNeeded() {
+      const contentEl = tableContentEl.value;
+      if (!props.headerAffixedTop || !tableContentVisible.value || !contentEl) {
+        headerAffixedNeeded.value = false;
+        return;
+      }
+      const contentRect = contentEl.getBoundingClientRect();
+      const scrollRect = outsideScrollEl.value?.getBoundingClientRect();
+      const headerOptions = typeof props.headerAffixedTop === "object" ? props.headerAffixedTop : void 0;
+      const visibleTop = (scrollRect?.top ?? 0) + (headerOptions?.offsetTop ?? 0);
+      const headerHeight = tableHeaderEl.value?.clientHeight ?? 0;
+      const originalHeaderNotVisible = contentRect.top < visibleTop - 1;
+      const hasVisibleBody = contentRect.bottom > visibleTop + headerHeight;
+      headerAffixedNeeded.value = originalHeaderNotVisible && hasVisibleBody;
+    }
+    function updateHorizontalScrollAffixed() {
+      const contentEl = tableContentEl.value;
+      if (props.horizontalScrollAffixedBottom === false || !tableContentVisible.value || !contentEl) {
+        horizontalScrollAffixed.value = false;
+        return;
+      }
+      const contentRect = contentEl.getBoundingClientRect();
+      const scrollRect = outsideScrollEl.value?.getBoundingClientRect();
+      const visibleBottom = (scrollRect?.bottom ?? window.innerHeight) - affixBottomOffset.value;
+      const hasHorizontalOverflow = contentEl.scrollWidth > contentEl.clientWidth + 1;
+      const hasVisibleBody = contentRect.top < visibleBottom;
+      const nativeScrollbarTop = contentRect.bottom - (contentEl.offsetHeight - contentEl.clientHeight - contentEl.clientTop);
+      const nativeScrollbarNotVisible = nativeScrollbarTop > visibleBottom + 1;
+      horizontalScrollAffixed.value = hasHorizontalOverflow && hasVisibleBody && nativeScrollbarNotVisible;
+    }
+    function refreshTableAffixPosition() {
+      if (affixRefreshRafId) return;
+      affixRefreshRafId = requestAnimationFrame(() => {
+        affixRefreshRafId = 0;
+        tableRef.value?.refreshTable();
+        updateHeaderAffixedNeeded();
+        updateHorizontalScrollAffixed();
+      });
+    }
+    function onResize(entries) {
+      const el = entries[0].target;
+      outsideScrollEl.value = getScrollEl(el);
+      refreshAffixedMetrics();
+      const headerEl = el.querySelector(".t-table__content .t-table__header");
+      tableHeaderEl.value = headerEl;
+      const contentEl = el.querySelector(".t-table__content");
+      tableContentEl.value = contentEl;
+      probeBottomBlockHeight();
+      updateHeaderAffixedNeeded();
+      refreshTableAffixPosition();
+    }
+    function isTransformAnimating(node) {
+      return node.getAnimations().length > 0;
+    }
+    function findAnimatingTransformAncestor(el) {
+      let node = el?.parentElement;
+      while (node) {
+        if (getComputedStyle(node).transform !== "none" && isTransformAnimating(node)) {
+          return node;
+        }
+        node = node.parentElement;
+      }
+      return null;
+    }
+    function watchAnimatingTransformAncestor() {
+      animatingAncestorCleanup?.();
+      const animatingNode = findAnimatingTransformAncestor(affixBaseEl.value);
+      if (!animatingNode) return;
+      const cleanup = () => {
+        animatingNode.removeEventListener("transitionend", onEnd);
+        animatingNode.removeEventListener("animationend", onEnd);
+        animatingAncestorCleanup = null;
+      };
+      const onEnd = () => {
+        cleanup();
+        refreshAffixedMetrics();
+        applyAffixedTransform();
+        probeBottomBlockHeight(false);
+        refreshTableAffixPosition();
+      };
+      animatingNode.addEventListener("transitionend", onEnd);
+      animatingNode.addEventListener("animationend", onEnd);
+      animatingAncestorCleanup = cleanup;
+    }
+    async function applyAffixedTransform() {
+      const el = affixBaseEl.value;
+      if (!el) return;
+      const {
+        y
+      } = getTransformOffset(el, {
+        skip: isTransformAnimating
+      });
+      affixedHeaderTransform.value = `translateY(-${y}px)`;
+    }
+    function handleTableMouseEnter() {
+      refreshAffixedMetrics();
+      applyAffixedTransform();
+      probeBottomBlockHeight();
+      refreshTableAffixPosition();
+    }
+    function normalizeWheelDeltaY(event, pageSize2) {
+      if (event.deltaMode === WheelEvent.DOM_DELTA_LINE) return event.deltaY * 16;
+      if (event.deltaMode === WheelEvent.DOM_DELTA_PAGE) return event.deltaY * pageSize2;
+      return event.deltaY;
+    }
+    function canConsumeHorizontalScroll(el, deltaX) {
+      if (deltaX < 0) return el.scrollLeft > 0;
+      return el.scrollLeft + el.clientWidth < el.scrollWidth - 1;
+    }
+    function isWheelFormTarget(target) {
+      if (!(target instanceof Element)) return false;
+      return !!target.closest('input, textarea, select, [contenteditable="true"], [role="spinbutton"], [role="slider"]');
+    }
+    function handleHorizontalWheel(event) {
+      if (event.defaultPrevented || event.ctrlKey || !event.shiftKey || !event.deltaY || Math.abs(event.deltaY) <= Math.abs(event.deltaX) || isWheelFormTarget(event.target)) {
+        return;
+      }
+      const rootEl = event.currentTarget;
+      const scrollEl = rootEl.querySelector(".t-table__content");
+      if (!scrollEl) return;
+      const deltaX = normalizeWheelDeltaY(event, scrollEl.clientWidth);
+      const maxLeft = Math.max(scrollEl.scrollWidth - scrollEl.clientWidth, 0);
+      if (!maxLeft) return;
+      event.preventDefault();
+      if (!canConsumeHorizontalScroll(scrollEl, deltaX)) return;
+      scrollEl.scrollLeft = Math.min(Math.max(scrollEl.scrollLeft + deltaX, 0), maxLeft);
+    }
+    function probeBottomBlockHeight(withDelay = true) {
+      if (withDelay) {
+        clearProbeDelayTimer();
+        probeDelayTimer.value = setTimeout(() => {
+          clearProbeDelayTimer();
+          probeBottomBlockHeight(false);
+        }, 320);
+      }
+      if (probeRafId) return;
+      probeRafId = requestAnimationFrame(() => {
+        probeRafId = 0;
+        const scrollEl = outsideScrollEl.value;
+        const tableEl = tableRef.value?.$el;
+        if (!scrollEl || !tableEl) return;
+        const overlayEl = scrollEl.closest(".t-dialog__ctx, .t-drawer");
+        const sRect = scrollEl.getBoundingClientRect();
+        const stack = document.elementsFromPoint(sRect.left + sRect.width / 2, sRect.bottom - 1);
+        let blockHeight = 0;
+        for (const el of stack) {
+          if (overlayEl && !overlayEl.contains(el)) continue;
+          if (tableEl.contains(el)) continue;
+          if (el === scrollEl || el.contains(scrollEl)) continue;
+          const {
+            position
+          } = getComputedStyle(el);
+          if (position !== "fixed" && position !== "sticky") continue;
+          const rect = el.getBoundingClientRect();
+          if (rect.top < sRect.top) continue;
+          blockHeight = Math.max(blockHeight, sRect.bottom - rect.top);
+        }
+        affixBottomOffset.value = blockHeight;
+      });
+    }
+    watch(columnControllerVisible, (visible) => {
+      const {
+        columns
+      } = reProps.value.tableOptions;
+      if (visible && !displayColumns.value && columns) {
+        displayColumns.value = getAllColKeys(columns);
+      }
+    }, {
+      immediate: true
+    });
+    watch(selectedRowKeys, (keys) => {
+      if (props.selectOnRowClick === false || !props.activeRowType || activeRowKeys.value.length || !keys.length) return;
+      activeRowKeys.value = [...keys];
+    }, {
+      immediate: true
+    });
+    watch(tableReadonly, (readonly) => {
+      if (!readonly) return;
+      clearEditingState();
+    }, {
+      flush: "sync"
+    });
+    watch(expandedTreeNodes, adjustScrollWhenTreeExpanded, {
+      flush: "post"
+    });
+    watch([data, displayData, () => props.rowspanAndColspan], () => {
+      if (!props.rowspanAndColspan) return;
+      rowspanData.value = [...displayData.value];
+    }, {
+      deep: true
+    });
+    watch(data, (newData) => {
+      handleCellDragCancel();
+      pruneCellValidationErrors(newData);
+      pruneDisabledSelectedRows(newData);
+    });
+    watch(tableContentVisible, (visible, _old, onCleanup) => {
+      clearAffixFallbackTimer();
+      if (!visible) return;
+      let active = true;
+      onCleanup(() => {
+        active = false;
+        clearAffixFallbackTimer();
+      });
+      watchAnimatingTransformAncestor();
+      nextTick(() => {
+        if (!active) return;
+        affixFallbackTimer.value = setTimeout(() => {
+          clearAffixFallbackTimer();
+          refreshAffixedMetrics();
+          applyAffixedTransform();
+          probeBottomBlockHeight(false);
+          refreshTableAffixPosition();
+        }, 320);
+      });
+    });
+    watch(outsideScrollEl, (el, _old, onCleanup) => {
+      const scrollTarget = el ?? window;
+      probeBottomBlockHeight();
+      const onScroll = () => {
+        updateHeaderAffixedNeeded();
+        updateHorizontalScrollAffixed();
+        probeBottomBlockHeight(false);
+      };
+      scrollTarget.addEventListener("scroll", onScroll, {
+        passive: true
+      });
+      onCleanup(() => {
+        scrollTarget.removeEventListener("scroll", onScroll);
+        if (probeRafId) {
+          cancelAnimationFrame(probeRafId);
+          probeRafId = 0;
+        }
+        clearProbeDelayTimer();
+      });
+    }, {
+      immediate: true
+    });
+    onMounted(() => {
+      document.addEventListener("click", handleDocumentClick);
+      document.addEventListener("keydown", handleDocumentKeydown);
+      document.addEventListener("paste", handleDocumentPaste);
+    });
+    onActivated(async () => {
+      const position = {
+        ...scrollRecord
+      };
+      tableContentResume();
+      await nextTick();
+      if (!activated.value) return;
+      cancelScrollRestore();
+      scheduleScrollRestore(position);
+    });
+    onDeactivated(() => {
+      handleCellDragCancel();
+      cancelScrollRestore();
+      tableContentPause();
+    });
+    onBeforeUnmount(() => {
+      handleCellDragCancel();
+      cancelScrollRestore();
+      tableContentStop();
+      if (probeRafId) cancelAnimationFrame(probeRafId);
+      if (affixRefreshRafId) cancelAnimationFrame(affixRefreshRafId);
+      animatingAncestorCleanup?.();
+      document.removeEventListener("click", handleDocumentClick);
+      document.removeEventListener("keydown", handleDocumentKeydown);
+      document.removeEventListener("paste", handleDocumentPaste);
+      unmountOffscreenForm();
+    });
+    __expose(createExposeProxy({
+      data,
+      tableLoad,
+      firstLoad,
+      manualTriggerLoad,
+      loading,
+      current,
+      pageSize,
+      total,
+      changeCurrent,
+      changePageSize,
+      changePagination,
+      runAsync,
+      run,
+      cancel,
+      refresh,
+      refreshAsync,
+      setPollingInterval,
+      validateTableData,
+      validateRowData,
+      clearValidateData,
+      submitTableData,
+      submitRowData,
+      getData: (key) => {
+        if (props.tree) return tableRef.value?.getData(key);
+        return data.value.find((item) => get(item, props.rowKey || qdServiceTableProps.rowKey) === key);
+      },
+      scrollToElement: (params) => {
+        const opts = params ?? {};
+        const top = opts.top ?? tableHeaderEl.value?.clientHeight ?? 0;
+        tableRef.value?.scrollToElement({
+          ...opts,
+          top
+        });
+      }
+    }, tableRef));
+    return (_ctx, _cache) => {
+      return withDirectives((openBlock(), createBlock(resolveDynamicComponent(reProps.value.tableOptions.tree ? unref(EnhancedTable) : unref(Table)), mergeProps({
+        ref: "table",
+        class: ["qd-service-table", __props.headerBg ? "" : "t-table--header-bg-inherit", horizontalScrollAffixed.value ? "t-table--horizontal-bar-affixed" : "", reProps.value.tableOptions.horizontalScrollAffixedBottom && !horizontalScrollAffixed.value ? "qd-service-table--horizontal-bar-static" : "", reProps.value.size === "mini" ? "qd-service-table--mini" : "", __props.emptyImage === false ? "qd-service-table--hide-empty-image" : "", __props.disableHorizontalScroll ? "qd-service-table--disable-horizontal-scroll" : "", isCellDragSelecting.value ? "qd-service-table--cell-drag-selecting" : ""],
+        onMouseenter: handleTableMouseEnter,
+        "selected-row-keys": unref(selectedRowKeys),
+        "onUpdate:selectedRowKeys": _cache[0] || (_cache[0] = ($event) => isRef(selectedRowKeys) ? selectedRowKeys.value = $event : null),
+        "active-row-keys": unref(activeRowKeys),
+        "onUpdate:activeRowKeys": _cache[1] || (_cache[1] = ($event) => isRef(activeRowKeys) ? activeRowKeys.value = $event : null),
+        "column-controller-visible": unref(columnControllerVisible),
+        "onUpdate:columnControllerVisible": _cache[2] || (_cache[2] = ($event) => isRef(columnControllerVisible) ? columnControllerVisible.value = $event : null),
+        "display-columns": unref(displayColumns),
+        "onUpdate:displayColumns": _cache[3] || (_cache[3] = ($event) => isRef(displayColumns) ? displayColumns.value = $event : null),
+        "expanded-row-keys": unref(expandedRowKeys),
+        "onUpdate:expandedRowKeys": _cache[4] || (_cache[4] = ($event) => isRef(expandedRowKeys) ? expandedRowKeys.value = $event : null),
+        "filter-value": unref(filterValue),
+        "onUpdate:filterValue": _cache[5] || (_cache[5] = ($event) => isRef(filterValue) ? filterValue.value = $event : null),
+        sort: reSort.value,
+        "onUpdate:sort": _cache[6] || (_cache[6] = ($event) => reSort.value = $event),
+        "expanded-tree-nodes": unref(expandedTreeNodes),
+        "onUpdate:expandedTreeNodes": _cache[7] || (_cache[7] = ($event) => isRef(expandedTreeNodes) ? expandedTreeNodes.value = $event : null)
+      }, reProps.value.tableOptions, {
+        "on-sort-change": reOnSortChange,
+        columns: autoWidthColumns.value,
+        loading: tableLoad.value,
+        data: tdesignData.value,
+        pagination: rePagination.value
+      }), createSlots({
+        empty: withCtx(() => [createVNode(unref(Empty), mergeProps({
+          class: "qd-service-table__empty",
+          title: reProps.value.emptyText ?? unref(t)("emptyText")
+        }, typeof __props.emptyImage === "boolean" ? {} : {
+          image: __props.emptyImage
+        }), null, 16, ["title"])]),
+        _: 2
+      }, [renderList(_ctx.$slots, (_, name) => {
+        return {
+          name,
+          fn: withCtx((slotProps) => [renderSlot(_ctx.$slots, name, normalizeProps(guardReactiveProps(resolveForwardedSlotProps(String(name), slotProps))), void 0, true)])
+        };
+      })]), 1040, ["class", "selected-row-keys", "active-row-keys", "column-controller-visible", "display-columns", "expanded-row-keys", "filter-value", "sort", "expanded-tree-nodes", "columns", "loading", "data", "pagination"])), [[unref(vResize), onResize], [vHorizontalWheel]]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};