@vizejs/ui 0.387.0 → 0.388.0

package/dist/virtualizer-BlxKjT3W.mjs

@@ -0,0 +1,793 @@
+import { t as createSizeObserver } from "./measure-runtime-C4qYJp3_.mjs";
+import { getCurrentScope, onScopeDispose, shallowReadonly, shallowRef, toValue, watch } from "vue";
+//#region src/families/interaction/virtualizer/virtualizer-measure-cache.ts
+/**
+* Lane-aware measurement cache for the virtualizer.
+*
+* Items are assigned round-robin to lanes; each lane keeps a lazily built
+* prefix-offset chain so estimated sizes, exact sizes, and dynamic
+* measurements resolve to stable main-axis placements. Mutations truncate
+* only the offsets they invalidate.
+*/
+const invalidOptionDiagnostic$1 = "VIZE_UI_VIRTUALIZER_OPTION";
+function assertSize(size, source) {
+	if (typeof size !== "number" || !Number.isFinite(size) || size < 0) throw new TypeError(`${invalidOptionDiagnostic$1}: ${source} must resolve to a finite non-negative number`);
+	return size;
+}
+/** Create one measurement cache bound to live layout config. */
+function createMeasureCache(config) {
+	/** `measured[index]` overrides the estimated base size once an item is measured. */
+	let measured = /* @__PURE__ */ new Map();
+	/** `laneOffsets[lane][position]` is the start offset of that lane slot. */
+	let laneOffsets = [];
+	const laneOf = (index) => index % config.getLanes();
+	const positionOf = (index) => Math.trunc(index / config.getLanes());
+	const laneIndexAt = (lane, position) => position * config.getLanes() + lane;
+	const laneLength = (lane) => {
+		const count = config.getCount();
+		if (lane >= count) return 0;
+		return Math.trunc((count - 1 - lane) / config.getLanes()) + 1;
+	};
+	const sizeOf = (index) => {
+		const base = () => assertSize(config.resolveBaseSize(index), "the item size");
+		if (config.usesExactSizes()) return base();
+		return measured.get(index) ?? base();
+	};
+	/** Build the whole prefix chain for one lane; results are cached until invalidated. */
+	const laneChain = (lane) => {
+		const length = laneLength(lane);
+		const chain = laneOffsets[lane] ??= [];
+		if (chain.length === 0) chain.push(config.getPaddingStart());
+		while (chain.length < length) {
+			const position = chain.length - 1;
+			const previous = chain[position] ?? 0;
+			chain.push(previous + sizeOf(laneIndexAt(lane, position)) + config.getGap());
+		}
+		return chain;
+	};
+	const assertIndex = (index) => {
+		const count = config.getCount();
+		if (!Number.isInteger(index) || index < 0 || index >= count) throw new RangeError(`${invalidOptionDiagnostic$1}: index ${index} is outside the collection of ${count}`);
+	};
+	const placement = (index) => {
+		assertIndex(index);
+		const lane = laneOf(index);
+		const start = laneChain(lane)[positionOf(index)] ?? config.getPaddingStart();
+		const size = sizeOf(index);
+		return Object.freeze({
+			start,
+			size,
+			end: start + size,
+			lane,
+			isMeasured: !config.usesExactSizes() && measured.has(index)
+		});
+	};
+	const truncateFrom = (index) => {
+		for (let lane = 0; lane < laneOffsets.length; lane++) {
+			const chain = laneOffsets[lane];
+			if (!chain) continue;
+			const keep = index <= lane ? 1 : Math.ceil((index - lane) / config.getLanes()) + 1;
+			if (chain.length > keep) chain.length = keep;
+		}
+	};
+	return Object.freeze({
+		placement,
+		laneLength,
+		laneIndexAt,
+		contentEnd() {
+			const count = config.getCount();
+			if (count === 0) return config.getPaddingStart();
+			let end = config.getPaddingStart();
+			const laneCount = Math.min(config.getLanes(), count);
+			for (let lane = 0; lane < laneCount; lane++) {
+				const last = laneIndexAt(lane, laneLength(lane) - 1);
+				end = Math.max(end, placement(last).end);
+			}
+			return end;
+		},
+		firstVisiblePosition(lane, offset) {
+			const length = laneLength(lane);
+			if (length === 0) return 0;
+			const chain = laneChain(lane);
+			let low = 0;
+			let high = length - 1;
+			while (low < high) {
+				const middle = Math.trunc((low + high) / 2);
+				if ((chain[middle] ?? 0) + sizeOf(laneIndexAt(lane, middle)) > offset) high = middle;
+				else low = middle + 1;
+			}
+			return low;
+		},
+		measuredSize: (index) => measured.get(index),
+		setMeasured(index, size) {
+			assertIndex(index);
+			assertSize(size, "the measured size");
+			if (config.usesExactSizes()) return 0;
+			const previous = sizeOf(index);
+			measured.set(index, size);
+			const delta = size - previous;
+			if (delta !== 0) truncateFrom(index);
+			return delta;
+		},
+		clearMeasuredFrom(fromIndex) {
+			for (const index of measured.keys()) if (index >= fromIndex) measured.delete(index);
+			truncateFrom(fromIndex);
+		},
+		invalidateFrom(index) {
+			if (index <= 0) laneOffsets = [];
+			else truncateFrom(index);
+		},
+		shiftMeasurements(by) {
+			measured = new Map([...measured.entries()].map(([index, size]) => [index + by, size]));
+			laneOffsets = [];
+		}
+	});
+}
+//#endregion
+//#region src/families/interaction/virtualizer/virtualizer-options.ts
+/** Validation and reactive readers for the public virtualizer options. */
+const invalidOptionDiagnostic = "VIZE_UI_VIRTUALIZER_OPTION";
+const disposedDiagnostic = "VIZE_UI_VIRTUALIZER_DISPOSED";
+const setupDiagnostic = "VIZE_UI_VIRTUALIZER_SETUP";
+const orientations = new Set(["horizontal", "vertical"]);
+function fail(message) {
+	throw new TypeError(`${invalidOptionDiagnostic}: ${message}`);
+}
+function readNumber(value, name, { integer = false, minimum = 0, fallback }) {
+	const resolved = toValue(value) ?? fallback;
+	if (typeof resolved !== "number" || !Number.isFinite(resolved) || resolved < minimum || integer && !Number.isInteger(resolved)) fail(`${name} must resolve to a${integer ? "n integer" : " finite number"} of at least ${minimum}`);
+	return resolved;
+}
+function readSizeSource(value, name) {
+	if (typeof value === "function") return value;
+	if (typeof value === "number" && Number.isFinite(value) && value >= 0) return () => value;
+	return fail(`${name} must be a non-negative pixel size or a resolver function`);
+}
+function readStaticNumber(value, name, fallback) {
+	if (value === void 0) return fallback;
+	if (typeof value !== "number" || !Number.isFinite(value) || value < 0) fail(`${name} must be a finite non-negative number`);
+	return value;
+}
+/** Validate static options once and wrap reactive options in checked readers. */
+function resolveVirtualizerOptions(options) {
+	for (const name of ["getItemKey", "onRangeChange"]) {
+		const callback = options[name];
+		if (callback !== void 0 && typeof callback !== "function") fail(`${name} must be a function`);
+	}
+	if (options.anchorScroll !== void 0 && typeof options.anchorScroll !== "boolean") fail("anchorScroll must be a boolean");
+	if (options.itemSize === void 0 && options.estimateItemSize === void 0) fail("one of itemSize or estimateItemSize is required");
+	const usesExactSizes = options.itemSize !== void 0;
+	const resolveBaseSize = usesExactSizes ? readSizeSource(options.itemSize, "itemSize") : readSizeSource(options.estimateItemSize, "estimateItemSize");
+	const initialRect = Object.freeze({
+		width: readStaticNumber(options.initialRect?.width, "initialRect.width", 0),
+		height: readStaticNumber(options.initialRect?.height, "initialRect.height", 0)
+	});
+	const readers = Object.freeze({
+		readCount: () => readNumber(options.count, "count", {
+			integer: true,
+			fallback: 0
+		}),
+		readOrientation() {
+			const resolved = toValue(options.orientation) ?? "vertical";
+			if (!orientations.has(resolved)) fail("orientation must resolve to horizontal or vertical");
+			return resolved;
+		},
+		readGap: () => readNumber(options.gap, "gap", { fallback: 0 }),
+		readLanes: () => readNumber(options.lanes, "lanes", {
+			integer: true,
+			minimum: 1,
+			fallback: 1
+		}),
+		readOverscan: () => readNumber(options.overscan, "overscan", {
+			integer: true,
+			fallback: 2
+		}),
+		readStickyIndexes() {
+			const resolved = toValue(options.stickyIndexes) ?? [];
+			if (!Array.isArray(resolved)) fail("stickyIndexes must resolve to an array of indexes");
+			return resolved;
+		},
+		resolveBaseSize,
+		usesExactSizes: () => usesExactSizes,
+		getItemKey: options.getItemKey ?? ((index) => index),
+		paddingStart: readStaticNumber(options.paddingStart, "paddingStart", 0),
+		paddingEnd: readStaticNumber(options.paddingEnd, "paddingEnd", 0),
+		anchorScroll: options.anchorScroll ?? true,
+		initialRect,
+		initialScrollOffset: readStaticNumber(options.initialScrollOffset, "initialScrollOffset", 0)
+	});
+	if (typeof options.count !== "function") readers.readCount();
+	if (typeof options.orientation !== "function") readers.readOrientation();
+	if (typeof options.gap !== "function") readers.readGap();
+	if (typeof options.lanes !== "function") readers.readLanes();
+	if (typeof options.overscan !== "function") readers.readOverscan();
+	if (typeof options.stickyIndexes !== "function") readers.readStickyIndexes();
+	return readers;
+}
+//#endregion
+//#region src/families/interaction/virtualizer/virtualizer-viewport.ts
+/**
+* DOM binding between one virtualizer and its scrollable viewport: scroll
+* offset reads and writes plus SSR-safe viewport size observation.
+*/
+function readOffset(element, orientation) {
+	return orientation === "vertical" ? element.scrollTop : element.scrollLeft;
+}
+/** Create one viewport binding. Attachment is a no-op contract during SSR. */
+function createViewportBinding(config) {
+	let element = null;
+	let releaseScroll = null;
+	const sizeObserver = createSizeObserver({ onResize(entries) {
+		for (const entry of entries) {
+			if (entry.target !== element) continue;
+			config.onViewportSize(Object.freeze({
+				width: entry.width,
+				height: entry.height
+			}));
+		}
+	} });
+	const detach = () => {
+		releaseScroll?.();
+		releaseScroll = null;
+		if (element) sizeObserver.unobserve(element);
+		element = null;
+	};
+	return Object.freeze({
+		element: () => element,
+		attach(next) {
+			if (next === element) return;
+			detach();
+			if (!next) return;
+			element = next;
+			const onScroll = () => {
+				if (element) config.onScrollOffset(readOffset(element, config.getOrientation()));
+			};
+			next.addEventListener("scroll", onScroll, { passive: true });
+			releaseScroll = () => next.removeEventListener("scroll", onScroll);
+			sizeObserver.observe(next);
+			if (next.clientWidth > 0 || next.clientHeight > 0) config.onViewportSize(Object.freeze({
+				width: next.clientWidth,
+				height: next.clientHeight
+			}));
+			config.onScrollOffset(readOffset(next, config.getOrientation()));
+		},
+		applyOffset(offset) {
+			if (!element) return;
+			if (typeof element.scrollTo === "function") element.scrollTo(config.getOrientation() === "vertical" ? { top: offset } : { left: offset });
+			else if (config.getOrientation() === "vertical") element.scrollTop = offset;
+			else element.scrollLeft = offset;
+		},
+		dispose() {
+			detach();
+			sizeObserver.dispose();
+		}
+	});
+}
+//#endregion
+//#region src/families/interaction/virtualizer/virtualizer-window.ts
+const emptyWindow = Object.freeze({
+	items: Object.freeze([]),
+	range: null,
+	activeStickyIndex: null
+});
+function laneVisibleSpan(input, lane, viewportEnd) {
+	const { cache, scrollOffset } = input;
+	const length = cache.laneLength(lane);
+	if (length === 0) return null;
+	const first = cache.firstVisiblePosition(lane, scrollOffset);
+	const zeroViewport = viewportEnd === scrollOffset;
+	let last = -1;
+	for (let position = first; position < length; position++) {
+		const placement = cache.placement(cache.laneIndexAt(lane, position));
+		if (!(placement.end > scrollOffset && (placement.start < viewportEnd || zeroViewport && placement.start <= scrollOffset))) break;
+		last = position;
+	}
+	return last < first ? null : {
+		firstVisible: first,
+		lastVisible: last
+	};
+}
+function activeSticky(input, stickySet) {
+	let active = null;
+	for (const index of stickySet) {
+		if (input.cache.placement(index).start > input.scrollOffset) continue;
+		if (active === null || index > active) active = index;
+	}
+	return active;
+}
+function buildItem(input, index, isSticky) {
+	const placement = input.cache.placement(index);
+	return Object.freeze({
+		index,
+		key: input.getItemKey(index),
+		lane: placement.lane,
+		start: placement.start,
+		size: placement.size,
+		end: placement.end,
+		isSticky,
+		isMeasured: placement.isMeasured
+	});
+}
+/** Compute the rendered window for the current scroll position. */
+function computeVirtualWindow(input) {
+	const { cache, count, lanes, overscan, scrollOffset, viewportSize } = input;
+	const stickySet = new Set(input.stickyIndexes.filter((index) => Number.isInteger(index) && index >= 0 && index < count));
+	if (count <= 0) return emptyWindow;
+	const viewportEnd = scrollOffset + viewportSize;
+	const indexes = /* @__PURE__ */ new Set();
+	let rangeStart = Number.POSITIVE_INFINITY;
+	let rangeEnd = Number.NEGATIVE_INFINITY;
+	for (let lane = 0; lane < Math.min(lanes, count); lane++) {
+		const span = laneVisibleSpan(input, lane, viewportEnd);
+		if (!span) continue;
+		rangeStart = Math.min(rangeStart, cache.laneIndexAt(lane, span.firstVisible));
+		rangeEnd = Math.max(rangeEnd, cache.laneIndexAt(lane, span.lastVisible));
+		const firstRendered = Math.max(0, span.firstVisible - overscan);
+		const lastRendered = Math.min(cache.laneLength(lane) - 1, span.lastVisible + overscan);
+		for (let position = firstRendered; position <= lastRendered; position++) indexes.add(cache.laneIndexAt(lane, position));
+	}
+	const pinned = activeSticky(input, stickySet);
+	if (pinned !== null) indexes.add(pinned);
+	const items = [...indexes].sort((left, right) => left - right).map((index) => buildItem(input, index, index === pinned || stickySet.has(index)));
+	return Object.freeze({
+		items: Object.freeze(items),
+		range: rangeStart <= rangeEnd ? Object.freeze({
+			startIndex: rangeStart,
+			endIndex: rangeEnd
+		}) : null,
+		activeStickyIndex: pinned
+	});
+}
+//#endregion
+//#region src/families/interaction/virtualizer/virtualizer-runtime.ts
+const alignments = new Set([
+	"auto",
+	"center",
+	"end",
+	"start"
+]);
+function rangesEqual(left, right) {
+	if (left === right) return true;
+	return left !== null && right !== null && left.startIndex === right.startIndex && left.endIndex === right.endIndex;
+}
+/** Create an SSR-safe windowing controller for one scroll axis. */
+function createVirtualizer(options) {
+	const readers = resolveVirtualizerOptions(options);
+	let disposed = false;
+	const scrollOffset = shallowRef(readers.initialScrollOffset);
+	const viewportRect = shallowRef(readers.initialRect);
+	const mainAxisSize = () => readers.readOrientation() === "vertical" ? viewportRect.value.height : viewportRect.value.width;
+	const viewportSize = shallowRef(mainAxisSize());
+	const layoutVersion = shallowRef(0);
+	const bump = () => {
+		layoutVersion.value++;
+	};
+	const cache = createMeasureCache({
+		getCount: readers.readCount,
+		getLanes: readers.readLanes,
+		getGap: readers.readGap,
+		getPaddingStart: () => readers.paddingStart,
+		resolveBaseSize: readers.resolveBaseSize,
+		usesExactSizes: readers.usesExactSizes
+	});
+	const virtualItems = shallowRef(Object.freeze([]));
+	const range = shallowRef(null);
+	const totalSize = shallowRef(0);
+	const activeStickyIndex = shallowRef(null);
+	const assertUsable = () => {
+		if (disposed) throw new Error(`${disposedDiagnostic}: the controller has been disposed`);
+	};
+	const assertIndex = (index) => {
+		const count = readers.readCount();
+		if (!Number.isInteger(index) || index < 0 || index >= count) throw new RangeError(`${invalidOptionDiagnostic}: index ${index} is outside the collection of ${count}`);
+	};
+	const recompute = () => {
+		const window = computeVirtualWindow({
+			cache,
+			count: readers.readCount(),
+			lanes: readers.readLanes(),
+			overscan: readers.readOverscan(),
+			scrollOffset: scrollOffset.value,
+			viewportSize: viewportSize.value,
+			stickyIndexes: readers.readStickyIndexes(),
+			getItemKey: readers.getItemKey
+		});
+		virtualItems.value = window.items;
+		totalSize.value = cache.contentEnd() + readers.paddingEnd;
+		activeStickyIndex.value = window.activeStickyIndex;
+		if (!rangesEqual(range.value, window.range)) {
+			range.value = window.range;
+			options.onRangeChange?.(window.range);
+		}
+	};
+	const binding = createViewportBinding({
+		getOrientation: readers.readOrientation,
+		onScrollOffset(offset) {
+			if (scrollOffset.value !== offset) scrollOffset.value = offset;
+		},
+		onViewportSize(rect) {
+			viewportRect.value = rect;
+			const next = mainAxisSize();
+			if (viewportSize.value !== next) viewportSize.value = next;
+		}
+	});
+	const anchorAdjust = (index, delta) => {
+		if (!readers.anchorScroll || delta === 0) return;
+		if (cache.placement(index).start >= scrollOffset.value) return;
+		const next = Math.max(0, scrollOffset.value + delta);
+		scrollOffset.value = next;
+		binding.applyOffset(next);
+	};
+	const applyMeasured = (index, size) => {
+		if (readers.usesExactSizes()) return;
+		const wasMeasured = cache.measuredSize(index) !== void 0;
+		const delta = cache.setMeasured(index, size);
+		if (delta === 0 && wasMeasured) return;
+		anchorAdjust(index, delta);
+		bump();
+	};
+	const indexElements = /* @__PURE__ */ new Map();
+	const elementIndexes = /* @__PURE__ */ new Map();
+	function forget(element) {
+		measureObserver.unobserve(element);
+		const index = elementIndexes.get(element);
+		elementIndexes.delete(element);
+		if (index !== void 0 && indexElements.get(index) === element) indexElements.delete(index);
+	}
+	const measureObserver = createSizeObserver({ onResize(entries) {
+		for (const entry of entries) {
+			const index = elementIndexes.get(entry.target);
+			if (index === void 0) continue;
+			if (!entry.target.isConnected) {
+				forget(entry.target);
+				continue;
+			}
+			applyMeasured(index, readers.readOrientation() === "vertical" ? entry.height : entry.width);
+		}
+	} });
+	const scrollToOffset = (offset) => {
+		assertUsable();
+		if (typeof offset !== "number" || !Number.isFinite(offset)) throw new TypeError(`${invalidOptionDiagnostic}: offset must be a finite number`);
+		const limit = Math.max(0, cache.contentEnd() + readers.paddingEnd - viewportSize.value);
+		const clamped = Math.min(Math.max(0, offset), limit);
+		if (scrollOffset.value !== clamped) scrollOffset.value = clamped;
+		binding.applyOffset(clamped);
+	};
+	const stopStructureWatch = watch(() => [
+		readers.readCount(),
+		readers.readLanes(),
+		readers.readGap(),
+		readers.readOrientation()
+	], (next, previous) => {
+		if (next[0] !== previous[0] || next[1] !== previous[1] || next[2] !== previous[2]) cache.invalidateFrom(0);
+		if (next[3] !== previous[3]) viewportSize.value = mainAxisSize();
+		recompute();
+	}, { flush: "sync" });
+	const stopWindowWatch = watch(() => [
+		scrollOffset.value,
+		viewportSize.value,
+		layoutVersion.value,
+		readers.readOverscan(),
+		readers.readStickyIndexes()
+	], recompute, { flush: "sync" });
+	recompute();
+	return Object.freeze({
+		virtualItems: shallowReadonly(virtualItems),
+		range: shallowReadonly(range),
+		totalSize: shallowReadonly(totalSize),
+		scrollOffset: shallowReadonly(scrollOffset),
+		viewportSize: shallowReadonly(viewportSize),
+		activeStickyIndex: shallowReadonly(activeStickyIndex),
+		setViewport(element) {
+			assertUsable();
+			if (element !== null && element.nodeType !== 1) throw new TypeError(`${invalidOptionDiagnostic}: the viewport must be an element`);
+			binding.attach(element);
+		},
+		measureElement(element, index) {
+			assertUsable();
+			if (element === null) {
+				const existing = indexElements.get(index);
+				if (existing) forget(existing);
+				return;
+			}
+			if (element.nodeType !== 1) throw new TypeError(`${invalidOptionDiagnostic}: measured targets must be elements`);
+			assertIndex(index);
+			const previous = indexElements.get(index);
+			if (previous && previous !== element) forget(previous);
+			const previousIndex = elementIndexes.get(element);
+			if (previousIndex !== void 0 && previousIndex !== index) indexElements.delete(previousIndex);
+			indexElements.set(index, element);
+			elementIndexes.set(element, index);
+			measureObserver.observe(element);
+			const rect = typeof element.getBoundingClientRect === "function" ? element.getBoundingClientRect() : null;
+			const extent = rect === null ? 0 : readers.readOrientation() === "vertical" ? rect.height : rect.width;
+			if (extent > 0) applyMeasured(index, extent);
+		},
+		resizeItem(index, size) {
+			assertUsable();
+			assertIndex(index);
+			applyMeasured(index, size);
+		},
+		invalidateMeasurements(fromIndex = 0) {
+			assertUsable();
+			if (!Number.isInteger(fromIndex) || fromIndex < 0) throw new TypeError(`${invalidOptionDiagnostic}: fromIndex must be a non-negative integer`);
+			cache.clearMeasuredFrom(fromIndex);
+			bump();
+		},
+		notifyPrepended(prepended) {
+			assertUsable();
+			if (!Number.isInteger(prepended) || prepended <= 0) throw new TypeError(`${invalidOptionDiagnostic}: notifyPrepended requires a positive integer`);
+			cache.shiftMeasurements(prepended);
+			const shiftedIndexElements = [...indexElements.entries()];
+			indexElements.clear();
+			for (const [index, element] of shiftedIndexElements) {
+				indexElements.set(index + prepended, element);
+				elementIndexes.set(element, index + prepended);
+			}
+			if (readers.anchorScroll) {
+				let delta = 0;
+				const gap = readers.readGap();
+				const lanes = readers.readLanes();
+				for (let index = 0; index < prepended; index++) delta += readers.resolveBaseSize(index) + gap;
+				bump();
+				scrollToOffset(scrollOffset.value + delta / lanes);
+			} else bump();
+		},
+		scrollToOffset,
+		scrollToIndex(index, alignment = "auto") {
+			assertUsable();
+			assertIndex(index);
+			if (!alignments.has(alignment)) throw new TypeError(`${invalidOptionDiagnostic}: unknown alignment ${String(alignment)}`);
+			const placement = cache.placement(index);
+			const viewport = viewportSize.value;
+			let resolved = alignment;
+			if (resolved === "auto") if (placement.start < scrollOffset.value) resolved = "start";
+			else if (placement.end > scrollOffset.value + viewport) resolved = "end";
+			else return;
+			if (resolved === "start") scrollToOffset(placement.start);
+			else if (resolved === "end") scrollToOffset(placement.end - viewport);
+			else scrollToOffset(placement.start - (viewport - placement.size) / 2);
+		},
+		createScrollSnapshot() {
+			assertUsable();
+			const anchorIndex = range.value?.startIndex ?? null;
+			return Object.freeze({
+				offset: scrollOffset.value,
+				anchorIndex,
+				anchorGap: anchorIndex === null ? 0 : scrollOffset.value - cache.placement(anchorIndex).start
+			});
+		},
+		restoreScroll(snapshot) {
+			assertUsable();
+			const { anchorIndex } = snapshot;
+			if (anchorIndex !== null && Number.isInteger(anchorIndex) && anchorIndex >= 0 && anchorIndex < readers.readCount() && Number.isFinite(snapshot.anchorGap)) {
+				scrollToOffset(cache.placement(anchorIndex).start + snapshot.anchorGap);
+				return;
+			}
+			scrollToOffset(snapshot.offset);
+		},
+		dispose() {
+			if (disposed) return;
+			disposed = true;
+			stopStructureWatch();
+			stopWindowWatch();
+			binding.dispose();
+			measureObserver.dispose();
+			indexElements.clear();
+			elementIndexes.clear();
+		}
+	});
+}
+/** Create a virtualizer disposed with the current Vue effect scope. */
+function useVirtualizer(options) {
+	if (!getCurrentScope()) throw new Error(`${setupDiagnostic}: use inside component setup or an active effect scope`);
+	const controller = createVirtualizer(options);
+	onScopeDispose(controller.dispose);
+	return controller;
+}
+//#endregion
+//#region src/families/interaction/virtualizer/virtualizer-grid.ts
+/** Two-axis grid virtualization composed from one row and one column virtualizer. */
+function axisOptions(options, axis) {
+	return {
+		count: axis.count,
+		orientation: axis.orientation,
+		...axis.size === void 0 ? {} : { itemSize: axis.size },
+		...axis.estimate === void 0 ? {} : { estimateItemSize: axis.estimate },
+		...axis.gap === void 0 ? {} : { gap: axis.gap },
+		...options.overscan === void 0 ? {} : { overscan: options.overscan },
+		...options.initialRect === void 0 ? {} : { initialRect: options.initialRect },
+		...axis.getKey === void 0 ? {} : { getItemKey: axis.getKey }
+	};
+}
+/** Create an SSR-safe two-axis grid virtualizer over one viewport. */
+function createGridVirtualizer(options) {
+	const rows = createVirtualizer(axisOptions(options, {
+		count: options.rowCount,
+		orientation: "vertical",
+		size: options.rowSize,
+		estimate: options.estimateRowSize,
+		gap: options.rowGap,
+		getKey: options.getRowKey
+	}));
+	const columns = createVirtualizer(axisOptions(options, {
+		count: options.columnCount,
+		orientation: "horizontal",
+		size: options.columnSize,
+		estimate: options.estimateColumnSize,
+		gap: options.columnGap,
+		getKey: options.getColumnKey
+	}));
+	const virtualCells = shallowRef(Object.freeze([]));
+	const stopCellWatch = watch(() => [rows.virtualItems.value, columns.virtualItems.value], ([rowItems, columnItems]) => {
+		const cells = [];
+		for (const row of rowItems) for (const column of columnItems) cells.push(Object.freeze({
+			rowIndex: row.index,
+			columnIndex: column.index,
+			key: `${String(row.key)}:${String(column.key)}`,
+			top: row.start,
+			left: column.start,
+			width: column.size,
+			height: row.size
+		}));
+		virtualCells.value = Object.freeze(cells);
+	}, {
+		flush: "sync",
+		immediate: true
+	});
+	return Object.freeze({
+		rows,
+		columns,
+		virtualCells: shallowReadonly(virtualCells),
+		setViewport(element) {
+			rows.setViewport(element);
+			columns.setViewport(element);
+		},
+		scrollToCell(rowIndex, columnIndex, alignment = "auto") {
+			rows.scrollToIndex(rowIndex, alignment);
+			columns.scrollToIndex(columnIndex, alignment);
+		},
+		dispose() {
+			stopCellWatch();
+			rows.dispose();
+			columns.dispose();
+		}
+	});
+}
+/** Create a grid virtualizer disposed with the current Vue effect scope. */
+function useGridVirtualizer(options) {
+	if (!getCurrentScope()) throw new Error(`${setupDiagnostic}: use inside component setup or an active effect scope`);
+	const controller = createGridVirtualizer(options);
+	onScopeDispose(controller.dispose);
+	return controller;
+}
+//#endregion
+//#region src/families/interaction/virtualizer/virtualizer-infinite.ts
+/** Bidirectional infinite loading over a virtualizer range, with stale-result cancellation. */
+function readThreshold(value) {
+	const resolved = toValue(value) ?? 4;
+	if (!Number.isInteger(resolved) || resolved < 0) throw new TypeError(`${invalidOptionDiagnostic}: threshold must resolve to a non-negative integer`);
+	return resolved;
+}
+/** Create an SSR-safe bidirectional infinite loading controller. */
+function createInfiniteLoader(options) {
+	for (const name of [
+		"onLoadBackward",
+		"onLoadForward",
+		"onLoadError"
+	]) if (options[name] !== void 0 && typeof options[name] !== "function") throw new TypeError(`${invalidOptionDiagnostic}: ${name} must be a function`);
+	if (typeof options.threshold !== "function") readThreshold(options.threshold);
+	const states = {
+		backward: {
+			status: shallowRef("idle"),
+			token: 0,
+			aborter: null
+		},
+		forward: {
+			status: shallowRef("idle"),
+			token: 0,
+			aborter: null
+		}
+	};
+	let disposed = false;
+	const assertUsable = () => {
+		if (disposed) throw new Error(`${disposedDiagnostic}: the loader has been disposed`);
+	};
+	const shouldLoad = (direction) => {
+		if (toValue(direction === "backward" ? options.canLoadBackward : options.canLoadForward) !== true) return false;
+		const count = toValue(options.count);
+		const range = toValue(options.range) ?? null;
+		const threshold = readThreshold(options.threshold);
+		if (range === null) return direction === "forward" && count === 0;
+		return direction === "backward" ? range.startIndex <= threshold : range.endIndex >= count - 1 - threshold;
+	};
+	function settle(state, token) {
+		if (disposed || token !== state.token || state.aborter?.signal.aborted) return false;
+		state.aborter = null;
+		state.status.value = "idle";
+		return true;
+	}
+	function trigger(direction) {
+		const state = states[direction];
+		const load = direction === "backward" ? options.onLoadBackward : options.onLoadForward;
+		if (!load || state.status.value === "loading" || !shouldLoad(direction)) return;
+		const token = ++state.token;
+		const aborter = new AbortController();
+		state.aborter = aborter;
+		state.status.value = "loading";
+		const context = Object.freeze({
+			direction,
+			signal: aborter.signal
+		});
+		let result;
+		try {
+			result = load(context);
+		} catch (error) {
+			if (settle(state, token)) {
+				if (!options.onLoadError) throw error;
+				options.onLoadError(direction, error);
+			}
+			return;
+		}
+		Promise.resolve(result).then(() => {
+			if (settle(state, token)) check();
+		}, (error) => {
+			if (!settle(state, token)) return;
+			if (options.onLoadError) options.onLoadError(direction, error);
+			else throw error;
+		});
+	}
+	function check() {
+		if (disposed) return;
+		trigger("backward");
+		trigger("forward");
+	}
+	function cancel(direction) {
+		for (const name of ["backward", "forward"]) {
+			if (direction !== void 0 && direction !== name) continue;
+			const state = states[name];
+			state.token++;
+			state.aborter?.abort();
+			state.aborter = null;
+			state.status.value = "idle";
+		}
+	}
+	const stopWatch = watch(() => {
+		const range = toValue(options.range) ?? null;
+		return [
+			range?.startIndex ?? -1,
+			range?.endIndex ?? -1,
+			toValue(options.count),
+			toValue(options.canLoadBackward) === true,
+			toValue(options.canLoadForward) === true
+		];
+	}, () => check(), { flush: "sync" });
+	check();
+	return Object.freeze({
+		backwardStatus: shallowReadonly(states.backward.status),
+		forwardStatus: shallowReadonly(states.forward.status),
+		check: () => {
+			assertUsable();
+			check();
+		},
+		cancel: (direction) => {
+			assertUsable();
+			cancel(direction);
+		},
+		dispose() {
+			if (disposed) return;
+			cancel();
+			disposed = true;
+			stopWatch();
+		}
+	});
+}
+/** Create an infinite loader disposed with the current Vue effect scope. */
+function useInfiniteLoader(options) {
+	if (!getCurrentScope()) throw new Error(`${setupDiagnostic}: use inside component setup or an active effect scope`);
+	const controller = createInfiniteLoader(options);
+	onScopeDispose(controller.dispose);
+	return controller;
+}
+//#endregion
+export { createVirtualizer as a, useGridVirtualizer as i, useInfiniteLoader as n, useVirtualizer as o, createGridVirtualizer as r, createInfiniteLoader as t };