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

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

@@ -0,0 +1,124 @@
+import TransferTree_default from "./TransferTree.mjs";
+import '../../less/AdvancedTransfer.css';/* empty css                                */
+import { FieldIconMap, t } from "@gct-paas/core";
+import { computed, createVNode, defineComponent, ref, toRefs, watch } from "vue";
+import { Empty, Transfer } from "ant-design-vue";
+//#region src/components/field-transfer/components/Transfer/AdvancedTransfer.tsx
+var noData = "/extras-assets/design-view/pic_nodata.svg";
+var noSearchData = "/extras-assets/design-view/pic_noresult.svg";
+var AdvancedTransfer_default = /* @__PURE__ */ defineComponent({
+	name: "AdvancedTransfer",
+	props: {
+		dataSource: {
+			type: Array,
+			required: true
+		},
+		treeObj: {
+			type: Object,
+			required: true
+		},
+		titles: {
+			type: Array,
+			default() {
+				return [t("sys.component.fieldTransfer.noSelect"), t("sys.component.fieldTransfer.select")];
+			}
+		}
+	},
+	setup(props) {
+		const { dataSource: propDataSource } = toRefs(props);
+		const { remainCount: propRemainCount, leafKeys, multiple } = toRefs(props.treeObj);
+		const checkedKeys = ref([]);
+		const targetCheckedKeys = ref([]);
+		const keyword = ref();
+		const hasSearchData = ref(true);
+		const remainCount = computed(() => {
+			return propRemainCount.value - checkedKeys.value.length;
+		});
+		const dataSource = computed(() => {
+			return propDataSource.value.map((item) => {
+				return {
+					...item,
+					disabled: item.disabled || remainCount.value === 0 && !checkedKeys.value.includes(item.id) && !leafKeys.value.includes(item.id)
+				};
+			});
+		});
+		watch(multiple, (val) => {
+			if (val) targetCheckedKeys.value = [];
+		}, { immediate: true });
+		const onSelectChange = (sourceSelectedKeys, targetSelectedKeys) => {
+			checkedKeys.value = sourceSelectedKeys.slice(0, propRemainCount.value);
+			targetCheckedKeys.value = targetSelectedKeys;
+		};
+		const onChange = (_, direction, moveKeys) => {
+			if (direction === "right") {
+				const nodes = moveKeys.map((key) => dataSource.value.find((item) => item.id === key)).map((item) => ({
+					key: item.id,
+					title: item.displayLabel,
+					type: "field",
+					fieldType: item.type,
+					isLeaf: true
+				}));
+				props.treeObj.addTreeNodes(nodes, props.treeObj.getContainerNode());
+			} else props.treeObj.removeTreeNodesByKeys(moveKeys);
+		};
+		const setTargetCheckedKeys = (keys) => {
+			targetCheckedKeys.value = keys;
+		};
+		const leftOption = computed(() => {
+			return dataSource.value.filter((item) => !leafKeys.value.includes(item.id));
+		});
+		const filteredLeftOption = computed(() => {
+			if (!keyword.value) return leftOption.value;
+			return leftOption.value.filter((item) => item.displayLabel.toLowerCase().includes(keyword.value.toLowerCase()));
+		});
+		const onSearch = (direction, value) => {
+			if (direction === "left") {
+				keyword.value = value;
+				hasSearchData.value = filteredLeftOption.value.length > 0;
+			}
+		};
+		/** 每行数据渲染函数  */
+		const renderItem = ({ type, displayLabel }) => {
+			return createVNode("div", {
+				"class": "field-title",
+				"title": displayLabel
+			}, [createVNode("i", { "class": ["field-icon iconfont", FieldIconMap[type] || "icon-zidingyi"] }, null), displayLabel]);
+		};
+		const slots = { children: ({ direction }) => {
+			if (direction === "right") return createVNode(TransferTree_default, {
+				"treeObj": props.treeObj,
+				"checkedKeys": targetCheckedKeys.value,
+				"onCheckedKeysChange": setTargetCheckedKeys
+			}, null);
+			if (direction === "left" && (!leftOption.value.length || !filteredLeftOption.value.length)) return createVNode("div", { "class": "empty-container" }, [createVNode(Empty, {
+				"image": leftOption.value.length ? noSearchData : noData,
+				"description": leftOption.value.length ? t("sys.component.fieldTransfer.noSearchData") : t("sys.component.fieldTransfer.noData")
+			}, null)]);
+		} };
+		return () => {
+			return createVNode("div", { "class": "advanced-transfer-container" }, [createVNode(Transfer, {
+				"dataSource": dataSource.value,
+				"targetKeys": leafKeys.value,
+				"selectedKeys": checkedKeys.value.concat(targetCheckedKeys.value),
+				"showSearch": true,
+				"filterOption": (text, item) => item.displayLabel.includes(text),
+				"oneWay": multiple.value,
+				"titles": props.titles,
+				"locale": {
+					itemUnit: t("sys.component.fieldTransfer.term"),
+					itemsUnit: t("sys.component.fieldTransfer.term"),
+					searchPlaceholder: t("sys.component.fieldTransfer.pleaseSearch"),
+					selectAll: t("sys.component.fieldTransfer.selectAllData"),
+					selectInvert: t("sys.component.fieldTransfer.invertCurrentPage")
+				},
+				"rowKey": (item) => item.id,
+				"onChange": onChange,
+				"onSearch": onSearch,
+				"onSelectChange": onSelectChange,
+				"render": renderItem
+			}, slots)]);
+		};
+	}
+});
+//#endregion
+export { AdvancedTransfer_default as default };

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

@@ -0,0 +1,83 @@
+import { PropType } from 'vue';
+import { ISelectObj } from '../../../../hooks';
+import { FIELD_TYPE, CreateType } from '@gct-paas/core';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    objFields: PropType<ISelectObj>;
+    /** 选中的字段数组 */
+    value: {
+        (arrayLength: number): IObject[];
+        (...items: IObject[]): IObject[];
+        new (arrayLength: number): IObject[];
+        new (...items: IObject[]): IObject[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    };
+    /** 穿梭框标题集合 */
+    titles: PropType<string[]>;
+    maxEnableCount: PropType<number>;
+    disabledFieldKey: PropType<string[]>;
+    /** 包含的字段 */
+    containFieldType: PropType<FIELD_TYPE[]>;
+    /** 包含的字段Key */
+    containFieldKey: PropType<string[]>;
+    /**包含的字段创建类型 */
+    containCreateType: PropType<CreateType[]>;
+    /** 排除的字段Key */
+    excludeFieldKey: PropType<string[]>;
+    /** 排除的字段 */
+    excludeFieldType: PropType<FIELD_TYPE[]>;
+    /**过滤函数 */
+    filterFieldByFunction: FunctionConstructor;
+    onChange: FunctionConstructor;
+    /** 是否支持拖拽 */
+    draggable: BooleanConstructor;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    objFields: PropType<ISelectObj>;
+    /** 选中的字段数组 */
+    value: {
+        (arrayLength: number): IObject[];
+        (...items: IObject[]): IObject[];
+        new (arrayLength: number): IObject[];
+        new (...items: IObject[]): IObject[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    };
+    /** 穿梭框标题集合 */
+    titles: PropType<string[]>;
+    maxEnableCount: PropType<number>;
+    disabledFieldKey: PropType<string[]>;
+    /** 包含的字段 */
+    containFieldType: PropType<FIELD_TYPE[]>;
+    /** 包含的字段Key */
+    containFieldKey: PropType<string[]>;
+    /**包含的字段创建类型 */
+    containCreateType: PropType<CreateType[]>;
+    /** 排除的字段Key */
+    excludeFieldKey: PropType<string[]>;
+    /** 排除的字段 */
+    excludeFieldType: PropType<FIELD_TYPE[]>;
+    /**过滤函数 */
+    filterFieldByFunction: FunctionConstructor;
+    onChange: FunctionConstructor;
+    /** 是否支持拖拽 */
+    draggable: BooleanConstructor;
+}>> & Readonly<{}>, {
+    draggable: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

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

@@ -0,0 +1,112 @@
+import { useModelField } from "../../../../hooks/use-model-field/use-model-field.mjs";
+import "../../../../hooks/index.mjs";
+import AdvancedColumnSetting_default from "./AdvancedColumnSetting.mjs";
+import { isEmpty } from "lodash-es";
+import { SCOPEINFO } from "@gct-paas/core";
+import { computed, createVNode, defineComponent, toRaw } from "vue";
+//#region src/components/field-transfer/components/Transfer/FieldTransfer.tsx
+var FieldTransfer_default = /* @__PURE__ */ defineComponent({
+	name: "FieldTransfer",
+	props: {
+		objFields: Object,
+		value: Array,
+		titles: Array,
+		maxEnableCount: Number,
+		disabledFieldKey: Array,
+		containFieldType: Array,
+		containFieldKey: Array,
+		containCreateType: Array,
+		excludeFieldKey: Array,
+		excludeFieldType: Array,
+		filterFieldByFunction: Function,
+		onChange: Function,
+		draggable: Boolean
+	},
+	setup(props) {
+		const { getFieldCodeChainStr } = useModelField(SCOPEINFO.FIELD_LIST);
+		const result = computed(() => {
+			const fields = [];
+			const _fieldMap = {};
+			const processColumns = [];
+			if (!props.objFields?.modelKey) return {
+				fields,
+				fieldMap: _fieldMap,
+				columns: processColumns,
+				otherFieldCount: 0
+			};
+			if (Array.isArray(props.value)) props.value.forEach((item) => {
+				const key = `${item.fieldCodeChain}!${item.key}`;
+				_fieldMap[key] = item;
+				if (item.fieldCodeChain !== (props.objFields?.fieldCodeChain ?? props.objFields?.modelKey)) fields.push({
+					id: key,
+					modelKey: item.modelKey,
+					displayLabel: item.name,
+					type: item.type,
+					disabled: item.disabled
+				});
+				processColumns.push({
+					id: key,
+					title: item.name,
+					tooltip: getFieldCodeChainStr(item.fieldCodeChain, item.name),
+					fieldType: item.type,
+					type: "field"
+				});
+			});
+			props.objFields.fieldList.filter((flist) => {
+				if (typeof props.filterFieldByFunction === "function" && !props.filterFieldByFunction(flist)) return false;
+				if (props.containCreateType && flist.createType && !props.containCreateType.includes(flist.createType)) return false;
+				if (props.containFieldType || props.containFieldKey) {
+					const isContainFieldType = (props.containFieldType ?? []).includes(flist.type);
+					const isContainFieldKey = (props.containFieldKey ?? []).includes(flist.key);
+					return isContainFieldType || isContainFieldKey;
+				}
+				if (props.excludeFieldType || props.excludeFieldKey) {
+					const isExcludeFieldType = (props.excludeFieldType ?? []).includes(flist.type);
+					const isExcludeFieldKey = (props.excludeFieldKey ?? []).includes(flist.key);
+					return !(isExcludeFieldType || isExcludeFieldKey);
+				}
+				return true;
+			}).forEach((fl) => {
+				const key = `${props.objFields?.fieldCodeChain}!${fl.key}`;
+				if (isEmpty(_fieldMap[key])) _fieldMap[key] = {
+					...toRaw(fl),
+					isFieldModel: props.objFields?.isFieldModel,
+					fieldCodeChain: props.objFields?.fieldCodeChain
+				};
+				const isMainModel = props?.objFields?.fieldCodeChain && JSON.parse(props.objFields?.fieldCodeChain).modelKey && JSON.parse(props.objFields?.fieldCodeChain).modelKey === props.objFields?.modelKey;
+				fields.push({
+					id: key,
+					modelKey: fl.modelKey,
+					displayLabel: fl.name,
+					type: fl.type,
+					disabled: !!(isMainModel && props.disabledFieldKey?.includes(fl.key))
+				});
+			});
+			return {
+				fields,
+				fieldMap: _fieldMap,
+				columns: processColumns,
+				otherFieldCount: processColumns.reduce((pre, cur) => {
+					return pre + (cur.disableCheckbox ? 1 : 0);
+				}, 0)
+			};
+		});
+		const handleColumnsChange = (columns) => {
+			if (typeof props?.onChange === "function") props?.onChange(columns.map((column) => result.value.fieldMap[column.id]));
+		};
+		return () => {
+			return createVNode(AdvancedColumnSetting_default, {
+				"key": props.objFields?.fieldCodeChain ?? props.objFields?.modelKey,
+				"fields": result.value.fields,
+				"columns": result.value.columns,
+				"useMultiLevelTHead": false,
+				"titles": props.titles,
+				"maxEnableCount": props.maxEnableCount,
+				"draggable": props.draggable,
+				"onColumnsChange": handleColumnsChange
+			}, null);
+		};
+	}
+});
+//#endregion
+export { FieldTransfer_default as default };

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

@@ -0,0 +1,62 @@
+import { PropType } from 'vue';
+import { TreeProps } from '../../hooks/useTreeData';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    /** useTreeData */
+    treeObj: {
+        type: PropType<TreeProps>;
+        required: true;
+    };
+    checkedKeys: {
+        type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        required: true;
+    };
+    onCheckedKeysChange: {
+        type: FunctionConstructor;
+        required: true;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    /** useTreeData */
+    treeObj: {
+        type: PropType<TreeProps>;
+        required: true;
+    };
+    checkedKeys: {
+        type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        required: true;
+    };
+    onCheckedKeysChange: {
+        type: FunctionConstructor;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

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

@@ -0,0 +1,84 @@
+import { traverseFilter } from "../../utils/tree-tool.mjs";
+import TreeItem_default from "./TreeItem.mjs";
+import '../../less/TransferTree.css';/* empty css                            */
+import { FieldIconMap, t } from "@gct-paas/core";
+import { computed, createVNode, defineComponent, ref, toRefs } from "vue";
+import { Empty, Input, Tree } from "ant-design-vue";
+//#region src/components/field-transfer/components/Transfer/TransferTree.tsx
+var noData = "/extras-assets/design-view/pic_nodata.svg";
+var noSearchData = "/extras-assets/design-view/pic_noresult.svg";
+var TransferTree_default = /* @__PURE__ */ defineComponent({
+	name: "TransferTree",
+	props: {
+		treeObj: {
+			type: Object,
+			required: true
+		},
+		checkedKeys: {
+			type: Array,
+			required: true
+		},
+		onCheckedKeysChange: {
+			type: Function,
+			required: true
+		}
+	},
+	setup(props) {
+		const { data, draggable } = toRefs(props.treeObj);
+		const keyword = ref("");
+		const filteredTreeData = computed(() => {
+			if (!keyword.value) return data.value;
+			return traverseFilter((node) => node.title.toLowerCase().includes(keyword.value.toLowerCase()), data.value);
+		});
+		const handleCheckedKeys = (keys) => {
+			if (!keyword.value) {
+				props.onCheckedKeysChange(keys);
+				return;
+			}
+			const nextKeys = keys.concat(props.checkedKeys.filter((key) => !keys.includes(key) && !filteredTreeData.value.some((item) => item.key === key)));
+			props.onCheckedKeysChange(nextKeys);
+		};
+		const slots = { title: (node) => {
+			return createVNode(TreeItem_default, {
+				"node": node,
+				"draggable": draggable.value
+			}, null);
+		} };
+		return () => {
+			return createVNode("div", { "class": "transfer-tree-container" }, [createVNode("div", { "class": "search-container" }, [createVNode(Input, {
+				"placeholder": t("sys.component.fieldTransfer.pleaseSearch"),
+				"value": keyword.value,
+				"onChange": (e) => keyword.value = e.target.value,
+				"allowClear": true,
+				"prefix": createVNode("i", { "class": ["search-icon iconfont", " icon-sousuo"] }, null)
+			}, null)]), createVNode("div", {
+				"class": "tree-wrapper",
+				"style": { overflow: "auto" }
+			}, [filteredTreeData.value.length === 0 ? createVNode("div", { "class": "empty-container" }, [createVNode(Empty, {
+				"image": keyword.value ? noSearchData : noData,
+				"description": keyword.value ? t("sys.component.fieldTransfer.noSearchData") : t("sys.component.fieldTransfer.noData")
+			}, null)]) : createVNode(Tree, {
+				"showIcon": true,
+				"showLine": { showLeafIcon: false },
+				"blockNode": true,
+				"draggable": draggable.value ? { icon: false } : false,
+				"checkedKeys": props.checkedKeys,
+				"onCheck": handleCheckedKeys,
+				"multiple": true,
+				"checkable": true,
+				"icon": (node) => createVNode("i", { "class": ["iconfont", node.isLeaf ? FieldIconMap[node.fieldType] || "icon-zidingyi" : "icon-file"] }, null),
+				"onSelect": (_, { selectedNodes }) => {
+					handleCheckedKeys(selectedNodes.map((node) => node.key));
+				},
+				"treeData": filteredTreeData.value,
+				"onDrop": ({ node, dragNode, dropToGap, dropPosition }) => {
+					const dropPos = node.pos.split("-");
+					const dir = dropPosition - Number(dropPos[dropPos.length - 1]);
+					if (dropToGap) props.treeObj.moveTreeNode(dragNode.dataRef, node.dataRef, dir);
+				}
+			}, slots)])]);
+		};
+	}
+});
+//#endregion
+export { TransferTree_default as default };

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

@@ -0,0 +1,17 @@
+import { PropType } from 'vue';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    node: {
+        type: PropType<IObject>;
+        required: true;
+    };
+    draggable: BooleanConstructor;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    node: {
+        type: PropType<IObject>;
+        required: true;
+    };
+    draggable: BooleanConstructor;
+}>> & Readonly<{}>, {
+    draggable: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

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

@@ -0,0 +1,25 @@
+import '../../less/TreeItem.css';/* empty css                        */
+import { t } from "@gct-paas/core";
+import { computed, createVNode, defineComponent } from "vue";
+import { Tooltip } from "ant-design-vue";
+//#region src/components/field-transfer/components/Transfer/TreeItem.tsx
+var TreeItem_default = /* @__PURE__ */ defineComponent({
+	name: "TreeItem",
+	props: {
+		node: {
+			type: Object,
+			required: true
+		},
+		draggable: Boolean
+	},
+	setup(props) {
+		const editing = computed(() => {
+			return props.node.isNew;
+		});
+		return () => {
+			return createVNode("div", { "class": "tree-item-container" }, [createVNode("div", { "class": "tree-title" }, [createVNode(Tooltip, { "title": props.node.tooltip }, { default: () => [createVNode("span", null, [props.node.title || "-"])] })]), !editing.value && props.draggable && !props.node?.disabled && !props.node?._preset && createVNode("div", { "class": "operation-container" }, [createVNode(Tooltip, { "title": t("sys.component.fieldTransfer.move") }, { default: () => [createVNode("i", { "class": ["iconfont", "icon-drag"] }, null)] })])]);
+		};
+	}
+});
+//#endregion
+export { TreeItem_default as default };

package/es/components/field-transfer/components/field-transfer-modal.vue.d.ts

@@ -0,0 +1,43 @@
+import { FIELD_TYPE, CreateType } from '@gct-paas/core';
+export interface Prop {
+    /** 模型key */
+    modelKey: string;
+    /** 是否显示级联选择 */
+    isShowCascader?: boolean;
+    /** 弹框标题 */
+    modalTitle?: string;
+    /** 选中的字段数组 */
+    data?: IObject[];
+    /** 穿梭框标题集合 */
+    titles?: string[];
+    /** 包含的字段 */
+    containFieldType?: FIELD_TYPE[];
+    /** 包含的字段Key */
+    containFieldKey?: string[];
+    /** 禁用的字段 */
+    disabledFieldKey?: string[];
+    /** 排除的字段key */
+    excludeFieldKey?: string[];
+    /** 排除的字段 */
+    excludeFieldType?: FIELD_TYPE[];
+    /**包含的字段创建类型 */
+    containCreateType?: CreateType[];
+    /**自定义过滤函数 */
+    filterFieldByFunction?: (field: IObject) => boolean;
+    /** 最大选择个数 */
+    maxEnableCount?: number;
+    modalKey?: string;
+    /** 是否支持拖拽 */
+    draggable?: boolean;
+    /**
+     * 子表的关联主键字段的父模型字段
+     */
+    childParentModelKey?: string;
+    destroyCallback?: () => void;
+    saveCallback?: (params: IObject) => void;
+    promptMessage?: string;
+}
+declare const _default: import('vue').DefineComponent<Prop, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Prop> & Readonly<{}>, {
+    draggable: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/es/components/field-transfer/components/field-transfer-modal.vue.mjs

@@ -0,0 +1,7 @@
+import _plugin_vue_export_helper_default from "../../../_virtual/_plugin-vue_export-helper.mjs";
+import field_transfer_modal_vue_vue_type_script_setup_true_name_field_transfer_modal_lang_default from "./field-transfer-modal.vue_vue_type_script_setup_true_name_field-transfer-modal_lang.mjs";
+import './field-transfer-modal.vue_vue_type_style_index_0_scoped_0c9dd8a1_lang.css';/* empty css                                                                           */
+//#region src/components/field-transfer/components/field-transfer-modal.vue
+var field_transfer_modal_default = /* @__PURE__ */ _plugin_vue_export_helper_default(field_transfer_modal_vue_vue_type_script_setup_true_name_field_transfer_modal_lang_default, [["__scopeId", "data-v-0c9dd8a1"]]);
+//#endregion
+export { field_transfer_modal_default as default };