@sy-common/organize-select-help 1.0.0-beta.63 → 1.0.0-beta.64

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sy-common/organize-select-help",
-  "version": "1.0.0-beta.63",
+  "version": "1.0.0-beta.64",
   "description": "",
   "main": "index.js",
   "author": "lambo",

package/src/index.vue

@@ -16,10 +16,14 @@
           <Tabs :value="tabName"  @input="handleTabChange">
             <TabPane label="组织选择" name="org" v-if="name.includes('org')">
               <div class="tab">
-                <span>组织搜索：</span>
-                <Select v-model="orgSearch" filterable :remote-method="getOrgListBySearch" @on-change="getOrgOption" :loading="loadingOrg" placeholder="请输入组织名称" style="width: 600px;" clearable>
-                  <Option v-for="(option, index) in orgSearchList" :value="option.orgUnitId" :key="index">{{option.name}}</Option>
-                </Select>
+                <div class="search-row">
+                  <span class="search-label">组织搜索：</span>
+                  <div class="search-input-wrapper">
+                    <Select v-model="orgSearch" filterable :remote-method="getOrgListBySearch" @on-change="getOrgOption" :loading="loadingOrg" placeholder="请输入组织名称" style="width: 100%;" clearable>
+                      <Option v-for="(option, index) in orgSearchList" :value="option.orgUnitId" :key="index">{{option.name}}</Option>
+                    </Select>
+                  </div>
+                </div>
                 <div class="tag-content" v-if="isQuickOpen && orgTagList.length > 0">
                   <span>快捷选择：</span>
                   <div class="custom-select-wrapper">
@@ -49,7 +53,7 @@
                   </div>
                 </div>
                 <div class="tree">
-                  <organizeTree @handleChange="getOrgList" ref="orgTree" :treeList="orgTree"></organizeTree>
+                  <organizeTree v-if="orgTreeLoaded" @handleChange="getOrgList" ref="orgTree" :treeList="orgTree" :is-custom-tree="true" :disable-lazy-load="false"></organizeTree>
                 </div>
                 <div class="bottom-select">
                   <CheckboxGroup v-model="includeLevelOrg">
@@ -75,10 +79,14 @@
                   </div>
                 </div>
                 <div class="right">
-                  <span>组织搜索：</span>
-                  <Select v-model="postSearch" filterable :remote-method="getPostListBySearch" @on-change="getPostOption" placeholder="组织选择" :loading="loadingPost" clearable @on-clear="handlePostSearchClear" style="width: 365px;">
-                    <Option v-for="(option, index) in postSearchList" :value="option.orgUnitId" :key="index">{{option.name}}</Option>
-                  </Select>
+                  <div class="search-row">
+                    <span class="search-label">组织搜索：</span>
+                    <div class="search-input-wrapper">
+                      <Select v-model="postSearch" filterable :remote-method="getPostListBySearch" @on-change="getPostOption" placeholder="请输入组织名称" :loading="loadingPost" clearable @on-clear="handlePostSearchClear" style="width: 100%;">
+                        <Option v-for="(option, index) in postSearchList" :value="option.orgUnitId" :key="index">{{option.name}}</Option>
+                      </Select>
+                    </div>
+                  </div>
                   <div class="tag-content" v-if="isQuickOpen && postTagList.length > 0">
                     <span>快捷选择：</span>
                     <div class="custom-select-wrapper">
@@ -108,7 +116,7 @@
                     </div>
                   </div>
                   <div class="tree">
-                    <organizeTree @handleChange="getPostList" ref="postTree" :treeList="postTree"></organizeTree>
+                    <organizeTree v-if="postTreeLoaded" @handleChange="getPostList" ref="postTree" :treeList="postTree" :is-custom-tree="true" :disable-lazy-load="false"></organizeTree>
                   </div>
                   <div class="bottom-select">
                     <CheckboxGroup v-model="includeLevelPost">
@@ -129,6 +137,7 @@
                   <div class="tree staff-org-tree">
                     <div class="tree-scroll-force">
                       <organizeTree
+                          v-if="staffTreeLoaded"
                           @handleChange="getStaffList"
                           ref="staffTree"
                           :treeList="staffTree"
@@ -143,7 +152,6 @@
                     </div>
                   </div>
                 </div>
-
                 <div class="staff-right-panel">
                   <Input v-model="staffSearch" @on-enter="searchStaff" @on-search="searchStaff" search placeholder="搜索人员"/>
                   <div style="position:relative;">
@@ -163,10 +171,10 @@
                     </div>
                     <Spin v-if="loadingStaff" size="large" fix />
                   </div>
-<!--                  <div class="bottom-select">-->
-<!--                    <div>当前已选择 <span class="num">{{getCheckedStaff}}</span>人</div>-->
-<!--                    <Button type="primary" icon="md-add" @click="addStaffList">添加人员</Button>-->
-<!--                  </div>-->
+                  <!--                  <div class="bottom-select">-->
+                  <!--                    <div>当前已选择 <span class="num">{{getCheckedStaff}}</span>人</div>-->
+                  <!--                    <Button type="primary" icon="md-add" @click="addStaffList">添加人员</Button>-->
+                  <!--                  </div>-->
                 </div>
               </div>
             </TabPane>
@@ -299,7 +307,14 @@ export default {
       selectedStaffOrgId: '', // 新增：选中的组织节点ID
       proStaffOrgList: [], // 新增：暂存选中的组织节点
       initialDefaultOrgUnitId: '', // 缓存初始defaultOrgUnitId
-      staffTreeInited: false, // 组织树初始化完成标记（用于需求3）
+      // staffTreeInited: false, // 组织树初始化完成标记
+      // 树加载完成标记
+      orgTreeLoaded: false,
+      postTreeLoaded: false,
+      staffTreeLoaded: false,
+      // 缓存原始组织树/岗位树数据
+      originalOrgTree: [], // 组织Tab原始树缓存
+      originalPostTree: [], // 岗位Tab原始树缓存
     }
   },
   mounted() {
@@ -307,79 +322,260 @@ export default {
     this.queryPositionList()
     // this.loadMore()
     this.initialDefaultOrgUnitId = this.defaultOrgUnitId || ''; // 缓存初始值
+    this.initOrgOrgTree()
+    this.initPostOrgTree()
     this.initStaffOrgTree()
   },
 
   methods:{
+    async initOrgOrgTree() {
+      try {
+        this.proOrgList = [];
+        this.orgSearch = '';
+        this.orgSearchList = [];
+        this.orgTreeLoaded = false;
+
+        const orgDetailRes = await ajax.get(`/pub-manage-server/pub/organ/q/queryOrg`, {
+          params: { orgUnitId: '' }
+        });
+
+        if (orgDetailRes.data.code !== 1 || !orgDetailRes.data.data) {
+          this.$Message.warning("未查询到组织根节点，显示空树");
+          this.orgTree = [];
+          this.originalOrgTree = []; // 缓存空数据
+          this.orgTreeLoaded = true;
+          return;
+        }
+
+        const rootOrgData = orgDetailRes.data.data;
+        const leafNode = await this.judgeNodeLeafe(rootOrgData.orgUnitId);
+        const rootNode = this.safeDeepCopy({
+          orgUnitId: rootOrgData.orgUnitId,
+          orgUnitName: rootOrgData.orgUnitName,
+          parentOrgUnitId: rootOrgData.parentOrgUnitId,
+          leafNode: leafNode,
+          title: rootOrgData.orgUnitName || `未命名组织(${rootOrgData.orgUnitId})`,
+          expand: true,
+          orgChildrenList: [],
+          children: []
+        });
+
+        let parentsList = [];
+        try {
+          parentsList = await this.getParentOrgNodesByOrgUnitId(rootOrgData.orgUnitId);
+        } catch (e) {
+          console.warn('父节点查询失败，仅显示根节点:', e);
+          parentsList = [];
+        }
+
+        const safeParents = this.safeDeepCopy(parentsList).map(node => ({
+          orgUnitId: node.orgUnitId,
+          orgUnitName: node.orgUnitName || node.name,
+          parentOrgUnitId: node.parentOrgUnitId || node.parentId,
+          leafNode: false,
+          title: node.orgUnitName || node.name || `未命名组织(${node.orgUnitId})`,
+          expand: true,
+          orgChildrenList: [],
+          children: []
+        }));
+
+        const treeSourceData = [...safeParents, rootNode].filter(Boolean);
+        this.orgTree = this.buildTree(treeSourceData);
+        // 缓存原始树数据
+        this.originalOrgTree = this.safeDeepCopy(this.orgTree);
+
+        if (this.orgTree.length === 0) {
+          this.orgTree = [rootNode];
+          this.originalOrgTree = [rootNode]; // 同步缓存
+        }
+
+        this.orgTreeLoaded = true;
+
+      } catch (e) {
+        console.error("组织选择Tab树初始化失败:", e);
+        this.orgTree = [];
+        this.originalOrgTree = []; // 缓存空数据
+        this.orgTreeLoaded = true;
+        this.$Message.error("组织树初始化失败，请刷新重试");
+      }
+    },
+    async initPostOrgTree() {
+      try {
+        this.proPostList = [];
+        this.postSearch = '';
+        this.postSearchList = [];
+        this.selectedPositionId = null;
+        this.postTreeLoaded = false;
+
+        const orgDetailRes = await ajax.get(`/pub-manage-server/pub/organ/q/queryOrg`, {
+          params: { orgUnitId: '' }
+        });
+
+        if (orgDetailRes.data.code !== 1 || !orgDetailRes.data.data) {
+          this.$Message.warning("未查询到组织根节点，显示空树");
+          this.postTree = [];
+          this.originalPostTree = []; // 缓存空数据
+          this.postTreeLoaded = true;
+          return;
+        }
+
+        const rootOrgData = orgDetailRes.data.data;
+        const leafNode = await this.judgeNodeLeafe(rootOrgData.orgUnitId);
+        const rootNode = this.safeDeepCopy({
+          orgUnitId: rootOrgData.orgUnitId,
+          orgUnitName: rootOrgData.orgUnitName,
+          parentOrgUnitId: rootOrgData.parentOrgUnitId,
+          leafNode: leafNode,
+          title: rootOrgData.orgUnitName || `未命名组织(${rootOrgData.orgUnitId})`,
+          expand: true,
+          orgChildrenList: [],
+          children: []
+        });
+
+        let parentsList = [];
+        try {
+          parentsList = await this.getParentOrgNodesByOrgUnitId(rootOrgData.orgUnitId);
+        } catch (e) {
+          console.warn('岗位Tab父节点查询失败:', e);
+          parentsList = [];
+        }
+
+        const safeParents = this.safeDeepCopy(parentsList).map(node => ({
+          orgUnitId: node.orgUnitId,
+          orgUnitName: node.orgUnitName || node.name,
+          parentOrgUnitId: node.parentOrgUnitId || node.parentId,
+          leafNode: false,
+          title: node.orgUnitName || node.name || `未命名组织(${node.orgUnitId})`,
+          expand: true,
+          orgChildrenList: [],
+          children: []
+        }));
+
+        const treeSourceData = [...safeParents, rootNode].filter(Boolean);
+        this.postTree = this.buildTree(treeSourceData);
+        // 缓存原始树数据
+        this.originalPostTree = this.safeDeepCopy(this.postTree);
+
+        if (this.postTree.length === 0) {
+          this.postTree = [rootNode];
+          this.originalPostTree = [rootNode]; // 同步缓存
+        }
+
+        this.postTreeLoaded = true;
+
+      } catch (e) {
+        console.error("岗位选择Tab树初始化失败:", e);
+        this.postTree = [];
+        this.originalPostTree = []; // 缓存空数据
+        this.postTreeLoaded = true;
+        this.$Message.error("岗位组织树初始化失败，请刷新重试");
+      }
+    },
+
     async initStaffOrgTree() {
       try {
-        // 关键修复：初始化时重置选中状态
+        // 初始化时重置选中状态
         this.$set(this, 'selectedStaffOrgId', '');
         this.proStaffOrgList = [];
-
+        this.staffTreeLoaded = false;
         const rootOrgId = this.defaultOrgUnitId || '';
         let rootNode = null;
         let treeSourceData = []; // 存储树原始数据，避免后续覆盖
 
-        if (rootOrgId) {
-          const orgDetailRes = await ajax.get(`/pub-manage-server/pub/organ/q/queryOrg`, {
-            params: { orgUnitId: rootOrgId }
+        // if (rootOrgId) {
+        //   const orgDetailRes = await ajax.get(`/pub-manage-server/pub/organ/q/queryOrg`, {
+        //     params: { orgUnitId: rootOrgId }
+        //   });
+        //   if (orgDetailRes.data.code === 1 && orgDetailRes.data.data) {
+        //     const orgData = orgDetailRes.data.data;
+        //     const leafNode = await this.judgeNodeLeafe(rootOrgId);
+        //     rootNode = this.safeDeepCopy({
+        //       ...orgData,
+        //       orgNodeName: orgData.orgUnitName || '',
+        //       title: orgData.orgUnitName || `未命名组织(${orgData.orgUnitId || ''})`,
+        //       leafNode,
+        //       expand: true,
+        //       parentOrgUnitId: orgData.parentOrgUnitId || orgData.parentId,
+        //       orgChildrenList: [], // 初始化自定义子节点字段
+        //       children: [] // 初始化 Tree 组件识别的 children 字段
+        //     });
+        //     // 父节点列表同样同步初始化 children 字段
+        //     let parentsList = await this.getParentOrgNodesByOrgUnitId(rootOrgId);
+        //     const safeParents = this.safeDeepCopy(parentsList);
+        //     safeParents.forEach(node => {
+        //       node.expand = true;
+        //       node.parentOrgUnitId = node.parentId;
+        //       node.orgNodeName = node.orgUnitName || node.orgNodeName || '';
+        //       node.title = node.orgUnitName || node.name || `未命名组织(${node.orgUnitId || ''})`;
+        //       node.orgChildrenList = [];
+        //       node.children = []; // 父节点也初始化 children 字段
+        //       node.leafNode = false;
+        //     });
+        //     treeSourceData = [...safeParents, rootNode];
+        //   } else {
+        //     this.$Message.error("根据默认组织ID查询根节点失败！");
+        //     return;
+        //   }
+        // } else {
+        //   // defaultOrgUnitId为空时，沿用原有接口/pub/personHelpBox/q/getOrgUnitList
+        //   const res = await ajax.get('/pub-manage-server/pub/personHelpBox/q/getOrgUnitList', {
+        //     params: { containsCurLevel: true }
+        //   });
+        //   if (res.data.code === 1) {
+        //     rootNode = res.data.data[0] || null;
+        //     if (rootNode) {
+        //       rootNode.expand = true;
+        //       rootNode.parentOrgUnitId = rootNode.parentId;
+        //       treeSourceData = [rootNode];
+        //     }
+        //   }
+        // }
+        const orgDetailRes = await ajax.get(`/pub-manage-server/pub/organ/q/queryOrg`, {
+          params: { orgUnitId: rootOrgId }
+        });
+        if (orgDetailRes.data.code === 1 && orgDetailRes.data.data) {
+          const orgData = orgDetailRes.data.data;
+          const leafNode = await this.judgeNodeLeafe(rootOrgId);
+          rootNode = this.safeDeepCopy({
+            ...orgData,
+            orgNodeName: orgData.orgUnitName || '',
+            title: orgData.orgUnitName || `未命名组织(${orgData.orgUnitId || ''})`,
+            leafNode,
+            expand: true,
+            parentOrgUnitId: orgData.parentOrgUnitId || orgData.parentId,
+            orgChildrenList: [], // 初始化自定义子节点字段
+            children: [] // 初始化 Tree 组件识别的 children 字段
           });
-          if (orgDetailRes.data.code === 1 && orgDetailRes.data.data) {
-            const orgData = orgDetailRes.data.data;
-            const leafNode = await this.judgeNodeLeafe(rootOrgId);
-            rootNode = this.safeDeepCopy({
-              ...orgData,
-              orgNodeName: orgData.orgUnitName || '',
-              title: orgData.orgUnitName || `未命名组织(${orgData.orgUnitId || ''})`,
-              leafNode,
-              expand: true,
-              parentOrgUnitId: orgData.parentOrgUnitId || orgData.parentId,
-              orgChildrenList: [], // 初始化自定义子节点字段
-              children: [] // 关键：初始化 Tree 组件识别的 children 字段
-            });
-            // 父节点列表同样同步初始化 children 字段
-            let parentsList = await this.getParentOrgNodesByOrgUnitId(rootOrgId);
-            const safeParents = this.safeDeepCopy(parentsList);
-            safeParents.forEach(node => {
-              node.expand = true;
-              node.parentOrgUnitId = node.parentId;
-              node.orgNodeName = node.orgUnitName || node.orgNodeName || '';
-              node.title = node.orgUnitName || node.name || `未命名组织(${node.orgUnitId || ''})`;
-              node.orgChildrenList = [];
-              node.children = []; // 父节点也初始化 children 字段
-              node.leafNode = false;
-            });
-            treeSourceData = [...safeParents, rootNode];
-          } else {
-            this.$Message.error("根据默认组织ID查询根节点失败！");
-            return;
-          }
-        } else {
-          // defaultOrgUnitId为空时，沿用原有接口/pub/personHelpBox/q/getOrgUnitList
-          const res = await ajax.get('/pub-manage-server/pub/personHelpBox/q/getOrgUnitList', {
-            params: { containsCurLevel: true }
+          // 父节点列表同样同步初始化 children 字段
+          let parentsList = await this.getParentOrgNodesByOrgUnitId(rootOrgId);
+          const safeParents = this.safeDeepCopy(parentsList);
+          safeParents.forEach(node => {
+            node.expand = true;
+            node.parentOrgUnitId = node.parentId;
+            node.orgNodeName = node.orgUnitName || node.orgNodeName || '';
+            node.title = node.orgUnitName || node.name || `未命名组织(${node.orgUnitId || ''})`;
+            node.orgChildrenList = [];
+            node.children = []; // 父节点也初始化 children 字段
+            node.leafNode = false;
           });
-          if (res.data.code === 1) {
-            rootNode = res.data.data[0] || null;
-            if (rootNode) {
-              rootNode.expand = true;
-              rootNode.parentOrgUnitId = rootNode.parentId;
-              treeSourceData = [rootNode];
-            }
-          }
+          treeSourceData = [...safeParents, rootNode];
+        } else {
+          this.$Message.error("根据默认组织ID查询根节点失败！");
+          this.staffTreeLoaded = true;
+          return;
         }
-
-        // 构建组织树，且仅赋值一次，避免后续覆盖（需求3）
+        // 构建组织树，且仅赋值一次，避免后续覆盖
         if (treeSourceData.length > 0) {
           const tree = this.buildTree(treeSourceData);
           this.staffTree = this.safeDeepCopy(tree);
-          // 关键：标记树已初始化完成，防止后续重复构建覆盖
-          this.staffTreeInited = true;
+          // 标记树已初始化完成，防止后续重复构建覆盖
+          // this.staffTreeInited = true;
+          this.staffTreeLoaded = true;
         }
       } catch (e) {
         this.$Message.error("人员选择组织树初始化失败！");
         console.error(e);
+        this.staffTreeLoaded = true;
       }
     },
     handlePostTagSelect(quickPickKey) {
@@ -504,7 +700,6 @@ export default {
           this.loadingPost = false;
           if (res.data.code === 1) {
             let resp = res.data.data?.items ?? [];
-            // 修复：岗位搜索结果深拷贝，避免引用污染
             this.postSearchList = this.safeDeepCopy(resp);
           } else {
             this.postSearchList = [];
@@ -512,13 +707,15 @@ export default {
           }
         });
       } else {
-        // 修复：清空搜索时，同时清空树数据和暂存列表（与组织Tab一致）
+        // 仅清空搜索结果，不重置树数据
         this.postSearchList = [];
+        // 仅重置选中状态，保留树结构
         if (this.$refs.postTree) {
-          this.$refs.postTree.initData();
+          this.$refs.postTree.initData(); // 清空选中状态
+          this.proPostList = []; // 清空暂存列表
         }
-        this.proPostList = []; // 清空岗位暂存列表
-        this.$set(this, 'postTree', []); // 清空岗位树数据
+        // 移除清空树数据的代码
+        // this.$set(this, 'postTree', []);
       }
     },
     getOrgUnitBySearchTerm(query,callback){
@@ -526,78 +723,138 @@ export default {
     },
     async getOrgOption(val) {
       this.selectedOrgTagKey = '';
-      this.orgTagList.forEach(tag => {
-        tag.checked = false;
-      });
+      this.orgTagList.forEach(tag => tag.checked = false);
       this.proOrgList = [];
-      if(!val) return this.$refs.orgTree.initData();
-      let item = this.orgSearchList.filter((item)=> item.orgUnitId === val).shift();
-      if (!item) return;
+      if (!val) {
+        // 清空搜索时恢复原始树数据，而非置空
+        this.orgTree = this.safeDeepCopy(this.originalOrgTree);
+        // 同步更新子组件数据
+        this.$nextTick(() => {
+          if (this.$refs.orgTree) {
+            this.$refs.orgTree.data = this.safeDeepCopy(this.orgTree);
+            // 重置树选中状态，但保留树结构
+            this.$refs.orgTree.initData();
+          }
+        });
+        return;
+      }
+      const orgDetailRes = await ajax.get(`/pub-manage-server/pub/organ/q/queryOrg`, {
+        params: { orgUnitId: val }
+      });
 
-      const leafNode = await this.judgeNodeLeafe(item.orgUnitId);
-      const ftem = this.safeDeepCopy({
-        ...item,
-        orgNodeName: item.name,
-        parentOrgUnitId: item.parentId,
-        leafNode: leafNode
+      if (orgDetailRes.data.code !== 1 || !orgDetailRes.data.data) {
+        this.$Message.error("获取组织节点详情失败！");
+        return;
+      }
+
+      const nodeData = orgDetailRes.data.data;
+      const currentNode = this.safeDeepCopy({
+        orgUnitId: nodeData.orgUnitId,
+        orgUnitName: nodeData.orgUnitName,
+        parentOrgUnitId: nodeData.parentOrgUnitId,
+        leafNode: nodeData.leafNode || await this.judgeNodeLeafe(nodeData.orgUnitId),
+        title: nodeData.orgUnitName || `未命名组织(${nodeData.orgUnitId})`,
+        expand: true,
+        orgChildrenList: [],
+        children: []
       });
 
-      try{
+      try {
         let parentsList = await this.getParentOrgNodesByOrgUnitId(val);
-        // 对父节点列表进行安全拷贝
-        const safeParents = this.safeDeepCopy(parentsList);
-        let tree = this.buildTree([...safeParents, ftem]);
-        this.orgTree = this.safeDeepCopy(tree);
-      }catch(e){
-        this.$Message.error("获取组织节点列表失败！");
+        const safeParents = this.safeDeepCopy(parentsList).map(node => ({
+          orgUnitId: node.orgUnitId,
+          orgUnitName: node.orgUnitName || node.name,
+          parentOrgUnitId: node.parentOrgUnitId || node.parentId,
+          leafNode: false,
+          title: node.orgUnitName || node.name || `未命名组织(${node.orgUnitId})`,
+          expand: true,
+          orgChildrenList: [],
+          children: []
+        }));
+
+        const treeSourceData = [...safeParents, currentNode].filter(Boolean);
+        this.orgTree = this.buildTree(treeSourceData);
+
+        // 强制更新子组件数据
+        this.$nextTick(() => {
+          if (this.$refs.orgTree) {
+            this.$refs.orgTree.data = this.safeDeepCopy(this.orgTree);
+          }
+        });
+      } catch (e) {
+        this.$Message.error("更新组织树失败！");
       }
     },
     async getPostOption(val) {
-      // 1. 重置选中的标签key
       this.selectedPostTagKey = '';
+      this.postTagList.forEach(tag => tag.checked = false);
 
-      // 2. 重置所有标签的选中状态
-      this.postTagList.forEach(tag => {
-        tag.checked = false;
-      });
       if (!val) {
-        // 修复：岗位树清空时，同时清空暂存列表和搜索框
-        if (this.$refs.postTree) {
-          this.$refs.postTree.initData();
-        }
-        this.proPostList = []; // 清空岗位暂存列表（与组织Tab保持一致）
-        this.postSearch = ''; // 清空搜索框
+        // 清空搜索时恢复原始树数据
+        this.postTree = this.safeDeepCopy(this.originalPostTree);
+        this.proPostList = [];
+        this.postSearch = '';
+        // 同步更新子组件数据
+        this.$nextTick(() => {
+          if (this.$refs.postTree) {
+            this.$refs.postTree.data = this.safeDeepCopy(this.postTree);
+            // 重置树选中状态，但保留树结构
+            this.$refs.postTree.initData();
+          }
+        });
         return;
       }
 
-      let item = this.postSearchList.filter(item => item.orgUnitId === val).shift();
-      if (!item) return;
+      // 原有逻辑保持不变
+      const orgDetailRes = await ajax.get(`/pub-manage-server/pub/organ/q/queryOrg`, {
+        params: { orgUnitId: val }
+      });
 
-      const leafNode = await this.judgeNodeLeafe(item.orgUnitId);
-      // 修复：岗位节点深拷贝，避免引用污染
-      const ftem = this.safeDeepCopy({
-        ...item,
-        orgNodeName: item.name || `未命名组织(${item.orgUnitId})`,
-        parentOrgUnitId: item.parentId,
-        leafNode: leafNode
+      if (orgDetailRes.data.code !== 1 || !orgDetailRes.data.data) {
+        this.$Message.error("获取组织节点详情失败！");
+        return;
+      }
+
+      const nodeData = orgDetailRes.data.data;
+      const currentNode = this.safeDeepCopy({
+        orgUnitId: nodeData.orgUnitId,
+        orgUnitName: nodeData.orgUnitName,
+        parentOrgUnitId: nodeData.parentOrgUnitId,
+        leafNode: nodeData.leafNode || await this.judgeNodeLeafe(nodeData.orgUnitId),
+        title: nodeData.orgUnitName || `未命名组织(${nodeData.orgUnitId})`,
+        expand: true,
+        orgChildrenList: [],
+        children: []
       });
 
       try {
         let parentsList = await this.getParentOrgNodesByOrgUnitId(val);
-        const safeParents = this.safeDeepCopy(parentsList);
-        let tree = this.buildTree([...safeParents, ftem]);
-        // 修复：用$set确保岗位树数据响应式更新
-        this.$set(this, 'postTree', this.safeDeepCopy(tree));
+        const safeParents = this.safeDeepCopy(parentsList).map(node => ({
+          orgUnitId: node.orgUnitId,
+          orgUnitName: node.orgUnitName || node.name,
+          parentOrgUnitId: node.parentOrgUnitId || node.parentId,
+          leafNode: false,
+          title: node.orgUnitName || node.name || `未命名组织(${node.orgUnitId})`,
+          expand: true,
+          orgChildrenList: [],
+          children: []
+        }));
+
+        const treeSourceData = [...safeParents, currentNode].filter(Boolean);
+        this.postTree = this.buildTree(treeSourceData);
 
-        // 修复：设置节点展开和选中（与组织Tab逻辑一致）
         this.$nextTick(() => {
           if (this.$refs.postTree && this.$refs.postTree.setCheckedNodes) {
-            this.$refs.postTree.setCheckedNodes([val]); // 选中当前节点
-            this.proPostList = [ftem]; // 同步暂存列表
+            this.$refs.postTree.setCheckedNodes([val]);
+            this.proPostList = [currentNode];
+          }
+          // 强制更新子组件数据
+          if (this.$refs.postTree) {
+            this.$refs.postTree.data = this.safeDeepCopy(this.postTree);
           }
         });
       } catch (e) {
-        this.$Message.error("获取组织节点列表失败！");
+        this.$Message.error("更新岗位组织树失败！");
       }
     },
     async getStaffOption(val) {
@@ -624,67 +881,84 @@ export default {
         this.$Message.error("获取组织节点列表失败！");
       }
     },
-    getParentOrgNodesByOrgUnitId(val){
-      return new Promise((resolve,reject)=>{
-        ajax.get('/pub-manage-server/pub/personHelpBox/q/getParentOrgNodesByOrgUnitId?orgUnitId='+val).then((res)=>{
-          if(res.data.code === 1){
-            let parentsList = res.data?.data?.items??[]
-            resolve(parentsList)
-          }else{
-            reject(false)
-          }
-        })
-      })
+    getParentOrgNodesByOrgUnitId(val) {
+      return new Promise((resolve) => {
+        ajax.get('/pub-manage-server/pub/personHelpBox/q/getParentOrgNodesByOrgUnitId?orgUnitId='+val)
+            .then((res) => {
+              if (res.data.code === 1) {
+                const parentsList = res.data?.data?.items ?? [];
+                resolve(parentsList); // 接口正常返回则取数据
+              } else {
+                resolve([]); // 接口报错返回空数组
+              }
+            })
+            .catch(() => {
+              resolve([]); // 网络/请求失败返回空数组
+            });
+      });
     },
-    judgeNodeLeafe(orgUnitId){
-      return new Promise((resolve,reject)=>{
-        ajax.get('/pub-manage-server/pub/personHelpBox/q/getOrgUnitList', { params:{
-            containsCurLevel:true,
-            orgUnitId:orgUnitId,
+    judgeNodeLeafe(orgUnitId) {
+      return new Promise((resolve) => {
+        ajax.get('/pub-manage-server/pub/personHelpBox/q/getOrgUnitList', {
+          params: {
+            containsCurLevel: true,
+            orgUnitId: orgUnitId,
           }
-        }).then((res)=>{
-          if(res.data.code === 1){
-            let treeList = res.data.data
-            if(treeList && treeList.length){
-              resolve(false)
-            }else{
-              resolve(true)
-            }
-          }else{
-            resolve(false)
+        }).then((res) => {
+          if (res.data.code === 1) {
+            const treeList = res.data.data || [];
+            resolve(treeList.length === 0);
+          } else {
+            resolve(false); // 接口失败默认非叶子节点
           }
-        })
-      })
+        }).catch(() => {
+          resolve(false); // 网络错误默认非叶子节点
+        });
+      });
     },
     buildTree(items) {
-      const map = {};
+      if (!Array.isArray(items) || items.length === 0) {
+        console.warn('构建树入参为空，返回空数组');
+        return [];
+      }
+
+      const map = new Map();
       const roots = [];
       const copiedItems = this.safeDeepCopy(items);
 
       copiedItems.forEach(item => {
         if (!item.orgUnitId) return;
-        map[item.orgUnitId] = this.safeDeepCopy({
-          ...item,
-          orgChildrenList: [],
-          children: [], // 强制初始化 children 空数组
-          title: item.orgUnitName || item.orgNodeName || item.name || `未命名组织(${item.orgUnitId || ''})`
-        });
+        map.set(item.orgUnitId, this.safeDeepCopy({
+          orgUnitId: item.orgUnitId,
+          orgUnitName: item.orgUnitName,
+          parentOrgUnitId: item.parentOrgUnitId,
+          leafNode: item.leafNode || false,
+          title: item.title || item.orgUnitName || `未命名组织(${item.orgUnitId})`,
+          expand: item.expand || true, // 保留展开状态
+          orgChildrenList: item.orgChildrenList || [],
+          children: item.children || []
+        }));
       });
 
       copiedItems.forEach(item => {
-        if (!item.orgUnitId || !map[item.orgUnitId]) return;
+        if (!item.orgUnitId || !map.has(item.orgUnitId)) return;
 
-        const node = map[item.orgUnitId];
-        if (!item.parentOrgUnitId || !map[item.parentOrgUnitId]) {
+        const node = map.get(item.orgUnitId);
+        if (!item.parentOrgUnitId || !map.has(item.parentOrgUnitId)) {
           roots.push(node);
         } else {
-          const parent = map[item.parentOrgUnitId];
+          const parent = map.get(item.parentOrgUnitId);
           parent.orgChildrenList.push(node);
-          parent.children.push(node); // 同步 children 字段
-          parent.leafNode = false;
-          parent.expand = true;
+          parent.children.push(node);
+          parent.leafNode = false; // 有子节点则强制非叶子节点
+          parent.expand = true; // 有子节点则强制展开
         }
       });
+
+      if (roots.length === 0 && map.size > 0) {
+        roots.push(Array.from(map.values())[0]);
+      }
+
       return roots;
     },
 
@@ -692,7 +966,7 @@ export default {
       this.staffEnding = false;
       this.offset = 0;
       this.staffAllList = [];
-      // 关键修复：50ms延迟，解决极端情况下的异步更新问题
+      // 50ms延迟，解决极端情况下的异步更新问题
       setTimeout(() => {
         this.loadMore();
       }, 50);
@@ -807,7 +1081,7 @@ export default {
         return;
       }
 
-      // 关键修复1：过滤仅含有效orgUnitId的节点，排除无效数据
+      // 过滤仅含有效orgUnitId的节点，排除无效数据
       const validNodes = data.filter(node =>
           node.orgUnitId && typeof node.orgUnitId === 'string' // 确保orgUnitId存在且为字符串
       );
@@ -821,7 +1095,7 @@ export default {
         return;
       }
 
-      // 关键修复2：单选逻辑强化，仅保留最后一个有效选中节点
+      // 单选逻辑强化，仅保留最后一个有效选中节点
       const currentNode = validNodes[validNodes.length - 1];
       const currentOrgUnitId = currentNode.orgUnitId.trim(); // 去除空格，避免无效字符串
 
@@ -836,11 +1110,11 @@ export default {
       if (pureNode.orgChildrenList) pureNode.orgChildrenList = [];
       if (pureNode.children) pureNode.children = [];
 
-      // 关键修复3：强制响应式更新，避免Vue数据延迟
+      // 强制响应式更新，避免Vue数据延迟
       this.$set(this, 'proStaffOrgList', [pureNode]);
       this.$set(this, 'selectedStaffOrgId', currentOrgUnitId);
 
-      // 关键修复4：双重nextTick确保数据完全更新后再查询
+      // 双重nextTick确保数据完全更新后再查询
       this.$nextTick(() => {
         if (this.selectedStaffOrgId !== currentOrgUnitId) {
           this.$set(this, 'selectedStaffOrgId', currentOrgUnitId);
@@ -1050,15 +1324,14 @@ export default {
         this.offset = 0;
         this.staffAllList = [];
         this.loadingStaff = false;
-        this.loadMore().catch(err => console.log("同步加载失败：", err));
-        this.$nextTick(() => {
-          setTimeout(() => {
-            this.loadMore();
-          }, 100);
-        });
-      } else if (tabName === 'post' && this.$refs.postTree && this.proPostList.length === 0) {
+        // 仅当树未初始化时才加载
+        if (!this.staffTreeLoaded || this.staffTree.length === 0) {
+          this.loadMore().catch(err => console.log("同步加载失败：", err));
+        }
+      } else if (tabName === 'post' && this.proPostList.length === 0) {
         this.proPostList = [];
-        this.$refs.postTree.initData();
+        // 移除initData调用，避免重置树数据
+        // this.$refs.postTree.initData();
       }
     },
     initStaffList() {
@@ -1082,7 +1355,8 @@ export default {
       const proListKey = 'proOrgList';
       const treeDataKey = 'orgTree';
       this[proListKey] = [];
-      if (treeRef) await treeRef.initData();
+      // 移除initData调用
+      // if (treeRef) await treeRef.initData();
       if (!treeRef) {
         this.$Message.error("组织树组件未初始化，请稍后再试");
         item.checked = !item.checked;
@@ -1126,7 +1400,8 @@ export default {
 
       this[proListKey] = [];
       const isCurrentlyChecked = item.checked;
-      if (treeRef) await treeRef.initData();
+      // 移除initData调用，避免重置树数据
+      // if (treeRef) await treeRef.initData();
 
       // 2. 清空岗位 Tab 标签选中状态（仅操作 postTagList）
       this.postTagList.forEach(tag => {
@@ -1323,7 +1598,6 @@ export default {
                 }
               }
 
-              // 最终数据赋值（根据Tab类型区分，核心统一逻辑）
 
               if (matchedNodes.length > 0) {
                 // 同步暂存列表（组织proOrgList/岗位proPostList）
@@ -1418,7 +1692,6 @@ export default {
         return obj;
       }
 
-      // 检测到循环引用时，保留核心字段（orgUnitId必选，其他字段尽可能保留）
       if (hash.has(obj)) {
         const safeObj = {
           orgUnitId: obj.orgUnitId,
@@ -1536,7 +1809,7 @@ export default {
               if (res.data.code === 1 && res.data.data && res.data.data.orgUnitId) {
                 // 深拷贝并清理无效字段
                 const node = this.safeDeepCopy(res.data.data);
-                // 核心修复：确保节点名称有默认值，避免空显示
+                // 确保节点名称有默认值，避免空显示
                 const nodeName = node.orgNodeName || node.orgUnitName || node.name || `未命名组织(${orgUnitId})`;
                 node.orgNodeName = nodeName;
                 node.orgUnitName = nodeName; // 同步更新orgUnitName，确保所有使用场景都有值
@@ -1835,8 +2108,16 @@ export default {
   }
 }
 
+
 .tab-content-pro {
   .tab {
+    .search-row {
+      display: flex;
+      align-items: center;
+      flex-wrap: nowrap; // 禁止换行
+      width: 100%;
+      gap: 8px; // 文字和搜索框之间的间距
+    }
     .tree {
       // 全屏 使用百分比高度 + 最小高度
       height: calc(100vh - 340px) !important; // 从300px增加到340px，缩减40px高度
@@ -1882,6 +2163,18 @@ export default {
         color:var(--primary-color);
       }
     }
+    // 搜索标签样式（固定宽度，不换行）
+    .search-label {
+      white-space: nowrap; // 文字不换行
+      flex-shrink: 0; // 不被压缩
+      font-size: 14px;
+      color: #333;
+    }
+    // 搜索框容器样式（自适应剩余宽度）
+    .search-input-wrapper {
+      flex: 1; // 占满剩余宽度
+      min-width: 0; // 允许搜索框收缩
+    }
   }
 }
 

package/src/organize-tree.vue

@@ -54,13 +54,34 @@ export default {
     return {
       data: [],
       manageUnitId: '',
-      loading: true
+      loading: true,
+      // 内部状态存储禁用懒加载的标识
+      isDisableLazyLoad: false
     };
   },
   mounted() {
-    this.initData();
+    // 优先使用 props 的 disableLazyLoad，覆盖内部状态
+    this.isDisableLazyLoad = this.disableLazyLoad;
+    // 优先使用 props 的 isCustomTree，覆盖内部判断
+    this.isCustomTree = this.isCustomTree;
+    // 仅在未禁用懒加载且非自定义树时执行 initData
+    if (!this.isDisableLazyLoad && !this.isCustomTree) {
+      this.initData();
+    } else {
+      // 直接使用父组件传递的树数据
+      this.loading = false;
+      let tree = deepCopy(this.treeList);
+      this.initTree(tree);
+      this.data = tree;
+    }
+
   },
   methods: {
+    setDisableLazyLoad(disabled) {
+      this.isDisableLazyLoad = disabled;
+      // 同时标记为自定义树，跳过子组件自身的 initData 逻辑
+      this.isCustomTree = disabled;
+    },
     safeDeepCopy(obj, hash = new WeakMap()) {
       if (obj === null || typeof obj !== 'object') {
         return obj;
@@ -108,14 +129,15 @@ export default {
       return copy;
     },
     async initData() {
-      if (this.isCustomTree) {
+      // 优先判断内部禁用状态，而非仅依赖 isCustomTree prop
+      if (this.isCustomTree || this.isDisableLazyLoad) {
         this.loading = false;
         let tree = deepCopy(this.treeList);
         this.initTree(tree);
         this.data = tree;
         return;
       }
-      // 仅在非自定义树场景下生效
+      // 仅在非自定义/非禁用场景下执行原有逻辑
       let data = await this.getOrgChildren();
       this.loading = false;
       this.data = data;
@@ -179,7 +201,23 @@ export default {
     },
 
     async loadData(item, callback) {
-      // 自定义树场景（defaultOrgUnitId 不为空）：原有逻辑不变
+      // 核心修改：即使禁用懒加载，也允许加载已有子节点
+      if (this.disableLazyLoad) {
+        let children = item.orgChildrenList || item.children || [];
+        const formattedChildren = this.safeDeepCopy(children).map(child => ({
+          ...child,
+          title: child.orgUnitName || child.orgNodeName || child.name || `未命名组织(${child.orgUnitId || child.id || ''})`,
+          checked: false,
+          expand: false,
+          leafNode: child.leafNode || false,
+          orgChildrenList: child.orgChildrenList || [],
+          children: child.children || []
+        }));
+        callback(formattedChildren);
+        return;
+      }
+
+      // 原有逻辑保持不变
       if (this.isCustomTree) {
         let children = item.orgChildrenList || item.children || [];
         const formattedChildren = this.safeDeepCopy(children).map(child => ({
@@ -201,7 +239,6 @@ export default {
             });
             if (res.data.code === 1) {
               const apiChildren = res.data.data || [];
-              // 关键：对接口返回的二级节点进行 initTree 初始化
               const initializedApiChildren = this.initTree(apiChildren);
               const apiFormattedChildren = initializedApiChildren.map(child => ({
                 ...child,
@@ -225,18 +262,16 @@ export default {
         return;
       }
 
-      // 非自定义树场景（defaultOrgUnitId 为空）：补充子节点初始化
-      if (this.disableLazyLoad) {
-        callback([]);
-        return;
-      }
-      // 加载子节点后，先经过 initTree 处理再返回
       let children = await this.getOrgChildren(item.orgUnitId);
       const initializedChildren = this.initTree(children);
       callback(initializedChildren);
     },
 
     getOrgChildren(orgUnitId = '') {
+      // 优先判断内部禁用状态
+      if (this.isDisableLazyLoad) {
+        return Promise.resolve([]);
+      }
       if (this.isCustomTree) {
         return Promise.resolve([]);
       }
@@ -517,18 +552,38 @@ export default {
     'treeList': {
       handler(val) {
         // 自定义树场景：直接使用父组件传递的树数据，不初始化旧接口
-        if (this.isCustomTree) {
-          let tree = deepCopy(val);
+        if (this.isCustomTree || this.isDisableLazyLoad) {
+          let tree = this.safeDeepCopy(val);
           this.initTree(tree);
           this.data = tree;
           return;
         }
-        // 原有逻辑
         let tree = deepCopy(val);
         this.initTree(tree);
         this.data = tree;
       },
       deep: true
+    },
+    // 监听 isCustomTree 变化
+    isCustomTree(newVal) {
+      if (newVal) {
+        this.isDisableLazyLoad = true;
+        this.loading = false;
+        let tree = this.safeDeepCopy(this.treeList);
+        this.initTree(tree);
+        this.data = tree;
+      }
+    },
+    // 监听 disableLazyLoad 变化
+    disableLazyLoad(newVal) {
+      this.isDisableLazyLoad = newVal;
+      if (newVal) {
+        this.isCustomTree = true;
+        this.loading = false;
+        let tree = this.safeDeepCopy(this.treeList);
+        this.initTree(tree);
+        this.data = tree;
+      }
     }
   }
 };
@@ -624,4 +679,4 @@ export default {
   text-shadow: none !important;
   background: none !important;
 }
-</style>
+</style>