@dt-frames/ui 2.0.1 → 2.0.3

package/es/components/curd/index.js

@@ -0,0 +1,3120 @@
+import { toRaw as toRaw$1, unref as unref$1, computed, getCurrentInstance as getCurrentInstance$1, reactive, readonly, watchEffect, nextTick as nextTick$1, defineComponent, useAttrs, openBlock, createBlock, mergeProps, isRef, withCtx, createElementBlock, Fragment, renderList, createTextVNode, toDisplayString, createElementVNode, createVNode, normalizeProps, guardReactiveProps, createCommentVNode, toRefs, isVNode, ref as ref$1, watch, resolveDirective, normalizeStyle, withDirectives, normalizeClass, onMounted as onMounted$1, withKeys, createSlots, renderSlot, onUnmounted, inject, h, provide, onBeforeUnmount, resolveDynamicComponent } from "vue";
+import { RadioButton, RadioGroup, Button, FormItem as FormItem$1, Col as Col$1, Row, Form as Form$1, Tooltip as Tooltip$1, Spin } from "ant-design-vue/es";
+import "ant-design-vue/es/form/style";
+import { DtCache, CacheKey, deepMerge, Pages, useGo, useRedo, Language, useAppStore, isNumber, useI18n, isString, isFunction, error, useSlots, isArray, isBoolean, isNull, dispatchResize, isObject, isNullAndUnDef, isEmpty, useTimeoutFn, useApp, off, on, windowResizeFn, useMessage } from "@dt-frames/core";
+import { isEqual, omit, cloneDeep, upperFirst, uniqBy, set } from "lodash-es";
+import { Input, Select, TreeSelect, Radio, Checkbox, AutoComplete, Cascader, DatePicker, InputNumber, Switch, TimePicker, Slider, Rate, Divider, Col, Tooltip, Form, FormItem, Modal as Modal$1 } from "ant-design-vue";
+import { defineStore } from "pinia";
+import "ant-design-vue/es/button/style";
+import dayjs from "dayjs";
+const _default = "";
+const index$3 = "";
+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(() => getMenuConf.collapsedShowTitle);
+  const getIsSidebarType = computed(() => getMenuConf.type === MenuType.SIDE);
+  const getMenuFixed = computed(() => getMenuConf.fixed);
+  const getShowMenu = computed(() => getMenuConf.show);
+  const getShowSidebar = computed(() => {
+    return unref$1(getSplit) || unref$1(getShowMenu) && unref$1(getMenuMode) !== MenuMode.HORIZONTAL;
+  });
+  const getMenuHidden = computed(() => getMenuConf.hidden);
+  const getMenuTheme = computed(() => getMenuConf.theme);
+  const getTrigger = computed(() => getMenuConf.trigger);
+  const getCanDrag = computed(() => getMenuConf.canDrag);
+  const getIsMixMode = computed(() => {
+    return unref$1(getMenuMode) === MenuMode.INLINE && unref$1(getMenuType) === MenuType.MIX;
+  });
+  const getMenuWidth = computed(() => unref$1(getIsMixMode) ? Number(getMenuConf.menuWidth) - 40 : getMenuConf.menuWidth);
+  const getLogoWidth = computed(() => getMenuConf.menuWidth);
+  const getMenuType = computed(() => getMenuConf.type);
+  const getIsTopMenu = computed(() => unref$1(getMenuType) === MenuType.TOP_MENU);
+  const getMenuMode = computed(() => getMenuConf.mode);
+  const getSplit = computed(() => getMenuConf.split);
+  const getCollapsed = computed(() => getMenuConf.collapsed);
+  const getIsHorizontal = computed(() => unref$1(getMenuMode) === MenuMode.HORIZONTAL);
+  const setThemeStore = (conf = {}) => setThemeConf(conf);
+  const toggleCollapsed = () => setThemeStore({
+    menuOptions: {
+      collapsed: !unref$1(getCollapsed)
+    }
+  });
+  const getMiniWidthNumber = computed(() => getMenuConf.collapsedShowTitle ? 80 : 48);
+  const getRealWidth = computed(() => {
+    return unref$1(getCollapsed) ? unref$1(getMiniWidthNumber) : unref$1(getMenuWidth);
+  });
+  const getCalcContentWidth = computed(() => {
+    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(() => getHeaderConf.theme);
+  const getFixed = computed(() => getHeaderConf.fixed);
+  const getShowHeaderLogo = computed(() => unref$1(getShowLogo) && !unref$1(getIsSidebarType));
+  const getShowSearch = computed(() => getHeaderConf.showSearch);
+  const getShowHeaderTrigger = computed(() => {
+    if (unref$1(getMenuType) === MenuType.TOP_MENU || !unref$1(getShowMenu) || unref$1(getMenuHidden)) {
+      return false;
+    }
+    return unref$1(getTrigger);
+  });
+  const getShowBreadCrumb = computed(() => getHeaderConf.showBreadCrumb);
+  const getShowBread = computed(
+    () => unref$1(getMenuMode) !== MenuMode.HORIZONTAL && !unref$1(getSplit) && unref$1(getShowBreadCrumb)
+  );
+  const getShowTopMenu = computed(() => unref$1(getMenuMode) === MenuMode.HORIZONTAL || unref$1(getSplit));
+  const getShowNotice = computed(() => getHeaderConf.showNotice);
+  const getShowFullScreen = computed(() => getHeaderConf.showFullScreen);
+  const getShowLocale = computed(() => getHeaderConf.showLocaleSwitch);
+  const getShowSettingTheme = computed(() => getHeaderConf.showSettingTheme);
+  const getShowFullHeaderRef = computed(() => {
+    return !unref$1(getIsSidebarType) && !unref$1(getIsTopMenu);
+  });
+  const getHeaderHeight = computed(() => {
+    let height = 0;
+    height += HEADER_HEIGHT;
+    if (unref$1(getShowMultipleTab) && !unref$1(getSplit)) {
+      height += TABS_HEIGHT;
+    }
+    return height;
+  });
+  const getTabsHeight = computed(() => TABS_HEIGHT);
+  const getShowInsetHeaderRef = computed(() => {
+    return unref$1(getIsSidebarType) || unref$1(getIsTopMenu);
+  });
+  const getShowBackToTop = computed(() => getHeaderConf.showBackToTop);
+  const getIsZH = computed(() => {
+    let local = DtCache.getLocal(CacheKey.LOCALE);
+    if (!local)
+      return true;
+    return local === Language.ZH;
+  });
+  const getUiSize = computed(() => getHeaderConf?.size ?? UiSize.SMALL);
+  const getShowUiSize = computed(() => getHeaderConf?.showSize);
+  const getShowLogo = computed(() => getHeaderConf.showLogo);
+  const getShowLoginOut = computed(() => 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
+  };
+}
+function useLabelWidth(schemaItemRef, propsRef) {
+  const { getIsZH } = useHeader();
+  const { appConf } = useAppStore();
+  return computed(() => {
+    const { labelWidth, enLabelWidth, labelCol = {}, wrapperCol = {} } = unref$1(schemaItemRef);
+    const {
+      labelWidth: gLabelWidth,
+      enLabelWidth: gEnLabelWidth,
+      labelCol: glabelCol = {},
+      wrapperCol: gwrapperCol = {},
+      layout = appConf.ui.form.layout
+    } = unref$1(propsRef);
+    let width = (unref$1(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"];
+const MULTIFY_DATA_TYPE = ["RangePicker"];
+const DATE_PICKER_TYPES = [...SINGLE_DATA_TYPE, ...MULTIFY_DATA_TYPE];
+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 handleInputNumberValue(component, val) {
+  if (!component)
+    return val;
+  if ([
+    "Input",
+    "InputPassword",
+    "InputSearch",
+    "InputTextArea"
+  ].includes(component)) {
+    return val && isNumber(val) ? `${val}` : val;
+  }
+  return val;
+}
+const index$2 = "";
+function useFormValue(props, key = "value", changeEvent = "change", emitData) {
+  const instance = getCurrentInstance$1();
+  const emit = instance?.emit;
+  const innerState = reactive({
+    value: props[key]
+  });
+  const defaultState = readonly(innerState);
+  const setState = (val) => {
+    innerState.value = val;
+    nextTick$1(() => {
+      emit?.(changeEvent, val, ...toRaw$1(unref$1(emitData)) || []);
+    });
+  };
+  watchEffect(() => {
+    innerState.value = props[key];
+  });
+  const state = computed({
+    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$d = /* @__PURE__ */ defineComponent({
+  __name: "radioButton",
+  props: {
+    value: {
+      type: [String, Number, Boolean]
+    },
+    options: {
+      type: Array,
+      default: () => []
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const attrs = useAttrs();
+    const [state] = useFormValue(props);
+    const getOptions = computed(() => {
+      const { options } = props;
+      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 _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const RadioButtonGroup = /* @__PURE__ */ _export_sfc(_sfc_main$d, [["__file", "D:/dt/dt-frame-front/dt-frames/frames/packages/ui/src/components/form/src/components/radioButton.vue"]]);
+const _hoisted_1$2 = { class: "input-with-dialog" };
+const _sfc_main$c = /* @__PURE__ */ defineComponent({
+  __name: "formInputUseDialog",
+  setup(__props) {
+    const { t } = useI18n("UI");
+    const attrs = useAttrs();
+    const bindProps = computed(() => {
+      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$2, [
+        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("v-if", true)
+      ]);
+    };
+  }
+});
+const DtFormInputDialog = /* @__PURE__ */ _export_sfc(_sfc_main$c, [["__file", "D:/dt/dt-frame-front/dt-frames/frames/packages/ui/src/components/form/src/components/formInputUseDialog.vue"]]);
+const components = {
+  Input,
+  InputWithDialog: DtFormInputDialog,
+  InputTextArea: Input.TextArea,
+  InputSearch: Input.Search,
+  InputGroup: Input.Group,
+  InputPassword: Input.Password,
+  Select,
+  TreeSelect,
+  Radio,
+  RadioGroup: Radio.Group,
+  RadioButtonGroup,
+  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);
+}
+const _sfc_main$b = {
+  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(props, {
+    emit,
+    slots
+  }) {
+    const {
+      getSlot
+    } = useSlots();
+    const {
+      t
+    } = useI18n("UI");
+    const {
+      getUiSize
+    } = useHeader();
+    const {
+      appConf
+    } = useAppStore();
+    const {
+      schema,
+      formProps
+    } = toRefs(props);
+    const getValues = computed(() => {
+      const {
+        defaultValues,
+        formModel,
+        schema: schema2
+      } = props;
+      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
+      } = props.schema;
+      if (!isAdvanced) {
+        return false;
+      }
+      if (isFunction(show)) {
+        return show(unref$1(getValues).model);
+      }
+      return show;
+    });
+    const getComponentProps = computed(() => {
+      const {
+        schema: schema2
+      } = props;
+      let {
+        props: cProps = {}
+      } = schema2;
+      if (isFunction(cProps)) {
+        cProps = cProps(unref$1(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
+      } = props.schema;
+      const {
+        labelCol,
+        wrapperCol
+      } = unref$1(useLabelWidth(schema, formProps));
+      const getContent = () => {
+        const value = unref$1(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$1(getValues).model) : suffix;
+      };
+      const getPrefix = () => {
+        return isFunction(prefix) ? prefix(unref$1(getValues).model) : prefix;
+      };
+      return createVNode(Form.Item, {
+        "name": isArray(name) ? name.join("-") : name,
+        "colon": colon,
+        "class": [unref$1(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 = {}
+      } = props.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$1(getValues).model) : toolTip;
+      const _toolTipProps = {
+        title: renderLabel2,
+        autoAdjustOverflow: true,
+        placement: "top",
+        ...toolTipProps
+      };
+      return _toolTip ? createVNode("span", null, [createVNode(Tooltip, _toolTipProps, _isSlot$1(renderLabel2) ? renderLabel2 : {
+        default: () => [renderLabel2]
+      })]) : renderLabel2;
+    }
+    function renderFormItem() {
+      const {
+        schema: schema2,
+        formModel,
+        formActionType
+      } = props;
+      const {
+        component,
+        name,
+        changeEvent = "change",
+        valueField,
+        renderComponent,
+        props: sProps
+      } = props.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)) {
+            props.setFormModel(name, value);
+          } else if (isArray(name)) {
+            name.map((key) => props.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
+        } = props.formProps;
+        const {
+          disabled
+        } = props.schema;
+        const {
+          disabled: itemDisabled = false
+        } = unref$1(getComponentProps);
+        let _disabled = !!gDisabled || itemDisabled;
+        if (isBoolean(disabled))
+          _disabled = disabled;
+        if (isFunction(disabled))
+          _disabled = disabled(unref$1(getValues).model);
+        return _disabled;
+      });
+      const itemProps = {
+        allowClear: _sProps?.allowClear ?? appConf.ui.form.allowClear,
+        size: unref$1(getUiSize) === UiSize.MIDDLE ? "default" : unref$1(getUiSize),
+        ...unref$1(getComponentProps),
+        disabled: unref$1(getDisable)
+      };
+      if (component === "Select") {
+        {
+          itemProps.showSearch = true;
+          itemProps.optionFilterProp = "label";
+        }
+      }
+      if (!itemProps.disabled && component !== "RangePicker") {
+        itemProps.placeholder = unref$1(getComponentProps)?.placeholder || createPlaceholder(component);
+      }
+      if (["DatePicker", "MonthPicker", "RangePicker"].includes(component)) {
+        itemProps.defaultValue = props.formModel[name];
+      }
+      itemProps.codeName = name;
+      itemProps.formValues = unref$1(getValues);
+      if (["Select", "DatePicker", "MonthPicker", "WeekPicker", "RangePicker"].includes(component)) {
+        itemProps.dropdownClassName += ` ${unref$1(getUiSize)}`;
+      }
+      const bindValue = {
+        [valueField || (isCheck ? "checked" : "value")]: props.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$1(getValues))
+      } : {
+        default: () => renderComponent
+      };
+      return createVNode(Comp, compAttr, _isSlot$1(compSlot) ? compSlot : {
+        default: () => [compSlot]
+      });
+    }
+    function handleRules() {
+      const {
+        rules: defaultRules = [],
+        component,
+        label,
+        dynamicRules,
+        required
+      } = props.schema;
+      if (!component)
+        return [];
+      if (isFunction(dynamicRules)) {
+        return dynamicRules(unref$1(getValues).model);
+      }
+      const defaultMsg = createPlaceholder(component) + label;
+      let rules = cloneDeep(defaultRules);
+      const getRequired = isFunction(required) ? required(unref$1(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$1(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$1(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$1(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
+      } = props.schema;
+      const {
+        colProps: gColProps,
+        mode
+      } = props.formProps;
+      let _colProps = colProps || gColProps || (mode === "search" ? appConf.ui.form.searchColspan : appConf.ui.form.dialogColspan);
+      const values = unref$1(getValues);
+      if (!component) {
+        if (!render && !renderCol && !slot) {
+          error(t("NEED_RENDER"));
+          return;
+        }
+      }
+      if (component === "Divider") {
+        let _slot;
+        let cprops = unref$1(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$1(getShow) && createVNode(Col, _colProps, _isSlot$1(_slot2 = getContent()) ? _slot2 : {
+        default: () => [_slot2]
+      });
+    };
+  }
+};
+const DtFormItem = /* @__PURE__ */ _export_sfc(_sfc_main$b, [["__file", "D:/dt/dt-frame-front/dt-frames/frames/packages/ui/src/components/form/src/components/FormItem.vue"]]);
+const _hoisted_1$1 = {
+  key: 0,
+  className: "preIcon pr-1"
+};
+const _hoisted_2 = {
+  key: 0,
+  className: "preIcon pl-1"
+};
+const _hoisted_3 = { class: "text" };
+const _hoisted_4 = /* @__PURE__ */ createElementVNode("i", { class: "text-2xl i ic:baseline-arrow-drop-down" }, null, -1);
+const _hoisted_5 = [
+  _hoisted_4
+];
+const _sfc_main$a = /* @__PURE__ */ defineComponent({
+  __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 props = __props;
+    const { t } = useI18n();
+    const advancedRef = ref$1(props.isAdvanced);
+    let key = 0;
+    const showAdvanceRef = computed(() => {
+      return props.mode === "search" ? props.showAdvancedButton : false;
+    });
+    const colOpt = computed(() => {
+      let style = {
+        textAlign: "right"
+      };
+      if (props.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(() => props.isAdvanced, (v) => {
+      if (v) {
+        nextTick$1(() => toggleAdvanced());
+      }
+    }, {
+      immediate: true
+    });
+    watch(
+      () => props.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?.value,
+                    disabled: button.disabled,
+                    key: unref$1(key),
+                    onClick: ($event) => handleBtnClick(button)
+                  }, {
+                    icon: withCtx(() => [
+                      button.preIcon ? withDirectives((openBlock(), createElementBlock("span", _hoisted_1$1, null, 512)), [
+                        [_directive_icon, button.preIcon]
+                      ]) : createCommentVNode("v-if", true)
+                    ]),
+                    default: withCtx(() => [
+                      createTextVNode(" " + toDisplayString(unref$1(t)(button.name)) + " ", 1),
+                      button.postIcon ? withDirectives((openBlock(), createElementBlock("span", _hoisted_2, null, 512)), [
+                        [_directive_icon, button.postIcon]
+                      ]) : createCommentVNode("v-if", true)
+                    ]),
+                    _: 2
+                  }, 1032, ["type", "class", "loading", "disabled", "onClick"])), [
+                    [_directive_auth, button.auth]
+                  ]) : createCommentVNode("v-if", true)
+                ], 64);
+              }), 256)),
+              unref$1(showAdvanceRef) ? (openBlock(), createBlock(_component_AButton, {
+                key: 0,
+                type: "link",
+                class: "advanced",
+                onClick: toggleAdvanced
+              }, {
+                default: withCtx(() => [
+                  createCommentVNode(" \u6536\u8D77 | \u5C55\u5F00 "),
+                  createElementVNode("span", _hoisted_3, toDisplayString(advancedRef.value ? unref$1(t)("UI.ADVANCED") : unref$1(t)("UI.EXPAND")), 1),
+                  createElementVNode("span", {
+                    class: normalizeClass(unref$1(getAdvanceClass))
+                  }, _hoisted_5, 2)
+                ]),
+                _: 1
+              })) : createCommentVNode("v-if", true)
+            ]),
+            _: 1
+          }, 8, ["style"])
+        ]),
+        _: 1
+      }, 16)) : createCommentVNode("v-if", true);
+    };
+  }
+});
+const DtFormButtons = /* @__PURE__ */ _export_sfc(_sfc_main$a, [["__file", "D:/dt/dt-frame-front/dt-frames/frames/packages/ui/src/components/form/src/components/FormButtons.vue"]]);
+const SEARCH_BTN_NAME = "UI.SEARCH";
+const RESET_BTN_NAME = "UI.RESET";
+const SEARCH_BTNS = [
+  { name: SEARCH_BTN_NAME, preIcon: "mdi:magnify", type: "primary" },
+  { name: RESET_BTN_NAME, preIcon: "mdi:refresh", type: "default" }
+];
+function useFormEvents({
+  emits,
+  getSchema,
+  formModel,
+  defaultValue,
+  formElRef,
+  schemaRef,
+  getProps,
+  handleFormValues
+}) {
+  function getFormValues() {
+    const formEl = unref$1(formElRef);
+    if (!formEl)
+      return {};
+    return handleFormValues(toRaw$1(unref$1(formModel)));
+  }
+  function updateSchema(data) {
+    let updateItems = [];
+    updateItems = isObject(data) ? [data] : [...data];
+    if (updateItems?.length && !updateItems.every((it) => it.component !== "Divider" && it.name)) {
+      console.error("\u6240\u6709\u7684\u5143\u7D20\u90FD\u5FC5\u987B\u8BBE\u7F6Ename\u5C5E\u6027");
+      return;
+    }
+    const schema = [];
+    updateItems.forEach((it) => {
+      unref$1(getSchema).forEach((val) => {
+        if (val.name === it.name) {
+          const newSchema = deepMerge(val, it);
+          schema.push(newSchema);
+        } else {
+          schema.push(val);
+        }
+      });
+    });
+    let shcemas = uniqBy(schema, "name");
+    _setValue(shcemas);
+    schemaRef.value = shcemas;
+  }
+  function resetSchema(data) {
+    let updateItems = [];
+    updateItems = isObject(data) ? [data] : [...data];
+    _setValue(updateItems, true);
+    schemaRef.value = updateItems;
+  }
+  function _setValue(data, isReset = false) {
+    data = isArray(data) ? data : [data];
+    let obj = {};
+    data.map((it) => {
+      let name = isArray(it.name) ? it.name[0] : it.name;
+      obj[name] = null;
+      if (!isNullAndUnDef(it.defaultValue))
+        return obj[name] = it.defaultValue;
+      let props = isFunction(it.props) ? it.props(toRaw$1(unref$1(formModel))) : it.props;
+      if (!isNullAndUnDef(props?.defaultValue))
+        obj[name] = props.defaultValue;
+    });
+    if (isReset) {
+      let oldValues = getFormValues();
+      let oldObj = {};
+      Object.keys(oldValues).map((key) => oldObj[key] = null);
+      obj = {
+        ...oldObj,
+        ...obj
+      };
+    }
+    setFormValues(obj);
+  }
+  async function clearValidate(name) {
+    await unref$1(formElRef)?.clearValidate(name);
+  }
+  function resetForms() {
+    const { resetFunc } = unref$1(getProps);
+    resetFunc && isFunction(resetFunc) && resetFunc();
+    if (!unref$1(formElRef))
+      return;
+    Object.keys(formModel).forEach((key) => {
+      const schema = unref$1(getSchema).find((item) => item.name === key);
+      const isInput = schema?.component && ["Input", "InputPassword", "InputSearch", "InputTextArea"].includes(schema.component);
+      formModel[key] = isInput ? defaultValue.value[key] || "" : defaultValue.value[key];
+    });
+    nextTick$1(() => clearValidate());
+    emits("reset", toRaw$1(formModel));
+  }
+  function removeFormByName(names) {
+    if (!names)
+      return;
+    const schemaList = cloneDeep(unref$1(getSchema));
+    const nameList = isString(names) ? [names] : names;
+    for (const name of nameList) {
+      _removeSchemaByName(name, schemaList);
+    }
+    schemaRef.value = schemaList;
+  }
+  function _removeSchemaByName(name, schemaList) {
+    const index2 = schemaList.findIndex((schema) => schema.name === name);
+    if (index2 !== -1) {
+      delete formModel[name];
+      schemaList.splice(index2, 1);
+    }
+  }
+  function appendFormItems(schema, prefixName, first = false) {
+    const schemaList = cloneDeep(unref$1(getSchema));
+    const index2 = schemaList.findIndex((schema2) => schema2.name === prefixName);
+    if (!prefixName || index2 === -1 || first) {
+      first ? schemaList.unshift(...schema) : schemaList.push(...schema);
+      schemaRef.value = schemaList;
+      return;
+    }
+    if (index2 !== -1) {
+      schemaList.splice(index2 + 1, 0, ...schema);
+    }
+    schemaRef.value = schemaList;
+  }
+  function itemIsDateType(key) {
+    return unref$1(getSchema).some((item) => {
+      return item.name === key ? ["DatePicker", "MonthPicker", "WeekPicker", "TimePicker", "RangePicker"].includes(item.component) : false;
+    });
+  }
+  async function validateFields(nameList) {
+    return unref$1(formElRef)?.validateFields(nameList);
+  }
+  function setFormValues(values) {
+    if (!values || !Object.keys(values).length) {
+      for (let it in formModel)
+        formModel[it] = Array.isArray(formModel[it]) ? [] : null;
+      return;
+    }
+    const names = unref$1(getSchema).map((item) => item.name).filter(Boolean);
+    const validKeys = [];
+    Object.keys(values).forEach((key) => {
+      const schema = unref$1(getSchema).find((item) => item.name === key);
+      let value = values[key];
+      const hasKey = Reflect.has(values, key);
+      value = handleInputNumberValue(schema?.component, value);
+      if (hasKey && names.includes(key)) {
+        if (itemIsDateType(key)) {
+          if (Array.isArray(value)) {
+            const arr = [];
+            for (const ele of value) {
+              arr.push(ele ? dayjs(ele) : null);
+            }
+            formModel[key] = arr;
+          } else {
+            const { props } = schema || {};
+            let _props = props;
+            if (typeof props === "function") {
+              _props = props({ formModel });
+            }
+            formModel[key] = value ? _props?.valueFormat ? value : dayjs(value) : null;
+          }
+        } else {
+          formModel[key] = value;
+        }
+        validKeys.push(key);
+      } else {
+        formModel[key] = value;
+      }
+    });
+    return validateFields(validKeys);
+  }
+  async function validate(nameList) {
+    return await unref$1(formElRef)?.validate(nameList);
+  }
+  return {
+    getFormValues,
+    updateSchema,
+    resetSchema,
+    clearValidate,
+    resetForms,
+    removeFormByName,
+    validateFields,
+    setFormValues,
+    validate,
+    appendFormItems
+  };
+}
+function useFormValues({
+  defaultValue,
+  getSchema,
+  formModel
+}) {
+  const getComMap = () => {
+    let comMap = /* @__PURE__ */ new Map();
+    unref$1(getSchema).map((it) => {
+      if (it.component && it.name) {
+        comMap.set(it.name, it);
+      }
+    });
+    return comMap;
+  };
+  function handleFormValues(model) {
+    if (!isObject(model))
+      return {};
+    const vals = {};
+    let comMap = getComMap();
+    for (let [key, val] of Object.entries(model)) {
+      let component = comMap.get(key)?.component;
+      if (!key || Array.isArray(val) && val.length === 0 || isFunction(val)) {
+        continue;
+      }
+      if (component) {
+        if (SINGLE_DATA_TYPE.includes(component)) {
+          val = dayjs(val).valueOf();
+        } else if (MULTIFY_DATA_TYPE.includes(component)) {
+          val = (val || []).map((it) => dayjs(it).valueOf());
+          if (comMap.get(key).extraName?.length) {
+            comMap.get(key).extraName.map((it, i) => {
+              set(vals, it, val.length > 0 ? val[i] : null);
+            });
+          }
+        }
+      }
+      if (isString(val)) {
+        val = val.trim();
+      }
+      set(vals, key, val);
+    }
+    return vals;
+  }
+  function initDefault() {
+    const schema = unref$1(getSchema), obj = {};
+    schema.forEach((item) => {
+      const { props = {}, name, component, defaultValue: gDefaultValue, extraName } = item;
+      const { defaultValue: itemDefaultValue, mode, format, treeCheckable } = isFunction(props) ? props(formModel) : props;
+      if (!name)
+        return;
+      let names = [];
+      if (component === "InputWithDialog") {
+        names = [name, ...extraName];
+      } else if (isArray(name)) {
+        names = name;
+      } else {
+        names = [name];
+      }
+      const defaultValue2 = itemDefaultValue ?? gDefaultValue;
+      if (!isNullAndUnDef(defaultValue2)) {
+        if (DATE_PICKER_TYPES.includes(component)) {
+          if (isArray(defaultValue2)) {
+            let vals = defaultValue2.map((it) => format ? dayjs(it, format) : dayjs(it));
+            if (names.length > 1) {
+              names.map((key, index2) => obj[key] = vals[index2] ?? null);
+            } else {
+              obj[names[0]] = vals;
+            }
+          } else {
+            obj[names[0]] = format ? dayjs(defaultValue2, format) : dayjs(defaultValue2);
+          }
+        } else {
+          if (names.length > 1) {
+            names.forEach((key, index2) => {
+              if (!defaultValue2 || defaultValue2.length - 1 < index2) {
+                obj[key] = null;
+              } else {
+                obj[key] = defaultValue2[index2];
+              }
+            });
+          } else {
+            obj[names[0]] = defaultValue2;
+          }
+        }
+      } else {
+        names.map((it) => {
+          if (component === "TreeSelect" || (mode === "multiple" || treeCheckable) || component === "Select" && mode === "multiple") {
+            obj[it] = [];
+          } else {
+            obj[it] = null;
+          }
+        });
+      }
+    });
+    defaultValue.value = { ...obj };
+    for (let key in obj) {
+      formModel[key] = obj[key];
+    }
+  }
+  return {
+    initDefault,
+    handleFormValues
+  };
+}
+function useFormActions(opt) {
+  const { getProps, defaultValue, updateSchema, getFormValues, setFormValues } = opt;
+  const { appConf } = useAppStore();
+  function handleAdvanced(isAdvanced) {
+    const { schemas, minShowColumn = appConf.ui.form?.minShowColumn || 2 } = unref$1(getProps);
+    let schema = schemas.reduce((t, it, index2) => {
+      if (index2 > minShowColumn - 1)
+        it.isAdvanced = isAdvanced;
+      t.push(it);
+      return t;
+    }, []);
+    updateSchema(schema);
+  }
+  function handleMethod(params) {
+    const { onSearch, onReset } = unref$1(getProps);
+    if (isBoolean(params)) {
+      handleAdvanced(params);
+    } else if (params.name === SEARCH_BTN_NAME) {
+      console.log(getProps);
+      onSearch(getFormValues());
+    } else if (params.name === RESET_BTN_NAME) {
+      setFormValues(toRaw(defaultValue.value));
+      onReset(getFormValues());
+    } else {
+      params.onClick();
+    }
+  }
+  return [handleMethod];
+}
+const BasicProps = {
+  mode: {
+    type: String,
+    default: "search"
+  },
+  autoFetch: {
+    type: Boolean,
+    default: true
+  },
+  model: {
+    type: Object,
+    default: () => ({})
+  },
+  layout: {
+    type: String,
+    default: "horizontal"
+  },
+  labelWidth: {
+    type: [Number, String],
+    default: 100
+  },
+  enLabelWidth: {
+    type: [Number, String],
+    default: 100
+  },
+  labelAlign: {
+    type: String,
+    default: "right"
+  },
+  labelCol: {
+    type: Object,
+    default: () => ({})
+  },
+  wrapperCol: {
+    type: Object,
+    default: () => ({})
+  },
+  rowProps: {
+    type: Object,
+    default: () => ({})
+  },
+  colProps: {
+    type: Object,
+    default: () => ({})
+  },
+  size: {
+    type: String,
+    default: "small"
+  },
+  disabled: {
+    type: Boolean,
+    default: false
+  },
+  compact: {
+    type: Boolean,
+    default: null
+  },
+  schemas: {
+    type: Array,
+    default: () => []
+  },
+  autoSearchOnEnter: {
+    type: Boolean,
+    default: true
+  },
+  alwaysShowLines: {
+    type: Boolean,
+    default: false
+  },
+  minShowColumn: {
+    type: Number,
+    default: 2
+  },
+  showAdvancedButton: {
+    type: Boolean,
+    default: true
+  },
+  allowClear: {
+    type: Boolean,
+    default: true
+  },
+  scrollToFirstError: {
+    type: Boolean,
+    default: true
+  },
+  colon: {
+    type: Boolean,
+    default: true
+  },
+  loading: {
+    type: Object,
+    default: () => {
+      return {
+        onSearch: ref$1(false),
+        onReset: ref$1(false)
+      };
+    }
+  },
+  onSearch: {
+    type: Function,
+    default: (params) => {
+    }
+  },
+  onReset: {
+    type: Function,
+    default: (params) => {
+    }
+  },
+  buttons: {
+    type: [Array, null, Boolean],
+    default: false
+  },
+  resetFunc: {
+    type: Function
+  },
+  registerInstance: {
+    type: Function
+  }
+};
+const _sfc_main$9 = /* @__PURE__ */ defineComponent({
+  __name: "index",
+  props: BasicProps,
+  emits: ["register"],
+  setup(__props, { emit: emits }) {
+    const props = __props;
+    const { getAppConf } = useAppStore();
+    const attrs = useAttrs();
+    const formElRef = ref$1(null);
+    const formModel = reactive({});
+    const defaultValue = ref$1({});
+    const propsRef = ref$1();
+    const schemaRef = ref$1(null);
+    const getProps = computed(() => {
+      let colProps = props.colProps;
+      if (isEmpty(props.colProps)) {
+        colProps = props.mode === "search" ? getAppConf.ui.form.searchColspan || { span: 8 } : getAppConf.ui.form.dialogColspan || { span: 12 };
+      }
+      return {
+        ...props,
+        ...getAppConf.ui.form,
+        colProps,
+        ...unref$1(propsRef)
+      };
+    });
+    const getBindValue = computed(() => {
+      return {
+        ...attrs,
+        ...unref$1(getProps)
+      };
+    });
+    const getSchema = computed(() => {
+      return unref$1(schemaRef) || unref$1(getProps).schemas;
+    });
+    const getFormClass = computed(() => {
+      const { compact, mode } = unref$1(getProps);
+      const getCompact = compact === null ? mode === "dialog" ? false : true : compact;
+      return [
+        "basic-form",
+        `basic-form__${mode}`,
+        {
+          "basic-form__compact": getCompact
+        }
+      ];
+    });
+    function setProps(formProps) {
+      propsRef.value = deepMerge(unref$1(propsRef) || {}, formProps);
+      return null;
+    }
+    function setFormModel(key, value) {
+      formModel[key] = value;
+      const { validateTrigger } = unref$1(getBindValue);
+      if (!validateTrigger || validateTrigger === "change") {
+        validateFields([key]);
+      }
+    }
+    function handleEnterPress() {
+    }
+    const { initDefault, handleFormValues } = useFormValues({
+      defaultValue,
+      getSchema,
+      formModel
+    });
+    const {
+      updateSchema,
+      resetSchema,
+      clearValidate,
+      resetForms,
+      removeFormByName,
+      setFormValues,
+      appendFormItems,
+      validate,
+      validateFields,
+      getFormValues
+    } = useFormEvents({
+      emits,
+      getSchema,
+      formModel,
+      formElRef,
+      defaultValue,
+      schemaRef,
+      getProps,
+      handleFormValues
+    });
+    const formActionMethods = {
+      setProps,
+      updateSchema,
+      resetSchema,
+      clearValidate,
+      resetForms,
+      removeFormByName,
+      setFormValues,
+      appendFormItems,
+      validate,
+      validateFields,
+      getFormValues
+    };
+    const getActionsProps = computed(() => {
+      const {
+        mode,
+        minShowColumn = getAppConf.ui.form.minShowColumn || 2,
+        schemas = [],
+        showAdvancedButton: advanced,
+        loading,
+        buttons
+      } = unref$1(getProps);
+      let showAdvancedButton = mode === "search" ? true : false;
+      if (advanced !== void 0) {
+        showAdvancedButton = advanced;
+      }
+      if (schemas.length <= minShowColumn) {
+        showAdvancedButton = false;
+      }
+      let buttonList = [];
+      if (isArray(buttons)) {
+        buttonList = [...buttons];
+      } else if (mode === "search" && !buttons) {
+        SEARCH_BTNS.forEach((it) => {
+          it.loading = it.name === SEARCH_BTN_NAME ? loading?.onSearch : loading?.onReset;
+          buttonList.push(it);
+        });
+      }
+      let colspan = mode === "search" ? getAppConf.ui.form.searchColspan : getAppConf.ui.form.dialogColspan;
+      return {
+        ...colspan,
+        ...{
+          showAdvancedButton,
+          buttonList
+        }
+      };
+    });
+    const [handleMethod] = useFormActions({
+      getProps,
+      defaultValue,
+      updateSchema,
+      getFormValues,
+      setFormValues
+    });
+    onMounted$1(() => {
+      setFormValues(null);
+      emits("register", formActionMethods);
+      initDefault();
+    });
+    watch(
+      () => unref$1(getProps).onSearch,
+      () => {
+        useTimeoutFn(() => {
+          const { onSearch, autoFetch } = unref$1(getProps);
+          if (autoFetch && onSearch && isFunction(onSearch)) {
+            onSearch(toRaw(defaultValue.value));
+          }
+        }, 1);
+      }
+    );
+    watch(
+      () => unref$1(getProps).model,
+      (v) => {
+        const { model } = unref$1(getProps);
+        if (!model || !Object.keys(model).length)
+          return;
+        setFormValues(model);
+      },
+      {
+        immediate: true,
+        deep: true
+      }
+    );
+    return (_ctx, _cache) => {
+      const _component_ARow = Row;
+      const _component_AForm = Form$1;
+      return openBlock(), createBlock(_component_AForm, mergeProps(unref$1(getBindValue), {
+        ref_key: "formElRef",
+        ref: formElRef,
+        class: unref$1(getFormClass),
+        model: formModel,
+        layout: unref$1(getProps).layout,
+        onKeypress: withKeys(handleEnterPress, ["enter"])
+      }), {
+        default: withCtx(() => [
+          createVNode(_component_ARow, mergeProps(unref$1(getProps).rowProps, { style: {
+            margin: 0
+          } }), {
+            default: withCtx(() => [
+              (openBlock(true), createElementBlock(Fragment, null, renderList(unref$1(getSchema), (schema) => {
+                return openBlock(), createBlock(unref$1(DtFormItem), {
+                  key: schema.name,
+                  schema,
+                  formProps: unref$1(getProps),
+                  formModel,
+                  defaultValues: defaultValue.value,
+                  setFormModel,
+                  formActionType: formActionMethods
+                }, createSlots({ _: 2 }, [
+                  renderList(Object.keys(_ctx.$slots), (item) => {
+                    return {
+                      name: item,
+                      fn: withCtx((data) => [
+                        renderSlot(_ctx.$slots, item, normalizeProps(guardReactiveProps(data || {})))
+                      ])
+                    };
+                  })
+                ]), 1032, ["schema", "formProps", "formModel", "defaultValues"]);
+              }), 128)),
+              unref$1(getActionsProps).buttonList?.length ? (openBlock(), createBlock(unref$1(DtFormButtons), mergeProps({ key: 0 }, unref$1(getActionsProps), { onHandleMethod: unref$1(handleMethod) }), null, 16, ["onHandleMethod"])) : createCommentVNode("v-if", true)
+            ]),
+            _: 3
+          }, 16)
+        ]),
+        _: 3
+      }, 16, ["class", "model", "layout", "onKeypress"]);
+    };
+  }
+});
+const Forms = /* @__PURE__ */ _export_sfc(_sfc_main$9, [["__file", "D:/dt/dt-frame-front/dt-frames/frames/packages/ui/src/components/form/src/index.vue"]]);
+function useForm(props) {
+  const formRef = ref$1(null);
+  const loadedRef = ref$1(false);
+  function register(instance) {
+    if (unref$1(loadedRef) && instance === unref$1(formRef))
+      return;
+    formRef.value = instance;
+    loadedRef.value = true;
+    watch(
+      () => props,
+      () => props && instance.setProps(props),
+      {
+        immediate: true,
+        deep: true
+      }
+    );
+  }
+  async function getForm() {
+    const form = unref$1(formRef);
+    if (!form)
+      console.error("\u8868\u5355\u672A\u7533\u660E!");
+    await nextTick$1();
+    return form;
+  }
+  const methods = {
+    setProps: async (props2) => {
+      const form = await getForm();
+      form.setProps(props2);
+    },
+    updateSchema: async (data) => {
+      const form = await getForm();
+      form.updateSchema(data);
+    },
+    resetSchema: async (data) => {
+      const form = await getForm();
+      form.resetSchema(data);
+    },
+    clearValidate: async (name) => {
+      const form = await getForm();
+      form.clearValidate(name);
+    },
+    resetForms: async () => {
+      const form = await getForm();
+      form.resetForms();
+    },
+    removeFormByName: async (name) => {
+      unref$1(formRef)?.removeFormByName(name);
+    },
+    setFormValues: async (values) => {
+      const form = await getForm();
+      form.setFormValues(values);
+    },
+    appendFormItems: async (schema, prefixName, first) => {
+      const form = await getForm();
+      form.appendFormItems(schema, prefixName, first);
+    },
+    validate: async (nameList) => {
+      const form = await getForm();
+      return form.validate(nameList);
+    },
+    validateFields: async (nameList) => {
+      const form = await getForm();
+      return form.validateFields(nameList);
+    },
+    getFormValues: () => {
+      return unref$1(formRef)?.getFormValues();
+    }
+  };
+  return [register, methods];
+}
+const withInstall = (comp) => {
+  comp.install = (app) => {
+    app.component(comp.name, comp);
+  };
+  return comp;
+};
+const DtForm = withInstall(Forms);
+const orgDialogProp = reactive({});
+const cbTransfer = reactive({});
+const dataTransfer = reactive({});
+function useModalOut() {
+  const modal = ref$1(null);
+  const loaded = ref$1(true);
+  const uid = ref$1(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$1(isProd)) {
+        modal.value = null;
+        loaded.value = false;
+        dataTransfer[unref$1(uid)] = null;
+        orgDialogProp[unref$1(uid)] = null;
+        cbTransfer[unref$1(uid)] = (res) => {
+        };
+      }
+    });
+    if (unref$1(loaded) && modalMethod === unref$1(modal))
+      return;
+    modal.value = modalMethod;
+    loaded.value = true;
+  }
+  const getInstance = () => {
+    const instance = unref$1(modal);
+    if (!instance) {
+      error("useModalOut \u5B9E\u4F8B\u672A\u5B9A\u4E49");
+    }
+    return instance;
+  };
+  const methods = {
+    setModalProps: (props) => {
+      getInstance()?.setModalProps(props);
+    },
+    redoModalHeight: () => {
+      getInstance()?.redoModalHeight?.();
+    },
+    openModal: (params, afterClose) => {
+      const id = unref$1(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(props, setModalData) {
+  const modalInstanceRef = ref$1(null);
+  const currentInstance = getCurrentInstance();
+  const uidRef = ref$1(null);
+  const { isProd } = useApp();
+  const getInstance = () => {
+    const instance = unref$1(modalInstanceRef);
+    if (!instance) {
+      error("useModal \u5B9E\u4F8B\u672A\u5B9A\u4E49");
+    }
+    return instance;
+  };
+  const register = (modalInstance, uuid) => {
+    if (unref$1(isProd)) {
+      modalInstanceRef.value = null;
+    }
+    uidRef.value = uuid;
+    modalInstanceRef.value = modalInstance;
+    currentInstance?.emit("register", modalInstance, uuid);
+    orgDialogProp[uuid] = toRaw(props);
+    modalInstance.setModalProps(props);
+  };
+  watchEffect(() => {
+    const data = dataTransfer[unref$1(uidRef)];
+    if (!data)
+      return;
+    if (!setModalData || !isFunction(setModalData))
+      return;
+    nextTick$1(() => {
+      setModalData(data);
+    });
+  });
+  const methods = {
+    setLoading: (loading = true) => {
+      getInstance()?.setModalProps({ loading });
+    },
+    closeModal: (rsp) => {
+      if (cbTransfer[unref$1(uidRef)])
+        cbTransfer[unref$1(uidRef)](rsp);
+      getInstance()?.setModalProps({ visible: false });
+    },
+    setModalProps: (props2) => {
+      getInstance()?.setModalProps(props2);
+    },
+    redoModalHeight: () => {
+      const callRedo = getInstance()?.redoModalHeight;
+      callRedo && callRedo();
+    }
+  };
+  return [register, methods];
+}
+const index$1 = "";
+const basicProps$1 = {
+  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$1(context.draggable));
+    const dialogHeaderEl = wrap.querySelector(".ant-modal-header");
+    const dragDom = wrap.querySelector(".ant-modal");
+    if (!dialogHeaderEl || !dragDom || !unref$1(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$1(context.destroyOnClose)) {
+          drag(wrap);
+        }
+      }
+    }
+  };
+  watchEffect(() => {
+    if (!unref$1(context.visible) || !unref$1(context.draggable)) {
+      return;
+    }
+    useTimeoutFn(() => {
+      handleDrag();
+    }, 30);
+  });
+}
+function _isSlot(s) {
+  return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s);
+}
+const _sfc_main$8 = {
+  name: "Modal",
+  inheritAttrs: false,
+  props: basicProps$1,
+  emits: ["cancel"],
+  setup(props, {
+    slots,
+    emit
+  }) {
+    const {
+      visible,
+      draggable,
+      destroyOnClose
+    } = toRefs(props);
+    const attrs = useAttrs();
+    useDragMove({
+      visible,
+      destroyOnClose,
+      draggable
+    });
+    const {
+      extendSlots
+    } = useSlots();
+    const onCancel = (e) => emit("cancel", e);
+    return () => {
+      let _slot;
+      const propsData = {
+        ...unref$1(attrs),
+        ...props,
+        destroyOnClose: true,
+        onCancel
+      };
+      if (!propsData?.visible)
+        return null;
+      return createVNode(Modal$1, propsData, _isSlot(_slot = extendSlots(slots)) ? _slot : {
+        default: () => [_slot]
+      });
+    };
+  }
+};
+const Modal = /* @__PURE__ */ _export_sfc(_sfc_main$8, [["__file", "D:/dt/dt-frame-front/dt-frames/frames/packages/ui/src/components/modal/src/components/Modal.vue"]]);
+const index = "";
+const _sfc_main$7 = /* @__PURE__ */ defineComponent({
+  __name: "CloseIcon",
+  props: {
+    canFullscreen: { type: Boolean, default: true },
+    fullScreen: { type: Boolean }
+  },
+  emits: ["cancel", "fullscreen"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const { t } = useI18n("UI");
+    const getClass = computed(() => {
+      return [
+        "dt-basic-modal-close",
+        `dt-basic-modal-close--custom`,
+        {
+          [`dt-basic-modal-close--can-full`]: props.canFullscreen
+        }
+      ];
+    });
+    function handleCancel(e) {
+      emit("cancel", e);
+    }
+    function handleFullScreen(e) {
+      e?.stopPropagation();
+      e?.preventDefault();
+      emit("fullscreen");
+    }
+    return (_ctx, _cache) => {
+      const _component_ATooltip = Tooltip$1;
+      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("v-if", true),
+        createElementVNode("i", {
+          class: "i mdi:close h-14 w-10 pr-4",
+          onClick: handleCancel
+        })
+      ], 2);
+    };
+  }
+});
+const CloseIcon = /* @__PURE__ */ _export_sfc(_sfc_main$7, [["__file", "D:/dt/dt-frame-front/dt-frames/frames/packages/ui/src/components/modal/src/components/CloseIcon.vue"]]);
+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({
+  name: "Bar",
+  props: {
+    vertical: Boolean,
+    size: String,
+    move: Number
+  },
+  setup(props) {
+    const instance = getCurrentInstance$1();
+    const thumb = ref$1();
+    const wrap = inject("scroll-bar-wrap", {});
+    const bar = computed(() => {
+      return BAR_MAP[props.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(() => {
+      off(document, "mouseup", mouseUpDocumentHandler);
+    });
+    return () => h(
+      "div",
+      {
+        class: ["scrollbar__bar", "is-" + bar.value.key],
+        onMousedown: clickTrackHandler
+      },
+      h("div", {
+        ref: thumb,
+        class: "scrollbar__thumb",
+        onMousedown: clickThumbHandler,
+        style: renderThumbStyle({
+          size: props.size,
+          move: props.move,
+          bar: bar.value
+        })
+      })
+    );
+  }
+});
+const _hoisted_1 = { class: "scrollbar relative h-full overflow-hidden" };
+const _sfc_main$6 = /* @__PURE__ */ defineComponent({
+  __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 props = __props;
+    const sizeWidth = ref$1("0");
+    const sizeHeight = ref$1("0");
+    const moveX = ref$1(0);
+    const moveY = ref$1(0);
+    const wrap = ref$1();
+    const resize = ref$1();
+    provide("scroll-bar-wrap", wrap);
+    const style = computed(() => {
+      let rsStyle = {};
+      if (Array.isArray(props.wrapStyle)) {
+        props.wrapStyle.forEach((it) => {
+          if (it)
+            rsStyle = Object.assign({}, rsStyle, it);
+        });
+      }
+      return rsStyle;
+    });
+    const handleScroll = () => {
+      moveY.value = unref$1(wrap).scrollTop * 100 / unref$1(wrap).clientHeight;
+      moveX.value = unref$1(wrap).scrollLeft * 100 / unref$1(wrap).clientWidth;
+    };
+    const update = () => {
+      if (!unref$1(wrap))
+        return;
+      const heightPercentage = unref$1(wrap).clientHeight * 100 / unref$1(wrap).scrollHeight;
+      const widthPercentage = unref$1(wrap).clientWidth * 100 / unref$1(wrap).scrollWidth;
+      sizeHeight.value = heightPercentage < 100 ? heightPercentage + "%" : "";
+      sizeWidth.value = widthPercentage < 100 ? widthPercentage + "%" : "";
+    };
+    onMounted$1(() => {
+      nextTick$1(update);
+      if (!props.noresize) {
+        addResizeListener(unref$1(resize), update);
+        addResizeListener(unref$1(wrap), update);
+        addEventListener("resize", update);
+      }
+    });
+    onBeforeUnmount(() => {
+      if (!props.noresize) {
+        removeResizeListener(unref$1(resize), update);
+        removeResizeListener(unref$1(wrap), update);
+        removeEventListener("resize", update);
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        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: moveX.value,
+          size: sizeWidth.value
+        }, null, 8, ["move", "size"]),
+        createVNode(unref$1(Bar), {
+          vertical: "",
+          move: moveY.value,
+          size: sizeHeight.value
+        }, null, 8, ["move", "size"])
+      ]);
+    };
+  }
+});
+const ScrollBar = /* @__PURE__ */ _export_sfc(_sfc_main$6, [["__file", "D:/dt/dt-frame-front/dt-frames/frames/packages/ui/src/components/container/src/components/scroll-bar.vue"]]);
+const _sfc_main$5 = /* @__PURE__ */ defineComponent({
+  __name: "scroll-container",
+  setup(__props) {
+    const scrollbarRef = ref$1(null);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(ScrollBar, mergeProps({
+        ref_key: "scrollbarRef",
+        ref: scrollbarRef
+      }, _ctx.$attrs, { class: "w-full h-full" }), {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 16);
+    };
+  }
+});
+const ScrollContainer = /* @__PURE__ */ _export_sfc(_sfc_main$5, [["__file", "D:/dt/dt-frame-front/dt-frames/frames/packages/ui/src/components/container/src/scroll-container.vue"]]);
+const _sfc_main$4 = /* @__PURE__ */ defineComponent({
+  __name: "slot-container",
+  props: {
+    template: {
+      type: Function
+    },
+    data: {
+      type: Object
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const Container = h("div", [props.template(props.data)]);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref$1(Container));
+    };
+  }
+});
+const SlotContainer = /* @__PURE__ */ _export_sfc(_sfc_main$4, [["__file", "D:/dt/dt-frame-front/dt-frames/frames/packages/ui/src/components/container/src/slot-container.vue"]]);
+const DtScrollContainer = withInstall(ScrollContainer);
+withInstall(SlotContainer);
+const _sfc_main$3 = /* @__PURE__ */ defineComponent({
+  __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 props = __props;
+    const wrapperRef = ref$1(null);
+    const wrapRef = ref$1(null);
+    const realHeightRef = ref$1(0);
+    const minRealHeightRef = ref$1(0);
+    let realHeight = 0;
+    const wrapStyle = computed(() => {
+      return {
+        minHeight: `${props.minHeight}px`,
+        [props.fullScreen ? "height" : "maxHeight"]: `${unref$1(realHeightRef)}px`
+      };
+    });
+    onMounted(() => {
+      const { modalHeaderHeight, modalFooterHeight } = props;
+      emits("ext-height", modalHeaderHeight + modalFooterHeight);
+    });
+    async function getModalDom() {
+      const wrapperRefDom = unref$1(wrapperRef);
+      if (!wrapperRefDom)
+        return;
+      const bodyDom = wrapperRefDom.$el.parentElement;
+      if (!bodyDom)
+        return;
+      bodyDom.style.padding = "0";
+      await nextTick$1();
+      const modalDom = bodyDom.parentElement && bodyDom.parentElement.parentElement;
+      return modalDom;
+    }
+    async function setModalHeight() {
+      if (!props.visible)
+        return;
+      try {
+        const modalDom = await getModalDom();
+        if (!modalDom)
+          return;
+        const modalRect = getComputedStyle(modalDom).top;
+        const modalTop = Number.parseInt(modalRect);
+        let maxHeight = window.innerHeight - props.modalFooterHeight - props.modalHeaderHeight - 100;
+        if (modalTop < 40) {
+          maxHeight -= 26;
+        }
+        await nextTick$1();
+        const warpEl = unref$1(wrapRef);
+        if (!warpEl)
+          return;
+        await nextTick$1();
+        realHeight = warpEl.scrollHeight;
+        if (props.fullScreen) {
+          realHeightRef.value = window.innerHeight - props.modalFooterHeight - props.modalHeaderHeight;
+        } else {
+          realHeightRef.value = props.height ? props.height : realHeight > maxHeight ? maxHeight : realHeight;
+        }
+        emits("height-change", unref$1(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(() => {
+      props.useWrapper && setModalHeight();
+    });
+    watch(
+      () => props.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 ModalWrapper = /* @__PURE__ */ _export_sfc(_sfc_main$3, [["__file", "D:/dt/dt-frame-front/dt-frames/frames/packages/ui/src/components/modal/src/components/ModalWrap.vue"]]);
+const _sfc_main$2 = /* @__PURE__ */ defineComponent({
+  __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 props = __props;
+    const { t } = useI18n("UI");
+    const buttonList = computed(() => {
+      if (props.buttons && props.buttons.length)
+        return props.buttons;
+      let buttonActions = [
+        { t: "\u4FDD\u5B58", name: props.okText || t("SAVE"), preIcon: "mdi:content-save", type: "primary", flag: "OK" },
+        { t: "\u5173\u95ED", name: props.cancelText || t("CLOSE"), preIcon: "mdi:close", flag: "CANCEL" }
+      ];
+      if (!props.showSave)
+        buttonActions = buttonActions.filter((btn) => btn.flag !== "OK");
+      if (!props.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(DtFormButtons, {
+          mode: "dialog",
+          buttonList: unref$1(buttonList),
+          onHandleMethod: _cache[0] || (_cache[0] = ($event) => handleMethod($event))
+        }, null, 8, ["buttonList"])
+      ], 64);
+    };
+  }
+});
+const ModalFooter = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["__file", "D:/dt/dt-frame-front/dt-frames/frames/packages/ui/src/components/modal/src/components/ModalFooter.vue"]]);
+function useFullScreen(wrapClassName) {
+  const fullScreenRef = ref$1(false);
+  const getWrapClassName = computed(() => {
+    const clsName = unref$1(wrapClassName) || "";
+    const cls = unref$1(fullScreenRef) ? `fullscreen-modal ${clsName} ` : unref$1(clsName);
+    return `dt-modal ${cls}`;
+  });
+  function toggleFullScreen(e) {
+    e && e.stopPropagation();
+    fullScreenRef.value = !unref$1(fullScreenRef);
+    dispatchResize();
+  }
+  return {
+    fullScreenRef,
+    getWrapClassName,
+    toggleFullScreen
+  };
+}
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  __name: "index",
+  props: basicProps$1,
+  emits: ["visible-change", "height-change", "cancel", "save", "register", "update:visible"],
+  setup(__props, { emit: emits }) {
+    const props = __props;
+    const visibleRef = ref$1(false);
+    const propsRef = ref$1();
+    const modalWrapperRef = ref$1(null);
+    const { getWrapClassName, toggleFullScreen, fullScreenRef } = useFullScreen(computed(() => unref$1(propsRef)?.wrapClassName));
+    const getMergeProps = computed(() => {
+      return {
+        ...props,
+        ...unref$1(propsRef)
+      };
+    });
+    const getBindValue = computed(() => {
+      const bindValue = {
+        ...unref$1(getMergeProps),
+        ...unref$1(propsRef),
+        visible: unref$1(visibleRef),
+        wrapClassName: unref$1(getWrapClassName)
+      };
+      let omitArr = unref$1(fullScreenRef) ? ["height", "title"] : ["title"];
+      if (isArray(unref$1(propsRef)?.footer)) {
+        omitArr.push("footer");
+      }
+      return omit(bindValue, omitArr);
+    });
+    const getWrapperHeight = computed(() => {
+      if (unref$1(fullScreenRef))
+        return void 0;
+      return unref$1(getBindValue).height;
+    });
+    const modalFooterHeight = computed(() => {
+      if (isArray(props.footer)) {
+        return (unref$1(propsRef)?.footer).length ? 0 : void 0;
+      }
+      return props?.footer !== void 0 && !props.footer ? 0 : void 0;
+    });
+    const modalMethods = {
+      setModalProps,
+      redoModalHeight: () => {
+        nextTick$1(() => {
+          if (unref$1(modalWrapperRef)) {
+            unref$1(modalWrapperRef).setModalHeight();
+          }
+        });
+      }
+    };
+    const instance = getCurrentInstance();
+    if (instance) {
+      emits("register", modalMethods, instance.uid);
+    }
+    function handleHeightChange(height) {
+      emits("height-change", height);
+    }
+    function setModalProps(props2) {
+      propsRef.value = deepMerge(unref$1(propsRef) || {}, props2);
+      if (Reflect.has(props2, "visible")) {
+        visibleRef.value = !!props2.visible;
+      }
+      if (Reflect.has(props2, "defaultFullscreen")) {
+        fullScreenRef.value = !!props2.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 (props.closeFunc && isFunction(props.closeFunc)) {
+          const isClose = await props.closeFunc();
+          visibleRef.value = !isClose;
+          return;
+        }
+      }
+      const { afterClose } = unref$1(getBindValue);
+      if (afterClose && isFunction(afterClose)) {
+        afterClose();
+      }
+      visibleRef.value = false;
+      emits("cancel", e);
+    }
+    watch(() => unref$1(visibleRef), (v) => {
+      emits("visible-change", v);
+      emits("update:visible", v);
+      nextTick$1(() => {
+        if (props.scrollTop && v && unref$1(modalWrapperRef)) {
+          unref$1(modalWrapperRef).$el.scrollTop = 0;
+        }
+      });
+    }, {
+      immediate: false
+    });
+    return (_ctx, _cache) => {
+      const _component_ASpin = Spin;
+      return openBlock(), createBlock(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(ModalWrapper, 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: visibleRef.value,
+                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(CloseIcon, {
+              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(ModalFooter, {
+              buttons: propsRef.value?.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 DtModal$1 = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["__file", "D:/dt/dt-frame-front/dt-frames/frames/packages/ui/src/components/modal/src/index.vue"]]);
+const basicProps = {
+  title: {
+    type: Object
+  },
+  width: {
+    type: [String, Number],
+    default: "50%"
+  },
+  schemas: {
+    type: Array,
+    default: () => []
+  },
+  footer: {
+    type: Array,
+    default: void 0
+  },
+  showFullscreen: {
+    type: Boolean,
+    default: true
+  },
+  showClosable: {
+    type: Boolean,
+    default: true
+  },
+  formProps: {
+    type: Object,
+    default: () => ({})
+  },
+  primaryKey: {
+    type: String,
+    default: "id"
+  },
+  actType: {
+    type: Object
+  },
+  onSave: {
+    type: Function,
+    default: () => ({})
+  },
+  onDeletes: {
+    type: Function,
+    default: (keys) => ({})
+  },
+  onQueryById: {
+    type: Function,
+    default: (id) => ({})
+  },
+  onRegister: {
+    type: Function
+  },
+  registerInstance: {
+    type: Function
+  }
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "Curd",
+  props: basicProps,
+  setup(__props) {
+    const props = __props;
+    const [registerDialog] = useModal({
+      ...omit(toRaw$1(props), [
+        "curd",
+        "formProps",
+        "schemas"
+      ]),
+      destroyOnClose: true
+    });
+    function handleSave() {
+      props?.onSave();
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref$1(DtModal$1), {
+        onRegister: unref$1(registerDialog),
+        onSave: _cache[0] || (_cache[0] = ($event) => handleSave())
+      }, {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 8, ["onRegister"]);
+    };
+  }
+});
+const DtModal = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "D:/dt/dt-frame-front/dt-frames/frames/packages/ui/src/components/curd/src/components/Curd.vue"]]);
+function useCurd(curdOpt) {
+  const [register, {
+    openModal,
+    closeModal,
+    setModalProps
+  }] = useModalOut();
+  const {
+    confirm,
+    message
+  } = useMessage();
+  const {
+    t
+  } = useI18n("UI");
+  const {
+    formProps,
+    schemas
+  } = curdOpt;
+  const oriTitle = isFunction(curdOpt.title) ? curdOpt.title() : unref(curdOpt.title);
+  const title = ref(oriTitle);
+  const [registerForm, curdFormMethods] = useForm({
+    ...formProps || {},
+    schemas,
+    mode: "dialog"
+  });
+  const DtCurdModal = () => {
+    return h(createVNode("div", {
+      "class": "dt-curd-modal"
+    }, [createVNode(DtModal, mergeProps(curdOpt, {
+      "title": title,
+      "onRegister": register
+    }), {
+      default: () => [createVNode(DtForm, {
+        "onRegister": registerForm
+      }, null)]
+    })]));
+  };
+  function add() {
+    title.value = t("ADD") + " - " + oriTitle;
+    openModal();
+  }
+  function del({
+    row
+  }) {
+    const {
+      primaryKey = "id",
+      onDeletes
+    } = curdOpt;
+    if (onDeletes && isFunction(onDeletes)) {
+      onDeletes([row[primaryKey]]);
+    }
+  }
+  function update({
+    row
+  }) {
+    const {
+      primaryKey = "id",
+      onQueryById
+    } = curdOpt;
+    title.value = t("EDIT") + " - " + oriTitle;
+    openModal();
+    if (onQueryById && isFunction(onQueryById)) {
+      onQueryById(row[primaryKey]).then((rsp) => {
+        curdFormMethods.setFormValues(rsp);
+        nextTick(() => dispatchResize());
+      });
+    }
+  }
+  function dels(ids = []) {
+    if (!ids.length) {
+      message.error(t("EMPTY"));
+      return;
+    }
+    const {
+      curd
+    } = curdOpt;
+    if (curd && curd.onDeletes && isFunction(curd.onDeletes)) {
+      confirm({
+        title: t("MULTIFY_DELETE_CONFIRM"),
+        content: t("CONFIRM_MULTIFY_DELETE", {
+          length: ids.length
+        }),
+        iconType: "warning",
+        onOk() {
+          curd.onDeletes(ids);
+        }
+      });
+    } else {
+      error(t("NEED_CURD"));
+    }
+  }
+  const instance = {
+    add,
+    del,
+    update,
+    dels,
+    closeModal,
+    setModalProps,
+    curdFormMethods
+  };
+  curdOpt.registerInstance && curdOpt.registerInstance(instance);
+  return {
+    DtCurdModal,
+    ...instance
+  };
+}
+export {
+  useCurd
+};