@itwin/presentation-hierarchies 2.0.0-alpha.0 → 2.0.0-alpha.10

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

@@ -5,6 +5,7 @@
  *--------------------------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createIModelHierarchyProvider = createIModelHierarchyProvider;
+exports.createMergedIModelHierarchyProvider = createMergedIModelHierarchyProvider;
 require("../internal/DisposePolyfill.js");
 const rxjs_1 = require("rxjs");
 const core_bentley_1 = require("@itwin/core-bentley");
@@ -12,6 +13,7 @@ const presentation_shared_1 = require("@itwin/presentation-shared");
 const HierarchyErrors_js_1 = require("../HierarchyErrors.js");
 const HierarchyNode_js_1 = require("../HierarchyNode.js");
 const HierarchyNodeKey_js_1 = require("../HierarchyNodeKey.js");
+const HierarchySearch_js_1 = require("../HierarchySearch.js");
 const Common_js_1 = require("../internal/Common.js");
 const EachValueFrom_js_1 = require("../internal/EachValueFrom.js");
 const LoggingUtils_js_1 = require("../internal/LoggingUtils.js");
@@ -19,8 +21,8 @@ const Partition_js_1 = require("../internal/operators/Partition.js");
 const ReduceToMergeMap_js_1 = require("../internal/operators/ReduceToMergeMap.js");
 const ShareReplayWithErrors_js_1 = require("../internal/operators/ShareReplayWithErrors.js");
 const Sorting_js_1 = require("../internal/operators/Sorting.js");
+const RxjsHierarchyDefinition_js_1 = require("../internal/RxjsHierarchyDefinition.js");
 const SubscriptionScheduler_js_1 = require("../internal/SubscriptionScheduler.js");
-const FilteringHierarchyDefinition_js_1 = require("./FilteringHierarchyDefinition.js");
 const HierarchyCache_js_1 = require("./HierarchyCache.js");
 const IModelHierarchyDefinition_js_1 = require("./IModelHierarchyDefinition.js");
 const NodeSelectQueryFactory_js_1 = require("./NodeSelectQueryFactory.js");
@@ -28,6 +30,7 @@ const DetermineChildren_js_1 = require("./operators/DetermineChildren.js");
 const Grouping_js_1 = require("./operators/Grouping.js");
 const HideIfNoChildren_js_1 = require("./operators/HideIfNoChildren.js");
 const HideNodesInHierarchy_js_1 = require("./operators/HideNodesInHierarchy.js");
+const SearchHierarchyDefinition_js_1 = require("./SearchHierarchyDefinition.js");
 const TreeNodesReader_js_1 = require("./TreeNodesReader.js");
 const LOGGING_NAMESPACE = `${Common_js_1.LOGGING_NAMESPACE}.IModelHierarchyProvider`;
 const LOGGING_NAMESPACE_INTERNAL = `${Common_js_1.LOGGING_NAMESPACE_INTERNAL}.IModelHierarchyProvider`;
@@ -35,33 +38,57 @@ const LOGGING_NAMESPACE_PERFORMANCE = `${Common_js_1.LOGGING_NAMESPACE_PERFORMAN
 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
  */
 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
+ */
+function createMergedIModelHierarchyProvider(props) {
     return new IModelHierarchyProviderImpl(props);
 }
 class IModelHierarchyProviderImpl {
-    _imodelAccess;
+    _imodels;
     _hierarchyChanged;
     _valuesFormatter;
     _sourceHierarchyDefinition;
     _activeHierarchyDefinition;
     _localizedStrings;
-    _queryScheduler;
+    _queryConcurrency;
+    _querySchedulers;
     _nodesCache;
     _unsubscribe;
     _dispose = new rxjs_1.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 = core_bentley_1.Guid.createValue();
+        this.#componentName = "IModelHierarchyProviderImpl";
+        /* c8 ignore next */
+        this.#sourceName = props.sourceName ?? `${this.#componentName}:${this.#componentId}`;
+        this._imodels = props.imodels;
         this._hierarchyChanged = new core_bentley_1.BeEvent();
-        this._activeHierarchyDefinition = this._sourceHierarchyDefinition = props.hierarchyDefinition;
+        this._activeHierarchyDefinition = this._sourceHierarchyDefinition = (0, RxjsHierarchyDefinition_js_1.getRxjsHierarchyDefinition)(props.hierarchyDefinition);
         this._valuesFormatter = props?.formatter ?? (0, presentation_shared_1.createDefaultValueFormatter)();
         this._localizedStrings = { other: "Other", unspecified: "Not specified", ...props?.localizedStrings };
-        this._queryScheduler = new SubscriptionScheduler_js_1.SubscriptionScheduler(props.queryConcurrency ?? DEFAULT_QUERY_CONCURRENCY);
-        this.setHierarchyFilter(props.filtering);
+        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_js_1.HierarchyCache({
@@ -70,11 +97,18 @@ class IModelHierarchyProviderImpl {
                 variationsCount: 1,
             });
         }
-        this._unsubscribe = props.imodelChanged?.addListener(() => {
-            this.invalidateHierarchyCache("Data source changed");
+        const imodelChangeSubscription = (0, rxjs_1.from)(this._imodels)
+            .pipe((0, rxjs_1.mergeMap)(({ imodelAccess, imodelChanged }) => imodelChanged
+            ? (0, rxjs_1.fromEventPattern)((handler) => imodelChanged.addListener(handler), (handler) => imodelChanged.removeListener(handler), () => imodelAccess)
+            : rxjs_1.EMPTY))
+            .subscribe(({ imodelKey }) => {
+            this.invalidateHierarchyCache(`Data source changed: "${imodelKey}"`);
             this._dispose.next();
             this._hierarchyChanged.raiseEvent();
         });
+        this._unsubscribe = () => {
+            imodelChangeSubscription.unsubscribe();
+        };
     }
     [Symbol.dispose]() {
         this._dispose.next();
@@ -87,6 +121,17 @@ class IModelHierarchyProviderImpl {
     get hierarchyChanged() {
         return this._hierarchyChanged;
     }
+    getQueryScheduler(imodelKey) {
+        let scheduler = this._querySchedulers.get(imodelKey);
+        if (!scheduler) {
+            scheduler = new SubscriptionScheduler_js_1.SubscriptionScheduler(this._queryConcurrency);
+            this._querySchedulers.set(imodelKey, scheduler);
+        }
+        return scheduler;
+    }
+    getPrimaryIModelAccess() {
+        return this._imodels[this._imodels.length - 1].imodelAccess;
+    }
     invalidateHierarchyCache(reason) {
         (0, LoggingUtils_js_1.doLog)({
             category: `${LOGGING_NAMESPACE}.Events`,
@@ -102,23 +147,24 @@ class IModelHierarchyProviderImpl {
         this._valuesFormatter = formatter ?? (0, presentation_shared_1.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_js_1.FilteringHierarchyDefinition({
-            imodelAccess: this._imodelAccess,
+        this._activeHierarchyDefinition = new SearchHierarchyDefinition_js_1.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: (0, rxjs_1.from)(groupingNode.children), processingStatus: "pre-processed" });
@@ -129,48 +175,53 @@ class IModelHierarchyProviderImpl {
             category: LOGGING_NAMESPACE_PERFORMANCE,
             message: /* c8 ignore next */ () => `[${requestContext.requestId}] Requesting hierarchy level definitions for ${(0, Common_js_1.createNodeIdentifierForLogging)(props.parentNode)}`,
         });
-        return (0, rxjs_1.from)((0, rxjs_1.defer)(async () => {
+        return (0, rxjs_1.from)(this._imodels).pipe((0, rxjs_1.mergeMap)(({ imodelAccess }, imodelAccessIndex) => {
             let parentNode = props.parentNode;
-            if (parentNode && HierarchyNode_js_1.HierarchyNode.isGeneric(parentNode) && parentNode.key.source && parentNode.key.source !== this._imodelAccess.imodelKey) {
-                return [];
+            if (parentNode && HierarchyNode_js_1.HierarchyNode.isGeneric(parentNode) && parentNode.key.source && parentNode.key.source !== this.#sourceName) {
+                return rxjs_1.EMPTY;
             }
             if (parentNode && HierarchyNode_js_1.HierarchyNode.isInstancesNode(parentNode)) {
                 parentNode = {
                     ...parentNode,
                     key: {
                         ...parentNode.key,
-                        instanceKeys: parentNode.key.instanceKeys.filter((ik) => !ik.imodelKey || ik.imodelKey === this._imodelAccess.imodelKey),
+                        instanceKeys: parentNode.key.instanceKeys.filter((ik) => !ik.imodelKey || ik.imodelKey === imodelAccess.imodelKey),
                     },
                 };
                 (0, core_bentley_1.assert)(HierarchyNodeKey_js_1.HierarchyNodeKey.isInstances(parentNode.key));
                 if (parentNode.key.instanceKeys.length === 0) {
-                    return [];
+                    return rxjs_1.EMPTY;
                 }
             }
-            return this._activeHierarchyDefinition.defineHierarchyLevel({ ...defineHierarchyLevelProps, parentNode });
-        })).pipe((0, rxjs_1.mergeAll)(), (0, rxjs_1.finalize)(() => (0, LoggingUtils_js_1.doLog)({
+            return this._activeHierarchyDefinition.defineHierarchyLevel({ ...defineHierarchyLevelProps, parentNode, imodelAccess }).pipe((0, rxjs_1.mergeAll)(), (0, rxjs_1.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 })));
+        }), (0, rxjs_1.finalize)(() => (0, LoggingUtils_js_1.doLog)({
             category: LOGGING_NAMESPACE_PERFORMANCE,
             message: /* c8 ignore next */ () => `[${requestContext.requestId}] Received all hierarchy level definitions for ${(0, Common_js_1.createNodeIdentifierForLogging)(props.parentNode)}`,
         })));
     }
     createSourceNodesObservable(props) {
         // pipe definitions to nodes and put "share replay" on it
-        return this.createHierarchyLevelDefinitionsObservable(props).pipe((0, rxjs_1.mergeMap)((def) => {
+        return this.createHierarchyLevelDefinitionsObservable(props).pipe((0, rxjs_1.mergeMap)(({ imodelAccess, imodelAccessIndex, hierarchyNodesDefinition: def }) => (0, rxjs_1.defer)(() => {
             if (IModelHierarchyDefinition_js_1.HierarchyNodesDefinition.isGenericNode(def)) {
-                return (0, rxjs_1.of)({ ...def.node, key: { type: "generic", id: def.node.key, source: this._imodelAccess.imodelKey } });
+                return (0, rxjs_1.of)({
+                    ...def.node,
+                    key: { type: "generic", id: def.node.key, source: this.#sourceName },
+                });
             }
-            return this._queryScheduler.scheduleSubscription((0, rxjs_1.of)(def.query).pipe((0, rxjs_1.map)((query) => filterQueryByInstanceKeys(query, props.filteredInstanceKeys)), (0, rxjs_1.mergeMap)((query) => (0, TreeNodesReader_js_1.readNodes)({
-                queryExecutor: this._imodelAccess,
+            return this.getQueryScheduler(imodelAccess.imodelKey).scheduleSubscription((0, rxjs_1.of)(def.query).pipe((0, rxjs_1.map)((query) => createInstanceKeysFilteredQuery(query, props.targetInstanceKeys)), (0, rxjs_1.mergeMap)((query) => (0, TreeNodesReader_js_1.readNodes)({
+                queryExecutor: imodelAccess,
                 query,
                 limit: props.hierarchyLevelSizeLimit,
                 parser: this._activeHierarchyDefinition.parseNode
-                    ? async (row) => this._activeHierarchyDefinition.parseNode(row, props.parentNode)
+                    ? ({ row }) => this._activeHierarchyDefinition.parseNode({ row, parentNode: props.parentNode, imodelKey: imodelAccess.imodelKey })
                     : undefined,
             })), (0, rxjs_1.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 })) },
             }))));
-        }), (0, rxjs_1.finalize)(() => (0, LoggingUtils_js_1.doLog)({
+        }).pipe((0, rxjs_1.map)((node) => ({ imodelAccess, imodelAccessIndex, node })))), mergeNodes, (0, rxjs_1.map)(({ node }) => node), (0, rxjs_1.finalize)(() => (0, LoggingUtils_js_1.doLog)({
             category: LOGGING_NAMESPACE_PERFORMANCE,
             message: /* c8 ignore next */ () => `[${props.requestContext.requestId}] Read all child nodes ${(0, Common_js_1.createNodeIdentifierForLogging)(props.parentNode)}`,
         })), (0, ShareReplayWithErrors_js_1.shareReplayWithErrors)());
@@ -182,8 +233,9 @@ class IModelHierarchyProviderImpl {
         // set parent node keys on the source node
         (0, rxjs_1.map)((node) => Object.assign(node, { parentKeys: createParentNodeKeysList(props.parentNode) })), 
         // format `ConcatenatedValue` labels into string labels
-        (0, rxjs_1.mergeMap)(async (node) => applyLabelsFormatting(node, this._valuesFormatter)), 
+        (0, rxjs_1.mergeMap)((node) => applyLabelsFormatting(node, this._valuesFormatter)), 
         // we have `ProcessedHierarchyNode` from here
+        // let consumers step-in
         preProcessNodes(this._activeHierarchyDefinition), 
         // process hiding
         (0, HideIfNoChildren_js_1.createHideIfNoChildrenOperator)((n) => this.getChildNodesObservables({ parentNode: n, requestContext: props.requestContext }).hasNodes), (0, HideNodesInHierarchy_js_1.createHideNodesInHierarchyOperator)(
@@ -194,7 +246,7 @@ class IModelHierarchyProviderImpl {
         })));
     }
     createProcessedNodesObservable(preprocessedNodesObservable, props) {
-        return preprocessedNodesObservable.pipe((0, Grouping_js_1.createGroupingOperator)(this._imodelAccess, props.parentNode, this._valuesFormatter, this._localizedStrings, undefined, (gn) => this.onGroupingNodeCreated(gn, props)), (0, rxjs_1.finalize)(() => (0, LoggingUtils_js_1.doLog)({
+        return preprocessedNodesObservable.pipe((0, Grouping_js_1.createGroupingOperator)(this.getPrimaryIModelAccess(), props.parentNode, this._valuesFormatter, this._localizedStrings, undefined, (gn) => this.onGroupingNodeCreated(gn, props)), (0, rxjs_1.finalize)(() => (0, LoggingUtils_js_1.doLog)({
             category: LOGGING_NAMESPACE_PERFORMANCE,
             message: /* c8 ignore next */ () => `[${props.requestContext.requestId}] Finished grouping child nodes for ${(0, Common_js_1.createNodeIdentifierForLogging)(props.parentNode)}`,
         })));
@@ -204,9 +256,7 @@ class IModelHierarchyProviderImpl {
             if ("processingParams" in n) {
                 delete n.processingParams;
             }
-            return Object.assign(n, {
-                children: (0, Common_js_1.hasChildren)(n),
-            });
+            return { ...n, children: (0, Common_js_1.hasChildren)(n) };
         }), (0, rxjs_1.takeUntil)(this._dispose), (0, rxjs_1.finalize)(() => (0, LoggingUtils_js_1.doLog)({
             category: LOGGING_NAMESPACE_PERFORMANCE,
             message: /* c8 ignore next */ () => `[${props.requestContext.requestId}] Finished finalizing child nodes for ${(0, Common_js_1.createNodeIdentifierForLogging)(props.parentNode)}`,
@@ -240,13 +290,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_js_1.HierarchyNode.isGroupingNode(parentNode)) {
                 parentNonGroupingNode = parentNode.nonGroupingAncestor;
-                filteredInstanceKeys = parentNode.groupedInstanceKeys;
+                targetInstanceKeys = parentNode.groupedInstanceKeys;
             }
             else {
                 // not sure why type checker doesn't pick this up
@@ -257,7 +307,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);
@@ -321,11 +371,11 @@ class IModelHierarchyProviderImpl {
             return (0, rxjs_1.from)(parentNode.groupedInstanceKeys);
         }
         (0, core_bentley_1.assert)(!parentNode || HierarchyNode_js_1.HierarchyNode.isGeneric(parentNode) || HierarchyNode_js_1.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] = (0, Partition_js_1.partition)(hierarchyLevelDefinitions, IModelHierarchyDefinition_js_1.HierarchyNodesDefinition.isGenericNode);
+        const hierarchyLevelDefinitions = this.createHierarchyLevelDefinitionsObservable({ parentNode, instanceFilter, requestContext });
+        const [instanceDefs, genericDefs] = (0, Partition_js_1.partition)(hierarchyLevelDefinitions, (x) => IModelHierarchyDefinition_js_1.HierarchyNodesDefinition.isInstanceNodesQuery(x.hierarchyNodesDefinition));
         // query instance keys and a flag whether they should be hidden
-        const instanceKeys = instanceDefs.pipe((0, rxjs_1.mergeMap)((def) => this._queryScheduler.scheduleSubscription((0, rxjs_1.of)(def.query).pipe((0, rxjs_1.mergeMap)(async (query) => {
+        const instanceKeys = instanceDefs.pipe((0, rxjs_1.mergeMap)(({ imodelAccess, hierarchyNodesDefinition: def }) => this.getQueryScheduler(imodelAccess.imodelKey).scheduleSubscription((0, rxjs_1.of)(def.query).pipe((0, rxjs_1.mergeMap)(async (query) => {
             const ecsql = `
                 SELECT
                   ${NodeSelectQueryFactory_js_1.NodeSelectClauseColumnNames.FullClassName},
@@ -335,12 +385,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/${core_bentley_1.Guid.createValue()}`,
+            });
             return (0, rxjs_1.from)(reader).pipe((0, rxjs_1.map)((row) => ({
                 key: {
                     className: (0, presentation_shared_1.normalizeFullClassName)(row[0]),
                     id: row[1],
-                    imodelKey: this._imodelAccess.imodelKey,
+                    imodelKey: imodelAccess.imodelKey,
                 },
                 hide: !!row[2],
             })));
@@ -350,17 +404,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 = (0, rxjs_1.merge)(genericDefs.pipe((0, rxjs_1.filter)((def) => !!def.node.processingParams?.hideInHierarchy), (0, rxjs_1.map)((def) => ({
+        const hiddenParentNodes = (0, rxjs_1.merge)(genericDefs.pipe((0, rxjs_1.filter)(({ hierarchyNodesDefinition }) => !!hierarchyNodesDefinition.node.processingParams?.hideInHierarchy), (0, rxjs_1.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
-        (0, ReduceToMergeMap_js_1.reduceToMergeMapList)(({ key }) => key.className, ({ key }) => key.id), 
+        (0, ReduceToMergeMap_js_1.reduceToMergeMapList)(({ key }) => key.className, ({ key }) => key), 
         // then, for each class, create an instance key
-        (0, rxjs_1.mergeMap)((mergedMap) => [...mergedMap.entries()].map(([className, ids]) => ({
+        (0, rxjs_1.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((0, rxjs_1.map)((key) => ({
             key,
             parentKeys: [],
@@ -398,26 +452,22 @@ class IModelHierarchyProviderImpl {
     }
 }
 function preProcessNodes(hierarchyFactory) {
-    return hierarchyFactory.preProcessNode
-        ? processNodes(hierarchyFactory.preProcessNode.bind(hierarchyFactory))
-        : (o) => o;
+    return hierarchyFactory.preProcessNode ? processNodes(hierarchyFactory.preProcessNode) : rxjs_1.identity;
 }
 function postProcessNodes(hierarchyFactory) {
-    return hierarchyFactory.postProcessNode
-        ? processNodes(hierarchyFactory.postProcessNode.bind(hierarchyFactory))
-        : (o) => o;
+    return hierarchyFactory.postProcessNode ? processNodes(hierarchyFactory.postProcessNode) : rxjs_1.identity;
 }
 function processNodes(processor) {
-    return (nodes) => nodes.pipe((0, rxjs_1.mergeMap)(processor), (0, rxjs_1.filter)((n) => !!n));
+    return (nodes) => nodes.pipe((0, rxjs_1.mergeMap)(processor));
 }
-async function applyLabelsFormatting(node, valueFormatter) {
-    return {
+function applyLabelsFormatting(node, valueFormatter) {
+    return (0, rxjs_1.from)((0, presentation_shared_1.formatConcatenatedValue)({
+        value: node.label,
+        valueFormatter,
+    })).pipe((0, rxjs_1.map)((label) => ({
         ...node,
-        label: await (0, presentation_shared_1.formatConcatenatedValue)({
-            value: node.label,
-            valueFormatter,
-        }),
-    };
+        label,
+    })));
 }
 function createParentNodeKeysList(parentNode) {
     if (!parentNode) {
@@ -425,20 +475,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 */
@@ -449,8 +499,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 (0, rxjs_1.from)(source).pipe((0, rxjs_1.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()), (0, rxjs_1.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: HierarchySearch_js_1.HierarchySearchPath.mergeOptions(primary.isSearchTarget ? primary.searchTargetOptions : undefined, secondary.isSearchTarget ? secondary.searchTargetOptions : undefined),
+            }
+            : {
+                isSearchTarget: false,
+            }),
+    };
+}
+function tryMergeInstanceNodes(primary, secondary) {
+    if (HierarchyNode_js_1.HierarchyNode.isInstancesNode(primary) &&
+        HierarchyNode_js_1.HierarchyNode.isInstancesNode(secondary) &&
+        primary.key.instanceKeys.some((lhsKey) => secondary.key.instanceKeys.some((rhsKey) => presentation_shared_1.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_js_1.HierarchyNode.isGeneric(primary) && HierarchyNode_js_1.HierarchyNode.isGeneric(secondary) && primary.key.type === secondary.key.type) {
+        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