@ptsecurity/mosaic 14.10.2 → 14.10.4

package/fesm2020/ptsecurity-mosaic-tree.mjs

@@ -346,7 +346,7 @@ class McTreeNodeToggleBaseDirective extends McTreeNodeToggleMixinBase {
         this.treeNode = treeNode;
         this._recursive = false;
         this.tree.treeControl.filterValue
-            .pipe(map((value) => value?.length > 0))
+            .pipe(map((value) => !!value && value.length > 0))
             .subscribe((state) => this.disabled = state);
     }
     get recursive() {
@@ -929,61 +929,61 @@ class FlatTreeControl extends BaseTreeControl {
     hasValue(value) {
         return this.dataNodes.find((node) => this.compareValues(this.getValue(node), value));
     }
-    filterNodes(value) {
+    filterNodes(value = null) {
         this.saveExpansionState();
-        this.filterModel.clear();
-        this.expansionModel.clear();
-        const filteredNodes = this.dataNodes
-            .filter((node) => this.compareViewValues(this.getViewValue(node), value));
+        const filteredNodes = [];
         const filteredNodesWithTheirParents = new Set();
-        filteredNodes.forEach((filteredNode) => {
-            this.getParents(filteredNode, [])
-                .forEach((node) => {
+        for (const node of this.dataNodes) {
+            if (this.compareViewValues(this.getViewValue(node), value)) {
+                filteredNodes.push(node);
+            }
+        }
+        for (const filteredNode of filteredNodes) {
+            for (const node of this.getParents(filteredNode, [])) {
                 filteredNodesWithTheirParents.add(node);
-                this.expandDataNode(node);
-            });
+            }
             filteredNodesWithTheirParents.add(filteredNode);
-            this.expandDataNode(filteredNode);
             if (this.isExpandable(filteredNode)) {
                 const childNodeLevel = this.getLevel(filteredNode) + 1;
-                this.getDescendants(filteredNode)
-                    .filter((childNode) => this.getLevel(childNode) === childNodeLevel)
-                    .filter((childNode) => !this.isExpandable(childNode) || !this.hasFilteredDescendant(childNode, filteredNodes))
-                    .forEach((childNode) => {
-                    filteredNodesWithTheirParents.add(childNode);
-                    this.expandDataNode(childNode);
-                });
+                for (const childNode of this.getDescendants(filteredNode)) {
+                    if (this.getLevel(childNode) === childNodeLevel &&
+                        (!this.isExpandable(childNode) || !this.hasFilteredDescendant(childNode, filteredNodes))) {
+                        filteredNodesWithTheirParents.add(childNode);
+                    }
+                }
             }
-        });
+        }
+        this.filterModel.clear();
         this.filterModel.select(...Array.from(filteredNodesWithTheirParents));
+        // set current expansion state according to filtered tree
+        this.expansionModel.setSelection(...Array.from(filteredNodesWithTheirParents).filter((node) => this.isExpandable(node)));
         this.updateFilterValue(value);
         this.restoreExpansionState();
     }
     updateFilterValue(value) {
         Promise.resolve().then(() => this.filterValue.next(value));
     }
-    expandDataNode(dataNode) {
-        if (this.isExpandable(dataNode)) {
-            this.expansionModel.select(dataNode);
-        }
-    }
     saveExpansionState() {
-        if (this.filterValue.value === '') {
+        if (!this.filterValue.value) {
             this.expandedItemsBeforeFiltration = this.expansionModel.selected;
         }
     }
     restoreExpansionState() {
-        if (this.filterValue.value === '') {
-            this.expansionModel.clear();
-            this.expansionModel.select(...this.expandedItemsBeforeFiltration);
+        if (!this.filterValue.value) {
+            this.expansionModel.setSelection(...this.expandedItemsBeforeFiltration);
         }
     }
     hasFilteredDescendant(dataNode, filteredNodes) {
-        const filteredViewValues = filteredNodes
-            .map((node) => this.getViewValue(node));
-        return this.getDescendants(dataNode)
-            .filter((node) => filteredViewValues.includes(this.getViewValue(node)))
-            .length > 0;
+        const filteredViewValues = [];
+        for (const node of filteredNodes) {
+            filteredViewValues.push(this.getViewValue(node));
+        }
+        for (const node of this.getDescendants(dataNode)) {
+            if (filteredViewValues.includes(this.getViewValue(node))) {
+                return true;
+            }
+        }
+        return false;
     }
 }