@opensumi/ide-components 2.21.13 → 2.22.0

package/lib/recycle-tree/tree/TreeNode.js

@@ -25,21 +25,6 @@ var BranchOperatorStatus;
     BranchOperatorStatus[BranchOperatorStatus["SHRINKED"] = 2] = "SHRINKED";
 })(BranchOperatorStatus = exports.BranchOperatorStatus || (exports.BranchOperatorStatus = {}));
 class TreeNode {
-    constructor(tree, parent, watcher, optionalMetadata) {
-        this._uid = TreeNode.nextId();
-        this._parent = parent;
-        this._tree = tree;
-        this._disposed = false;
-        this._visible = true;
-        this._metadata = Object.assign({}, (optionalMetadata || {}));
-        this._depth = parent ? parent.depth + 1 : 0;
-        if (watcher) {
-            this._watcher = watcher;
-        }
-        else if (parent) {
-            this._watcher = parent.watcher;
-        }
-    }
     static is(node) {
         return !!node && 'depth' in node && 'name' in node && 'path' in node && 'id' in node;
     }
@@ -64,8 +49,7 @@ class TreeNode {
         return TreeNode.pathToId.set(path, id);
     }
     static getGlobalTreeState(path) {
-        const root = path.split(Path.separator).slice(0, 2).join(Path.separator);
-        let state = TreeNode.pathToGlobalTreeState.get(root);
+        let state = TreeNode.pathToGlobalTreeState.get(path);
         if (!state) {
             state = {
                 isExpanding: false,
@@ -78,8 +62,7 @@ class TreeNode {
         return state;
     }
     static setGlobalTreeState(path, updateState) {
-        const root = path.split(Path.separator).slice(0, 2).join(Path.separator);
-        let state = TreeNode.pathToGlobalTreeState.get(root);
+        let state = TreeNode.pathToGlobalTreeState.get(path);
         if (!state) {
             state = {
                 isExpanding: false,
@@ -90,9 +73,24 @@ class TreeNode {
             };
         }
         state = Object.assign(Object.assign({}, state), updateState);
-        TreeNode.pathToGlobalTreeState.set(root, state);
+        TreeNode.pathToGlobalTreeState.set(path, state);
         return state;
     }
+    constructor(tree, parent, watcher, optionalMetadata) {
+        this._uid = TreeNode.nextId();
+        this._parent = parent;
+        this._tree = tree;
+        this._disposed = false;
+        this._visible = true;
+        this._metadata = Object.assign({}, (optionalMetadata || {}));
+        this._depth = parent ? parent.depth + 1 : 0;
+        if (watcher) {
+            this._watcher = watcher;
+        }
+        else if (parent) {
+            this._watcher = parent.watcher;
+        }
+    }
     get disposed() {
         return this._disposed;
     }
@@ -244,80 +242,6 @@ TreeNode.pathToId = new Map();
 // 每颗树都只会在根节点上绑定一个可取消的对象，即同个时间点只能存在一个改变树数据结构的事情
 TreeNode.pathToGlobalTreeState = new Map();
 class CompositeTreeNode extends TreeNode {
-    // parent 为undefined即表示该节点为根节点
-    constructor(tree, parent, watcher, optionalMetadata) {
-        super(tree, parent, watcher, optionalMetadata);
-        this._children = null;
-        this.refreshThrottler = new ide_utils_1.Throttler();
-        this._lock = false;
-        /**
-         * 处理Watch事件，同时可通过外部手动调 g用节点更新函数进行节点替换，这里为通用的事件管理
-         * 如： transferItem，insertItem, unlinkItem等
-         * @private
-         * @memberof CompositeTreeNode
-         */
-        this.handleWatchEvent = async (event) => {
-            this.watcher.notifyWillProcessWatchEvent(this, event);
-            if (event.type === types_1.WatchEvent.Moved) {
-                const { oldPath, newPath } = event;
-                if (typeof oldPath !== 'string') {
-                    throw new TypeError('Expected oldPath to be a string');
-                }
-                if (typeof newPath !== 'string') {
-                    throw new TypeError('Expected newPath to be a string');
-                }
-                if (Path.isRelative(oldPath)) {
-                    throw new TypeError('oldPath must be absolute');
-                }
-                if (Path.isRelative(newPath)) {
-                    throw new TypeError('newPath must be absolute');
-                }
-                this.transferItem(oldPath, newPath);
-            }
-            else if (event.type === types_1.WatchEvent.Added) {
-                const { node } = event;
-                if (!TreeNode.is(node)) {
-                    throw new TypeError('Expected node to be a TreeNode');
-                }
-                this.insertItem(node);
-            }
-            else if (event.type === types_1.WatchEvent.Removed) {
-                const { path } = event;
-                const pathObject = new Path(path);
-                const dirName = pathObject.dir.toString();
-                const name = pathObject.base.toString();
-                if (dirName === this.path && !!this.children) {
-                    const item = this.children.find((c) => c.name === name);
-                    if (item) {
-                        this.unlinkItem(item);
-                    }
-                }
-            }
-            else {
-                // 如果当前变化的节点已在数据视图（并非滚动到不可见区域）中不可见，则将该节点折叠，待下次更新即可，
-                if (!this.isItemVisibleAtRootSurface(this)) {
-                    this.isExpanded = false;
-                    this._children = null;
-                }
-                else {
-                    // needReload --- 判断根目录是否需要进行一次刷新，部分情况，如压缩目录下的文件创建后不应该刷新
-                    await this.refresh();
-                }
-            }
-            this.watcher.notifyDidProcessWatchEvent(this, event);
-        };
-        this.isExpanded = parent ? false : true;
-        this._branchSize = 0;
-        if (!parent) {
-            this.watchEvents = new Map();
-            // 为根节点创建监听器
-            this._watcher = this.generatorWatcher();
-            TreeNode.setTreeNode(this.id, this.path, this);
-        }
-        else {
-            this._watcher = parent.watcher;
-        }
-    }
     static defaultSortComparator(a, b) {
         if (a.constructor === b.constructor) {
             return a.name > b.name ? 1 : a.name < b.name ? -1 : 0;
@@ -396,6 +320,81 @@ class CompositeTreeNode extends TreeNode {
         };
         return watcher;
     }
+    // parent 为undefined即表示该节点为根节点
+    constructor(tree, parent, watcher, optionalMetadata) {
+        super(tree, parent, watcher, optionalMetadata);
+        this._children = null;
+        this._lock = false;
+        this.refreshThrottler = new ide_utils_1.ThrottledDelayer(CompositeTreeNode.REFRESH_DELAY);
+        this.toRefreshPathQueue = new Set();
+        /**
+         * 处理 Watch 事件，同时可通过外部手动调 g用节点更新函数进行节点替换，这里为通用的事件管理
+         * 如： transferItem，insertItem, unlinkItem等
+         * @private
+         * @memberof CompositeTreeNode
+         */
+        this.handleWatchEvent = async (event) => {
+            this.watcher.notifyWillProcessWatchEvent(this, event);
+            if (event.type === types_1.WatchEvent.Moved) {
+                const { oldPath, newPath } = event;
+                if (typeof oldPath !== 'string') {
+                    throw new TypeError('Expected oldPath to be a string');
+                }
+                if (typeof newPath !== 'string') {
+                    throw new TypeError('Expected newPath to be a string');
+                }
+                if (Path.isRelative(oldPath)) {
+                    throw new TypeError('oldPath must be absolute');
+                }
+                if (Path.isRelative(newPath)) {
+                    throw new TypeError('newPath must be absolute');
+                }
+                this.transferItem(oldPath, newPath);
+            }
+            else if (event.type === types_1.WatchEvent.Added) {
+                const { node } = event;
+                if (!TreeNode.is(node)) {
+                    throw new TypeError('Expected node to be a TreeNode');
+                }
+                this.insertItem(node);
+            }
+            else if (event.type === types_1.WatchEvent.Removed) {
+                const { path } = event;
+                const pathObject = new Path(path);
+                const dirName = pathObject.dir.toString();
+                const name = pathObject.base.toString();
+                if (dirName === this.path && !!this.children) {
+                    const item = this.children.find((c) => c.name === name);
+                    if (item) {
+                        this.unlinkItem(item);
+                    }
+                }
+            }
+            else {
+                // 如果当前变化的节点已在数据视图（并非滚动到不可见区域）中不可见，则将该节点折叠，待下次更新即可，
+                if (!this.isItemVisibleAtRootSurface(this)) {
+                    this.isExpanded = false;
+                    this._children = null;
+                }
+                else {
+                    await this.refresh();
+                }
+            }
+            this.watcher.notifyDidProcessWatchEvent(this, event);
+        };
+        this.isExpanded = parent ? false : true;
+        this._branchSize = 0;
+        if (!parent) {
+            this.watchEvents = new Map();
+            // 为根节点创建监听器
+            this._watcher = this.generatorWatcher();
+            this._root = this;
+            TreeNode.setTreeNode(this.id, this.path, this);
+        }
+        else {
+            this._watcher = parent.watcher;
+        }
+    }
     // 重载 name 的 getter/setter，路径改变时需要重新监听文件节点变化
     set name(name) {
         const prevPath = this.path;
@@ -452,6 +451,19 @@ class CompositeTreeNode extends TreeNode {
     get lock() {
         return this._lock;
     }
+    get root() {
+        if ((0, ide_utils_1.isUndefined)(this._root)) {
+            this._root = this.getRoot() || null;
+        }
+        return this._root;
+    }
+    getRoot() {
+        let root = this.parent;
+        while (root && root.parent) {
+            root = root.parent;
+        }
+        return root;
+    }
     /**
      * 确保此“目录”的子级已加载（不影响“展开”状态）
      * 如果子级已经加载，则返回的Promise将立即解决
@@ -528,14 +540,24 @@ class CompositeTreeNode extends TreeNode {
             TreeNode.setTreeNode(this.id, this.path, this);
         }
     }
+    isCompactNode(node) {
+        return CompositeTreeNode.is(node) && node.name.includes(Path.separator);
+    }
     // 获取当前节点下所有展开的节点路径
     getAllExpandedNodePath() {
+        var _a;
         let paths = [];
         if (this.children) {
             for (let i = 0; i < this.children.length; i++) {
                 const child = this.children[i];
                 if (CompositeTreeNode.is(child) && child.expanded) {
-                    paths.push(child.path);
+                    if (this.isCompactNode(child) && ((_a = child.parent) === null || _a === void 0 ? void 0 : _a.path)) {
+                        // 当获取到的节点为压缩节点时，仅需要存储其根路径，便于后续展开更新节点状态
+                        paths.push(new Path(child.parent.path).join(child.name.split(Path.separator)[0]).toString());
+                    }
+                    else {
+                        paths.push(child.path);
+                    }
                     paths = paths.concat(child.getAllExpandedNodePath());
                 }
             }
@@ -572,7 +594,7 @@ class CompositeTreeNode extends TreeNode {
      * @param token CancellationToken
      */
     async resolveChildrens(token) {
-        var _a;
+        var _a, _b, _c;
         let childrens = this.children;
         let expandedPaths = [];
         try {
@@ -598,8 +620,8 @@ class CompositeTreeNode extends TreeNode {
             flatTree[i] = this._children[i].id;
         }
         const expandedChilds = [];
-        for (let i = 0; i < (this.children || []).length; i++) {
-            const subChild = this.children[i];
+        for (let i = 0, len = ((_b = this.children) === null || _b === void 0 ? void 0 : _b.length) || 0; i < len; i++) {
+            const subChild = (_c = this.children) === null || _c === void 0 ? void 0 : _c[i];
             if (CompositeTreeNode.is(subChild) && subChild.expanded) {
                 const paths = await subChild.resolveChildrens(token);
                 if (paths) {
@@ -629,16 +651,22 @@ class CompositeTreeNode extends TreeNode {
             }
         }
     }
-    // 静默刷新子节点, 即不触发分支更新事件
-    async refreshTreeNodeByPaths(expandedPaths = this.getAllExpandedNodePath(), needReload = true, token, root) {
+    /**
+     * 静默刷新子节点, 即不触发分支更新事件
+     * @param toExpandPaths 待展开的路径
+     * @param token CancellationToken
+     * @param origin 当 this === origin 时，说明此节点为调用的源头节点
+     */
+    async refreshTreeNodeByPaths(toExpandPaths = this.getAllExpandedNodePath(), token, origin) {
         if (!CompositeTreeNode.is(this)) {
             return;
         }
         // 如果某次刷新操作被取消，则下次刷新依旧使用上一次刷新的展开目录进行刷新
-        let forceLoadPath;
+        let toExpandPath;
+        const originChildren = this.children;
         let childrens = this.children || [];
         if (this.expanded) {
-            if (needReload) {
+            if (this === origin) {
                 try {
                     childrens = (await this._tree.resolveChildren(this)) || [];
                 }
@@ -664,12 +692,15 @@ class CompositeTreeNode extends TreeNode {
                     return;
                 }
             }
-            while ((forceLoadPath = expandedPaths.shift())) {
-                const isRelative = forceLoadPath.indexOf(`${this.path}${Path.separator}`) > -1;
+            while ((toExpandPath = toExpandPaths.shift())) {
+                const isRelative = toExpandPath.indexOf(`${this.path}${Path.separator}`) > -1;
                 if (!isRelative) {
+                    if (toExpandPath === this.path) {
+                        toExpandPath = undefined;
+                    }
                     break;
                 }
-                const child = childrens === null || childrens === void 0 ? void 0 : childrens.find((child) => child.path === forceLoadPath);
+                const child = childrens === null || childrens === void 0 ? void 0 : childrens.find((child) => child.path === toExpandPath);
                 // 对于压缩情况的路径需要额外处理一下
                 // 如果这里加载的路径是 a/b/c, 有可能目前只加载到 a/b
                 if (!child) {
@@ -678,33 +709,32 @@ class CompositeTreeNode extends TreeNode {
                     }
                     for (let i = 0; i < childrens.length; i++) {
                         const child = childrens[i];
-                        if (forceLoadPath.indexOf(`${child.path}${Path.separator}`) === 0 && CompositeTreeNode.is(child)) {
+                        if (toExpandPath.indexOf(`${child.path}${Path.separator}`) === 0 && CompositeTreeNode.is(child)) {
                             // 包含压缩节点的情况
-                            if (!CompositeTreeNode.is(child) || child.expanded) {
-                                // 说明此时节点初始化时已默认展开或被裁切，不需要进一步处理
+                            if (!CompositeTreeNode.is(child)) {
+                                // 说明此节点为非折叠节点时不处理
                                 continue;
                             }
                             child.isExpanded = true;
                             // 加载路径包含当前判断路径，尝试加载该节点再匹配
                             const extraExpandedPaths = await child.resolveChildrens(token);
-                            if (extraExpandedPaths) {
-                                expandedPaths = expandedPaths.filter((path) => !extraExpandedPaths.find((a) => a === path));
-                            }
                             if (token === null || token === void 0 ? void 0 : token.isCancellationRequested) {
                                 return;
                             }
-                            if (expandedPaths.length > 0) {
+                            if (extraExpandedPaths) {
+                                toExpandPaths = toExpandPaths.filter((path) => !extraExpandedPaths.find((a) => a === path));
+                            }
+                            if (child.path !== toExpandPath && !toExpandPath.includes(child.path)) {
+                                toExpandPaths.unshift(toExpandPath);
+                            }
+                            if (toExpandPaths.length > 0) {
                                 // 不需要重新reload压缩节点的子节点内容
-                                await child.refreshTreeNodeByPaths(expandedPaths, false, token, root);
+                                toExpandPaths =
+                                    (await child.refreshTreeNodeByPaths([...toExpandPaths], token, origin)) || [];
                                 if (token === null || token === void 0 ? void 0 : token.isCancellationRequested) {
                                     return;
                                 }
                             }
-                            else {
-                                if (child.parent !== root) {
-                                    child.expandBranch(child, true);
-                                }
-                            }
                             break;
                         }
                     }
@@ -715,27 +745,31 @@ class CompositeTreeNode extends TreeNode {
                         child.isExpanded = true;
                     }
                     const extraExpandedPaths = await child.resolveChildrens(token);
-                    if (extraExpandedPaths) {
-                        expandedPaths = expandedPaths.filter((path) => !extraExpandedPaths.find((a) => a === path));
-                    }
                     if (token === null || token === void 0 ? void 0 : token.isCancellationRequested) {
                         return;
                     }
-                    if (expandedPaths.length > 0 && !(token === null || token === void 0 ? void 0 : token.isCancellationRequested)) {
-                        await child.refreshTreeNodeByPaths(expandedPaths, false, token, root);
+                    if (extraExpandedPaths) {
+                        toExpandPaths = toExpandPaths.filter((path) => !extraExpandedPaths.find((a) => a === path));
+                    }
+                    if (toExpandPaths.length > 0 && !(token === null || token === void 0 ? void 0 : token.isCancellationRequested)) {
+                        toExpandPaths =
+                            (await child.refreshTreeNodeByPaths([...toExpandPaths], token, origin)) || [];
                         if (token === null || token === void 0 ? void 0 : token.isCancellationRequested) {
                             return;
                         }
                     }
                 }
             }
-            if (forceLoadPath) {
-                expandedPaths.unshift(forceLoadPath);
-                if (needReload) {
-                    if (this.children) {
-                        for (let i = 0; i < this.children.length; i++) {
-                            const child = this.children[i];
-                            child.dispose();
+            if (toExpandPath) {
+                // 仍然存在需要进一步处理的待展开路径
+                toExpandPaths.unshift(toExpandPath);
+                if (this === origin) {
+                    // 说明待展开的路径已经不存在，直接处理子节点
+                    if (originChildren) {
+                        this.shrinkBranch(this, true);
+                        for (let i = 0; i < originChildren.length; i++) {
+                            const child = originChildren[i];
+                            child === null || child === void 0 ? void 0 : child.dispose();
                         }
                     }
                     const expandedChilds = [];
@@ -756,24 +790,20 @@ class CompositeTreeNode extends TreeNode {
                     }
                     this._branchSize = flatTree.length;
                     this.setFlattenedBranch(flatTree, true);
+                    this.watcher.notifyDidUpdateBranch();
                 }
-                if (this.parent !== root) {
-                    // 第二层节点不处理
+                if (this.parent !== origin) {
+                    // 将所有子节点合并至第二层 Children 上，减少后续递归拼接带来额外成本
                     this.expandBranch(this, true);
                 }
+                return toExpandPaths;
             }
             else if (CompositeTreeNode.isRoot(this)) {
-                if (token === null || token === void 0 ? void 0 : token.isCancellationRequested) {
-                    return;
-                }
                 if (this.children) {
-                    // 重置旧的节点分支
                     this.shrinkBranch(this, true);
-                }
-                if (this.children) {
                     for (let i = 0; i < this.children.length; i++) {
                         const child = this.children[i];
-                        child.dispose();
+                        child === null || child === void 0 ? void 0 : child.dispose();
                     }
                 }
                 const expandedChilds = [];
@@ -822,26 +852,23 @@ class CompositeTreeNode extends TreeNode {
                 this.watcher.notifyDidUpdateBranch();
             }
             else {
-                if (token === null || token === void 0 ? void 0 : token.isCancellationRequested) {
-                    return;
-                }
+                // 非根节点刷新的情况
                 const expandedChilds = [];
-                if (needReload) {
-                    // 非根节点刷新的情况
+                if (this === origin) {
                     // 通知节点更新
                     if (this.children) {
                         // 重置旧的节点分支
                         this.shrinkBranch(this, true);
                     }
                     if (this.children) {
-                        for (let i = 0; i < this.children.length; i++) {
+                        for (let i = 0, len = this.children.length; i < len; i++) {
                             const child = this.children[i];
                             child.dispose();
                         }
                     }
                     const flatTree = new Array(childrens.length);
                     this._children = Array(childrens.length);
-                    for (let i = 0; i < childrens.length; i++) {
+                    for (let i = 0, len = childrens.length; i < len; i++) {
                         const child = childrens[i];
                         child.id = TreeNode.getIdByPath(child.path) || child.id;
                         this._children[i] = child;
@@ -874,12 +901,11 @@ class CompositeTreeNode extends TreeNode {
                     const child = expandedChilds[i];
                     child.expandBranch(child, true);
                 }
-                // 清理上一次监听函数
                 if (typeof this.watchTerminator === 'function') {
                     this.watchTerminator(this.path);
                 }
                 this.watchTerminator = this.watcher.onWatchEvent(this.path, this.handleWatchEvent);
-                if (needReload) {
+                if (this === origin) {
                     this.expandBranch(this);
                 }
             }
@@ -890,7 +916,7 @@ class CompositeTreeNode extends TreeNode {
                 // 清理子节点，等待下次展开时更新
                 if (!!this.children && this.parent) {
                     // eslint-disable-next-line @typescript-eslint/prefer-for-of
-                    for (let i = 0; i < this.children.length; i++) {
+                    for (let i = 0, len = this.children.length; i < len; i++) {
                         const child = this.children[i];
                         child.dispose();
                     }
@@ -1049,6 +1075,7 @@ class CompositeTreeNode extends TreeNode {
      * 直接调用此方法将不会触发onWillHandleWatchEvent和onDidHandleWatchEvent事件
      */
     unlinkItem(item, reparenting) {
+        var _a;
         if (!this._children) {
             return;
         }
@@ -1060,7 +1087,7 @@ class CompositeTreeNode extends TreeNode {
         if (!this.isItemVisibleAtRootSurface(this)) {
             return;
         }
-        this._children.splice(idx, 1);
+        (_a = this._children) === null || _a === void 0 ? void 0 : _a.splice(idx, 1);
         const branchSizeDecrease = 1 + (item instanceof CompositeTreeNode && item.expanded ? item._branchSize : 0);
         this._branchSize -= branchSizeDecrease;
         // 逐级往上查找节点的父节点，并沿途裁剪分支数
@@ -1087,13 +1114,14 @@ class CompositeTreeNode extends TreeNode {
      * 转换节点路径
      */
     transferItem(oldPath, newPath) {
+        var _a;
         const oldP = new Path(oldPath);
         const from = oldP.dir.toString();
         if (from !== this.path) {
             return;
         }
         const name = oldP.base.toString();
-        const item = this._children.find((c) => c.name === name);
+        const item = (_a = this._children) === null || _a === void 0 ? void 0 : _a.find((c) => c.name === name);
         if (!item) {
             return;
         }
@@ -1216,7 +1244,6 @@ class CompositeTreeNode extends TreeNode {
         const tempChildren = new Array(rawItems.length);
         for (let i = 0; i < rawItems.length; i++) {
             const child = rawItems[i];
-            // 如果存在上一次缓存的节点，则使用缓存节点的 ID
             child.id = TreeNode.getIdByPath(child.path) || child.id;
             tempChildren[i] = child;
             TreeNode.setIdByPath(child.path, child.id);
@@ -1235,13 +1262,13 @@ class CompositeTreeNode extends TreeNode {
             flatTree[i] = tempChildren[i].id;
         }
         if (this.children) {
-            // 重置节点分支
             this.shrinkBranch(this);
         }
         if (this.children) {
             for (let i = 0; i < this.children.length; i++) {
                 const child = this.children[i];
-                child.dispose();
+                // The Child maybe `undefined`.
+                child === null || child === void 0 ? void 0 : child.dispose();
             }
         }
         for (let i = 0; i < tempChildren.length; i++) {
@@ -1294,7 +1321,11 @@ class CompositeTreeNode extends TreeNode {
         }
     }
     // 当没有传入具体路径时，使用当前展开目录作为刷新路径
-    async refresh(tokenSource) {
+    async refresh(tokenSource, target) {
+        if (!CompositeTreeNode.isRoot(this)) {
+            // 刷新操作只能从根节点进行，便于对重复的刷新操作进行合并
+            return await this.root.refresh(tokenSource, this);
+        }
         const state = TreeNode.getGlobalTreeState(this.path);
         if (state.isLoadingPath || state.isExpanding) {
             return;
@@ -1320,14 +1351,55 @@ class CompositeTreeNode extends TreeNode {
                 token = state.refreshCancelToken.token;
             }
         }
-        await this.refreshThrottler.queue(async () => this.doRefresh(token));
+        this.toRefreshPathQueue.add((target || this).path);
+        await this.refreshThrottler.trigger(() => this.doRefresh(token));
         TreeNode.setGlobalTreeState(this.path, {
             isRefreshing: false,
         });
     }
     async doRefresh(token) {
-        const paths = this.getAllExpandedNodePath();
-        await this.refreshTreeNodeByPaths(paths, true, token, this);
+        const target = this.getRefreshNode() || this;
+        if (!CompositeTreeNode.is(target)) {
+            return;
+        }
+        const paths = target.getAllExpandedNodePath();
+        await target.refreshTreeNodeByPaths(paths, token, target);
+    }
+    getRefreshNode() {
+        let paths = Array.from(this.toRefreshPathQueue);
+        this.toRefreshPathQueue.clear();
+        if (!paths.length) {
+            return this.root;
+        }
+        // 根据路径层级深度进行排序
+        paths = paths.sort((a, b) => {
+            const depthA = Path.pathDepth(a);
+            const depthB = Path.pathDepth(b);
+            return depthA - depthB;
+        });
+        if (paths.length === 1 || Path.pathDepth(paths[0]) === 1) {
+            // 说明刷新队列中包含根节点，直接返回根节点进行刷新
+            return TreeNode.getTreeNodeByPath(paths[0]);
+        }
+        const sortedPaths = paths.map((p) => new Path(p));
+        let rootPath = sortedPaths[0];
+        for (let i = 1, len = sortedPaths.length; i < len; i++) {
+            if (rootPath.isEqualOrParent(sortedPaths[i])) {
+                continue;
+            }
+            else {
+                while (!rootPath.isRoot) {
+                    rootPath = rootPath.dir;
+                    if (!rootPath || rootPath.isEqualOrParent(sortedPaths[i])) {
+                        break;
+                    }
+                }
+            }
+        }
+        if (rootPath) {
+            return TreeNode.getTreeNodeByPath(rootPath.toString());
+        }
+        return this.root;
     }
     isItemVisibleAtRootSurface(node) {
         let parent = node;
@@ -1571,7 +1643,11 @@ class CompositeTreeNode extends TreeNode {
      * @memberof CompositeTreeNode
      */
     getTreeNodeAtIndex(index) {
-        const id = this._flattenedBranch[index];
+        var _a;
+        const id = (_a = this._flattenedBranch) === null || _a === void 0 ? void 0 : _a[index];
+        if (!id) {
+            return undefined;
+        }
         return TreeNode.getTreeNodeById(id);
     }
     /**
@@ -1594,4 +1670,5 @@ class CompositeTreeNode extends TreeNode {
     }
 }
 exports.CompositeTreeNode = CompositeTreeNode;
+CompositeTreeNode.REFRESH_DELAY = 200;
 //# sourceMappingURL=TreeNode.js.map