@dt-frames/ui 2.0.1 → 2.0.2

package/es/components/table/index.js

@@ -0,0 +1,4414 @@
+import { DtCache, CacheKey, deepMerge, Pages, useGo, useRedo, Language, useAppStore, useSlots as useSlots$1, error, http, useApp, getDynamicProps, isBoolean, isFunction, getPopupContainer, useI18n, isNumber, isArray, isObject, isString, isNull, dispatchResize, useTimeoutFn, off, on, windowResizeFn, useMessage, isNullAndUnDef, getDictValueByCode, formatNumber, isVnode } from "@dt-frames/core";
+import { toRaw as toRaw$1, unref as unref$1, computed as computed$1, defineComponent as defineComponent$1, resolveDirective, openBlock, createElementBlock, Fragment, renderList, withDirectives, createVNode, withCtx, createTextVNode, toDisplayString, createElementVNode, normalizeClass, normalizeStyle, createCommentVNode, createBlock, provide as provide$1, inject, mergeProps, ref as ref$1, watch as watch$1, getCurrentInstance as getCurrentInstance$1, reactive as reactive$1, readonly, watchEffect as watchEffect$1, nextTick as nextTick$1, isRef, useAttrs as useAttrs$1, normalizeProps, guardReactiveProps, isVNode, onUnmounted as onUnmounted$1, h as h$1, resolveDynamicComponent, renderSlot, createSlots } from "vue";
+import { defineStore } from "pinia";
+import { Tooltip, MenuItem, Menu, Dropdown, RadioButton, RadioGroup, Button, FormItem as FormItem$1, Col as Col$1, Spin, Checkbox as Checkbox$1, Divider as Divider$1, Row, CheckboxGroup, Popover as Popover$1, Table } from "ant-design-vue/es";
+import { omit, cloneDeep, isEqual, upperFirst } from "lodash-es";
+import { useDebounceFn, useFullscreen, isFunction as isFunction$1 } from "@vueuse/core";
+import { Input, InputNumber, Select, TreeSelect, Switch, Checkbox, DatePicker, TimePicker, Popover, Radio, AutoComplete, Cascader, Slider, Rate, Divider, Col, Tooltip as Tooltip$1, Form, FormItem, Modal as Modal$1 } from "ant-design-vue";
+import "ant-design-vue/es/form/style";
+import "ant-design-vue/es/button/style";
+import "ant-design-vue/es/checkbox/style";
+import "ant-design-vue/es/popover/style";
+import Sortablejs from "sortablejs";
+import dayjs from "dayjs";
+var Theme = /* @__PURE__ */ ((Theme2) => {
+  Theme2["DARK"] = "dark";
+  Theme2["LIGHT"] = "light";
+  return Theme2;
+})(Theme || {});
+var MenuType = /* @__PURE__ */ ((MenuType2) => {
+  MenuType2["SIDE"] = "sidebar";
+  MenuType2["TOP_MENU"] = "top-menu";
+  MenuType2["MIX"] = "mix";
+  return MenuType2;
+})(MenuType || {});
+var MenuMode = /* @__PURE__ */ ((MenuMode2) => {
+  MenuMode2["INLINE"] = "inline";
+  MenuMode2["HORIZONTAL"] = "horizontal";
+  MenuMode2["VERTICAL"] = "vertical";
+  return MenuMode2;
+})(MenuMode || {});
+var ContentMode = /* @__PURE__ */ ((ContentMode2) => {
+  ContentMode2["FULL"] = "full";
+  ContentMode2["FIXED"] = "fixed";
+  return ContentMode2;
+})(ContentMode || {});
+var UiSize = /* @__PURE__ */ ((UiSize2) => {
+  UiSize2["LARGE"] = "large";
+  UiSize2["MIDDLE"] = "middle";
+  UiSize2["SMALL"] = "small";
+  return UiSize2;
+})(UiSize || {});
+const defaultThemeConf = {
+  content: {
+    contentMode: ContentMode.FULL
+  },
+  headOptions: {
+    fixed: true,
+    theme: Theme.LIGHT,
+    showLogo: true,
+    showBackToTop: true,
+    useLockPage: true,
+    size: UiSize.SMALL,
+    showSize: true,
+    showBreadCrumb: true,
+    showFullScreen: true,
+    showSearch: true,
+    showNotice: true,
+    showLocaleSwitch: true,
+    showSettingTheme: true,
+    showLoginOut: true
+  },
+  menuOptions: {
+    fixed: true,
+    theme: Theme.DARK,
+    collapsed: false,
+    collapsedShowTitle: false,
+    canDrag: true,
+    show: true,
+    hidden: false,
+    split: false,
+    menuWidth: 240,
+    trigger: true,
+    type: MenuType.SIDE,
+    mode: MenuMode.INLINE
+  },
+  footerOptions: {
+    show: false,
+    height: 48,
+    title: "Copyright(C) 2021 by www.ithinkdt.com. All rights reserved.",
+    subTitle: "Privacy Statement"
+  },
+  routeReuse: {
+    show: true,
+    cache: true,
+    canDrag: true,
+    showQuick: true,
+    showRedo: true,
+    showFold: true
+  }
+};
+const useThemeStore = defineStore({
+  id: "dt-theme",
+  state: () => ({
+    themeConf: DtCache.getLocal(CacheKey.THEME) ?? defaultThemeConf,
+    pageLoading: false
+  }),
+  getters: {
+    getThemeConf() {
+      return this.themeConf;
+    },
+    getHeaderConf() {
+      return this.themeConf.headOptions;
+    },
+    getMenuConf() {
+      return this.themeConf.menuOptions;
+    },
+    getFooterConf() {
+      return this.themeConf.footerOptions;
+    },
+    getRouteReuseConf() {
+      return this.themeConf.routeReuse;
+    },
+    getPageLoading() {
+      return this.pageLoading;
+    }
+  },
+  actions: {
+    setThemeConf(options = {}) {
+      let newThemeConf = deepMerge(this.themeConf, options);
+      this.themeConf = deepMerge(defaultThemeConf, newThemeConf);
+      DtCache.setLocal(CacheKey.THEME, this.themeConf);
+    }
+  }
+});
+defineStore({
+  id: "route-reuse",
+  state: () => ({
+    cacheTabList: /* @__PURE__ */ new Set(),
+    tabList: DtCache.getLocal(CacheKey.THEME)?.routeReuse?.cache ? DtCache.getLocal(CacheKey.ROUTE_REUSE) || [] : [],
+    lastDragEndIndex: 0
+  }),
+  getters: {
+    getTabList() {
+      return this.tabList;
+    },
+    getCachedTabList() {
+      return Array.from(this.cacheTabList);
+    },
+    getLastDragEndIndex() {
+      return this.lastDragEndIndex;
+    }
+  },
+  actions: {
+    async addTab(route) {
+      const { path, name, fullPath, params, query, meta } = route;
+      if (path === Pages.NOT_FOUND || path === Pages.LOGIN || path === Pages.BASE_PAGE) {
+        return;
+      }
+      let updateIndex = -1;
+      const tabHasExits = this.tabList.some((tab, index2) => {
+        updateIndex = index2;
+        return (tab.fullPath || tab.path) === (fullPath || path);
+      });
+      if (tabHasExits) {
+        const curTab = toRaw$1(this.tabList)[updateIndex];
+        curTab.params = params || curTab.params;
+        curTab.query = query || curTab.query;
+        curTab.fullPath = fullPath || curTab.fullPath;
+        this.tabList.splice(updateIndex, 1, curTab);
+      } else {
+        this.tabList.push(JSON.parse(JSON.stringify(route)));
+      }
+      this.updateCacheTab();
+    },
+    closeTab(path, router) {
+      const go = useGo(router);
+      const index2 = this.tabList.findIndex((item) => item.path === path);
+      let page;
+      if (index2 === 0) {
+        if (this.tabList.length !== 1) {
+          page = this.tabList[index2 + 1];
+        }
+      } else {
+        page = this.tabList[index2 - 1];
+      }
+      this.bulkCloseTabs([path]);
+      this.updateCacheTab();
+      path === router.currentRoute.value.path && go(page.path);
+    },
+    closeAllTab(currentRoute, router) {
+      const go = useGo(router);
+      let filterTabList = this.tabList.filter((item) => item?.meta?.affix ?? false);
+      const route = filterTabList.length > 0 ? filterTabList[filterTabList.length - 1] : unref$1(currentRoute);
+      this.tabList = [route];
+      this.updateCacheTab();
+      go(route.path);
+    },
+    closeLeftTabs(path) {
+      const index2 = this.tabList.findIndex((item) => item.path === path);
+      if (index2 > 0) {
+        const leftTabs = this.tabList.slice(0, index2);
+        const pathList = [];
+        for (const item of leftTabs) {
+          const affix = item?.meta?.affix ?? false;
+          if (!affix) {
+            pathList.push(item.fullPath);
+          }
+        }
+        this.bulkCloseTabs(pathList);
+      }
+      this.updateCacheTab();
+    },
+    closeRightTabs(path) {
+      const index2 = this.tabList.findIndex((item) => item.path === path);
+      if (index2 >= 0 && index2 < this.tabList.length - 1) {
+        const rightTabs = this.tabList.slice(index2 + 1, this.tabList.length);
+        const pathList = [];
+        for (const item of rightTabs) {
+          const affix = item?.meta?.affix ?? false;
+          if (!affix) {
+            pathList.push(item.fullPath);
+          }
+        }
+        this.bulkCloseTabs(pathList);
+      }
+      this.updateCacheTab();
+    },
+    closeOtherTabs(path) {
+      const pathList = [];
+      for (let item of this.tabList) {
+        const affix = item?.meta?.affix ?? false;
+        if (item.path !== path && !affix) {
+          pathList.push(item.path);
+        }
+      }
+      this.bulkCloseTabs(pathList);
+      this.updateCacheTab();
+    },
+    bulkCloseTabs(pathList) {
+      this.tabList = this.tabList.filter((item) => !pathList.includes(item.fullPath));
+    },
+    updateCacheTab() {
+      const cacheTab = DtCache.getLocal(CacheKey.THEME)?.routeReuse?.cache;
+      cacheTab && DtCache.setLocal(CacheKey.ROUTE_REUSE, this.tabList);
+      const cacheMap = /* @__PURE__ */ new Set();
+      for (const tab of this.tabList) {
+        if (tab.meta?.hideTab) {
+          continue;
+        }
+        const name = tab.name;
+        cacheMap.add(name);
+      }
+      this.cacheTabList = cacheMap;
+    },
+    async refreshPage(router) {
+      const findTab = this.getCachedTabList.find((item) => item === unref$1(router.currentRoute).name);
+      if (findTab) {
+        this.cacheTabList.delete(findTab.toString());
+      }
+      const redo = useRedo(router);
+      await redo();
+    },
+    sortTabs(oldIndex, newIndex) {
+      const currentTab = this.tabList[oldIndex];
+      this.tabList.splice(oldIndex, 1);
+      this.tabList.splice(newIndex, 0, currentTab);
+      this.lastDragEndIndex = this.lastDragEndIndex + 1;
+    }
+  }
+});
+function useMenu() {
+  const { getMenuConf, setThemeConf } = useThemeStore();
+  const getCollapsedShowTitle = computed$1(() => getMenuConf.collapsedShowTitle);
+  const getIsSidebarType = computed$1(() => getMenuConf.type === MenuType.SIDE);
+  const getMenuFixed = computed$1(() => getMenuConf.fixed);
+  const getShowMenu = computed$1(() => getMenuConf.show);
+  const getShowSidebar = computed$1(() => {
+    return unref$1(getSplit) || unref$1(getShowMenu) && unref$1(getMenuMode) !== MenuMode.HORIZONTAL;
+  });
+  const getMenuHidden = computed$1(() => getMenuConf.hidden);
+  const getMenuTheme = computed$1(() => getMenuConf.theme);
+  const getTrigger = computed$1(() => getMenuConf.trigger);
+  const getCanDrag = computed$1(() => getMenuConf.canDrag);
+  const getIsMixMode = computed$1(() => {
+    return unref$1(getMenuMode) === MenuMode.INLINE && unref$1(getMenuType) === MenuType.MIX;
+  });
+  const getMenuWidth = computed$1(() => unref$1(getIsMixMode) ? Number(getMenuConf.menuWidth) - 40 : getMenuConf.menuWidth);
+  const getLogoWidth = computed$1(() => getMenuConf.menuWidth);
+  const getMenuType = computed$1(() => getMenuConf.type);
+  const getIsTopMenu = computed$1(() => unref$1(getMenuType) === MenuType.TOP_MENU);
+  const getMenuMode = computed$1(() => getMenuConf.mode);
+  const getSplit = computed$1(() => getMenuConf.split);
+  const getCollapsed = computed$1(() => getMenuConf.collapsed);
+  const getIsHorizontal = computed$1(() => unref$1(getMenuMode) === MenuMode.HORIZONTAL);
+  const setThemeStore = (conf = {}) => setThemeConf(conf);
+  const toggleCollapsed = () => setThemeStore({
+    menuOptions: {
+      collapsed: !unref$1(getCollapsed)
+    }
+  });
+  const getMiniWidthNumber = computed$1(() => getMenuConf.collapsedShowTitle ? 80 : 48);
+  const getRealWidth = computed$1(() => {
+    return unref$1(getCollapsed) ? unref$1(getMiniWidthNumber) : unref$1(getMenuWidth);
+  });
+  const getCalcContentWidth = computed$1(() => {
+    const width = unref$1(getIsTopMenu) || !unref$1(getShowMenu) || unref$1(getSplit) && unref$1(getMenuHidden) ? 0 : unref$1(getRealWidth);
+    return `calc(100% - ${unref$1(width)}px)`;
+  });
+  return {
+    getCollapsedShowTitle,
+    getIsSidebarType,
+    getMenuFixed,
+    getShowMenu,
+    getShowSidebar,
+    getMenuHidden,
+    getMenuTheme,
+    getTrigger,
+    getMenuWidth,
+    getLogoWidth,
+    getMenuType,
+    getIsTopMenu,
+    getMenuMode,
+    getSplit,
+    getCollapsed,
+    getIsHorizontal,
+    getMiniWidthNumber,
+    getRealWidth,
+    getCalcContentWidth,
+    getIsMixMode,
+    getCanDrag,
+    toggleCollapsed,
+    setThemeStore
+  };
+}
+function useMultipleTab() {
+  const { getRouteReuseConf } = useThemeStore();
+  const getShowMultipleTab = computed(() => getRouteReuseConf.show);
+  const getShowQuick = computed(() => getRouteReuseConf.showQuick);
+  const getShowRedo = computed(() => getRouteReuseConf.showRedo);
+  const getCanCache = computed(() => getRouteReuseConf.cache);
+  const getCanDrag = computed(() => getRouteReuseConf.canDrag);
+  return {
+    getShowMultipleTab,
+    getShowQuick,
+    getShowRedo,
+    getCanCache,
+    getCanDrag
+  };
+}
+function useHeader() {
+  const HEADER_HEIGHT = 48;
+  const TABS_HEIGHT = 33;
+  const { getHeaderConf = {} } = useThemeStore();
+  const {
+    getIsSidebarType,
+    getMenuType,
+    getShowMenu,
+    getMenuHidden,
+    getTrigger,
+    getMenuMode,
+    getSplit,
+    getIsTopMenu,
+    getIsMixMode
+  } = useMenu();
+  const { getShowMultipleTab } = useMultipleTab();
+  const getHeaderTheme = computed$1(() => getHeaderConf.theme);
+  const getFixed = computed$1(() => getHeaderConf.fixed);
+  const getShowHeaderLogo = computed$1(() => unref$1(getShowLogo) && !unref$1(getIsSidebarType));
+  const getShowSearch = computed$1(() => getHeaderConf.showSearch);
+  const getShowHeaderTrigger = computed$1(() => {
+    if (unref$1(getMenuType) === MenuType.TOP_MENU || !unref$1(getShowMenu) || unref$1(getMenuHidden)) {
+      return false;
+    }
+    return unref$1(getTrigger);
+  });
+  const getShowBreadCrumb = computed$1(() => getHeaderConf.showBreadCrumb);
+  const getShowBread = computed$1(
+    () => unref$1(getMenuMode) !== MenuMode.HORIZONTAL && !unref$1(getSplit) && unref$1(getShowBreadCrumb)
+  );
+  const getShowTopMenu = computed$1(() => unref$1(getMenuMode) === MenuMode.HORIZONTAL || unref$1(getSplit));
+  const getShowNotice = computed$1(() => getHeaderConf.showNotice);
+  const getShowFullScreen = computed$1(() => getHeaderConf.showFullScreen);
+  const getShowLocale = computed$1(() => getHeaderConf.showLocaleSwitch);
+  const getShowSettingTheme = computed$1(() => getHeaderConf.showSettingTheme);
+  const getShowFullHeaderRef = computed$1(() => {
+    return !unref$1(getIsSidebarType) && !unref$1(getIsTopMenu);
+  });
+  const getHeaderHeight = computed$1(() => {
+    let height = 0;
+    height += HEADER_HEIGHT;
+    if (unref$1(getShowMultipleTab) && !unref$1(getSplit)) {
+      height += TABS_HEIGHT;
+    }
+    return height;
+  });
+  const getTabsHeight = computed$1(() => TABS_HEIGHT);
+  const getShowInsetHeaderRef = computed$1(() => {
+    return unref$1(getIsSidebarType) || unref$1(getIsTopMenu);
+  });
+  const getShowBackToTop = computed$1(() => getHeaderConf.showBackToTop);
+  const getIsZH = computed$1(() => {
+    let local = DtCache.getLocal(CacheKey.LOCALE);
+    if (!local)
+      return true;
+    return local === Language.ZH;
+  });
+  const getUiSize = computed$1(() => getHeaderConf?.size ?? UiSize.SMALL);
+  const getShowUiSize = computed$1(() => getHeaderConf?.showSize);
+  const getShowLogo = computed$1(() => getHeaderConf.showLogo);
+  const getShowLoginOut = computed$1(() => getHeaderConf.showLoginOut);
+  const loginOutClick = getHeaderConf.logoutClick;
+  return {
+    getHeaderTheme,
+    getFixed,
+    getShowSearch,
+    getShowHeaderLogo,
+    getShowHeaderTrigger,
+    getShowBread,
+    getShowTopMenu,
+    getShowFullScreen,
+    getShowLocale,
+    getShowSettingTheme,
+    getShowNotice,
+    getShowFullHeaderRef,
+    getHeaderHeight,
+    getTabsHeight,
+    getShowInsetHeaderRef,
+    getShowBackToTop,
+    getIsZH,
+    getUiSize,
+    getShowLogo,
+    getShowLoginOut,
+    getShowUiSize,
+    loginOutClick
+  };
+}
+const codeMap = /* @__PURE__ */ new Map();
+function useHeaderCode(code, changeColumns) {
+  const { appConf } = useAppStore();
+  const { getIsZH } = useHeader();
+  useSlots$1();
+  useSlots();
+  if (!appConf.pages.queryColumnApi) {
+    error("\u8BF7\u5728init.config.ts\u4E2D\u914D\u7F6EqueryColumnApi\uFF01");
+    return;
+  }
+  const getAlign = (key) => key === 0 ? "center" : key === 2 ? "right" : "left";
+  const renderCell = (type, slot, ctx) => {
+    switch (type) {
+      case 0:
+        return { date: ctx };
+      case 1:
+        return { dict: ctx };
+      case 5:
+        return { percent: ctx };
+      case 7:
+        if (!appConf.structure[ctx]) {
+          error(`\u672A\u627E\u5230structure: ${ctx} !`);
+          return {};
+        }
+        return { dict: { ...appConf.structure[ctx], struCode: ctx } };
+      case 11:
+        return { number: ctx };
+    }
+  };
+  function getColumns() {
+    if (codeMap.get(code)) {
+      changeColumns(codeMap.get(code));
+      return;
+    }
+    http.post(
+      appConf.pages.queryColumnApi,
+      { tableCode: code }
+    ).then((rsp) => {
+      handleData(rsp);
+    });
+  }
+  function handleData(data) {
+    let rows = [];
+    data.forEach((it) => {
+      let obj = {
+        title: unref$1(getIsZH) ? it.cloumnName : it.cloumnEngName,
+        dataIndex: it.cloumnCode,
+        sorter: it.ifOrder,
+        align: getAlign(it.textAlign),
+        show: Boolean(it.ifDisplay),
+        defaultHidden: !Boolean(it.ifDisplay)
+      };
+      if (it.cloumnType !== void 0)
+        obj.render = renderCell(it.cloumnType, it.slot, it.dictCode);
+      if (it.width)
+        obj.width = Number(it.width);
+      rows.push(obj);
+    });
+    codeMap.set(code, rows);
+    changeColumns(rows);
+  }
+  getColumns();
+}
+function useTable(props2) {
+  const tableRef = ref(null);
+  const loadedRef = ref(false);
+  let stopWatch;
+  function registerTable(instance) {
+    const { isProd } = useApp();
+    if (unref(loadedRef) && unref(isProd) && instance === unref(tableRef))
+      return;
+    if (props2?.columnCode) {
+      useHeaderCode(
+        props2.columnCode,
+        (columns) => {
+          props2.columns = columns;
+          instance.setProps(getDynamicProps(props2));
+        }
+      );
+    }
+    tableRef.value = instance;
+    loadedRef.value = true;
+    stopWatch?.();
+    stopWatch = watch(
+      () => props2,
+      () => {
+        props2 && instance.setProps(getDynamicProps(props2));
+      },
+      {
+        immediate: true,
+        deep: true
+      }
+    );
+    onUnmounted(() => {
+      tableRef.value = null;
+      loadedRef.value = null;
+    });
+  }
+  function getTableInstance2() {
+    const table = unref(tableRef);
+    if (!table) {
+      error("\u6CA1\u6709table\u8868\u5355\u5B9E\u4F8B");
+    }
+    return table;
+  }
+  const methods = {
+    setProps: (props22) => getTableInstance2().setProps(props22),
+    setLoading: (loading) => getTableInstance2().setLoading(loading),
+    clearSelectedRowKeys: () => getTableInstance2().clearSelectedRowKeys(),
+    getSelectRows: () => getTableInstance2().getSelectRows(),
+    getSelectedRowKeys: () => getTableInstance2().getSelectedRowKeys(),
+    setSelectedRowKeys: (keys) => getTableInstance2().setSelectedRowKeys(keys),
+    getRowSelection: () => toRaw(getTableInstance2().getRowSelection()),
+    getColumns: (opt) => toRaw(getTableInstance2().getColumns(opt)),
+    setColumns: (columns) => getTableInstance2().setColumns(columns),
+    setColumnsByDataIndex: (dataIndex, value) => {
+      return getTableInstance2().setColumnsByDataIndex(dataIndex, value);
+    },
+    getCacheColumns: () => toRaw(getTableInstance2().getCacheColumns()),
+    findTableDataRecord: (rowKey) => getTableInstance2().findTableDataRecord(rowKey),
+    updateTableDataRecord: (rowKey, record) => getTableInstance2().updateTableDataRecord(rowKey, record),
+    getPagination: () => getTableInstance2().getPagination()
+  };
+  return [registerTable, methods];
+}
+const _default = "";
+const index$e = "";
+const index$d = "";
+const index$c = "";
+const index$b = "";
+const index$a = "";
+const index$9 = "";
+const index$8 = "";
+const index$7 = "";
+const index$6 = "";
+const index$5 = "";
+const index$4 = "";
+const index$3 = "";
+const _imports_0 = "data:image/png;base64,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";
+const index$2 = "";
+const _hoisted_1$b = {
+  key: 0,
+  class: "dt-table-action-btn"
+};
+const _hoisted_2$3 = ["onClick"];
+const _hoisted_3$3 = /* @__PURE__ */ createElementVNode("i", { class: "i ic:baseline-settings dt-table-action-dropdown cursor-pointer" }, null, -1);
+const _hoisted_4$3 = { class: "text-13 opacity-80" };
+const _sfc_main$j = /* @__PURE__ */ defineComponent$1({
+  __name: "TableAction",
+  props: {
+    fixed: {
+      type: String,
+      default: "right"
+    },
+    expand: {
+      type: Boolean,
+      default: false
+    },
+    width: {
+      type: String,
+      default: "70px"
+    },
+    btns: {
+      type: Array,
+      default: []
+    },
+    flag: {
+      type: String
+    },
+    record: {
+      default: {}
+    },
+    index: {
+      type: Number
+    }
+  },
+  setup(__props) {
+    const props2 = __props;
+    const actionBtns = ref([]);
+    function handleAction(it) {
+      if (isFunction(it.onClick)) {
+        it.onClick({
+          row: props2.record,
+          index: props2.index
+        });
+      }
+    }
+    const attrs = useAttrs();
+    function getPopupContainer$1() {
+      return isFunction(attrs.getPopupContainer) ? attrs.getPopupContainer() : getPopupContainer();
+    }
+    watch(
+      () => props2.btns,
+      (btns) => {
+        actionBtns.value = [...btns].map((it) => {
+          return {
+            ...it,
+            ifShow: isBoolean(it.show) ? it.show : isFunction(it.show) ? it.show(props2.record) : true
+          };
+        });
+      },
+      {
+        immediate: true
+      }
+    );
+    return (_ctx, _cache) => {
+      const _component_ATooltip = Tooltip;
+      const _component_AMenuItem = MenuItem;
+      const _component_AMenu = Menu;
+      const _component_ADropdown = Dropdown;
+      const _directive_auth = resolveDirective("auth");
+      return props2.expand ? (openBlock(true), createElementBlock(Fragment, { key: 0 }, renderList(unref$1(actionBtns), (item) => {
+        return openBlock(), createElementBlock(Fragment, null, [
+          item.ifShow ? withDirectives((openBlock(), createElementBlock("span", _hoisted_1$b, [
+            createVNode(_component_ATooltip, { placement: "bottom" }, {
+              title: withCtx(() => [
+                createTextVNode(toDisplayString(item.name), 1)
+              ]),
+              default: withCtx(() => [
+                createElementVNode("i", {
+                  class: normalizeClass(["i cursor-pointer", item.icon]),
+                  style: normalizeStyle({
+                    color: item.color
+                  }),
+                  onClick: ($event) => handleAction(item)
+                }, null, 14, _hoisted_2$3)
+              ]),
+              _: 2
+            }, 1024)
+          ])), [
+            [_directive_auth, item.auth]
+          ]) : createCommentVNode("", true)
+        ], 64);
+      }), 256)) : (openBlock(), createBlock(_component_ADropdown, {
+        key: 1,
+        getPopupContainer: getPopupContainer$1,
+        trigger: ["click"]
+      }, {
+        overlay: withCtx(() => [
+          createVNode(_component_AMenu, { class: "dt-action-select flex flex-col" }, {
+            default: withCtx(() => [
+              (openBlock(true), createElementBlock(Fragment, null, renderList(unref$1(actionBtns), (item) => {
+                return withDirectives((openBlock(), createElementBlock("span", null, [
+                  item.ifShow ? (openBlock(), createBlock(_component_AMenuItem, {
+                    key: 0,
+                    onClick: ($event) => handleAction(item)
+                  }, {
+                    default: withCtx(() => [
+                      createElementVNode("i", {
+                        class: normalizeClass(["i text-base opacity-80 pr-2", item.icon]),
+                        style: normalizeStyle({
+                          color: item.color
+                        })
+                      }, null, 6),
+                      createElementVNode("span", _hoisted_4$3, toDisplayString(item.name), 1)
+                    ]),
+                    _: 2
+                  }, 1032, ["onClick"])) : createCommentVNode("", true)
+                ])), [
+                  [_directive_auth, item.auth]
+                ]);
+              }), 256))
+            ]),
+            _: 1
+          })
+        ]),
+        default: withCtx(() => [
+          _hoisted_3$3
+        ]),
+        _: 1
+      }));
+    };
+  }
+});
+const tableKey = Symbol("dt-page");
+function createTableInstance(instance) {
+  provide$1(tableKey, instance);
+}
+function getTableInstance() {
+  return inject(tableKey);
+}
+const componentMap$1 = /* @__PURE__ */ new Map();
+componentMap$1.set("Input", Input);
+componentMap$1.set("InputNumber", InputNumber);
+componentMap$1.set("Select", Select);
+componentMap$1.set("TreeSelect", TreeSelect);
+componentMap$1.set("Switch", Switch);
+componentMap$1.set("Checkbox", Checkbox);
+componentMap$1.set("DatePicker", DatePicker);
+componentMap$1.set("TimePicker", TimePicker);
+const CellComponent = ({
+  component = "Input",
+  rule = true,
+  ruleMessage,
+  popoverVisible,
+  getPopupContainer: getPopupContainer2
+}, { attrs }) => {
+  const Comp = componentMap$1.get(component);
+  const DefaultComp = h(Comp, attrs);
+  if (!rule)
+    return DefaultComp;
+  return h(
+    Popover,
+    {
+      overlayClassName: "edit-cell-rule-popover",
+      visible: !!popoverVisible,
+      ...getPopupContainer2 ? { getPopupContainer: getPopupContainer2 } : {}
+    },
+    {
+      default: () => DefaultComp,
+      content: () => ruleMessage
+    }
+  );
+};
+const basicProps$1 = {
+  value: {
+    type: [String, Number, Boolean, Object],
+    default: ""
+  },
+  record: {
+    type: Object
+  },
+  column: {
+    type: Object,
+    default: () => ({})
+  },
+  index: Number
+};
+const _hoisted_1$a = { class: "editable-cell" };
+const _sfc_main$i = /* @__PURE__ */ defineComponent$1({
+  __name: "EditTableCell",
+  props: basicProps$1,
+  setup(__props) {
+    const props2 = __props;
+    const { getUiSize } = useHeader();
+    const { t } = useI18n("UI");
+    const { editRule, align = "left" } = props2.column;
+    const table = getTableInstance();
+    const ruleMessage = ref("");
+    const ruleVisible = ref(false);
+    const optionsRef = ref([]);
+    const currentValueRef = ref(props2.value);
+    const getComponent = computed(() => props2.column?.editComponent || "Input");
+    const getRuleVisible = computed(() => {
+      return unref(ruleMessage) && unref(ruleVisible);
+    });
+    const getWrapperClass = computed(() => {
+      return `edit-cell-align-${align}`;
+    });
+    const getIsCheckComp = computed(() => {
+      const component = unref(getComponent);
+      return ["Checkbox", "Switch"].includes(component);
+    });
+    const createPlaceholderMessage = (component) => {
+      if (component.includes("Input")) {
+        return t("PLEASE_INPUT");
+      }
+      return t("PLEASE_SELECT");
+    };
+    const setTableValue = () => {
+      props2.record[props2.column.dataIndex] = unref(currentValueRef);
+    };
+    const getComponentProps = computed(() => {
+      const isCheckValue = unref(getIsCheckComp);
+      const valueField = isCheckValue ? "checked" : "value";
+      const val = unref(currentValueRef);
+      const value = isCheckValue ? isNumber(val) && isBoolean(val) ? val : !!val : val;
+      let compProps = props2.column?.editComponentProps ?? {};
+      const { record, column, index: index2 } = props2;
+      if (isFunction(compProps)) {
+        compProps = compProps({ text: val, record, column, index: index2 }) ?? {};
+      }
+      if (unref(getComponent) === "InputNumber") {
+        compProps = {
+          formatter: (value2) => `${value2}`.replace(/[1-9]\d{0,2}(?=(\d{3})+$)/g, "$&,"),
+          parser: (value2) => value2.replace(/\$\s?|(,*)/g, ""),
+          ...compProps
+        };
+      }
+      return {
+        size: "small",
+        dropdownClassName: unref(getUiSize),
+        getPopupContainer: () => document.body,
+        placeholder: createPlaceholderMessage(unref(getComponent)),
+        ...omit(compProps, "onChange"),
+        [valueField]: value
+      };
+    });
+    async function handleChange(e) {
+      const component = unref(getComponent);
+      if (component === "Checkbox") {
+        currentValueRef.value = e.target.checked;
+      } else if (e?.target && Reflect.has(e.target, "value")) {
+        currentValueRef.value = e.target.value;
+      } else {
+        currentValueRef.value = e;
+      }
+      const onChange = unref(getComponentProps)?.onChange;
+      if (onChange && isFunction(onChange))
+        onChange(...arguments);
+      setTableValue();
+      table.emits?.("edit-change", {
+        column: props2.column,
+        value: unref(currentValueRef),
+        record: toRaw(props2.record),
+        index: props2.index
+      });
+      handleSubmitRule();
+    }
+    async function handleSubmitRule() {
+      const { column, record } = props2;
+      const { editRule: editRule2 } = column;
+      const currentValue = unref(currentValueRef);
+      if (editRule2) {
+        if (isBoolean(editRule2) && !currentValue && !isNumber(currentValue)) {
+          ruleVisible.value = true;
+          const component = unref(getComponent);
+          ruleMessage.value = createPlaceholderMessage(component);
+          return false;
+        }
+        if (isFunction(editRule2)) {
+          const res = await editRule2(currentValue, record);
+          if (!!res) {
+            ruleMessage.value = res;
+            ruleVisible.value = true;
+            return false;
+          }
+        }
+      }
+      ruleMessage.value = "";
+      return true;
+    }
+    function handleOptionsChange(options) {
+      optionsRef.value = options;
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$a, [
+        createVNode(unref$1(CellComponent), mergeProps({ ref: "elRef" }, unref$1(getComponentProps), {
+          component: _ctx.column?.editComponent,
+          popoverVisible: unref$1(getRuleVisible),
+          rule: unref$1(editRule),
+          ruleMessage: unref$1(ruleMessage),
+          class: unref$1(getWrapperClass),
+          onChange: handleChange,
+          onOptionsChange: handleOptionsChange
+        }), null, 16, ["component", "popoverVisible", "rule", "ruleMessage", "class"])
+      ]);
+    };
+  }
+});
+function renderEditCell(column) {
+  return ({ text: value, record, index: index2 }) => {
+    record.onValid = async () => {
+      if (isArray(record?.validCbs)) {
+        const validFns = (record?.validCbs || []).map((fn) => fn());
+        const res = await Promise.all(validFns);
+        return res.every((item) => !!item);
+      }
+      return false;
+    };
+    record.onEdit = async (edit, submit = false) => {
+      if (!submit) {
+        record.editable = edit;
+      }
+      if (!edit && submit) {
+        if (!await record.onValid())
+          return false;
+        const res = await record.onSubmitEdit?.();
+        if (res) {
+          record.editable = false;
+          return true;
+        }
+        return false;
+      }
+      if (!edit && !submit) {
+        record.onCancelEdit?.();
+      }
+      return true;
+    };
+    return h(_sfc_main$i, {
+      value,
+      record,
+      column,
+      index: index2
+    });
+  };
+}
+const INDEX_FLAG = "INDEX";
+const ACTION_COLUMN = "ACTION";
+function handleItem(item, ellipsis) {
+  const { appConf } = useAppStore();
+  const { align } = appConf.ui.table;
+  const { key, dataIndex, children } = item;
+  item.align = item.align || align;
+  if (ellipsis) {
+    if (!key)
+      item.key = dataIndex && dataIndex.toString();
+    if (!isBoolean(item.ellipsis)) {
+      item = Object.assign(item, {
+        ellipsis
+      });
+    }
+  }
+  if (children && children.length) {
+    handleChildren(children, !!ellipsis);
+  }
+}
+function handleChildren(children, ellipsis) {
+  if (!children)
+    return;
+  children.forEach((item) => {
+    const { children: children2 } = item;
+    handleItem(item, ellipsis);
+    handleChildren(children2, ellipsis);
+  });
+}
+function handleIndexColumn(propsRef, getPaginationRef, columns) {
+  const { getIsZH } = useHeader();
+  const { t } = useI18n("UI");
+  const { showIndexColumn, indexColumnProps, isTreeTable } = unref$1(propsRef);
+  let pushIndexColumns = false;
+  if (unref$1(isTreeTable)) {
+    return;
+  }
+  columns.forEach(() => {
+    const indIndex = columns.findIndex((column) => column.flag === INDEX_FLAG);
+    if (showIndexColumn) {
+      pushIndexColumns = indIndex === -1;
+    } else if (!showIndexColumn && indIndex !== -1) {
+      columns.splice(indIndex, 1);
+    }
+  });
+  if (!pushIndexColumns)
+    return;
+  const isFixedLeft = columns.some((item) => item.fixed === "left");
+  columns.unshift({
+    flag: INDEX_FLAG,
+    width: unref$1(getIsZH) ? 50 : 70,
+    title: t("NUMBER"),
+    align: "center",
+    customRender: ({ index: index2 }) => {
+      const getPagination = unref$1(getPaginationRef);
+      const { appConf } = useAppStore();
+      const { defaultPageSize } = appConf.ui.table;
+      if (isBoolean(getPagination)) {
+        return `${index2 + 1}`;
+      }
+      const { current = 1, pageSize = defaultPageSize } = getPagination;
+      return ((current < 1 ? 1 : current) - 1) * pageSize + index2 + 1;
+    },
+    ...isFixedLeft ? {
+      fixed: "left"
+    } : {},
+    ...indexColumnProps
+  });
+}
+function handleActionColumn(propsRef, columns) {
+  const { getIsZH } = useHeader();
+  const { t } = useI18n("UI");
+  const { operations = [
+    { name: t("EDIT"), icon: "mdi:text-box-edit-outline", onClick: unref$1(propsRef).onUpdate },
+    { name: t("DELETE"), icon: "mdi:delete-outline", onClick: unref$1(propsRef).onDelete }
+  ] } = unref$1(propsRef);
+  if (!operations || isObject(operations) && !operations?.btns || isArray(operations) && !operations)
+    return;
+  const hasIndex = columns.findIndex((column) => column.flag === ACTION_COLUMN);
+  if (hasIndex === -1) {
+    let column = isObject(operations) ? operations : isArray(operations) ? { btns: operations } : {};
+    let expand = column.expand ? column.expand : false;
+    let columnObj = {
+      fixed: "right",
+      title: t("ACTIONS"),
+      align: "center",
+      expand,
+      width: `${expand ? column.btns.length * 30 + 40 : unref$1(getIsZH) ? 70 : 90}px`,
+      ...column,
+      flag: ACTION_COLUMN
+    };
+    columns.push({
+      ...columnObj,
+      customRender: ({ record, index: index2 }) => {
+        return h(
+          _sfc_main$j,
+          omit({
+            ...columnObj,
+            record,
+            index: index2
+          }, "align")
+        );
+      }
+    });
+  }
+}
+function sortFixedColumn(columns) {
+  const fixedLeftColumn = [];
+  const fixedRightColumn = [];
+  const defaultColumn = [];
+  for (let column of columns) {
+    if (column.defaultHidden)
+      continue;
+    if (column.fixed === "left") {
+      fixedLeftColumn.push(column);
+      continue;
+    }
+    if (column.fixed === "right") {
+      fixedRightColumn.push(column);
+      continue;
+    }
+    defaultColumn.push(column);
+  }
+  return [
+    ...fixedLeftColumn,
+    ...defaultColumn,
+    ...fixedRightColumn
+  ];
+}
+function useColumns(propsRef, getPaginationRef, tableElRef) {
+  const columnsRef = ref(unref$1(propsRef).columns);
+  let cacheColumns = unref$1(propsRef).columns;
+  const getColumnsRef = computed(() => {
+    const columns = cloneDeep(unref$1(columnsRef));
+    const { ellipsis } = unref$1(propsRef);
+    columns.forEach((it, index2) => {
+      it.class = it.class ?? "";
+      if (!it.class.split(" ").includes("__column")) {
+        it.class = `${it.class} __column`;
+      }
+      const { customRender, render } = it;
+      if (it.sorter) {
+        it.sorter = {
+          multiple: Number(it.sorter)
+        };
+      }
+      handleItem(
+        it,
+        Reflect.has(it, "ellipsis") ? !!it.ellipsis : !!ellipsis && !render && !customRender
+      );
+    });
+    handleIndexColumn(propsRef, getPaginationRef, columns);
+    handleActionColumn(propsRef, columns);
+    return columns;
+  });
+  const getViewColumns = computed(() => {
+    const viewColumns = sortFixedColumn(unref$1(getColumnsRef));
+    const columns = cloneDeep(viewColumns);
+    return columns.filter((column) => isIfShow(column)).map((column) => {
+      if (column.edit) {
+        column.customRender = renderEditCell(column);
+      }
+      return column;
+    });
+  });
+  function isIfShow(column) {
+    const ifShow = column.show;
+    return isBoolean(ifShow) ? ifShow : isFunction(ifShow) ? ifShow(column) : true;
+  }
+  const resizeFn = useDebounceFn(addResize, 100);
+  function addResize() {
+    const { resizable, minWidth = 50, maxWidth = 700 } = unref$1(propsRef);
+    let els = unref$1(tableElRef)?.$el.querySelectorAll(".__column"), allWidth = 0, columnAllWidth = 0, noWidthNum = 0, avgWidth = 0;
+    for (let i = 0; i < els?.length; i++) {
+      allWidth += els[i].offsetWidth ?? 0;
+    }
+    columnsRef.value.forEach((it) => {
+      if (isIfShow(it)) {
+        if (it.width) {
+          columnAllWidth += parseInt(`${it.width}`);
+        } else {
+          noWidthNum++;
+        }
+      }
+    });
+    avgWidth = (allWidth - columnAllWidth) / noWidthNum;
+    columnsRef.value.forEach((it) => {
+      it.width = it.width || avgWidth - 1;
+      if (Reflect.has(it, "resizable") ? !!it.resizable : resizable) {
+        it.resizable = true;
+        it.minWidth = it.minWidth || minWidth;
+        it.maxWidth = it.maxWidth || maxWidth;
+      }
+    });
+  }
+  function getColumns(opt) {
+    const { ignoreIndex, ignoreAction, sort } = opt || {};
+    let columns = toRaw(unref$1(getColumnsRef));
+    if (ignoreIndex) {
+      columns = columns.filter((it) => it.flag !== INDEX_FLAG);
+    }
+    if (ignoreAction) {
+      columns = columns.filter((it) => it.flag !== ACTION_COLUMN);
+    }
+    if (sort) {
+      columns = sortFixedColumn(columns);
+    }
+    return columns;
+  }
+  function setColumns(columnList = []) {
+    const columns = cloneDeep(columnList);
+    if (!isArray(columns) || !columns.length) {
+      columnsRef.value = [];
+      return;
+    }
+    const cacheKeys = cacheColumns.map((item) => item.dataIndex);
+    if (!isString(columns[0])) {
+      columnsRef.value = columns;
+    } else {
+      const columnKeys = columns;
+      const newColumns = [];
+      cacheColumns.forEach((it) => {
+        newColumns.push({
+          ...it,
+          show: true,
+          defaultHidden: !columnKeys.includes(it.dataIndex || it.key)
+        });
+      });
+      if (!isEqual(cacheKeys, columns)) {
+        newColumns.sort((prev, next) => {
+          return columnKeys.indexOf(prev.dataIndex) - columnKeys.indexOf(next.dataIndex);
+        });
+      }
+      columnsRef.value = newColumns;
+      cacheColumns = [...newColumns];
+    }
+  }
+  function setColumnsByDataIndex(dataIndex, value) {
+    if (!dataIndex || !value)
+      return;
+    cacheColumns.forEach((item) => {
+      if (item.dataIndex === dataIndex) {
+        Object.assign(item, value);
+        return;
+      }
+    });
+    columnsRef.value = [...cacheColumns];
+  }
+  function getCacheColumns() {
+    return cacheColumns;
+  }
+  watch(
+    () => unref$1(propsRef).columns,
+    (columns) => {
+      columnsRef.value = columns;
+      cacheColumns = columns.filter((it) => !it.flag) ?? [];
+      nextTick(() => resizeFn());
+    }
+  );
+  return {
+    getViewColumns,
+    getColumnsRef,
+    getColumns,
+    setColumns,
+    setColumnsByDataIndex,
+    getCacheColumns
+  };
+}
+function useCustomRow(propsRef, { setSelectedRowKeys, getSelectedRowKeys, clearSelectedRowKeys, emits }) {
+  const customRow = (record, index2) => {
+    return {
+      onClick: (e) => {
+        e?.stopPropagation();
+        function handleClick() {
+          const { rowSelection, rowKey, clickToSelectRow } = unref$1(propsRef);
+          if (!rowSelection || !clickToSelectRow)
+            return;
+          const keys = getSelectedRowKeys();
+          const key = record[rowKey];
+          if (!key)
+            return;
+          const isCheckbox = rowSelection.type === "checkbox";
+          const isRadio = rowSelection.type === "radio";
+          if (clickToSelectRow) {
+            if (isCheckbox) {
+              if (keys.includes(key)) {
+                setSelectedRowKeys(keys.filter((it) => it !== key));
+              } else {
+                setSelectedRowKeys([...keys, key]);
+              }
+            }
+            if (isRadio)
+              setSelectedRowKeys([key]);
+            return;
+          }
+          if (isCheckbox) {
+            const tr = e.composedPath?.().find((dom) => dom.tagName === "TR");
+            if (!tr)
+              return;
+            const checkBox = tr.querySelector("input[type=checkbox]");
+            if (!checkBox || checkBox.hasAttribute("disabled"))
+              return;
+            if (!keys.includes(key)) {
+              setSelectedRowKeys([...keys, key]);
+              return;
+            }
+            const keyIndex = keys.findIndex((item) => item === key);
+            keys.splice(keyIndex, 1);
+            setSelectedRowKeys(keys);
+            return;
+          }
+          if (isRadio) {
+            if (!keys.includes(key)) {
+              if (keys.length) {
+                clearSelectedRowKeys();
+              }
+              setSelectedRowKeys([key]);
+              return;
+            }
+            clearSelectedRowKeys();
+          }
+        }
+        handleClick();
+        emits("row-click", record, index2, e);
+      },
+      onDblclick: (event) => {
+        emits("row-dbClick", record, index2, event);
+      },
+      onContextmenu: (event) => {
+        emits("row-contextmenu", record, index2, event);
+      },
+      onMouseenter: (event) => {
+        emits("row-mouseenter", record, index2, event);
+      },
+      onMouseleave: (event) => {
+        emits("row-mouseleave", record, index2, event);
+      }
+    };
+  };
+  return {
+    customRow
+  };
+}
+function useDataSource(propsRef, {
+  getPaginationInfo,
+  setPagination,
+  clearSelectedRowKeys
+}) {
+  const dataSourceRef = ref$1([]);
+  watch$1(
+    () => unref$1(propsRef).dataSource,
+    (dataSource) => {
+      dataSource && (dataSourceRef.value = dataSource);
+    },
+    {
+      immediate: true
+    }
+  );
+  const getDataSourceRef = computed$1(() => {
+    return unref$1(dataSourceRef);
+  });
+  function handleTableChange(pagination, filters, sorter) {
+    const { sortFn, filterFn, onTableChange: onTableChange2, clearSelectOnPageChange } = unref$1(propsRef);
+    const { appConf: appConf2 } = useAppStore();
+    const { current = 1, pageSize = appConf2.ui.table.defaultPageSize } = pagination;
+    if (clearSelectOnPageChange) {
+      clearSelectedRowKeys();
+    }
+    setPagination(pagination);
+    const params = {};
+    if (sorter && isFunction(sortFn)) {
+      params.sortInfo = sortFn(sorter);
+    }
+    if (filters && isFunction(filterFn)) {
+      params.filterInfo = filterFn(filters);
+    }
+    return onTableChange2({
+      pagination: {
+        current,
+        pageSize
+      },
+      sort: sorter,
+      filter: toRaw$1(unref$1(params.filterInfo)),
+      showBtnLoading: false
+    });
+  }
+  const { defSort, onTableChange } = unref$1(propsRef);
+  const { appConf } = useAppStore();
+  onTableChange({
+    pagination: {
+      current: 1,
+      pageSize: appConf.ui.table.defaultPageSize
+    },
+    sort: defSort,
+    filter: null,
+    showBtnLoading: false
+  }, false);
+  function updateTableDataRecord(rowKey, record) {
+    const row = findTableDataRecord(rowKey);
+    if (row) {
+      for (const field in record) {
+        row[field] = record[field];
+      }
+      return row;
+    }
+  }
+  function findTableDataRecord(rowKey) {
+    if (!dataSourceRef.value || dataSourceRef.value.length == 0 || !rowKey)
+      return;
+    const { childrenColumnName = "children" } = unref$1(propsRef);
+    const findRow = (array) => {
+      let ret;
+      array.some(function iter(r) {
+        if (Reflect.has(r, unref$1(propsRef).rowKey) && r[unref$1(propsRef).rowKey] === rowKey) {
+          ret = r;
+          return true;
+        }
+        return r[childrenColumnName] && r[childrenColumnName].some(iter);
+      });
+      return ret;
+    };
+    return findRow(dataSourceRef.value);
+  }
+  return {
+    getDataSourceRef,
+    handleTableChange,
+    updateTableDataRecord,
+    findTableDataRecord
+  };
+}
+function useLabelWidth(schemaItemRef, propsRef) {
+  const { getIsZH } = useHeader();
+  const { appConf } = useAppStore();
+  return computed(() => {
+    const { labelWidth, enLabelWidth, labelCol = {}, wrapperCol = {} } = unref(schemaItemRef);
+    const {
+      labelWidth: gLabelWidth,
+      enLabelWidth: gEnLabelWidth,
+      labelCol: glabelCol = {},
+      wrapperCol: gwrapperCol = {},
+      layout = appConf.ui.form.layout
+    } = unref(propsRef);
+    let width = (unref(getIsZH) ? labelWidth ?? gLabelWidth : enLabelWidth ?? gEnLabelWidth) ?? labelWidth ?? gLabelWidth ?? 0;
+    const labelcol = { ...glabelCol, ...labelCol };
+    const wrapcol = { ...gwrapperCol, ...wrapperCol };
+    width = isNumber(width) ? `${width}px` : width;
+    return {
+      labelCol: {
+        style: { width },
+        ...labelcol
+      },
+      wrapperCol: {
+        style: { width: layout === "vertical" ? "100%" : `calc(100% - ${width})` },
+        ...wrapcol
+      }
+    };
+  });
+}
+const SINGLE_DATA_TYPE = ["DatePicker", "MonthPicker", "WeekPicker", "TimePicker"];
+function createPlaceholder(component) {
+  const { t } = useI18n("UI");
+  if (component.includes("Input") || component.includes("Complete")) {
+    return t("PLEASE_INPUT");
+  }
+  if (component.includes("Picker") || component.includes("Select") || component.includes("Cascader") || component.includes("Checkbox") || component.includes("Radio") || component.includes("Switch")) {
+    return t("PLEASE_SELECT");
+  }
+  if (component.includes("Icon")) {
+    return t("PLEASE_SET_ICON");
+  }
+  return "";
+}
+function setComponentRuleType(rule, component, valueFormat) {
+  if (SINGLE_DATA_TYPE.includes(component)) {
+    rule.type = valueFormat ? "string" : "object";
+  } else if (["RangePicker", "Upload", "CheckboxGroup", "TimePicker"].includes(component)) {
+    rule.type = "array";
+  } else if (["InputNumber"].includes(component)) {
+    rule.type = "number";
+  }
+}
+function useFormValue(props2, key = "value", changeEvent = "change", emitData) {
+  const instance = getCurrentInstance$1();
+  const emit = instance?.emit;
+  const innerState = reactive$1({
+    value: props2[key]
+  });
+  const defaultState = readonly(innerState);
+  const setState = (val) => {
+    innerState.value = val;
+    nextTick$1(() => {
+      emit?.(changeEvent, val, ...toRaw$1(unref$1(emitData)) || []);
+    });
+  };
+  watchEffect$1(() => {
+    innerState.value = props2[key];
+  });
+  const state = computed$1({
+    get() {
+      return innerState.value;
+    },
+    set(value) {
+      if (isEqual(value, defaultState.value))
+        return;
+      innerState.value = value;
+      nextTick$1(() => {
+        emit?.(changeEvent, value, ...toRaw$1(unref$1(emitData)) || []);
+      });
+    }
+  });
+  return [state, setState, defaultState];
+}
+const _sfc_main$h = /* @__PURE__ */ defineComponent$1({
+  __name: "radioButton",
+  props: {
+    value: {
+      type: [String, Number, Boolean]
+    },
+    options: {
+      type: Array,
+      default: () => []
+    }
+  },
+  setup(__props) {
+    const props2 = __props;
+    const attrs = useAttrs();
+    const [state] = useFormValue(props2);
+    const getOptions = computed$1(() => {
+      const { options } = props2;
+      if (!options || options?.length === 0)
+        return [];
+      const isStringArr = options.some((item) => isString(item));
+      if (!isStringArr)
+        return options;
+      return options.map((item) => ({ label: item, value: item }));
+    });
+    return (_ctx, _cache) => {
+      const _component_ARadioButton = RadioButton;
+      const _component_ARadioGroup = RadioGroup;
+      return openBlock(), createBlock(_component_ARadioGroup, mergeProps(unref$1(attrs), {
+        value: unref$1(state),
+        "onUpdate:value": _cache[0] || (_cache[0] = ($event) => isRef(state) ? state.value = $event : null),
+        "button-style": "solid"
+      }), {
+        default: withCtx(() => [
+          (openBlock(true), createElementBlock(Fragment, null, renderList(unref$1(getOptions), (item) => {
+            return openBlock(), createBlock(_component_ARadioButton, {
+              key: `${item.value}`,
+              value: item.value,
+              disabled: item.disabled
+            }, {
+              default: withCtx(() => [
+                createTextVNode(toDisplayString(item.label), 1)
+              ]),
+              _: 2
+            }, 1032, ["value", "disabled"]);
+          }), 128))
+        ]),
+        _: 1
+      }, 16, ["value"]);
+    };
+  }
+});
+const _hoisted_1$9 = { class: "input-with-dialog" };
+const _sfc_main$g = /* @__PURE__ */ defineComponent$1({
+  __name: "formInputUseDialog",
+  setup(__props) {
+    const { t } = useI18n("UI");
+    const attrs = useAttrs$1();
+    const bindProps = computed$1(() => {
+      return {
+        ...omit(attrs, [
+          "formValues"
+        ]),
+        disabled: true
+      };
+    });
+    function onClickInput() {
+      const { model, schema = {} } = attrs.formValues;
+      if (!schema.openDialog || !isFunction(schema.openDialog)) {
+        error(t("MUSE_FUNCTION"));
+        return;
+      }
+      schema.openDialog(model);
+    }
+    function clearProps() {
+      const { model, schema = {} } = attrs.formValues;
+      [...schema.linkProps, schema.name].forEach((it) => model[it] = null);
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$9, [
+        createElementVNode("div", { onClick: onClickInput }, [
+          createVNode(unref$1(Input), normalizeProps(guardReactiveProps(unref$1(bindProps))), null, 16)
+        ]),
+        unref$1(attrs).formValues?.schema?.linkProps?.length ? (openBlock(), createElementBlock("i", {
+          key: 0,
+          class: "i mdi:close-circle",
+          onClick: clearProps
+        })) : createCommentVNode("", true)
+      ]);
+    };
+  }
+});
+const components = {
+  Input,
+  InputWithDialog: _sfc_main$g,
+  InputTextArea: Input.TextArea,
+  InputSearch: Input.Search,
+  InputGroup: Input.Group,
+  InputPassword: Input.Password,
+  Select,
+  TreeSelect,
+  Radio,
+  RadioGroup: Radio.Group,
+  RadioButtonGroup: _sfc_main$h,
+  Checkbox,
+  CheckboxGroup: Checkbox.Group,
+  AutoComplete,
+  Cascader,
+  DatePicker,
+  MonthPicker: DatePicker.MonthPicker,
+  WeekPicker: DatePicker.WeekPicker,
+  RangePicker: DatePicker.RangePicker,
+  InputNumber,
+  Switch,
+  TimePicker,
+  Slider,
+  Rate,
+  Divider
+};
+const componentMap = /* @__PURE__ */ new Map();
+for (let item in components) {
+  componentMap.set(item, components[item]);
+}
+function _isSlot$1(s) {
+  return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s);
+}
+defineComponent({
+  name: "FormItem",
+  inheritAttrs: false,
+  props: {
+    schema: {
+      type: Object,
+      default: () => ({})
+    },
+    formProps: {
+      type: Object,
+      default: () => ({})
+    },
+    defaultValues: {
+      type: Object,
+      default: () => ({})
+    },
+    formModel: {
+      type: Object,
+      default: () => ({})
+    },
+    setFormModel: {
+      type: Function
+    },
+    formActionType: {
+      type: Object
+    }
+  },
+  setup(props2, {
+    emit,
+    slots
+  }) {
+    const {
+      getSlot
+    } = useSlots$1();
+    const {
+      t
+    } = useI18n("UI");
+    const {
+      getUiSize
+    } = useHeader();
+    const {
+      appConf
+    } = useAppStore();
+    const {
+      schema,
+      formProps
+    } = toRefs(props2);
+    const getValues = computed(() => {
+      const {
+        defaultValues,
+        formModel,
+        schema: schema2
+      } = props2;
+      let name = schema2.name;
+      return {
+        name: isArray(name) ? name.join("-") : name,
+        model: formModel,
+        schema: schema2,
+        values: {
+          ...defaultValues,
+          ...formModel
+        }
+      };
+    });
+    const getShow = computed(() => {
+      const {
+        show = true,
+        isAdvanced = true
+      } = props2.schema;
+      if (!isAdvanced) {
+        return false;
+      }
+      if (isFunction(show)) {
+        return show(unref(getValues).model);
+      }
+      return show;
+    });
+    const getComponentProps = computed(() => {
+      const {
+        schema: schema2
+      } = props2;
+      let {
+        props: cProps = {}
+      } = schema2;
+      if (isFunction(cProps)) {
+        cProps = cProps(unref(getValues).model) ?? {};
+      }
+      if (schema2.component === "Divider") {
+        cProps = Object.assign({
+          type: "horizontal"
+        }, cProps, {
+          orientation: "left"
+        });
+      }
+      return cProps;
+    });
+    function renderItem() {
+      const {
+        component,
+        slot,
+        render,
+        name,
+        colon = appConf.ui.form.colon,
+        suffix,
+        prefix
+      } = props2.schema;
+      const {
+        labelCol,
+        wrapperCol
+      } = unref(useLabelWidth(schema, formProps));
+      const getContent = () => {
+        const value = unref(getValues);
+        let _con = slot ? getSlot(slots, slot, value.model) : render ? render(value.model) : renderFormItem();
+        return component === "InputGroup" || component === "Icon" ? createVNode(FormItem, {
+          "class": "m-0"
+        }, _isSlot$1(_con) ? _con : {
+          default: () => [_con]
+        }) : _con;
+      };
+      const getSuffix = () => {
+        return isFunction(suffix) ? suffix(unref(getValues).model) : suffix;
+      };
+      const getPrefix = () => {
+        return isFunction(prefix) ? prefix(unref(getValues).model) : prefix;
+      };
+      return createVNode(Form.Item, {
+        "name": isArray(name) ? name.join("-") : name,
+        "colon": colon,
+        "class": [unref(getUiSize), {
+          "suffix-item": !!suffix
+        }],
+        "label": renderLabel(),
+        "rules": handleRules(),
+        "labelCol": labelCol,
+        "wrapperCol": wrapperCol
+      }, {
+        default: () => [createVNode("div", {
+          "style": "display:flex"
+        }, [!!prefix && createVNode("span", {
+          "class": "prefix px-2"
+        }, [getPrefix()]), createVNode("div", {
+          "style": "flex:1; width: 100%;"
+        }, [getContent()]), !!suffix && createVNode("span", {
+          "class": "suffix px-2"
+        }, [getSuffix()])])]
+      });
+    }
+    function renderLabel() {
+      const {
+        label,
+        toolTip,
+        subLabel,
+        toolTipProps = {}
+      } = props2.schema;
+      const renderLabel2 = subLabel ? createVNode("span", null, [createTextVNode(" "), label, createTextVNode(" "), createVNode("span", {
+        "class": "text-secondary opacity-50"
+      }, [createTextVNode("("), subLabel, createTextVNode(")")])]) : label;
+      const _toolTip = isFunction(toolTip) ? toolTip(unref(getValues).model) : toolTip;
+      const _toolTipProps = {
+        title: renderLabel2,
+        autoAdjustOverflow: true,
+        placement: "top",
+        ...toolTipProps
+      };
+      return _toolTip ? createVNode("span", null, [createVNode(Tooltip$1, _toolTipProps, _isSlot$1(renderLabel2) ? renderLabel2 : {
+        default: () => [renderLabel2]
+      })]) : renderLabel2;
+    }
+    function renderFormItem() {
+      const {
+        schema: schema2,
+        formModel,
+        formActionType
+      } = props2;
+      const {
+        component,
+        name,
+        changeEvent = "change",
+        valueField,
+        renderComponent,
+        props: sProps
+      } = props2.schema;
+      const isCheck = component && ["Switch", "Checkbox"].includes(component);
+      const eventKey = `on${upperFirst(changeEvent)}`;
+      const _sProps = isFunction(sProps) ? sProps(formModel) : sProps;
+      const on2 = {
+        [eventKey]: (...args) => {
+          const [e] = args;
+          const target = e ? e.target : null;
+          const value = target ? isCheck ? target.checked : target.value : e;
+          if (isString(name)) {
+            props2.setFormModel(name, value);
+          } else if (isArray(name)) {
+            name.map((key) => props2.setFormModel(key, value));
+          }
+          if (_sProps && _sProps[eventKey])
+            _sProps[eventKey](...args, formModel);
+        }
+      };
+      for (let it in _sProps) {
+        if (it.startsWith("on") && it !== eventKey) {
+          on2[it] = (...args) => {
+            _sProps[it](...args, formModel);
+          };
+        }
+      }
+      const getDisable = computed(() => {
+        const {
+          disabled: gDisabled
+        } = props2.formProps;
+        const {
+          disabled
+        } = props2.schema;
+        const {
+          disabled: itemDisabled = false
+        } = unref(getComponentProps);
+        let _disabled = !!gDisabled || itemDisabled;
+        if (isBoolean(disabled))
+          _disabled = disabled;
+        if (isFunction(disabled))
+          _disabled = disabled(unref(getValues).model);
+        return _disabled;
+      });
+      const itemProps = {
+        allowClear: _sProps?.allowClear ?? appConf.ui.form.allowClear,
+        size: unref(getUiSize) === UiSize.MIDDLE ? "default" : unref(getUiSize),
+        ...unref(getComponentProps),
+        disabled: unref(getDisable)
+      };
+      if (component === "Select") {
+        {
+          itemProps.showSearch = true;
+          itemProps.optionFilterProp = "label";
+        }
+      }
+      if (!itemProps.disabled && component !== "RangePicker") {
+        itemProps.placeholder = unref(getComponentProps)?.placeholder || createPlaceholder(component);
+      }
+      if (["DatePicker", "MonthPicker", "RangePicker"].includes(component)) {
+        itemProps.defaultValue = props2.formModel[name];
+      }
+      itemProps.codeName = name;
+      itemProps.formValues = unref(getValues);
+      if (["Select", "DatePicker", "MonthPicker", "WeekPicker", "RangePicker"].includes(component)) {
+        itemProps.dropdownClassName += ` ${unref(getUiSize)}`;
+      }
+      const bindValue = {
+        [valueField || (isCheck ? "checked" : "value")]: props2.formModel[name]
+      };
+      let compAttr = {
+        ...itemProps,
+        ...bindValue,
+        ...on2
+      };
+      const Comp = componentMap.get(component);
+      if (!renderComponent) {
+        return createVNode(Comp, compAttr, null);
+      }
+      const compSlot = isFunction(renderComponent) ? {
+        ...renderComponent(unref(getValues))
+      } : {
+        default: () => renderComponent
+      };
+      return createVNode(Comp, compAttr, _isSlot$1(compSlot) ? compSlot : {
+        default: () => [compSlot]
+      });
+    }
+    function handleRules() {
+      const {
+        rules: defaultRules = [],
+        component,
+        label,
+        dynamicRules,
+        required
+      } = props2.schema;
+      if (!component)
+        return [];
+      if (isFunction(dynamicRules)) {
+        return dynamicRules(unref(getValues).model);
+      }
+      const defaultMsg = createPlaceholder(component) + label;
+      let rules = cloneDeep(defaultRules);
+      const getRequired = isFunction(required) ? required(unref(getValues).model) : required;
+      function validator(rule, value) {
+        const msg = rule.message || defaultMsg;
+        if (value === void 0 || isNull(value) || Array.isArray(value) && value.length === 0 || typeof value === "string" && value.trim() === "" || typeof value === "object" && Reflect.has(value, "checked") && Reflect.has(value, "halfChecked") && Array.isArray(value.checked) && Array.isArray(value.halfChecked) && value.checked.length === 0 && value.halfChecked.length === 0) {
+          return Promise.reject(msg);
+        }
+        return Promise.resolve();
+      }
+      if (!rules || !rules.length) {
+        let _required = isBoolean(getRequired) ? getRequired : unref(getRequired);
+        rules = _required ? [{
+          required: _required,
+          validator
+        }] : [];
+      }
+      const requiredIndex = rules.findIndex((rule) => Reflect.has(rule, "required") && !Reflect.has(rule, "validator"));
+      if (requiredIndex !== -1) {
+        const rule = rules[requiredIndex];
+        if (!unref(getShow)) {
+          rule.required = false;
+        }
+        if (!Reflect.has(rule, "type")) {
+          rule.type = component === "InputNumber" ? "number" : "string";
+        }
+        rule.message = rule.message || defaultMsg;
+        if (component.includes("Input") || component.includes("Textarea")) {
+          rule.whitespace = true;
+        }
+        const valueFormat = unref(getComponentProps)?.valueFormat;
+        setComponentRuleType(rule, component, valueFormat);
+      }
+      const maxIndex = rules.findIndex((val) => val.max);
+      if (maxIndex !== -1 && !rules[maxIndex].validator) {
+        rules[maxIndex].message = rules[maxIndex].message || `\u6700\u5927\u503C\u4E3A${rules[maxIndex].max}`;
+      }
+      return rules;
+    }
+    return () => {
+      let _slot2;
+      const {
+        colSlot,
+        renderCol,
+        colProps,
+        component,
+        render,
+        slot
+      } = props2.schema;
+      const {
+        colProps: gColProps,
+        mode
+      } = props2.formProps;
+      let _colProps = colProps || gColProps || (mode === "search" ? appConf.ui.form.searchColspan : appConf.ui.form.dialogColspan);
+      const values = unref(getValues);
+      if (!component) {
+        if (!render && !renderCol && !slot) {
+          error(t("NEED_RENDER"));
+          return;
+        }
+      }
+      if (component === "Divider") {
+        let _slot;
+        let cprops = unref(getComponentProps);
+        const span = cprops?.span ?? 24;
+        return createVNode(Col, {
+          "span": span
+        }, {
+          default: () => [createVNode(Divider, cprops, _isSlot$1(_slot = renderLabel()) ? _slot : {
+            default: () => [_slot]
+          })]
+        });
+      }
+      const getContent = () => {
+        return colSlot ? getSlot(slots, colSlot, values) : renderCol ? renderCol(values) : renderItem();
+      };
+      return unref(getShow) && createVNode(Col, _colProps, _isSlot$1(_slot2 = getContent()) ? _slot2 : {
+        default: () => [_slot2]
+      });
+    };
+  }
+});
+const index$1 = "";
+const _hoisted_1$8 = {
+  key: 0,
+  className: "preIcon pr-1"
+};
+const _hoisted_2$2 = {
+  key: 0,
+  className: "preIcon pl-1"
+};
+const _hoisted_3$2 = { class: "text" };
+const _hoisted_4$2 = /* @__PURE__ */ createElementVNode("i", { class: "text-2xl i ic:baseline-arrow-drop-down" }, null, -1);
+const _hoisted_5$1 = [
+  _hoisted_4$2
+];
+const _sfc_main$f = /* @__PURE__ */ defineComponent$1({
+  __name: "FormButtons",
+  props: {
+    mode: {
+      type: String,
+      default: "search"
+    },
+    show: {
+      type: Boolean,
+      default: true
+    },
+    showAdvancedButton: {
+      type: Boolean,
+      default: true
+    },
+    minShowColumn: {
+      type: Number,
+      default: 2
+    },
+    buttonList: {
+      type: [Array],
+      default: []
+    },
+    isAdvanced: {
+      type: Boolean,
+      default: true
+    }
+  },
+  emits: ["handle-method"],
+  setup(__props, { emit: emits }) {
+    const props2 = __props;
+    const { t } = useI18n();
+    const advancedRef = ref(props2.isAdvanced);
+    let key = 0;
+    const showAdvanceRef = computed(() => {
+      return props2.mode === "search" ? props2.showAdvancedButton : false;
+    });
+    const colOpt = computed(() => {
+      let style = {
+        textAlign: "right"
+      };
+      if (props2.mode === "dialog") {
+        Object.assign(style, {
+          display: "inline-block"
+        });
+      }
+      return { style };
+    });
+    const getAdvanceClass = computed(() => {
+      return [
+        "basic-arrow",
+        { "basic-arrow--active": !advancedRef.value }
+      ];
+    });
+    const toggleAdvanced = () => {
+      advancedRef.value = !advancedRef.value;
+      dispatchResize();
+      emits("handle-method", advancedRef.value);
+    };
+    function handleBtnClick(button) {
+      if (button.onClick && isFunction(button.onClick)) {
+        button.onClick();
+      } else {
+        emits("handle-method", button);
+      }
+    }
+    watch(() => props2.isAdvanced, (v) => {
+      if (v) {
+        nextTick(() => toggleAdvanced());
+      }
+    }, {
+      immediate: true
+    });
+    watch(
+      () => props2.buttonList,
+      (v) => key = new Date().getTime(),
+      {
+        immediate: true,
+        deep: true
+      }
+    );
+    return (_ctx, _cache) => {
+      const _component_AButton = Button;
+      const _component_AFormItem = FormItem$1;
+      const _component_ACol = Col$1;
+      const _directive_icon = resolveDirective("icon");
+      const _directive_auth = resolveDirective("auth");
+      return __props.show ? (openBlock(), createBlock(_component_ACol, normalizeProps(mergeProps({ key: 0 }, unref$1(colOpt))), {
+        default: withCtx(() => [
+          createVNode(_component_AFormItem, {
+            class: "dt-form-btns",
+            style: normalizeStyle({
+              "margin-bottom": __props.mode === "search" ? "16px" : "0px"
+            })
+          }, {
+            default: withCtx(() => [
+              (openBlock(true), createElementBlock(Fragment, null, renderList(__props.buttonList, (button) => {
+                return openBlock(), createElementBlock(Fragment, null, [
+                  (button.show === void 0 ? true : button.show) ? withDirectives((openBlock(), createBlock(_component_AButton, {
+                    type: button.type,
+                    class: normalizeClass(button.class),
+                    loading: button.loading,
+                    disabled: button.disabled,
+                    key: unref$1(key),
+                    onClick: ($event) => handleBtnClick(button)
+                  }, {
+                    icon: withCtx(() => [
+                      button.preIcon ? withDirectives((openBlock(), createElementBlock("span", _hoisted_1$8, null, 512)), [
+                        [_directive_icon, button.preIcon]
+                      ]) : createCommentVNode("", true)
+                    ]),
+                    default: withCtx(() => [
+                      createTextVNode(" " + toDisplayString(unref$1(t)(button.name)) + " ", 1),
+                      button.postIcon ? withDirectives((openBlock(), createElementBlock("span", _hoisted_2$2, null, 512)), [
+                        [_directive_icon, button.postIcon]
+                      ]) : createCommentVNode("", true)
+                    ]),
+                    _: 2
+                  }, 1032, ["type", "class", "loading", "disabled", "onClick"])), [
+                    [_directive_auth, button.auth]
+                  ]) : createCommentVNode("", true)
+                ], 64);
+              }), 256)),
+              unref$1(showAdvanceRef) ? (openBlock(), createBlock(_component_AButton, {
+                key: 0,
+                type: "link",
+                class: "advanced",
+                onClick: toggleAdvanced
+              }, {
+                default: withCtx(() => [
+                  createElementVNode("span", _hoisted_3$2, toDisplayString(unref$1(advancedRef) ? unref$1(t)("UI.ADVANCED") : unref$1(t)("UI.EXPAND")), 1),
+                  createElementVNode("span", {
+                    class: normalizeClass(unref$1(getAdvanceClass))
+                  }, _hoisted_5$1, 2)
+                ]),
+                _: 1
+              })) : createCommentVNode("", true)
+            ]),
+            _: 1
+          }, 8, ["style"])
+        ]),
+        _: 1
+      }, 16)) : createCommentVNode("", true);
+    };
+  }
+});
+const _hoisted_1$7 = { key: 0 };
+const _sfc_main$e = /* @__PURE__ */ defineComponent$1({
+  __name: "Fullscreen",
+  setup(__props) {
+    const { t } = useI18n("UI");
+    const table = getTableInstance();
+    const wrapEl = ref(null);
+    const { toggle, isFullscreen } = useFullscreen(wrapEl);
+    watch(
+      () => table.tableElRef.value,
+      (v) => {
+        const getParent = (el) => {
+          if (!el || !el.parentNode)
+            return null;
+          if (el.parentNode.className?.indexOf("dt-layout-content") !== -1) {
+            wrapEl.value = el.parentNode;
+          } else {
+            getParent(el.parentNode);
+          }
+        };
+        getParent(v.$el);
+      }
+    );
+    return (_ctx, _cache) => {
+      const _component_ATooltip = Tooltip;
+      return openBlock(), createBlock(_component_ATooltip, { placement: "top" }, {
+        title: withCtx(() => [
+          !unref$1(isFullscreen) ? (openBlock(), createElementBlock("span", _hoisted_1$7, toDisplayString(unref$1(t)("FULLSCREEN")), 1)) : createCommentVNode("", true)
+        ]),
+        default: withCtx(() => [
+          createElementVNode("span", {
+            class: "flex",
+            onClick: _cache[0] || (_cache[0] = (...args) => unref$1(toggle) && unref$1(toggle)(...args))
+          }, [
+            createElementVNode("i", {
+              class: normalizeClass(["i w-7 leading-7 text-center cursor-pointer", unref$1(isFullscreen) ? "ic:baseline-fullscreen-exit" : "ic:baseline-fullscreen"])
+            }, null, 2)
+          ])
+        ]),
+        _: 1
+      });
+    };
+  }
+});
+const orgDialogProp = reactive({});
+const cbTransfer = reactive({});
+const dataTransfer = reactive({});
+function useModalOut() {
+  const modal = ref(null);
+  const loaded = ref(true);
+  const uid = ref(null);
+  const { isProd } = useApp();
+  function register(modalMethod, uuid) {
+    if (!getCurrentInstance()) {
+      throw new Error("useModal\u53EA\u80FD\u5728setup()\u6216\u8005\u51FD\u6570\u4E2D\u4F7F\u7528");
+    }
+    uid.value = uuid;
+    onUnmounted(() => {
+      if (unref(isProd)) {
+        modal.value = null;
+        loaded.value = false;
+        dataTransfer[unref(uid)] = null;
+        orgDialogProp[unref(uid)] = null;
+        cbTransfer[unref(uid)] = (res) => {
+        };
+      }
+    });
+    if (unref(loaded) && modalMethod === unref(modal))
+      return;
+    modal.value = modalMethod;
+    loaded.value = true;
+  }
+  const getInstance = () => {
+    const instance = unref(modal);
+    if (!instance) {
+      error("useModalOut \u5B9E\u4F8B\u672A\u5B9A\u4E49");
+    }
+    return instance;
+  };
+  const methods = {
+    setModalProps: (props2) => {
+      getInstance()?.setModalProps(props2);
+    },
+    redoModalHeight: () => {
+      getInstance()?.redoModalHeight?.();
+    },
+    openModal: (params, afterClose) => {
+      const id = unref(uid);
+      dataTransfer[id] = isObject(params) ? { ...toRaw(params) } : params;
+      getInstance()?.setModalProps({
+        footer: [],
+        defaultFullscreen: false,
+        ...orgDialogProp[id],
+        visible: true
+      });
+      cbTransfer[id] = (res) => {
+        if (afterClose && isFunction(afterClose)) {
+          afterClose(res);
+        }
+      };
+    },
+    closeModal: () => {
+      getInstance()?.setModalProps({ visible: false });
+    }
+  };
+  return [register, methods];
+}
+function useModal(props2, setModalData) {
+  const modalInstanceRef = ref(null);
+  const currentInstance = getCurrentInstance();
+  const uidRef = ref(null);
+  const { isProd } = useApp();
+  const getInstance = () => {
+    const instance = unref(modalInstanceRef);
+    if (!instance) {
+      error("useModal \u5B9E\u4F8B\u672A\u5B9A\u4E49");
+    }
+    return instance;
+  };
+  const register = (modalInstance, uuid) => {
+    if (unref(isProd)) {
+      modalInstanceRef.value = null;
+    }
+    uidRef.value = uuid;
+    modalInstanceRef.value = modalInstance;
+    currentInstance?.emit("register", modalInstance, uuid);
+    orgDialogProp[uuid] = toRaw(props2);
+    modalInstance.setModalProps(props2);
+  };
+  watchEffect(() => {
+    const data = dataTransfer[unref(uidRef)];
+    if (!data)
+      return;
+    if (!setModalData || !isFunction(setModalData))
+      return;
+    nextTick(() => {
+      setModalData(data);
+    });
+  });
+  const methods = {
+    setLoading: (loading = true) => {
+      getInstance()?.setModalProps({ loading });
+    },
+    closeModal: (rsp) => {
+      if (cbTransfer[unref(uidRef)])
+        cbTransfer[unref(uidRef)](rsp);
+      getInstance()?.setModalProps({ visible: false });
+    },
+    setModalProps: (props22) => {
+      getInstance()?.setModalProps(props22);
+    },
+    redoModalHeight: () => {
+      const callRedo = getInstance()?.redoModalHeight;
+      callRedo && callRedo();
+    }
+  };
+  return [register, methods];
+}
+const basicProps = {
+  t: {
+    type: String
+  },
+  visible: {
+    type: Boolean
+  },
+  closable: {
+    type: Boolean,
+    default: true
+  },
+  destroyOnClose: {
+    type: Boolean
+  },
+  scrollTop: {
+    type: Boolean,
+    default: true
+  },
+  height: { type: Number },
+  minHeight: { type: Number },
+  width: { type: [String, Number] },
+  draggable: {
+    type: Boolean,
+    default: true
+  },
+  defaultFullscreen: {
+    type: Boolean
+  },
+  canFullscreen: {
+    type: Boolean,
+    default: true
+  },
+  title: {
+    type: String
+  },
+  loading: { type: Boolean, default: false },
+  loadingTip: { type: String, default: "\u52A0\u8F7D\u4E2D..." },
+  useWrapper: {
+    type: Boolean,
+    default: true
+  },
+  wrapClassName: { type: String },
+  zIndex: { type: Number },
+  centered: { type: Boolean },
+  showOkBtn: {
+    type: Boolean,
+    default: true
+  },
+  showCancelBtn: {
+    type: Boolean,
+    default: true
+  },
+  okText: {
+    type: String
+  },
+  cancelText: {
+    type: String
+  },
+  mask: { type: Boolean, default: true },
+  maskClosable: { type: Boolean, default: true },
+  keyboard: { type: Boolean, default: true },
+  maskStyle: Object,
+  footer: {
+    type: Object
+  },
+  bodyStyle: Object,
+  wrapperProps: Object,
+  getContainer: Function,
+  closeFunc: Function,
+  afterClose: Function
+};
+function useDragMove(context) {
+  const getStyle = (dom, attr) => {
+    return getComputedStyle(dom)[attr];
+  };
+  const drag = (wrap) => {
+    if (!wrap)
+      return;
+    wrap.setAttribute("data-drag", unref(context.draggable));
+    const dialogHeaderEl = wrap.querySelector(".ant-modal-header");
+    const dragDom = wrap.querySelector(".ant-modal");
+    if (!dialogHeaderEl || !dragDom || !unref(context.draggable))
+      return;
+    dialogHeaderEl.style.cursor = "move";
+    dialogHeaderEl.onmousedown = (e) => {
+      if (!e)
+        return;
+      const disX = e.clientX;
+      const disY = e.clientY;
+      const screenWidth = document.body.clientWidth;
+      const screenHeight = document.documentElement.clientHeight;
+      const dragDomWidth = dragDom.offsetWidth;
+      const dragDomheight = dragDom.offsetHeight;
+      console.log(dragDomWidth, dragDomheight, screenHeight, screenWidth);
+      const minDragDomLeft = dragDom.offsetLeft;
+      const maxDragDomLeft = screenWidth - dragDom.offsetLeft - dragDomWidth;
+      const minDragDomTop = dragDom.offsetTop;
+      const maxDragDomTop = screenHeight - dragDom.offsetTop - dragDomheight;
+      const domLeft = getStyle(dragDom, "left");
+      const domTop = getStyle(dragDom, "top");
+      let styL = +domLeft;
+      let styT = +domTop;
+      if (domLeft.includes("%")) {
+        styL = +document.body.clientWidth * (+domLeft.replace(/%/g, "") / 100);
+        styT = +document.body.clientHeight * (+domTop.replace(/%/g, "") / 100);
+      } else {
+        styL = +domLeft.replace(/px/g, "");
+        styT = +domTop.replace(/px/g, "");
+      }
+      document.onmousemove = function(e2) {
+        let left = e2.clientX - disX;
+        let top = e2.clientY - disY;
+        if (-left > minDragDomLeft) {
+          left = -minDragDomLeft;
+        } else if (left > maxDragDomLeft) {
+          left = maxDragDomLeft;
+        }
+        if (-top > minDragDomTop) {
+          top = -minDragDomTop;
+        } else if (top > maxDragDomTop) {
+          top = maxDragDomTop;
+        }
+        dragDom.style.cssText += `;left:${left + styL}px;top:${top + styT}px;`;
+      };
+      document.onmouseup = () => {
+        document.onmousemove = null;
+        document.onmouseup = null;
+      };
+    };
+  };
+  const handleDrag = () => {
+    const dragWraps = document.querySelectorAll(".ant-modal-wrap");
+    for (const wrap of Array.from(dragWraps)) {
+      if (!wrap)
+        continue;
+      const display = getStyle(wrap, "display");
+      const draggable = wrap.getAttribute("data-drag");
+      if (display !== "none") {
+        if (draggable === null || unref(context.destroyOnClose)) {
+          drag(wrap);
+        }
+      }
+    }
+  };
+  watchEffect(() => {
+    if (!unref(context.visible) || !unref(context.draggable)) {
+      return;
+    }
+    useTimeoutFn(() => {
+      handleDrag();
+    }, 30);
+  });
+}
+function _isSlot(s) {
+  return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s);
+}
+const Modal = defineComponent({
+  name: "Modal",
+  inheritAttrs: false,
+  props: basicProps,
+  emits: ["cancel"],
+  setup(props2, {
+    slots,
+    emit
+  }) {
+    const {
+      visible,
+      draggable,
+      destroyOnClose
+    } = toRefs(props2);
+    const attrs = useAttrs();
+    useDragMove({
+      visible,
+      destroyOnClose,
+      draggable
+    });
+    const {
+      extendSlots
+    } = useSlots$1();
+    const onCancel = (e) => emit("cancel", e);
+    return () => {
+      let _slot;
+      const propsData = {
+        ...unref(attrs),
+        ...props2,
+        destroyOnClose: true,
+        onCancel
+      };
+      if (!propsData?.visible)
+        return null;
+      return createVNode(Modal$1, propsData, _isSlot(_slot = extendSlots(slots)) ? _slot : {
+        default: () => [_slot]
+      });
+    };
+  }
+});
+const _sfc_main$d = /* @__PURE__ */ defineComponent$1({
+  __name: "CloseIcon",
+  props: {
+    canFullscreen: { type: Boolean, default: true },
+    fullScreen: { type: Boolean }
+  },
+  emits: ["cancel", "fullscreen"],
+  setup(__props, { emit }) {
+    const props2 = __props;
+    const { t } = useI18n("UI");
+    const getClass = computed(() => {
+      return [
+        "dt-basic-modal-close",
+        `dt-basic-modal-close--custom`,
+        {
+          [`dt-basic-modal-close--can-full`]: props2.canFullscreen
+        }
+      ];
+    });
+    function handleCancel(e) {
+      emit("cancel", e);
+    }
+    function handleFullScreen(e) {
+      e?.stopPropagation();
+      e?.preventDefault();
+      emit("fullscreen");
+    }
+    return (_ctx, _cache) => {
+      const _component_ATooltip = Tooltip;
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["flex h-14 items-center justify-center", unref$1(getClass)])
+      }, [
+        __props.canFullscreen ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+          __props.fullScreen ? (openBlock(), createBlock(_component_ATooltip, {
+            key: 0,
+            title: unref$1(t)("EXIT_FULLSCREEN"),
+            placement: "bottom"
+          }, {
+            default: withCtx(() => [
+              createElementVNode("i", {
+                class: "i ic:baseline-fullscreen-exit hover:font-bold inline-block w-10 h-14 pr-4",
+                onClick: handleFullScreen
+              })
+            ]),
+            _: 1
+          }, 8, ["title"])) : (openBlock(), createBlock(_component_ATooltip, {
+            key: 1,
+            title: unref$1(t)("FULLSCREEN"),
+            placement: "bottom"
+          }, {
+            default: withCtx(() => [
+              createElementVNode("i", {
+                class: "i ic:baseline-fullscreen hover:font-bold inline-block h-14 w-10 pr-4",
+                onClick: handleFullScreen
+              })
+            ]),
+            _: 1
+          }, 8, ["title"]))
+        ], 64)) : createCommentVNode("", true),
+        createElementVNode("i", {
+          class: "i mdi:close h-14 w-10 pr-4",
+          onClick: handleCancel
+        })
+      ], 2);
+    };
+  }
+});
+const isServer = typeof window === "undefined";
+const BAR_MAP = {
+  vertical: {
+    offset: "offsetHeight",
+    scroll: "scrollTop",
+    scrollSize: "scrollHeight",
+    size: "height",
+    key: "vertical",
+    axis: "Y",
+    client: "clientY",
+    direction: "top"
+  },
+  horizontal: {
+    offset: "offsetWidth",
+    scroll: "scrollLeft",
+    scrollSize: "scrollWidth",
+    size: "width",
+    key: "horizontal",
+    axis: "X",
+    client: "clientX",
+    direction: "left"
+  }
+};
+function renderThumbStyle({ move, size, bar }) {
+  const style = {};
+  const translate = `translate${bar.axis}(${move}%)`;
+  style[bar.size] = size;
+  style.transform = translate;
+  style.msTransform = translate;
+  style.webkitTransform = translate;
+  return style;
+}
+function resizeHandler(entries) {
+  for (const entry of entries) {
+    const listeners = entry.target.__resizeListeners__ || [];
+    if (listeners.length) {
+      listeners.forEach((fn) => {
+        fn();
+      });
+    }
+  }
+}
+function addResizeListener(element, fn) {
+  if (isServer)
+    return;
+  if (!element.__resizeListeners__) {
+    element.__resizeListeners__ = [];
+    element.__ro__ = new ResizeObserver(resizeHandler);
+    element.__ro__.observe(element);
+  }
+  element.__resizeListeners__.push(fn);
+}
+function removeResizeListener(element, fn) {
+  if (!element || !element.__resizeListeners__)
+    return;
+  element.__resizeListeners__.splice(element.__resizeListeners__.indexOf(fn), 1);
+  if (!element.__resizeListeners__.length) {
+    element.__ro__.disconnect();
+  }
+}
+const Bar = defineComponent$1({
+  name: "Bar",
+  props: {
+    vertical: Boolean,
+    size: String,
+    move: Number
+  },
+  setup(props2) {
+    const instance = getCurrentInstance$1();
+    const thumb = ref$1();
+    const wrap = inject("scroll-bar-wrap", {});
+    const bar = computed$1(() => {
+      return BAR_MAP[props2.vertical ? "vertical" : "horizontal"];
+    });
+    const barStore = ref$1({});
+    const cursorDown = ref$1();
+    const clickThumbHandler = (e) => {
+      if (e.ctrlKey || e.button === 2) {
+        return;
+      }
+      window.getSelection()?.removeAllRanges();
+      startDrag(e);
+      barStore.value[bar.value.axis] = e.currentTarget[bar.value.offset] - (e[bar.value.client] - e.currentTarget.getBoundingClientRect()[bar.value.direction]);
+    };
+    const clickTrackHandler = (e) => {
+      const offset = Math.abs(
+        e.target.getBoundingClientRect()[bar.value.direction] - e[bar.value.client]
+      );
+      const thumbHalf = thumb.value[bar.value.offset] / 2;
+      const thumbPositionPercentage = (offset - thumbHalf) * 100 / instance?.vnode.el?.[bar.value.offset];
+      wrap.value[bar.value.scroll] = thumbPositionPercentage * wrap.value[bar.value.scrollSize] / 100;
+    };
+    const startDrag = (e) => {
+      e.stopImmediatePropagation();
+      cursorDown.value = true;
+      on(document, "mousemove", mouseMoveDocumentHandler);
+      on(document, "mouseup", mouseUpDocumentHandler);
+      document.onselectstart = () => false;
+    };
+    const mouseMoveDocumentHandler = (e) => {
+      if (cursorDown.value === false)
+        return;
+      const prevPage = barStore.value[bar.value.axis];
+      if (!prevPage)
+        return;
+      const offset = (instance?.vnode.el?.getBoundingClientRect()[bar.value.direction] - e[bar.value.client]) * -1;
+      const thumbClickPosition = thumb.value[bar.value.offset] - prevPage;
+      const thumbPositionPercentage = (offset - thumbClickPosition) * 100 / instance?.vnode.el?.[bar.value.offset];
+      wrap.value[bar.value.scroll] = thumbPositionPercentage * wrap.value[bar.value.scrollSize] / 100;
+    };
+    function mouseUpDocumentHandler() {
+      cursorDown.value = false;
+      barStore.value[bar.value.axis] = 0;
+      off(document, "mousemove", mouseMoveDocumentHandler);
+      document.onselectstart = null;
+    }
+    onUnmounted$1(() => {
+      off(document, "mouseup", mouseUpDocumentHandler);
+    });
+    return () => h$1(
+      "div",
+      {
+        class: ["scrollbar__bar", "is-" + bar.value.key],
+        onMousedown: clickTrackHandler
+      },
+      h$1("div", {
+        ref: thumb,
+        class: "scrollbar__thumb",
+        onMousedown: clickThumbHandler,
+        style: renderThumbStyle({
+          size: props2.size,
+          move: props2.move,
+          bar: bar.value
+        })
+      })
+    );
+  }
+});
+const _hoisted_1$6 = { class: "scrollbar relative h-full overflow-hidden" };
+const _sfc_main$c = /* @__PURE__ */ defineComponent$1({
+  __name: "scroll-bar",
+  props: {
+    wrapClass: {
+      type: [String, Array],
+      default: ""
+    },
+    wrapStyle: Array,
+    viewClass: {
+      type: [String, Array],
+      default: ""
+    },
+    viewStyle: {
+      type: [String, Array],
+      default: ""
+    },
+    noresize: Boolean,
+    tag: {
+      type: String,
+      default: "div"
+    }
+  },
+  setup(__props) {
+    const props2 = __props;
+    const sizeWidth = ref("0");
+    const sizeHeight = ref("0");
+    const moveX = ref(0);
+    const moveY = ref(0);
+    const wrap = ref();
+    const resize = ref();
+    provide("scroll-bar-wrap", wrap);
+    const style = computed(() => {
+      let rsStyle = {};
+      if (Array.isArray(props2.wrapStyle)) {
+        props2.wrapStyle.forEach((it) => {
+          if (it)
+            rsStyle = Object.assign({}, rsStyle, it);
+        });
+      }
+      return rsStyle;
+    });
+    const handleScroll = () => {
+      moveY.value = unref(wrap).scrollTop * 100 / unref(wrap).clientHeight;
+      moveX.value = unref(wrap).scrollLeft * 100 / unref(wrap).clientWidth;
+    };
+    const update = () => {
+      if (!unref(wrap))
+        return;
+      const heightPercentage = unref(wrap).clientHeight * 100 / unref(wrap).scrollHeight;
+      const widthPercentage = unref(wrap).clientWidth * 100 / unref(wrap).scrollWidth;
+      sizeHeight.value = heightPercentage < 100 ? heightPercentage + "%" : "";
+      sizeWidth.value = widthPercentage < 100 ? widthPercentage + "%" : "";
+    };
+    onMounted(() => {
+      nextTick(update);
+      if (!props2.noresize) {
+        addResizeListener(unref(resize), update);
+        addResizeListener(unref(wrap), update);
+        addEventListener("resize", update);
+      }
+    });
+    onBeforeUnmount(() => {
+      if (!props2.noresize) {
+        removeResizeListener(unref(resize), update);
+        removeResizeListener(unref(wrap), update);
+        removeEventListener("resize", update);
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$6, [
+        createElementVNode("div", {
+          ref_key: "wrap",
+          ref: wrap,
+          class: normalizeClass([[__props.wrapClass, "scrollbar__wrap--hidden-default"], "h-full overflow-auto"]),
+          style: normalizeStyle(unref$1(style)),
+          onScroll: handleScroll
+        }, [
+          (openBlock(), createBlock(resolveDynamicComponent(__props.tag), {
+            class: normalizeClass(["box-border", __props.viewClass]),
+            ref_key: "resize",
+            ref: resize,
+            style: normalizeStyle(__props.viewStyle)
+          }, {
+            default: withCtx(() => [
+              renderSlot(_ctx.$slots, "default")
+            ]),
+            _: 3
+          }, 8, ["class", "style"]))
+        ], 38),
+        createVNode(unref$1(Bar), {
+          move: unref$1(moveX),
+          size: unref$1(sizeWidth)
+        }, null, 8, ["move", "size"]),
+        createVNode(unref$1(Bar), {
+          vertical: "",
+          move: unref$1(moveY),
+          size: unref$1(sizeHeight)
+        }, null, 8, ["move", "size"])
+      ]);
+    };
+  }
+});
+const _sfc_main$b = /* @__PURE__ */ defineComponent$1({
+  __name: "scroll-container",
+  setup(__props) {
+    const scrollbarRef = ref(null);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(_sfc_main$c, mergeProps({
+        ref_key: "scrollbarRef",
+        ref: scrollbarRef
+      }, _ctx.$attrs, { class: "w-full h-full" }), {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 16);
+    };
+  }
+});
+const _sfc_main$a = defineComponent({
+  name: "slot-container",
+  props: {
+    template: {
+      type: Function
+    },
+    data: {
+      type: Object
+    }
+  },
+  setup(props2) {
+    return () => {
+      return h("div", [props2.template(props2.data)]);
+    };
+  }
+});
+const withInstall = (comp) => {
+  comp.install = (app) => {
+    app.component(comp.name, comp);
+  };
+  return comp;
+};
+const DtScrollContainer = withInstall(_sfc_main$b);
+withInstall(_sfc_main$a);
+const _sfc_main$9 = /* @__PURE__ */ defineComponent$1({
+  __name: "ModalWrap",
+  props: {
+    useWrapper: { type: Boolean, default: true },
+    modalHeaderHeight: { type: Number, default: 55 },
+    modalFooterHeight: { type: Number, default: 58 },
+    minHeight: { type: Number, default: 200 },
+    height: { type: Number },
+    visible: { type: Boolean },
+    fullScreen: { type: Boolean }
+  },
+  emits: ["ext-height", "height-change"],
+  setup(__props, { emit: emits }) {
+    const props2 = __props;
+    const wrapperRef = ref(null);
+    const wrapRef = ref(null);
+    const realHeightRef = ref(0);
+    const minRealHeightRef = ref(0);
+    let realHeight = 0;
+    const wrapStyle = computed(() => {
+      return {
+        minHeight: `${props2.minHeight}px`,
+        [props2.fullScreen ? "height" : "maxHeight"]: `${unref(realHeightRef)}px`
+      };
+    });
+    onMounted(() => {
+      const { modalHeaderHeight, modalFooterHeight } = props2;
+      emits("ext-height", modalHeaderHeight + modalFooterHeight);
+    });
+    async function getModalDom() {
+      const wrapperRefDom = unref(wrapperRef);
+      if (!wrapperRefDom)
+        return;
+      const bodyDom = wrapperRefDom.$el.parentElement;
+      if (!bodyDom)
+        return;
+      bodyDom.style.padding = "0";
+      await nextTick();
+      const modalDom = bodyDom.parentElement && bodyDom.parentElement.parentElement;
+      return modalDom;
+    }
+    async function setModalHeight() {
+      if (!props2.visible)
+        return;
+      try {
+        const modalDom = await getModalDom();
+        if (!modalDom)
+          return;
+        const modalRect = getComputedStyle(modalDom).top;
+        const modalTop = Number.parseInt(modalRect);
+        let maxHeight = window.innerHeight - props2.modalFooterHeight - props2.modalHeaderHeight - 100;
+        if (modalTop < 40) {
+          maxHeight -= 26;
+        }
+        await nextTick();
+        const warpEl = unref(wrapRef);
+        if (!warpEl)
+          return;
+        await nextTick();
+        realHeight = warpEl.scrollHeight;
+        if (props2.fullScreen) {
+          realHeightRef.value = window.innerHeight - props2.modalFooterHeight - props2.modalHeaderHeight;
+        } else {
+          realHeightRef.value = props2.height ? props2.height : realHeight > maxHeight ? maxHeight : realHeight;
+        }
+        emits("height-change", unref(realHeightRef));
+        const _modalDom = await getModalDom();
+        _modalDom.style.top = (window.innerHeight - _modalDom.offsetHeight) / 2 + "px";
+      } catch (error2) {
+        console.log(error2);
+      }
+    }
+    windowResizeFn(setModalHeight.bind(null, false));
+    watchEffect(() => {
+      props2.useWrapper && setModalHeight();
+    });
+    watch(
+      () => props2.fullScreen,
+      (v) => {
+        setModalHeight();
+        if (!v) {
+          realHeightRef.value = minRealHeightRef.value;
+        } else {
+          minRealHeightRef.value = realHeightRef.value;
+        }
+      }
+    );
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref$1(DtScrollContainer), {
+        ref_key: "wrapperRef",
+        ref: wrapperRef
+      }, {
+        default: withCtx(() => [
+          createElementVNode("div", {
+            ref_key: "wrapRef",
+            ref: wrapRef,
+            style: normalizeStyle(unref$1(wrapStyle))
+          }, [
+            renderSlot(_ctx.$slots, "default")
+          ], 4)
+        ]),
+        _: 3
+      }, 512);
+    };
+  }
+});
+const _sfc_main$8 = /* @__PURE__ */ defineComponent$1({
+  __name: "ModalFooter",
+  props: {
+    buttons: Object,
+    showSave: { type: Boolean, default: true },
+    showCancel: { type: Boolean, default: true },
+    okText: { type: String },
+    cancelText: { type: String }
+  },
+  emits: [
+    "handleSave",
+    "handleCancel"
+  ],
+  setup(__props, { emit: emits }) {
+    const props2 = __props;
+    const { t } = useI18n("UI");
+    const buttonList = computed$1(() => {
+      if (props2.buttons && props2.buttons.length)
+        return props2.buttons;
+      let buttonActions = [
+        { t: "\u4FDD\u5B58", name: props2.okText || t("SAVE"), preIcon: "mdi:content-save", type: "primary", flag: "OK" },
+        { t: "\u5173\u95ED", name: props2.cancelText || t("CLOSE"), preIcon: "mdi:close", flag: "CANCEL" }
+      ];
+      if (!props2.showSave)
+        buttonActions = buttonActions.filter((btn) => btn.flag !== "OK");
+      if (!props2.showCancel)
+        buttonActions = buttonActions.filter((btn) => btn.flag !== "CANCEL");
+      return buttonActions;
+    });
+    function handleMethod(item) {
+      switch (item.flag) {
+        case "OK":
+          emits("handleSave");
+          break;
+        case "CANCEL":
+          emits("handleCancel");
+          break;
+      }
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock(Fragment, null, [
+        renderSlot(_ctx.$slots, "appendFooter"),
+        createVNode(_sfc_main$f, {
+          mode: "dialog",
+          buttonList: unref$1(buttonList),
+          onHandleMethod: _cache[0] || (_cache[0] = ($event) => handleMethod($event))
+        }, null, 8, ["buttonList"])
+      ], 64);
+    };
+  }
+});
+function useFullScreen(wrapClassName) {
+  const fullScreenRef = ref(false);
+  const getWrapClassName = computed(() => {
+    const clsName = unref(wrapClassName) || "";
+    const cls = unref(fullScreenRef) ? `fullscreen-modal ${clsName} ` : unref(clsName);
+    return `dt-modal ${cls}`;
+  });
+  function toggleFullScreen(e) {
+    e && e.stopPropagation();
+    fullScreenRef.value = !unref(fullScreenRef);
+    dispatchResize();
+  }
+  return {
+    fullScreenRef,
+    getWrapClassName,
+    toggleFullScreen
+  };
+}
+const _sfc_main$7 = /* @__PURE__ */ defineComponent$1({
+  __name: "index",
+  props: basicProps,
+  emits: ["visible-change", "height-change", "cancel", "save", "register", "update:visible"],
+  setup(__props, { emit: emits }) {
+    const props2 = __props;
+    const visibleRef = ref(false);
+    const propsRef = ref();
+    const modalWrapperRef = ref(null);
+    const { getWrapClassName, toggleFullScreen, fullScreenRef } = useFullScreen(computed(() => unref(propsRef)?.wrapClassName));
+    const getMergeProps = computed(() => {
+      return {
+        ...props2,
+        ...unref(propsRef)
+      };
+    });
+    const getBindValue = computed(() => {
+      const bindValue = {
+        ...unref(getMergeProps),
+        ...unref(propsRef),
+        visible: unref(visibleRef),
+        wrapClassName: unref(getWrapClassName)
+      };
+      let omitArr = unref(fullScreenRef) ? ["height", "title"] : ["title"];
+      if (isArray(unref(propsRef)?.footer)) {
+        omitArr.push("footer");
+      }
+      return omit(bindValue, omitArr);
+    });
+    const getWrapperHeight = computed(() => {
+      if (unref(fullScreenRef))
+        return void 0;
+      return unref(getBindValue).height;
+    });
+    const modalFooterHeight = computed(() => {
+      if (isArray(props2.footer)) {
+        return (unref(propsRef)?.footer).length ? 0 : void 0;
+      }
+      return props2?.footer !== void 0 && !props2.footer ? 0 : void 0;
+    });
+    const modalMethods = {
+      setModalProps,
+      redoModalHeight: () => {
+        nextTick(() => {
+          if (unref(modalWrapperRef)) {
+            unref(modalWrapperRef).setModalHeight();
+          }
+        });
+      }
+    };
+    const instance = getCurrentInstance();
+    if (instance) {
+      emits("register", modalMethods, instance.uid);
+    }
+    function handleHeightChange(height) {
+      emits("height-change", height);
+    }
+    function setModalProps(props22) {
+      propsRef.value = deepMerge(unref(propsRef) || {}, props22);
+      if (Reflect.has(props22, "visible")) {
+        visibleRef.value = !!props22.visible;
+      }
+      if (Reflect.has(props22, "defaultFullscreen")) {
+        fullScreenRef.value = !!props22.defaultFullscreen;
+      }
+    }
+    function handleSave() {
+      emits("save");
+    }
+    async function handleCancel(e = null) {
+      if (e) {
+        e?.stopPropagation();
+        if (e.target?.classList?.contains("dt-basic-modal-close--custom"))
+          return;
+        if (props2.closeFunc && isFunction(props2.closeFunc)) {
+          const isClose = await props2.closeFunc();
+          visibleRef.value = !isClose;
+          return;
+        }
+      }
+      const { afterClose } = unref(getBindValue);
+      if (afterClose && isFunction(afterClose)) {
+        afterClose();
+      }
+      visibleRef.value = false;
+      emits("cancel", e);
+    }
+    watch(() => unref(visibleRef), (v) => {
+      emits("visible-change", v);
+      emits("update:visible", v);
+      nextTick(() => {
+        if (props2.scrollTop && v && unref(modalWrapperRef)) {
+          unref(modalWrapperRef).$el.scrollTop = 0;
+        }
+      });
+    }, {
+      immediate: false
+    });
+    return (_ctx, _cache) => {
+      const _component_ASpin = Spin;
+      return openBlock(), createBlock(unref$1(Modal), mergeProps(unref$1(getBindValue), { onCancel: handleCancel }), createSlots({
+        default: withCtx(() => [
+          createVNode(_component_ASpin, {
+            spinning: unref$1(getBindValue).loading,
+            tip: unref$1(getBindValue).loadingTip
+          }, {
+            default: withCtx(() => [
+              createVNode(_sfc_main$9, mergeProps({
+                useWrapper: unref$1(getBindValue).useWrapper,
+                fullScreen: unref$1(fullScreenRef),
+                ref_key: "modalWrapperRef",
+                ref: modalWrapperRef,
+                minHeight: unref$1(getBindValue).minHeight,
+                height: unref$1(getWrapperHeight),
+                visible: unref$1(visibleRef),
+                modalFooterHeight: unref$1(modalFooterHeight)
+              }, unref$1(omit)(unref$1(getBindValue).wrapperProps, "visible", "height", "modalFooterHeight"), { onHeightChange: handleHeightChange }), {
+                default: withCtx(() => [
+                  renderSlot(_ctx.$slots, "default")
+                ]),
+                _: 3
+              }, 16, ["useWrapper", "fullScreen", "minHeight", "height", "visible", "modalFooterHeight"])
+            ]),
+            _: 3
+          }, 8, ["spinning", "tip"])
+        ]),
+        _: 2
+      }, [
+        !_ctx.$slots.closeIcon ? {
+          name: "closeIcon",
+          fn: withCtx(() => [
+            createVNode(_sfc_main$d, {
+              canFullscreen: unref$1(getBindValue).canFullscreen,
+              fullScreen: unref$1(fullScreenRef),
+              onCancel: handleCancel,
+              onFullscreen: unref$1(toggleFullScreen)
+            }, null, 8, ["canFullscreen", "fullScreen", "onFullscreen"])
+          ]),
+          key: "0"
+        } : void 0,
+        !_ctx.$slots.title ? {
+          name: "title",
+          fn: withCtx(() => [
+            createTextVNode(toDisplayString(unref$1(getMergeProps).title), 1)
+          ]),
+          key: "1"
+        } : void 0,
+        !_ctx.$slots.footer ? {
+          name: "footer",
+          fn: withCtx(() => [
+            createVNode(_sfc_main$8, {
+              buttons: unref$1(propsRef)?.footer,
+              showSave: unref$1(getBindValue).showOkBtn,
+              showCancel: unref$1(getBindValue).showCancelBtn,
+              okText: unref$1(getBindValue).okText,
+              cancelText: unref$1(getBindValue).cancelText,
+              onHandleSave: handleSave,
+              onHandleCancel: handleCancel
+            }, createSlots({ _: 2 }, [
+              renderList(Object.keys(_ctx.$slots), (item) => {
+                return {
+                  name: item,
+                  fn: withCtx((data) => [
+                    renderSlot(_ctx.$slots, item, normalizeProps(guardReactiveProps(data || {})))
+                  ])
+                };
+              })
+            ]), 1032, ["buttons", "showSave", "showCancel", "okText", "cancelText"])
+          ]),
+          key: "2"
+        } : void 0,
+        renderList(Object.keys(unref$1(omit)(_ctx.$slots, "default")), (item) => {
+          return {
+            name: item,
+            fn: withCtx((data) => [
+              renderSlot(_ctx.$slots, item, normalizeProps(guardReactiveProps(data || {})))
+            ])
+          };
+        })
+      ]), 1040);
+    };
+  }
+});
+const index = "";
+const _hoisted_1$5 = { class: "column-select" };
+const _sfc_main$6 = /* @__PURE__ */ defineComponent$1({
+  __name: "DownloadCtrl",
+  setup(__props) {
+    const { t } = useI18n("UI");
+    const { message } = useMessage();
+    const state = reactive({
+      indeterminate: false,
+      checkAll: false
+    });
+    const modalData = ref([]);
+    const onCheckAllChange = (e) => {
+      modalData.value?.map((it) => it.show = e.target.checked);
+    };
+    const [registerDialog, { closeModal }] = useModal(
+      {
+        width: "60%",
+        title: t("SETTING_EXPORT_COLUMN")
+      },
+      (data) => {
+        modalData.value = data;
+      }
+    );
+    function save() {
+      let columns = unref(modalData)?.filter((it) => it.show);
+      if (!columns.length) {
+        message.error(t("NO_EXPORT_COLUMN"));
+        return;
+      }
+      closeModal(columns);
+    }
+    watch(
+      () => unref(modalData),
+      (v) => {
+        if (isArray(v)) {
+          let showLens = v.filter((it) => it.show).length;
+          Object.assign(state, {
+            checkAll: showLens === v.length,
+            indeterminate: showLens !== v.length && showLens > 0
+          });
+        }
+      },
+      {
+        deep: true
+      }
+    );
+    return (_ctx, _cache) => {
+      const _component_ACheckbox = Checkbox$1;
+      const _component_ADivider = Divider$1;
+      const _component_ACol = Col$1;
+      const _component_ARow = Row;
+      return openBlock(), createBlock(unref$1(_sfc_main$7), {
+        onRegister: unref$1(registerDialog),
+        onSave: save
+      }, {
+        default: withCtx(() => [
+          createElementVNode("div", _hoisted_1$5, [
+            createVNode(_component_ACheckbox, {
+              checked: unref$1(state).checkAll,
+              "onUpdate:checked": _cache[0] || (_cache[0] = ($event) => unref$1(state).checkAll = $event),
+              indeterminate: unref$1(state).indeterminate,
+              onChange: onCheckAllChange
+            }, {
+              default: withCtx(() => [
+                createTextVNode(toDisplayString(unref$1(t)("SELECT_ALL")), 1)
+              ]),
+              _: 1
+            }, 8, ["checked", "indeterminate"]),
+            createVNode(_component_ADivider, { dashed: "" }),
+            createVNode(_component_ARow, null, {
+              default: withCtx(() => [
+                (openBlock(true), createElementBlock(Fragment, null, renderList(unref$1(modalData), (it, index2) => {
+                  return openBlock(), createBlock(_component_ACol, { span: 8 }, {
+                    default: withCtx(() => [
+                      createVNode(_component_ACheckbox, {
+                        checked: it.show,
+                        "onUpdate:checked": ($event) => it.show = $event
+                      }, {
+                        default: withCtx(() => [
+                          createTextVNode(toDisplayString(it.title), 1)
+                        ]),
+                        _: 2
+                      }, 1032, ["checked", "onUpdate:checked"])
+                    ]),
+                    _: 2
+                  }, 1024);
+                }), 256))
+              ]),
+              _: 1
+            })
+          ])
+        ]),
+        _: 1
+      }, 8, ["onRegister"]);
+    };
+  }
+});
+const _hoisted_1$4 = /* @__PURE__ */ createElementVNode("i", { class: "i ic:baseline-download w-7 leading-7 text-center cursor-pointer" }, null, -1);
+const _sfc_main$5 = /* @__PURE__ */ defineComponent$1({
+  __name: "Download",
+  props: {
+    onlyBackDowonload: Boolean,
+    onlyFrontDownload: Boolean
+  },
+  setup(__props) {
+    const table = getTableInstance();
+    const [registerDialog, { openModal }] = useModalOut();
+    const { t } = useI18n("UI");
+    function handleTitleClick({ key }) {
+      const { onDownload, columns: allColumns, dataSource } = unref(table.getBind);
+      const excludesFlag = ["ACTION", "CHECKBOX", "RADIO"];
+      const columns = allColumns.filter((it) => !excludesFlag.includes(it.flag));
+      openModal(columns, (selectColumns) => {
+        onDownload({
+          type: key,
+          columns: selectColumns,
+          rows: key === "select" ? table.getSelectRows() : key === "current" ? dataSource : []
+        });
+      });
+    }
+    return (_ctx, _cache) => {
+      const _component_AMenuItem = MenuItem;
+      const _component_AMenu = Menu;
+      const _component_ADropdown = Dropdown;
+      const _component_ATooltip = Tooltip;
+      return openBlock(), createBlock(_component_ATooltip, { placement: "top" }, {
+        title: withCtx(() => [
+          createElementVNode("span", null, toDisplayString(unref$1(t)("EXPORT")), 1)
+        ]),
+        default: withCtx(() => [
+          createVNode(_component_ADropdown, {
+            placement: "bottom",
+            trigger: ["click"],
+            getPopupContainer: unref$1(getPopupContainer)
+          }, {
+            overlay: withCtx(() => [
+              createVNode(_component_AMenu, { onClick: handleTitleClick }, {
+                default: withCtx(() => [
+                  !__props.onlyBackDowonload ? (openBlock(), createBlock(_component_AMenuItem, { key: "current" }, {
+                    default: withCtx(() => [
+                      createElementVNode("span", null, toDisplayString(unref$1(t)("EXPORT_CURRENT_PAGE")), 1)
+                    ]),
+                    _: 1
+                  })) : createCommentVNode("", true),
+                  !__props.onlyBackDowonload ? (openBlock(), createBlock(_component_AMenuItem, { key: "select" }, {
+                    default: withCtx(() => [
+                      createElementVNode("span", null, toDisplayString(unref$1(t)("EXPORT_SELECT_COLUMN")), 1)
+                    ]),
+                    _: 1
+                  })) : createCommentVNode("", true),
+                  !__props.onlyFrontDownload ? (openBlock(), createBlock(_component_AMenuItem, { key: "all" }, {
+                    default: withCtx(() => [
+                      createElementVNode("span", null, toDisplayString(unref$1(t)("EXPORT_ALL")), 1)
+                    ]),
+                    _: 1
+                  })) : createCommentVNode("", true)
+                ]),
+                _: 1
+              })
+            ]),
+            default: withCtx(() => [
+              _hoisted_1$4
+            ]),
+            _: 1
+          }, 8, ["getPopupContainer"]),
+          createVNode(_sfc_main$6, { onRegister: unref$1(registerDialog) }, null, 8, ["onRegister"])
+        ]),
+        _: 1
+      });
+    };
+  }
+});
+const _hoisted_1$3 = /* @__PURE__ */ createElementVNode("i", { class: "i ant-design:drag-outlined drag-icon cursor-pointer" }, null, -1);
+const _hoisted_2$1 = ["onClick"];
+const _hoisted_3$1 = ["onClick"];
+const _hoisted_4$1 = /* @__PURE__ */ createElementVNode("i", { class: "i ant-design:setting-outlined w-7 leading-7 text-center cursor-pointer" }, null, -1);
+const _sfc_main$4 = /* @__PURE__ */ defineComponent$1({
+  __name: "Column",
+  emits: [
+    "columns-change"
+  ],
+  setup(__props, { emit: emits }) {
+    const { t } = useI18n("UI");
+    const attrs = useAttrs();
+    const prefixCls = "column-setting";
+    const table = getTableInstance();
+    const defaultRowSelection = omit(table.getRowSelection(), "selectedRowKeys");
+    let inited = false;
+    const cachePlainOptions = ref([]);
+    const plainOptions = ref([]);
+    const plainSortOptions = ref([]);
+    const columnListRef = ref(null);
+    const checkIndex = ref(false);
+    const checkSelect = ref(false);
+    const getValues = computed(() => {
+      return unref(table?.getBind);
+    });
+    let sortable;
+    let sortableOrder = [];
+    const state = reactive({
+      checkAll: true,
+      checkedList: [],
+      defaultCheckList: []
+    });
+    const indeterminate = computed(() => {
+      let len = plainOptions.value.length;
+      let checkedLen = state.checkedList.length;
+      unref(checkIndex) && checkedLen--;
+      return checkedLen > 0 && checkedLen < len;
+    });
+    watchEffect(() => {
+      const columns = table.getColumns();
+      if (columns && columns.length) {
+        init();
+      }
+    });
+    watchEffect(() => {
+      const values = unref(getValues);
+      checkIndex.value = !!values.showIndexColumn;
+      checkSelect.value = !!values.rowSelection;
+    });
+    function handleVisibleChange() {
+      if (inited)
+        return;
+      nextTick(() => {
+        const columnListEl = unref(columnListRef);
+        if (!columnListEl)
+          return;
+        const el = columnListEl.$el;
+        if (!el)
+          return;
+        sortable = Sortablejs.create(unref(el), {
+          animation: 500,
+          delay: 400,
+          delayOnTouchOnly: true,
+          handle: ".drag-icon ",
+          onEnd: (evt) => {
+            const { oldIndex, newIndex } = evt;
+            if (isNullAndUnDef(oldIndex) || isNullAndUnDef(newIndex) || oldIndex === newIndex) {
+              return;
+            }
+            const columns = cloneDeep(plainSortOptions.value);
+            if (oldIndex > newIndex) {
+              columns.splice(newIndex, 0, columns[oldIndex]);
+              columns.splice(oldIndex + 1, 1);
+            } else {
+              columns.splice(newIndex + 1, 0, columns[oldIndex]);
+              columns.splice(oldIndex, 1);
+            }
+            plainSortOptions.value = columns;
+            setColumns(
+              columns.map((col) => col.value).filter((value) => state.checkedList.includes(value))
+            );
+          }
+        });
+        sortableOrder = sortable.toArray();
+        inited = true;
+      });
+    }
+    function onCheckAllChange(e) {
+      const checkList = plainOptions.value.map((item) => item.value);
+      if (e.target.checked) {
+        state.checkedList = checkList;
+        setColumns(checkList);
+      } else {
+        state.checkedList = [];
+        setColumns([]);
+      }
+    }
+    function handleIndexCheckChange(e) {
+      table.setProps({
+        showIndexColumn: e.target.checked
+      });
+    }
+    function handleSelectCheckChange(e) {
+      table.setProps({
+        rowSelection: e.target.checked ? defaultRowSelection : null
+      });
+    }
+    function onChange(checkedList) {
+      const len = plainSortOptions.value.length;
+      state.checkAll = checkedList.length === len;
+      const sortList = unref(plainSortOptions).map((item) => item.value);
+      checkedList.sort((prev, next) => {
+        return sortList.indexOf(prev) - sortList.indexOf(next);
+      });
+      setColumns(checkedList);
+    }
+    function reset() {
+      state.checkedList = [...state.defaultCheckList];
+      state.checkAll = true;
+      plainOptions.value = unref(cachePlainOptions);
+      plainSortOptions.value = unref(cachePlainOptions);
+      setColumns(table.getCacheColumns());
+      sortable.sort(sortableOrder);
+    }
+    function getColumns() {
+      return table.getColumns({
+        ignoreIndex: true,
+        ignoreAction: true
+      }).reduce((ret, it) => {
+        ret.push({
+          label: it.title,
+          value: it.dataIndex || it.title,
+          ...it
+        });
+        return ret;
+      }, []);
+    }
+    function handleColumnFixed(item, fixed) {
+      if (!state.checkedList.includes(item.dataIndex))
+        return;
+      const columns = getColumns();
+      const isFixed = item.fixed === fixed ? false : fixed;
+      const index2 = columns.findIndex((col) => col.dataIndex === item.dataIndex);
+      if (index2 !== -1) {
+        columns[index2].fixed = isFixed;
+      }
+      item.fixed = isFixed;
+      if (isFixed && !item.width) {
+        item.width = 100;
+      }
+      table.setColumnsByDataIndex?.(item.dataIndex, { fixed: isFixed });
+      setColumns(columns);
+    }
+    function setColumns(columns) {
+      table.setColumns(columns);
+      const data = unref(plainSortOptions).map((col) => {
+        const visable = columns.findIndex(
+          (c) => c === col.value || typeof c !== "string" && c.dataIndex === col.value
+        ) !== -1;
+        return { dataIndex: col.value, fixed: col.fixed, visable };
+      });
+      emits("columns-change", data);
+    }
+    function init() {
+      const columns = getColumns();
+      const checkList = table.getColumns({ ignoreAction: true }).map((it) => it.defaultHidden ? "" : it.dataIndex || it.title).filter(Boolean);
+      if (!plainOptions.value.length) {
+        plainOptions.value = columns;
+        plainSortOptions.value = columns;
+        cachePlainOptions.value = cloneDeep(columns);
+        state.defaultCheckList = checkList;
+      } else {
+        unref(plainOptions).forEach(
+          (it) => it.fixed === columns.find((col) => col.dataIndex === it.dataIndex)?.fixed
+        );
+      }
+      state.isInit = true;
+      state.checkedList = checkList;
+    }
+    function getPopupContainer$1() {
+      return isFunction$1(attrs.getPopupContainer) ? attrs.getPopupContainer() : getPopupContainer();
+    }
+    return (_ctx, _cache) => {
+      const _component_ACheckbox = Checkbox$1;
+      const _component_AButton = Button;
+      const _component_ATooltip = Tooltip;
+      const _component_ADivider = Divider$1;
+      const _component_ACheckboxGroup = CheckboxGroup;
+      const _component_APopover = Popover$1;
+      return openBlock(), createBlock(_component_ATooltip, { placement: "top" }, {
+        title: withCtx(() => [
+          createElementVNode("span", null, toDisplayString(unref$1(t)("COLUMN_CONTROL")), 1)
+        ]),
+        default: withCtx(() => [
+          createVNode(_component_APopover, {
+            placement: "bottomLeft",
+            trigger: "click",
+            overlayClassName: `${prefixCls}__cloumn-list`,
+            onVisibleChange: handleVisibleChange,
+            getPopupContainer: getPopupContainer$1
+          }, {
+            title: withCtx(() => [
+              createElementVNode("div", {
+                class: normalizeClass(`${prefixCls}__popover-title flex`)
+              }, [
+                createVNode(_component_ACheckbox, {
+                  indeterminate: unref$1(indeterminate),
+                  checked: unref$1(state).checkAll,
+                  "onUpdate:checked": _cache[0] || (_cache[0] = ($event) => unref$1(state).checkAll = $event),
+                  onChange: onCheckAllChange
+                }, {
+                  default: withCtx(() => [
+                    createTextVNode(toDisplayString(unref$1(t)("COLUMN_SHOW")), 1)
+                  ]),
+                  _: 1
+                }, 8, ["indeterminate", "checked"]),
+                createVNode(_component_ACheckbox, {
+                  checked: unref$1(checkIndex),
+                  "onUpdate:checked": _cache[1] || (_cache[1] = ($event) => isRef(checkIndex) ? checkIndex.value = $event : null),
+                  onChange: handleIndexCheckChange
+                }, {
+                  default: withCtx(() => [
+                    createTextVNode(toDisplayString(unref$1(t)("INDEX")), 1)
+                  ]),
+                  _: 1
+                }, 8, ["checked"]),
+                createVNode(_component_ACheckbox, {
+                  checked: unref$1(checkSelect),
+                  "onUpdate:checked": _cache[2] || (_cache[2] = ($event) => isRef(checkSelect) ? checkSelect.value = $event : null),
+                  onChange: handleSelectCheckChange,
+                  disabled: !unref$1(defaultRowSelection)
+                }, {
+                  default: withCtx(() => [
+                    createTextVNode(toDisplayString(unref$1(t)("CHECKBOX")), 1)
+                  ]),
+                  _: 1
+                }, 8, ["checked", "disabled"]),
+                createVNode(_component_AButton, {
+                  type: "link",
+                  onClick: reset
+                }, {
+                  default: withCtx(() => [
+                    createTextVNode(toDisplayString(unref$1(t)("RESET")), 1)
+                  ]),
+                  _: 1
+                })
+              ], 2)
+            ]),
+            content: withCtx(() => [
+              createVNode(_component_ACheckboxGroup, {
+                value: unref$1(state).checkedList,
+                "onUpdate:value": _cache[3] || (_cache[3] = ($event) => unref$1(state).checkedList = $event),
+                onChange,
+                ref_key: "columnListRef",
+                ref: columnListRef
+              }, {
+                default: withCtx(() => [
+                  (openBlock(true), createElementBlock(Fragment, null, renderList(unref$1(plainOptions), (item) => {
+                    return openBlock(), createElementBlock("div", {
+                      key: item.value,
+                      class: normalizeClass(`${prefixCls}__check-item flex pt-1 pr-4 pb-2 items-center`)
+                    }, [
+                      _hoisted_1$3,
+                      createVNode(_component_ACheckbox, {
+                        value: item.value
+                      }, {
+                        default: withCtx(() => [
+                          createTextVNode(toDisplayString(item.label), 1)
+                        ]),
+                        _: 2
+                      }, 1032, ["value"]),
+                      createVNode(_component_ATooltip, {
+                        placement: "bottomLeft",
+                        mouseLeaveDelay: 0.4,
+                        getPopupContainer: getPopupContainer$1
+                      }, {
+                        title: withCtx(() => [
+                          createTextVNode(toDisplayString(unref$1(t)("FIXED_TO_LEFT")), 1)
+                        ]),
+                        default: withCtx(() => [
+                          createElementVNode("span", {
+                            class: normalizeClass({
+                              disabled: !unref$1(state).checkedList.includes(item.value),
+                              active: item.fixed === "left"
+                            })
+                          }, [
+                            createElementVNode("i", {
+                              class: normalizeClass(["i mdi:arrow-collapse-left cursor-pointer", `${prefixCls}__fixed-left`]),
+                              onClick: ($event) => handleColumnFixed(item, "left")
+                            }, null, 10, _hoisted_2$1)
+                          ], 2)
+                        ]),
+                        _: 2
+                      }, 1032, ["mouseLeaveDelay"]),
+                      createVNode(_component_ADivider, { type: "vertical" }),
+                      createVNode(_component_ATooltip, {
+                        placement: "bottomLeft",
+                        mouseLeaveDelay: 0.4,
+                        getPopupContainer: getPopupContainer$1
+                      }, {
+                        title: withCtx(() => [
+                          createTextVNode(toDisplayString(unref$1(t)("FIXED_TO_RIGHT")), 1)
+                        ]),
+                        default: withCtx(() => [
+                          createElementVNode("span", {
+                            class: normalizeClass({
+                              disabled: !unref$1(state).checkedList.includes(item.value),
+                              active: item.fixed === "right"
+                            })
+                          }, [
+                            createElementVNode("i", {
+                              class: normalizeClass(["i mdi:arrow-collapse-right cursor-pointer", `${prefixCls}__fixed-right`]),
+                              onClick: ($event) => handleColumnFixed(item, "right")
+                            }, null, 10, _hoisted_3$1)
+                          ], 2)
+                        ]),
+                        _: 2
+                      }, 1032, ["mouseLeaveDelay"])
+                    ], 2);
+                  }), 128))
+                ]),
+                _: 1
+              }, 8, ["value"])
+            ]),
+            default: withCtx(() => [
+              _hoisted_4$1
+            ]),
+            _: 1
+          }, 8, ["overlayClassName"])
+        ]),
+        _: 1
+      });
+    };
+  }
+});
+const _hoisted_1$2 = { class: "flex dt-table-setting" };
+const _sfc_main$3 = /* @__PURE__ */ defineComponent$1({
+  __name: "index",
+  props: {
+    setting: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  emits: ["columns-change"],
+  setup(__props, { emit: emits }) {
+    const props2 = __props;
+    const getSetting = computed(() => {
+      return {
+        download: true,
+        setting: true,
+        fullscreen: true,
+        ...props2.setting
+      };
+    });
+    function handleColumnChange(data) {
+      emits("columns-change", data);
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$2, [
+        unref$1(getSetting).download ? (openBlock(), createBlock(_sfc_main$5, normalizeProps(mergeProps({ key: 0 }, unref$1(getSetting))), null, 16)) : createCommentVNode("", true),
+        unref$1(getSetting).setting ? (openBlock(), createBlock(_sfc_main$4, {
+          key: 1,
+          onColumnsChange: handleColumnChange
+        })) : createCommentVNode("", true),
+        unref$1(getSetting).fullscreen ? (openBlock(), createBlock(_sfc_main$e, { key: 2 })) : createCommentVNode("", true)
+      ]);
+    };
+  }
+});
+const _hoisted_1$1 = { class: "dt-table-header" };
+const _hoisted_2 = { class: "flex flex-row justify-between" };
+const _hoisted_3 = { class: "flex flex-row flex-1" };
+const _hoisted_4 = { key: 0 };
+const _hoisted_5 = {
+  key: 0,
+  class: "border dt-table-header-top text-12 bg-gray-100 mt-1 py-1 px-3 border-dashed"
+};
+const _sfc_main$2 = /* @__PURE__ */ defineComponent$1({
+  __name: "TableHeader",
+  props: {
+    tableSetting: {
+      type: [Object, Boolean]
+    },
+    toolbar: {
+      type: Array,
+      default: []
+    }
+  },
+  setup(__props) {
+    const props2 = __props;
+    const getActionsProps = {
+      mode: null,
+      showAdvancedButton: false,
+      show: true,
+      buttonList: props2.toolbar
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$1, [
+        createElementVNode("div", _hoisted_2, [
+          createElementVNode("div", _hoisted_3, [
+            unref$1(getActionsProps)?.buttonList.length ? (openBlock(), createBlock(unref$1(_sfc_main$f), normalizeProps(mergeProps({ key: 0 }, unref$1(getActionsProps))), null, 16)) : createCommentVNode("", true),
+            renderSlot(_ctx.$slots, "toolbar")
+          ]),
+          __props.tableSetting ? (openBlock(), createElementBlock("div", _hoisted_4, [
+            createVNode(_sfc_main$3, { setting: __props.tableSetting }, null, 8, ["setting"])
+          ])) : createCommentVNode("", true)
+        ]),
+        _ctx.$slots.headerTop ? (openBlock(), createElementBlock("div", _hoisted_5, [
+          renderSlot(_ctx.$slots, "headerTop")
+        ])) : createCommentVNode("", true)
+      ]);
+    };
+  }
+});
+function useTableHeader(propsRef, slots, handlers) {
+  const { t } = useI18n("UI");
+  const getHeaderProps = computed(() => {
+    const TABLE_TOOLS = [
+      { t: "\u65B0\u589E", name: t("ADD"), preIcon: "mdi:plus", type: "primary", onClick: unref(propsRef).onAdd },
+      { t: "\u5220\u9664", name: t("DELETE"), preIcon: "mdi:delete-outline", onClick: unref(propsRef).onDeletes }
+    ];
+    const { tableSetting, toolbar = TABLE_TOOLS } = unref(propsRef);
+    const { getSlot } = useSlots$1();
+    const hideTitle = (!toolbar || !toolbar.filter((it) => it.show ?? true).length) && !slots.toolbar && !slots.headerTop && !tableSetting;
+    return {
+      title: hideTitle ? null : () => h(
+        _sfc_main$2,
+        {
+          tableSetting,
+          toolbar,
+          onColumnsChange: handlers.onColumnsChange
+        },
+        {
+          ...slots.toolbar ? {
+            toolbar: () => getSlot(slots, "toolbar")
+          } : {},
+          ...slots.headerTop ? {
+            headerTop: () => getSlot(slots, "headerTop")
+          } : {}
+        }
+      )
+    };
+  });
+  return {
+    getHeaderProps
+  };
+}
+function useLoading(props2) {
+  const getLoading = ref(false);
+  watch(
+    () => unref(props2)?.loading,
+    (v) => getLoading.value = v
+  );
+  function setLoading(loading) {
+    getLoading.value = loading;
+  }
+  return {
+    getLoading,
+    setLoading
+  };
+}
+function usePagination(props2) {
+  const { t } = useI18n("UI");
+  const paginationRef = ref();
+  const showPagination = ref(true);
+  const { getUiSize } = useHeader();
+  watch(
+    () => unref(props2).pagination,
+    (pagination) => {
+      if (!isBoolean(pagination) && pagination) {
+        paginationRef.value = {
+          ...unref(paginationRef),
+          ...pagination ?? {}
+        };
+      }
+    }
+  );
+  const getPaginationInfo = computed(() => {
+    const { pagination } = unref(props2);
+    if (!unref(showPagination) || isBoolean(pagination) && !pagination) {
+      return false;
+    }
+    const { appConf } = useAppStore();
+    const { defaultPageSize = pagination.pageSize, pageSizeOptions } = appConf.ui.table;
+    return {
+      current: 1,
+      pageSize: defaultPageSize,
+      defaultPageSize,
+      showTotal: (total, range) => t("TOTAL_PAGE", { total }),
+      showSizeChanger: true,
+      pageSizeOptions,
+      showQuickJumper: true,
+      class: `dt-pagination dt-pagination-${unref(getUiSize)}`,
+      ...isBoolean(pagination) ? {} : pagination,
+      ...unref(paginationRef)
+    };
+  });
+  function setPagination(info) {
+    const paginationInfo = unref(getPaginationInfo);
+    paginationRef.value = {
+      ...!isBoolean(paginationInfo) ? paginationInfo : {},
+      ...info
+    };
+  }
+  function getPagination() {
+    return unref(getPaginationInfo);
+  }
+  function getShowPagination() {
+    return unref(showPagination);
+  }
+  function setShowPagination(flag) {
+    showPagination.value = flag;
+  }
+  return {
+    getPaginationInfo,
+    setPagination,
+    getPagination,
+    getShowPagination,
+    setShowPagination
+  };
+}
+const DEFAULT_CONFIG = {
+  id: "id",
+  children: "children",
+  pid: "pid"
+};
+function useRowSelection(propsRef, emit) {
+  const selectedRowKeysRef = ref([]);
+  const selectedRowRef = ref([]);
+  const getRowSelectionRef = computed(() => {
+    const { rowSelection, showCheckboxColumn } = unref(propsRef);
+    if (!rowSelection && !showCheckboxColumn)
+      return null;
+    if (isBoolean(showCheckboxColumn)) {
+      if (showCheckboxColumn) {
+        rowSelection.type = "checkbox";
+      } else {
+        return null;
+      }
+    }
+    return {
+      selectedRowKeys: unref(selectedRowKeysRef),
+      onChange: (selectedRowKeys) => setSelectedRowKeys(selectedRowKeys),
+      ...omit(rowSelection, ["onChange"])
+    };
+  });
+  function findeNodeAll(tree, func, config = {}) {
+    const _config = Object.assign({}, DEFAULT_CONFIG, config), result = [], list = [...tree];
+    for (const node of list) {
+      func(node) && result.push(node);
+      node[_config?.children] && list.push(...node[_config?.children]);
+    }
+    return result;
+  }
+  function setSelectedRowKeys(rowKeys) {
+    selectedRowKeysRef.value = rowKeys;
+    const allSelectedRows = findeNodeAll(
+      toRaw(unref(propsRef).dataSource).concat(toRaw(unref(selectedRowRef))),
+      (item) => rowKeys.includes(item[unref(propsRef).rowKey]),
+      {
+        children: propsRef.value.childrenColumnName ?? "children"
+      }
+    );
+    const trueSelectedRows = [];
+    rowKeys.forEach((key) => {
+      const found = allSelectedRows.find((item) => item[unref(propsRef).rowKey] === key);
+      found && trueSelectedRows.push(found);
+    });
+    selectedRowRef.value = trueSelectedRows;
+  }
+  function clearSelectedRowKeys() {
+    selectedRowKeysRef.value = [];
+    selectedRowRef.value = [];
+  }
+  function getRowSelection() {
+    return unref(getRowSelectionRef);
+  }
+  function getSelectedRowKeys() {
+    return unref(selectedRowKeysRef);
+  }
+  function getSelectRows() {
+    return unref(selectedRowRef);
+  }
+  watch(
+    () => unref(propsRef).rowSelection?.selectedRowKeys,
+    (v) => {
+      setSelectedRowKeys(v);
+    }
+  );
+  watch(
+    () => unref(selectedRowKeysRef),
+    () => {
+      nextTick(() => {
+        const { rowSelection } = unref(propsRef);
+        if (rowSelection) {
+          const { onChange } = rowSelection;
+          if (onChange && isFunction(onChange))
+            onChange(getSelectedRowKeys(), getSelectRows());
+        }
+        emit("selection-change", {
+          keys: getSelectedRowKeys(),
+          rows: getSelectRows()
+        });
+      });
+    },
+    { deep: true }
+  );
+  return {
+    getRowSelectionRef,
+    clearSelectedRowKeys,
+    getRowSelection,
+    getSelectedRowKeys,
+    getSelectRows,
+    setSelectedRowKeys
+  };
+}
+function useTableScroll(propsRef, tableElRef, columnsRef, rowSelectionRef) {
+  const tableHeightRef = ref(0), filterSource = ref([]);
+  ref(null);
+  let footerEl, bodyEl;
+  const debounceRedoHeight = useDebounceFn(redoHeight, 100);
+  windowResizeFn(calcTableHeight, 280);
+  const getCanResize = computed(() => {
+    const { canResize, scroll } = unref(propsRef);
+    return canResize && !(scroll || {}).y;
+  });
+  watch(
+    () => propsRef.value.dataSource,
+    (v) => {
+      debounceRedoHeight();
+    },
+    {
+      deep: true,
+      flush: "post"
+    }
+  );
+  function redoHeight() {
+    nextTick(() => calcTableHeight());
+  }
+  function setHeight(height) {
+    tableHeightRef.value = height;
+  }
+  async function calcTableHeight() {
+    const { pagination, virtual } = unref(propsRef);
+    const table = unref(tableElRef);
+    const tableEl = table?.$el;
+    const tableData = unref(propsRef).dataSource;
+    if (!tableEl)
+      return;
+    if (!bodyEl) {
+      bodyEl = tableEl.querySelector(".ant-table-body");
+      if (!bodyEl)
+        return;
+    }
+    const hasScrollBarY = bodyEl.scrollHeight > bodyEl.clientHeight;
+    const hasScrollBarX = bodyEl.scrollWidth > bodyEl.clientWidth;
+    if (hasScrollBarY) {
+      tableEl.classList.contains("hide-scrollbar-y") && tableEl.classList.remove("hide-scrollbar-y");
+    } else {
+      !tableEl.classList.contains("hide-scrollbar-y") && tableEl.classList.add("hide-scrollbar-y");
+    }
+    if (hasScrollBarX) {
+      tableEl.classList.contains("hide-scrollbar-x") && tableEl.classList.remove("hide-scrollbar-x");
+    } else {
+      !tableEl.classList.contains("hide-scrollbar-x") && tableEl.classList.add("hide-scrollbar-x");
+    }
+    bodyEl.style.height = "unset";
+    if (!unref(getCanResize) || !unref(tableData) || tableData.length === 0)
+      return;
+    await nextTick();
+    let headerHeight = 0, paginationHeight = 2, footerHeight = 0, titleHeight = tableEl.querySelector(".ant-table-title")?.offsetHeight ?? 0, marginHeight = 15;
+    const headEl = tableEl.querySelector(".ant-table-thead ");
+    if (headEl) {
+      headerHeight = headEl.offsetHeight;
+    }
+    if (!isBoolean(pagination)) {
+      let paginationEl = tableEl.querySelector(".ant-pagination");
+      if (paginationEl) {
+        const offsetHeight = paginationEl.offsetHeight;
+        paginationHeight += offsetHeight || 0;
+      } else {
+        paginationHeight += 50;
+      }
+      if (!footerEl) {
+        footerEl = tableEl.querySelector(".ant-table-footer");
+      } else {
+        const offsetHeight = footerEl.offsetHeight;
+        footerHeight += offsetHeight || 0;
+      }
+    } else {
+      paginationHeight = -8;
+    }
+    const tableHeight = table?.$el?.offsetHeight ?? 0;
+    let height = tableHeight - paginationHeight - footerHeight - headerHeight - titleHeight - marginHeight;
+    height = Math.max(height, 167);
+    setHeight(height);
+    bodyEl.style.height = `${height}px`;
+    filterSource.value = unref(propsRef)?.dataSource;
+  }
+  const getScrollX = computed(() => {
+    let width = 0;
+    if (unref(rowSelectionRef)) {
+      width += 32;
+    }
+    const NORMAL_WIDTH = 120;
+    const columns = unref(columnsRef).filter((item) => !item.defaultHidden);
+    columns.forEach((item) => {
+      width += Number.parseInt(item.width) || NORMAL_WIDTH;
+    });
+    const table = unref(tableElRef);
+    const tableWidth = table?.$el?.offsetWidth ?? 0;
+    return tableWidth > width ? "100%" : width;
+  });
+  const getScrollRef = computed(() => {
+    const tableHeight = unref(tableHeightRef);
+    const { canResize, scroll } = unref(propsRef);
+    return {
+      x: unref(getScrollX),
+      y: tableHeight,
+      scrollToFirstRowOnChange: false,
+      ...scroll
+    };
+  });
+  onMounted(() => {
+    calcTableHeight();
+    nextTick(() => debounceRedoHeight());
+  });
+  return {
+    getScrollRef,
+    filterSource
+  };
+}
+function useRows(propsRef) {
+  function getRowClassName(record, index2) {
+    const { striped, rowClassName } = unref(propsRef);
+    const classNames = [];
+    if (striped) {
+      classNames.push(index2 % 2 === 1 ? "table-striped" : "");
+    }
+    if (rowClassName && isFunction(rowClassName)) {
+      classNames.push(rowClassName(record, index2));
+    }
+    return classNames.join(" ");
+  }
+  return {
+    getRowClassName
+  };
+}
+const props = {
+  column: Object,
+  record: Object,
+  index: Number
+};
+const _sfc_main$1 = defineComponent({
+  name: "TableRender",
+  props,
+  setup(props2, {}) {
+    let renderText = ref(null);
+    watch(() => [props2.record, props2.column], (v) => {
+      if (v) {
+        renderCell();
+      }
+    }, {
+      immediate: true,
+      deep: true
+    });
+    function renderCell() {
+      const {
+        column,
+        record,
+        index: index2
+      } = props2;
+      const {
+        render,
+        dataIndex
+      } = column;
+      const text = record[dataIndex.toString()];
+      if (isObject(render)) {
+        const {
+          dict,
+          date,
+          number,
+          percent,
+          struc
+        } = render;
+        if (struc) {
+          const {
+            appConf
+          } = useAppStore();
+          let apiStruc = appConf.structure[struc];
+          if (!apiStruc) {
+            error(`${struc}\u672A\u5728structure\u4E2D\u914D\u7F6E`);
+          } else {
+            renderText = getDictValueByCode(text, apiStruc);
+          }
+        } else if (dict) {
+          renderText = getDictValueByCode(text, dict);
+        } else if (date) {
+          renderText.value = (text && dayjs(text).format(date || "YYYY-MM-DD")) ?? "";
+        } else if (number) {
+          renderText.value = formatNumber(text, number);
+        } else if (percent) {
+          renderText.value = formatNumber((text || 0) * 100, percent) + "%";
+        } else if (isVnode(render)) {
+          renderText.value = createVNode(Fragment, null, [createTextVNode(" "), render, createTextVNode(" ")]);
+        } else if (render["setup"]) {
+          renderText.value = createVNode(render, {
+            ...record,
+            text
+          });
+        }
+      } else if (isFunction(render)) {
+        let afterRenderData = render(record, index2, text);
+        if (afterRenderData.__v_isRef) {
+          renderText = afterRenderData;
+        } else if (afterRenderData["setup"]) {
+          renderText.value = createVNode(afterRenderData, {
+            ...record,
+            text
+          });
+        } else {
+          renderText.value = isVnode(afterRenderData) ? createVNode(Fragment, null, [afterRenderData]) : afterRenderData;
+        }
+      } else {
+        renderText.value = unref(text);
+      }
+    }
+    return () => createVNode("span", null, [unref(renderText)]);
+  }
+});
+const DEFAULT_SORT_FN = (sortInfo) => {
+  const { field, order } = sortInfo;
+  return field && order ? { field, order } : {};
+};
+const TableProps = {
+  clickToSelectRow: { type: Boolean, default: false },
+  tableSetting: { type: [Boolean, Object], default: () => ({}) },
+  striped: { type: Boolean, default: true },
+  canColDrag: { type: Boolean, default: true },
+  clearSelectOnPageChange: { type: Boolean, default: false },
+  resizable: { type: Boolean, default: true },
+  minWidth: { type: Number },
+  maxWidth: { type: Number },
+  virtual: { type: Boolean, default: false },
+  sortFn: { type: Function, default: DEFAULT_SORT_FN },
+  defSort: { type: Object, default: null },
+  filterFn: {
+    type: Function,
+    default: (data) => {
+      return data;
+    }
+  },
+  rowKey: {
+    type: String,
+    default: "id"
+  },
+  columnCode: { type: String, default: "" },
+  columns: { type: [Array], default: () => [] },
+  slotsTemplate: { type: Object, default: {} },
+  showIndexColumn: { type: Boolean, default: false },
+  showCheckboxColumn: { type: Boolean, default: true },
+  expandMethodIcon: { type: Boolean, default: false },
+  ellipsis: { type: Boolean, default: true },
+  dataSource: { type: Array, default: null },
+  bordered: { type: Boolean, default: true },
+  canResize: { type: Boolean, default: true },
+  pagination: {
+    type: [Object, Boolean],
+    default: {
+      pageSize: 20,
+      current: 1
+    }
+  },
+  loading: { type: Boolean, default: false },
+  rowClassName: { type: Function },
+  scroll: {
+    type: Object,
+    default: {}
+  },
+  onTableChange: {
+    type: Function,
+    default: () => {
+    }
+  },
+  onDownload: {
+    type: Function,
+    default: (excelData) => {
+    }
+  },
+  rowSelection: {
+    type: Object,
+    default: {
+      type: "checkbox",
+      fixed: true
+    }
+  },
+  customRow: {
+    type: Function,
+    default: () => {
+    }
+  },
+  childrenColumnName: {
+    type: String,
+    default: "children"
+  },
+  indexColumnProps: {
+    type: [Array],
+    default: () => []
+  },
+  isTreeTable: {
+    type: Boolean,
+    default: false
+  },
+  operations: {
+    type: Object
+  },
+  toolbar: {
+    type: Array
+  },
+  registerInstance: {
+    type: Function
+  },
+  onAdd: {
+    type: Function,
+    default: (params) => {
+    }
+  },
+  onUpdate: {
+    type: Function,
+    default: (params) => {
+    }
+  },
+  onDelete: {
+    type: Function,
+    default: (params) => {
+    }
+  },
+  onDeletes: {
+    type: Function,
+    default: (params) => {
+    }
+  }
+};
+const _hoisted_1 = /* @__PURE__ */ createElementVNode("img", { src: _imports_0 }, null, -1);
+const _sfc_main = /* @__PURE__ */ defineComponent$1({
+  __name: "index",
+  props: TableProps,
+  emits: [
+    "register",
+    "selection-change",
+    "columns-change",
+    "row-click",
+    "row-dbClick",
+    "row-contextmenu",
+    "row-mouseenter",
+    "row-mouseleave",
+    "edit-change"
+  ],
+  setup(__props, { emit: emits }) {
+    const props2 = __props;
+    const tableElRef = ref(null);
+    const attrs = useAttrs();
+    const slots = useSlots();
+    const innerPropsRef = ref();
+    const getProps = computed(() => {
+      return { ...props2, ...unref(innerPropsRef) };
+    });
+    const { getRowClassName } = useRows(getProps);
+    const tableCls = computed(() => {
+      return [
+        "dt-table",
+        "box-border",
+        { "dt-table-no-pagation": !unref(getProps).pagination }
+      ];
+    });
+    const { getLoading, setLoading } = useLoading(getProps);
+    const { getPaginationInfo, setPagination, getPagination, getShowPagination, setShowPagination } = usePagination(getProps);
+    const {
+      getViewColumns,
+      getColumnsRef,
+      getColumns,
+      setColumns,
+      setColumnsByDataIndex,
+      getCacheColumns
+    } = useColumns(getProps, getPaginationInfo, tableElRef);
+    const {
+      getRowSelectionRef,
+      clearSelectedRowKeys,
+      getRowSelection,
+      getSelectRows,
+      getSelectedRowKeys,
+      setSelectedRowKeys
+    } = useRowSelection(getProps, emits);
+    const { getScrollRef, filterSource } = useTableScroll(getProps, tableElRef, getColumnsRef, getRowSelectionRef);
+    const handlers = {
+      onColumnsChange: (data) => {
+        emits("columns-change", data);
+        unref(getProps).onColumnsChange?.(data);
+      }
+    };
+    const { getHeaderProps } = useTableHeader(getProps, slots, handlers);
+    const { customRow } = useCustomRow(getProps, { setSelectedRowKeys, getSelectedRowKeys, clearSelectedRowKeys, emits });
+    const { handleTableChange, findTableDataRecord, updateTableDataRecord } = useDataSource(
+      getProps,
+      {
+        getPaginationInfo,
+        setPagination,
+        clearSelectedRowKeys
+      }
+    );
+    const getBind = computed(() => {
+      return {
+        ...attrs,
+        ...unref(getProps),
+        ...unref(getHeaderProps),
+        scroll: unref(getScrollRef),
+        loading: unref(getLoading),
+        dataSource: toRaw(unref(filterSource)),
+        pagination: toRaw(unref(getPaginationInfo)),
+        rowSelection: unref(getRowSelectionRef),
+        rowKey: unref(getProps).rowKey,
+        columns: unref(getViewColumns),
+        tableLayout: "fixed",
+        class: unref(tableCls),
+        customRow,
+        onChange: handleTableChange,
+        onResizeColumn: (w, col) => {
+          col.width = w;
+          setColumnsByDataIndex(col.dataIndex, col);
+        }
+      };
+    });
+    function setProps(props22) {
+      let allProps = {
+        ...unref(innerPropsRef),
+        ...props22
+      };
+      if (isObject(props22.tableSetting)) {
+        let historyTableSetting = unref(innerPropsRef)?.tableSetting;
+        allProps.tableSetting = {
+          ...isBoolean(historyTableSetting) ? {} : historyTableSetting,
+          ...props22.tableSetting
+        };
+      }
+      innerPropsRef.value = allProps;
+    }
+    const tableAction = {
+      setProps,
+      setLoading,
+      clearSelectedRowKeys,
+      getSelectRows,
+      getSelectedRowKeys,
+      setSelectedRowKeys,
+      getRowSelection,
+      getColumns,
+      setColumns,
+      setColumnsByDataIndex,
+      getCacheColumns,
+      findTableDataRecord,
+      updateTableDataRecord,
+      getPagination,
+      emits
+    };
+    createTableInstance({ ...tableAction, tableElRef, getBind, getProps });
+    emits("register", tableAction);
+    if (unref(innerPropsRef)?.registerInstance) {
+      unref(innerPropsRef)?.registerInstance(tableAction);
+    }
+    return (_ctx, _cache) => {
+      const _component_ATable = Table;
+      return openBlock(), createBlock(_component_ATable, mergeProps({
+        ref_key: "tableElRef",
+        ref: tableElRef
+      }, unref$1(getBind), {
+        rowClassName: unref$1(getRowClassName),
+        onChange: unref$1(handleTableChange)
+      }), createSlots({
+        bodyCell: withCtx(({ column, record, index: index2 }) => [
+          _ctx.$slots.bodyCell ? renderSlot(_ctx.$slots, "bodyCell", normalizeProps(mergeProps({ key: 0 }, { column, record, index: index2 }))) : createCommentVNode("", true),
+          column?.render && !_ctx.$slots.bodyCell ? (openBlock(), createBlock(_sfc_main$1, {
+            key: 1,
+            column,
+            record,
+            index: index2
+          }, null, 8, ["column", "record", "index"])) : createCommentVNode("", true)
+        ]),
+        emptyText: withCtx(() => [
+          _hoisted_1
+        ]),
+        _: 2
+      }, [
+        renderList(Object.keys(_ctx.$slots), (item) => {
+          return {
+            name: item,
+            fn: withCtx((data) => [
+              renderSlot(_ctx.$slots, item, normalizeProps(guardReactiveProps(data || {})))
+            ])
+          };
+        })
+      ]), 1040, ["rowClassName", "onChange"]);
+    };
+  }
+});
+export {
+  _sfc_main as DtTable,
+  useTable
+};