ep-craft 0.1.8 → 0.1.9

package/dist/node_modules/element-plus/es/components/virtual-list/src/builders/build-grid.js

@@ -0,0 +1,304 @@
+import { useEventListener as Ot } from "../../../../../../@vueuse/core/dist/index.js";
+import { isNumber as b } from "../../../../utils/types.js";
+import { isString as K, hasOwn as It } from "../../../../../../@vue/shared/dist/shared.esm-bundler.js";
+import { getScrollBarWidth as $t } from "../../../../utils/dom/scroll.js";
+import { useNamespace as Ft } from "../../../../hooks/use-namespace/index.js";
+import { useCache as Gt } from "../hooks/use-cache.js";
+import { ITEM_RENDER_EVT as J, SCROLL_EVT as Q, FORWARD as Z, AUTO_ALIGNMENT as zt, RTL_OFFSET_POS_ASC as Nt, RTL_OFFSET_NAG as j, RTL_OFFSET_POS_DESC as Vt } from "../defaults.js";
+import { virtualizedGridProps as Ht } from "../props.js";
+import { getScrollDir as A, getRTLOffsetType as p, isRTL as tt } from "../utils.js";
+import et from "../components/scrollbar.js";
+import { useGridWheel as qt } from "../hooks/use-grid-wheel.js";
+import { useGridTouch as Bt } from "../hooks/use-grid-touch.js";
+import { defineComponent as Pt, getCurrentInstance as Ut, ref as M, computed as m, unref as r, onMounted as Xt, nextTick as F, resolveDynamicComponent as ot, h as E, mergeProps as Yt, Fragment as Kt } from "vue";
+import { isClient as Jt } from "../../../../../../@vueuse/shared/dist/index.js";
+const de = ({ name: lt, clearCache: _, getColumnPosition: G, getColumnStartIndexForOffset: rt, getColumnStopIndexForStartIndex: nt, getEstimatedTotalHeight: z, getEstimatedTotalWidth: N, getColumnOffset: ct, getRowOffset: at, getRowPosition: it, getRowStartIndexForOffset: st, getRowStopIndexForStartIndex: ht, initCache: dt, injectToInstance: W, validateProps: ut }) => Pt({
+  name: lt ?? "ElVirtualList",
+  props: Ht,
+  emits: [J, Q],
+  setup(t, { emit: V, expose: mt, slots: D }) {
+    const C = Ft("vl");
+    ut(t);
+    const k = Ut(), f = M(dt(t, k));
+    W == null || W(k, f);
+    const T = M(), H = M(), q = M(), B = M(), h = M({
+      isScrolling: !1,
+      scrollLeft: b(t.initScrollLeft) ? t.initScrollLeft : 0,
+      scrollTop: b(t.initScrollTop) ? t.initScrollTop : 0,
+      updateRequested: !1,
+      xAxisScrollDir: Z,
+      yAxisScrollDir: Z
+    }), O = Gt(), y = m(() => Number.parseInt(`${t.height}`, 10)), R = m(() => Number.parseInt(`${t.width}`, 10)), P = m(() => {
+      const { totalColumn: o, totalRow: e, columnCache: l } = t, { isScrolling: i, xAxisScrollDir: n, scrollLeft: c } = r(h);
+      if (o === 0 || e === 0) return [
+        0,
+        0,
+        0,
+        0
+      ];
+      const a = rt(t, c, r(f)), s = nt(t, a, c, r(f)), d = !i || n === "backward" ? Math.max(1, l) : 1, u = !i || n === "forward" ? Math.max(1, l) : 1;
+      return [
+        Math.max(0, a - d),
+        Math.max(0, Math.min(o - 1, s + u)),
+        a,
+        s
+      ];
+    }), U = m(() => {
+      const { totalColumn: o, totalRow: e, rowCache: l } = t, { isScrolling: i, yAxisScrollDir: n, scrollTop: c } = r(h);
+      if (o === 0 || e === 0) return [
+        0,
+        0,
+        0,
+        0
+      ];
+      const a = st(t, c, r(f)), s = ht(t, a, c, r(f)), d = !i || n === "backward" ? Math.max(1, l) : 1, u = !i || n === "forward" ? Math.max(1, l) : 1;
+      return [
+        Math.max(0, a - d),
+        Math.max(0, Math.min(e - 1, s + u)),
+        a,
+        s
+      ];
+    }), x = m(() => z(t, r(f))), g = m(() => N(t, r(f))), ft = m(() => [
+      {
+        position: "relative",
+        overflow: "hidden",
+        WebkitOverflowScrolling: "touch",
+        willChange: "transform"
+      },
+      {
+        direction: t.direction,
+        height: b(t.height) ? `${t.height}px` : t.height,
+        width: b(t.width) ? `${t.width}px` : t.width
+      },
+      t.style ?? {}
+    ]), St = m(() => {
+      const o = `${r(g)}px`;
+      return {
+        height: `${r(x)}px`,
+        pointerEvents: r(h).isScrolling ? "none" : void 0,
+        width: o,
+        margin: 0,
+        boxSizing: "border-box"
+      };
+    }), I = () => {
+      const { totalColumn: o, totalRow: e } = t;
+      if (o > 0 && e > 0) {
+        const [s, d, u, v] = r(P), [S, w, $, kt] = r(U);
+        V(J, {
+          columnCacheStart: s,
+          columnCacheEnd: d,
+          rowCacheStart: S,
+          rowCacheEnd: w,
+          columnVisibleStart: u,
+          columnVisibleEnd: v,
+          rowVisibleStart: $,
+          rowVisibleEnd: kt
+        });
+      }
+      const { scrollLeft: l, scrollTop: i, updateRequested: n, xAxisScrollDir: c, yAxisScrollDir: a } = r(h);
+      V(Q, {
+        xAxisScrollDir: c,
+        scrollLeft: l,
+        yAxisScrollDir: a,
+        scrollTop: i,
+        updateRequested: n
+      });
+    }, wt = (o) => {
+      const { clientHeight: e, clientWidth: l, scrollHeight: i, scrollLeft: n, scrollTop: c, scrollWidth: a } = o.currentTarget, s = r(h);
+      if (s.scrollTop === c && s.scrollLeft === n) return;
+      let d = n;
+      if (tt(t.direction)) switch (p()) {
+        case j:
+          d = -n;
+          break;
+        case Vt:
+          d = a - l - n;
+          break;
+      }
+      h.value = {
+        ...s,
+        isScrolling: !0,
+        scrollLeft: d,
+        scrollTop: Math.max(0, Math.min(c, i - e)),
+        updateRequested: !0,
+        xAxisScrollDir: A(s.scrollLeft, d),
+        yAxisScrollDir: A(s.scrollTop, c)
+      }, F(() => X()), Y(), I();
+    }, vt = (o, e) => {
+      const l = r(y), i = (x.value - l) / e * o;
+      L({ scrollTop: Math.min(x.value - l, i) });
+    }, xt = (o, e) => {
+      const l = r(R), i = (g.value - l) / e * o;
+      L({ scrollLeft: Math.min(g.value - l, i) });
+    }, { onWheel: gt } = qt({
+      atXStartEdge: m(() => h.value.scrollLeft <= 0),
+      atXEndEdge: m(() => h.value.scrollLeft >= g.value - r(R)),
+      atYStartEdge: m(() => h.value.scrollTop <= 0),
+      atYEndEdge: m(() => h.value.scrollTop >= x.value - r(y))
+    }, (o, e) => {
+      var n, c, a, s;
+      (c = (n = H.value) == null ? void 0 : n.onMouseUp) == null || c.call(n), (s = (a = q.value) == null ? void 0 : a.onMouseUp) == null || s.call(a);
+      const l = r(R), i = r(y);
+      L({
+        scrollLeft: Math.min(h.value.scrollLeft + o, g.value - l),
+        scrollTop: Math.min(h.value.scrollTop + e, x.value - i)
+      });
+    });
+    Ot(T, "wheel", gt, { passive: !1 });
+    const L = ({ scrollLeft: o = h.value.scrollLeft, scrollTop: e = h.value.scrollTop }) => {
+      o = Math.max(o, 0), e = Math.max(e, 0);
+      const l = r(h);
+      e === l.scrollTop && o === l.scrollLeft || (h.value = {
+        ...l,
+        xAxisScrollDir: A(l.scrollLeft, o),
+        yAxisScrollDir: A(l.scrollTop, e),
+        scrollLeft: o,
+        scrollTop: e,
+        updateRequested: !0
+      }, F(() => X()), Y(), I());
+    }, { touchStartX: Tt, touchStartY: Lt, handleTouchStart: bt, handleTouchMove: Mt } = Bt(T, h, L, g, x, R, y), Et = (o = 0, e = 0, l = zt) => {
+      const i = r(h);
+      e = Math.max(0, Math.min(e, t.totalColumn - 1)), o = Math.max(0, Math.min(o, t.totalRow - 1));
+      const n = $t(C.namespace.value), c = r(f), a = z(t, c), s = N(t, c);
+      L({
+        scrollLeft: ct(t, e, l, i.scrollLeft, c, s > t.width ? n : 0),
+        scrollTop: at(t, o, l, i.scrollTop, c, a > t.height ? n : 0)
+      });
+    }, yt = (o, e) => {
+      const { columnWidth: l, direction: i, rowHeight: n } = t, c = O.value(_ && l, _ && n, _ && i), a = `${o},${e}`;
+      if (It(c, a)) return c[a];
+      {
+        const [, s] = G(t, e, r(f)), d = r(f), u = tt(i), [v, S] = it(t, o, d), [w] = G(t, e, d);
+        return c[a] = {
+          position: "absolute",
+          left: u ? void 0 : `${s}px`,
+          right: u ? `${s}px` : void 0,
+          top: `${S}px`,
+          height: `${v}px`,
+          width: `${w}px`
+        }, c[a];
+      }
+    }, X = () => {
+      h.value.isScrolling = !1, F(() => {
+        O.value(-1, null, null);
+      });
+    };
+    Xt(() => {
+      if (!Jt) return;
+      const { initScrollLeft: o, initScrollTop: e } = t, l = r(T);
+      l && (b(o) && (l.scrollLeft = o), b(e) && (l.scrollTop = e)), I();
+    });
+    const Y = () => {
+      const { direction: o } = t, { scrollLeft: e, scrollTop: l, updateRequested: i } = r(h), n = r(T);
+      if (i && n) {
+        if (o === "rtl") switch (p()) {
+          case j:
+            n.scrollLeft = -e;
+            break;
+          case Nt:
+            n.scrollLeft = e;
+            break;
+          default: {
+            const { clientWidth: c, scrollWidth: a } = n;
+            n.scrollLeft = a - c - e;
+            break;
+          }
+        }
+        else n.scrollLeft = Math.max(0, e);
+        n.scrollTop = Math.max(0, l);
+      }
+    }, { resetAfterColumnIndex: Rt, resetAfterRowIndex: Ct, resetAfter: At } = k.proxy;
+    mt({
+      windowRef: T,
+      innerRef: B,
+      getItemStyleCache: O,
+      touchStartX: Tt,
+      touchStartY: Lt,
+      handleTouchStart: bt,
+      handleTouchMove: Mt,
+      scrollTo: L,
+      scrollToItem: Et,
+      states: h,
+      resetAfterColumnIndex: Rt,
+      resetAfterRowIndex: Ct,
+      resetAfter: At
+    });
+    const _t = () => {
+      const { scrollbarAlwaysOn: o, scrollbarStartGap: e, scrollbarEndGap: l, totalColumn: i, totalRow: n } = t, c = r(R), a = r(y), s = r(g), d = r(x), { scrollLeft: u, scrollTop: v } = r(h);
+      return {
+        horizontalScrollbar: E(et, {
+          ref: H,
+          alwaysOn: o,
+          startGap: e,
+          endGap: l,
+          class: C.e("horizontal"),
+          clientSize: c,
+          layout: "horizontal",
+          onScroll: xt,
+          ratio: c * 100 / s,
+          scrollFrom: u / (s - c),
+          total: n,
+          visible: !0
+        }),
+        verticalScrollbar: E(et, {
+          ref: q,
+          alwaysOn: o,
+          startGap: e,
+          endGap: l,
+          class: C.e("vertical"),
+          clientSize: a,
+          layout: "vertical",
+          onScroll: vt,
+          ratio: a * 100 / d,
+          scrollFrom: v / (d - a),
+          total: i,
+          visible: !0
+        })
+      };
+    }, Wt = () => {
+      var v;
+      const [o, e] = r(P), [l, i] = r(U), { data: n, totalColumn: c, totalRow: a, useIsScrolling: s, itemKey: d } = t, u = [];
+      if (a > 0 && c > 0) for (let S = l; S <= i; S++) for (let w = o; w <= e; w++) {
+        const $ = d({
+          columnIndex: w,
+          data: n,
+          rowIndex: S
+        });
+        u.push(E(Kt, { key: $ }, (v = D.default) == null ? void 0 : v.call(D, {
+          columnIndex: w,
+          data: n,
+          isScrolling: s ? r(h).isScrolling : void 0,
+          style: yt(S, w),
+          rowIndex: S
+        })));
+      }
+      return u;
+    }, Dt = () => {
+      const o = ot(t.innerElement), e = Wt();
+      return [E(o, Yt(t.innerProps, {
+        style: r(St),
+        ref: B
+      }), K(o) ? e : { default: () => e })];
+    };
+    return () => {
+      const o = ot(t.containerElement), { horizontalScrollbar: e, verticalScrollbar: l } = _t(), i = Dt();
+      return E("div", {
+        key: 0,
+        class: C.e("wrapper"),
+        role: t.role
+      }, [
+        E(o, {
+          class: t.className,
+          style: r(ft),
+          onScroll: wt,
+          ref: T
+        }, K(o) ? i : { default: () => i }),
+        e,
+        l
+      ]);
+    };
+  }
+});
+export {
+  de as default
+};

package/dist/node_modules/element-plus/es/components/virtual-list/src/builders/build-list.js

@@ -0,0 +1,254 @@
+import { useEventListener as Et } from "../../../../../../@vueuse/core/dist/index.js";
+import { isNumber as _ } from "../../../../utils/types.js";
+import { isString as Q, hasOwn as Ot } from "../../../../../../@vue/shared/dist/shared.esm-bundler.js";
+import { isGreaterThan as X } from "../../../../utils/numbers.js";
+import { useNamespace as Tt } from "../../../../hooks/use-namespace/index.js";
+import { useCache as yt } from "../hooks/use-cache.js";
+import { ITEM_RENDER_EVT as Y, SCROLL_EVT as Z, END_REACHED_EVT as B, FORWARD as Rt, RTL_OFFSET_POS_ASC as bt, RTL_OFFSET_NAG as tt, AUTO_ALIGNMENT as xt, RTL_OFFSET_POS_DESC as zt } from "../defaults.js";
+import Lt from "../hooks/use-wheel.js";
+import { virtualizedListProps as Mt } from "../props.js";
+import { isHorizontal as _t, getRTLOffsetType as et, getScrollDir as Ct } from "../utils.js";
+import kt from "../components/scrollbar.js";
+import { defineComponent as Dt, resolveDynamicComponent as lt, h as C, Fragment as It, mergeProps as Ft, getCurrentInstance as Nt, ref as k, computed as a, unref as s, onMounted as Wt, onUpdated as $t, onActivated as At, watch as Ht, nextTick as ot } from "vue";
+import { isClient as qt, clamp as Pt } from "../../../../../../@vueuse/shared/dist/index.js";
+const ee = ({ name: nt, getOffset: st, getItemSize: rt, getItemOffset: it, getEstimatedTotalSize: ct, getStartIndexForOffset: at, getStopIndexForStartIndex: ft, initCache: dt, clearCache: q, validateProps: ut }) => Dt({
+  name: nt ?? "ElVirtualList",
+  props: Mt,
+  emits: [
+    Y,
+    Z,
+    B
+  ],
+  setup(l, { emit: h, expose: P }) {
+    ut(l);
+    const R = Nt(), V = Tt("vl"), m = k(dt(l, R)), b = yt(), d = k(), D = k(), I = k(), i = k({
+      isScrolling: !1,
+      scrollDir: Rt,
+      scrollOffset: _(l.initScrollOffset) ? l.initScrollOffset : 0,
+      updateRequested: !1,
+      isScrollbarDragging: !1
+    }), x = a(() => {
+      const { total: t, cache: o } = l, { isScrolling: e, scrollDir: r, scrollOffset: n } = s(i);
+      if (t === 0) return [
+        0,
+        0,
+        0,
+        0
+      ];
+      const c = at(l, n, s(m)), u = ft(l, c, n, s(m)), T = !e || r === "backward" ? Math.max(1, o) : 1, y = !e || r === "forward" ? Math.max(1, o) : 1;
+      return [
+        Math.max(0, c - T),
+        Math.max(0, Math.min(t - 1, u + y)),
+        c,
+        u
+      ];
+    }), E = a(() => ct(l, s(m))), f = a(() => _t(l.layout)), G = a(() => [
+      {
+        position: "relative",
+        [`overflow-${f.value ? "x" : "y"}`]: "scroll",
+        WebkitOverflowScrolling: "touch",
+        willChange: "transform"
+      },
+      {
+        direction: l.direction,
+        height: _(l.height) ? `${l.height}px` : l.height,
+        width: _(l.width) ? `${l.width}px` : l.width
+      },
+      l.style
+    ]), F = a(() => {
+      const t = s(E), o = s(f), e = l.innerWidth;
+      return {
+        height: o ? "100%" : `${t}px`,
+        pointerEvents: s(i).isScrolling ? "none" : void 0,
+        width: o ? `${t}px` : e !== void 0 ? _(e) ? `${e}px` : e : "100%",
+        margin: 0,
+        boxSizing: "border-box"
+      };
+    }), N = a(() => f.value ? l.width : l.height), S = a(() => Math.max(0, E.value - N.value)), z = (t) => Pt(t, 0, S.value), W = 1, $ = (t) => ({
+      start: !X(t, 0, W),
+      end: !X(S.value, t, W)
+    }), A = a(() => z(i.value.scrollOffset)), v = a(() => $(A.value));
+    let g = v.value;
+    const { onWheel: L } = Lt({
+      atStartEdge: a(() => v.value.start),
+      atEndEdge: a(() => v.value.end),
+      layout: a(() => l.layout)
+    }, (t) => {
+      var o, e;
+      (e = (o = I.value).onMouseUp) == null || e.call(o), M(Math.min(i.value.scrollOffset + t, S.value));
+    });
+    Et(d, "wheel", L, { passive: !1 });
+    const H = () => {
+      const { total: t } = l;
+      if (t > 0) {
+        const [n, c, u, T] = s(x);
+        h(Y, n, c, u, T);
+      }
+      const { scrollDir: o, scrollOffset: e, updateRequested: r } = s(i);
+      h(Z, o, e, r);
+    }, U = (t, o) => {
+      const e = $(o), r = l.direction === "rtl" ? "left" : "right", n = l.direction === "rtl" ? "right" : "left";
+      t === "forward" && e.end && !g.end && h(B, f.value ? r : "bottom"), t === "backward" && e.start && !g.start && h(B, f.value ? n : "top"), g = e;
+    }, O = (t, { isScrolling: o, updateRequested: e }) => {
+      const r = s(i), n = Math.max(t, 0);
+      if (n === r.scrollOffset) return;
+      const c = Ct(r.scrollOffset, n);
+      i.value = {
+        ...r,
+        isScrolling: o,
+        scrollDir: c,
+        scrollOffset: n,
+        updateRequested: e
+      }, U(c, z(n)), ot(vt);
+    }, w = (t) => {
+      const { clientHeight: o, scrollHeight: e, scrollTop: r } = t.currentTarget;
+      s(i).scrollOffset !== r && O(Math.min(r, e - o), {
+        isScrolling: !0,
+        updateRequested: !1
+      });
+    }, ht = (t) => {
+      const { clientWidth: o, scrollLeft: e, scrollWidth: r } = t.currentTarget;
+      if (s(i).scrollOffset === e) return;
+      const { direction: n } = l;
+      let c = e;
+      if (n === "rtl") switch (et()) {
+        case tt:
+          c = -e;
+          break;
+        case zt:
+          c = r - o - e;
+          break;
+      }
+      O(Math.min(c, r - o), {
+        isScrolling: !0,
+        updateRequested: !1
+      });
+    }, mt = (t) => {
+      s(f) ? ht(t) : w(t), H();
+    }, St = (t, o) => {
+      const e = S.value / o * t;
+      M(Math.min(S.value, e));
+    }, M = (t) => {
+      O(t, {
+        isScrolling: s(i).isScrolling,
+        updateRequested: !0
+      });
+    }, j = (t, o = xt) => {
+      const { scrollOffset: e } = s(i);
+      t = Math.max(0, Math.min(t, l.total - 1)), M(st(l, t, o, e, s(m)));
+    }, gt = (t) => {
+      const { direction: o, itemSize: e, layout: r } = l, n = b.value(q && e, q && r, q && o);
+      let c;
+      if (Ot(n, String(t))) c = n[t];
+      else {
+        const u = it(l, t, s(m)), T = rt(l, t, s(m)), y = s(f), J = o === "rtl", K = y ? u : 0;
+        n[t] = c = {
+          position: "absolute",
+          left: J ? void 0 : `${K}px`,
+          right: J ? `${K}px` : void 0,
+          top: y ? 0 : `${u}px`,
+          height: y ? "100%" : `${T}px`,
+          width: y ? `${T}px` : "100%"
+        };
+      }
+      return c;
+    }, vt = () => {
+      i.value.isScrolling = !1, ot(() => {
+        b.value(-1, null, null);
+      });
+    }, p = () => {
+      const t = d.value;
+      t && (t.scrollTop = 0);
+    };
+    Wt(() => {
+      if (!qt) return;
+      const { initScrollOffset: t } = l, o = s(d);
+      _(t) && o && (s(f) ? o.scrollLeft = t : o.scrollTop = t), H();
+    }), $t(() => {
+      const { direction: t, layout: o } = l, { scrollOffset: e, updateRequested: r } = s(i), n = s(d);
+      if (r && n) if (o === "horizontal") if (t === "rtl") switch (et()) {
+        case tt:
+          n.scrollLeft = -e;
+          break;
+        case bt:
+          n.scrollLeft = e;
+          break;
+        default: {
+          const { clientWidth: c, scrollWidth: u } = n;
+          n.scrollLeft = u - c - e;
+          break;
+        }
+      }
+      else n.scrollLeft = e;
+      else n.scrollTop = e;
+    }), At(() => {
+      s(d).scrollTop = s(i).scrollOffset;
+    }), Ht(S, () => {
+      g = v.value;
+    });
+    const wt = {
+      ns: V,
+      clientSize: N,
+      estimatedTotalSize: E,
+      windowStyle: G,
+      windowRef: d,
+      innerRef: D,
+      innerStyle: F,
+      itemsToRender: x,
+      scrollbarRef: I,
+      states: i,
+      getItemStyle: gt,
+      onScroll: mt,
+      onScrollbarScroll: St,
+      onWheel: L,
+      scrollTo: M,
+      scrollToItem: j,
+      resetScrollTop: p
+    };
+    return P({
+      windowRef: d,
+      innerRef: D,
+      getItemStyleCache: b,
+      scrollTo: M,
+      scrollToItem: j,
+      resetScrollTop: p,
+      states: i
+    }), wt;
+  },
+  render(l) {
+    var O;
+    const { $slots: h, className: P, clientSize: R, containerElement: V, data: m, getItemStyle: b, innerElement: d, itemsToRender: D, innerStyle: I, layout: i, scrollbarAlwaysOn: x, total: E, onScroll: f, onScrollbarScroll: G, states: F, useIsScrolling: N, windowStyle: S, ns: z } = l, [W, $] = D, A = lt(V), v = lt(d), g = [];
+    if (E > 0) for (let w = W; w <= $; w++) g.push(C(It, { key: w }, (O = h.default) == null ? void 0 : O.call(h, {
+      data: m,
+      index: w,
+      isScrolling: N ? F.isScrolling : void 0,
+      style: b(w)
+    })));
+    const L = [C(v, Ft(l.innerProps, {
+      style: I,
+      ref: "innerRef"
+    }), Q(v) ? g : { default: () => g })], H = C(kt, {
+      ref: "scrollbarRef",
+      clientSize: R,
+      layout: i,
+      onScroll: G,
+      ratio: R * 100 / this.estimatedTotalSize,
+      scrollFrom: F.scrollOffset / (this.estimatedTotalSize - R),
+      total: E,
+      alwaysOn: x
+    }), U = C(A, {
+      class: [z.e("window"), P],
+      style: S,
+      onScroll: f,
+      ref: "windowRef",
+      key: 0
+    }, Q(A) ? [L] : { default: () => [L] });
+    return C("div", {
+      key: 0,
+      class: [z.e("wrapper"), x ? "always-on" : ""]
+    }, [U, H]);
+  }
+});
+export {
+  ee as default
+};

package/dist/node_modules/element-plus/es/components/virtual-list/src/components/dynamic-size-grid.js

@@ -0,0 +1,148 @@
+import { isNumber as E, isUndefined as R } from "../../../../utils/types.js";
+import { throwError as w } from "../../../../utils/error.js";
+import { AUTO_ALIGNMENT as z, CENTERED_ALIGNMENT as I, START_ALIGNMENT as x } from "../defaults.js";
+import N from "../builders/build-grid.js";
+import { isFunction as A } from "../../../../../../@vue/shared/dist/shared.esm-bundler.js";
+const { max: S, min: O, floor: M } = Math, T = "ElDynamicSizeGrid", G = {
+  column: "columnWidth",
+  row: "rowHeight"
+}, d = {
+  column: "lastVisitedColumnIndex",
+  row: "lastVisitedRowIndex"
+}, l = (t, s, e, n) => {
+  const [f, o, i] = [
+    e[n],
+    t[G[n]],
+    e[d[n]]
+  ];
+  if (s > i) {
+    let r = 0;
+    if (i >= 0) {
+      const m = f[i];
+      r = m.offset + m.size;
+    }
+    for (let m = i + 1; m <= s; m++) {
+      const u = o(m);
+      f[m] = {
+        offset: r,
+        size: u
+      }, r += u;
+    }
+    e[d[n]] = s;
+  }
+  return f[s];
+}, h = (t, s, e, n, f, o) => {
+  for (; e <= n; ) {
+    const i = e + M((n - e) / 2), r = l(t, i, s, o).offset;
+    if (r === f) return i;
+    r < f ? e = i + 1 : n = i - 1;
+  }
+  return S(0, e - 1);
+}, P = (t, s, e, n, f) => {
+  const o = f === "column" ? t.totalColumn : t.totalRow;
+  let i = 1;
+  for (; e < o && l(t, e, s, f).offset < n; )
+    e += i, i *= 2;
+  return h(t, s, M(e / 2), O(e, o - 1), n, f);
+}, _ = (t, s, e, n) => {
+  const [f, o] = [s[n], s[d[n]]];
+  return (o > 0 ? f[o].offset : 0) >= e ? h(t, s, 0, o, e, n) : P(t, s, S(0, o), e, n);
+}, v = ({ totalRow: t }, { estimatedRowHeight: s, lastVisitedRowIndex: e, row: n }) => {
+  let f = 0;
+  if (e >= t && (e = t - 1), e >= 0) {
+    const i = n[e];
+    f = i.offset + i.size;
+  }
+  const o = (t - e - 1) * s;
+  return f + o;
+}, g = ({ totalColumn: t }, { column: s, estimatedColumnWidth: e, lastVisitedColumnIndex: n }) => {
+  let f = 0;
+  if (n > t && (n = t - 1), n >= 0) {
+    const i = s[n];
+    f = i.offset + i.size;
+  }
+  const o = (t - n - 1) * e;
+  return f + o;
+}, D = {
+  column: g,
+  row: v
+}, C = (t, s, e, n, f, o, i) => {
+  const [r, m] = [o === "row" ? t.height : t.width, D[o]], u = l(t, s, f, o), a = S(0, O(m(t, f) - r, u.offset)), c = S(0, u.offset - r + i + u.size);
+  switch (e === "smart" && (n >= c - r && n <= a + r ? e = z : e = I), e) {
+    case x:
+      return a;
+    case "end":
+      return c;
+    case I:
+      return Math.round(c + (a - c) / 2);
+    case z:
+    default:
+      return n >= c && n <= a ? n : c > a || n < c ? c : a;
+  }
+}, Y = N({
+  name: "ElDynamicSizeGrid",
+  getColumnPosition: (t, s, e) => {
+    const n = l(t, s, e, "column");
+    return [n.size, n.offset];
+  },
+  getRowPosition: (t, s, e) => {
+    const n = l(t, s, e, "row");
+    return [n.size, n.offset];
+  },
+  getColumnOffset: (t, s, e, n, f, o) => C(t, s, e, n, f, "column", o),
+  getRowOffset: (t, s, e, n, f, o) => C(t, s, e, n, f, "row", o),
+  getColumnStartIndexForOffset: (t, s, e) => _(t, e, s, "column"),
+  getColumnStopIndexForStartIndex: (t, s, e, n) => {
+    const f = l(t, s, n, "column"), o = e + t.width;
+    let i = f.offset + f.size, r = s;
+    for (; r < t.totalColumn - 1 && i < o; )
+      r++, i += l(t, s, n, "column").size;
+    return r;
+  },
+  getEstimatedTotalHeight: v,
+  getEstimatedTotalWidth: g,
+  getRowStartIndexForOffset: (t, s, e) => _(t, e, s, "row"),
+  getRowStopIndexForStartIndex: (t, s, e, n) => {
+    const { totalRow: f, height: o } = t, i = l(t, s, n, "row"), r = e + o;
+    let m = i.size + i.offset, u = s;
+    for (; u < f - 1 && m < r; )
+      u++, m += l(t, u, n, "row").size;
+    return u;
+  },
+  injectToInstance: (t, s) => {
+    const e = ({ columnIndex: o, rowIndex: i }, r) => {
+      var m, u;
+      r = R(r) ? !0 : r, E(o) && (s.value.lastVisitedColumnIndex = Math.min(s.value.lastVisitedColumnIndex, o - 1)), E(i) && (s.value.lastVisitedRowIndex = Math.min(s.value.lastVisitedRowIndex, i - 1)), (m = t.exposed) == null || m.getItemStyleCache.value(-1, null, null), r && ((u = t.proxy) == null || u.$forceUpdate());
+    }, n = (o, i) => {
+      e({ columnIndex: o }, i);
+    }, f = (o, i) => {
+      e({ rowIndex: o }, i);
+    };
+    Object.assign(t.proxy, {
+      resetAfterColumnIndex: n,
+      resetAfterRowIndex: f,
+      resetAfter: e
+    });
+  },
+  initCache: ({ estimatedColumnWidth: t = 50, estimatedRowHeight: s = 50 }) => ({
+    column: {},
+    estimatedColumnWidth: t,
+    estimatedRowHeight: s,
+    lastVisitedColumnIndex: -1,
+    lastVisitedRowIndex: -1,
+    row: {}
+  }),
+  clearCache: !1,
+  validateProps: ({ columnWidth: t, rowHeight: s }) => {
+    A(t) || w(T, `
+          "columnWidth" must be passed as function,
+            instead ${typeof t} was given.
+        `), A(s) || w(T, `
+          "rowHeight" must be passed as function,
+            instead ${typeof s} was given.
+        `);
+  }
+});
+export {
+  Y as default
+};