@unicom-cloud/ui 0.8.65 → 0.8.67

package/chunk/BP9sYyk9.js

@@ -0,0 +1,8 @@
+import { useReducer as n } from "react";
+function c() {
+  const [o, e] = n((r) => (r + 1) % 27, 0);
+  return e;
+}
+export {
+  c
+};

package/chunk/BUdtVdnv.js

@@ -0,0 +1,38 @@
+import { Component as f } from "react";
+import { findDOMNode as r } from "react-dom";
+import { x as c } from "./CkNSv2U7.js";
+import u from "../utils/warning.js";
+import "./CSC_V_25.js";
+import i from "lodash/isFunction.js";
+let n;
+function d(e) {
+  const t = e.constructor;
+  if (typeof t != "function")
+    return !1;
+  !n && typeof WeakSet == "function" && (n = /* @__PURE__ */ new WeakSet());
+  const o = !!(n != null && n.has(t));
+  return n == null || n.add(t), o;
+}
+const M = (e, t) => {
+  if (e) {
+    if (e instanceof Element)
+      return e;
+    if (e.current instanceof Element)
+      return e.current;
+    if (i(e.getRootDOMNode))
+      return e.getRootDOMNode();
+    if (e instanceof f && r)
+      return r(e);
+  }
+  return t && (u(
+    c && !d(t),
+    "Element does not define the `getRootDOMNode` method causing a call to React.findDOMNode. but findDOMNode is deprecated in StrictMode. Please check the code logic",
+    { element: e, instance: t }
+  ), r) ? r(t) : null;
+}, g = (e, t) => {
+  e && e.ref && (i(e.ref) && (e == null || e.ref(t)), "current" in e.ref && (e.ref.current = t));
+};
+export {
+  g as D,
+  M as g
+};

package/chunk/BVQlOzTS.js

@@ -0,0 +1,11 @@
+import { useEffect as c } from "react";
+import { n as m } from "./DU6bs_19.js";
+function e(t, r) {
+  const f = m(t);
+  c(() => {
+    t !== f && r(t, f);
+  }, [t]);
+}
+export {
+  e as c
+};

package/chunk/B__a_gb_.js

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

package/chunk/BbEYToV1.js

@@ -0,0 +1,10 @@
+import { useRef as c, useEffect as f } from "react";
+function n(r, t = []) {
+  const e = c(!1);
+  f(() => {
+    e.current ? r() : e.current = !0;
+  }, t);
+}
+export {
+  n as c
+};

package/chunk/BbdDQAnm.js

@@ -0,0 +1,15 @@
+import c from "lodash/isNumber";
+import s from "lodash/isPlainObject";
+import m from "lodash/isString";
+import h from "react";
+const p = (o) => m(o) || c(o);
+function l(o) {
+  const i = [""];
+  return s(o) && o.children && (o = o.children), h.Children.forEach(o, (r) => {
+    const n = i.length - 1, t = i[n];
+    p(r) && p(t) ? i[n] = `${t}${r}` : r && r.props && r.props.children && i.push(l(r.props.children));
+  }), i.join("");
+}
+export {
+  l as u
+};

package/chunk/BdUcgWdu.js

@@ -0,0 +1,11 @@
+function o(c, e) {
+  const t = {
+    ...c
+  };
+  return e.forEach((n) => {
+    n in t && delete t[n];
+  }), t;
+}
+export {
+  o as c
+};

package/chunk/BfbXSG70.js

@@ -0,0 +1,26 @@
+import { useRef as f, useEffect as u } from "react";
+function w(c, { hidden: d }) {
+  const r = f(!1), o = f({}), l = (e) => e.tagName === "BODY" ? window.innerWidth - (document.body.clientWidth || document.documentElement.clientWidth) : e.offsetWidth - e.clientWidth, s = () => {
+    const e = c();
+    if (e && e.style.overflow !== "hidden") {
+      const t = e.style;
+      r.current = !0;
+      const n = l(e);
+      n && (o.current.width = t.width, e.style.width = `calc(${e.style.width || "100%"} - ${n}px)`), o.current.overflow = t.overflow, e.style.overflow = "hidden";
+    }
+  }, i = () => {
+    if (r.current && c()) {
+      const e = c(), t = o.current;
+      Object.keys(t).forEach(
+        (n) => e.style[n] = t[n]
+      );
+    }
+    r.current = !1, o.current = {};
+  };
+  return u(() => (d ? s() : i(), () => {
+    i();
+  }), [c, d]), [i, s];
+}
+export {
+  w as y
+};