@itwin/tree-widget-react 4.0.0-alpha.2 → 4.0.0-alpha.20

package/lib/esm/tree-widget-react/components/trees/common/internal/useTreeHooks/UseIdsCache.js

@@ -0,0 +1,46 @@
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
+import { useCallback, useEffect, useRef, useState } from "react";
+import { useIModelChangeListener } from "../UseIModelChangeListener.js";
+/** @internal */
+export function useIdsCache(props) {
+    const cacheRef = useRef(undefined);
+    const clearCacheRef = useRef(() => {
+        cacheRef.current?.[Symbol.dispose]?.();
+        cacheRef.current = undefined;
+    });
+    const { imodel, createCache, cacheSpecificProps } = props;
+    const createCacheGetterRef = useRef((currImodel, specificProps, componentId) => {
+        return () => {
+            if (cacheRef.current === undefined) {
+                cacheRef.current = createCache({ imodel: currImodel, specificProps, componentId });
+            }
+            return cacheRef.current;
+        };
+    });
+    const [getCache, setCacheGetter] = useState(() => createCacheGetterRef.current(imodel, cacheSpecificProps, props.componentId));
+    useEffect(() => {
+        // clear cache in case it was created before `useEffect` was run first time
+        clearCacheRef.current();
+        // make sure all cache users rerender
+        setCacheGetter(() => createCacheGetterRef.current(imodel, cacheSpecificProps, props.componentId));
+        return () => {
+            // eslint-disable-next-line react-hooks/exhaustive-deps
+            clearCacheRef.current();
+        };
+    }, [imodel, cacheSpecificProps, props.componentId]);
+    useIModelChangeListener({
+        imodel,
+        action: useCallback(() => {
+            clearCacheRef.current();
+            // make sure all cache users rerender
+            setCacheGetter(() => createCacheGetterRef.current(imodel, cacheSpecificProps, props.componentId));
+        }, [imodel, cacheSpecificProps, props.componentId]),
+    });
+    return {
+        getCache,
+    };
+}
+//# sourceMappingURL=UseIdsCache.js.map

package/lib/esm/tree-widget-react/components/trees/common/internal/useTreeHooks/UseIdsCache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UseIdsCache.js","sourceRoot":"","sources":["../../../../../../../../src/tree-widget-react/components/trees/common/internal/useTreeHooks/UseIdsCache.ts"],"names":[],"mappings":"AAAA;;;gGAGgG;AAEhG,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AACjE,OAAO,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAoBxE,gBAAgB;AAChB,MAAM,UAAU,WAAW,CACzB,KAAoD;IAEpD,MAAM,QAAQ,GAAG,MAAM,CAAqB,SAAS,CAAC,CAAC;IACvD,MAAM,aAAa,GAAG,MAAM,CAAC,GAAG,EAAE;QAChC,QAAQ,CAAC,OAAO,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,EAAE,CAAC;QACvC,QAAQ,CAAC,OAAO,GAAG,SAAS,CAAC;IAC/B,CAAC,CAAC,CAAC;IACH,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,kBAAkB,EAAE,GAAG,KAAK,CAAC;IAE1D,MAAM,oBAAoB,GAAG,MAAM,CAAC,CAAC,UAA4B,EAAE,aAAkC,EAAE,WAAuB,EAAE,EAAE;QAChI,OAAO,GAAG,EAAE;YACV,IAAI,QAAQ,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;gBACnC,QAAQ,CAAC,OAAO,GAAG,WAAW,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC,CAAC;YACrF,CAAC;YACD,OAAO,QAAQ,CAAC,OAAO,CAAC;QAC1B,CAAC,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,QAAQ,EAAE,cAAc,CAAC,GAAG,QAAQ,CAAe,GAAG,EAAE,CAAC,oBAAoB,CAAC,OAAO,CAAC,MAAM,EAAE,kBAAkB,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC;IAE7I,SAAS,CAAC,GAAG,EAAE;QACb,2EAA2E;QAC3E,aAAa,CAAC,OAAO,EAAE,CAAC;QAExB,qCAAqC;QACrC,cAAc,CAAC,GAAG,EAAE,CAAC,oBAAoB,CAAC,OAAO,CAAC,MAAM,EAAE,kBAAkB,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC;QAClG,OAAO,GAAG,EAAE;YACV,uDAAuD;YACvD,aAAa,CAAC,OAAO,EAAE,CAAC;QAC1B,CAAC,CAAC;IACJ,CAAC,EAAE,CAAC,MAAM,EAAE,kBAAkB,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC;IAEpD,uBAAuB,CAAC;QACtB,MAAM;QACN,MAAM,EAAE,WAAW,CAAC,GAAG,EAAE;YACvB,aAAa,CAAC,OAAO,EAAE,CAAC;YACxB,qCAAqC;YACrC,cAAc,CAAC,GAAG,EAAE,CAAC,oBAAoB,CAAC,OAAO,CAAC,MAAM,EAAE,kBAAkB,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC;QACpG,CAAC,EAAE,CAAC,MAAM,EAAE,kBAAkB,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;KACpD,CAAC,CAAC;IAEH,OAAO;QACL,QAAQ;KACT,CAAC;AACJ,CAAC","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n * See LICENSE.md in the project root for license terms and full copyright notice.\n *--------------------------------------------------------------------------------------------*/\n\nimport { useCallback, useEffect, useRef, useState } from \"react\";\nimport { useIModelChangeListener } from \"../UseIModelChangeListener.js\";\n\nimport type { GuidString } from \"@itwin/core-bentley\";\nimport type { IModelConnection } from \"@itwin/core-frontend\";\n\n/** @internal */\nexport interface CreateCacheProps<TCacheSpecificProps> {\n  imodel: IModelConnection;\n  specificProps: TCacheSpecificProps;\n  componentId: GuidString;\n}\n\n/** @internal */\nexport interface UseIdsCacheProps<TCache, TCacheSpecificProps> {\n  imodel: IModelConnection;\n  createCache: (props: CreateCacheProps<TCacheSpecificProps>) => TCache;\n  cacheSpecificProps: TCacheSpecificProps;\n  componentId: GuidString;\n}\n\n/** @internal */\nexport function useIdsCache<TCache extends Disposable, TCacheSpecificProps extends object>(\n  props: UseIdsCacheProps<TCache, TCacheSpecificProps>,\n): { getCache: () => TCache } {\n  const cacheRef = useRef<TCache | undefined>(undefined);\n  const clearCacheRef = useRef(() => {\n    cacheRef.current?.[Symbol.dispose]?.();\n    cacheRef.current = undefined;\n  });\n  const { imodel, createCache, cacheSpecificProps } = props;\n\n  const createCacheGetterRef = useRef((currImodel: IModelConnection, specificProps: TCacheSpecificProps, componentId: GuidString) => {\n    return () => {\n      if (cacheRef.current === undefined) {\n        cacheRef.current = createCache({ imodel: currImodel, specificProps, componentId });\n      }\n      return cacheRef.current;\n    };\n  });\n\n  const [getCache, setCacheGetter] = useState<() => TCache>(() => createCacheGetterRef.current(imodel, cacheSpecificProps, props.componentId));\n\n  useEffect(() => {\n    // clear cache in case it was created before `useEffect` was run first time\n    clearCacheRef.current();\n\n    // make sure all cache users rerender\n    setCacheGetter(() => createCacheGetterRef.current(imodel, cacheSpecificProps, props.componentId));\n    return () => {\n      // eslint-disable-next-line react-hooks/exhaustive-deps\n      clearCacheRef.current();\n    };\n  }, [imodel, cacheSpecificProps, props.componentId]);\n\n  useIModelChangeListener({\n    imodel,\n    action: useCallback(() => {\n      clearCacheRef.current();\n      // make sure all cache users rerender\n      setCacheGetter(() => createCacheGetterRef.current(imodel, cacheSpecificProps, props.componentId));\n    }, [imodel, cacheSpecificProps, props.componentId]),\n  });\n\n  return {\n    getCache,\n  };\n}\n"]}

package/lib/esm/tree-widget-react/components/trees/common/internal/visibility/BaseFilteredTree.d.ts

@@ -0,0 +1,91 @@
+import { HierarchyFilteringPath, HierarchyNode } from "@itwin/presentation-hierarchies";
+import type { Id64String } from "@itwin/core-bentley";
+import type { ClassGroupingNodeKey, InstancesNodeKey } from "@itwin/presentation-hierarchies";
+import type { InstanceKey } from "@itwin/presentation-shared";
+/** @internal */
+export type FilteredTreeNodeChildren<TFilteredTreeNode> = Map<Id64String, TFilteredTreeNode>;
+/**
+ * A generic interface for a filtered tree root node.
+ *
+ * It differs from `BaseFilteredTreeNode` in that it only contains children details and nothing else.
+ * @internal
+ */
+export interface FilteredTreeRootNode<TFilteredTreeNode extends BaseFilteredTreeNode<TFilteredTreeNode>> {
+    children: FilteredTreeNodeChildren<TFilteredTreeNode>;
+}
+/**
+ * A generic interface for a filtered tree node.
+ *
+ * It represents every node in a filtered tree structure.
+ * @internal
+ * */
+export interface BaseFilteredTreeNode<TFilteredTreeNode extends BaseFilteredTreeNode<TFilteredTreeNode>> {
+    type: string;
+    id: Id64String;
+    children?: FilteredTreeNodeChildren<TFilteredTreeNode>;
+    isFilterTarget: boolean;
+}
+/**
+ * Class that provides methods to handle filtered nodes in a tree structure.
+ *
+ * It provides two methods that can be shared across different filtered trees:
+ * - `processFilteredNodes` - processes filtered nodes and returns a function to get filter targets for a node.
+ * - `accept` - accepts a new node and adds it to the tree structure.
+ * @internal
+ */
+export declare abstract class FilteredNodesHandler<TProcessedFilteredNodes, TFilterTargets, TFilteredTreeNode extends BaseFilteredTreeNode<TFilteredTreeNode>> {
+    readonly root: FilteredTreeRootNode<TFilteredTreeNode>;
+    readonly filteredNodesArr: TFilteredTreeNode[];
+    /** Returns filtered tree node type based on its' className */
+    abstract getType(className: string): Promise<TFilteredTreeNode["type"]>;
+    /** Converts nodes to filter targets */
+    abstract convertNodesToFilterTargets(filteredNodes: TFilteredTreeNode[], processedFilteredNodes: TProcessedFilteredNodes): TFilterTargets | undefined;
+    /**
+     * Processes filtered nodes.
+     *
+     * Nodes are created using filtering paths, and some information is not present in the filtering paths.
+     * Because of this, some nodes may need to be processed to get additional information.
+     *
+     * E.g. Retrieving categoryId of elements can't be done using filtering paths.
+     */
+    abstract getProcessedFilteredNodes(): Promise<TProcessedFilteredNodes>;
+    /** Creates filtered nodes  */
+    abstract createFilteredTreeNode(props: {
+        type: TFilteredTreeNode["type"];
+        id: Id64String;
+        isFilterTarget: boolean;
+        parent: TFilteredTreeNode | FilteredTreeRootNode<TFilteredTreeNode>;
+    }): TFilteredTreeNode;
+    processFilteredNodes(): Promise<{
+        getNodeFilterTargets: (node: HierarchyNode & {
+            key: ClassGroupingNodeKey | InstancesNodeKey;
+        }) => TFilterTargets | undefined;
+    }>;
+    /** Takes a new node and adds it to the tree structure. */
+    accept(props: {
+        instanceKey: InstanceKey;
+        parentNode: TFilteredTreeNode | FilteredTreeRootNode<TFilteredTreeNode>;
+        isFilterTarget: boolean;
+    }): Promise<TFilteredTreeNode>;
+    /** Takes a specific node and gets all filter targets related to it. */
+    private getNodeFilterTargets;
+    /** Finds filtered nodes that match the given keys. */
+    private findMatchingFilteredNodes;
+}
+/** @internal */
+export interface FilteredTree<TFilterTargets> {
+    getFilterTargets: (node: HierarchyNode & {
+        key: ClassGroupingNodeKey | InstancesNodeKey;
+    }) => TFilterTargets | undefined;
+}
+/** @internal */
+export interface CreateFilteredTreeProps<TProcessedFilteredNodes, TFilterTargets, TFilteredTreeNode extends BaseFilteredTreeNode<TFilteredTreeNode>> {
+    filteredNodesHandler: FilteredNodesHandler<TProcessedFilteredNodes, TFilterTargets, TFilteredTreeNode>;
+    filteringPaths: HierarchyFilteringPath[];
+}
+/**
+ * Function iterates over filtering paths and creates uses `filteredNodesHandler` to create a filtered tree.
+ * @internal
+ */
+export declare function createFilteredTree<TProcessedFilteredNodes, TFilterTargets, TFilteredTreeNode extends BaseFilteredTreeNode<TFilteredTreeNode>>(props: CreateFilteredTreeProps<TProcessedFilteredNodes, TFilterTargets, TFilteredTreeNode>): Promise<FilteredTree<TFilterTargets>>;
+//# sourceMappingURL=BaseFilteredTree.d.ts.map

package/lib/esm/tree-widget-react/components/trees/common/internal/visibility/BaseFilteredTree.js

@@ -0,0 +1,112 @@
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
+import { Id64 } from "@itwin/core-bentley";
+import { HierarchyFilteringPath, HierarchyNode, HierarchyNodeIdentifier, HierarchyNodeKey } from "@itwin/presentation-hierarchies";
+/**
+ * Class that provides methods to handle filtered nodes in a tree structure.
+ *
+ * It provides two methods that can be shared across different filtered trees:
+ * - `processFilteredNodes` - processes filtered nodes and returns a function to get filter targets for a node.
+ * - `accept` - accepts a new node and adds it to the tree structure.
+ * @internal
+ */
+export class FilteredNodesHandler {
+    root = {
+        children: new Map(),
+    };
+    filteredNodesArr = new Array();
+    async processFilteredNodes() {
+        const processedFilteredNodes = await this.getProcessedFilteredNodes();
+        return {
+            getNodeFilterTargets: (node) => this.getNodeFilterTargets(node, processedFilteredNodes),
+        };
+    }
+    /** Takes a new node and adds it to the tree structure. */
+    async accept(props) {
+        const { instanceKey, parentNode, isFilterTarget } = props;
+        const type = await this.getType(instanceKey.className);
+        const newNode = this.createFilteredTreeNode({
+            type,
+            id: instanceKey.id,
+            isFilterTarget,
+            parent: parentNode,
+        });
+        (parentNode.children ??= new Map()).set(instanceKey.id, newNode);
+        this.filteredNodesArr.push(newNode);
+        return newNode;
+    }
+    /** Takes a specific node and gets all filter targets related to it. */
+    getNodeFilterTargets(node, processedFilteredNodes) {
+        let lookupParents = [this.root];
+        // find the filtered parent nodes of the `node`
+        for (const parentKey of node.parentKeys) {
+            if (!HierarchyNodeKey.isInstances(parentKey)) {
+                continue;
+            }
+            // 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 = this.findMatchingFilteredNodes(lookupParents, parentKey.instanceKeys.map((key) => key.id));
+            if (parentNodes.length === 0) {
+                return undefined;
+            }
+            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 = this.findMatchingFilteredNodes(lookupParents, ids);
+        if (filteredNodes.length === 0) {
+            return undefined;
+        }
+        return this.convertNodesToFilterTargets(filteredNodes, processedFilteredNodes);
+    }
+    /** Finds filtered nodes that match the given keys. */
+    findMatchingFilteredNodes(lookupParents, ids) {
+        return lookupParents.flatMap((lookup) => {
+            const childrenArray = Array();
+            for (const id of Id64.iterable(ids)) {
+                const node = lookup.children?.get(id);
+                if (node) {
+                    childrenArray.push(node);
+                }
+            }
+            return childrenArray;
+        });
+    }
+}
+/**
+ * Function iterates over filtering paths and creates uses `filteredNodesHandler` to create a filtered tree.
+ * @internal
+ */
+export async function createFilteredTree(props) {
+    const { filteringPaths, filteredNodesHandler } = props;
+    for (const filteringPath of filteringPaths) {
+        const normalizedPath = HierarchyFilteringPath.normalize(filteringPath).path;
+        let parentNode = filteredNodesHandler.root;
+        for (let i = 0; i < normalizedPath.length; ++i) {
+            if ("type" in parentNode && "isFilterTarget" in parentNode && parentNode.isFilterTarget) {
+                break;
+            }
+            const identifier = normalizedPath[i];
+            if (!HierarchyNodeIdentifier.isInstanceNodeIdentifier(identifier)) {
+                break;
+            }
+            const currentNode = parentNode.children?.get(identifier.id);
+            if (currentNode !== undefined) {
+                parentNode = currentNode;
+                continue;
+            }
+            parentNode = await filteredNodesHandler.accept({
+                instanceKey: identifier,
+                parentNode,
+                isFilterTarget: i === normalizedPath.length - 1,
+            });
+        }
+    }
+    const processedFilteredNodes = await filteredNodesHandler.processFilteredNodes();
+    return {
+        getFilterTargets: (node) => processedFilteredNodes.getNodeFilterTargets(node),
+    };
+}
+//# sourceMappingURL=BaseFilteredTree.js.map

package/lib/esm/tree-widget-react/components/trees/common/internal/visibility/BaseFilteredTree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseFilteredTree.js","sourceRoot":"","sources":["../../../../../../../../src/tree-widget-react/components/trees/common/internal/visibility/BaseFilteredTree.ts"],"names":[],"mappings":"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","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n * See LICENSE.md in the project root for license terms and full copyright notice.\n *--------------------------------------------------------------------------------------------*/\n\nimport { Id64 } from \"@itwin/core-bentley\";\nimport { HierarchyFilteringPath, HierarchyNode, HierarchyNodeIdentifier, HierarchyNodeKey } from \"@itwin/presentation-hierarchies\";\n\nimport type { Id64Arg, Id64String } from \"@itwin/core-bentley\";\nimport type { ClassGroupingNodeKey, InstancesNodeKey } from \"@itwin/presentation-hierarchies\";\nimport type { InstanceKey } from \"@itwin/presentation-shared\";\n\n/** @internal */\nexport type FilteredTreeNodeChildren<TFilteredTreeNode> = Map<Id64String, TFilteredTreeNode>;\n\n/**\n * A generic interface for a filtered tree root node.\n *\n * It differs from `BaseFilteredTreeNode` in that it only contains children details and nothing else.\n * @internal\n */\nexport interface FilteredTreeRootNode<TFilteredTreeNode extends BaseFilteredTreeNode<TFilteredTreeNode>> {\n  children: FilteredTreeNodeChildren<TFilteredTreeNode>;\n}\n\n/**\n * A generic interface for a filtered tree node.\n *\n * It represents every node in a filtered tree structure.\n * @internal\n * */\nexport interface BaseFilteredTreeNode<TFilteredTreeNode extends BaseFilteredTreeNode<TFilteredTreeNode>> {\n  type: string;\n  id: Id64String;\n  children?: FilteredTreeNodeChildren<TFilteredTreeNode>;\n  isFilterTarget: boolean;\n}\n\n/**\n * Class that provides methods to handle filtered nodes in a tree structure.\n *\n * It provides two methods that can be shared across different filtered trees:\n * - `processFilteredNodes` - processes filtered nodes and returns a function to get filter targets for a node.\n * - `accept` - accepts a new node and adds it to the tree structure.\n * @internal\n */\nexport abstract class FilteredNodesHandler<TProcessedFilteredNodes, TFilterTargets, TFilteredTreeNode extends BaseFilteredTreeNode<TFilteredTreeNode>> {\n  public readonly root: FilteredTreeRootNode<TFilteredTreeNode> = {\n    children: new Map(),\n  };\n  public readonly filteredNodesArr = new Array<TFilteredTreeNode>();\n\n  /** Returns filtered tree node type based on its' className */\n  public abstract getType(className: string): Promise<TFilteredTreeNode[\"type\"]>;\n  /** Converts nodes to filter targets */\n  public abstract convertNodesToFilterTargets(filteredNodes: TFilteredTreeNode[], processedFilteredNodes: TProcessedFilteredNodes): TFilterTargets | undefined;\n  /**\n   * Processes filtered nodes.\n   *\n   * Nodes are created using filtering paths, and some information is not present in the filtering paths.\n   * Because of this, some nodes may need to be processed to get additional information.\n   *\n   * E.g. Retrieving categoryId of elements can't be done using filtering paths.\n   */\n  public abstract getProcessedFilteredNodes(): Promise<TProcessedFilteredNodes>;\n  /** Creates filtered nodes  */\n  public abstract createFilteredTreeNode(props: {\n    type: TFilteredTreeNode[\"type\"];\n    id: Id64String;\n    isFilterTarget: boolean;\n    parent: TFilteredTreeNode | FilteredTreeRootNode<TFilteredTreeNode>;\n  }): TFilteredTreeNode;\n\n  public async processFilteredNodes(): Promise<{\n    getNodeFilterTargets: (node: HierarchyNode & { key: ClassGroupingNodeKey | InstancesNodeKey }) => TFilterTargets | undefined;\n  }> {\n    const processedFilteredNodes = await this.getProcessedFilteredNodes();\n    return {\n      getNodeFilterTargets: (node: HierarchyNode & { key: ClassGroupingNodeKey | InstancesNodeKey }) => this.getNodeFilterTargets(node, processedFilteredNodes),\n    };\n  }\n\n  /** Takes a new node and adds it to the tree structure. */\n  public async accept(props: {\n    instanceKey: InstanceKey;\n    parentNode: TFilteredTreeNode | FilteredTreeRootNode<TFilteredTreeNode>;\n    isFilterTarget: boolean;\n  }): Promise<TFilteredTreeNode> {\n    const { instanceKey, parentNode, isFilterTarget } = props;\n    const type = await this.getType(instanceKey.className);\n\n    const newNode = this.createFilteredTreeNode({\n      type,\n      id: instanceKey.id,\n      isFilterTarget,\n      parent: parentNode,\n    });\n    (parentNode.children ??= new Map()).set(instanceKey.id, newNode);\n    this.filteredNodesArr.push(newNode);\n    return newNode;\n  }\n\n  /** Takes a specific node and gets all filter targets related to it. */\n  private getNodeFilterTargets(\n    node: HierarchyNode & { key: ClassGroupingNodeKey | InstancesNodeKey },\n    processedFilteredNodes: TProcessedFilteredNodes,\n  ): TFilterTargets | undefined {\n    let lookupParents: Array<FilteredTreeRootNode<TFilteredTreeNode> | TFilteredTreeNode> = [this.root];\n\n    // find the filtered parent nodes of the `node`\n    for (const parentKey of node.parentKeys) {\n      if (!HierarchyNodeKey.isInstances(parentKey)) {\n        continue;\n      }\n\n      // tree node might be merged from multiple instances. As filtered tree stores only one instance per node, we need to find all matching nodes\n      // and use them when checking for matching node in one level deeper.\n      const parentNodes = this.findMatchingFilteredNodes(\n        lookupParents,\n        parentKey.instanceKeys.map((key) => key.id),\n      );\n      if (parentNodes.length === 0) {\n        return undefined;\n      }\n      lookupParents = parentNodes;\n    }\n\n    const ids = HierarchyNode.isInstancesNode(node) ? node.key.instanceKeys.map(({ id }) => id) : node.groupedInstanceKeys.map(({ id }) => id);\n    // find filtered nodes that match the `node`\n    const filteredNodes = this.findMatchingFilteredNodes(lookupParents, ids);\n    if (filteredNodes.length === 0) {\n      return undefined;\n    }\n\n    return this.convertNodesToFilterTargets(filteredNodes, processedFilteredNodes);\n  }\n\n  /** Finds filtered nodes that match the given keys. */\n  private findMatchingFilteredNodes(lookupParents: Array<FilteredTreeRootNode<TFilteredTreeNode> | TFilteredTreeNode>, ids: Id64Arg) {\n    return lookupParents.flatMap((lookup) => {\n      const childrenArray = Array<TFilteredTreeNode>();\n      for (const id of Id64.iterable(ids)) {\n        const node = lookup.children?.get(id);\n        if (node) {\n          childrenArray.push(node);\n        }\n      }\n      return childrenArray;\n    });\n  }\n}\n\n/** @internal */\nexport interface FilteredTree<TFilterTargets> {\n  getFilterTargets: (node: HierarchyNode & { key: ClassGroupingNodeKey | InstancesNodeKey }) => TFilterTargets | undefined;\n}\n\n/** @internal */\nexport interface CreateFilteredTreeProps<TProcessedFilteredNodes, TFilterTargets, TFilteredTreeNode extends BaseFilteredTreeNode<TFilteredTreeNode>> {\n  filteredNodesHandler: FilteredNodesHandler<TProcessedFilteredNodes, TFilterTargets, TFilteredTreeNode>;\n  filteringPaths: HierarchyFilteringPath[];\n}\n\n/**\n * Function iterates over filtering paths and creates uses `filteredNodesHandler` to create a filtered tree.\n * @internal\n */\nexport async function createFilteredTree<TProcessedFilteredNodes, TFilterTargets, TFilteredTreeNode extends BaseFilteredTreeNode<TFilteredTreeNode>>(\n  props: CreateFilteredTreeProps<TProcessedFilteredNodes, TFilterTargets, TFilteredTreeNode>,\n): Promise<FilteredTree<TFilterTargets>> {\n  const { filteringPaths, filteredNodesHandler } = props;\n\n  for (const filteringPath of filteringPaths) {\n    const normalizedPath = HierarchyFilteringPath.normalize(filteringPath).path;\n\n    let parentNode: FilteredTreeRootNode<TFilteredTreeNode> | TFilteredTreeNode = filteredNodesHandler.root;\n    for (let i = 0; i < normalizedPath.length; ++i) {\n      if (\"type\" in parentNode && \"isFilterTarget\" in parentNode && parentNode.isFilterTarget) {\n        break;\n      }\n\n      const identifier = normalizedPath[i];\n\n      if (!HierarchyNodeIdentifier.isInstanceNodeIdentifier(identifier)) {\n        break;\n      }\n\n      const currentNode: TFilteredTreeNode | undefined = parentNode.children?.get(identifier.id);\n      if (currentNode !== undefined) {\n        parentNode = currentNode;\n        continue;\n      }\n      parentNode = await filteredNodesHandler.accept({\n        instanceKey: identifier,\n        parentNode,\n        isFilterTarget: i === normalizedPath.length - 1,\n      });\n    }\n  }\n  const processedFilteredNodes = await filteredNodesHandler.processFilteredNodes();\n  return {\n    getFilterTargets: (node: HierarchyNode & { key: ClassGroupingNodeKey | InstancesNodeKey }) => processedFilteredNodes.getNodeFilterTargets(node),\n  };\n}\n"]}

package/lib/esm/tree-widget-react/components/trees/common/internal/visibility/BaseVisibilityHelper.d.ts

@@ -0,0 +1,236 @@
+import type { Observable } from "rxjs";
+import type { Id64Arg, Id64Set, Id64String } from "@itwin/core-bentley";
+import type { HierarchyNode } from "@itwin/presentation-hierarchies";
+import type { TreeWidgetViewport } from "../../TreeWidgetViewport.js";
+import type { HierarchyVisibilityHandlerOverridableMethod, HierarchyVisibilityOverrideHandler, VisibilityStatus } from "../../UseHierarchyVisibility.js";
+import type { AlwaysAndNeverDrawnElementInfo } from "../AlwaysAndNeverDrawnElementInfo.js";
+/**
+ * Functionality of tree visibility handler methods that can be overridden.
+ * Each callback is provided original implementation and reference to a `HierarchyVisibilityHandler`.
+ * @beta
+ */
+export interface BaseTreeVisibilityHandlerOverrides {
+    getModelsVisibilityStatus?: HierarchyVisibilityHandlerOverridableMethod<(props: {
+        modelIds: Id64Arg;
+    }) => Promise<VisibilityStatus>>;
+    getCategoriesVisibilityStatus?: HierarchyVisibilityHandlerOverridableMethod<(props: {
+        categoryIds: Id64Arg;
+        modelId?: Id64String;
+    }) => Promise<VisibilityStatus>>;
+    getElementsVisibilityStatus?: HierarchyVisibilityHandlerOverridableMethod<(props: {
+        elementIds: Id64Arg;
+        modelId: Id64String;
+        categoryId: Id64String;
+    }) => Promise<VisibilityStatus>>;
+    changeModelsVisibilityStatus?: HierarchyVisibilityHandlerOverridableMethod<(props: {
+        modelIds: Id64Arg;
+        on: boolean;
+    }) => Promise<void>>;
+    changeCategoriesVisibilityStatus?: HierarchyVisibilityHandlerOverridableMethod<(props: {
+        categoryIds: Id64Arg;
+        modelId?: Id64String;
+        on: boolean;
+    }) => Promise<void>>;
+    changeElementsVisibilityStatus?: HierarchyVisibilityHandlerOverridableMethod<(props: {
+        elementIds: Id64Arg;
+        modelId: Id64String;
+        categoryId: Id64String;
+        on: boolean;
+    }) => Promise<void>>;
+}
+/** @internal */
+export interface BaseIdsCache {
+    hasSubModel: (elementId: Id64String) => Observable<boolean>;
+    getElementsCount: (props: {
+        modelId: Id64String;
+        categoryId: Id64String;
+    }) => Observable<number>;
+    getSubCategories: (props: {
+        categoryIds: Id64Arg;
+    }) => Observable<{
+        id: Id64String;
+        subCategories: Id64Arg | undefined;
+    }>;
+    getModels: (props: {
+        categoryIds: Id64Arg;
+    }) => Observable<{
+        id: Id64String;
+        models: Id64Arg | undefined;
+    }>;
+    getCategories: (props: {
+        modelIds: Id64Arg;
+    }) => Observable<{
+        id: Id64String;
+        drawingCategories?: Id64Arg;
+        spatialCategories?: Id64Arg;
+    }>;
+    getSubModels: (props: {
+        modelIds: Id64Arg;
+        categoryId?: Id64String;
+    } | {
+        categoryIds: Id64Arg;
+        modelId: Id64String | undefined;
+    }) => Observable<{
+        id: Id64String;
+        subModels: Id64Arg | undefined;
+    }>;
+    getAllCategories: () => Observable<{
+        drawingCategories?: Id64Set;
+        spatialCategories?: Id64Set;
+    }>;
+}
+/**
+ * Interface for a tree visibility handler that provides methods to get and change visibility status of hierarchy nodes.
+ * @internal
+ */
+export interface TreeSpecificVisibilityHandler<TFilterTargets> {
+    getVisibilityStatus: (node: HierarchyNode) => Observable<VisibilityStatus>;
+    changeVisibilityStatus: (node: HierarchyNode, on: boolean) => Observable<void>;
+    getFilterTargetsVisibilityStatus: (targets: TFilterTargets) => Observable<VisibilityStatus>;
+    changeFilterTargetsVisibilityStatus: (targets: TFilterTargets, on: boolean) => Observable<void>;
+}
+/** @internal */
+export interface BaseVisibilityHelperProps {
+    viewport: TreeWidgetViewport;
+    alwaysAndNeverDrawnElementInfo: AlwaysAndNeverDrawnElementInfo;
+    overrideHandler?: HierarchyVisibilityOverrideHandler;
+    overrides?: BaseTreeVisibilityHandlerOverrides;
+    baseIdsCache: BaseIdsCache;
+}
+/**
+ * Base class for visibility status getters and modifiers.
+ *
+ * It provides methods that help retrieve and change visibility status of models, categories, elements.
+ * @internal
+ */
+export declare class BaseVisibilityHelper implements Disposable {
+    #private;
+    constructor(props: BaseVisibilityHelperProps);
+    [Symbol.dispose](): void;
+    /**
+     * Removes "always drawn exclusive" mode from the viewport without affecting any visibilities.
+     *
+     * This is achieved by:
+     * - Resets `alwaysDrawn` exclusive flag to `false`;
+     * - Turns off all categories;
+     * - Clears always drawn list;
+     * - Removes all per-model category overrides. */
+    removeAlwaysDrawnExclusive(): Observable<void>;
+    /**
+     * Returns visibility status of models.
+     *
+     * Determines visibility status by checking:
+     * - Models visibility in the viewport;
+     * - Models' subModels visibility (if elements' modelId is in the provided modelIds, and element is itself a model, then it is considered a subModel);
+     * - Categories visibility in the viewport (if elements' modelId is in the provided modelIds, then its' category gets checked).
+     */
+    getModelsVisibilityStatus(props: {
+        modelIds: Id64Arg;
+        type: "GeometricModel3d" | "GeometricModel2d";
+    }): Observable<VisibilityStatus>;
+    /**
+     * Gets visibility status of a model's categories, assuming model is visible.
+     *
+     * Determines visibility status by checking:
+     * - Elements in the viewports' always/never drawn lists;
+     * - Default categories visibility status in the viewport;
+     * - SubModels that are related to the modelId and categoryIds
+     */
+    private getVisibleModelCategoriesVisibilityStatus;
+    /** Gets visibility status of sub-categories, assuming category is visible. */
+    private getVisibleCategorySubCategoriesVisibilityStatus;
+    /**
+     * Gets visibility status of sub-categories.
+     *
+     * Determines visibility status by checking:
+     * - Models that contain the category visibility;
+     * - Per model category visibility overrides;
+     * - Category selector visibility in the viewport.
+     * - Sub-categories visibility in the viewport.
+     */
+    getSubCategoriesVisibilityStatus(props: {
+        subCategoryIds: Id64Arg;
+        categoryId: Id64String;
+        modelId?: Id64String;
+    }): Observable<VisibilityStatus>;
+    /**
+     * Gets visibility status of categories.
+     *
+     * Determines visibility status by checking:
+     * - Categories visibility;
+     * - Visibility of models that are related to the categories;
+     * - sub-categories visibility.
+     */
+    getCategoriesVisibilityStatus(props: {
+        categoryIds: Id64Arg;
+        modelId: Id64String | undefined;
+        type: "DrawingCategory" | "SpatialCategory";
+    }): Observable<VisibilityStatus>;
+    /**
+     * Gets visibility status of categories, assuming model is visible.
+     *
+     * Determines visibility status by checking:
+     * - Per model category visibility overrides;
+     * - Category selector visibility in the viewport.
+     */
+    getVisibleModelCategoriesDirectVisibilityStatus({ modelId, categoryIds }: {
+        categoryIds: Id64Arg;
+        modelId: Id64String;
+    }): VisibilityStatus;
+    /**
+     * Gets visibility status of elements.
+     *
+     * Determines visibility status by checking:
+     * - Elements in the viewports' always/never drawn lists;
+     * - Related categories and models visibility status;
+     * - Sub-models that are related to the specified elements.
+     */
+    getElementsVisibilityStatus(props: {
+        elementIds: Id64Arg;
+        modelId: Id64String;
+        categoryId: Id64String;
+        type: "GeometricElement3d" | "GeometricElement2d";
+    }): Observable<VisibilityStatus>;
+    /** Gets visibility status of elements based on viewport's always/never drawn elements and related categories and models. */
+    private getVisibilityFromAlwaysAndNeverDrawnElements;
+    /**
+     * Changes visibility status of models.
+     *
+     * Also, changes visibility status of related categories and sub-models.
+     */
+    changeModelsVisibilityStatus(props: {
+        modelIds: Id64Arg;
+        on: boolean;
+    }): Observable<void>;
+    /** Turns model on and turns off elements with categories related to that model. */
+    private showModelWithoutAnyCategoriesOrElements;
+    /** Adds per-model category overrides based on category visibility in category selector. */
+    private changeCategoryStateInViewportAccordingToModelVisibility;
+    /**
+     * Changes categories visibility status.
+     *
+     * Also:
+     * - Turns on models in cases where categories need to be turned on and models are not already on.
+     * - Removed related elements from always/never drawn elements.
+     * - changes visibility of sub-models that are related to the specified categories.
+     */
+    changeCategoriesVisibilityStatus(props: {
+        modelId: Id64String | undefined;
+        categoryIds: Id64Arg;
+        on: boolean;
+    }): Observable<void>;
+    /**
+     * Changes visibility status of elements by adding them to the viewport's always/never drawn elements.
+     *
+     * Also, changes visibility status of specified elements that are models.
+     */
+    changeElementsVisibilityStatus(props: {
+        elementIds: Id64Arg;
+        modelId: Id64String;
+        categoryId: Id64String;
+        on: boolean;
+    }): Observable<void>;
+    /** Queues visibility change for elements. */
+    private queueElementsVisibilityChange;
+}
+//# sourceMappingURL=BaseVisibilityHelper.d.ts.map