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

package/dist/carousel/types.d.ts

@@ -0,0 +1,70 @@
+import { HTMLAttributes, StyleValue, VNodeChild } from 'vue';
+export declare const CAROUSEL_ANIMATIONS: readonly ["slide", "fade"];
+export declare const CAROUSEL_ARROW_TYPES: readonly ["always", "hover"];
+export declare const CAROUSEL_INDICATOR_POSITIONS: readonly ["left", "center", "right"];
+export declare const CAROUSEL_INDICATOR_SIZES: readonly ["small", "medium"];
+export declare const CAROUSEL_INDICATOR_TYPES: readonly ["columnar", "line", "dot"];
+export declare const CAROUSEL_SLIDE_DIRECTIONS: readonly ["left", "right"];
+export declare const CAROUSEL_THEMES: readonly ["dark", "primary", "light"];
+export declare const CAROUSEL_TRIGGERS: readonly ["click", "hover"];
+export type CarouselAnimation = (typeof CAROUSEL_ANIMATIONS)[number];
+export type CarouselArrowType = (typeof CAROUSEL_ARROW_TYPES)[number];
+export type CarouselIndicatorPosition = (typeof CAROUSEL_INDICATOR_POSITIONS)[number];
+export type CarouselIndicatorSize = (typeof CAROUSEL_INDICATOR_SIZES)[number];
+export type CarouselIndicatorType = (typeof CAROUSEL_INDICATOR_TYPES)[number];
+export type CarouselSlideDirection = (typeof CAROUSEL_SLIDE_DIRECTIONS)[number];
+export type CarouselTheme = (typeof CAROUSEL_THEMES)[number];
+export type CarouselTrigger = (typeof CAROUSEL_TRIGGERS)[number];
+export interface CarouselAutoPlayOptions {
+    hoverToPause?: boolean;
+    interval?: number;
+}
+export interface CarouselArrowButton {
+    children?: VNodeChild;
+    props?: HTMLAttributes & Record<string, unknown>;
+}
+export interface CarouselArrowProps {
+    leftArrow?: CarouselArrowButton;
+    rightArrow?: CarouselArrowButton;
+}
+export interface CarouselProps {
+    activeIndex?: number | undefined;
+    animation?: CarouselAnimation;
+    arrowProps?: CarouselArrowProps | undefined;
+    autoPlay?: boolean | CarouselAutoPlayOptions;
+    arrowType?: CarouselArrowType;
+    class?: HTMLAttributes['class'];
+    className?: HTMLAttributes['class'];
+    defaultActiveIndex?: number;
+    indicatorPosition?: CarouselIndicatorPosition;
+    indicatorSize?: CarouselIndicatorSize;
+    indicatorType?: CarouselIndicatorType;
+    showArrow?: boolean;
+    showIndicator?: boolean;
+    slideDirection?: CarouselSlideDirection;
+    speed?: number;
+    style?: StyleValue;
+    theme?: CarouselTheme;
+    trigger?: CarouselTrigger;
+}
+export interface CarouselEmits {
+    change: [activeIndex: number, preIndex: number];
+}
+export interface CarouselSlots {
+    default?: () => VNodeChild;
+    leftArrow?: () => VNodeChild;
+    rightArrow?: () => VNodeChild;
+}
+export interface CarouselMethods {
+    goTo(targetIndex: number): void;
+    next(): void;
+    play(): void;
+    prev(): void;
+    stop(): void;
+}
+export interface CarouselState {
+    activeIndex: number;
+    isInit: boolean;
+    isReverse: boolean;
+    preIndex: number;
+}

package/dist/carousel/use-carousel-foundation.d.ts

@@ -0,0 +1,19 @@
+import { ComputedRef, VNode } from 'vue';
+import { CarouselEmits, CarouselProps, CarouselState } from './types';
+interface CarouselFoundationController {
+    getIsControlledComponent(): boolean;
+    getValidIndex(index: number): number;
+    goTo(targetIndex: number): void;
+    handleAutoPlay(): void;
+    next(): void;
+    onIndicatorChange(activeIndex: number): void;
+    prev(): void;
+    setForcePlay(forcePlay: boolean): void;
+    stop(): void;
+}
+interface CarouselFoundationBinding {
+    foundation: CarouselFoundationController;
+    state: CarouselState;
+}
+export declare function useCarouselFoundation(props: Readonly<CarouselProps>, children: ComputedRef<VNode[]>, emit: <Event extends keyof CarouselEmits>(event: Event, ...args: CarouselEmits[Event]) => void): CarouselFoundationBinding;
+export {};

package/dist/carousel-B4WlIRJH.js

@@ -0,0 +1,458 @@
+import "./src-DNBBthjO.js";
+import { g as e, s as t, t as n } from "./foundation-Cawx37mp.js";
+import { t as r } from "./env-BeIzjQx7.js";
+import { Comment as i, Fragment as a, Text as o, cloneVNode as s, computed as c, createBlock as l, createCommentVNode as u, createElementBlock as d, createElementVNode as f, createSlots as p, createVNode as m, defineComponent as h, getCurrentInstance as g, markRaw as _, mergeProps as v, normalizeClass as y, onBeforeUnmount as b, onMounted as x, openBlock as S, renderList as C, renderSlot as w, shallowReactive as T, unref as E, useAttrs as D, useSlots as O, watch as k, withCtx as A } from "vue";
+import { IconChevronLeft as j, IconChevronRight as M } from "@aifuxi/semi-icons-vue";
+`${r}`, `${r}`, `${r}`, `${r}`, `${r}`, `${r}`, `${r}`, `${r}`, `${r}`;
+var N = {
+	DEFAULT_ACTIVE_INDEX: 0,
+	DEFAULT_INTERVAL: 2e3,
+	DEFAULT_SPEED: 300
+}, P = class extends n {
+	constructor(e) {
+		super({ ...e }), this._interval = null, this._forcePlay = !1;
+	}
+	setForcePlay(e) {
+		this._forcePlay = e;
+	}
+	play(e) {
+		this._interval && clearInterval(this._interval), this._interval = setInterval(() => {
+			this.next();
+		}, e);
+	}
+	stop() {
+		this._interval && clearInterval(this._interval);
+	}
+	goTo(e) {
+		let { activeIndex: t } = this.getStates(), n = this.getValidIndex(e);
+		this._adapter.setIsReverse(t > n), this.getIsControlledComponent() ? this._notifyChange(n) : (this._notifyChange(n), this.handleNewActiveIndex(n));
+	}
+	next() {
+		this.stop();
+		let { activeIndex: e } = this.getStates(), t = this.getValidIndex(e + 1);
+		this._adapter.setIsReverse(!1), this.getIsControlledComponent() ? this._notifyChange(t) : (this._notifyChange(t), this.handleNewActiveIndex(t)), this.handleAutoPlay();
+	}
+	prev() {
+		this.stop();
+		let { activeIndex: e } = this.getStates(), t = this.getValidIndex(e - 1);
+		this._adapter.setIsReverse(!0), this.getIsControlledComponent() ? this._notifyChange(t) : (this._notifyChange(t), this.handleNewActiveIndex(t)), this.handleAutoPlay();
+	}
+	destroy() {
+		this._unregisterInterval();
+	}
+	_unregisterInterval() {
+		this._interval &&= (clearInterval(this._interval), null);
+	}
+	_notifyChange(e) {
+		let { activeIndex: t, isInit: n } = this.getStates();
+		n && this._adapter.setIsInit(!1), t !== e && (this._adapter.setPreActiveIndex(t), this._adapter.notifyChange(e, t));
+	}
+	getValidIndex(e) {
+		let t = this._adapter.getChildren();
+		return (e + t.length) % t.length;
+	}
+	getSwitchingTime() {
+		let { autoPlay: n, speed: r } = this.getProps();
+		return typeof n == "boolean" ? N.DEFAULT_INTERVAL + r : (0, e.default)(n) ? (0, t.default)(n, "interval", N.DEFAULT_INTERVAL) + r : r;
+	}
+	getIsControlledComponent() {
+		return this._isInProps("activeIndex");
+	}
+	handleAutoPlay() {
+		let { autoPlay: t } = this.getProps();
+		this._adapter.getChildren().length > 1 && (t === !0 || (0, e.default)(t) || this._forcePlay) && this.play(this.getSwitchingTime());
+	}
+	handleKeyDown(e) {
+		e.key === "ArrowLeft" && this.prev(), e.key === "ArrowRight" && this.next();
+	}
+	onIndicatorChange(e) {
+		let { activeIndex: t } = this.getStates();
+		this._adapter.setIsReverse(t > e), this._notifyChange(e), this.getIsControlledComponent() || this.handleNewActiveIndex(e);
+	}
+	handleNewActiveIndex(e) {
+		let { activeIndex: t } = this.getStates();
+		t !== e && this._adapter.setNewActiveIndex(e);
+	}
+	getDefaultActiveIndex() {
+		let e, t = this.getProps();
+		return "activeIndex" in t ? e = t.activeIndex : "defaultActiveIndex" in t && (e = t.defaultActiveIndex), e;
+	}
+}, F = h({
+	name: "CarouselNodeRenderer",
+	props: { content: {
+		type: null,
+		default: void 0
+	} },
+	setup: (e) => () => e.content
+}), I = /* @__PURE__ */ h({
+	__name: "CarouselArrow",
+	props: {
+		arrowProps: {},
+		theme: {},
+		type: {}
+	},
+	emits: ["next", "prev"],
+	setup(e, { emit: t }) {
+		let n = e, r = t, i = O(), a = c(() => [
+			"semi-carousel-arrow",
+			`semi-carousel-arrow-${n.theme}`,
+			{ "semi-carousel-arrow-hover": n.type === "hover" }
+		]), o = (e, t, n) => {
+			let r = { ...e ?? {} }, i = r.class ?? r.className;
+			return delete r.class, delete r.className, {
+				class: i ?? t,
+				onClick: n,
+				...r
+			};
+		}, s = c(() => o(n.arrowProps?.leftArrow?.props, ["semi-carousel-arrow-prev", `semi-carousel-arrow-${n.theme}`], () => r("prev"))), u = c(() => o(n.arrowProps?.rightArrow?.props, ["semi-carousel-arrow-next", `semi-carousel-arrow-${n.theme}`], () => r("next"))), p = c(() => i.leftArrow?.() ?? n.arrowProps?.leftArrow?.children), m = c(() => i.rightArrow?.() ?? n.arrowProps?.rightArrow?.children);
+		return (e, t) => (S(), d("div", { class: y(a.value) }, [f("div", v(s.value, { "x-semi-prop": "arrowProps.leftArrow.children" }), [p.value ? (S(), l(E(F), {
+			key: 0,
+			content: p.value
+		}, null, 8, ["content"])) : (S(), l(E(j), {
+			key: 1,
+			"aria-label": "Previous index",
+			size: "inherit"
+		}))], 16), f("div", v(u.value, { "x-semi-prop": "arrowProps.rightArrow.children" }), [m.value ? (S(), l(E(F), {
+			key: 0,
+			content: m.value
+		}, null, 8, ["content"])) : (S(), l(E(M), {
+			key: 1,
+			"aria-label": "Next index",
+			size: "inherit"
+		}))], 16)], 2));
+	}
+}), L = [
+	"data-index",
+	"onClick",
+	"onMouseenter"
+], R = /* @__PURE__ */ h({
+	__name: "CarouselIndicator",
+	props: {
+		activeIndex: {},
+		position: {},
+		size: {},
+		theme: {},
+		total: {},
+		trigger: {},
+		type: {}
+	},
+	emits: ["change"],
+	setup(e, { emit: t }) {
+		let n = e, r = t, i = c(() => [
+			"semi-carousel-indicator",
+			`semi-carousel-indicator-${n.type}`,
+			`semi-carousel-indicator-${n.position}`
+		]);
+		function o(e) {
+			n.trigger === "click" && r("change", e);
+		}
+		function s(e) {
+			n.trigger === "hover" && r("change", e);
+		}
+		return (e, t) => (S(), d("div", { class: y(i.value) }, [(S(!0), d(a, null, C(n.total, (e) => (S(), d("span", {
+			key: e - 1,
+			class: y([
+				"semi-carousel-indicator-item",
+				`semi-carousel-indicator-item-${n.theme}`,
+				`semi-carousel-indicator-item-${n.size}`,
+				{ "semi-carousel-indicator-item-active": e - 1 === n.activeIndex }
+			]),
+			"data-index": e - 1,
+			onClick: (t) => o(e - 1),
+			onMouseenter: (t) => s(e - 1)
+		}, null, 42, L))), 128))], 2));
+	}
+}), z = h({
+	name: "CarouselItemRenderer",
+	props: {
+		itemClass: {
+			type: null,
+			default: void 0
+		},
+		itemStyle: {
+			type: null,
+			default: void 0
+		},
+		node: {
+			type: Object,
+			required: !0
+		}
+	},
+	setup: (e) => () => s(e.node, {
+		class: e.itemClass,
+		style: e.itemStyle
+	})
+});
+//#endregion
+//#region src/carousel/use-carousel-foundation.ts
+function B(e, t) {
+	return !!(e && Object.prototype.hasOwnProperty.call(e, t));
+}
+function V(e, t, n) {
+	let r = g(), i = () => B(r?.vnode.props, "activeIndex") || B(r?.vnode.props, "active-index"), a = T({
+		activeIndex: e.activeIndex ?? e.defaultActiveIndex ?? 0,
+		preIndex: e.activeIndex ?? e.defaultActiveIndex ?? 0,
+		isReverse: !1,
+		isInit: !0
+	}), o = /* @__PURE__ */ new Map(), s = () => {
+		let t = {
+			animation: e.animation ?? "slide",
+			arrowType: e.arrowType ?? "always",
+			autoPlay: e.autoPlay ?? !0,
+			defaultActiveIndex: e.defaultActiveIndex ?? 0,
+			indicatorPosition: e.indicatorPosition ?? "center",
+			indicatorSize: e.indicatorSize ?? "small",
+			indicatorType: e.indicatorType ?? "dot",
+			showArrow: e.showArrow ?? !0,
+			showIndicator: e.showIndicator ?? !0,
+			slideDirection: e.slideDirection ?? "left",
+			speed: e.speed ?? 300,
+			theme: e.theme ?? "light",
+			trigger: e.trigger ?? "click"
+		};
+		return i() && (t.activeIndex = e.activeIndex), t;
+	}, c = _(new P({
+		getContext: () => void 0,
+		getContexts: () => ({}),
+		getProp: (e) => s()[e],
+		getProps: s,
+		getState: (e) => a[e],
+		getStates: () => a,
+		setState: (e, t) => {
+			Object.assign(a, e), t?.();
+		},
+		getCache: (e) => o.get(e),
+		getCaches: () => o,
+		setCache: (e, t) => o.set(e, t),
+		stopPropagation: (e) => e?.stopPropagation?.(),
+		persistEvent: () => void 0,
+		notifyChange: (e, t) => n("change", e, t),
+		setNewActiveIndex: (e) => {
+			a.activeIndex = e;
+		},
+		setPreActiveIndex: (e) => {
+			a.preIndex = e;
+		},
+		setIsReverse: (e) => {
+			a.isReverse = e;
+		},
+		setIsInit: (e) => {
+			a.isInit = e;
+		},
+		getChildren: () => t.value
+	}));
+	return k(() => e.activeIndex, (e) => {
+		i() && e !== void 0 && e !== a.activeIndex && (a.activeIndex = e);
+	}), x(() => {
+		c.getIsControlledComponent() || c.handleAutoPlay();
+	}), b(() => c.destroy()), {
+		foundation: c,
+		state: a
+	};
+}
+//#endregion
+//#region src/carousel/Carousel.vue?vue&type=script&setup=true&lang.ts
+var H = {
+	key: 0,
+	class: "semi-carousel-indicator"
+}, U = /* @__PURE__ */ h({
+	name: "Carousel",
+	inheritAttrs: !1,
+	__name: "Carousel",
+	props: {
+		activeIndex: {},
+		animation: { default: "slide" },
+		arrowProps: {},
+		autoPlay: {
+			type: [Boolean, Object],
+			default: !0
+		},
+		arrowType: { default: "always" },
+		class: { type: [
+			Boolean,
+			null,
+			String,
+			Object,
+			Array
+		] },
+		className: { type: [
+			Boolean,
+			null,
+			String,
+			Object,
+			Array
+		] },
+		defaultActiveIndex: { default: 0 },
+		indicatorPosition: { default: "center" },
+		indicatorSize: { default: "small" },
+		indicatorType: { default: "dot" },
+		showArrow: {
+			type: Boolean,
+			default: !0
+		},
+		showIndicator: {
+			type: Boolean,
+			default: !0
+		},
+		slideDirection: { default: "left" },
+		speed: { default: 300 },
+		style: { type: [
+			Boolean,
+			null,
+			String,
+			Object,
+			Array
+		] },
+		theme: { default: "light" },
+		trigger: { default: "click" }
+	},
+	emits: ["change"],
+	setup(e, { expose: t, emit: n }) {
+		let r = e, s = n, h = D(), g = O();
+		function _(e, t = []) {
+			for (let n of e ?? []) if (n.type !== i && n.type !== o) {
+				if (n.type === a && Array.isArray(n.children)) {
+					_(n.children, t);
+					continue;
+				}
+				t.push(n);
+			}
+			return t;
+		}
+		let x = c(() => _(g.default?.())), { foundation: T, state: k } = V(r, x, s), j = c(() => Object.fromEntries(Object.entries(h).filter(([e]) => !["class", "style"].includes(e)))), M = c(() => [
+			"semi-carousel-content",
+			`semi-carousel-content-${r.animation}`,
+			{ "semi-carousel-content-reverse": r.slideDirection === "left" ? k.isReverse : !k.isReverse }
+		]), N = c(() => ({
+			transitionTimingFunction: "ease",
+			transitionDuration: `${r.speed}ms`,
+			animationTimingFunction: "ease",
+			animationDuration: `${r.speed}ms`
+		})), P = c(() => r.showIndicator && x.value.length > 1), F = c(() => r.showArrow && x.value.length > 1), L, B;
+		function U() {
+			L !== void 0 && clearTimeout(L), B !== void 0 && clearTimeout(B), L = void 0, B = void 0;
+		}
+		function W() {
+			L !== void 0 && clearTimeout(L), L = setTimeout(() => {
+				(r.autoPlay === !0 || typeof r.autoPlay == "object" && r.autoPlay.hoverToPause) && T.stop();
+			}, 400);
+		}
+		function G() {
+			B !== void 0 && clearTimeout(B), B = setTimeout(() => {
+				(typeof r.autoPlay != "object" || r.autoPlay.hoverToPause) && !T.getIsControlledComponent() && T.handleAutoPlay();
+			}, 400);
+		}
+		function K(e) {
+			let t = e === k.activeIndex, n = x.value.length ? T.getValidIndex(k.activeIndex - 1) : -1;
+			return {
+				"semi-carousel-content-item": !0,
+				"semi-carousel-content-item-active": t,
+				"semi-carousel-content-item-current": t,
+				"semi-carousel-content-item-next": e === (x.value.length ? T.getValidIndex(k.activeIndex + 1) : -1),
+				"semi-carousel-content-item-prev": e === n,
+				"semi-carousel-content-item-slide-in": r.animation === "slide" && !k.isInit && t,
+				"semi-carousel-content-item-slide-out": r.animation === "slide" && !k.isInit && e === k.preIndex
+			};
+		}
+		function q() {
+			T.setForcePlay(!0), T.handleAutoPlay();
+		}
+		function J() {
+			T.setForcePlay(!1), T.stop();
+		}
+		function Y(e) {
+			T.goTo(e);
+		}
+		function X() {
+			T.prev();
+		}
+		function Z() {
+			T.next();
+		}
+		function Q(e) {
+			T.onIndicatorChange(e);
+		}
+		return t({
+			goTo: Y,
+			next: Z,
+			play: q,
+			prev: X,
+			stop: J
+		}), b(U), (e, t) => (S(), d("div", v(j.value, {
+			class: ["semi-carousel", [
+				E(h).class,
+				r.class,
+				r.className
+			]],
+			style: [E(h).style, r.style],
+			onMouseenter: W,
+			onMouseleave: G
+		}), [
+			f("div", {
+				class: y(M.value),
+				"x-semi-prop": "children"
+			}, [(S(!0), d(a, null, C(x.value, (e, t) => (S(), l(E(z), {
+				key: e.key ?? t,
+				"item-class": K(t),
+				"item-style": N.value,
+				node: e
+			}, null, 8, [
+				"item-class",
+				"item-style",
+				"node"
+			]))), 128))], 2),
+			P.value ? (S(), d("div", H, [m(R, {
+				"active-index": E(k).activeIndex,
+				position: r.indicatorPosition,
+				size: r.indicatorSize,
+				theme: r.theme,
+				total: x.value.length,
+				trigger: r.trigger,
+				type: r.indicatorType,
+				onChange: Q
+			}, null, 8, [
+				"active-index",
+				"position",
+				"size",
+				"theme",
+				"total",
+				"trigger",
+				"type"
+			])])) : u("", !0),
+			F.value ? (S(), l(I, {
+				key: 1,
+				"arrow-props": r.arrowProps,
+				theme: r.theme,
+				type: r.arrowType,
+				onNext: Z,
+				onPrev: X
+			}, p({ _: 2 }, [E(g).leftArrow ? {
+				name: "leftArrow",
+				fn: A(() => [w(e.$slots, "leftArrow")]),
+				key: "0"
+			} : void 0, E(g).rightArrow ? {
+				name: "rightArrow",
+				fn: A(() => [w(e.$slots, "rightArrow")]),
+				key: "1"
+			} : void 0]), 1032, [
+				"arrow-props",
+				"theme",
+				"type"
+			])) : u("", !0)
+		], 16));
+	}
+}), W = ["slide", "fade"], G = ["always", "hover"], K = [
+	"left",
+	"center",
+	"right"
+], q = ["small", "medium"], J = [
+	"columnar",
+	"line",
+	"dot"
+], Y = ["left", "right"], X = [
+	"dark",
+	"primary",
+	"light"
+], Z = ["click", "hover"], Q = U;
+//#endregion
+export { q as a, X as c, K as i, Z as l, W as n, J as o, G as r, Y as s, Q as t };

package/dist/cascader/Cascader.vue.d.ts

@@ -0,0 +1,71 @@
+import { CascaderData, CascaderEntity, CascaderExposed, CascaderProps, CascaderSlots, CascaderValue } from './types';
+type __VLS_Slots = CascaderSlots;
+declare const __VLS_base: import('vue').DefineComponent<CascaderProps, CascaderExposed, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    clear: () => any;
+    search: (value: string) => any;
+    select: (value: string | number | (string | number)[]) => any;
+    blur: (event: unknown) => any;
+    change: (value: CascaderValue) => any;
+    focus: (event: unknown) => any;
+    load: (loadedKeys: Set<string>, data: CascaderData) => any;
+    "update:modelValue": (value: CascaderValue) => any;
+    "update:value": (value: CascaderValue) => any;
+    visibleChange: (visible: boolean) => any;
+    exceed: (checkedItems: CascaderEntity[]) => any;
+    listScroll: (event: Event, panel: import('./types').CascaderScrollPanelProps) => any;
+}, string, import('vue').PublicProps, Readonly<CascaderProps> & Readonly<{
+    onClear?: () => any;
+    onSearch?: (value: string) => any;
+    onSelect?: (value: string | number | (string | number)[]) => any;
+    onBlur?: (event: unknown) => any;
+    onChange?: (value: CascaderValue) => any;
+    onFocus?: (event: unknown) => any;
+    onLoad?: (loadedKeys: Set<string>, data: CascaderData) => any;
+    "onUpdate:modelValue"?: (value: CascaderValue) => any;
+    "onUpdate:value"?: (value: CascaderValue) => any;
+    onVisibleChange?: (visible: boolean) => any;
+    onExceed?: (checkedItems: CascaderEntity[]) => any;
+    onListScroll?: (event: Event, panel: import('./types').CascaderScrollPanelProps) => any;
+}>, {
+    disabled: boolean;
+    size: import('./types').CascaderSize;
+    separator: string;
+    multiple: boolean;
+    zIndex: number;
+    borderless: boolean;
+    showClear: boolean;
+    validateStatus: import('./types').CascaderValidateStatus;
+    ariaLabel: string;
+    motion: boolean;
+    stopPropagation: boolean | string;
+    autoAdjustOverflow: boolean;
+    autoClearSearchValue: boolean;
+    defaultOpen: boolean;
+    onChangeWithObject: boolean;
+    remote: boolean;
+    searchPosition: import('./types').CascaderSearchPosition;
+    showRestTagsPopover: boolean;
+    restTagsPopoverProps: import('..').PopoverProps;
+    showNext: import('./types').CascaderShowNext;
+    autoMergeValue: boolean;
+    changeOnSelect: boolean;
+    checkRelation: import('./types').CascaderCheckRelation;
+    clickToSelect: boolean;
+    disableStrictly: boolean;
+    displayProp: string;
+    enableLeafClick: boolean;
+    filterLeafOnly: boolean;
+    filterTreeNode: boolean | ((inputValue: string, treeNodeString: string, data?: CascaderData) => boolean);
+    keyMaps: import('./types').CascaderKeyMaps;
+    leafOnly: boolean;
+    treeData: CascaderData[];
+    treeNodeFilterProp: string;
+}, {}, {}, {}, 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/cascader/CascaderNodeRenderer.d.ts

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

package/dist/cascader/CascaderPanel.vue.d.ts

@@ -0,0 +1,36 @@
+import { VNode, VNodeArrayChildren, VNodeChild } from 'vue';
+import { CascaderData, CascaderEntity, CascaderFilterData, CascaderFilterRenderProps, CascaderShowNext, CascaderVirtualize } from './types';
+type CascaderPanelNode = string | number | VNode | VNodeArrayChildren | null;
+interface Props {
+    activeKeys: Set<string>;
+    checkedKeys: Set<string>;
+    data: Array<CascaderEntity | CascaderFilterData>;
+    direction: 'ltr' | 'rtl';
+    emptyContent?: CascaderPanelNode | undefined;
+    expandIcon?: CascaderPanelNode | undefined;
+    filterRender?: ((props: CascaderFilterRenderProps) => VNodeChild) | undefined;
+    halfCheckedKeys: Set<string>;
+    keyword: string;
+    loadData?: ((selectOptions: CascaderData[]) => Promise<void>) | undefined;
+    loadedKeys: Set<string>;
+    loadingKeys: Set<string>;
+    multiple: boolean;
+    searchable: boolean;
+    selectedKeys: Set<string>;
+    separator: string;
+    showNext: CascaderShowNext;
+    virtualize?: CascaderVirtualize | undefined;
+}
+declare const __VLS_export: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    listScroll: (event: Event, panelIndex: number) => any;
+    check: (item: CascaderEntity | CascaderFilterData) => any;
+    itemClick: (event: MouseEvent | KeyboardEvent, item: CascaderEntity | CascaderFilterData) => any;
+    itemHover: (event: MouseEvent, item: CascaderEntity) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onListScroll?: (event: Event, panelIndex: number) => any;
+    onCheck?: (item: CascaderEntity | CascaderFilterData) => any;
+    onItemClick?: (event: MouseEvent | KeyboardEvent, item: CascaderEntity | CascaderFilterData) => any;
+    onItemHover?: (event: MouseEvent, item: CascaderEntity) => any;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/cascader/index.d.ts

@@ -0,0 +1,6 @@
+import { DefineComponent } from 'vue';
+import { CascaderExposed, CascaderProps } from './types';
+export type CascaderComponent = DefineComponent<CascaderProps, CascaderExposed>;
+export declare const Cascader: CascaderComponent;
+export type { CascaderCheckRelation, CascaderData, CascaderEmits, CascaderEntity, CascaderExposed, CascaderFilterData, CascaderFilterRenderProps, CascaderKeyMaps, CascaderProps, CascaderScrollPanelProps, CascaderSearchPosition, CascaderShowNext, CascaderSimpleValue, CascaderSize, CascaderSlots, CascaderTriggerRenderProps, CascaderValidateStatus, CascaderValue, CascaderVirtualize, } from './types';
+export default Cascader;

package/dist/cascader/index.js

@@ -0,0 +1,2 @@
+import { t as e } from "../cascader-Ch6clCeh.js";
+export { e as Cascader, e as default };