@gct-paas/core-web 0.1.6-dev.2 → 0.1.6-dev.20

package/es/modules/data-rules-container/src/hooks/useDataRulesTree.d.ts

@@ -0,0 +1,30 @@
+export declare function useDataRulesTree(isReadyOnly: boolean): {
+    setTree: (data: string) => void;
+    showDataRulesTree: import('vue').Ref<IObject[], IObject[]>;
+    editDataRulesTree: import('vue').Ref<IObject[], IObject[]>;
+    addNewGroup: (id: string) => void;
+    addNewRow: (pid: string, id?: string) => void;
+    deleteGroup: (id: string) => void;
+    deleteRow: (id: string) => void;
+    updateNodeItem: (id: string, attr: string, value: IObject | string | string[] | number | null | undefined, opts?: IObject) => void;
+    getDataRules: (type: string, mainModelKey: string) => {
+        exp?: undefined;
+        error: never;
+        query?: undefined;
+        varKeys?: undefined;
+        treeStr?: undefined;
+        typeMap?: undefined;
+    } | {
+        error?: undefined;
+        query: {};
+        varKeys: string[];
+        exp: string;
+        treeStr: string;
+        typeMap: {};
+    };
+    resetTree: () => void;
+    getAllExpandedKeys: () => {
+        allExpandedKeys: any[];
+        selectFiledKeys: any[];
+    };
+};

package/es/modules/data-rules-container/src/hooks/useDataRulesTree.mjs

@@ -0,0 +1,317 @@
+import { OperatorTypeEnum } from "../constant/interface.mjs";
+import { reactive, ref, toRaw } from "vue";
+import { isEmpty } from "lodash-es";
+import { FIELD_TYPE, SEARCH_SERVICE, t, useUUid } from "@gct-paas/core";
+//#region src/modules/data-rules-container/src/hooks/useDataRulesTree.ts
+var editDataRulesTree = ref([]);
+var showDataRulesTree = ref([]);
+function useDataRulesTree(isReadyOnly) {
+	const { getUuidGenerate } = useUUid(ref([]), ref(""), {
+		needPrefix: true,
+		isString: false,
+		prefix: "t_"
+	});
+	const uuidGenerate = getUuidGenerate([]);
+	const transfromReactive = (data) => {
+		return data.map((item) => {
+			const node = reactive(Object.assign({}, {
+				key: item.key,
+				pid: item.pid,
+				level: item.level,
+				class: item.class
+			}, item.type === "group" ? {
+				operatorType: item.operatorType,
+				type: item.type,
+				children: reactive([])
+			} : {
+				firstRow: item.firstRow,
+				leftValue: item.leftValue,
+				operatorValue: item.operatorValue,
+				rightValue: item.rightValue
+			}));
+			if (Array.isArray(item.children)) node.children?.push(...transfromReactive(item.children));
+			return node;
+		});
+	};
+	const setPageTreeItem = (data, len) => {
+		return data.forEach((item, index) => {
+			if (Array.isArray(item.children)) {
+				item.type = "group";
+				item.class = "tree-group";
+				if (isEmpty(item.operatorType)) item.operatorType = OperatorTypeEnum.AND;
+				setPageTreeItem(item.children, item.children.length);
+			} else {
+				const filterData = data.filter((item) => !item.children);
+				if (index === 0 || index === filterData.length - 1) {
+					item.class = `${index === 0 ? "first-node" : ""} ${index === filterData.length - 1 ? "last-node" : ""}`;
+					item.firstRow = index === 0;
+				} else item.class = "";
+				item.dataLen = len;
+			}
+		});
+	};
+	const addNode = ({ pid, insertId, data, isGroup = false, prevId = "" }) => {
+		if (pid === "init") {
+			const node = {
+				key: "root",
+				pid: "",
+				level: 1,
+				class: void 0,
+				operatorType: void 0,
+				type: void 0,
+				children: reactive([])
+			};
+			data.push(node);
+			return;
+		}
+		return data.forEach((item) => {
+			if (item.key === pid) {
+				const childrenNode = reactive(Object.assign({}, {
+					key: insertId,
+					pid: item.key,
+					level: Number(item.level) + 1,
+					class: ""
+				}, isGroup ? {
+					operatorType: void 0,
+					type: void 0,
+					children: reactive([])
+				} : {
+					firstRow: void 0,
+					leftValue: void 0,
+					operatorValue: void 0,
+					rightValue: void 0
+				}));
+				if (prevId) {
+					const index = item.children.findIndex((k) => k.key === prevId);
+					item.children.splice(index + 1, 0, childrenNode);
+				} else item.children.push(childrenNode);
+				item.children.forEach((i) => {
+					i.dataLen = item.children?.length;
+				});
+				return;
+			}
+			if (item.children) addNode({
+				pid,
+				insertId,
+				data: item.children,
+				isGroup,
+				prevId
+			});
+		});
+	};
+	const deleteNode = (id, data) => {
+		return data.forEach((item, index) => {
+			if (item.key === id) {
+				data.splice(index, 1);
+				return;
+			} else if (item.children) deleteNode(id, item.children);
+		});
+	};
+	const createGroupNodes = (data, pid, isInit = false) => {
+		const uuid = uuidGenerate.next();
+		addNode({
+			pid: isInit ? "init" : pid,
+			insertId: uuid,
+			data,
+			isGroup: true
+		});
+		addNode({
+			pid: isInit ? pid : uuid,
+			insertId: isInit ? uuid : uuidGenerate.next(),
+			data
+		});
+		setPageTreeItem(data);
+	};
+	const setTree = (data) => {
+		if (!data) createGroupNodes(isReadyOnly ? showDataRulesTree.value : editDataRulesTree.value, "root", true);
+		else {
+			console.log("转换成页面想要的tree结构", JSON.parse(data));
+			if (isReadyOnly) showDataRulesTree.value = transfromReactive(JSON.parse(data));
+			else editDataRulesTree.value = transfromReactive(JSON.parse(data));
+		}
+	};
+	const addNewGroup = (id) => {
+		createGroupNodes(editDataRulesTree.value, id);
+	};
+	const deleteGroup = (id) => {
+		deleteNode(id, editDataRulesTree.value);
+		setPageTreeItem(editDataRulesTree.value);
+	};
+	const addNewRow = (pid, id) => {
+		addNode({
+			pid,
+			insertId: uuidGenerate.next(),
+			data: editDataRulesTree.value,
+			isGroup: false,
+			prevId: id
+		});
+		setPageTreeItem(editDataRulesTree.value);
+	};
+	const deleteRow = (id) => {
+		deleteNode(id, editDataRulesTree.value);
+		setPageTreeItem(editDataRulesTree.value);
+	};
+	/** 递归查找是否存在树结构中的值 */
+	const findTreePathById = (leafId, nodes) => {
+		for (let i = 0; i < nodes.length; i++) {
+			if (leafId === nodes[i].key) return nodes[i];
+			if (nodes[i].children) {
+				const findResult = findTreePathById(leafId, nodes[i].children);
+				if (findResult) return findResult;
+			}
+		}
+		return null;
+	};
+	const updateNodeItem = (id, attr, value, opts) => {
+		const node = findTreePathById(id, editDataRulesTree.value);
+		if (!node) return;
+		if (attr === "rightValue") {
+			if (opts?.isRest) node.rightValue = reactive(opts.defaultValues.map((val) => {
+				return { [opts.key]: val };
+			}));
+			if (opts?.key === "valueType") node[attr][opts.index] = {};
+			node[attr][opts?.index][opts?.key] = value;
+		} else node[attr] = typeof value === "object" ? reactive(value) : value;
+		if (attr === "leftValue") {
+			/** 运算符 */
+			node.operatorValue = void 0;
+			/** 右值 */
+			node.rightValue = void 0;
+		} else if (attr === "operatorValue") node.rightValue = reactive(opts?.defaultValues?.map((val) => {
+			return { [opts.key]: val };
+		}));
+	};
+	const getAllExpandedKeys = () => {
+		const list = flatten(isReadyOnly ? showDataRulesTree.value : editDataRulesTree.value, "");
+		return {
+			allExpandedKeys: list.map((item) => item.key),
+			selectFiledKeys: list.map((item) => item.leftValue?.id).filter((i) => i)
+		};
+	};
+	const flatten = (array = [], pathStr) => {
+		return [].concat(...array.map((item) => {
+			item.pathStr = `${pathStr}|${item.children ? item.operatorType : "content"}`;
+			return [].concat({
+				key: item.key,
+				pid: item.pid,
+				operatorType: item.children ? item.operatorType : "content",
+				pathStr: item.pathStr,
+				leftValue: item.leftValue,
+				operatorValue: item.operatorValue,
+				rightValue: item.rightValue
+			}, flatten(item.children || [], item.pathStr));
+		}));
+	};
+	const getExpList = (array = [], parent, type) => {
+		return [].concat(...array.map((item) => {
+			let name = "";
+			if (!item.children && item.leftValue && item.leftValue.key && item.operatorValue && item.key) {
+				name = `${item.leftValue.field_search_key || item.leftValue.key}.${item.operatorValue}:${item.key}`;
+				if (type === "filterConfig") name = `${item.leftValue.modelKey}#${item.leftValue.key}.${item.operatorValue}:${item.key}`;
+				else if (type === "businessFlow") name = `${item.leftValue.nodeKey}.${item.leftValue.modelKey}.${item.operatorValue}:${item.key}`;
+			}
+			return [].concat(item.children ? [] : item.leftValue && item.leftValue.key && item.operatorValue && item.key ? {
+				name,
+				type: parent.operatorType,
+				operatorType: item.children ? item.operatorType : "content"
+			} : [], [getExpList(item.children || [], item, type)]);
+		}));
+	};
+	const filterExpList = (array) => {
+		const list = [];
+		array.forEach((item) => {
+			if (Array.isArray(item) && item.length !== 0) list.push(filterExpList(item));
+			else if (!Array.isArray(item) && item.operatorType === "content") list.push(item);
+		});
+		return list;
+	};
+	const setExpValue = (array) => {
+		const list = [];
+		array.forEach((item, index) => {
+			if (index === 0) list.push(`#before${item.type}#`);
+			if (Array.isArray(item) && item.length !== 0) list.push(...setExpValue(item));
+			else if (!Array.isArray(item)) list.push(item.name);
+			if (index === array.length - 1) list.push("#after#");
+		});
+		return list;
+	};
+	/** 递归得到数据规则算子 */
+	const getDataRules = (type, mainModelKey) => {
+		const list = flatten(isReadyOnly ? showDataRulesTree.value : editDataRulesTree.value, "");
+		let error;
+		const query = {};
+		const varKeys = [];
+		const typeMap = {};
+		list.forEach((item) => {
+			if (item.operatorType === "content") {
+				if (isEmpty(item.leftValue) || isEmpty(item.operatorValue) || isEmpty(item.rightValue)) {
+					error = t("sys.webRender.saveTip");
+					return;
+				}
+				let key = "";
+				if (type === "businessFlow") key = `${item.leftValue.nodeKey}.${item.leftValue.modelKey}.${item.operatorValue}:${item.key}`;
+				else if (type === "filterConfig") key = `${item.leftValue.modelKey}#${item.leftValue.key}.${item.operatorValue}:${item.key}`;
+				else key = `${item.leftValue.field_search_key || item.leftValue.key}.${item.operatorValue}:${item.key}`;
+				if ([SEARCH_SERVICE.ISNOTNULL, SEARCH_SERVICE.ISNULL].includes(item.operatorValue)) Object.assign(query, { [key]: null });
+				else {
+					if (item.rightValue.some((rv) => isEmpty(rv.result))) {
+						error = t("sys.webRender.saveTip");
+						return;
+					}
+					const types = [];
+					const values = item.rightValue.map((kk) => {
+						types.push(kk.valueType);
+						if (kk.valueType === "SYS") varKeys.push(key);
+						if ([
+							FIELD_TYPE.USER_MULTI,
+							FIELD_TYPE.ORG_MULTI,
+							FIELD_TYPE.USER,
+							FIELD_TYPE.ORG
+						].includes(item.leftValue.type) && kk.valueType === "FIXED") {
+							const _orgs = kk?.result?.orgs?.map((org) => `ORG:${org}`) ?? [];
+							const _users = kk?.result?.users?.map((user) => `USER:${user}`) ?? [];
+							if ([FIELD_TYPE.USER, FIELD_TYPE.ORG].includes(item.leftValue.type) && [SEARCH_SERVICE.EQ, SEARCH_SERVICE.NE].includes(item.operatorValue)) return [..._orgs, ..._users]?.[0];
+							return [..._orgs, ..._users];
+						}
+						return kk?.valueType === "FIELD" ? mainModelKey ? `__F__:${mainModelKey}.${kk?.result}` : `__F__:${kk?.result.replace("$", ".")}` : kk?.result;
+					});
+					Object.assign(typeMap, { [key]: types.length === 1 ? toRaw(types[0]) : toRaw(types) });
+					Object.assign(query, { [key]: values.length === 1 ? toRaw(values[0]) : toRaw(values) });
+				}
+			}
+		});
+		if (error) return { error };
+		const explist = setExpValue(filterExpList(getExpList((isReadyOnly ? showDataRulesTree.value : editDataRulesTree.value)[0].children, (isReadyOnly ? showDataRulesTree.value : editDataRulesTree.value)[0], type)));
+		const expStr = explist.toString().replace(/#beforeAND#,/g, "AND(").replace(/#beforeOR#,/g, "OR(").replace(/,#after#/g, ")");
+		console.warn("getDataRules query", query);
+		console.warn("getDataRules varKeys", varKeys);
+		console.warn("getDataRules explist", explist);
+		console.warn("getDataRules expStr", expStr);
+		return {
+			query,
+			varKeys,
+			exp: expStr,
+			treeStr: JSON.stringify(isReadyOnly ? showDataRulesTree.value : editDataRulesTree.value),
+			typeMap
+		};
+	};
+	const resetTree = () => {
+		if (isReadyOnly) showDataRulesTree.value = [];
+		else editDataRulesTree.value = [];
+	};
+	return {
+		setTree,
+		showDataRulesTree,
+		editDataRulesTree,
+		addNewGroup,
+		addNewRow,
+		deleteGroup,
+		deleteRow,
+		updateNodeItem,
+		getDataRules,
+		resetTree,
+		getAllExpandedKeys
+	};
+}
+//#endregion
+export { useDataRulesTree };

package/es/modules/data-rules-container/src/hooks/useEmitter.d.ts

@@ -0,0 +1,10 @@
+export declare enum EmitterEnum {
+    /** 打开编辑用户组弹框 */
+    on_edit_user_group = "on-edit-user-group",
+    on_refresh_detail = "on-refresh-detail",
+    on_delete_user_group = "on-delete-user-group"
+}
+export declare function useEmitter(): {
+    emitter: import('mitt').Emitter<Record<import('mitt').EventType, unknown>>;
+    EmitterEnum: typeof EmitterEnum;
+};

package/es/modules/data-rules-container/src/hooks/useRdoHooks.d.ts

@@ -0,0 +1,37 @@
+export declare function useAsyncOptions({ bindModelKey, modelCategory }: IObject): {
+    getChildrens: (ids?: string[]) => Promise<void>;
+    getAsyncOptions: (arg: IObject) => Promise<void>;
+    treeData: import('vue').Ref<({
+        [x: string]: any;
+        disabled?: boolean | undefined;
+        checkable?: boolean | undefined;
+        disableCheckbox?: boolean | undefined;
+        children?: /*elided*/ any[] | undefined;
+    } | {
+        [x: string]: any;
+        disabled?: boolean | undefined;
+        checkable?: boolean | undefined;
+        disableCheckbox?: boolean | undefined;
+        value?: import('ant-design-vue/lib/vc-tree-select/TreeSelect').RawValueType | undefined;
+        title?: any;
+        label?: any;
+        key?: import('ant-design-vue/lib/vc-tree-select/interface').Key | undefined;
+        children?: /*elided*/ any[] | undefined;
+    })[] | undefined, (import('ant-design-vue/lib/vc-tree-select/TreeSelect').BaseOptionType | import('ant-design-vue/lib/vc-tree-select/TreeSelect').DefaultOptionType)[] | ({
+        [x: string]: any;
+        disabled?: boolean | undefined;
+        checkable?: boolean | undefined;
+        disableCheckbox?: boolean | undefined;
+        children?: /*elided*/ any[] | undefined;
+    } | {
+        [x: string]: any;
+        disabled?: boolean | undefined;
+        checkable?: boolean | undefined;
+        disableCheckbox?: boolean | undefined;
+        value?: import('ant-design-vue/lib/vc-tree-select/TreeSelect').RawValueType | undefined;
+        title?: any;
+        label?: any;
+        key?: import('ant-design-vue/lib/vc-tree-select/interface').Key | undefined;
+        children?: /*elided*/ any[] | undefined;
+    })[] | undefined>;
+};

package/es/modules/data-rules-container/src/hooks/useRdoHooks.mjs

@@ -0,0 +1,144 @@
+import select_more_default from "../components/select-more.vue.mjs";
+import { h, ref } from "vue";
+import { t } from "@gct-paas/core";
+//#region src/modules/data-rules-container/src/hooks/useRdoHooks.ts
+function useAsyncOptions({ bindModelKey, modelCategory }) {
+	const treeData = ref([]);
+	let searchField = "name_"?.split(",") || [];
+	async function getModelInfo() {
+		if (bindModelKey) {
+			const res = await _api.apaas.modelMeta.getInfo({ id: bindModelKey }) || {};
+			searchField = (res.displayField ? `${res.displayField},name_` : "name_")?.split(",") || [];
+		}
+	}
+	getModelInfo();
+	const getQueryDateByKeyWord = (keyword) => {
+		return searchField?.reduce((total, filedKey) => {
+			const expkey = filedKey.split(".").length > 1 ? filedKey : filedKey + ".like";
+			total[expkey] = keyword;
+			return total;
+		}, {}) || {};
+	};
+	const getExp = () => {
+		return `OR(${searchField.map((key) => `${key}.like`).join(",")})`;
+	};
+	async function getRdoAsyncOptions(arg = {}) {
+		let complete = true;
+		let optionsData = [];
+		const queryData = arg.keyword ? getQueryDateByKeyWord(arg.keyword) : {};
+		const queryExp = getExp();
+		const res = await _api.apaas.modelComprehensive.postBizServiceModelCategoryModelKeyBsKey({
+			bsKey: "rdoListByPage",
+			modelKey: bindModelKey,
+			modelCategory
+		}, {}, {
+			exp: queryExp,
+			query: queryData,
+			pageSize: 30,
+			pageNo: arg.pageNo
+		}) || {};
+		/**自定义数据源可能不存在 totalPage 默认 全部加载完成*/
+		complete = res.totalPage ? res.totalPage <= res.pageNo : true;
+		optionsData = (res?.data || []).map((i) => {
+			const rdoLabel = i.__LABEL__ || i.name_;
+			return {
+				value: i.id_,
+				title: rdoLabel,
+				_info: i.__CHILDREN__?.find((k) => k.default_),
+				full_path: h("div", [h("span", `${rdoLabel}`), h("span", { class: "gct-custom-tag ml8px" }, t("sys.default"))]),
+				children: i.__CHILDREN__?.map((j) => {
+					const versionLabel = j.__LABEL__ || j.version_;
+					return {
+						value: `${i.id_}:${j.id_}`,
+						title: h("div", [h("span", { class: "version" }, versionLabel), j.default_ ? h("span", { class: "version gct-custom-tag ml8px" }, t("sys.default")) : null]),
+						_info: { ...j },
+						full_path: h("div", [h("span", `${rdoLabel}:${versionLabel}`)])
+					};
+				})
+			};
+		});
+		return {
+			complete,
+			optionsData
+		};
+	}
+	/**
+	* 补全查询
+	* @param v
+	*/
+	async function getChildrens({ id_ } = {}) {
+		const [_fId, _cId] = id_?.split(":") ?? ["", ""];
+		console.log("_cId", _cId);
+		const data = (await _api.apaas.modelComprehensive.postBizServiceModelCategoryModelKeyBsKey({
+			bsKey: "rdoListVersionByRefIdsWithParent",
+			modelKey: bindModelKey,
+			modelCategory
+		}, { foreignFields: [] }, {
+			refIds: id_,
+			includeDeleted: 1
+		}) || {})?.data?.[0];
+		const rdoLabel = data.__LABEL__ || data.name_;
+		let children = [];
+		try {
+			children = (await _api.apaas.modelComprehensive.postBizServiceModelCategoryModelKeyBsKey({
+				bsKey: "rdoListVersionById",
+				modelKey: bindModelKey,
+				modelCategory
+			}, { foreignFields: [] }, { id: _fId }) || {}).data?.map((i) => {
+				const versionLabel = i.__LABEL__ || i.version_;
+				return {
+					value: `${_fId}:${i.id_}`,
+					title: h("div", [h("span", { class: "version" }, versionLabel), i.default_ ? h("span", { class: "version gct-custom-tag ml8px" }, t("sys.default")) : null]),
+					_info: { ...i },
+					full_path: h("div", [h("span", `${rdoLabel}:${versionLabel}`)])
+				};
+			});
+		} catch (error) {
+			console.error("getChildrens 获取子节点失败：", error);
+		}
+		return {
+			value: _fId,
+			title: rdoLabel,
+			full_path: h("div", [h("span", `${rdoLabel}`), h("span", { class: "gct-custom-tag ml8px" }, t("sys.default"))]),
+			children
+		};
+	}
+	async function getAsyncOptions(arg) {
+		if (!arg.pageNo) arg.pageNo = 1;
+		const { optionsData, complete } = await getRdoAsyncOptions(arg);
+		if (treeData.value?.length) if (arg.pageNo > 1) treeData.value?.pop();
+		else treeData.value = [];
+		optionsData.forEach((i) => {
+			treeData.value?.push(i);
+		});
+		if (!complete) treeData.value?.push({
+			selectable: false,
+			title: () => h(select_more_default, { onNextOnce: () => {
+				arg.pageNo += 1;
+				getAsyncOptions(arg);
+			} })
+		});
+	}
+	return {
+		getChildrens: async (ids = []) => {
+			try {
+				if (!Array.isArray(ids) || ids.length === 0) return;
+				for (const id_ of ids) {
+					if (!id_) continue;
+					const [_fId, _cId] = id_.split(":");
+					console.log("_cId", _cId);
+					if (treeData.value?.some((item) => item.value === _fId)) continue;
+					const row = await getChildrens({ id_ });
+					if (treeData.value?.some((item) => item.value === _fId)) continue;
+					if (row) treeData.value?.unshift(row);
+				}
+			} catch (error) {
+				console.error("getChildrens 批量加载失败：", error);
+			}
+		},
+		getAsyncOptions,
+		treeData
+	};
+}
+//#endregion
+export { useAsyncOptions };

package/es/modules/data-rules-container/src/hooks/useRole.d.ts

@@ -0,0 +1,8 @@
+export declare function useRole(): {
+    userGroupUsePerms: import('vue').ComputedRef<{
+        Insert: boolean;
+        Update: boolean;
+        Delete: boolean;
+    }>;
+    inEDHRApp: import('vue').ComputedRef<boolean>;
+};

package/es/modules/data-rules-container/src/typing.d.ts

@@ -0,0 +1,40 @@
+import { FieldMetaDTO } from '@gct-paas/api/apaas';
+export type LocalFieldMetaDTO = FieldMetaDTO & {
+    __bindFields: string[];
+};
+export interface OptionItem {
+    label: string;
+    value: string;
+    disabled?: boolean;
+    type?: string;
+}
+export interface ApiParams {
+    modelKey: string;
+    [key: string]: string;
+}
+export interface CompProps {
+    value?: string | string[];
+    api: (params: IObject) => Promise<IObject>;
+    apiParams: ApiParams;
+    filterType?: string;
+}
+export interface TreeProps {
+    data: IObject;
+    /** 树的层级，从0开始 */
+    level?: number;
+    /** key */
+    id: string;
+    /** 操作类型 */
+    operatorType: string;
+    readonly?: boolean;
+}
+export interface IPickerCompParams {
+    modelKey?: string;
+    fieldKey?: string;
+    multiple: boolean;
+}
+export interface ModalCompProps {
+    supportModalType: string;
+    pickerCompParams: IPickerCompParams;
+    value: string | string[];
+}

package/es/modules/gct-form/components/flex-item/flex-item.mjs

@@ -30,7 +30,7 @@ var FlexItem = /* @__PURE__ */ defineComponent({
 		return createVNode("div", {
 			"class": this.ns.b(),
 			"style": this.getStyle()
-		}, [this.$slots.default?.()]);
+		}, { default: () => this.$slots.default?.() });
 	}
 });
 //#endregion

package/es/modules/gct-form/components/grid-container/grid-container.mjs

@@ -15,8 +15,7 @@ var GridContainer = /* @__PURE__ */ defineComponent({
 		return () => {
 			let _slot;
 			const l = props.layout || {};
-			let items = slots.default?.() || [];
-			if (items.length > 0) items = items[0].children || [];
+			const items = slots.default?.() || [];
 			return createVNode(resolveComponent("a-row"), {
 				"class": ns.b(),
 				"wrap": true,

package/es/modules/gct-form/controller/editor-item/editor-item.controller.d.ts

@@ -12,4 +12,5 @@ export declare class EditorController<M extends IEditorBasic = IEditorBasic> imp
     model: M;
     options: IObject[];
     constructor(model: M);
+    protected init(): void;
 }

package/es/modules/gct-form/controller/editor-item/editor-item.controller.mjs

@@ -13,6 +13,17 @@ var EditorController = class {
 	options = [];
 	constructor(model) {
 		this.model = model;
+		this.init();
+	}
+	init() {
+		if (this.model.codeList) {
+			if (this.model.codeList.mode === "static" && this.model.codeList.items) this.options = this.model.codeList.items;
+		} else if (this.model.codeTag) {
+			const cfg = _gct.dictionary.getConfig(this.model.codeTag);
+			if (cfg) {
+				if (cfg.mode === "static") this.options = _gct.dictionary.get(this.model.codeTag);
+			}
+		}
 	}
 };
 //#endregion

package/es/modules/gct-form/controller/form-item-basic/form-item-basic.controller.mjs

@@ -13,6 +13,8 @@ import { reactive } from "vue";
 * @implements {IFormItemBasicController}
 */
 var FormItemBasicController = class {
+	form;
+	model;
 	/**
 	* 表单项标识，默认为表单项的 name
 	*

package/es/modules/gct-form/controller/gct-form/gct-form.controller.mjs

@@ -13,6 +13,7 @@ import { QXEvent } from "qx-util";
 * @implements {IFormController}
 */
 var GctFormController = class {
+	model;
 	evt = new QXEvent();
 	state = reactive(new FormState());
 	item = {};