sard 1.0.0 → 1.0.2

package/components/date-strip/date-strip.js

@@ -0,0 +1,271 @@
+import { createBem } from "../../utils/bem.js";
+import { formatDate, getLunarDayName, getLunarMonthName, minmaxDate, parseDate, solarToLunar, toDateNumber } from "../../utils/date.js";
+import { scrollToTarget } from "../../utils/geometry.js";
+import { useTranslateWithPrefix } from "../../locale/index.js";
+import { defaultDateStripProps, getMaxDate, getMinDate, sortDates } from "./common.js";
+import { Fragment, computed, createCommentVNode, createElementBlock, createElementVNode, defineComponent, mergeDefaults, nextTick, normalizeClass, normalizeStyle, openBlock, renderList, shallowRef, toDisplayString, toRaw, unref, useTemplateRef, watch } from "vue";
+//#region packages/sard/components/date-strip/date-strip.vue
+const _hoisted_1 = ["data-key", "onClick"];
+var date_strip_default = /*@__PURE__*/ defineComponent({
+	__name: "date-strip",
+	props: /*@__PURE__*/ mergeDefaults({
+		type: {
+			type: String,
+			required: false
+		},
+		modelValue: {
+			type: [
+				Date,
+				Array,
+				String
+			],
+			required: false
+		},
+		min: {
+			type: Date,
+			required: false
+		},
+		max: {
+			type: Date,
+			required: false
+		},
+		currentDate: {
+			type: Date,
+			required: false
+		},
+		disabledDate: {
+			type: Function,
+			required: false
+		},
+		maxDays: {
+			type: Number,
+			required: false
+		},
+		overMaxDays: {
+			type: Function,
+			required: false
+		},
+		formatter: {
+			type: Function,
+			required: false
+		},
+		filter: {
+			type: Function,
+			required: false
+		},
+		allowSameDay: {
+			type: Boolean,
+			required: false
+		},
+		valueFormat: {
+			type: String,
+			required: false
+		},
+		startDateText: {
+			type: String,
+			required: false
+		},
+		endDateText: {
+			type: String,
+			required: false
+		},
+		sameDateText: {
+			type: String,
+			required: false
+		},
+		showLunar: {
+			type: Boolean,
+			required: false
+		}
+	}, defaultDateStripProps),
+	emits: ["update:modelValue", "change"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const bem = createBem("date-strip");
+		const { t, select } = useTranslateWithPrefix("calendar");
+		const getAnchorDate = () => {
+			return props.currentDate || /* @__PURE__ */ new Date();
+		};
+		const minDate = computed(() => {
+			return props.min || getMinDate(getAnchorDate());
+		});
+		const maxDate = computed(() => {
+			const maxDate = props.max || getMaxDate(getAnchorDate());
+			return maxDate.getTime() < minDate.value.getTime() ? new Date(minDate.value) : maxDate;
+		});
+		const toDate = (date) => {
+			if (date instanceof Date) return date;
+			return parseDate(date, props.valueFormat);
+		};
+		const makeDate = (date) => {
+			return Array.isArray(date) ? date.map((item) => toDate(item)) : toDate(date);
+		};
+		const normalizeValue = (value) => {
+			return value ? makeDate(value) : props.type === "single" ? void 0 : [];
+		};
+		const innerValue = shallowRef(normalizeValue(props.modelValue));
+		let currentEmitValue = innerValue.value;
+		watch(() => toRaw(props.modelValue), (value) => {
+			if (currentEmitValue !== value) {
+				innerValue.value = normalizeValue(value);
+				currentEmitValue = value;
+			}
+		});
+		const innerCurrentDate = shallowRef(minmaxDate(getAnchorDate(), minDate.value, maxDate.value));
+		watch(() => props.currentDate, () => {
+			innerCurrentDate.value = minmaxDate(getAnchorDate(), minDate.value, maxDate.value);
+		});
+		watch([minDate, maxDate], () => {
+			innerCurrentDate.value = minmaxDate(innerCurrentDate.value, minDate.value, maxDate.value);
+		});
+		watch(innerValue, () => {
+			const onlyOneDate = Array.isArray(innerValue.value) ? innerValue.value.length === 1 ? innerValue.value[0] : void 0 : innerValue.value;
+			if (onlyOneDate) innerCurrentDate.value = minmaxDate(onlyOneDate, minDate.value, maxDate.value);
+		});
+		const startDate = shallowRef(props.type === "range" && Array.isArray(innerValue.value) && innerValue.value.length === 1 ? innerValue.value[0] : void 0);
+		const currentDates = computed(() => {
+			if (props.type === "range" && startDate.value) return [startDate.value];
+			if (Array.isArray(innerValue.value)) return innerValue.value;
+			return innerValue.value ? [innerValue.value] : [];
+		});
+		const getDefaultLunarLabel = (date) => {
+			const lunarDate = solarToLunar(date.getFullYear(), date.getMonth() + 1, date.getDate());
+			return lunarDate.day === 1 ? getLunarMonthName(Math.abs(lunarDate.month), lunarDate.month < 0) : getLunarDayName(lunarDate.day);
+		};
+		const daysInfo = computed(() => {
+			const todayNumber = toDateNumber(/* @__PURE__ */ new Date());
+			const dates = [];
+			const cursor = new Date(minDate.value);
+			while (cursor.getTime() <= maxDate.value.getTime()) {
+				dates.push(new Date(cursor));
+				cursor.setDate(cursor.getDate() + 1);
+			}
+			return dates.filter((date) => {
+				return props.filter ? props.filter(date) : true;
+			}).map((date) => {
+				const dateNumber = toDateNumber(date);
+				const selected = props.type !== "range" && currentDates.value.some((item) => toDateNumber(item) === dateNumber);
+				const isStart = props.type === "range" && currentDates.value[0] && toDateNumber(currentDates.value[0]) === dateNumber;
+				const isEnd = props.type === "range" && currentDates.value[1] && toDateNumber(currentDates.value[1]) === dateNumber;
+				const isMiddle = props.type === "range" && currentDates.value.length === 2 && dateNumber > toDateNumber(currentDates.value[0]) && dateNumber < toDateNumber(currentDates.value[1]);
+				const d = date.getDay();
+				const week = select(`abbrWeeks.${d}`) || select(`weeks.${d}`);
+				const day = {
+					date,
+					disabled: !!props.disabledDate?.(date),
+					top: week,
+					text: formatDate(date, "MM-DD"),
+					bottom: isStart && isEnd ? props.sameDateText || `${t("start")}/${t("end")}` : isStart ? props.startDateText || t("start") : isEnd ? props.endDateText || t("end") : props.showLunar ? getDefaultLunarLabel(date) : "",
+					type: isStart && isEnd ? "same" : isStart ? "start" : isMiddle ? "middle" : isEnd ? "end" : selected ? "selected" : "normal",
+					today: todayNumber === dateNumber
+				};
+				props.formatter?.(day);
+				return {
+					key: dateNumber,
+					day,
+					style: day.style,
+					className: [
+						bem.e("item"),
+						bem.em("item", day.type, day.type !== "normal"),
+						bem.em("item", "disabled", day.disabled),
+						bem.em("item", "today", day.today),
+						day.className
+					]
+				};
+			});
+		});
+		const onDayClick = (day) => {
+			if (day.disabled) return;
+			let nextValue;
+			if (props.type === "single") nextValue = day.date;
+			else if (props.type === "multiple") {
+				if (Array.isArray(innerValue.value)) if (innerValue.value.some((item) => toDateNumber(item) === toDateNumber(day.date))) nextValue = innerValue.value.filter((item) => toDateNumber(item) !== toDateNumber(day.date));
+				else {
+					if (innerValue.value.length >= props.maxDays) {
+						props.overMaxDays?.();
+						return;
+					}
+					nextValue = sortDates(innerValue.value.concat(day.date));
+				}
+			} else if (props.type === "range") {
+				if (startDate.value) {
+					const startDays = toDateNumber(startDate.value);
+					const endDays = toDateNumber(day.date);
+					if (!props.allowSameDay && startDays === endDays) return;
+					if (endDays < startDays) {
+						startDate.value = day.date;
+						return;
+					}
+					let endDate = day.date;
+					if (endDays - startDays + 1 > props.maxDays) {
+						props.overMaxDays?.();
+						endDate = new Date(startDate.value);
+						endDate.setDate(endDate.getDate() + (props.maxDays - 1));
+					}
+					nextValue = [startDate.value, endDate];
+				} else nextValue = [];
+				startDate.value = startDate.value ? void 0 : day.date;
+			}
+			if (nextValue !== void 0) {
+				innerValue.value = nextValue;
+				const emitValue = props.valueFormat ? Array.isArray(nextValue) ? nextValue.map((item) => formatDate(item, props.valueFormat)) : formatDate(nextValue, props.valueFormat) : nextValue;
+				currentEmitValue = emitValue;
+				emit("update:modelValue", emitValue);
+				emit("change", emitValue);
+			}
+		};
+		const scrollRef = useTemplateRef("scroll");
+		const itemRefs = useTemplateRef("items");
+		const getCenterDate = () => {
+			return currentDates.value[0] || innerCurrentDate.value;
+		};
+		const scrollToCenterDate = (animated = true) => {
+			const dateNumber = toDateNumber(getCenterDate());
+			const item = itemRefs.value?.find((item) => +item.dataset.key === dateNumber);
+			if (item) scrollToTarget(scrollRef.value, item, {
+				animated,
+				position: "center"
+			});
+		};
+		let firstScrollCenter = true;
+		watch([
+			daysInfo,
+			currentDates,
+			innerCurrentDate
+		], () => {
+			if (props.type === "single" || firstScrollCenter) nextTick(() => {
+				scrollToCenterDate(!firstScrollCenter);
+				firstScrollCenter = false;
+			});
+		}, {
+			immediate: true,
+			flush: "post"
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				ref: "scroll",
+				class: normalizeClass(unref(bem).b())
+			}, [createElementVNode("div", { class: normalizeClass(unref(bem).e("content")) }, [(openBlock(true), createElementBlock(Fragment, null, renderList(daysInfo.value, (item) => {
+				return openBlock(), createElementBlock("div", {
+					key: item.key,
+					ref_for: true,
+					ref: "items",
+					"data-key": item.key,
+					class: normalizeClass(item.className),
+					style: normalizeStyle(item.style),
+					onClick: ($event) => onDayClick(item.day)
+				}, [
+					createElementVNode("div", { class: normalizeClass(unref(bem).e("item-week")) }, toDisplayString(item.day.top), 3),
+					createElementVNode("div", { class: normalizeClass(unref(bem).e("item-day")) }, toDisplayString(item.day.text), 3),
+					__props.type === "range" || item.day.bottom ? (openBlock(), createElementBlock("div", {
+						key: 0,
+						class: normalizeClass(unref(bem).e("item-info"))
+					}, toDisplayString(item.day.bottom || "\xA0"), 3)) : createCommentVNode("v-if", true)
+				], 14, _hoisted_1);
+			}), 128))], 2)], 2);
+		};
+	}
+});
+//#endregion
+export { date_strip_default as default };

package/components/date-strip/index.css

@@ -0,0 +1 @@
+:root{--s-date-strip-column-gap:8px;--s-date-strip-item-width:64px;--s-date-strip-item-padding-y:9px;--s-date-strip-item-padding-x:6px;--s-date-strip-item-radius:var(--s-border-radius);--s-date-strip-item-border-color:rgba(0,0,0,0);--s-date-strip-item-bg:rgba(0,0,0,0);--s-date-strip-item-week-font-size:var(--s-font-size-sm);--s-date-strip-item-week-color:var(--s-text-color-secondary);--s-date-strip-item-week-order:1;--s-date-strip-item-day-font-size:var(--s-font-size);--s-date-strip-item-day-color:inherit;--s-date-strip-item-day-order:2;--s-date-strip-item-info-font-size:var(--s-font-size-xs);--s-date-strip-item-info-color:var(--s-text-color-tertiary);--s-date-strip-item-info-order:3;--s-date-strip-item-color-selected:var(--s-white);--s-date-strip-item-bg-selected:var(--s-color-primary);--s-date-strip-item-bg-middle:rgba(var(--s-color-primary-rgb), 0.1);--s-date-strip-item-color-today:var(--s-color-primary)}.s-date-strip{overflow-x:auto;overflow-y:hidden}.s-date-strip__content{display:inline-flex;flex-direction:row;column-gap:var(--s-date-strip-column-gap)}.s-date-strip__item{display:flex;flex-direction:column;justify-content:flex-start;align-items:center;flex:none;width:var(--s-date-strip-item-width);padding:var(--s-date-strip-item-padding-y) var(--s-date-strip-item-padding-x);text-align:center;border-radius:var(--s-date-strip-item-radius);border:1px solid var(--s-date-strip-item-border-color);background:var(--s-date-strip-item-bg);cursor:pointer}.s-date-strip__item-week{font-size:var(--s-date-strip-item-week-font-size);color:var(--s-date-strip-item-week-color);order:var(--s-date-strip-item-week-order)}.s-date-strip__item-day{font-size:var(--s-date-strip-item-day-font-size);color:var(--s-date-strip-item-day-color);order:var(--s-date-strip-item-day-order)}.s-date-strip__item-info{font-size:var(--s-date-strip-item-info-font-size);color:var(--s-date-strip-item-info-color);order:var(--s-date-strip-item-info-order)}.s-date-strip__item--today{color:var(--s-date-strip-item-color-today)}.s-date-strip__item--selected,.s-date-strip__item--start,.s-date-strip__item--end,.s-date-strip__item--same{color:var(--s-date-strip-item-color-selected);border-color:rgba(0,0,0,0);background:var(--s-date-strip-item-bg-selected)}.s-date-strip__item--middle{border-color:rgba(0,0,0,0);background:var(--s-date-strip-item-bg-middle)}.s-date-strip__item--disabled{color:var(--s-text-color-disabled);cursor:var(--s-cursor-disabled)}.s-date-strip__item--selected .s-date-strip__item-week,.s-date-strip__item--selected .s-date-strip__item-info,.s-date-strip__item--selected .s-date-strip__item-day,.s-date-strip__item--start .s-date-strip__item-week,.s-date-strip__item--start .s-date-strip__item-info,.s-date-strip__item--start .s-date-strip__item-day,.s-date-strip__item--end .s-date-strip__item-week,.s-date-strip__item--end .s-date-strip__item-info,.s-date-strip__item--end .s-date-strip__item-day,.s-date-strip__item--same .s-date-strip__item-week,.s-date-strip__item--same .s-date-strip__item-info,.s-date-strip__item--same .s-date-strip__item-day,.s-date-strip__item--disabled .s-date-strip__item-week,.s-date-strip__item--disabled .s-date-strip__item-info,.s-date-strip__item--disabled .s-date-strip__item-day,.s-date-strip__item--today .s-date-strip__item-week,.s-date-strip__item--today .s-date-strip__item-info,.s-date-strip__item--today .s-date-strip__item-day{color:inherit}

package/components/date-strip/index.d.ts

@@ -0,0 +1,6 @@
+import { type EnhancedComponent } from '../../utils';
+import _DateStrip from './date-strip.vue';
+export declare const DateStrip: EnhancedComponent<typeof _DateStrip>;
+export default DateStrip;
+export type { CalendarDay, CalendarType } from '../calendar';
+export type { DateStripProps, DateStripEmits } from './common';

package/components/date-strip/index.js

@@ -0,0 +1,6 @@
+import { enhanceComponent } from "../../utils/component.js";
+import date_strip_default from "./date-strip.js";
+//#region packages/sard/components/date-strip/index.ts
+const DateStrip = enhanceComponent(date_strip_default);
+//#endregion
+export { DateStrip, DateStrip as default };

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

@@ -0,0 +1,49 @@
+import { type DefaultProps } from '../config';
+import { type PickerSlots } from '../picker/common';
+export interface DatetimePickerProps {
+    type?: string;
+    calendar?: 'solar' | 'lunar';
+    min?: Date | string;
+    max?: Date | string;
+    modelValue?: Date | string;
+    filter?: (letter: DatetimeLetter, value: number, date: Date, index: number) => boolean;
+    formatter?: (letter: DatetimeLetter, option: DatetimeColumnOption, date: Date, index: number) => string | void | undefined;
+    valueFormat?: string;
+}
+export declare const defaultDatetimePickerProps: DefaultProps<DatetimePickerProps>;
+export interface DatetimePickerSlots extends PickerSlots<number> {
+}
+export interface DatetimePickerEmits {
+    (e: 'update:modelValue', date: Date | string): void;
+    (e: 'change', date: Date | string): void;
+}
+export interface DatetimeColumnOption {
+    value: number;
+    label?: string;
+    zerofill?: string;
+    [key: PropertyKey]: any;
+}
+export type DatetimeLetter = 'y' | 'M' | 'd' | 'h' | 'm' | 's';
+export type DateEvery = [number, number, number, number, number, number];
+export declare const getMinDate: () => Date;
+export declare const getMaxDate: () => Date;
+interface Strategies {
+    [p: string]: [
+        index: number,
+        length: number,
+        min: number | null,
+        max: number | null,
+        getter: (date: Date) => number,
+        setter: (date: Date, value: number) => number
+    ];
+}
+export declare const strategies: Strategies;
+export declare const letterArray: DatetimeLetter[];
+export declare function getBoundaryValue(calendar: 'solar' | 'lunar', isMax: boolean, endDate: Date, currentDate: Date): number[];
+export declare function correctSolarDate(date: DateEvery, minDate: Date, maxDate: Date): void;
+export declare function correctLunarDate(date: DateEvery, minDate: Date, maxDate: Date): void;
+export declare function correctDate(calendar: 'solar' | 'lunar', date: DateEvery, minDate: Date, maxDate: Date): void;
+export declare const getColumnData: (calendar: "solar" | "lunar", min: number, max: number, length: number, letter: DatetimeLetter, currentDate: Date, translate: (...args: any[]) => any, filter?: (letter: DatetimeLetter, value: number, date: Date, index: number) => boolean, formatter?: (letter: DatetimeLetter, option: DatetimeColumnOption, date: Date, index: number) => string | void | undefined) => DatetimeColumnOption[];
+export declare function getInitialValue(minDate: Date, maxDate: Date): Date;
+export declare const normalizeRangeValue: (minDate: Date, maxDate: Date, value?: (string | Date)[], valueFormat?: string) => (string | Date)[];
+export {};

package/components/datetime-picker/common.js

@@ -0,0 +1,233 @@
+import { clamp } from "../../utils/number.js";
+import { formatDate, getDaysInMonth, getLunarDayName, getLunarLeapMonth, getLunarLeapMonthDays, getLunarMonthDays, getLunarMonthName, solarToLunar, toDate } from "../../utils/date.js";
+import { isDate } from "../../utils/is.js";
+//#region packages/sard/components/datetime-picker/common.ts
+const defaultDatetimePickerProps = {
+	type: "yMd",
+	calendar: "solar"
+};
+const getMinDate = () => {
+	return new Date((/* @__PURE__ */ new Date()).getFullYear() - 10, 0, 1, 0, 0, 0);
+};
+const getMaxDate = () => {
+	return new Date((/* @__PURE__ */ new Date()).getFullYear() + 10, 11, 31, 23, 59, 59);
+};
+const strategies = {
+	y: [
+		0,
+		4,
+		0,
+		0,
+		(d) => d.getFullYear(),
+		(d, val) => d.setFullYear(val)
+	],
+	M: [
+		1,
+		2,
+		1,
+		12,
+		(d) => d.getMonth() + 1,
+		(d, val) => d.setMonth(val - 1)
+	],
+	d: [
+		2,
+		2,
+		1,
+		31,
+		(d) => d.getDate(),
+		(d, val) => d.setDate(val)
+	],
+	h: [
+		3,
+		2,
+		0,
+		23,
+		(d) => d.getHours(),
+		(d, val) => d.setHours(val)
+	],
+	m: [
+		4,
+		2,
+		0,
+		59,
+		(d) => d.getMinutes(),
+		(d, val) => d.setMinutes(val)
+	],
+	s: [
+		5,
+		2,
+		0,
+		59,
+		(d) => d.getSeconds(),
+		(d, val) => d.setSeconds(val)
+	]
+};
+const letterArray = [
+	"y",
+	"M",
+	"d",
+	"h",
+	"m",
+	"s"
+];
+function getSolarBoundaryValue(isMax, endDate, currentDate) {
+	const currEvery = [endDate.getFullYear()];
+	const minOrMaxIndex = isMax ? 3 : 2;
+	let aside = true;
+	let prevGetter = strategies.y[4];
+	letterArray.slice(1).forEach((letter, index) => {
+		const strategy = strategies[letter];
+		let minOrMax = strategy[minOrMaxIndex];
+		if (isMax && letter === "d") minOrMax = getDaysInMonth(currentDate.getFullYear(), currentDate.getMonth());
+		aside = aside && currEvery[index] === prevGetter(currentDate);
+		currEvery[index + 1] = aside ? strategy[4](endDate) : minOrMax;
+		prevGetter = strategy[4];
+	});
+	return currEvery;
+}
+function getLunarBoundaryValue(isMax, endDate, currentDate) {
+	const lunarDate = solarToLunar(currentDate.getFullYear(), currentDate.getMonth() + 1, currentDate.getDate());
+	const lunarEndDate = solarToLunar(endDate.getFullYear(), endDate.getMonth() + 1, endDate.getDate());
+	const currEvery = [lunarEndDate.year];
+	const minOrMaxIndex = isMax ? 3 : 2;
+	let aside = true;
+	let prevGetter = strategies.y[4];
+	letterArray.slice(1).forEach((letter, index) => {
+		const prevValue = currEvery[index];
+		const strategy = strategies[letter];
+		const currGetter = strategy[4];
+		let minOrMax = strategy[minOrMaxIndex];
+		if (isMax && letter === "d") minOrMax = lunarDate.month < 0 ? getLunarLeapMonthDays(lunarDate.year) : getLunarMonthDays(lunarDate.year, lunarDate.month);
+		let asideValue = 0;
+		if (aside) if (letter === "M") {
+			aside = lunarDate.year === prevValue;
+			if (aside) asideValue = lunarEndDate.month;
+		} else if (letter === "d") {
+			aside = lunarDate.month === prevValue;
+			if (aside) asideValue = lunarEndDate.day;
+		} else {
+			aside = prevGetter(currentDate) === prevValue;
+			if (aside) asideValue = currGetter(currentDate);
+		}
+		currEvery[index + 1] = aside ? asideValue : minOrMax;
+		prevGetter = currGetter;
+	});
+	return currEvery;
+}
+function getBoundaryValue(calendar, isMax, endDate, currentDate) {
+	return calendar === "solar" ? getSolarBoundaryValue(isMax, endDate, currentDate) : getLunarBoundaryValue(isMax, endDate, currentDate);
+}
+function correctSolarDate(date, minDate, maxDate) {
+	let minAside = true;
+	let maxAside = true;
+	let prevGetter = strategies.y[4];
+	letterArray.slice(1).forEach((letter, index) => {
+		const strategy = strategies[letter];
+		let minValue = strategy[2];
+		let maxValue = strategy[3];
+		if (letter === "d") maxValue = getDaysInMonth(date[0], date[1] - 1);
+		const currGetter = strategy[4];
+		if (minAside = minAside && prevGetter(minDate) === date[index]) minValue = currGetter(minDate);
+		if (maxAside = maxAside && prevGetter(maxDate) === date[index]) maxValue = currGetter(maxDate);
+		date[index + 1] = clamp(date[index + 1], minValue, maxValue);
+		prevGetter = currGetter;
+	});
+}
+function correctLunarDate(date, minDate, maxDate) {
+	const lunarMinDate = solarToLunar(minDate.getFullYear(), minDate.getMonth() + 1, minDate.getDate());
+	const lunarMaxDate = solarToLunar(maxDate.getFullYear(), maxDate.getMonth() + 1, maxDate.getDate());
+	const range = [{
+		value: 0,
+		edge: true,
+		date: minDate,
+		lunarDate: lunarMinDate
+	}, {
+		value: 0,
+		edge: true,
+		date: maxDate,
+		lunarDate: lunarMaxDate
+	}];
+	let prevGetter = strategies.y[4];
+	letterArray.slice(1).forEach((letter, index) => {
+		const prevValue = date[index];
+		const currIndex = index + 1;
+		const currValue = date[currIndex];
+		const strategy = strategies[letter];
+		range[0].value = strategy[2];
+		range[1].value = strategy[3];
+		if (letter === "d") range[1].value = date[1] < 0 ? getLunarLeapMonthDays(date[0]) : getLunarMonthDays(date[0], date[1]);
+		let currGetter = strategy[4];
+		range.forEach((point) => {
+			if (point.edge) if (letter === "M") {
+				point.edge = point.lunarDate.year === prevValue;
+				if (point.edge) point.value = point.lunarDate.month;
+			} else if (letter === "d") {
+				point.edge = point.lunarDate.month === prevValue;
+				if (point.edge) point.value = point.lunarDate.day;
+			} else {
+				point.edge = prevGetter(point.date) === prevValue;
+				if (point.edge) point.value = currGetter(point.date);
+			}
+		});
+		if (letter === "M") {
+			let min = range[0].value;
+			let max = range[1].value;
+			let value = currValue;
+			if (min < 0) min = Math.abs(min) + .5;
+			else if (max < 0) max = Math.abs(max) + .5;
+			if (value < 0) value = Math.abs(value) + .5;
+			value = clamp(value, min, max);
+			date[currIndex] = value % 1 === .5 ? ~~value * -1 : value;
+		} else date[currIndex] = clamp(currValue, range[0].value, range[1].value);
+		if (letter === "d") currGetter = (date) => {
+			return date === minDate ? lunarMinDate.day : lunarMaxDate.day;
+		};
+		prevGetter = currGetter;
+	});
+}
+function correctDate(calendar, date, minDate, maxDate) {
+	if (calendar === "solar") correctSolarDate(date, minDate, maxDate);
+	else correctLunarDate(date, minDate, maxDate);
+}
+const getColumnData = (calendar, min, max, length, letter, currentDate, translate, filter, formatter) => {
+	const lunarDate = solarToLunar(currentDate.getFullYear(), currentDate.getMonth() + 1, currentDate.getDate());
+	let column = Array(Math.abs(max) - Math.abs(min) + 1).fill(0).map((_, i) => ({ value: i + Math.abs(min) }));
+	if (calendar === "lunar" && letter === "M") if (min < 0) column[0].value = min;
+	else if (max < 0) column.push({ value: max });
+	else {
+		const leapMonth = getLunarLeapMonth(lunarDate.year);
+		if (leapMonth > 0 && leapMonth > min && leapMonth < max) column.splice(column.findIndex((item) => item.value === leapMonth) + 1, 0, { value: -leapMonth });
+	}
+	if (filter) column = column.filter((option, i) => filter(letter, option.value, currentDate, i));
+	column.forEach((option) => {
+		option.zerofill = String(option.value).padStart(length, "0");
+		if (calendar === "solar") option.label = option.zerofill + translate(letter);
+		else switch (letter) {
+			case "M":
+				option.label = getLunarMonthName(Math.abs(option.value), option.value < 0);
+				break;
+			case "d":
+				option.label = getLunarDayName(option.value);
+				break;
+			default:
+				option.label = option.zerofill + translate(letter);
+				break;
+		}
+	});
+	if (formatter) column.forEach((option, i) => {
+		option.label = formatter(letter, option, currentDate, i) ?? option.label;
+	});
+	return column;
+};
+function getInitialValue(minDate, maxDate) {
+	const value = /* @__PURE__ */ new Date();
+	return value.getTime() < minDate.getTime() ? new Date(minDate) : value.getTime() > maxDate.getTime() ? new Date(maxDate) : value;
+}
+const normalizeRangeValue = (minDate, maxDate, value, valueFormat) => {
+	const [start, end] = value || [];
+	const startValue = start || getInitialValue(minDate, maxDate);
+	const endValue = end || getInitialValue(toDate(startValue, valueFormat), maxDate);
+	return [valueFormat && isDate(startValue) ? formatDate(startValue, valueFormat) : startValue, valueFormat && isDate(endValue) ? formatDate(endValue, valueFormat) : endValue];
+};
+//#endregion
+export { correctDate, correctLunarDate, correctSolarDate, defaultDatetimePickerProps, getBoundaryValue, getColumnData, getInitialValue, getMaxDate, getMinDate, letterArray, normalizeRangeValue, strategies };

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

@@ -0,0 +1,26 @@
+import { type DatetimePickerProps, type DatetimePickerSlots, type DatetimeLetter, type DatetimeColumnOption } from './common';
+type __VLS_Slots = DatetimePickerSlots;
+declare const __VLS_base: import("vue").DefineComponent<DatetimePickerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    change: (date: string | Date) => any;
+    "update:modelValue": (date: string | Date) => any;
+}, string, import("vue").PublicProps, Readonly<DatetimePickerProps> & Readonly<{
+    onChange?: ((date: string | Date) => any) | undefined;
+    "onUpdate:modelValue"?: ((date: string | Date) => any) | undefined;
+}>, {
+    filter: (letter: DatetimeLetter, value: number, date: Date, index: number) => boolean;
+    min: Date | string;
+    max: Date | string;
+    type: string;
+    modelValue: Date | string;
+    formatter: (letter: DatetimeLetter, option: DatetimeColumnOption, date: Date, index: number) => string | void | undefined;
+    valueFormat: string;
+    calendar: "solar" | "lunar";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};