@indielayer/ui 1.18.1 → 2.0.0

package/lib/virtual/components/virtualList/VirtualList.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,139 @@
+import { useVirtualizer as e } from "../../core/useVirtualizer.js";
+import { isDynamicRowHeight as t } from "./isDynamicRowHeight.js";
+import { DATA_ATTRIBUTE_LIST_INDEX as n } from "./useDynamicRowHeight.js";
+import { Fragment as r, computed as i, createBlock as a, createElementBlock as o, createElementVNode as s, defineComponent as c, normalizeClass as l, normalizeStyle as u, openBlock as d, ref as f, renderList as p, renderSlot as m, resolveDynamicComponent as h, unref as g, watch as _, withCtx as v } from "vue";
+var y = /* @__PURE__ */ c({
+	name: "XVirtualList",
+	props: {
+		class: {},
+		defaultHeight: { default: 0 },
+		onResize: {},
+		onRowsRendered: {},
+		overscanCount: { default: 3 },
+		rowCount: {},
+		rowHeight: {},
+		rowProps: {},
+		style: {},
+		tag: { default: "div" }
+	},
+	setup(c, { expose: y }) {
+		let b = c, x = f(null), S = i(() => b.rowProps || {}), C = i(() => b.rowCount), w = i(() => t(b.rowHeight)), T = i(() => {
+			if (w.value) {
+				let e = b.rowHeight, t = e.getAverageRowHeight();
+				return (n) => e.getRowHeight(n) ?? t;
+			}
+			return b.rowHeight;
+		}), { getCellBounds: E, getEstimatedSize: D, scrollToIndex: O, startIndexOverscan: k, startIndexVisible: A, stopIndexOverscan: j, stopIndexVisible: M } = e({
+			containerElement: x,
+			containerStyle: b.style,
+			defaultContainerSize: b.defaultHeight,
+			direction: "vertical",
+			itemCount: C,
+			itemProps: S,
+			itemSize: T,
+			onResize: b.onResize,
+			overscanCount: b.overscanCount
+		});
+		y({
+			get element() {
+				return x.value;
+			},
+			scrollToRow({ align: e = "auto", behavior: t = "auto", index: n }) {
+				let r = O({
+					align: e,
+					containerScrollOffset: x.value?.scrollTop ?? 0,
+					index: n
+				});
+				typeof x.value?.scrollTo == "function" && r !== void 0 && x.value.scrollTo({
+					behavior: t,
+					top: r
+				});
+			}
+		}), _([
+			x,
+			k,
+			j,
+			w,
+			() => b.rowHeight
+		], ([e, t, r, i], a, o) => {
+			if (!e || !i) return;
+			let s = Array.from(e.children).filter((e, r) => {
+				if (e.hasAttribute("aria-hidden")) return !1;
+				let i = `${t + r}`;
+				return e.setAttribute(n, i), !0;
+			}), c = b.rowHeight;
+			o(c.observeRowElements(s));
+		}, { flush: "post" }), _([
+			k,
+			A,
+			j,
+			M
+		], ([e, t, n, r]) => {
+			e >= 0 && n >= 0 && b.onRowsRendered && b.onRowsRendered({
+				startIndex: t,
+				stopIndex: r
+			}, {
+				startIndex: e,
+				stopIndex: n
+			});
+		});
+		let N = i(() => {
+			let e = [];
+			if (b.rowCount > 0) for (let t = k.value; t <= j.value; t++) {
+				let n = E(t), r = {
+					position: "absolute",
+					left: 0,
+					transform: `translateY(${n.scrollOffset}px)`,
+					height: w.value ? void 0 : `${n.size}px`,
+					width: "100%"
+				};
+				e.push({
+					key: t,
+					index: t,
+					style: r,
+					ariaAttributes: {
+						"aria-posinset": t + 1,
+						"aria-setsize": b.rowCount,
+						role: "listitem"
+					}
+				});
+			}
+			return e;
+		});
+		return (e, t) => (d(), a(h(c.tag), {
+			ref_key: "element",
+			ref: x,
+			class: l(e.$props.class),
+			style: u({
+				position: "relative",
+				maxHeight: "100%",
+				flexGrow: 1,
+				overflowY: "auto",
+				...c.style
+			}),
+			role: "list"
+		}, {
+			default: v(() => [
+				(d(!0), o(r, null, p(N.value, (t) => m(e.$slots, "row", {
+					key: t.key,
+					index: t.index,
+					style: u(t.style),
+					ariaAttributes: t.ariaAttributes,
+					props: S.value
+				})), 128)),
+				m(e.$slots, "default"),
+				s("div", {
+					"aria-hidden": "",
+					style: u({
+						height: `${g(D)}px`,
+						width: "100%",
+						zIndex: -1
+					})
+				}, null, 4)
+			]),
+			_: 3
+		}, 8, ["class", "style"]));
+	}
+});
+//#endregion
+export { y as default };

package/lib/virtual/components/virtualList/isDynamicRowHeight.js

@@ -1,6 +1,6 @@
-function i(t) {
-  return typeof t == "object" && t !== null && "getAverageRowHeight" in t && "getRowHeight" in t && "setRowHeight" in t;
+//#region src/virtual/components/virtualList/isDynamicRowHeight.ts
+function e(e) {
+	return typeof e == "object" && !!e && "getAverageRowHeight" in e && "getRowHeight" in e && "setRowHeight" in e;
 }
-export {
-  i as isDynamicRowHeight
-};
+//#endregion
+export { e as isDynamicRowHeight };

package/lib/virtual/components/virtualList/useDynamicRowHeight.js

@@ -1,68 +1,59 @@
-import { ref as p, watch as d, getCurrentInstance as H, onBeforeUnmount as R } from "vue";
-import { assert as I } from "../../utils/assert.js";
-const b = "data-virtual-index";
-function y({
-  defaultRowHeight: v,
-  key: o
-}) {
-  const r = p(/* @__PURE__ */ new Map()), a = p(0);
-  o !== void 0 && typeof o == "object" && "value" in o && d(o, () => {
-    r.value = /* @__PURE__ */ new Map(), a.value++;
-  });
-  const w = () => {
-    a.value;
-    let e = 0;
-    return r.value.forEach((t) => {
-      e += t;
-    }), e === 0 ? v : e / r.value.size;
-  }, m = (e) => {
-    a.value;
-    const t = r.value.get(e);
-    return t !== void 0 ? t : v;
-  }, A = (e, t) => {
-    if (r.value.get(e) === t)
-      return;
-    const n = new Map(r.value);
-    n.set(e, t), r.value = n, a.value++;
-  }, E = (e) => {
-    if (e.length === 0)
-      return;
-    let t = !1;
-    const n = [];
-    if (e.forEach((s) => {
-      const { borderBoxSize: i, target: c } = s, g = c.getAttribute(b);
-      I(
-        g !== null,
-        `Invalid ${b} attribute value`
-      );
-      const h = parseInt(g), { blockSize: l } = i[0];
-      if (!l)
-        return;
-      r.value.get(h) !== l && (n.push({ index: h, height: l }), t = !0);
-    }), t) {
-      const s = new Map(r.value);
-      n.forEach(({ index: i, height: c }) => {
-        s.set(i, c);
-      }), r.value = s, a.value++;
-    }
-  }, u = new ResizeObserver(E);
-  function f() {
-    u.disconnect();
-  }
-  return H() && R(f), {
-    getAverageRowHeight: w,
-    getRowHeight: m,
-    setRowHeight: A,
-    observeRowElements: (e) => {
-      const t = Array.isArray(e) ? e : Array.from(e);
-      return t.forEach((n) => u.observe(n)), () => {
-        t.forEach((n) => u.unobserve(n));
-      };
-    },
-    cleanup: f
-  };
+import { assert as e } from "../../utils/assert.js";
+import { getCurrentInstance as t, onBeforeUnmount as n, ref as r, watch as i } from "vue";
+//#region src/virtual/components/virtualList/useDynamicRowHeight.ts
+var a = "data-virtual-index";
+function o({ defaultRowHeight: o, key: s }) {
+	let c = r(/* @__PURE__ */ new Map()), l = r(0);
+	s !== void 0 && typeof s == "object" && "value" in s && i(s, () => {
+		c.value = /* @__PURE__ */ new Map(), l.value++;
+	});
+	let u = () => {
+		l.value;
+		let e = 0;
+		return c.value.forEach((t) => {
+			e += t;
+		}), e === 0 ? o : e / c.value.size;
+	}, d = (e) => {
+		l.value;
+		let t = c.value.get(e);
+		return t === void 0 ? o : t;
+	}, f = (e, t) => {
+		if (c.value.get(e) === t) return;
+		let n = new Map(c.value);
+		n.set(e, t), c.value = n, l.value++;
+	}, p = new ResizeObserver((t) => {
+		if (t.length === 0) return;
+		let n = !1, r = [];
+		if (t.forEach((t) => {
+			let { borderBoxSize: i, target: o } = t, s = o.getAttribute(a);
+			e(s !== null, `Invalid ${a} attribute value`);
+			let l = parseInt(s), { blockSize: u } = i[0];
+			u && c.value.get(l) !== u && (r.push({
+				index: l,
+				height: u
+			}), n = !0);
+		}), n) {
+			let e = new Map(c.value);
+			r.forEach(({ index: t, height: n }) => {
+				e.set(t, n);
+			}), c.value = e, l.value++;
+		}
+	});
+	function m() {
+		p.disconnect();
+	}
+	return t() && n(m), {
+		getAverageRowHeight: u,
+		getRowHeight: d,
+		setRowHeight: f,
+		observeRowElements: (e) => {
+			let t = Array.isArray(e) ? e : Array.from(e);
+			return t.forEach((e) => p.observe(e)), () => {
+				t.forEach((e) => p.unobserve(e));
+			};
+		},
+		cleanup: m
+	};
 }
-export {
-  b as DATA_ATTRIBUTE_LIST_INDEX,
-  y as useDynamicRowHeight
-};
+//#endregion
+export { a as DATA_ATTRIBUTE_LIST_INDEX, o as useDynamicRowHeight };

package/lib/virtual/composables/infinite-loader/scanForUnloadedIndices.js

@@ -1,41 +1,27 @@
-function o({
-  isRowLoaded: x,
-  minimumBatchSize: d,
-  rowCount: i,
-  startIndex: I,
-  stopIndex: a
-}) {
-  const r = [];
-  let s = -1, e = -1;
-  for (let t = I; t <= a; t++)
-    x(t) ? e >= 0 && (r.push({
-      startIndex: s,
-      stopIndex: e
-    }), s = e = -1) : (e = t, s < 0 && (s = t));
-  if (e >= 0) {
-    const t = Math.min(
-      Math.max(e, s + d - 1),
-      i - 1
-    );
-    for (let n = e + 1; n <= t && !x(n); n++)
-      e = n;
-    r.push({
-      startIndex: s,
-      stopIndex: e
-    });
-  }
-  if (r.length) {
-    const t = r[0];
-    for (; t.stopIndex - t.startIndex + 1 < d && t.startIndex > 0; ) {
-      const n = t.startIndex - 1;
-      if (!x(n))
-        t.startIndex = n;
-      else
-        break;
-    }
-  }
-  return r;
+//#region src/virtual/composables/infinite-loader/scanForUnloadedIndices.ts
+function e({ isRowLoaded: e, minimumBatchSize: t, rowCount: n, startIndex: r, stopIndex: i }) {
+	let a = [], o = -1, s = -1;
+	for (let t = r; t <= i; t++) e(t) ? s >= 0 && (a.push({
+		startIndex: o,
+		stopIndex: s
+	}), o = s = -1) : (s = t, o < 0 && (o = t));
+	if (s >= 0) {
+		let r = Math.min(Math.max(s, o + t - 1), n - 1);
+		for (let t = s + 1; t <= r && !e(t); t++) s = t;
+		a.push({
+			startIndex: o,
+			stopIndex: s
+		});
+	}
+	if (a.length) {
+		let n = a[0];
+		for (; n.stopIndex - n.startIndex + 1 < t && n.startIndex > 0;) {
+			let t = n.startIndex - 1;
+			if (!e(t)) n.startIndex = t;
+			else break;
+		}
+	}
+	return a;
 }
-export {
-  o as scanForUnloadedIndices
-};
+//#endregion
+export { e as scanForUnloadedIndices };

package/lib/virtual/composables/infinite-loader/useInfiniteLoader.js

@@ -1,42 +1,31 @@
-import { reactive as I, computed as a, toValue as s } from "vue";
-import { scanForUnloadedIndices as v } from "./scanForUnloadedIndices.js";
-function z(d) {
-  const e = I(/* @__PURE__ */ new Set()), r = a(
-    () => s(d).isRowLoaded
-  ), m = a(
-    () => s(d).loadMoreRows
-  ), w = a(
-    () => s(d).minimumBatchSize ?? 10
-  ), u = a(
-    () => s(d).rowCount
-  ), c = a(
-    () => s(d).threshold ?? 15
-  ), f = (t) => r.value(t) ? (e.has(t) && e.delete(t), !0) : e.has(t);
-  return {
-    onRowsRendered: ({ startIndex: t, stopIndex: R }) => {
-      if (e.size > 0) {
-        const n = [];
-        e.forEach((o) => {
-          r.value(o) && n.push(o);
-        }), n.forEach((o) => e.delete(o));
-      }
-      const l = v({
-        isRowLoaded: f,
-        minimumBatchSize: w.value,
-        rowCount: u.value,
-        startIndex: Math.max(0, t - c.value),
-        stopIndex: Math.min(u.value - 1, R + c.value)
-      });
-      for (let n = 0; n < l.length; n++) {
-        const { startIndex: o, stopIndex: h } = l[n];
-        for (let i = o; i <= h; i++)
-          e.add(i);
-        m.value(o, h);
-      }
-    },
-    pendingRowsCache: e
-  };
+import { scanForUnloadedIndices as e } from "./scanForUnloadedIndices.js";
+import { computed as t, reactive as n, toValue as r } from "vue";
+//#region src/virtual/composables/infinite-loader/useInfiniteLoader.ts
+function i(i) {
+	let a = n(/* @__PURE__ */ new Set()), o = t(() => r(i).isRowLoaded), s = t(() => r(i).loadMoreRows), c = t(() => r(i).minimumBatchSize ?? 10), l = t(() => r(i).rowCount), u = t(() => r(i).threshold ?? 15), d = (e) => o.value(e) ? (a.has(e) && a.delete(e), !0) : a.has(e);
+	return {
+		onRowsRendered: ({ startIndex: t, stopIndex: n }) => {
+			if (a.size > 0) {
+				let e = [];
+				a.forEach((t) => {
+					o.value(t) && e.push(t);
+				}), e.forEach((e) => a.delete(e));
+			}
+			let r = e({
+				isRowLoaded: d,
+				minimumBatchSize: c.value,
+				rowCount: l.value,
+				startIndex: Math.max(0, t - u.value),
+				stopIndex: Math.min(l.value - 1, n + u.value)
+			});
+			for (let e = 0; e < r.length; e++) {
+				let { startIndex: t, stopIndex: n } = r[e];
+				for (let e = t; e <= n; e++) a.add(e);
+				s.value(t, n);
+			}
+		},
+		pendingRowsCache: a
+	};
 }
-export {
-  z as useInfiniteLoader
-};
+//#endregion
+export { i as useInfiniteLoader };

package/lib/virtual/core/createCachedBounds.js

@@ -1,55 +1,41 @@
-import { assert as f } from "../utils/assert.js";
-function d({
-  itemCount: u,
-  itemProps: a,
-  itemSize: r
-}) {
-  const e = /* @__PURE__ */ new Map();
-  return {
-    get(s) {
-      for (f(s < u, `Invalid index ${s}`); e.size - 1 < s; ) {
-        const t = e.size;
-        let c;
-        switch (typeof r) {
-          case "function": {
-            c = r(t, a);
-            break;
-          }
-          case "number": {
-            c = r;
-            break;
-          }
-        }
-        if (t === 0)
-          e.set(t, {
-            size: c,
-            scrollOffset: 0
-          });
-        else {
-          const n = e.get(t - 1);
-          f(
-            n !== void 0,
-            `Unexpected bounds cache miss for index ${s}`
-          ), e.set(t, {
-            scrollOffset: n.scrollOffset + n.size,
-            size: c
-          });
-        }
-      }
-      const o = e.get(s);
-      return f(
-        o !== void 0,
-        `Unexpected bounds cache miss for index ${s}`
-      ), o;
-    },
-    set(s, o) {
-      e.set(s, o);
-    },
-    get size() {
-      return e.size;
-    }
-  };
+import { assert as e } from "../utils/assert.js";
+//#region src/virtual/core/createCachedBounds.ts
+function t({ itemCount: t, itemProps: n, itemSize: r }) {
+	let i = /* @__PURE__ */ new Map();
+	return {
+		get(a) {
+			for (e(a < t, `Invalid index ${a}`); i.size - 1 < a;) {
+				let t = i.size, o;
+				switch (typeof r) {
+					case "function":
+						o = r(t, n);
+						break;
+					case "number":
+						o = r;
+						break;
+				}
+				if (t === 0) i.set(t, {
+					size: o,
+					scrollOffset: 0
+				});
+				else {
+					let n = i.get(t - 1);
+					e(n !== void 0, `Unexpected bounds cache miss for index ${a}`), i.set(t, {
+						scrollOffset: n.scrollOffset + n.size,
+						size: o
+					});
+				}
+			}
+			let o = i.get(a);
+			return e(o !== void 0, `Unexpected bounds cache miss for index ${a}`), o;
+		},
+		set(e, t) {
+			i.set(e, t);
+		},
+		get size() {
+			return i.size;
+		}
+	};
 }
-export {
-  d as createCachedBounds
-};
+//#endregion
+export { t as createCachedBounds };

package/lib/virtual/core/getEstimatedSize.js

@@ -1,22 +1,12 @@
-import { assert as f } from "../utils/assert.js";
-function o({
-  cachedBounds: e,
-  itemCount: s,
-  itemSize: t
-}) {
-  if (s === 0)
-    return 0;
-  if (typeof t == "number")
-    return s * t;
-  {
-    const r = e.get(
-      e.size === 0 ? 0 : e.size - 1
-    );
-    f(r !== void 0, "Unexpected bounds cache miss");
-    const i = (r.scrollOffset + r.size) / e.size;
-    return s * i;
-  }
+import { assert as e } from "../utils/assert.js";
+//#region src/virtual/core/getEstimatedSize.ts
+function t({ cachedBounds: t, itemCount: n, itemSize: r }) {
+	if (n === 0) return 0;
+	if (typeof r == "number") return n * r;
+	{
+		let r = t.get(t.size === 0 ? 0 : t.size - 1);
+		return e(r !== void 0, "Unexpected bounds cache miss"), n * ((r.scrollOffset + r.size) / t.size);
+	}
 }
-export {
-  o as getEstimatedSize
-};
+//#endregion
+export { t as getEstimatedSize };

package/lib/virtual/core/getOffsetForIndex.js

@@ -1,40 +1,18 @@
-import { getEstimatedSize as o } from "./getEstimatedSize.js";
-function p({
-  align: u,
-  cachedBounds: l,
-  index: r,
-  itemCount: a,
-  itemSize: d,
-  containerScrollOffset: e,
-  containerSize: t
-}) {
-  if (r < 0 || r >= a)
-    throw new RangeError(
-      `Invalid index specified: ${r}. Index ${r} is not within the range of 0 - ${a - 1}`
-    );
-  const h = o({
-    cachedBounds: l,
-    itemCount: a,
-    itemSize: d
-  }), s = l.get(r), m = Math.max(
-    0,
-    Math.min(h - t, s.scrollOffset)
-  ), f = Math.max(
-    0,
-    s.scrollOffset - t + s.size
-  );
-  switch (u === "smart" && (e >= f && e <= m ? u = "auto" : u = "center"), u) {
-    case "start":
-      return m;
-    case "end":
-      return f;
-    case "center":
-      return s.scrollOffset <= t / 2 ? 0 : s.scrollOffset + s.size / 2 >= h - t / 2 ? h - t : s.scrollOffset + s.size / 2 - t / 2;
-    case "auto":
-    default:
-      return e >= f && e <= m ? e : e < f ? f : m;
-  }
+import { getEstimatedSize as e } from "./getEstimatedSize.js";
+//#region src/virtual/core/getOffsetForIndex.ts
+function t({ align: t, cachedBounds: n, index: r, itemCount: i, itemSize: a, containerScrollOffset: o, containerSize: s }) {
+	if (r < 0 || r >= i) throw RangeError(`Invalid index specified: ${r}. Index ${r} is not within the range of 0 - ${i - 1}`);
+	let c = e({
+		cachedBounds: n,
+		itemCount: i,
+		itemSize: a
+	}), l = n.get(r), u = Math.max(0, Math.min(c - s, l.scrollOffset)), d = Math.max(0, l.scrollOffset - s + l.size);
+	switch (t === "smart" && (t = o >= d && o <= u ? "auto" : "center"), t) {
+		case "start": return u;
+		case "end": return d;
+		case "center": return l.scrollOffset <= s / 2 ? 0 : l.scrollOffset + l.size / 2 >= c - s / 2 ? c - s : l.scrollOffset + l.size / 2 - s / 2;
+		default: return o >= d && o <= u ? o : o < d ? d : u;
+	}
 }
-export {
-  p as getOffsetForIndex
-};
+//#endregion
+export { t as getOffsetForIndex };