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

package/dist/collapse/CollapsePanel.vue.d.ts

@@ -0,0 +1,99 @@
+import { PropType } from 'vue';
+import { CollapsePanelProps, CollapsePanelSlots } from './types';
+type __VLS_Slots = CollapsePanelSlots;
+declare const __VLS_base: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    itemKey: {
+        type: StringConstructor;
+        required: true;
+    };
+    extra: {
+        type: PropType<CollapsePanelProps["extra"]>;
+        default: undefined;
+    };
+    header: {
+        type: PropType<CollapsePanelProps["header"]>;
+        default: undefined;
+    };
+    class: {
+        type: PropType<CollapsePanelProps["class"]>;
+        default: undefined;
+    };
+    className: {
+        type: PropType<CollapsePanelProps["className"]>;
+        default: undefined;
+    };
+    reCalcKey: {
+        type: PropType<number | string>;
+        default: undefined;
+    };
+    style: {
+        type: PropType<CollapsePanelProps["style"]>;
+        default: undefined;
+    };
+    showArrow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    motionEnd: () => any;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    itemKey: {
+        type: StringConstructor;
+        required: true;
+    };
+    extra: {
+        type: PropType<CollapsePanelProps["extra"]>;
+        default: undefined;
+    };
+    header: {
+        type: PropType<CollapsePanelProps["header"]>;
+        default: undefined;
+    };
+    class: {
+        type: PropType<CollapsePanelProps["class"]>;
+        default: undefined;
+    };
+    className: {
+        type: PropType<CollapsePanelProps["className"]>;
+        default: undefined;
+    };
+    reCalcKey: {
+        type: PropType<number | string>;
+        default: undefined;
+    };
+    style: {
+        type: PropType<CollapsePanelProps["style"]>;
+        default: undefined;
+    };
+    showArrow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onMotionEnd?: () => any;
+}>, {
+    className: import('vue').ClassValue;
+    style: import('vue').StyleValue;
+    disabled: boolean;
+    class: import('vue').ClassValue;
+    header: import('vue').VNodeChild;
+    showArrow: boolean;
+    extra: import('vue').VNodeChild;
+    reCalcKey: string | number;
+}, {}, {}, {}, 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/collapse/collapse-context.d.ts

@@ -0,0 +1,14 @@
+import { ComputedRef, InjectionKey, VNodeChild } from 'vue';
+import { CollapseIconPosition } from './types';
+export interface CollapseContextValue {
+    activeSet: ComputedRef<ReadonlySet<string>>;
+    clickHeaderToExpand: ComputedRef<boolean>;
+    collapseIcon: () => VNodeChild;
+    expandIcon: () => VNodeChild;
+    expandIconPosition: ComputedRef<CollapseIconPosition>;
+    keepDOM: ComputedRef<boolean>;
+    lazyRender: ComputedRef<boolean>;
+    motion: ComputedRef<boolean>;
+    onClick: (itemKey: string, event: MouseEvent) => void;
+}
+export declare const collapseContextKey: InjectionKey<CollapseContextValue>;

package/dist/collapse/index.d.ts

@@ -0,0 +1,10 @@
+import { DefineComponent } from 'vue';
+import { CollapsePanelProps, CollapseProps } from './types';
+export type CollapseCompoundComponent = DefineComponent<CollapseProps> & {
+    Panel: DefineComponent<CollapsePanelProps>;
+};
+export declare const CollapsePanel: DefineComponent<CollapsePanelProps>;
+export declare const Collapse: CollapseCompoundComponent;
+export { COLLAPSE_ICON_POSITIONS } from './types';
+export type { CollapseActiveKey, CollapseEmits, CollapseIconPosition, CollapsePanelEmits, CollapsePanelProps, CollapsePanelSlots, CollapseProps, CollapseSlots, CollapseState, } from './types';
+export default Collapse;

package/dist/collapse/index.js

@@ -0,0 +1,2 @@
+import { n as e, r as t, t as n } from "../collapse-7YtQLWqt.js";
+export { t as COLLAPSE_ICON_POSITIONS, n as Collapse, n as default, e as CollapsePanel };

package/dist/collapse/types.d.ts

@@ -0,0 +1,50 @@
+import { HTMLAttributes, StyleValue, VNodeChild } from 'vue';
+export declare const COLLAPSE_ICON_POSITIONS: readonly ["left", "right"];
+export type CollapseIconPosition = (typeof COLLAPSE_ICON_POSITIONS)[number];
+export type CollapseActiveKey = string | string[];
+export interface CollapseProps {
+    activeKey?: CollapseActiveKey;
+    defaultActiveKey?: CollapseActiveKey;
+    accordion?: boolean;
+    clickHeaderToExpand?: boolean;
+    expandIcon?: VNodeChild;
+    collapseIcon?: VNodeChild;
+    expandIconPosition?: CollapseIconPosition;
+    keepDOM?: boolean;
+    motion?: boolean;
+    lazyRender?: boolean;
+    class?: HTMLAttributes['class'];
+    className?: HTMLAttributes['class'];
+    style?: StyleValue;
+}
+export interface CollapseEmits {
+    change: [activeKey: CollapseActiveKey, event: MouseEvent];
+    'update:activeKey': [activeKey: CollapseActiveKey];
+}
+export interface CollapseSlots {
+    default?: () => VNodeChild;
+    expandIcon?: () => VNodeChild;
+    collapseIcon?: () => VNodeChild;
+}
+export interface CollapseState {
+    activeSet: Set<string>;
+}
+export interface CollapsePanelProps {
+    itemKey: string;
+    extra?: VNodeChild;
+    header?: VNodeChild;
+    class?: HTMLAttributes['class'];
+    className?: HTMLAttributes['class'];
+    reCalcKey?: number | string;
+    style?: StyleValue;
+    showArrow?: boolean;
+    disabled?: boolean;
+}
+export interface CollapsePanelEmits {
+    motionEnd: [];
+}
+export interface CollapsePanelSlots {
+    default?: () => VNodeChild;
+    extra?: () => VNodeChild;
+    header?: () => VNodeChild;
+}

package/dist/collapse-7YtQLWqt.js

@@ -0,0 +1,278 @@
+import "./src-DNBBthjO.js";
+import { t as e } from "./foundation-Cawx37mp.js";
+import { t } from "./uuid-BUHV1G8U.js";
+import { n } from "./config-provider-VMfNNSF1.js";
+import { Collapsible as r } from "./collapsible/index.js";
+import { Fragment as i, computed as a, createBlock as o, createCommentVNode as s, createElementBlock as c, createElementVNode as l, createVNode as u, defineComponent as d, getCurrentInstance as f, h as p, inject as m, markRaw as h, mergeProps as g, normalizeClass as _, onBeforeUnmount as v, onMounted as y, openBlock as b, provide as x, renderSlot as S, shallowRef as C, toDisplayString as w, unref as T, useAttrs as E, useSlots as D, useTemplateRef as O, watch as k, withCtx as A } from "vue";
+import { IconChevronDown as j, IconChevronUp as M } from "@aifuxi/semi-icons-vue";
+//#region bundled-foundation
+var N = class extends e {
+	constructor(e) {
+		super({ ...e });
+	}
+	initActiveKey() {
+		let { defaultActiveKey: e, activeKey: t, accordion: n } = this.getProps(), r = t || e;
+		return n && (r = Array.isArray(r) ? r[0] : r), r && r.length ? (r = Array.isArray(r) ? r : [r], r) : [];
+	}
+	handleChange(e, t) {
+		let { activeKey: n, accordion: r } = this.getProps(), { activeSet: i } = this.getStates(), a = new Set(i);
+		a.has(e) ? a.delete(e) : r ? a = /* @__PURE__ */ new Set([e]) : a.add(e), this._adapter.handleChange([...a.values()], t), n === void 0 && this._adapter.addActiveKey(a);
+	}
+}, P = Symbol("semi-collapse-context"), F = /* @__PURE__ */ d({
+	name: "Collapse",
+	inheritAttrs: !1,
+	__name: "Collapse",
+	props: {
+		activeKey: {
+			type: [String, Array],
+			default: void 0
+		},
+		defaultActiveKey: {
+			type: [String, Array],
+			default: void 0
+		},
+		accordion: {
+			type: Boolean,
+			default: void 0
+		},
+		clickHeaderToExpand: {
+			type: Boolean,
+			default: void 0
+		},
+		expandIcon: {
+			type: null,
+			default: void 0
+		},
+		collapseIcon: {
+			type: null,
+			default: void 0
+		},
+		expandIconPosition: {
+			type: String,
+			default: void 0,
+			validator: (e) => e === "left" || e === "right"
+		},
+		keepDOM: {
+			type: Boolean,
+			default: void 0
+		},
+		motion: {
+			type: Boolean,
+			default: void 0
+		},
+		lazyRender: {
+			type: Boolean,
+			default: void 0
+		},
+		class: {
+			type: null,
+			default: void 0
+		},
+		className: {
+			type: null,
+			default: void 0
+		},
+		style: {
+			type: null,
+			default: void 0
+		}
+	},
+	emits: ["change", "update:activeKey"],
+	setup(e, { emit: t }) {
+		let r = e, i = t, o = E(), s = D(), l = f();
+		function u(e) {
+			let t = l?.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 d(e, t) {
+			if (u(e) && r[e] !== void 0) return r[e];
+			let i = n.config.overrideDefaultProps?.Collapse?.[e];
+			return i === void 0 ? t : i;
+		}
+		function p(e) {
+			return u(e) ? r[e] : n.config.overrideDefaultProps?.Collapse?.[e];
+		}
+		let m = a(() => p("activeKey")), _ = a(() => d("defaultActiveKey", "")), y = a(() => d("accordion", !1)), w = a(() => d("clickHeaderToExpand", !0)), T = a(() => d("expandIconPosition", "right")), O = a(() => d("keepDOM", !1)), A = a(() => d("motion", !0)), j = a(() => d("lazyRender", !1)), M = a(() => ({
+			accordion: y.value,
+			activeKey: m.value,
+			defaultActiveKey: _.value
+		})), F = C(/* @__PURE__ */ new Set()), I = h(new N({
+			getProps: () => M.value,
+			getStates: () => ({ activeSet: F.value }),
+			handleChange: (e, t) => {
+				i("change", e, t), i("update:activeKey", e);
+			},
+			addActiveKey: (e) => {
+				F.value = e;
+			}
+		}));
+		F.value = new Set(I.initActiveKey());
+		function L(e, t) {
+			if (e.size !== t.size) return !1;
+			for (let n of e) if (!t.has(n)) return !1;
+			return !0;
+		}
+		k(m, (e) => {
+			if (!e) return;
+			let t = new Set(Array.isArray(e) ? e : [e]);
+			L(F.value, t) || (F.value = t);
+		}), x(P, {
+			activeSet: a(() => F.value),
+			clickHeaderToExpand: w,
+			collapseIcon: () => s.collapseIcon?.() ?? p("collapseIcon"),
+			expandIcon: () => s.expandIcon?.() ?? p("expandIcon"),
+			expandIconPosition: T,
+			keepDOM: O,
+			lazyRender: j,
+			motion: A,
+			onClick: (e, t) => I.handleChange(e, t)
+		});
+		let R = a(() => [
+			"semi-collapse",
+			o.class,
+			r.class,
+			r.className
+		]), z = a(() => [r.style, o.style]), B = a(() => Object.fromEntries(Object.entries(o).filter(([e]) => e.startsWith("data-"))));
+		return v(() => I.destroy()), (e, t) => (b(), c("div", g(B.value, {
+			class: R.value,
+			style: z.value
+		}), [S(e.$slots, "default")], 16));
+	}
+}), I = d({
+	name: "CollapseNodeRenderer",
+	props: { content: {
+		type: null,
+		default: void 0
+	} },
+	setup(e) {
+		return () => e.content;
+	}
+}), L = [
+	"aria-disabled",
+	"aria-expanded",
+	"aria-owns"
+], R = { class: "semi-collapse-header-right" }, z = ["id", "aria-hidden"], B = { class: "semi-collapse-content-wrapper" }, V = /* @__PURE__ */ d({
+	name: "CollapsePanel",
+	inheritAttrs: !1,
+	__name: "CollapsePanel",
+	props: {
+		itemKey: {
+			type: String,
+			required: !0
+		},
+		extra: {
+			type: null,
+			default: void 0
+		},
+		header: {
+			type: null,
+			default: void 0
+		},
+		class: {
+			type: null,
+			default: void 0
+		},
+		className: {
+			type: null,
+			default: void 0
+		},
+		reCalcKey: {
+			type: [Number, String],
+			default: void 0
+		},
+		style: {
+			type: null,
+			default: void 0
+		},
+		showArrow: {
+			type: Boolean,
+			default: !0
+		},
+		disabled: {
+			type: Boolean,
+			default: !1
+		}
+	},
+	emits: ["motionEnd"],
+	setup(e, { emit: n }) {
+		let d = e, f = n, h = E(), v = D(), x = m(P);
+		if (!x) throw Error("CollapsePanel 必须作为 Collapse 的后代使用");
+		let C = x, k = O("header-icon"), N = a(() => C.activeSet.value.has(d.itemKey)), F = a(() => !!v.default), V = a(() => F.value && !d.disabled), H = a(() => !v.header && typeof d.header == "string"), U = a(() => [
+			"semi-collapse-item",
+			N.value ? "semi-collapse-item-active" : void 0,
+			h.class,
+			d.class,
+			d.className
+		]), W = a(() => [d.style, h.style]), G = a(() => [
+			"semi-collapse-header",
+			d.disabled ? "semi-collapse-header-disabled" : void 0,
+			C.expandIconPosition.value === "left" ? "semi-collapse-header-iconLeft" : void 0
+		]), K = a(() => ["semi-collapse-header-icon", V.value ? void 0 : "semi-collapse-header-iconDisabled"]), q = a(() => {
+			let e = C.expandIcon(), t = C.collapseIcon();
+			return !V.value || !N.value ? e ?? p(j) : t ?? p(M);
+		}), J = a(() => Object.fromEntries(Object.entries(h).filter(([e]) => e !== "class" && e !== "style"))), Y = a(() => ({
+			isOpen: N.value,
+			keepDOM: C.keepDOM.value,
+			lazyRender: C.lazyRender.value,
+			motion: C.motion.value,
+			...d.reCalcKey === void 0 ? {} : { reCalcKey: d.reCalcKey }
+		})), X = "";
+		y(() => {
+			X = t({});
+		});
+		function Z(e) {
+			if (d.disabled) return;
+			let t = e.target;
+			(C.clickHeaderToExpand.value || t instanceof Node && k.value?.contains(t)) && C.onClick(d.itemKey, e);
+		}
+		return (e, t) => (b(), c("div", g(J.value, {
+			class: U.value,
+			style: W.value
+		}), [l("div", {
+			role: "button",
+			tabindex: "0",
+			class: _(G.value),
+			"aria-disabled": d.disabled,
+			"aria-expanded": N.value,
+			"aria-owns": T(X),
+			onClick: Z
+		}, [H.value ? (b(), c(i, { key: 0 }, [
+			d.showArrow && T(C).expandIconPosition.value === "left" ? (b(), c("span", {
+				key: 0,
+				ref: "header-icon",
+				"aria-hidden": "true",
+				class: _(K.value)
+			}, [u(T(I), { content: q.value }, null, 8, ["content"])], 2)) : s("", !0),
+			l("span", null, w(d.header), 1),
+			l("span", R, [l("span", null, [S(e.$slots, "extra", {}, () => [u(T(I), { content: d.extra }, null, 8, ["content"])])]), d.showArrow && T(C).expandIconPosition.value !== "left" ? (b(), c("span", {
+				key: 0,
+				ref: "header-icon",
+				"aria-hidden": "true",
+				class: _(K.value)
+			}, [u(T(I), { content: q.value }, null, 8, ["content"])], 2)) : s("", !0)])
+		], 64)) : (b(), c(i, { key: 1 }, [
+			d.showArrow && T(C).expandIconPosition.value === "left" ? (b(), c("span", {
+				key: 0,
+				ref: "header-icon",
+				"aria-hidden": "true",
+				class: _(K.value)
+			}, [u(T(I), { content: q.value }, null, 8, ["content"])], 2)) : s("", !0),
+			S(e.$slots, "header", {}, () => [u(T(I), { content: d.header }, null, 8, ["content"])]),
+			d.showArrow && T(C).expandIconPosition.value !== "left" ? (b(), c("span", {
+				key: 1,
+				ref: "header-icon",
+				"aria-hidden": "true",
+				class: _(K.value)
+			}, [u(T(I), { content: q.value }, null, 8, ["content"])], 2)) : s("", !0)
+		], 64))], 10, L), F.value ? (b(), o(T(r), g({ key: 0 }, Y.value, { onMotionEnd: t[0] ||= (e) => f("motionEnd") }), {
+			default: A(() => [l("div", {
+				id: T(X),
+				class: "semi-collapse-content",
+				"aria-hidden": !N.value
+			}, [l("div", B, [S(e.$slots, "default")])], 8, z)]),
+			_: 3
+		}, 16)) : s("", !0)], 16));
+	}
+}), H = ["left", "right"], U = V, W = Object.assign(F, { Panel: U });
+//#endregion
+export { U as n, H as r, W as t };

package/dist/collapsible/Collapsible.vue.d.ts

@@ -0,0 +1,136 @@
+import { PropType } from 'vue';
+import { CollapsibleProps, CollapsibleSlots } from './types';
+type __VLS_Slots = CollapsibleSlots;
+declare const __VLS_base: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    class: {
+        type: PropType<CollapsibleProps["class"]>;
+        default: undefined;
+    };
+    className: {
+        type: PropType<CollapsibleProps["className"]>;
+        default: undefined;
+    };
+    collapseHeight: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    collapseHeightAdaptive: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    duration: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    fade: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    isOpen: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    keepDOM: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    lazyRender: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    motion: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    reCalcKey: {
+        type: PropType<number | string>;
+        default: undefined;
+    };
+    style: {
+        type: PropType<CollapsibleProps["style"]>;
+        default: undefined;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    motionEnd: () => any;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    class: {
+        type: PropType<CollapsibleProps["class"]>;
+        default: undefined;
+    };
+    className: {
+        type: PropType<CollapsibleProps["className"]>;
+        default: undefined;
+    };
+    collapseHeight: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    collapseHeightAdaptive: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    duration: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    fade: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    isOpen: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    keepDOM: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    lazyRender: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    motion: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    reCalcKey: {
+        type: PropType<number | string>;
+        default: undefined;
+    };
+    style: {
+        type: PropType<CollapsibleProps["style"]>;
+        default: undefined;
+    };
+}>> & Readonly<{
+    onMotionEnd?: () => any;
+}>, {
+    className: import('vue').ClassValue;
+    style: import('vue').StyleValue;
+    class: import('vue').ClassValue;
+    duration: number;
+    id: string;
+    motion: boolean;
+    keepDOM: boolean;
+    isOpen: boolean;
+    lazyRender: boolean;
+    fade: boolean;
+    collapseHeight: number;
+    collapseHeightAdaptive: boolean;
+    reCalcKey: string | number;
+}, {}, {}, {}, 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/collapsible/index.d.ts

@@ -0,0 +1,5 @@
+import { DefineComponent } from 'vue';
+import { CollapsibleProps } from './types';
+export declare const Collapsible: DefineComponent<CollapsibleProps>;
+export type { CollapsibleEmits, CollapsibleProps, CollapsibleSlots, CollapsibleState, } from './types';
+export default Collapsible;

package/dist/collapsible/index.js

@@ -0,0 +1,5 @@
+import { t as e } from "../Collapsible-DeV0aJ4n.js";
+//#region src/collapsible/index.ts
+var t = e;
+//#endregion
+export { t as Collapsible, t as default };

package/dist/collapsible/types.d.ts

@@ -0,0 +1,28 @@
+import { HTMLAttributes, StyleValue, VNodeChild } from 'vue';
+export interface CollapsibleProps {
+    class?: HTMLAttributes['class'];
+    className?: HTMLAttributes['class'];
+    collapseHeight?: number;
+    collapseHeightAdaptive?: boolean;
+    duration?: number;
+    fade?: boolean;
+    id?: string;
+    isOpen?: boolean;
+    keepDOM?: boolean;
+    lazyRender?: boolean;
+    motion?: boolean;
+    reCalcKey?: number | string;
+    style?: StyleValue;
+}
+export interface CollapsibleEmits {
+    motionEnd: [];
+}
+export interface CollapsibleSlots {
+    default?: () => VNodeChild;
+}
+export interface CollapsibleState {
+    domHeight: number;
+    domInRenderTree: boolean;
+    isTransitioning: boolean;
+    visible: boolean;
+}

package/dist/color-picker/AlphaSlider.vue.d.ts

@@ -0,0 +1,14 @@
+import { HsvaColor } from './types';
+interface Props {
+    handleSize: number;
+    height: number;
+    hsva: HsvaColor;
+    width: number;
+}
+declare const __VLS_export: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (alpha: number) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onChange?: (alpha: number) => any;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/color-picker/ColorChooseArea.vue.d.ts

@@ -0,0 +1,20 @@
+import { HsvaColor } from './types';
+interface Props {
+    handleSize: number;
+    height: number;
+    hsva: HsvaColor;
+    width: number;
+}
+declare const __VLS_export: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (value: {
+        s: number;
+        v: number;
+    }) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onChange?: (value: {
+        s: number;
+        v: number;
+    }) => any;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/color-picker/ColorDataPart.vue.d.ts

@@ -0,0 +1,15 @@
+import { ColorPickerFormat, ColorValue, HsvaColor, RgbaColor } from './types';
+interface Props {
+    alpha: boolean;
+    currentColor: ColorValue;
+    defaultFormat: ColorPickerFormat;
+    eyeDropper: boolean;
+    width: number;
+}
+declare const __VLS_export: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (color: string | HsvaColor | RgbaColor, format: ColorPickerFormat) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onChange?: (color: string | HsvaColor | RgbaColor, format: ColorPickerFormat) => any;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;