ep-craft 0.1.37 → 0.1.39

package/dist/components/message-box/src/index.vue.js

@@ -0,0 +1,203 @@
+import T from "./index2.vue.js";
+import { resolveComponent as d, openBlock as l, createBlock as a, Transition as $, withCtx as i, withDirectives as C, createVNode as u, createElementVNode as t, normalizeClass as o, withModifiers as v, normalizeStyle as B, createElementBlock as f, resolveDynamicComponent as p, createCommentVNode as r, toDisplayString as m, withKeys as y, renderSlot as E, vShow as b, createTextVNode as k } from "vue";
+import z from "../../../_virtual/_plugin-vue_export-helper.js";
+const R = ["aria-label", "aria-describedby"], A = ["aria-label"], S = ["id"];
+function V(e, n, L, K, D, N) {
+  const g = d("el-icon"), h = d("el-input"), w = d("el-button"), I = d("el-focus-trap"), M = d("el-overlay");
+  return l(), a($, {
+    name: "fade-in-linear",
+    onAfterLeave: n[11] || (n[11] = (s) => e.$emit("vanish"))
+  }, {
+    default: i(() => [
+      C(u(M, {
+        "z-index": e.zIndex,
+        "overlay-class": [e.ns.is("message-box"), e.modalClass],
+        mask: e.modal
+      }, {
+        default: i(() => [
+          t("div", {
+            role: "dialog",
+            "aria-label": e.title,
+            "aria-modal": "true",
+            "aria-describedby": e.showInput ? void 0 : e.contentId,
+            class: o(`${e.ns.namespace.value}-overlay-message-box`),
+            onClick: n[8] || (n[8] = (...s) => e.overlayEvent.onClick && e.overlayEvent.onClick(...s)),
+            onMousedown: n[9] || (n[9] = (...s) => e.overlayEvent.onMousedown && e.overlayEvent.onMousedown(...s)),
+            onMouseup: n[10] || (n[10] = (...s) => e.overlayEvent.onMouseup && e.overlayEvent.onMouseup(...s))
+          }, [
+            u(I, {
+              loop: "",
+              trapped: e.visible,
+              "focus-trap-el": e.rootRef,
+              "focus-start-el": e.focusStartRef,
+              onReleaseRequested: e.onCloseRequested
+            }, {
+              default: i(() => [
+                t("div", {
+                  ref: "rootRef",
+                  class: o([
+                    e.ns.b(),
+                    e.customClass,
+                    e.ns.is("draggable", e.draggable),
+                    e.ns.is("dragging", e.isDragging),
+                    { [e.ns.m("center")]: e.center }
+                  ]),
+                  style: B(e.customStyle),
+                  tabindex: "-1",
+                  onClick: n[7] || (n[7] = v(() => {
+                  }, ["stop"]))
+                }, [
+                  e.title !== null && e.title !== void 0 ? (l(), f("div", {
+                    key: 0,
+                    ref: "headerRef",
+                    class: o([e.ns.e("header"), { "show-close": e.showClose }])
+                  }, [
+                    t("div", {
+                      class: o(e.ns.e("title"))
+                    }, [
+                      e.iconComponent && e.center ? (l(), a(g, {
+                        key: 0,
+                        class: o([e.ns.e("status"), e.typeClass])
+                      }, {
+                        default: i(() => [
+                          (l(), a(p(e.iconComponent)))
+                        ]),
+                        _: 1
+                      }, 8, ["class"])) : r("", !0),
+                      t("span", null, m(e.title), 1)
+                    ], 2),
+                    e.showClose ? (l(), f("button", {
+                      key: 0,
+                      type: "button",
+                      class: o(e.ns.e("headerbtn")),
+                      "aria-label": e.t("el.messagebox.close"),
+                      onClick: n[0] || (n[0] = (s) => e.handleAction(e.distinguishCancelAndClose ? "close" : "cancel")),
+                      onKeydown: n[1] || (n[1] = y(v((s) => e.handleAction(e.distinguishCancelAndClose ? "close" : "cancel"), ["prevent"]), ["enter"]))
+                    }, [
+                      u(g, {
+                        class: o(e.ns.e("close"))
+                      }, {
+                        default: i(() => [
+                          (l(), a(p(e.closeIcon || "close")))
+                        ]),
+                        _: 1
+                      }, 8, ["class"])
+                    ], 42, A)) : r("", !0)
+                  ], 2)) : r("", !0),
+                  t("div", {
+                    id: e.contentId,
+                    class: o(e.ns.e("content"))
+                  }, [
+                    t("div", {
+                      class: o(e.ns.e("container"))
+                    }, [
+                      e.iconComponent && !e.center && e.hasMessage ? (l(), a(g, {
+                        key: 0,
+                        class: o([e.ns.e("status"), e.typeClass])
+                      }, {
+                        default: i(() => [
+                          (l(), a(p(e.iconComponent)))
+                        ]),
+                        _: 1
+                      }, 8, ["class"])) : r("", !0),
+                      e.hasMessage ? (l(), f("div", {
+                        key: 1,
+                        class: o(e.ns.e("message"))
+                      }, [
+                        E(e.$slots, "default", {}, () => [
+                          e.dangerouslyUseHTMLString ? (l(), a(p(e.showInput ? "label" : "p"), {
+                            key: 1,
+                            for: e.showInput ? e.inputId : void 0,
+                            innerHTML: e.message
+                          }, null, 8, ["for", "innerHTML"])) : (l(), a(p(e.showInput ? "label" : "p"), {
+                            key: 0,
+                            for: e.showInput ? e.inputId : void 0,
+                            textContent: m(e.message)
+                          }, null, 8, ["for", "textContent"]))
+                        ])
+                      ], 2)) : r("", !0)
+                    ], 2),
+                    C(t("div", {
+                      class: o(e.ns.e("input"))
+                    }, [
+                      u(h, {
+                        id: e.inputId,
+                        ref: "inputRef",
+                        modelValue: e.inputValue,
+                        "onUpdate:modelValue": n[2] || (n[2] = (s) => e.inputValue = s),
+                        type: e.inputType,
+                        placeholder: e.inputPlaceholder,
+                        "aria-invalid": e.validateError,
+                        class: o({ invalid: e.validateError }),
+                        onKeydown: y(e.handleInputEnter, ["enter"])
+                      }, null, 8, ["id", "modelValue", "type", "placeholder", "aria-invalid", "class", "onKeydown"]),
+                      t("div", {
+                        class: o(e.ns.e("errormsg")),
+                        style: B({
+                          visibility: e.editorErrorMessage ? "visible" : "hidden"
+                        })
+                      }, m(e.editorErrorMessage), 7)
+                    ], 2), [
+                      [b, e.showInput]
+                    ])
+                  ], 10, S),
+                  e.showCancelButton || e.showConfirmButton ? (l(), f("div", {
+                    key: 1,
+                    class: o(e.ns.e("btns"))
+                  }, [
+                    e.showCancelButton ? (l(), a(w, {
+                      key: 0,
+                      type: e.cancelButtonType === "text" ? "" : e.cancelButtonType,
+                      text: e.cancelButtonType === "text",
+                      loading: e.cancelButtonLoading,
+                      "loading-icon": e.cancelButtonLoadingIcon,
+                      class: o([e.cancelButtonClass]),
+                      round: e.roundButton,
+                      size: e.btnSize,
+                      onClick: n[3] || (n[3] = (s) => e.handleAction("cancel")),
+                      onKeydown: n[4] || (n[4] = y(v((s) => e.handleAction("cancel"), ["prevent"]), ["enter"]))
+                    }, {
+                      default: i(() => [
+                        k(m(e.cancelButtonText || e.t("el.messagebox.cancel")), 1)
+                      ]),
+                      _: 1
+                    }, 8, ["type", "text", "loading", "loading-icon", "class", "round", "size"])) : r("", !0),
+                    C(u(w, {
+                      ref: "confirmRef",
+                      type: e.confirmButtonType === "text" ? "" : e.confirmButtonType,
+                      text: e.confirmButtonType === "text",
+                      loading: e.confirmButtonLoading,
+                      "loading-icon": e.confirmButtonLoadingIcon,
+                      class: o([e.confirmButtonClasses]),
+                      round: e.roundButton,
+                      disabled: e.confirmButtonDisabled,
+                      size: e.btnSize,
+                      onClick: n[5] || (n[5] = (s) => e.handleAction("confirm")),
+                      onKeydown: n[6] || (n[6] = y(v((s) => e.handleAction("confirm"), ["prevent"]), ["enter"]))
+                    }, {
+                      default: i(() => [
+                        k(m(e.confirmButtonText || e.t("el.messagebox.confirm")), 1)
+                      ]),
+                      _: 1
+                    }, 8, ["type", "text", "loading", "loading-icon", "class", "round", "disabled", "size"]), [
+                      [b, e.showConfirmButton]
+                    ])
+                  ], 2)) : r("", !0)
+                ], 6)
+              ]),
+              _: 3
+            }, 8, ["trapped", "focus-trap-el", "focus-start-el", "onReleaseRequested"])
+          ], 42, R)
+        ]),
+        _: 3
+      }, 8, ["z-index", "overlay-class", "mask"]), [
+        [b, e.visible]
+      ])
+    ]),
+    _: 3
+  });
+}
+const P = /* @__PURE__ */ z(T, [["render", V]]);
+export {
+  P as default
+};

package/dist/components/message-box/src/index2.vue.js

@@ -0,0 +1,237 @@
+import { defineComponent as G, computed as r, ref as s, reactive as W, markRaw as b, watch as x, nextTick as m, onMounted as Z, onBeforeUnmount as j, toRefs as J } from "vue";
+import { EpButton as K } from "../../button/index.js";
+import "../../../directives/click-outside/index.js";
+import { isFunction as N, isString as Q } from "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import { TypeComponents as X, TypeComponentsMap as T } from "../../../utils/vue/icon.js";
+import { isValidComponentSize as Y } from "../../../utils/vue/validator.js";
+import ee from "../../../directives/trap-focus/index.js";
+import "normalize-wheel-es";
+import { useId as I } from "../../../hooks/use-id/index.js";
+import "../../../hooks/use-size/index.js";
+import "@popperjs/core";
+import "../../../hooks/use-z-index/index.js";
+import "../../../hooks/use-delayed-toggle/index.js";
+import "../../../hooks/use-aria/index.js";
+import "../../../hooks/use-model-toggle/index.js";
+import "../../../hooks/use-empty-values/index.js";
+import { useLockscreen as te } from "../../../hooks/use-lockscreen/index.js";
+import { useSameTarget as oe } from "../../../hooks/use-same-target/index.js";
+import { useDraggable as ne } from "../../../hooks/use-draggable/index.js";
+import { EpInput as re } from "../../input/index.js";
+import { EpOverlay as ae } from "../../overlay/overlay.js";
+import { ElIcon as se } from "../../icon/index.js";
+import { Loading as M } from "@element-plus/icons-vue";
+import { EpFocusTrap as ie } from "../../focus-trap/index.js";
+import "../../config-provider/index.js";
+import { useGlobalComponentSettings as le } from "../../config-provider/src/hooks/use-global-config.js";
+const Ae = G({
+  name: "ElMessageBox",
+  directives: {
+    TrapFocus: ee
+  },
+  components: {
+    ElButton: K,
+    ElFocusTrap: ie,
+    ElInput: re,
+    ElOverlay: ae,
+    ElIcon: se,
+    ...X
+  },
+  inheritAttrs: !1,
+  props: {
+    buttonSize: {
+      type: String,
+      validator: Y
+    },
+    modal: {
+      type: Boolean,
+      default: !0
+    },
+    lockScroll: {
+      type: Boolean,
+      default: !0
+    },
+    showClose: {
+      type: Boolean,
+      default: !0
+    },
+    closeOnClickModal: {
+      type: Boolean,
+      default: !0
+    },
+    closeOnPressEscape: {
+      type: Boolean,
+      default: !0
+    },
+    closeOnHashChange: {
+      type: Boolean,
+      default: !0
+    },
+    center: Boolean,
+    draggable: Boolean,
+    overflow: Boolean,
+    roundButton: Boolean,
+    container: {
+      type: String,
+      // default append to body
+      default: "body"
+    },
+    boxType: {
+      type: String,
+      default: ""
+    }
+  },
+  emits: ["vanish", "action"],
+  setup(n, { emit: w }) {
+    const {
+      locale: S,
+      zIndex: k,
+      ns: p,
+      size: L
+    } = le(
+      "message-box",
+      r(() => n.buttonSize)
+    ), { t: d } = S, { nextZIndex: v } = k, i = s(!1), e = W({
+      // autofocus element when open message-box
+      autofocus: !0,
+      beforeClose: null,
+      callback: null,
+      cancelButtonText: "",
+      cancelButtonClass: "",
+      confirmButtonText: "",
+      confirmButtonClass: "",
+      cancelButtonType: "",
+      confirmButtonType: "primary",
+      customClass: "",
+      customStyle: {},
+      dangerouslyUseHTMLString: !1,
+      distinguishCancelAndClose: !1,
+      icon: "",
+      closeIcon: "",
+      inputPattern: null,
+      inputPlaceholder: "",
+      inputType: "text",
+      inputValue: "",
+      inputValidator: void 0,
+      inputErrorMessage: "",
+      message: "",
+      modalFade: !0,
+      modalClass: "",
+      showCancelButton: !1,
+      showConfirmButton: !0,
+      type: "",
+      title: void 0,
+      showInput: !1,
+      action: "",
+      confirmButtonLoading: !1,
+      cancelButtonLoading: !1,
+      confirmButtonLoadingIcon: b(M),
+      cancelButtonLoadingIcon: b(M),
+      confirmButtonDisabled: !1,
+      editorErrorMessage: "",
+      // refer to: https://github.com/ElemeFE/element/commit/2999279ae34ef10c373ca795c87b020ed6753eed
+      // seemed ok for now without this state.
+      // isOnComposition: false, // temporary remove
+      validateError: !1,
+      zIndex: v()
+    }), O = r(() => {
+      const t = e.type;
+      return { [p.bm("icon", t)]: t && T[t] };
+    }), z = I(), V = I(), P = r(() => {
+      const t = e.type;
+      return e.icon || t && T[t] || "";
+    }), R = r(() => !!e.message), a = s(), y = s(), l = s(), u = s(), C = s(), F = r(() => e.confirmButtonClass);
+    x(
+      () => e.inputValue,
+      async (t) => {
+        await m(), n.boxType === "prompt" && t && B();
+      },
+      { immediate: !0 }
+    ), x(
+      () => i.value,
+      (t) => {
+        var o;
+        t && (n.boxType !== "prompt" && (e.autofocus ? l.value = ((o = C.value) == null ? void 0 : o.$el) ?? a.value : l.value = a.value), e.zIndex = v()), n.boxType === "prompt" && (t ? m().then(() => {
+          u.value && u.value.$el && (e.autofocus ? l.value = _() ?? a.value : l.value = a.value);
+        }) : (e.editorErrorMessage = "", e.validateError = !1));
+      }
+    );
+    const A = r(() => n.draggable), D = r(() => n.overflow), { isDragging: H } = ne(a, y, A, D);
+    Z(async () => {
+      await m(), n.closeOnHashChange && window.addEventListener("hashchange", c);
+    }), j(() => {
+      n.closeOnHashChange && window.removeEventListener("hashchange", c);
+    });
+    function c() {
+      i.value && (i.value = !1, m(() => {
+        e.action && w("action", e.action);
+      }));
+    }
+    const E = () => {
+      n.closeOnClickModal && f(e.distinguishCancelAndClose ? "close" : "cancel");
+    }, $ = oe(E), U = (t) => {
+      var o;
+      if (e.inputType !== "textarea" && !((o = u.value) != null && o.isComposing))
+        return t.preventDefault(), f("confirm");
+    }, f = (t) => {
+      var o;
+      n.boxType === "prompt" && t === "confirm" && !B() || (e.action = t, e.beforeClose ? (o = e.beforeClose) == null || o.call(e, t, e, c) : c());
+    }, B = () => {
+      if (n.boxType === "prompt") {
+        const t = e.inputPattern;
+        if (t && !t.test(e.inputValue || ""))
+          return e.editorErrorMessage = e.inputErrorMessage || d("el.messagebox.error"), e.validateError = !0, !1;
+        const o = e.inputValidator;
+        if (N(o)) {
+          const g = o(e.inputValue);
+          if (g === !1)
+            return e.editorErrorMessage = e.inputErrorMessage || d("el.messagebox.error"), e.validateError = !0, !1;
+          if (Q(g))
+            return e.editorErrorMessage = g, e.validateError = !0, !1;
+        }
+      }
+      return e.editorErrorMessage = "", e.validateError = !1, !0;
+    }, _ = () => {
+      var o;
+      const t = (o = u.value) == null ? void 0 : o.$refs;
+      return (t == null ? void 0 : t.input) ?? (t == null ? void 0 : t.textarea);
+    }, h = () => {
+      f("close");
+    }, q = () => {
+      n.closeOnPressEscape && h();
+    };
+    return n.lockScroll && te(i, { ns: p }), {
+      ...J(e),
+      ns: p,
+      overlayEvent: $,
+      visible: i,
+      hasMessage: R,
+      typeClass: O,
+      contentId: z,
+      inputId: V,
+      btnSize: L,
+      iconComponent: P,
+      confirmButtonClasses: F,
+      rootRef: a,
+      focusStartRef: l,
+      headerRef: y,
+      inputRef: u,
+      isDragging: H,
+      confirmRef: C,
+      doClose: c,
+      // for outside usage
+      handleClose: h,
+      // for out side usage
+      onCloseRequested: q,
+      handleWrapperClick: E,
+      handleInputEnter: U,
+      handleAction: f,
+      t: d
+    };
+  }
+});
+export {
+  Ae as default
+};

package/dist/components/message-box/src/message-box.type.d.ts

@@ -0,0 +1,167 @@
+import type { AppContext, Component, VNode } from 'vue';
+import type { ComponentSize } from '../../../constants/index';
+import type { CSSProperties } from '../../../utils/index';
+import type { InputType } from '../../input/index';
+import type { buttonTypes } from '../../button/button';
+export type MessageType = '' | 'primary' | 'success' | 'warning' | 'info' | 'error';
+export type MessageBoxButtonType = (typeof buttonTypes)[number];
+export type Action = 'confirm' | 'close' | 'cancel';
+export type MessageBoxType = '' | 'prompt' | 'alert' | 'confirm';
+export type MessageBoxData = MessageBoxInputData & Action;
+export interface MessageBoxInputData {
+    value: string;
+    action: Action;
+}
+export type MessageBoxInputValidator = ((value: string) => boolean | string) | undefined;
+export type CloseFn = () => void;
+export interface MessageBoxActionHandlers {
+    confirm: CloseFn;
+    cancel: CloseFn;
+    close: CloseFn;
+}
+export interface MessageBoxState {
+    autofocus: boolean;
+    title: string | undefined;
+    message: string;
+    type: MessageType;
+    icon: string | Component;
+    closeIcon: string | Component;
+    customClass: string;
+    customStyle: CSSProperties;
+    showInput: boolean;
+    inputValue: string;
+    inputPlaceholder: string;
+    inputType: InputType;
+    inputPattern: RegExp | null;
+    inputValidator: MessageBoxInputValidator;
+    inputErrorMessage: string;
+    showConfirmButton: boolean;
+    showCancelButton: boolean;
+    action: Action;
+    dangerouslyUseHTMLString: boolean;
+    confirmButtonText: string;
+    cancelButtonText: string;
+    confirmButtonType: MessageBoxButtonType;
+    cancelButtonType: MessageBoxButtonType;
+    confirmButtonLoading: boolean;
+    cancelButtonLoading: boolean;
+    confirmButtonLoadingIcon: string | Component;
+    cancelButtonLoadingIcon: string | Component;
+    confirmButtonClass: string;
+    confirmButtonDisabled: boolean;
+    cancelButtonClass: string;
+    editorErrorMessage: string;
+    beforeClose: null | ((action: Action, instance: MessageBoxState, done: () => void) => void);
+    callback: null | Callback;
+    distinguishCancelAndClose: boolean;
+    modalFade: boolean;
+    modalClass: string;
+    validateError: boolean;
+    zIndex: number;
+}
+export type Callback = ((value: string, action: Action) => any) | ((action: Action) => any);
+/** Options used in MessageBox */
+export interface ElMessageBoxOptions {
+    /**
+     * auto focus when open message-box
+     */
+    autofocus?: boolean;
+    /** Callback before MessageBox closes, and it will prevent MessageBox from closing */
+    beforeClose?: (action: Action, instance: MessageBoxState, done: () => void) => void;
+    /** Custom class name for MessageBox */
+    customClass?: string;
+    /** Custom inline style for MessageBox */
+    customStyle?: CSSProperties;
+    /** Whether a mask is displayed */
+    modal?: boolean;
+    /** modal class name for MessageBox */
+    modalClass?: string;
+    /** MessageBox closing callback if you don't prefer Promise */
+    callback?: Callback;
+    /** Text content of cancel button */
+    cancelButtonText?: string;
+    /** Text content of confirm button */
+    confirmButtonText?: string;
+    /** Type of cancel button */
+    cancelButtonType?: MessageBoxButtonType;
+    /** Type of confirm button */
+    confirmButtonType?: MessageBoxButtonType;
+    /** Loading Icon content of cancel button */
+    cancelButtonLoadingIcon?: string | Component;
+    /** Loading Icon content of confirm button */
+    confirmButtonLoadingIcon?: string | Component;
+    /** Custom class name of cancel button */
+    cancelButtonClass?: string;
+    /** Custom class name of confirm button */
+    confirmButtonClass?: string;
+    /** Whether to align the content in center */
+    center?: boolean;
+    /** Whether MessageBox can be drag */
+    draggable?: boolean;
+    /** Draggable MessageBox can overflow the viewport */
+    overflow?: boolean;
+    /** Content of the MessageBox */
+    message?: string | VNode | ((params: MessageBoxActionHandlers) => VNode);
+    /** Title of the MessageBox */
+    title?: string | ElMessageBoxOptions;
+    /** Message type, used for icon display */
+    type?: MessageType;
+    /** Message box type */
+    boxType?: MessageBoxType;
+    /** Custom icon component */
+    icon?: string | Component;
+    /** Custom close icon component */
+    closeIcon?: string | Component;
+    /** Whether message is treated as HTML string */
+    dangerouslyUseHTMLString?: boolean;
+    /** Whether to distinguish canceling and closing */
+    distinguishCancelAndClose?: boolean;
+    /** Whether to lock body scroll when MessageBox prompts */
+    lockScroll?: boolean;
+    /** Whether to show a cancel button */
+    showCancelButton?: boolean;
+    /** Whether to show a confirm button */
+    showConfirmButton?: boolean;
+    /** Whether to show a close button */
+    showClose?: boolean;
+    /** Whether to use round button */
+    roundButton?: boolean;
+    /** Whether MessageBox can be closed by clicking the mask */
+    closeOnClickModal?: boolean;
+    /** Whether MessageBox can be closed by pressing the ESC */
+    closeOnPressEscape?: boolean;
+    /** Whether to close MessageBox when hash changes */
+    closeOnHashChange?: boolean;
+    /** Whether to show an input */
+    showInput?: boolean;
+    /** Placeholder of input */
+    inputPlaceholder?: string;
+    /** Initial value of input */
+    inputValue?: string;
+    /** Regexp for the input */
+    inputPattern?: RegExp;
+    /** type of input, see more in [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Form_%3Cinput%3E_types) */
+    inputType?: InputType;
+    /** Validation function for the input. Should returns a boolean or string. If a string is returned, it will be assigned to inputErrorMessage */
+    inputValidator?: MessageBoxInputValidator;
+    /** Error message when validation fails */
+    inputErrorMessage?: string;
+    /** Custom size of confirm and cancel buttons */
+    buttonSize?: ComponentSize;
+    /** Custom element to append the message box to */
+    appendTo?: HTMLElement | string;
+}
+export type ElMessageBoxShortcutMethod = ((message: ElMessageBoxOptions['message'], options?: ElMessageBoxOptions, appContext?: AppContext | null) => Promise<MessageBoxData>) & ((message: ElMessageBoxOptions['message'], title: ElMessageBoxOptions['title'], options?: ElMessageBoxOptions, appContext?: AppContext | null) => Promise<MessageBoxData>);
+export interface IElMessageBox {
+    _context: AppContext | null;
+    /** Show a message box */
+    (options: ElMessageBoxOptions, appContext?: AppContext | null): Promise<MessageBoxData>;
+    /** Show an alert message box */
+    alert: ElMessageBoxShortcutMethod;
+    /** Show a confirm message box */
+    confirm: ElMessageBoxShortcutMethod;
+    /** Show a prompt message box */
+    prompt: ElMessageBoxShortcutMethod;
+    /** Close current message box */
+    close: CloseFn;
+}

package/dist/components/message-box/src/messageBox.d.ts

@@ -0,0 +1,3 @@
+import type { IElMessageBox } from './message-box.type';
+declare const _default: IElMessageBox;
+export default _default;