@hoci/core 0.8.0 → 0.9.0

package/dist/index.js

@@ -0,0 +1,910 @@
+import { n as __reExport, t as __exportAll } from "./chunk-DzK395Rf.js";
+import { classPropType, defineHookComponent, defineHookEmits, defineHookProps, elementRef, getFirstChilld, isWindow, labelPropType, throttleByRaf, toArray, toReactive, useElement, useSharedConfig, valuePropType } from "@hoci/shared";
+import { isDefined, onClickOutside, syncRef, tryOnScopeDispose, useElementBounding, useElementVisibility, useEventListener, useVModel } from "@vueuse/core";
+import { cls, createUnitFormat, px } from "tslx";
+import { computed, inject, nextTick, provide, reactive, ref, renderSlot, shallowRef, triggerRef, watch, watchPostEffect } from "vue";
+import { Virtualizer, elementScroll, observeElementOffset, observeElementRect } from "@tanstack/virtual-core";
+
+export * from "@hoci/shared"
+
+//#region src/affix/index.ts
+const affixProps = defineHookProps({
+	fixedClass: {
+		type: String,
+		default: ""
+	},
+	offset: {
+		type: Number,
+		default: 0
+	},
+	position: {
+		type: String,
+		default: "top"
+	},
+	target: { type: [
+		String,
+		Object,
+		Function
+	] },
+	zIndex: {
+		type: Number,
+		default: 998
+	}
+});
+const affixEmits = defineHookEmits(["scroll", "change"]);
+const AFFIX_TARGET_KEY = Symbol("AFFIX_TARGET_KEY");
+function getTargetRect(target) {
+	return isWindow(target) ? {
+		top: 0,
+		bottom: window.innerHeight
+	} : target.getBoundingClientRect();
+}
+const useAffix = defineHookComponent({
+	props: affixProps,
+	setup(props, { emit }) {
+		const wrapperRef = elementRef();
+		const wrapperRect = toReactive(useElementBounding(wrapperRef));
+		const parentRef = inject(AFFIX_TARGET_KEY, void 0);
+		const targetRef = useElement(props.target, parentRef);
+		const isFixed = ref(false);
+		const placeholderStyle = ref({});
+		const fixedStyle = ref({});
+		const className = computed(() => {
+			return isFixed.value ? props.fixedClass : "";
+		});
+		const wrapperVisible = useElementVisibility(wrapperRef);
+		const containerRef = computed(() => {
+			if (!wrapperVisible.value) return null;
+			return targetRef.value ?? window;
+		});
+		const updatePosition = throttleByRaf(async () => {
+			if (!wrapperRef.value || !containerRef.value) return;
+			if (wrapperRect.width * wrapperRect.height === 0) return;
+			const newPlaceholderStyles = {
+				width: px(wrapperRect.width),
+				height: px(wrapperRect.height)
+			};
+			const targetRect = getTargetRect(containerRef.value);
+			let newIsFixed = false;
+			let newFixedStyles = {};
+			const offset = props.offset;
+			if (props.position === "top") {
+				newIsFixed = wrapperRect.top - targetRect.top < offset && offset >= 0;
+				newFixedStyles = newIsFixed ? {
+					position: "fixed",
+					zIndex: props.zIndex,
+					top: px(targetRect.top + offset)
+				} : {};
+			} else {
+				newIsFixed = targetRect.bottom - wrapperRect.bottom < offset;
+				newFixedStyles = newIsFixed ? {
+					position: "fixed",
+					bottom: px(window.innerHeight - targetRect.bottom + offset)
+				} : {};
+			}
+			if (newIsFixed !== isFixed.value) {
+				isFixed.value = newIsFixed;
+				emit("change", newIsFixed);
+			}
+			placeholderStyle.value = newPlaceholderStyles;
+			fixedStyle.value = {
+				...newFixedStyles,
+				...newIsFixed ? newPlaceholderStyles : {}
+			};
+		});
+		useEventListener(containerRef, "scroll", () => {
+			emit("scroll");
+			updatePosition();
+		});
+		useEventListener(containerRef, "resize", updatePosition);
+		watchPostEffect(updatePosition);
+		return {
+			className,
+			wrapperRef,
+			containerRef,
+			isFixed,
+			placeholderStyle,
+			fixedStyle,
+			updatePosition
+		};
+	}
+});
+function provideAffixTarget(target) {
+	provide(AFFIX_TARGET_KEY, target);
+}
+
+//#endregion
+//#region src/config-provider/index.ts
+const configProviderProps = defineHookProps({
+	icon: { type: Object },
+	activateEvent: { type: String }
+});
+
+//#endregion
+//#region src/file-upload/index.ts
+const fileUploadProps = defineHookProps({
+	modelValue: {
+		type: [File, Array],
+		default: () => []
+	},
+	multiple: {
+		type: Boolean,
+		default: false
+	}
+});
+const fileUploadEmits = defineHookEmits(["update:modelValue", "change"]);
+const useFileUpload = defineHookComponent({
+	props: fileUploadProps,
+	emits: fileUploadEmits,
+	setup(props, { emit }) {
+		const fileInputRef = elementRef();
+		const files = ref([]);
+		watch(() => toArray(props.modelValue), (value) => {
+			files.value = value;
+		}, {
+			immediate: true,
+			deep: true
+		});
+		const openFileInput = () => {
+			fileInputRef.value?.click();
+		};
+		const toModelValue = (files) => {
+			if (props.multiple) return files;
+			if (files.length) return files[files.length - 1];
+			return null;
+		};
+		useEventListener(fileInputRef, "change", (event) => {
+			const input = event.target;
+			const newFiles = Array.from(input.files ?? []);
+			if (newFiles.length) if (props.multiple) files.value.push(...newFiles);
+			else files.value = newFiles.slice(newFiles.length - 1);
+			input.value = "";
+			const value = toModelValue(files.value);
+			emit("update:modelValue", value);
+			emit("change", value);
+		});
+		return {
+			fileInputRef,
+			files,
+			openFileInput
+		};
+	}
+});
+
+//#endregion
+//#region src/icon/index.ts
+const iconProps = defineHookProps({
+	src: {
+		type: String,
+		required: true
+	},
+	size: { type: [Number, String] },
+	width: { type: [Number, String] },
+	height: { type: [Number, String] },
+	color: {
+		type: String,
+		default: "currentColor"
+	},
+	mask: {
+		type: [Boolean, String],
+		default: () => "auto"
+	}
+});
+const isSvg = (src) => src.endsWith(".svg") || src.startsWith("data:image/svg+xml");
+const useIcon = defineHookComponent({
+	props: iconProps,
+	setup(props, context) {
+		const sharedConfig = useSharedConfig("icon");
+		const sizeStyle = computed(() => {
+			const s = props.size ?? sharedConfig.size;
+			const unit = createUnitFormat(sharedConfig.sizeUnit ?? "px");
+			const size = s ? unit(s) : void 0;
+			const w = props.width ?? size;
+			const h = props.height ?? size;
+			return {
+				width: w ? unit(w) : void 0,
+				height: h ? unit(h) : void 0
+			};
+		});
+		const dynamicStyle = computed(() => {
+			if (!(props.mask === "auto" ? isSvg(props.src) : props.mask)) return {
+				"background-image": "var(--icon-url)",
+				"background-size": "100% 100%"
+			};
+			return {
+				"mask": "var(--icon-url) no-repeat",
+				"mask-size": "100% 100%",
+				"-webkit-mask": "var(--icon-url) no-repeat",
+				"-webkit-mask-size": "100% 100%",
+				"background-color": props.color
+			};
+		});
+		const staticStyle = computed(() => {
+			return { "--icon-url": `url("${props.src}")` };
+		});
+		return { style: computed(() => {
+			return {
+				...staticStyle.value,
+				...dynamicStyle.value,
+				...sizeStyle.value,
+				...context.attrs.style ?? {}
+			};
+		}) };
+	}
+});
+
+//#endregion
+//#region src/selection/index.ts
+const selectionProps = defineHookProps({
+	modelValue: {
+		type: valuePropType,
+		default: () => null
+	},
+	activeClass: {
+		type: classPropType,
+		default: "active"
+	},
+	itemClass: {
+		type: classPropType,
+		default: ""
+	},
+	disabledClass: {
+		type: classPropType,
+		default: "disabled"
+	},
+	unactiveClass: {
+		type: classPropType,
+		default: ""
+	},
+	label: { type: labelPropType },
+	multiple: {
+		type: [
+			Boolean,
+			Number,
+			Array
+		],
+		default: () => false
+	},
+	clearable: { type: Boolean },
+	defaultValue: {
+		type: valuePropType,
+		default: () => null
+	},
+	activateEvent: { type: String }
+});
+const selectionEmits = defineHookEmits([
+	"update:modelValue",
+	"change",
+	"load",
+	"unload",
+	"reject"
+]);
+const HiSelectionContextSymbol = Symbol("[hi-selection]context");
+function useSelectionContext() {
+	return inject(HiSelectionContextSymbol, {
+		isActive: () => false,
+		activate: () => {},
+		changeActive: () => {},
+		reject: () => {},
+		activeClass: "active",
+		unactiveClass: "unactive",
+		disabledClass: "disabled",
+		itemClass: "",
+		activateEvent: useSharedConfig().activateEvent,
+		label: null,
+		multiple: false,
+		limit: [0, Number.POSITIVE_INFINITY]
+	});
+}
+const useSelectionList = defineHookComponent({
+	props: selectionProps,
+	emits: selectionEmits,
+	setup(props, { emit, slots }) {
+		const options = reactive([]);
+		function toArray(value) {
+			if (!isDefined(value)) return [];
+			if (props.multiple && Array.isArray(value)) return value.filter((v) => v != null || v !== void 0);
+			return [value];
+		}
+		const actives = reactive([...toArray(props.modelValue ?? props.defaultValue)]);
+		const currentValue = computed({
+			get() {
+				return props.multiple ? actives : actives[0];
+			},
+			set(val) {
+				actives.splice(0, actives.length, ...toArray(val));
+			}
+		});
+		syncRef(currentValue, computed({
+			get() {
+				return props.modelValue ?? props.defaultValue;
+			},
+			set(val) {
+				emit("update:modelValue", val);
+			}
+		}), {
+			immediate: true,
+			deep: true
+		});
+		const emitChange = () => emit("change", currentValue.value);
+		function isActive(value) {
+			return actives.includes(value);
+		}
+		const multipleActive = computed(() => !!props.multiple);
+		/**
+		* [min,max]
+		*/
+		const multipleLimit = computed(() => {
+			if (Array.isArray(props.multiple)) {
+				if (props.multiple[1] === void 0) return [props.multiple[0], Number.POSITIVE_INFINITY];
+				return props.multiple;
+			}
+			return [0, Number.POSITIVE_INFINITY];
+		});
+		function activate(value) {
+			const [min, max] = multipleLimit.value;
+			if (isActive(value)) {
+				if (multipleActive.value && actives.length > min || props.clearable) {
+					actives.splice(actives.indexOf(value), 1);
+					emitChange();
+				}
+			} else if (props.multiple) {
+				if (actives.length < max) {
+					actives.push(value);
+					emitChange();
+				}
+			} else {
+				actives.splice(0, actives.length, value);
+				emitChange();
+			}
+		}
+		function reject(value) {
+			emit("reject", value);
+		}
+		const init = (option) => {
+			function remove() {
+				const index = options.findIndex((e) => e.id === option.id);
+				if (index > -1) {
+					options.splice(index, 1);
+					emit("unload", option);
+				}
+			}
+			for (let i = 0; i < options.length; i++) if (options[i].value === option.value) {
+				options.splice(i, 1);
+				i--;
+			}
+			options.push(option);
+			emit("load", option);
+			return remove;
+		};
+		const sharedConfig = useSharedConfig();
+		provide(HiSelectionContextSymbol, toReactive({
+			activeClass: computed(() => cls(props.activeClass)),
+			unactiveClass: computed(() => cls(props.unactiveClass)),
+			disabledClass: computed(() => cls(props.disabledClass)),
+			itemClass: computed(() => cls(props.itemClass)),
+			label: computed(() => props.label),
+			multiple: multipleActive,
+			limit: multipleLimit,
+			clearable: computed(() => props.clearable),
+			defaultValue: computed(() => props.defaultValue),
+			activateEvent: computed(() => props.activateEvent ?? sharedConfig.activateEvent),
+			active: currentValue,
+			activate,
+			changeActive: activate,
+			isActive,
+			reject,
+			init
+		}));
+		const renderItem = () => {
+			const children = options.filter((e) => actives.includes(e.value)).map((e) => e.render());
+			return props.multiple ? children : getFirstChilld(children);
+		};
+		const slotData = {
+			isActive,
+			changeActive: activate,
+			renderItem
+		};
+		const render = () => {
+			return renderSlot(slots, "default", slotData);
+		};
+		return {
+			options,
+			actives,
+			isActive,
+			changeActive: activate,
+			renderItem,
+			render
+		};
+	}
+});
+
+//#endregion
+//#region src/item/index.ts
+const itemProps = defineHookProps({
+	value: {
+		type: valuePropType,
+		default() {
+			return Math.random().toString(16).slice(2);
+		}
+	},
+	label: { type: [Function, String] },
+	keepAlive: {
+		type: Boolean,
+		default: () => true
+	},
+	activateEvent: { type: String },
+	disabled: {
+		type: Boolean,
+		default: false
+	}
+});
+const itemEmits = defineHookEmits(["reject"]);
+const useSelectionItem = defineHookComponent({
+	props: itemProps,
+	emits: itemEmits,
+	setup(props, { slots, emit }) {
+		const context = useSelectionContext();
+		const activate = () => {
+			if (props.disabled) {
+				emit("reject", props.value);
+				context.reject(props.value);
+				return;
+			}
+			context.activate(props.value);
+		};
+		const label = computed(() => {
+			let label = props.label ?? context.label;
+			if (label && typeof label === "function") label = label(props.value);
+			return Array.isArray(label) ? label : [label];
+		});
+		function render() {
+			return slots.default?.({
+				active: context.isActive(props.value),
+				activate
+			}) ?? label.value.filter(Boolean);
+		}
+		let remove = () => {};
+		const init = context.init;
+		if (init) {
+			watch(() => props.value, (value) => {
+				remove();
+				remove = init({
+					id: Math.random().toString(16).slice(2),
+					label: typeof props.label === "string" ? props.label : void 0,
+					value,
+					render
+				});
+			}, { immediate: true });
+			tryOnScopeDispose(remove);
+		}
+		const isActive = computed(() => context.isActive(props.value));
+		const isDisabled = computed(() => props.disabled);
+		return {
+			activate,
+			render,
+			isActive,
+			isDisabled,
+			className: computed(() => {
+				const array = [context.itemClass];
+				if (!isDisabled.value) array.push(context.isActive(props.value) ? context.activeClass : context.unactiveClass);
+				else array.push(context.disabledClass);
+				return cls(array);
+			}),
+			activateEvent: computed(() => props.activateEvent ?? context.activateEvent),
+			label
+		};
+	}
+});
+
+//#endregion
+//#region src/popover/index.ts
+const popoverProps = defineHookProps({
+	popupClass: { type: String },
+	placement: {
+		type: String,
+		default: () => "auto"
+	},
+	triggerEvent: {
+		type: String,
+		default: () => "hover"
+	},
+	offset: {
+		type: Number,
+		default: () => 8
+	},
+	lazy: {
+		type: Boolean,
+		default: () => false
+	},
+	visible: {
+		type: Boolean,
+		default: () => false
+	},
+	disabled: {
+		type: Boolean,
+		default: () => false
+	},
+	teleport: {
+		type: [
+			String,
+			Object,
+			Boolean
+		],
+		default: () => true
+	}
+});
+const popoverEmits = defineHookEmits(["update:visible", "change"]);
+const usePopover = defineHookComponent({
+	props: popoverProps,
+	emits: popoverEmits,
+	setup(props, context) {
+		const visible = useVModel(props, "visible", context.emit, { passive: true });
+		const triggerRef = elementRef();
+		const popupRef = elementRef();
+		const validate = (event) => {
+			const events = Array.isArray(event) ? event : [event];
+			return !props.disabled && events.includes(props.triggerEvent);
+		};
+		let timer;
+		const toggle = (_value) => {
+			const value = _value ?? !visible.value;
+			visible.value = value;
+			context.emit("change", value);
+		};
+		function onMouseover() {
+			if (!validate("hover")) return;
+			timer = setTimeout(() => {
+				toggle(true);
+			}, props.lazy ? 800 : 100);
+		}
+		function onMouseout() {
+			if (!validate("hover")) return;
+			clearTimeout(timer);
+			toggle(false);
+		}
+		const onClick = (e) => {
+			if (!validate("click")) return;
+			e.preventDefault();
+			e.stopPropagation();
+			toggle();
+		};
+		onClickOutside(triggerRef, () => {
+			if (!validate([
+				"click",
+				"contextmenu",
+				"touch",
+				"dblclick",
+				"mousedown"
+			])) return;
+			toggle(false);
+		}, { ignore: [popupRef] });
+		const onContextmenu = (e) => {
+			if (!validate("contextmenu")) return;
+			e.preventDefault();
+			e.stopPropagation();
+			toggle();
+		};
+		const onFocusin = () => {
+			if (!validate("focus")) return;
+			toggle(true);
+		};
+		const onFocusout = () => {
+			if (!validate("focus")) return;
+			toggle(false);
+		};
+		const onTouchend = () => {
+			if (!validate("touch")) return;
+			toggle(true);
+		};
+		const onDblclick = () => {
+			if (!validate("dblclick")) return;
+			toggle(true);
+		};
+		const onMousedown = () => {
+			if (!validate("mousedown")) return;
+			toggle(true);
+		};
+		const onMouseup = () => {
+			if (!validate("mousedown")) return;
+			toggle(false);
+		};
+		const events = {
+			onMouseover,
+			onMouseout,
+			onMousedown,
+			onMouseup,
+			onContextmenu,
+			onClick,
+			onDblclick,
+			onFocusin,
+			onFocusout,
+			onTouchend
+		};
+		const dropdownPosition = reactive({
+			x: 0,
+			y: 0
+		});
+		const popupClass = computed(() => {
+			return props.popupClass;
+		});
+		function resize() {
+			const trigger = triggerRef.value;
+			const popup = popupRef.value;
+			if (!!trigger && !!popup && visible.value) {
+				const { width, height, left, top } = trigger.getBoundingClientRect();
+				const { clientWidth: pWidth, clientHeight: pHeight } = popup;
+				let x = 0;
+				let y = 0;
+				const offset = props.offset;
+				switch (props.placement) {
+					case "auto":
+					case "bottom":
+						x = left - (pWidth - width) / 2;
+						y = top + height + offset;
+						break;
+					case "bottom-left":
+						x = left;
+						y = top + height + offset;
+						break;
+					case "bottom-right":
+						x = left + width - pWidth;
+						y = top + height + offset;
+						break;
+					case "top":
+						x = left - (pWidth - width) / 2;
+						y = top - pHeight - offset;
+						break;
+					case "top-left":
+						x = left;
+						y = top - pHeight - offset;
+						break;
+					case "top-right":
+						x = left + width - pWidth;
+						y = top - pHeight - offset;
+						break;
+					case "left":
+						x = left - pWidth - offset;
+						y = top - (pHeight - height) / 2;
+						break;
+					case "left-top":
+						x = left - pWidth - offset;
+						y = top;
+						break;
+					case "left-bottom":
+						x = left - pWidth - offset;
+						y = top + height - pHeight;
+						break;
+					case "right":
+						x = left + width + offset;
+						y = top - (pHeight - height) / 2;
+						break;
+					case "right-top":
+						x = left + width + offset;
+						y = top;
+						break;
+					case "right-bottom":
+						x = left + width + offset;
+						y = top + height - pHeight;
+						break;
+				}
+				dropdownPosition.x = x;
+				dropdownPosition.y = y;
+			}
+		}
+		watch(visible, () => {
+			nextTick(resize);
+		});
+		return {
+			events,
+			dropdownPosition,
+			triggerRef,
+			popupRef,
+			popupClass,
+			popupStyle: computed(() => {
+				return {
+					left: px(dropdownPosition.x),
+					top: px(dropdownPosition.y),
+					visibility: visible.value ? "visible" : "hidden",
+					position: "fixed"
+				};
+			})
+		};
+	}
+});
+
+//#endregion
+//#region src/switch/index.ts
+const switchProps = defineHookProps({
+	modelValue: {
+		type: Boolean,
+		default: () => false
+	},
+	class: { type: classPropType },
+	activeClass: { type: classPropType },
+	unactiveClass: { type: classPropType },
+	activateEvent: { type: String },
+	disabled: {
+		type: Boolean,
+		default: () => false
+	},
+	disabledClass: { type: classPropType }
+});
+const switchEmits = defineHookEmits([
+	"update:modelValue",
+	"change",
+	"reject"
+]);
+const useSwitch = defineHookComponent({
+	props: switchProps,
+	emits: switchEmits,
+	setup(props, context) {
+		const modelValue = useVModel(props, "modelValue", context.emit, {
+			passive: true,
+			defaultValue: false
+		});
+		const toggle = function(value) {
+			if (props.disabled) {
+				context.emit("reject", value);
+				return;
+			}
+			const oldValue = modelValue.value;
+			const newValue = typeof value === "boolean" ? value : !oldValue;
+			if (newValue !== oldValue) {
+				modelValue.value = newValue;
+				context.emit("change", newValue);
+			}
+		};
+		const isDisabled = computed(() => props.disabled);
+		const className = computed(() => {
+			return cls([
+				props.class,
+				modelValue.value ? props.activeClass : props.unactiveClass,
+				isDisabled.value ? props.disabledClass : ""
+			]);
+		});
+		const sharedConfig = useSharedConfig();
+		return {
+			toggle,
+			modelValue,
+			className,
+			isDisabled,
+			activateEvent: computed(() => props.activateEvent ?? sharedConfig.activateEvent)
+		};
+	}
+});
+
+//#endregion
+//#region src/virtual-list/index.ts
+const virtualListProps = defineHookProps({
+	options: {
+		type: Object,
+		default: () => ({})
+	},
+	count: {
+		type: Number,
+		default: () => 0
+	},
+	estimateSize: {
+		type: [Function, Number],
+		default: () => 50
+	},
+	horizontal: {
+		type: Boolean,
+		default: () => false
+	}
+});
+const virtualListEmits = defineHookEmits({
+	scrollEnd: () => true,
+	scrollStart: () => true,
+	scroll: (_) => true
+});
+const useVirtualList = defineHookComponent({
+	props: virtualListProps,
+	emits: virtualListEmits,
+	setup(props, context) {
+		const { emit } = context;
+		const scrollElementRef = elementRef();
+		const propsEstimateSize = props.estimateSize;
+		const estimateSize = typeof propsEstimateSize === "function" ? propsEstimateSize : () => propsEstimateSize;
+		const options = computed(() => {
+			return {
+				...props.options || {},
+				count: props.count,
+				estimateSize,
+				horizontal: props.horizontal,
+				getScrollElement: () => scrollElementRef.value,
+				observeElementRect,
+				observeElementOffset,
+				scrollToFn: elementScroll
+			};
+		});
+		const virtualizer = new Virtualizer(options.value);
+		const state = shallowRef(virtualizer);
+		const virtualItems = computed(() => state.value.getVirtualItems());
+		const virtualIndexes = computed(() => state.value.getVirtualIndexes());
+		const totalSize = computed(() => state.value.getTotalSize());
+		watch(virtualIndexes, (indexes) => {
+			if (indexes.length === 0) return;
+			if (indexes[indexes.length - 1] === props.count - 1) emit("scrollEnd");
+			else if (indexes[0] === 0) emit("scrollStart");
+			emit("scroll", indexes);
+		}, { immediate: true });
+		watch(options, (opts) => {
+			virtualizer.setOptions({
+				...opts,
+				onChange: (instance, sync) => {
+					opts.onChange?.(instance, sync);
+					triggerRef(state);
+				}
+			});
+			virtualizer._willUpdate();
+			triggerRef(state);
+		}, { immediate: true });
+		watch(scrollElementRef, (el) => {
+			if (el) {
+				virtualizer._willUpdate();
+				triggerRef(state);
+			}
+		}, { immediate: true });
+		tryOnScopeDispose(virtualizer._didMount());
+		const measureElement = (el) => {
+			virtualizer.measureElement(el);
+		};
+		const scrollToIndex = (index, options = { behavior: "smooth" }) => {
+			virtualizer.scrollToIndex(index, options);
+		};
+		const scrollToStart = (options = { behavior: "smooth" }) => {
+			scrollToIndex(0, options);
+		};
+		const scrollToEnd = (options = { behavior: "smooth" }) => {
+			scrollToIndex(props.count - 1, options);
+		};
+		return {
+			virtualizer,
+			virtualItems,
+			virtualIndexes,
+			totalSize,
+			scrollElementRef,
+			measureElement,
+			scrollToIndex,
+			scrollToStart,
+			scrollToEnd
+		};
+	}
+});
+
+//#endregion
+//#region index.ts
+var core_exports = /* @__PURE__ */ __exportAll({
+	AFFIX_TARGET_KEY: () => AFFIX_TARGET_KEY,
+	affixEmits: () => affixEmits,
+	affixProps: () => affixProps,
+	configProviderProps: () => configProviderProps,
+	fileUploadEmits: () => fileUploadEmits,
+	fileUploadProps: () => fileUploadProps,
+	iconProps: () => iconProps,
+	itemEmits: () => itemEmits,
+	itemProps: () => itemProps,
+	popoverEmits: () => popoverEmits,
+	popoverProps: () => popoverProps,
+	provideAffixTarget: () => provideAffixTarget,
+	selectionEmits: () => selectionEmits,
+	selectionProps: () => selectionProps,
+	switchEmits: () => switchEmits,
+	switchProps: () => switchProps,
+	useAffix: () => useAffix,
+	useFileUpload: () => useFileUpload,
+	useIcon: () => useIcon,
+	usePopover: () => usePopover,
+	useSelectionContext: () => useSelectionContext,
+	useSelectionItem: () => useSelectionItem,
+	useSelectionList: () => useSelectionList,
+	useSwitch: () => useSwitch,
+	useVirtualList: () => useVirtualList,
+	virtualListEmits: () => virtualListEmits,
+	virtualListProps: () => virtualListProps
+});
+
+//#endregion
+export { AFFIX_TARGET_KEY, affixEmits, affixProps, configProviderProps, fileUploadEmits, fileUploadProps, iconProps, itemEmits, itemProps, popoverEmits, popoverProps, provideAffixTarget, selectionEmits, selectionProps, switchEmits, switchProps, useAffix, useFileUpload, useIcon, usePopover, useSelectionContext, useSelectionItem, useSelectionList, useSwitch, useVirtualList, virtualListEmits, virtualListProps };