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

package/package.json

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

package/src/index.vue

@@ -146,7 +146,7 @@
                           :autoExpandParent="true"
                           :isSingleSelect="true"
                           :default-org-unit-id="defaultOrgUnitId"
-                          :is-custom-tree="!!defaultOrgUnitId"
+                          :is-custom-tree="true"
                           :disable-lazy-load="false"
                       ></organizeTree>
                     </div>
@@ -296,7 +296,7 @@ export default {
       parentOrgList: [],
       orgTagList:[],
       postTagList:[],
-      selectedPositionId: null, // 新增：岗位单选的选中状态存储
+      selectedPositionId: null, // 岗位单选的选中状态存储
       selectedOrgTagKey: '', // 存储选中标签的唯一标识
       selectedPostTagKey: '', // 存储选中标签的唯一标识
       //人员选择
@@ -304,8 +304,8 @@ export default {
       staffTagList:[],
       staffOrgList:[],
       staffSearchList:[],
-      selectedStaffOrgId: '', // 新增：选中的组织节点ID
-      proStaffOrgList: [], // 新增：暂存选中的组织节点
+      selectedStaffOrgId: '', // 选中的组织节点ID
+      proStaffOrgList: [], // 暂存选中的组织节点
       initialDefaultOrgUnitId: '', // 缓存初始defaultOrgUnitId
       // staffTreeInited: false, // 组织树初始化完成标记
       // 树加载完成标记
@@ -1517,7 +1517,7 @@ export default {
                     continue;
                   }
 
-                  // 父节点追溯与节点链挂载（修复：使用当前Tab的树数据originalTreeData，而非固定orgTree）
+                  // 父节点追溯与节点链挂载（使用当前Tab的树数据originalTreeData，而非固定orgTree）
                   let targetParent = null;
                   let nodeChain = [currentNode];
                   const MAX_DEPTH = 8;
@@ -1542,7 +1542,7 @@ export default {
                     }
 
                     parentNode.orgNodeName = parentNode.orgNodeName || parentNode.orgUnitName || `未命名组织(${parentId})`;
-                    // 修复：查询父节点是否在当前Tab的树数据中（originalTreeData），而非固定orgTree
+                    // 查询父节点是否在当前Tab的树数据中（originalTreeData），而非固定orgTree
                     const parentInTree = this.findNodeInTree(originalTreeData, parentNode.orgUnitId);
 
                     if (parentInTree) {
@@ -1629,7 +1629,7 @@ export default {
                     treeRef.handleChange(matchedNodes);
                   }
 
-                  // 提示信息（通用逻辑）
+                  // 提示信息
                   this.$Message.success(`成功选中${matchedNodes.length}个组织节点`);
                 });
               } else {
@@ -1647,11 +1647,10 @@ export default {
       });
     },
 
-    // 新增：移除树数据中的 parent 引用，避免子组件处理时形成循环
+    // 移除树数据中的 parent 引用，避免子组件处理时形成循环
     removeParentReferences(treeData) {
       if (!Array.isArray(treeData)) return;
       treeData.forEach(node => {
-        // 删除可能存在的 parent 引用（如果节点有此属性）
         if (node.parent) delete node.parent;
         // 递归处理子节点
         if (Array.isArray(node.orgChildrenList)) {
@@ -1686,7 +1685,6 @@ export default {
       return null;
     },
 
-    // 增强安全深拷贝，主动移除循环引用字段
     safeDeepCopy(obj, hash = new WeakMap()) {
       if (obj === null || typeof obj !== 'object') {
         return obj;
@@ -1715,15 +1713,12 @@ export default {
         hash.set(obj, copy);
         for (let key in obj) {
           if (obj.hasOwnProperty(key)) {
-            // 仅过滤vue内部字段，保留业务字段
             if (['__vue__', '__ob__', '$parent', '$children'].includes(key)) {
               continue;
             }
-            // 子节点数组特殊处理
             if (['orgChildrenList', 'children'].includes(key) && Array.isArray(obj[key])) {
               copy[key] = obj[key].map(child => this.safeDeepCopy(child, hash));
             } else {
-              // 保留所有业务字段，不额外过滤
               copy[key] = this.safeDeepCopy(obj[key], hash);
             }
           }
@@ -1735,9 +1730,9 @@ export default {
     },
 
     /**
-     * 查询单个节点的原生详情（适配后端接口，返回原生字段）
-     * @param {string} orgUnitId - 节点ID（如11510101）
-     * @returns {Promise<Object|null>} 原生节点详情（无数据返回null）
+     * 查询单个节点的原生详情
+     * @param {string} orgUnitId
+     * @returns {Promise<Object|null>}
      */
     getOrgNodeDetail(orgUnitId) {
       return new Promise((resolve) => {
@@ -1745,13 +1740,12 @@ export default {
           params: { orgUnitId: orgUnitId }
         }).then((res) => {
           if (res.data.code === 1 && res.data.data) {
-            // 仅保留原生树结构必需字段（过滤业务冗余字段）
             const { orgUnitId, parentOrgUnitId, orgNodeName, orgChildrenList } = res.data.data;
             resolve({
               orgUnitId,
               parentOrgUnitId,
               orgNodeName,
-              orgChildrenList: orgChildrenList || [] // 兼容接口返回空的情况
+              orgChildrenList: orgChildrenList || []
             });
           } else {
             resolve(null);
@@ -1764,7 +1758,7 @@ export default {
     },
 
     /**
-     * 迭代查找节点（替代递归，避免栈溢出）
+     * 迭代查找节点
      * @param {Array} treeData - 树形数据
      * @param {string} targetOrgUnitId - 目标节点ID
      * @returns {Object|null} 找到的节点
@@ -1777,7 +1771,6 @@ export default {
       const queue = [...treeData];
       while (queue.length > 0) {
         const currentNode = queue.shift();
-        // 兼容子组件可能的字段映射（orgUnitId可能存储在id字段）
         const nodeId = currentNode.orgUnitId || currentNode.id || '';
         if (nodeId === targetOrgUnitId) {
           return currentNode;

package/src/organize-tree.vue

@@ -201,7 +201,7 @@ export default {
     },
 
     async loadData(item, callback) {
-      // 核心修改：即使禁用懒加载，也允许加载已有子节点
+      // 即使禁用懒加载，也允许加载已有子节点
       if (this.disableLazyLoad) {
         let children = item.orgChildrenList || item.children || [];
         const formattedChildren = this.safeDeepCopy(children).map(child => ({
@@ -305,7 +305,7 @@ export default {
         return;
       }
 
-      // 单选逻辑强化：清空所有选中状态
+      // 单选，清空所有选中状态
       this.clearAllChecked(this.data);
 
       const targetList = this.isSingleSelect
@@ -412,34 +412,27 @@ export default {
       }
       return null;
     },
-    // organize-tree.vue - 重构 initTree 方法，确保递归处理所有层级
+
     initTree(treeList) {
       // 递归处理节点的内部方法
       const recursiveInitNode = (node) => {
-        // 1. 统一节点标题（优先级：orgUnitName > orgNodeName > name > 兜底）
         node.title = node.orgUnitName || node.orgNodeName || node.name || `未命名组织(${node.orgUnitId || node.id || ''})`;
-        // 2. 初始化基础字段
         node.loading = false;
         node.expand = false;
         node.checked = false;
-        // 3. 关键：无论是否有子节点，先初始化 children 空数组（让 Tree 组件识别可懒加载）
         node.children = node.children || [];
-        // 4. 同步 orgChildrenList 和 children（双向绑定，避免字段不一致）
         node.orgChildrenList = node.orgChildrenList || node.children || [];
-        // 5. 禁用状态处理
         if (this.disabled) {
           node.disabled = true;
         }
-        // 6. 叶子节点判断：如果明确标记为 leafNode，删除 loading 和 children（禁止展开）
         if (node.leafNode) {
           delete node.loading;
           delete node.children;
           delete node.orgChildrenList;
         } else {
-          // 7. 非叶子节点：递归处理已有子节点（确保下级节点也完成初始化）
           if (Array.isArray(node.orgChildrenList) && node.orgChildrenList.length > 0) {
             node.children = node.orgChildrenList.map(child => recursiveInitNode(child));
-            node.expand = true; // 默认展开已有子节点的节点
+            node.expand = true;
           }
         }
         return node;
@@ -509,18 +502,16 @@ export default {
             flex: 1,
             pointerEvents: 'none',
             userSelect: 'none',
-            // 新增：防止文字溢出导致的截断（可选，解决orgUnitId显示不全问题）
             whiteSpace: 'normal',
             wordWrap: 'break-word'
           }
-        }, nodeText) // 使用调整优先级后的节点文字
+        }, nodeText)
       ]);
     },
     collectCurrentCheckedNodes(nodeList) {
       let checkedNodes = [];
       nodeList.forEach(node => {
         if (node.checked) {
-          // 强制补全orgUnitId，过滤无效节点
           const nodeId = node.orgUnitId || node.id || '';
           if (nodeId && typeof nodeId === 'string' && nodeId.trim()) {
             const validNode = {
@@ -551,7 +542,6 @@ export default {
   watch: {
     'treeList': {
       handler(val) {
-        // 自定义树场景：直接使用父组件传递的树数据，不初始化旧接口
         if (this.isCustomTree || this.isDisableLazyLoad) {
           let tree = this.safeDeepCopy(val);
           this.initTree(tree);