@antdv-vue/pro-utils 0.0.0-stage → 2.1.1

package/dist/components/InlineErrorFormItem/InlineErrorFormItemPopover.js

@@ -0,0 +1,95 @@
+import { useEffect } from "../../hooks/useEffect/index.js";
+import { useState } from "../../hooks/useState/index.js";
+import style_default from "./style/index.js";
+import { Fragment, computed, createVNode, defineComponent, mergeProps } from "vue";
+import { classNames } from "@v-c/util";
+import { Popover } from "antdv-next";
+import { LoadingOutlined } from "@antdv-next/icons";
+import { useConfig as useConfig$1 } from "antdv-next/config-provider/context";
+//#region src/components/InlineErrorFormItem/InlineErrorFormItemPopover.tsx
+const InlineErrorFormItemPopover = /* @__PURE__ */ defineComponent((props) => {
+	const [open, setOpen] = useState(false);
+	const [messages, setMessages] = useState({
+		errors: [],
+		warnings: []
+	});
+	const config = useConfig$1();
+	const prefixCls = computed(() => props.prefixCls || config.value.getPrefixCls());
+	useEffect(() => {
+		if (props.inputProps.validateStatus !== "validating") setMessages({
+			errors: props.inputProps.errors ?? [],
+			warnings: props.inputProps.warnings ?? []
+		});
+	}, [
+		() => props.inputProps.errors,
+		() => props.inputProps.warnings,
+		() => props.inputProps.validateStatus
+	]);
+	const baseClassName = computed(() => `${prefixCls.value}-form-item`);
+	const [hashId, cssVarCls] = style_default(baseClassName);
+	return () => {
+		const { popoverProps, inputProps, input, extra, errorList } = props;
+		const loading = inputProps.validateStatus === "validating";
+		const hasMessages = (messages.value.errors?.length ?? 0) + (messages.value.warnings?.length ?? 0) >= 1;
+		setOpen(!hasMessages ? false : open.value);
+		return createVNode(Popover, mergeProps({ "key": "popover" }, popoverProps, {
+			"open": open.value,
+			"onUpdate:open": (_open) => {
+				popoverProps?.["onUpdate:open"]?.(_open);
+				setOpen(_open);
+			},
+			"onOpenChange": (changeOpen) => {
+				popoverProps?.onOpenChange?.(changeOpen);
+				setOpen(changeOpen);
+			},
+			"trigger": popoverProps?.trigger || ["click"],
+			"placement": popoverProps?.placement || "topLeft",
+			"getPopupContainer": popoverProps?.getPopupContainer,
+			"getTooltipContainer": popoverProps?.getTooltipContainer,
+			"content": createVNode("div", {
+				"class": classNames(baseClassName.value, hashId.value, cssVarCls.value),
+				"style": {
+					margin: 0,
+					padding: 0
+				}
+			}, [createVNode("div", { "class": classNames(`${baseClassName.value}-with-help`, hashId.value, cssVarCls.value) }, [loading ? createVNode(LoadingOutlined, null, null) : null, hasMessages ? createVNode(Fragment, null, [messages.value.errors?.map((error, index) => createVNode("div", {
+				"key": `error-${index}`,
+				"class": classNames(`${baseClassName.value}-explain-error`, hashId.value, cssVarCls.value)
+			}, [error])), messages.value.warnings?.map((warning, index) => createVNode("div", {
+				"key": `warning-${index}`,
+				"class": classNames(`${baseClassName.value}-explain-warning`, hashId.value, cssVarCls.value)
+			}, [warning]))]) : errorList])])
+		}), { default: () => [createVNode(Fragment, null, [input, extra])] });
+	};
+}, {
+	props: {
+		prefixCls: {
+			type: String,
+			required: false
+		},
+		inputProps: {
+			type: Object,
+			required: true
+		},
+		input: {
+			type: [Object, null],
+			required: false
+		},
+		errorList: {
+			type: [Object, null],
+			required: false
+		},
+		extra: {
+			type: [Object, null],
+			required: false
+		},
+		popoverProps: {
+			type: Object,
+			required: false
+		}
+	},
+	name: "InlineErrorFormItemPopover",
+	inheritAttrs: false
+});
+//#endregion
+export { InlineErrorFormItemPopover as default };

package/dist/components/InlineErrorFormItem/index.d.ts

@@ -0,0 +1,14 @@
+import { FormItemProps as FormItemProps$1 } from "../FormItem/index.js";
+import { CSSProperties, FunctionalComponent } from "vue";
+import { PopoverProps } from "antdv-next";
+
+//#region src/components/InlineErrorFormItem/index.d.ts
+type InlineErrorFormItemProps = FormItemProps$1 & {
+  errorType?: 'popover' | 'default';
+  popoverProps?: PopoverProps;
+  style?: CSSProperties;
+  class?: string;
+};
+declare const InlineErrorFormItem: FunctionalComponent<InlineErrorFormItemProps>;
+//#endregion
+export { InlineErrorFormItem as default };

package/dist/components/InlineErrorFormItem/index.js

@@ -0,0 +1,44 @@
+import FormItem from "../FormItem/index.js";
+import InlineErrorFormItemPopover from "./InlineErrorFormItemPopover.js";
+import { createVNode, mergeProps } from "vue";
+import { unit } from "@antdv-next/cssinjs";
+//#region src/components/InlineErrorFormItem/index.tsx
+const FIX_INLINE_STYLE = {
+	marginBlockStart: unit(-5),
+	marginBlockEnd: unit(-5),
+	marginInlineStart: 0,
+	marginInlineEnd: 0
+};
+const InternalFormItemFunction = ({ rules, name, popoverProps, style, ...rest }, { slots }) => createVNode(FormItem, mergeProps(rest, {
+	"name": name,
+	"_internalItemRender": {
+		mark: "pro_table_render",
+		render: (inputProps, doms) => createVNode(InlineErrorFormItemPopover, mergeProps({
+			"inputProps": inputProps,
+			"popoverProps": popoverProps
+		}, doms), null)
+	},
+	"rules": rules,
+	"hasFeedback": false,
+	"style": {
+		...FIX_INLINE_STYLE,
+		...style
+	}
+}), slots);
+const InlineErrorFormItem = ({ errorType, rules = [], name, popoverProps, style, ...rest }, { slots }) => {
+	if (name && Array.isArray(rules) && rules?.length && errorType === "popover") return createVNode(InternalFormItemFunction, mergeProps({
+		"name": name,
+		"rules": rules,
+		"popoverProps": popoverProps
+	}, rest), slots);
+	return createVNode(FormItem, mergeProps(rest, {
+		"rules": rules,
+		"name": name,
+		"style": {
+			...FIX_INLINE_STYLE,
+			...style
+		}
+	}), slots);
+};
+//#endregion
+export { InlineErrorFormItem as default };

package/dist/components/InlineErrorFormItem/style/index.d.ts

@@ -0,0 +1,8 @@
+import * as _$vue from "vue";
+import { ProAliasCssVarToken } from "@antdv-vue/pro-provider";
+
+//#region src/components/InlineErrorFormItem/style/index.d.ts
+interface ProInlineErrorFormItemToken extends ProAliasCssVarToken {}
+declare const _default: (prefixCls: _$vue.Ref<string>, rootCls?: _$vue.Ref<string | undefined>) => readonly [_$vue.Ref<string, string>, _$vue.ComputedRef<string | undefined>];
+//#endregion
+export { ProInlineErrorFormItemToken, _default as default };

package/dist/components/InlineErrorFormItem/style/index.js

@@ -0,0 +1,46 @@
+import { useStyle } from "@antdv-vue/pro-provider";
+import { mergeToken } from "@antdv-next/cssinjs";
+//#region src/components/InlineErrorFormItem/style/index.ts
+const genProInlineErrorFormItemStyle = (token) => {
+	const progressBgCls = `${token.antCls}-progress-bg`;
+	return { [token.componentCls]: { "&-with-help": {
+		"&-multiple": {
+			paddingBlockStart: 6,
+			paddingBlockEnd: 12,
+			paddingInline: 8
+		},
+		"&-progress": {
+			"&-success": { [progressBgCls]: { backgroundColor: token.colorSuccess } },
+			"&-error": { [progressBgCls]: { backgroundColor: token.colorError } },
+			"&-warning": { [progressBgCls]: { backgroundColor: token.colorWarning } }
+		},
+		"&-rule": {
+			display: "flex",
+			alignItems: "center",
+			"&-icon": {
+				"&-default": {
+					display: "flex",
+					alignItems: "center",
+					justifyContent: "center",
+					width: 14,
+					height: 22,
+					"&-circle": {
+						width: 6,
+						height: 6,
+						backgroundColor: token.colorTextSecondary,
+						borderRadius: 4
+					}
+				},
+				"&-loading": { color: token.colorPrimary },
+				"&-error": { color: token.colorError },
+				"&-success": { color: token.colorSuccess }
+			},
+			"&-text": { color: token.colorText }
+		}
+	} } };
+};
+var style_default = useStyle("InlineErrorFormItem", (token) => {
+	return [genProInlineErrorFormItemStyle(mergeToken(token, {}))];
+});
+//#endregion
+export { style_default as default };

package/dist/components/LabelIconTip/index.d.ts

@@ -0,0 +1,16 @@
+import * as _$vue from "vue";
+import { VueNode } from "@v-c/util";
+import { FormItemTooltipType } from "antdv-next/dist/form/FormItemLabel";
+
+//#region src/components/LabelIconTip/index.d.ts
+interface LabelIconTipProps {
+  label?: VueNode;
+  subTitle?: VueNode;
+  tooltip?: FormItemTooltipType;
+  ellipsis?: boolean | {
+    showTitle?: boolean;
+  };
+}
+declare const LabelIconTip: _$vue.DefineSetupFnComponent<LabelIconTipProps, {}, {}, LabelIconTipProps & {}, _$vue.PublicProps>;
+//#endregion
+export { LabelIconTipProps, LabelIconTip as default };

package/dist/components/LabelIconTip/index.js

@@ -0,0 +1,79 @@
+import style_default from "./style/index.js";
+import { Fragment, computed, createVNode, defineComponent, isVNode } from "vue";
+import { classNames } from "@v-c/util";
+import { Tooltip } from "antdv-next";
+import { InfoCircleOutlined } from "@antdv-next/icons";
+import { useConfig as useConfig$1 } from "antdv-next/config-provider/context";
+//#region src/components/LabelIconTip/index.tsx
+const LabelIconTip = /* @__PURE__ */ defineComponent((props) => {
+	const config = useConfig$1();
+	const prefixCls = computed(() => config.value.getPrefixCls("pro"));
+	const baseClassName = computed(() => `${prefixCls.value}-core-label-tip`);
+	const [hashId, cssVarCls] = style_default(baseClassName);
+	return () => {
+		const { tooltip, subTitle, label, ellipsis } = props;
+		if (!tooltip && !subTitle) return createVNode(Fragment, null, [label]);
+		const tooltipProps = typeof tooltip === "string" || isVNode(tooltip) ? { title: tooltip } : tooltip;
+		const icon = tooltipProps?.icon || createVNode(InfoCircleOutlined, null, null);
+		return createVNode("div", {
+			"class": classNames(baseClassName.value, hashId.value, cssVarCls.value),
+			"onMousedown": (e) => e.stopPropagation(),
+			"onMouseleave": (e) => e.stopPropagation(),
+			"onMousemove": (e) => e.stopPropagation()
+		}, [
+			createVNode("div", { "class": classNames(`${baseClassName.value}-title`, hashId.value, cssVarCls.value, { [`${baseClassName.value}-title-ellipsis`]: ellipsis }) }, [label]),
+			subTitle && createVNode("div", { "class": classNames(`${baseClassName.value}-subtitle`, hashId.value, cssVarCls.value) }, [subTitle]),
+			tooltip && createVNode(Tooltip, tooltipProps, { default: () => [createVNode("span", { "class": classNames(`${baseClassName.value}-icon`, hashId.value, cssVarCls.value) }, [icon])] })
+		]);
+	};
+}, {
+	props: {
+		label: {
+			type: [
+				Object,
+				Function,
+				String,
+				Number,
+				null,
+				Boolean,
+				Array
+			],
+			required: false,
+			default: void 0
+		},
+		subTitle: {
+			type: [
+				Object,
+				Function,
+				String,
+				Number,
+				null,
+				Boolean,
+				Array
+			],
+			required: false,
+			default: void 0
+		},
+		tooltip: {
+			type: [
+				Object,
+				Function,
+				String,
+				Number,
+				null,
+				Boolean
+			],
+			required: false,
+			default: void 0
+		},
+		ellipsis: {
+			type: [Boolean, Object],
+			required: false,
+			default: void 0
+		}
+	},
+	name: "LabelIconTip",
+	inheritAttrs: false
+});
+//#endregion
+export { LabelIconTip as default };

package/dist/components/LabelIconTip/style/index.d.ts

@@ -0,0 +1,8 @@
+import * as _$vue from "vue";
+import { ProAliasCssVarToken } from "@antdv-vue/pro-provider";
+
+//#region src/components/LabelIconTip/style/index.d.ts
+interface ProLabelIconTipToken extends ProAliasCssVarToken {}
+declare const _default: (prefixCls: _$vue.Ref<string>, rootCls?: _$vue.Ref<string | undefined>) => readonly [_$vue.Ref<string, string>, _$vue.ComputedRef<string | undefined>];
+//#endregion
+export { ProLabelIconTipToken, _default as default };

package/dist/components/LabelIconTip/style/index.js

@@ -0,0 +1,38 @@
+import { useStyle } from "@antdv-vue/pro-provider";
+import { mergeToken } from "@antdv-next/cssinjs";
+//#region src/components/LabelIconTip/style/index.ts
+const genProLabelIconTipStyle = (token) => {
+	return { [token.componentCls]: {
+		display: "inline-flex",
+		alignItems: "center",
+		maxWidth: "100%",
+		"&-icon": {
+			display: "block",
+			marginInlineStart: 4,
+			cursor: "pointer",
+			"&:hover": { color: token.colorPrimary }
+		},
+		"&-title": {
+			display: "inline-flex",
+			flex: "1"
+		},
+		"&-subtitle ": {
+			marginInlineStart: 8,
+			color: token.colorTextSecondary,
+			fontWeight: "normal",
+			fontSize: token.fontSize,
+			whiteSpace: "nowrap"
+		},
+		"&-title-ellipsis": {
+			overflow: "hidden",
+			whiteSpace: "nowrap",
+			textOverflow: "ellipsis",
+			wordBreak: "keep-all"
+		}
+	} };
+};
+var style_default = useStyle("LabelIconTip", (token) => {
+	return [genProLabelIconTipStyle(mergeToken(token, {}))];
+});
+//#endregion
+export { style_default as default };

package/dist/components/ProFormContext/index.d.ts

@@ -0,0 +1,51 @@
+import { InjectionKey, ShallowRef } from "vue";
+import { FormInstance } from "antdv-next";
+import { NamePath } from "antdv-next/dist/form/types";
+
+//#region src/components/ProFormContext/index.d.ts
+interface ProFormInstanceType<T> {
+  /**
+   * 获取被 ProForm 格式化后的所有数据
+   * @param nameList boolean
+   * @returns T
+   *
+   * @example  getFieldsFormatValue() ->返回所有数据
+   * @example  getFieldsFormatValue(true) ->返回所有数据，即使没有被 form 托管的
+   */
+  getFieldsFormatValue?: (nameList?: true, omitNil?: boolean) => T;
+  /**
+   * 获取被 ProForm 格式化后的单个数据
+   * @param nameList (string|number)[]
+   * @returns T
+   *
+   * @example {a:{b:value}} -> getFieldFormatValue(['a', 'b']) -> value
+   */
+  getFieldFormatValue?: (nameList?: NamePath<string | number | boolean>, omitNilParam?: boolean) => T | undefined;
+  /**
+   * 获取被 ProForm 格式化后的单个数据, 包含他的 name
+   * @param nameList (string|number)[]
+   * @returns T
+   *
+   * @example {a:{b:value}}->getFieldFormatValueObject(['a','b'])->{a:{b:value}}
+   */
+  getFieldFormatValueObject?: (nameList?: NamePath<string | number | boolean>, omitNilParam?: boolean) => T;
+  /**
+   *验字段后返回格式化之后的所有数据
+   * @param nameList (string|number)[]
+   * @returns T
+   *
+   * @example validateFieldsReturnFormatValue -> {a:{b:value}}
+   */
+  validateFieldsReturnFormatValue?: (nameList?: NamePath<string | number | boolean>[], omitNilParam?: boolean) => Promise<T>;
+}
+declare const proFormContextKey: InjectionKey<ProFormInstanceType<any> & {
+  formRef?: ShallowRef<FormInstance | null>;
+}>;
+declare function useProFormContextProvider(props: ProFormInstanceType<any> & {
+  formRef?: ShallowRef<FormInstance | null>;
+}): void;
+declare function useProFormContextInject(): ProFormInstanceType<any> & {
+  formRef?: ShallowRef<FormInstance | null>;
+};
+//#endregion
+export { ProFormInstanceType, proFormContextKey, useProFormContextInject, useProFormContextProvider };

package/dist/components/ProFormContext/index.js

@@ -0,0 +1,11 @@
+import { inject, provide } from "vue";
+//#region src/components/ProFormContext/index.ts
+const proFormContextKey = Symbol("proFormContext");
+function useProFormContextProvider(props) {
+	return provide(proFormContextKey, props);
+}
+function useProFormContextInject() {
+	return inject(proFormContextKey, {});
+}
+//#endregion
+export { proFormContextKey, useProFormContextInject, useProFormContextProvider };

package/dist/conversionMomentValue/index.d.ts

@@ -0,0 +1,48 @@
+import { ProFieldValueType } from "../typing.js";
+import { ShallowRef } from "vue";
+import dayjs from "dayjs";
+import { NamePath } from "antdv-next/dist/form/types";
+
+//#region src/conversionMomentValue/index.d.ts
+type DateFormatter = (string & Record<string, any>) | 'number' | 'string' | ((value: dayjs.Dayjs, valueType: string) => string | number) | false;
+declare const dateFormatterMap: {
+  time: string;
+  timeRange: string;
+  date: string;
+  dateWeek: string;
+  dateMonth: string;
+  dateQuarter: string;
+  dateYear: string;
+  dateRange: string;
+  dateTime: string;
+  dateTimeRange: string;
+};
+/**
+ * 判断是否是一个的简单的 object
+ * @param  {{constructor:any}} o
+ * @returns boolean
+ */
+declare function isPlainObject(o: {
+  constructor: any;
+}): boolean;
+/**
+ * 根据不同的格式转化 dayjs
+ * @param  {dayjs.Dayjs} value
+ * @param  {string|((value:dayjs.Dayjs} dateFormatter
+ * @param  {string} valueType
+ */
+declare function convertMoment(value: dayjs.Dayjs, dateFormatter: DateFormatter, valueType: string): string | number | dayjs.Dayjs;
+/**
+ * 这里主要是来转化一下数据 将 dayjs 转化为 string 将 all 默认删除
+ * @param  {object} value
+ * @param  {DateFormatter} dateFormatter
+ * @param  {Record<string} valueTypeMap
+ * @param {boolean} omitNil
+ * @param {NamePath} parentKey
+ */
+declare function conversionMomentValue<T extends Record<string, any> = any>(value: T, dateFormatter: DateFormatter, valueTypeMap: ShallowRef<Record<string, {
+  valueType: ProFieldValueType;
+  dateFormat: string;
+} | any>>, omitNil?: boolean, parentKey?: NamePath): T;
+//#endregion
+export { conversionMomentValue, convertMoment, dateFormatterMap, isPlainObject };

package/dist/conversionMomentValue/index.js

@@ -0,0 +1,103 @@
+import { isNil } from "../isNil/index.js";
+import dayjs from "dayjs";
+import { get } from "@v-c/util";
+import quarterOfYear from "dayjs/plugin/quarterOfYear";
+//#region src/conversionMomentValue/index.ts
+dayjs.extend(quarterOfYear);
+const dateFormatterMap = {
+	time: "HH:mm:ss",
+	timeRange: "HH:mm:ss",
+	date: "YYYY-MM-DD",
+	dateWeek: "YYYY-wo",
+	dateMonth: "YYYY-MM",
+	dateQuarter: "YYYY-[Q]Q",
+	dateYear: "YYYY",
+	dateRange: "YYYY-MM-DD",
+	dateTime: "YYYY-MM-DD HH:mm:ss",
+	dateTimeRange: "YYYY-MM-DD HH:mm:ss"
+};
+/**
+* 判断是不是一个 object
+* @param  {any} o
+* @returns boolean
+*/
+function isObject(o) {
+	return Object.prototype.toString.call(o) === "[object Object]";
+}
+/**
+* 判断是否是一个的简单的 object
+* @param  {{constructor:any}} o
+* @returns boolean
+*/
+function isPlainObject(o) {
+	if (!isObject(o)) return false;
+	const ctor = o.constructor;
+	if (ctor === void 0) return true;
+	const prot = ctor.prototype;
+	if (!isObject(prot)) return false;
+	if (!Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf")) return false;
+	return true;
+}
+/**
+*  一个比较hack的moment判断工具
+* @param  {any} value
+* @returns boolean
+*/
+const isMoment = (value) => !!value?._isAMomentObject;
+/**
+* 根据不同的格式转化 dayjs
+* @param  {dayjs.Dayjs} value
+* @param  {string|((value:dayjs.Dayjs} dateFormatter
+* @param  {string} valueType
+*/
+function convertMoment(value, dateFormatter, valueType) {
+	if (!dateFormatter) return value;
+	if (dayjs.isDayjs(value) || isMoment(value)) {
+		if (dateFormatter === "number") return value.valueOf();
+		if (dateFormatter === "string") return value.format(dateFormatterMap[valueType] || "YYYY-MM-DD HH:mm:ss");
+		if (typeof dateFormatter === "string" && dateFormatter !== "string") return value.format(dateFormatter);
+		if (typeof dateFormatter === "function") return dateFormatter(value, valueType);
+	}
+	return value;
+}
+/**
+* 这里主要是来转化一下数据 将 dayjs 转化为 string 将 all 默认删除
+* @param  {object} value
+* @param  {DateFormatter} dateFormatter
+* @param  {Record<string} valueTypeMap
+* @param {boolean} omitNil
+* @param {NamePath} parentKey
+*/
+function conversionMomentValue(value, dateFormatter, valueTypeMap, omitNil, parentKey) {
+	const tmpValue = {};
+	if (typeof window === "undefined") return value;
+	if (typeof value !== "object" || isNil(value) || value instanceof Blob || Array.isArray(value)) return value;
+	Object.keys(value).forEach((valueKey) => {
+		const namePath = parentKey ? [parentKey, valueKey].flat(1) : [valueKey];
+		const valueFormatMap = get(valueTypeMap.value, namePath) || "text";
+		let valueType = "text";
+		let dateFormat;
+		if (typeof valueFormatMap === "string") valueType = valueFormatMap;
+		else if (valueFormatMap) {
+			valueType = valueFormatMap.valueType;
+			dateFormat = valueFormatMap.dateFormat;
+		}
+		const itemValue = value[valueKey];
+		if (isNil(itemValue) && omitNil) return;
+		if (isPlainObject(itemValue) && !Array.isArray(itemValue) && !dayjs.isDayjs(itemValue) && !isMoment(itemValue)) {
+			tmpValue[valueKey] = conversionMomentValue(itemValue, dateFormatter, valueTypeMap, omitNil, namePath);
+			return;
+		}
+		if (Array.isArray(itemValue)) {
+			tmpValue[valueKey] = itemValue.map((arrayValue, index) => {
+				if (dayjs.isDayjs(arrayValue) || isMoment(arrayValue)) return convertMoment(arrayValue, dateFormat || dateFormatter, valueType);
+				return conversionMomentValue(arrayValue, dateFormatter, valueTypeMap, omitNil, [valueKey, `${index}`].flat(1));
+			});
+			return;
+		}
+		tmpValue[valueKey] = convertMoment(itemValue, dateFormat || dateFormatter, valueType);
+	});
+	return tmpValue;
+}
+//#endregion
+export { conversionMomentValue, convertMoment, dateFormatterMap, isPlainObject };

package/dist/dateArrayFormatter/index.d.ts

@@ -0,0 +1,14 @@
+//#region src/dateArrayFormatter/index.d.ts
+type FormatType = ((dayjs: any) => string) | string;
+/**
+ * 格式化区域日期,如果是一个数组，会返回 start ~ end
+ * @param  {any} value
+ * @param  {FormatType | FormatType[]} format
+ * returns string
+ */
+declare function dateArrayFormatter(value: any[], format: FormatType | FormatType[] | {
+  format: string;
+  type?: 'mask';
+}): string;
+//#endregion
+export { dateArrayFormatter };

package/dist/dateArrayFormatter/index.js

@@ -0,0 +1,38 @@
+import dayjs from "dayjs";
+//#region src/dateArrayFormatter/index.ts
+/**
+* 通过 format 来格式化日期，因为支持了function 所以需要单独的方法来处理
+* @param  {any} endText
+* @param  {FormatType} format
+* @return string
+*/
+function formatString(endText, format) {
+	if (typeof format === "function") return format(dayjs(endText));
+	return dayjs(endText).format(format);
+}
+/**
+* 格式化区域日期,如果是一个数组，会返回 start ~ end
+* @param  {any} value
+* @param  {FormatType | FormatType[]} format
+* returns string
+*/
+function dateArrayFormatter(value, format) {
+	const [startText, endText] = Array.isArray(value) ? value : [];
+	let formatFirst;
+	let formatEnd;
+	if (Array.isArray(format)) {
+		formatFirst = format[0];
+		formatEnd = format[1];
+	} else if (typeof format === "object" && format.type === "mask") {
+		formatFirst = format.format;
+		formatEnd = format.format;
+	} else {
+		formatFirst = format;
+		formatEnd = format;
+	}
+	const parsedStartText = startText ? formatString(startText, formatFirst) : "";
+	const parsedEndText = endText ? formatString(endText, formatEnd) : "";
+	return parsedStartText && parsedEndText ? `${parsedStartText} ~ ${parsedEndText}` : "";
+}
+//#endregion
+export { dateArrayFormatter };

package/dist/deepMerge/index.d.ts

@@ -0,0 +1,4 @@
+//#region src/deepMerge/index.d.ts
+declare function deepMerge<T = any>(...objs: any[]): T;
+//#endregion
+export { deepMerge };

package/dist/deepMerge/index.js

@@ -0,0 +1,17 @@
+//#region src/deepMerge/index.ts
+function deepMerge(...objs) {
+	const result = {};
+	for (const obj of objs) {
+		if (!obj || typeof obj !== "object") continue;
+		for (const key in obj) {
+			if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
+			const val = obj[key];
+			const existing = result[key];
+			if (val && typeof val === "object" && !Array.isArray(val) && existing && typeof existing === "object" && !Array.isArray(existing)) result[key] = deepMerge(existing, val);
+			else result[key] = val;
+		}
+	}
+	return result;
+}
+//#endregion
+export { deepMerge };