ep-craft 0.1.24 → 0.1.25

package/dist/components/icon/index.js

@@ -1,14 +1,15 @@
-import { withInstall as t } from "../../utils/with-install.js";
+import { withInstall as o } from "../../utils/with-install.js";
 import "@vue/shared";
 import "lodash-unified";
 import "@vueuse/core";
 import "@element-plus/icons-vue";
 import "vue";
 import { withInstall as i } from "../../utils/vue/install.js";
-import o from "./src/icon.vue.js";
+import t from "./src/icon.vue.js";
 import "./src/icon.js";
-const f = i(o), h = t(o, "ep-icon");
+const I = i(t), e = o(t, "ep-icon");
 export {
-  f as ElIcon,
-  h as EpIcon
+  I as ElIcon,
+  e as EpIcon,
+  e as default
 };

package/dist/components/input/EpInput.vue.d.ts

@@ -0,0 +1,87 @@
+import type { StyleValue } from 'vue';
+import type { InputProps } from './input';
+declare var __VLS_1: {}, __VLS_3: {}, __VLS_26: {}, __VLS_46: {
+    visible: boolean;
+}, __VLS_60: {};
+type __VLS_Slots = {} & {
+    prepend?: (props: typeof __VLS_1) => any;
+} & {
+    prefix?: (props: typeof __VLS_3) => any;
+} & {
+    suffix?: (props: typeof __VLS_26) => any;
+} & {
+    'password-icon'?: (props: typeof __VLS_46) => any;
+} & {
+    append?: (props: typeof __VLS_60) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<InputProps, {
+    /** @description HTML input element */
+    input: import("vue").ShallowRef<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+    /** @description HTML textarea element */
+    textarea: import("vue").ShallowRef<HTMLTextAreaElement | undefined, HTMLTextAreaElement | undefined>;
+    /** @description HTML element, input or textarea */
+    ref: import("vue").ComputedRef<HTMLInputElement | HTMLTextAreaElement | undefined>;
+    /** @description style of textarea. */
+    textareaStyle: import("vue").ComputedRef<StyleValue>;
+    /** @description from props (used on unit test) */
+    autosize: import("vue").Ref<import("./input").InputAutoSize | undefined, import("./input").InputAutoSize | undefined>;
+    /** @description is input composing */
+    isComposing: import("vue").Ref<boolean, boolean>;
+    /** @description whether the password is visible */
+    passwordVisible: import("vue").Ref<boolean, boolean>;
+    /** @description HTML input element native method */
+    focus: () => void | undefined;
+    /** @description HTML input element native method */
+    blur: () => void | undefined;
+    /** @description HTML input element native method */
+    select: () => void;
+    /** @description clear input value */
+    clear: (evt?: MouseEvent) => void;
+    /** @description resize textarea. */
+    resizeTextarea: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    clear: (evt: MouseEvent | undefined) => void;
+    "update:modelValue": (value: string) => void;
+    change: (value: string, evt?: Event | undefined) => void;
+    input: (value: string) => void;
+    focus: (evt: FocusEvent) => void;
+    blur: (evt: FocusEvent) => void;
+    compositionend: (evt: CompositionEvent) => void;
+    compositionstart: (evt: CompositionEvent) => void;
+    compositionupdate: (evt: CompositionEvent) => void;
+    keydown: (evt: Event | KeyboardEvent) => void;
+    mouseenter: (evt: MouseEvent) => void;
+    mouseleave: (evt: MouseEvent) => void;
+}, string, import("vue").PublicProps, Readonly<InputProps> & Readonly<{
+    onClear?: ((evt: MouseEvent | undefined) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onChange?: ((value: string, evt?: Event | undefined) => any) | undefined;
+    onInput?: ((value: string) => any) | undefined;
+    onFocus?: ((evt: FocusEvent) => any) | undefined;
+    onBlur?: ((evt: FocusEvent) => any) | undefined;
+    onCompositionend?: ((evt: CompositionEvent) => any) | undefined;
+    onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;
+    onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;
+    onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;
+    onMouseenter?: ((evt: MouseEvent) => any) | undefined;
+    onMouseleave?: ((evt: MouseEvent) => any) | undefined;
+}>, {
+    disabled: boolean;
+    tabindex: string | number;
+    type: import("./input").InputType;
+    modelValue: string | number | null;
+    modelModifiers: import("./input").InputModelModifiers;
+    autocomplete: string;
+    clearIcon: import("@element-plus/utils").IconPropType;
+    wordLimitPosition: "inside" | "outside";
+    validateEvent: boolean;
+    inputStyle: string | false | import("vue").CSSProperties | StyleValue[] | null;
+    rows: 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/input/EpInput.vue.js

@@ -0,0 +1,552 @@
+import { defineComponent as yt, useAttrs as ht, useSlots as bt, computed as r, shallowRef as he, ref as P, toRef as be, watch as ae, nextTick as B, onMounted as gt, onBeforeUnmount as xt, openBlock as i, createElementBlock as h, normalizeStyle as ne, normalizeClass as u, unref as o, Fragment as ge, renderSlot as j, createCommentVNode as m, createElementVNode as N, toDisplayString as R, createBlock as b, withCtx as G, resolveDynamicComponent as T, mergeProps as Ae, withModifiers as le, mergeDefaults as wt } from "vue";
+import { useResizeObserver as Ct, isClient as It } from "@vueuse/core";
+import { isNil as kt } from "lodash-unified";
+import { ElIcon as $ } from "../icon/index.js";
+import { View as St, Hide as Mt } from "@element-plus/icons-vue";
+import "../form/index.js";
+import { NOOP as A, isObject as Oe } from "@vue/shared";
+import { debugWarn as Et } from "../../utils/error.js";
+import { rAF as Vt, cAF as De } from "../../utils/raf.js";
+import { INPUT_EVENT as xe, UPDATE_MODEL_EVENT as we, CHANGE_EVENT as He } from "../../constants/event.js";
+import { ValidateComponentsMap as zt } from "../../utils/vue/icon.js";
+import { useNamespace as Fe } from "../../hooks/use-namespace/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 { useFocusController as Lt } from "../../hooks/use-focus-controller/index.js";
+import { useAttrs as Pt } from "../../hooks/use-attrs/index.js";
+import { useComposition as Bt } from "../../hooks/use-composition/index.js";
+import { useCursor as Nt } from "../../hooks/use-cursor/index.js";
+import { useFloatLabel as Rt } from "../../hooks/use-float-label/index.js";
+import { looseToNumber as We, calcTextareaHeight as Ke } from "./utils.js";
+import { inputEmits as Gt, inputPropsDefaults as Tt } from "./input.js";
+import { useFormItem as $t, useFormItemInputId as At } from "../form/src/hooks/use-form-item.js";
+import { useFormSize as Ot, useFormDisabled as Dt } from "../form/src/hooks/use-form-common-props.js";
+const Ht = ["id", "name", "minlength", "maxlength", "type", "disabled", "readonly", "autocomplete", "tabindex", "aria-label", "placeholder", "form", "autofocus", "role", "inputmode"], Ft = ["id", "name", "minlength", "maxlength", "tabindex", "disabled", "readonly", "autocomplete", "aria-label", "placeholder", "form", "autofocus", "rows", "role", "inputmode"], Ue = "EpInput", xo = /* @__PURE__ */ yt({
+  name: Ue,
+  inheritAttrs: !1,
+  __name: "EpInput",
+  props: /* @__PURE__ */ wt({
+    id: {},
+    size: {},
+    disabled: { type: Boolean },
+    modelValue: {},
+    modelModifiers: {},
+    maxlength: {},
+    minlength: {},
+    type: {},
+    resize: {},
+    autosize: { type: [Object, Boolean] },
+    autocomplete: {},
+    formatter: { type: Function },
+    parser: { type: Function },
+    placeholder: {},
+    form: {},
+    readonly: { type: Boolean },
+    clearable: { type: Boolean },
+    clearIcon: {},
+    showPassword: { type: Boolean },
+    showWordLimit: { type: Boolean },
+    wordLimitPosition: {},
+    suffixIcon: {},
+    prefixIcon: {},
+    containerRole: {},
+    tabindex: {},
+    validateEvent: { type: Boolean },
+    inputStyle: { type: [Boolean, null, String, Object, Array] },
+    autofocus: { type: Boolean },
+    rows: {},
+    ariaLabel: {},
+    inputmode: {},
+    name: {},
+    countGraphemes: { type: Function },
+    floatLabel: { type: Boolean }
+  }, Tt),
+  emits: Gt,
+  setup(a, { expose: je, emit: Ye }) {
+    const t = a, p = Ye, Ce = ht(), O = bt(), qe = r(() => [
+      t.type === "textarea" ? D.b() : s.b(),
+      s.m(Qe.value),
+      s.is("disabled", I.value),
+      s.is("exceed", et.value),
+      s.is("float-label", t.floatLabel),
+      {
+        [s.b("group")]: O.prepend || O.append,
+        [s.m("prefix")]: O.prefix || t.prefixIcon,
+        [s.m("suffix")]: O.suffix || t.suffixIcon || t.clearable || t.showPassword,
+        [s.bm("suffix", "password-clear")]: X.value && ue.value,
+        [s.b("hidden")]: t.type === "hidden"
+      },
+      Ce.class
+    ]), Je = r(() => [
+      s.e("wrapper"),
+      s.is("focus", Q.value)
+    ]), Ie = Pt(), C = r(() => {
+      var e;
+      return (e = t.maxlength) == null ? void 0 : e.toString();
+    }), { form: se, formItem: f } = $t(), { inputId: ke } = At(t, {
+      formItemContext: f
+    }), Qe = Ot(), I = Dt(), s = Fe("input"), D = Fe("textarea"), Y = he(), x = he(), ie = P(!1), M = P(!1), Se = P(), Me = P(), q = he(t.inputStyle), H = P(""), J = P(), y = r(() => Y.value || x.value), { wrapperRef: Xe, isFocused: Q, handleFocus: Ee, handleBlur: Ve } = Lt(
+      y,
+      {
+        disabled: I,
+        afterBlur() {
+          var e;
+          t.validateEvent && ((e = f == null ? void 0 : f.validate) == null || e.call(f, "blur").catch(A));
+        }
+      }
+    ), ze = r(() => (se == null ? void 0 : se.statusIcon) ?? !1), F = r(() => (f == null ? void 0 : f.validateState) || ""), Le = r(
+      () => F.value && zt[F.value]
+    ), Ze = r(() => M.value ? St : Mt), _e = r(() => [
+      Ce.style
+    ]), Pe = r(() => [
+      t.inputStyle,
+      q.value,
+      { resize: t.resize },
+      J.value ? { height: J.value } : void 0
+    ]), w = r(
+      () => kt(t.modelValue) ? "" : String(t.modelValue)
+    ), { floatLabelClass: Be } = Rt({
+      floatLabel: be(t, "floatLabel"),
+      isFocused: Q,
+      hasValue: r(() => !!w.value),
+      isDisabled: I,
+      isReadonly: be(t, "readonly")
+    }), re = r(
+      () => t.clearable && !I.value && !t.readonly
+    ), X = r(
+      () => re.value && !!w.value && (Q.value || ie.value)
+    ), ue = r(
+      () => t.showPassword && !I.value && !!w.value
+    ), E = r(
+      () => t.showWordLimit && !!C.value && (t.type === "text" || t.type === "textarea") && !I.value && !t.readonly && !t.showPassword
+    ), ce = r(() => t.countGraphemes && t.showWordLimit ? t.countGraphemes(w.value) : w.value.length), et = r(
+      () => (
+        // show exceed style if length of initial value greater then maxlength
+        !!E.value && ce.value > Number(C.value)
+      )
+    ), tt = r(
+      () => !!O.suffix || !!t.suffixIcon || t.clearable || t.showPassword || E.value || !!F.value && ze.value
+    ), ot = r(
+      () => !!Object.keys(t.modelModifiers).length
+    ), [at, nt] = Nt(Y);
+    let V;
+    Ct(x, (e) => {
+      if (lt(), !E.value && !re.value || t.resize !== "both" && t.resize !== "horizontal")
+        return;
+      const n = e[0], { width: l } = n.target.getBoundingClientRect(), d = () => {
+        V = void 0, Se.value = {
+          /** right: 100% - (width - right(10)) */
+          right: `calc(100% - ${l - 10}px)`
+        }, Me.value = {
+          /** right: 100% - (width - right(11)) */
+          right: `calc(100% - ${l - 11}px)`
+        };
+      };
+      V && De(V), V = Vt(d);
+    });
+    const W = () => {
+      const { type: e, autosize: n } = t;
+      if (!(!It || e !== "textarea" || !x.value))
+        if (n) {
+          const l = Oe(n) ? n.minRows : void 0, d = Oe(n) ? n.maxRows : void 0, c = Ke(x.value, l, d);
+          q.value = {
+            overflowY: "hidden",
+            ...c
+          }, B(() => {
+            x.value.offsetHeight, q.value = c;
+          });
+        } else
+          q.value = {
+            minHeight: Ke(x.value).minHeight
+          };
+    }, lt = ((e) => {
+      let n = !1;
+      return () => {
+        var d;
+        if (n || !t.autosize) {
+          t.resize !== "none" && setTimeout(() => {
+            var c;
+            J.value = (c = x.value) == null ? void 0 : c.style.height;
+          });
+          return;
+        }
+        ((d = x.value) == null ? void 0 : d.offsetParent) === null || (setTimeout(e), n = !0);
+      };
+    })(W), z = () => {
+      const e = y.value, n = t.formatter ? t.formatter(w.value) : w.value;
+      !e || e.value === n || t.type === "file" || (e.value = n);
+    }, Ne = (e) => {
+      const { trim: n, number: l } = t.modelModifiers;
+      return n && (e = e.trim()), l && (e = `${We(e)}`), t.formatter && t.parser && (e = t.parser(e)), e;
+    }, de = async (e) => {
+      if (Ge.value) return;
+      const { lazy: n } = t.modelModifiers;
+      let { value: l } = e.target, d = !1;
+      if (n) {
+        p(xe, l);
+        return;
+      }
+      if (l = Ne(l), t.countGraphemes && C.value != null) {
+        const c = Number(C.value), te = t.countGraphemes(l), L = t.countGraphemes(H.value);
+        if (te > c && te > L)
+          if (L > c)
+            l = H.value, d = !0;
+          else {
+            const k = H.value, g = l;
+            let v = 0;
+            for (; v < k.length && v < g.length && k[v] === g[v]; )
+              v++;
+            let S = k.length, K = g.length;
+            for (; S > v && K > v && k[S - 1] === g[K - 1]; )
+              S--, K--;
+            const dt = g.slice(0, v), mt = k.slice(v, S), $e = g.slice(v, K), ft = g.slice(K), vt = t.countGraphemes(mt), pt = L - vt, ve = Math.max(0, c - pt);
+            let U = "";
+            if (ve > 0)
+              if (typeof Intl < "u" && "Segmenter" in Intl) {
+                const pe = new Intl.Segmenter(void 0, {
+                  granularity: "grapheme"
+                });
+                for (const { segment: oe } of pe.segment($e)) {
+                  const ye = U + oe;
+                  if (t.countGraphemes(ye) > ve) break;
+                  U = ye;
+                }
+              } else
+                for (const pe of Array.from($e)) {
+                  const oe = U + pe;
+                  if (t.countGraphemes(oe) > ve) break;
+                  U = oe;
+                }
+            l = dt + U + ft, d = !0;
+          }
+      }
+      if (String(l) === w.value) {
+        if (t.formatter || d) {
+          const c = e.target, te = c.value, L = c.selectionStart, k = c.selectionEnd;
+          if (z(), d && y.value && L != null && k != null) {
+            const g = y.value.value, v = te.slice(Math.max(0, k));
+            let S = Math.min(L, g.length);
+            v && g.endsWith(v) && (S = g.length - v.length), y.value.setSelectionRange(S, S);
+          }
+        }
+        return;
+      }
+      H.value = l, at(), p(we, l), p(xe, l), await B(), (t.formatter && t.parser || !ot.value) && z(), nt();
+    }, Re = async (e) => {
+      let { value: n } = e.target;
+      n = Ne(n), t.modelModifiers.lazy && p(we, n), p(He, n, e), await B(), z();
+    }, {
+      isComposing: Ge,
+      handleCompositionStart: Z,
+      handleCompositionUpdate: _,
+      handleCompositionEnd: ee
+    } = Bt({ emit: p, afterComposition: de }), st = () => {
+      M.value = !M.value;
+    }, me = () => {
+      var e;
+      return (e = y.value) == null ? void 0 : e.focus();
+    }, it = () => {
+      var e;
+      return (e = y.value) == null ? void 0 : e.blur();
+    }, rt = (e) => {
+      ie.value = !1, p("mouseleave", e);
+    }, ut = (e) => {
+      ie.value = !0, p("mouseenter", e);
+    }, Te = (e) => {
+      p("keydown", e);
+    }, ct = () => {
+      var e;
+      (e = y.value) == null || e.select();
+    }, fe = (e) => {
+      p(we, ""), p(He, ""), p("clear", e), p(xe, "");
+    };
+    return ae(
+      () => t.modelValue,
+      () => {
+        var e;
+        B(() => {
+          W(), t.autosize && (J.value = void 0);
+        }), t.validateEvent && ((e = f == null ? void 0 : f.validate) == null || e.call(f, "change").catch(A));
+      }
+    ), ae(
+      () => w.value,
+      (e) => {
+        H.value = e;
+      },
+      { immediate: !0 }
+    ), ae(w, (e) => {
+      if (!y.value)
+        return;
+      const { trim: n, number: l } = t.modelModifiers, d = y.value.value, c = (l || t.type === "number") && !/^0\d/.test(d) ? `${We(d)}` : d;
+      c !== e && (document.activeElement === y.value && y.value.type !== "range" && n && c.trim() === e || z());
+    }), ae(
+      () => t.type,
+      async () => {
+        await B(), z(), W();
+      }
+    ), gt(() => {
+      !t.formatter && t.parser && Et(
+        Ue,
+        "If you set the parser, you also need to set the formatter."
+      ), z(), B(W);
+    }), xt(() => {
+      V && De(V);
+    }), je({
+      /** @description HTML input element */
+      input: Y,
+      /** @description HTML textarea element */
+      textarea: x,
+      /** @description HTML element, input or textarea */
+      ref: y,
+      /** @description style of textarea. */
+      textareaStyle: Pe,
+      /** @description from props (used on unit test) */
+      autosize: be(t, "autosize"),
+      /** @description is input composing */
+      isComposing: Ge,
+      /** @description whether the password is visible */
+      passwordVisible: M,
+      /** @description HTML input element native method */
+      focus: me,
+      /** @description HTML input element native method */
+      blur: it,
+      /** @description HTML input element native method */
+      select: ct,
+      /** @description clear input value */
+      clear: fe,
+      /** @description resize textarea. */
+      resizeTextarea: W
+    }), (e, n) => (i(), h("div", {
+      class: u([
+        qe.value,
+        {
+          [o(s).bm("group", "append")]: e.$slots.append,
+          [o(s).bm("group", "prepend")]: e.$slots.prepend
+        }
+      ]),
+      style: ne(_e.value),
+      onMouseenter: ut,
+      onMouseleave: rt
+    }, [
+      a.type !== "textarea" ? (i(), h(ge, { key: 0 }, [
+        e.$slots.prepend ? (i(), h("div", {
+          key: 0,
+          class: u(o(s).be("group", "prepend"))
+        }, [
+          j(e.$slots, "prepend")
+        ], 2)) : m("", !0),
+        N("div", {
+          ref_key: "wrapperRef",
+          ref: Xe,
+          class: u(Je.value)
+        }, [
+          a.floatLabel ? (i(), h("span", {
+            key: 0,
+            class: u(["el-float-label", o(Be)]),
+            onClick: me
+          }, R(a.placeholder), 3)) : m("", !0),
+          e.$slots.prefix || a.prefixIcon ? (i(), h("span", {
+            key: 1,
+            class: u(o(s).e("prefix"))
+          }, [
+            N("span", {
+              class: u(o(s).e("prefix-inner"))
+            }, [
+              j(e.$slots, "prefix"),
+              a.prefixIcon ? (i(), b(o($), {
+                key: 0,
+                class: u(o(s).e("icon"))
+              }, {
+                default: G(() => [
+                  (i(), b(T(a.prefixIcon)))
+                ]),
+                _: 1
+              }, 8, ["class"])) : m("", !0)
+            ], 2)
+          ], 2)) : m("", !0),
+          N("input", Ae({
+            id: o(ke),
+            ref_key: "input",
+            ref: Y,
+            class: o(s).e("inner")
+          }, o(Ie), {
+            name: a.name,
+            minlength: a.countGraphemes ? void 0 : a.minlength,
+            maxlength: a.countGraphemes ? void 0 : C.value,
+            type: a.showPassword ? M.value ? "text" : "password" : a.type,
+            disabled: o(I),
+            readonly: a.readonly,
+            autocomplete: a.autocomplete,
+            tabindex: a.tabindex,
+            "aria-label": a.ariaLabel,
+            placeholder: a.floatLabel ? void 0 : a.placeholder,
+            style: a.inputStyle,
+            form: a.form,
+            autofocus: a.autofocus,
+            role: a.containerRole,
+            inputmode: a.inputmode,
+            onCompositionstart: n[0] || (n[0] = //@ts-ignore
+            (...l) => o(Z) && o(Z)(...l)),
+            onCompositionupdate: n[1] || (n[1] = //@ts-ignore
+            (...l) => o(_) && o(_)(...l)),
+            onCompositionend: n[2] || (n[2] = //@ts-ignore
+            (...l) => o(ee) && o(ee)(...l)),
+            onInput: de,
+            onChange: Re,
+            onKeydown: Te
+          }), null, 16, Ht),
+          tt.value ? (i(), h("span", {
+            key: 2,
+            class: u(o(s).e("suffix"))
+          }, [
+            N("span", {
+              class: u(o(s).e("suffix-inner"))
+            }, [
+              re.value ? (i(), b(o($), {
+                key: 0,
+                class: u([o(s).e("icon"), o(s).e("clear")]),
+                style: ne({ visibility: X.value ? "visible" : "hidden" }),
+                onMousedown: le(o(A), ["prevent"]),
+                onClick: fe
+              }, {
+                default: G(() => [
+                  (i(), b(T(a.clearIcon)))
+                ]),
+                _: 1
+              }, 8, ["class", "style", "onMousedown"])) : m("", !0),
+              !X.value || !ue.value || !E.value ? (i(), h(ge, { key: 1 }, [
+                j(e.$slots, "suffix"),
+                a.suffixIcon ? (i(), b(o($), {
+                  key: 0,
+                  class: u(o(s).e("icon"))
+                }, {
+                  default: G(() => [
+                    (i(), b(T(a.suffixIcon)))
+                  ]),
+                  _: 1
+                }, 8, ["class"])) : m("", !0)
+              ], 64)) : m("", !0),
+              ue.value ? (i(), b(o($), {
+                key: 2,
+                class: u([o(s).e("icon"), o(s).e("password")]),
+                onClick: st,
+                onMousedown: le(o(A), ["prevent"]),
+                onMouseup: le(o(A), ["prevent"])
+              }, {
+                default: G(() => [
+                  j(e.$slots, "password-icon", { visible: M.value }, () => [
+                    (i(), b(T(Ze.value)))
+                  ])
+                ]),
+                _: 3
+              }, 8, ["class", "onMousedown", "onMouseup"])) : m("", !0),
+              E.value ? (i(), h("span", {
+                key: 3,
+                class: u([
+                  o(s).e("count"),
+                  o(s).is("outside", a.wordLimitPosition === "outside")
+                ])
+              }, [
+                N("span", {
+                  class: u(o(s).e("count-inner"))
+                }, R(ce.value) + " / " + R(C.value), 3)
+              ], 2)) : m("", !0),
+              F.value && Le.value && ze.value ? (i(), b(o($), {
+                key: 4,
+                class: u([
+                  o(s).e("icon"),
+                  o(s).e("validateIcon"),
+                  o(s).is("loading", F.value === "validating")
+                ])
+              }, {
+                default: G(() => [
+                  (i(), b(T(Le.value)))
+                ]),
+                _: 1
+              }, 8, ["class"])) : m("", !0)
+            ], 2)
+          ], 2)) : m("", !0)
+        ], 2),
+        e.$slots.append ? (i(), h("div", {
+          key: 1,
+          class: u(o(s).be("group", "append"))
+        }, [
+          j(e.$slots, "append")
+        ], 2)) : m("", !0)
+      ], 64)) : (i(), h(ge, { key: 1 }, [
+        a.floatLabel ? (i(), h("span", {
+          key: 0,
+          class: u(["el-float-label", o(Be)]),
+          onClick: me
+        }, R(a.placeholder), 3)) : m("", !0),
+        N("textarea", Ae({
+          id: o(ke),
+          ref_key: "textarea",
+          ref: x,
+          class: [
+            o(D).e("inner"),
+            o(s).is("focus", o(Q)),
+            o(D).is("clearable", a.clearable)
+          ]
+        }, o(Ie), {
+          name: a.name,
+          minlength: a.countGraphemes ? void 0 : a.minlength,
+          maxlength: a.countGraphemes ? void 0 : C.value,
+          tabindex: a.tabindex,
+          disabled: o(I),
+          readonly: a.readonly,
+          autocomplete: a.autocomplete,
+          style: Pe.value,
+          "aria-label": a.ariaLabel,
+          placeholder: a.floatLabel ? void 0 : a.placeholder,
+          form: a.form,
+          autofocus: a.autofocus,
+          rows: a.rows,
+          role: a.containerRole,
+          inputmode: a.inputmode,
+          onCompositionstart: n[3] || (n[3] = //@ts-ignore
+          (...l) => o(Z) && o(Z)(...l)),
+          onCompositionupdate: n[4] || (n[4] = //@ts-ignore
+          (...l) => o(_) && o(_)(...l)),
+          onCompositionend: n[5] || (n[5] = //@ts-ignore
+          (...l) => o(ee) && o(ee)(...l)),
+          onInput: de,
+          onFocus: n[6] || (n[6] = //@ts-ignore
+          (...l) => o(Ee) && o(Ee)(...l)),
+          onBlur: n[7] || (n[7] = //@ts-ignore
+          (...l) => o(Ve) && o(Ve)(...l)),
+          onChange: Re,
+          onKeydown: Te
+        }), null, 16, Ft),
+        X.value ? (i(), b(o($), {
+          key: 1,
+          class: u([o(D).e("icon"), o(D).e("clear")]),
+          style: ne(Me.value),
+          onMousedown: le(o(A), ["prevent"]),
+          onClick: fe
+        }, {
+          default: G(() => [
+            (i(), b(T(a.clearIcon)))
+          ]),
+          _: 1
+        }, 8, ["class", "style", "onMousedown"])) : m("", !0),
+        E.value ? (i(), h("span", {
+          key: 2,
+          style: ne(Se.value),
+          class: u([
+            o(s).e("count"),
+            o(s).is("outside", a.wordLimitPosition === "outside")
+          ])
+        }, R(ce.value) + " / " + R(C.value), 7)) : m("", !0)
+      ], 64))
+    ], 38));
+  }
+});
+export {
+  xo as default
+};

package/dist/components/input/EpInput2.vue.js

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

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

@@ -1,4 +1,7 @@
 import type { Plugin } from 'vue';
-import { ElInput } from 'element-plus';
-export declare const EpInput: typeof ElInput & Plugin;
+import _EpInput from './EpInput.vue';
+export declare const EpInput: typeof _EpInput & Plugin;
 export default EpInput;
+export { inputEmits, inputProps, inputPropsDefaults, } from './input';
+export type { InputAutoSize, InputEmits, InputModelModifiers, InputProps, InputPropsPublic, InputType, } from './input';
+export type { InputInstance } from './instance';