x-sccba 0.1.2 → 0.2.4

package/dist/vue2/index85.mjs

@@ -0,0 +1,781 @@
+import './components/XTable/style.css';var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { defineComponent, toRef, ref, watch, provide, onMounted, getCurrentInstance, computed, toRaw } from "@vue/composition-api";
+import { getUIComponent } from "./index2.mjs";
+import { h } from "./index127.mjs";
+import { useCompatSlots, useCompatListeners, renderSlot } from "./index129.mjs";
+import { warnOnce } from "./index145.mjs";
+import ClickEditCell from "./index198.mjs";
+import EditCell from "./index199.mjs";
+import OperatorColumn from "./index200.mjs";
+import RadioColumn from "./index201.mjs";
+import TableToolbar from "./index202.mjs";
+import { copyText, mergeColumnBind, expandFiltersFromList, resolveCellLabel } from "./index203.mjs";
+import { useCellEdit, XTABLE_EDIT_CTX_KEY } from "./index204.mjs";
+import { useColumns } from "./index205.mjs";
+import { useColumnSetting } from "./index206.mjs";
+import { useExpose } from "./index207.mjs";
+import { useFirstColumn } from "./index208.mjs";
+import { usePagination } from "./index209.mjs";
+import { useRowDrag } from "./index210.mjs";
+import { useVirtualScroll } from "./index211.mjs";
+import { useXTablePermission } from "./index212.mjs";
+/* empty css          */
+import { useMessage } from "./index124.mjs";
+import { useForwardProps } from "./index121.mjs";
+import { useOmitForwardProps } from "./index126.mjs";
+const XTABLE_ALIGN_KEY = Symbol("xTableAlign");
+const tableProps = {
+  // ===== 配置驱动入口 =====
+  columns: {
+    type: Array,
+    default: void 0
+  },
+  firstColumn: {
+    type: [Object, Array],
+    default: void 0
+  },
+  // ===== 虚拟滚动 =====
+  useVirtual: { type: Boolean, default: false },
+  virtualShowSize: { type: Number, default: 30 },
+  virtualItemHeight: { type: Number, default: 50 },
+  // ===== 内置分页 =====
+  showPagination: { type: Boolean, default: false },
+  paginationConfig: {
+    type: Object,
+    default: void 0
+  },
+  paginationCumulative: { type: Boolean, default: false },
+  // ===== 行拖拽 =====
+  rowDrag: { type: Boolean, default: false },
+  rowDragIcon: { type: Boolean, default: false },
+  // ===== 列设置（持久化）=====
+  columnSetting: { type: Boolean, default: false },
+  cacheKey: { type: String, default: "" },
+  // ===== 工具栏 / 密度 =====
+  title: { type: String, default: "" },
+  densitySetting: { type: Boolean, default: false },
+  defaultSize: { type: String, default: "" },
+  // ===== Loading =====
+  loading: { type: Boolean, default: false },
+  loadingText: { type: String, default: "" },
+  // ===== 单元格复制 =====
+  cellCopy: { type: Boolean, default: false },
+  // ===== 点击行选中 / 单选默认 =====
+  rowClickRadio: { type: Boolean, default: false },
+  rowClickCheckbox: { type: Boolean, default: false },
+  defaultRadioCol: { type: Number, default: void 0 },
+  // ===== 底部保存区 =====
+  showFooterBtn: { type: Boolean, default: false },
+  footerBtnAlign: { type: String, default: "right" },
+  // ===== 操作列与权限 =====
+  operatorConfig: {
+    type: Object,
+    default: void 0
+  },
+  btnPermissions: { type: Array, default: void 0 },
+  // ===== 数据源映射 =====
+  listTypeInfo: {
+    type: Object,
+    default: void 0
+  }
+};
+const tableEmits = [
+  "page-change",
+  "size-change",
+  "current-page-change",
+  "radio-change",
+  "row-drag-end",
+  "save",
+  "handle-event",
+  "validate-error",
+  "cell-edit-confirm",
+  "cell-edit-cancel"
+];
+const SELF_PROP_KEYS = [
+  "columns",
+  "firstColumn",
+  "useVirtual",
+  "virtualShowSize",
+  "virtualItemHeight",
+  "showPagination",
+  "paginationConfig",
+  "paginationCumulative",
+  "rowDrag",
+  "rowDragIcon",
+  "columnSetting",
+  "cacheKey",
+  "title",
+  "densitySetting",
+  "defaultSize",
+  "loading",
+  "loadingText",
+  "cellCopy",
+  "rowClickRadio",
+  "rowClickCheckbox",
+  "defaultRadioCol",
+  "showFooterBtn",
+  "footerBtnAlign",
+  "operatorConfig",
+  "btnPermissions",
+  "listTypeInfo"
+];
+const XTable = defineComponent({
+  name: "XTable",
+  inheritAttrs: false,
+  props: tableProps,
+  emits: [...tableEmits],
+  setup(props, { attrs, emit, expose }) {
+    const ElTable = getUIComponent("Table");
+    const ElTableColumn = getUIComponent("TableColumn");
+    const ElPagination = getUIComponent("Pagination");
+    const perm = useXTablePermission(toRef(props, "btnPermissions"));
+    const colSetting = useColumnSetting(
+      toRef(props, "columns"),
+      toRef(props, "cacheKey"),
+      toRef(props, "columnSetting")
+    );
+    const { renderColumns, isConfigMode } = useColumns(
+      toRef(props, "columns"),
+      colSetting.cacheOrder,
+      colSetting.hiddenProps
+    );
+    const { merged, currentPage, pageSize, onCurrentChange, onSizeChange } = usePagination(toRef(props, "paginationConfig"), emit);
+    const {
+      items: firstColumnItems,
+      indexMethod,
+      reserveSelection
+    } = useFirstColumn(
+      toRef(props, "firstColumn"),
+      toRef(props, "paginationCumulative"),
+      currentPage,
+      pageSize
+    );
+    const dataMutableRef = ref([]);
+    watch(
+      () => attrs.data || [],
+      (v) => {
+        dataMutableRef.value = v;
+      },
+      { immediate: true }
+    );
+    const cellEdit = useCellEdit(
+      emit,
+      toRef(props, "columns"),
+      dataMutableRef,
+      toRef(props, "listTypeInfo")
+    );
+    provide(XTABLE_EDIT_CTX_KEY, cellEdit.ctx);
+    const tableAlignRef = ref("");
+    const tableHeaderAlignRef = ref("");
+    provide(XTABLE_ALIGN_KEY, {
+      align: tableAlignRef,
+      headerAlign: tableHeaderAlignRef
+    });
+    const radioSelectedRow = ref(null);
+    const isSameRow = (a, b) => {
+      if (a === b) return true;
+      return toRaw(a) === toRaw(b);
+    };
+    const handleRowClick = (row) => {
+      if (props.rowClickRadio) {
+        radioSelectedRow.value = isSameRow(radioSelectedRow.value, row) ? null : row;
+        emit("radio-change", radioSelectedRow.value);
+      }
+    };
+    const { message: msgService } = useMessage({ duration: 1500 });
+    const handleCellDblClick = (row, column, _cell, _evt) => __async(null, null, function* () {
+      if (!props.cellCopy) {
+        return;
+      }
+      const propName = column == null ? void 0 : column.property;
+      if (!propName) {
+        return;
+      }
+      const value = row == null ? void 0 : row[propName];
+      const text = value == null ? "" : String(value);
+      const ok = yield copyText(text);
+      if (ok) {
+        msgService.success("已复制");
+      }
+    });
+    const _a = useExpose({
+      save: cellEdit.save,
+      saveMethod: cellEdit.saveMethod,
+      resetFields: cellEdit.resetFields,
+      clearValidate: cellEdit.clearValidate,
+      clearRadioHandle: () => {
+        radioSelectedRow.value = null;
+      },
+      defaultRadioSelect: (idx) => {
+        const arr = attrs.data || [];
+        if (idx >= 0 && idx < arr.length) {
+          radioSelectedRow.value = arr[idx];
+          emit("radio-change", arr[idx]);
+        }
+      }
+    }), { tableRef } = _a, exposed = __objRest(_a, ["tableRef"]);
+    const localSize = ref(
+      props.defaultSize || "medium"
+    );
+    watch(
+      () => props.defaultSize,
+      (v) => {
+        if (v) {
+          localSize.value = v;
+        }
+      }
+    );
+    const rowDrag = useRowDrag(
+      toRef(props, "rowDrag"),
+      tableRef,
+      dataMutableRef,
+      emit,
+      toRef(props, "rowDragIcon")
+    );
+    onMounted(() => {
+      rowDrag.ensureLoaded();
+    });
+    onMounted(() => {
+      if (props.defaultRadioCol != null) {
+        const arr = attrs.data || [];
+        const idx = props.defaultRadioCol - 1;
+        if (idx >= 0 && idx < arr.length) {
+          radioSelectedRow.value = arr[idx];
+          emit("radio-change", arr[idx]);
+        }
+      }
+    });
+    const {
+      shouldVirtualize,
+      RecycleScroller,
+      itemSize,
+      bufferSize,
+      ensureLoaded,
+      checkCompat
+    } = useVirtualScroll(
+      toRef(props, "useVirtual"),
+      toRef(props, "virtualShowSize"),
+      toRef(props, "virtualItemHeight"),
+      () => attrs
+    );
+    onMounted(() => {
+      ensureLoaded();
+      checkCompat();
+    });
+    watch(
+      reserveSelection,
+      (need) => {
+        if (need && !attrs.rowKey && !attrs["row-key"]) {
+          warnOnce(
+            "XTable:reserveSelection:rowKey",
+            "[XTable] firstColumn.isPaging=true 需要传 row-key（attrs.rowKey），否则翻页保持选中无法生效"
+          );
+        }
+      },
+      { immediate: true }
+    );
+    expose == null ? void 0 : expose(exposed);
+    {
+      const inst = getCurrentInstance();
+      onMounted(() => {
+        const vm = inst == null ? void 0 : inst.proxy;
+        if (vm) Object.assign(vm, exposed);
+      });
+    }
+    const forwarded = useForwardProps(props);
+    const elForwarded = useOmitForwardProps(forwarded, SELF_PROP_KEYS);
+    const isPureForward = computed(
+      () => !isConfigMode.value && !props.title && !props.columnSetting && !props.densitySetting && !props.showPagination && !props.showFooterBtn && !props.loading && !props.cellCopy
+    );
+    return () => {
+      const inst = getCurrentInstance();
+      const slots = useCompatSlots(inst);
+      const listenerProps = useCompatListeners(inst);
+      if (isConfigMode.value && slots.default) {
+        warnOnce(
+          "XTable:columns+slot",
+          "[XTable] columns prop 与 default slot 同时存在时，columns 优先，slot 内容被忽略"
+        );
+      }
+      const _a2 = attrs, {
+        align: attrAlign,
+        headerAlign: attrHeaderAlign
+      } = _a2, restAttrs = __objRest(_a2, [
+        "align",
+        "headerAlign"
+      ]);
+      tableAlignRef.value = attrAlign || "";
+      tableHeaderAlignRef.value = attrHeaderAlign || "";
+      const elTableProps = __spreadProps(__spreadValues(__spreadValues(__spreadValues({}, elForwarded.value), restAttrs), listenerProps), {
+        ref: tableRef
+      });
+      const isSizeDefault = localSize.value === "medium" || localSize.value === "";
+      if (localSize.value && !isSizeDefault) {
+        elTableProps.size = localSize.value;
+      }
+      if (props.rowClickRadio || props.rowClickCheckbox) {
+        const existingRowClassName = elTableProps.rowClassName || restAttrs.rowClassName;
+        elTableProps.rowClassName = ({ row, rowIndex }) => {
+          const base = typeof existingRowClassName === "function" ? existingRowClassName({ row, rowIndex }) : existingRowClassName || "";
+          return [base, "x-table__row--clickable"].filter(Boolean).join(" ");
+        };
+        const userRowClick = listenerProps.onRowClick;
+        elTableProps.onRowClick = (row, col, evt) => {
+          var _a3;
+          handleRowClick(row);
+          if (props.rowClickCheckbox && ((_a3 = tableRef.value) == null ? void 0 : _a3.toggleRowSelection)) {
+            tableRef.value.toggleRowSelection(row);
+          }
+          userRowClick == null ? void 0 : userRowClick(row, col, evt);
+        };
+      }
+      if (props.cellCopy) {
+        const existingCellClassName = elTableProps.cellClassName || restAttrs.cellClassName;
+        elTableProps.cellClassName = ({
+          row,
+          column,
+          rowIndex,
+          columnIndex
+        }) => {
+          const base = typeof existingCellClassName === "function" ? existingCellClassName({ row, column, rowIndex, columnIndex }) : existingCellClassName || "";
+          return [base, "x-table__cell--copyable"].filter(Boolean).join(" ");
+        };
+        const userCellDblClick = listenerProps.onCellDblclick;
+        elTableProps.onCellDblclick = (row, column, cell, evt) => {
+          handleCellDblClick(row, column);
+          userCellDblClick == null ? void 0 : userCellDblClick(row, column, cell, evt);
+        };
+      }
+      const renderColumn = (col) => {
+        var _a3, _b, _c, _d, _e, _f, _g;
+        const colProps = mergeColumnBind(col);
+        const slotNodes = {};
+        if (!colProps.align && attrAlign) {
+          colProps.align = attrAlign;
+        }
+        if (!colProps.headerAlign && attrHeaderAlign) {
+          colProps.headerAlign = attrHeaderAlign;
+        }
+        if (Array.isArray(col.filters)) {
+          const expanded = expandFiltersFromList(
+            col.filters,
+            props.listTypeInfo
+          );
+          if (expanded) {
+            colProps.filters = expanded;
+          }
+        }
+        if (col.renderHeader) {
+          slotNodes.header = (scope) => col.renderHeader(scope);
+        }
+        const useOperator = Array.isArray(col.operator) && col.operator.length > 0;
+        const useEdit = !useOperator && col.canEdit != null;
+        const useClickEdit = !useOperator && col.isClickEdit === true && !useEdit;
+        if (useOperator) {
+          slotNodes.default = (scope) => {
+            if (!scope || scope.row == null) return null;
+            return h(OperatorColumn, {
+              operators: col.operator,
+              config: props.operatorConfig,
+              hasPermission: perm.hasPermission,
+              row: scope.row,
+              rowIndex: scope.$index
+            });
+          };
+          if (((_a3 = props.operatorConfig) == null ? void 0 : _a3.fixed) != null) {
+            colProps.fixed = props.operatorConfig.fixed;
+          }
+          if (((_b = props.operatorConfig) == null ? void 0 : _b.width) != null) {
+            colProps.width = props.operatorConfig.width;
+          }
+          if (((_c = props.operatorConfig) == null ? void 0 : _c.minWidth) != null) {
+            colProps.minWidth = props.operatorConfig.minWidth;
+          }
+          if (((_d = props.operatorConfig) == null ? void 0 : _d.label) != null) {
+            colProps.label = props.operatorConfig.label;
+          }
+          if (((_e = props.operatorConfig) == null ? void 0 : _e.align) != null) {
+            colProps.align = props.operatorConfig.align;
+          }
+        } else if (useEdit) {
+          slotNodes.default = (scope) => {
+            if (!scope || scope.row == null) return null;
+            if (cellEdit.ctx.isAlwaysEdit(col, scope.row)) {
+              return h(EditCell, {
+                column: col,
+                row: scope.row,
+                rowIndex: scope.$index
+              });
+            }
+            return col.formatter ? col.formatter(scope.row, col, scope.row[col.prop], scope.$index) : scope.row[col.prop];
+          };
+        } else if (useClickEdit) {
+          slotNodes.default = (scope) => {
+            if (!scope || scope.row == null) return null;
+            return h(ClickEditCell, {
+              column: col,
+              row: scope.row,
+              rowIndex: scope.$index
+            });
+          };
+        } else if (Array.isArray(col.children) && col.children.length > 0) {
+          slotNodes.default = () => col.children.map((child) => renderColumn(child));
+        } else if (col.render) {
+          slotNodes.default = (scope) => {
+            if (!scope || scope.row == null) return null;
+            return col.render(scope);
+          };
+        } else if (col.slotName && slots[col.slotName]) {
+          slotNodes.default = (scope) => {
+            if (!scope || scope.row == null) return null;
+            return renderSlot(slots, col.slotName, scope);
+          };
+        }
+        if (!slotNodes.default && ((_g = (_f = col.filters) == null ? void 0 : _f[0]) == null ? void 0 : _g.list)) {
+          const listKey = col.filters[0].list;
+          slotNodes.default = (scope) => {
+            if (!scope || scope.row == null) return null;
+            const v = scope.row[col.prop];
+            return resolveCellLabel(v, listKey, props.listTypeInfo);
+          };
+        }
+        return h(ElTableColumn, colProps, slotNodes);
+      };
+      const renderConfigColumns = () => {
+        const nodes = [];
+        if (props.rowDrag && props.rowDragIcon) {
+          nodes.push(
+            h(
+              ElTableColumn,
+              __spreadValues({
+                width: 50,
+                align: "center"
+              }, {}),
+              {
+                header: () => "",
+                default: () => h("span", { class: "x-table__drag-handle" }, [
+                  // 拖拽手柄 SVG 图标（6 个圆点）
+                  h(
+                    "svg",
+                    {
+                      viewBox: "0 0 20 20",
+                      width: "16",
+                      height: "16",
+                      fill: "currentColor",
+                      style: "vertical-align: middle"
+                    },
+                    [
+                      h("circle", { cx: "7", cy: "4", r: "1.5" }),
+                      h("circle", { cx: "13", cy: "4", r: "1.5" }),
+                      h("circle", { cx: "7", cy: "10", r: "1.5" }),
+                      h("circle", { cx: "13", cy: "10", r: "1.5" }),
+                      h("circle", { cx: "7", cy: "16", r: "1.5" }),
+                      h("circle", { cx: "13", cy: "16", r: "1.5" })
+                    ]
+                  )
+                ])
+              }
+            )
+          );
+        }
+        firstColumnItems.value.forEach((item) => {
+          if (item.type === "radio") {
+            nodes.push(
+              h(RadioColumn, {
+                fixed: item.fixed,
+                isRadioDisabled: item.isRadioDisabled,
+                modelValue: radioSelectedRow.value,
+                "onUpdate:modelValue": (row) => {
+                  radioSelectedRow.value = row;
+                  emit("radio-change", row);
+                }
+              })
+            );
+            return;
+          }
+          const colProps = { type: item.type };
+          if (item.type === "index") {
+            colProps.label = item.label || "序号";
+            colProps.width = 60;
+            colProps.index = indexMethod;
+          } else if (item.type === "selection") {
+            colProps.width = 50;
+          } else if (item.type === "expand") {
+            colProps.width = 50;
+          }
+          if (item.fixed != null) colProps.fixed = item.fixed;
+          if (item.selectable != null) colProps.selectable = item.selectable;
+          if (reserveSelection.value && item.type === "selection") {
+            colProps.reserveSelection = true;
+          }
+          if (item.type === "expand" && slots.expand) {
+            nodes.push(
+              h(ElTableColumn, colProps, {
+                default: (scope) => renderSlot(slots, "expand", scope)
+              })
+            );
+          } else {
+            nodes.push(h(ElTableColumn, colProps));
+          }
+        });
+        renderColumns.value.forEach((col) => {
+          nodes.push(renderColumn(col));
+        });
+        return nodes;
+      };
+      const tableSlotNodes = {};
+      if (isConfigMode.value) {
+        tableSlotNodes.default = () => renderConfigColumns();
+        ["empty", "append"].forEach((name) => {
+          if (slots[name]) {
+            tableSlotNodes[name] = (scope) => renderSlot(slots, name, scope);
+          }
+        });
+      } else {
+        Object.keys(slots).forEach((name) => {
+          tableSlotNodes[name] = (scope) => renderSlot(slots, name, scope);
+        });
+      }
+      const innerTable = h(ElTable, elTableProps, tableSlotNodes);
+      const hasEditableCol = (cols) => cols.some(
+        (c) => c.canEdit != null || c.isClickEdit === true || Array.isArray(c.children) && hasEditableCol(c.children)
+      );
+      const hasEditable = hasEditableCol(props.columns || []);
+      const tableNode = hasEditable ? h(
+        getUIComponent("Form"),
+        {
+          ref: cellEdit.formRef,
+          // 包装为对象：ElForm.model 在 Vue2 中要求 Object 类型，
+          // 直接传数组会触发 "Expected Object, got Array" 警告。
+          // EditCell 的 propPath 对应调整为 `rows.${rowIndex}.${prop}`。
+          model: { rows: dataMutableRef.value },
+          class: "x-table__edit-form"
+        },
+        { default: () => innerTable }
+      ) : innerTable;
+      if (isPureForward.value) {
+        return tableNode;
+      }
+      const renderToolbar = () => h(
+        TableToolbar,
+        {
+          title: props.title,
+          columnSetting: props.columnSetting,
+          densitySetting: props.densitySetting,
+          columns: props.columns,
+          hiddenProps: colSetting.hiddenProps.value,
+          cacheOrder: colSetting.cacheOrder.value,
+          size: localSize.value,
+          "onToggle-column": (p, v) => colSetting.toggleColumn(p, v),
+          "onReorder-columns": (o) => colSetting.reorderColumns(o),
+          "onReset-columns": () => colSetting.reset(),
+          "onUpdate:size": (v) => {
+            localSize.value = v;
+          }
+        },
+        {
+          titleTip: slots.titleTip ? () => renderSlot(slots, "titleTip") : void 0,
+          toolbar: slots.toolbar ? () => renderSlot(slots, "toolbar") : void 0
+        }
+      );
+      const renderFooter = () => {
+        const customFooter = slots.footer;
+        const showBtn = props.showFooterBtn;
+        if (!customFooter && !showBtn) return null;
+        const style = {
+          textAlign: props.footerBtnAlign || "right"
+        };
+        if (customFooter) {
+          return h(
+            "div",
+            { class: "x-table__footer", style },
+            renderSlot(slots, "footer")
+          );
+        }
+        const ElButton = getUIComponent("Button");
+        return h("div", { class: "x-table__footer", style }, [
+          h(
+            ElButton,
+            {
+              type: "primary",
+              onClick: () => {
+                cellEdit.save().catch(() => {
+                });
+              }
+            },
+            () => "保存"
+          )
+        ]);
+      };
+      const renderPagination = () => {
+        if (!props.showPagination) return null;
+        if (slots.pagination) return renderSlot(slots, "pagination");
+        const m = merged.value;
+        return h(ElPagination, {
+          class: "x-table__pagination",
+          currentPage: currentPage.value,
+          pageSize: pageSize.value,
+          pageSizes: m.pageSizes,
+          total: m.total,
+          layout: m.layout,
+          background: m.background,
+          "onUpdate:currentPage": (p) => {
+            currentPage.value = p;
+          },
+          "onUpdate:pageSize": (s) => {
+            pageSize.value = s;
+          },
+          onCurrentChange,
+          onSizeChange
+        });
+      };
+      if (shouldVirtualize.value && isConfigMode.value && Array.isArray(attrs.data)) {
+        const Scroller = RecycleScroller.value;
+        const rows = attrs.data;
+        return h(
+          "div",
+          {
+            class: [
+              "x-table x-table--virtual",
+              props.rowDrag && "x-table--row-drag",
+              props.rowDrag && props.rowDragIcon && "x-table--row-drag-icon"
+            ].filter(Boolean).join(" ")
+          },
+          [
+            renderToolbar(),
+            // 表头壳 —— 复用 ElTable 渲染表头结构（data 设为 []，仅展示表头）
+            h(
+              ElTable,
+              __spreadProps(__spreadValues({}, elTableProps), { data: [] }),
+              {
+                default: () => isConfigMode.value ? renderConfigColumns() : []
+              }
+            ),
+            // RecycleScroller 数据行
+            h(
+              Scroller,
+              {
+                class: "x-table__virtual-wrapper",
+                items: rows,
+                itemSize: itemSize.value,
+                keyField: attrs.rowKey || "id",
+                buffer: bufferSize.value * itemSize.value,
+                style: { height: `${bufferSize.value * itemSize.value}px` }
+              },
+              {
+                default: ({ item, index }) => h(
+                  "div",
+                  {
+                    class: "x-table__virtual-row",
+                    style: { height: `${itemSize.value}px` }
+                  },
+                  renderColumns.value.map(
+                    (col) => h(
+                      "div",
+                      { class: "x-table__virtual-cell", key: col.prop },
+                      col.render ? col.render({
+                        row: item,
+                        $index: index,
+                        column: col
+                      }) : col.slotName && slots[col.slotName] ? renderSlot(slots, col.slotName, {
+                        row: item,
+                        column: col,
+                        $index: index
+                      }) : col.formatter ? col.formatter(item, col, item[col.prop], index) : item[col.prop]
+                    )
+                  )
+                )
+              }
+            ),
+            renderFooter(),
+            renderPagination()
+          ].filter(Boolean)
+        );
+      }
+      const wrapperClass = [
+        "x-table",
+        props.rowDrag && "x-table--row-drag",
+        props.rowDrag && props.rowDragIcon && "x-table--row-drag-icon"
+      ].filter(Boolean).join(" ");
+      return h(
+        "div",
+        { class: wrapperClass },
+        [
+          renderToolbar(),
+          tableNode,
+          renderFooter(),
+          renderPagination(),
+          props.loading ? h(
+            "div",
+            { class: "x-table__loading-mask" },
+            [
+              h("div", { class: "x-table__loading-spinner" }),
+              props.loadingText ? h(
+                "div",
+                { class: "x-table__loading-text" },
+                props.loadingText
+              ) : null
+            ].filter(Boolean)
+          ) : null
+        ].filter(Boolean)
+      );
+    };
+  }
+});
+export {
+  XTABLE_ALIGN_KEY,
+  XTable as default,
+  tableEmits,
+  tableProps
+};
+//# sourceMappingURL=index85.mjs.map