@dt-frames/ui 2.0.24 → 4.0.1

package/es/components/iframe/src/index.d.ts

@@ -1,38 +0,0 @@
-declare const _sfc_main: import("vue").DefineComponent<{
-    showLoading: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    src: {
-        type: StringConstructor;
-    };
-    exeReduce: {
-        type: NumberConstructor;
-        default: number;
-    };
-    postMsg: any;
-}, {
-    props: any;
-    loading: import("vue").Ref<boolean>;
-    frameRef: import("vue").Ref<any>;
-    calcHeight: () => void;
-    afterLoaded: () => void;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
-    showLoading: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    src: {
-        type: StringConstructor;
-    };
-    exeReduce: {
-        type: NumberConstructor;
-        default: number;
-    };
-    postMsg: any;
-}>>, {
-    showLoading: boolean;
-    exeReduce: number;
-    postMsg: any;
-}>;
-export default _sfc_main;

package/es/components/modal/index.d.ts

@@ -1,4 +0,0 @@
-import { useModal, useModalOut } from './src/hooks/useModal';
-import { default as DtModal } from "./src/index";
-import { basicProps } from './src/props';
-export { basicProps, DtModal, useModalOut, useModal };

package/es/components/modal/index.js

@@ -1,646 +0,0 @@
-import { useApp, isFunction, isObject, error, useTimeoutFn, useSlots, getPopupContainer, useI18n, dispatchResize, isArray, deepMerge } from "@dt-frames/core";
-import { reactive, ref, getCurrentInstance, watchEffect, unref, nextTick, onUnmounted, toRaw, toRefs, useAttrs, createVNode, isVNode, defineComponent, computed, openBlock, createElementBlock, normalizeClass, Fragment, createBlock, withCtx, createElementVNode, createCommentVNode, renderSlot, watch, mergeProps, createSlots, createTextVNode, toDisplayString, renderList, normalizeProps, guardReactiveProps } from "vue";
-import { Tooltip, Spin } from "ant-design-vue/es";
-import "ant-design-vue/es/spin/style";
-import { omit } from "lodash-es";
-import { Modal as Modal$1 } from "ant-design-vue";
-import "ant-design-vue/es/modal/style";
-import "ant-design-vue/es/tooltip/style";
-import { DtFormButtons } from "../form";
-const orgDialogProp = reactive({});
-const cbTransfer = reactive({});
-const dataTransfer = reactive({});
-function useModalOut() {
-  const modal = ref(null);
-  const loaded = ref(true);
-  const uid = ref(null);
-  const { isProd } = useApp();
-  function register(modalMethod, uuid) {
-    if (!getCurrentInstance()) {
-      throw new Error("useModal\u53EA\u80FD\u5728setup()\u6216\u8005\u51FD\u6570\u4E2D\u4F7F\u7528");
-    }
-    uid.value = uuid;
-    onUnmounted(() => {
-      if (unref(isProd)) {
-        modal.value = null;
-        loaded.value = false;
-        dataTransfer[unref(uid)] = null;
-        orgDialogProp[unref(uid)] = null;
-        cbTransfer[unref(uid)] = (res) => {
-        };
-      }
-    });
-    if (unref(loaded) && modalMethod === unref(modal))
-      return;
-    modal.value = modalMethod;
-    loaded.value = true;
-  }
-  const getInstance = () => {
-    const instance = unref(modal);
-    if (!instance) {
-      error("useModalOut \u5B9E\u4F8B\u672A\u5B9A\u4E49");
-    }
-    return instance;
-  };
-  const methods = {
-    setModalProps: (props) => {
-      getInstance()?.setModalProps(props);
-    },
-    redoModalHeight: () => {
-      getInstance()?.redoModalHeight?.();
-    },
-    openModal: (params, afterClose) => {
-      const id = unref(uid);
-      dataTransfer[id] = isObject(params) ? { ...toRaw(params) } : params;
-      getInstance()?.setModalProps({
-        footer: [],
-        defaultFullscreen: false,
-        ...orgDialogProp[id],
-        visible: true
-      });
-      cbTransfer[id] = (res) => {
-        if (afterClose && isFunction(afterClose)) {
-          afterClose(res);
-        }
-      };
-    },
-    closeModal: () => {
-      getInstance()?.setModalProps({ visible: false });
-    }
-  };
-  return [register, methods];
-}
-function useModal(props, setModalData) {
-  const modalInstanceRef = ref(null);
-  const currentInstance = getCurrentInstance();
-  const uidRef = ref(null);
-  const isFirstRegister = ref(true);
-  const { isProd } = useApp();
-  const getInstance = () => {
-    const instance = unref(modalInstanceRef);
-    if (!instance) {
-      error("useModal \u5B9E\u4F8B\u672A\u5B9A\u4E49");
-    }
-    return instance;
-  };
-  const register = (modalInstance, uuid) => {
-    if (unref(isProd)) {
-      modalInstanceRef.value = null;
-    }
-    uidRef.value = uuid;
-    modalInstanceRef.value = modalInstance;
-    currentInstance?.emit("register", modalInstance, uuid);
-    orgDialogProp[uuid] = toRaw(props);
-    modalInstance.setModalProps(props);
-  };
-  watchEffect(() => {
-    if (!unref(uidRef))
-      return;
-    const data = dataTransfer[unref(uidRef)];
-    if (!setModalData || !isFunction(setModalData))
-      return;
-    nextTick(() => {
-      if (unref(isFirstRegister)) {
-        isFirstRegister.value = false;
-        return;
-      }
-      setModalData(data ?? {});
-      if (!data)
-        return;
-      if (props?.title && isFunction(props?.title)) {
-        let title = props.title(data);
-        methods.setModalProps({ title });
-      }
-    });
-  });
-  const methods = {
-    setLoading: (loading = true) => {
-      getInstance()?.setModalProps({ loading });
-    },
-    closeModal: (rsp) => {
-      if (cbTransfer[unref(uidRef)])
-        cbTransfer[unref(uidRef)](rsp);
-      getInstance()?.setModalProps({ visible: false });
-    },
-    setModalProps: (props2) => {
-      getInstance()?.setModalProps(props2);
-    },
-    redoModalHeight: () => {
-      const callRedo = getInstance()?.redoModalHeight;
-      callRedo && callRedo();
-    }
-  };
-  return [register, methods];
-}
-const basicProps = {
-  t: {
-    type: String
-  },
-  visible: {
-    type: Boolean
-  },
-  closable: {
-    type: Boolean,
-    default: true
-  },
-  destroyOnClose: {
-    type: Boolean
-  },
-  scrollTop: {
-    type: Boolean,
-    default: true
-  },
-  height: { type: Number },
-  minHeight: { type: Number },
-  width: { type: [String, Number] },
-  draggable: {
-    type: Boolean,
-    default: true
-  },
-  defaultFullscreen: {
-    type: Boolean
-  },
-  canFullscreen: {
-    type: Boolean,
-    default: true
-  },
-  title: {
-    type: String
-  },
-  loading: { type: Boolean, default: false },
-  loadingTip: { type: String, default: "\u52A0\u8F7D\u4E2D..." },
-  useWrapper: {
-    type: Boolean,
-    default: true
-  },
-  wrapClassName: { type: String },
-  zIndex: { type: Number },
-  centered: { type: Boolean },
-  showOkBtn: {
-    type: Boolean,
-    default: true
-  },
-  showCancelBtn: {
-    type: Boolean,
-    default: true
-  },
-  okText: {
-    type: String
-  },
-  cancelText: {
-    type: String
-  },
-  mask: { type: Boolean, default: true },
-  maskClosable: { type: Boolean, default: true },
-  keyboard: { type: Boolean, default: true },
-  maskStyle: Object,
-  footer: {
-    type: Object
-  },
-  bodyStyle: Object,
-  wrapperProps: Object,
-  getContainer: Function,
-  closeFunc: Function,
-  afterClose: Function
-};
-function useDragMove(context) {
-  const getStyle = (dom, attr) => {
-    return getComputedStyle(dom)[attr];
-  };
-  const drag = (wrap) => {
-    if (!wrap)
-      return;
-    wrap.setAttribute("data-drag", unref(context.draggable));
-    const dialogHeaderEl = wrap.querySelector(".ant-modal-header");
-    const dragDom = wrap.querySelector(".ant-modal");
-    if (!dialogHeaderEl || !dragDom || !unref(context.draggable))
-      return;
-    dialogHeaderEl.style.cursor = "move";
-    dialogHeaderEl.onmousedown = (e) => {
-      if (!e)
-        return;
-      const disX = e.clientX;
-      const disY = e.clientY;
-      const screenWidth = document.body.clientWidth;
-      const screenHeight = document.documentElement.clientHeight;
-      const dragDomWidth = dragDom.offsetWidth;
-      const dragDomheight = dragDom.offsetHeight;
-      const minDragDomLeft = dragDom.offsetLeft;
-      const maxDragDomLeft = screenWidth - dragDom.offsetLeft - dragDomWidth;
-      const minDragDomTop = dragDom.offsetTop;
-      const maxDragDomTop = screenHeight - dragDom.offsetTop - dragDomheight;
-      const domLeft = getStyle(dragDom, "left");
-      const domTop = getStyle(dragDom, "top");
-      let styL = +domLeft;
-      let styT = +domTop;
-      if (domLeft.includes("%")) {
-        styL = +document.body.clientWidth * (+domLeft.replace(/%/g, "") / 100);
-        styT = +document.body.clientHeight * (+domTop.replace(/%/g, "") / 100);
-      } else {
-        styL = +domLeft.replace(/px/g, "");
-        styT = +domTop.replace(/px/g, "");
-      }
-      document.onmousemove = function(e2) {
-        let left = e2.clientX - disX;
-        let top = e2.clientY - disY;
-        if (-left > minDragDomLeft) {
-          left = -minDragDomLeft;
-        } else if (left > maxDragDomLeft) {
-          left = maxDragDomLeft;
-        }
-        if (-top > minDragDomTop) {
-          top = -minDragDomTop;
-        } else if (top > maxDragDomTop) {
-          top = maxDragDomTop;
-        }
-        dragDom.style.cssText += `;left:${left + styL}px;top:${top + styT}px;`;
-      };
-      document.onmouseup = () => {
-        document.onmousemove = null;
-        document.onmouseup = null;
-      };
-    };
-  };
-  const handleDrag = () => {
-    const dragWraps = document.querySelectorAll(".ant-modal-wrap");
-    for (const wrap of Array.from(dragWraps)) {
-      if (!wrap)
-        continue;
-      const display = getStyle(wrap, "display");
-      const draggable = wrap.getAttribute("data-drag");
-      if (display !== "none") {
-        if (draggable === null || unref(context.destroyOnClose)) {
-          drag(wrap);
-        }
-      }
-    }
-  };
-  watchEffect(() => {
-    if (!unref(context.visible) || !unref(context.draggable)) {
-      return;
-    }
-    useTimeoutFn(() => {
-      handleDrag();
-    }, 30);
-  });
-}
-function _isSlot(s) {
-  return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s);
-}
-const _sfc_main$3 = {
-  name: "Modal",
-  inheritAttrs: false,
-  props: basicProps,
-  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(attrs),
-        ...props,
-        destroyOnClose: true,
-        onCancel,
-        centered: true,
-        getContainer: getPopupContainer()
-      };
-      if (!propsData?.visible)
-        return null;
-      return createVNode(Modal$1, propsData, _isSlot(_slot = extendSlots(slots)) ? _slot : {
-        default: () => [_slot]
-      });
-    };
-  }
-};
-const _export_sfc = (sfc, props) => {
-  const target = sfc.__vccOpts || sfc;
-  for (const [key, val] of props) {
-    target[key] = val;
-  }
-  return target;
-};
-const Modal = /* @__PURE__ */ _export_sfc(_sfc_main$3, [["__file", "D:/dt/dt-frame-front/dt-frames/frames/packages/ui/src/components/modal/src/components/Modal.vue"]]);
-const _sfc_main$2 = /* @__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;
-      return openBlock(), createElementBlock("div", {
-        class: normalizeClass(["flex h-14 items-center justify-center", unref(getClass)])
-      }, [
-        __props.canFullscreen ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
-          __props.fullScreen ? (openBlock(), createBlock(_component_ATooltip, {
-            key: 0,
-            title: unref(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(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$2, [["__file", "D:/dt/dt-frame-front/dt-frames/frames/packages/ui/src/components/modal/src/components/CloseIcon.vue"]]);
-const _sfc_main$1 = /* @__PURE__ */ defineComponent({
-  __name: "ModalFooter",
-  props: {
-    authPrefix: { type: String },
-    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: "\u5173\u95ED", label: props.cancelText || t("CLOSE"), preIcon: "mdi:close", flag: "CANCEL" },
-        { t: "\u4FDD\u5B58", label: props.okText || t("SAVE"), preIcon: "mdi:content-save", auth: "edit", type: "primary", flag: "OK" }
-      ];
-      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(unref(DtFormButtons), {
-          mode: "dialog",
-          buttonList: unref(buttonList),
-          authPrefix: __props.authPrefix,
-          onHandleMethod: _cache[0] || (_cache[0] = ($event) => handleMethod($event))
-        }, null, 8, ["buttonList", "authPrefix"])
-      ], 64);
-    };
-  }
-});
-const ModalFooter = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["__file", "D:/dt/dt-frame-front/dt-frames/frames/packages/ui/src/components/modal/src/components/ModalFooter.vue"]]);
-function useFullScreen(wrapClassName) {
-  const fullScreenRef = ref(false);
-  const getWrapClassName = computed(() => {
-    const clsName = unref(wrapClassName) || "";
-    const cls = unref(fullScreenRef) ? `fullscreen-modal ${clsName} ` : unref(clsName);
-    return `dt-modal ${cls}`;
-  });
-  function toggleFullScreen(e) {
-    e && e.stopPropagation();
-    fullScreenRef.value = !unref(fullScreenRef);
-    dispatchResize();
-  }
-  return {
-    fullScreenRef,
-    getWrapClassName,
-    toggleFullScreen
-  };
-}
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "index",
-  props: basicProps,
-  emits: ["visible-change", "cancel", "save", "register", "toggle-fullscreen", "update:visible"],
-  setup(__props, { emit: emits }) {
-    const props = __props;
-    const visibleRef = ref(false);
-    const propsRef = ref();
-    const modalWrapperRef = ref(null);
-    const { getWrapClassName, toggleFullScreen, fullScreenRef } = useFullScreen(computed(() => unref(propsRef)?.wrapClassName));
-    function handleFullscreen(e) {
-      toggleFullScreen(e);
-      emits("toggle-fullscreen", unref(fullScreenRef));
-    }
-    const getMergeProps = computed(() => {
-      return {
-        ...props,
-        ...unref(propsRef)
-      };
-    });
-    const getBindValue = computed(() => {
-      const bindValue = {
-        ...unref(getMergeProps),
-        ...unref(propsRef),
-        visible: unref(visibleRef),
-        wrapClassName: unref(getWrapClassName)
-      };
-      let omitArr = unref(fullScreenRef) ? ["height", "title"] : ["title"];
-      if (isArray(unref(propsRef)?.footer)) {
-        omitArr.push("footer");
-      }
-      return omit(bindValue, omitArr);
-    });
-    const modalMethods = {
-      setModalProps,
-      redoModalHeight: () => {
-        nextTick(() => {
-          if (unref(modalWrapperRef)) {
-            unref(modalWrapperRef).setModalHeight();
-          }
-        });
-      }
-    };
-    const instance = getCurrentInstance();
-    if (instance) {
-      emits("register", modalMethods, instance.uid);
-    }
-    function setModalProps(props2) {
-      propsRef.value = deepMerge(unref(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(getBindValue);
-      if (afterClose && isFunction(afterClose)) {
-        afterClose();
-      }
-      visibleRef.value = false;
-      emits("cancel", e);
-    }
-    watch(() => unref(visibleRef), (v) => {
-      emits("visible-change", v);
-      emits("update:visible", v);
-      nextTick(() => {
-        if (props.scrollTop && v && unref(modalWrapperRef)) {
-          unref(modalWrapperRef).$el.scrollTop = 0;
-        }
-      });
-    }, {
-      immediate: false
-    });
-    return (_ctx, _cache) => {
-      const _component_ASpin = Spin;
-      return openBlock(), createBlock(Modal, mergeProps(unref(getBindValue), { onCancel: handleCancel }), createSlots({
-        default: withCtx(() => [
-          createVNode(_component_ASpin, {
-            spinning: unref(getBindValue).loading,
-            tip: unref(getBindValue).loadingTip
-          }, {
-            default: withCtx(() => [
-              renderSlot(_ctx.$slots, "default")
-            ]),
-            _: 3
-          }, 8, ["spinning", "tip"])
-        ]),
-        _: 2
-      }, [
-        !_ctx.$slots.closeIcon ? {
-          name: "closeIcon",
-          fn: withCtx(() => [
-            createVNode(CloseIcon, {
-              canFullscreen: unref(getBindValue).canFullscreen,
-              fullScreen: unref(fullScreenRef),
-              onCancel: handleCancel,
-              onFullscreen: handleFullscreen
-            }, null, 8, ["canFullscreen", "fullScreen"])
-          ]),
-          key: "0"
-        } : void 0,
-        !_ctx.$slots.title ? {
-          name: "title",
-          fn: withCtx(() => [
-            createTextVNode(toDisplayString(unref(getMergeProps).title), 1)
-          ]),
-          key: "1"
-        } : void 0,
-        !_ctx.$slots.footer ? {
-          name: "footer",
-          fn: withCtx(() => [
-            createVNode(ModalFooter, {
-              authPrefix: unref(getBindValue).authPrefix,
-              buttons: propsRef.value?.footer,
-              showSave: unref(getBindValue).showOkBtn,
-              showCancel: unref(getBindValue).showCancelBtn,
-              okText: unref(getBindValue).okText,
-              cancelText: unref(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, ["authPrefix", "buttons", "showSave", "showCancel", "okText", "cancelText"])
-          ]),
-          key: "2"
-        } : void 0,
-        renderList(Object.keys(unref(omit)(_ctx.$slots, "default")), (item) => {
-          return {
-            name: item,
-            fn: withCtx((data) => [
-              renderSlot(_ctx.$slots, item, normalizeProps(guardReactiveProps(data || {})))
-            ])
-          };
-        })
-      ]), 1040);
-    };
-  }
-});
-const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "D:/dt/dt-frame-front/dt-frames/frames/packages/ui/src/components/modal/src/index.vue"]]);
-export {
-  index as DtModal,
-  basicProps,
-  useModal,
-  useModalOut
-};