@sdata/web-vue 1.9.0 → 1.10.0

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

@@ -0,0 +1,470 @@
+import { _objectSpread2 } from "../../_virtual/_@oxc-project_runtime@0.124.0/helpers/objectSpread2.js";
+import { getPrefixCls } from "../../_utils/global-config.js";
+import { isString } from "../../_utils/is.js";
+import { _asyncToGenerator } from "../../_virtual/_@oxc-project_runtime@0.124.0/helpers/asyncToGenerator.js";
+import { computed, defineComponent, nextTick, onBeforeUnmount, onMounted, 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
+		] },
+		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 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 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 isDynamicScroller = computed(() => {
+			return 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 = () => {
+			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) => {
+					onScroll(event);
+				} });
+				overlayViewportReadyRef.value = true;
+			});
+			return function initOverlayScrollbar() {
+				return _ref2.apply(this, arguments);
+			};
+		}();
+		onMounted(() => {
+			initOverlayScrollbar(false);
+		});
+		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();
+				(_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 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;
+			(_getScroller = getScroller()) === null || _getScroller === void 0 || _getScroller.scrollToItem(index, options);
+		};
+		const scrollToPosition = (position, options) => {
+			var _getScroller2;
+			(_getScroller2 = getScroller()) === null || _getScroller2 === void 0 || _getScroller2.scrollToPosition(position, options);
+		};
+		const findItemIndex = (offset) => {
+			var _getScroller$findItem, _getScroller3;
+			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;
+			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 (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 = () => {
+			const scroller = getScroller();
+			scroller === null || scroller === void 0 || scroller.scrollToBottom();
+		};
+		const forceUpdate = (clear) => {
+			const scroller = getScroller();
+			scroller === null || scroller === void 0 || scroller.forceUpdate(clear);
+		};
+		const getDynamicItemSize = (item, index) => {
+			var _scroller$getItemSize;
+			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;
+			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,
+			hostClassNames,
+			scrollbarHostRef,
+			scrollerRef,
+			currentScroller,
+			isDynamicScroller,
+			containerOuterStyle,
+			scrollerStyle,
+			scrollerProps,
+			scrollerListeners,
+			getSlotItemWithSize,
+			onScroll
+		};
+	}
+});
+//#endregion
+export { virtual_list_vue_vue_type_script_lang_default as default };

package/es/_hooks/use-allow-clear.d.ts

@@ -1,4 +1,4 @@
 import { Ref } from 'vue';
-export declare const useAllowClear: (allowClear?: Ref<boolean | undefined>) => {
+export declare const useAllowClear: (allowClear?: Ref<boolean | undefined>, extraPropNames?: readonly string[]) => {
     mergedAllowClear: import("vue").ComputedRef<boolean | undefined>;
 };

package/es/_hooks/use-allow-clear.js

@@ -2,13 +2,13 @@ import { configProviderInjectionKey } from "../config-provider/context.js";
 import { computed, getCurrentInstance, inject } from "vue";
 //#region components/_hooks/use-allow-clear.ts
 var ALLOW_CLEAR_PROP_NAMES = ["allowClear", "allow-clear"];
-var useAllowClear = (allowClear) => {
+var useAllowClear = (allowClear, extraPropNames = []) => {
 	const instance = getCurrentInstance();
 	const configProviderCtx = inject(configProviderInjectionKey, void 0);
 	const hasAllowClearProp = computed(() => {
 		const rawProps = instance === null || instance === void 0 ? void 0 : instance.vnode.props;
 		if (!rawProps) return false;
-		return ALLOW_CLEAR_PROP_NAMES.some((propName) => Object.prototype.hasOwnProperty.call(rawProps, propName));
+		return [...ALLOW_CLEAR_PROP_NAMES, ...extraPropNames].some((propName) => Object.hasOwn(rawProps, propName));
 	});
 	return { mergedAllowClear: computed(() => {
 		if (hasAllowClearProp.value) return allowClear === null || allowClear === void 0 ? void 0 : allowClear.value;

package/es/_hooks/use-pure-prop.js

@@ -1,9 +1,9 @@
 import { isEqual } from "../_utils/is-equal.js";
-import { ref, toRef, watch } from "vue";
+import { shallowRef, toRef, watch } from "vue";
 //#region components/_hooks/use-pure-prop.ts
 var usePureProp = (props, name) => {
 	const _value = toRef(props, name);
-	const value = ref(_value.value);
+	const value = shallowRef(_value.value);
 	watch(_value, (cur, pre) => {
 		if (!isEqual(cur, pre)) value.value = cur;
 	});

package/es/_hooks/use-resize-observer.d.ts

@@ -1,7 +1,7 @@
 import { Ref } from 'vue';
 export declare const useResizeObserver: ({ elementRef, onResize, }: {
     elementRef: Ref<HTMLElement | undefined>;
-    onResize: () => void;
+    onResize: (entry: ResizeObserverEntry) => void;
 }) => {
     createResizeObserver: () => void;
     destroyResizeObserver: () => void;

package/es/_utils/date.d.ts

@@ -29,7 +29,5 @@ export declare function getDateValue(value: (Dayjs | undefined)[] | undefined):
 export declare function getDateValue(value: Dayjs | (Dayjs | undefined)[]): Date | (Date | undefined)[];
 export declare function getDateValue(value: Dayjs | (Dayjs | undefined)[] | undefined): Date | (Date | undefined)[] | undefined;
 export declare function initializeDateLocale(localeName: string, weekStart: number): void;
-export declare function pickDataAttributes<T extends Record<string, any>, K extends keyof T>(obj: T): {
-    [key in K]: any;
-};
+export declare function pickDataAttributes<T extends Record<string, unknown>>(obj: T): Record<`data-${string}` | `aria-${string}`, unknown>;
 export {};

package/es/_utils/date.js

@@ -116,7 +116,7 @@ function initializeDateLocale(localeName, weekStart) {
 function pickDataAttributes(obj) {
 	const clone = {};
 	obj && Object.keys(obj).forEach((key) => {
-		const k = String(key);
+		const k = key;
 		if (k.indexOf("data-") === 0) clone[k] = obj[k];
 		if (k.indexOf("aria-") === 0) clone[k] = obj[k];
 	});

package/es/_utils/raf.d.ts

@@ -1,3 +1,3 @@
-declare const raf: any;
-declare const caf: any;
+declare const raf: typeof requestAnimationFrame;
+declare const caf: typeof cancelAnimationFrame;
 export { raf, caf };

package/es/_utils/style.d.ts

@@ -1,3 +1,3 @@
 export declare function fixedWidth(width: number): Record<string, unknown>;
 export declare function setTransformStyle(value: string): Record<string, unknown>;
-export declare function getStyle(element: HTMLElement | null, prop: string | null): string | number | CSSRule | ((index: number) => string) | ((property: string, value: string | null, priority?: string) => void) | null;
+export declare function getStyle(element: HTMLElement | null, prop: string | null): string | number | ((index: number) => string) | CSSRule | ((property: string, value: string | null, priority?: string) => void) | null;

package/es/_utils/use-prop-or-slot.d.ts

@@ -1,7 +1,5 @@
 import { Slots } from 'vue';
-export default function usePropOrSlot<T = {
+export default function usePropOrSlot<T extends Record<string, unknown>>(props: T, slots: Slots, propName: keyof T & string): import("vue").ComputedRef<import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
     [key: string]: any;
-}>(props: T, slots: Slots, propName: string): import("vue").ComputedRef<any>;
-export declare function hasPropOrSlot<T = {
-    [key: string]: any;
-}>(props: T, slots: Slots, propName: string): import("vue").ComputedRef<boolean>;
+}>[] | NonNullable<T[keyof T & string]> | undefined>;
+export declare function hasPropOrSlot<T extends Record<string, unknown>>(props: T, slots: Slots, propName: keyof T & string): import("vue").ComputedRef<boolean>;

package/es/_utils/virtual-dropdown.d.ts

@@ -0,0 +1,4 @@
+import type { VirtualListProps } from '../_components/virtual-list/interface';
+import type { TriggerProps } from '../trigger';
+export declare const DEFAULT_VIRTUAL_DROPDOWN_HEIGHT = "200px";
+export declare function resolveDropdownVirtualListProps(virtualListProps?: VirtualListProps, triggerProps?: Pick<TriggerProps, 'popupStyle'>, defaultItemSize?: number): VirtualListProps | undefined;

package/es/_utils/virtual-dropdown.js

@@ -0,0 +1,17 @@
+import { _objectSpread2 } from "../_virtual/_@oxc-project_runtime@0.124.0/helpers/objectSpread2.js";
+//#region components/_utils/virtual-dropdown.ts
+var DEFAULT_VIRTUAL_DROPDOWN_HEIGHT = "200px";
+function resolveDropdownVirtualListProps(virtualListProps, triggerProps, defaultItemSize) {
+	var _ref, _popupStyle$maxHeight;
+	if (!virtualListProps) return;
+	const nextVirtualListProps = _objectSpread2({}, virtualListProps);
+	if (nextVirtualListProps.itemSize === void 0 && nextVirtualListProps.minItemSize === void 0) {
+		if (defaultItemSize !== void 0) nextVirtualListProps.itemSize = defaultItemSize;
+	}
+	if (nextVirtualListProps.height !== void 0) return nextVirtualListProps;
+	const popupStyle = triggerProps === null || triggerProps === void 0 ? void 0 : triggerProps.popupStyle;
+	const fallbackHeight = (_ref = (_popupStyle$maxHeight = popupStyle === null || popupStyle === void 0 ? void 0 : popupStyle.maxHeight) !== null && _popupStyle$maxHeight !== void 0 ? _popupStyle$maxHeight : popupStyle === null || popupStyle === void 0 ? void 0 : popupStyle.height) !== null && _ref !== void 0 ? _ref : DEFAULT_VIRTUAL_DROPDOWN_HEIGHT;
+	return _objectSpread2(_objectSpread2({}, nextVirtualListProps), {}, { height: fallbackHeight });
+}
+//#endregion
+export { resolveDropdownVirtualListProps };