@unicom-cloud/ui 0.8.123 → 0.8.125

package/virtual-list/VirtualList.js

@@ -1,64 +1,51 @@
-/* 2025-11-19 09:09:44 */
-import { jsx as E, jsxs as Ft, Fragment as Ct } from "react/jsx-runtime";
-import J, { useRef as T, useState as Nt, useMemo as kt, useEffect as A, useImperativeHandle as Ut } from "react";
-import Vt from "@unicom-cloud/ui-common/hooks/use-force-update";
-import jt from "@unicom-cloud/ui-common/hooks/use-is-first-render";
+/* 2025-11-27 12:11:12 */
+import { jsx as h, jsxs as Ft, Fragment as Ct } from "react/jsx-runtime";
+import W, { useRef as T, useState as Nt, useMemo as kt, useEffect as F, useImperativeHandle as Ut } from "react";
+import Vt from "@unicom-cloud/ui-common/hooks/use-is-first-render";
 import Dt from "@unicom-cloud/ui-common/hooks/use-isomorphic-layout-effect";
 import Kt from "@unicom-cloud/ui-common/hooks/use-previous";
 import Bt from "@unicom-cloud/ui-common/hooks/use-resize-observers";
-import qt from "@unicom-cloud/ui-common/hooks/use-state-with-promise";
-import { isNumber as Q, isObjectLike as Gt, isFunction as ft, isString as Wt } from "@unicom-cloud/ui-common/utils/is";
-import pt from "./Filler.js";
-import { findListDiffIndex as Yt, getIndexByStartLoc as zt } from "./utils/algorithm.js";
-import { getItemRelativeTop as Z, getScrollPercentage as v, getItemAbsoluteTop as Xt, getRangeIndex as gt, getValidScrollTop as ht, GHOST_ITEM_KEY as $t, getCompareItemRelativeTop as Jt, getLocationItem as Qt, getLongestItemIndex as Zt, getNodeHeight as It } from "./utils/item.js";
-const te = 32, L = `__virtual_item_height_${Math.random().toFixed(5).slice(2)}`, ee = (h) => {
-  const x = Vt(), { current: f } = h;
-  A(() => {
-    Object.keys(f).length && !f[L] && (f[L] = Object.entries(f).reduce(
-      (_, [, H], m, S) => {
-        const w = _ + H;
-        return m === S.length - 1 ? Math.round(w / S.length) : w;
-      },
-      0
-    ), x());
-  }, [Object.keys(f).length]);
-}, re = (h) => {
-  const x = T({}), f = T(h);
-  return A(() => {
-    f.current = h;
-  }, [h]), h !== f.current && (x.current = {}), (_, H, m) => (Object.prototype.hasOwnProperty.call(x.current, H) || (x.current[H] = h(_, H, m)), x.current[H]);
-}, ne = J.forwardRef((h, x) => {
+import jt from "@unicom-cloud/ui-common/hooks/use-state-with-promise";
+import { isNumber as Y, isObjectLike as qt, isFunction as mt, isString as Gt } from "@unicom-cloud/ui-common/utils/is";
+import { getReactElementRef as Wt } from "@unicom-cloud/ui-common/utils/ref";
+import { KEY_VIRTUAL_ITEM_HEIGHT as C, DEFAULT_VIRTUAL_ITEM_HEIGHT as Yt } from "./constant.js";
+import at from "./Filler.js";
+import zt from "./hook/useCacheChildrenNodes.js";
+import Xt from "./hook/useComputeVirtualItemHeight.js";
+import { findListDiffIndex as Jt, getIndexByStartLoc as Qt } from "./utils/algorithm.js";
+import { getItemRelativeTop as z, getScrollPercentage as y, getItemAbsoluteTop as Zt, getRangeIndex as ut, getValidScrollTop as dt, GHOST_ITEM_KEY as $t, getCompareItemRelativeTop as te, getLocationItem as ee, getLongestItemIndex as re, getNodeHeight as ft } from "./utils/item.js";
+const ne = W.forwardRef((pt, gt) => {
   const {
-    style: f,
-    className: _,
-    children: H,
-    data: m = [],
-    itemKey: S,
-    threshold: w = 100,
+    style: N,
+    className: It,
+    children: ht,
+    data: d = [],
+    itemKey: v,
+    threshold: X = 100,
     wrapper: Tt = "div",
     height: xt = "100%",
-    isStaticItemHeight: K = !0,
+    isStaticItemHeight: k = !0,
     itemHeight: Ht,
     measureLongestItem: St,
-    scrollOptions: yt,
-    onScroll: tt,
-    needFiller: Et = !0,
-    outerStyle: et,
-    innerStyle: rt,
-    wrapperChild: B = J.Fragment,
-    ...Rt
-  } = h, U = f && f.maxHeight || xt, F = T({}), [Pt, bt] = Nt(200), nt = re(H);
-  ee(F);
-  const R = m.length, P = Ht || F.current[L] || te, V = Q(U) ? U : Pt, b = Math.ceil(V / P), q = P * R, I = w !== null && R >= w && q > V, s = T(null), Mt = T({}), y = T(null), C = T(!1), ot = T(I), st = kt(() => {
-    if (s.current) {
-      const t = (e) => +window.getComputedStyle(s.current)[e].replace(/\D/g, "");
+    scrollOptions: Et,
+    onScroll: J,
+    needFiller: Rt = !0,
+    outerStyle: Q,
+    innerStyle: Z,
+    wrapperChild: U = W.Fragment,
+    ...yt
+  } = pt, M = N && N.maxHeight || xt, P = T({}), [Pt, At] = Nt(200), $ = zt(ht);
+  Xt(P);
+  const x = d.length, H = Ht || P.current[C] || Yt, O = Y(M) ? M : Pt, S = Math.ceil(O / H), V = H * x, g = X !== null && x >= X && V > O, l = T(null), Lt = T({}), I = T(null), A = T(!1), tt = T(g), et = kt(() => {
+    if (l.current) {
+      const t = (e) => +window.getComputedStyle(l.current)[e].replace(/\D/g, "");
       return {
         top: t("paddingTop"),
         bottom: t("paddingBottom")
       };
     }
     return { top: 0, bottom: 0 };
-  }, [s.current]), [o, N] = qt({
+  }, [l.current]), [o, L] = jt({
     // measure status
     status: "NONE",
     // render range info
@@ -69,308 +56,310 @@ const te = 32, L = `__virtual_item_height_${Math.random().toFixed(5).slice(2)}`,
     // scroll info
     startItemTop: 0,
     scrollTop: 0
-  }), j = Kt(m) || [], Ot = jt(), k = (t, e) => ft(S) ? S(t, e) : Wt(S) ? t[S] : t.key || e, p = (t, e = m) => {
+  }), w = Kt(d) || [], bt = Vt(), b = (t, e) => mt(v) ? v(t, e) : Gt(v) ? t[v] : t.key || e, f = (t, e = d) => {
     if (t === e.length)
       return $t;
     const i = e[t];
-    return i !== void 0 ? k(i, t) : null;
-  }, g = (t) => F.current[t] || P, it = (t) => {
-    const { itemIndex: e, relativeTop: i } = t, { scrollHeight: r, clientHeight: l } = s.current, c = o.scrollTop, n = r - l;
-    let u = Number.MAX_VALUE, a = null, d = null, M = null, O = null, ct = null, W = 0;
-    for (let Y = 0; Y < n; Y++) {
-      const ut = zt(0, n, c, Y), at = v({
-        scrollTop: ut,
+    return i !== void 0 ? b(i, t) : null;
+  }, p = (t) => P.current[t] || H, rt = (t) => {
+    const { itemIndex: e, relativeTop: i } = t, { scrollHeight: r, clientHeight: s } = l.current, c = o.scrollTop, n = r - s;
+    let m = Number.MAX_VALUE, a = null, u = null, E = null, R = null, ot = null, K = 0;
+    for (let B = 0; B < n; B++) {
+      const it = Qt(0, n, c, B), st = y({
+        scrollTop: it,
         scrollHeight: r,
-        clientHeight: l
-      }), { itemIndex: z, itemOffsetPtg: mt, startIndex: X, endIndex: $ } = gt(
-        at,
-        R,
-        b
+        clientHeight: s
+      }), { itemIndex: j, itemOffsetPtg: lt, startIndex: q, endIndex: G } = ut(
+        st,
+        x,
+        S
       );
-      if (X <= e && e <= $) {
-        const _t = Z({
-          itemHeight: g(p(z)),
-          itemOffsetPtg: mt,
-          clientHeight: l,
-          scrollPtg: at
-        }), wt = Jt({
-          locatedItemRelativeTop: _t,
-          locatedItemIndex: z,
+      if (q <= e && e <= G) {
+        const wt = z({
+          itemHeight: p(f(j)),
+          itemOffsetPtg: lt,
+          clientHeight: s,
+          scrollPtg: st
+        }), _t = te({
+          locatedItemRelativeTop: wt,
+          locatedItemIndex: j,
           compareItemIndex: e,
-          startIndex: X,
-          endIndex: $,
-          itemHeight: P,
-          getItemKey: p,
-          itemElementHeights: F.current
-        }), dt = Math.abs(wt - i);
-        dt < u ? (u = dt, a = ut, d = z, M = mt, O = X, ct = $, W = 0) : W += 1;
+          startIndex: q,
+          endIndex: G,
+          itemHeight: H,
+          getItemKey: f,
+          itemElementHeights: P.current
+        }), ct = Math.abs(_t - i);
+        ct < m ? (m = ct, a = it, u = j, E = lt, R = q, ot = G, K = 0) : K += 1;
       }
-      if (W > 10)
+      if (K > 10)
         break;
     }
-    a !== null && (C.current = !0, s.current.scrollTop = a, N({
+    a !== null && (A.current = !0, l.current.scrollTop = a, L({
       ...o,
       status: "MEASURE_START",
       scrollTop: a,
-      itemIndex: d,
-      itemOffsetPtg: M,
-      startIndex: O,
-      endIndex: ct
-    })), y.current = requestAnimationFrame(() => {
-      C.current = !1;
+      itemIndex: u,
+      itemOffsetPtg: E,
+      startIndex: R,
+      endIndex: ot
+    })), I.current = requestAnimationFrame(() => {
+      A.current = !1;
     });
   }, vt = (t) => {
     const {
       scrollTop: e,
       clientHeight: i,
       scrollHeight: r
-    } = s.current, l = ht(
+    } = l.current, s = dt(
       e,
       r - i
-    ), c = v({
-      scrollTop: l,
+    ), c = y({
+      scrollTop: s,
       clientHeight: i,
       scrollHeight: r
-    }), { index: n, offsetPtg: u } = Qt(c, R);
-    N({
+    }), { index: n, offsetPtg: m } = ee(c, x);
+    L({
       ...o,
-      scrollTop: l,
+      scrollTop: s,
       itemIndex: n,
-      itemOffsetPtg: u
-    }), t && tt?.(t, { index: n });
-  }, lt = (t, e = !1) => {
-    const i = q, { scrollTop: r, clientHeight: l } = s.current, c = ht(
+      itemOffsetPtg: m
+    }), t && J?.(t, { index: n });
+  }, nt = (t, e = !1) => {
+    const i = V, { scrollTop: r, clientHeight: s } = l.current, c = dt(
       r,
-      i - l
+      i - s
     );
-    if (!e && (c === o.scrollTop || C.current))
+    if (!e && (c === o.scrollTop || A.current))
       return;
-    const n = v({
+    const n = y({
       scrollTop: c,
-      clientHeight: l,
+      clientHeight: s,
       scrollHeight: i
-    }), { itemIndex: u, itemOffsetPtg: a, startIndex: d, endIndex: M } = gt(
+    }), { itemIndex: m, itemOffsetPtg: a, startIndex: u, endIndex: E } = ut(
       n,
-      R,
-      b
+      x,
+      S
     );
-    N({
+    L({
       ...o,
       scrollTop: c,
-      itemIndex: u,
+      itemIndex: m,
       itemOffsetPtg: a,
-      startIndex: d,
-      endIndex: M,
+      startIndex: u,
+      endIndex: E,
       status: "MEASURE_START"
-    }), t && tt?.(t, { index: u });
+    }), t && J?.(t, { index: m });
   };
-  A(() => () => {
-    y.current && cancelAnimationFrame(y.current);
-  }, []), A(() => {
-    s.current && (Ot && (s.current.scrollTop = 0), lt(null, !0));
-  }, [b]), A(() => {
-    if (!s.current)
+  F(() => () => {
+    I.current && cancelAnimationFrame(I.current);
+  }, []), F(() => {
+    l.current && (bt && (l.current.scrollTop = 0), nt(null, !0));
+  }, [S]), F(() => {
+    if (!l.current)
       return;
     let t = null;
-    const e = ot.current !== I ? I ? "virtual" : "raw" : "";
-    if (ot.current = I, V && j.length !== m.length) {
-      const i = Yt(j, m, k);
+    const e = tt.current !== g ? g ? "virtual" : "raw" : "";
+    if (tt.current = g, O && w.length !== d.length) {
+      const i = Jt(w, d, b);
       t = i ? i.index : null;
     }
-    if (e || I && t) {
-      const { clientHeight: i } = s.current, r = Z({
-        itemHeight: g(
-          p(o.itemIndex, j)
+    if (e || g && t) {
+      const { clientHeight: i } = l.current, r = z({
+        itemHeight: p(
+          f(o.itemIndex, w)
         ),
         itemOffsetPtg: o.itemOffsetPtg,
-        scrollPtg: v({
+        scrollPtg: y({
           scrollTop: o.scrollTop,
-          scrollHeight: j.length * P,
+          scrollHeight: w.length * H,
           clientHeight: i
         }),
         clientHeight: i
       });
       if (e === "raw") {
-        let l = r;
+        let s = r;
         for (let c = 0; c < o.itemIndex; c++)
-          l -= g(p(c));
-        s.current.scrollTop = -l, C.current = !0, y.current = requestAnimationFrame(() => {
-          C.current = !1;
+          s -= p(f(c));
+        l.current.scrollTop = -s, A.current = !0, I.current = requestAnimationFrame(() => {
+          A.current = !1;
         });
       } else
-        it({
+        rt({
           itemIndex: o.itemIndex,
           relativeTop: r
         });
     }
-  }, [m, I]), Dt(() => {
-    if (o.status === "MEASURE_START" && s.current) {
-      const { scrollTop: t, scrollHeight: e, clientHeight: i } = s.current, r = v({
+  }, [d, g]), Dt(() => {
+    if (o.status === "MEASURE_START" && l.current) {
+      const { scrollTop: t, scrollHeight: e, clientHeight: i } = l.current, r = y({
         scrollTop: t,
         scrollHeight: e,
         clientHeight: i
       });
-      let l = Xt({
+      let s = Zt({
         scrollPtg: r,
         clientHeight: i,
-        scrollTop: t - (st.top + st.bottom) * r,
-        itemHeight: g(p(o.itemIndex)),
+        scrollTop: t - (et.top + et.bottom) * r,
+        itemHeight: p(f(o.itemIndex)),
         itemOffsetPtg: o.itemOffsetPtg
       });
       for (let c = o.itemIndex - 1; c >= o.startIndex; c--)
-        l -= g(p(c));
-      N({
+        s -= p(f(c));
+      L({
         ...o,
-        startItemTop: l,
+        startItemTop: s,
         status: "MEASURE_DONE"
       });
     }
-  }, [o]), Ut(
-    x,
-    () => ({
-      dom: s.current,
-      getRootDOMNode: () => s.current,
-      // Scroll to a certain height or an element
-      scrollTo: (t) => {
-        y.current && cancelAnimationFrame(y.current), y.current = requestAnimationFrame(() => {
-          if (!s.current) return;
-          if (Q(t)) {
-            s.current.scrollTop = t;
-            return;
-          }
-          let e = 0;
-          "index" in t ? e = t.index : "key" in t ? e = m.findIndex(
-            (n, u) => k(n, u) === t.key
-          ) : e = 0;
-          const i = m[e];
-          if (!i) return;
-          let r = Gt(t) && t.options?.block ? t.options.block : yt?.block || "nearest";
-          const { clientHeight: l, scrollTop: c } = s.current;
-          if (I && !K) {
-            if (r === "nearest") {
-              const { itemIndex: n, itemOffsetPtg: u } = o;
-              if (Math.abs(n - e) < b) {
-                let a = Z({
-                  itemHeight: g(p(n)),
-                  itemOffsetPtg: u,
-                  clientHeight: l,
-                  scrollPtg: v(s.current)
-                });
-                if (e < n)
-                  for (let d = e; d < n; d++)
-                    a -= g(p(d));
-                else
-                  for (let d = n; d < e; d++)
-                    a += g(p(d));
-                if (a < 0 || a > l)
-                  r = a < 0 ? "start" : "end";
-                else
-                  return;
-              } else
-                r = e < n ? "start" : "end";
-            }
-            N({
-              ...o,
-              startIndex: Math.max(0, e - b),
-              endIndex: Math.min(R - 1, e + b)
-            }).then(() => {
-              const n = g(k(i, e));
-              it({
-                itemIndex: e,
-                relativeTop: r === "start" ? 0 : (l - n) / (r === "center" ? 2 : 1)
+  }, [o]), Ut(gt, () => ({
+    getRootElement() {
+      return l.current;
+    },
+    // Scroll to a certain height or an element
+    scrollTo: (t) => {
+      I.current && cancelAnimationFrame(I.current), I.current = requestAnimationFrame(() => {
+        if (!l.current) return;
+        if (Y(t)) {
+          l.current.scrollTop = t;
+          return;
+        }
+        let e = 0;
+        "index" in t ? e = t.index : "key" in t ? e = d.findIndex(
+          (n, m) => b(n, m) === t.key
+        ) : e = 0;
+        const i = d[e];
+        if (!i) return;
+        let r = qt(t) && t.options?.block ? t.options.block : Et?.block || "nearest";
+        const { clientHeight: s, scrollTop: c } = l.current;
+        if (g && !k) {
+          if (r === "nearest") {
+            const { itemIndex: n, itemOffsetPtg: m } = o;
+            if (Math.abs(n - e) < S) {
+              let a = z({
+                itemHeight: p(f(n)),
+                itemOffsetPtg: m,
+                clientHeight: s,
+                scrollPtg: y(l.current)
               });
-            });
-          } else {
-            const n = g(
-              p(e)
-            );
-            let u = 0;
-            for (let O = 0; O < e; O++)
-              u += g(p(O));
-            const a = u + n, d = u + n / 2;
-            if (d > c && d < l + c)
-              return;
-            r === "nearest" && (u < c ? r = "start" : a > c + l && (r = "end"));
-            const M = l - n;
-            s.current.scrollTop = u - (r === "start" ? 0 : M / (r === "center" ? 2 : 1));
+              if (e < n)
+                for (let u = e; u < n; u++)
+                  a -= p(f(u));
+              else
+                for (let u = n; u < e; u++)
+                  a += p(f(u));
+              if (a < 0 || a > s)
+                r = a < 0 ? "start" : "end";
+              else
+                return;
+            } else
+              r = e < n ? "start" : "end";
           }
-        });
-      }
-    }),
-    [m, P, o]
-  );
-  const G = (t, e = 0) => t.map((i, r) => {
-    const l = e + r, c = nt(i, l, {
+          L({
+            ...o,
+            startIndex: Math.max(0, e - S),
+            endIndex: Math.min(x - 1, e + S)
+          }).then(() => {
+            const n = p(b(i, e));
+            rt({
+              itemIndex: e,
+              relativeTop: r === "start" ? 0 : (s - n) / (r === "center" ? 2 : 1)
+            });
+          });
+        } else {
+          const n = p(
+            f(e)
+          );
+          let m = 0;
+          for (let R = 0; R < e; R++)
+            m += p(f(R));
+          const a = m + n, u = m + n / 2;
+          if (u > c && u < s + c)
+            return;
+          r === "nearest" && (m < c ? r = "start" : a > c + s && (r = "end"));
+          const E = s - n;
+          l.current.scrollTop = m - (r === "start" ? 0 : E / (r === "center" ? 2 : 1));
+        }
+      });
+    }
+  }), [d, H, o]);
+  const D = (t, e = 0) => t.map((i, r) => {
+    const s = e + r, c = $(i, s, {
       style: {},
       itemIndex: r
-    }), n = k(i, l);
-    return J.cloneElement(c, {
+    }), n = b(i, s);
+    return W.cloneElement(c, {
       key: n,
-      ref: (u) => {
-        const { current: a } = F;
-        u && (Mt.current[r] = u, o.status === "MEASURE_START" && (!K || a[n] === void 0) && (K ? (a[L] || (a[L] = It(u, !0)), a[n] = a[L]) : a[n] = It(u, !0))), ft(c?.ref) && c?.ref(u);
+      ref: (m) => {
+        const { current: a } = P;
+        m && (Lt.current[r] = m, o.status === "MEASURE_START" && (!k || a[n] === void 0) && (k ? (a[C] || (a[C] = ft(m, !0)), a[n] = a[C]) : a[n] = ft(m, !0)));
+        {
+          const u = Wt(c);
+          mt(u) && u(m);
+        }
       }
     });
-  }), D = T(null);
-  A(() => {
-    D.current = null;
-  }, [m]);
-  const At = () => {
+  }), _ = T(null);
+  F(() => {
+    _.current = null;
+  }, [d]);
+  const Mt = () => {
     if (St) {
-      const t = D.current === null ? Zt(m) : D.current, e = m[t];
-      return D.current = t, e ? /* @__PURE__ */ E("div", { style: { height: 1, overflow: "hidden", opacity: 0 }, children: nt(e, t, { style: {} }) }) : null;
+      const t = _.current === null ? re(d) : _.current, e = d[t];
+      return _.current = t, e ? /* @__PURE__ */ h("div", { style: { height: 1, overflow: "hidden", opacity: 0 }, children: $(e, t, { style: {} }) }) : null;
     }
     return null;
   };
-  function Lt(t) {
-    if (s.current && !Q(U)) {
-      const { clientHeight: e } = s.current;
-      bt(e);
+  function Ot(t) {
+    if (l.current && !Y(M)) {
+      const { clientHeight: e } = l.current;
+      At(e);
     }
   }
   return Bt(
     (t) => {
-      Lt();
+      Ot();
     },
-    [s.current]
-  ), /* @__PURE__ */ E(
+    [l.current],
+    { immediate: !0 }
+  ), /* @__PURE__ */ h(
     Tt,
     {
-      ref: s,
+      ref: l,
       style: {
         overflowY: "auto",
         scrollSnapType: "y mandatory",
         overflowAnchor: "none",
-        ...f,
-        maxHeight: U
+        ...N,
+        maxHeight: M
       },
-      className: _,
-      onScroll: I ? lt : vt,
-      ...Rt,
-      children: I ? /* @__PURE__ */ Ft(Ct, { children: [
-        /* @__PURE__ */ E(
-          pt,
+      className: It,
+      onScroll: g ? nt : vt,
+      ...yt,
+      children: g ? /* @__PURE__ */ Ft(Ct, { children: [
+        /* @__PURE__ */ h(
+          at,
           {
-            height: q,
-            outerStyle: et,
-            innerStyle: rt,
+            height: V,
+            outerStyle: Q,
+            innerStyle: Z,
             offset: o.status === "MEASURE_DONE" ? o.startItemTop : 0,
-            children: /* @__PURE__ */ E(B, { children: G(
-              m.slice(o.startIndex, o.endIndex + 1),
+            children: /* @__PURE__ */ h(U, { children: D(
+              d.slice(o.startIndex, o.endIndex + 1),
               o.startIndex
             ) })
           }
         ),
-        At()
-      ] }) : Et ? /* @__PURE__ */ E(
-        pt,
+        Mt()
+      ] }) : Rt ? /* @__PURE__ */ h(
+        at,
         {
-          height: V,
-          outerStyle: et,
-          innerStyle: rt,
-          children: /* @__PURE__ */ E(B, { children: G(m, 0) })
+          height: O,
+          outerStyle: Q,
+          innerStyle: Z,
+          children: /* @__PURE__ */ h(U, { children: D(d, 0) })
         }
-      ) : /* @__PURE__ */ E(B, { children: G(m, 0) })
+      ) : /* @__PURE__ */ h(U, { children: D(d, 0) })
     }
   );
 });

package/virtual-list/constant.js

@@ -0,0 +1,7 @@
+/* 2025-11-27 12:11:12 */
+import { v4 as T } from "uuid";
+const I = 32, _ = T();
+export {
+  I as DEFAULT_VIRTUAL_ITEM_HEIGHT,
+  _ as KEY_VIRTUAL_ITEM_HEIGHT
+};

package/virtual-list/hook/useCacheChildrenNodes.js

@@ -0,0 +1,11 @@
+/* 2025-11-27 12:11:12 */
+import { useRef as c, useEffect as s } from "react";
+const n = (r) => {
+  const e = c({}), u = c(r);
+  return s(() => {
+    u.current = r;
+  }, [r]), r !== u.current && (e.current = {}), (o, t, f) => (Object.prototype.hasOwnProperty.call(e.current, t) || (e.current[t] = r(o, t, f)), e.current[t]);
+};
+export {
+  n as default
+};

package/virtual-list/hook/useComputeVirtualItemHeight.js

@@ -0,0 +1,19 @@
+/* 2025-11-27 12:11:12 */
+import { useEffect as f } from "react";
+import h from "@unicom-cloud/ui-common/hooks/use-force-update";
+import { KEY_VIRTUAL_ITEM_HEIGHT as r } from "../constant.js";
+const l = (n) => {
+  const c = h(), { current: e } = n;
+  f(() => {
+    Object.keys(e).length && !e[r] && (e[r] = Object.entries(e).reduce(
+      (s, [, u], m, t) => {
+        const o = s + u;
+        return m === t.length - 1 ? Math.round(o / t.length) : o;
+      },
+      0
+    ), c());
+  }, [Object.keys(e).length]);
+};
+export {
+  l as default
+};