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

package/dist/descriptions/Descriptions.vue.d.ts

@@ -0,0 +1,96 @@
+import { PropType } from 'vue';
+import { DescriptionsAlign, DescriptionsDataItem, DescriptionsLayout, DescriptionsProps, DescriptionsSize, DescriptionsSlots } from './types';
+type __VLS_Slots = DescriptionsSlots;
+declare const __VLS_base: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    align: {
+        type: PropType<DescriptionsAlign>;
+        default: undefined;
+    };
+    row: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    size: {
+        type: PropType<DescriptionsSize>;
+        default: undefined;
+    };
+    class: {
+        type: PropType<DescriptionsProps["class"]>;
+        default: undefined;
+    };
+    className: {
+        type: PropType<DescriptionsProps["className"]>;
+        default: undefined;
+    };
+    style: {
+        type: PropType<DescriptionsProps["style"]>;
+        default: undefined;
+    };
+    data: {
+        type: PropType<readonly DescriptionsDataItem[]>;
+        default: undefined;
+    };
+    layout: {
+        type: PropType<DescriptionsLayout>;
+        default: undefined;
+    };
+    column: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    align: {
+        type: PropType<DescriptionsAlign>;
+        default: undefined;
+    };
+    row: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    size: {
+        type: PropType<DescriptionsSize>;
+        default: undefined;
+    };
+    class: {
+        type: PropType<DescriptionsProps["class"]>;
+        default: undefined;
+    };
+    className: {
+        type: PropType<DescriptionsProps["className"]>;
+        default: undefined;
+    };
+    style: {
+        type: PropType<DescriptionsProps["style"]>;
+        default: undefined;
+    };
+    data: {
+        type: PropType<readonly DescriptionsDataItem[]>;
+        default: undefined;
+    };
+    layout: {
+        type: PropType<DescriptionsLayout>;
+        default: undefined;
+    };
+    column: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    className: import('vue').ClassValue;
+    style: import('vue').StyleValue;
+    size: "small" | "medium" | "large";
+    class: import('vue').ClassValue;
+    data: readonly DescriptionsDataItem[];
+    column: number;
+    layout: "horizontal" | "vertical";
+    row: boolean;
+    align: "center" | "left" | "justify" | "plain";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, 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/descriptions/DescriptionsItem.vue.d.ts

@@ -0,0 +1,96 @@
+import { PropType, VNodeChild } from 'vue';
+import { DescriptionsItemProps, DescriptionsItemSlots } from './types';
+type __VLS_Slots = DescriptionsItemSlots;
+declare const __VLS_base: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    hidden: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    class: {
+        type: PropType<DescriptionsItemProps["class"]>;
+        default: undefined;
+    };
+    className: {
+        type: PropType<DescriptionsItemProps["className"]>;
+        default: undefined;
+    };
+    style: {
+        type: PropType<DescriptionsItemProps["style"]>;
+        default: undefined;
+    };
+    itemKey: {
+        type: PropType<VNodeChild>;
+        default: undefined;
+    };
+    span: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    keyStyle: {
+        type: PropType<DescriptionsItemProps["keyStyle"]>;
+        default: undefined;
+    };
+    internalKey: {
+        type: PropType<VNodeChild | (() => VNodeChild)>;
+        default: undefined;
+    };
+    internalValue: {
+        type: PropType<VNodeChild | (() => VNodeChild)>;
+        default: undefined;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    hidden: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    class: {
+        type: PropType<DescriptionsItemProps["class"]>;
+        default: undefined;
+    };
+    className: {
+        type: PropType<DescriptionsItemProps["className"]>;
+        default: undefined;
+    };
+    style: {
+        type: PropType<DescriptionsItemProps["style"]>;
+        default: undefined;
+    };
+    itemKey: {
+        type: PropType<VNodeChild>;
+        default: undefined;
+    };
+    span: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    keyStyle: {
+        type: PropType<DescriptionsItemProps["keyStyle"]>;
+        default: undefined;
+    };
+    internalKey: {
+        type: PropType<VNodeChild | (() => VNodeChild)>;
+        default: undefined;
+    };
+    internalValue: {
+        type: PropType<VNodeChild | (() => VNodeChild)>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    className: import('vue').ClassValue;
+    style: import('vue').StyleValue;
+    class: import('vue').ClassValue;
+    span: number;
+    hidden: boolean;
+    itemKey: VNodeChild;
+    keyStyle: import('vue').StyleValue;
+    internalKey: VNodeChild | (() => VNodeChild);
+    internalValue: VNodeChild | (() => VNodeChild);
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, 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/descriptions/DescriptionsNodeRenderer.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/descriptions/descriptions-context.d.ts

@@ -0,0 +1,7 @@
+import { ComputedRef, InjectionKey } from 'vue';
+import { DescriptionsAlign, DescriptionsLayout } from './types';
+export interface DescriptionsContextValue {
+    align: ComputedRef<DescriptionsAlign>;
+    layout: ComputedRef<DescriptionsLayout>;
+}
+export declare const descriptionsContextKey: InjectionKey<DescriptionsContextValue>;

package/dist/descriptions/index.d.ts

@@ -0,0 +1,10 @@
+import { DefineComponent } from 'vue';
+import { DescriptionsItemProps, DescriptionsProps } from './types';
+export type DescriptionsCompoundComponent = DefineComponent<DescriptionsProps> & {
+    Item: DefineComponent<DescriptionsItemProps>;
+};
+export declare const DescriptionsItem: DefineComponent<DescriptionsItemProps>;
+export declare const Descriptions: DescriptionsCompoundComponent;
+export { DESCRIPTIONS_ALIGNS, DESCRIPTIONS_LAYOUTS, DESCRIPTIONS_SIZES } from './types';
+export type { DescriptionsAlign, DescriptionsDataItem, DescriptionsItemProps, DescriptionsItemSlots, DescriptionsLayout, DescriptionsProps, DescriptionsSize, DescriptionsSlots, } from './types';
+export default Descriptions;

package/dist/descriptions/index.js

@@ -0,0 +1,2 @@
+import { a as e, i as t, n, r, t as i } from "../descriptions-BU6ahbge.js";
+export { r as DESCRIPTIONS_ALIGNS, t as DESCRIPTIONS_LAYOUTS, e as DESCRIPTIONS_SIZES, i as Descriptions, i as default, n as DescriptionsItem };

package/dist/descriptions/types.d.ts

@@ -0,0 +1,45 @@
+import { HTMLAttributes, StyleValue, VNodeChild } from 'vue';
+export declare const DESCRIPTIONS_ALIGNS: readonly ["center", "justify", "left", "plain"];
+export declare const DESCRIPTIONS_SIZES: readonly ["small", "medium", "large"];
+export declare const DESCRIPTIONS_LAYOUTS: readonly ["horizontal", "vertical"];
+export type DescriptionsAlign = (typeof DESCRIPTIONS_ALIGNS)[number];
+export type DescriptionsSize = (typeof DESCRIPTIONS_SIZES)[number];
+export type DescriptionsLayout = (typeof DESCRIPTIONS_LAYOUTS)[number];
+export interface DescriptionsDataItem {
+    key?: VNodeChild;
+    value?: VNodeChild | (() => VNodeChild);
+    hidden?: boolean;
+    span?: number;
+    keyStyle?: StyleValue;
+    class?: HTMLAttributes['class'];
+    className?: HTMLAttributes['class'];
+    style?: StyleValue;
+    [dataAttribute: `data-${string}`]: unknown;
+}
+export interface DescriptionsProps {
+    align?: DescriptionsAlign;
+    row?: boolean;
+    size?: DescriptionsSize;
+    class?: HTMLAttributes['class'];
+    className?: HTMLAttributes['class'];
+    style?: StyleValue;
+    data?: readonly DescriptionsDataItem[];
+    layout?: DescriptionsLayout;
+    column?: number;
+}
+export interface DescriptionsSlots {
+    default?: () => VNodeChild;
+}
+export interface DescriptionsItemProps {
+    hidden?: boolean;
+    class?: HTMLAttributes['class'];
+    className?: HTMLAttributes['class'];
+    style?: StyleValue;
+    itemKey?: VNodeChild;
+    span?: number;
+    keyStyle?: StyleValue;
+}
+export interface DescriptionsItemSlots {
+    default?: () => VNodeChild;
+    key?: () => VNodeChild;
+}

package/dist/descriptions-BU6ahbge.js

@@ -0,0 +1,272 @@
+import "./src-DNBBthjO.js";
+import { t as e } from "./foundation-Cawx37mp.js";
+import { n as t } from "./config-provider-VMfNNSF1.js";
+import { Comment as n, Fragment as r, Text as i, computed as a, createBlock as o, createCommentVNode as s, createElementBlock as c, createElementVNode as l, createTextVNode as u, createVNode as d, defineComponent as f, getCurrentInstance as p, inject as m, isVNode as h, markRaw as g, mergeProps as _, normalizeStyle as v, openBlock as y, provide as b, renderList as x, renderSlot as S, unref as C, useAttrs as w, useSlots as T } from "vue";
+//#region bundled-foundation
+var E = class extends e {
+	constructor(e) {
+		super({ ...e });
+	}
+	getHorizontalList() {
+		let { column: e, data: t, children: n } = this.getProps(), r = this._adapter.getColumns().filter((e) => !e.hidden), i = [], a = {
+			totalSpan: 0,
+			itemList: []
+		};
+		for (let t of r) a.totalSpan += t.span || 1, a.itemList.push(t), a.totalSpan >= e && (i.push(a.itemList), a.itemList = [], a.totalSpan = 0);
+		if (a.itemList.length != 0) {
+			let t = a.itemList[a.itemList.length - 1];
+			if (isNaN(t.span)) {
+				let n = 0;
+				a.itemList.forEach((e) => n += isNaN(e.span) ? 1 : e.span), n < e && (t.span = e - n + 1);
+			}
+			i.push(a.itemList);
+		}
+		return i;
+	}
+}, D = f({
+	name: "DescriptionsNodeRenderer",
+	props: { content: {
+		type: null,
+		default: void 0
+	} },
+	setup(e) {
+		return () => typeof e.content == "function" ? e.content() : e.content;
+	}
+}), O = Symbol("semi-descriptions-context"), k = ["colspan"], A = { class: "semi-descriptions-value" }, j = { class: "semi-descriptions-item semi-descriptions-item-th" }, M = ["colspan"], N = { class: "semi-descriptions-value" }, P = ["colspan"], F = { class: "semi-descriptions-value" }, I = { class: "semi-descriptions-item semi-descriptions-item-th" }, L = ["colspan"], R = { class: "semi-descriptions-value" }, z = /* @__PURE__ */ f({
+	name: "DescriptionsItem",
+	inheritAttrs: !1,
+	__name: "DescriptionsItem",
+	props: {
+		hidden: {
+			type: Boolean,
+			default: !1
+		},
+		class: {
+			type: null,
+			default: void 0
+		},
+		className: {
+			type: null,
+			default: void 0
+		},
+		style: {
+			type: null,
+			default: void 0
+		},
+		itemKey: {
+			type: null,
+			default: void 0
+		},
+		span: {
+			type: Number,
+			default: void 0
+		},
+		keyStyle: {
+			type: null,
+			default: void 0
+		},
+		internalKey: {
+			type: null,
+			default: void 0
+		},
+		internalValue: {
+			type: null,
+			default: void 0
+		}
+	},
+	setup(e) {
+		let t = e, n = w(), i = m(O, void 0), o = a(() => i?.align.value ?? "center"), f = a(() => i?.layout.value ?? "vertical"), p = a(() => o.value === "plain"), h = a(() => n.class || t.class || t.className ? [
+			n.class,
+			t.class,
+			t.className
+		] : void 0), g = a(() => n.style || t.style ? [t.style, n.style] : void 0), b = a(() => Object.fromEntries(Object.entries(n).filter(([e]) => e.startsWith("data-")))), x = a(() => t.internalKey ?? t.itemKey), T = a(() => t.span ? t.span * 2 - 1 : 1);
+		return (t, n) => e.hidden ? s("", !0) : (y(), c(r, { key: 0 }, [f.value === "horizontal" ? (y(), c(r, { key: 0 }, [p.value ? (y(), c("td", {
+			key: 0,
+			class: "semi-descriptions-item",
+			colspan: e.span || 1
+		}, [l("span", {
+			class: "semi-descriptions-key",
+			style: v(e.keyStyle)
+		}, [S(t.$slots, "key", {}, () => [d(C(D), { content: x.value }, null, 8, ["content"])]), n[0] ||= u(": ", -1)], 4), l("span", A, [S(t.$slots, "default", {}, () => [d(C(D), { content: e.internalValue }, null, 8, ["content"])])])], 8, k)) : (y(), c(r, { key: 1 }, [l("th", j, [l("span", {
+			class: "semi-descriptions-key",
+			style: v(e.keyStyle)
+		}, [S(t.$slots, "key", {}, () => [d(C(D), { content: x.value }, null, 8, ["content"])])], 4)]), l("td", {
+			class: "semi-descriptions-item semi-descriptions-item-td",
+			colspan: T.value
+		}, [l("span", N, [S(t.$slots, "default", {}, () => [d(C(D), { content: e.internalValue }, null, 8, ["content"])])])], 8, M)], 64))], 64)) : (y(), c("tr", _({
+			key: 1,
+			class: h.value,
+			style: g.value
+		}, b.value), [p.value ? (y(), c("td", {
+			key: 0,
+			class: "semi-descriptions-item",
+			colspan: e.span || 1
+		}, [l("span", {
+			class: "semi-descriptions-key",
+			style: v(e.keyStyle)
+		}, [S(t.$slots, "key", {}, () => [d(C(D), { content: x.value }, null, 8, ["content"])]), n[1] ||= u(": ", -1)], 4), l("span", F, [S(t.$slots, "default", {}, () => [d(C(D), { content: e.internalValue }, null, 8, ["content"])])])], 8, P)) : (y(), c(r, { key: 1 }, [l("th", I, [l("span", {
+			class: "semi-descriptions-key",
+			style: v(e.keyStyle)
+		}, [S(t.$slots, "key", {}, () => [d(C(D), { content: x.value }, null, 8, ["content"])])], 4)]), l("td", {
+			class: "semi-descriptions-item semi-descriptions-item-td",
+			colspan: T.value
+		}, [l("span", R, [S(t.$slots, "default", {}, () => [d(C(D), { content: e.internalValue }, null, 8, ["content"])])])], 8, L)], 64))], 16))], 64));
+	}
+}), B = /* @__PURE__ */ f({
+	name: "Descriptions",
+	inheritAttrs: !1,
+	__name: "Descriptions",
+	props: {
+		align: {
+			type: String,
+			default: void 0
+		},
+		row: {
+			type: Boolean,
+			default: void 0
+		},
+		size: {
+			type: String,
+			default: void 0
+		},
+		class: {
+			type: null,
+			default: void 0
+		},
+		className: {
+			type: null,
+			default: void 0
+		},
+		style: {
+			type: null,
+			default: void 0
+		},
+		data: {
+			type: Array,
+			default: void 0
+		},
+		layout: {
+			type: String,
+			default: void 0
+		},
+		column: {
+			type: Number,
+			default: void 0
+		}
+	},
+	setup(e) {
+		let s = e, u = w(), d = T(), f = p();
+		function m(e) {
+			let t = f?.vnode.props, n = String(e).replace(/[A-Z]/g, (e) => `-${e.toLowerCase()}`);
+			return !!(t && (Object.prototype.hasOwnProperty.call(t, e) || Object.prototype.hasOwnProperty.call(t, n)));
+		}
+		function v(e, n) {
+			if (m(e) && s[e] !== void 0) return s[e];
+			let r = t.config.overrideDefaultProps?.Descriptions?.[e];
+			return r === void 0 ? n : r;
+		}
+		let C = a(() => v("align", "center")), D = a(() => v("row", !1)), k = a(() => v("size", "medium")), A = a(() => v("data", [])), j = a(() => v("layout", "vertical")), M = a(() => v("column", 3));
+		b(O, {
+			align: C,
+			layout: j
+		});
+		function N(e) {
+			if (!e || typeof e != "object" || Array.isArray(e)) return !1;
+			let t = Object.getPrototypeOf(e);
+			return t === Object.prototype || t === null;
+		}
+		function P(e) {
+			return e.filter(N).map((e) => ({
+				class: e.class,
+				className: e.className,
+				dataAttrs: Object.fromEntries(Object.entries(e).filter(([e]) => e.startsWith("data-"))),
+				hidden: e.hidden === !0,
+				internalKey: e.key,
+				internalValue: e.value,
+				keyStyle: e.keyStyle,
+				span: e.span,
+				style: e.style
+			}));
+		}
+		function F(e, t, n) {
+			let r = e.props;
+			if (r) return Object.prototype.hasOwnProperty.call(r, t) ? r[t] : r[n];
+		}
+		function I(e, t, n) {
+			let r = e.props;
+			return !!(r && (Object.prototype.hasOwnProperty.call(r, t) || Object.prototype.hasOwnProperty.call(r, n)));
+		}
+		function L(e, t = []) {
+			if (Array.isArray(e)) {
+				for (let n of e) L(n, t);
+				return t;
+			}
+			return !h(e) || e.type === n || e.type === i || (e.type === r ? L(e.children, t) : e.type === z && t.push(e)), t;
+		}
+		function R(e, t) {
+			let n = e.children;
+			if (!n || typeof n != "object" || Array.isArray(n)) return;
+			let r = n[t];
+			return typeof r == "function" ? r : void 0;
+		}
+		function B(e) {
+			let t = F(e, "span", "span"), n = F(e, "hidden", "hidden");
+			return {
+				class: F(e, "class", "class"),
+				className: F(e, "className", "class-name"),
+				hidden: I(e, "hidden", "hidden") ? n !== !1 : !1,
+				internalKey: R(e, "key") ?? F(e, "itemKey", "item-key"),
+				internalValue: R(e, "default"),
+				keyStyle: F(e, "keyStyle", "key-style"),
+				span: t === void 0 ? void 0 : Number(t),
+				style: F(e, "style", "style"),
+				dataAttrs: Object.fromEntries(Object.entries(e.props ?? {}).filter(([e]) => e.startsWith("data-")))
+			};
+		}
+		let V = a(() => L(d.default?.() ?? []).map(B)), H = a(() => A.value.length > 0 ? P(A.value) : V.value), U = a(() => ({
+			children: d.default,
+			column: M.value,
+			data: A.value
+		})), W = g(new E({
+			getProps: () => U.value,
+			getColumns: () => H.value.map((e) => ({ ...e }))
+		})), G = a(() => W.getHorizontalList()), K = a(() => [
+			"semi-descriptions",
+			D.value ? void 0 : `semi-descriptions-${C.value}`,
+			D.value ? "semi-descriptions-double" : void 0,
+			D.value ? `semi-descriptions-double-${k.value}` : void 0,
+			`semi-descriptions-${j.value}`,
+			u.class,
+			s.class,
+			s.className
+		]), q = a(() => [s.style, u.style]), J = a(() => Object.fromEntries(Object.entries(u).filter(([e]) => e.startsWith("data-"))));
+		function Y(e) {
+			return {
+				...e.dataAttrs,
+				class: e.class,
+				className: e.className,
+				hidden: e.hidden,
+				internalKey: e.internalKey,
+				internalValue: e.internalValue,
+				keyStyle: e.keyStyle,
+				span: e.span,
+				style: e.style
+			};
+		}
+		return (e, t) => (y(), c("div", _({
+			class: K.value,
+			style: q.value
+		}, J.value), [l("table", null, [l("tbody", null, [j.value === "horizontal" ? (y(!0), c(r, { key: 0 }, x(G.value, (e, t) => (y(), c("tr", { key: t }, [(y(!0), c(r, null, x(e, (e, n) => (y(), o(z, _({ key: `${t}-${n}` }, { ref_for: !0 }, Y(e)), null, 16))), 128))]))), 128)) : A.value.length > 0 ? (y(!0), c(r, { key: 1 }, x(H.value, (e, t) => (y(), o(z, _({ key: t }, { ref_for: !0 }, Y(e)), null, 16))), 128)) : S(e.$slots, "default", {}, void 0, void 0, 2)])])], 16));
+	}
+}), V = [
+	"center",
+	"justify",
+	"left",
+	"plain"
+], H = [
+	"small",
+	"medium",
+	"large"
+], U = ["horizontal", "vertical"], W = z, G = Object.assign(B, { Item: W });
+//#endregion
+export { H as a, U as i, W as n, V as r, G as t };

package/dist/divider/Divider.vue.d.ts

@@ -0,0 +1,15 @@
+import { DividerProps, DividerSlots } from './types';
+type __VLS_Slots = DividerSlots;
+declare const __VLS_base: import('vue').DefineComponent<DividerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<DividerProps> & Readonly<{}>, {
+    dashed: boolean;
+    layout: import('./types').DividerLayout;
+    align: import('./types').DividerAlign;
+}, {}, {}, {}, 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/divider/DividerContentRenderer.d.ts

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

package/dist/divider/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Divider } from './Divider.vue';
+export { DIVIDER_ALIGNS, DIVIDER_LAYOUTS } from './types';
+export type { DividerAlign, DividerLayout, DividerProps, DividerSlots } from './types';

package/dist/divider/index.js

@@ -0,0 +1,3 @@
+import { t as e } from "../Divider-BQmwhGfH.js";
+import { n as t, t as n } from "../divider-DA9U4uOl.js";
+export { n as DIVIDER_ALIGNS, t as DIVIDER_LAYOUTS, e as Divider };

package/dist/divider/types.d.ts

@@ -0,0 +1,13 @@
+export declare const DIVIDER_ALIGNS: readonly ["left", "right", "center"];
+export declare const DIVIDER_LAYOUTS: readonly ["horizontal", "vertical"];
+export type DividerAlign = (typeof DIVIDER_ALIGNS)[number];
+export type DividerLayout = (typeof DIVIDER_LAYOUTS)[number];
+export interface DividerProps {
+    align?: DividerAlign;
+    dashed?: boolean;
+    layout?: DividerLayout;
+    margin?: number | string;
+}
+export interface DividerSlots {
+    default?: () => unknown;
+}

package/dist/divider-DA9U4uOl.js

@@ -0,0 +1,8 @@
+//#region src/divider/types.ts
+var e = [
+	"left",
+	"right",
+	"center"
+], t = ["horizontal", "vertical"];
+//#endregion
+export { t as n, e as t };

package/dist/dropdown/Dropdown.vue.d.ts

@@ -0,0 +1,23 @@
+import { DropdownExposed, DropdownProps, DropdownSlots } from './types';
+type __VLS_Slots = DropdownSlots;
+declare const __VLS_base: import('vue').DefineComponent<DropdownProps, DropdownExposed, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    afterClose: () => any;
+    clickOutside: (event: MouseEvent) => any;
+    escKeydown: (event: KeyboardEvent) => any;
+    visibleChange: (visible: boolean) => any;
+    "update:visible": (visible: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<DropdownProps> & Readonly<{
+    onAfterClose?: () => any;
+    onClickOutside?: (event: MouseEvent) => any;
+    onEscKeydown?: (event: KeyboardEvent) => any;
+    onVisibleChange?: (visible: boolean) => any;
+    "onUpdate:visible"?: (visible: boolean) => 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/dropdown/DropdownDivider.vue.d.ts

@@ -0,0 +1,4 @@
+import { DropdownDividerProps } from './types';
+declare const __VLS_export: import('vue').DefineComponent<DropdownDividerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<DropdownDividerProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/dropdown/DropdownItem.vue.d.ts

@@ -0,0 +1,28 @@
+import { DropdownItemProps, DropdownItemSlots } from './types';
+type __VLS_Slots = DropdownItemSlots;
+declare const __VLS_base: import('vue').DefineComponent<DropdownItemProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+    keydown: (event: KeyboardEvent) => any;
+    contextmenu: (event: MouseEvent) => any;
+    mouseenter: (event: MouseEvent) => any;
+    mouseleave: (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<DropdownItemProps> & Readonly<{
+    onClick?: (event: MouseEvent) => any;
+    onKeydown?: (event: KeyboardEvent) => any;
+    onContextmenu?: (event: MouseEvent) => any;
+    onMouseenter?: (event: MouseEvent) => any;
+    onMouseleave?: (event: MouseEvent) => any;
+}>, {
+    disabled: boolean;
+    active: boolean;
+    hover: boolean;
+    showTick: boolean;
+}, {}, {}, {}, 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;
+    };
+};