@v-c/picker 0.0.1

package/dist/PickerTrigger/index.js

@@ -0,0 +1,130 @@
+import { usePickerContext } from "../PickerInput/context.js";
+import { getRealPlacement } from "../utils/uiUtil.js";
+import { computed, createVNode, defineComponent } from "vue";
+import { clsx } from "@v-c/util";
+import Trigger from "@v-c/trigger";
+var BUILT_IN_PLACEMENTS = {
+	bottomLeft: {
+		points: ["tl", "bl"],
+		offset: [0, 4],
+		overflow: {
+			adjustX: 1,
+			adjustY: 1
+		}
+	},
+	bottomRight: {
+		points: ["tr", "br"],
+		offset: [0, 4],
+		overflow: {
+			adjustX: 1,
+			adjustY: 1
+		}
+	},
+	topLeft: {
+		points: ["bl", "tl"],
+		offset: [0, -4],
+		overflow: {
+			adjustX: 0,
+			adjustY: 1
+		}
+	},
+	topRight: {
+		points: ["br", "tr"],
+		offset: [0, -4],
+		overflow: {
+			adjustX: 0,
+			adjustY: 1
+		}
+	}
+};
+var PickerTrigger_default = /* @__PURE__ */ defineComponent((props, { slots }) => {
+	const ctx = usePickerContext();
+	const dropdownPrefixCls = computed(() => `${ctx.value.prefixCls}-dropdown`);
+	const realPlacement = computed(() => getRealPlacement(props.placement, props.direction === "rtl"));
+	return () => createVNode(Trigger, {
+		"showAction": [],
+		"hideAction": ["click"],
+		"popupPlacement": realPlacement.value,
+		"builtinPlacements": props.builtinPlacements || BUILT_IN_PLACEMENTS,
+		"prefixCls": dropdownPrefixCls.value,
+		"popupMotion": props.transitionName ? { motionName: props.transitionName } : void 0,
+		"popup": props.popupElement,
+		"popupAlign": props.popupAlign,
+		"popupVisible": props.visible,
+		"popupClassName": clsx(props.popupClassName, {
+			[`${dropdownPrefixCls.value}-range`]: props.range,
+			[`${dropdownPrefixCls.value}-rtl`]: props.direction === "rtl"
+		}),
+		"popupStyle": props.popupStyle,
+		"stretch": "minWidth",
+		"getPopupContainer": props.getPopupContainer,
+		"onPopupVisibleChange": (nextVisible) => {
+			if (!nextVisible) props.onClose?.();
+		}
+	}, { default: () => [slots.default?.()] });
+}, {
+	props: {
+		popupElement: {
+			required: false,
+			default: void 0
+		},
+		popupStyle: {
+			type: Object,
+			required: false,
+			default: void 0
+		},
+		transitionName: {
+			type: String,
+			required: false,
+			default: void 0
+		},
+		getPopupContainer: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		popupAlign: {
+			type: Object,
+			required: false,
+			default: void 0
+		},
+		range: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		popupClassName: {
+			type: String,
+			required: false,
+			default: void 0
+		},
+		placement: {
+			type: String,
+			required: false,
+			default: void 0
+		},
+		builtinPlacements: {
+			type: Object,
+			required: false,
+			default: void 0
+		},
+		direction: {
+			type: String,
+			required: false,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		onClose: {
+			type: Function,
+			required: false,
+			default: void 0
+		}
+	},
+	name: "PickerTrigger",
+	inheritAttrs: false
+});
+export { PickerTrigger_default as default };

package/dist/PickerTrigger/util.cjs

@@ -0,0 +1,13 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_miscUtil = require("../utils/miscUtil.cjs");
+function pickTriggerProps(props) {
+	return require_miscUtil.pickProps(props, [
+		"placement",
+		"builtinPlacements",
+		"popupAlign",
+		"getPopupContainer",
+		"transitionName",
+		"direction"
+	]);
+}
+exports.pickTriggerProps = pickTriggerProps;

package/dist/PickerTrigger/util.d.ts

@@ -0,0 +1,2 @@
+import { SharedPickerProps } from '../interface';
+export declare function pickTriggerProps(props: Omit<SharedPickerProps, 'showTime'>): Omit<SharedPickerProps<any>, "showTime">;

package/dist/PickerTrigger/util.js

@@ -0,0 +1,12 @@
+import { pickProps } from "../utils/miscUtil.js";
+function pickTriggerProps(props) {
+	return pickProps(props, [
+		"placement",
+		"builtinPlacements",
+		"popupAlign",
+		"getPopupContainer",
+		"transitionName",
+		"direction"
+	]);
+}
+export { pickTriggerProps };

package/dist/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,21 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+exports.__toESM = __toESM;

package/dist/generate/dateFns.cjs

@@ -0,0 +1,80 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_rolldown_runtime = require("../_virtual/rolldown_runtime.cjs");
+let date_fns = require("date-fns");
+let date_fns_locale = require("date-fns/locale");
+date_fns_locale = require_rolldown_runtime.__toESM(date_fns_locale);
+function getLocale(locale) {
+	const tmpLocales = date_fns_locale;
+	return tmpLocales[locale] || tmpLocales[locale.replace(/_/g, "")] || tmpLocales[locale.replace(/_.*$/g, "")];
+}
+function localeParse(format) {
+	return format.replace(/Y/g, "y").replace(/D/g, "d").replace(/gggg/, "yyyy").replace(/g/g, "G").replace(/([Ww])o/g, "wo");
+}
+function parse(text, format, locale) {
+	return (0, date_fns.parse)(text, localeParse(format), /* @__PURE__ */ new Date(), { locale: getLocale(locale) });
+}
+function isStrictValidDate(text, format, locale) {
+	const date = parse(text, format, locale);
+	if (!(0, date_fns.isValid)(date)) return false;
+	return text === (0, date_fns.format)(date, format, { locale: getLocale(locale) });
+}
+var generateConfig = {
+	getNow: () => /* @__PURE__ */ new Date(),
+	getFixedDate: (string) => new Date(string),
+	getEndDate: (date) => (0, date_fns.endOfMonth)(date),
+	getWeekDay: (date) => (0, date_fns.getDay)(date),
+	getYear: (date) => (0, date_fns.getYear)(date),
+	getMonth: (date) => (0, date_fns.getMonth)(date),
+	getDate: (date) => (0, date_fns.getDate)(date),
+	getHour: (date) => (0, date_fns.getHours)(date),
+	getMinute: (date) => (0, date_fns.getMinutes)(date),
+	getSecond: (date) => (0, date_fns.getSeconds)(date),
+	getMillisecond: (date) => (0, date_fns.getMilliseconds)(date),
+	addYear: (date, diff) => (0, date_fns.addYears)(date, diff),
+	addMonth: (date, diff) => (0, date_fns.addMonths)(date, diff),
+	addDate: (date, diff) => (0, date_fns.addDays)(date, diff),
+	setYear: (date, year) => (0, date_fns.setYear)(date, year),
+	setMonth: (date, month) => (0, date_fns.setMonth)(date, month),
+	setDate: (date, num) => (0, date_fns.setDate)(date, num),
+	setHour: (date, hour) => (0, date_fns.setHours)(date, hour),
+	setMinute: (date, minute) => (0, date_fns.setMinutes)(date, minute),
+	setSecond: (date, second) => (0, date_fns.setSeconds)(date, second),
+	setMillisecond: (date, millisecond) => (0, date_fns.setMilliseconds)(date, millisecond),
+	isAfter: (date1, date2) => (0, date_fns.isAfter)(date1, date2),
+	isValidate: (date) => (0, date_fns.isValid)(date),
+	locale: {
+		getWeekFirstDay: (locale) => {
+			return getLocale(locale).options?.weekStartsOn;
+		},
+		getWeekFirstDate: (locale, date) => {
+			return (0, date_fns.startOfWeek)(date, { locale: getLocale(locale) });
+		},
+		getWeek: (locale, date) => {
+			return (0, date_fns.getWeek)(date, { locale: getLocale(locale) });
+		},
+		getShortWeekDays: (locale) => {
+			const clone = getLocale(locale);
+			return Array.from({ length: 7 }).map((_, i) => clone.localize.day(i, { width: "short" }));
+		},
+		getShortMonths: (locale) => {
+			const clone = getLocale(locale);
+			return Array.from({ length: 12 }).map((_, i) => clone.localize.month(i, { width: "abbreviated" }));
+		},
+		format: (locale, date, format) => {
+			if (!(0, date_fns.isValid)(date)) return null;
+			return (0, date_fns.format)(date, localeParse(format), { locale: getLocale(locale) });
+		},
+		parse: (locale, text, formats) => {
+			for (let i = 0; i < formats.length; i += 1) {
+				const format = localeParse(formats[i]);
+				if (isStrictValidDate(text, format, locale)) return parse(text, format, locale);
+			}
+			return null;
+		}
+	}
+};
+var dateFns_default = generateConfig;
+exports.default = dateFns_default;

package/dist/generate/dateFns.d.ts

@@ -0,0 +1,3 @@
+import { GenerateConfig } from './index';
+declare const generateConfig: GenerateConfig<Date>;
+export default generateConfig;

package/dist/generate/dateFns.js

@@ -0,0 +1,73 @@
+import { addDays, addMonths, addYears, endOfMonth, format, getDate, getDay, getHours, getMilliseconds, getMinutes, getMonth, getSeconds, getWeek, getYear, isAfter, isValid, parse, setDate, setHours, setMilliseconds, setMinutes, setMonth, setSeconds, setYear, startOfWeek } from "date-fns";
+import * as locales from "date-fns/locale";
+function getLocale(locale) {
+	const tmpLocales = locales;
+	return tmpLocales[locale] || tmpLocales[locale.replace(/_/g, "")] || tmpLocales[locale.replace(/_.*$/g, "")];
+}
+function localeParse(format$1) {
+	return format$1.replace(/Y/g, "y").replace(/D/g, "d").replace(/gggg/, "yyyy").replace(/g/g, "G").replace(/([Ww])o/g, "wo");
+}
+function parse$1(text, format$1, locale) {
+	return parse(text, localeParse(format$1), /* @__PURE__ */ new Date(), { locale: getLocale(locale) });
+}
+function isStrictValidDate(text, format$1, locale) {
+	const date = parse$1(text, format$1, locale);
+	if (!isValid(date)) return false;
+	return text === format(date, format$1, { locale: getLocale(locale) });
+}
+var dateFns_default = {
+	getNow: () => /* @__PURE__ */ new Date(),
+	getFixedDate: (string) => new Date(string),
+	getEndDate: (date) => endOfMonth(date),
+	getWeekDay: (date) => getDay(date),
+	getYear: (date) => getYear(date),
+	getMonth: (date) => getMonth(date),
+	getDate: (date) => getDate(date),
+	getHour: (date) => getHours(date),
+	getMinute: (date) => getMinutes(date),
+	getSecond: (date) => getSeconds(date),
+	getMillisecond: (date) => getMilliseconds(date),
+	addYear: (date, diff) => addYears(date, diff),
+	addMonth: (date, diff) => addMonths(date, diff),
+	addDate: (date, diff) => addDays(date, diff),
+	setYear: (date, year) => setYear(date, year),
+	setMonth: (date, month) => setMonth(date, month),
+	setDate: (date, num) => setDate(date, num),
+	setHour: (date, hour) => setHours(date, hour),
+	setMinute: (date, minute) => setMinutes(date, minute),
+	setSecond: (date, second) => setSeconds(date, second),
+	setMillisecond: (date, millisecond) => setMilliseconds(date, millisecond),
+	isAfter: (date1, date2) => isAfter(date1, date2),
+	isValidate: (date) => isValid(date),
+	locale: {
+		getWeekFirstDay: (locale) => {
+			return getLocale(locale).options?.weekStartsOn;
+		},
+		getWeekFirstDate: (locale, date) => {
+			return startOfWeek(date, { locale: getLocale(locale) });
+		},
+		getWeek: (locale, date) => {
+			return getWeek(date, { locale: getLocale(locale) });
+		},
+		getShortWeekDays: (locale) => {
+			const clone = getLocale(locale);
+			return Array.from({ length: 7 }).map((_, i) => clone.localize.day(i, { width: "short" }));
+		},
+		getShortMonths: (locale) => {
+			const clone = getLocale(locale);
+			return Array.from({ length: 12 }).map((_, i) => clone.localize.month(i, { width: "abbreviated" }));
+		},
+		format: (locale, date, format$1) => {
+			if (!isValid(date)) return null;
+			return format(date, localeParse(format$1), { locale: getLocale(locale) });
+		},
+		parse: (locale, text, formats) => {
+			for (let i = 0; i < formats.length; i += 1) {
+				const format$1 = localeParse(formats[i]);
+				if (isStrictValidDate(text, format$1, locale)) return parse$1(text, format$1, locale);
+			}
+			return null;
+		}
+	}
+};
+export { dateFns_default as default };

package/dist/generate/dayjs.cjs

@@ -0,0 +1,117 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_rolldown_runtime = require("../_virtual/rolldown_runtime.cjs");
+let dayjs_esm = require("dayjs/esm");
+dayjs_esm = require_rolldown_runtime.__toESM(dayjs_esm);
+let dayjs_esm_plugin_advancedFormat_index = require("dayjs/esm/plugin/advancedFormat/index");
+dayjs_esm_plugin_advancedFormat_index = require_rolldown_runtime.__toESM(dayjs_esm_plugin_advancedFormat_index);
+let dayjs_esm_plugin_customParseFormat_index = require("dayjs/esm/plugin/customParseFormat/index");
+dayjs_esm_plugin_customParseFormat_index = require_rolldown_runtime.__toESM(dayjs_esm_plugin_customParseFormat_index);
+let dayjs_esm_plugin_localeData_index = require("dayjs/esm/plugin/localeData/index");
+dayjs_esm_plugin_localeData_index = require_rolldown_runtime.__toESM(dayjs_esm_plugin_localeData_index);
+let dayjs_esm_plugin_weekday_index = require("dayjs/esm/plugin/weekday/index");
+dayjs_esm_plugin_weekday_index = require_rolldown_runtime.__toESM(dayjs_esm_plugin_weekday_index);
+let dayjs_esm_plugin_weekOfYear_index = require("dayjs/esm/plugin/weekOfYear/index");
+dayjs_esm_plugin_weekOfYear_index = require_rolldown_runtime.__toESM(dayjs_esm_plugin_weekOfYear_index);
+let dayjs_esm_plugin_weekYear_index = require("dayjs/esm/plugin/weekYear/index");
+dayjs_esm_plugin_weekYear_index = require_rolldown_runtime.__toESM(dayjs_esm_plugin_weekYear_index);
+dayjs_esm.default.extend(dayjs_esm_plugin_customParseFormat_index.default);
+dayjs_esm.default.extend(dayjs_esm_plugin_advancedFormat_index.default);
+dayjs_esm.default.extend(dayjs_esm_plugin_weekday_index.default);
+dayjs_esm.default.extend(dayjs_esm_plugin_localeData_index.default);
+dayjs_esm.default.extend(dayjs_esm_plugin_weekOfYear_index.default);
+dayjs_esm.default.extend(dayjs_esm_plugin_weekYear_index.default);
+dayjs_esm.default.extend((_, c) => {
+	const proto = c.prototype;
+	const oldFormat = proto.format;
+	proto.format = function f(formatStr) {
+		const str = (formatStr || "").replace("Wo", "wo");
+		return oldFormat.bind(this)(str);
+	};
+});
+var localeMap = {
+	bn_BD: "bn-bd",
+	by_BY: "be",
+	en_GB: "en-gb",
+	en_US: "en",
+	fr_BE: "fr",
+	fr_CA: "fr-ca",
+	hy_AM: "hy-am",
+	kmr_IQ: "ku",
+	nl_BE: "nl-be",
+	pt_BR: "pt-br",
+	zh_CN: "zh-cn",
+	zh_HK: "zh-hk",
+	zh_TW: "zh-tw"
+};
+function parseLocale(locale) {
+	return localeMap[locale] || locale.split("_")[0];
+}
+/* istanbul ignore next */
+function parseNoMatchNotice() {}
+var generateConfig = {
+	getNow: () => {
+		const now = (0, dayjs_esm.default)();
+		if ("tz" in now && typeof now.tz === "function") return now.tz();
+		return now;
+	},
+	getFixedDate: (string) => (0, dayjs_esm.default)(string, ["YYYY-M-DD", "YYYY-MM-DD"]),
+	getEndDate: (date) => date.endOf("month"),
+	getWeekDay: (date) => {
+		const clone = date.locale("en");
+		return clone.weekday() + clone.localeData().firstDayOfWeek();
+	},
+	getYear: (date) => date.year(),
+	getMonth: (date) => date.month(),
+	getDate: (date) => date.date(),
+	getHour: (date) => date.hour(),
+	getMinute: (date) => date.minute(),
+	getSecond: (date) => date.second(),
+	getMillisecond: (date) => date.millisecond(),
+	addYear: (date, diff) => date.add(diff, "year"),
+	addMonth: (date, diff) => date.add(diff, "month"),
+	addDate: (date, diff) => date.add(diff, "day"),
+	setYear: (date, year) => date.year(year),
+	setMonth: (date, month) => date.month(month),
+	setDate: (date, num) => date.date(num),
+	setHour: (date, hour) => date.hour(hour),
+	setMinute: (date, minute) => date.minute(minute),
+	setSecond: (date, second) => date.second(second),
+	setMillisecond: (date, milliseconds) => date.millisecond(milliseconds),
+	isAfter: (date1, date2) => date1.isAfter(date2),
+	isValidate: (date) => date.isValid(),
+	locale: {
+		getWeekFirstDay: (locale) => (0, dayjs_esm.default)().locale(parseLocale(locale)).localeData().firstDayOfWeek(),
+		getWeekFirstDate: (locale, date) => date.locale(parseLocale(locale)).weekday(0),
+		getWeek: (locale, date) => date.locale(parseLocale(locale)).week(),
+		getShortWeekDays: (locale) => (0, dayjs_esm.default)().locale(parseLocale(locale)).localeData().weekdaysMin(),
+		getShortMonths: (locale) => (0, dayjs_esm.default)().locale(parseLocale(locale)).localeData().monthsShort(),
+		format: (locale, date, format) => date.locale(parseLocale(locale)).format(format),
+		parse: (locale, text, formats) => {
+			const localeStr = parseLocale(locale);
+			for (let i = 0; i < formats.length; i += 1) {
+				const format = formats[i];
+				const formatText = text;
+				if (format.includes("wo") || format.includes("Wo")) {
+					const year = formatText.split("-")[0];
+					const weekStr = formatText.split("-")[1];
+					const firstWeek = (0, dayjs_esm.default)(year, "YYYY").startOf("year").locale(localeStr);
+					for (let j = 0; j <= 52; j += 1) {
+						const nextWeek = firstWeek.add(j, "week");
+						if (nextWeek.format("Wo") === weekStr) return nextWeek;
+					}
+					parseNoMatchNotice();
+					return null;
+				}
+				const date = (0, dayjs_esm.default)(formatText, format, true).locale(localeStr);
+				if (date.isValid()) return date;
+			}
+			if (text) parseNoMatchNotice();
+			return null;
+		}
+	}
+};
+var dayjs_default = generateConfig;
+exports.default = dayjs_default;

package/dist/generate/dayjs.d.ts

@@ -0,0 +1,4 @@
+import { Dayjs } from 'dayjs';
+import { GenerateConfig } from '.';
+declare const generateConfig: GenerateConfig<Dayjs>;
+export default generateConfig;

package/dist/generate/dayjs.js

@@ -0,0 +1,104 @@
+import dayjs from "dayjs/esm";
+import advancedFormat from "dayjs/esm/plugin/advancedFormat/index";
+import customParseFormat from "dayjs/esm/plugin/customParseFormat/index";
+import localeData from "dayjs/esm/plugin/localeData/index";
+import weekday from "dayjs/esm/plugin/weekday/index";
+import weekOfYear from "dayjs/esm/plugin/weekOfYear/index";
+import weekYear from "dayjs/esm/plugin/weekYear/index";
+dayjs.extend(customParseFormat);
+dayjs.extend(advancedFormat);
+dayjs.extend(weekday);
+dayjs.extend(localeData);
+dayjs.extend(weekOfYear);
+dayjs.extend(weekYear);
+dayjs.extend((_, c) => {
+	const proto = c.prototype;
+	const oldFormat = proto.format;
+	proto.format = function f(formatStr) {
+		const str = (formatStr || "").replace("Wo", "wo");
+		return oldFormat.bind(this)(str);
+	};
+});
+var localeMap = {
+	bn_BD: "bn-bd",
+	by_BY: "be",
+	en_GB: "en-gb",
+	en_US: "en",
+	fr_BE: "fr",
+	fr_CA: "fr-ca",
+	hy_AM: "hy-am",
+	kmr_IQ: "ku",
+	nl_BE: "nl-be",
+	pt_BR: "pt-br",
+	zh_CN: "zh-cn",
+	zh_HK: "zh-hk",
+	zh_TW: "zh-tw"
+};
+function parseLocale(locale) {
+	return localeMap[locale] || locale.split("_")[0];
+}
+/* istanbul ignore next */
+function parseNoMatchNotice() {}
+var dayjs_default = {
+	getNow: () => {
+		const now = dayjs();
+		if ("tz" in now && typeof now.tz === "function") return now.tz();
+		return now;
+	},
+	getFixedDate: (string) => dayjs(string, ["YYYY-M-DD", "YYYY-MM-DD"]),
+	getEndDate: (date) => date.endOf("month"),
+	getWeekDay: (date) => {
+		const clone = date.locale("en");
+		return clone.weekday() + clone.localeData().firstDayOfWeek();
+	},
+	getYear: (date) => date.year(),
+	getMonth: (date) => date.month(),
+	getDate: (date) => date.date(),
+	getHour: (date) => date.hour(),
+	getMinute: (date) => date.minute(),
+	getSecond: (date) => date.second(),
+	getMillisecond: (date) => date.millisecond(),
+	addYear: (date, diff) => date.add(diff, "year"),
+	addMonth: (date, diff) => date.add(diff, "month"),
+	addDate: (date, diff) => date.add(diff, "day"),
+	setYear: (date, year) => date.year(year),
+	setMonth: (date, month) => date.month(month),
+	setDate: (date, num) => date.date(num),
+	setHour: (date, hour) => date.hour(hour),
+	setMinute: (date, minute) => date.minute(minute),
+	setSecond: (date, second) => date.second(second),
+	setMillisecond: (date, milliseconds) => date.millisecond(milliseconds),
+	isAfter: (date1, date2) => date1.isAfter(date2),
+	isValidate: (date) => date.isValid(),
+	locale: {
+		getWeekFirstDay: (locale) => dayjs().locale(parseLocale(locale)).localeData().firstDayOfWeek(),
+		getWeekFirstDate: (locale, date) => date.locale(parseLocale(locale)).weekday(0),
+		getWeek: (locale, date) => date.locale(parseLocale(locale)).week(),
+		getShortWeekDays: (locale) => dayjs().locale(parseLocale(locale)).localeData().weekdaysMin(),
+		getShortMonths: (locale) => dayjs().locale(parseLocale(locale)).localeData().monthsShort(),
+		format: (locale, date, format) => date.locale(parseLocale(locale)).format(format),
+		parse: (locale, text, formats) => {
+			const localeStr = parseLocale(locale);
+			for (let i = 0; i < formats.length; i += 1) {
+				const format = formats[i];
+				const formatText = text;
+				if (format.includes("wo") || format.includes("Wo")) {
+					const year = formatText.split("-")[0];
+					const weekStr = formatText.split("-")[1];
+					const firstWeek = dayjs(year, "YYYY").startOf("year").locale(localeStr);
+					for (let j = 0; j <= 52; j += 1) {
+						const nextWeek = firstWeek.add(j, "week");
+						if (nextWeek.format("Wo") === weekStr) return nextWeek;
+					}
+					parseNoMatchNotice();
+					return null;
+				}
+				const date = dayjs(formatText, format, true).locale(localeStr);
+				if (date.isValid()) return date;
+			}
+			if (text) parseNoMatchNotice();
+			return null;
+		}
+	}
+};
+export { dayjs_default as default };

package/dist/generate/index.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });

package/dist/generate/index.d.ts

@@ -0,0 +1,37 @@
+export interface GenerateConfig<DateType> {
+    getWeekDay: (value: DateType) => number;
+    getMillisecond: (value: DateType) => number;
+    getSecond: (value: DateType) => number;
+    getMinute: (value: DateType) => number;
+    getHour: (value: DateType) => number;
+    getDate: (value: DateType) => number;
+    getMonth: (value: DateType) => number;
+    getYear: (value: DateType) => number;
+    getNow: () => DateType;
+    getFixedDate: (fixed: string) => DateType;
+    getEndDate: (value: DateType) => DateType;
+    addYear: (value: DateType, diff: number) => DateType;
+    addMonth: (value: DateType, diff: number) => DateType;
+    addDate: (value: DateType, diff: number) => DateType;
+    setYear: (value: DateType, year: number) => DateType;
+    setMonth: (value: DateType, month: number) => DateType;
+    setDate: (value: DateType, date: number) => DateType;
+    setHour: (value: DateType, hour: number) => DateType;
+    setMinute: (value: DateType, minute: number) => DateType;
+    setSecond: (value: DateType, second: number) => DateType;
+    setMillisecond: (value: DateType, millisecond: number) => DateType;
+    isAfter: (date1: DateType, date2: DateType) => boolean;
+    isValidate: (date: DateType) => boolean;
+    locale: {
+        getWeekFirstDay: (locale: string) => number | undefined;
+        getWeekFirstDate: (locale: string, value: DateType) => DateType;
+        getWeek: (locale: string, value: DateType) => number;
+        format: (locale: string, date: DateType, format: string) => string | null;
+        /** Should only return validate date instance */
+        parse: (locale: string, text: string, formats: string[]) => DateType | null;
+        /** A proxy for getting locale with moment or other locale library */
+        getShortWeekDays?: (locale: string) => string[];
+        /** A proxy for getting locale with moment or other locale library */
+        getShortMonths?: (locale: string) => string[];
+    };
+}