@itwin/presentation-hierarchies 2.0.0-alpha.1 → 2.0.0-alpha.11

package/lib/esm/hierarchies/imodel/IModelHierarchyProvider.js

@@ -3,12 +3,13 @@
  * See LICENSE.md in the project root for license terms and full copyright notice.
  *--------------------------------------------------------------------------------------------*/
 import "../internal/DisposePolyfill.js";
-import { catchError, concat, defaultIfEmpty, EMPTY, filter, finalize, from, identity, map, merge, mergeAll, mergeMap, of, Subject, take, takeUntil, tap, } from "rxjs";
+import { catchError, concat, defaultIfEmpty, defer, EMPTY, filter, finalize, from, fromEventPattern, identity, map, merge, mergeAll, mergeMap, of, reduce, Subject, take, takeUntil, tap, } from "rxjs";
 import { assert, BeEvent, Guid, StopWatch } from "@itwin/core-bentley";
-import { createDefaultValueFormatter, formatConcatenatedValue, normalizeFullClassName, } from "@itwin/presentation-shared";
+import { createDefaultValueFormatter, formatConcatenatedValue, InstanceKey, normalizeFullClassName } from "@itwin/presentation-shared";
 import { RowsLimitExceededError } from "../HierarchyErrors.js";
 import { HierarchyNode } from "../HierarchyNode.js";
 import { HierarchyNodeKey } from "../HierarchyNodeKey.js";
+import { HierarchySearchPath } from "../HierarchySearch.js";
 import { LOGGING_NAMESPACE as BASE_LOGGING_NAMESPACE, LOGGING_NAMESPACE_INTERNAL as BASE_LOGGING_NAMESPACE_INTERNAL, LOGGING_NAMESPACE_PERFORMANCE as BASE_LOGGING_NAMESPACE_PERFORMANCE, createNodeIdentifierForLogging, hasChildren, } from "../internal/Common.js";
 import { eachValueFrom } from "../internal/EachValueFrom.js";
 import { doLog, log } from "../internal/LoggingUtils.js";
@@ -18,7 +19,6 @@ import { shareReplayWithErrors } from "../internal/operators/ShareReplayWithErro
 import { sortNodesByLabelOperator } from "../internal/operators/Sorting.js";
 import { getRxjsHierarchyDefinition } from "../internal/RxjsHierarchyDefinition.js";
 import { SubscriptionScheduler } from "../internal/SubscriptionScheduler.js";
-import { FilteringHierarchyDefinition } from "./FilteringHierarchyDefinition.js";
 import { HierarchyCache } from "./HierarchyCache.js";
 import { HierarchyNodesDefinition } from "./IModelHierarchyDefinition.js";
 import { NodeSelectClauseColumnNames } from "./NodeSelectQueryFactory.js";
@@ -26,6 +26,7 @@ import { createDetermineChildrenOperator } from "./operators/DetermineChildren.j
 import { createGroupingOperator } from "./operators/Grouping.js";
 import { createHideIfNoChildrenOperator } from "./operators/HideIfNoChildren.js";
 import { createHideNodesInHierarchyOperator } from "./operators/HideNodesInHierarchy.js";
+import { SearchHierarchyDefinition } from "./SearchHierarchyDefinition.js";
 import { readNodes } from "./TreeNodesReader.js";
 const LOGGING_NAMESPACE = `${BASE_LOGGING_NAMESPACE}.IModelHierarchyProvider`;
 const LOGGING_NAMESPACE_INTERNAL = `${BASE_LOGGING_NAMESPACE_INTERNAL}.IModelHierarchyProvider`;
@@ -33,33 +34,57 @@ const LOGGING_NAMESPACE_PERFORMANCE = `${BASE_LOGGING_NAMESPACE_PERFORMANCE}.IMo
 const DEFAULT_QUERY_CONCURRENCY = 10;
 const DEFAULT_QUERY_CACHE_SIZE = 1;
 /**
- * Creates an instance of `HierarchyProvider` that creates a hierarchy based on given iModel and
+ * Creates an instance of `HierarchyProvider` that creates a hierarchy based on given the iModel and
  * a hierarchy definition, which defines each hierarchy level through ECSQL queries.
  *
  * @public
  */
 export function createIModelHierarchyProvider(props) {
+    const { imodelAccess, imodelChanged, ...restProps } = props;
+    return createMergedIModelHierarchyProvider({ ...restProps, imodels: [{ imodelAccess, imodelChanged }] });
+}
+/**
+ * Creates an instance of `HierarchyProvider` that creates a hierarchy based on multiple version of **the same** iModel
+ * and a hierarchy definition, which defines each hierarchy level through ECSQL queries.
+ *
+ * **Warning:** This is an experimental API that **should not be used in production**.
+ *
+ * @alpha
+ */
+export function createMergedIModelHierarchyProvider(props) {
     return new IModelHierarchyProviderImpl(props);
 }
 class IModelHierarchyProviderImpl {
-    _imodelAccess;
+    _imodels;
     _hierarchyChanged;
     _valuesFormatter;
     _sourceHierarchyDefinition;
     _activeHierarchyDefinition;
     _localizedStrings;
-    _queryScheduler;
+    _queryConcurrency;
+    _querySchedulers;
     _nodesCache;
     _unsubscribe;
     _dispose = new Subject();
+    #componentId;
+    #componentName;
+    #sourceName;
     constructor(props) {
-        this._imodelAccess = props.imodelAccess;
+        if (props.imodels.length === 0) {
+            throw new Error(`Creating an iModel hierarchy provider requires at least one iModel.`);
+        }
+        this.#componentId = Guid.createValue();
+        this.#componentName = "IModelHierarchyProviderImpl";
+        /* c8 ignore next */
+        this.#sourceName = props.sourceName ?? `${this.#componentName}:${this.#componentId}`;
+        this._imodels = props.imodels;
         this._hierarchyChanged = new BeEvent();
         this._activeHierarchyDefinition = this._sourceHierarchyDefinition = getRxjsHierarchyDefinition(props.hierarchyDefinition);
-        this._valuesFormatter = props?.formatter ?? createDefaultValueFormatter();
-        this._localizedStrings = { other: "Other", unspecified: "Not specified", ...props?.localizedStrings };
-        this._queryScheduler = new SubscriptionScheduler(props.queryConcurrency ?? DEFAULT_QUERY_CONCURRENCY);
-        this.setHierarchyFilter(props.filtering);
+        this._valuesFormatter = props.formatter ?? createDefaultValueFormatter();
+        this._localizedStrings = { other: "Other", unspecified: "Not specified", ...props.localizedStrings };
+        this._queryConcurrency = props.queryConcurrency ?? DEFAULT_QUERY_CONCURRENCY;
+        this._querySchedulers = new Map();
+        this.setHierarchySearch(props.search);
         const queryCacheSize = props.queryCacheSize ?? DEFAULT_QUERY_CACHE_SIZE;
         if (queryCacheSize !== 0) {
             this._nodesCache = new HierarchyCache({
@@ -68,11 +93,18 @@ class IModelHierarchyProviderImpl {
                 variationsCount: 1,
             });
         }
-        this._unsubscribe = props.imodelChanged?.addListener(() => {
-            this.invalidateHierarchyCache("Data source changed");
+        const imodelChangeSubscription = from(this._imodels)
+            .pipe(mergeMap(({ imodelAccess, imodelChanged }) => imodelChanged
+            ? fromEventPattern((handler) => imodelChanged.addListener(handler), (handler) => imodelChanged.removeListener(handler), () => imodelAccess)
+            : EMPTY))
+            .subscribe(({ imodelKey }) => {
+            this.invalidateHierarchyCache(`Data source changed: "${imodelKey}"`);
             this._dispose.next();
-            this._hierarchyChanged.raiseEvent();
+            this._hierarchyChanged.raiseEvent({});
         });
+        this._unsubscribe = () => {
+            imodelChangeSubscription.unsubscribe();
+        };
     }
     [Symbol.dispose]() {
         this._dispose.next();
@@ -85,6 +117,17 @@ class IModelHierarchyProviderImpl {
     get hierarchyChanged() {
         return this._hierarchyChanged;
     }
+    getQueryScheduler(imodelKey) {
+        let scheduler = this._querySchedulers.get(imodelKey);
+        if (!scheduler) {
+            scheduler = new SubscriptionScheduler(this._queryConcurrency);
+            this._querySchedulers.set(imodelKey, scheduler);
+        }
+        return scheduler;
+    }
+    getPrimaryIModelAccess() {
+        return this._imodels[this._imodels.length - 1].imodelAccess;
+    }
     invalidateHierarchyCache(reason) {
         doLog({
             category: `${LOGGING_NAMESPACE}.Events`,
@@ -100,23 +143,24 @@ class IModelHierarchyProviderImpl {
         this._valuesFormatter = formatter ?? createDefaultValueFormatter();
         this._hierarchyChanged.raiseEvent({ formatterChange: { newFormatter: this._valuesFormatter } });
     }
-    setHierarchyFilter(props) {
+    setHierarchySearch(props) {
         if (!props) {
             if (this._sourceHierarchyDefinition !== this._activeHierarchyDefinition) {
                 this._activeHierarchyDefinition = this._sourceHierarchyDefinition;
-                this.invalidateHierarchyCache("Hierarchy filter reset");
+                this.invalidateHierarchyCache("Hierarchy search reset");
             }
-            this._hierarchyChanged.raiseEvent({ filterChange: { newFilter: undefined } });
+            this._hierarchyChanged.raiseEvent({ searchChange: { newSearch: undefined } });
             return;
         }
-        this._activeHierarchyDefinition = new FilteringHierarchyDefinition({
-            imodelAccess: this._imodelAccess,
+        this._activeHierarchyDefinition = new SearchHierarchyDefinition({
+            imodelAccess: this.getPrimaryIModelAccess(),
             source: this._sourceHierarchyDefinition,
-            nodeIdentifierPaths: props.paths,
+            sourceName: this.#sourceName,
+            targetPaths: props.paths,
         });
-        this.invalidateHierarchyCache("Hierarchy filter set");
+        this.invalidateHierarchyCache("Hierarchy search set");
         this._dispose.next();
-        this._hierarchyChanged.raiseEvent({ filterChange: { newFilter: props } });
+        this._hierarchyChanged.raiseEvent({ searchChange: { newSearch: props } });
     }
     onGroupingNodeCreated(groupingNode, props) {
         this._nodesCache?.set({ ...props, parentNode: groupingNode }, { observable: from(groupingNode.children), processingStatus: "pre-processed" });
@@ -127,44 +171,53 @@ class IModelHierarchyProviderImpl {
             category: LOGGING_NAMESPACE_PERFORMANCE,
             message: /* c8 ignore next */ () => `[${requestContext.requestId}] Requesting hierarchy level definitions for ${createNodeIdentifierForLogging(props.parentNode)}`,
         });
-        let parentNode = props.parentNode;
-        if (parentNode && HierarchyNode.isGeneric(parentNode) && parentNode.key.source && parentNode.key.source !== this._imodelAccess.imodelKey) {
-            return EMPTY;
-        }
-        if (parentNode && HierarchyNode.isInstancesNode(parentNode)) {
-            parentNode = {
-                ...parentNode,
-                key: {
-                    ...parentNode.key,
-                    instanceKeys: parentNode.key.instanceKeys.filter((ik) => !ik.imodelKey || ik.imodelKey === this._imodelAccess.imodelKey),
-                },
-            };
-            assert(HierarchyNodeKey.isInstances(parentNode.key));
-            if (parentNode.key.instanceKeys.length === 0) {
+        return from(this._imodels).pipe(mergeMap(({ imodelAccess }, imodelAccessIndex) => {
+            let parentNode = props.parentNode;
+            if (parentNode && HierarchyNode.isGeneric(parentNode) && parentNode.key.source && parentNode.key.source !== this.#sourceName) {
                 return EMPTY;
             }
-        }
-        return this._activeHierarchyDefinition.defineHierarchyLevel({ ...defineHierarchyLevelProps, parentNode }).pipe(mergeAll(), finalize(() => doLog({
+            if (parentNode && HierarchyNode.isInstancesNode(parentNode)) {
+                parentNode = {
+                    ...parentNode,
+                    key: {
+                        ...parentNode.key,
+                        instanceKeys: parentNode.key.instanceKeys.filter((ik) => !ik.imodelKey || ik.imodelKey === imodelAccess.imodelKey),
+                    },
+                };
+                assert(HierarchyNodeKey.isInstances(parentNode.key));
+                if (parentNode.key.instanceKeys.length === 0) {
+                    return EMPTY;
+                }
+            }
+            return this._activeHierarchyDefinition.defineHierarchyLevel({ ...defineHierarchyLevelProps, parentNode, imodelAccess }).pipe(mergeAll(), map(
+            /* Using `as` to work around TS not understanding that `{ x: A, y: B | C }` is the same as `{ x: A } & ({ y: B } | { y: C })` */
+            (hierarchyNodesDefinition) => ({ imodelAccess, imodelAccessIndex, hierarchyNodesDefinition })));
+        }), finalize(() => doLog({
             category: LOGGING_NAMESPACE_PERFORMANCE,
             message: /* c8 ignore next */ () => `[${requestContext.requestId}] Received all hierarchy level definitions for ${createNodeIdentifierForLogging(props.parentNode)}`,
         })));
     }
     createSourceNodesObservable(props) {
         // pipe definitions to nodes and put "share replay" on it
-        return this.createHierarchyLevelDefinitionsObservable(props).pipe(mergeMap((def) => {
+        return this.createHierarchyLevelDefinitionsObservable(props).pipe(mergeMap(({ imodelAccess, imodelAccessIndex, hierarchyNodesDefinition: def }) => defer(() => {
             if (HierarchyNodesDefinition.isGenericNode(def)) {
-                return of({ ...def.node, key: { type: "generic", id: def.node.key, source: this._imodelAccess.imodelKey } });
+                return of({
+                    ...def.node,
+                    key: { type: "generic", id: def.node.key, source: this.#sourceName },
+                });
             }
-            return this._queryScheduler.scheduleSubscription(of(def.query).pipe(map((query) => filterQueryByInstanceKeys(query, props.filteredInstanceKeys)), mergeMap((query) => readNodes({
-                queryExecutor: this._imodelAccess,
+            return this.getQueryScheduler(imodelAccess.imodelKey).scheduleSubscription(of(def.query).pipe(map((query) => createInstanceKeysFilteredQuery(query, props.targetInstanceKeys)), mergeMap((query) => readNodes({
+                queryExecutor: imodelAccess,
                 query,
                 limit: props.hierarchyLevelSizeLimit,
-                parser: this._activeHierarchyDefinition.parseNode ? (row) => this._activeHierarchyDefinition.parseNode(row, props.parentNode) : undefined,
+                parser: this._activeHierarchyDefinition.parseNode
+                    ? ({ row }) => this._activeHierarchyDefinition.parseNode({ row, parentNode: props.parentNode, imodelKey: imodelAccess.imodelKey })
+                    : undefined,
             })), map((node) => ({
                 ...node,
-                key: { ...node.key, instanceKeys: node.key.instanceKeys.map((key) => ({ ...key, imodelKey: this._imodelAccess.imodelKey })) },
+                key: { ...node.key, instanceKeys: node.key.instanceKeys.map((key) => ({ ...key, imodelKey: imodelAccess.imodelKey })) },
             }))));
-        }), finalize(() => doLog({
+        }).pipe(map((node) => ({ imodelAccess, imodelAccessIndex, node })))), mergeNodes, map(({ node }) => node), finalize(() => doLog({
             category: LOGGING_NAMESPACE_PERFORMANCE,
             message: /* c8 ignore next */ () => `[${props.requestContext.requestId}] Read all child nodes ${createNodeIdentifierForLogging(props.parentNode)}`,
         })), shareReplayWithErrors());
@@ -178,7 +231,8 @@ class IModelHierarchyProviderImpl {
         // format `ConcatenatedValue` labels into string labels
         mergeMap((node) => applyLabelsFormatting(node, this._valuesFormatter)), 
         // we have `ProcessedHierarchyNode` from here
-        preProcessNodes(this._activeHierarchyDefinition), 
+        // let consumers step-in
+        preProcessNodes(this._activeHierarchyDefinition, props.parentNode), 
         // process hiding
         createHideIfNoChildrenOperator((n) => this.getChildNodesObservables({ parentNode: n, requestContext: props.requestContext }).hasNodes), createHideNodesInHierarchyOperator(
         // note: for child nodes created because of hidden parent, we want to use parent's request props (instance filter, limit)
@@ -188,19 +242,17 @@ class IModelHierarchyProviderImpl {
         })));
     }
     createProcessedNodesObservable(preprocessedNodesObservable, props) {
-        return preprocessedNodesObservable.pipe(createGroupingOperator(this._imodelAccess, props.parentNode, this._valuesFormatter, this._localizedStrings, undefined, (gn) => this.onGroupingNodeCreated(gn, props)), finalize(() => doLog({
+        return preprocessedNodesObservable.pipe(createGroupingOperator(this.getPrimaryIModelAccess(), props.parentNode, this._valuesFormatter, this._localizedStrings, undefined, (gn) => this.onGroupingNodeCreated(gn, props)), finalize(() => doLog({
             category: LOGGING_NAMESPACE_PERFORMANCE,
             message: /* c8 ignore next */ () => `[${props.requestContext.requestId}] Finished grouping child nodes for ${createNodeIdentifierForLogging(props.parentNode)}`,
         })));
     }
     createFinalizedNodesObservable(processedNodesObservable, props) {
-        return processedNodesObservable.pipe(createDetermineChildrenOperator((n) => this.getChildNodesObservables({ parentNode: n, requestContext: props.requestContext }).hasNodes), postProcessNodes(this._activeHierarchyDefinition), sortNodesByLabelOperator, map((n) => {
+        return processedNodesObservable.pipe(createDetermineChildrenOperator((n) => this.getChildNodesObservables({ parentNode: n, requestContext: props.requestContext }).hasNodes), postProcessNodes(this._activeHierarchyDefinition, props.parentNode), sortNodesByLabelOperator, map((n) => {
             if ("processingParams" in n) {
                 delete n.processingParams;
             }
-            return Object.assign(n, {
-                children: hasChildren(n),
-            });
+            return { ...n, children: hasChildren(n) };
         }), takeUntil(this._dispose), finalize(() => doLog({
             category: LOGGING_NAMESPACE_PERFORMANCE,
             message: /* c8 ignore next */ () => `[${props.requestContext.requestId}] Finished finalizing child nodes for ${createNodeIdentifierForLogging(props.parentNode)}`,
@@ -234,13 +286,13 @@ class IModelHierarchyProviderImpl {
             return cached;
         }
         // if we don't find an entry for a grouping node, we load its instances by getting a query and applying
-        // a filter based on grouped instance keys
-        let filteredInstanceKeys;
+        // a search based on grouped instance keys
+        let targetInstanceKeys;
         let parentNonGroupingNode;
         if (parentNode) {
             if (HierarchyNode.isGroupingNode(parentNode)) {
                 parentNonGroupingNode = parentNode.nonGroupingAncestor;
-                filteredInstanceKeys = parentNode.groupedInstanceKeys;
+                targetInstanceKeys = parentNode.groupedInstanceKeys;
             }
             else {
                 // not sure why type checker doesn't pick this up
@@ -251,7 +303,7 @@ class IModelHierarchyProviderImpl {
         const nonGroupingNodeChildrenRequestProps = {
             ...restProps,
             parentNode: parentNonGroupingNode,
-            ...(filteredInstanceKeys ? { filteredInstanceKeys } : undefined),
+            ...(targetInstanceKeys ? { targetInstanceKeys } : undefined),
         };
         const value = { observable: this.createSourceNodesObservable(nonGroupingNodeChildrenRequestProps), processingStatus: "none" };
         this._nodesCache?.set(nonGroupingNodeChildrenRequestProps, value);
@@ -315,11 +367,11 @@ class IModelHierarchyProviderImpl {
             return from(parentNode.groupedInstanceKeys);
         }
         assert(!parentNode || HierarchyNode.isGeneric(parentNode) || HierarchyNode.isInstancesNode(parentNode));
-        const hierarchyLevelDefinitions = this.createHierarchyLevelDefinitionsObservable({ parentNode, instanceFilter, requestContext });
         // split the definitions based on whether they're for generic nodes or for instance nodes
-        const [genericDefs, instanceDefs] = partition(hierarchyLevelDefinitions, HierarchyNodesDefinition.isGenericNode);
+        const hierarchyLevelDefinitions = this.createHierarchyLevelDefinitionsObservable({ parentNode, instanceFilter, requestContext });
+        const [instanceDefs, genericDefs] = partition(hierarchyLevelDefinitions, (x) => HierarchyNodesDefinition.isInstanceNodesQuery(x.hierarchyNodesDefinition));
         // query instance keys and a flag whether they should be hidden
-        const instanceKeys = instanceDefs.pipe(mergeMap((def) => this._queryScheduler.scheduleSubscription(of(def.query).pipe(mergeMap(async (query) => {
+        const instanceKeys = instanceDefs.pipe(mergeMap(({ imodelAccess, hierarchyNodesDefinition: def }) => this.getQueryScheduler(imodelAccess.imodelKey).scheduleSubscription(of(def.query).pipe(mergeMap(async (query) => {
             const ecsql = `
                 SELECT
                   ${NodeSelectClauseColumnNames.FullClassName},
@@ -329,12 +381,16 @@ class IModelHierarchyProviderImpl {
                   ${query.ecsql}
                 )
               `;
-            const reader = this._imodelAccess.createQueryReader({ ...query, ecsql }, { rowFormat: "Indexes", limit: hierarchyLevelSizeLimit });
+            const reader = imodelAccess.createQueryReader({ ...query, ecsql }, {
+                rowFormat: "Indexes",
+                limit: hierarchyLevelSizeLimit,
+                restartToken: `${this.#componentName}/${this.#componentId}/node-instance-keys/${Guid.createValue()}`,
+            });
             return from(reader).pipe(map((row) => ({
                 key: {
                     className: normalizeFullClassName(row[0]),
                     id: row[1],
-                    imodelKey: this._imodelAccess.imodelKey,
+                    imodelKey: imodelAccess.imodelKey,
                 },
                 hide: !!row[2],
             })));
@@ -344,17 +400,17 @@ class IModelHierarchyProviderImpl {
         // hidden items' handling:
         // - if a generic node is hidden, we'll want to retrieve instance keys of its children, otherwise we don't care about it,
         // - if an instance key is hidden, we want to create a merged node similar to what we do in `createHideNodesInHierarchyOperator`
-        const hiddenParentNodes = merge(genericDefs.pipe(filter((def) => !!def.node.processingParams?.hideInHierarchy), map((def) => ({
+        const hiddenParentNodes = merge(genericDefs.pipe(filter(({ hierarchyNodesDefinition }) => !!hierarchyNodesDefinition.node.processingParams?.hideInHierarchy), map(({ hierarchyNodesDefinition }) => ({
             type: "generic",
-            id: def.node.key,
-            source: this._imodelAccess.imodelKey,
+            id: hierarchyNodesDefinition.node.key,
+            source: this.#sourceName,
         }))), hiddenNodeInstanceKeys.pipe(
         // first merge all keys by class
-        reduceToMergeMapList(({ key }) => key.className, ({ key }) => key.id), 
+        reduceToMergeMapList(({ key }) => key.className, ({ key }) => key), 
         // then, for each class, create an instance key
-        mergeMap((mergedMap) => [...mergedMap.entries()].map(([className, ids]) => ({
+        mergeMap((mergedMap) => [...mergedMap.entries()].map(([className, keys]) => ({
             type: "instances",
-            instanceKeys: ids.map((id) => ({ className, id, imodelKey: this._imodelAccess.imodelKey })),
+            instanceKeys: keys.map(({ id, imodelKey }) => ({ className, id, imodelKey })),
         }))))).pipe(map((key) => ({
             key,
             parentKeys: [],
@@ -391,14 +447,14 @@ class IModelHierarchyProviderImpl {
         })));
     }
 }
-function preProcessNodes(hierarchyFactory) {
-    return hierarchyFactory.preProcessNode ? processNodes(hierarchyFactory.preProcessNode) : identity;
+function preProcessNodes(hierarchyFactory, parentNode) {
+    return hierarchyFactory.preProcessNode ? processNodes(hierarchyFactory.preProcessNode, parentNode) : identity;
 }
-function postProcessNodes(hierarchyFactory) {
-    return hierarchyFactory.postProcessNode ? processNodes(hierarchyFactory.postProcessNode) : identity;
+function postProcessNodes(hierarchyFactory, parentNode) {
+    return hierarchyFactory.postProcessNode ? processNodes(hierarchyFactory.postProcessNode, parentNode) : identity;
 }
-function processNodes(processor) {
-    return (nodes) => nodes.pipe(mergeMap(processor));
+function processNodes(processor, parentNode) {
+    return (nodes) => nodes.pipe(mergeMap((node) => processor({ node, parentNode })));
 }
 function applyLabelsFormatting(node, valueFormatter) {
     return from(formatConcatenatedValue({
@@ -415,20 +471,20 @@ function createParentNodeKeysList(parentNode) {
     }
     return [...parentNode.parentKeys, parentNode.key];
 }
-function filterQueryByInstanceKeys(query, filteredInstanceKeys) {
-    if (!filteredInstanceKeys || !filteredInstanceKeys.length) {
+function createInstanceKeysFilteredQuery(query, targetInstanceKeys) {
+    if (!targetInstanceKeys || !targetInstanceKeys.length) {
         return query;
     }
     const MAX_ALLOWED_BINDINGS = 1000;
-    if (filteredInstanceKeys.length < MAX_ALLOWED_BINDINGS) {
+    if (targetInstanceKeys.length < MAX_ALLOWED_BINDINGS) {
         return {
             ...query,
             ecsql: `
         SELECT *
         FROM (${query.ecsql}) q
-        WHERE q.ECInstanceId IN (${filteredInstanceKeys.map(() => "?").join(",")})
+        WHERE q.ECInstanceId IN (${targetInstanceKeys.map(() => "?").join(",")})
       `,
-            bindings: [...(query.bindings ?? []), ...filteredInstanceKeys.map((k) => ({ type: "id", value: k.id }))],
+            bindings: [...(query.bindings ?? []), ...targetInstanceKeys.map((k) => ({ type: "id", value: k.id }))],
         };
     }
     /* c8 ignore start */
@@ -439,8 +495,78 @@ function filterQueryByInstanceKeys(query, filteredInstanceKeys) {
       FROM (${query.ecsql}) q
       WHERE InVirtualSet(?, q.ECInstanceId)
     `,
-        bindings: [...(query.bindings ?? []), { type: "idset", value: filteredInstanceKeys.map((k) => k.id) }],
+        bindings: [...(query.bindings ?? []), { type: "idset", value: targetInstanceKeys.map((k) => k.id) }],
     };
     /* c8 ignore end */
 }
+function mergeNodes(source) {
+    return from(source).pipe(reduce((acc, input) => {
+        for (let i = 0; i < acc.length; ++i) {
+            if (input.imodelAccess === acc[i].imodelAccess) {
+                // don't attempt to merge nodes if they come from the same provider
+                continue;
+            }
+            // the first argument for `tryMergeNodes` acts as the primary data source, so we have to make sure we pass
+            // the node with higher `imodelAccessIndex` first
+            const candidates = input.imodelAccessIndex > acc[i].imodelAccessIndex
+                ? { imodelAccess: input.imodelAccess, imodelAccessIndex: input.imodelAccessIndex, primary: input.node, secondary: acc[i].node }
+                : { imodelAccess: acc[i].imodelAccess, imodelAccessIndex: acc[i].imodelAccessIndex, primary: acc[i].node, secondary: input.node };
+            const merged = tryMergeNodes(candidates.primary, candidates.secondary);
+            if (merged) {
+                acc[i] = { node: merged, imodelAccess: candidates.imodelAccess, imodelAccessIndex: candidates.imodelAccessIndex };
+                return acc;
+            }
+        }
+        acc.push(input);
+        return acc;
+    }, new Array()), mergeAll());
+}
+function mergeSearchProps(primary, secondary) {
+    if (!primary || !secondary) {
+        return primary ?? secondary;
+    }
+    const hasSearchTargetAncestor = primary.hasSearchTargetAncestor || secondary.hasSearchTargetAncestor;
+    const childrenTargetPaths = [...(primary.childrenTargetPaths ?? []), ...(secondary.childrenTargetPaths ?? [])];
+    return {
+        ...(hasSearchTargetAncestor ? { hasSearchTargetAncestor } : undefined),
+        ...(childrenTargetPaths.length ? { childrenTargetPaths } : undefined),
+        ...(primary.isSearchTarget || secondary.isSearchTarget
+            ? {
+                isSearchTarget: true,
+                searchTargetOptions: HierarchySearchPath.mergeOptions(primary.isSearchTarget ? primary.searchTargetOptions : undefined, secondary.isSearchTarget ? secondary.searchTargetOptions : undefined),
+            }
+            : {
+                isSearchTarget: false,
+            }),
+    };
+}
+function tryMergeInstanceNodes(primary, secondary) {
+    if (HierarchyNode.isInstancesNode(primary) &&
+        HierarchyNode.isInstancesNode(secondary) &&
+        primary.key.instanceKeys.some((lhsKey) => secondary.key.instanceKeys.some((rhsKey) => InstanceKey.equals(lhsKey, rhsKey)))) {
+        const searchProps = mergeSearchProps(primary.search, secondary.search);
+        return {
+            ...primary,
+            key: {
+                type: "instances",
+                instanceKeys: primary.key.instanceKeys.concat(secondary.key.instanceKeys),
+            },
+            ...(searchProps ? { search: searchProps } : undefined),
+        };
+    }
+    return undefined;
+}
+function tryMergeGenericNodes(primary, secondary) {
+    if (HierarchyNode.isGeneric(primary) && HierarchyNode.isGeneric(secondary) && primary.key.id === secondary.key.id) {
+        const searchProps = mergeSearchProps(primary.search, secondary.search);
+        return {
+            ...primary,
+            ...(searchProps ? { search: searchProps } : undefined),
+        };
+    }
+    return undefined;
+}
+function tryMergeNodes(primary, secondary) {
+    return tryMergeInstanceNodes(primary, secondary) ?? tryMergeGenericNodes(primary, secondary) ?? undefined;
+}
 //# sourceMappingURL=IModelHierarchyProvider.js.map