@unicom-cloud/ui 0.8.43 → 0.8.45

package/virtual-list/VirtualList.js

@@ -0,0 +1,378 @@
+import { jsx as R, jsxs as Ct, Fragment as Ot } from "react/jsx-runtime";
+import pt from "lodash/isNumber";
+import tt, { useRef as S, useState as Nt, useMemo as Ut, useEffect as P, useImperativeHandle as kt } from "react";
+import Vt from "../hooks/useForceUpdate.js";
+import Ft from "../hooks/useIsFirstRender.js";
+import jt from "../hooks/useIsomorphicLayoutEffect.js";
+import Dt from "../hooks/usePrevious.js";
+import Kt from "../hooks/useStateWithPromise.js";
+import { caf as gt, raf as et } from "../utils/raf.js";
+import ht from "./Filler.js";
+import { findListDiffIndex as Bt, getIndexByStartLoc as Gt } from "./util/algorithm.js";
+import { getItemRelativeTop as rt, getScrollPercentage as v, getItemAbsoluteTop as Wt, GHOST_ITEM_KEY as Yt, getCompareItemRelativeTop as Xt, getNodeHeight as It, getLongestItemIndex as $t, getRangeIndex as Tt, getValidScrollTop as xt, getLocationItem as qt } from "./util/item.js";
+const Jt = 32, A = `__virtual_item_height_${Math.random().toFixed(5).slice(2)}`, Qt = (I) => {
+  const x = Vt(), { current: f } = I;
+  P(() => {
+    Object.keys(f).length && !f[A] && (f[A] = Object.entries(f).reduce(
+      (C, [, H], a, y) => {
+        const O = C + H;
+        return a === y.length - 1 ? Math.round(O / y.length) : O;
+      },
+      0
+    ), x());
+  }, [Object.keys(f).length]);
+}, Zt = (I) => {
+  const x = S({}), f = S(I);
+  return P(() => {
+    f.current = I;
+  }, [I]), I !== f.current && (x.current = {}), (C, H, a) => (Object.prototype.hasOwnProperty.call(x.current, H) || (x.current[H] = I(C, H, a)), x.current[H]);
+}, zt = tt.forwardRef((I, x) => {
+  const {
+    style: f,
+    className: C,
+    children: H,
+    data: a = [],
+    itemKey: y,
+    threshold: O = 100,
+    wrapper: Ht = "div",
+    height: St = "100%",
+    isStaticItemHeight: G = !0,
+    itemHeight: yt,
+    measureLongestItem: Et,
+    scrollOptions: W,
+    onScroll: M,
+    needFiller: Rt = !0,
+    outerStyle: nt,
+    innerStyle: ot,
+    wrapperChild: Y = tt.Fragment,
+    ...Pt
+  } = I, F = f && f.maxHeight || St, N = S({}), [Mt, bt] = Nt(200), it = Zt(H);
+  Qt(N);
+  const b = a.length, L = yt || N.current[A] || Jt, j = pt(F) ? F : Mt, _ = Math.ceil(j / L), X = L * b, T = O !== null && b >= O && X > j, o = S(null), E = S(null), U = S(!1), st = S(T), lt = Ut(() => {
+    if (o.current) {
+      const e = (t) => +window.getComputedStyle(o.current)[t].replace(/\D/g, "");
+      return {
+        top: e("paddingTop"),
+        bottom: e("paddingBottom")
+      };
+    }
+    return { top: 0, bottom: 0 };
+  }, [o.current]), [i, k] = Kt({
+    // measure status
+    status: "NONE",
+    // render range info
+    startIndex: 0,
+    endIndex: 0,
+    itemIndex: 0,
+    itemOffsetPtg: 0,
+    // scroll info
+    startItemTop: 0,
+    scrollTop: 0
+  }), D = Dt(a) || [], Lt = Ft(), V = (e, t) => typeof y == "function" ? y(e, t) : typeof y == "string" ? e[y] : e.key || t, g = (e, t = a) => {
+    if (e === t.length)
+      return Yt;
+    const r = t[e];
+    return r !== void 0 ? V(r, e) : null;
+  }, h = (e) => N.current[e] || L, ct = (e) => {
+    const { itemIndex: t, relativeTop: r } = e, { scrollHeight: n, clientHeight: l } = o.current, u = i.scrollTop, m = n - l;
+    let s = Number.MAX_VALUE, c = null, p = null, d = null, B = null, w = null, q = 0;
+    for (let J = 0; J < m; J++) {
+      const at = Gt(0, m, u, J), mt = v({
+        scrollTop: at,
+        scrollHeight: n,
+        clientHeight: l
+      }), { itemIndex: Q, itemOffsetPtg: dt, startIndex: Z, endIndex: z } = Tt(
+        mt,
+        b,
+        _
+      );
+      if (Z <= t && t <= z) {
+        const vt = rt({
+          itemHeight: h(g(Q)),
+          itemOffsetPtg: dt,
+          clientHeight: l,
+          scrollPtg: mt
+        }), At = Xt({
+          locatedItemRelativeTop: vt,
+          locatedItemIndex: Q,
+          compareItemIndex: t,
+          startIndex: Z,
+          endIndex: z,
+          itemHeight: L,
+          getItemKey: g,
+          itemElementHeights: N.current
+        }), ft = Math.abs(At - r);
+        ft < s ? (s = ft, c = at, p = Q, d = dt, B = Z, w = z, q = 0) : q += 1;
+      }
+      if (q > 10)
+        break;
+    }
+    c !== null && (U.current = !0, o.current.scrollTop = c, k({
+      ...i,
+      status: "MEASURE_START",
+      scrollTop: c,
+      itemIndex: p,
+      itemOffsetPtg: d,
+      startIndex: B,
+      endIndex: w
+    })), E.current = et(() => {
+      U.current = !1;
+    });
+  }, _t = (e) => {
+    const {
+      scrollTop: t,
+      clientHeight: r,
+      scrollHeight: n
+    } = o.current, l = xt(
+      t,
+      n - r
+    ), u = v({
+      scrollTop: l,
+      clientHeight: r,
+      scrollHeight: n
+    }), { index: m, offsetPtg: s } = qt(u, b);
+    k({
+      ...i,
+      scrollTop: l,
+      itemIndex: m,
+      itemOffsetPtg: s
+    }), e && (M == null || M(e, { index: m }));
+  }, ut = (e, t = !1) => {
+    const r = X, { scrollTop: n, clientHeight: l } = o.current, u = xt(
+      n,
+      r - l
+    );
+    if (!t && (u === i.scrollTop || U.current))
+      return;
+    const m = v({
+      scrollTop: u,
+      clientHeight: l,
+      scrollHeight: r
+    }), { itemIndex: s, itemOffsetPtg: c, startIndex: p, endIndex: d } = Tt(
+      m,
+      b,
+      _
+    );
+    k({
+      ...i,
+      scrollTop: u,
+      itemIndex: s,
+      itemOffsetPtg: c,
+      startIndex: p,
+      endIndex: d,
+      status: "MEASURE_START"
+    }), e && (M == null || M(e, { index: s }));
+  };
+  P(() => () => {
+    E.current && gt(E.current);
+  }, []), P(() => {
+    o.current && (Lt && (o.current.scrollTop = 0), ut(null, !0));
+  }, [_]), P(() => {
+    if (!o.current) return;
+    let e = null;
+    const t = st.current !== T ? T ? "virtual" : "raw" : "";
+    if (st.current = T, j && D.length !== a.length) {
+      const r = Bt(D, a, V);
+      e = r ? r.index : null;
+    }
+    if (t || T && e) {
+      const { clientHeight: r } = o.current, n = rt({
+        itemHeight: h(
+          g(i.itemIndex, D)
+        ),
+        itemOffsetPtg: i.itemOffsetPtg,
+        scrollPtg: v({
+          scrollTop: i.scrollTop,
+          scrollHeight: D.length * L,
+          clientHeight: r
+        }),
+        clientHeight: r
+      });
+      if (t === "raw") {
+        let l = n;
+        for (let u = 0; u < i.itemIndex; u++)
+          l -= h(g(u));
+        o.current.scrollTop = -l, U.current = !0, E.current = et(() => {
+          U.current = !1;
+        });
+      } else
+        ct({
+          itemIndex: i.itemIndex,
+          relativeTop: n
+        });
+    }
+  }, [a, T]), jt(() => {
+    if (i.status === "MEASURE_START" && o.current) {
+      const { scrollTop: e, scrollHeight: t, clientHeight: r } = o.current, n = v({
+        scrollTop: e,
+        scrollHeight: t,
+        clientHeight: r
+      });
+      let l = Wt({
+        scrollPtg: n,
+        clientHeight: r,
+        scrollTop: e - (lt.top + lt.bottom) * n,
+        itemHeight: h(g(i.itemIndex)),
+        itemOffsetPtg: i.itemOffsetPtg
+      });
+      for (let u = i.itemIndex - 1; u >= i.startIndex; u--)
+        l -= h(g(u));
+      k({
+        ...i,
+        startItemTop: l,
+        status: "MEASURE_DONE"
+      });
+    }
+  }, [i]), kt(
+    x,
+    () => ({
+      dom: o.current,
+      getRootDOMNode: () => o.current,
+      // Scroll to a certain height or an element
+      scrollTo: (e) => {
+        E.current && gt(E.current), E.current = et(() => {
+          var m;
+          if (!o.current) return;
+          if (typeof e == "number") {
+            o.current.scrollTop = e;
+            return;
+          }
+          const t = "index" in e ? e.index : "key" in e ? a.findIndex(
+            (s, c) => V(s, c) === e.key
+          ) : 0, r = a[t];
+          if (!r)
+            return;
+          let n = typeof e == "object" && ((m = e.options) != null && m.block) ? e.options.block : (W == null ? void 0 : W.block) || "nearest";
+          const { clientHeight: l, scrollTop: u } = o.current;
+          if (T && !G) {
+            if (n === "nearest") {
+              const { itemIndex: s, itemOffsetPtg: c } = i;
+              if (Math.abs(s - t) < _) {
+                let p = rt({
+                  itemHeight: h(g(s)),
+                  itemOffsetPtg: c,
+                  clientHeight: l,
+                  scrollPtg: v(o.current)
+                });
+                if (t < s)
+                  for (let d = t; d < s; d++)
+                    p -= h(g(d));
+                else
+                  for (let d = s; d < t; d++)
+                    p += h(g(d));
+                if (p < 0 || p > l)
+                  n = p < 0 ? "start" : "end";
+                else
+                  return;
+              } else
+                n = t < s ? "start" : "end";
+            }
+            k({
+              ...i,
+              startIndex: Math.max(0, t - _),
+              endIndex: Math.min(b - 1, t + _)
+            }).then(() => {
+              const s = h(V(r, t));
+              ct({
+                itemIndex: t,
+                relativeTop: n === "start" ? 0 : (l - s) / (n === "center" ? 2 : 1)
+              });
+            });
+          } else {
+            const s = h(
+              g(t)
+            );
+            let c = 0;
+            for (let w = 0; w < t; w++)
+              c += h(g(w));
+            const p = c + s, d = c + s / 2;
+            if (d > u && d < l + u)
+              return;
+            n === "nearest" && (c < u ? n = "start" : p > u + l && (n = "end"));
+            const B = l - s;
+            o.current.scrollTop = c - (n === "start" ? 0 : B / (n === "center" ? 2 : 1));
+          }
+        });
+      }
+    }),
+    [a, L, i]
+  );
+  const $ = (e, t) => e.map((r, n) => {
+    const l = t + n, u = it(r, l, {
+      style: {},
+      itemIndex: n
+    }), m = V(r, l);
+    return tt.cloneElement(u, {
+      key: m,
+      ref: (s) => {
+        const { current: c } = N;
+        s && i.status === "MEASURE_START" && (!G || c[m] === void 0) && (G ? (c[A] || (c[A] = It(s, !0)), c[m] = c[A]) : c[m] = It(s, !0));
+      }
+    });
+  }), K = S(null);
+  P(() => {
+    K.current = null;
+  }, [a]);
+  const wt = () => {
+    if (Et) {
+      const e = K.current === null ? $t(a) : K.current, t = a[e];
+      return K.current = e, t ? /* @__PURE__ */ R("div", { style: { height: 1, overflow: "hidden", opacity: 0 }, children: it(t, e, { style: {} }) }) : null;
+    }
+    return null;
+  };
+  return P(() => {
+    function e() {
+      if (o.current && !pt(F)) {
+        const { clientHeight: r } = o.current;
+        bt(r);
+      }
+    }
+    let t;
+    return o.current && (t = new ResizeObserver(e), t.observe(o.current)), () => {
+      var r, n;
+      o.current && ((r = t == null ? void 0 : t.unobserve) == null || r.call(t, o.current)), (n = t == null ? void 0 : t.disconnect) == null || n.call(t), t = null;
+    };
+  }, [o.current]), /* @__PURE__ */ R(
+    Ht,
+    {
+      ref: o,
+      style: {
+        overflowY: "auto",
+        overflowAnchor: "none",
+        ...f,
+        maxHeight: F
+      },
+      className: C,
+      onScroll: T ? ut : _t,
+      ...Pt,
+      children: T ? /* @__PURE__ */ Ct(Ot, { children: [
+        /* @__PURE__ */ R(
+          ht,
+          {
+            height: X,
+            outerStyle: nt,
+            innerStyle: ot,
+            offset: i.status === "MEASURE_DONE" ? i.startItemTop : 0,
+            children: /* @__PURE__ */ R(Y, { children: $(
+              a.slice(i.startIndex, i.endIndex + 1),
+              i.startIndex
+            ) })
+          }
+        ),
+        wt()
+      ] }) : Rt ? /* @__PURE__ */ R(
+        ht,
+        {
+          height: j,
+          outerStyle: nt,
+          innerStyle: ot,
+          children: /* @__PURE__ */ R(Y, { children: $(a, 0) })
+        }
+      ) : /* @__PURE__ */ R(Y, { children: $(a, 0) })
+    }
+  );
+});
+zt.displayName = "VirtualList";
+export {
+  zt as default
+};

package/virtual-list/util/algorithm.js

@@ -0,0 +1,32 @@
+function y(f, r, t, e) {
+  const o = t - f, l = r - t, u = Math.min(o, l) * 2;
+  if (e <= u) {
+    const c = Math.floor(e / 2);
+    return e % 2 ? t + c + 1 : t - c;
+  }
+  return o > l ? t - (e - l) : t + (e - o);
+}
+function M(f, r, t) {
+  const e = f.length, o = r.length;
+  let l, u;
+  if (e === 0 && o === 0)
+    return null;
+  e < o ? (l = f, u = r) : (l = r, u = f);
+  const c = { __EMPTY_ITEM__: !0 };
+  function s(n, i) {
+    return n !== void 0 ? t(n, i) : c;
+  }
+  let h = null, I = Math.abs(e - o) !== 1;
+  for (let n = 0; n < u.length; n += 1) {
+    const i = s(l[n], n), g = s(u[n], n);
+    if (i !== g) {
+      h = n, I = I || i !== s(u[n + 1], n + 1);
+      break;
+    }
+  }
+  return h === null ? null : { index: h, multiple: I };
+}
+export {
+  M as findListDiffIndex,
+  y as getIndexByStartLoc
+};

package/virtual-list/util/item.js

@@ -0,0 +1,99 @@
+import m from "../../utils/getStringLength.js";
+import { findDOMNode as l } from "../../utils/reactDOM.js";
+const M = "__rc_ghost_item__";
+function d(n, e) {
+  const o = Math.floor(n * e), t = o / e, f = (n - t) / (1 / e);
+  return {
+    index: o,
+    // scrollPtg >= itemTopPtg，计算结果为元素应当补充的滚动距离相对自身高度的偏移量
+    offsetPtg: Number.isNaN(f) ? 0 : f
+  };
+}
+function T(n, e = !1) {
+  const o = l(n);
+  let t = 0;
+  if (e) {
+    const { marginTop: f, marginBottom: r } = window.getComputedStyle(n);
+    t = Number(f.replace(/\D/g, "")) + Number(r.replace(/\D/g, "")), t = isNaN(t) ? 0 : t;
+  }
+  return o ? o.offsetHeight + t : 0;
+}
+function h(n, e) {
+  return n < 0 ? 0 : n > e ? e : n;
+}
+function b({
+  scrollTop: n,
+  scrollHeight: e,
+  clientHeight: o
+}) {
+  const t = e - o;
+  return t <= 0 ? 0 : h(n, t) / t;
+}
+function I(n, e, o) {
+  const { index: t, offsetPtg: f } = d(n, e), r = Math.ceil(n * o), c = Math.ceil((1 - n) * o);
+  return {
+    itemIndex: t,
+    itemOffsetPtg: f,
+    startIndex: Math.max(0, t - r),
+    endIndex: Math.min(e - 1, t + c)
+  };
+}
+function x({
+  itemHeight: n,
+  itemOffsetPtg: e,
+  scrollPtg: o,
+  clientHeight: t
+}) {
+  return Math.floor(t * o - n * e);
+}
+function k({ scrollTop: n, ...e }) {
+  return n + x(e);
+}
+function y({
+  locatedItemRelativeTop: n,
+  locatedItemIndex: e,
+  compareItemIndex: o,
+  startIndex: t,
+  endIndex: f,
+  getItemKey: r,
+  itemElementHeights: c,
+  itemHeight: s
+}) {
+  let a = n;
+  const u = r(o);
+  if (o <= e)
+    for (let i = e; i >= t && r(i) !== u; i -= 1) {
+      const p = r(i - 1);
+      a -= c[p] || s;
+    }
+  else
+    for (let i = e; i <= f; i += 1) {
+      const g = r(i);
+      if (g === u)
+        break;
+      a += c[g] || s;
+    }
+  return a;
+}
+function S(n) {
+  let e = -1, o = 0;
+  return n.forEach((t, f) => {
+    var r;
+    if (t = typeof t == "string" ? t : (r = t.props) == null ? void 0 : r.children, typeof t == "string") {
+      const c = m(t);
+      c > o && (o = c, e = f);
+    }
+  }), e;
+}
+export {
+  M as GHOST_ITEM_KEY,
+  y as getCompareItemRelativeTop,
+  k as getItemAbsoluteTop,
+  x as getItemRelativeTop,
+  d as getLocationItem,
+  S as getLongestItemIndex,
+  T as getNodeHeight,
+  I as getRangeIndex,
+  b as getScrollPercentage,
+  h as getValidScrollTop
+};

package/{chunk/BCEX3Acw.js → watermark/Watermark.js}

@@ -1,10 +1,11 @@
 import { jsx as l } from "react/jsx-runtime";
 import { forwardRef as g, useContext as p, useRef as u, useCallback as d, useEffect as C } from "react";
-import "./C6Kfwj0f.js";
-import { a as h } from "./Dr0iXIXO.js";
-import x from "../hooks/use-watermark.js";
-import k from "../hooks/useMergeProps.js";
-import w from "@unicom-cloud/utils/class-name";
+/* empty css                  */
+import "../config-provider/ConfigProvider.js";
+import h from "../hooks/use-watermark.js";
+import x from "../hooks/useMergeProps.js";
+import k from "@unicom-cloud/utils/class-name";
+import { ConfigContext as w } from "../config-provider/context.js";
 const y = {}, N = [
   "zIndex",
   "width",
@@ -17,16 +18,16 @@ const y = {}, N = [
   "offset",
   "getContainer"
 ];
-function W(m, O) {
+function O(m, S) {
   var f;
-  const r = p(h), t = k(
+  const r = p(w), t = x(
     m,
     y,
     (f = r.componentConfig) == null ? void 0 : f.Watermark
   ), n = u(), o = d(() => {
     var e;
     return n.current || ((e = t.getContainer) == null ? void 0 : e.call(t));
-  }, [n.current, t.getContainer]), i = N.reduce((e, a) => (a in t && (e[a] = t[a]), e), {}), { setWatermark: c } = x({
+  }, [n.current, t.getContainer]), i = N.reduce((e, a) => (a in t && (e[a] = t[a]), e), {}), { setWatermark: c } = h({
     ...i,
     getContainer: o
   });
@@ -51,7 +52,7 @@ function W(m, O) {
   return t.children ? /* @__PURE__ */ l(
     "div",
     {
-      className: w(`${s}`, t.className, {
+      className: k(`${s}`, t.className, {
         [`${s}-rtl`]: r.rtl
       }),
       style: t.style,
@@ -60,7 +61,8 @@ function W(m, O) {
     }
   ) : null;
 }
-const b = g(W);
+const j = g(O);
 export {
-  b as W
+  O as WatermarkComponent,
+  j as default
 };