ep-craft 0.1.37 → 0.1.39

package/dist/components/loading/index.js

@@ -0,0 +1,13 @@
+import t from "./src/service.js";
+import i from "./src/directive.js";
+const r = {
+  install(o) {
+    t._context = o._context, i._context = o._context, o.directive("loading", i), o.config.globalProperties.$loading = t;
+  },
+  directive: i,
+  service: t
+};
+export {
+  r as EpLoading,
+  i as vLoading
+};

package/dist/components/loading/src/directive.d.ts

@@ -0,0 +1,13 @@
+import type { Directive, UnwrapRef } from 'vue';
+import type { LoadingOptions } from './types';
+import type { LoadingInstance } from './loading';
+declare const INSTANCE_KEY: unique symbol;
+export type LoadingBinding = boolean | UnwrapRef<LoadingOptions>;
+export interface ElementLoading extends HTMLElement {
+    [INSTANCE_KEY]?: {
+        instance: LoadingInstance;
+        options: LoadingOptions;
+    };
+}
+declare const vLoading: Directive<ElementLoading, LoadingBinding>;
+export default vLoading;

package/dist/components/loading/src/directive.js

@@ -0,0 +1,62 @@
+import { isRef as d, ref as x } from "vue";
+import { isObject as m, hyphenate as b, isString as A } from "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import k from "./service.js";
+const u = Symbol("ElLoading"), r = (t) => `element-loading-${b(t)}`, g = (t, e) => {
+  const o = e.instance, n = (s) => m(e.value) ? e.value[s] : void 0, p = (s) => {
+    const v = A(s) && (o == null ? void 0 : o[s]) || s;
+    return x(v);
+  }, c = (s) => p(
+    n(s) || t.getAttribute(r(s))
+  ), a = n("fullscreen") ?? e.modifiers.fullscreen, i = {
+    text: c("text"),
+    svg: c("svg"),
+    svgViewBox: c("svgViewBox"),
+    spinner: c("spinner"),
+    background: c("background"),
+    customClass: c("customClass"),
+    fullscreen: a,
+    target: n("target") ?? (a ? void 0 : t),
+    body: n("body") ?? e.modifiers.body,
+    lock: n("lock") ?? e.modifiers.lock
+  }, l = k(i);
+  l._context = f._context, t[u] = {
+    options: i,
+    instance: l
+  };
+}, y = (t, e) => {
+  for (const o of Object.keys(t))
+    d(t[o]) && (t[o].value = e[o]);
+}, f = {
+  mounted(t, e) {
+    e.value && g(t, e);
+  },
+  updated(t, e) {
+    const o = t[u];
+    if (!e.value) {
+      o == null || o.instance.close(), t[u] = null;
+      return;
+    }
+    o ? y(
+      o.options,
+      m(e.value) ? e.value : {
+        text: t.getAttribute(r("text")),
+        svg: t.getAttribute(r("svg")),
+        svgViewBox: t.getAttribute(r("svgViewBox")),
+        spinner: t.getAttribute(r("spinner")),
+        background: t.getAttribute(r("background")),
+        customClass: t.getAttribute(r("customClass"))
+      }
+    ) : g(t, e);
+  },
+  unmounted(t) {
+    var e;
+    (e = t[u]) == null || e.instance.close(), t[u] = null;
+  }
+};
+f._context = null;
+export {
+  f as default
+};

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

@@ -0,0 +1,34 @@
+import type { AppContext, VNode } from 'vue';
+import type { LoadingOptionsResolved } from './types';
+export declare function createLoadingComponent(options: LoadingOptionsResolved, appContext: AppContext | null): {
+    setText: (text: string | VNode | VNode[]) => void;
+    removeElLoadingChild: () => void;
+    close: () => void;
+    handleAfterLeave: () => void;
+    vm: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import("vue").ComponentProvideOptions>, {}, {}, "", {}, any>;
+    $el: HTMLElement;
+    originalPosition: import("vue").Ref<string, string>;
+    originalOverflow: import("vue").Ref<string, string>;
+    visible: import("vue").Ref<boolean, boolean>;
+    parent: import("vue").Ref<import("./types").LoadingParentElement, import("./types").LoadingParentElement>;
+    background: import("vue").Ref<string, string>;
+    svg: import("vue").Ref<string, string>;
+    svgViewBox: import("vue").Ref<string, string>;
+    spinner: import("vue").Ref<string | boolean, string | boolean>;
+    text: import("vue").Ref<string | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>[], string | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>[]>;
+    fullscreen: import("vue").Ref<boolean, boolean>;
+    lock: import("vue").Ref<boolean, boolean>;
+    customClass: import("vue").Ref<string, string>;
+    target: import("vue").Ref<HTMLElement, HTMLElement>;
+    beforeClose?: import("vue").Ref<(() => boolean) | undefined, (() => boolean) | undefined> | undefined;
+    closed?: import("vue").Ref<(() => void) | undefined, (() => void) | undefined> | undefined;
+};
+export type LoadingInstance = ReturnType<typeof createLoadingComponent>;

package/dist/components/loading/src/loading.js

@@ -0,0 +1,121 @@
+import { ref as A, reactive as w, defineComponent as T, h as s, Transition as N, withCtx as S, withDirectives as $, createVNode as k, vShow as y, createApp as B, toRefs as E } from "vue";
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import { removeClass as f } from "../../../utils/dom/style.js";
+import "@element-plus/icons-vue";
+import "../../config-provider/index.js";
+import { useGlobalComponentSettings as I } from "../../config-provider/src/hooks/use-global-config.js";
+function H(o, v) {
+  let u;
+  const a = A(!1), t = w({
+    ...o,
+    originalPosition: "",
+    originalOverflow: "",
+    visible: !1
+  });
+  function g(e) {
+    t.text = e;
+  }
+  function b() {
+    const e = t.parent, r = i.ns;
+    if (!e.vLoadingAddClassList) {
+      let n = e.getAttribute("loading-number");
+      n = Number.parseInt(n) - 1, n ? e.setAttribute("loading-number", n.toString()) : (f(e, r.bm("parent", "relative")), e.removeAttribute("loading-number")), f(e, r.bm("parent", "hidden"));
+    }
+    d(), c.unmount();
+  }
+  function d() {
+    var e, r;
+    (r = (e = i.$el) == null ? void 0 : e.parentNode) == null || r.removeChild(i.$el);
+  }
+  function p() {
+    var e;
+    o.beforeClose && !o.beforeClose() || (a.value = !0, clearTimeout(u), u = setTimeout(l, 400), t.visible = !1, (e = o.closed) == null || e.call(o));
+  }
+  function l() {
+    if (!a.value) return;
+    const e = t.parent;
+    a.value = !1, e.vLoadingAddClassList = void 0, b();
+  }
+  const x = T({
+    name: "ElLoading",
+    setup(e, { expose: r }) {
+      const { ns: n, zIndex: C } = I("loading");
+      return r({
+        ns: n,
+        zIndex: C
+      }), () => {
+        const m = t.spinner || t.svg, L = s(
+          "svg",
+          {
+            class: "circular",
+            viewBox: t.svgViewBox ? t.svgViewBox : "0 0 50 50",
+            ...m ? { innerHTML: m } : {}
+          },
+          [
+            s("circle", {
+              class: "path",
+              cx: "25",
+              cy: "25",
+              r: "20",
+              fill: "none"
+            })
+          ]
+        ), h = t.text ? s("p", { class: n.b("text") }, [t.text]) : void 0;
+        return s(
+          N,
+          {
+            name: n.b("fade"),
+            onAfterLeave: l
+          },
+          {
+            default: S(() => [
+              $(
+                k(
+                  "div",
+                  {
+                    style: {
+                      backgroundColor: t.background || ""
+                    },
+                    class: [
+                      n.b("mask"),
+                      t.customClass,
+                      n.is("fullscreen", t.fullscreen)
+                    ]
+                  },
+                  [
+                    s(
+                      "div",
+                      {
+                        class: n.b("spinner")
+                      },
+                      [L, h]
+                    )
+                  ]
+                ),
+                [[y, t.visible]]
+              )
+            ])
+          }
+        );
+      };
+    }
+  }), c = B(x);
+  Object.assign(c._context, v ?? {});
+  const i = c.mount(document.createElement("div"));
+  return {
+    ...E(t),
+    setText: g,
+    removeElLoadingChild: d,
+    close: p,
+    handleAfterLeave: l,
+    vm: i,
+    get $el() {
+      return i.$el;
+    }
+  };
+}
+export {
+  H as createLoadingComponent
+};

package/dist/components/loading/src/service.d.ts

@@ -0,0 +1,8 @@
+import type { LoadingInstance } from './loading';
+import type { LoadingOptions } from './types';
+import type { AppContext } from 'vue';
+declare const Loading: {
+    (options?: LoadingOptions, context?: AppContext | null): LoadingInstance;
+    _context: AppContext | null;
+};
+export default Loading;

package/dist/components/loading/src/service.js

@@ -0,0 +1,67 @@
+import { nextTick as m } from "vue";
+import { isString as b } from "@vue/shared";
+import "lodash-unified";
+import { isClient as g } from "@vueuse/core";
+import { getStyle as d, addClass as a, removeClass as c } from "../../../utils/dom/style.js";
+import "@element-plus/icons-vue";
+import { createLoadingComponent as v } from "./loading.js";
+let i;
+const f = function(t = {}, o) {
+  if (!g) return;
+  const e = p(t);
+  if (e.fullscreen && i)
+    return i;
+  const l = v(
+    {
+      ...e,
+      closed: () => {
+        var r;
+        (r = e.closed) == null || r.call(e), e.fullscreen && (i = void 0);
+      }
+    },
+    o ?? f._context
+  );
+  y(e, e.parent, l), u(e, e.parent, l), e.parent.vLoadingAddClassList = () => u(e, e.parent, l);
+  let n = e.parent.getAttribute("loading-number");
+  return n ? n = `${Number.parseInt(n) + 1}` : n = "1", e.parent.setAttribute("loading-number", n), e.parent.appendChild(l.$el), m(() => l.visible.value = e.visible), e.fullscreen && (i = l), l;
+}, p = (t) => {
+  let o;
+  return b(t.target) ? o = document.querySelector(t.target) ?? document.body : o = t.target || document.body, {
+    parent: o === document.body || t.body ? document.body : o,
+    background: t.background || "",
+    svg: t.svg || "",
+    svgViewBox: t.svgViewBox || "",
+    spinner: t.spinner || !1,
+    text: t.text || "",
+    fullscreen: o === document.body && (t.fullscreen ?? !0),
+    lock: t.lock ?? !1,
+    customClass: t.customClass || "",
+    visible: t.visible ?? !0,
+    beforeClose: t.beforeClose,
+    closed: t.closed,
+    target: o
+  };
+}, y = async (t, o, e) => {
+  const { nextZIndex: l } = e.vm.zIndex || e.vm._.exposed.zIndex, n = {};
+  if (t.fullscreen)
+    e.originalPosition.value = d(document.body, "position"), e.originalOverflow.value = d(document.body, "overflow"), n.zIndex = l();
+  else if (t.parent === document.body) {
+    e.originalPosition.value = d(document.body, "position"), await m();
+    for (const r of ["top", "left"]) {
+      const s = r === "top" ? "scrollTop" : "scrollLeft";
+      n[r] = `${t.target.getBoundingClientRect()[r] + document.body[s] + document.documentElement[s] - Number.parseInt(d(document.body, `margin-${r}`), 10)}px`;
+    }
+    for (const r of ["height", "width"])
+      n[r] = `${t.target.getBoundingClientRect()[r]}px`;
+  } else
+    e.originalPosition.value = d(o, "position");
+  for (const [r, s] of Object.entries(n))
+    e.$el.style[r] = s;
+}, u = (t, o, e) => {
+  const l = e.vm.ns || e.vm._.exposed.ns;
+  ["absolute", "fixed", "sticky"].includes(e.originalPosition.value) ? c(o, l.bm("parent", "relative")) : a(o, l.bm("parent", "relative")), t.fullscreen && t.lock ? a(o, l.bm("parent", "hidden")) : c(o, l.bm("parent", "hidden"));
+};
+f._context = null;
+export {
+  f as default
+};

package/dist/components/loading/src/types.d.ts

@@ -0,0 +1,47 @@
+import type { MaybeRef, VNode } from 'vue';
+export type LoadingOptionsResolved = {
+    parent: LoadingParentElement;
+    /**
+     * @description background color of the mask
+     */
+    background: MaybeRef<string>;
+    svg: MaybeRef<string>;
+    svgViewBox: MaybeRef<string>;
+    /**
+     * @description class name of the custom spinner
+     */
+    spinner: MaybeRef<boolean | string>;
+    /**
+     * @description loading text that displays under the spinner
+     */
+    text: MaybeRef<string | VNode | VNode[]>;
+    /**
+     * @description same as the `fullscreen` modifier of `v-loading`
+     */
+    fullscreen: boolean;
+    /**
+     * @description same as the `lock` modifier of `v-loading`
+     */
+    lock: boolean;
+    /**
+     * @description custom class name for Loading
+     */
+    customClass: MaybeRef<string>;
+    visible: boolean;
+    target: HTMLElement;
+    beforeClose?: () => boolean;
+    closed?: () => void;
+};
+export type LoadingOptions = Partial<Omit<LoadingOptionsResolved, 'parent' | 'target'> & {
+    /**
+     * @description the DOM node Loading needs to cover. Accepts a DOM object or a string. If it's a string, it will be passed to `document.querySelector` to get the corresponding DOM node
+     */
+    target: HTMLElement | string;
+    /**
+     * @description same as the `body` modifier of `v-loading`
+     */
+    body: boolean;
+}>;
+export interface LoadingParentElement extends HTMLElement {
+    vLoadingAddClassList?: () => void;
+}

package/dist/components/mention/EpMention.vue.d.ts

@@ -1,7 +1,7 @@
 import { nextTick } from 'vue';
 import type { MentionProps } from './mention';
 import type { CSSProperties } from 'vue';
-import type { TooltipInstance } from '@element-plus/components/tooltip';
+import type { TooltipInstance } from '../tooltip/index';
 import type { MentionOption } from './types';
 declare const _default: <T extends MentionOption = MentionOption>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
@@ -19,15 +19,15 @@ declare const _default: <T extends MentionOption = MentionOption>(__VLS_props: N
             $data: {};
             $props: {
                 readonly id?: string | undefined;
-                readonly size?: import("@element-plus/constants").ComponentSize | undefined;
+                readonly size?: import("../../constants/index").ComponentSize | undefined;
                 readonly disabled?: boolean | undefined;
                 readonly modelValue?: string | number | null | undefined | undefined;
-                readonly modelModifiers?: import("@element-plus/components/input").InputModelModifiers | undefined;
+                readonly modelModifiers?: import("../input/index").InputModelModifiers | undefined;
                 readonly maxlength?: string | number | undefined;
                 readonly minlength?: string | number | undefined;
-                readonly type?: import("@element-plus/components/input").InputType | undefined;
+                readonly type?: import("../input/index").InputType | undefined;
                 readonly resize?: "none" | "both" | "horizontal" | "vertical" | undefined;
-                readonly autosize?: import("@element-plus/components/input").InputAutoSize | undefined;
+                readonly autosize?: import("../input/index").InputAutoSize | undefined;
                 readonly autocomplete?: string | undefined;
                 readonly formatter?: ((value: string) => string) | undefined;
                 readonly parser?: ((value: string) => string) | undefined;
@@ -35,12 +35,12 @@ declare const _default: <T extends MentionOption = MentionOption>(__VLS_props: N
                 readonly form?: string | undefined;
                 readonly readonly?: boolean | undefined;
                 readonly clearable?: boolean | undefined;
-                readonly clearIcon?: import("@element-plus/utils").IconPropType | undefined;
+                readonly clearIcon?: import("../../utils/index").IconPropType | undefined;
                 readonly showPassword?: boolean | undefined;
                 readonly showWordLimit?: boolean | undefined;
                 readonly wordLimitPosition?: "inside" | "outside" | undefined;
-                readonly suffixIcon?: import("@element-plus/utils").IconPropType | undefined;
-                readonly prefixIcon?: import("@element-plus/utils").IconPropType | undefined;
+                readonly suffixIcon?: import("../../utils/index").IconPropType | undefined;
+                readonly prefixIcon?: import("../../utils/index").IconPropType | undefined;
                 readonly containerRole?: string | undefined;
                 readonly tabindex?: string | number | undefined;
                 readonly validateEvent?: boolean | undefined;
@@ -77,7 +77,7 @@ declare const _default: <T extends MentionOption = MentionOption>(__VLS_props: N
             $host: Element | null;
             $emit: ((event: "clear", evt: MouseEvent | undefined) => void) & ((event: "update:modelValue", value: string) => void) & ((event: "change", value: string, evt?: Event | undefined) => void) & ((event: "input", value: string) => void) & ((event: "focus", evt: FocusEvent) => void) & ((event: "blur", evt: FocusEvent) => void) & ((event: "compositionend", evt: CompositionEvent) => void) & ((event: "compositionstart", evt: CompositionEvent) => void) & ((event: "compositionupdate", evt: CompositionEvent) => void) & ((event: "keydown", evt: Event | KeyboardEvent) => void) & ((event: "mouseenter", evt: MouseEvent) => void) & ((event: "mouseleave", evt: MouseEvent) => void);
             $el: any;
-            $options: import("vue").ComponentOptionsBase<Readonly<import("@element-plus/components/input").InputProps> & Readonly<{
+            $options: import("vue").ComponentOptionsBase<Readonly<import("../input/index").InputProps> & Readonly<{
                 onClear?: ((evt: MouseEvent | undefined) => any) | undefined;
                 "onUpdate:modelValue"?: ((value: string) => any) | undefined;
                 onChange?: ((value: string, evt?: Event | undefined) => any) | undefined;
@@ -95,7 +95,7 @@ declare const _default: <T extends MentionOption = MentionOption>(__VLS_props: N
                 textarea: import("vue").ShallowRef<HTMLTextAreaElement | undefined, HTMLTextAreaElement | undefined>;
                 ref: import("vue").ComputedRef<HTMLInputElement | HTMLTextAreaElement | undefined>;
                 textareaStyle: import("vue").ComputedRef<import("vue").StyleValue>;
-                autosize: import("vue").Ref<import("@element-plus/components/input").InputAutoSize | undefined, import("@element-plus/components/input").InputAutoSize | undefined>;
+                autosize: import("vue").Ref<import("../input/index").InputAutoSize | undefined, import("../input/index").InputAutoSize | undefined>;
                 isComposing: import("vue").Ref<boolean, boolean>;
                 passwordVisible: import("vue").Ref<boolean, boolean>;
                 focus: () => void | undefined;
@@ -119,11 +119,11 @@ declare const _default: <T extends MentionOption = MentionOption>(__VLS_props: N
             }, string, {
                 disabled: boolean;
                 tabindex: string | number;
-                type: import("@element-plus/components/input").InputType;
+                type: import("../input/index").InputType;
                 modelValue: string | number | null;
-                modelModifiers: import("@element-plus/components/input").InputModelModifiers;
+                modelModifiers: import("../input/index").InputModelModifiers;
                 autocomplete: string;
-                clearIcon: import("@element-plus/utils").IconPropType;
+                clearIcon: import("../../utils/index").IconPropType;
                 wordLimitPosition: "inside" | "outside";
                 validateEvent: boolean;
                 inputStyle: string | false | CSSProperties | import("vue").StyleValue[] | null;
@@ -151,16 +151,16 @@ declare const _default: <T extends MentionOption = MentionOption>(__VLS_props: N
         } & Readonly<{
             disabled: boolean;
             tabindex: string | number;
-            type: import("@element-plus/components/input").InputType;
+            type: import("../input/index").InputType;
             modelValue: string | number | null;
-            modelModifiers: import("@element-plus/components/input").InputModelModifiers;
+            modelModifiers: import("../input/index").InputModelModifiers;
             autocomplete: string;
-            clearIcon: import("@element-plus/utils").IconPropType;
+            clearIcon: import("../../utils/index").IconPropType;
             wordLimitPosition: "inside" | "outside";
             validateEvent: boolean;
             inputStyle: string | false | CSSProperties | import("vue").StyleValue[] | null;
             rows: number;
-        }> & Omit<Readonly<import("@element-plus/components/input").InputProps> & Readonly<{
+        }> & Omit<Readonly<import("../input/index").InputProps> & Readonly<{
             onClear?: ((evt: MouseEvent | undefined) => any) | undefined;
             "onUpdate:modelValue"?: ((value: string) => any) | undefined;
             onChange?: ((value: string, evt?: Event | undefined) => any) | undefined;
@@ -178,7 +178,7 @@ declare const _default: <T extends MentionOption = MentionOption>(__VLS_props: N
             textarea: HTMLTextAreaElement | undefined;
             ref: HTMLInputElement | HTMLTextAreaElement | undefined;
             textareaStyle: import("vue").StyleValue;
-            autosize: import("@element-plus/components/input").InputAutoSize | undefined;
+            autosize: import("../input/index").InputAutoSize | undefined;
             isComposing: boolean;
             passwordVisible: boolean;
             focus: () => void | undefined;
@@ -207,15 +207,15 @@ declare const _default: <T extends MentionOption = MentionOption>(__VLS_props: N
             $data: {};
             $props: {
                 readonly id?: string | undefined;
-                readonly size?: import("@element-plus/constants").ComponentSize | undefined;
+                readonly size?: import("../../constants/index").ComponentSize | undefined;
                 readonly disabled?: boolean | undefined;
                 readonly modelValue?: string | number | null | undefined | undefined;
-                readonly modelModifiers?: import("@element-plus/components/input").InputModelModifiers | undefined;
+                readonly modelModifiers?: import("../input/index").InputModelModifiers | undefined;
                 readonly maxlength?: string | number | undefined;
                 readonly minlength?: string | number | undefined;
-                readonly type?: import("@element-plus/components/input").InputType | undefined;
+                readonly type?: import("../input/index").InputType | undefined;
                 readonly resize?: "none" | "both" | "horizontal" | "vertical" | undefined;
-                readonly autosize?: import("@element-plus/components/input").InputAutoSize | undefined;
+                readonly autosize?: import("../input/index").InputAutoSize | undefined;
                 readonly autocomplete?: string | undefined;
                 readonly formatter?: ((value: string) => string) | undefined;
                 readonly parser?: ((value: string) => string) | undefined;
@@ -223,12 +223,12 @@ declare const _default: <T extends MentionOption = MentionOption>(__VLS_props: N
                 readonly form?: string | undefined;
                 readonly readonly?: boolean | undefined;
                 readonly clearable?: boolean | undefined;
-                readonly clearIcon?: import("@element-plus/utils").IconPropType | undefined;
+                readonly clearIcon?: import("../../utils/index").IconPropType | undefined;
                 readonly showPassword?: boolean | undefined;
                 readonly showWordLimit?: boolean | undefined;
                 readonly wordLimitPosition?: "inside" | "outside" | undefined;
-                readonly suffixIcon?: import("@element-plus/utils").IconPropType | undefined;
-                readonly prefixIcon?: import("@element-plus/utils").IconPropType | undefined;
+                readonly suffixIcon?: import("../../utils/index").IconPropType | undefined;
+                readonly prefixIcon?: import("../../utils/index").IconPropType | undefined;
                 readonly containerRole?: string | undefined;
                 readonly tabindex?: string | number | undefined;
                 readonly validateEvent?: boolean | undefined;
@@ -265,7 +265,7 @@ declare const _default: <T extends MentionOption = MentionOption>(__VLS_props: N
             $host: Element | null;
             $emit: ((event: "clear", evt: MouseEvent | undefined) => void) & ((event: "update:modelValue", value: string) => void) & ((event: "change", value: string, evt?: Event | undefined) => void) & ((event: "input", value: string) => void) & ((event: "focus", evt: FocusEvent) => void) & ((event: "blur", evt: FocusEvent) => void) & ((event: "compositionend", evt: CompositionEvent) => void) & ((event: "compositionstart", evt: CompositionEvent) => void) & ((event: "compositionupdate", evt: CompositionEvent) => void) & ((event: "keydown", evt: Event | KeyboardEvent) => void) & ((event: "mouseenter", evt: MouseEvent) => void) & ((event: "mouseleave", evt: MouseEvent) => void);
             $el: any;
-            $options: import("vue").ComponentOptionsBase<Readonly<import("@element-plus/components/input").InputProps> & Readonly<{
+            $options: import("vue").ComponentOptionsBase<Readonly<import("../input/index").InputProps> & Readonly<{
                 onClear?: ((evt: MouseEvent | undefined) => any) | undefined;
                 "onUpdate:modelValue"?: ((value: string) => any) | undefined;
                 onChange?: ((value: string, evt?: Event | undefined) => any) | undefined;
@@ -283,7 +283,7 @@ declare const _default: <T extends MentionOption = MentionOption>(__VLS_props: N
                 textarea: import("vue").ShallowRef<HTMLTextAreaElement | undefined, HTMLTextAreaElement | undefined>;
                 ref: import("vue").ComputedRef<HTMLInputElement | HTMLTextAreaElement | undefined>;
                 textareaStyle: import("vue").ComputedRef<import("vue").StyleValue>;
-                autosize: import("vue").Ref<import("@element-plus/components/input").InputAutoSize | undefined, import("@element-plus/components/input").InputAutoSize | undefined>;
+                autosize: import("vue").Ref<import("../input/index").InputAutoSize | undefined, import("../input/index").InputAutoSize | undefined>;
                 isComposing: import("vue").Ref<boolean, boolean>;
                 passwordVisible: import("vue").Ref<boolean, boolean>;
                 focus: () => void | undefined;
@@ -307,11 +307,11 @@ declare const _default: <T extends MentionOption = MentionOption>(__VLS_props: N
             }, string, {
                 disabled: boolean;
                 tabindex: string | number;
-                type: import("@element-plus/components/input").InputType;
+                type: import("../input/index").InputType;
                 modelValue: string | number | null;
-                modelModifiers: import("@element-plus/components/input").InputModelModifiers;
+                modelModifiers: import("../input/index").InputModelModifiers;
                 autocomplete: string;
-                clearIcon: import("@element-plus/utils").IconPropType;
+                clearIcon: import("../../utils/index").IconPropType;
                 wordLimitPosition: "inside" | "outside";
                 validateEvent: boolean;
                 inputStyle: string | false | CSSProperties | import("vue").StyleValue[] | null;
@@ -339,16 +339,16 @@ declare const _default: <T extends MentionOption = MentionOption>(__VLS_props: N
         } & Readonly<{
             disabled: boolean;
             tabindex: string | number;
-            type: import("@element-plus/components/input").InputType;
+            type: import("../input/index").InputType;
             modelValue: string | number | null;
-            modelModifiers: import("@element-plus/components/input").InputModelModifiers;
+            modelModifiers: import("../input/index").InputModelModifiers;
             autocomplete: string;
-            clearIcon: import("@element-plus/utils").IconPropType;
+            clearIcon: import("../../utils/index").IconPropType;
             wordLimitPosition: "inside" | "outside";
             validateEvent: boolean;
             inputStyle: string | false | CSSProperties | import("vue").StyleValue[] | null;
             rows: number;
-        }> & Omit<Readonly<import("@element-plus/components/input").InputProps> & Readonly<{
+        }> & Omit<Readonly<import("../input/index").InputProps> & Readonly<{
             onClear?: ((evt: MouseEvent | undefined) => any) | undefined;
             "onUpdate:modelValue"?: ((value: string) => any) | undefined;
             onChange?: ((value: string, evt?: Event | undefined) => any) | undefined;
@@ -366,7 +366,7 @@ declare const _default: <T extends MentionOption = MentionOption>(__VLS_props: N
             textarea: HTMLTextAreaElement | undefined;
             ref: HTMLInputElement | HTMLTextAreaElement | undefined;
             textareaStyle: import("vue").StyleValue;
-            autosize: import("@element-plus/components/input").InputAutoSize | undefined;
+            autosize: import("../input/index").InputAutoSize | undefined;
             isComposing: boolean;
             passwordVisible: boolean;
             focus: () => void | undefined;

package/dist/components/mention/mention-dropdown.d.ts

@@ -10,7 +10,7 @@ export interface MentionDropdownProps {
  * @deprecated Removed after 3.0.0, Use `MentionDropdownProps` instead.
  */
 export declare const mentionDropdownProps: {
-    options: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => MentionOption[]) | (() => MentionOption[]) | (((new (...args: any[]) => MentionOption[]) | (() => MentionOption[])) | null)[], unknown, unknown, () => never[], boolean>;
+    options: import("../../utils/index").EpPropFinalized<(new (...args: any[]) => MentionOption[]) | (() => MentionOption[]) | (((new (...args: any[]) => MentionOption[]) | (() => MentionOption[])) | null)[], unknown, unknown, () => never[], boolean>;
     loading: BooleanConstructor;
     disabled: BooleanConstructor;
     contentId: StringConstructor;