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

package/dist/proFieldParsingText/index.d.ts

@@ -0,0 +1,25 @@
+import { ProFieldValueEnumType, ProSchemaValueEnumMap, VueNode } from "../typing.js";
+import { FunctionalComponent, VNode } from "vue";
+import { BadgeProps, SelectValue } from "antdv-next";
+
+//#region src/proFieldParsingText/index.d.ts
+declare const ProFieldBadgeColor: FunctionalComponent<BadgeProps, {}, {
+  default?: () => VNode;
+}>;
+declare function objectToMap(value?: ProFieldValueEnumType): ProSchemaValueEnumMap;
+/**
+ * 转化 text 和 valueEnum 通过 type 来添加 Status
+ *
+ * @param text
+ * @param valueEnumParams
+ * @param key
+ */
+declare function proFieldParsingText(text: SelectValue | {
+  title?: string;
+  value: any;
+} | ({
+  title?: string;
+  value: any;
+})[], valueEnumParams: ProFieldValueEnumType, key?: number | string): VueNode;
+//#endregion
+export { ProFieldBadgeColor, objectToMap, proFieldParsingText };

package/dist/proFieldParsingText/index.js

@@ -0,0 +1,100 @@
+import { Fragment, createVNode, isVNode, mergeProps } from "vue";
+import { Badge, Space } from "antdv-next";
+//#region src/proFieldParsingText/index.tsx
+/**
+* 获取类型的 type
+*
+* @param obj
+*/
+function _isSlot(s) {
+	return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s);
+}
+function getType(obj) {
+	const type = Object.prototype.toString.call(obj)?.match(/^\[object (.*)\]$/)[1]?.toLowerCase();
+	if (type === "string" && typeof obj === "object") return "object";
+	if (obj === null) return "null";
+	if (obj === void 0) return "undefined";
+	return type;
+}
+const ProFieldBadgeColor = ({ color, ...rest }, { slots }) => createVNode(Badge, mergeProps(rest, {
+	"color": color,
+	"text": slots.default?.()
+}), null);
+function objectToMap(value) {
+	if (getType(value) === "map") return value;
+	return new Map(Object.entries(value || {}));
+}
+const TableStatus = {
+	Success: (props, { slots }) => createVNode(Badge, mergeProps(props, {
+		"status": "success",
+		"text": slots.default?.()
+	}), null),
+	Error: (props, { slots }) => createVNode(Badge, mergeProps(props, {
+		"status": "error",
+		"text": slots.default?.()
+	}), null),
+	Default: (props, { slots }) => createVNode(Badge, mergeProps(props, {
+		"status": "default",
+		"text": slots.default?.()
+	}), null),
+	Processing: (props, { slots }) => createVNode(Badge, mergeProps(props, {
+		"status": "processing",
+		"text": slots.default?.()
+	}), null),
+	Warning: (props, { slots }) => createVNode(Badge, mergeProps(props, {
+		"status": "warning",
+		"text": slots.default?.()
+	}), null),
+	success: (props, { slots }) => createVNode(Badge, mergeProps(props, {
+		"status": "success",
+		"text": slots.default?.()
+	}), null),
+	error: (props, { slots }) => createVNode(Badge, mergeProps(props, {
+		"status": "error",
+		"text": slots.default?.()
+	}), null),
+	default: (props, { slots }) => createVNode(Badge, mergeProps(props, {
+		"status": "default",
+		"text": slots.default?.()
+	}), null),
+	processing: (props, { slots }) => createVNode(Badge, mergeProps(props, {
+		"status": "processing",
+		"text": slots.default?.()
+	}), null),
+	warning: (props, { slots }) => createVNode(Badge, mergeProps(props, {
+		"status": "warning",
+		"text": slots.default?.()
+	}), null)
+};
+/**
+* 转化 text 和 valueEnum 通过 type 来添加 Status
+*
+* @param text
+* @param valueEnumParams
+* @param key
+*/
+function proFieldParsingText(text, valueEnumParams, key) {
+	if (Array.isArray(text)) {
+		let _slot;
+		return createVNode(Space, {
+			"key": key,
+			"separator": ",",
+			"size": 2,
+			"wrap": true
+		}, _isSlot(_slot = text.map((value, index) => proFieldParsingText(value, valueEnumParams, index))) ? _slot : { default: () => [_slot] });
+	}
+	const valueEnum = objectToMap(valueEnumParams);
+	if (!valueEnum.has(text) && !valueEnum.has(`${text}`)) return text?.label || text?.title || text;
+	const domText = valueEnum.get(text) || valueEnum.get(`${text}`);
+	if (!domText) return createVNode(Fragment, { "key": key }, [text?.label || text?.title || text]);
+	const { status, color } = domText;
+	const Status = TableStatus[status || "Init"];
+	if (Status) return createVNode(Status, { "key": key }, { default: () => [domText.text] });
+	if (color) return createVNode(ProFieldBadgeColor, {
+		"key": key,
+		"color": color
+	}, { default: () => [domText.text] });
+	return createVNode(Fragment, { "key": key }, [domText.text || domText]);
+}
+//#endregion
+export { ProFieldBadgeColor, objectToMap, proFieldParsingText };

package/dist/runFunction/index.d.ts

@@ -0,0 +1,5 @@
+//#region src/runFunction/index.d.ts
+/** 如果是个方法执行一下它 */
+declare function runFunction<T extends any[]>(valueEnum: any, ...rest: T): any;
+//#endregion
+export { runFunction };

package/dist/runFunction/index.js

@@ -0,0 +1,8 @@
+//#region src/runFunction/index.ts
+/** 如果是个方法执行一下它 */
+function runFunction(valueEnum, ...rest) {
+	if (typeof valueEnum === "function") return valueEnum(...rest);
+	return valueEnum;
+}
+//#endregion
+export { runFunction };

package/dist/stringify/index.d.ts

@@ -0,0 +1,7 @@
+import * as _$safe_stable_stringify0 from "safe-stable-stringify";
+import { configure } from "safe-stable-stringify";
+
+//#region src/stringify/index.d.ts
+declare const stringify: typeof _$safe_stable_stringify0.default;
+//#endregion
+export { configure, stringify };

package/dist/stringify/index.js

@@ -0,0 +1,10 @@
+import { configure } from "safe-stable-stringify";
+//#region src/stringify/index.ts
+const stringify = configure({
+	bigint: true,
+	circularValue: "Magic circle!",
+	deterministic: false,
+	maximumDepth: 4
+});
+//#endregion
+export { configure, stringify };

package/dist/transformBooleanProps/index.d.ts

@@ -0,0 +1,4 @@
+//#region src/transformBooleanProps/index.d.ts
+declare function transformBooleanProps<T extends Record<string, any>>(booleanPropsKey: (keyof T)[], props: T): Record<string, any>;
+//#endregion
+export { transformBooleanProps };

package/dist/transformBooleanProps/index.js

@@ -0,0 +1,9 @@
+//#region src/transformBooleanProps/index.ts
+function transformBooleanProps(booleanPropsKey, props) {
+	return booleanPropsKey.reduce((acc, key) => {
+		acc[key] = typeof props[key] === "string" ? true : props[key];
+		return acc;
+	}, {});
+}
+//#endregion
+export { transformBooleanProps };

package/dist/transformKeySubmitValue/index.d.ts

@@ -0,0 +1,24 @@
+import { SearchTransformKeyFn } from "../typing.js";
+
+//#region src/transformKeySubmitValue/index.d.ts
+type DataFormatMapType = Record<string, SearchTransformKeyFn | undefined>;
+/**
+ * 暂时还不支持 Set和 Map 结构 判断是不是一个能遍历的对象
+ *
+ * @param itemValue
+ * @returns Boolean
+ */
+declare function isPlainObj(itemValue: any): boolean;
+/**
+ * 转换提交值中的键名
+ * 支持两种格式的转换配置：
+ * 1. 点号路径格式：'users.0.name' => 转换嵌套路径的值
+ * 2. 传统嵌套对象格式：{ users: { 0: { name: transformFn } } }
+ *
+ * @param values - 要转换的值对象
+ * @param dataFormatMapRaw - 转换配置映射
+ * @returns 转换后的值对象
+ */
+declare function transformKeySubmitValue<T extends Record<string, any> = any>(values: T, dataFormatMapRaw: Record<string, SearchTransformKeyFn | undefined | DataFormatMapType>): T;
+//#endregion
+export { DataFormatMapType, isPlainObj, transformKeySubmitValue };

package/dist/transformKeySubmitValue/index.js

@@ -0,0 +1,200 @@
+import { isNil } from "../isNil/index.js";
+import { isVNode } from "vue";
+import { get } from "@v-c/util";
+import { cloneDeep } from "es-toolkit";
+//#region src/transformKeySubmitValue/index.ts
+/**
+* 暂时还不支持 Set和 Map 结构 判断是不是一个能遍历的对象
+*
+* @param itemValue
+* @returns Boolean
+*/
+function isPlainObj(itemValue) {
+	if (typeof itemValue !== "object") return false;
+	/** Null 也要处理，不然omit空会失效 */
+	if (itemValue === null) return true;
+	if (isVNode(itemValue)) return false;
+	if (itemValue.constructor === RegExp) return false;
+	if (itemValue instanceof Map) return false;
+	if (itemValue instanceof Set) return false;
+	if (itemValue instanceof HTMLElement) return false;
+	if (itemValue instanceof Blob) return false;
+	if (itemValue instanceof File) return false;
+	return !Array.isArray(itemValue);
+}
+/**
+* 将点号路径字符串转换为路径数组
+* 例如: 'users.0.name' => ['users', 0, 'name']
+*
+* @param dotPath - 点号分隔的路径字符串
+* @returns 路径数组，数字会被转换为数字类型
+*/
+function parseDotPath(dotPath) {
+	return dotPath.split(".").map((segment) => {
+		return /^\d+$/.test(segment) ? Number.parseInt(segment, 10) : segment;
+	});
+}
+/**
+* 过滤掉空值的转换配置
+*
+* @param dataFormatMapRaw - 原始转换配置
+* @returns 过滤后的转换配置
+*/
+function filterNilTransforms(dataFormatMapRaw) {
+	const filtered = {};
+	for (const key in dataFormatMapRaw) {
+		const value = dataFormatMapRaw[key];
+		if (!isNil(value)) filtered[key] = value;
+	}
+	return filtered;
+}
+/**
+* 将转换配置分为点号路径格式和传统嵌套对象格式
+*
+* @param dataFormatMapRaw - 原始转换配置
+* @returns 包含两种格式转换配置的对象
+*/
+function separateTransformFormats(dataFormatMapRaw) {
+	const dotPathTransforms = {};
+	const objectTransforms = {};
+	for (const key in dataFormatMapRaw) {
+		const value = dataFormatMapRaw[key];
+		if (isNil(value)) continue;
+		if (key.includes(".")) dotPathTransforms[key] = value;
+		else objectTransforms[key] = value;
+	}
+	return {
+		dotPathTransforms,
+		objectTransforms
+	};
+}
+/**
+* 处理点号路径格式的转换
+* 例如: 'users.0.name' => 转换 users[0].name 的值
+*
+* @param result - 要转换的数据对象
+* @param dotPathTransforms - 点号路径转换配置
+*/
+function processDotPathTransforms(result, dotPathTransforms) {
+	for (const dotPath in dotPathTransforms) {
+		const transform = dotPathTransforms[dotPath];
+		if (typeof transform !== "function") continue;
+		const pathArray = parseDotPath(dotPath);
+		const currentValue = get(result, pathArray);
+		if (currentValue === void 0) continue;
+		const transformed = transform(currentValue, pathArray.map(String), result);
+		if (typeof transformed === "object" && transformed !== null && !Array.isArray(transformed)) {
+			const parentPath = pathArray.slice(0, -1);
+			const parentObj = parentPath.length > 0 ? get(result, parentPath) : result;
+			if (parentObj && typeof parentObj === "object") {
+				const keyToDelete = pathArray[pathArray.length - 1];
+				delete parentObj[keyToDelete];
+				Object.assign(parentObj, transformed);
+			}
+		} else {
+			let current = result;
+			for (let i = 0; i < pathArray.length - 1; i++) {
+				const key = pathArray[i];
+				if (current[key] === void 0) {
+					const nextKey = pathArray[i + 1];
+					current[key] = typeof nextKey === "number" ? [] : {};
+				}
+				current = current[key];
+			}
+			current[pathArray[pathArray.length - 1]] = transformed;
+		}
+	}
+}
+/**
+* 在嵌套转换配置中查找转换函数
+*
+* @param currentTransforms - 当前转换配置
+* @param parentsKey - 父级路径
+* @param entityKey - 当前实体键
+* @returns 找到的转换函数或 undefined
+*/
+function findNestedTransformFunction(currentTransforms, parentsKey, entityKey) {
+	let nestedTransforms = currentTransforms;
+	for (const parentKey of parentsKey) {
+		const parentKeyStr = String(parentKey);
+		if (nestedTransforms && typeof nestedTransforms[parentKeyStr] === "object") nestedTransforms = nestedTransforms[parentKeyStr];
+		else {
+			nestedTransforms = null;
+			break;
+		}
+	}
+	if (nestedTransforms && typeof nestedTransforms[entityKey] === "function") return nestedTransforms[entityKey];
+}
+/**
+* 检查路径是否包含数组索引
+*
+* @param parentsKey - 父级路径数组
+* @returns 如果包含数组索引返回 true
+*/
+function isInArrayPath(parentsKey) {
+	return parentsKey.some((key) => !Number.isNaN(Number(key)));
+}
+/**
+* 递归处理嵌套对象转换（传统格式）
+*
+* @param tempValues - 要处理的值
+* @param parentsKey - 父级路径
+* @param currentTransforms - 当前转换配置
+* @param rootMergeObjects - 存储需要在根级别合并的对象
+* @param visited - 存储已经访问过的对象，防止循环引用
+* @returns 处理后的结果
+*/
+function processNestedObjectTransforms(tempValues, parentsKey, currentTransforms, rootMergeObjects, visited) {
+	if (tempValues != null && typeof tempValues === "object") {
+		if (visited.has(tempValues)) return tempValues;
+		visited.add(tempValues);
+	}
+	const isArrayValues = Array.isArray(tempValues);
+	const tempResult = isArrayValues ? [] : {};
+	if (tempValues == null || tempValues === void 0) return tempResult;
+	const keysToProcess = isArrayValues ? tempValues.map((_, index) => index.toString()) : Object.keys(tempValues);
+	for (const entityKey of keysToProcess) {
+		const key = parentsKey ? [...parentsKey, entityKey] : [entityKey];
+		const itemValue = tempValues[entityKey];
+		let transformFunction = currentTransforms[entityKey];
+		if (!transformFunction && parentsKey) transformFunction = findNestedTransformFunction(currentTransforms, parentsKey, entityKey);
+		if (transformFunction && typeof transformFunction === "function") {
+			const transformed = transformFunction(itemValue, entityKey, tempValues);
+			if (typeof transformed === "object" && transformed !== null && !Array.isArray(transformed)) if (parentsKey ? isInArrayPath(parentsKey) : false) Object.assign(tempResult, transformed);
+			else rootMergeObjects.push(transformed);
+			else tempResult[entityKey] = transformed;
+		} else if (isPlainObj(itemValue) && !isNil(itemValue)) {
+			const nestedTransforms = currentTransforms[entityKey];
+			if (nestedTransforms && typeof nestedTransforms === "object") {
+				const nested = processNestedObjectTransforms(itemValue, key, nestedTransforms, rootMergeObjects, visited);
+				if (Object.keys(nested).length > 0) tempResult[entityKey] = nested;
+			} else tempResult[entityKey] = processNestedObjectTransforms(itemValue, key, currentTransforms, rootMergeObjects, visited);
+		} else if (!isNil(itemValue)) tempResult[entityKey] = itemValue;
+	}
+	return tempResult;
+}
+/**
+* 转换提交值中的键名
+* 支持两种格式的转换配置：
+* 1. 点号路径格式：'users.0.name' => 转换嵌套路径的值
+* 2. 传统嵌套对象格式：{ users: { 0: { name: transformFn } } }
+*
+* @param values - 要转换的值对象
+* @param dataFormatMapRaw - 转换配置映射
+* @returns 转换后的值对象
+*/
+function transformKeySubmitValue(values, dataFormatMapRaw) {
+	const dataFormatMap = filterNilTransforms(dataFormatMapRaw);
+	if (Object.keys(dataFormatMap).length < 1) return values;
+	if (typeof window === "undefined") return values;
+	if (typeof values !== "object" || isNil(values) || values instanceof Blob) return values;
+	let result = cloneDeep(values);
+	const { dotPathTransforms, objectTransforms } = separateTransformFormats(dataFormatMapRaw);
+	processDotPathTransforms(result, dotPathTransforms);
+	const rootMergeObjects = [];
+	if (Object.keys(objectTransforms).length > 0) result = processNestedObjectTransforms(result, void 0, objectTransforms, rootMergeObjects, /* @__PURE__ */ new Set());
+	for (const obj of rootMergeObjects) Object.assign(result, obj);
+	return result;
+}
+//#endregion
+export { isPlainObj, transformKeySubmitValue };

package/dist/transformVueNodeType/index.d.ts

@@ -0,0 +1,14 @@
+import * as _$vue from "vue";
+import { VNode } from "vue";
+import { VueNode } from "@v-c/util";
+
+//#region src/transformVueNodeType/index.d.ts
+declare function transformVueNodeType(vueNode: VueNode | (() => VueNode[])): string | number | true | VNode<_$vue.RendererNode, _$vue.RendererElement, {
+  [key: string]: any;
+}> | (string | number | boolean | VNode<_$vue.RendererNode, _$vue.RendererElement, {
+  [key: string]: any;
+}> | (string | number | boolean | VNode<_$vue.RendererNode, _$vue.RendererElement, {
+  [key: string]: any;
+}> | undefined)[] | undefined)[] | undefined;
+//#endregion
+export { transformVueNodeType };

package/dist/transformVueNodeType/index.js

@@ -0,0 +1,14 @@
+import { h } from "vue";
+//#region src/transformVueNodeType/index.ts
+function transformVueNodeType(vueNode) {
+	if (vueNode) {
+		if (typeof vueNode === "function") return h(vueNode);
+		if (typeof vueNode === "string" || typeof vueNode === "boolean" || typeof vueNode === "number") return vueNode;
+		if (Array.isArray(vueNode)) return vueNode.filter((node) => node).map((node) => {
+			return transformVueNodeType(node);
+		}).filter(Boolean);
+		return h(vueNode);
+	}
+}
+//#endregion
+export { transformVueNodeType };