[Tree widget]: Prerequisite for children visibility changes (#1472)

* Prerequisite for children visibility changes

* Cleanup

* Prettier

* Change getVisibilityChangeTargets to accept node

* Fix isFiltered to hasDirectNonFilteredTargets

* Prettier

* Apply suggestion

* Add back getElementDisplayStatus

* Address comments

* Change filtered tree to accept correct nodes

* Fix lint issues

Author: JonasDov

change/@itwin-tree-widget-react-22b44617-23db-4ba6-abc7-1fef8aea7190.json

@@ -0,0 +1,7 @@
+{
+  "type": "none",
+  "comment": "",
+  "packageName": "@itwin/tree-widget-react",
+  "email": "[email protected]",
+  "dependentChangeType": "none"
+}

packages/itwin/tree-widget/src/tree-widget-react/components/trees/models-tree/ModelsTreeDefinition.ts

@@ -188,13 +188,36 @@ export class ModelsTreeDefinition implements HierarchyDefinition {
 
   public async postProcessNode(node: ProcessedHierarchyNode): Promise<ProcessedHierarchyNode> {
     if (ProcessedHierarchyNode.isGroupingNode(node)) {
+      let hasDirectNonFilteredTargets = false;
+      let hasFilterTargetAncestor = false;
+      for (const child of node.children) {
+        if (child.filtering) {
+          if (child.filtering.hasFilterTargetAncestor) {
+            hasFilterTargetAncestor = true;
+            break;
+          }
+          if (!child.filtering.isFilterTarget) {
+            hasDirectNonFilteredTargets = true;
+            break;
+          }
+        }
+      }
       return {
         ...node,
+        ...(hasFilterTargetAncestor
+          ? {
+              filtering: {
+                ...(node.filtering ?? {}),
+                hasFilterTargetAncestor,
+              },
+            }
+          : {}),
         label: this._hierarchyConfig.elementClassGrouping === "enableWithCounts" ? `${node.label} (${node.children.length})` : node.label,
         extendedData: {
           ...node.extendedData,
           // add `modelId` and `categoryId` from the first grouped element
           ...node.children[0].extendedData,
+          ...(hasDirectNonFilteredTargets ? { hasDirectNonFilteredTargets } : {}),
           // `imageId` is assigned to instance nodes at query time, but grouping ones need to
           // be handled during post-processing
           imageId: "icon-ec-class",

packages/itwin/tree-widget/src/tree-widget-react/components/trees/models-tree/internal/FilteredTree.ts

@@ -3,12 +3,12 @@
  * See LICENSE.md in the project root for license terms and full copyright notice.
  *--------------------------------------------------------------------------------------------*/
 
-import { assert } from "@itwin/core-bentley";
-import { HierarchyFilteringPath, HierarchyNodeIdentifier, HierarchyNodeKey } from "@itwin/presentation-hierarchies";
+import { assert, Id64 } from "@itwin/core-bentley";
+import { HierarchyFilteringPath, HierarchyNode, HierarchyNodeIdentifier, HierarchyNodeKey } from "@itwin/presentation-hierarchies";
 
-import type { Id64String } from "@itwin/core-bentley";
-import type { HierarchyNode } from "@itwin/presentation-hierarchies";
-import type { ECClassHierarchyInspector, InstanceKey } from "@itwin/presentation-shared";
+import type { Id64Arg, Id64String } from "@itwin/core-bentley";
+import type { ClassGroupingNodeKey, InstancesNodeKey } from "@itwin/presentation-hierarchies";
+import type { ECClassHierarchyInspector } from "@itwin/presentation-shared";
 
 interface FilteredTreeRootNode {
   children: Map<Id64String, FilteredTreeNode>;
@@ -37,8 +37,9 @@ interface ElementFilteredTreeNode extends BaseFilteredTreeNode {
 
 type FilteredTreeNode = GenericFilteredTreeNode | CategoryFilteredTreeNode | ElementFilteredTreeNode;
 
+/** @internal */
 export interface FilteredTree {
-  getVisibilityChangeTargets(node: HierarchyNode): VisibilityChangeTargets;
+  getVisibilityChangeTargets(node: HierarchyNode & { key: ClassGroupingNodeKey | InstancesNodeKey }): VisibilityChangeTargets;
 }
 
 export const SUBJECT_CLASS_NAME = "BisCore.Subject" as const;
@@ -52,18 +53,21 @@ function createCategoryKey(modelId: string, categoryId: string): CategoryKey {
   return `${modelId}-${categoryId}`;
 }
 
+/** @internal */
 export function parseCategoryKey(key: CategoryKey) {
   const [modelId, categoryId] = key.split("-");
   return { modelId, categoryId };
 }
 
-interface VisibilityChangeTargets {
+/** @internal */
+export interface VisibilityChangeTargets {
   subjects?: Set<Id64String>;
   models?: Set<Id64String>;
   categories?: Set<CategoryKey>;
-  elements?: Map<CategoryKey, Set<Id64String>>;
+  elements?: Map<CategoryKey, Map<Id64String, { isFilterTarget: boolean }>>;
 }
 
+/** @internal */
 export async function createFilteredTree(imodelAccess: ECClassHierarchyInspector, filteringPaths: HierarchyFilteringPath[]): Promise<FilteredTree> {
   const root: FilteredTreeRootNode = {
     children: new Map(),
@@ -102,19 +106,14 @@ export async function createFilteredTree(imodelAccess: ECClassHierarchyInspector
   }
 
   return {
-    getVisibilityChangeTargets: (node: HierarchyNode) => getVisibilityChangeTargets(root, node),
+    getVisibilityChangeTargets: (node) => getVisibilityChangeTargets(root, node),
   };
 }
 
-function getVisibilityChangeTargets(root: FilteredTreeRootNode, node: HierarchyNode) {
-  let lookupParents: Array<{ children?: Map<Id64String, FilteredTreeNode> }> = [root];
+function getVisibilityChangeTargets(root: FilteredTreeRootNode, node: HierarchyNode & { key: ClassGroupingNodeKey | InstancesNodeKey }) {
+  let lookupParents: Array<FilteredTreeRootNode | FilteredTreeNode> = [root];
   const changeTargets: VisibilityChangeTargets = {};
 
-  const nodeKey = node.key;
-  if (!HierarchyNodeKey.isInstances(nodeKey)) {
-    return changeTargets;
-  }
-
   // find the filtered parent nodes of the `node`
   for (const parentKey of node.parentKeys) {
     if (!HierarchyNodeKey.isInstances(parentKey)) {
@@ -123,15 +122,18 @@ function getVisibilityChangeTargets(root: FilteredTreeRootNode, node: HierarchyN
 
     // tree node might be merged from multiple instances. As filtered tree stores only one instance per node, we need to find all matching nodes
     // and use them when checking for matching node in one level deeper.
-    const parentNodes = findMatchingFilteredNodes(lookupParents, parentKey.instanceKeys);
+    const parentNodes = findMatchingFilteredNodes(
+      lookupParents,
+      parentKey.instanceKeys.map((key) => key.id),
+    );
     if (parentNodes.length === 0) {
       return changeTargets;
     }
     lookupParents = parentNodes;
   }
-
+  const ids = HierarchyNode.isInstancesNode(node) ? node.key.instanceKeys.map(({ id }) => id) : node.groupedInstanceKeys.map(({ id }) => id);
   // find filtered nodes that match the `node`
-  const filteredNodes = findMatchingFilteredNodes(lookupParents, nodeKey.instanceKeys);
+  const filteredNodes = findMatchingFilteredNodes(lookupParents, ids);
   if (filteredNodes.length === 0) {
     return changeTargets;
   }
@@ -140,10 +142,17 @@ function getVisibilityChangeTargets(root: FilteredTreeRootNode, node: HierarchyN
   return changeTargets;
 }
 
-function findMatchingFilteredNodes(lookupParents: Array<{ children?: Map<Id64String, FilteredTreeNode> }>, keys: InstanceKey[]) {
-  return lookupParents
-    .flatMap((lookup) => keys.map((key) => lookup.children?.get(key.id)))
-    .filter((lookupNode): lookupNode is FilteredTreeNode => lookupNode !== undefined);
+function findMatchingFilteredNodes(lookupParents: Array<FilteredTreeRootNode | FilteredTreeNode>, ids: Id64Arg): Array<FilteredTreeNode> {
+  return lookupParents.flatMap((lookup) => {
+    const childrenArray = Array<FilteredTreeNode>();
+    for (const id of Id64.iterable(ids)) {
+      const node = lookup.children?.get(id);
+      if (node) {
+        childrenArray.push(node);
+      }
+    }
+    return childrenArray;
+  });
 }
 
 function collectVisibilityChangeTargets(changeTargets: VisibilityChangeTargets, node: FilteredTreeNode) {
@@ -181,11 +190,10 @@ function addTarget(filterTargets: VisibilityChangeTargets, node: FilteredTreeNod
       const categoryKey = createCategoryKey(node.modelId, node.categoryId);
       const elements = (filterTargets.elements ??= new Map()).get(categoryKey);
       if (elements) {
-        elements.add(node.id);
-        return;
+        elements.set(node.id, { isFilterTarget: node.isFilterTarget });
+      } else {
+        filterTargets.elements.set(categoryKey, new Map([[node.id, { isFilterTarget: node.isFilterTarget }]]));
       }
-      filterTargets.elements.set(categoryKey, new Set([node.id]));
-      return;
   }
 }