@gct-paas/design 0.1.4-dev.9 → 0.1.5-dev.0

package/es/components/field-cascader/src/hooks.d.ts

@@ -0,0 +1,129 @@
+import { FieldMetaDTO } from '@gct-paas/api/apaas';
+export declare function useFieldCascader(props: comPropsType, { onFieldClick }: IObject): {
+    visibleValue: import('vue').Ref<boolean, boolean>;
+    filterOptions: import('vue').ComputedRef<{
+        children: any;
+        value: string;
+        label?: any;
+        disabled?: boolean | undefined;
+        isLeaf?: boolean | undefined;
+        __props: {
+            backendOnly?: number | undefined;
+            bindFieldKey?: string | undefined;
+            bindInfo?: string | undefined;
+            createTime?: string | undefined;
+            createType?: string | undefined;
+            createUserId?: string | undefined;
+            createUserName?: string | undefined;
+            defaultValue?: {
+                name?: string | undefined;
+                type?: string | undefined;
+                value?: IObject | undefined;
+            } | undefined;
+            defaultValueTips?: string[] | undefined;
+            description?: string | undefined;
+            draft?: number | undefined;
+            expression?: string | undefined;
+            fieldCategory?: string | undefined;
+            functionName?: string | undefined;
+            i18nConfig?: string | undefined;
+            id?: string | undefined;
+            initCommitId?: string | undefined;
+            key?: string | undefined;
+            mappingType?: string | undefined;
+            modelCategory?: string | undefined;
+            modelKey?: string | undefined;
+            modelMeta?: {
+                constraint?: {
+                    convertFromFieldUniqueConstraint?: boolean | undefined;
+                    fieldKeys?: string[] | undefined;
+                    fieldNames?: string[] | undefined;
+                    type?: string | undefined;
+                }[] | undefined;
+                createTime?: string | undefined;
+                createUserId?: string | undefined;
+                createUserName?: string | undefined;
+                deletePolicy?: number | undefined;
+                deleted?: number | undefined;
+                description?: string | undefined;
+                displayField?: string | undefined;
+                hidden?: boolean | undefined;
+                id?: string | undefined;
+                initCommitId?: string | undefined;
+                key?: string | undefined;
+                maxSubLevel?: number | undefined;
+                modifyTime?: string | undefined;
+                modifyUserId?: string | undefined;
+                modifyUserName?: string | undefined;
+                name?: string | undefined;
+                order?: number | undefined;
+                permissionEnabled?: number | undefined;
+                recycled?: number | undefined;
+                refModelKey?: string | undefined;
+                source?: string | undefined;
+                specificConfig?: IObject | undefined;
+                subModel?: number | undefined;
+                supportMessage?: number | undefined;
+                supportProcess?: number | undefined;
+                supportStateMachine?: number | undefined;
+                sysBuiltin?: number | undefined;
+                type?: string | undefined;
+            } | undefined;
+            modelName?: string | undefined;
+            modelType?: string | undefined;
+            modifyTime?: string | undefined;
+            modifyUserId?: string | undefined;
+            modifyUserName?: string | undefined;
+            name?: string | undefined;
+            originFieldKey?: string | undefined;
+            originModelKey?: string | undefined;
+            parentField?: number | undefined;
+            rdoUniqueFieldKey?: boolean | undefined;
+            refModelSource?: string | undefined;
+            refModelType?: string | undefined;
+            relationModelName?: string | undefined;
+            required?: number | undefined;
+            sortNum?: number | undefined;
+            source?: string | undefined;
+            specificConfig?: IObject | undefined;
+            sysBuiltin?: number | undefined;
+            type?: string | undefined;
+            uniqueConstraint?: {
+                checkStrategy?: string | undefined;
+                fieldKeys?: string[] | undefined;
+                type?: string | undefined;
+            } | undefined;
+            __bindFields: string[];
+        };
+        __id?: string | undefined;
+    }[]>;
+    getChildrenOptionsByKey: ({ bindInfo, relationModelName, id, __bindFields, key, name, }: LocalFieldMetaDTO, level: number) => Promise<Option[] | undefined>;
+    fieldValues: import('vue').ComputedRef<string[]>;
+    fieldMapByKey: Record<string, {
+        name: string;
+    }>;
+};
+type LocalFieldMetaDTO = FieldMetaDTO & {
+    __bindFields: string[];
+};
+export interface Option {
+    value: string;
+    label?: any;
+    disabled?: boolean;
+    children?: Option[];
+    isLeaf?: boolean;
+    __props: LocalFieldMetaDTO;
+    __id?: string;
+    [key: string]: any;
+}
+export interface comPropsType {
+    fieldMetaList: LocalFieldMetaDTO[];
+    modelName: string;
+    maxLevel: number;
+    value: string;
+    valueSeparator?: string;
+    searchable?: boolean;
+    /**过滤函数 */
+    filterFieldByFunction?: (w: LocalFieldMetaDTO) => boolean;
+}
+export {};

package/es/components/field-cascader/src/hooks.mjs

@@ -0,0 +1,163 @@
+import SearchInput_default from "./SearchInput.vue.mjs";
+import { FIELD_TYPE } from "@gct-paas/core";
+import { computed, createTextVNode, createVNode, h, onMounted, reactive, ref } from "vue";
+//#region src/components/field-cascader/src/hooks.tsx
+function useFieldCascader(props, { onFieldClick }) {
+	const { fieldMetaList, modelName, maxLevel, filterFieldByFunction = () => true } = props;
+	const optionsMapByModalKey = ref({});
+	const fieldMapByKey = reactive({});
+	/**根节点第一个查询 */
+	const keyword = ref();
+	const options = ref([]);
+	const fieldValues = computed(() => {
+		return props.value ? props.value.split(props.valueSeparator || "$") : [];
+	});
+	const visibleValue = ref(false);
+	const filterOptions = computed(() => {
+		return options.value.filter((i) => !i.title || !keyword.value || i.title.includes(keyword.value || "")).map((i) => {
+			const children = i.isExpandField ? recursionTreeFilterByKeyword(i, 2, optionsMapByModalKey.value) : [];
+			return {
+				...i,
+				children
+			};
+		});
+	});
+	/**初始化自动展开 */
+	async function autoExpand() {
+		const fields = [...fieldValues.value];
+		let nodeOptions = [...options.value];
+		let level = 1;
+		while (fields.length > 1) {
+			const filedKey = fields.shift();
+			const fieldItem = nodeOptions.find((i) => i.value === filedKey);
+			if (!fieldItem) return;
+			level += 1;
+			nodeOptions = await getChildrenOptionsByKey(fieldItem.__props, level) || [];
+		}
+	}
+	onMounted(() => {
+		/**添加第一列 */
+		options.value = createOptionsByModel({
+			fields: fieldMetaList,
+			title: modelName,
+			search: (val) => {
+				keyword.value = val;
+			},
+			onFieldClick,
+			level: 1,
+			__bindFields: []
+		});
+		autoExpand();
+	});
+	/**根据模型key 获取子节点信息 */
+	async function getChildrenOptionsByKey({ bindInfo, relationModelName, id, __bindFields, key, name }, level) {
+		fieldMapByKey[key] = { name };
+		/**级联字段唯一标识 */
+		const fieldKey = id + level;
+		if (optionsMapByModalKey.value[fieldKey]) {
+			optionsMapByModalKey.value[fieldKey].keyword = "";
+			return;
+		}
+		const res = await _api.apaas.modelMeta.getDetail({ modelKey: bindInfo });
+		optionsMapByModalKey.value[fieldKey] = {
+			keyword: "",
+			option: []
+		};
+		optionsMapByModalKey.value[fieldKey].option = createOptionsByModel({
+			fields: res.fieldMetaList,
+			title: relationModelName,
+			search: (val) => {
+				optionsMapByModalKey.value[fieldKey].keyword = val;
+			},
+			onFieldClick,
+			level,
+			__bindFields
+		});
+		return optionsMapByModalKey.value[fieldKey].option;
+	}
+	function createSearchInput(onChange, level) {
+		return {
+			value: level,
+			label: h(SearchInput_default, {
+				visibleValue,
+				onChange
+			}),
+			isLeaf: false,
+			__props: {},
+			isExpandField: false
+		};
+	}
+	/**
+	* 根据模型名称获取模型下拉数据
+	*/
+	function createOptionsByModel({ fields, title, search, level, onFieldClick, __bindFields }) {
+		const options = [props.searchable ? createSearchInput(search, level) : null, createTitleItem(title)].filter(Boolean);
+		fields.filter(filterFieldByFunction).forEach((row) => {
+			options.push(createOptionItem(row, {
+				level,
+				onClick() {
+					onFieldClick(row, level);
+				},
+				__bindFields
+			}));
+		});
+		return options;
+	}
+	function createOptionItem(row, { level, onClick, __bindFields }) {
+		const isExpandField = level < maxLevel && isExpandFieldArg.includes(row.type);
+		row.__bindFields = [...__bindFields, row.key];
+		const titleWithRelation = isExpandField ? `${row.name}(${row.relationModelName})` : row.name;
+		const labels = row.name;
+		return {
+			value: row.key,
+			label: getFileldLabel(labels, isExpandField, onClick),
+			title: labels,
+			titleWithRelation,
+			isLeaf: false,
+			isExpandField,
+			children: [],
+			__props: row,
+			__level: level,
+			__id: row.id
+		};
+	}
+	/**根距关键字递归过滤tree */
+	function recursionTreeFilterByKeyword(row, level, optionKey) {
+		const { option = [], keyword = "" } = optionKey[row.__id + level] || {};
+		return option.filter((i) => !i.title || !keyword || i.title.includes(keyword)).map((i) => {
+			return {
+				...i,
+				children: i.isExpandField ? recursionTreeFilterByKeyword(i, level + 1, optionKey) : []
+			};
+		});
+	}
+	return {
+		visibleValue,
+		filterOptions,
+		getChildrenOptionsByKey,
+		fieldValues,
+		fieldMapByKey
+	};
+}
+function createTitleItem(title) {
+	return {
+		value: title,
+		label: h("div", { class: "gct-option-title ell" }, title),
+		isLeaf: false,
+		__props: {},
+		isExpandField: false
+	};
+}
+var getFileldLabel = (labels, isExpandField, onClick) => {
+	return createVNode("div", {
+		"class": "ell gct-option-label ks-row",
+		"onClick": onClick
+	}, [createVNode("div", { "class": "ks-col ell" }, [createTextVNode(" "), labels]), isExpandField ? createVNode("span", { "class": "iconfont icon-pad_arrow_right" }, null) : null]);
+};
+var isExpandFieldArg = [
+	FIELD_TYPE.RDO_REF,
+	FIELD_TYPE.REF,
+	FIELD_TYPE.REF_MULTI
+];
+//#endregion
+export { useFieldCascader };

package/es/components/field-transfer/components/Cascader/FieldCascader.d.ts

@@ -0,0 +1,25 @@
+import { PropType } from 'vue';
+import { SCOPEINFO } from '@gct-paas/core';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    scope: {
+        type: PropType<SCOPEINFO>;
+        default: SCOPEINFO;
+    };
+    isShowCascader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    scope: {
+        type: PropType<SCOPEINFO>;
+        default: SCOPEINFO;
+    };
+    isShowCascader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    isShowCascader: boolean;
+    scope: SCOPEINFO;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/es/components/field-transfer/components/Cascader/FieldCascader.mjs

@@ -0,0 +1,150 @@
+import { useModelField } from "../../../../hooks/use-model-field/use-model-field.mjs";
+import "../../../../hooks/index.mjs";
+import '../../less/FieldCascader.css';/* empty css                             */
+import { has, isEmpty } from "lodash-es";
+import { FIELD_TYPE, SCOPEINFO, t } from "@gct-paas/core";
+import { Fragment, computed, createTextVNode, createVNode, defineComponent, ref } from "vue";
+import { DownOutlined } from "@ant-design/icons-vue";
+import { Cascader, Tooltip } from "ant-design-vue";
+//#region src/components/field-transfer/components/Cascader/FieldCascader.tsx
+var FieldCascader_default = /* @__PURE__ */ defineComponent({
+	name: "FieldCascader",
+	props: {
+		scope: {
+			type: String,
+			default: SCOPEINFO.FIELD_FORM
+		},
+		isShowCascader: {
+			type: Boolean,
+			default: true
+		}
+	},
+	setup(props) {
+		const { fieldCascaderSelectValue, objInfo, getModelInfo, getModelFieldInfo, fetchDetailList, changeSelectInfo } = useModelField(props.scope);
+		const visible = ref(false);
+		const isReadyonly = computed(() => {
+			return !props.isShowCascader || objInfo.value.relateObjList.length === 0;
+		});
+		const handleClickItem = async (_e, item) => {
+			visible.value = false;
+			const key = has(item, "fieldKey") ? item.bindModelKey : item.modelKey;
+			await fetchDetailList(key);
+			changeSelectInfo(key, item);
+		};
+		const renderOptions = () => {
+			const label = (item, showIcon = false) => {
+				const modelInfo = getModelInfo(item.bindModelKey || item.modelKey);
+				if (modelInfo) {
+					let name = createVNode("span", { "class": "field-ops-name" }, [modelInfo.modelName]);
+					if (item.belongModelKey && item.fieldKey !== "ref_master_id_") {
+						const fieldInfo = getModelFieldInfo(item.belongModelKey, item.fieldKey);
+						if (fieldInfo) name = createVNode("span", { "class": "field-ops-name" }, [fieldInfo.name, createVNode("span", { "class": "field-ops-desc" }, [
+							createTextVNode("（"),
+							modelInfo.modelName,
+							createTextVNode("）")
+						])]);
+					}
+					return createVNode(Fragment, null, [createVNode("div", {
+						"class": "field-ops",
+						"onClick": (e) => handleClickItem(e, item)
+					}, [name]), showIcon && createVNode("i", { "class": "iconfont icon-a-Rightarrow" }, null)]);
+				}
+				return null;
+			};
+			const tipOptInfo = (label, value) => {
+				return {
+					label: createVNode("div", { "class": "field-ops" }, [createVNode("span", { "class": "field-ops-name" }, [label])]),
+					value,
+					isLeaf: true,
+					disabled: true
+				};
+			};
+			const options = [];
+			if (!isEmpty(objInfo.value)) {
+				const recursive = (fieldItem) => {
+					if (!fieldItem.relateObjList) return [];
+					return [tipOptInfo(t("sys.component.fieldTransfer.linkModel"), "link")].concat(fieldItem.relateObjList.filter((item) => FIELD_TYPE.ASSOCIATED_PRIMARY_KEY !== item.fieldType).map((item) => {
+						const isShowIcon = item.children.length !== 0;
+						return {
+							label: label(item, isShowIcon),
+							value: item.fieldCodeChain,
+							isLeaf: false,
+							children: isShowIcon ? [tipOptInfo(t("sys.component.fieldTransfer.linkModel"), "link")].concat(item.children.map((i) => {
+								return {
+									label: label(i),
+									value: i.fieldCodeChain
+								};
+							})) : []
+						};
+					}));
+				};
+				const mainModelList = objInfo.value.relateObjList?.filter((item) => FIELD_TYPE.ASSOCIATED_PRIMARY_KEY === item.fieldType);
+				let subMainOpts = [];
+				if (mainModelList.length) subMainOpts = [tipOptInfo(t("sys.component.fieldTransfer.subMainModel"), "submain")].concat(mainModelList.map((item) => ({
+					label: label(item),
+					value: item.fieldCodeChain
+				})));
+				const children = recursive(objInfo.value);
+				options.push(tipOptInfo(t("sys.component.fieldTransfer.currentModel"), "current"));
+				options.push({
+					label: label(objInfo.value, children.length >= 2),
+					value: objInfo.value.fieldCodeChain,
+					children: children.length >= 2 ? children : [],
+					isLeaf: false
+				});
+				options.push(...subMainOpts);
+			}
+			return options;
+		};
+		const renderSelectName = () => {
+			let fieldName = createVNode("span", null, null);
+			let name = "";
+			let lastName = "";
+			if (fieldCascaderSelectValue.value && fieldCascaderSelectValue.value.length > 0) fieldCascaderSelectValue.value.forEach((pos) => {
+				const fieldCodeChainObj = JSON.parse(pos);
+				if (has(fieldCodeChainObj, "bindFieldKey")) {
+					const belongModelInfo = getModelInfo(fieldCodeChainObj.belongModelKey);
+					const fieldInfo = getModelFieldInfo(fieldCodeChainObj.belongModelKey, fieldCodeChainObj.bindFieldKey);
+					const bindModelInfo = getModelInfo(fieldCodeChainObj.bindModelKey);
+					if (belongModelInfo && fieldInfo && bindModelInfo) {
+						if (fieldInfo.key !== "ref_master_id_") name += `${belongModelInfo.modelName}  /  `;
+						if (fieldInfo.type === FIELD_TYPE.ASSOCIATED_PRIMARY_KEY) lastName = bindModelInfo.modelName;
+						else lastName = `${fieldInfo.name}(${bindModelInfo.modelName})`;
+					}
+				} else {
+					const modelInfo = getModelInfo(fieldCodeChainObj.modelKey);
+					if (modelInfo) lastName = modelInfo.modelName;
+				}
+			});
+			else if (objInfo.value.modelKey) {
+				const modelInfo = getModelInfo(JSON.parse(objInfo.value.fieldCodeChain).modelKey);
+				if (modelInfo) lastName = modelInfo.modelName;
+			}
+			fieldName = createVNode("span", null, [
+				createVNode("span", { "class": "bread" }, [createVNode("span", { "class": "field-cascader-title" }, [t("sys.component.fieldTransfer.soModelTitle")]), name]),
+				createVNode(Tooltip, { "title": t("sys.model.modelKey") + "：" + objInfo.value.modelKey }, { default: () => [createVNode("span", { "class": "last-name" }, [lastName])] }),
+				!isReadyonly.value && createVNode(DownOutlined, { "class": "ml-4px down-icon" }, null)
+			]);
+			return fieldName;
+		};
+		return () => {
+			return createVNode("div", {
+				"class": "field-cascader",
+				"style": { cursor: isReadyonly.value ? "default" : "pointer" }
+			}, [createVNode(Cascader, {
+				"dropdownClassName": "field-popup-cascader",
+				"options": renderOptions(),
+				"value": fieldCascaderSelectValue.value,
+				"onUpdate:value": ($event) => fieldCascaderSelectValue.value = $event,
+				"expandTrigger": "hover",
+				"onDropdownVisibleChange": (v) => {
+					visible.value = v;
+				},
+				"open": isReadyonly.value ? false : visible.value,
+				"changeOnSelect": true
+			}, { default: () => [createVNode("div", null, [renderSelectName(), createTextVNode(" ")])] })]);
+		};
+	}
+});
+//#endregion
+export { FieldCascader_default as default };

package/es/components/field-transfer/components/Transfer/AdvancedColumnSetting.d.ts

@@ -0,0 +1,46 @@
+import { PropType } from 'vue';
+import { FieldItem, ColumnItem, ColumnsChange } from '../../types/index.d';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    /** 所有字段 */
+    fields: {
+        type: PropType<FieldItem[]>;
+        required: true;
+    };
+    /** 树形数据 */
+    columns: PropType<ColumnItem[]>;
+    /** 是否启用多级表头 */
+    useMultiLevelTHead: BooleanConstructor;
+    /** 是否刷新数据 */
+    isResetData: BooleanConstructor;
+    /** 是否支持拖拽 */
+    draggable: BooleanConstructor;
+    /** 穿梭框标题集合 */
+    titles: PropType<string[]>;
+    maxEnableCount: PropType<number>;
+    /** 回调方法 */
+    onColumnsChange: PropType<ColumnsChange>;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    /** 所有字段 */
+    fields: {
+        type: PropType<FieldItem[]>;
+        required: true;
+    };
+    /** 树形数据 */
+    columns: PropType<ColumnItem[]>;
+    /** 是否启用多级表头 */
+    useMultiLevelTHead: BooleanConstructor;
+    /** 是否刷新数据 */
+    isResetData: BooleanConstructor;
+    /** 是否支持拖拽 */
+    draggable: BooleanConstructor;
+    /** 穿梭框标题集合 */
+    titles: PropType<string[]>;
+    maxEnableCount: PropType<number>;
+    /** 回调方法 */
+    onColumnsChange: PropType<ColumnsChange>;
+}>> & Readonly<{}>, {
+    draggable: boolean;
+    useMultiLevelTHead: boolean;
+    isResetData: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/es/components/field-transfer/components/Transfer/AdvancedColumnSetting.mjs

@@ -0,0 +1,45 @@
+import { useTreeData } from "../../hooks/useTreeData.mjs";
+import AdvancedTransfer_default from "./AdvancedTransfer.mjs";
+import { createVNode, defineComponent, watch } from "vue";
+//#region src/components/field-transfer/components/Transfer/AdvancedColumnSetting.tsx
+var AdvancedColumnSetting_default = /* @__PURE__ */ defineComponent({
+	name: "AdvancedColumnSetting",
+	props: {
+		fields: {
+			type: Array,
+			required: true
+		},
+		columns: Array,
+		useMultiLevelTHead: Boolean,
+		isResetData: Boolean,
+		draggable: Boolean,
+		titles: Array,
+		maxEnableCount: Number,
+		onColumnsChange: Function
+	},
+	setup(props, { expose }) {
+		const treeObj = useTreeData(props.useMultiLevelTHead, props.isResetData, props.draggable, props.maxEnableCount, props.onColumnsChange);
+		watch([() => props.columns, () => props.fields], () => {
+			treeObj.onChangeTree(props.columns ?? [], props.fields);
+		}, {
+			deep: true,
+			immediate: true
+		});
+		const getResult = () => {
+			return {
+				useMultiLevelTHead: treeObj.multiple,
+				headerTree: treeObj.data
+			};
+		};
+		expose({ getResult });
+		return () => {
+			return createVNode(AdvancedTransfer_default, {
+				"dataSource": props.fields,
+				"treeObj": treeObj,
+				"titles": props.titles
+			}, null);
+		};
+	}
+});
+//#endregion
+export { AdvancedColumnSetting_default as default };

package/es/components/field-transfer/components/Transfer/AdvancedTransfer.d.ts

@@ -0,0 +1,39 @@
+import { PropType } from 'vue';
+import { FieldItem } from '../../types/index.d';
+import { TreeProps } from '../../hooks/useTreeData';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    /** 数据源 */
+    dataSource: {
+        type: PropType<FieldItem[]>;
+        required: true;
+    };
+    /** useTreeData */
+    treeObj: {
+        type: PropType<TreeProps>;
+        required: true;
+    };
+    /** 穿梭框标题集合 */
+    titles: {
+        type: PropType<string[]>;
+        default(): string[];
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    /** 数据源 */
+    dataSource: {
+        type: PropType<FieldItem[]>;
+        required: true;
+    };
+    /** useTreeData */
+    treeObj: {
+        type: PropType<TreeProps>;
+        required: true;
+    };
+    /** 穿梭框标题集合 */
+    titles: {
+        type: PropType<string[]>;
+        default(): string[];
+    };
+}>> & Readonly<{}>, {
+    titles: string[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;