ep-craft 0.1.37 → 0.1.38

package/dist/components/message/src/message.d.ts

@@ -0,0 +1,175 @@
+import type { AppContext, ExtractPublicPropTypes, VNode } from 'vue';
+import type { IconPropType, Mutable } from '@element-plus/utils';
+import type MessageConstructor from './message.vue';
+export interface MessageProps {
+    /**
+     * @description custom class name for Message
+     */
+    customClass?: string;
+    /**
+     * @description whether `message` is treated as HTML string
+     */
+    dangerouslyUseHTMLString?: boolean;
+    /**
+     * @description display duration, millisecond. If set to 0, it will not turn off automatically
+     */
+    duration?: number;
+    /**
+     * @description custom icon component, overrides `type`
+     */
+    icon?: IconPropType;
+    /**
+     * @description message dom id
+     */
+    id?: string;
+    /**
+     * @description message text
+     */
+    message?: string | VNode | (() => VNode);
+    /**
+     * @description callback function when closed with the message instance as the parameter
+     */
+    onClose?: () => void;
+    /**
+     * @description whether to show a close button
+     */
+    showClose?: boolean;
+    /**
+     * @description message type
+     */
+    type?: MessageType;
+    /**
+     * @description whether message is plain
+     */
+    plain?: boolean;
+    /**
+     * @description set the distance to the top of viewport
+     */
+    offset?: number;
+    /**
+     * @description message placement position
+     */
+    placement?: MessagePlacement;
+    /**
+     * @description message element zIndex value
+     */
+    zIndex?: number;
+    /**
+     * @description merge messages with the same content, type of VNode message is not supported
+     */
+    grouping?: boolean;
+    /**
+     * @description The number of repetitions, similar to badge, is used as the initial number when used with `grouping`
+     */
+    repeatNum?: number;
+}
+export declare const messageTypes: readonly ["primary", "success", "info", "warning", "error"];
+export declare const messagePlacement: readonly ["top", "top-left", "top-right", "bottom", "bottom-left", "bottom-right"];
+export declare const MESSAGE_DEFAULT_PLACEMENT = "top";
+export type MessageType = (typeof messageTypes)[number];
+export type MessagePlacement = (typeof messagePlacement)[number];
+/** @deprecated please use `MessageType` instead */
+export type messageType = MessageType;
+export interface MessageConfigContext {
+    max?: number;
+    grouping?: boolean;
+    duration?: number;
+    offset?: number;
+    showClose?: boolean;
+    plain?: boolean;
+    placement?: string;
+}
+export declare const messageDefaults: Mutable<{
+    readonly customClass: "";
+    readonly dangerouslyUseHTMLString: false;
+    readonly duration: 3000;
+    readonly icon: undefined;
+    readonly id: "";
+    readonly message: "";
+    readonly onClose: undefined;
+    readonly showClose: false;
+    readonly type: "info";
+    readonly plain: false;
+    readonly offset: 16;
+    readonly placement: undefined;
+    readonly zIndex: 0;
+    readonly grouping: false;
+    readonly repeatNum: 1;
+    readonly appendTo: HTMLElement;
+}>;
+/**
+ * @deprecated Removed after 3.0.0, Use `MessageProps` instead.
+ */
+export declare const messageProps: {
+    readonly customClass: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly dangerouslyUseHTMLString: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly duration: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 3000, boolean>;
+    readonly icon: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown, undefined, boolean>;
+    readonly id: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly message: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | (() => VNode)) | (() => string | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | (() => VNode)) | (((new (...args: any[]) => string | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | (() => VNode)) | (() => string | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | (() => VNode))) | null)[], unknown, unknown, "", boolean>;
+    readonly onClose: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => () => void) | (() => () => void) | {
+        (): () => void;
+        new (): any;
+        readonly prototype: any;
+    } | (((new (...args: any[]) => () => void) | (() => () => void) | {
+        (): () => void;
+        new (): any;
+        readonly prototype: any;
+    }) | null)[], unknown, unknown, undefined, boolean>;
+    readonly showClose: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly type: import("@element-plus/utils").EpPropFinalized<StringConstructor, "error" | "primary" | "success" | "warning" | "info", unknown, "info", boolean>;
+    readonly plain: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly offset: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 16, boolean>;
+    readonly placement: import("@element-plus/utils").EpPropFinalized<StringConstructor, "bottom" | "top" | "top-left" | "top-right" | "bottom-left" | "bottom-right", unknown, undefined, boolean>;
+    readonly zIndex: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly grouping: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly repeatNum: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `MessageProps` instead.
+ */
+export type MessagePropsPublic = ExtractPublicPropTypes<typeof messageProps>;
+export declare const messageEmits: {
+    destroy: () => boolean;
+};
+export type MessageEmits = typeof messageEmits;
+export type MessageInstance = InstanceType<typeof MessageConstructor> & unknown;
+export type MessageOptions = Partial<Mutable<Omit<MessageProps, 'id'> & {
+    appendTo?: HTMLElement | string;
+}>>;
+export type MessageParams = MessageOptions | MessageOptions['message'];
+export type MessageParamsNormalized = Omit<MessageProps, 'id'> & {
+    /**
+     * @description set the root element for the message, default to `document.body`
+     */
+    appendTo: HTMLElement;
+};
+export type MessageOptionsWithType = Omit<MessageOptions, 'type'>;
+export type MessageParamsWithType = MessageOptionsWithType | MessageOptions['message'];
+export interface MessageHandler {
+    /**
+     * @description close the Message
+     */
+    close: () => void;
+}
+export type MessageFn = {
+    (options?: MessageParams, appContext?: null | AppContext): MessageHandler;
+    closeAll(type?: MessageType): void;
+    closeAllByPlacement(position: MessagePlacement): void;
+};
+export type MessageTypedFn = (options?: MessageParamsWithType, appContext?: null | AppContext) => MessageHandler;
+export type Message = MessageFn & {
+    primary: MessageTypedFn;
+    success: MessageTypedFn;
+    warning: MessageTypedFn;
+    info: MessageTypedFn;
+    error: MessageTypedFn;
+};

package/dist/components/message/src/message.js

@@ -0,0 +1,160 @@
+import "@vue/shared";
+import "lodash-unified";
+import { isClient as o } from "@vueuse/core";
+import { mutable as s } from "../../../utils/typescript.js";
+import { iconPropType as a } from "../../../utils/vue/icon.js";
+import "vue";
+import { buildProps as n, definePropType as t } from "../../../utils/vue/props/runtime.js";
+const p = [
+  "primary",
+  "success",
+  "info",
+  "warning",
+  "error"
+], l = [
+  "top",
+  "top-left",
+  "top-right",
+  "bottom",
+  "bottom-left",
+  "bottom-right"
+], y = "top", e = s({
+  customClass: "",
+  dangerouslyUseHTMLString: !1,
+  duration: 3e3,
+  icon: void 0,
+  id: "",
+  message: "",
+  onClose: void 0,
+  showClose: !1,
+  type: "info",
+  plain: !1,
+  offset: 16,
+  placement: void 0,
+  zIndex: 0,
+  grouping: !1,
+  repeatNum: 1,
+  appendTo: o ? document.body : void 0
+}), c = n({
+  /**
+   * @description custom class name for Message
+   */
+  customClass: {
+    type: String,
+    default: e.customClass
+  },
+  /**
+   * @description whether `message` is treated as HTML string
+   */
+  dangerouslyUseHTMLString: {
+    type: Boolean,
+    default: e.dangerouslyUseHTMLString
+  },
+  /**
+   * @description display duration, millisecond. If set to 0, it will not turn off automatically
+   */
+  duration: {
+    type: Number,
+    default: e.duration
+  },
+  /**
+   * @description custom icon component, overrides `type`
+   */
+  icon: {
+    type: a,
+    default: e.icon
+  },
+  /**
+   * @description message dom id
+   */
+  id: {
+    type: String,
+    default: e.id
+  },
+  /**
+   * @description message text
+   */
+  message: {
+    type: t([
+      String,
+      Object,
+      Function
+    ]),
+    default: e.message
+  },
+  /**
+   * @description callback function when closed with the message instance as the parameter
+   */
+  onClose: {
+    type: t(Function),
+    default: e.onClose
+  },
+  /**
+   * @description whether to show a close button
+   */
+  showClose: {
+    type: Boolean,
+    default: e.showClose
+  },
+  /**
+   * @description message type
+   */
+  type: {
+    type: String,
+    values: p,
+    default: e.type
+  },
+  /**
+   * @description whether message is plain
+   */
+  plain: {
+    type: Boolean,
+    default: e.plain
+  },
+  /**
+   * @description set the distance to the top of viewport
+   */
+  offset: {
+    type: Number,
+    default: e.offset
+  },
+  /**
+   * @description message placement position
+   */
+  placement: {
+    type: String,
+    values: l,
+    default: e.placement
+  },
+  /**
+   * @description message element zIndex value
+   */
+  zIndex: {
+    type: Number,
+    default: e.zIndex
+  },
+  /**
+   * @description merge messages with the same content, type of VNode message is not supported
+   */
+  grouping: {
+    type: Boolean,
+    default: e.grouping
+  },
+  /**
+   * @description The number of repetitions, similar to badge, is used as the initial number when used with `grouping`
+   */
+  repeatNum: {
+    type: Number,
+    default: e.repeatNum
+  }
+}), b = {
+  destroy: () => !0
+};
+export {
+  y as MESSAGE_DEFAULT_PLACEMENT,
+  e as messageDefaults,
+  b as messageEmits,
+  l as messagePlacement,
+  c as messageProps,
+  p as messageTypes
+};

package/dist/components/message/src/message.vue.d.ts

@@ -0,0 +1,38 @@
+import type { MessageProps } from './message';
+declare function close(): void;
+declare var __VLS_23: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_23) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<MessageProps, {
+    visible: import("vue").Ref<boolean, boolean>;
+    bottom: import("vue").ComputedRef<number>;
+    close: typeof close;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    destroy: () => void;
+}, string, import("vue").PublicProps, Readonly<MessageProps> & Readonly<{
+    onDestroy?: (() => any) | undefined;
+}>, {
+    icon: import("@element-plus/utils").IconPropType;
+    zIndex: number;
+    offset: number;
+    id: string;
+    type: import("./message").MessageType;
+    onClose: () => void;
+    message: string | import("vue").VNode | (() => import("vue").VNode);
+    placement: import("./message").MessagePlacement;
+    duration: number;
+    plain: boolean;
+    customClass: string;
+    dangerouslyUseHTMLString: boolean;
+    showClose: boolean;
+    grouping: boolean;
+    repeatNum: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/message/src/message.vue.js

@@ -0,0 +1,156 @@
+import { defineComponent as P, ref as p, computed as a, onMounted as Z, watch as j, openBlock as l, createBlock as m, Transition as W, unref as o, withCtx as g, withDirectives as q, createElementVNode as J, normalizeStyle as K, normalizeClass as i, createCommentVNode as C, resolveDynamicComponent as Q, createElementBlock as M, renderSlot as X, createTextVNode as Y, toDisplayString as _, withModifiers as ee, createVNode as te, vShow as oe, mergeDefaults as ne, nextTick as se } from "vue";
+import { useEventListener as ae, useResizeObserver as le, useTimeoutFn as ie } from "@vueuse/core";
+import "@vue/shared";
+import { omit as re } from "lodash-unified";
+import { getEventCode as ue } from "../../../utils/dom/event.js";
+import { TypeComponentsMap as S, TypeComponents as me } from "../../../utils/vue/icon.js";
+import { EVENT_CODE as ce } from "../../../constants/aria.js";
+import { EpBadge as fe } from "../../badge/index.js";
+import "../../config-provider/index.js";
+import { ElIcon as x } from "../../icon/index.js";
+import { messageEmits as de, MESSAGE_DEFAULT_PLACEMENT as pe, messageDefaults as ve } from "./message.js";
+import { getLastOffset as ye, getOffsetOrSpace as ge } from "./instance.js";
+import { useGlobalComponentSettings as Ce } from "../../config-provider/src/hooks/use-global-config.js";
+const Ee = ["id"], Te = ["innerHTML"], Ie = /* @__PURE__ */ P({
+  name: "ElMessage",
+  __name: "message",
+  props: /* @__PURE__ */ ne({
+    customClass: {},
+    dangerouslyUseHTMLString: { type: Boolean },
+    duration: {},
+    icon: {},
+    id: {},
+    message: { type: [String, Object, Function] },
+    onClose: { type: Function },
+    showClose: { type: Boolean },
+    type: {},
+    plain: { type: Boolean },
+    offset: {},
+    placement: {},
+    zIndex: {},
+    grouping: { type: Boolean },
+    repeatNum: {}
+  }, re(ve, "appendTo")),
+  emits: de,
+  setup(n, { expose: L, emit: w }) {
+    const { Close: N } = me, e = n, z = w, E = p(!1), { ns: t, zIndex: D } = Ce("message"), { currentZIndex: O, nextZIndex: I } = D, v = p(), c = p(!1), T = p(0);
+    let f;
+    const $ = a(
+      () => e.type ? e.type === "error" ? "danger" : e.type : "info"
+    ), V = a(() => {
+      const s = e.type;
+      return { [t.bm("icon", s)]: s && S[s] };
+    }), h = a(
+      () => e.icon || S[e.type] || ""
+    ), r = a(() => e.placement || pe), A = a(() => ye(e.id, r.value)), b = a(() => Math.max(
+      ge(e.id, e.offset, r.value) + A.value,
+      e.offset
+    )), F = a(() => T.value + b.value), H = a(() => r.value.includes("left") ? t.is("left") : r.value.includes("right") ? t.is("right") : t.is("center")), k = a(
+      () => r.value.startsWith("top") ? "top" : "bottom"
+    ), R = a(() => ({
+      [k.value]: `${b.value}px`,
+      zIndex: O.value
+    }));
+    function y() {
+      e.duration !== 0 && ({ stop: f } = ie(() => {
+        d();
+      }, e.duration));
+    }
+    function B() {
+      f == null || f();
+    }
+    function d() {
+      c.value = !1, se(() => {
+        var s;
+        E.value || ((s = e.onClose) == null || s.call(e), z("destroy"));
+      });
+    }
+    function U(s) {
+      ue(s) === ce.esc && d();
+    }
+    return Z(() => {
+      y(), I(), c.value = !0;
+    }), j(
+      () => e.repeatNum,
+      () => {
+        B(), y();
+      }
+    ), ae(document, "keydown", U), le(v, () => {
+      T.value = v.value.getBoundingClientRect().height;
+    }), L({
+      visible: c,
+      bottom: F,
+      close: d
+    }), (s, u) => (l(), m(W, {
+      name: o(t).b("fade"),
+      onBeforeEnter: u[0] || (u[0] = (G) => E.value = !0),
+      onBeforeLeave: n.onClose,
+      onAfterLeave: u[1] || (u[1] = (G) => s.$emit("destroy"))
+    }, {
+      default: g(() => [
+        q(J("div", {
+          id: n.id,
+          ref_key: "messageRef",
+          ref: v,
+          class: i([
+            o(t).b(),
+            { [o(t).m(n.type)]: n.type },
+            o(t).is("closable", n.showClose),
+            o(t).is("plain", n.plain),
+            o(t).is("bottom", k.value === "bottom"),
+            H.value,
+            n.customClass
+          ]),
+          style: K(R.value),
+          role: "alert",
+          onMouseenter: B,
+          onMouseleave: y
+        }, [
+          n.repeatNum > 1 ? (l(), m(o(fe), {
+            key: 0,
+            value: n.repeatNum,
+            type: $.value,
+            class: i(o(t).e("badge"))
+          }, null, 8, ["value", "type", "class"])) : C("", !0),
+          h.value ? (l(), m(o(x), {
+            key: 1,
+            class: i([o(t).e("icon"), V.value])
+          }, {
+            default: g(() => [
+              (l(), m(Q(h.value)))
+            ]),
+            _: 1
+          }, 8, ["class"])) : C("", !0),
+          !n.dangerouslyUseHTMLString || s.$slots.default ? (l(), M("p", {
+            key: 2,
+            class: i(o(t).e("content"))
+          }, [
+            X(s.$slots, "default", {}, () => [
+              Y(_(n.message), 1)
+            ])
+          ], 2)) : (l(), M("p", {
+            key: 3,
+            class: i(o(t).e("content")),
+            innerHTML: n.message
+          }, null, 10, Te)),
+          n.showClose ? (l(), m(o(x), {
+            key: 4,
+            class: i(o(t).e("closeBtn")),
+            onClick: ee(d, ["stop"])
+          }, {
+            default: g(() => [
+              te(o(N))
+            ]),
+            _: 1
+          }, 8, ["class"])) : C("", !0)
+        ], 46, Ee), [
+          [oe, c.value]
+        ])
+      ]),
+      _: 3
+    }, 8, ["name", "onBeforeLeave"]));
+  }
+});
+export {
+  Ie as default
+};

package/dist/components/message/src/message2.vue.js

@@ -0,0 +1,4 @@
+import f from "./message.vue.js";
+export {
+  f as default
+};

package/dist/components/message/src/method.d.ts

@@ -0,0 +1,5 @@
+import type { Message, MessagePlacement, MessageType } from './message';
+export declare function closeAll(type?: MessageType): void;
+export declare function closeAllByPlacement(placement: MessagePlacement): void;
+declare const _default: Message;
+export default _default;

package/dist/components/message/src/method.js

@@ -0,0 +1,123 @@
+import { isVNode as C, createVNode as A, render as E } from "vue";
+import { isNumber as d, isBoolean as f, isElement as b } from "../../../utils/types.js";
+import "lodash-unified";
+import { isClient as v } from "@vueuse/core";
+import { debugWarn as x } from "../../../utils/error.js";
+import { isString as g, isFunction as u, hasOwn as M } from "@vue/shared";
+import "@element-plus/icons-vue";
+import "../../config-provider/index.js";
+import _ from "./message.vue.js";
+import { MESSAGE_DEFAULT_PLACEMENT as m, messageDefaults as P, messagePlacement as w, messageTypes as N } from "./message.js";
+import { getOrCreatePlacementInstances as F, placementInstances as i } from "./instance.js";
+import { messageConfig as s } from "../../config-provider/src/config-provider.js";
+let S = 1;
+const B = (e) => {
+  if (!e.appendTo)
+    e.appendTo = document.body;
+  else if (g(e.appendTo)) {
+    let n = document.querySelector(e.appendTo);
+    b(n) || (x(
+      "ElMessage",
+      "the appendTo option is not an HTMLElement. Falling back to document.body."
+    ), n = document.body), e.appendTo = n;
+  }
+}, D = (e) => {
+  !e.placement && g(s.placement) && s.placement && (e.placement = s.placement), e.placement || (e.placement = m), w.includes(e.placement) || (x(
+    "ElMessage",
+    `Invalid placement: ${e.placement}. Falling back to '${m}'.`
+  ), e.placement = m);
+}, y = (e) => {
+  const o = !e || g(e) || C(e) || u(e) ? { message: e } : e, n = {
+    ...P,
+    ...o
+  };
+  return B(n), D(n), f(s.grouping) && !n.grouping && (n.grouping = s.grouping), d(s.duration) && n.duration === 3e3 && (n.duration = s.duration), d(s.offset) && n.offset === 16 && (n.offset = s.offset), f(s.showClose) && !n.showClose && (n.showClose = s.showClose), f(s.plain) && !n.plain && (n.plain = s.plain), n;
+}, I = (e) => {
+  const o = e.props.placement || m, n = i[o], t = n.indexOf(e);
+  if (t === -1) return;
+  n.splice(t, 1);
+  const { handler: c } = e;
+  c.close();
+}, L = ({ appendTo: e, ...o }, n) => {
+  const t = `message_${S++}`, c = o.onClose, l = document.createElement("div"), a = {
+    ...o,
+    // now the zIndex will be used inside the message.vue component instead of here.
+    // zIndex: nextIndex() + options.zIndex
+    id: t,
+    onClose: () => {
+      c == null || c(), I(T);
+    },
+    // clean message element preventing mem leak
+    onDestroy: () => {
+      E(null, l);
+    }
+  }, p = A(
+    _,
+    a,
+    u(a.message) || C(a.message) ? {
+      default: u(a.message) ? a.message : () => a.message
+    } : null
+  );
+  p.appContext = n || r._context, E(p, l), e.appendChild(l.firstElementChild);
+  const h = p.component, T = {
+    id: t,
+    vnode: p,
+    vm: h,
+    handler: {
+      // instead of calling the onClose function directly, setting this value so that we can have the full lifecycle
+      // for out component, so that all closing steps will not be skipped.
+      close: () => {
+        h.exposed.close();
+      }
+    },
+    props: p.component.props
+  };
+  return T;
+}, r = (e = {}, o) => {
+  if (!v) return { close: () => {
+  } };
+  const n = y(e), t = F(
+    n.placement || m
+  );
+  if (n.grouping && t.length) {
+    const l = t.find(
+      ({ vnode: a }) => {
+        var p;
+        return ((p = a.props) == null ? void 0 : p.message) === n.message;
+      }
+    );
+    if (l)
+      return l.props.repeatNum += 1, l.props.type = n.type, l.handler;
+  }
+  if (d(s.max) && t.length >= s.max)
+    return { close: () => {
+    } };
+  const c = L(n, o);
+  return t.push(c), c.handler;
+};
+N.forEach((e) => {
+  r[e] = (o = {}, n) => {
+    const t = y(o);
+    return r({ ...t, type: e }, n);
+  };
+});
+function O(e) {
+  for (const o in i)
+    if (M(i, o)) {
+      const n = [...i[o]];
+      for (const t of n)
+        (!e || e === t.props.type) && t.handler.close();
+    }
+}
+function $(e) {
+  if (!i[e]) return;
+  [...i[e]].forEach((n) => n.handler.close());
+}
+r.closeAll = O;
+r.closeAllByPlacement = $;
+r._context = null;
+export {
+  O as closeAll,
+  $ as closeAllByPlacement,
+  r as default
+};

package/dist/components/message-box/index.d.ts

@@ -0,0 +1,6 @@
+import MessageBox from './src/messageBox';
+import type { SFCWithInstall } from '@element-plus/utils';
+declare const _MessageBox: SFCWithInstall<typeof MessageBox>;
+export default _MessageBox;
+export declare const EpMessageBox: SFCWithInstall<import(".").IElMessageBox>;
+export * from './src/message-box.type';

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

@@ -0,0 +1,9 @@
+import r from "./src/messageBox.js";
+const o = r;
+o.install = (e) => {
+  o._context = e._context, e.config.globalProperties.$msgbox = o, e.config.globalProperties.$messageBox = o, e.config.globalProperties.$alert = o.alert, e.config.globalProperties.$confirm = o.confirm, e.config.globalProperties.$prompt = o.prompt;
+};
+const s = o;
+export {
+  s as EpMessageBox
+};