antdv-next 0.0.111 → 1.0.0-alpha.1

package/dist/color-picker/components/ColorSteppers.js

@@ -0,0 +1,63 @@
+import input_number_default from "../../input-number/index.js";
+import { computed, createVNode, defineComponent, shallowRef, watch } from "vue";
+import { clsx } from "@v-c/util";
+
+//#region src/color-picker/components/ColorSteppers.tsx
+var ColorSteppers_default = /* @__PURE__ */ defineComponent((props) => {
+	const internalValue = shallowRef(0);
+	watch(() => props.value, (val) => {
+		if (typeof val === "number") internalValue.value = val;
+	});
+	const stepValue = computed(() => !Number.isNaN(props.value) ? props.value : internalValue.value);
+	return () => {
+		const { prefixCls, className, min, max, formatter, onChange } = props;
+		return createVNode(input_number_default, {
+			"class": clsx(`${prefixCls}-steppers`, className),
+			"min": min ?? 0,
+			"max": max ?? 100,
+			"value": stepValue.value,
+			"formatter": formatter,
+			"size": "small",
+			"onChange": (step) => {
+				internalValue.value = step ?? 0;
+				onChange?.(step ?? null);
+			}
+		}, null);
+	};
+}, {
+	props: {
+		prefixCls: {
+			type: String,
+			required: true
+		},
+		value: {
+			type: Number,
+			required: false
+		},
+		min: {
+			type: Number,
+			required: false
+		},
+		max: {
+			type: Number,
+			required: false
+		},
+		onChange: {
+			type: Function,
+			required: false
+		},
+		className: {
+			type: String,
+			required: false
+		},
+		formatter: {
+			type: Function,
+			required: false
+		}
+	},
+	name: "ColorSteppers",
+	inheritAttrs: false
+});
+
+//#endregion
+export { ColorSteppers_default as default };

package/dist/color-picker/components/ColorTrigger.js

@@ -0,0 +1,92 @@
+import { getColorAlpha } from "../util.js";
+import useLocale_default from "../../locale/useLocale.js";
+import ColorClear_default from "./ColorClear.js";
+import { computed, createVNode, defineComponent, mergeProps } from "vue";
+import { clsx } from "@v-c/util";
+import { ColorBlock } from "@v-c/color-picker";
+
+//#region src/color-picker/components/ColorTrigger.tsx
+var ColorTrigger_default = /* @__PURE__ */ defineComponent((props, { attrs }) => {
+	const [locale] = useLocale_default("ColorPicker");
+	const colorTriggerPrefixCls = computed(() => `${props.prefixCls}-trigger`);
+	const colorTextPrefixCls = computed(() => `${colorTriggerPrefixCls.value}-text`);
+	const colorTextCellPrefixCls = computed(() => `${colorTextPrefixCls.value}-cell`);
+	const desc = computed(() => {
+		const { color, showText, format, activeIndex } = props;
+		if (!showText) return "";
+		if (typeof showText === "function") return showText(color);
+		if (color.cleared) return locale?.value?.transparent;
+		if (color.isGradient()) return color.getColors().map((c, index) => {
+			const inactive = activeIndex !== -1 && activeIndex !== index;
+			return createVNode("span", {
+				"key": index,
+				"class": clsx(colorTextCellPrefixCls.value, inactive && `${colorTextCellPrefixCls.value}-inactive`)
+			}, [`${c.color.toRgbString()} ${c.percent}%`]);
+		});
+		const hexString = color.toHexString().toUpperCase();
+		const alpha = getColorAlpha(color);
+		switch (format) {
+			case "rgb": return color.toRgbString();
+			case "hsb": return color.toHsbString();
+			default: return alpha < 100 ? `${hexString.slice(0, 7)},${alpha}%` : hexString;
+		}
+	});
+	const containerNode = computed(() => {
+		const { color, prefixCls } = props;
+		return color?.cleared ? createVNode(ColorClear_default, { "prefixCls": prefixCls }, null) : createVNode(ColorBlock, {
+			"prefixCls": prefixCls,
+			"color": color.toCssString()
+		}, null);
+	});
+	return () => {
+		const { open, disabled, style, className } = props;
+		return createVNode("div", mergeProps(attrs, {
+			"class": clsx(colorTriggerPrefixCls.value, className, {
+				[`${colorTriggerPrefixCls.value}-active`]: open,
+				[`${colorTriggerPrefixCls.value}-disabled`]: disabled
+			}),
+			"style": style
+		}), [containerNode.value, props.showText && createVNode("div", { "class": colorTextPrefixCls.value }, [desc.value])]);
+	};
+}, {
+	props: {
+		prefixCls: {
+			type: String,
+			required: true
+		},
+		disabled: {
+			type: Boolean,
+			required: false
+		},
+		format: { required: false },
+		color: {
+			type: Object,
+			required: true
+		},
+		open: {
+			type: Boolean,
+			required: false
+		},
+		showText: {
+			type: [Boolean, Function],
+			required: false
+		},
+		className: {
+			type: String,
+			required: false
+		},
+		style: {
+			type: Object,
+			required: false
+		},
+		activeIndex: {
+			type: Number,
+			required: true
+		}
+	},
+	name: "AColorTrigger",
+	inheritAttrs: false
+});
+
+//#endregion
+export { ColorTrigger_default as default };

package/dist/color-picker/components/PanelPicker/GradientColorBar.js

@@ -0,0 +1,163 @@
+import { AggregationColor } from "../../color.js";
+import { getGradientPercentColor } from "../../util.js";
+import { GradientColorSlider } from "../ColorSlider.js";
+import { computed, createVNode, defineComponent, shallowRef, watch } from "vue";
+
+//#region src/color-picker/components/PanelPicker/GradientColorBar.tsx
+function sortColors(colors) {
+	return [...colors].sort((a, b) => a.percent - b.percent);
+}
+/**
+* GradientColorBar will auto show when the mode is `gradient`.
+*/
+var GradientColorBar_default = /* @__PURE__ */ defineComponent((props) => {
+	const isGradient = computed(() => props.mode === "gradient");
+	const colorList = computed(() => props.colors.map((info) => ({
+		percent: info.percent,
+		color: info.color.toRgbString()
+	})));
+	const values = computed(() => colorList.value.map((info) => info.percent));
+	const colorsRef = shallowRef(colorList.value);
+	watch(colorList, (val) => {
+		colorsRef.value = val;
+	}, { deep: true });
+	const onDragStart = ({ rawValues, draggingIndex, draggingValue }) => {
+		if (rawValues.length > colorList.value.length) {
+			const newPointColor = getGradientPercentColor(colorList.value, draggingValue);
+			const nextColors = [...colorList.value];
+			nextColors.splice(draggingIndex, 0, {
+				percent: draggingValue,
+				color: newPointColor
+			});
+			colorsRef.value = nextColors;
+		} else colorsRef.value = colorList.value;
+		props.onGradientDragging(true);
+		props.onChange?.(new AggregationColor(sortColors(colorsRef.value)), true);
+	};
+	const onDragChange = ({ deleteIndex, draggingIndex, draggingValue }) => {
+		let nextColors = [...colorsRef.value];
+		if (deleteIndex !== -1) nextColors.splice(deleteIndex, 1);
+		else {
+			nextColors[draggingIndex] = {
+				...nextColors[draggingIndex],
+				percent: draggingValue
+			};
+			nextColors = sortColors(nextColors);
+		}
+		props.onChange?.(new AggregationColor(nextColors), true);
+	};
+	const onKeyDelete = (index) => {
+		const nextColors = [...colorList.value];
+		nextColors.splice(index, 1);
+		const nextColor = new AggregationColor(nextColors);
+		props.onChange?.(nextColor);
+		props.onChangeComplete?.(nextColor);
+	};
+	const onInternalChangeComplete = (nextValues) => {
+		props.onChangeComplete?.(new AggregationColor(colorList.value));
+		if (props.activeIndex >= nextValues.length) props.onActive(nextValues.length - 1);
+		props.onGradientDragging(false);
+	};
+	return () => {
+		if (!isGradient.value) return null;
+		return createVNode(GradientColorSlider, {
+			"min": 0,
+			"max": 100,
+			"prefixCls": props.prefixCls,
+			"className": `${props.prefixCls}-gradient-slider`,
+			"colors": colorList.value,
+			"color": null,
+			"value": values.value,
+			"range": true,
+			"onChangeComplete": onInternalChangeComplete,
+			"disabled": false,
+			"type": "gradient",
+			"activeIndex": props.activeIndex,
+			"onActive": props.onActive,
+			"onDragStart": onDragStart,
+			"onDragChange": onDragChange,
+			"onKeyDelete": onKeyDelete
+		}, null);
+	};
+}, {
+	props: {
+		colors: {
+			type: Array,
+			required: true
+		},
+		prefixCls: {
+			type: String,
+			required: true
+		},
+		allowClear: {
+			type: Boolean,
+			required: false
+		},
+		disabled: {
+			type: Boolean,
+			required: false
+		},
+		disabledAlpha: {
+			type: Boolean,
+			required: false
+		},
+		mode: {
+			type: String,
+			required: true
+		},
+		onModeChange: {
+			type: Function,
+			required: true
+		},
+		modeOptions: {
+			type: Array,
+			required: true
+		},
+		value: {
+			type: Object,
+			required: true
+		},
+		onChange: {
+			type: Function,
+			required: false
+		},
+		onChangeComplete: {
+			type: Function,
+			required: false
+		},
+		format: { required: false },
+		onFormatChange: {
+			type: Function,
+			required: false
+		},
+		activeIndex: {
+			type: Number,
+			required: true
+		},
+		onActive: {
+			type: Function,
+			required: true
+		},
+		gradientDragging: {
+			type: Boolean,
+			required: true
+		},
+		onGradientDragging: {
+			type: Function,
+			required: true
+		},
+		onClear: {
+			type: Function,
+			required: false
+		},
+		disabledFormat: {
+			type: Boolean,
+			required: false
+		}
+	},
+	name: "GradientColorBar",
+	inheritAttrs: false
+});
+
+//#endregion
+export { GradientColorBar_default as default };

package/dist/color-picker/components/PanelPicker/index.js

@@ -0,0 +1,136 @@
+import { AggregationColor } from "../../color.js";
+import { genAlphaColor, generateColor } from "../../util.js";
+import segmented_default from "../../../segmented/index.js";
+import { usePanelPickerContext } from "../../context.js";
+import ColorClear_default from "../ColorClear.js";
+import ColorInput_default from "../ColorInput.js";
+import ColorSlider_default from "../ColorSlider.js";
+import GradientColorBar_default from "./GradientColorBar.js";
+import { Fragment, createVNode, defineComponent, mergeProps, shallowRef, watch } from "vue";
+import VcColorPicker from "@v-c/color-picker";
+
+//#region src/color-picker/components/PanelPicker/index.tsx
+var PanelPicker_default = /* @__PURE__ */ defineComponent(() => {
+	const panelPickerContext = usePanelPickerContext();
+	const colors = () => {
+		const ctx = panelPickerContext.value;
+		if (ctx?.value && !ctx.value.cleared) return ctx.value.getColors();
+		return [{
+			percent: 0,
+			color: new AggregationColor("")
+		}, {
+			percent: 100,
+			color: new AggregationColor("")
+		}];
+	};
+	const isSingle = () => !panelPickerContext.value?.value?.isGradient();
+	const lockedColor = shallowRef(panelPickerContext.value?.value ?? new AggregationColor(""));
+	watch(() => [
+		isSingle(),
+		panelPickerContext.value?.gradientDragging,
+		panelPickerContext.value?.activeIndex,
+		panelPickerContext.value?.value?.toHexString?.()
+	], () => {
+		if (!isSingle()) lockedColor.value = colors()[panelPickerContext.value?.activeIndex || 0]?.color;
+	}, { immediate: true });
+	const activeColor = () => {
+		const ctx = panelPickerContext.value;
+		if (isSingle()) return ctx.value;
+		if (ctx.gradientDragging) return lockedColor.value;
+		return colors()[ctx.activeIndex]?.color ?? ctx.value;
+	};
+	const pickerColor = shallowRef(activeColor());
+	const forceSync = shallowRef(0);
+	const mergedPickerColor = () => pickerColor.value?.equals(activeColor()) ? activeColor() : pickerColor.value;
+	watch(() => [activeColor()?.toHexString?.(), forceSync.value], () => {
+		pickerColor.value = activeColor();
+	}, { immediate: true });
+	const fillColor = (nextColor, info) => {
+		const ctx = panelPickerContext.value;
+		let submitColor = generateColor(nextColor);
+		if (ctx.value?.cleared) {
+			const rgb = submitColor.toRgb();
+			if (!rgb.r && !rgb.g && !rgb.b && info) {
+				const { type: infoType, value: infoValue = 0 } = info;
+				submitColor = new AggregationColor({
+					h: infoType === "hue" ? infoValue : 0,
+					s: 1,
+					b: 1,
+					a: infoType === "alpha" ? infoValue / 100 : 1
+				});
+			} else submitColor = genAlphaColor(submitColor);
+		}
+		if (ctx.mode === "single") return submitColor;
+		const nextColors = [...colors()];
+		const activeIndex = ctx.activeIndex || 0;
+		nextColors[activeIndex] = {
+			...nextColors[activeIndex],
+			color: submitColor
+		};
+		return new AggregationColor(nextColors);
+	};
+	const onPickerChange = (colorValue, info) => {
+		const nextColor = fillColor(generateColor(colorValue), info);
+		const activeIndex = panelPickerContext.value?.activeIndex || 0;
+		pickerColor.value = nextColor.isGradient() ? nextColor.getColors()[activeIndex].color : nextColor;
+		panelPickerContext.value?.onChange?.(nextColor, true);
+	};
+	const onInternalChangeComplete = (nextColor, info) => {
+		panelPickerContext.value?.onChangeComplete?.(fillColor(nextColor, info));
+		forceSync.value += 1;
+	};
+	const onInputChange = (colorValue) => {
+		panelPickerContext.value?.onChange?.(fillColor(colorValue));
+	};
+	return () => {
+		const { prefixCls, allowClear, disabledAlpha, mode, onModeChange, modeOptions, disabled, onClear, format, onFormatChange, disabledFormat } = panelPickerContext.value;
+		const showMode = (modeOptions?.length || 0) > 1;
+		const operationNode = allowClear || showMode ? createVNode("div", { "class": `${prefixCls}-operation` }, [showMode && createVNode(segmented_default, {
+			"size": "small",
+			"options": modeOptions,
+			"value": mode,
+			"onChange": (val) => onModeChange(val)
+		}, null), createVNode(ColorClear_default, {
+			"prefixCls": prefixCls,
+			"value": panelPickerContext.value?.value,
+			"disabled": disabled,
+			"onChange": (clearColor) => {
+				panelPickerContext.value?.onChange?.(clearColor);
+				onClear?.();
+			}
+		}, null)]) : null;
+		const active = activeColor();
+		return createVNode(Fragment, null, [
+			operationNode,
+			createVNode(GradientColorBar_default, mergeProps(panelPickerContext.value, { "colors": colors() }), null),
+			createVNode(VcColorPicker, {
+				"prefixCls": prefixCls,
+				"value": mergedPickerColor()?.toHsb(),
+				"disabledAlpha": disabledAlpha,
+				"disabled": disabled,
+				"onChange": (colorValue, info) => {
+					onPickerChange(colorValue, info);
+				},
+				"onChangeComplete": (colorValue, info) => {
+					onInternalChangeComplete(colorValue, info);
+				},
+				"components": { slider: ColorSlider_default }
+			}, null),
+			createVNode(ColorInput_default, {
+				"value": active,
+				"onChange": onInputChange,
+				"prefixCls": prefixCls,
+				"disabledAlpha": disabledAlpha,
+				"format": format,
+				"onFormatChange": onFormatChange,
+				"disabledFormat": disabledFormat
+			}, null)
+		]);
+	};
+}, {
+	name: "ColorPanelPicker",
+	inheritAttrs: false
+});
+
+//#endregion
+export { PanelPicker_default as default };

package/dist/color-picker/components/PanelPresets.js

@@ -0,0 +1,23 @@
+import ColorPresets_default from "./ColorPresets.js";
+import { usePanelPresetsContext } from "../context.js";
+import { createVNode, defineComponent } from "vue";
+
+//#region src/color-picker/components/PanelPresets.tsx
+var PanelPresets_default = /* @__PURE__ */ defineComponent(() => {
+	const presetsContext = usePanelPresetsContext();
+	return () => {
+		const { prefixCls, value, presets, onChange } = presetsContext.value;
+		return Array.isArray(presets) ? createVNode(ColorPresets_default, {
+			"value": value,
+			"presets": presets,
+			"prefixCls": prefixCls,
+			"onChange": onChange
+		}, null) : null;
+	};
+}, {
+	name: "ColorPanelPresets",
+	inheritAttrs: false
+});
+
+//#endregion
+export { PanelPresets_default as default };

package/dist/color-picker/context.js

@@ -0,0 +1,20 @@
+import { computed, defineComponent, inject, provide, shallowRef } from "vue";
+
+//#region src/color-picker/context.tsx
+const PanelPickerContextKey = Symbol("PanelPickerContext");
+const PanelPresetsContextKey = Symbol("PanelPresetsContext");
+function usePanelPickerProvider(value) {
+	provide(PanelPickerContextKey, value);
+}
+function usePanelPickerContext() {
+	return inject(PanelPickerContextKey, shallowRef({}));
+}
+function usePanelPresetsProvider(value) {
+	provide(PanelPresetsContextKey, value);
+}
+function usePanelPresetsContext() {
+	return inject(PanelPresetsContextKey, shallowRef({}));
+}
+
+//#endregion
+export { usePanelPickerContext, usePanelPickerProvider, usePanelPresetsContext, usePanelPresetsProvider };

package/dist/color-picker/hooks/useModeColor.js

@@ -0,0 +1,59 @@
+import { generateColor } from "../util.js";
+import useLocale_default from "../../locale/useLocale.js";
+import { computed, shallowRef, watch } from "vue";
+
+//#region src/color-picker/hooks/useModeColor.ts
+function useModeColor(value, mode, defaultValue) {
+	const [locale] = useLocale_default("ColorPicker");
+	const mergedColor = shallowRef(value.value ?? defaultValue);
+	watch(value, () => {
+		mergedColor.value = value.value;
+	});
+	const modeState = shallowRef("single");
+	const modeOptionListCompute = computed(() => {
+		const list = (Array.isArray(mode.value) ? mode.value : [mode.value]).filter((m) => !!m);
+		if (!list.length) list.push("single");
+		const modes = new Set(list);
+		const optionList = [];
+		const pushOption = (modeType, localeTxt) => {
+			if (modes.has(modeType)) optionList.push({
+				label: localeTxt,
+				value: modeType
+			});
+		};
+		pushOption("single", locale?.value.singleColor);
+		pushOption("gradient", locale?.value.gradientColor);
+		return [optionList, modes];
+	});
+	const modeOptionList = computed(() => modeOptionListCompute.value[0]);
+	const modeSet = computed(() => modeOptionListCompute.value[1]);
+	const cacheColor = shallowRef();
+	const setColor = (nextColor) => {
+		cacheColor.value = nextColor;
+		mergedColor.value = nextColor;
+	};
+	const postColor = computed(() => {
+		const colorObj = generateColor(mergedColor.value || "");
+		return colorObj.equals(cacheColor.value) ? cacheColor.value : colorObj;
+	});
+	const postMode = computed(() => {
+		if (modeSet.value?.has(modeState.value)) return modeState.value;
+		return modeOptionList.value[0]?.value;
+	});
+	watch(postColor, () => {
+		modeState.value = postColor.value?.isGradient() ? "gradient" : "single";
+	}, { immediate: true });
+	const setModeState = (nextMode) => {
+		modeState.value = nextMode;
+	};
+	return [
+		postColor,
+		setColor,
+		postMode,
+		setModeState,
+		modeOptionList
+	];
+}
+
+//#endregion
+export { useModeColor as default };

package/dist/color-picker/index.d.ts

@@ -0,0 +1,3 @@
+import { AggregationColor } from "./color.js";
+import { ColorPickerEmits, ColorPickerProps, ColorPickerSlots, ColorValueType } from "./interface.js";
+import { ColorPicker } from "./ColorPicker.js";

package/dist/color-picker/index.js

@@ -0,0 +1,7 @@
+import ColorPicker_default from "./ColorPicker.js";
+
+//#region src/color-picker/index.tsx
+var color_picker_default = ColorPicker_default;
+
+//#endregion
+export { color_picker_default as default };

package/dist/color-picker/interface.d.ts

@@ -0,0 +1,116 @@
+import { VueNode } from "../_util/type.js";
+import { SemanticClassNames, SemanticClassNamesType, SemanticStyles, SemanticStylesType } from "../_util/hooks/useMergeSemantic.js";
+import "../_util/hooks/index.js";
+import { SizeType } from "../config-provider/SizeContext.js";
+import { TooltipPlacement } from "../tooltip/index.js";
+import { PopoverProps } from "../popover/index.js";
+import { AggregationColor } from "./color.js";
+import { CSSProperties } from "vue";
+import { ColorGenInput, ColorPickerProps } from "@v-c/color-picker";
+import { Key } from "@v-c/util/dist/type";
+
+//#region src/color-picker/interface.d.ts
+type Colors<T> = {
+  color: ColorGenInput<T>;
+  percent: number;
+}[];
+declare const FORMAT_HEX = "hex";
+declare const FORMAT_RGB = "rgb";
+declare const FORMAT_HSB = "hsb";
+type ColorFormatType = typeof FORMAT_HEX | typeof FORMAT_RGB | typeof FORMAT_HSB;
+interface PresetsItem {
+  label: VueNode;
+  colors: (string | AggregationColor)[];
+  /**
+   * Whether the initial state is collapsed
+   * @since 5.11.0
+   * @default true
+   */
+  defaultOpen?: boolean;
+  /**
+   * The key of the panel
+   * @since 5.23.0
+   */
+  key?: Key;
+}
+type TriggerType = 'click' | 'hover';
+type TriggerPlacement = TooltipPlacement;
+type SingleValueType = AggregationColor | string;
+type LineGradientType = {
+  color: SingleValueType;
+  percent: number;
+}[];
+type ColorValueType = SingleValueType | null | LineGradientType;
+type ModeType = 'single' | 'gradient';
+type SemanticName = 'root';
+type PopupSemantic = 'root';
+type ColorPickerClassNamesType = SemanticClassNamesType<ColorPickerProps$1, SemanticName, {
+  popup?: SemanticClassNames<PopupSemantic>;
+}>;
+type ColorPickerStylesType = SemanticStylesType<ColorPickerProps$1, SemanticName, {
+  popup?: SemanticStyles<PopupSemantic>;
+  popupOverlayInner?: CSSProperties;
+}>;
+type ColorPickerProps$1 = Omit<ColorPickerProps, 'onChange' | 'onChangeComplete' | 'value' | 'defaultValue' | 'panelRender' | 'disabledAlpha' | 'components'> & {
+  mode?: ModeType | ModeType[];
+  value?: ColorValueType;
+  defaultValue?: ColorValueType;
+  open?: boolean;
+  disabled?: boolean;
+  placement?: TriggerPlacement;
+  trigger?: TriggerType;
+  format?: ColorFormatType;
+  defaultFormat?: ColorFormatType;
+  allowClear?: boolean;
+  presets?: PresetsItem[];
+  arrow?: boolean | {
+    pointAtCenter: boolean;
+  };
+  panelRender?: (params: {
+    panel: any;
+    extra: {
+      components: {
+        Picker: any;
+        Presets: any;
+      };
+    };
+  }) => any;
+  showText?: boolean | ((params: {
+    color: AggregationColor;
+  }) => any);
+  size?: SizeType;
+  classes?: ColorPickerClassNamesType;
+  styles?: ColorPickerStylesType;
+  rootClass?: string;
+  disabledAlpha?: boolean;
+  disabledFormat?: boolean;
+  [key: `data-${string}`]: string;
+} & Pick<PopoverProps, 'getPopupContainer' | 'autoAdjustOverflow' | 'destroyOnHidden'>;
+interface ColorPickerEmits {
+  'change': (value: AggregationColor, css: string) => void;
+  'clear': () => void;
+  'changeComplete': (value: AggregationColor) => void;
+  'openChange': (open: boolean) => void;
+  'update:open': (open: boolean) => void;
+  'formatChange': (format?: ColorFormatType) => void;
+  'update:value': (value: ColorValueType) => void;
+  'update:format': (format: ColorFormatType) => void;
+  [key: string]: (...args: any[]) => void;
+}
+interface ColorPickerSlots {
+  panelRender: (params: {
+    panel: any;
+    extra: {
+      components: {
+        Picker: any;
+        Presets: any;
+      };
+    };
+  }) => any;
+  showText: (params: {
+    color: AggregationColor;
+  }) => any;
+  default: () => any;
+}
+//#endregion
+export { ColorFormatType, type ColorGenInput, ColorPickerClassNamesType, ColorPickerEmits, ColorPickerProps$1 as ColorPickerProps, ColorPickerSlots, ColorPickerStylesType, ColorValueType, Colors, ModeType, PresetsItem, TriggerPlacement, TriggerType };

package/dist/color-picker/interface.js

@@ -0,0 +1,7 @@
+//#region src/color-picker/interface.ts
+const FORMAT_HEX = "hex";
+const FORMAT_RGB = "rgb";
+const FORMAT_HSB = "hsb";
+
+//#endregion
+export { FORMAT_HEX, FORMAT_HSB, FORMAT_RGB };