@glhrmoura/vue-virtualize 0.1.0

package/dist/index.mjs

@@ -0,0 +1,974 @@
+import { shallowRef as xe, ref as L, toValue as l, watch as me, onBeforeUnmount as ge, computed as b, defineComponent as ee, openBlock as R, createBlock as j, resolveDynamicComponent as q, normalizeStyle as V, withCtx as Y, renderSlot as A, createElementBlock as C, Fragment as H, renderList as P, unref as B, mergeProps as te, createElementVNode as oe, toDisplayString as le, createTextVNode as pe } from "vue";
+function U(e) {
+  return !Number.isFinite(e) || e < 0 ? 0 : e;
+}
+class be {
+  sizes = /* @__PURE__ */ new Map();
+  divergent = !1;
+  get(t) {
+    return this.sizes.get(t);
+  }
+  set(t, i, n) {
+    this.sizes.set(t, i), n !== null && Math.abs(i - n) >= 0.5 && (this.divergent = !0);
+  }
+  get hasDivergent() {
+    return this.divergent;
+  }
+  clear() {
+    this.sizes.clear(), this.divergent = !1;
+  }
+  trim(t, i) {
+    let n = !1;
+    for (const r of this.sizes.keys())
+      r >= t && (this.sizes.delete(r), n = !0);
+    if (n && (this.divergent = !1, i !== null)) {
+      for (const r of this.sizes.values())
+        if (Math.abs(r - i) >= 0.5) {
+          this.divergent = !0;
+          return;
+        }
+    }
+  }
+}
+function ve(e, t, i) {
+  return Math.min(i, Math.max(t, e));
+}
+function Q(e, t, i) {
+  const n = Math.max(0, t - Math.max(0, i));
+  return ve(Number.isFinite(e) ? e : 0, 0, n);
+}
+function Ie(e, t, i) {
+  if (e <= 0) return 0;
+  let n = 0, r = e - 1, s = e - 1;
+  for (; n <= r; ) {
+    const f = n + r >>> 1;
+    i(f) > t ? (s = f, r = f - 1) : n = f + 1;
+  }
+  return s;
+}
+function Oe(e, t, i) {
+  if (e <= 0) return 0;
+  let n = 0, r = e - 1, s = 0;
+  for (; n <= r; ) {
+    const f = n + r >>> 1;
+    i(f) < t ? (s = f, n = f + 1) : r = f - 1;
+  }
+  return s;
+}
+function Re(e) {
+  const t = e.start + e.size;
+  let i = e.align;
+  if (i === "auto") {
+    const n = e.current + e.viewport;
+    if (e.start >= e.current && t <= n) return e.current;
+    i = e.start < e.current ? "start" : "end";
+  }
+  return i === "center" ? e.start - (e.viewport - e.size) / 2 : i === "end" ? t - e.viewport : e.start;
+}
+class Te {
+  count = 0;
+  estimateSize = () => 0;
+  overscan = 0;
+  gap = 0;
+  paddingStart = 0;
+  paddingEnd = 0;
+  lanes = 1;
+  itemSize = null;
+  viewportSize = 0;
+  scrollOffset = 0;
+  getItemKey = (t) => t;
+  measurements = new be();
+  built = 0;
+  offsets = [];
+  laneCursor = [];
+  laneEnd = [];
+  setOptions(t) {
+    const i = Math.max(1, Math.floor(t.lanes ?? 1)), n = t.gap ?? 0, r = t.paddingStart ?? 0, s = t.paddingEnd ?? 0, f = Math.max(0, Math.floor(t.count)), m = t.itemSize === void 0 || t.itemSize === null ? null : U(t.itemSize), y = this.itemSize, p = i !== this.lanes || n !== this.gap || r !== this.paddingStart || s !== this.paddingEnd || t.estimateSize !== this.estimateSize || m !== this.itemSize;
+    this.count = f, this.lanes = i, this.gap = n, this.paddingStart = r, this.paddingEnd = s, this.overscan = Math.max(0, Math.floor(t.overscan ?? 0)), this.estimateSize = t.estimateSize, this.itemSize = m, this.getItemKey = t.getItemKey ?? ((v) => v), t.viewportSize !== void 0 && (this.viewportSize = Math.max(0, t.viewportSize)), m !== y && this.measurements.clear(), this.measurements.trim(this.count, this.itemSize), (p || this.built > this.count) && this.resetGeometry();
+  }
+  setScrollOffset(t) {
+    this.scrollOffset = Number.isFinite(t) ? t : 0;
+  }
+  getScrollOffset() {
+    return this.scrollOffset;
+  }
+  getViewportSize() {
+    return this.viewportSize;
+  }
+  measure(t, i) {
+    if (t < 0 || t >= this.count) return !1;
+    const n = U(i), r = this.measurements.get(t);
+    if (r !== void 0 && Math.abs(r - n) < 0.5) return !1;
+    const s = this.getItemSize(t);
+    return this.measurements.set(t, n, this.itemSize), Math.abs(s - n) < 0.5 ? !1 : (this.resetGeometry(), !0);
+  }
+  clearMeasurements() {
+    this.measurements.clear(), this.resetGeometry();
+  }
+  getItemSize(t) {
+    const i = this.measurements.get(t);
+    return i !== void 0 ? i : this.itemSize !== null ? this.itemSize : U(this.estimateSize(t));
+  }
+  getItemOffset(t) {
+    if (t <= 0 || this.count <= 0) return this.paddingStart;
+    const i = Math.min(t, this.count - 1);
+    if (this.usesFixedPath()) {
+      const n = Math.floor(i / this.lanes);
+      return this.paddingStart + n * ((this.itemSize ?? 0) + this.gap);
+    }
+    return this.ensure(i), this.offsets[i] ?? this.paddingStart;
+  }
+  getTotalSize() {
+    if (this.count <= 0) return this.paddingStart + this.paddingEnd;
+    if (this.usesFixedPath()) {
+      let i = this.paddingStart;
+      const n = this.itemSize ?? 0;
+      for (let r = 0; r < this.lanes && r < this.count; r += 1) {
+        const s = this.laneLength(r), f = this.paddingStart + s * n + Math.max(0, s - 1) * this.gap;
+        f > i && (i = f);
+      }
+      return i + this.paddingEnd;
+    }
+    this.ensure(this.count - 1);
+    let t = this.paddingStart;
+    for (let i = 0; i < this.lanes && i < this.count; i += 1) {
+      const n = this.laneEnd[i] ?? this.paddingStart;
+      n > t && (t = n);
+    }
+    return t + this.paddingEnd;
+  }
+  getVirtualItems() {
+    if (this.count <= 0 || this.viewportSize <= 0) return [];
+    const t = Q(this.scrollOffset, this.getTotalSize(), this.viewportSize), i = t + this.viewportSize, n = [];
+    for (let r = 0; r < this.lanes; r += 1) {
+      const s = this.laneLength(r);
+      if (s <= 0) continue;
+      const f = Ie(s, t, (v) => {
+        const w = this.ordinalIndex(r, v);
+        return this.getItemOffset(w) + this.getItemSize(w);
+      }), m = Oe(
+        s,
+        i,
+        (v) => this.getItemOffset(this.ordinalIndex(r, v))
+      ), y = Math.max(0, Math.min(f, m) - this.overscan), p = Math.min(s - 1, Math.max(f, m) + this.overscan);
+      for (let v = y; v <= p; v += 1) {
+        const w = this.ordinalIndex(r, v), E = this.getItemOffset(w), k = this.getItemSize(w);
+        n.push({
+          index: w,
+          key: this.getItemKey(w),
+          start: E,
+          size: k,
+          end: E + k,
+          lane: r
+        });
+      }
+    }
+    return n.sort((r, s) => r.index - s.index), n;
+  }
+  getOffsetForIndex(t, i = "auto") {
+    if (this.count <= 0) return 0;
+    const n = ve(t, 0, this.count - 1), r = this.getItemOffset(n), s = this.getItemSize(n), f = Re({
+      start: r,
+      size: s,
+      viewport: this.viewportSize,
+      current: this.scrollOffset,
+      align: i
+    });
+    return Q(f, this.getTotalSize(), this.viewportSize);
+  }
+  usesFixedPath() {
+    return this.itemSize !== null && !this.measurements.hasDivergent;
+  }
+  ordinalIndex(t, i) {
+    return t + i * this.lanes;
+  }
+  laneLength(t) {
+    return t < 0 || t >= this.lanes || t >= this.count ? 0 : Math.floor((this.count - t - 1) / this.lanes) + 1;
+  }
+  ensure(t) {
+    if (t < this.built) return;
+    const i = Math.min(t, this.count - 1);
+    for (; this.built <= i; ) {
+      const n = this.built % this.lanes, r = this.laneCursor[n] ?? this.paddingStart;
+      this.offsets[this.built] = r;
+      const s = r + this.getItemSize(this.built);
+      this.laneEnd[n] = s, this.laneCursor[n] = s + this.gap, this.built += 1;
+    }
+  }
+  resetGeometry() {
+    this.built = 0, this.offsets = [], this.laneCursor = Array.from({ length: this.lanes }, () => this.paddingStart), this.laneEnd = Array.from({ length: this.lanes }, () => this.paddingStart);
+  }
+}
+function W() {
+  return typeof window < "u" && typeof document < "u";
+}
+function Se(e) {
+  return typeof Element > "u" ? null : e instanceof Element ? e : null;
+}
+function X(e, t, i, n) {
+  if (n === "smooth" && typeof e.scrollTo == "function") {
+    e.scrollTo({
+      top: i ? e.scrollTop : t,
+      left: i ? t : e.scrollLeft,
+      behavior: n
+    });
+    return;
+  }
+  i ? e.scrollLeft = t : e.scrollTop = t;
+}
+function J(e, t) {
+  return t ? e.scrollLeft : e.scrollTop;
+}
+function ue(e, t) {
+  return t ? e.clientWidth : e.clientHeight;
+}
+function ce(e) {
+  return typeof requestAnimationFrame == "function" ? requestAnimationFrame(e) : setTimeout(e, 0);
+}
+function fe(e) {
+  e && (typeof cancelAnimationFrame == "function" ? cancelAnimationFrame(e) : clearTimeout(e));
+}
+function Ee(e, t) {
+  if (e.length !== t.length) return !1;
+  for (let i = 0; i < e.length; i += 1) {
+    const n = e[i], r = t[i];
+    if (!n || !r || n.index !== r.index || n.start !== r.start || n.size !== r.size || n.end !== r.end || n.lane !== r.lane || n.key !== r.key)
+      return !1;
+  }
+  return !0;
+}
+function Z(e) {
+  const t = new Te(), i = xe([]), n = L(0), r = L(0), s = L(!1), f = (c) => e.estimateSize(c);
+  let m = null, y = null, p = null, v = 0, w = 0, E = 0, k = l(e.revision);
+  const o = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Map(), a = [];
+  function d() {
+    const c = l(e.container);
+    return typeof HTMLElement > "u" ? null : c instanceof HTMLElement ? c : null;
+  }
+  function S() {
+    return l(e.horizontal) ?? !1;
+  }
+  function K() {
+    const c = l(e.initialRect);
+    return c ? S() ? c.width : c.height : 0;
+  }
+  function M() {
+    const c = l(e.revision);
+    Object.is(c, k) || (k = c, t.clearMeasurements());
+    const z = d(), x = z ? ue(z, S()) : 0, O = l(e.viewportInset) ?? 0, T = Math.max(0, (x > 0 ? x : K()) - O), F = l(e.itemSize);
+    t.setOptions({
+      count: l(e.count),
+      estimateSize: f,
+      overscan: l(e.overscan) ?? 5,
+      gap: l(e.gap) ?? 0,
+      paddingStart: l(e.paddingStart) ?? 0,
+      paddingEnd: l(e.paddingEnd) ?? 0,
+      lanes: l(e.lanes) ?? 1,
+      itemSize: F ?? null,
+      getItemKey: e.getItemKey,
+      viewportSize: T
+    });
+    const G = Math.max(0, t.getTotalSize() - T);
+    t.getScrollOffset() > G && (t.setScrollOffset(G), z && J(z, S()) !== G && X(z, G, S(), "auto"));
+    const re = t.getVirtualItems();
+    Ee(i.value, re) || (i.value = re);
+    const se = t.getTotalSize();
+    n.value !== se && (n.value = se);
+    const ae = t.getScrollOffset();
+    r.value !== ae && (r.value = ae);
+  }
+  function _() {
+    if (!W()) {
+      M();
+      return;
+    }
+    v || (v = ce(() => {
+      v = 0, s.value = !0, M(), typeof window < "u" && (window.clearTimeout(E), E = window.setTimeout(() => {
+        s.value = !1;
+      }, 150));
+    }));
+  }
+  function h() {
+    const c = d();
+    c && (t.setScrollOffset(J(c, S())), _());
+  }
+  function I() {
+    const c = d();
+    if (c === m || (m && (m.removeEventListener("scroll", h), y?.disconnect(), y = null), m = c, !c || !W())) return;
+    const z = S();
+    t.getScrollOffset() > 0 ? X(c, t.getScrollOffset(), z, "auto") : t.setScrollOffset(J(c, z)), c.addEventListener("scroll", h, { passive: !0 }), typeof ResizeObserver < "u" && (y = new ResizeObserver(() => M()), y.observe(c));
+  }
+  function g() {
+    return !W() || typeof ResizeObserver > "u" ? null : (p || (p = new ResizeObserver((c) => {
+      const z = S();
+      let x = !1;
+      for (const O of c) {
+        const T = o.get(O.target);
+        if (T === void 0) continue;
+        const F = O.borderBoxSize?.[0], G = z ? F?.inlineSize ?? O.contentRect.width : F?.blockSize ?? O.contentRect.height;
+        G > 0 && t.measure(T, G) && (x = !0);
+      }
+      x && M();
+    })), p);
+  }
+  function $() {
+    w = 0;
+    const c = a.splice(0, a.length), z = S();
+    let x = !1;
+    for (const O of c) {
+      if (!O.element.isConnected) continue;
+      const T = O.element.getBoundingClientRect(), F = z ? T.width : T.height;
+      F > 0 && t.measure(O.index, F) && (x = !0);
+    }
+    x && M();
+  }
+  function D(c, z) {
+    const x = Se(c), O = g(), T = u.get(z);
+    T && T !== x && (O?.unobserve(T), o.delete(T), u.delete(z)), x && (u.set(z, x), o.set(x, z), O?.observe(x), a.push({ element: x, index: z }), !w && (w = ce($)));
+  }
+  function ne(c, z = "auto") {
+    const x = d(), O = x ? ue(x, S()) : 0, T = O > 0 ? O : t.getViewportSize(), F = Q(c, t.getTotalSize(), T);
+    t.setScrollOffset(F), x && X(x, F, S(), z), M();
+  }
+  function ye(c, z) {
+    const x = t.getOffsetForIndex(c, z?.align ?? "auto");
+    ne(x, z?.behavior ?? "auto");
+  }
+  function we(c, z) {
+    t.measure(c, z) && M();
+  }
+  return M(), me(
+    () => [
+      l(e.count),
+      l(e.overscan),
+      l(e.gap),
+      l(e.paddingStart),
+      l(e.paddingEnd),
+      l(e.lanes),
+      l(e.horizontal),
+      l(e.itemSize),
+      l(e.viewportInset),
+      l(e.revision),
+      l(e.container),
+      l(e.initialRect)?.width,
+      l(e.initialRect)?.height
+    ],
+    () => {
+      I(), M();
+    },
+    { flush: "post" }
+  ), ge(() => {
+    m && m.removeEventListener("scroll", h), y?.disconnect(), p?.disconnect(), fe(v), fe(w), typeof window < "u" && window.clearTimeout(E), o.clear(), u.clear(), a.length = 0;
+  }), {
+    virtualItems: b(() => i.value),
+    totalSize: b(() => n.value),
+    scrollOffset: b(() => r.value),
+    isScrolling: b(() => s.value),
+    scrollToIndex: ye,
+    scrollToOffset: ne,
+    measure: we,
+    measureElement: D
+  };
+}
+function Me(e, t, i) {
+  return typeof e == "function" ? e(t, i) : typeof e == "number" ? e : 48;
+}
+function ze(e) {
+  const t = Z({
+    count: () => l(e.items).length,
+    estimateSize: (n) => {
+      const r = l(e.items);
+      return Me(e.estimateSize, n, r[n]);
+    },
+    getItemKey: (n) => {
+      const s = l(e.items)[n];
+      return e.getItemKey?.(s, n) ?? n;
+    },
+    itemSize: () => e.itemSize !== void 0 ? l(e.itemSize) : typeof e.estimateSize == "number" ? e.estimateSize : void 0,
+    container: e.container,
+    horizontal: e.horizontal,
+    overscan: e.overscan,
+    gap: e.gap,
+    paddingStart: e.paddingStart,
+    paddingEnd: e.paddingEnd,
+    initialRect: e.initialRect,
+    viewportInset: e.viewportInset,
+    revision: e.revision
+  });
+  return {
+    virtualItems: b(() => {
+      const n = l(e.items);
+      return t.virtualItems.value.map((r) => {
+        const s = n[r.index];
+        return {
+          ...r,
+          item: s,
+          key: e.getItemKey?.(s, r.index) ?? r.key
+        };
+      });
+    }),
+    totalSize: t.totalSize,
+    scrollOffset: t.scrollOffset,
+    isScrolling: t.isScrolling,
+    scrollToIndex: t.scrollToIndex,
+    scrollToOffset: t.scrollToOffset,
+    measure: t.measure,
+    measureElement: t.measureElement
+  };
+}
+function de(e, t, i) {
+  return typeof e == "function" ? e(t) : typeof e == "number" ? e : i;
+}
+function ke(e) {
+  const t = b(() => Math.max(1, Math.floor(l(e.columnCount) || 1))), i = b(() => Math.ceil(l(e.items).length / t.value)), n = /* @__PURE__ */ new Map(), r = Z({
+    count: () => i.value,
+    estimateSize: (o) => de(l(e.estimateRowSize), o, 48),
+    itemSize: () => {
+      const o = l(e.estimateRowSize);
+      return typeof o == "number" ? o : void 0;
+    },
+    overscan: () => l(e.overscanRows) ?? l(e.overscan) ?? 2,
+    gap: () => l(e.rowGap) ?? 0,
+    horizontal: !1,
+    container: e.container,
+    initialRect: e.initialRect,
+    revision: e.revision
+  }), s = Z({
+    count: () => t.value,
+    estimateSize: (o) => de(l(e.estimateColumnSize), o, 160),
+    itemSize: () => {
+      const o = l(e.estimateColumnSize);
+      return typeof o == "number" ? o : void 0;
+    },
+    overscan: () => l(e.overscanColumns) ?? l(e.overscan) ?? 1,
+    gap: () => l(e.columnGap) ?? 0,
+    horizontal: !0,
+    container: e.container,
+    initialRect: e.initialRect,
+    revision: e.revision
+  }), f = b(() => {
+    const o = l(e.items), u = t.value, a = [];
+    for (const d of r.virtualItems.value)
+      for (const S of s.virtualItems.value) {
+        const K = d.index * u + S.index;
+        if (K >= o.length) continue;
+        const M = o[K];
+        a.push({
+          index: K,
+          key: e.getItemKey?.(M, K) ?? K,
+          item: M,
+          row: d,
+          column: S
+        });
+      }
+    return a;
+  });
+  function m(o, u) {
+    const a = l(e.items);
+    if (!a.length) return;
+    const d = Math.min(Math.max(o, 0), a.length - 1), S = t.value;
+    r.scrollToIndex(Math.floor(d / S), u), s.scrollToIndex(d % S, u);
+  }
+  function y(o, u = "auto") {
+    o.top !== void 0 && r.scrollToOffset(o.top, u), o.left !== void 0 && s.scrollToOffset(o.left, u);
+  }
+  function p(o, u) {
+    const a = Math.max(n.get(o) ?? 0, u);
+    a <= 0 || a === n.get(o) || (n.set(o, a), r.measure(o, a));
+  }
+  let v = null;
+  const w = /* @__PURE__ */ new Map();
+  function E() {
+    return !W() || typeof ResizeObserver > "u" ? null : (v || (v = new ResizeObserver((o) => {
+      for (const u of o) {
+        const a = w.get(u.target);
+        if (a === void 0) continue;
+        const S = u.borderBoxSize?.[0]?.blockSize ?? u.contentRect.height;
+        S > 0 && p(a, S);
+      }
+    })), v);
+  }
+  function k(o, u) {
+    const a = Se(o), d = E();
+    if (!a) return;
+    w.set(a, u), d?.observe(a);
+    const S = a.getBoundingClientRect().height;
+    S > 0 && p(u, S);
+  }
+  return ge(() => {
+    v?.disconnect(), w.clear();
+  }), {
+    virtualRows: r.virtualItems,
+    virtualColumns: s.virtualItems,
+    virtualCells: f,
+    totalHeight: r.totalSize,
+    totalWidth: s.totalSize,
+    scrollToIndex: m,
+    scrollToOffset: y,
+    measureRow: p,
+    measureRowElement: k,
+    measureColumn: s.measure
+  };
+}
+function Ce(e) {
+  const t = ze({
+    items: e.rows,
+    estimateSize: e.estimateRowSize,
+    container: e.container,
+    overscan: e.overscan,
+    getItemKey: e.getRowKey,
+    initialRect: e.initialRect,
+    viewportInset: e.viewportInset,
+    revision: e.revision,
+    itemSize: e.itemSize
+  }), i = b(() => {
+    const s = l(e.columns);
+    let f = 0;
+    return s.map((m) => {
+      const y = m.width ?? m.minWidth ?? 160, p = {
+        ...m,
+        start: f,
+        size: y,
+        end: f + y
+      };
+      return f += y, p;
+    });
+  }), n = b(() => {
+    const s = i.value;
+    return s.length ? s[s.length - 1]?.end ?? 0 : 0;
+  });
+  return {
+    virtualRows: b(() => t.virtualItems.value),
+    columns: i,
+    totalHeight: t.totalSize,
+    totalWidth: n,
+    scrollOffset: t.scrollOffset,
+    isScrolling: t.isScrolling,
+    scrollToIndex: t.scrollToIndex,
+    scrollToOffset: t.scrollToOffset,
+    measure: t.measure,
+    measureElement: t.measureElement
+  };
+}
+function he(e) {
+  if (typeof e == "number" && Number.isFinite(e)) return `${e}px`;
+  if (typeof e == "string" && e.trim()) return e;
+}
+function N(e) {
+  if (typeof e == "number" && Number.isFinite(e)) return e;
+  if (typeof e != "string") return 0;
+  const t = /^(-?\d+(?:\.\d+)?)px$/.exec(e.trim());
+  if (!t?.[1]) return 0;
+  const i = Number(t[1]);
+  return Number.isFinite(i) ? i : 0;
+}
+function ie(e) {
+  return {
+    overflow: "auto",
+    position: "relative",
+    height: he(e.height) ?? (e.horizontal ? "100%" : void 0),
+    width: he(e.width) ?? (e.horizontal ? void 0 : "100%"),
+    overflowAnchor: "none"
+  };
+}
+function $e(e, t) {
+  return {
+    position: "relative",
+    width: t ? `${e}px` : "100%",
+    height: t ? "100%" : `${e}px`
+  };
+}
+function Fe(e, t) {
+  return {
+    position: "absolute",
+    top: 0,
+    left: 0,
+    width: t ? void 0 : "100%",
+    height: t ? "100%" : void 0,
+    transform: t ? `translateX(${e}px)` : `translateY(${e}px)`
+  };
+}
+const Ae = /* @__PURE__ */ ee({
+  __name: "VirtualList",
+  props: {
+    items: {},
+    estimateSize: { type: [Number, Function], default: 48 },
+    height: {},
+    width: {},
+    horizontal: { type: Boolean, default: !1 },
+    overscan: { default: 5 },
+    gap: { default: 0 },
+    paddingStart: { default: 0 },
+    paddingEnd: { default: 0 },
+    getItemKey: {},
+    tag: { default: "div" },
+    itemTag: { default: "div" },
+    itemAttrs: {},
+    revision: {}
+  },
+  setup(e, { expose: t }) {
+    const i = e, n = L(null), { virtualItems: r, totalSize: s, scrollToIndex: f, scrollToOffset: m, measure: y, measureElement: p } = ze({
+      items: () => i.items,
+      estimateSize: (o, u) => {
+        const a = i.estimateSize;
+        return typeof a == "number" ? a : a(o, u);
+      },
+      itemSize: () => typeof i.estimateSize == "number" ? i.estimateSize : void 0,
+      container: n,
+      horizontal: () => i.horizontal,
+      overscan: () => i.overscan,
+      gap: () => i.gap,
+      paddingStart: () => i.paddingStart,
+      paddingEnd: () => i.paddingEnd,
+      getItemKey: (o, u) => i.getItemKey?.(o, u) ?? u,
+      initialRect: () => ({
+        width: N(i.width),
+        height: N(i.height)
+      }),
+      revision: () => i.revision
+    }), v = b(
+      () => ie({
+        height: i.height,
+        width: i.width,
+        horizontal: i.horizontal
+      })
+    ), w = b(() => $e(s.value, i.horizontal));
+    function E(o) {
+      return Fe(o, i.horizontal);
+    }
+    function k(o) {
+      return (u) => {
+        p(u, o);
+      };
+    }
+    return t({
+      scrollToIndex: f,
+      scrollToOffset: m,
+      measure: y
+    }), (o, u) => (R(), j(q(e.tag), {
+      ref_key: "container",
+      ref: n,
+      "data-virtual-container": "",
+      role: "list",
+      style: V(v.value)
+    }, {
+      default: Y(() => [
+        e.items.length ? (R(), C("div", {
+          key: 1,
+          "data-virtual-spacer": "",
+          style: V(w.value)
+        }, [
+          (R(!0), C(H, null, P(B(r), (a) => (R(), j(q(e.itemTag), te({
+            key: a.key,
+            ref_for: !0,
+            ref: k(a.index),
+            role: "listitem",
+            "data-index": a.index,
+            "data-key": String(a.key),
+            "aria-setsize": e.items.length,
+            "aria-posinset": a.index + 1,
+            style: E(a.start)
+          }, { ref_for: !0 }, e.itemAttrs), {
+            default: Y(() => [
+              A(o.$slots, "default", {
+                item: a.item,
+                index: a.index,
+                start: a.start,
+                size: a.size,
+                end: a.end
+              })
+            ]),
+            _: 2
+          }, 1040, ["data-index", "data-key", "aria-setsize", "aria-posinset", "style"]))), 128))
+        ], 4)) : A(o.$slots, "empty", {}, void 0, void 0, 0)
+      ]),
+      _: 3
+    }, 8, ["style"]));
+  }
+}), Ve = ["data-index", "data-key"], Be = /* @__PURE__ */ ee({
+  __name: "VirtualGrid",
+  props: {
+    items: {},
+    columnCount: { default: 1 },
+    estimateRowSize: { type: [Number, Function], default: 48 },
+    estimateColumnSize: { type: [Number, Function], default: 160 },
+    height: {},
+    width: {},
+    overscan: { default: 2 },
+    overscanRows: {},
+    overscanColumns: {},
+    rowGap: { default: 0 },
+    columnGap: { default: 0 },
+    getItemKey: {},
+    tag: { default: "div" },
+    itemAttrs: {},
+    revision: {}
+  },
+  setup(e, { expose: t }) {
+    const i = e, n = L(null), {
+      virtualCells: r,
+      totalWidth: s,
+      totalHeight: f,
+      scrollToIndex: m,
+      scrollToOffset: y,
+      measureRow: p,
+      measureRowElement: v
+    } = ke({
+      items: () => i.items,
+      columnCount: () => i.columnCount,
+      estimateRowSize: () => i.estimateRowSize,
+      estimateColumnSize: () => i.estimateColumnSize,
+      container: n,
+      overscan: () => i.overscan,
+      overscanRows: () => i.overscanRows,
+      overscanColumns: () => i.overscanColumns,
+      rowGap: () => i.rowGap,
+      columnGap: () => i.columnGap,
+      getItemKey: (u, a) => i.getItemKey?.(u, a) ?? a,
+      initialRect: () => ({
+        width: N(i.width),
+        height: N(i.height)
+      }),
+      revision: () => i.revision
+    }), w = b(
+      () => ie({
+        height: i.height,
+        width: i.width,
+        horizontal: !1
+      })
+    ), E = b(() => ({
+      position: "relative",
+      width: `${s.value}px`,
+      height: `${f.value}px`
+    }));
+    function k(u) {
+      return (a) => {
+        v(a, u);
+      };
+    }
+    function o(u, a, d) {
+      return {
+        position: "absolute",
+        top: 0,
+        left: 0,
+        width: `${a}px`,
+        transform: `translate(${u}px, ${d}px)`
+      };
+    }
+    return t({
+      scrollToIndex: m,
+      scrollToOffset: y,
+      measureRow: p
+    }), (u, a) => (R(), j(q(e.tag), {
+      ref_key: "container",
+      ref: n,
+      "data-virtual-container": "",
+      role: "grid",
+      style: V(w.value)
+    }, {
+      default: Y(() => [
+        e.items.length ? (R(), C("div", {
+          key: 1,
+          "data-virtual-spacer": "",
+          style: V(E.value)
+        }, [
+          (R(!0), C(H, null, P(B(r), (d) => (R(), C("div", te({
+            key: d.key,
+            ref_for: !0,
+            ref: k(d.row.index),
+            role: "gridcell",
+            "data-index": d.index,
+            "data-key": String(d.key),
+            style: o(d.column.start, d.column.size, d.row.start)
+          }, { ref_for: !0 }, e.itemAttrs), [
+            A(u.$slots, "default", {
+              item: d.item,
+              index: d.index,
+              rowIndex: d.row.index,
+              columnIndex: d.column.index,
+              row: d.row,
+              column: d.column
+            })
+          ], 16, Ve))), 128))
+        ], 4)) : A(u.$slots, "empty", {}, void 0, void 0, 0)
+      ]),
+      _: 3
+    }, 8, ["style"]));
+  }
+}), Ke = ["data-index", "data-key", "aria-rowindex"], Ne = /* @__PURE__ */ ee({
+  __name: "VirtualTable",
+  props: {
+    rows: {},
+    columns: {},
+    estimateRowSize: { type: [Number, Function], default: 44 },
+    height: {},
+    width: {},
+    overscan: { default: 5 },
+    getRowKey: {},
+    stickyHeader: { type: Boolean, default: !0 },
+    tag: { default: "div" },
+    rowAttrs: {},
+    revision: {}
+  },
+  setup(e, { expose: t }) {
+    const i = e, n = L(null), r = L(null), s = L(0), {
+      virtualRows: f,
+      columns: m,
+      totalWidth: y,
+      totalHeight: p,
+      scrollToIndex: v,
+      scrollToOffset: w,
+      measure: E,
+      measureElement: k
+    } = Ce({
+      rows: () => i.rows,
+      columns: () => i.columns,
+      estimateRowSize: (h, I) => {
+        const g = i.estimateRowSize;
+        return typeof g == "number" ? g : g(h, I);
+      },
+      container: n,
+      overscan: () => i.overscan,
+      getRowKey: (h, I) => i.getRowKey?.(h, I) ?? I,
+      initialRect: () => ({
+        width: N(i.width),
+        height: N(i.height)
+      }),
+      viewportInset: s,
+      revision: () => i.revision,
+      itemSize: () => typeof i.estimateRowSize == "number" ? i.estimateRowSize : void 0
+    });
+    me(r, (h, I, g) => {
+      if (I === h && !h || !h || !W() || typeof ResizeObserver > "u") return;
+      const $ = () => {
+        s.value = h.getBoundingClientRect().height;
+      }, D = new ResizeObserver($);
+      D.observe(h), $(), g(() => D.disconnect());
+    });
+    const o = b(
+      () => ie({
+        height: i.height,
+        width: i.width,
+        horizontal: !1
+      })
+    ), u = b(() => ({
+      minWidth: `${y.value}px`
+    })), a = b(() => ({
+      position: i.stickyHeader ? "sticky" : "relative",
+      top: i.stickyHeader ? "0px" : void 0,
+      zIndex: 1,
+      display: "flex",
+      width: `${y.value}px`
+    })), d = b(() => ({
+      position: "relative",
+      height: `${p.value}px`,
+      width: `${y.value}px`
+    }));
+    function S(h) {
+      return {
+        width: `${h.size}px`,
+        minWidth: `${h.size}px`,
+        flex: "0 0 auto",
+        textAlign: h.align ?? "left"
+      };
+    }
+    function K(h) {
+      return {
+        position: "absolute",
+        top: 0,
+        left: 0,
+        width: "100%",
+        display: "flex",
+        transform: `translateY(${h}px)`
+      };
+    }
+    function M(h) {
+      return (I) => {
+        k(I, h);
+      };
+    }
+    function _(h, I, g) {
+      return I.accessor ? I.accessor(h, g) : h && typeof h == "object" && I.id in h ? h[I.id] : "";
+    }
+    return t({
+      scrollToIndex: v,
+      scrollToOffset: w,
+      measure: E
+    }), (h, I) => (R(), j(q(e.tag), {
+      ref_key: "container",
+      ref: n,
+      "data-virtual-container": "",
+      role: "table",
+      style: V(o.value)
+    }, {
+      default: Y(() => [
+        oe("div", {
+          style: V(u.value)
+        }, [
+          oe("div", {
+            ref_key: "header",
+            ref: r,
+            role: "row",
+            style: V(a.value)
+          }, [
+            A(h.$slots, "header", { columns: B(m) }, () => [
+              (R(!0), C(H, null, P(B(m), (g) => (R(), C("div", {
+                key: g.id,
+                role: "columnheader",
+                style: V(S(g))
+              }, le(g.header), 5))), 128))
+            ])
+          ], 4),
+          e.rows.length ? (R(), C("div", {
+            key: 1,
+            "data-virtual-spacer": "",
+            role: "rowgroup",
+            style: V(d.value)
+          }, [
+            (R(!0), C(H, null, P(B(f), (g) => (R(), C("div", te({
+              key: g.key,
+              ref_for: !0,
+              ref: M(g.index),
+              role: "row",
+              "data-index": g.index,
+              "data-key": String(g.key),
+              "aria-rowindex": g.index + 1,
+              style: K(g.start)
+            }, { ref_for: !0 }, e.rowAttrs), [
+              (R(!0), C(H, null, P(B(m), ($) => (R(), C("div", {
+                key: $.id,
+                role: "cell",
+                style: V(S($))
+              }, [
+                A(h.$slots, "cell", {
+                  row: g.item,
+                  column: $,
+                  rowIndex: g.index,
+                  value: _(g.item, $, g.index)
+                }, () => [
+                  pe(le(_(g.item, $, g.index)), 1)
+                ])
+              ], 4))), 128))
+            ], 16, Ke))), 128))
+          ], 4)) : A(h.$slots, "empty", {}, void 0, void 0, 0)
+        ], 4)
+      ]),
+      _: 3
+    }, 8, ["style"]));
+  }
+});
+export {
+  be as MeasurementCache,
+  Be as VirtualGrid,
+  Ae as VirtualList,
+  Ne as VirtualTable,
+  Te as Virtualizer,
+  Q as clampScrollOffset,
+  U as normalizeSize,
+  Re as resolveScrollOffset,
+  ke as useVirtualGrid,
+  ze as useVirtualList,
+  Ce as useVirtualTable,
+  Z as useVirtualizer
+};
+//# sourceMappingURL=index.mjs.map