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

package/lib/esm/tree-widget-react/components/trees/categories-tree/CategoriesTreeDefinition.js

@@ -2,202 +2,777 @@
  * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
  * See LICENSE.md in the project root for license terms and full copyright notice.
  *--------------------------------------------------------------------------------------------*/
-import { createNodesQueryClauseFactory, createPredicateBasedHierarchyDefinition } from "@itwin/presentation-hierarchies";
+import { bufferCount, defaultIfEmpty, defer, EMPTY, firstValueFrom, forkJoin, from, fromEvent, identity, lastValueFrom, map, merge, mergeMap, of, reduce, takeUntil, toArray, } from "rxjs";
+import { assert, Guid } from "@itwin/core-bentley";
+import { createNodesQueryClauseFactory, createPredicateBasedHierarchyDefinition, ProcessedHierarchyNode } from "@itwin/presentation-hierarchies";
 import { createBisInstanceLabelSelectClauseFactory, ECSql } from "@itwin/presentation-shared";
+import { CLASS_NAME_DefinitionContainer, CLASS_NAME_InformationPartitionElement, CLASS_NAME_ISubModeledElement, CLASS_NAME_Model, CLASS_NAME_SubCategory, } from "../common/internal/ClassNameDefinitions.js";
+import { createIdsSelector, getClassesByView, getDistinctMapValues, getOptimalBatchSize, groupingNodeHasFilterTargets, parseIdsSelectorResult, releaseMainThreadOnItemsCount, } from "../common/internal/Utils.js";
 import { FilterLimitExceededError } from "../common/TreeErrors.js";
 const MAX_FILTERING_INSTANCE_KEY_COUNT = 100;
+/** @internal */
+export const defaultHierarchyConfiguration = {
+    hideSubCategories: false,
+    showElements: false,
+    showEmptyCategories: false,
+};
+/** @internal */
 export class CategoriesTreeDefinition {
+    #impl;
+    #selectQueryFactory;
+    #nodeLabelSelectClauseFactory;
+    #idsCache;
+    #hierarchyConfig;
+    #iModelAccess;
+    #categoryClass;
+    #categoryElementClass;
+    #categoryModelClass;
+    static #componentName = "CategoriesTreeDefinition";
     constructor(props) {
-        this._impl = createPredicateBasedHierarchyDefinition({
-            classHierarchyInspector: props.imodelAccess,
-            hierarchy: {
-                rootNodes: async (requestProps) => this.createRootHierarchyLevelDefinition({ ...requestProps, viewType: props.viewType }),
-                childNodes: [
-                    {
-                        parentInstancesNodePredicate: "BisCore.Category",
-                        definitions: async (requestProps) => this.createSubcategoryQuery(requestProps),
-                    },
-                ],
-            },
-        });
-        this._nodeLabelSelectClauseFactory = createBisInstanceLabelSelectClauseFactory({ classHierarchyInspector: props.imodelAccess });
-        this._selectQueryFactory = createNodesQueryClauseFactory({
+        this.#iModelAccess = props.imodelAccess;
+        this.#idsCache = props.idsCache;
+        this.#nodeLabelSelectClauseFactory = createBisInstanceLabelSelectClauseFactory({ classHierarchyInspector: props.imodelAccess });
+        this.#selectQueryFactory = createNodesQueryClauseFactory({
             imodelAccess: props.imodelAccess,
-            instanceLabelSelectClauseFactory: this._nodeLabelSelectClauseFactory,
+            instanceLabelSelectClauseFactory: this.#nodeLabelSelectClauseFactory,
         });
+        this.#hierarchyConfig = props.hierarchyConfig;
+        const { categoryClass, elementClass, modelClass } = getClassesByView(props.viewType);
+        this.#categoryClass = categoryClass;
+        this.#categoryElementClass = elementClass;
+        this.#categoryModelClass = modelClass;
+    }
+    async postProcessNode(node) {
+        if (ProcessedHierarchyNode.isGroupingNode(node)) {
+            const modelElementsMap = new Map();
+            node.children.forEach((child) => {
+                let modelEntry = modelElementsMap.get(child.extendedData?.modelId);
+                if (!modelEntry) {
+                    modelEntry = new Set();
+                    modelElementsMap.set(child.extendedData?.modelId, modelEntry);
+                }
+                assert(child.key.type === "instances");
+                for (const { id } of child.key.instanceKeys) {
+                    modelEntry.add(id);
+                }
+            });
+            const { hasFilterTargetAncestor, hasDirectNonFilteredTargets } = groupingNodeHasFilterTargets(node.children);
+            return {
+                ...node,
+                label: node.label,
+                extendedData: {
+                    ...node.extendedData,
+                    // add `categoryId` from the first grouped element
+                    categoryId: node.children[0].extendedData?.categoryId,
+                    modelElementsMap,
+                    ...(hasDirectNonFilteredTargets ? { hasDirectNonFilteredTargets } : {}),
+                    ...(hasFilterTargetAncestor ? { hasFilterTargetAncestor } : {}),
+                    // `imageId` is assigned to instance nodes at query time, but grouping ones need to
+                    // be handled during post-processing
+                    imageId: "icon-ec-class",
+                },
+            };
+        }
+        return node;
+    }
+    async getHierarchyDefinition() {
+        this.#impl ??= (async () => {
+            const isDefinitionContainerSupported = await firstValueFrom(this.#idsCache.getIsDefinitionContainerSupported());
+            return createPredicateBasedHierarchyDefinition({
+                classHierarchyInspector: this.#iModelAccess,
+                hierarchy: {
+                    rootNodes: async (requestProps) => this.createDefinitionContainersAndCategoriesQuery(requestProps),
+                    childNodes: [
+                        ...(this.#hierarchyConfig.showElements
+                            ? [
+                                {
+                                    parentInstancesNodePredicate: this.#categoryElementClass,
+                                    definitions: async (requestProps) => this.createElementChildrenQuery(requestProps),
+                                },
+                                {
+                                    parentInstancesNodePredicate: CLASS_NAME_ISubModeledElement,
+                                    definitions: async (requestProps) => this.createISubModeledElementChildrenQuery(requestProps),
+                                },
+                                {
+                                    parentInstancesNodePredicate: this.#categoryModelClass,
+                                    definitions: async (requestProps) => this.createGeometricModel3dChildrenQuery(requestProps),
+                                },
+                            ]
+                            : []),
+                        ...(this.#hierarchyConfig.hideSubCategories && !this.#hierarchyConfig.showElements
+                            ? []
+                            : [
+                                {
+                                    parentInstancesNodePredicate: this.#categoryClass,
+                                    definitions: async (requestProps) => this.createCategoryChildrenQuery(requestProps),
+                                },
+                            ]),
+                        ...(isDefinitionContainerSupported
+                            ? [
+                                {
+                                    parentInstancesNodePredicate: CLASS_NAME_DefinitionContainer,
+                                    definitions: async (requestProps) => this.createDefinitionContainersAndCategoriesQuery(requestProps),
+                                },
+                            ]
+                            : []),
+                    ],
+                },
+            });
+        })();
+        return this.#impl;
     }
     async defineHierarchyLevel(props) {
-        return this._impl.defineHierarchyLevel(props);
+        return (await this.getHierarchyDefinition()).defineHierarchyLevel(props);
     }
-    async createRootHierarchyLevelDefinition(props) {
-        const { categoryClass, categoryElementClass } = getClassesByView(props.viewType);
-        const instanceFilterClauses = await this._selectQueryFactory.createFilterClauses({
-            filter: props.instanceFilter,
-            contentClass: { fullName: categoryClass, alias: "this" },
+    async createISubModeledElementChildrenQuery({ parentNodeInstanceIds: elementIds, }) {
+        // note: we do not apply hierarchy level filtering on this hierarchy level, because it's always
+        // hidden - the filter will get applied on the child hierarchy levels
+        return [
+            {
+                fullClassName: this.#categoryModelClass,
+                query: {
+                    ecsql: `
+            SELECT
+              ${await this.#selectQueryFactory.createSelectClause({
+                        ecClassId: { selector: "this.ECClassId" },
+                        ecInstanceId: { selector: "this.ECInstanceId" },
+                        nodeLabel: "", // doesn't matter - the node is always hidden
+                        hideNodeInHierarchy: true,
+                        hasChildren: true,
+                        extendedData: {
+                            isModel: true,
+                        },
+                    })}
+            FROM ${this.#categoryModelClass} this
+            WHERE
+              this.ModeledElement.Id IN (${elementIds.map(() => "?").join(",")})
+              AND NOT this.IsPrivate
+              AND this.ECInstanceId IN (SELECT Model.Id FROM ${this.#categoryElementClass})
+          `,
+                    bindings: [...elementIds.map((id) => ({ type: "id", value: id }))],
+                },
+            },
+        ];
+    }
+    async createGeometricModel3dChildrenQuery({ parentNodeInstanceIds: modelIds, instanceFilter, }) {
+        const instanceFilterClauses = await this.#selectQueryFactory.createFilterClauses({
+            filter: instanceFilter,
+            contentClass: { fullName: this.#categoryClass, alias: "this" },
         });
         return [
             {
-                fullClassName: categoryClass,
+                fullClassName: this.#categoryClass,
+                query: {
+                    ecsql: `
+          SELECT
+            ${await this.#selectQueryFactory.createSelectClause({
+                        ecClassId: { selector: "this.ECClassId" },
+                        ecInstanceId: { selector: "this.ECInstanceId" },
+                        nodeLabel: {
+                            selector: await this.#nodeLabelSelectClauseFactory.createSelectClause({
+                                classAlias: "this",
+                                className: this.#categoryClass,
+                            }),
+                        },
+                        grouping: { byLabel: { action: "merge", groupId: "category" } },
+                        hasChildren: true,
+                        extendedData: {
+                            imageId: "icon-layers",
+                            isCategory: true,
+                            modelIds: { selector: createIdsSelector(modelIds) },
+                            isCategoryOfSubModel: true,
+                        },
+                        supportsFiltering: true,
+                    })}
+          FROM ${instanceFilterClauses.from} this
+          ${instanceFilterClauses.joins}
+          WHERE
+            EXISTS (
+              SELECT 1
+              FROM ${this.#categoryElementClass} element
+              WHERE
+                element.Model.Id IN (${modelIds.join(",")})
+                AND element.Category.Id = +this.ECInstanceId
+                AND element.Parent.Id IS NULL
+            )
+            ${instanceFilterClauses.where ? `AND ${instanceFilterClauses.where}` : ""}
+        `,
+                },
+            },
+        ];
+    }
+    async createDefinitionContainersAndCategoriesQuery(props) {
+        const { parentNodeInstanceIds, instanceFilter } = props;
+        const { definitionContainers, categories } = await firstValueFrom(parentNodeInstanceIds === undefined
+            ? this.#idsCache.getRootDefinitionContainersAndCategories({ includeEmpty: this.#hierarchyConfig.showEmptyCategories })
+            : this.#idsCache.getDirectChildDefinitionContainersAndCategories({
+                parentDefinitionContainerIds: parentNodeInstanceIds,
+                includeEmpty: this.#hierarchyConfig.showEmptyCategories,
+            }));
+        const hierarchyDefinition = new Array();
+        if (categories.length > 0) {
+            hierarchyDefinition.push(...(await this.createCategoriesQuery({ categories, instanceFilter })));
+        }
+        if (definitionContainers.length > 0) {
+            hierarchyDefinition.push(...(await this.createDefinitionContainersQuery({ definitionContainerIds: definitionContainers, instanceFilter })));
+        }
+        return hierarchyDefinition;
+    }
+    async createDefinitionContainersQuery({ definitionContainerIds, instanceFilter, }) {
+        const instanceFilterClauses = await this.#selectQueryFactory.createFilterClauses({
+            filter: instanceFilter,
+            contentClass: { fullName: CLASS_NAME_DefinitionContainer, alias: "this" },
+        });
+        return [
+            {
+                fullClassName: CLASS_NAME_DefinitionContainer,
                 query: {
                     ecsql: `
             SELECT
-              ${await this._selectQueryFactory.createSelectClause({
+              ${await this.#selectQueryFactory.createSelectClause({
                         ecClassId: { selector: ECSql.createRawPropertyValueSelector("this", "ECClassId") },
                         ecInstanceId: { selector: "this.ECInstanceId" },
                         nodeLabel: {
-                            selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
+                            selector: await this.#nodeLabelSelectClauseFactory.createSelectClause({
                                 classAlias: "this",
-                                className: categoryClass,
+                                className: CLASS_NAME_DefinitionContainer,
                             }),
                         },
-                        hasChildren: {
-                            selector: `
-                    IFNULL((
-                      SELECT 1
-                      FROM (
-                        SELECT COUNT(1) AS ChildCount
-                        FROM BisCore.SubCategory sc
-                        WHERE sc.Parent.Id = this.ECInstanceId
-                      )
-                      WHERE ChildCount > 1
-                    ), 0)
-                  `,
+                        extendedData: {
+                            isDefinitionContainer: true,
+                            imageId: "icon-definition-container",
+                        },
+                        hasChildren: true,
+                        supportsFiltering: true,
+                    })}
+            FROM
+              ${instanceFilterClauses.from} this
+              ${instanceFilterClauses.joins}
+            WHERE
+              this.ECInstanceId IN (${definitionContainerIds.join(", ")})
+              ${instanceFilterClauses.where ? `AND ${instanceFilterClauses.where}` : ""}
+          `,
+                },
+            },
+        ];
+    }
+    async createCategoriesQuery({ categories, instanceFilter, }) {
+        const instanceFilterClauses = await this.#selectQueryFactory.createFilterClauses({
+            filter: instanceFilter,
+            contentClass: { fullName: this.#categoryClass, alias: "this" },
+        });
+        const categoriesWithMultipleSubCategories = categories
+            .filter((categoryInfo) => categoryInfo.subCategoryChildCount > 1)
+            .map((categoryInfo) => categoryInfo.id);
+        const hasChildrenSelector = () => {
+            const conditions = new Array();
+            if (!this.#hierarchyConfig.hideSubCategories && categoriesWithMultipleSubCategories.length > 0) {
+                conditions.push(`this.ECInstanceId IN (${categoriesWithMultipleSubCategories.join(",")})`);
+            }
+            if (this.#hierarchyConfig.showElements) {
+                conditions.push(`
+          this.ECInstanceId IN (
+            SELECT e.Category.Id
+            FROM ${this.#categoryElementClass} e
+            WHERE
+              e.Parent.Id IS NULL
+              AND e.ECInstanceId NOT IN (SELECT m.ECInstanceId FROM ${this.#categoryModelClass} m)
+          )`);
+            }
+            return conditions.length > 0
+                ? {
+                    selector: `IIF(${conditions.join(" OR ")}, 1, 0)`,
+                }
+                : false;
+        };
+        return [
+            {
+                fullClassName: this.#categoryClass,
+                query: {
+                    ecsql: `
+            SELECT
+              ${await this.#selectQueryFactory.createSelectClause({
+                        ecClassId: { selector: ECSql.createRawPropertyValueSelector("this", "ECClassId") },
+                        ecInstanceId: { selector: "this.ECInstanceId" },
+                        nodeLabel: {
+                            selector: await this.#nodeLabelSelectClauseFactory.createSelectClause({
+                                classAlias: "this",
+                                className: this.#categoryClass,
+                            }),
                         },
+                        hasChildren: hasChildrenSelector(),
                         extendedData: {
                             description: { selector: "this.Description" },
+                            isCategory: true,
+                            imageId: "icon-layers",
+                            hasSubCategories: categoriesWithMultipleSubCategories.length > 0
+                                ? { selector: `IIF(this.ECInstanceId IN (${categoriesWithMultipleSubCategories.join(",")}), true, false) ` }
+                                : false,
                         },
                         supportsFiltering: true,
                     })}
-            FROM ${instanceFilterClauses.from} this
-            ${instanceFilterClauses.joins}
-            JOIN BisCore.Model m ON m.ECInstanceId = this.Model.Id
+            FROM
+              ${instanceFilterClauses.from} this
+              ${instanceFilterClauses.joins}
             WHERE
-              NOT this.IsPrivate
-              AND (NOT m.IsPrivate OR m.ECClassId IS (BisCore.DictionaryModel))
-              AND EXISTS (SELECT 1 FROM ${categoryElementClass} e WHERE e.Category.Id = this.ECInstanceId)
+              this.ECInstanceId IN (${categories.map((category) => category.id).join(", ")})
               ${instanceFilterClauses.where ? `AND ${instanceFilterClauses.where}` : ""}
           `,
                 },
             },
         ];
     }
-    async createSubcategoryQuery({ parentNodeInstanceIds: elementIds, instanceFilter, }) {
-        const instanceFilterClauses = await this._selectQueryFactory.createFilterClauses({
+    async createCategoryChildrenQuery(props) {
+        return (await Promise.all([
+            ...(!this.#hierarchyConfig.hideSubCategories && props.parentNode.extendedData?.hasSubCategories ? [this.createSubCategoriesQuery(props)] : []),
+            ...(this.#hierarchyConfig.showElements ? [this.createCategoryElementsQuery(props)] : []),
+        ])).reduce((acc, levelDefinition) => acc.concat(levelDefinition), new Array());
+    }
+    async createSubCategoriesQuery({ parentNodeInstanceIds: categoryIds, instanceFilter, }) {
+        const instanceFilterClauses = await this.#selectQueryFactory.createFilterClauses({
             filter: instanceFilter,
-            contentClass: { fullName: "BisCore.SubCategory", alias: "this" },
+            contentClass: { fullName: CLASS_NAME_SubCategory, alias: "this" },
         });
         return [
             {
-                fullClassName: "BisCore.SubCategory",
+                fullClassName: CLASS_NAME_SubCategory,
                 query: {
                     ecsql: `
             SELECT
-              ${await this._selectQueryFactory.createSelectClause({
+              ${await this.#selectQueryFactory.createSelectClause({
                         ecClassId: { selector: "this.ECClassId" },
                         ecInstanceId: { selector: "this.ECInstanceId" },
                         nodeLabel: {
-                            selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
+                            selector: await this.#nodeLabelSelectClauseFactory.createSelectClause({
                                 classAlias: "this",
-                                className: "BisCore.SubCategory",
+                                className: CLASS_NAME_SubCategory,
                             }),
                         },
                         extendedData: {
                             categoryId: { selector: "printf('0x%x', this.Parent.Id)" },
+                            isSubCategory: true,
+                            imageId: "icon-layers-isolate",
                         },
                         supportsFiltering: false,
                     })}
             FROM ${instanceFilterClauses.from} this
             ${instanceFilterClauses.joins}
             WHERE
-              NOT this.IsPrivate AND this.Parent.Id IN (${elementIds.map(() => "?").join(",")})
+              NOT this.IsPrivate AND this.Parent.Id IN (${categoryIds.join(",")})
+              ${instanceFilterClauses.where ? `AND ${instanceFilterClauses.where}` : ""}
+          `,
+                },
+            },
+        ];
+    }
+    async createCategoryElementsQuery({ parentNodeInstanceIds: categoryIds, instanceFilter, parentNode, }) {
+        const instanceFilterClauses = await this.#selectQueryFactory.createFilterClauses({
+            filter: instanceFilter,
+            contentClass: { fullName: this.#categoryElementClass, alias: "this" },
+        });
+        const modelIds = parentNode.extendedData?.isCategoryOfSubModel
+            ? parseIdsSelectorResult(parentNode.extendedData?.modelIds)
+            : [...getDistinctMapValues(await firstValueFrom(this.#idsCache.getCategoriesElementModels(categoryIds)))];
+        if (modelIds.length === 0) {
+            return [];
+        }
+        const modeledElements = await firstValueFrom(from(modelIds).pipe(mergeMap((modelId) => this.#idsCache.getCategoriesModeledElements(modelId, categoryIds)), reduce((acc, foundModeledElements) => {
+            return acc.concat(foundModeledElements);
+        }, new Array())));
+        return [
+            {
+                fullClassName: this.#categoryElementClass,
+                query: {
+                    ecsql: `
+            SELECT
+            ${await this.#selectQueryFactory.createSelectClause({
+                        ecClassId: { selector: "this.ECClassId" },
+                        ecInstanceId: { selector: "this.ECInstanceId" },
+                        nodeLabel: {
+                            selector: await this.#nodeLabelSelectClauseFactory.createSelectClause({
+                                classAlias: "this",
+                                className: this.#categoryElementClass,
+                            }),
+                        },
+                        hasChildren: {
+                            selector: `
+                  IIF(
+                    ${modeledElements.length ? `this.ECInstanceId IN (${modeledElements.join(",")})` : `FALSE`},
+                    1,
+                    IFNULL((
+                      SELECT 1
+                      FROM ${this.#categoryElementClass} ce
+                      WHERE ce.Parent.Id = this.ECInstanceId
+                      LIMIT 1
+                    ), 0)
+                  )
+                `,
+                        },
+                        grouping: {
+                            byClass: true,
+                        },
+                        extendedData: {
+                            modelId: { selector: "IdToHex(this.Model.Id)" },
+                            categoryId: { selector: "IdToHex(this.Category.Id)" },
+                            imageId: "icon-item",
+                            isElement: true,
+                        },
+                        supportsFiltering: true,
+                    })}
+          FROM ${instanceFilterClauses.from} this
+          ${parentNode.extendedData?.isCategoryOfSubModel ? "" : `JOIN ${CLASS_NAME_InformationPartitionElement} ipe ON ipe.ECInstanceId = this.Model.Id`}
+          ${instanceFilterClauses.joins}
+          WHERE
+            this.Category.Id IN (${categoryIds.join(",")})
+            AND this.Model.Id IN (${modelIds.join(",")})
+            AND this.Parent.Id IS NULL
+            ${instanceFilterClauses.where ? `AND ${instanceFilterClauses.where}` : ""}
+          `,
+                },
+            },
+        ];
+    }
+    async createElementChildrenQuery({ parentNodeInstanceIds: elementIds, instanceFilter, }) {
+        const instanceFilterClauses = await this.#selectQueryFactory.createFilterClauses({
+            filter: instanceFilter,
+            contentClass: { fullName: this.#categoryElementClass, alias: "this" },
+        });
+        return [
+            {
+                fullClassName: this.#categoryElementClass,
+                query: {
+                    ecsql: `
+            SELECT
+              ${await this.#selectQueryFactory.createSelectClause({
+                        ecClassId: { selector: "this.ECClassId" },
+                        ecInstanceId: { selector: "this.ECInstanceId" },
+                        nodeLabel: {
+                            selector: await this.#nodeLabelSelectClauseFactory.createSelectClause({
+                                classAlias: "this",
+                                className: this.#categoryElementClass,
+                            }),
+                        },
+                        hasChildren: {
+                            selector: `
+                    IFNULL((
+                      SELECT 1
+                      FROM ${this.#categoryElementClass} ce
+                      JOIN ${CLASS_NAME_Model} m ON ce.Model.Id = m.ECInstanceId
+                      WHERE ce.Parent.Id = this.ECInstanceId OR (ce.Model.Id = this.ECInstanceId AND m.IsPrivate = false)
+                      LIMIT 1
+                    ), 0)
+                  `,
+                        },
+                        grouping: {
+                            byClass: true,
+                        },
+                        extendedData: {
+                            modelId: { selector: "IdToHex(this.Model.Id)" },
+                            categoryId: { selector: "IdToHex(this.Category.Id)" },
+                            imageId: "icon-item",
+                            isElement: true,
+                        },
+                        supportsFiltering: true,
+                    })}
+            FROM ${instanceFilterClauses.from} this
+            ${instanceFilterClauses.joins}
+            WHERE
+              this.Parent.Id IN (${elementIds.join(",")})
               ${instanceFilterClauses.where ? `AND ${instanceFilterClauses.where}` : ""}
           `,
-                    bindings: elementIds.map((id) => ({ type: "id", value: id })),
                 },
             },
         ];
     }
     static async createInstanceKeyPaths(props) {
         const labelsFactory = createBisInstanceLabelSelectClauseFactory({ classHierarchyInspector: props.imodelAccess });
-        return createInstanceKeyPathsFromInstanceLabel({ ...props, labelsFactory });
+        return createInstanceKeyPathsFromInstanceLabel({
+            ...props,
+            labelsFactory,
+            componentId: props.componentId ?? Guid.createValue(),
+            componentName: this.#componentName,
+        });
     }
 }
-function getClassesByView(viewType) {
-    return viewType === "2d"
-        ? { categoryClass: "BisCore.DrawingCategory", categoryElementClass: "BisCore:GeometricElement2d" }
-        : { categoryClass: "BisCore.SpatialCategory", categoryElementClass: "BisCore:GeometricElement3d" };
-}
 async function createInstanceKeyPathsFromInstanceLabel(props) {
-    const { categoryClass, categoryElementClass } = getClassesByView(props.viewType);
-    const adjustedLabel = props.label.replace(/[%_\\]/g, "\\$&");
-    const reader = props.imodelAccess.createQueryReader({
-        ctes: [
-            `RootCategoriesWithLabels(ClassName, ECInstanceId, ChildCount, DisplayLabel) as (
+    const { idsCache, abortSignal, label, viewType, labelsFactory, limit, hierarchyConfig, imodelAccess, componentId, componentName } = props;
+    const { categoryClass, elementClass } = getClassesByView(viewType);
+    const adjustedLabel = label.replace(/[%_\\]/g, "\\$&");
+    const CATEGORIES_WITH_LABELS_CTE = "CategoriesWithLabels";
+    const ELEMENTS_WITH_LABELS_CTE = "ElementsWithLabels";
+    const SUBCATEGORIES_WITH_LABELS_CTE = "SubCategoriesWithLabels";
+    const DEFINITION_CONTAINERS_WITH_LABELS_CTE = "DefinitionContainersWithLabels";
+    return lastValueFrom(idsCache
+        .getAllDefinitionContainersAndCategories({
+        includeEmpty: props.hierarchyConfig.showEmptyCategories,
+    })
+        .pipe(mergeMap(async ({ definitionContainers, categories }) => {
+        if (categories.length === 0) {
+            return undefined;
+        }
+        const [categoryLabelSelectClause, subCategoryLabelSelectClause, elementLabelSelectClause, definitionContainerLabelSelectClause] = await Promise.all([categoryClass, CLASS_NAME_SubCategory, elementClass, ...(definitionContainers.length > 0 ? [CLASS_NAME_DefinitionContainer] : [])].map(async (className) => labelsFactory.createSelectClause({ classAlias: "this", className })));
+        const ctes = [
+            `${CATEGORIES_WITH_LABELS_CTE}(ClassName, ECInstanceId, ChildCount, DisplayLabel) AS (
+            SELECT
+              'c',
+              this.ECInstanceId,
+              COUNT(sc.ECInstanceId),
+              ${categoryLabelSelectClause}
+            FROM
+              ${categoryClass} this
+              JOIN ${CLASS_NAME_SubCategory} sc ON sc.Parent.Id = this.ECInstanceId
+            WHERE
+              this.ECInstanceId IN (${categories.join(", ")})
+              GROUP BY this.ECInstanceId
+          )`,
+            ...(hierarchyConfig.showElements
+                ? [
+                    `${ELEMENTS_WITH_LABELS_CTE}(ClassName, ECInstanceId, ParentId, DisplayLabel) AS (
+                  SELECT
+                    'e',
+                    this.ECInstanceId,
+                    this.Parent.Id,
+                    ${elementLabelSelectClause}
+                  FROM
+                    ${elementClass} this
+                    JOIN ${CLASS_NAME_Model} m ON this.Model.Id = m.ECInstanceId
+                  WHERE
+                    NOT m.IsPrivate
+                    AND this.Category.Id IN (${categories.join(", ")})
+                )`,
+                ]
+                : []),
+            ...(hierarchyConfig.hideSubCategories
+                ? []
+                : [
+                    `${SUBCATEGORIES_WITH_LABELS_CTE}(ClassName, ECInstanceId, ParentId, DisplayLabel) AS (
+                SELECT
+                  'sc',
+                  this.ECInstanceId,
+                  this.Parent.Id,
+                  ${subCategoryLabelSelectClause}
+                FROM
+                  ${CLASS_NAME_SubCategory} this
+                WHERE
+                  NOT this.IsPrivate
+                  AND this.Parent.Id IN (${categories.join(", ")})
+              )`,
+                ]),
+            ...(definitionContainers.length > 0
+                ? [
+                    `${DEFINITION_CONTAINERS_WITH_LABELS_CTE}(ClassName, ECInstanceId, DisplayLabel) AS (
+                SELECT
+                  'dc',
+                  this.ECInstanceId,
+                  ${definitionContainerLabelSelectClause}
+                FROM
+                  ${CLASS_NAME_DefinitionContainer} this
+                WHERE
+                  this.ECInstanceId IN (${definitionContainers.join(", ")})
+              )`,
+                ]
+                : []),
+        ];
+        const ecsql = `
+        SELECT * FROM (
           SELECT
-            ec_classname(this.ECClassId, 's.c'),
-            this.ECInstanceId,
-            COUNT(sc.ECInstanceId),
-            ${await props.labelsFactory.createSelectClause({
-                classAlias: "this",
-                className: categoryClass,
-            })}
-          FROM ${categoryClass} this
-          JOIN BisCore.Model m ON m.ECInstanceId = this.Model.Id
-          JOIN BisCore.SubCategory sc ON sc.Parent.Id = this.ECInstanceId
+            c.ClassName AS ClassName,
+            c.ECInstanceId AS ECInstanceId
+          FROM
+            ${CATEGORIES_WITH_LABELS_CTE} c
           WHERE
-            NOT this.IsPrivate
-            AND (NOT m.IsPrivate OR m.ECClassId IS (BisCore.DictionaryModel))
-            AND EXISTS (SELECT 1 FROM ${categoryElementClass} e WHERE e.Category.Id = this.ECInstanceId)
-          GROUP BY this.ECInstanceId
-        )`,
-            `SubCategoriesWithLabels(ClassName, ECInstanceId, ParentId, DisplayLabel) as (
-          SELECT
-            ec_classname(this.ECClassId, 's.c'),
-            this.ECInstanceId,
-            this.Parent.Id,
-            ${await props.labelsFactory.createSelectClause({
-                classAlias: "this",
-                className: "BisCore.SubCategory",
-            })}
-          FROM BisCore.SubCategory this
-          WHERE NOT this.IsPrivate
-        )`,
-        ],
-        ecsql: `
-      SELECT * FROM (
+            c.DisplayLabel LIKE '%' || ? || '%' ESCAPE '\\'
+          ${hierarchyConfig.showElements
+            ? `
+                UNION ALL
+                SELECT
+                  e.ClassName AS ClassName,
+                  e.ECInstanceId AS ECInstanceId
+                FROM
+                  ${ELEMENTS_WITH_LABELS_CTE} e
+                WHERE
+                  e.DisplayLabel LIKE '%' || ? || '%' ESCAPE '\\'
+              `
+            : ""}
+          ${hierarchyConfig.hideSubCategories
+            ? ""
+            : `
+                UNION ALL
+                SELECT
+                  sc.ClassName AS ClassName,
+                  sc.ECInstanceId AS ECInstanceId
+                FROM
+                  ${CATEGORIES_WITH_LABELS_CTE} c
+                  JOIN ${SUBCATEGORIES_WITH_LABELS_CTE} sc ON sc.ParentId = c.ECInstanceId
+                WHERE
+                  c.ChildCount > 1
+                  AND sc.DisplayLabel LIKE '%' || ? || '%' ESCAPE '\\'
+              `}
+          ${definitionContainers.length > 0
+            ? `
+                UNION ALL
+                SELECT
+                  dc.ClassName AS ClassName,
+                  dc.ECInstanceId AS ECInstanceId
+                FROM
+                  ${DEFINITION_CONTAINERS_WITH_LABELS_CTE} dc
+                WHERE
+                  dc.DisplayLabel LIKE '%' || ? || '%' ESCAPE '\\'
+              `
+            : ""}
+        )
+        ${limit === undefined ? `LIMIT ${MAX_FILTERING_INSTANCE_KEY_COUNT + 1}` : limit !== "unbounded" ? `LIMIT ${limit}` : ""}
+      `;
+        const bindings = [
+            { type: "string", value: adjustedLabel },
+            ...(hierarchyConfig.showElements ? [{ type: "string", value: adjustedLabel }] : []),
+            ...(hierarchyConfig.hideSubCategories ? [] : [{ type: "string", value: adjustedLabel }]),
+            ...(definitionContainers.length > 0 ? [{ type: "string", value: adjustedLabel }] : []),
+        ];
+        return { ctes, ecsql, bindings };
+    }), mergeMap((queryProps) => {
+        if (!queryProps) {
+            return EMPTY;
+        }
+        return imodelAccess.createQueryReader(queryProps, { restartToken: `${componentName}/${componentId}/filter-by-label`, limit });
+    }), releaseMainThreadOnItemsCount(1000), map((row) => {
+        let className;
+        switch (row.ClassName) {
+            case "c":
+                className = categoryClass;
+                break;
+            case "sc":
+                className = CLASS_NAME_SubCategory;
+                break;
+            case "e":
+                className = elementClass;
+                break;
+            default:
+                className = CLASS_NAME_DefinitionContainer;
+                break;
+        }
+        return {
+            className,
+            id: row.ECInstanceId,
+        };
+    }), toArray(), mergeMap((targetItems) => createInstanceKeyPathsFromTargetItems({ ...props, targetItems })), toArray(), abortSignal ? takeUntil(fromEvent(abortSignal, "abort")) : identity, defaultIfEmpty([])));
+}
+function createInstanceKeyPathsFromTargetItems({ targetItems, imodelAccess, viewType, hierarchyConfig, idsCache, limit, componentId, componentName, }) {
+    if (limit !== "unbounded" && targetItems.length > (limit ?? MAX_FILTERING_INSTANCE_KEY_COUNT)) {
+        throw new FilterLimitExceededError(limit ?? MAX_FILTERING_INSTANCE_KEY_COUNT);
+    }
+    const { categoryClass } = getClassesByView(viewType);
+    return from(targetItems).pipe(releaseMainThreadOnItemsCount(500), reduce((acc, { id, className }) => {
+        if (className === categoryClass) {
+            acc.categoryIds.push(id);
+            return acc;
+        }
+        if (className === CLASS_NAME_DefinitionContainer) {
+            acc.definitionContainerIds.push(id);
+            return acc;
+        }
+        if (className === CLASS_NAME_SubCategory) {
+            if (hierarchyConfig.hideSubCategories) {
+                return acc;
+            }
+            acc.subCategoryIds.push(id);
+            return acc;
+        }
+        if (!hierarchyConfig.showElements) {
+            return acc;
+        }
+        acc.elementIds.push(id);
+        return acc;
+    }, {
+        definitionContainerIds: new Array(),
+        categoryIds: new Array(),
+        subCategoryIds: new Array(),
+        elementIds: new Array(),
+    }), mergeMap((ids) => {
+        const elementsLength = ids.elementIds.length;
+        return merge(from(ids.definitionContainerIds).pipe(mergeMap((id) => idsCache.getInstanceKeyPaths({ definitionContainerId: id })), map((path) => ({ path, options: { reveal: true } }))), from(ids.categoryIds).pipe(mergeMap((id) => idsCache.getInstanceKeyPaths({ categoryId: id })), map((path) => ({ path, options: { reveal: true } }))), from(ids.subCategoryIds).pipe(mergeMap((id) => idsCache.getInstanceKeyPaths({ subCategoryId: id })), map((path) => ({ path, options: { reveal: true } }))), from(ids.elementIds).pipe(bufferCount(getOptimalBatchSize({ totalSize: elementsLength, maximumBatchSize: 5000 })), releaseMainThreadOnItemsCount(1), mergeMap((block, chunkIndex) => createGeometricElementInstanceKeyPaths({
+            imodelAccess,
+            idsCache,
+            hierarchyConfig,
+            viewType,
+            targetItems: block,
+            chunkIndex,
+            componentId,
+            componentName,
+        }), 10)));
+    }));
+}
+function createGeometricElementInstanceKeyPaths(props) {
+    const separator = ";";
+    const { targetItems, chunkIndex, componentId, componentName, hierarchyConfig, idsCache, imodelAccess, viewType } = props;
+    const { categoryClass, elementClass, modelClass } = getClassesByView(viewType);
+    if (targetItems.length === 0 || !hierarchyConfig.showElements) {
+        return EMPTY;
+    }
+    return defer(() => {
+        const ctes = [
+            `CategoriesElementsHierarchy(ECInstanceId, ParentId, ModelId, Path) AS (
         SELECT
-          c.ClassName AS CategoryClass,
-          c.ECInstanceId AS CategoryId,
-          sc.ClassName AS SubcategoryClass,
-          sc.ECInstanceId AS SubcategoryId
-        FROM RootCategoriesWithLabels c
-        JOIN SubCategoriesWithLabels sc ON sc.ParentId = c.ECInstanceId
-        WHERE c.ChildCount > 1 AND sc.DisplayLabel LIKE '%' || ? || '%' ESCAPE '\\'
+          e.ECInstanceId,
+          e.Parent.Id,
+          e.Model.Id,
+          IIF(e.Parent.Id IS NULL,
+            'm${separator}' || CAST(IdToHex([m].[ECInstanceId]) AS TEXT) || '${separator}c${separator}' || CAST(IdToHex([c].[ECInstanceId]) AS TEXT) || '${separator}e${separator}' || CAST(IdToHex([e].[ECInstanceId]) AS TEXT),
+            'e${separator}' || CAST(IdToHex([e].[ECInstanceId]) AS TEXT)
+          )
+        FROM ${elementClass} e
+        LEFT JOIN ${modelClass} m ON (e.Parent.Id IS NULL AND m.ECInstanceId = e.Model.Id)
+        LEFT JOIN ${categoryClass} c ON (e.Parent.Id IS NULL AND c.ECInstanceId = e.Category.Id)
+        WHERE e.ECInstanceId IN (${targetItems.join(",")})
+
         UNION ALL
+
         SELECT
-          c.ClassName AS CategoryClass,
-          c.ECInstanceId AS CategoryId,
-          CAST(NULL AS TEXT) AS SubcategoryClass,
-          CAST(NULL AS TEXT) AS SubcategoryId
-        FROM RootCategoriesWithLabels c
-        WHERE c.DisplayLabel LIKE '%' || ? || '%' ESCAPE '\\'
-        )
-        LIMIT ${MAX_FILTERING_INSTANCE_KEY_COUNT + 1}
-      `,
-        bindings: [
-            { type: "string", value: adjustedLabel },
-            { type: "string", value: adjustedLabel },
-        ],
-    }, { restartToken: "tree-widget/categories-tree/filter-by-label-query" });
-    const paths = [];
-    for await (const row of reader) {
-        const path = { path: [{ className: row.CategoryClass, id: row.CategoryId }], options: { autoExpand: true } };
-        row.SubcategoryId && path.path.push({ className: row.SubcategoryClass, id: row.SubcategoryId });
-        paths.push(path);
-    }
-    if (paths.length > MAX_FILTERING_INSTANCE_KEY_COUNT) {
-        throw new FilterLimitExceededError(MAX_FILTERING_INSTANCE_KEY_COUNT);
-    }
-    return paths;
+          pe.ECInstanceId,
+          pe.Parent.Id,
+          pe.Model.Id,
+          IIF(pe.Parent.Id IS NULL,
+            'm${separator}' || CAST(IdToHex([m].[ECInstanceId]) AS TEXT) || '${separator}c${separator}' || CAST(IdToHex([c].[ECInstanceId]) AS TEXT) || '${separator}e${separator}' || CAST(IdToHex([pe].[ECInstanceId]) AS TEXT) || '${separator}' || ce.Path,
+            'e${separator}' || CAST(IdToHex([pe].[ECInstanceId]) AS TEXT) || '${separator}' || ce.Path
+          )
+        FROM CategoriesElementsHierarchy ce
+        JOIN ${elementClass} pe ON (pe.ECInstanceId = ce.ParentId OR pe.ECInstanceId = ce.ModelId AND ce.ParentId IS NULL)
+        LEFT JOIN ${modelClass} m ON (pe.Parent.Id IS NULL AND m.ECInstanceId = pe.Model.Id)
+        LEFT JOIN ${categoryClass} c ON (pe.Parent.Id IS NULL AND c.ECInstanceId = pe.Category.Id)
+      )`,
+        ];
+        const ecsql = `
+      SELECT mce.Path
+      FROM CategoriesElementsHierarchy mce
+      WHERE mce.ParentId IS NULL
+    `;
+        return imodelAccess.createQueryReader({ ctes, ecsql }, { rowFormat: "Indexes", limit: "unbounded", restartToken: `${componentName}/${componentId}/element-paths/${chunkIndex}` });
+    }).pipe(releaseMainThreadOnItemsCount(300), map((row) => parseQueryRow(row, separator, elementClass, categoryClass, modelClass)), mergeMap((elementHierarchyPath) => forkJoin({ elementHierarchyPath: of(elementHierarchyPath), pathToCategory: idsCache.getInstanceKeyPaths({ categoryId: elementHierarchyPath[0].id }) })), map(({ elementHierarchyPath, pathToCategory }) => {
+        pathToCategory.pop(); // category is already included in the element hierarchy path
+        const path = [...pathToCategory, ...elementHierarchyPath];
+        return { path, options: { reveal: true } };
+    }));
+}
+function parseQueryRow(row, separator, elementClassName, categoryClassName, modelClassName) {
+    const rowElements = row[0].split(separator);
+    const path = new Array();
+    for (let i = 0; i < rowElements.length; i += 2) {
+        switch (rowElements[i]) {
+            case "e":
+                path.push({ className: elementClassName, id: rowElements[i + 1] });
+                break;
+            case "c":
+                path.push({ className: categoryClassName, id: rowElements[i + 1] });
+                break;
+            case "m":
+                // Ignore first model since it isn't in hierarchy
+                if (i === 0) {
+                    break;
+                }
+                path.push({ className: modelClassName, id: rowElements[i + 1] });
+                break;
+        }
+    }
+    return path;
 }
 //# sourceMappingURL=CategoriesTreeDefinition.js.map