pro-design-vue 0.0.1-beta.1

package/lib/components/table/src/components/InteralTable.vue2.js

@@ -0,0 +1,895 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var antDesignVue = require('ant-design-vue');
+var config = require('./config.js');
+var _interface = require('./interface.js');
+var constant = require('./Drag/constant.js');
+var util = require('../utils/util.js');
+var useEdit = require('../hooks/useEdit.js');
+var PopupContext = require('./context/PopupContext.js');
+var useHScrollSync = require('../hooks/useHScrollSync.js');
+var useVScrollSync = require('../hooks/useVScrollSync.js');
+var TableContext = require('./context/TableContext.js');
+var useRangeStore = require('../hooks/useRangeStore.js');
+var useKVMap = require('../hooks/useKVMap.js');
+var useLicense = require('../hooks/useLicense.js');
+var devWarning = require('../utils/devWarning.js');
+var eagerComputed = require('../utils/eagerComputed.js');
+var getScrollBarSize = require('../utils/getScrollBarSize.js');
+var useColumns = require('../hooks/useColumns.js');
+var useSorter = require('../hooks/useSorter.js');
+var useFilter = require('../hooks/useFilter.js');
+var useCal = require('../hooks/useCal.js');
+var useFlattenRecords = require('../hooks/useFlattenRecords.js');
+var useRowSelection = require('../hooks/useRowSelection.js');
+var usePagination = require('../hooks/usePagination.js');
+var raf = require('../utils/raf.js');
+var easeoutScroll = require('../utils/easeoutScroll.js');
+var useData = require('../hooks/useData.js');
+var supportSticky = require('../utils/supportSticky.js');
+var classNames = require('../utils/classNames.js');
+var useCellProps = require('../hooks/useCellProps.js');
+var KeyCode = require('../utils/KeyCode.js');
+var TableSlotsContext = require('./context/TableSlotsContext.js');
+var MeasureWidth = require('./MeasureWidth.vue.js');
+var PopupContainer = require('./PopupContainer.vue.js');
+var Header$1 = require('./AutoHeightHeader/Header.vue.js');
+var Header = require('./Header/Header.vue.js');
+var Body = require('./Body/Body.vue.js');
+var resize = require('../../../../directives/resize.js');
+var index = require('../../../../hooks/use-prefix-cls/index.js');
+var lodashUnified = require('lodash-unified');
+var omit = require('../../../../utils/omit.js');
+
+const EMPTY_LIST = [];
+var _sfc_main = vue.defineComponent({
+  name: "ProTable",
+  inheritAttrs: false,
+  directives: { resize: resize.resize },
+  components: {
+    TableSlotsContextProvider: TableSlotsContext.default,
+    Spin: antDesignVue.Spin,
+    MeasureWidth: MeasureWidth.default,
+    Pagination: antDesignVue.Pagination,
+    PopupContainer: PopupContainer.default,
+    AutoHeightHeader: Header$1.default,
+    ProHeader: Header.default,
+    ProBody: Body.default
+  },
+  props: _interface.baseTableProps(),
+  emits: [
+    "update:pagination",
+    "scroll",
+    "update:selectedRowKeys",
+    "update:expandedRowKeys",
+    "update:columns",
+    "update:sorter",
+    "update:filters",
+    "expand",
+    "expandedRowsChange",
+    "resizeColumn",
+    "update:dataSource",
+    "cellKeydown"
+  ],
+  slots: {},
+  setup(props, { expose, emit, slots }) {
+    const rowKey = vue.computed(() => {
+      var _a;
+      return (_a = props.rowKey) != null ? _a : "id";
+    });
+    const popupContainer = vue.shallowRef(null);
+    const customUiCls = index.usePrefixCls("custom-ui");
+    const { editCellKeys, openEditor, closeEditor } = useEdit.useEditProvider();
+    PopupContext.useProvidePopup();
+    const getPopupContainer = vue.computed(() => props.getPopupContainer);
+    const { status, watermarkMsg } = useLicense.default();
+    const dragRowsHandle = /* @__PURE__ */ new Map();
+    const draggingRowKey = vue.ref(null);
+    const insertToRowKey = vue.ref(null);
+    const dragColumnsHandle = /* @__PURE__ */ new Map();
+    const draggingColumnKey = vue.ref("");
+    const latestRangeStartCell = vue.shallowRef(null);
+    const mergedSummaryFixed = vue.computed(
+      () => props.summaryFixed === true || props.summaryFixed === "" ? "bottom" : props.summaryFixed
+    );
+    const realHeaderHeight = vue.ref(0);
+    vue.watchEffect(() => {
+      devWarning.default(
+        !(typeof rowKey.value == "function" && rowKey.value.length > 1),
+        "table",
+        "`index` parameter of `rowKey` function is deprecated. There is no guarantee that it will work as expected."
+      );
+    });
+    const localeData = vue.inject("localeData", {
+      antLocale: {
+        Table: {
+          triggerDesc: "Click to sort descending",
+          triggerAsc: "Click to sort ascending",
+          cancelSort: "Click to cancel sorting"
+        }
+      }
+    });
+    const locale = vue.computed(() => {
+      const antLocale = (localeData == null ? void 0 : localeData.antLocale) || {};
+      return {
+        ...antLocale.locale === "zh-cn" ? {
+          triggerDesc: "\u70B9\u51FB\u964D\u5E8F",
+          triggerAsc: "\u70B9\u51FB\u5347\u5E8F",
+          cancelSort: "\u53D6\u6D88\u6392\u5E8F"
+        } : {},
+        ...antLocale.Table || {},
+        ...props.locale || {}
+      };
+    });
+    const scrollTop = vue.ref(0);
+    const scrollLeft = vue.ref(0);
+    const rootRef = vue.ref();
+    const bodyWidth = vue.ref(0);
+    const bodyHeight = vue.ref(0);
+    const measureWidthRef = vue.shallowRef();
+    const mergedScrollX = eagerComputed.default(() => {
+      var _a, _b;
+      return (_b = props.scrollX) != null ? _b : (_a = props.scroll) == null ? void 0 : _a.x;
+    });
+    const mergedScrollY = eagerComputed.default(() => {
+      var _a, _b, _c;
+      return (_c = (_b = (_a = props.scroll) == null ? void 0 : _a.y) != null ? _b : props.height) != null ? _c : props.maxHeight;
+    });
+    const bodyScrollWidth = vue.ref(typeof mergedScrollX.value == "number" ? mergedScrollX.value : 0);
+    vue.watch(mergedScrollX, () => {
+      bodyScrollWidth.value = typeof mergedScrollX.value == "number" ? mergedScrollX.value : 0;
+    });
+    const virtual = eagerComputed.default(() => !(props.virtual === false || !mergedScrollY.value));
+    const xVirtual = eagerComputed.default(
+      () => props.xVirtual || props.virtual !== false && props.xVirtual !== false
+    );
+    const getRowKey = vue.computed(
+      () => typeof rowKey.value == "function" ? rowKey.value : (record) => {
+        return record == null ? void 0 : record[rowKey.value];
+      }
+    );
+    const rawData = vue.shallowRef([]);
+    const rawColumns = vue.shallowRef([]);
+    let dataSourceWatchStopHandle;
+    let columnsWatchStopHandle;
+    vue.watch(
+      () => props.deepWatchDataSource,
+      () => {
+        dataSourceWatchStopHandle && dataSourceWatchStopHandle();
+        dataSourceWatchStopHandle = vue.watch(
+          () => props.dataSource,
+          () => {
+            rawData.value = vue.toRaw(props.dataSource) || EMPTY_LIST;
+            vue.triggerRef(rawData);
+          },
+          { immediate: true, deep: !!props.deepWatchDataSource }
+        );
+      },
+      { immediate: true, deep: true }
+    );
+    vue.watch(
+      () => props.deepWatchColumns,
+      () => {
+        columnsWatchStopHandle && columnsWatchStopHandle();
+        columnsWatchStopHandle = vue.watch(
+          () => props.columns,
+          () => {
+            rawColumns.value = vue.toRaw(props.columns) || EMPTY_LIST;
+            vue.triggerRef(rawColumns);
+          },
+          { immediate: true, deep: true }
+        );
+      },
+      { immediate: true, deep: !!props.deepWatchColumns }
+    );
+    const childrenColumnName = vue.computed(() => props.childrenColumnName || "children");
+    const { getRecordByKey, getIndexsByKey, getKeyByIndexs, allDataRowKeys, allDataRootRowKeys } = useKVMap.default(rawData, childrenColumnName, getRowKey);
+    const defaultExpandedRowKeys = vue.shallowRef([]);
+    vue.watchEffect(() => {
+      props.defaultExpandedRowKeys && (defaultExpandedRowKeys.value = props.defaultExpandedRowKeys);
+      props.defaultExpandAllRows && (defaultExpandedRowKeys.value = allDataRowKeys.value);
+    });
+    const mergedRowSelection = vue.computed(() => {
+      const rowSelection = props.rowSelection || {};
+      const { checkStrictly = true } = rowSelection;
+      return { ...rowSelection, checkStrictly };
+    });
+    const expandedRowKeys = vue.computed(
+      () => new Set(props.expandedRowKeys || defaultExpandedRowKeys.value || [])
+    );
+    const spinProps = vue.computed(() => {
+      if (typeof props.loading === "boolean") {
+        return { spinning: props.loading };
+      } else if (typeof props.loading === "object") {
+        return { spinning: true, ...props.loading };
+      } else {
+        return { spinning: false };
+      }
+    });
+    vue.onActivated(() => {
+      scrollTo({ left: 0, top: 0 });
+    });
+    let triggerOnChange = () => {
+    };
+    const scrollBarSize = vue.shallowRef(getScrollBarSize.default());
+    const baseHeight = vue.computed(
+      () => props.size === "small" ? 39 : props.size === "middle" ? 47 : 55
+    );
+    const expandedRowRender = vue.computed(() => props.expandedRowRender);
+    const expandType = eagerComputed.default(
+      () => rawData.value.some((column) => column == null ? void 0 : column[childrenColumnName.value]) ? "nest" : expandedRowRender.value ? "row" : null
+    );
+    const expandable = eagerComputed.default(() => !!props.expandedRowRender);
+    const columns = useColumns.default({
+      props,
+      rawColumns,
+      bodyScrollWidth,
+      baseHeight,
+      measureWidthRef,
+      expandable,
+      expandType,
+      scrollLeft,
+      bodyWidth,
+      xVirtual,
+      draggingColumnKey,
+      latestRangeStartCell
+    });
+    const { sortedData, sorterStates, sorter, changeSorter } = useSorter.default(
+      props,
+      rawData,
+      columns.allColumns,
+      (sorter2, sorterStates2) => {
+        scrollTop.value > bodyHeight.value && updateAnimate();
+        triggerOnChange({ sorter: sorter2, sorterStates: sorterStates2 }, "sort", false);
+      }
+    );
+    const { filterData, filterStates, filters, changeFilter } = useFilter.default(
+      props,
+      sortedData,
+      columns.allColumns,
+      (filters2, filterStates2) => {
+        triggerOnChange({ filters: filters2, filterStates: filterStates2 }, "filter", true);
+      }
+    );
+    const total = eagerComputed.default(() => filterData.value.length);
+    const paginationParam = vue.computed(() => {
+      if (props.pagination === false) {
+        return {};
+      }
+      return usePagination.getPaginationParam(props.pagination, mergedPagination.value);
+    });
+    const triggeronPaginationChange = (current, pageSize) => {
+      const pagination = { ...paginationParam.value, current, pageSize };
+      props["onUpdate:pagination"] && emit(
+        "update:pagination",
+        vue.isReactive(props.pagination) ? Object.assign(props.pagination || {}, pagination) : pagination
+      );
+    };
+    const {
+      mergedPagination,
+      pos,
+      refreshPagination,
+      onChange: onPaginationChange,
+      onShowSizeChange,
+      pageData
+    } = usePagination.default(total, props, filterData, (current, pageSize) => {
+      const pagination = { ...paginationParam.value, current, pageSize };
+      triggeronPaginationChange(current, pageSize);
+      updateAnimate();
+      triggerOnChange({ pagination }, "paginate");
+    });
+    const {
+      flattenData,
+      keyEntities,
+      pageDataRowKeys,
+      pageDataEnableRowKeys,
+      checkboxPropsMap,
+      getRowFlattenIndexByKey,
+      isMyChildren,
+      getRowByFlattenIndex
+    } = useFlattenRecords.default(
+      pageData,
+      childrenColumnName,
+      expandedRowKeys,
+      getRowKey,
+      expandType,
+      mergedRowSelection
+    );
+    const cal = useCal.default(props, flattenData, bodyHeight, scrollTop, virtual, keyEntities);
+    const { rowPosition, viewportHeight, startIndex, endIndex } = cal;
+    const { leftWidth, rightWidth, centerWidth, bodyMaxWidth } = columns;
+    const selection = useRowSelection.default(props, mergedRowSelection, rawData, {
+      prefixCls: vue.computed(() => props.prefixCls),
+      pageData,
+      getRowKey,
+      getRecordByKey,
+      locale,
+      keyEntities,
+      checkboxPropsMap,
+      allDataRootRowKeys,
+      pageDataRowKeys});
+    const bodyRef = vue.ref();
+    let leftRaf, topRaf;
+    const scrollTo = (options = {}, type = "auto", isAnimate = false) => {
+      if (!isAnimate) {
+        updateAnimate();
+      }
+      const mergeOptions = typeof options == "number" ? { top: options } : options;
+      let left, top;
+      if ("left" in mergeOptions) {
+        left = mergeOptions.left || 0;
+      } else if ("columnIndex" in mergeOptions) {
+        const position = columns.getColumnPosition(mergeOptions.columnIndex);
+        if (position) {
+          left = position.left - leftWidth.value;
+        }
+      } else if ("columnKey" in mergeOptions) {
+        const position = columns.getColumnPositionByKey(mergeOptions.columnKey);
+        if (position) {
+          left = position.left - leftWidth.value;
+        }
+      }
+      if ("top" in mergeOptions) {
+        top = Math.min(Math.max(mergeOptions.top || 0, 0), maxScrollTop.value);
+      } else if ("rowKey" in mergeOptions) {
+        const pos2 = cal.getRowPositionByKey(mergeOptions.rowKey);
+        if (pos2) {
+          top = pos2;
+        }
+      }
+      left = Math.max(Math.min(maxScrollLeft.value, left || 0), 0);
+      if (!showVerticalScrollbar.value) {
+        top = 0;
+      }
+      if (type === "smooth") {
+        if (left !== void 0) {
+          raf.default.cancel(leftRaf);
+          leftRaf = easeoutScroll.default(scrollLeft.value, left, (val) => {
+            scrollLeft.value = val;
+          });
+        }
+        if (top !== void 0) {
+          raf.default.cancel(topRaf);
+          topRaf = easeoutScroll.default(scrollTop.value, top, (val) => {
+            scrollTop.value = val;
+          });
+        }
+      } else {
+        if (left !== void 0) {
+          scrollLeft.value = left;
+        }
+        if (top !== void 0) {
+          scrollTop.value = top;
+        }
+      }
+    };
+    const useAnimate = vue.ref(false);
+    const animateRows = vue.computed(() => {
+      var _a;
+      return !!((_a = props.animateRows) != null ? _a : config.animateRows.value);
+    });
+    let timer;
+    vue.watch(
+      animateRows,
+      (newVal) => {
+        useAnimate.value = newVal;
+      },
+      { immediate: true }
+    );
+    const updateAnimate = () => {
+      useAnimate.value = false;
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        useAnimate.value = animateRows.value;
+      }, 100);
+    };
+    const maxScrollLeft = vue.computed(() => bodyMaxWidth.value - bodyWidth.value);
+    const maxScrollTop = vue.computed(() => viewportHeight.value - bodyHeight.value);
+    const onScroll = (e) => {
+      emit("scroll", e);
+    };
+    useHScrollSync.useHScrollSyncProvide({ scrollLeft, maxScrollLeft, onScroll, bodyWidth });
+    useVScrollSync.useVScrollSyncProvide({ scrollTop, maxScrollTop, onScroll, updateAnimate, bodyWidth });
+    const { data, pos: dataRowPosition } = useData.default(
+      props,
+      rowPosition,
+      flattenData,
+      startIndex,
+      endIndex,
+      draggingRowKey,
+      useAnimate,
+      getRowFlattenIndexByKey,
+      latestRangeStartCell
+    );
+    const pingedLeft = vue.ref(false);
+    const pingedRight = vue.ref(false);
+    const noPinged = vue.ref(false);
+    vue.watchEffect(() => {
+      pingedLeft.value = supportSticky.default && !!scrollLeft.value;
+      pingedRight.value = supportSticky.default && centerWidth.value - (bodyWidth.value - leftWidth.value - rightWidth.value) > scrollLeft.value;
+      noPinged.value = !pingedLeft.value && !pingedRight.value;
+    });
+    const rootClass = vue.computed(
+      () => classNames.default({
+        [`${props.prefixCls}`]: true,
+        [`${props.prefixCls}-support-sticky`]: supportSticky.default,
+        [`${props.prefixCls}-stripe`]: props.stripe,
+        [`${props.prefixCls}-bordered`]: props.bordered,
+        [`${props.prefixCls}-${props.size}`]: true,
+        [`${props.prefixCls}-ping-left`]: pingedLeft.value,
+        [`${props.prefixCls}-ping-right`]: pingedRight.value,
+        [`${props.prefixCls}-no-ping`]: noPinged.value,
+        [`${props.prefixCls}-has-animate`]: animateRows.value
+      })
+    );
+    const rootStyle = vue.computed(() => ({
+      height: typeof props.height == "number" ? `${props.height}px` : props.height,
+      maxHeight: typeof props.maxHeight == "number" ? `${props.maxHeight}px` : props.maxHeight,
+      minHeight: typeof props.minHeight == "number" ? `${props.minHeight}px` : props.minHeight
+    }));
+    const showHorizontalScrollbar = vue.ref(false);
+    const debounceFn = lodashUnified.debounce(() => {
+      showHorizontalScrollbar.value = bodyMaxWidth.value > bodyWidth.value;
+    }, 100);
+    vue.watch([bodyMaxWidth, bodyWidth], () => {
+      debounceFn();
+    });
+    const showVerticalScrollbar = eagerComputed.default(
+      () => !!mergedScrollY.value && bodyHeight.value + 0.9 < viewportHeight.value
+    );
+    const scrollToFirstRow = eagerComputed.default(
+      () => !props.scroll || props.scroll && props.scroll.scrollToFirstRowOnChange !== false
+    );
+    triggerOnChange = (info, action, reset = false) => {
+      var _a, _b, _c;
+      if (reset) {
+        refreshPagination();
+        triggeronPaginationChange(1, mergedPagination.value.pageSize);
+        if (props.pagination) {
+          (_b = (_a = props.pagination).onChange) == null ? void 0 : _b.call(_a, 1, mergedPagination.value.pageSize);
+        }
+      }
+      if (scrollToFirstRow.value) {
+        scrollTop.value = 0;
+      }
+      (_c = props.onChange) == null ? void 0 : _c.call(
+        props,
+        info.pagination || mergedPagination.value,
+        info.filters || filters.value,
+        info.sorter || sorter.value,
+        {
+          currentDataSource: info.currentDataSource || filterData.value,
+          action
+        }
+      );
+    };
+    const paginationProps = vue.computed(() => {
+      return omit.omit(mergedPagination.value, ["position", "onChange", "onShowSizeChange"]);
+    });
+    const paginationClass = vue.computed(() => {
+      return {
+        [`${props.prefixCls}-pagination`]: true,
+        [`${props.prefixCls}-pagination-${pos.value.bottom}`]: true,
+        [`${customUiCls}`]: true
+      };
+    });
+    const bottomPaginationHeight = vue.ref(0);
+    const bottomPaginationStyle = vue.computed(() => {
+      var _a, _b;
+      if (!props.paginationSticky) {
+        return {};
+      }
+      if (props.paginationSticky === true) {
+        return { position: "sticky", "z-index": 9, bottom: "0px" };
+      }
+      return {
+        position: "sticky",
+        "z-index": 9,
+        bottom: `${(_b = (_a = props.paginationSticky) == null ? void 0 : _a.offsetBottom) != null ? _b : 0}px`
+      };
+    });
+    const indentSize = vue.computed(() => typeof props.indentSize == "number" ? props.indentSize : 15);
+    const cellProps = useCellProps.default({
+      leftColumns: columns.leftColumns,
+      rightColumns: columns.rightColumns,
+      visibleCenterColumns: columns.visibleCenterColumns,
+      allColumns: columns.allColumns,
+      data,
+      mergedRowHeights: cal.mergedRowHeights,
+      getColumnPosition: columns.getColumnPosition,
+      bodyWidth,
+      leftWidth,
+      centerWidth,
+      getRowHeight: cal.getRowHeight,
+      customCell: vue.toRef(props, "customCell")
+    });
+    vue.watch(
+      [realHeaderHeight, scrollLeft],
+      () => {
+        var _a, _b;
+        (_b = (_a = popupContainer.value) == null ? void 0 : _a.alignPopup) == null ? void 0 : _b.call(_a);
+      },
+      { flush: "post" }
+    );
+    TableContext.useProvideTable({
+      ...cal,
+      ...columns,
+      ...cellProps,
+      rootRef,
+      rawData,
+      getRowFlattenIndexByKey,
+      prefixCls: vue.computed(() => props.prefixCls),
+      draggingRowKey,
+      insertToRowKey,
+      status,
+      useAnimate,
+      animateRows,
+      watermarkMsg,
+      onResizeColumn: (w, col, action) => {
+        var _a;
+        const width = col.width;
+        const result = (_a = props.onResizeColumn) == null ? void 0 : _a.call(props, w, col, action);
+        if (result !== false && !(width === w && col.width === w)) {
+          col.width = width !== col.width ? col.width : w;
+          vue.triggerRef(rawColumns);
+        }
+      },
+      onRowDragEnd: (opt) => {
+        var _a;
+        const { insertToRowKey: insertToRowKey2, record, fromIndexs, rowKey: rowKey2, dir, preTargetInfo, nextTargetInfo } = opt;
+        const rawRecord = vue.toRaw(record);
+        const dragEnd = (_a = props.onRowDragEnd) == null ? void 0 : _a.call(props, { ...opt, record: rawRecord, fromIndexs });
+        if (dragEnd === false) {
+          return;
+        }
+        const handler = () => {
+          if (!isMyChildren(rowKey2, preTargetInfo == null ? void 0 : preTargetInfo.rowKey) && insertToRowKey2 !== rowKey2) {
+            if (insertToRowKey2 !== null) {
+              const parentRecord = getRecordByKey(insertToRowKey2);
+              if (insertToRowKey2 === (preTargetInfo == null ? void 0 : preTargetInfo.rowKey) || insertToRowKey2 === (nextTargetInfo == null ? void 0 : nextTargetInfo.rowKey)) {
+                if (dir === constant.DOWN) {
+                  util.addNestItemData(
+                    parentRecord[childrenColumnName.value],
+                    [],
+                    childrenColumnName.value,
+                    rawRecord
+                  );
+                  util.deleteNestItemData(rawData.value, fromIndexs, childrenColumnName.value);
+                } else {
+                  util.deleteNestItemData(rawData.value, fromIndexs, childrenColumnName.value);
+                  util.addNestItemData(
+                    parentRecord[childrenColumnName.value],
+                    [],
+                    childrenColumnName.value,
+                    rawRecord
+                  );
+                }
+              } else {
+                if (dir === constant.DOWN) {
+                  util.addNestItemData(
+                    rawData.value,
+                    preTargetInfo == null ? void 0 : preTargetInfo.indexs,
+                    childrenColumnName.value,
+                    rawRecord
+                  );
+                  util.deleteNestItemData(rawData.value, fromIndexs, childrenColumnName.value);
+                } else {
+                  util.deleteNestItemData(rawData.value, fromIndexs, childrenColumnName.value);
+                  util.addNestItemData(
+                    rawData.value,
+                    preTargetInfo == null ? void 0 : preTargetInfo.indexs,
+                    childrenColumnName.value,
+                    rawRecord
+                  );
+                }
+              }
+            } else {
+              if (dir === constant.DOWN && preTargetInfo) {
+                util.addNestItemData(
+                  rawData.value,
+                  [preTargetInfo.indexs[0]],
+                  childrenColumnName.value,
+                  rawRecord
+                );
+                util.deleteNestItemData(rawData.value, fromIndexs, childrenColumnName.value);
+              } else if (dir === constant.UP && nextTargetInfo) {
+                util.deleteNestItemData(rawData.value, fromIndexs, childrenColumnName.value);
+                util.addNestItemData(
+                  rawData.value,
+                  (preTargetInfo == null ? void 0 : preTargetInfo.indexs) ? [preTargetInfo.indexs[0]] : [],
+                  childrenColumnName.value,
+                  rawRecord
+                );
+              }
+            }
+            vue.triggerRef(rawData);
+            emit("update:dataSource", rawData.value);
+          }
+        };
+        if (util.isPromise(dragEnd)) {
+          dragEnd.then(() => {
+            handler();
+          }).catch(() => {
+          });
+        } else {
+          handler();
+        }
+      },
+      virtual,
+      xVirtual,
+      dataRowPosition,
+      rawColumns,
+      bodyHeight,
+      scrollTop,
+      scrollLeft,
+      supportSticky: supportSticky.default,
+      childrenColumnName,
+      bodyScrollWidth,
+      baseHeight,
+      startIndex,
+      data,
+      pageData,
+      getRecordByKey,
+      getIndexsByKey,
+      expandType,
+      flattenData,
+      expandedRowKeys,
+      indentSize,
+      props,
+      bodyWidth,
+      scrollTo,
+      scrollBarSize,
+      leftWidth,
+      rightWidth,
+      centerWidth,
+      showVerticalScrollbar,
+      showHorizontalScrollbar,
+      getRowKey,
+      selection,
+      updateSelectedRowKeys: (keys) => {
+        emit("update:selectedRowKeys", keys);
+      },
+      locale,
+      sorterStates,
+      changeSorter,
+      changeFilter,
+      filterStates,
+      onTriggerExpand: (record, key) => {
+        let keys;
+        const hasKey = expandedRowKeys.value.has(key);
+        if (hasKey) {
+          expandedRowKeys.value.delete(key);
+          keys = [...expandedRowKeys.value];
+        } else {
+          keys = [...expandedRowKeys.value, key];
+        }
+        defaultExpandedRowKeys.value = keys;
+        emit("update:expandedRowKeys", keys);
+        emit("expand", !hasKey, record);
+        emit("expandedRowsChange", keys);
+      },
+      keyEntities,
+      pageDataRowKeys,
+      pageDataEnableRowKeys,
+      checkboxPropsMap,
+      mergedRowSelection,
+      getPopupContainer,
+      allDataRowKeys,
+      allDataRootRowKeys,
+      dragRowsHandle,
+      isMyChildren,
+      getKeyByIndexs,
+      getRowByFlattenIndex,
+      draggingColumnKey,
+      dragColumnsHandle,
+      onColumnDragEnd: (arg) => {
+        var _a;
+        const { dir, column, targetColumn } = arg;
+        const dragEnd = (_a = props.onColumnDragEnd) == null ? void 0 : _a.call(props, arg);
+        if (dragEnd === false) {
+          return;
+        }
+        const handler = () => {
+          if (column === targetColumn || column.key === targetColumn.key) return;
+          const index = rawColumns.value.findIndex(
+            (col) => col === column || col.key === column.key
+          );
+          const targetIndex = rawColumns.value.findIndex(
+            (col) => col === targetColumn || col.key === targetColumn.key
+          );
+          if (dir === constant.LEFT) {
+            rawColumns.value.splice(index, 1);
+            rawColumns.value.splice(targetIndex, 0, column);
+          } else {
+            rawColumns.value.splice(targetIndex + 1, 0, column);
+            rawColumns.value.splice(index, 1);
+          }
+          vue.triggerRef(rawColumns);
+          emit("update:columns", rawColumns.value);
+        };
+        if (util.isPromise(dragEnd)) {
+          dragEnd.then(() => {
+            handler();
+          }).catch(() => {
+          });
+        } else {
+          handler();
+        }
+      },
+      onColumnDrag: () => {
+      },
+      columnDrag: vue.computed(() => props.columnDrag),
+      summaryFixed: mergedSummaryFixed,
+      realHeaderHeight,
+      bottomPaginationHeight,
+      pos
+    });
+    const tabGuardTopRef = vue.ref();
+    const tabGuardBottomRef = vue.ref();
+    const {
+      navigationService,
+      getSelectedRange,
+      clearAllSelectedRange,
+      copySelectedRange,
+      appendCellToSelectedRange,
+      onBodyKeydown
+    } = useRangeStore.useProvideRangeStore({
+      allColumns: columns.allColumns,
+      flattenData,
+      rangeSelection: vue.computed(() => props.rangeSelection),
+      getRowByFlattenIndex,
+      rootRef,
+      prefixCls: vue.computed(() => props.prefixCls),
+      allCellProps: cellProps.allCellProps,
+      tabGuardTopRef,
+      tabGuardBottomRef,
+      ensureCellColumnVisible: (cell) => {
+        if (!cell.column || cell.column.fixed) return;
+        const sl = scrollLeft.value;
+        const pos2 = columns.getColumnPositionByKey(cell.column.columnKey);
+        if (pos2) {
+          const { width, left } = pos2;
+          const lw = leftWidth.value;
+          const rw = rightWidth.value;
+          left - lw < sl ? scrollLeft.value = left - lw : left + width > sl + bodyWidth.value - rw && (scrollLeft.value = left + width - bodyWidth.value + rw);
+        }
+      },
+      ensureCellRowVisible: (cell) => {
+        var _a;
+        const { rowIndex } = cell;
+        const st = scrollTop.value;
+        const row = getRowByFlattenIndex(rowIndex);
+        const pos2 = cal.getRowPositionByKey(row.rowKey);
+        const cprops = (((_a = cellProps.allCellProps.value[row.rowKey]) == null ? void 0 : _a[cell.column.columnKey]) || {}).props || {};
+        const height = cal.getRowHeight(rowIndex, cprops.rowSpan);
+        if (pos2 !== void 0) {
+          updateAnimate();
+          if (pos2 < st) {
+            scrollTop.value = pos2;
+          } else {
+            if (pos2 + height > st + bodyHeight.value) {
+              scrollTop.value = pos2 + height - bodyHeight.value;
+            }
+          }
+        }
+      },
+      latestRangeStartCell,
+      bodyRef: vue.computed(() => {
+        var _a;
+        return (_a = bodyRef.value) == null ? void 0 : _a.bodyRef;
+      }),
+      scrollLeft,
+      scrollTop,
+      scrollTo,
+      showVerticalScrollbar,
+      showHorizontalScrollbar,
+      getIndexsByKey,
+      formatRangeCellText: (parmas) => {
+        if (props.formatRangeCellText) {
+          return props.formatRangeCellText(parmas);
+        } else if (parmas.value) {
+          return parmas.value;
+        }
+        return "";
+      },
+      editCellKeys,
+      copyDelimiter: vue.computed(() => props.copyDelimiter)
+    });
+    expose({
+      scrollTo,
+      scrollLeft,
+      scrollTop,
+      bodyRef: vue.computed(() => {
+        var _a;
+        return (_a = bodyRef.value) == null ? void 0 : _a.bodyRef;
+      }),
+      getSelectedRange,
+      clearAllSelectedRange,
+      copySelectedRange,
+      appendCellToSelectedRange,
+      openEditor: (cellInfos) => {
+        openEditor(cellInfos.map((info) => `${info.rowKey} ${info.columnKey}`));
+      },
+      closeEditor: (cellInfos) => {
+        if (cellInfos) {
+          closeEditor(cellInfos.map((info) => `${info.rowKey} ${info.columnKey}`));
+        } else {
+          closeEditor();
+        }
+      }
+    });
+    return {
+      bodyRef,
+      spinProps,
+      rowPosition,
+      viewportHeight,
+      startIndex,
+      data,
+      watermarkMsg,
+      rootStyle,
+      rootClass,
+      onBodyKeydown,
+      watermarkStyle: vue.computed(() => ({
+        minWidth: "100px!important",
+        minHeight: "40px!important",
+        position: "absolute!important",
+        fontSize: "20px!important",
+        opacity: "0.8!important",
+        bottom: "40px!important",
+        right: "40px!important",
+        pointerEvents: "none",
+        display: "block!important",
+        zIndex: "999999!important",
+        color: "#000000!important",
+        margin: "0px!important",
+        padding: "0px!important",
+        transform: "unset!important"
+      })),
+      mergedPagination,
+      pos,
+      onPaginationChange,
+      scrollBarSize,
+      scrollTop,
+      bodyScrollWidth,
+      bodyWidth,
+      scrollLeft,
+      cal,
+      selection,
+      locale,
+      paginationProps,
+      slots,
+      mergedScrollX,
+      mergedScrollY,
+      bodyHeight,
+      measureWidthRef,
+      flattenData,
+      rootRef,
+      mergedSummaryFixed,
+      handleResize: (e) => {
+        realHeaderHeight.value = e.detail.height;
+      },
+      handlePaginationResize: (e) => {
+        bottomPaginationHeight.value = e.detail.height;
+      },
+      popupContainer,
+      handleGuardTopKeydown: (e) => {
+        e.keyCode !== KeyCode.default.TAB || e.shiftKey || (navigationService.getFirstCellToFocus(e.shiftKey), e.preventDefault());
+      },
+      handleGuardBottomKeydown: (e) => {
+        e.keyCode === KeyCode.default.TAB && e.shiftKey && (navigationService.getLastCellToFocus(e.shiftKey), e.preventDefault());
+      },
+      tabGuardTopRef,
+      tabGuardBottomRef,
+      onShowSizeChange,
+      customUiCls,
+      paginationClass,
+      bottomPaginationStyle
+    };
+  }
+});
+
+exports.default = _sfc_main;
+//# sourceMappingURL=InteralTable.vue2.js.map