@unicom-cloud/ui 0.8.67 → 0.8.69

package/input/InputElement.js

@@ -0,0 +1,235 @@
+import { jsxs as K, Fragment as L, jsx as c } from "react/jsx-runtime";
+import Y from "@unicom-cloud/icons/IconUiClose";
+import Z from "lodash/isFunction";
+import _, { useState as ee, useRef as I, useImperativeHandle as te, useEffect as O } from "react";
+import { u as oe } from "../chunk/XTEsYGuF.js";
+import { I as ne } from "../chunk/ll867Bf3.js";
+import { m as k } from "../chunk/JPPo5nY_.js";
+import { f as re } from "../chunk/CftuXmo_.js";
+import "../chunk/D-TPB2Do.js";
+import { o as ie } from "../chunk/BKKEev13.js";
+import { r as ae } from "../chunk/CIRG541s.js";
+import se from "./useComposition.js";
+import "../chunk/URXCKjXr.js";
+import h from "lodash/isPlainObject.js";
+const le = 2, ue = (o) => {
+  if (!o)
+    return {};
+  const g = window.getComputedStyle(o);
+  return [
+    "font",
+    "letterSpacing",
+    "overflow",
+    "tabSize",
+    "textIndent",
+    "textTransform",
+    "whiteSpace",
+    "wordBreak",
+    "wordSpacing",
+    "paddingLeft",
+    "paddingRight",
+    "borderLeft",
+    "borderRight",
+    "boxSizing"
+  ].reduce((l, d) => (l[d] = g[d], l), {});
+}, ce = _.forwardRef(
+  (o, g) => {
+    const {
+      allowClear: y,
+      disabled: l,
+      placeholder: d,
+      className: M,
+      style: S,
+      height: z,
+      prefixCls: a,
+      hasParent: C,
+      size: W,
+      value: v,
+      autoFitWidth: n,
+      onClear: x,
+      readOnly: P,
+      onChange: T,
+      onKeyDown: j,
+      onPressEnter: F,
+      maxLength: m,
+      clearIcon: N,
+      ...i
+    } = o, V = ie(i, [
+      "error",
+      "status",
+      "showWordLimit",
+      "className",
+      "defaultValue",
+      "addBefore",
+      "addAfter",
+      "afterStyle",
+      "beforeStyle",
+      "prefix",
+      "suffix",
+      "normalize",
+      "normalizeTrigger",
+      "autoWidth"
+    ]), [$, A] = ee(), E = oe(), r = I(), u = I(), D = I(null), B = h(m) ? m.errorOnly ? void 0 : m.length : m, R = (e) => {
+      let t;
+      const s = o.normalizeTrigger || ["onBlur"];
+      return Array.isArray(s) && s.indexOf(e) > -1 && Z(o.normalize) && (t = o.normalize), t;
+    }, {
+      compositionValue: U,
+      valueChangeHandler: q,
+      compositionHandler: b,
+      keyDownHandler: G,
+      triggerValueChangeCallback: H
+    } = se({
+      value: v,
+      maxLength: B,
+      onChange: T,
+      onKeyDown: j,
+      onPressEnter: F,
+      normalizeHandler: R
+    }), J = k(
+      a,
+      a && {
+        [`${a}-size-${W}`]: W,
+        [`${a}-${o.status}`]: o.status,
+        [`${a}-disabled`]: l,
+        [`${a}-autowidth`]: n
+      },
+      C ? void 0 : M
+    ), w = {
+      "aria-invalid": o.status === "error" || void 0,
+      ...V,
+      readOnly: P,
+      maxLength: B,
+      disabled: l,
+      placeholder: d,
+      value: U || v || "",
+      className: J,
+      onKeyDown: G,
+      onChange: q,
+      onCompositionStart: (e) => {
+        var t;
+        (t = i.onCompositionStart) == null || t.call(i, e), b(e);
+      },
+      onCompositionUpdate: (e) => {
+        var t;
+        (t = i.onCompositionUpdate) == null || t.call(i, e), b(e);
+      },
+      onCompositionEnd: (e) => {
+        var t;
+        (t = i.onCompositionEnd) == null || t.call(i, e), b(e);
+      },
+      onBlur: (e) => {
+        var s;
+        (s = o.onBlur) == null || s.call(o, e);
+        const t = R("onBlur");
+        t && H(t(e.target.value), e);
+      }
+    };
+    te(g, () => ({
+      dom: r.current,
+      getRootDOMNode: () => r.current,
+      focus: () => {
+        var e, t;
+        (t = (e = r.current) == null ? void 0 : e.focus) == null || t.call(e);
+      },
+      blur: () => {
+        var e, t;
+        (t = (e = r.current) == null ? void 0 : e.blur) == null || t.call(e);
+      }
+    }), []);
+    const f = () => {
+      if (u.current && r.current) {
+        const e = u.current.offsetWidth;
+        r.current.style.width = `${e + le}px`;
+      }
+    };
+    O(() => {
+      n && ((!h(n) || !n.pure) && A(ue(r.current)), f());
+    }, [n]);
+    const Q = w.value || d, p = (e) => {
+      r.current && r.current.focus && r.current.focus(), H("", e), x == null || x();
+    };
+    function X() {
+      var t;
+      const e = (t = u.current) == null ? void 0 : t.offsetWidth;
+      if (typeof n == "object") {
+        const s = typeof n.delay == "function" ? n.delay(e, D.current) : n.delay;
+        s ? setTimeout(f, s) : f();
+      } else
+        f();
+      D.current = e;
+    }
+    return O(() => {
+      const e = ae([u.current], X);
+      return () => {
+        e();
+      };
+    }, [u.current]), /* @__PURE__ */ K(L, { children: [
+      y ? /* @__PURE__ */ K(L, { children: [
+        /* @__PURE__ */ c("input", { ref: r, ...w }),
+        !P && !l && y && v ? N !== void 0 ? /* @__PURE__ */ c(
+          "span",
+          {
+            tabIndex: 0,
+            className: `${a}-clear-icon`,
+            ...E({ onPressEnter: p }),
+            onClick: (e) => {
+              e.stopPropagation(), p(e);
+            },
+            onMouseDown: (e) => {
+              e.preventDefault();
+            },
+            children: N
+          }
+        ) : /* @__PURE__ */ c(
+          ne,
+          {
+            tabIndex: 0,
+            className: `${a}-clear-icon`,
+            ...E({ onPressEnter: p }),
+            onClick: (e) => {
+              e.stopPropagation(), p(e);
+            },
+            children: /* @__PURE__ */ c(
+              Y,
+              {
+                onMouseDown: (e) => {
+                  e.preventDefault();
+                }
+              }
+            )
+          }
+        ) : null
+      ] }) : /* @__PURE__ */ c(
+        "input",
+        {
+          ref: r,
+          ...w,
+          style: C ? {} : {
+            minWidth: h(n) ? n.minWidth : void 0,
+            maxWidth: h(n) ? n.maxWidth : void 0,
+            ...S,
+            ..."height" in o ? { height: z } : {}
+          }
+        }
+      ),
+      n && /* @__PURE__ */ c(
+        "span",
+        {
+          className: k(`${a}-mirror`),
+          style: C ? $ : {
+            ...$,
+            ...S,
+            ..."height" in o ? { height: z } : {}
+          },
+          ref: u,
+          children: re(Q)
+        }
+      )
+    ] });
+  }
+);
+ce.displayName = "InputComponent";
+export {
+  ce as default
+};

package/input/Number.js

@@ -0,0 +1,4 @@
+import { InputNumber as e } from "./Input.js";
+export {
+  e as default
+};

package/input/Password.js

@@ -0,0 +1,13 @@
+import "react/jsx-runtime";
+import "@unicom-cloud/icons/IconUiEye";
+import "@unicom-cloud/icons/IconUiEyeInvisible";
+import "react";
+import "../chunk/ll867Bf3.js";
+import "../chunk/XTEsYGuF.js";
+import "../chunk/CdaT1b_F.js";
+import "../chunk/JPPo5nY_.js";
+import "../chunk/BKKEev13.js";
+import { InputPassword as u } from "./Input.js";
+export {
+  u as default
+};

package/input/Search.js

@@ -0,0 +1,14 @@
+import "react/jsx-runtime";
+import "@unicom-cloud/icons/IconUiLoading";
+import "@unicom-cloud/icons/IconUiSearch";
+import "lodash/isPlainObject";
+import "react";
+import "../button/index.js";
+import "../chunk/ll867Bf3.js";
+import "../chunk/CdaT1b_F.js";
+import "../chunk/JPPo5nY_.js";
+import "../chunk/BKKEev13.js";
+import { InputSearch as h } from "./Input.js";
+export {
+  h as default
+};

package/input/Tag.js

@@ -0,0 +1,4 @@
+import a from "../input-tag/InputTag.js";
+export {
+  a as default
+};

package/input/Textarea.js

@@ -0,0 +1,16 @@
+import "react/jsx-runtime";
+import "@unicom-cloud/icons/IconUiClose";
+import "react";
+import "../chunk/ll867Bf3.js";
+import "../chunk/B2yFlXke.js";
+import "../chunk/CdaT1b_F.js";
+import "../chunk/JPPo5nY_.js";
+import "../chunk/D-TPB2Do.js";
+import "../chunk/BKKEev13.js";
+import { InputTextArea as s } from "./Input.js";
+import "./autoSizeTextAreaHeight.js";
+import "./useComposition.js";
+import "lodash/isPlainObject.js";
+export {
+  s 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/index.js

@@ -0,0 +1,15 @@
+import e from "./Input.js";
+import { InputNumber as p, InputPassword as u, InputSearch as o, InputTextArea as n, InputTextArea as f, formatValue as m } from "./Input.js";
+import { default as x } from "./Group.js";
+import { default as l } from "../input-tag/InputTag.js";
+export {
+  x as InputGroup,
+  p as InputNumber,
+  u as InputPassword,
+  o as InputSearch,
+  l as InputTag,
+  n as InputTextArea,
+  f as TextArea,
+  e as default,
+  m as formatValue
+};

package/input/interface.js

@@ -0,0 +1 @@
+

package/input/useComposition.js

@@ -0,0 +1,39 @@
+import { useRef as d, useState as k } from "react";
+import { e as y } from "../chunk/BrOW642m.js";
+function S({
+  value: a,
+  maxLength: v,
+  onChange: s,
+  onKeyDown: u,
+  onPressEnter: f,
+  beforeTriggerValueChangeCallback: m,
+  normalizeHandler: p
+}) {
+  const c = d(!1), [e, r] = 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 || (r(void 0), o(t.target.value, t));
+    },
+    valueChangeHandler: (t) => {
+      const i = t.target.value;
+      c.current ? (c.current = !1, r(i)) : (e && r(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 = p == null ? void 0 : p("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/index.js

@@ -0,0 +1,18 @@
+import "react/jsx-runtime";
+import "@unicom-cloud/icons/IconUiDown";
+import "@unicom-cloud/icons/IconUiMinus";
+import "@unicom-cloud/icons/IconUiPlus";
+import "@unicom-cloud/icons/IconUiUp";
+import "lodash/isNumber";
+import "react";
+import "../chunk/ll867Bf3.js";
+import "../chunk/BFTV6myl.js";
+import { InputNumber as I } from "../input/Input.js";
+import "../chunk/JPPo5nY_.js";
+import "../chunk/BrOW642m.js";
+import "../chunk/BKKEev13.js";
+import "./decimal.js";
+import "./useSelectionRange.js";
+export {
+  I as default
+};

package/input-number/interface.js

@@ -0,0 +1 @@
+

package/input-number/useSelectionRange.js

@@ -0,0 +1,26 @@
+import s from "lodash/isNumber";
+import { useRef as c } from "react";
+import { u as a } from "../chunk/B2yFlXke.js";
+function m({
+  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 {
+  m 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
+};