@sdata/web-vue 1.9.0 → 1.11.0

package/es/_components/virtual-list/virtual-list.vue_vue_type_script_lang.js

@@ -0,0 +1,742 @@
+import { _objectSpread2 } from "../../_virtual/_@oxc-project_runtime@0.124.0/helpers/objectSpread2.js";
+import { getPrefixCls } from "../../_utils/global-config.js";
+import { isObject, isString } from "../../_utils/is.js";
+import { useVirtualSize } from "./use-virtual-size.js";
+import { _asyncToGenerator } from "../../_virtual/_@oxc-project_runtime@0.124.0/helpers/asyncToGenerator.js";
+import { computed, defineComponent, nextTick, onBeforeUnmount, onMounted, onUpdated, ref, watch } from "vue";
+import { OverlayScrollbars } from "overlayscrollbars";
+import { DynamicScroller, DynamicScrollerItem, RecycleScroller } from "vue-virtual-scroller";
+//#region components/_components/virtual-list/virtual-list.vue?vue&type=script&lang.ts
+var virtual_list_vue_vue_type_script_lang_default = defineComponent({
+	name: "VirtualList",
+	components: {
+		RecycleScroller,
+		DynamicScroller,
+		DynamicScrollerItem
+	},
+	props: {
+		items: {
+			type: Array,
+			default: () => []
+		},
+		height: {
+			type: [Number, String],
+			default: void 0
+		},
+		keyField: {
+			type: [String, Function],
+			default: "key"
+		},
+		direction: {
+			type: String,
+			default: "vertical"
+		},
+		listTag: {
+			type: String,
+			default: "div"
+		},
+		itemTag: {
+			type: String,
+			default: "div"
+		},
+		itemSize: {
+			type: [
+				Number,
+				Function,
+				Object
+			],
+			default: void 0
+		},
+		gridItems: Number,
+		itemSecondarySize: Number,
+		minItemSize: {
+			type: [Number, String],
+			default: void 0
+		},
+		sizeField: String,
+		typeField: String,
+		buffer: Number,
+		shift: Boolean,
+		cache: Object,
+		prerender: Number,
+		emitUpdate: Boolean,
+		disableTransform: Boolean,
+		flowMode: Boolean,
+		hiddenPosition: Number,
+		updateInterval: Number,
+		skipHover: Boolean,
+		enabled: {
+			type: Boolean,
+			default: true
+		},
+		listClass: { type: [
+			String,
+			Object,
+			Array
+		] },
+		itemClass: { type: [
+			String,
+			Object,
+			Array
+		] },
+		threshold: {
+			type: Number,
+			default: 0
+		},
+		fixedSize: {
+			type: Boolean,
+			default: false
+		},
+		estimatedSize: {
+			type: Number,
+			default: void 0
+		},
+		component: {
+			type: [String, Object],
+			default: void 0
+		},
+		listAttrs: {
+			type: Object,
+			default: void 0
+		},
+		contentWrapperAttrs: {
+			type: Object,
+			default: void 0
+		},
+		contentAttrs: {
+			type: Object,
+			default: void 0
+		},
+		listStyle: {
+			type: Object,
+			default: void 0
+		},
+		paddingPosition: {
+			type: String,
+			default: "content"
+		},
+		scrollbar: {
+			type: [Boolean, Object],
+			default: true
+		}
+	},
+	emits: {
+		scroll: (_ev) => true,
+		reachBottom: (_ev) => true,
+		resize: () => true,
+		visible: () => true,
+		hidden: () => true,
+		update: (_startIndex, _endIndex, _visibleStartIndex, _visibleEndIndex) => true,
+		scrollStart: () => true,
+		scrollEnd: () => true
+	},
+	setup(props, { emit, expose }) {
+		const prefixCls = getPrefixCls("virtual-list");
+		const scrollbarHostRef = ref();
+		const scrollerRef = ref();
+		const viewportRef = ref();
+		const compatItemRefs = /* @__PURE__ */ new Map();
+		const osInstanceRef = ref(null);
+		const overlayViewportReadyRef = ref(false);
+		const resolvedItems = computed(() => {
+			var _props$items;
+			return (_props$items = props.items) !== null && _props$items !== void 0 ? _props$items : [];
+		});
+		const isCompatMode = computed(() => {
+			return Boolean(props.component || props.listAttrs || props.contentWrapperAttrs || props.contentAttrs || props.listStyle || props.paddingPosition !== "content");
+		});
+		const hasCompatContentWrapper = computed(() => {
+			return Boolean(props.contentWrapperAttrs || isObject(props.component) && props.component.item);
+		});
+		const resolvedScrollbarProps = computed(() => {
+			if (!props.scrollbar) return;
+			if (typeof props.scrollbar === "boolean") return { type: "embed" };
+			return _objectSpread2({ type: "embed" }, props.scrollbar);
+		});
+		const hostClassNames = computed(() => {
+			var _resolvedScrollbarPro;
+			return [
+				prefixCls,
+				resolvedScrollbarProps.value && "sd-scrollbar",
+				resolvedScrollbarProps.value && `sd-scrollbar-type-${(_resolvedScrollbarPro = resolvedScrollbarProps.value.type) !== null && _resolvedScrollbarPro !== void 0 ? _resolvedScrollbarPro : "embed"}`,
+				resolvedScrollbarProps.value && `${prefixCls}-scrollbar`
+			];
+		});
+		const containerOuterStyle = computed(() => {
+			if (props.height === void 0) return;
+			return { height: typeof props.height === "number" ? `${props.height}px` : props.height };
+		});
+		const resolvedHeightValue = computed(() => {
+			if (props.height === void 0) return;
+			return typeof props.height === "number" ? `${props.height}px` : props.height;
+		});
+		const mergedCompatComponent = computed(() => {
+			var _props$component;
+			if (isObject(props.component)) return _objectSpread2({
+				container: "div",
+				list: "div",
+				content: "div",
+				item: "div"
+			}, props.component);
+			return {
+				container: (_props$component = props.component) !== null && _props$component !== void 0 ? _props$component : "div",
+				list: "div",
+				content: "div",
+				item: "div"
+			};
+		});
+		const compatFixedSize = computed(() => {
+			return props.fixedSize || typeof props.itemSize === "number";
+		});
+		const compatEstimatedSize = computed(() => {
+			if (props.estimatedSize !== void 0) return props.estimatedSize;
+			if (typeof props.itemSize === "number") return props.itemSize;
+			if (typeof props.minItemSize === "number") return props.minItemSize;
+		});
+		const compatViewportSize = ref(0);
+		const compatResolvedItemSize = computed(() => {
+			var _compatEstimatedSize$;
+			return (_compatEstimatedSize$ = compatEstimatedSize.value) !== null && _compatEstimatedSize$ !== void 0 ? _compatEstimatedSize$ : 30;
+		});
+		const compatBuffer = computed(() => {
+			var _props$buffer;
+			return (_props$buffer = props.buffer) !== null && _props$buffer !== void 0 ? _props$buffer : 200;
+		});
+		const compatOverscan = computed(() => {
+			const baseItemSize = Math.max(compatResolvedItemSize.value, 1);
+			return Math.max(Math.ceil(compatBuffer.value / baseItemSize), 0);
+		});
+		const compatVisibleCount = computed(() => {
+			const baseItemSize = Math.max(compatResolvedItemSize.value, 1);
+			if (compatViewportSize.value <= 0) return 1;
+			return Math.max(Math.ceil(compatViewportSize.value / baseItemSize), 1);
+		});
+		const getCompatItemKey = (item, index) => {
+			const keyField = props.keyField;
+			if (typeof keyField === "function") return keyField(item, index);
+			if (item && typeof item === "object" && isString(keyField)) {
+				var _item$keyField;
+				return (_item$keyField = item[keyField]) !== null && _item$keyField !== void 0 ? _item$keyField : index;
+			}
+			return index;
+		};
+		const { frontPadding: compatFrontPadding, behindPadding: compatBehindPadding, start: compatStartRef, end: compatEnd, getStartByScroll: getCompatStartByScroll, setItemSize: compatSetItemSize, setStart: setCompatStart, getScrollOffset: getCompatScrollOffset, getItemSize: getCompatItemSize } = useVirtualSize({
+			dataKeys: computed(() => {
+				return resolvedItems.value.map((item, index) => getCompatItemKey(item, index));
+			}),
+			fixedSize: compatFixedSize,
+			estimatedSize: compatEstimatedSize,
+			overscan: compatOverscan,
+			visibleCount: compatVisibleCount
+		});
+		const compatCurrentList = computed(() => {
+			if (!isCompatMode.value) return [];
+			if (props.threshold && resolvedItems.value.length <= props.threshold) return resolvedItems.value;
+			return resolvedItems.value.slice(compatStartRef.value, compatEnd.value);
+		});
+		const compatStart = computed(() => {
+			if (props.threshold && resolvedItems.value.length <= props.threshold) return 0;
+			return compatStartRef.value;
+		});
+		const compatViewportStyle = computed(() => {
+			const style = { minHeight: 0 };
+			if (resolvedHeightValue.value !== void 0) style.height = resolvedScrollbarProps.value && resolvedHeightValue.value !== "auto" ? "100%" : resolvedHeightValue.value;
+			if (!resolvedScrollbarProps.value || !overlayViewportReadyRef.value) if (props.direction === "horizontal") {
+				style.overflowX = "auto";
+				style.overflowY = "hidden";
+			} else {
+				style.overflowY = "auto";
+				style.overflowX = "hidden";
+			}
+			return style;
+		});
+		const compatListPaddingStyle = computed(() => {
+			if (props.paddingPosition !== "list") return;
+			return {
+				paddingTop: `${compatFrontPadding.value}px`,
+				paddingBottom: `${compatBehindPadding.value}px`
+			};
+		});
+		const compatContentPaddingStyle = computed(() => {
+			if (props.paddingPosition !== "content") return;
+			return {
+				paddingTop: `${compatFrontPadding.value}px`,
+				paddingBottom: `${compatBehindPadding.value}px`
+			};
+		});
+		const compatListStyle = computed(() => {
+			if (!props.listStyle && !compatListPaddingStyle.value) return;
+			return _objectSpread2(_objectSpread2({}, props.listStyle), compatListPaddingStyle.value);
+		});
+		const compatContentStyle = computed(() => {
+			return compatContentPaddingStyle.value;
+		});
+		const compatContentWrapperStyle = computed(() => {
+			if (!hasCompatContentWrapper.value || props.paddingPosition !== "content") return;
+			return compatContentStyle.value;
+		});
+		const updateCompatItemSize = (key, element) => {
+			const height = element.getBoundingClientRect().height || element.offsetHeight;
+			if (height) compatSetItemSize(key, height);
+		};
+		const updateCompatItemSizes = () => {
+			compatItemRefs.forEach((element, key) => {
+				updateCompatItemSize(key, element);
+			});
+		};
+		const updateCompatViewportSize = () => {
+			var _scrollerElement$clie, _scrollerElement$clie2;
+			if (!isCompatMode.value) {
+				compatViewportSize.value = 0;
+				return;
+			}
+			const scrollerElement = getScrollerElement();
+			const nextViewportSize = props.direction === "horizontal" ? (_scrollerElement$clie = scrollerElement === null || scrollerElement === void 0 ? void 0 : scrollerElement.clientWidth) !== null && _scrollerElement$clie !== void 0 ? _scrollerElement$clie : 0 : (_scrollerElement$clie2 = scrollerElement === null || scrollerElement === void 0 ? void 0 : scrollerElement.clientHeight) !== null && _scrollerElement$clie2 !== void 0 ? _scrollerElement$clie2 : 0;
+			if (nextViewportSize > 0) compatViewportSize.value = nextViewportSize;
+		};
+		const setCompatItemRef = (key, value) => {
+			var _value$$el;
+			const element = (_value$$el = value === null || value === void 0 ? void 0 : value.$el) !== null && _value$$el !== void 0 ? _value$$el : value;
+			if (!(element instanceof HTMLElement)) {
+				compatItemRefs.delete(key);
+				return;
+			}
+			compatItemRefs.set(key, element);
+			updateCompatItemSize(key, element);
+		};
+		const getCompatContentStyle = (index) => {
+			if (hasCompatContentWrapper.value) return;
+			if (props.paddingPosition !== "content") return compatContentStyle.value;
+			const style = _objectSpread2({}, compatContentStyle.value);
+			if (index === 0) style.paddingTop = `${compatFrontPadding.value}px`;
+			if (index === compatCurrentList.value.length - 1) style.paddingBottom = `${compatBehindPadding.value}px`;
+			return style;
+		};
+		const isDynamicScroller = computed(() => {
+			return !isCompatMode.value && props.itemSize === void 0;
+		});
+		const currentScroller = computed(() => {
+			return isDynamicScroller.value ? DynamicScroller : RecycleScroller;
+		});
+		const scrollerStyle = computed(() => {
+			const style = { minHeight: 0 };
+			if (resolvedHeightValue.value !== void 0) style.height = resolvedScrollbarProps.value ? "100%" : resolvedHeightValue.value;
+			if (!resolvedScrollbarProps.value || !overlayViewportReadyRef.value) if (props.direction === "horizontal") {
+				style.overflowX = "auto";
+				style.overflowY = "hidden";
+			} else {
+				style.overflowY = "auto";
+				style.overflowX = "hidden";
+			}
+			return style;
+		});
+		const resolvedOverlayOptions = computed(() => {
+			var _scrollbarProps$overl, _scrollbarProps$paddi, _scrollbarProps$showN, _scrollbarProps$updat;
+			const scrollbarProps = resolvedScrollbarProps.value;
+			if (!scrollbarProps) return null;
+			const overlayOptions = (_scrollbarProps$overl = scrollbarProps.overlayOptions) !== null && _scrollbarProps$overl !== void 0 ? _scrollbarProps$overl : {};
+			const isTrackType = scrollbarProps.type === "track";
+			return _objectSpread2(_objectSpread2({}, overlayOptions), {}, {
+				paddingAbsolute: (_scrollbarProps$paddi = scrollbarProps.paddingAbsolute) !== null && _scrollbarProps$paddi !== void 0 ? _scrollbarProps$paddi : overlayOptions.paddingAbsolute,
+				showNativeOverlaidScrollbars: (_scrollbarProps$showN = scrollbarProps.showNativeOverlaidScrollbars) !== null && _scrollbarProps$showN !== void 0 ? _scrollbarProps$showN : overlayOptions.showNativeOverlaidScrollbars,
+				update: (_scrollbarProps$updat = scrollbarProps.updateOptions) !== null && _scrollbarProps$updat !== void 0 ? _scrollbarProps$updat : overlayOptions.update,
+				overflow: _objectSpread2(_objectSpread2({
+					x: "scroll",
+					y: "scroll"
+				}, overlayOptions.overflow), scrollbarProps.overflow),
+				scrollbars: _objectSpread2(_objectSpread2({
+					theme: isTrackType ? "sd-scrollbar-theme-track" : "sd-scrollbar-theme-embed",
+					visibility: isTrackType ? "visible" : "auto",
+					autoHide: isTrackType ? "never" : "leave",
+					autoHideSuspend: true,
+					clickScroll: "instant"
+				}, overlayOptions.scrollbars), scrollbarProps.scrollbars)
+			});
+		});
+		const resolveOSInstance = () => {
+			const instance = osInstanceRef.value;
+			if (!instance || instance.state().destroyed) return null;
+			return instance;
+		};
+		const getScrollerElement = () => {
+			if (isCompatMode.value) {
+				var _viewportRef$value;
+				return (_viewportRef$value = viewportRef.value) !== null && _viewportRef$value !== void 0 ? _viewportRef$value : null;
+			}
+			const scroller = scrollerRef.value;
+			return (scroller === null || scroller === void 0 ? void 0 : scroller.$el) instanceof HTMLElement ? scroller.$el : null;
+		};
+		const getEstimatedItemSize = () => {
+			if (typeof props.itemSize === "number" && props.itemSize > 0) return props.itemSize;
+			if (typeof props.minItemSize === "number" && props.minItemSize > 0) return props.minItemSize;
+			return 32;
+		};
+		const shouldResetScrollForSmallList = (nextItems, previousItems) => {
+			const viewport = getScrollerElement();
+			if (!viewport || viewport.scrollTop <= 0 || !(previousItems === null || previousItems === void 0 ? void 0 : previousItems.length)) return false;
+			if (!nextItems.length) return true;
+			if (nextItems.length >= previousItems.length || props.shift) return false;
+			const estimatedItemSize = getEstimatedItemSize();
+			const visibleCount = Math.max(1, Math.ceil(viewport.clientHeight / estimatedItemSize));
+			return nextItems.length <= visibleCount * 2;
+		};
+		const clampScrollPosition = () => {
+			const viewport = getScrollerElement();
+			if (!viewport) return;
+			const maxScrollTop = Math.max(viewport.scrollHeight - viewport.clientHeight, 0);
+			if (viewport.scrollTop > maxScrollTop) scrollToPosition(maxScrollTop);
+		};
+		const refreshVisibleWindow = (itemsChanged = true) => {
+			if (isDynamicScroller.value) {
+				forceUpdate(true);
+				return;
+			}
+			updateVisibleItems(itemsChanged, true);
+		};
+		const waitForLayoutFrame = function() {
+			var _ref = _asyncToGenerator(function* () {
+				yield new Promise((resolve) => {
+					if (typeof requestAnimationFrame === "function") {
+						requestAnimationFrame(() => resolve());
+						return;
+					}
+					resolve();
+				});
+			});
+			return function waitForLayoutFrame() {
+				return _ref.apply(this, arguments);
+			};
+		}();
+		const destroyOverlayScrollbar = () => {
+			var _osInstanceRef$value;
+			overlayViewportReadyRef.value = false;
+			(_osInstanceRef$value = osInstanceRef.value) === null || _osInstanceRef$value === void 0 || _osInstanceRef$value.destroy();
+			osInstanceRef.value = null;
+		};
+		const initOverlayScrollbar = function() {
+			var _ref2 = _asyncToGenerator(function* (waitForDom = true) {
+				destroyOverlayScrollbar();
+				if (!resolvedOverlayOptions.value) return;
+				if (waitForDom) yield nextTick();
+				const host = scrollbarHostRef.value;
+				const viewport = getScrollerElement();
+				if (!host || !viewport) return;
+				osInstanceRef.value = OverlayScrollbars({
+					target: host,
+					elements: {
+						viewport,
+						padding: false,
+						content: false
+					}
+				}, resolvedOverlayOptions.value, { scroll: (_instance, event) => {
+					if (!isCompatMode.value) onScroll(event);
+				} });
+				overlayViewportReadyRef.value = true;
+			});
+			return function initOverlayScrollbar() {
+				return _ref2.apply(this, arguments);
+			};
+		}();
+		onMounted(_asyncToGenerator(function* () {
+			yield nextTick();
+			updateCompatViewportSize();
+			initOverlayScrollbar(false);
+		}));
+		onUpdated(() => {
+			if (isCompatMode.value) {
+				updateCompatItemSizes();
+				updateCompatViewportSize();
+			}
+		});
+		watch([currentScroller, resolvedOverlayOptions], _asyncToGenerator(function* () {
+			if (!resolvedOverlayOptions.value) {
+				destroyOverlayScrollbar();
+				return;
+			}
+			yield nextTick();
+			const viewport = getScrollerElement();
+			const osInstance = resolveOSInstance();
+			if (!viewport || !scrollbarHostRef.value) return;
+			if (!osInstance || osInstance.elements().viewport !== viewport) {
+				yield initOverlayScrollbar(true);
+				return;
+			}
+			osInstance.options(resolvedOverlayOptions.value);
+			osInstance.update(true);
+		}), { deep: true });
+		watch(() => resolvedItems.value, function() {
+			var _ref3 = _asyncToGenerator(function* (nextItems, previousItems) {
+				var _resolveOSInstance, _resolveOSInstance2;
+				yield nextTick();
+				if (isCompatMode.value) {
+					updateCompatItemSizes();
+					updateCompatViewportSize();
+				}
+				(_resolveOSInstance = resolveOSInstance()) === null || _resolveOSInstance === void 0 || _resolveOSInstance.update(true);
+				yield waitForLayoutFrame();
+				if (shouldResetScrollForSmallList(nextItems, previousItems)) {
+					scrollToPosition(0);
+					yield waitForLayoutFrame();
+				}
+				refreshVisibleWindow(true);
+				yield nextTick();
+				yield waitForLayoutFrame();
+				clampScrollPosition();
+				(_resolveOSInstance2 = resolveOSInstance()) === null || _resolveOSInstance2 === void 0 || _resolveOSInstance2.update(true);
+				yield nextTick();
+				yield waitForLayoutFrame();
+				refreshVisibleWindow(true);
+			});
+			return function(_x, _x2) {
+				return _ref3.apply(this, arguments);
+			};
+		}(), { deep: true });
+		onBeforeUnmount(() => {
+			destroyOverlayScrollbar();
+		});
+		const scrollerProps = computed(() => {
+			const commonProps = {
+				items: resolvedItems.value,
+				height: props.height,
+				keyField: props.keyField,
+				direction: props.direction,
+				listTag: props.listTag,
+				itemTag: props.itemTag,
+				shift: props.shift,
+				cache: props.cache,
+				disableTransform: props.disableTransform,
+				flowMode: props.flowMode,
+				hiddenPosition: props.hiddenPosition,
+				enabled: props.enabled
+			};
+			if (isDynamicScroller.value) {
+				var _props$minItemSize;
+				return _objectSpread2(_objectSpread2({}, commonProps), {}, { minItemSize: (_props$minItemSize = props.minItemSize) !== null && _props$minItemSize !== void 0 ? _props$minItemSize : 32 });
+			}
+			return _objectSpread2(_objectSpread2({}, commonProps), {}, {
+				itemSize: props.itemSize,
+				gridItems: props.gridItems,
+				itemSecondarySize: props.itemSecondarySize,
+				minItemSize: props.minItemSize,
+				sizeField: props.sizeField,
+				typeField: props.typeField,
+				buffer: props.buffer,
+				prerender: props.prerender,
+				emitUpdate: props.emitUpdate,
+				updateInterval: props.updateInterval,
+				skipHover: props.skipHover,
+				listClass: props.listClass,
+				itemClass: props.itemClass
+			});
+		});
+		const onScroll = (ev) => {
+			emit("scroll", ev);
+			const target = ev.target;
+			if (!target) return;
+			if (Math.floor(target.scrollHeight - (target.scrollTop + target.clientHeight)) <= 0) emit("reachBottom", ev);
+		};
+		const onCompatScroll = (ev) => {
+			const target = ev.target;
+			if (target) {
+				const nextStart = getCompatStartByScroll(target.scrollTop);
+				if (nextStart !== compatStartRef.value) setCompatStart(nextStart);
+			}
+			onScroll(ev);
+		};
+		const onScrollEnd = () => {
+			var _osInstance$elements$;
+			emit("scrollEnd");
+			const osInstance = resolveOSInstance();
+			if (!(osInstance ? (_osInstance$elements$ = osInstance.elements().scrollOffsetElement) !== null && _osInstance$elements$ !== void 0 ? _osInstance$elements$ : osInstance.elements().viewport : getScrollerElement())) return;
+			emit("reachBottom", new Event("scroll"));
+		};
+		const scrollerListeners = computed(() => {
+			if (isDynamicScroller.value) return {
+				resize: () => emit("resize"),
+				visible: () => emit("visible")
+			};
+			return {
+				resize: () => emit("resize"),
+				visible: () => emit("visible"),
+				hidden: () => emit("hidden"),
+				update: (startIndex, endIndex, visibleStartIndex, visibleEndIndex) => emit("update", startIndex, endIndex, visibleStartIndex, visibleEndIndex),
+				scrollStart: () => emit("scrollStart"),
+				scrollEnd: onScrollEnd
+			};
+		});
+		const normalizeAlign = (align) => {
+			if (!align || align === "auto") return "nearest";
+			if (align === "top") return "start";
+			if (align === "bottom") return "end";
+			return align;
+		};
+		const getSlotItemWithSize = (slotProps) => {
+			return "itemWithSize" in slotProps ? slotProps.itemWithSize : void 0;
+		};
+		const getScroller = () => scrollerRef.value;
+		const scrollToItem = (index, options) => {
+			var _getScroller;
+			if (isCompatMode.value) {
+				scrollTo({
+					index,
+					align: (options === null || options === void 0 ? void 0 : options.smooth) ? "auto" : void 0,
+					smooth: options === null || options === void 0 ? void 0 : options.smooth,
+					offset: options === null || options === void 0 ? void 0 : options.offset
+				});
+				return;
+			}
+			(_getScroller = getScroller()) === null || _getScroller === void 0 || _getScroller.scrollToItem(index, options);
+		};
+		const scrollToPosition = (position, options) => {
+			var _getScroller2;
+			if (isCompatMode.value) {
+				const viewport = getScrollerElement();
+				if (!viewport) return;
+				if (options === null || options === void 0 ? void 0 : options.smooth) viewport.scrollTo({
+					top: position,
+					behavior: "smooth"
+				});
+				else viewport.scrollTop = position;
+				return;
+			}
+			(_getScroller2 = getScroller()) === null || _getScroller2 === void 0 || _getScroller2.scrollToPosition(position, options);
+		};
+		const findItemIndex = (offset) => {
+			var _getScroller$findItem, _getScroller3;
+			if (isCompatMode.value) return getCompatStartByScroll(offset);
+			return (_getScroller$findItem = (_getScroller3 = getScroller()) === null || _getScroller3 === void 0 ? void 0 : _getScroller3.findItemIndex(offset)) !== null && _getScroller$findItem !== void 0 ? _getScroller$findItem : -1;
+		};
+		const getItemOffset = (index) => {
+			var _getScroller$getItemO, _getScroller4;
+			if (isCompatMode.value) return getCompatScrollOffset(index);
+			return (_getScroller$getItemO = (_getScroller4 = getScroller()) === null || _getScroller4 === void 0 ? void 0 : _getScroller4.getItemOffset(index)) !== null && _getScroller$getItemO !== void 0 ? _getScroller$getItemO : 0;
+		};
+		const getItemSize = (index) => {
+			var _getScroller$getItemS, _getScroller5;
+			if (isCompatMode.value) return getCompatItemSize(index);
+			if (isDynamicScroller.value) {
+				const dynamicScroller = getScroller();
+				if (!dynamicScroller) return 0;
+				return dynamicScroller.getItemSize(resolvedItems.value[index], index);
+			}
+			return (_getScroller$getItemS = (_getScroller5 = getScroller()) === null || _getScroller5 === void 0 ? void 0 : _getScroller5.getItemSize(index)) !== null && _getScroller$getItemS !== void 0 ? _getScroller$getItemS : 0;
+		};
+		const cacheSnapshot = () => {
+			const scroller = getScroller();
+			if (!(scroller === null || scroller === void 0 ? void 0 : scroller.cacheSnapshot)) return;
+			if ("value" in scroller.cacheSnapshot) return scroller.cacheSnapshot.value;
+			return scroller.cacheSnapshot;
+		};
+		const restoreCache = (snapshot) => {
+			var _getScroller$restoreC, _getScroller6;
+			return (_getScroller$restoreC = (_getScroller6 = getScroller()) === null || _getScroller6 === void 0 ? void 0 : _getScroller6.restoreCache(snapshot)) !== null && _getScroller$restoreC !== void 0 ? _getScroller$restoreC : false;
+		};
+		const updateVisibleItems = (itemsChanged, checkPositionDiff) => {
+			const scroller = getScroller();
+			scroller === null || scroller === void 0 || scroller.updateVisibleItems(itemsChanged, checkPositionDiff);
+		};
+		const scrollToBottom = () => {
+			if (isCompatMode.value) {
+				const viewport = getScrollerElement();
+				if (!viewport) return;
+				scrollToPosition(viewport.scrollHeight);
+				return;
+			}
+			const scroller = getScroller();
+			scroller === null || scroller === void 0 || scroller.scrollToBottom();
+		};
+		const forceUpdate = (clear) => {
+			if (isCompatMode.value) {
+				if (clear) setCompatStart(0);
+				return;
+			}
+			const scroller = getScroller();
+			scroller === null || scroller === void 0 || scroller.forceUpdate(clear);
+		};
+		const getDynamicItemSize = (item, index) => {
+			var _scroller$getItemSize;
+			if (isCompatMode.value) return typeof index === "number" ? getCompatItemSize(index) : 0;
+			const scroller = getScroller();
+			return (_scroller$getItemSize = scroller === null || scroller === void 0 ? void 0 : scroller.getItemSize(item, index)) !== null && _scroller$getItemSize !== void 0 ? _scroller$getItemSize : 0;
+		};
+		const scrollTo = (options) => {
+			if (typeof options === "number") {
+				scrollToPosition(options);
+				return;
+			}
+			let index = options.index;
+			if (typeof index !== "number" && options.key !== void 0) {
+				const keyField = props.keyField;
+				index = resolvedItems.value.findIndex((item, currentIndex) => {
+					if (typeof keyField === "function") return keyField(item, currentIndex) === options.key;
+					if (item && typeof item === "object" && isString(keyField)) return item[keyField] === options.key;
+					return currentIndex === options.key;
+				});
+			}
+			if (typeof index !== "number" || index < 0) return;
+			if (isCompatMode.value) {
+				setCompatStart(index - compatOverscan.value);
+				scrollToPosition(getCompatScrollOffset(index), {
+					smooth: options.smooth,
+					offset: options.offset
+				});
+				nextTick(() => {
+					const scrollTop = getCompatScrollOffset(index);
+					const viewport = getScrollerElement();
+					if (viewport && scrollTop !== viewport.scrollTop) viewport.scrollTop = scrollTop;
+				});
+				return;
+			}
+			scrollToItem(index, {
+				align: normalizeAlign(options.align),
+				smooth: options.smooth,
+				offset: options.offset
+			});
+		};
+		expose({
+			scrollToItem,
+			scrollToPosition,
+			findItemIndex,
+			getItemOffset,
+			getItemSize,
+			cacheSnapshot,
+			restoreCache,
+			updateVisibleItems,
+			scrollToBottom,
+			forceUpdate,
+			getDynamicItemSize,
+			scrollTo
+		});
+		return {
+			prefixCls,
+			props,
+			hostClassNames,
+			scrollbarHostRef,
+			scrollerRef,
+			viewportRef,
+			isCompatMode,
+			mergedCompatComponent,
+			hasCompatContentWrapper,
+			compatViewportStyle,
+			compatListStyle,
+			compatContentStyle,
+			compatContentWrapperStyle,
+			compatCurrentList,
+			compatStart,
+			getCompatItemKey,
+			setCompatItemRef,
+			getCompatContentStyle,
+			onCompatScroll,
+			currentScroller,
+			isDynamicScroller,
+			containerOuterStyle,
+			scrollerStyle,
+			scrollerProps,
+			scrollerListeners,
+			getSlotItemWithSize,
+			onScroll
+		};
+	}
+});
+//#endregion
+export { virtual_list_vue_vue_type_script_lang_default as default };