ep-craft 0.1.37 → 0.1.39

package/dist/components/message-box/src/messageBox.js

@@ -0,0 +1,102 @@
+import { isVNode as g, render as h, markRaw as b, createVNode as p } from "vue";
+import { isElement as u, isUndefined as A } from "../../../utils/types.js";
+import "lodash-unified";
+import { isClient as M } from "@vueuse/core";
+import { debugWarn as O } from "../../../utils/error.js";
+import { isString as E, hasOwn as d, isObject as C, isFunction as f } from "@vue/shared";
+import "@element-plus/icons-vue";
+import T from "./index.vue.js";
+const s = /* @__PURE__ */ new Map(), v = (e) => {
+  let t = document.body;
+  return e.appendTo && (E(e.appendTo) && (t = document.querySelector(e.appendTo)), u(e.appendTo) && (t = e.appendTo), u(t) || (O(
+    "ElMessageBox",
+    "the appendTo option is not an HTMLElement. Falling back to document.body."
+  ), t = document.body)), t;
+}, i = (e, t) => {
+  var c;
+  const l = (c = e.component) == null ? void 0 : c.proxy;
+  return () => l.handleAction(t);
+}, w = (e, t, l = null) => {
+  const c = p(
+    T,
+    e,
+    f(e.message) || g(e.message) ? {
+      default: f(e.message) ? () => e.message({
+        confirm: i(c, "confirm"),
+        cancel: i(c, "cancel"),
+        close: i(c, "close")
+      }) : () => e.message
+    } : null
+  );
+  return c.appContext = l, h(c, t), v(e).appendChild(t.firstElementChild), c.component;
+}, x = () => document.createElement("div"), B = (e, t) => {
+  const l = x();
+  e.onVanish = () => {
+    h(null, l), s.delete(r);
+  }, e.onAction = (n) => {
+    const m = s.get(r);
+    let o;
+    e.showInput ? o = { value: r.inputValue, action: n } : o = n, e.callback ? e.callback(o, c.proxy) : n === "cancel" || n === "close" ? e.distinguishCancelAndClose && n !== "cancel" ? m.reject("close") : m.reject("cancel") : m.resolve(o);
+  };
+  const c = w(e, l, t), r = c.proxy;
+  for (const n in e)
+    d(e, n) && !d(r.$props, n) && (n === "closeIcon" && C(e[n]) ? r[n] = b(e[n]) : r[n] = e[n]);
+  return r.visible = !0, r;
+};
+function a(e, t = null) {
+  if (!M) return Promise.reject();
+  let l;
+  return E(e) || g(e) ? e = {
+    message: e
+  } : l = e.callback, new Promise((c, r) => {
+    const n = B(
+      e,
+      t ?? a._context
+    );
+    s.set(n, {
+      options: e,
+      callback: l,
+      resolve: c,
+      reject: r
+    });
+  });
+}
+const S = ["alert", "confirm", "prompt"], _ = {
+  alert: { closeOnPressEscape: !1, closeOnClickModal: !1 },
+  confirm: { showCancelButton: !0 },
+  prompt: { showCancelButton: !0, showInput: !0 }
+};
+S.forEach((e) => {
+  a[e] = k(
+    e
+  );
+});
+function k(e) {
+  return (t, l, c, r) => {
+    let n = "";
+    return C(l) ? (c = l, n = "") : A(l) ? n = "" : n = l, a(
+      Object.assign(
+        {
+          title: n,
+          message: t,
+          type: "",
+          ..._[e]
+        },
+        c,
+        {
+          boxType: e
+        }
+      ),
+      r
+    );
+  };
+}
+a.close = () => {
+  s.forEach((e, t) => {
+    t.doClose();
+  }), s.clear();
+};
+a._context = null;
+export {
+  a as default
+};

package/dist/components/notification/index.d.ts

@@ -0,0 +1,3 @@
+export declare const EpNotification: import("../../utils/index").SFCInstallWithContext<import(".").Notify>;
+export default EpNotification;
+export * from './src/notification';

package/dist/components/notification/index.js

@@ -0,0 +1,15 @@
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import "vue";
+import { withInstallFunction as o } from "../../utils/vue/install.js";
+import i from "./src/notify.js";
+import { notificationEmits as y, notificationProps as l, notificationTypes as x } from "./src/notification.js";
+const a = o(i, "$notify");
+export {
+  a as EpNotification,
+  y as notificationEmits,
+  l as notificationProps,
+  x as notificationTypes
+};

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

@@ -0,0 +1,157 @@
+import type { AppContext, ExtractPublicPropTypes, VNode } from 'vue';
+import type { IconPropType } from '../../../utils/index';
+import type Notification from './notification.vue';
+export declare const notificationTypes: readonly ["primary", "success", "info", "warning", "error"];
+export type NotificationType = (typeof notificationTypes)[number] | '';
+export type NotificationPosition = 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left';
+export interface NotificationProps {
+    /**
+     * @description custom class name for Notification
+     */
+    customClass?: string;
+    /**
+     * @description whether `message` is treated as HTML string
+     */
+    dangerouslyUseHTMLString?: boolean;
+    /**
+     * @description duration before close. It will not automatically close if set 0
+     */
+    duration?: number;
+    /**
+     * @description custom icon component. It will be overridden by `type`
+     */
+    icon?: IconPropType;
+    /**
+     * @description notification dom id
+     */
+    id?: string;
+    /**
+     * @description description text
+     */
+    message?: string | VNode | (() => VNode);
+    /**
+     * @description offset from the top edge of the screen. Every Notification instance of the same moment should have the same offset
+     */
+    offset?: number;
+    /**
+     * @description callback function when notification clicked
+     */
+    onClick?: () => void;
+    /**
+     * @description callback function when closed
+     */
+    onClose: () => void;
+    /**
+     * @description custom position
+     */
+    position?: NotificationPosition;
+    /**
+     * @description whether to show a close button
+     */
+    showClose?: boolean;
+    /**
+     * @description title
+     */
+    title?: string;
+    /**
+     * @description notification type
+     */
+    type?: NotificationType;
+    /**
+     * @description initial zIndex
+     */
+    zIndex?: number;
+    /**
+     * @description custom close icon, default is Close
+     */
+    closeIcon?: IconPropType;
+}
+/**
+ * @deprecated Removed after 3.0.0, Use `NotificationProps` instead.
+ */
+export declare const notificationProps: {
+    readonly customClass: import("../../../utils/index").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly dangerouslyUseHTMLString: BooleanConstructor;
+    readonly duration: import("../../../utils/index").EpPropFinalized<NumberConstructor, unknown, unknown, 4500, boolean>;
+    readonly icon: {
+        readonly type: import("vue").PropType<import("../../../utils/index").EpPropMergeType<(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>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly id: import("../../../utils/index").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly message: import("../../../utils/index").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 offset: import("../../../utils/index").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly onClick: import("../../../utils/index").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 onClose: {
+        readonly type: import("vue").PropType<() => void>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly position: import("../../../utils/index").EpPropFinalized<StringConstructor, "top-left" | "top-right" | "bottom-left" | "bottom-right", unknown, "top-right", boolean>;
+    readonly showClose: import("../../../utils/index").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly title: import("../../../utils/index").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly type: import("../../../utils/index").EpPropFinalized<StringConstructor, "" | "error" | "primary" | "success" | "warning" | "info", unknown, "", boolean>;
+    readonly zIndex: NumberConstructor;
+    readonly closeIcon: import("../../../utils/index").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, import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, boolean>;
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `NotificationProps` instead.
+ */
+export type NotificationPropsPublic = ExtractPublicPropTypes<typeof notificationProps>;
+export declare const notificationEmits: {
+    destroy: () => boolean;
+};
+export type NotificationEmits = typeof notificationEmits;
+export type NotificationInstance = InstanceType<typeof Notification> & unknown;
+export type NotificationOptions = Omit<NotificationProps, 'id' | 'onClose'> & {
+    /**
+     * @description set the root element for the notification, default to `document.body`
+     */
+    appendTo?: HTMLElement | string;
+    /**
+     * @description callback function when closed
+     */
+    onClose?(vm: VNode): void;
+};
+export type NotificationOptionsTyped = Omit<NotificationOptions, 'type'>;
+export interface NotificationHandle {
+    close: () => void;
+}
+export type NotificationParams = Partial<NotificationOptions> | string | VNode;
+export type NotificationParamsTyped = Partial<NotificationOptionsTyped> | string | VNode;
+export interface NotifyFn {
+    (options?: NotificationParams, appContext?: null | AppContext): NotificationHandle;
+    closeAll(): void;
+    updateOffsets(position?: NotificationOptions['position']): void;
+    _context: AppContext | null;
+}
+export type NotifyTypedFn = (options?: NotificationParamsTyped, appContext?: null | AppContext) => NotificationHandle;
+export interface Notify extends NotifyFn {
+    primary: NotifyTypedFn;
+    success: NotifyTypedFn;
+    warning: NotifyTypedFn;
+    error: NotifyTypedFn;
+    info: NotifyTypedFn;
+}
+export interface NotificationQueueItem {
+    vm: VNode;
+}
+export type NotificationQueue = NotificationQueueItem[];

package/dist/components/notification/src/notification.js

@@ -0,0 +1,127 @@
+import { Close as o } from "@element-plus/icons-vue";
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import { iconPropType as e } from "../../../utils/vue/icon.js";
+import "vue";
+import { buildProps as i, definePropType as t } from "../../../utils/vue/props/runtime.js";
+const r = [
+  "primary",
+  "success",
+  "info",
+  "warning",
+  "error"
+], d = i({
+  /**
+   * @description custom class name for Notification
+   */
+  customClass: {
+    type: String,
+    default: ""
+  },
+  /**
+   * @description whether `message` is treated as HTML string
+   */
+  dangerouslyUseHTMLString: Boolean,
+  /**
+   * @description duration before close. It will not automatically close if set 0
+   */
+  duration: {
+    type: Number,
+    default: 4500
+  },
+  /**
+   * @description custom icon component. It will be overridden by `type`
+   */
+  icon: {
+    type: e
+  },
+  /**
+   * @description notification dom id
+   */
+  id: {
+    type: String,
+    default: ""
+  },
+  /**
+   * @description description text
+   */
+  message: {
+    type: t([
+      String,
+      Object,
+      Function
+    ]),
+    default: ""
+  },
+  /**
+   * @description offset from the top edge of the screen. Every Notification instance of the same moment should have the same offset
+   */
+  offset: {
+    type: Number,
+    default: 0
+  },
+  /**
+   * @description callback function when notification clicked
+   */
+  onClick: {
+    type: t(Function),
+    default: () => {
+    }
+  },
+  /**
+   * @description callback function when closed
+   */
+  onClose: {
+    type: t(Function),
+    required: !0
+  },
+  /**
+   * @description custom position
+   */
+  position: {
+    type: String,
+    values: ["top-right", "top-left", "bottom-right", "bottom-left"],
+    default: "top-right"
+  },
+  /**
+   * @description whether to show a close button
+   */
+  showClose: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description title
+   */
+  title: {
+    type: String,
+    default: ""
+  },
+  /**
+   * @description notification type
+   */
+  type: {
+    type: String,
+    values: [...r, ""],
+    default: ""
+  },
+  /**
+   * @description initial zIndex
+   */
+  zIndex: Number,
+  /**
+   * @description custom close icon, default is Close
+   */
+  closeIcon: {
+    type: e,
+    default: o
+  }
+}), y = {
+  destroy: () => !0
+};
+export {
+  y as notificationEmits,
+  d as notificationProps,
+  r as notificationTypes
+};

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

@@ -0,0 +1,34 @@
+import type { NotificationProps } from './notification';
+declare function close(): void;
+declare var __VLS_18: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_18) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<NotificationProps, {
+    visible: import("vue").Ref<boolean, boolean>;
+    /** @description close notification */
+    close: typeof close;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    destroy: () => void;
+}, string, import("vue").PublicProps, Readonly<NotificationProps> & Readonly<{
+    onDestroy?: (() => any) | undefined;
+}>, {
+    position: import("./notification").NotificationPosition;
+    offset: number;
+    title: string;
+    id: string;
+    type: import("./notification").NotificationType;
+    onClick: () => void;
+    message: string | import("vue").VNode | (() => import("vue").VNode);
+    duration: number;
+    customClass: string;
+    showClose: boolean;
+    closeIcon: import("../../../utils/index").IconPropType;
+}, {}, {}, {}, 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/notification/src/notification.vue.js

@@ -0,0 +1,146 @@
+import { defineComponent as O, ref as U, computed as c, onMounted as W, openBlock as s, createBlock as u, Transition as Z, unref as o, withCtx as p, withDirectives as h, createElementVNode as f, normalizeStyle as x, normalizeClass as a, resolveDynamicComponent as b, createCommentVNode as w, toDisplayString as E, renderSlot as j, createElementBlock as T, vShow as I, withModifiers as A, markRaw as G } from "vue";
+import { useEventListener as K, useTimeoutFn as P } from "@vueuse/core";
+import "@vue/shared";
+import "lodash-unified";
+import { getEventCode as R } from "../../../utils/dom/event.js";
+import { TypeComponentsMap as M } from "../../../utils/vue/icon.js";
+import { EVENT_CODE as y } from "../../../constants/aria.js";
+import { ElIcon as S } from "../../icon/index.js";
+import "../../config-provider/index.js";
+import { notificationEmits as q } from "./notification.js";
+import { Close as J } from "@element-plus/icons-vue";
+import { useGlobalComponentSettings as Q } from "../../config-provider/src/hooks/use-global-config.js";
+const X = ["id"], Y = ["textContent"], _ = { key: 0 }, ee = ["innerHTML"], fe = /* @__PURE__ */ O({
+  name: "ElNotification",
+  __name: "notification",
+  props: {
+    customClass: { default: "" },
+    dangerouslyUseHTMLString: { type: Boolean },
+    duration: { default: 4500 },
+    icon: {},
+    id: { default: "" },
+    message: { type: [String, Object, Function], default: "" },
+    offset: { default: 0 },
+    onClick: { type: Function, default: () => {
+    } },
+    onClose: {},
+    position: { default: "top-right" },
+    showClose: { type: Boolean, default: !0 },
+    title: { default: "" },
+    type: { default: "" },
+    zIndex: {},
+    closeIcon: { default: G(J) }
+  },
+  emits: q,
+  setup(e, { expose: B }) {
+    const t = e, { ns: n, zIndex: L } = Q("notification"), { nextZIndex: z, currentZIndex: D } = L, l = U(!1);
+    let d;
+    const H = c(() => {
+      const i = t.type;
+      return i && M[t.type] ? n.m(i) : "";
+    }), C = c(() => t.type && M[t.type] || t.icon), N = c(
+      () => t.position.endsWith("right") ? "right" : "left"
+    ), $ = c(
+      () => t.position.startsWith("top") ? "top" : "bottom"
+    ), F = c(() => ({
+      [$.value]: `${t.offset}px`,
+      zIndex: t.zIndex ?? D.value
+    }));
+    function v() {
+      t.duration > 0 && ({ stop: d } = P(() => {
+        l.value && m();
+      }, t.duration));
+    }
+    function k() {
+      d == null || d();
+    }
+    function m() {
+      l.value = !1;
+    }
+    function V(i) {
+      switch (R(i)) {
+        case y.delete:
+        case y.backspace:
+          k();
+          break;
+        case y.esc:
+          l.value && m();
+          break;
+        default:
+          v();
+          break;
+      }
+    }
+    return W(() => {
+      v(), z(), l.value = !0;
+    }), K(document, "keydown", V), B({
+      visible: l,
+      /** @description close notification */
+      close: m
+    }), (i, r) => (s(), u(Z, {
+      name: o(n).b("fade"),
+      onBeforeLeave: e.onClose,
+      onAfterLeave: r[1] || (r[1] = (g) => i.$emit("destroy"))
+    }, {
+      default: p(() => [
+        h(f("div", {
+          id: e.id,
+          class: a([o(n).b(), e.customClass, N.value]),
+          style: x(F.value),
+          role: "alert",
+          onMouseenter: k,
+          onMouseleave: v,
+          onClick: r[0] || (r[0] = //@ts-ignore
+          (...g) => e.onClick && e.onClick(...g))
+        }, [
+          C.value ? (s(), u(o(S), {
+            key: 0,
+            class: a([o(n).e("icon"), H.value])
+          }, {
+            default: p(() => [
+              (s(), u(b(C.value)))
+            ]),
+            _: 1
+          }, 8, ["class"])) : w("", !0),
+          f("div", {
+            class: a(o(n).e("group"))
+          }, [
+            f("h2", {
+              class: a(o(n).e("title")),
+              textContent: E(e.title)
+            }, null, 10, Y),
+            h(f("div", {
+              class: a(o(n).e("content")),
+              style: x(e.title ? void 0 : { margin: 0 })
+            }, [
+              j(i.$slots, "default", {}, () => [
+                e.dangerouslyUseHTMLString ? (s(), T("p", {
+                  key: 1,
+                  innerHTML: e.message
+                }, null, 8, ee)) : (s(), T("p", _, E(e.message), 1))
+              ])
+            ], 6), [
+              [I, e.message]
+            ]),
+            e.showClose ? (s(), u(o(S), {
+              key: 0,
+              class: a(o(n).e("closeBtn")),
+              onClick: A(m, ["stop"])
+            }, {
+              default: p(() => [
+                (s(), u(b(e.closeIcon)))
+              ]),
+              _: 1
+            }, 8, ["class"])) : w("", !0)
+          ], 2)
+        ], 46, X), [
+          [I, l.value]
+        ])
+      ]),
+      _: 3
+    }, 8, ["name", "onBeforeLeave"]));
+  }
+});
+export {
+  fe as default
+};

package/dist/components/notification/src/notification2.vue.js

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

package/dist/components/notification/src/notify.d.ts

@@ -0,0 +1,15 @@
+import type { VNode } from 'vue';
+import type { NotificationPosition, Notify } from './notification';
+/**
+ * This function gets called when user click `x` button or press `esc` or the time reached its limitation.
+ * Emitted by transition@before-leave event so that we can fetch the current notification.offsetHeight, if this was called
+ * by @after-leave the DOM element will be removed from the page thus we can no longer fetch the offsetHeight.
+ * @param {String} id notification id to be closed
+ * @param {Position} position the positioning strategy
+ * @param {Function} userOnClose the callback called when close passed by user
+ */
+export declare function close(id: string, position: NotificationPosition, userOnClose?: (vm: VNode) => void): void;
+export declare function closeAll(): void;
+export declare function updateOffsets(position?: NotificationPosition): void;
+declare const _default: Notify;
+export default _default;