sard 1.0.0 → 1.0.1

package/components/password-input/password-input.js

@@ -0,0 +1,189 @@
+import { createBem } from "../../utils/bem.js";
+import { isNullish } from "../../utils/is.js";
+import "../../utils/index.js";
+import { useFormContext, useFormItemContext } from "../form/common.js";
+import { defaultPasswordInputProps } from "./common.js";
+import { Fragment, computed, createCommentVNode, createElementBlock, createElementVNode, defineComponent, mergeDefaults, nextTick, normalizeClass, normalizeStyle, onMounted, openBlock, ref, renderList, toDisplayString, unref, useTemplateRef, watch } from "vue";
+//#region packages/sard/components/password-input/password-input.vue
+const _hoisted_1 = ["disabled", "maxlength"];
+var password_input_default = /*@__PURE__*/ defineComponent({
+	__name: "password-input",
+	props: /*@__PURE__*/ mergeDefaults({
+		modelValue: {
+			type: String,
+			required: false
+		},
+		length: {
+			type: Number,
+			required: false
+		},
+		type: {
+			type: String,
+			required: false
+		},
+		gap: {
+			type: [Number, String],
+			required: false
+		},
+		plainText: {
+			type: Boolean,
+			required: false
+		},
+		focused: {
+			type: Boolean,
+			required: false
+		},
+		customKeyboard: {
+			type: Boolean,
+			required: false
+		},
+		disabled: {
+			type: Boolean,
+			required: false
+		},
+		readonly: {
+			type: Boolean,
+			required: false
+		},
+		validateEvent: {
+			type: Boolean,
+			required: false
+		}
+	}, defaultPasswordInputProps),
+	emits: [
+		"update:modelValue",
+		"change",
+		"update:focused",
+		"focus",
+		"blur"
+	],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const bem = createBem("password-input");
+		const formContext = useFormContext();
+		const formItemContext = useFormItemContext();
+		const isDisabled = computed(() => {
+			return formContext?.disabled || props.disabled;
+		});
+		const isReadonly = computed(() => {
+			return formContext?.readonly || props.readonly;
+		});
+		const inputRef = useTemplateRef("input");
+		const normalizeInputValue = (value) => {
+			return value.replace(/[^\d]/g, "");
+		};
+		const toEnd = () => {
+			const el = inputRef.value;
+			el.setSelectionRange(el.value.length, el.value.length);
+		};
+		const nativeInputValue = computed(() => isNullish(props.modelValue) ? "" : normalizeInputValue(String(props.modelValue)));
+		const setNativeInputValue = () => {
+			const input = inputRef.value;
+			if (!input || input.value === nativeInputValue.value) return;
+			input.value = nativeInputValue.value;
+		};
+		const onInput = (event) => {
+			let { value } = event.target;
+			value = normalizeInputValue(value);
+			if (value === nativeInputValue.value) {
+				setNativeInputValue();
+				return;
+			}
+			emit("update:modelValue", value);
+			emit("change", value);
+			nextTick(() => {
+				setNativeInputValue();
+			});
+		};
+		onMounted(() => {
+			setNativeInputValue();
+		});
+		watch(nativeInputValue, () => {
+			nextTick(() => {
+				setNativeInputValue();
+			});
+		});
+		watch(() => props.modelValue, () => {
+			if (props.validateEvent) formItemContext?.onChange();
+		});
+		const innerFocused = ref(props.focused);
+		watch(() => props.focused, () => {
+			innerFocused.value = props.focused;
+		});
+		const onFocus = (event) => {
+			toEnd();
+			innerFocused.value = true;
+			emit("update:focused", true);
+			emit("focus", event);
+		};
+		const onBlur = (event) => {
+			innerFocused.value = false;
+			emit("update:focused", false);
+			emit("blur", event);
+			if (props.validateEvent) formItemContext?.onBlur();
+		};
+		const items = computed(() => {
+			const valueLength = nativeInputValue.value.length;
+			return Array(props.length).fill(0).map((_, i) => {
+				return {
+					index: i,
+					active: innerFocused.value && (i === valueLength || i === valueLength - 1 && i === props.length - 1)
+				};
+			});
+		});
+		const isTight = computed(() => {
+			return props.gap === 0 || typeof props.gap === "string" && parseInt(props.gap) === 0;
+		});
+		const passwordInputClass = computed(() => {
+			return [
+				bem.b(),
+				bem.m("readonly", isReadonly.value),
+				bem.m("disabled", isDisabled.value),
+				bem.m(props.type, !isTight.value),
+				bem.m(`tight-${props.type}`, isTight.value)
+			];
+		});
+		const passwordInputStyle = computed(() => {
+			return { gap: props.gap };
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				class: normalizeClass(passwordInputClass.value),
+				style: normalizeStyle(passwordInputStyle.value)
+			}, [(openBlock(true), createElementBlock(Fragment, null, renderList(items.value, (item) => {
+				return openBlock(), createElementBlock("div", {
+					key: item.index,
+					class: normalizeClass([unref(bem).e("item"), unref(bem).em("item", "active", item.active)])
+				}, [item.index < nativeInputValue.value.length ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [__props.plainText ? (openBlock(), createElementBlock("div", {
+					key: 0,
+					class: normalizeClass(unref(bem).e("plaintext"))
+				}, toDisplayString(nativeInputValue.value[item.index]), 3)) : (openBlock(), createElementBlock("div", {
+					key: 1,
+					class: normalizeClass(unref(bem).e("ciphertext"))
+				}, null, 2))], 64)) : createCommentVNode("v-if", true), innerFocused.value && item.index === nativeInputValue.value.length ? (openBlock(), createElementBlock("div", {
+					key: 1,
+					class: normalizeClass(unref(bem).e("cursor"))
+				}, null, 2)) : createCommentVNode("v-if", true)], 2);
+			}), 128)), !__props.customKeyboard ? (openBlock(), createElementBlock("div", {
+				key: 0,
+				class: normalizeClass(unref(bem).e("input-wrapper"))
+			}, [createElementVNode("input", {
+				ref: "input",
+				type: "text",
+				inputmode: "numeric",
+				class: normalizeClass(unref(bem).e("input")),
+				disabled: isDisabled.value || isReadonly.value,
+				maxlength: __props.length,
+				onInput,
+				onFocus,
+				onBlur,
+				onClick: toEnd,
+				onKeyup: toEnd,
+				onSelect: toEnd
+			}, null, 42, _hoisted_1)], 2)) : createCommentVNode("v-if", true)], 6);
+		};
+	}
+});
+//#endregion
+export { password_input_default as default };

package/components/picker/common.d.ts

@@ -0,0 +1,25 @@
+import { type DefaultProps } from '../config';
+import { type OptionKeys, type UseOptionKeysReturn } from '../../use';
+export interface PickerProps<T> {
+    columns?: T[] | T[][];
+    optionKeys?: OptionKeys;
+    modelValue?: any;
+}
+export declare const defaultPickerProps: DefaultProps<PickerProps<any>>;
+export interface PickerSlots<T> {
+    option?(props: {
+        option: T;
+        rowIndex: number;
+        columnIndex: number;
+    }): any;
+}
+export interface PickerEmits<T> {
+    (e: 'update:modelValue', value: any, selectedOptions: T[], indexes: number[]): void;
+    (e: 'change', value: any, selectedOptions: T[], indexes: number[]): void;
+}
+export declare function getColumnsType<T>(columns: T[] | T[][], { getChildren }: UseOptionKeysReturn): "single" | "multi" | "cascader";
+export declare function getOptionsByIndexes<T>(indexes: number[], columns: T[] | T[][], useOptionKeysReturn: UseOptionKeysReturn): T[];
+export declare function getCascaderValidIndexes<T>(indexes: number[], columns: T[] | T[][], { getChildren }: UseOptionKeysReturn): number[];
+export declare function getMaySingleValueByOptions<T>(options: T[], useOptionKeysReturn: UseOptionKeysReturn, columns: T[] | T[][]): any;
+export declare function getIndexesByValue<T>(value: any[], columns: T[] | T[][], useOptionKeysReturn: UseOptionKeysReturn): number[];
+export declare function getInitialValue<T>(columns: T[] | T[][], useOptionKeysReturn: UseOptionKeysReturn): any[];

package/components/picker/common.js

@@ -0,0 +1,77 @@
+//#region packages/sard/components/picker/common.ts
+const defaultPickerProps = { columns: () => [] };
+function getColumnsType(columns, { getChildren }) {
+	const firstColumn = columns[0];
+	if (Array.isArray(firstColumn)) return "multi";
+	if (firstColumn && typeof firstColumn === "object" && Array.isArray(getChildren(firstColumn))) return "cascader";
+	return "single";
+}
+function getOptionsByIndexes(indexes, columns, useOptionKeysReturn) {
+	const { getChildren } = useOptionKeysReturn;
+	function recurse(columns, i = 0) {
+		const option = columns[Math.min(indexes[i], columns.length - 1)];
+		const nextColumn = getChildren(option);
+		if (Array.isArray(nextColumn)) return [option, ...recurse(nextColumn, ++i)];
+		return [option];
+	}
+	switch (getColumnsType(columns, useOptionKeysReturn)) {
+		case "single": return [columns[indexes[0]]];
+		case "multi": return columns.map((column, i) => column[indexes[i]]);
+		case "cascader": return recurse(columns);
+	}
+}
+function getCascaderValidIndexes(indexes, columns, { getChildren }) {
+	function recurse(columns, i = 0) {
+		let index = Math.min(indexes[i], columns.length - 1);
+		const option = columns[index];
+		if (!option) index = 0;
+		const nextColumn = getChildren(option);
+		if (Array.isArray(nextColumn)) return [index, ...recurse(nextColumn, ++i)];
+		return [index];
+	}
+	return recurse(columns);
+}
+function getMaySingleValueByOptions(options, useOptionKeysReturn, columns) {
+	const { getValue } = useOptionKeysReturn;
+	const values = options.map((option) => getValue(option));
+	return getColumnsType(columns, useOptionKeysReturn) === "single" ? values[0] : values;
+}
+function getIndexesByValue(value, columns, useOptionKeysReturn) {
+	const { getValue, getChildren } = useOptionKeysReturn;
+	const type = getColumnsType(columns, useOptionKeysReturn);
+	function recurse(columns, i = 0) {
+		let index = columns.findIndex((option) => getValue(option) === value[i]);
+		if (index === -1) index = 0;
+		const option = columns[index];
+		const nextColumn = getChildren(option);
+		if (Array.isArray(nextColumn)) return [index, ...recurse(nextColumn, ++i)];
+		return [index];
+	}
+	if (type === "cascader") return recurse(columns);
+	if (type === "single") columns = [columns];
+	return columns.map((column, index) => {
+		const optionIndex = column.findIndex((option) => getValue(option) === value[index]);
+		return Math.max(optionIndex, 0);
+	});
+}
+function getInitialValue(columns, useOptionKeysReturn) {
+	const { getChildren, getValue } = useOptionKeysReturn;
+	function recurse(columns, options) {
+		const option = columns[0];
+		options.push(option);
+		const nextColumn = getChildren(option);
+		if (Array.isArray(nextColumn) && nextColumn.length > 0) return recurse(nextColumn, options);
+		return option;
+	}
+	switch (getColumnsType(columns, useOptionKeysReturn)) {
+		case "single": return [getValue(columns[0]), [columns[0]]];
+		case "multi": return [columns.map((column) => getValue(column[0])), columns.map((column) => column[0])];
+		case "cascader": {
+			const options = [];
+			recurse(columns, options);
+			return [options.map((option) => getValue(option)), options];
+		}
+	}
+}
+//#endregion
+export { defaultPickerProps, getCascaderValidIndexes, getColumnsType, getIndexesByValue, getInitialValue, getMaySingleValueByOptions, getOptionsByIndexes };

package/components/picker/index.css

@@ -0,0 +1 @@
+:root{--s-picker-item-font-size:var(--s-font-size-lg);--s-picker-item-color:var(--s-text-color-primary)}.s-picker__item{line-height:var(--s-picker-view-indicator-height);font-size:var(--s-picker-item-font-size);color:var(--s-picker-item-color);text-align:center;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}

package/components/picker/index.d.ts

@@ -0,0 +1,5 @@
+import { type EnhancedComponent } from '../../utils';
+import _Picker from './picker.vue';
+export declare const Picker: EnhancedComponent<typeof _Picker>;
+export default Picker;
+export type { PickerProps, PickerEmits } from './common';

package/components/picker/index.js

@@ -0,0 +1,7 @@
+import { enhanceComponent } from "../../utils/component.js";
+import "../../utils/index.js";
+import picker_default from "./picker.js";
+//#region packages/sard/components/picker/index.ts
+const Picker = enhanceComponent(picker_default);
+//#endregion
+export { Picker, Picker as default };

package/components/picker/picker.d.ts

@@ -0,0 +1,22 @@
+import { type PickerProps, type PickerSlots, type PickerEmits } from './common';
+declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<PickerProps<T> & {
+        onChange?: ((value: any, selectedOptions: T[], indexes: number[]) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: any, selectedOptions: T[], indexes: number[]) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: PickerSlots<T>;
+    emit: PickerEmits<T>;
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/components/picker/picker.js

@@ -0,0 +1,143 @@
+import { createBem } from "../../utils/bem.js";
+import { isEmptyArray } from "../../utils/is.js";
+import { isEmptyBinding } from "../../utils/utils.js";
+import { nestedToMulti } from "../../utils/object.js";
+import { arrayEqual, toArray } from "../../utils/array.js";
+import { useOptionKeys } from "../../use/useOptionKeys.js";
+import "../../use/index.js";
+import "../../utils/index.js";
+import { defaultPickerProps, getCascaderValidIndexes, getColumnsType, getIndexesByValue, getMaySingleValueByOptions, getOptionsByIndexes } from "./common.js";
+import picker_view_default from "../picker-view/picker-view.js";
+import picker_view_column_default from "../picker-view/picker-view-column.js";
+import { Fragment, computed, createBlock, createElementBlock, createTextVNode, createVNode, defineComponent, mergeDefaults, nextTick, normalizeClass, openBlock, ref, renderList, renderSlot, toDisplayString, unref, useSlots, watch, withCtx } from "vue";
+//#region packages/sard/components/picker/picker.vue
+var picker_default = /*@__PURE__*/ defineComponent({
+	__name: "picker",
+	props: /*@__PURE__*/ mergeDefaults({
+		columns: {
+			type: Array,
+			required: false
+		},
+		optionKeys: {
+			type: Object,
+			required: false
+		},
+		modelValue: {
+			type: null,
+			required: false
+		}
+	}, defaultPickerProps),
+	emits: ["update:modelValue", "change"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		useSlots();
+		const emit = __emit;
+		const bem = createBem("picker");
+		const useOptionKeysReturn = useOptionKeys(props);
+		const { aliasProps, getLabel } = useOptionKeysReturn;
+		const columnsType = computed(() => {
+			return getColumnsType(props.columns, useOptionKeysReturn);
+		});
+		const innerValue = ref(props.modelValue);
+		watch(() => props.modelValue, () => {
+			innerValue.value = props.modelValue;
+		});
+		const columnIndexes = ref([]);
+		const updateColumnIndexes = () => {
+			const indexes = getIndexesByValue(toArray(innerValue.value), props.columns, useOptionKeysReturn);
+			if (!arrayEqual(indexes, columnIndexes.value)) columnIndexes.value = indexes;
+		};
+		updateColumnIndexes();
+		watch([
+			innerValue,
+			() => props.columns,
+			aliasProps
+		], () => {
+			if (!isEmptyBinding(innerValue.value) && !isEmptyArray(innerValue.value)) updateColumnIndexes();
+		});
+		const onChange = (value) => {
+			if (!props.columns || props.columns.length === 0) return;
+			let indexes = value;
+			if (indexes.some((index) => index === Infinity)) {
+				nextTick(() => {
+					columnIndexes.value = isEmptyBinding(innerValue.value) || isEmptyArray(innerValue.value) ? columnIndexes.value.map(() => 0) : [...columnIndexes.value];
+				});
+				return;
+			}
+			indexes = renderedColumns.value.map((_, index) => indexes[index] || 0);
+			if (columnsType.value === "cascader") {
+				let startIndex = -1;
+				const nextIndexes = [];
+				for (let i = 0; i < columnIndexes.value.length; i++) {
+					if (startIndex < 0 && columnIndexes.value[i] !== indexes[i]) startIndex = i;
+					nextIndexes.push(startIndex > -1 && i > startIndex ? 0 : indexes[i]);
+				}
+				indexes = nextIndexes;
+				{
+					const validIndexes = getCascaderValidIndexes(indexes, props.columns, useOptionKeysReturn);
+					if (!arrayEqual(indexes, validIndexes)) indexes = validIndexes;
+				}
+			}
+			const selectedOptions = getOptionsByIndexes(indexes, props.columns, useOptionKeysReturn);
+			if (!arrayEqual(indexes, columnIndexes.value)) columnIndexes.value = indexes;
+			const nextValue = getMaySingleValueByOptions(selectedOptions, useOptionKeysReturn, props.columns);
+			innerValue.value = nextValue;
+			emit("update:modelValue", nextValue, selectedOptions, indexes);
+			emit("change", nextValue, selectedOptions, indexes);
+		};
+		const getRenderedColumns = () => {
+			switch (columnsType.value) {
+				case "single": return [props.columns];
+				case "multi": return props.columns;
+				case "cascader": return nestedToMulti(props.columns, toArray(innerValue.value), useOptionKeysReturn);
+				default: return [];
+			}
+		};
+		const renderedColumns = ref(getRenderedColumns());
+		const updateRenderedColumns = () => {
+			renderedColumns.value = getRenderedColumns();
+		};
+		watch([() => props.columns, innerValue], ([newColumns, newValue], [oldColumns, oldValue]) => {
+			if (newColumns !== oldColumns || newValue !== oldValue && columnsType.value === "cascader" && !isEmptyBinding(newValue) && !isEmptyArray(newValue)) updateRenderedColumns();
+		});
+		watch(() => props.modelValue, () => {
+			if (isEmptyBinding(props.modelValue) || isEmptyArray(props.modelValue)) {
+				updateColumnIndexes();
+				updateRenderedColumns();
+			}
+		});
+		const pickerViewClass = bem.e("picker-view");
+		const indicatorClass = bem.e("indicator");
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", { class: normalizeClass(unref(bem).b()) }, [createVNode(unref(picker_view_default), {
+				class: normalizeClass(unref(pickerViewClass)),
+				"indicator-class": unref(indicatorClass),
+				value: columnIndexes.value,
+				onChange
+			}, {
+				default: withCtx(() => [(openBlock(true), createElementBlock(Fragment, null, renderList(renderedColumns.value, (column, i) => {
+					return openBlock(), createBlock(unref(picker_view_column_default), { key: i }, {
+						default: withCtx(() => [(openBlock(true), createElementBlock(Fragment, null, renderList(column, (option, j) => {
+							return openBlock(), createElementBlock("div", {
+								key: j,
+								class: normalizeClass(unref(bem).e("item"))
+							}, [renderSlot(_ctx.$slots, "option", {
+								option,
+								rowIndex: j,
+								columnIndex: i
+							}, () => [createTextVNode(toDisplayString(unref(getLabel)(option)), 1)])], 2);
+						}), 128))]),
+						_: 2
+					}, 1024);
+				}), 128))]),
+				_: 3
+			}, 8, [
+				"class",
+				"indicator-class",
+				"value"
+			])], 2);
+		};
+	}
+});
+//#endregion
+export { picker_default as default };

package/components/picker-input/common.d.ts

@@ -0,0 +1,81 @@
+import { type PopoutInputSlots, type PopoutInputProps } from '../popout-input/common';
+import { type PickerPopoutSlots, type PickerPopoutEmits, type PickerPopoutProps } from '../picker-popout/common';
+export interface PickerInputProps<T> extends PickerPopoutProps<T>, Omit<PopoutInputProps, 'modelValue'> {
+}
+export declare const defaultPickerInputProps: {
+    visible?: (boolean | ((props: {
+        visible: boolean;
+        title: string;
+        resettable: boolean;
+        validateEvent: boolean;
+        showConfirm: boolean;
+        columns: any[] | any[][] | undefined;
+        optionKeys: import("../..").OptionKeys;
+        modelValue: any;
+    }) => boolean)) | undefined;
+    title?: (string | ((props: {
+        visible: boolean;
+        title: string;
+        resettable: boolean;
+        validateEvent: boolean;
+        showConfirm: boolean;
+        columns: any[] | any[][] | undefined;
+        optionKeys: import("../..").OptionKeys;
+        modelValue: any;
+    }) => string)) | undefined;
+    resettable?: (boolean | ((props: {
+        visible: boolean;
+        title: string;
+        resettable: boolean;
+        validateEvent: boolean;
+        showConfirm: boolean;
+        columns: any[] | any[][] | undefined;
+        optionKeys: import("../..").OptionKeys;
+        modelValue: any;
+    }) => boolean)) | undefined;
+    validateEvent?: (boolean | ((props: {
+        visible: boolean;
+        title: string;
+        resettable: boolean;
+        validateEvent: boolean;
+        showConfirm: boolean;
+        columns: any[] | any[][] | undefined;
+        optionKeys: import("../..").OptionKeys;
+        modelValue: any;
+    }) => boolean)) | undefined;
+    showConfirm?: (boolean | ((props: {
+        visible: boolean;
+        title: string;
+        resettable: boolean;
+        validateEvent: boolean;
+        showConfirm: boolean;
+        columns: any[] | any[][] | undefined;
+        optionKeys: import("../..").OptionKeys;
+        modelValue: any;
+    }) => boolean)) | undefined;
+    columns?: ((props: {
+        visible: boolean;
+        title: string;
+        resettable: boolean;
+        validateEvent: boolean;
+        showConfirm: boolean;
+        columns: any[] | any[][] | undefined;
+        optionKeys: import("../..").OptionKeys;
+        modelValue: any;
+    }) => any[] | any[][]) | undefined;
+    optionKeys?: ((props: {
+        visible: boolean;
+        title: string;
+        resettable: boolean;
+        validateEvent: boolean;
+        showConfirm: boolean;
+        columns: any[] | any[][] | undefined;
+        optionKeys: import("../..").OptionKeys;
+        modelValue: any;
+    }) => import("../..").OptionKeys) | undefined;
+    modelValue?: any;
+};
+export interface PickerInputSlots<T> extends PickerPopoutSlots<T>, PopoutInputSlots {
+}
+export interface PickerInputEmits extends PickerPopoutEmits {
+}

package/components/picker-input/common.js

@@ -0,0 +1,5 @@
+import { defaultPickerPopoutProps } from "../picker-popout/common.js";
+//#region packages/sard/components/picker-input/common.ts
+const defaultPickerInputProps = { ...defaultPickerPopoutProps };
+//#endregion
+export { defaultPickerInputProps };

package/components/picker-input/index.d.ts

@@ -0,0 +1,5 @@
+import { type EnhancedComponent } from '../../utils';
+import _PickerInput from './picker-input.vue';
+export declare const PickerInput: EnhancedComponent<typeof _PickerInput>;
+export default PickerInput;
+export type { PickerInputProps, PickerInputEmits } from './common';

package/components/picker-input/index.js

@@ -0,0 +1,7 @@
+import { enhanceComponent } from "../../utils/component.js";
+import "../../utils/index.js";
+import picker_input_default from "./picker-input.js";
+//#region packages/sard/components/picker-input/index.ts
+const PickerInput = enhanceComponent(picker_input_default);
+//#endregion
+export { PickerInput, PickerInput as default };

package/components/picker-input/picker-input.d.ts

@@ -0,0 +1,33 @@
+import { type PickerInputProps, type PickerInputEmits, type PickerInputSlots } from './common';
+declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<PickerInputProps<T> & {
+        onChange?: ((value: any) => any) | undefined;
+        "onBefore-enter"?: ((el: Element) => any) | undefined;
+        onEnter?: ((el: Element) => any) | undefined;
+        "onAfter-enter"?: ((el: Element) => any) | undefined;
+        "onEnter-cancelled"?: ((el: Element) => any) | undefined;
+        "onBefore-leave"?: ((el: Element) => any) | undefined;
+        onLeave?: ((el: Element) => any) | undefined;
+        "onAfter-leave"?: ((el: Element) => any) | undefined;
+        "onLeave-cancelled"?: ((el: Element) => any) | undefined;
+        "onVisible-hook"?: ((name: import("../index.ts").MotionHookName, el: Element) => any) | undefined;
+        "onUpdate:visible"?: ((visible: boolean) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+        onConfirm?: (() => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: PickerInputSlots<T>;
+    emit: PickerInputEmits;
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};