@v-c/picker 0.0.1

package/dist/PickerInput/context.cjs

@@ -0,0 +1,12 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_rolldown_runtime = require("../_virtual/rolldown_runtime.cjs");
+let vue = require("vue");
+var PickerContextKey = Symbol("PickerContext");
+function providePickerContext(context) {
+	(0, vue.provide)(PickerContextKey, context);
+}
+function usePickerContext() {
+	return (0, vue.inject)(PickerContextKey, (0, vue.ref)({}));
+}
+exports.providePickerContext = providePickerContext;
+exports.usePickerContext = usePickerContext;

package/dist/PickerInput/context.d.ts

@@ -0,0 +1,16 @@
+import { Ref } from 'vue';
+import { GenerateConfig } from '../generate';
+import { FilledClassNames, FilledStyles } from '../hooks/useSemantic';
+import { Components, Locale } from '../interface';
+export interface PickerContextProps<DateType = any> {
+    prefixCls: string | undefined;
+    locale: Locale;
+    generateConfig: GenerateConfig<DateType>;
+    /** Customize button component */
+    button?: Components['button'];
+    input?: Components['input'];
+    classNames: FilledClassNames;
+    styles: FilledStyles;
+}
+export declare function providePickerContext(context: Ref<PickerContextProps>): void;
+export declare function usePickerContext(): Ref<PickerContextProps>;

package/dist/PickerInput/context.js

@@ -0,0 +1,9 @@
+import { inject, provide, ref } from "vue";
+var PickerContextKey = Symbol("PickerContext");
+function providePickerContext(context) {
+	provide(PickerContextKey, context);
+}
+function usePickerContext() {
+	return inject(PickerContextKey, ref({}));
+}
+export { providePickerContext, usePickerContext };

package/dist/PickerInput/hooks/useCellRender.cjs

@@ -0,0 +1,25 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_rolldown_runtime = require("../../_virtual/rolldown_runtime.cjs");
+let _v_c_util = require("@v-c/util");
+function useCellRender(cellRender, dateRender, monthCellRender, range) {
+	if (process.env.NODE_ENV !== "production") {
+		(0, _v_c_util.warning)(!dateRender?.value, `'dateRender' is deprecated. Please use 'cellRender' instead.`);
+		(0, _v_c_util.warning)(!monthCellRender?.value, `'monthCellRender' is deprecated. Please use 'cellRender' instead.`);
+	}
+	const mergedCellRender = (current, info) => {
+		if (cellRender.value) return cellRender.value(current, info);
+		const date = current;
+		if (dateRender?.value && info.type === "date") return dateRender.value(date, info.today);
+		if (monthCellRender?.value && info.type === "month") return monthCellRender.value(date, info.locale);
+		return info.originNode;
+	};
+	const onInternalCellRender = (date, info) => mergedCellRender(date, {
+		...info,
+		range: range?.value
+	});
+	return onInternalCellRender;
+}
+exports.default = useCellRender;

package/dist/PickerInput/hooks/useCellRender.d.ts

@@ -0,0 +1,3 @@
+import { Ref } from 'vue';
+import { CellRender, CellRenderInfo, SharedPickerProps } from '../../interface';
+export default function useCellRender<DateType extends object = any>(cellRender: Ref<SharedPickerProps<DateType>['cellRender'] | undefined>, dateRender?: Ref<SharedPickerProps<DateType>['dateRender'] | undefined>, monthCellRender?: Ref<SharedPickerProps<DateType>['monthCellRender'] | undefined>, range?: Ref<CellRenderInfo<DateType>['range'] | undefined>): CellRender<DateType>;

package/dist/PickerInput/hooks/useCellRender.js

@@ -0,0 +1,20 @@
+import { warning } from "@v-c/util";
+function useCellRender(cellRender, dateRender, monthCellRender, range) {
+	if (process.env.NODE_ENV !== "production") {
+		warning(!dateRender?.value, `'dateRender' is deprecated. Please use 'cellRender' instead.`);
+		warning(!monthCellRender?.value, `'monthCellRender' is deprecated. Please use 'cellRender' instead.`);
+	}
+	const mergedCellRender = (current, info) => {
+		if (cellRender.value) return cellRender.value(current, info);
+		const date = current;
+		if (dateRender?.value && info.type === "date") return dateRender.value(date, info.today);
+		if (monthCellRender?.value && info.type === "month") return monthCellRender.value(date, info.locale);
+		return info.originNode;
+	};
+	const onInternalCellRender = (date, info) => mergedCellRender(date, {
+		...info,
+		range: range?.value
+	});
+	return onInternalCellRender;
+}
+export { useCellRender as default };

package/dist/PickerInput/hooks/useDelayState.cjs

@@ -0,0 +1,34 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_rolldown_runtime = require("../../_virtual/rolldown_runtime.cjs");
+let vue = require("vue");
+let _v_c_util = require("@v-c/util");
+function useDelayState(value, defaultValue, onChange) {
+	const internalValue = (0, vue.ref)(defaultValue);
+	const state = (0, vue.computed)(() => value.value !== void 0 ? value.value : internalValue.value);
+	const nextValueRef = (0, vue.ref)(state.value);
+	const rafRef = (0, vue.ref)();
+	const cancelRaf = () => {
+		if (rafRef.value) _v_c_util.raf.cancel(rafRef.value);
+	};
+	const doUpdate = () => {
+		if (value.value === void 0) internalValue.value = nextValueRef.value;
+		if (onChange && state.value !== nextValueRef.value) onChange(nextValueRef.value);
+	};
+	const updateValue = (next, immediately) => {
+		cancelRaf();
+		nextValueRef.value = next;
+		if (next || immediately) doUpdate();
+		else rafRef.value = (0, _v_c_util.raf)(doUpdate);
+	};
+	(0, vue.watch)(value, () => {
+		if (value.value !== void 0) nextValueRef.value = value.value;
+	});
+	(0, vue.onBeforeUnmount)(() => {
+		cancelRaf();
+	});
+	return [state, updateValue];
+}
+exports.default = useDelayState;

package/dist/PickerInput/hooks/useDelayState.d.ts

@@ -0,0 +1,2 @@
+import { Ref } from 'vue';
+export default function useDelayState<T>(value: Ref<T | undefined>, defaultValue: T, onChange?: (next: T) => void): readonly [import('vue').ComputedRef<any>, (next: T, immediately?: boolean) => void];

package/dist/PickerInput/hooks/useDelayState.js

@@ -0,0 +1,29 @@
+import { computed, onBeforeUnmount, ref, watch } from "vue";
+import { raf } from "@v-c/util";
+function useDelayState(value, defaultValue, onChange) {
+	const internalValue = ref(defaultValue);
+	const state = computed(() => value.value !== void 0 ? value.value : internalValue.value);
+	const nextValueRef = ref(state.value);
+	const rafRef = ref();
+	const cancelRaf = () => {
+		if (rafRef.value) raf.cancel(rafRef.value);
+	};
+	const doUpdate = () => {
+		if (value.value === void 0) internalValue.value = nextValueRef.value;
+		if (onChange && state.value !== nextValueRef.value) onChange(nextValueRef.value);
+	};
+	const updateValue = (next, immediately) => {
+		cancelRaf();
+		nextValueRef.value = next;
+		if (next || immediately) doUpdate();
+		else rafRef.value = raf(doUpdate);
+	};
+	watch(value, () => {
+		if (value.value !== void 0) nextValueRef.value = value.value;
+	});
+	onBeforeUnmount(() => {
+		cancelRaf();
+	});
+	return [state, updateValue];
+}
+export { useDelayState as default };

package/dist/PickerInput/hooks/useDisabledBoundary.cjs

@@ -0,0 +1,15 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_dateUtil = require("../../utils/dateUtil.cjs");
+function useDisabledBoundary(generateConfig, locale, disabledDate, minDate, maxDate) {
+	const mergedDisabledDate = (date, info) => {
+		if (disabledDate.value && disabledDate.value(date, info)) return true;
+		if (minDate.value && generateConfig.value.isAfter(minDate.value, date) && !require_dateUtil.isSame(generateConfig.value, locale.value, minDate.value, date, info.type)) return true;
+		if (maxDate.value && generateConfig.value.isAfter(date, maxDate.value) && !require_dateUtil.isSame(generateConfig.value, locale.value, maxDate.value, date, info.type)) return true;
+		return false;
+	};
+	return mergedDisabledDate;
+}
+exports.default = useDisabledBoundary;

package/dist/PickerInput/hooks/useDisabledBoundary.d.ts

@@ -0,0 +1,8 @@
+import { Ref } from 'vue';
+import { GenerateConfig } from '../../generate';
+import { DisabledDate, InternalMode, Locale } from '../../interface';
+export type IsInvalidBoundary<DateType> = (currentDate: DateType, type: InternalMode, fromDate?: DateType) => boolean;
+/**
+ * Merge `disabledDate` with `minDate` & `maxDate`.
+ */
+export default function useDisabledBoundary<DateType extends object = any>(generateConfig: Ref<GenerateConfig<DateType>>, locale: Ref<Locale>, disabledDate: Ref<DisabledDate<DateType> | undefined>, minDate: Ref<DateType | undefined>, maxDate: Ref<DateType | undefined>): DisabledDate<DateType>;

package/dist/PickerInput/hooks/useDisabledBoundary.js

@@ -0,0 +1,11 @@
+import { isSame } from "../../utils/dateUtil.js";
+function useDisabledBoundary(generateConfig, locale, disabledDate, minDate, maxDate) {
+	const mergedDisabledDate = (date, info) => {
+		if (disabledDate.value && disabledDate.value(date, info)) return true;
+		if (minDate.value && generateConfig.value.isAfter(minDate.value, date) && !isSame(generateConfig.value, locale.value, minDate.value, date, info.type)) return true;
+		if (maxDate.value && generateConfig.value.isAfter(date, maxDate.value) && !isSame(generateConfig.value, locale.value, maxDate.value, date, info.type)) return true;
+		return false;
+	};
+	return mergedDisabledDate;
+}
+export { useDisabledBoundary as default };

package/dist/PickerInput/hooks/useFieldFormat.cjs

@@ -0,0 +1,17 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_rolldown_runtime = require("../../_virtual/rolldown_runtime.cjs");
+const require_miscUtil = require("../../utils/miscUtil.cjs");
+let vue = require("vue");
+function useFieldFormat(picker, locale, format) {
+	const info = (0, vue.computed)(() => {
+		const formatList = require_miscUtil.toArray(require_miscUtil.getRowFormat(picker.value, locale.value, format?.value));
+		const firstFormat = formatList[0];
+		const maskFormat = typeof firstFormat === "object" && firstFormat.type === "mask" ? firstFormat.format : void 0;
+		return {
+			formatList: formatList.map((config) => typeof config === "string" || typeof config === "function" ? config : config.format),
+			maskFormat
+		};
+	});
+	return [(0, vue.computed)(() => info.value.formatList), (0, vue.computed)(() => info.value.maskFormat)];
+}
+exports.useFieldFormat = useFieldFormat;

package/dist/PickerInput/hooks/useFieldFormat.d.ts

@@ -0,0 +1,3 @@
+import { ComputedRef, Ref } from 'vue';
+import { FormatType, InternalMode, Locale, SharedPickerProps } from '../../interface';
+export declare function useFieldFormat<DateType = any>(picker: Ref<InternalMode>, locale: Ref<Locale>, format?: Ref<SharedPickerProps['format'] | undefined>): [formatList: ComputedRef<FormatType<DateType>[]>, maskFormat: ComputedRef<string | undefined>];

package/dist/PickerInput/hooks/useFieldFormat.js

@@ -0,0 +1,15 @@
+import { getRowFormat, toArray } from "../../utils/miscUtil.js";
+import { computed } from "vue";
+function useFieldFormat(picker, locale, format) {
+	const info = computed(() => {
+		const formatList = toArray(getRowFormat(picker.value, locale.value, format?.value));
+		const firstFormat = formatList[0];
+		const maskFormat = typeof firstFormat === "object" && firstFormat.type === "mask" ? firstFormat.format : void 0;
+		return {
+			formatList: formatList.map((config) => typeof config === "string" || typeof config === "function" ? config : config.format),
+			maskFormat
+		};
+	});
+	return [computed(() => info.value.formatList), computed(() => info.value.maskFormat)];
+}
+export { useFieldFormat };

package/dist/PickerInput/hooks/useFieldsInvalidate.cjs

@@ -0,0 +1,24 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_rolldown_runtime = require("../../_virtual/rolldown_runtime.cjs");
+const require_miscUtil = require("../../utils/miscUtil.cjs");
+let vue = require("vue");
+function useFieldsInvalidate(calendarValue, isInvalidateDate, allowEmpty = (0, vue.ref)([])) {
+	const fieldsInvalidates = (0, vue.ref)([false, false]);
+	const onSelectorInvalid = (invalid, index) => {
+		fieldsInvalidates.value = require_miscUtil.fillIndex(fieldsInvalidates.value, index, invalid);
+	};
+	return [(0, vue.computed)(() => {
+		return fieldsInvalidates.value.map((invalid, index) => {
+			if (invalid) return true;
+			const current = calendarValue.value[index];
+			if (!current) return false;
+			if (!allowEmpty.value?.[index] && !current) return true;
+			if (current && isInvalidateDate(current, { activeIndex: index })) return true;
+			return false;
+		});
+	}), onSelectorInvalid];
+}
+exports.default = useFieldsInvalidate;

package/dist/PickerInput/hooks/useFieldsInvalidate.d.ts

@@ -0,0 +1,6 @@
+import { ComputedRef, Ref } from 'vue';
+import { default as useInvalidate } from './useInvalidate';
+/**
+ * Used to control each fields invalidate status
+ */
+export default function useFieldsInvalidate<DateType extends object, ValueType extends DateType[]>(calendarValue: Ref<ValueType>, isInvalidateDate: ReturnType<typeof useInvalidate<DateType>>, allowEmpty?: Ref<boolean[] | undefined> | ComputedRef<boolean[] | undefined>): readonly [ComputedRef<[boolean, boolean]>, (invalid: boolean, index: number) => void];

package/dist/PickerInput/hooks/useFieldsInvalidate.js

@@ -0,0 +1,19 @@
+import { fillIndex } from "../../utils/miscUtil.js";
+import { computed, ref } from "vue";
+function useFieldsInvalidate(calendarValue, isInvalidateDate, allowEmpty = ref([])) {
+	const fieldsInvalidates = ref([false, false]);
+	const onSelectorInvalid = (invalid, index) => {
+		fieldsInvalidates.value = fillIndex(fieldsInvalidates.value, index, invalid);
+	};
+	return [computed(() => {
+		return fieldsInvalidates.value.map((invalid, index) => {
+			if (invalid) return true;
+			const current = calendarValue.value[index];
+			if (!current) return false;
+			if (!allowEmpty.value?.[index] && !current) return true;
+			if (current && isInvalidateDate(current, { activeIndex: index })) return true;
+			return false;
+		});
+	}), onSelectorInvalid];
+}
+export { useFieldsInvalidate as default };

package/dist/PickerInput/hooks/useFilledProps.cjs

@@ -0,0 +1,103 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_rolldown_runtime = require("../../_virtual/rolldown_runtime.cjs");
+const require_miscUtil = require("../../utils/miscUtil.cjs");
+const require_useLocale = require("../../hooks/useLocale.cjs");
+const require_useTimeConfig = require("../../hooks/useTimeConfig.cjs");
+const require_useClearIcon = require("../Selector/hooks/useClearIcon.cjs");
+const require_useDisabledBoundary = require("./useDisabledBoundary.cjs");
+const require_useFieldFormat = require("./useFieldFormat.cjs");
+const require_useInputReadOnly = require("./useInputReadOnly.cjs");
+const require_useInvalidate = require("./useInvalidate.cjs");
+let vue = require("vue");
+let _v_c_util = require("@v-c/util");
+function useList(value, fillMode = false) {
+	return (0, vue.computed)(() => {
+		const val = value.value;
+		const list = val ? require_miscUtil.toArray(val) : val;
+		if (fillMode && list && Array.isArray(list)) {
+			const clone = [...list];
+			clone[1] = clone[1] || clone[0];
+			return clone;
+		}
+		return list;
+	});
+}
+function useFilledProps(props, updater) {
+	const mergedPicker = (0, vue.computed)(() => props.value.picker || "date");
+	const mergedPrefixCls = (0, vue.computed)(() => props.value.prefixCls || "vc-picker");
+	const mergedPreviewValue = (0, vue.computed)(() => props.value.previewValue ?? "hover");
+	const mergedStyles = (0, vue.computed)(() => props.value.styles || {});
+	const mergedClassNames = (0, vue.computed)(() => props.value.classNames || {});
+	const mergedOrder = (0, vue.computed)(() => props.value.order ?? true);
+	const mergedComponents = (0, vue.computed)(() => ({
+		input: props.value.inputRender,
+		...props.value.components
+	}));
+	const values = useList((0, vue.computed)(() => props.value.value));
+	const defaultValues = useList((0, vue.computed)(() => props.value.defaultValue));
+	const pickerValues = useList((0, vue.computed)(() => props.value.pickerValue));
+	const defaultPickerValues = useList((0, vue.computed)(() => props.value.defaultPickerValue));
+	const internalPicker = (0, vue.computed)(() => mergedPicker.value === "date" && props.value.showTime ? "datetime" : mergedPicker.value);
+	const multipleInteractivePicker = (0, vue.computed)(() => internalPicker.value === "time" || internalPicker.value === "datetime");
+	const complexPicker = (0, vue.computed)(() => multipleInteractivePicker.value || props.value.multiple);
+	const mergedNeedConfirm = (0, vue.computed)(() => {
+		return props.value.needConfirm ?? multipleInteractivePicker.value;
+	});
+	const timePropsInfo = (0, vue.computed)(() => require_useTimeConfig.getTimeProps(props.value));
+	const timeProps = (0, vue.computed)(() => timePropsInfo.value[0]);
+	const localeTimeProps = (0, vue.computed)(() => timePropsInfo.value[1]);
+	const showTimeFormat = (0, vue.computed)(() => timePropsInfo.value[2]);
+	const propFormat = (0, vue.computed)(() => timePropsInfo.value[3]);
+	const mergedLocale = require_useLocale.default((0, vue.computed)(() => props.value.locale), localeTimeProps);
+	const mergedShowTime = (0, vue.computed)(() => require_useTimeConfig.fillShowTimeConfig(internalPicker.value, showTimeFormat.value, propFormat.value, timeProps.value, mergedLocale.value));
+	if (process.env.NODE_ENV !== "production") {
+		if (mergedPicker.value === "time") {
+			if ([
+				"disabledHours",
+				"disabledMinutes",
+				"disabledSeconds"
+			].some((key) => props[key])) (0, _v_c_util.warning)(false, `'disabledHours', 'disabledMinutes', 'disabledSeconds' will be removed in the next major version, please use 'disabledTime' instead.`);
+		}
+	}
+	const filledProps = (0, vue.computed)(() => ({
+		...props.value,
+		previewValue: mergedPreviewValue.value,
+		prefixCls: mergedPrefixCls.value,
+		locale: mergedLocale.value,
+		picker: mergedPicker.value,
+		styles: mergedStyles.value,
+		classNames: mergedClassNames.value,
+		order: mergedOrder.value,
+		components: mergedComponents.value,
+		clearIcon: require_useClearIcon.fillClearIcon(mergedPrefixCls.value, props.value.allowClear, props.value.clearIcon),
+		showTime: mergedShowTime.value,
+		value: values.value,
+		defaultValue: defaultValues.value,
+		pickerValue: pickerValues.value,
+		defaultPickerValue: defaultPickerValues.value,
+		...updater?.()
+	}));
+	const [formatList, maskFormat] = require_useFieldFormat.useFieldFormat(internalPicker, mergedLocale, (0, vue.computed)(() => props.value.format));
+	const mergedInputReadOnly = require_useInputReadOnly.default(formatList, (0, vue.computed)(() => props.value.inputReadOnly), (0, vue.computed)(() => props.value.multiple));
+	const disabledBoundaryDate = require_useDisabledBoundary.default((0, vue.computed)(() => props.value.generateConfig), (0, vue.computed)(() => props.value.locale), (0, vue.computed)(() => props.value.disabledDate), (0, vue.computed)(() => props.value.minDate), (0, vue.computed)(() => props.value.maxDate));
+	const isInvalidateDate = require_useInvalidate.default((0, vue.computed)(() => props.value.generateConfig), mergedPicker, disabledBoundaryDate, mergedShowTime);
+	return [
+		(0, vue.computed)(() => {
+			return {
+				...filledProps.value,
+				needConfirm: mergedNeedConfirm.value,
+				inputReadOnly: mergedInputReadOnly.value,
+				disabledDate: disabledBoundaryDate
+			};
+		}),
+		internalPicker,
+		complexPicker,
+		formatList,
+		maskFormat,
+		isInvalidateDate
+	];
+}
+exports.default = useFilledProps;

package/dist/PickerInput/hooks/useFilledProps.d.ts

@@ -0,0 +1,33 @@
+import { ComputedRef } from 'vue';
+import { FormatType, InternalMode, PickerMode } from '../../interface';
+import { RangePickerProps } from '../RangePicker';
+import { PickerProps } from '../SinglePicker';
+import { default as useInvalidate } from './useInvalidate';
+type UseInvalidate<DateType extends object = any> = typeof useInvalidate<DateType>;
+type PickedProps<DateType extends object = any> = RangePickerProps<DateType> | PickerProps<DateType>;
+type ExcludeBooleanType<T> = T extends boolean ? never : T;
+type GetGeneric<T> = T extends PickedProps<infer U> ? U : never;
+type ToArrayType<T, DateType> = T extends any[] ? T : DateType[];
+type FilledProps<InProps extends PickedProps, DateType extends GetGeneric<InProps>, UpdaterProps extends object = object> = Omit<InProps, keyof UpdaterProps | 'showTime' | 'value' | 'defaultValue'> & UpdaterProps & {
+    picker: PickerMode;
+    showTime?: ExcludeBooleanType<InProps['showTime']>;
+    value?: ToArrayType<InProps['value'], DateType>;
+    defaultValue?: ToArrayType<InProps['value'], DateType>;
+    pickerValue?: ToArrayType<InProps['value'], DateType>;
+    defaultPickerValue?: ToArrayType<InProps['value'], DateType>;
+};
+/**
+ * Align the outer props with unique typed and fill undefined props.
+ * This is shared with both RangePicker and Picker. This will do:
+ * - Convert `value` & `defaultValue` to array
+ * - handle the legacy props fill like `clearIcon` + `allowClear` = `clearIcon`
+ */
+export default function useFilledProps<InProps extends PickedProps, DateType extends GetGeneric<InProps>, UpdaterProps extends object>(props: ComputedRef<InProps>, updater?: () => UpdaterProps): [
+    filledProps: ComputedRef<FilledProps<InProps, DateType, UpdaterProps>>,
+    internalPicker: ComputedRef<InternalMode>,
+    complexPicker: ComputedRef<boolean | undefined>,
+    formatList: ComputedRef<FormatType<DateType>[]>,
+    maskFormat: ComputedRef<string | undefined>,
+    isInvalidateDate: ReturnType<UseInvalidate<DateType>>
+];
+export {};

package/dist/PickerInput/hooks/useFilledProps.js

@@ -0,0 +1,98 @@
+import { toArray } from "../../utils/miscUtil.js";
+import useLocale from "../../hooks/useLocale.js";
+import { fillShowTimeConfig, getTimeProps } from "../../hooks/useTimeConfig.js";
+import { fillClearIcon } from "../Selector/hooks/useClearIcon.js";
+import useDisabledBoundary from "./useDisabledBoundary.js";
+import { useFieldFormat } from "./useFieldFormat.js";
+import useInputReadOnly from "./useInputReadOnly.js";
+import useInvalidate from "./useInvalidate.js";
+import { computed } from "vue";
+import { warning } from "@v-c/util";
+function useList(value, fillMode = false) {
+	return computed(() => {
+		const val = value.value;
+		const list = val ? toArray(val) : val;
+		if (fillMode && list && Array.isArray(list)) {
+			const clone = [...list];
+			clone[1] = clone[1] || clone[0];
+			return clone;
+		}
+		return list;
+	});
+}
+function useFilledProps(props, updater) {
+	const mergedPicker = computed(() => props.value.picker || "date");
+	const mergedPrefixCls = computed(() => props.value.prefixCls || "vc-picker");
+	const mergedPreviewValue = computed(() => props.value.previewValue ?? "hover");
+	const mergedStyles = computed(() => props.value.styles || {});
+	const mergedClassNames = computed(() => props.value.classNames || {});
+	const mergedOrder = computed(() => props.value.order ?? true);
+	const mergedComponents = computed(() => ({
+		input: props.value.inputRender,
+		...props.value.components
+	}));
+	const values = useList(computed(() => props.value.value));
+	const defaultValues = useList(computed(() => props.value.defaultValue));
+	const pickerValues = useList(computed(() => props.value.pickerValue));
+	const defaultPickerValues = useList(computed(() => props.value.defaultPickerValue));
+	const internalPicker = computed(() => mergedPicker.value === "date" && props.value.showTime ? "datetime" : mergedPicker.value);
+	const multipleInteractivePicker = computed(() => internalPicker.value === "time" || internalPicker.value === "datetime");
+	const complexPicker = computed(() => multipleInteractivePicker.value || props.value.multiple);
+	const mergedNeedConfirm = computed(() => {
+		return props.value.needConfirm ?? multipleInteractivePicker.value;
+	});
+	const timePropsInfo = computed(() => getTimeProps(props.value));
+	const timeProps = computed(() => timePropsInfo.value[0]);
+	const localeTimeProps = computed(() => timePropsInfo.value[1]);
+	const showTimeFormat = computed(() => timePropsInfo.value[2]);
+	const propFormat = computed(() => timePropsInfo.value[3]);
+	const mergedLocale = useLocale(computed(() => props.value.locale), localeTimeProps);
+	const mergedShowTime = computed(() => fillShowTimeConfig(internalPicker.value, showTimeFormat.value, propFormat.value, timeProps.value, mergedLocale.value));
+	if (process.env.NODE_ENV !== "production") {
+		if (mergedPicker.value === "time") {
+			if ([
+				"disabledHours",
+				"disabledMinutes",
+				"disabledSeconds"
+			].some((key) => props[key])) warning(false, `'disabledHours', 'disabledMinutes', 'disabledSeconds' will be removed in the next major version, please use 'disabledTime' instead.`);
+		}
+	}
+	const filledProps = computed(() => ({
+		...props.value,
+		previewValue: mergedPreviewValue.value,
+		prefixCls: mergedPrefixCls.value,
+		locale: mergedLocale.value,
+		picker: mergedPicker.value,
+		styles: mergedStyles.value,
+		classNames: mergedClassNames.value,
+		order: mergedOrder.value,
+		components: mergedComponents.value,
+		clearIcon: fillClearIcon(mergedPrefixCls.value, props.value.allowClear, props.value.clearIcon),
+		showTime: mergedShowTime.value,
+		value: values.value,
+		defaultValue: defaultValues.value,
+		pickerValue: pickerValues.value,
+		defaultPickerValue: defaultPickerValues.value,
+		...updater?.()
+	}));
+	const [formatList, maskFormat] = useFieldFormat(internalPicker, mergedLocale, computed(() => props.value.format));
+	const mergedInputReadOnly = useInputReadOnly(formatList, computed(() => props.value.inputReadOnly), computed(() => props.value.multiple));
+	const disabledBoundaryDate = useDisabledBoundary(computed(() => props.value.generateConfig), computed(() => props.value.locale), computed(() => props.value.disabledDate), computed(() => props.value.minDate), computed(() => props.value.maxDate));
+	const isInvalidateDate = useInvalidate(computed(() => props.value.generateConfig), mergedPicker, disabledBoundaryDate, mergedShowTime);
+	return [
+		computed(() => {
+			return {
+				...filledProps.value,
+				needConfirm: mergedNeedConfirm.value,
+				inputReadOnly: mergedInputReadOnly.value,
+				disabledDate: disabledBoundaryDate
+			};
+		}),
+		internalPicker,
+		complexPicker,
+		formatList,
+		maskFormat,
+		isInvalidateDate
+	];
+}
+export { useFilledProps as default };

package/dist/PickerInput/hooks/useInputReadOnly.cjs

@@ -0,0 +1,13 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_rolldown_runtime = require("../../_virtual/rolldown_runtime.cjs");
+let vue = require("vue");
+function useInputReadOnly(formatList, inputReadOnly, multiple) {
+	return (0, vue.computed)(() => {
+		if (typeof formatList.value[0] === "function" || multiple.value) return true;
+		return inputReadOnly.value;
+	});
+}
+exports.default = useInputReadOnly;

package/dist/PickerInput/hooks/useInputReadOnly.d.ts

@@ -0,0 +1,3 @@
+import { Ref } from 'vue';
+import { FormatType } from '../../interface';
+export default function useInputReadOnly<DateType = any>(formatList: Ref<FormatType<DateType>[]>, inputReadOnly: Ref<boolean | undefined>, multiple: Ref<boolean | undefined>): import('vue').ComputedRef<boolean | undefined>;

package/dist/PickerInput/hooks/useInputReadOnly.js

@@ -0,0 +1,8 @@
+import { computed } from "vue";
+function useInputReadOnly(formatList, inputReadOnly, multiple) {
+	return computed(() => {
+		if (typeof formatList.value[0] === "function" || multiple.value) return true;
+		return inputReadOnly.value;
+	});
+}
+export { useInputReadOnly as default };

package/dist/PickerInput/hooks/useInvalidate.cjs

@@ -0,0 +1,34 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+function useInvalidate(generateConfig, picker, disabledDate, showTime) {
+	const isInvalidate = (date, info) => {
+		const outsideInfo = {
+			type: picker.value,
+			...info
+		};
+		delete outsideInfo.activeIndex;
+		if (!generateConfig.value.isValidate(date) || disabledDate.value && disabledDate.value(date, outsideInfo)) return true;
+		if ((picker.value === "date" || picker.value === "time") && showTime.value) {
+			const range = info && info.activeIndex === 1 ? "end" : "start";
+			const { disabledHours, disabledMinutes, disabledSeconds, disabledMilliseconds } = showTime.value.disabledTime?.(date, range, { from: outsideInfo.from }) || {};
+			const { disabledHours: legacyDisabledHours, disabledMinutes: legacyDisabledMinutes, disabledSeconds: legacyDisabledSeconds, disabledMilliseconds: legacyDisabledMilliseconds } = showTime.value;
+			const mergedDisabledHours = disabledHours || legacyDisabledHours;
+			const mergedDisabledMinutes = disabledMinutes || legacyDisabledMinutes;
+			const mergedDisabledSeconds = disabledSeconds || legacyDisabledSeconds;
+			const mergedDisabledMilliseconds = disabledMilliseconds || legacyDisabledMilliseconds;
+			const hour = generateConfig.value.getHour(date);
+			const minute = generateConfig.value.getMinute(date);
+			const second = generateConfig.value.getSecond(date);
+			const millisecond = generateConfig.value.getMillisecond(date);
+			if (mergedDisabledHours && mergedDisabledHours().includes(hour)) return true;
+			if (mergedDisabledMinutes && mergedDisabledMinutes(hour).includes(minute)) return true;
+			if (mergedDisabledSeconds && mergedDisabledSeconds(hour, minute).includes(second)) return true;
+			if (mergedDisabledMilliseconds && mergedDisabledMilliseconds(hour, minute, second).includes(millisecond)) return true;
+		}
+		return false;
+	};
+	return isInvalidate;
+}
+exports.default = useInvalidate;

package/dist/PickerInput/hooks/useInvalidate.d.ts

@@ -0,0 +1,10 @@
+import { ComputedRef, Ref } from 'vue';
+import { GenerateConfig } from '../../generate';
+import { PanelMode, RangeTimeProps, SharedPickerProps, SharedTimeProps } from '../../interface';
+/**
+ * Check if provided date is valid for the `disabledDate` & `showTime.disabledTime`.
+ */
+export default function useInvalidate<DateType extends object = any>(generateConfig: Ref<GenerateConfig<DateType>>, picker: Ref<PanelMode>, disabledDate: Ref<SharedPickerProps<DateType>['disabledDate'] | undefined>, showTime: Ref<SharedTimeProps<DateType> | RangeTimeProps | null> | ComputedRef<SharedTimeProps<DateType> | RangeTimeProps | null>): (date: DateType, info?: {
+    from?: DateType;
+    activeIndex: number;
+}) => boolean;

package/dist/PickerInput/hooks/useInvalidate.js

@@ -0,0 +1,30 @@
+function useInvalidate(generateConfig, picker, disabledDate, showTime) {
+	const isInvalidate = (date, info) => {
+		const outsideInfo = {
+			type: picker.value,
+			...info
+		};
+		delete outsideInfo.activeIndex;
+		if (!generateConfig.value.isValidate(date) || disabledDate.value && disabledDate.value(date, outsideInfo)) return true;
+		if ((picker.value === "date" || picker.value === "time") && showTime.value) {
+			const range = info && info.activeIndex === 1 ? "end" : "start";
+			const { disabledHours, disabledMinutes, disabledSeconds, disabledMilliseconds } = showTime.value.disabledTime?.(date, range, { from: outsideInfo.from }) || {};
+			const { disabledHours: legacyDisabledHours, disabledMinutes: legacyDisabledMinutes, disabledSeconds: legacyDisabledSeconds, disabledMilliseconds: legacyDisabledMilliseconds } = showTime.value;
+			const mergedDisabledHours = disabledHours || legacyDisabledHours;
+			const mergedDisabledMinutes = disabledMinutes || legacyDisabledMinutes;
+			const mergedDisabledSeconds = disabledSeconds || legacyDisabledSeconds;
+			const mergedDisabledMilliseconds = disabledMilliseconds || legacyDisabledMilliseconds;
+			const hour = generateConfig.value.getHour(date);
+			const minute = generateConfig.value.getMinute(date);
+			const second = generateConfig.value.getSecond(date);
+			const millisecond = generateConfig.value.getMillisecond(date);
+			if (mergedDisabledHours && mergedDisabledHours().includes(hour)) return true;
+			if (mergedDisabledMinutes && mergedDisabledMinutes(hour).includes(minute)) return true;
+			if (mergedDisabledSeconds && mergedDisabledSeconds(hour, minute).includes(second)) return true;
+			if (mergedDisabledMilliseconds && mergedDisabledMilliseconds(hour, minute, second).includes(millisecond)) return true;
+		}
+		return false;
+	};
+	return isInvalidate;
+}
+export { useInvalidate as default };