@aifuxi/semi-ui-vue 0.1.0-alpha.0

package/dist/scroll-list/ScrollItem.vue.d.ts

@@ -0,0 +1,21 @@
+import { ScrollItemData, ScrollItemExposed, ScrollItemProps, ScrollItemSelectData } from './types';
+declare const __VLS_export: <Item extends ScrollItemData = ScrollItemData>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<ScrollItemProps<Item> & {
+        onSelect?: (data: ScrollItemSelectData<Item>) => any;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import('vue').ShallowUnwrapRef<ScrollItemExposed>) => void;
+    attrs: any;
+    slots: {};
+    emit: (evt: "select", data: ScrollItemSelectData<Item>) => void;
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/scroll-list/ScrollList.vue.d.ts

@@ -0,0 +1,11 @@
+import { ScrollListProps, ScrollListSlots } from './types';
+type __VLS_Slots = ScrollListSlots;
+declare const __VLS_base: import('vue').DefineComponent<ScrollListProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ScrollListProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/scroll-list/ScrollListNodeRenderer.d.ts

@@ -0,0 +1,15 @@
+import { PropType, VNodeChild } from 'vue';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    content: {
+        type: PropType<VNodeChild>;
+        default: undefined;
+    };
+}>, () => VNodeChild, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    content: {
+        type: PropType<VNodeChild>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    content: VNodeChild;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/scroll-list/index.d.ts

@@ -0,0 +1,10 @@
+import { DefineComponent } from 'vue';
+import { default as ScrollListBase } from './ScrollList.vue';
+import { ScrollItemProps } from './types';
+export type ScrollListCompoundComponent = typeof ScrollListBase & {
+    Item: DefineComponent<ScrollItemProps>;
+};
+export declare const ScrollItem: DefineComponent<ScrollItemProps>;
+export declare const ScrollList: ScrollListCompoundComponent;
+export default ScrollList;
+export { SCROLL_ITEM_MODES, type ScrollItemData, type ScrollItemEmits, type ScrollItemExposed, type ScrollItemMode, type ScrollItemProps, type ScrollItemSelectData, type ScrollListProps, type ScrollListSlots, type ScrollMotion, type ScrollMotionObject, } from './types';

package/dist/scroll-list/index.js

@@ -0,0 +1,2 @@
+import { n as e, r as t, t as n } from "../scroll-list-BSXksNOR.js";
+export { t as SCROLL_ITEM_MODES, n as ScrollItem, e as ScrollList, e as default };

package/dist/scroll-list/types.d.ts

@@ -0,0 +1,54 @@
+import { HTMLAttributes, StyleValue, VNodeChild } from 'vue';
+export declare const SCROLL_ITEM_MODES: readonly ["normal", "wheel"];
+export type ScrollItemMode = (typeof SCROLL_ITEM_MODES)[number];
+export interface ScrollMotionObject {
+    [key: string]: unknown;
+}
+export type ScrollMotion = boolean | ScrollMotionObject | ((props: Record<string, unknown>) => ScrollMotionObject);
+export interface ScrollItemData {
+    disabled?: boolean;
+    text?: string;
+    transform?: (value: unknown, text: string) => unknown;
+    value: unknown;
+    [key: string]: unknown;
+}
+export type ScrollItemSelectData<Item extends ScrollItemData = ScrollItemData> = Item & {
+    index: number;
+    type?: number | string;
+};
+export interface ScrollListProps {
+    bodyHeight?: number | string;
+    class?: HTMLAttributes['class'];
+    className?: HTMLAttributes['class'];
+    footer?: VNodeChild;
+    header?: VNodeChild;
+    prefixCls?: string;
+    style?: StyleValue;
+}
+export interface ScrollListSlots {
+    default?: () => VNodeChild;
+    footer?: () => VNodeChild;
+    header?: () => VNodeChild;
+}
+export interface ScrollItemProps<Item extends ScrollItemData = ScrollItemData> {
+    ariaLabel?: string;
+    class?: HTMLAttributes['class'];
+    className?: HTMLAttributes['class'];
+    cycled?: boolean;
+    list?: Item[];
+    mode?: ScrollItemMode;
+    motion?: ScrollMotion;
+    selectedIndex?: number;
+    style?: StyleValue;
+    transform?: (value: unknown, text: string) => unknown;
+    type?: number | string;
+}
+export interface ScrollItemEmits<Item extends ScrollItemData = ScrollItemData> {
+    select: [data: ScrollItemSelectData<Item>];
+}
+export interface ScrollItemExposed {
+    scrollToCenter(selectedNode?: HTMLElement, scrollWrapper?: HTMLElement, duration?: number): void;
+    scrollToIndex(selectedIndex?: number, duration?: number): void;
+    scrollToNode(node: HTMLElement, duration?: number): void;
+    scrollToPos(targetTop: number, duration?: number): void;
+}

package/dist/scroll-list-BSXksNOR.js

@@ -0,0 +1,466 @@
+import { t as e } from "./src-DNBBthjO.js";
+import { a as t, o as n, t as r, w as i } from "./foundation-Cawx37mp.js";
+import { t as a } from "./env-BeIzjQx7.js";
+import { t as o } from "./isElement-Cx0AsIov.js";
+import { Fragment as s, computed as c, createCommentVNode as l, createElementBlock as u, createElementVNode as d, createVNode as f, defineComponent as p, markRaw as m, mergeProps as h, nextTick as g, normalizeClass as _, normalizeStyle as v, onBeforeUnmount as ee, onMounted as y, openBlock as b, renderList as x, renderSlot as S, shallowReactive as C, toDisplayString as w, unref as T, useAttrs as E, useSlots as D, useTemplateRef as O, watch as k } from "vue";
+//#region bundled-foundation
+function A(e, ...t) {
+	for (let n of t) e.appendChild(n);
+	return e;
+}
+function j(e, ...t) {
+	if (e.children && e.children.length) {
+		let n = e.children[0];
+		for (let r of t) e.insertBefore(r, n);
+	} else A(e, ...t);
+	return e;
+}
+//#endregion
+//#region bundled-foundation
+var M = class extends r {
+	constructor(...e) {
+		super(...e), this._cachedSelectedNode = null;
+	}
+	selectIndex(e, t) {
+		let { type: n, list: r } = this.getProps();
+		if (e > -1 && Array.isArray(r) && r.length && o(t)) {
+			let i = e % r.length, a = r[i], o = t.children[e];
+			this._adapter.setSelectedNode(o), this._adapter.notifySelectItem({
+				...a,
+				value: a.value,
+				type: n,
+				index: i
+			});
+		}
+	}
+	selectNode(e, t) {
+		let { type: r, list: i } = this.getProps();
+		if (o(e) && o(t)) {
+			let a = (0, n.default)(t.children, (t) => t === e) % i.length, o = (0, n.default)(t.children, (e) => e === this._cachedSelectedNode) % i.length, s = i[a];
+			this._adapter.setSelectedNode(e), this._adapter.scrollToCenter(e), this._cachedSelectedNode !== e && (this._cachedSelectedNode = e, o !== a && this._adapter.notifySelectItem({
+				...s,
+				value: s.value,
+				type: r,
+				index: a
+			}));
+		}
+	}
+	shouldAppend(e, t, n = 2) {
+		if (o(e) && o(t)) {
+			let r = e.querySelectorAll("li"), i = r[r.length - 1], { list: a } = this.getProps();
+			if (i) {
+				let e = t.getBoundingClientRect(), r = i.getBoundingClientRect(), o = r.height * a.length;
+				if (o <= 0) return 0;
+				let s = r.top, c = 0;
+				for (; s <= e.top + e.height * n;) c += 1, s += o;
+				return c;
+			}
+		}
+		return !1;
+	}
+	shouldPrepend(e, t, n = 2) {
+		if (o(e) && o(t)) {
+			let r = e.querySelectorAll("li")[0], { list: i } = this.getProps();
+			if (r) {
+				let e = t.getBoundingClientRect(), a = r.getBoundingClientRect(), o = a.height * i.length;
+				if (o <= 0) return 0;
+				let s = a.top, c = 0;
+				for (; s + a.height >= e.top - e.height * n;) c += 1, s -= o;
+				return c;
+			}
+		}
+		return 0;
+	}
+	initWheelList(e, t, n) {
+		let { list: r } = this.getProps();
+		if (o(t) && o(e) && r && r.length) {
+			let a = e.children;
+			(0, i.default)(a, 0, r.length);
+			let o = this.shouldPrepend(e, t), s = this.shouldAppend(e, t);
+			this._adapter.setState({
+				prependCount: o,
+				appendCount: s
+			}, n);
+		}
+	}
+	adjustInfiniteList(e, t, n) {
+		let { list: r } = this.getProps();
+		if (o(t) && o(e) && r && r.length) {
+			let n = e.querySelectorAll("li"), a = n.length, o = this.shouldPrepend(e, t, 1), s = this.shouldAppend(e, t, 1);
+			if (o) for (let t = 0; t < o; t++) j(e, ...(0, i.default)(n, a - r.length * (t + 1), a - r.length * t));
+			if (s) for (let t = 0; t < s; t++) A(e, ...(0, i.default)(n, t * r.length, (t + 1) * r.length));
+		}
+	}
+	getNearestNodeInfo(e, t) {
+		if (o(e) && o(t)) {
+			let n = t.getBoundingClientRect().top, r = e.querySelectorAll("li"), i = null, a = -1, o = Infinity;
+			return Array.from(r).map((e, t) => {
+				let r = e.getBoundingClientRect().top, s = Math.abs(r - n);
+				s < o && !this._adapter.isDisabledIndex(t) && (o = s, i = e, a = t);
+			}), {
+				nearestNode: i,
+				nearestIndex: a
+			};
+		}
+	}
+	getTargetNode(e, n) {
+		if (e && o(n)) {
+			let r = e.target, i = n.querySelectorAll("li"), a = this.getProp("list"), o = Array.isArray(a) ? a.length : 0, s = -1, c = -1, l = null, u = (0, t.default)(i, (e, t) => {
+				if (e === r || e.contains(r)) return s = t, o > 0 && (c = t % o), !0;
+			});
+			return c > -1 && (l = a[c]), {
+				targetNode: u,
+				targetIndex: s,
+				indexInList: c,
+				infoInList: l
+			};
+		}
+		return null;
+	}
+}, te = (t, n, r) => {
+	let i = new e({
+		from: { scrollTop: t.scrollTop },
+		to: { scrollTop: n }
+	}, { duration: r });
+	return i.on("frame", ({ scrollTop: e }) => {
+		t.scrollTop = e;
+	}), i;
+}, N = {
+	PREFIX: `${a}-scrolllist`,
+	SELECTED: `${a}-scrolllist-item-selected`
+}, P = {
+	DEFAULT_ITEM_HEIGHT: 36,
+	DEFAULT_SCROLL_DURATION: 120
+}, F = ["aria-label"], I = ["aria-disabled", "onClick"], L = ["aria-label"], R = ["aria-disabled"], z = /* @__PURE__ */ p({
+	inheritAttrs: !1,
+	__name: "ScrollItem",
+	props: {
+		ariaLabel: {},
+		class: { type: [
+			Boolean,
+			null,
+			String,
+			Object,
+			Array
+		] },
+		className: { type: [
+			Boolean,
+			null,
+			String,
+			Object,
+			Array
+		] },
+		cycled: {
+			type: Boolean,
+			default: !1
+		},
+		list: { default: () => [] },
+		mode: { default: "wheel" },
+		motion: {
+			type: [
+				Boolean,
+				Object,
+				Function
+			],
+			default: !0
+		},
+		selectedIndex: { default: 0 },
+		style: { type: [
+			Boolean,
+			null,
+			String,
+			Object,
+			Array
+		] },
+		transform: {},
+		type: {}
+	},
+	emits: ["select"],
+	setup(e, { expose: t, emit: n }) {
+		let r = e, i = n, a = O("wrapper"), o = O("list"), l = O("selector"), f = C({
+			appendCount: 0,
+			prependCount: 0
+		}), p = /* @__PURE__ */ new Map(), h = null, S = null, T = null, E, D, A = () => ({
+			...r,
+			cycled: r.cycled,
+			list: r.list,
+			mode: r.mode,
+			motion: r.motion,
+			selectedIndex: r.selectedIndex
+		});
+		function j(e) {
+			return !!(e && typeof e == "object" && e.disabled);
+		}
+		function z(e) {
+			return r.list.length === 0 || e < 0 ? !1 : j(r.list[e % r.list.length]);
+		}
+		function B(e) {
+			e && (S = e);
+		}
+		let V = m(new M({
+			getContext: () => void 0,
+			getContexts: () => ({}),
+			getProp: (e) => A()[e],
+			getProps: A,
+			getState: (e) => f[e],
+			getStates: () => f,
+			setState: (e, t) => {
+				Object.assign(f, e), t && g(t);
+			},
+			getCache: (e) => p.get(e),
+			getCaches: () => p,
+			setCache: (e, t) => p.set(e, t),
+			stopPropagation: (e) => e?.stopPropagation?.(),
+			persistEvent: () => void 0,
+			setPrependCount: (e) => {
+				f.prependCount = e;
+			},
+			setAppendCount: (e) => {
+				f.appendCount = e;
+			},
+			isDisabledIndex: z,
+			setSelectedNode: B,
+			notifySelectItem: (e) => i("select", e),
+			scrollToCenter: (e, t, n) => Q(e, t, n)
+		})), H = c(() => {
+			let e = (e) => r.list.map((t, n) => ({
+				item: t,
+				key: `${e}${n}`,
+				sourceIndex: n
+			})), t = [];
+			for (let n = f.prependCount - 1; n >= 0; --n) t.push(...e(`pre_${n}_`));
+			t.push(...e(""));
+			for (let n = 0; n < f.appendCount; n += 1) t.push(...e(`app_${n}_`));
+			return t;
+		});
+		function U(e, t) {
+			let n = e.text == null ? e.value : e.text;
+			if (t !== r.selectedIndex) return n;
+			let i = typeof e.transform == "function" ? e.transform : r.transform;
+			return typeof i == "function" ? i(e.value, e.text ?? "") : n;
+		}
+		function W(e, t) {
+			return r.list.length > 0 ? e % r.list.length === t % r.list.length : void 0;
+		}
+		function G(e) {
+			return e && o.value ? [...o.value.children].indexOf(e) : -1;
+		}
+		function K(e) {
+			return o.value ? e > -1 ? o.value.children[e] ?? null : [...o.value.children].find((e, t) => !z(t)) ?? null : null;
+		}
+		function q(e, t, n) {
+			if (!e || !n || r.list.length === 0) return e;
+			let i = t % r.list.length, a = G(e) + i;
+			for (; a < 0;) a += r.list.length;
+			return i ? K(a) : e;
+		}
+		function J(e, t = N.SELECTED) {
+			let n = o.value, r = e ?? h;
+			!n || !r || ([...n.children].forEach((e) => e.classList.remove(t)), r.classList.add(t));
+		}
+		function Y(e, t = P.DEFAULT_SCROLL_DURATION) {
+			let n = a.value;
+			if (n) {
+				if (t && r.motion) {
+					if (T?.destroy(), n.scrollTop === e) {
+						r.mode === "wheel" && o.value && l.value && J(V.getNearestNodeInfo(o.value, l.value).nearestNode);
+						return;
+					}
+					T = te(n, e, t), T.on("rest", () => {
+						r.mode === "wheel" && o.value && l.value && J(V.getNearestNodeInfo(o.value, l.value).nearestNode);
+					}), T.start();
+					return;
+				}
+				n.scrollTop = e;
+			}
+		}
+		function X(e, t = P.DEFAULT_SCROLL_DURATION) {
+			let n = a.value, r = o.value;
+			if (!n || !r || !e) return;
+			let i = e.offsetHeight || P.DEFAULT_ITEM_HEIGHT;
+			Y((e.offsetTop || r.children.length * i / 2) - (n.offsetHeight - i) / 2, t);
+		}
+		function Z(e = r.selectedIndex, t = P.DEFAULT_SCROLL_DURATION) {
+			h && X(h, t);
+		}
+		function Q(e = h, t = a.value, n = P.DEFAULT_SCROLL_DURATION) {
+			if (!e || !t) return;
+			let r = t.getBoundingClientRect(), i = e.getBoundingClientRect();
+			Y(t.scrollTop + (i.top - (r.top + r.height / 2 - i.height / 2)), n);
+		}
+		function ne(e) {
+			z(e) || !o.value || V.selectIndex(e, o.value);
+		}
+		function re(e) {
+			!e || !o.value || (h = e, V.selectNode(e, o.value));
+		}
+		function $(e) {
+			D !== void 0 && clearTimeout(D), D = setTimeout(() => re(e), 1e3 / 60 * 2);
+		}
+		function ie() {
+			if (!o.value || !l.value || !a.value) return;
+			let e = V.getNearestNodeInfo(o.value, l.value).nearestNode;
+			r.cycled && E === void 0 && (E = requestAnimationFrame(() => {
+				E = void 0, o.value && a.value && e && V.adjustInfiniteList(o.value, a.value, e);
+			})), $(e);
+		}
+		function ae(e) {
+			if (e.stopImmediatePropagation?.(), !o.value) return;
+			let t = V.getTargetNode(e, o.value);
+			t?.targetNode && t.infoInList && !t.infoInList.disabled && $(t.targetNode);
+		}
+		function oe() {
+			V.init(), h = K(typeof r.selectedIndex == "number" && r.selectedIndex > -1 ? r.selectedIndex : 0), S = h, h && (r.mode === "wheel" && r.cycled && o.value && a.value ? V.initWheelList(o.value, a.value, () => {
+				h && X(h, 0);
+			}) : X(h, 0));
+		}
+		return k(() => r.selectedIndex, (e, t) => {
+			t !== void 0 && (W(G(S), e) || (S = q(h, e - t, o.value)), h = S, Z(e));
+		}, { flush: "post" }), y(() => void g(oe)), ee(() => {
+			D !== void 0 && clearTimeout(D), E !== void 0 && cancelAnimationFrame(E), T?.destroy(), V.destroy();
+		}), t({
+			scrollToCenter: Q,
+			scrollToIndex: Z,
+			scrollToNode: X,
+			scrollToPos: Y
+		}), (e, t) => r.mode === "normal" ? (b(), u("div", {
+			key: 0,
+			ref_key: "wrapper",
+			ref: a,
+			class: _([
+				"semi-scrolllist-item",
+				r.className,
+				r.class
+			]),
+			style: v(r.style)
+		}, [d("ul", {
+			ref: "list",
+			role: "listbox",
+			"aria-label": r.ariaLabel,
+			"aria-multiselectable": !1
+		}, [(b(!0), u(s, null, x(r.list, (e, t) => (b(), u("li", {
+			key: t,
+			class: _([t === r.selectedIndex ? "semi-scrolllist-item-sel" : void 0, e.disabled ? "semi-scrolllist-item-disabled" : void 0]),
+			role: "option",
+			"aria-disabled": e.disabled,
+			onClick: (e) => ne(t)
+		}, w(U(e, t)), 11, I))), 128))], 8, F)], 6)) : (b(), u("div", {
+			key: 1,
+			class: _([
+				"semi-scrolllist-item-wheel",
+				r.className,
+				r.class
+			]),
+			style: v(r.style)
+		}, [
+			t[0] ||= d("div", { class: "semi-scrolllist-shade semi-scrolllist-shade-pre" }, null, -1),
+			d("div", {
+				ref_key: "selector",
+				ref: l,
+				class: "semi-scrolllist-selector"
+			}, null, 512),
+			t[1] ||= d("div", { class: "semi-scrolllist-shade semi-scrolllist-shade-post" }, null, -1),
+			d("div", {
+				ref_key: "wrapper",
+				ref: a,
+				class: _(["semi-scrolllist-list-outer", r.cycled ? void 0 : "semi-scrolllist-list-outer-nocycle"]),
+				onScroll: ie
+			}, [d("ul", {
+				ref: "list",
+				role: "listbox",
+				"aria-label": r.ariaLabel,
+				"aria-multiselectable": !1,
+				onClick: ae
+			}, [(b(!0), u(s, null, x(H.value, (e) => (b(), u("li", {
+				key: e.key,
+				class: _(e.item.disabled ? "semi-scrolllist-item-disabled" : void 0),
+				role: "option",
+				"aria-disabled": e.item.disabled
+			}, w(U(e.item, e.sourceIndex)), 11, R))), 128))], 8, L)], 34)
+		], 6));
+	}
+}), B = p({
+	name: "ScrollListNodeRenderer",
+	props: { content: {
+		type: null,
+		default: void 0
+	} },
+	setup(e) {
+		return () => e.content;
+	}
+}), V = ["x-semi-prop"], H = ["x-semi-prop"], U = /* @__PURE__ */ p({
+	inheritAttrs: !1,
+	__name: "ScrollList",
+	props: {
+		bodyHeight: {},
+		class: { type: [
+			Boolean,
+			null,
+			String,
+			Object,
+			Array
+		] },
+		className: { type: [
+			Boolean,
+			null,
+			String,
+			Object,
+			Array
+		] },
+		footer: { type: [
+			Object,
+			String,
+			Number,
+			Boolean,
+			null,
+			Array
+		] },
+		header: { type: [
+			Object,
+			String,
+			Number,
+			Boolean,
+			null,
+			Array
+		] },
+		prefixCls: {},
+		style: { type: [
+			Boolean,
+			null,
+			String,
+			Object,
+			Array
+		] }
+	},
+	setup(e) {
+		let t = e, n = E(), r = D(), i = c(() => t.prefixCls || "semi-scrolllist"), a = c(() => Object.fromEntries(Object.entries(n).filter(([e]) => e.startsWith("data-")))), o = c(() => n["x-semi-header-alias"] ?? "header"), s = c(() => n["x-semi-footer-alias"] ?? "footer"), p = c(() => !!(r.header || t.header)), m = c(() => !!(r.footer || t.footer)), g = c(() => typeof t.bodyHeight == "number" ? `${t.bodyHeight}px` : t.bodyHeight || "");
+		return (e, n) => (b(), u("div", h({
+			class: [
+				i.value,
+				t.className,
+				t.class
+			],
+			style: t.style
+		}, a.value), [
+			p.value ? (b(), u("div", {
+				key: 0,
+				class: _(`${i.value}-header`)
+			}, [d("div", {
+				class: _(`${i.value}-header-title`),
+				"x-semi-prop": o.value
+			}, [S(e.$slots, "header", {}, () => [f(T(B), { content: t.header }, null, 8, ["content"])])], 10, V), d("div", { class: _(`${i.value}-line`) }, null, 2)], 2)) : l("", !0),
+			d("div", {
+				class: _(`${i.value}-body`),
+				style: v({ height: g.value }),
+				"x-semi-prop": "children"
+			}, [S(e.$slots, "default")], 6),
+			m.value ? (b(), u("div", {
+				key: 1,
+				class: _(`${i.value}-footer`),
+				"x-semi-prop": s.value
+			}, [S(e.$slots, "footer", {}, () => [f(T(B), { content: t.footer }, null, 8, ["content"])])], 10, H)) : l("", !0)
+		], 16));
+	}
+}), W = ["normal", "wheel"], G = z, K = Object.assign(U, { Item: G });
+//#endregion
+export { K as n, W as r, G as t };

package/dist/select/Select.vue.d.ts

@@ -0,0 +1,39 @@
+import { SelectExposed, SelectProps, SelectSlots } from './types';
+type __VLS_Slots = SelectSlots;
+declare const __VLS_base: import('vue').DefineComponent<SelectProps, SelectExposed, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    clear: () => any;
+    search: (value: string, event?: Event | undefined) => any;
+    select: (value: import('./types').SelectPrimitive | undefined, option: import('./types').SelectOptionProps) => any;
+    blur: (event: FocusEvent) => any;
+    change: (value: import('./types').SelectModelValue) => any;
+    focus: (event: FocusEvent) => any;
+    "update:modelValue": (value: import('./types').SelectModelValue) => any;
+    "update:value": (value: import('./types').SelectModelValue) => any;
+    create: (option: import('./types').SelectOptionProps) => any;
+    deselect: (value: import('./types').SelectPrimitive | undefined, option: import('./types').SelectOptionProps) => any;
+    dropdownVisibleChange: (visible: boolean) => any;
+    exceed: (option: import('./types').SelectOptionProps) => any;
+    listScroll: (event: Event) => any;
+}, string, import('vue').PublicProps, Readonly<SelectProps> & Readonly<{
+    onClear?: () => any;
+    onSearch?: (value: string, event?: Event | undefined) => any;
+    onSelect?: (value: import('./types').SelectPrimitive | undefined, option: import('./types').SelectOptionProps) => any;
+    onBlur?: (event: FocusEvent) => any;
+    onChange?: (value: import('./types').SelectModelValue) => any;
+    onFocus?: (event: FocusEvent) => any;
+    "onUpdate:modelValue"?: (value: import('./types').SelectModelValue) => any;
+    "onUpdate:value"?: (value: import('./types').SelectModelValue) => any;
+    onCreate?: (option: import('./types').SelectOptionProps) => any;
+    onDeselect?: (value: import('./types').SelectPrimitive | undefined, option: import('./types').SelectOptionProps) => any;
+    onDropdownVisibleChange?: (visible: boolean) => any;
+    onExceed?: (option: import('./types').SelectOptionProps) => any;
+    onListScroll?: (event: Event) => any;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/select/SelectFragment.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import('vue').DefineComponent<{}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/select/SelectNodeRenderer.d.ts

@@ -0,0 +1,15 @@
+import { PropType, VNodeChild } from 'vue';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    content: {
+        type: PropType<VNodeChild>;
+        default: undefined;
+    };
+}>, () => VNodeChild, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    content: {
+        type: PropType<VNodeChild>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    content: VNodeChild;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/select/SelectOption.vue.d.ts

@@ -0,0 +1,13 @@
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/select/SelectOptionCollector.d.ts

@@ -0,0 +1,13 @@
+import { PropType, VNodeChild } from 'vue';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    collect: {
+        type: PropType<(nodes: VNodeChild) => void>;
+        required: true;
+    };
+}>, () => null, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    collect: {
+        type: PropType<(nodes: VNodeChild) => void>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;