@dazhicheng/ui 1.0.7 → 1.0.8

package/dist/index-D72GrrFm.js

@@ -0,0 +1,392 @@
+import { isNil as y } from "lodash-es";
+import { e as f, b as me, a as _, u as fe, g as x, d as V, h as pe, j as be, t as ve, w as Ne } from "./use-form-common-props-CH53YdF-.js";
+import { u as he } from "./index-B-3b7Nox.js";
+import { U as N, I as P, C as te, d as Ve, e as Ee, m as ye, f as ge, p as Ie, g as we } from "./index-7R1S3sB2.js";
+import { defineComponent as Se, ref as xe, reactive as Ae, computed as E, watch as H, onMounted as ke, onUpdated as Fe, createElementBlock as K, openBlock as b, withModifiers as Pe, normalizeClass as O, unref as l, withDirectives as q, createCommentVNode as J, createVNode as R, withKeys as Q, renderSlot as A, withCtx as k, createBlock as F, createSlots as Ce } from "vue";
+import { E as Te } from "./index-D2KfwzYW.js";
+import { E as Y } from "./index-BWFNEHAe.js";
+import { v as Z } from "./index-RZOtcmxt.js";
+import { g as De, a as Me, E as ee } from "./event-CgLWlq-W.js";
+import { u as Be } from "./index-BQfVaV7A.js";
+import { u as $e } from "./use-form-item--pOyiE--.js";
+const ze = me({
+  /**
+   * @description same as `id` in native input
+   */
+  id: {
+    type: String,
+    default: void 0
+  },
+  /**
+   * @description incremental step
+   */
+  step: {
+    type: Number,
+    default: 1
+  },
+  /**
+   * @description whether input value can only be multiple of step
+   */
+  stepStrictly: Boolean,
+  /**
+   * @description the maximum allowed value
+   */
+  max: {
+    type: Number,
+    default: Number.MAX_SAFE_INTEGER
+  },
+  /**
+   * @description the minimum allowed value
+   */
+  min: {
+    type: Number,
+    default: Number.MIN_SAFE_INTEGER
+  },
+  /**
+   * @description binding value
+   */
+  modelValue: {
+    type: [Number, null]
+  },
+  /**
+   * @description same as `readonly` in native input
+   */
+  readonly: Boolean,
+  /**
+   * @description whether the component is disabled
+   */
+  disabled: {
+    type: Boolean,
+    default: void 0
+  },
+  /**
+   * @description size of the component
+   */
+  size: fe,
+  /**
+   * @description whether to enable the control buttons
+   */
+  controls: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description position of the control buttons
+   */
+  controlsPosition: {
+    type: String,
+    default: "",
+    values: ["", "right"]
+  },
+  /**
+   * @description value should be set when input box is cleared
+   */
+  valueOnClear: {
+    type: _([String, Number, null]),
+    validator: (n) => n === null || f(n) || ["min", "max"].includes(n),
+    default: null
+  },
+  /**
+   * @description same as `name` in native input
+   */
+  name: String,
+  /**
+   * @description same as `placeholder` in native input
+   */
+  placeholder: String,
+  /**
+   * @description precision of input value
+   */
+  precision: {
+    type: Number,
+    validator: (n) => n >= 0 && n === Number.parseInt(`${n}`, 10)
+  },
+  /**
+   * @description whether to trigger form validation
+   */
+  validateEvent: {
+    type: Boolean,
+    default: !0
+  },
+  ...he(["ariaLabel"]),
+  /**
+   * @description native input mode for virtual keyboards
+   */
+  inputmode: {
+    type: _(String),
+    default: void 0
+  },
+  /**
+   * @description alignment for the inner input text
+   */
+  align: {
+    type: _(String),
+    default: "center"
+  },
+  /**
+   * @description whether to disable scientific notation input (e.g. 'e', 'E')
+   */
+  disabledScientific: Boolean
+}), _e = {
+  [te]: (n, C) => C !== n,
+  blur: (n) => n instanceof FocusEvent,
+  focus: (n) => n instanceof FocusEvent,
+  [P]: (n) => f(n) || y(n),
+  [N]: (n) => f(n) || y(n)
+}, Ke = ["aria-label"], Oe = ["aria-label"];
+var Re = /* @__PURE__ */ Se({
+  name: "ElInputNumber",
+  __name: "input-number",
+  props: ze,
+  emits: _e,
+  setup(n, { expose: C, emit: ne }) {
+    const a = n, c = ne, { t: G } = Be(), d = Ve("input-number"), p = xe(), u = Ae({
+      currentValue: a.modelValue,
+      userInput: null
+    }), { formItem: v } = $e(), L = E(
+      () => f(a.modelValue) && a.modelValue <= a.min
+    ), U = E(
+      () => f(a.modelValue) && a.modelValue >= a.max
+    ), re = E(() => {
+      const e = X(a.step);
+      return x(a.precision) ? Math.max(X(a.modelValue), e) : (e > a.precision && V(
+        "InputNumber",
+        "precision should not be less than the decimal places of step"
+      ), a.precision);
+    }), T = E(() => a.controls && a.controlsPosition === "right"), W = pe(), h = be(), D = E(() => {
+      if (u.userInput !== null)
+        return u.userInput;
+      let e = u.currentValue;
+      if (y(e)) return "";
+      if (f(e)) {
+        if (Number.isNaN(e)) return "";
+        x(a.precision) || (e = e.toFixed(a.precision));
+      }
+      return e;
+    }), g = (e, t) => {
+      if (x(t) && (t = re.value), t === 0) return Math.round(e);
+      let r = String(e);
+      const i = r.indexOf(".");
+      if (i === -1 || !r.replace(".", "").split("")[i + t]) return e;
+      const w = r.length;
+      return r.charAt(w - 1) === "5" && (r = `${r.slice(0, Math.max(0, w - 1))}6`), Number.parseFloat(Number(r).toFixed(t));
+    }, X = (e) => {
+      if (y(e)) return 0;
+      const t = e.toString(), r = t.indexOf(".");
+      let i = 0;
+      return r !== -1 && (i = t.length - r - 1), i;
+    }, j = (e, t = 1) => f(e) ? e >= Number.MAX_SAFE_INTEGER && t === 1 ? (V(
+      "InputNumber",
+      "The value has reached the maximum safe integer limit."
+    ), e) : e <= Number.MIN_SAFE_INTEGER && t === -1 ? (V(
+      "InputNumber",
+      "The value has reached the minimum safe integer limit."
+    ), e) : g(e + a.step * t) : u.currentValue, ae = (e) => {
+      const t = De(e), r = Me(e);
+      if (a.disabledScientific && ["e", "E"].includes(r)) {
+        e.preventDefault();
+        return;
+      }
+      switch (t) {
+        case ee.up: {
+          e.preventDefault(), M();
+          break;
+        }
+        case ee.down: {
+          e.preventDefault(), B();
+          break;
+        }
+      }
+    }, M = () => {
+      if (a.readonly || h.value || U.value) return;
+      const e = Number(D.value) || 0, t = j(e);
+      I(t), c(P, u.currentValue), z();
+    }, B = () => {
+      if (a.readonly || h.value || L.value) return;
+      const e = Number(D.value) || 0, t = j(e, -1);
+      I(t), c(P, u.currentValue), z();
+    }, $ = (e, t) => {
+      const { max: r, min: i, step: s, precision: m, stepStrictly: w, valueOnClear: S } = a;
+      r < i && ve("InputNumber", "min should not be greater than max.");
+      let o = Number(e);
+      if (y(e) || Number.isNaN(o))
+        return null;
+      if (e === "") {
+        if (S === null)
+          return null;
+        o = we(S) ? { min: i, max: r }[S] : S;
+      }
+      return w && (o = g(
+        Math.round(g(o / s)) * s,
+        m
+      ), o !== e && t && c(N, o)), x(m) || (o = g(o, m)), (o > r || o < i) && (o = o > r ? r : i, t && c(N, o)), o;
+    }, I = (e, t = !0) => {
+      var r;
+      const i = u.currentValue, s = $(e);
+      if (!t) {
+        c(N, s);
+        return;
+      }
+      u.userInput = null, !(i === s && e) && (c(N, s), i !== s && c(te, s, i), a.validateEvent && ((r = v == null ? void 0 : v.validate) == null || r.call(v, "change").catch((m) => V(m))), u.currentValue = s);
+    }, le = (e) => {
+      u.userInput = e;
+      const t = e === "" ? null : Number(e);
+      c(P, t), I(t, !1);
+    }, ue = (e) => {
+      const t = e !== "" ? Number(e) : "";
+      (f(t) && !Number.isNaN(t) || e === "") && I(t), z(), u.userInput = null;
+    }, ie = () => {
+      var e, t;
+      (t = (e = p.value) == null ? void 0 : e.focus) == null || t.call(e);
+    }, se = () => {
+      var e, t;
+      (t = (e = p.value) == null ? void 0 : e.blur) == null || t.call(e);
+    }, oe = (e) => {
+      c("focus", e);
+    }, ce = (e) => {
+      var t, r;
+      u.userInput = null, u.currentValue === null && ((t = p.value) != null && t.input) && (p.value.input.value = ""), c("blur", e), a.validateEvent && ((r = v == null ? void 0 : v.validate) == null || r.call(v, "blur").catch((i) => V(i)));
+    }, z = () => {
+      u.currentValue !== a.modelValue && (u.currentValue = a.modelValue);
+    }, de = (e) => {
+      document.activeElement === e.target && e.preventDefault();
+    };
+    return H(
+      () => a.modelValue,
+      (e, t) => {
+        const r = $(e, !0);
+        u.userInput === null && r !== t && (u.currentValue = r);
+      },
+      { immediate: !0 }
+    ), H(
+      () => a.precision,
+      () => {
+        u.currentValue = $(a.modelValue);
+      }
+    ), ke(() => {
+      var e;
+      const { min: t, max: r, modelValue: i } = a, s = (e = p.value) == null ? void 0 : e.input;
+      if (s.setAttribute("role", "spinbutton"), Number.isFinite(r) ? s.setAttribute("aria-valuemax", String(r)) : s.removeAttribute("aria-valuemax"), Number.isFinite(t) ? s.setAttribute("aria-valuemin", String(t)) : s.removeAttribute("aria-valuemin"), s.setAttribute(
+        "aria-valuenow",
+        u.currentValue || u.currentValue === 0 ? String(u.currentValue) : ""
+      ), s.setAttribute("aria-disabled", String(h.value)), !f(i) && i != null) {
+        let m = Number(i);
+        Number.isNaN(m) && (m = null), c(N, m);
+      }
+      s.addEventListener("wheel", de, { passive: !1 });
+    }), Fe(() => {
+      var e, t;
+      const r = (e = p.value) == null ? void 0 : e.input;
+      r == null || r.setAttribute("aria-valuenow", `${(t = u.currentValue) != null ? t : ""}`);
+    }), C({
+      /** @description get focus the input component */
+      focus: ie,
+      /** @description remove focus the input component */
+      blur: se
+    }), (e, t) => (b(), K(
+      "div",
+      {
+        class: O([
+          l(d).b(),
+          l(d).m(l(W)),
+          l(d).is("disabled", l(h)),
+          l(d).is("without-controls", !n.controls),
+          l(d).is("controls-right", T.value),
+          l(d).is(n.align, !!n.align)
+        ]),
+        onDragstart: t[0] || (t[0] = Pe(() => {
+        }, ["prevent"]))
+      },
+      [
+        n.controls ? q((b(), K("span", {
+          key: 0,
+          role: "button",
+          "aria-label": l(G)("el.inputNumber.decrease"),
+          class: O([l(d).e("decrease"), l(d).is("disabled", L.value)]),
+          onKeydown: Q(B, ["enter"])
+        }, [
+          A(e.$slots, "decrease-icon", {}, () => [
+            R(l(Y), null, {
+              default: k(() => [
+                T.value ? (b(), F(l(Ee), { key: 0 })) : (b(), F(l(ye), { key: 1 }))
+              ]),
+              _: 1
+              /* STABLE */
+            })
+          ])
+        ], 42, Ke)), [
+          [l(Z), B]
+        ]) : J("v-if", !0),
+        n.controls ? q((b(), K("span", {
+          key: 1,
+          role: "button",
+          "aria-label": l(G)("el.inputNumber.increase"),
+          class: O([l(d).e("increase"), l(d).is("disabled", U.value)]),
+          onKeydown: Q(M, ["enter"])
+        }, [
+          A(e.$slots, "increase-icon", {}, () => [
+            R(l(Y), null, {
+              default: k(() => [
+                T.value ? (b(), F(l(ge), { key: 0 })) : (b(), F(l(Ie), { key: 1 }))
+              ]),
+              _: 1
+              /* STABLE */
+            })
+          ])
+        ], 42, Oe)), [
+          [l(Z), M]
+        ]) : J("v-if", !0),
+        R(l(Te), {
+          id: n.id,
+          ref_key: "input",
+          ref: p,
+          type: "number",
+          step: n.step,
+          "model-value": D.value,
+          placeholder: n.placeholder,
+          readonly: n.readonly,
+          disabled: l(h),
+          size: l(W),
+          max: n.max,
+          min: n.min,
+          name: n.name,
+          "aria-label": n.ariaLabel,
+          "validate-event": !1,
+          inputmode: n.inputmode,
+          onKeydown: ae,
+          onBlur: ce,
+          onFocus: oe,
+          onInput: le,
+          onChange: ue
+        }, Ce({
+          _: 2
+          /* DYNAMIC */
+        }, [
+          e.$slots.prefix ? {
+            name: "prefix",
+            fn: k(() => [
+              A(e.$slots, "prefix")
+            ]),
+            key: "0"
+          } : void 0,
+          e.$slots.suffix ? {
+            name: "suffix",
+            fn: k(() => [
+              A(e.$slots, "suffix")
+            ]),
+            key: "1"
+          } : void 0
+        ]), 1032, ["id", "step", "model-value", "placeholder", "readonly", "disabled", "size", "max", "min", "name", "aria-label", "inputmode"])
+      ],
+      34
+      /* CLASS, NEED_HYDRATION */
+    ));
+  }
+});
+const Ze = Ne(Re);
+export {
+  Ze as ElInputNumber,
+  Ze as default,
+  _e as inputNumberEmits,
+  ze as inputNumberProps
+};