@gct-paas/core-web 0.1.6-dev.4 → 0.1.6-dev.6

package/es/modules/category/category-sider.vue.d.ts

@@ -0,0 +1,337 @@
+import { BasicAction } from '@gct-paas/core';
+import { CategoryModuleEnum } from './type';
+import { ITreeNode, TreeExDropEvent } from '../../components';
+type __VLS_Props = {
+    module: CategoryModuleEnum;
+    value?: string;
+    siderTitle: string;
+    readonly: boolean;
+    isTree: boolean;
+    needFolderIcon: boolean;
+    customDelFunc?: Fn;
+    customDelTips?: string;
+    hasTitle?: boolean;
+    draggable?: boolean;
+    ignoreCase?: number;
+    hasPerBtns?: BasicAction[];
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {
+    getCategoryData: () => ITreeNode[];
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    changeCategory: (value?: string | undefined) => void;
+    changeValue: (value?: object | undefined) => void;
+    "update:value": (value?: string | undefined) => void;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChangeCategory?: ((value?: string | undefined) => any) | undefined;
+    onChangeValue?: ((value?: object | undefined) => any) | undefined;
+    "onUpdate:value"?: ((value?: string | undefined) => any) | undefined;
+}>, {
+    hasTitle: boolean;
+    draggable: boolean;
+    hasPerBtns: BasicAction[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    treeExRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        draggable: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        data: {
+            type: import('vue').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: TreeExDropEvent) => any) | undefined;
+        "onUpdate:checkedKeys"?: ((_val: string[]) => any) | undefined;
+        "onUpdate:expandedKeys"?: ((_val: string[]) => any) | undefined;
+        "onUpdate:selectedKeys"?: ((_val: string[]) => any) | undefined;
+    }>, {
+        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: import('ant-design-vue/es/tree').EventDataNode;
+        }) => void;
+        handleCheck: (checked: string[] | {
+            checked: string[];
+            halfChecked: string[];
+        }, info: import('ant-design-vue/es/vc-tree/props').CheckInfo) => void;
+        handleDrop: (info: import('ant-design-vue/es/tree').AntTreeNodeDropEvent) => Promise<void>;
+        collapseAll: () => void;
+        expandAll: () => void;
+        onExpand: (eKeys: (string | number)[], { expanded: _expanded, node: _node, }: {
+            expanded: boolean;
+            node: import('ant-design-vue/es/tree').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: TreeExDropEvent) => boolean;
+    }, import('vue').PublicProps, {
+        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;
+    }, true, {}, import('vue').SlotsType<{
+        title: {
+            node: ITreeNode;
+        };
+    }>, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('vue').ExtractPropTypes<{
+        draggable: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        data: {
+            type: import('vue').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: TreeExDropEvent) => any) | undefined;
+        "onUpdate:checkedKeys"?: ((_val: string[]) => any) | undefined;
+        "onUpdate:expandedKeys"?: ((_val: string[]) => any) | undefined;
+        "onUpdate:selectedKeys"?: ((_val: string[]) => any) | undefined;
+    }>, {
+        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: import('ant-design-vue/es/tree').EventDataNode;
+        }) => void;
+        handleCheck: (checked: string[] | {
+            checked: string[];
+            halfChecked: string[];
+        }, info: import('ant-design-vue/es/vc-tree/props').CheckInfo) => void;
+        handleDrop: (info: import('ant-design-vue/es/tree').AntTreeNodeDropEvent) => Promise<void>;
+        collapseAll: () => void;
+        expandAll: () => void;
+        onExpand: (eKeys: (string | number)[], { expanded: _expanded, node: _node, }: {
+            expanded: boolean;
+            node: import('ant-design-vue/es/tree').EventDataNode;
+        }) => void;
+        expandNode: (key: string, isExpand?: boolean) => void;
+    }, {}, {}, {}, {
+        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;
+    }> | null;
+}, HTMLDivElement>;
+export default _default;

package/es/modules/category/category-sider.vue.mjs

@@ -0,0 +1,7 @@
+import _plugin_vue_export_helper_default from "../../_virtual/_plugin-vue_export-helper.mjs";
+import category_sider_vue_vue_type_script_setup_true_name_category_sider_lang_default from "./category-sider.vue_vue_type_script_setup_true_name_category-sider_lang.mjs";
+import './category-sider.vue_vue_type_style_index_0_scoped_5af8c1ba_lang.css';/* empty css                                                                     */
+//#region src/modules/category/category-sider.vue
+var category_sider_default = /* @__PURE__ */ _plugin_vue_export_helper_default(category_sider_vue_vue_type_script_setup_true_name_category_sider_lang_default, [["__scopeId", "data-v-5af8c1ba"]]);
+//#endregion
+export { category_sider_default as default };

package/es/modules/category/category-sider.vue_vue_type_script_setup_true_name_category-sider_lang.mjs

@@ -0,0 +1,239 @@
+import { recursiveTransfer } from "../../utils/recursive.mjs";
+import "../../utils/index.mjs";
+import { TreeEx } from "../../components/TreeEx/tree-ex.mjs";
+import "../../components/index.mjs";
+import { useCategory } from "./hooks/useCategory.mjs";
+import { computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createTextVNode, createVNode, defineComponent, normalizeClass, onMounted, openBlock, ref, resolveComponent, toDisplayString, unref, watch, withCtx } from "vue";
+import { BasicAction, t, useNamespace } from "@gct-paas/core";
+//#region src/modules/category/category-sider.vue?vue&type=script&setup=true&name=category-sider&lang.ts
+var _hoisted_1 = ["title"];
+var category_sider_vue_vue_type_script_setup_true_name_category_sider_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "category-sider",
+	props: {
+		module: {},
+		value: {},
+		siderTitle: {},
+		readonly: { type: Boolean },
+		isTree: { type: Boolean },
+		needFolderIcon: { type: Boolean },
+		customDelFunc: {},
+		customDelTips: {},
+		hasTitle: {
+			type: Boolean,
+			default: true
+		},
+		draggable: {
+			type: Boolean,
+			default: true
+		},
+		ignoreCase: {},
+		hasPerBtns: { default: () => [
+			BasicAction.Insert,
+			BasicAction.Update,
+			BasicAction.Delete
+		] }
+	},
+	emits: [
+		"update:value",
+		"changeCategory",
+		"changeValue"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const MenuClickEvent = {
+			EDIT: "edit",
+			DELETE: "delete"
+		};
+		const $t = t;
+		const ns = useNamespace("category-sider");
+		const props = __props;
+		const emit = __emit;
+		const selectedKeys = computed({
+			get() {
+				return props.value ? [props.value] : void 0;
+			},
+			set(v) {
+				emit("update:value", v?.[0]);
+			}
+		});
+		const selfExpandedKeys = ref([]);
+		const searchKey = ref();
+		const treeExRef = ref();
+		const { load, createCategory, editCategory, deleteCategoryAPI, dragCategory, categoryTreeData, isFormDesign } = useCategory({ module: props.module });
+		const highlightId = ref("");
+		const onVisibleChange = (visible, treeId) => {
+			highlightId.value = visible ? treeId : "";
+		};
+		/**
+		* 节点选中事件
+		*/
+		const onMenuVisibleChange = (visible, treeId) => {
+			onVisibleChange(visible, treeId);
+		};
+		const onTreeMenuClick = (node, event) => {
+			handleMenuClick(node, String(event.key));
+		};
+		const handleSelect = (sKeys, { node }) => {
+			if (sKeys.length === 0) return;
+			if (node.dataRef?.children?.length && !isFormDesign) return;
+			if (node.categoryId && !selfExpandedKeys.value.includes(node.categoryId)) selfExpandedKeys.value.push(node.categoryId);
+			emit("changeValue", node.dataRef);
+		};
+		const treeData = computed(() => {
+			return recursiveTransfer(categoryTreeData.value || [], (item, resolveChild) => {
+				const treeItem = item;
+				const node = {
+					key: treeItem.id,
+					title: treeItem.name,
+					sortNum: treeItem.sortNum,
+					showFolder: treeItem.children && props.isTree || props.needFolderIcon,
+					sysBuiltin: treeItem.sysBuiltin
+				};
+				if ((treeItem.children || treeItem.child) && props.isTree) node.children = resolveChild(treeItem.children || treeItem.child);
+				return node;
+			});
+		});
+		onMounted(async () => {
+			await load();
+			if (!props.value) {
+				emit("update:value", treeData.value[0]?.key);
+				if (treeData.value[0]) emit("changeValue", treeData.value[0]);
+			}
+		});
+		watch(treeExRef, () => {
+			treeExRef.value?.expandAll();
+		}, { immediate: true });
+		/**
+		* 拖拽事件处理
+		* @param dragNode
+		* @param after
+		*/
+		const onDrop = async ({ dragNode, after }) => {
+			let targetSortNum = 1;
+			if (after.nextNode) targetSortNum = Number(after.nextNode.sortNum ?? 0) + 1;
+			else if (after.prevNode) targetSortNum = Number(after.prevNode.sortNum ?? 1);
+			await dragCategory({
+				id: dragNode.key,
+				targetParentId: after.parent?.key,
+				targetSortNum
+			});
+		};
+		const handleMenuClick = async (node, key) => {
+			switch (key) {
+				case MenuClickEvent.EDIT:
+					await editCategory(node);
+					onVisibleChange(false, node.key);
+					break;
+				case MenuClickEvent.DELETE: {
+					const currentSelectedKey = selectedKeys.value[0];
+					const res = await deleteCategoryAPI(node, props.customDelFunc, props.customDelTips);
+					onVisibleChange(false, node.key);
+					if (res && currentSelectedKey === node.key) {
+						selectedKeys.value = treeData.value.length ? [treeData.value[0].key] : [];
+						emit("changeValue", treeData.value[0]);
+					}
+					break;
+				}
+			}
+		};
+		const newCategory = async () => {
+			const data = await createCategory();
+			onVisibleChange(false, "");
+			if (data.parentId) selfExpandedKeys.value.push(data.parentId);
+			selectedKeys.value = treeData.value.length ? [treeData.value[0].key] : [];
+			emit("changeValue", treeData.value[0]);
+		};
+		const getCategoryData = () => {
+			return treeData.value;
+		};
+		__expose({ getCategoryData });
+		return (_ctx, _cache) => {
+			const _component_a_button = resolveComponent("a-button");
+			const _component_a_input = resolveComponent("a-input");
+			const _component_ellipsis_outlined = resolveComponent("ellipsis-outlined");
+			const _component_a_menu_item = resolveComponent("a-menu-item");
+			const _component_a_menu = resolveComponent("a-menu");
+			const _component_a_dropdown = resolveComponent("a-dropdown");
+			return openBlock(), createElementBlock("div", { class: normalizeClass([unref(ns).b()]) }, [
+				__props.hasTitle || !__props.readonly ? (openBlock(), createElementBlock("div", {
+					key: 0,
+					class: normalizeClass([unref(ns).e("title-container")])
+				}, [createElementVNode("span", { class: normalizeClass([unref(ns).e("title")]) }, toDisplayString(__props.siderTitle), 3), !__props.readonly && __props.hasPerBtns.includes(unref(BasicAction).Insert) ? (openBlock(), createBlock(_component_a_button, {
+					key: 0,
+					type: "link",
+					class: normalizeClass([unref(ns).e("add")]),
+					onClick: newCategory
+				}, {
+					default: withCtx(() => [_cache[3] || (_cache[3] = createElementVNode("i", { class: "iconfont icon-chuangjian" }, null, -1)), createTextVNode(" " + toDisplayString(unref($t)("sys.newCategory")), 1)]),
+					_: 1
+				}, 8, ["class"])) : createCommentVNode("", true)], 2)) : createCommentVNode("", true),
+				createElementVNode("div", { class: normalizeClass([unref(ns).e("search-container")]) }, [createVNode(_component_a_input, {
+					value: searchKey.value,
+					"onUpdate:value": _cache[0] || (_cache[0] = ($event) => searchKey.value = $event),
+					class: normalizeClass([unref(ns).e("search-input")]),
+					placeholder: unref(t)("sys.onlineForm.searchCategory"),
+					"allow-clear": ""
+				}, {
+					prefix: withCtx(() => [..._cache[4] || (_cache[4] = [createElementVNode("i", { class: "iconfont icon-sousuo1" }, null, -1)])]),
+					_: 1
+				}, 8, [
+					"value",
+					"class",
+					"placeholder"
+				])], 2),
+				createElementVNode("div", { class: normalizeClass([unref(ns).e("tree-container")]) }, [treeData.value.length ? (openBlock(), createBlock(unref(TreeEx), {
+					key: 0,
+					ref_key: "treeExRef",
+					ref: treeExRef,
+					"selected-keys": selectedKeys.value,
+					"onUpdate:selectedKeys": _cache[1] || (_cache[1] = ($event) => selectedKeys.value = $event),
+					"expanded-keys": selfExpandedKeys.value,
+					"onUpdate:expandedKeys": _cache[2] || (_cache[2] = ($event) => selfExpandedKeys.value = $event),
+					class: normalizeClass([unref(ns).e("tree"), __props.draggable && "draggable-tree"]),
+					draggable: __props.draggable,
+					data: treeData.value,
+					"last-selection-locked": "",
+					filter: searchKey.value ? searchKey.value.trim() : "",
+					"ignore-case": __props.ignoreCase,
+					onDrop,
+					onSelect: handleSelect
+				}, {
+					title: withCtx(({ node }) => [createElementVNode("div", { class: normalizeClass([unref(ns).b("tree-node"), unref(ns).is("highlight", highlightId.value === node.key)]) }, [createElementVNode("span", {
+						class: normalizeClass([unref(ns).be("tree-node", "title")]),
+						title: node.title
+					}, toDisplayString(node.title), 11, _hoisted_1), !__props.readonly && (__props.hasPerBtns.includes(unref(BasicAction).Update) || __props.hasPerBtns.includes(unref(BasicAction).Delete)) ? (openBlock(), createBlock(_component_a_dropdown, {
+						key: 0,
+						class: normalizeClass([unref(ns).be("tree-node", "more")]),
+						onVisibleChange: ($event) => onMenuVisibleChange($event, node.key)
+					}, {
+						overlay: withCtx(() => [createVNode(_component_a_menu, {
+							style: { "width": "102px" },
+							onClick: ($event) => onTreeMenuClick(node, $event)
+						}, {
+							default: withCtx(() => [__props.hasPerBtns.includes(unref(BasicAction).Update) ? (openBlock(), createBlock(_component_a_menu_item, { key: MenuClickEvent.EDIT }, {
+								default: withCtx(() => [createTextVNode(toDisplayString(unref($t)("sys.component.dataConnection.rename")), 1)]),
+								_: 1
+							})) : createCommentVNode("", true), __props.hasPerBtns.includes(unref(BasicAction).Delete) ? (openBlock(), createBlock(_component_a_menu_item, { key: MenuClickEvent.DELETE }, {
+								default: withCtx(() => [createTextVNode(toDisplayString(unref($t)("sys.delText")), 1)]),
+								_: 1
+							})) : createCommentVNode("", true)]),
+							_: 1
+						}, 8, ["onClick"])]),
+						default: withCtx(() => [createVNode(_component_ellipsis_outlined)]),
+						_: 2
+					}, 1032, ["class", "onVisibleChange"])) : createCommentVNode("", true)], 2)]),
+					_: 1
+				}, 8, [
+					"selected-keys",
+					"expanded-keys",
+					"class",
+					"draggable",
+					"data",
+					"filter",
+					"ignore-case"
+				])) : createCommentVNode("", true)], 2)
+			], 2);
+		};
+	}
+});
+//#endregion
+export { category_sider_vue_vue_type_script_setup_true_name_category_sider_lang_default as default };