@unicom-cloud/ui 0.8.43 → 0.8.45

package/input/Textarea.js

@@ -0,0 +1,168 @@
+import { jsx as m, jsxs as D } from "react/jsx-runtime";
+import Z from "@unicom-cloud/icons/IconUiClose";
+import _, { useRef as ee, useState as te, useContext as oe, useImperativeHandle as re, useMemo as ne } from "react";
+/* empty css                  */
+import "../config-provider/ConfigProvider.js";
+import ae from "../hooks/useIsomorphicLayoutEffect.js";
+import le from "../hooks/useMergeValue.js";
+import se from "../IconHover.js";
+import x from "@unicom-cloud/utils/class-name";
+import { isObject as T } from "../utils/is.js";
+import ie from "../utils/omit.js";
+import { formatValue as b } from "./Input.js";
+import ce from "./autoSizeTextAreaHeight.js";
+import ue from "./useComposition.js";
+import { ConfigContext as me } from "../config-provider/context.js";
+const fe = (n, L) => {
+  const {
+    className: R,
+    style: H,
+    wrapperStyle: M,
+    placeholder: k,
+    disabled: i,
+    error: I,
+    maxLength: a,
+    showWordLimit: C,
+    allowClear: f,
+    onChange: z,
+    onClear: d,
+    onKeyDown: E,
+    onPressEnter: P,
+    status: W,
+    clearIcon: v,
+    ...j
+  } = n, l = T(a) ? a.length : a, r = T(a) ? a.errorOnly ? void 0 : a.length : a, t = ee(), [w, O] = te({}), [s, K] = le("", {
+    defaultValue: "defaultValue" in n ? b(n.defaultValue, r) : void 0,
+    value: "value" in n ? b(n.value, r) : void 0
+  }), {
+    compositionValue: U,
+    compositionHandler: p,
+    valueChangeHandler: F,
+    keyDownHandler: q,
+    triggerValueChangeCallback: B
+  } = ue({
+    value: s,
+    maxLength: r,
+    onChange: z,
+    onKeyDown: E,
+    onPressEnter: P,
+    beforeTriggerValueChangeCallback: (e) => {
+      !("value" in n) && (r === void 0 || e.length <= r) && K(e);
+    }
+  }), y = U || s || "", { getPrefixCls: G, rtl: g } = oe(me), o = G("textarea");
+  i && (w.resize = "none");
+  const S = () => {
+    if (t.current && t.current.focus) {
+      if (t.current.setSelectionRange) {
+        const e = t.current.textContent.length;
+        t.current.setSelectionRange(e, e);
+      }
+      t.current.focus();
+    }
+  }, J = () => {
+    const e = ce(
+      n.autoSize,
+      t.current
+    );
+    e && O(e);
+  }, $ = (e) => {
+    e.stopPropagation(), S(), B("", e), d == null || d();
+  };
+  ae(() => {
+    J();
+  }, [y]), re(
+    L,
+    () => ({
+      dom: t.current,
+      focus: () => {
+        S();
+      },
+      blur: () => {
+        var e, u;
+        (u = (e = t.current) == null ? void 0 : e.blur) == null || u.call(e);
+      },
+      getRootDOMNode: () => t.current
+    }),
+    []
+  );
+  const c = s ? s.length : 0, Q = l && C || f, N = ne(() => !r && l ? c > l : !1, [c, l, r]), V = W || (I || N ? "error" : void 0), X = x(
+    o,
+    {
+      [`${o}-${V}`]: V,
+      // [`${prefixCls}-error`]: error || lengthError || status === 'error',
+      [`${o}-disabled`]: i,
+      [`${o}-rtl`]: g
+    },
+    R
+  ), A = /* @__PURE__ */ m(
+    "textarea",
+    {
+      ...ie(j, ["autoSize", "defaultValue"]),
+      maxLength: r,
+      ref: t,
+      style: { ...H, ...w },
+      className: X,
+      placeholder: k,
+      disabled: i,
+      value: y,
+      onChange: F,
+      onKeyDown: q,
+      onCompositionStart: p,
+      onCompositionUpdate: p,
+      onCompositionEnd: p
+    }
+  );
+  if (Q) {
+    const e = !i && f && s, [u, Y] = g ? [l, c] : [c, l];
+    return /* @__PURE__ */ D(
+      "div",
+      {
+        className: x(`${o}-wrapper`, {
+          [`${o}-clear-wrapper`]: f,
+          [`${o}-wrapper-rtl`]: g
+        }),
+        style: M,
+        children: [
+          A,
+          e ? v !== void 0 ? /* @__PURE__ */ m(
+            "span",
+            {
+              className: `${o}-clear-icon`,
+              onClick: $,
+              onMouseDown: (h) => {
+                h.preventDefault();
+              },
+              children: v
+            }
+          ) : /* @__PURE__ */ m(se, { className: `${o}-clear-icon`, children: /* @__PURE__ */ m(
+            Z,
+            {
+              onClick: $,
+              onMouseDown: (h) => {
+                h.preventDefault();
+              }
+            }
+          ) }) : null,
+          l && C && /* @__PURE__ */ D(
+            "span",
+            {
+              className: x(`${o}-word-limit`, {
+                [`${o}-word-limit-error`]: N
+              }),
+              children: [
+                u,
+                "/",
+                Y
+              ]
+            }
+          )
+        ]
+      }
+    );
+  }
+  return A;
+}, de = _.forwardRef(fe);
+de.displayName = "TextArea";
+export {
+  de as default
+};

package/input/autoSizeTextAreaHeight.js

@@ -0,0 +1,65 @@
+import c from "lodash/isNumber";
+import b from "lodash/isPlainObject";
+const u = [
+  "position: absolute",
+  "min-height: 0 !important",
+  "max-height: none",
+  "height:0",
+  "visibility: hidden",
+  "z-index: -100",
+  "top: 0",
+  "right: 0"
+].join(";"), w = [
+  "border-width",
+  "box-sizing",
+  "font-family",
+  "font-weight",
+  "font-size",
+  "font-variant",
+  "letter-spacing",
+  "line-height",
+  "padding-top",
+  "padding-bottom",
+  "padding-left",
+  "padding-right",
+  "text-indent",
+  "text-rendering",
+  "text-transform",
+  "width"
+];
+let r;
+function y(n) {
+  r || (r = document.createElement("textarea"), document.body.appendChild(r));
+  const t = window.getComputedStyle(n), m = w.map((a) => `${a}:${t.getPropertyValue(a)}`).join(";");
+  r.setAttribute("style", u + m);
+  const e = parseFloat(t.getPropertyValue("padding-top")) + parseFloat(t.getPropertyValue("padding-bottom")), i = t.getPropertyValue("box-sizing"), l = parseFloat(t.getPropertyValue("border-top-width")) + parseFloat(t.getPropertyValue("border-bottom-width"));
+  return {
+    paddingSize: e,
+    boxSizing: i,
+    borderSize: l
+  };
+}
+function H(n, t) {
+  const m = () => {
+    let e, i;
+    return b(n) && (e = n.minRows, i = n.maxRows), {
+      minRows: e,
+      maxRows: i
+    };
+  };
+  if (n) {
+    const { minRows: e, maxRows: i } = m(), l = t, { paddingSize: a, boxSizing: x, borderSize: p } = y(l);
+    r.value = l.value || l.placeholder || "";
+    let d = r.scrollHeight + p, g, o, h;
+    if (e || i) {
+      r.value = "";
+      const f = r.scrollHeight - a;
+      c(e) && (g = f * e, x === "border-box" && (g += a, g += p), d = Math.max(d, g)), c(i) && (o = f * i, x === "border-box" && (o += a, o += p), h = d > o ? "auto" : "", o = Math.min(d, o));
+    }
+    const s = {};
+    return s.height = d, g && (s.minHeight = g), o && (s.maxHeight = o), h && (s.overflowY = h), s;
+  }
+}
+export {
+  H as default
+};

package/input/useComposition.js

@@ -0,0 +1,39 @@
+import { useRef as d, useState as k } from "react";
+import { Enter as y } from "../utils/keyCode.js";
+function S({
+  value: a,
+  maxLength: v,
+  onChange: s,
+  onKeyDown: u,
+  onPressEnter: f,
+  beforeTriggerValueChangeCallback: m,
+  normalizeHandler: r
+}) {
+  const c = d(!1), [e, p] = k(""), o = (t, i) => {
+    m && m(t), // Avoid triggering onChange repeatedly for the same value
+    // Compositionend is earlier than onchange in Firefox, different with chrome
+    t !== a && (v === void 0 || t.length <= v) && (s == null || s(t, i));
+  };
+  return {
+    compositionValue: e,
+    triggerValueChangeCallback: o,
+    compositionHandler: (t) => {
+      c.current = t.type !== "compositionend", c.current || (p(void 0), o(t.target.value, t));
+    },
+    valueChangeHandler: (t) => {
+      const i = t.target.value;
+      c.current ? (c.current = !1, p(i)) : (e && p(void 0), o(i, t));
+    },
+    keyDownHandler: (t) => {
+      const i = t.key;
+      if (!c.current && (u == null || u(t), i === y.key)) {
+        f == null || f(t);
+        const l = r == null ? void 0 : r("onPressEnter");
+        l && o(l(t.target.value), t);
+      }
+    }
+  };
+}
+export {
+  S as default
+};

package/input-number/decimal.js

@@ -0,0 +1,154 @@
+var b = Object.defineProperty;
+var I = (n, t, i) => t in n ? b(n, t, { enumerable: !0, configurable: !0, writable: !0, value: i }) : n[t] = i;
+var s = (n, t, i) => I(n, typeof t != "symbol" ? t + "" : t, i);
+import { supportBigInt as $, toSafeString as S, validateNumber as E, trimNumber as l, getNumberPrecision as N } from "./util.js";
+class g {
+  constructor(t) {
+    s(this, "isEmpty");
+    s(this, "isNaN");
+    s(this, "isNegative");
+    s(this, "origin", "");
+    s(this, "integer");
+    s(this, "decimal");
+    s(this, "decimalLen");
+    if (this.origin = String(t), !t && t !== 0 || !this.origin.trim()) {
+      this.isEmpty = !0;
+      return;
+    }
+    if (t === "-") {
+      this.isNaN = !0;
+      return;
+    }
+    const i = S(t);
+    if (E(i)) {
+      const { negative: e, trimStr: r } = l(i), [u, a = "0"] = r.split(".");
+      this.isNegative = e, this.integer = BigInt(u), this.decimal = BigInt(a), this.decimalLen = a.length;
+    } else
+      this.isNaN = !0;
+  }
+  get isInvalid() {
+    return this.isEmpty || this.isNaN;
+  }
+  getMark() {
+    return this.isNegative ? "-" : "";
+  }
+  getIntegerStr() {
+    return this.integer.toString();
+  }
+  getDecimalStr() {
+    return this.decimal.toString().padStart(this.decimalLen, "0");
+  }
+  alignDecimal(t) {
+    return BigInt(
+      `${this.getMark()}${this.getIntegerStr()}${this.getDecimalStr().padEnd(
+        t,
+        "0"
+      )}`
+    );
+  }
+  negate() {
+    const t = this.toString();
+    return new g(
+      t.startsWith("-") ? t.slice(1) : `-${t}`
+    );
+  }
+  add(t) {
+    const i = new g(t);
+    if (i.isInvalid)
+      return this;
+    if (this.isInvalid)
+      return i;
+    const e = Math.max(this.decimalLen, i.decimalLen), r = this.alignDecimal(e), u = i.alignDecimal(e), a = (r + u).toString(), { negativeStr: c, trimStr: h } = l(a), m = `${c}${h.padStart(
+      e + 1,
+      "0"
+    )}`;
+    return new g(
+      `${m.slice(0, -e)}.${m.slice(
+        -e
+      )}`
+    );
+  }
+  equals(t) {
+    return this.toString() === (t == null ? void 0 : t.toString());
+  }
+  less(t) {
+    return this.isInvalid || t.isInvalid ? !1 : this.add(t.negate().toString()).toNumber() < 0;
+  }
+  toNumber() {
+    return this.isNaN ? NaN : Number(this.toString());
+  }
+  toString(t = { safe: !0 }) {
+    const { safe: i, precision: e } = t, r = i ? this.isInvalid ? "" : l(
+      `${this.getMark()}${this.getIntegerStr()}.${this.getDecimalStr()}`
+    ).fullStr : this.origin;
+    return typeof e == "number" ? d(r, e) : r;
+  }
+}
+class o {
+  constructor(t) {
+    s(this, "isEmpty");
+    s(this, "isNaN");
+    s(this, "origin", "");
+    s(this, "number");
+    this.origin = String(t), this.number = Number(t), !t && t !== 0 || !this.origin.trim() ? this.isEmpty = !0 : this.isNaN = Number.isNaN(this.number);
+  }
+  get isInvalid() {
+    return this.isEmpty || this.isNaN;
+  }
+  negate() {
+    return new o(-this.toNumber());
+  }
+  equals(t) {
+    return this.toNumber() === (t == null ? void 0 : t.toNumber());
+  }
+  less(t) {
+    return this.isInvalid || t.isInvalid ? !1 : this.add(t.negate().toString()).toNumber() < 0;
+  }
+  add(t) {
+    const i = new o(t);
+    if (i.isInvalid)
+      return this;
+    if (this.isInvalid)
+      return i;
+    const e = this.number + i.number;
+    if (e > Number.MAX_SAFE_INTEGER)
+      return new o(Number.MAX_SAFE_INTEGER);
+    if (e < Number.MIN_SAFE_INTEGER)
+      return new o(Number.MIN_SAFE_INTEGER);
+    const r = Math.max(
+      N(this.number),
+      N(i.number)
+    );
+    return new o(e.toFixed(r));
+  }
+  toNumber() {
+    return this.number;
+  }
+  toString(t = { safe: !0 }) {
+    const { safe: i, precision: e } = t, r = i ? this.isInvalid ? "" : S(this.number) : this.origin;
+    return typeof e == "number" ? d(r, e) : r;
+  }
+}
+function p(n) {
+  return $() ? new g(n) : new o(n);
+}
+function d(n, t, i = !1) {
+  if (n === "")
+    return "";
+  const e = ".", { negativeStr: r, integerStr: u, decimalStr: a } = l(n), c = `${e}${a}`, h = `${r}${u}`;
+  if (t >= 0) {
+    const m = Number(a[t]);
+    if (m >= 5 && !i) {
+      const f = p(n).add(
+        `${r}0.${"0".repeat(t)}${10 - m}`
+      );
+      return d(f.toString(), t, i);
+    }
+    return t === 0 ? h : `${h}${e}${a.padEnd(t, "0").slice(0, t)}`;
+  }
+  return `${h}${c === ".0" ? "" : c}`;
+}
+export {
+  p as getDecimal,
+  d as toFixed
+};

package/input-number/useSelectionRange.js

@@ -0,0 +1,26 @@
+import s from "lodash/isNumber";
+import { useRef as c } from "react";
+import a from "../hooks/useIsomorphicLayoutEffect.js";
+function u({
+  inputElement: n,
+  inputValue: o
+}) {
+  const r = c(null);
+  return a(() => {
+    try {
+      const e = r.current;
+      if (n && o && s(e)) {
+        const t = Math.max(0, o.length - e);
+        n.setSelectionRange(t, t);
+      }
+    } catch (e) {
+      console.warn("Failed to reset input selection range position", e);
+    }
+  }, [o]), (e) => {
+    const { selectionEnd: t, value: i } = e.target;
+    s(t) && (r.current = i.length - t);
+  };
+}
+export {
+  u as default
+};

package/input-number/util.js

@@ -0,0 +1,57 @@
+function l(t) {
+  return !Number.isNaN(Number(t)) && String(t).includes("e");
+}
+function c() {
+  return typeof BigInt == "function";
+}
+function o(t) {
+  const e = String(t);
+  if (l(t)) {
+    let r = Number(e.slice(e.indexOf("e-") + 2));
+    return e.replace(/\.(\d+)/, (i, n) => (r += n.length, i)), r;
+  }
+  return e.includes(".") && f(e) ? e.length - e.indexOf(".") - 1 : 0;
+}
+function S(t) {
+  let e = String(t);
+  if (l(t)) {
+    if (t < Number.MIN_SAFE_INTEGER)
+      return c() ? BigInt(t).toString() : Number.MIN_SAFE_INTEGER.toString();
+    if (t > Number.MAX_SAFE_INTEGER)
+      return c() ? BigInt(t).toString() : Number.MAX_SAFE_INTEGER.toString();
+    const r = o(e);
+    e = Number(t).toFixed(Math.min(100, r));
+  }
+  return N(e).fullStr;
+}
+function f(t) {
+  return typeof t == "number" ? !Number.isNaN(t) : t ? (
+    // 1.1
+    /^\s*-?\d+(\.\d+)?\s*$/.test(t) || // 1.
+    /^\s*-?\d+\.\s*$/.test(t) || // .1
+    /^\s*-?\.\d+\s*$/.test(t)
+  ) : !1;
+}
+function N(t) {
+  let e = t.trim(), r = !1;
+  e = e.replace(/^-/, () => (r = !0, "")).replace(/(\.\d*[^0])0*$/, "$1").replace(/\.0*$/, "").replace(/^0+/, "").replace(/^\./, "0.");
+  const i = e || "0", [n = "0", s = "0"] = i.split(".");
+  n === "0" && s === "0" && (r = !1);
+  const u = r ? "-" : "";
+  return {
+    negative: r,
+    negativeStr: u,
+    trimStr: i,
+    integerStr: n,
+    decimalStr: s,
+    fullStr: `${u}${i}`
+  };
+}
+export {
+  o as getNumberPrecision,
+  l as isE,
+  c as supportBigInt,
+  S as toSafeString,
+  N as trimNumber,
+  f as validateNumber
+};