@gct-paas/core-web 0.1.5-test.1 → 0.1.6-dev.0

package/es/components/TreeEx/tree-ex.d.ts

@@ -0,0 +1,265 @@
+import { PropType } from 'vue';
+import { ITreeNode } from './type';
+import { EventDataNode, AntTreeNodeDropEvent } from 'ant-design-vue/es/tree';
+import { CheckInfo } from 'ant-design-vue/es/vc-tree/props';
+export declare const TreeEx: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    draggable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    data: {
+        type: PropType<ITreeNode[]>;
+        required: true;
+    };
+    filter: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    selectedKeys: {
+        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[];
+            readonly [Symbol.species]: ArrayConstructor;
+            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>[]>;
+        };
+        default: undefined;
+    };
+    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[];
+            readonly [Symbol.species]: ArrayConstructor;
+            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>[]>;
+        };
+        default: undefined;
+    };
+    expandedKeys: {
+        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[];
+            readonly [Symbol.species]: ArrayConstructor;
+            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>[]>;
+        };
+        default: undefined;
+    };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** 最后一个选中的数据不能取消选中 */
+    lastSelectionLocked: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** 节点前出复选框 */
+    checkable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** 节点复选框父子节点不关联 */
+    checkStrictly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    autoExpandParent: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    defaultExpandAll: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showLine: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    ignoreCase: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, {
+    ns: import('@gct-paas/core').Namespace;
+    selectedKeysValue: import('vue').WritableComputedRef<string[], string[]>;
+    checkedKeysValue: import('vue').WritableComputedRef<string[], string[]>;
+    expandedKeysValue: import('vue').WritableComputedRef<string[] | undefined, string[] | undefined>;
+    actualDraggable: import('vue').ComputedRef<boolean>;
+    filteredTreeData: import('vue').ComputedRef<ITreeNode[]>;
+    handleSelect: (sKeys: (string | number)[], { node }: {
+        node: EventDataNode;
+    }) => void;
+    handleCheck: (checked: string[] | {
+        checked: string[];
+        halfChecked: string[];
+    }, info: CheckInfo) => void;
+    handleDrop: (info: AntTreeNodeDropEvent) => Promise<void>;
+    collapseAll: () => void;
+    expandAll: () => void;
+    onExpand: (eKeys: (string | number)[], { expanded: _expanded, node: _node, }: {
+        expanded: boolean;
+        node: EventDataNode;
+    }) => void;
+    expandNode: (key: string, isExpand?: boolean) => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:selectedKeys": (_val: string[]) => boolean;
+    "update:checkedKeys": (_val: string[]) => boolean;
+    "update:expandedKeys": (_val: string[]) => boolean;
+    drop: (event: import('./type').TreeExDropEvent) => boolean;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    draggable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    data: {
+        type: PropType<ITreeNode[]>;
+        required: true;
+    };
+    filter: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    selectedKeys: {
+        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[];
+            readonly [Symbol.species]: ArrayConstructor;
+            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>[]>;
+        };
+        default: undefined;
+    };
+    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[];
+            readonly [Symbol.species]: ArrayConstructor;
+            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>[]>;
+        };
+        default: undefined;
+    };
+    expandedKeys: {
+        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[];
+            readonly [Symbol.species]: ArrayConstructor;
+            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>[]>;
+        };
+        default: undefined;
+    };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** 最后一个选中的数据不能取消选中 */
+    lastSelectionLocked: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** 节点前出复选框 */
+    checkable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** 节点复选框父子节点不关联 */
+    checkStrictly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    autoExpandParent: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    defaultExpandAll: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showLine: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    ignoreCase: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{
+    onDrop?: ((event: import('./type').TreeExDropEvent) => any) | undefined;
+    "onUpdate:checkedKeys"?: ((_val: string[]) => any) | undefined;
+    "onUpdate:expandedKeys"?: ((_val: string[]) => any) | undefined;
+    "onUpdate:selectedKeys"?: ((_val: string[]) => any) | undefined;
+}>, {
+    draggable: boolean;
+    filter: string;
+    selectedKeys: string[];
+    checkedKeys: string[];
+    expandedKeys: string[];
+    multiple: boolean;
+    lastSelectionLocked: boolean;
+    checkable: boolean;
+    checkStrictly: boolean;
+    autoExpandParent: boolean;
+    defaultExpandAll: boolean;
+    showLine: boolean;
+    ignoreCase: number;
+}, import('vue').SlotsType<{
+    title: {
+        node: ITreeNode;
+    };
+}>, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/es/components/TreeEx/tree-ex.mjs

@@ -0,0 +1,208 @@
+import { filterTreeData, recursiveIterate } from "../../utils/recursive.mjs";
+import "../../utils/index.mjs";
+import { TreeExEmits, TreeSlots, findNodeInfoByKey, transferToDropInfo } from "./tree-ex.util.mjs";
+import './tree-ex.css';/* empty css              */
+import { computed, createVNode, defineComponent, nextTick, ref, renderSlot, watch } from "vue";
+import { cloneDeep, isNil } from "lodash-es";
+import { useNamespace } from "@gct-paas/core";
+import { Tree } from "ant-design-vue";
+//#region src/components/TreeEx/tree-ex.tsx
+var TreeEx = /* @__PURE__ */ defineComponent({
+	name: "TreeEx",
+	props: {
+		draggable: {
+			type: Boolean,
+			default: false
+		},
+		data: {
+			type: Object,
+			required: true
+		},
+		filter: {
+			type: String,
+			default: void 0
+		},
+		selectedKeys: {
+			type: Array,
+			default: void 0
+		},
+		checkedKeys: {
+			type: Array,
+			default: void 0
+		},
+		expandedKeys: {
+			type: Array,
+			default: void 0
+		},
+		multiple: {
+			type: Boolean,
+			default: false
+		},
+		lastSelectionLocked: {
+			type: Boolean,
+			default: false
+		},
+		checkable: {
+			type: Boolean,
+			default: false
+		},
+		checkStrictly: {
+			type: Boolean,
+			default: false
+		},
+		autoExpandParent: {
+			type: Boolean,
+			default: true
+		},
+		defaultExpandAll: {
+			type: Boolean,
+			default: false
+		},
+		showLine: {
+			type: Boolean,
+			default: false
+		},
+		ignoreCase: {
+			type: Number,
+			default: 0
+		}
+	},
+	emits: TreeExEmits,
+	slots: TreeSlots,
+	setup(props, { emit }) {
+		const ns = useNamespace("tree-ex");
+		const selfExpandedKeys = ref();
+		const expandedKeysValue = computed({
+			get() {
+				return isNil(props.expandedKeys) ? selfExpandedKeys.value : props.expandedKeys;
+			},
+			set(v) {
+				selfExpandedKeys.value = v || [];
+				emit("update:expandedKeys", v || []);
+			}
+		});
+		const selfSelectedKeys = ref([]);
+		const selectedKeysValue = computed({
+			get() {
+				return isNil(props.selectedKeys) ? selfSelectedKeys.value : props.selectedKeys;
+			},
+			set(v) {
+				selfSelectedKeys.value = v;
+				emit("update:selectedKeys", v);
+			}
+		});
+		const handleSelect = (sKeys, { node }) => {
+			if (props.lastSelectionLocked && sKeys.length === 0) return;
+			if (node.dataRef.selectable === false) return;
+			if (props.multiple) selectedKeysValue.value = [...sKeys];
+			else if (sKeys.length === 0) selectedKeysValue.value = [];
+			else selectedKeysValue.value = [node.dataRef.key];
+		};
+		const selfCheckedKeys = ref([]);
+		const checkedKeysValue = computed({
+			get() {
+				return isNil(props.checkedKeys) ? selfCheckedKeys.value : props.checkedKeys;
+			},
+			set(v) {
+				selfCheckedKeys.value = v;
+				emit("update:checkedKeys", v);
+			}
+		});
+		const handleCheck = (checked, info) => {
+			const checkedKeys = Array.isArray(checked) ? checked : checked.checked;
+			const { node } = info;
+			if (props.lastSelectionLocked && checkedKeys.length === 0) return;
+			if (node.dataRef.checkable === false) return;
+			if (props.multiple) checkedKeysValue.value = [...checkedKeys];
+			else checkedKeysValue.value = [node.dataRef.key];
+		};
+		const actualDraggable = computed(() => {
+			return props.draggable && !props.filter;
+		});
+		const handleDrop = async (info) => {
+			emit("drop", transferToDropInfo(info, props.data));
+			console.log("[ info ] >", info);
+			console.log("[ newEvent ] >", transferToDropInfo(info, props.data));
+		};
+		const collapseAll = () => {
+			console.log("[ collapseAll ] >");
+			expandedKeysValue.value = [];
+		};
+		const expandAll = () => {
+			console.log("[ expandAll ] >");
+			const newExpandKeys = [];
+			recursiveIterate(props.data, ({ item }) => {
+				if (item.children?.length) newExpandKeys.push(item.key);
+			});
+			expandedKeysValue.value = newExpandKeys;
+		};
+		const expandNode = (key, isExpand) => {
+			const newKeys = [...expandedKeysValue.value || []];
+			const currentExpanded = newKeys.includes(key);
+			const toExpanded = isNil(isExpand) ? !currentExpanded : isExpand;
+			if (currentExpanded === toExpanded) return;
+			console.log("[ expandNode ] >", key, toExpanded);
+			if (toExpanded) newKeys.push(key);
+			else newKeys.splice(newKeys.indexOf(key), 1);
+			expandedKeysValue.value = newKeys;
+		};
+		const onExpand = (eKeys, { expanded: _expanded, node: _node }) => {
+			expandedKeysValue.value = [...eKeys];
+		};
+		watch(() => props.data, (_newData) => {
+			if (props.defaultExpandAll) expandAll();
+		}, { immediate: true });
+		return {
+			ns,
+			selectedKeysValue,
+			checkedKeysValue,
+			expandedKeysValue,
+			actualDraggable,
+			filteredTreeData: computed(() => {
+				if (props.filter) {
+					const filterData = filterTreeData(cloneDeep(props.data), (item) => {
+						console.log("item.title.includes(props.filter!)", item.title, item.title.includes(props.filter));
+						if (props.ignoreCase) return item.title.toLowerCase().includes(props.filter.toLowerCase());
+						else return item.title.includes(props.filter);
+					});
+					if (filterData.length > 0) nextTick(() => {
+						expandAll();
+					});
+					return filterData;
+				} else return props.data;
+			}),
+			handleSelect,
+			handleCheck,
+			handleDrop,
+			collapseAll,
+			expandAll,
+			onExpand,
+			expandNode
+		};
+	},
+	render() {
+		const treeSlots = {};
+		if (Object.keys(this.$slots).includes("title")) treeSlots.title = (item) => {
+			const { node } = findNodeInfoByKey(this.data, item.dataRef.key);
+			return renderSlot(this.$slots, "title", { node });
+		};
+		return createVNode(Tree, {
+			"class": [this.ns.b(), this.showLine && "show-tree-line"],
+			"selectedKeys": this.selectedKeysValue,
+			"checkedKeys": this.checkedKeysValue,
+			"expandedKeys": this.expandedKeysValue,
+			"onExpand": this.onExpand,
+			"block-node": true,
+			"checkable": this.checkable,
+			"checkStrictly": this.checkStrictly,
+			"multiple": this.multiple,
+			"draggable": this.actualDraggable,
+			"tree-data": this.filteredTreeData,
+			"onDrop": this.handleDrop,
+			"onSelect": this.handleSelect,
+			"onCheck": this.handleCheck
+		}, { ...treeSlots });
+	}
+});
+//#endregion
+export { TreeEx };

package/es/components/TreeEx/tree-ex.util.d.ts

@@ -0,0 +1,34 @@
+import { AntTreeNodeDropEvent } from 'ant-design-vue/es/tree';
+import { ITreeNode, TreeExDropEvent } from './type';
+import { SlotsType } from 'vue';
+export declare const TreeExEmits: {
+    "update:selectedKeys": (_val: string[]) => boolean;
+    "update:checkedKeys": (_val: string[]) => boolean;
+    "update:expandedKeys": (_val: string[]) => boolean;
+    drop: (event: TreeExDropEvent) => boolean;
+};
+export declare const TreeSlots: SlotsType<{
+    title: {
+        node: ITreeNode;
+    };
+}>;
+/**
+ * 找到对应的树节点和父节点信息
+ * @author lingxiaoming
+ * @date 2024-07-23 04:35:47
+ * @param {ITreeNode[]} treeData
+ * @param {string} key
+ */
+export declare function findNodeInfoByKey(treeData: ITreeNode[], key: string): {
+    parent: ITreeNode | undefined;
+    node: ITreeNode;
+} | undefined;
+/**
+ * 转换ant-tree的drop事件
+ * @author lingxiaoming
+ * @date 2024-07-22 05:52:23
+ * @param {AntTreeNodeDropEvent} info
+ * @param {ITreeNode[]} treeData 所有的树节点数据
+ * @return {*}  {TreeExDropEvent}
+ */
+export declare function transferToDropInfo(info: AntTreeNodeDropEvent, treeData: ITreeNode[]): TreeExDropEvent;

package/es/components/TreeEx/tree-ex.util.mjs

@@ -0,0 +1,77 @@
+import { findRecursiveChild } from "../../utils/recursive.mjs";
+import "../../utils/index.mjs";
+//#region src/components/TreeEx/tree-ex.util.ts
+var TreeExEmits = {
+	["update:selectedKeys"]: (_val) => true,
+	["update:checkedKeys"]: (_val) => true,
+	["update:expandedKeys"]: (_val) => true,
+	drop: (event) => !!event
+};
+var TreeSlots = {};
+/**
+* 找到对应的树节点和父节点信息
+* @author lingxiaoming
+* @date 2024-07-23 04:35:47
+* @param {ITreeNode[]} treeData
+* @param {string} key
+*/
+function findNodeInfoByKey(treeData, key) {
+	const find = findRecursiveChild(treeData, key, { compareField: "key" });
+	return find?.child ? {
+		parent: find.parent,
+		node: find.child
+	} : void 0;
+}
+/**
+* 转换ant-tree的drop事件
+* @author lingxiaoming
+* @date 2024-07-22 05:52:23
+* @param {AntTreeNodeDropEvent} info
+* @param {ITreeNode[]} treeData 所有的树节点数据
+* @return {*}  {TreeExDropEvent}
+*/
+function transferToDropInfo(info, treeData) {
+	const { dragNode, node, dropPosition, dropToGap, event } = info;
+	const drag = findNodeInfoByKey(treeData, dragNode.dataRef.key);
+	const dragData = drag.node;
+	const beforeParent = drag?.parent;
+	const beforeIndex = Number(dragNode.pos.split("-").pop());
+	const beforeArr = beforeParent ? beforeParent.children || [] : treeData;
+	const drop = findNodeInfoByKey(treeData, node.dataRef.key);
+	const afterParent = dropToGap ? drop?.parent : drop?.node;
+	const nodeIndex = Number(node.pos.split("-").pop());
+	let afterIndex = 0;
+	switch (dropPosition - nodeIndex) {
+		case 0:
+			afterIndex = 0;
+			break;
+		case 1:
+			afterIndex = nodeIndex + 1;
+			break;
+		case -1:
+			afterIndex = nodeIndex;
+			break;
+		default: break;
+	}
+	const afterArr = afterParent ? afterParent.children || [] : treeData;
+	return {
+		event,
+		dragNode: dragData,
+		before: {
+			parent: beforeParent,
+			index: beforeIndex,
+			arr: beforeArr,
+			prevNode: beforeArr[beforeIndex - 1],
+			nextNode: beforeArr[beforeIndex + 1]
+		},
+		after: {
+			parent: afterParent,
+			index: afterIndex,
+			arr: afterArr,
+			prevNode: afterArr[afterIndex - 1],
+			nextNode: afterArr[afterIndex]
+		}
+	};
+}
+//#endregion
+export { TreeExEmits, TreeSlots, findNodeInfoByKey, transferToDropInfo };

package/es/components/TreeEx/tree-select-ex/tree-select-ex.vue.d.ts

@@ -0,0 +1,11 @@
+import { ITreeNode } from '../type';
+type __VLS_Props = {
+    value?: string;
+    treeData: ITreeNode[];
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:value": (value: string | undefined) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:value"?: ((value: string | undefined) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/es/components/TreeEx/tree-select-ex/tree-select-ex.vue.mjs

@@ -0,0 +1,7 @@
+import _plugin_vue_export_helper_default from "../../../_virtual/_plugin-vue_export-helper.mjs";
+import tree_select_ex_vue_vue_type_script_setup_true_name_EdhrOutline_lang_default from "./tree-select-ex.vue_vue_type_script_setup_true_name_EdhrOutline_lang.mjs";
+import './tree-select-ex.vue_vue_type_style_index_0_scoped_1f7c12f5_lang.css';/* empty css                                                                     */
+//#region src/components/TreeEx/tree-select-ex/tree-select-ex.vue
+var tree_select_ex_default = /* @__PURE__ */ _plugin_vue_export_helper_default(tree_select_ex_vue_vue_type_script_setup_true_name_EdhrOutline_lang_default, [["__scopeId", "data-v-1f7c12f5"]]);
+//#endregion
+export { tree_select_ex_default as default };

package/es/components/TreeEx/tree-select-ex/tree-select-ex.vue_vue_type_script_setup_true_name_EdhrOutline_lang.mjs

@@ -0,0 +1,51 @@
+import { computed, createBlock, defineComponent, normalizeClass, openBlock, resolveComponent, unref } from "vue";
+import { useNamespace } from "@gct-paas/core";
+//#region src/components/TreeEx/tree-select-ex/tree-select-ex.vue?vue&type=script&setup=true&name=EdhrOutline&lang.ts
+var tree_select_ex_vue_vue_type_script_setup_true_name_EdhrOutline_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "tree-select-ex",
+	props: {
+		value: {},
+		treeData: {}
+	},
+	emits: ["update:value"],
+	setup(__props, { emit: __emit }) {
+		const ns = useNamespace("edhr-outline-select");
+		const props = __props;
+		const emit = __emit;
+		/**
+		* 转换为ant的树形选项结构
+		*/
+		function toTreeOptions(nodes) {
+			const result = [];
+			nodes.forEach((node) => {
+				const item = {
+					value: node.key,
+					label: node.title
+				};
+				if (node.children) item.children = toTreeOptions(node.children);
+				result.push(item);
+			});
+			return result;
+		}
+		const treeData = computed(() => {
+			return toTreeOptions(props.treeData);
+		});
+		return (_ctx, _cache) => {
+			const _component_a_tree_select = resolveComponent("a-tree-select");
+			return openBlock(), createBlock(_component_a_tree_select, {
+				class: normalizeClass([unref(ns).b()]),
+				value: __props.value,
+				"tree-data": treeData.value,
+				"tree-default-expand-all": "",
+				size: "small",
+				"onUpdate:value": _cache[0] || (_cache[0] = ($event) => emit("update:value", $event))
+			}, null, 8, [
+				"class",
+				"value",
+				"tree-data"
+			]);
+		};
+	}
+});
+//#endregion
+export { tree_select_ex_vue_vue_type_script_setup_true_name_EdhrOutline_lang_default as default };

package/es/components/{wujie-container/wujie-container.css → TreeEx/tree-select-ex/tree-select-ex.vue_vue_type_style_index_0_scoped_1f7c12f5_lang.css}

@@ -62,13 +62,6 @@
  *   }
  */
 /* stylelint-disable scss/no-global-function-names */
-.gct-wujie-container {
-  height: 100%;
+.gct-edhr-outline-select[data-v-1f7c12f5] {
   width: 100%;
-}
-.gct-wujie-container .__vue-devtools-container__ {
-  display: none;
-}
-.gct-wujie-container iframe {
-  border: 0;
 }