@unicom-cloud/ui 0.8.57 → 0.8.59

package/chunk/D3NFxdmG.js

@@ -0,0 +1,518 @@
+import { jsx as P, jsxs as kt, Fragment as At } from "react/jsx-runtime";
+import Ot from "lodash/isFunction";
+import xt from "lodash/isNumber";
+import it, { useRef as w, useState as Ut, useMemo as Vt, useEffect as N, useImperativeHandle as Dt } from "react";
+import { useForceUpdate as Ft } from "../hooks/useForceUpdate.js";
+import { useIsFirstRender as Kt } from "../hooks/useIsFirstRender.js";
+import { useIsomorphicLayoutEffect as jt } from "../hooks/useIsomorphicLayoutEffect.js";
+import { usePrevious as Bt } from "../hooks/usePrevious.js";
+import { useStateWithPromise as Yt } from "../hooks/useStateWithPromise.js";
+import { caf as yt, raf as lt } from "../utils/raf.js";
+import Gt from "../utils/getStringLength.js";
+import { findDOMNode as Wt } from "../utils/reactDOM.js";
+const Ht = ({
+  height: l,
+  offset: o,
+  children: i,
+  outerStyle: e,
+  innerStyle: c
+}) => {
+  let r = {}, f = {
+    display: "flex",
+    flexDirection: "column"
+  };
+  return o !== void 0 ? (r = {
+    height: l,
+    position: "relative",
+    overflow: "hidden",
+    zIndex: 0,
+    ...e
+  }, f = {
+    ...f,
+    transform: `translateY(${o}px)`,
+    position: "absolute",
+    left: 0,
+    right: 0,
+    top: 0,
+    ...c
+  }) : (r = { ...e }, f = { ...f, ...c }), /* @__PURE__ */ P("div", { style: r, children: /* @__PURE__ */ P("div", { style: f, children: i }) });
+};
+function $t(l, o, i, e) {
+  const c = i - l, r = o - i, f = Math.min(c, r) * 2;
+  if (e <= f) {
+    const H = Math.floor(e / 2);
+    return e % 2 ? i + H + 1 : i - H;
+  }
+  return c > r ? i - (e - r) : i + (e - c);
+}
+function Xt(l, o, i) {
+  const e = l.length, c = o.length;
+  let r, f;
+  if (e === 0 && c === 0)
+    return null;
+  e < c ? (r = l, f = o) : (r = o, f = l);
+  const H = { __EMPTY_ITEM__: !0 };
+  function _(I, v) {
+    return I !== void 0 ? i(I, v) : H;
+  }
+  let R = null, T = Math.abs(e - c) !== 1;
+  for (let I = 0; I < f.length; I += 1) {
+    const v = _(r[I], I), F = _(f[I], I);
+    if (v !== F) {
+      R = I, T = T || v !== _(f[I + 1], I + 1);
+      break;
+    }
+  }
+  return R === null ? null : { index: R, multiple: T };
+}
+const qt = "__rc_ghost_item__";
+function Et(l, o) {
+  const i = Math.floor(l * o), e = i / o, c = (l - e) / (1 / o);
+  return {
+    index: i,
+    // scrollPtg >= itemTopPtg，计算结果为元素应当补充的滚动距离相对自身高度的偏移量
+    offsetPtg: Number.isNaN(c) ? 0 : c
+  };
+}
+function Mt(l, o = !1) {
+  const i = Wt(l);
+  let e = 0;
+  if (o) {
+    const { marginTop: c, marginBottom: r } = window.getComputedStyle(l);
+    e = Number(c.replace(/\D/g, "")) + Number(r.replace(/\D/g, "")), e = isNaN(e) ? 0 : e;
+  }
+  return i ? i.offsetHeight + e : 0;
+}
+function ct(l, o) {
+  return l < 0 ? 0 : l > o ? o : l;
+}
+function V({
+  scrollTop: l,
+  scrollHeight: o,
+  clientHeight: i
+}) {
+  const e = o - i;
+  return e <= 0 ? 0 : ct(l, e) / e;
+}
+function St(l, o, i) {
+  const { index: e, offsetPtg: c } = Et(l, o), r = Math.ceil(l * i), f = Math.ceil((1 - l) * i);
+  return {
+    itemIndex: e,
+    itemOffsetPtg: c,
+    startIndex: Math.max(0, e - r),
+    endIndex: Math.min(o - 1, e + f)
+  };
+}
+function J({
+  itemHeight: l,
+  itemOffsetPtg: o,
+  scrollPtg: i,
+  clientHeight: e
+}) {
+  return Math.floor(e * i - l * o);
+}
+function Jt({ scrollTop: l, ...o }) {
+  return l + J(o);
+}
+function Qt({
+  locatedItemRelativeTop: l,
+  locatedItemIndex: o,
+  compareItemIndex: i,
+  startIndex: e,
+  endIndex: c,
+  getItemKey: r,
+  itemElementHeights: f,
+  itemHeight: H
+}) {
+  let _ = l;
+  const R = r(i);
+  if (i <= o)
+    for (let T = o; T >= e && r(T) !== R; T -= 1) {
+      const v = r(T - 1);
+      _ -= f[v] || H;
+    }
+  else
+    for (let T = o; T <= c; T += 1) {
+      const I = r(T);
+      if (I === R)
+        break;
+      _ += f[I] || H;
+    }
+  return _;
+}
+function Zt(l) {
+  let o = -1, i = 0;
+  return l.forEach((e, c) => {
+    var r;
+    if (e = typeof e == "string" ? e : (r = e.props) == null ? void 0 : r.children, typeof e == "string") {
+      const f = Gt(e);
+      f > i && (i = f, o = c);
+    }
+  }), o;
+}
+const zt = 32, D = `__virtual_item_height_${Math.random().toFixed(5).slice(2)}`, te = (l) => {
+  const o = Ft(), { current: i } = l;
+  N(() => {
+    Object.keys(i).length && !i[D] && (i[D] = Object.entries(i).reduce(
+      (e, [, c], r, f) => {
+        const H = e + c;
+        return r === f.length - 1 ? Math.round(H / f.length) : H;
+      },
+      0
+    ), o());
+  }, [Object.keys(i).length]);
+}, ee = (l) => {
+  const o = w({}), i = w(l);
+  return N(() => {
+    i.current = l;
+  }, [l]), l !== i.current && (o.current = {}), (e, c, r) => (Object.prototype.hasOwnProperty.call(o.current, c) || (o.current[c] = l(e, c, r)), o.current[c]);
+}, ne = it.forwardRef((l, o) => {
+  const {
+    style: i,
+    className: e,
+    children: c,
+    data: r = [],
+    itemKey: f,
+    threshold: H = 100,
+    wrapper: _ = "div",
+    height: R = "100%",
+    isStaticItemHeight: T = !0,
+    itemHeight: I,
+    measureLongestItem: v,
+    scrollOptions: F,
+    onScroll: C,
+    needFiller: _t = !0,
+    outerStyle: st,
+    innerStyle: ut,
+    wrapperChild: Q = it.Fragment,
+    ...bt
+  } = l, G = i && i.maxHeight || R, K = w({}), [Pt, Rt] = Ut(200), ft = ee(c);
+  te(K);
+  const k = r.length, A = I || K.current[D] || zt, W = xt(G) ? G : Pt, O = Math.ceil(W / A), Z = A * k, b = H !== null && k >= H && Z > W, a = w(null), L = w(null), j = w(!1), at = w(b), mt = Vt(() => {
+    if (a.current) {
+      const n = (t) => +window.getComputedStyle(a.current)[t].replace(/\D/g, "");
+      return {
+        top: n("paddingTop"),
+        bottom: n("paddingBottom")
+      };
+    }
+    return { top: 0, bottom: 0 };
+  }, [a.current]), [g, B] = Yt({
+    // measure status
+    status: "NONE",
+    // render range info
+    startIndex: 0,
+    endIndex: 0,
+    itemIndex: 0,
+    itemOffsetPtg: 0,
+    // scroll info
+    startItemTop: 0,
+    scrollTop: 0
+  }), $ = Bt(r) || [], vt = Kt(), Y = (n, t) => typeof f == "function" ? f(n, t) : typeof f == "string" ? n[f] : n.key || t, S = (n, t = r) => {
+    if (n === t.length)
+      return qt;
+    const s = t[n];
+    return s !== void 0 ? Y(s, n) : null;
+  }, E = (n) => K.current[n] || A, dt = (n) => {
+    const { itemIndex: t, relativeTop: s } = n, { scrollHeight: u, clientHeight: p } = a.current, m = g.scrollTop, x = u - p;
+    let d = Number.MAX_VALUE, h = null, M = null, y = null, q = null, U = null, tt = 0;
+    for (let et = 0; et < x; et++) {
+      const pt = $t(0, x, m, et), ht = V({
+        scrollTop: pt,
+        scrollHeight: u,
+        clientHeight: p
+      }), { itemIndex: nt, itemOffsetPtg: It, startIndex: rt, endIndex: ot } = St(
+        ht,
+        k,
+        O
+      );
+      if (rt <= t && t <= ot) {
+        const Nt = J({
+          itemHeight: E(S(nt)),
+          itemOffsetPtg: It,
+          clientHeight: p,
+          scrollPtg: ht
+        }), Ct = Qt({
+          locatedItemRelativeTop: Nt,
+          locatedItemIndex: nt,
+          compareItemIndex: t,
+          startIndex: rt,
+          endIndex: ot,
+          itemHeight: A,
+          getItemKey: S,
+          itemElementHeights: K.current
+        }), Tt = Math.abs(Ct - s);
+        Tt < d ? (d = Tt, h = pt, M = nt, y = It, q = rt, U = ot, tt = 0) : tt += 1;
+      }
+      if (tt > 10)
+        break;
+    }
+    h !== null && (j.current = !0, a.current.scrollTop = h, B({
+      ...g,
+      status: "MEASURE_START",
+      scrollTop: h,
+      itemIndex: M,
+      itemOffsetPtg: y,
+      startIndex: q,
+      endIndex: U
+    })), L.current = lt(() => {
+      j.current = !1;
+    });
+  }, wt = (n) => {
+    const {
+      scrollTop: t,
+      clientHeight: s,
+      scrollHeight: u
+    } = a.current, p = ct(
+      t,
+      u - s
+    ), m = V({
+      scrollTop: p,
+      clientHeight: s,
+      scrollHeight: u
+    }), { index: x, offsetPtg: d } = Et(m, k);
+    B({
+      ...g,
+      scrollTop: p,
+      itemIndex: x,
+      itemOffsetPtg: d
+    }), n && (C == null || C(n, { index: x }));
+  }, gt = (n, t = !1) => {
+    const s = Z, { scrollTop: u, clientHeight: p } = a.current, m = ct(
+      u,
+      s - p
+    );
+    if (!t && (m === g.scrollTop || j.current))
+      return;
+    const x = V({
+      scrollTop: m,
+      clientHeight: p,
+      scrollHeight: s
+    }), { itemIndex: d, itemOffsetPtg: h, startIndex: M, endIndex: y } = St(
+      x,
+      k,
+      O
+    );
+    B({
+      ...g,
+      scrollTop: m,
+      itemIndex: d,
+      itemOffsetPtg: h,
+      startIndex: M,
+      endIndex: y,
+      status: "MEASURE_START"
+    }), n && (C == null || C(n, { index: d }));
+  };
+  N(() => () => {
+    L.current && yt(L.current);
+  }, []), N(() => {
+    a.current && (vt && (a.current.scrollTop = 0), gt(null, !0));
+  }, [O]), N(() => {
+    if (!a.current) return;
+    let n = null;
+    const t = at.current !== b ? b ? "virtual" : "raw" : "";
+    if (at.current = b, W && $.length !== r.length) {
+      const s = Xt($, r, Y);
+      n = s ? s.index : null;
+    }
+    if (t || b && n) {
+      const { clientHeight: s } = a.current, u = J({
+        itemHeight: E(
+          S(g.itemIndex, $)
+        ),
+        itemOffsetPtg: g.itemOffsetPtg,
+        scrollPtg: V({
+          scrollTop: g.scrollTop,
+          scrollHeight: $.length * A,
+          clientHeight: s
+        }),
+        clientHeight: s
+      });
+      if (t === "raw") {
+        let p = u;
+        for (let m = 0; m < g.itemIndex; m++)
+          p -= E(S(m));
+        a.current.scrollTop = -p, j.current = !0, L.current = lt(() => {
+          j.current = !1;
+        });
+      } else
+        dt({
+          itemIndex: g.itemIndex,
+          relativeTop: u
+        });
+    }
+  }, [r, b]), jt(() => {
+    if (g.status === "MEASURE_START" && a.current) {
+      const { scrollTop: n, scrollHeight: t, clientHeight: s } = a.current, u = V({
+        scrollTop: n,
+        scrollHeight: t,
+        clientHeight: s
+      });
+      let p = Jt({
+        scrollPtg: u,
+        clientHeight: s,
+        scrollTop: n - (mt.top + mt.bottom) * u,
+        itemHeight: E(S(g.itemIndex)),
+        itemOffsetPtg: g.itemOffsetPtg
+      });
+      for (let m = g.itemIndex - 1; m >= g.startIndex; m--)
+        p -= E(S(m));
+      B({
+        ...g,
+        startItemTop: p,
+        status: "MEASURE_DONE"
+      });
+    }
+  }, [g]), Dt(
+    o,
+    () => ({
+      dom: a.current,
+      getRootDOMNode: () => a.current,
+      // Scroll to a certain height or an element
+      scrollTo: (n) => {
+        L.current && yt(L.current), L.current = lt(() => {
+          var x;
+          if (!a.current) return;
+          if (typeof n == "number") {
+            a.current.scrollTop = n;
+            return;
+          }
+          const t = "index" in n ? n.index : "key" in n ? r.findIndex(
+            (d, h) => Y(d, h) === n.key
+          ) : 0, s = r[t];
+          if (!s)
+            return;
+          let u = typeof n == "object" && ((x = n.options) != null && x.block) ? n.options.block : (F == null ? void 0 : F.block) || "nearest";
+          const { clientHeight: p, scrollTop: m } = a.current;
+          if (b && !T) {
+            if (u === "nearest") {
+              const { itemIndex: d, itemOffsetPtg: h } = g;
+              if (Math.abs(d - t) < O) {
+                let M = J({
+                  itemHeight: E(S(d)),
+                  itemOffsetPtg: h,
+                  clientHeight: p,
+                  scrollPtg: V(a.current)
+                });
+                if (t < d)
+                  for (let y = t; y < d; y++)
+                    M -= E(S(y));
+                else
+                  for (let y = d; y < t; y++)
+                    M += E(S(y));
+                if (M < 0 || M > p)
+                  u = M < 0 ? "start" : "end";
+                else
+                  return;
+              } else
+                u = t < d ? "start" : "end";
+            }
+            B({
+              ...g,
+              startIndex: Math.max(0, t - O),
+              endIndex: Math.min(k - 1, t + O)
+            }).then(() => {
+              const d = E(Y(s, t));
+              dt({
+                itemIndex: t,
+                relativeTop: u === "start" ? 0 : (p - d) / (u === "center" ? 2 : 1)
+              });
+            });
+          } else {
+            const d = E(
+              S(t)
+            );
+            let h = 0;
+            for (let U = 0; U < t; U++)
+              h += E(S(U));
+            const M = h + d, y = h + d / 2;
+            if (y > m && y < p + m)
+              return;
+            u === "nearest" && (h < m ? u = "start" : M > m + p && (u = "end"));
+            const q = p - d;
+            a.current.scrollTop = h - (u === "start" ? 0 : q / (u === "center" ? 2 : 1));
+          }
+        });
+      }
+    }),
+    [r, A, g]
+  );
+  const z = (n, t) => n.map((s, u) => {
+    const p = t + u, m = ft(s, p, {
+      style: {},
+      itemIndex: u
+    }), x = Y(s, p);
+    return it.cloneElement(m, {
+      key: x,
+      ref: (d) => {
+        const { current: h } = K;
+        d && g.status === "MEASURE_START" && (!T || h[x] === void 0) && (T ? (h[D] || (h[D] = Mt(d, !0)), h[x] = h[D]) : h[x] = Mt(d, !0)), Ot(m == null ? void 0 : m.ref) && (m == null || m.ref(d));
+      }
+    });
+  }), X = w(null);
+  N(() => {
+    X.current = null;
+  }, [r]);
+  const Lt = () => {
+    if (v) {
+      const n = X.current === null ? Zt(r) : X.current, t = r[n];
+      return X.current = n, t ? /* @__PURE__ */ P("div", { style: { height: 1, overflow: "hidden", opacity: 0 }, children: ft(t, n, { style: {} }) }) : null;
+    }
+    return null;
+  };
+  return N(() => {
+    function n() {
+      if (a.current && !xt(G)) {
+        const { clientHeight: s } = a.current;
+        Rt(s);
+      }
+    }
+    let t;
+    return a.current && (t = new ResizeObserver(n), t.observe(a.current)), () => {
+      var s, u;
+      a.current && ((s = t == null ? void 0 : t.unobserve) == null || s.call(t, a.current)), (u = t == null ? void 0 : t.disconnect) == null || u.call(t), t = null;
+    };
+  }, [a.current]), /* @__PURE__ */ P(
+    _,
+    {
+      ref: a,
+      style: {
+        overflowY: "auto",
+        overflowAnchor: "none",
+        ...i,
+        maxHeight: G
+      },
+      className: e,
+      onScroll: b ? gt : wt,
+      ...bt,
+      children: b ? /* @__PURE__ */ kt(At, { children: [
+        /* @__PURE__ */ P(
+          Ht,
+          {
+            height: Z,
+            outerStyle: st,
+            innerStyle: ut,
+            offset: g.status === "MEASURE_DONE" ? g.startItemTop : 0,
+            children: /* @__PURE__ */ P(Q, { children: z(
+              r.slice(g.startIndex, g.endIndex + 1),
+              g.startIndex
+            ) })
+          }
+        ),
+        Lt()
+      ] }) : _t ? /* @__PURE__ */ P(
+        Ht,
+        {
+          height: W,
+          outerStyle: st,
+          innerStyle: ut,
+          children: /* @__PURE__ */ P(Q, { children: z(r, 0) })
+        }
+      ) : /* @__PURE__ */ P(Q, { children: z(r, 0) })
+    }
+  );
+});
+ne.displayName = "VirtualList";
+export {
+  ne as V
+};

package/chunk/{C2fspJbE.js → D3xQFJcO.js}

@@ -1,6 +1,6 @@
 import { jsx as o } from "react/jsx-runtime";
 import i from "react";
-import { u as n } from "./B45v5S9k.js";
+import { u as n } from "./BHn4xgbv.js";
 const u = i.forwardRef(function(r, t) {
   const e = n({ ...r, name: "ui-up" });
   return /* @__PURE__ */ o(

package/chunk/{Lk60-jkf.js → DApXtulb.js}

@@ -1090,9 +1090,13 @@ const qt = An, Ot = Zn, Ft = Dn, At = Sn, Zt = {
   divide: At
 };
 export {
+  Ft as c,
   At as d,
   Zn as i,
   Zt as l,
+  Ot as m,
   Dn as o,
+  Sn as r,
+  qt as s,
   An as u
 };

package/chunk/{sl8s35SK.js → DJcEys80.js}

@@ -1,6 +1,6 @@
 import { jsx as e } from "react/jsx-runtime";
 import m from "react";
-import { u as i } from "./B45v5S9k.js";
+import { u as i } from "./BHn4xgbv.js";
 const c = m.forwardRef(function(t, o) {
   const r = i({ ...t, name: "ui-delete" });
   return /* @__PURE__ */ e(

package/chunk/{B1S1OEw6.js → DLIm6rRJ.js}

@@ -1,6 +1,6 @@
 import { jsx as o } from "react/jsx-runtime";
 import c from "react";
-import { u as i } from "./B45v5S9k.js";
+import { u as i } from "./BHn4xgbv.js";
 const p = c.forwardRef(function(r, e) {
   const t = i({ ...r, name: "ui-clock-circle" });
   return /* @__PURE__ */ o(

package/chunk/{C95ipQ6b.js → DOWEHtqM.js}

@@ -1,6 +1,6 @@
 import { jsxs as e, jsx as t } from "react/jsx-runtime";
 import i from "react";
-import { u as n } from "./B45v5S9k.js";
+import { u as n } from "./BHn4xgbv.js";
 const c = i.forwardRef(function(h, o) {
   const r = n({ ...h, name: "ui-drag-dot-vertical" });
   return /* @__PURE__ */ e(