@itwin/tree-widget-react 4.0.0-alpha.5 → 4.0.0-alpha.7

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

@@ -2,23 +2,64 @@
  * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
  * See LICENSE.md in the project root for license terms and full copyright notice.
  *--------------------------------------------------------------------------------------------*/
-import { defer, EMPTY, from, lastValueFrom, map, mergeMap, toArray } from "rxjs";
-import { createNodesQueryClauseFactory, createPredicateBasedHierarchyDefinition } from "@itwin/presentation-hierarchies";
+import { bufferCount, defer, firstValueFrom, from, lastValueFrom, map, merge, mergeMap, of, reduce, toArray } from "rxjs";
+import { assert } from "@itwin/core-bentley";
+import { createNodesQueryClauseFactory, createPredicateBasedHierarchyDefinition, ProcessedHierarchyNode } from "@itwin/presentation-hierarchies";
 import { createBisInstanceLabelSelectClauseFactory, ECSql } from "@itwin/presentation-shared";
+import { DEFINITION_CONTAINER_CLASS_NAME, INFORMATION_PARTITION_ELEMENT_CLASS_NAME, MODEL_CLASS_NAME, SUB_CATEGORY_CLASS_NAME, SUB_MODELED_ELEMENT_CLASS_NAME, } from "../common/internal/ClassNameDefinitions.js";
+import { createIdsSelector, getClassesByView, getDistinctMapValues, parseIdsSelectorResult, releaseMainThreadOnItemsCount } from "../common/internal/Utils.js";
 import { FilterLimitExceededError } from "../common/TreeErrors.js";
-import { getClassesByView } from "./internal/CategoriesTreeIdsCache.js";
-import { DEFINITION_CONTAINER_CLASS, DEFINITION_ELEMENT_CLASS, SUB_CATEGORY_CLASS } from "./internal/ClassNameDefinitions.js";
 const MAX_FILTERING_INSTANCE_KEY_COUNT = 100;
+/** @internal */
+export const defaultHierarchyConfiguration = {
+    hideSubCategories: false,
+    showElements: false,
+};
+/** @internal */
 export class CategoriesTreeDefinition {
     constructor(props) {
         this._iModelAccess = props.imodelAccess;
-        this._viewType = props.viewType;
         this._idsCache = props.idsCache;
         this._nodeLabelSelectClauseFactory = createBisInstanceLabelSelectClauseFactory({ classHierarchyInspector: props.imodelAccess });
         this._selectQueryFactory = createNodesQueryClauseFactory({
             imodelAccess: props.imodelAccess,
             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);
+                }
+            });
+            return {
+                ...node,
+                label: node.label,
+                extendedData: {
+                    ...node.extendedData,
+                    // add `categoryId` from the first grouped element
+                    categoryId: node.children[0].extendedData?.categoryId,
+                    modelElementsMap,
+                    // `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 () => {
@@ -26,20 +67,37 @@ export class CategoriesTreeDefinition {
             return createPredicateBasedHierarchyDefinition({
                 classHierarchyInspector: this._iModelAccess,
                 hierarchy: {
-                    rootNodes: async (requestProps) => this.createDefinitionContainersAndCategoriesQuery({ ...requestProps, viewType: this._viewType }),
+                    rootNodes: async (requestProps) => this.createDefinitionContainersAndCategoriesQuery(requestProps),
                     childNodes: [
-                        {
-                            parentInstancesNodePredicate: "BisCore.Category",
-                            definitions: async (requestProps) => this.createSubcategoryQuery(requestProps),
-                        },
+                        ...(this._hierarchyConfig.showElements
+                            ? [
+                                {
+                                    parentInstancesNodePredicate: this._categoryElementClass,
+                                    definitions: async (requestProps) => this.createElementChildrenQuery(requestProps),
+                                },
+                                {
+                                    parentInstancesNodePredicate: SUB_MODELED_ELEMENT_CLASS_NAME,
+                                    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: DEFINITION_CONTAINER_CLASS,
-                                    definitions: async (requestProps) => this.createDefinitionContainersAndCategoriesQuery({
-                                        ...requestProps,
-                                        viewType: this._viewType,
-                                    }),
+                                    parentInstancesNodePredicate: DEFINITION_CONTAINER_CLASS_NAME,
+                                    definitions: async (requestProps) => this.createDefinitionContainersAndCategoriesQuery(requestProps),
                                 },
                             ]
                             : []),
@@ -52,116 +110,215 @@ export class CategoriesTreeDefinition {
     async defineHierarchyLevel(props) {
         return (await this.getHierarchyDefinition()).defineHierarchyLevel(props);
     }
+    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: "",
+                        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: 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, viewType } = props;
+        const { parentNodeInstanceIds, instanceFilter } = props;
         const { definitionContainers, categories } = parentNodeInstanceIds === undefined
             ? await this._idsCache.getRootDefinitionContainersAndCategories()
             : await this._idsCache.getDirectChildDefinitionContainersAndCategories(parentNodeInstanceIds);
-        if (categories.length === 0 && definitionContainers.length === 0) {
-            return [];
+        const hierarchyDefinition = new Array();
+        if (categories.length > 0) {
+            hierarchyDefinition.push(...(await this.createCategoriesQuery({ categories, instanceFilter })));
         }
-        const categoriesWithSingleChild = new Array();
-        const categoriesWithMultipleChildren = new Array();
-        categories.forEach((category) => {
-            if (category.childCount > 1) {
-                categoriesWithMultipleChildren.push(category.id);
-            }
-            else {
-                categoriesWithSingleChild.push(category.id);
-            }
-        });
-        const dataToDetermineHasChildren = categoriesWithSingleChild.length > categoriesWithMultipleChildren.length
-            ? { ids: categoriesWithMultipleChildren, ifTrue: 1, ifFalse: 0 }
-            : { ids: categoriesWithSingleChild, ifTrue: 0, ifFalse: 1 };
-        const { categoryClass } = getClassesByView(viewType);
-        const [categoriesInstanceFilterClauses, definitionContainersInstanceFilterClauses] = await Promise.all([categoryClass, ...(definitionContainers.length > 0 ? [DEFINITION_CONTAINER_CLASS] : [])].map(async (className) => this._selectQueryFactory.createFilterClauses({
+        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: className, alias: "this" },
-        })));
-        const definitionContainersQuery = definitionContainers.length > 0
-            ? `
-          SELECT
-            ${await this._selectQueryFactory.createSelectClause({
-                ecClassId: { selector: ECSql.createRawPropertyValueSelector("this", "ECClassId") },
-                ecInstanceId: { selector: "this.ECInstanceId" },
-                nodeLabel: {
-                    selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
-                        classAlias: "this",
-                        className: DEFINITION_CONTAINER_CLASS,
-                    }),
-                },
-                extendedData: {
-                    isDefinitionContainer: true,
-                    imageId: "icon-definition-container",
-                },
-                hasChildren: true,
-                supportsFiltering: true,
-            })}
-          FROM
-            ${definitionContainersInstanceFilterClauses.from} this
-            ${definitionContainersInstanceFilterClauses.joins}
-          WHERE
-            this.ECInstanceId IN (${definitionContainers.join(", ")})
-            ${definitionContainersInstanceFilterClauses.where ? `AND ${definitionContainersInstanceFilterClauses.where}` : ""}
-        `
-            : undefined;
-        const categoriesQuery = categories.length > 0
-            ? `
-          SELECT
+            contentClass: { fullName: DEFINITION_CONTAINER_CLASS_NAME, alias: "this" },
+        });
+        return [
+            {
+                fullClassName: DEFINITION_CONTAINER_CLASS_NAME,
+                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: categoryClass,
-                    }),
-                },
-                ...(dataToDetermineHasChildren.ids.length > 0
-                    ? {
-                        hasChildren: {
-                            selector: `
-                            IIF(this.ECInstanceId IN (${dataToDetermineHasChildren.ids.join(",")}),
-                              ${dataToDetermineHasChildren.ifTrue},
-                              ${dataToDetermineHasChildren.ifFalse}
-                            )
-                          `,
+                        ecClassId: { selector: ECSql.createRawPropertyValueSelector("this", "ECClassId") },
+                        ecInstanceId: { selector: "this.ECInstanceId" },
+                        nodeLabel: {
+                            selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
+                                classAlias: "this",
+                                className: DEFINITION_CONTAINER_CLASS_NAME,
+                            }),
                         },
-                    }
-                    : { hasChildren: !!dataToDetermineHasChildren.ifFalse }),
-                extendedData: {
-                    description: { selector: "this.Description" },
-                    isCategory: true,
-                    imageId: "icon-layers",
-                },
-                supportsFiltering: true,
-            })}
+                        extendedData: {
+                            isDefinitionContainer: true,
+                            imageId: "icon-definition-container",
+                        },
+                        hasChildren: true,
+                        supportsFiltering: true,
+                    })}
             FROM
-              ${categoriesInstanceFilterClauses.from} this
-              ${categoriesInstanceFilterClauses.joins}
+              ${instanceFilterClauses.from} this
+              ${instanceFilterClauses.joins}
             WHERE
-              this.ECInstanceId IN (${categories.map((category) => category.id).join(", ")})
-              ${categoriesInstanceFilterClauses.where ? `AND ${categoriesInstanceFilterClauses.where}` : ""}
-        `
-            : undefined;
-        const queries = [categoriesQuery, definitionContainersQuery].filter((query) => query !== undefined);
+              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: DEFINITION_ELEMENT_CLASS,
+                fullClassName: this._categoryClass,
                 query: {
-                    ecsql: queries.join(" UNION ALL "),
+                    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}
+            WHERE
+              this.ECInstanceId IN (${categories.map((category) => category.id).join(", ")})
+              ${instanceFilterClauses.where ? `AND ${instanceFilterClauses.where}` : ""}
+          `,
                 },
             },
         ];
     }
-    async createSubcategoryQuery({ parentNodeInstanceIds: elementIds, instanceFilter, }) {
+    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: SUB_CATEGORY_CLASS, alias: "this" },
+            contentClass: { fullName: SUB_CATEGORY_CLASS_NAME, alias: "this" },
         });
         return [
             {
-                fullClassName: SUB_CATEGORY_CLASS,
+                fullClassName: SUB_CATEGORY_CLASS_NAME,
                 query: {
                     ecsql: `
             SELECT
@@ -171,7 +328,7 @@ export class CategoriesTreeDefinition {
                         nodeLabel: {
                             selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
                                 classAlias: "this",
-                                className: SUB_CATEGORY_CLASS,
+                                className: SUB_CATEGORY_CLASS_NAME,
                             }),
                         },
                         extendedData: {
@@ -184,30 +341,149 @@ export class CategoriesTreeDefinition {
             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 this._idsCache.getCategoriesElementModels(categoryIds))];
+        if (modelIds.length === 0) {
+            return [];
+        }
+        const modeledElements = await firstValueFrom(from(modelIds).pipe(mergeMap(async (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 ${INFORMATION_PARTITION_ELEMENT_CLASS_NAME} 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 ${MODEL_CLASS_NAME} 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, cache: props.idsCache });
+        return createInstanceKeyPathsFromInstanceLabel({ ...props, labelsFactory });
     }
 }
 async function createInstanceKeyPathsFromInstanceLabel(props) {
-    const { definitionContainers, categories } = await props.cache.getAllDefinitionContainersAndCategories();
+    const { definitionContainers, categories } = await props.idsCache.getAllDefinitionContainersAndCategories();
     if (categories.length === 0) {
         return [];
     }
-    const { categoryClass } = getClassesByView(props.viewType);
+    const { categoryClass, elementClass } = getClassesByView(props.viewType);
     const adjustedLabel = props.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";
-    const [categoryLabelSelectClause, subCategoryLabelSelectClause, definitionContainerLabelSelectClause] = await Promise.all([categoryClass, SUB_CATEGORY_CLASS, ...(definitionContainers.length > 0 ? [DEFINITION_CONTAINER_CLASS] : [])].map(async (className) => props.labelsFactory.createSelectClause({ classAlias: "this", className })));
+    const [categoryLabelSelectClause, subCategoryLabelSelectClause, elementLabelSelectClause, definitionContainerLabelSelectClause] = await Promise.all([categoryClass, SUB_CATEGORY_CLASS_NAME, elementClass, ...(definitionContainers.length > 0 ? [DEFINITION_CONTAINER_CLASS_NAME] : [])].map(async (className) => props.labelsFactory.createSelectClause({ classAlias: "this", className })));
     return lastValueFrom(defer(() => {
         const ctes = [
             `${CATEGORIES_WITH_LABELS_CTE}(ClassName, ECInstanceId, ChildCount, DisplayLabel) AS (
@@ -218,23 +494,44 @@ async function createInstanceKeyPathsFromInstanceLabel(props) {
               ${categoryLabelSelectClause}
             FROM
               ${categoryClass} this
-              JOIN ${SUB_CATEGORY_CLASS} sc ON sc.Parent.Id = this.ECInstanceId
+              JOIN ${SUB_CATEGORY_CLASS_NAME} sc ON sc.Parent.Id = this.ECInstanceId
             WHERE
               this.ECInstanceId IN (${categories.join(", ")})
               GROUP BY this.ECInstanceId
           )`,
-            `${SUBCATEGORIES_WITH_LABELS_CTE}(ClassName, ECInstanceId, ParentId, DisplayLabel) AS (
-            SELECT
-              'sc',
-              this.ECInstanceId,
-              this.Parent.Id,
-              ${subCategoryLabelSelectClause}
-            FROM
-              ${SUB_CATEGORY_CLASS} this
-            WHERE
-              NOT this.IsPrivate
-              AND this.Parent.Id IN (${categories.join(", ")})
-          )`,
+            ...(props.hierarchyConfig.showElements
+                ? [
+                    `${ELEMENTS_WITH_LABELS_CTE}(ClassName, ECInstanceId, ParentId, DisplayLabel) AS (
+                  SELECT
+                    'e',
+                    this.ECInstanceId,
+                    this.Parent.Id,
+                    ${elementLabelSelectClause}
+                  FROM
+                    ${elementClass} this
+                    JOIN ${MODEL_CLASS_NAME} m ON this.Model.Id = m.ECInstanceId
+                  WHERE
+                    NOT m.IsPrivate
+                    AND this.Category.Id IN (${categories.join(", ")})
+                )`,
+                ]
+                : []),
+            ...(props.hierarchyConfig.hideSubCategories
+                ? []
+                : [
+                    `${SUBCATEGORIES_WITH_LABELS_CTE}(ClassName, ECInstanceId, ParentId, DisplayLabel) AS (
+                SELECT
+                  'sc',
+                  this.ECInstanceId,
+                  this.Parent.Id,
+                  ${subCategoryLabelSelectClause}
+                FROM
+                  ${SUB_CATEGORY_CLASS_NAME} this
+                WHERE
+                  NOT this.IsPrivate
+                  AND this.Parent.Id IN (${categories.join(", ")})
+              )`,
+                ]),
             ...(definitionContainers.length > 0
                 ? [
                     `${DEFINITION_CONTAINERS_WITH_LABELS_CTE}(ClassName, ECInstanceId, DisplayLabel) AS (
@@ -243,7 +540,7 @@ async function createInstanceKeyPathsFromInstanceLabel(props) {
                   this.ECInstanceId,
                   ${definitionContainerLabelSelectClause}
                 FROM
-                  ${DEFINITION_CONTAINER_CLASS} this
+                  ${DEFINITION_CONTAINER_CLASS_NAME} this
                 WHERE
                   this.ECInstanceId IN (${definitionContainers.join(", ")})
               )`,
@@ -252,69 +549,190 @@ async function createInstanceKeyPathsFromInstanceLabel(props) {
         ];
         const ecsql = `
         SELECT * FROM (
-            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 '\\'
-
-            UNION ALL
-
-            SELECT
-              c.ClassName AS ClassName,
-              c.ECInstanceId AS ECInstanceId
-            FROM
-              ${CATEGORIES_WITH_LABELS_CTE} c
-            WHERE
-              c.DisplayLabel LIKE '%' || ? || '%' ESCAPE '\\'
-
-            ${definitionContainers.length > 0
+          SELECT
+            c.ClassName AS ClassName,
+            c.ECInstanceId AS ECInstanceId
+          FROM
+            ${CATEGORIES_WITH_LABELS_CTE} c
+          WHERE
+            c.DisplayLabel LIKE '%' || ? || '%' ESCAPE '\\'
+          ${props.hierarchyConfig.showElements
             ? `
-                  UNION ALL
-                  SELECT
-                    dc.ClassName AS ClassName,
-                    dc.ECInstanceId AS ECInstanceId
-                  FROM
-                    ${DEFINITION_CONTAINERS_WITH_LABELS_CTE} dc
-                  WHERE
-                    dc.DisplayLabel LIKE '%' || ? || '%' ESCAPE '\\'
-                `
+                UNION ALL
+                SELECT
+                  e.ClassName AS ClassName,
+                  e.ECInstanceId AS ECInstanceId
+                FROM
+                  ${ELEMENTS_WITH_LABELS_CTE} e
+                WHERE
+                  e.DisplayLabel LIKE '%' || ? || '%' ESCAPE '\\'
+              `
+            : ""}
+          ${props.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 '\\'
+              `
             : ""}
         )
         ${props.limit === undefined ? `LIMIT ${MAX_FILTERING_INSTANCE_KEY_COUNT + 1}` : props.limit !== "unbounded" ? `LIMIT ${props.limit}` : ""}
       `;
         const bindings = [
             { type: "string", value: adjustedLabel },
-            { type: "string", value: adjustedLabel },
+            ...(props.hierarchyConfig.showElements ? [{ type: "string", value: adjustedLabel }] : []),
+            ...(props.hierarchyConfig.hideSubCategories ? [] : [{ type: "string", value: adjustedLabel }]),
             ...(definitionContainers.length > 0 ? [{ type: "string", value: adjustedLabel }] : []),
         ];
         return props.imodelAccess.createQueryReader({ ctes, ecsql, bindings }, { restartToken: "tree-widget/categories-tree/filter-by-label-query", limit: props.limit });
-    }).pipe(map((row) => ({
-        className: row.ClassName === "c" ? categoryClass : row.ClassName === "sc" ? SUB_CATEGORY_CLASS : DEFINITION_CONTAINER_CLASS,
-        id: row.ECInstanceId,
-    })), toArray(), mergeMap((targetItems) => createInstanceKeyPathsFromTargetItems({ ...props, targetItems })), toArray()));
+    }).pipe(map((row) => {
+        let className;
+        switch (row.ClassName) {
+            case "c":
+                className = categoryClass;
+                break;
+            case "sc":
+                className = SUB_CATEGORY_CLASS_NAME;
+                break;
+            case "e":
+                className = elementClass;
+                break;
+            default:
+                className = DEFINITION_CONTAINER_CLASS_NAME;
+                break;
+        }
+        return {
+            className,
+            id: row.ECInstanceId,
+        };
+    }), toArray(), mergeMap((targetItems) => createInstanceKeyPathsFromTargetItems({ ...props, targetItems })), toArray()));
 }
-function createInstanceKeyPathsFromTargetItems(props) {
-    const { limit, targetItems, viewType, idsCache } = props;
+function createInstanceKeyPathsFromTargetItems({ targetItems, imodelAccess, viewType, hierarchyConfig, idsCache, limit, }) {
     if (limit !== "unbounded" && targetItems.length > (limit ?? MAX_FILTERING_INSTANCE_KEY_COUNT)) {
         throw new FilterLimitExceededError(limit ?? MAX_FILTERING_INSTANCE_KEY_COUNT);
     }
-    if (targetItems.length === 0) {
-        return EMPTY;
-    }
     const { categoryClass } = getClassesByView(viewType);
-    return from(targetItems).pipe(mergeMap(async (targetItem) => {
-        if (targetItem.className === SUB_CATEGORY_CLASS) {
-            return { path: await idsCache.getInstanceKeyPaths({ subCategoryId: targetItem.id }), options: { autoExpand: true } };
+    return from(targetItems).pipe(releaseMainThreadOnItemsCount(2000), reduce((acc, { id, className }) => {
+        if (className === categoryClass) {
+            acc.categoryIds.push(id);
+            return acc;
+        }
+        if (className === DEFINITION_CONTAINER_CLASS_NAME) {
+            acc.definitionContainerIds.push(id);
+            return acc;
+        }
+        if (className === SUB_CATEGORY_CLASS_NAME) {
+            if (hierarchyConfig.hideSubCategories) {
+                return acc;
+            }
+            acc.subCategoryIds.push(id);
+            return acc;
         }
-        if (targetItem.className === categoryClass) {
-            return { path: await idsCache.getInstanceKeyPaths({ categoryId: targetItem.id }), options: { autoExpand: true } };
+        if (!hierarchyConfig.showElements) {
+            return acc;
         }
-        return { path: await idsCache.getInstanceKeyPaths({ definitionContainerId: targetItem.id }), options: { autoExpand: true } };
+        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(async (id) => ({ path: await idsCache.getInstanceKeyPaths({ definitionContainerId: id }), options: { autoExpand: true } }))), from(ids.categoryIds).pipe(mergeMap(async (id) => ({ path: await idsCache.getInstanceKeyPaths({ categoryId: id }), options: { autoExpand: true } }))), from(ids.subCategoryIds).pipe(mergeMap(async (id) => ({ path: await idsCache.getInstanceKeyPaths({ subCategoryId: id }), options: { autoExpand: true } }))), from(ids.elementIds).pipe(bufferCount(Math.ceil(elementsLength / Math.ceil(elementsLength / 5000))), releaseMainThreadOnItemsCount(1), mergeMap((block) => createGeometricElementInstanceKeyPaths(imodelAccess, idsCache, hierarchyConfig, viewType, block), 10)));
     }));
 }
+function createGeometricElementInstanceKeyPaths(imodelAccess, idsCache, hierarchyConfig, viewType, targetItems) {
+    const separator = ";";
+    const { categoryClass, elementClass, modelClass } = getClassesByView(viewType);
+    if (targetItems.length === 0 || !hierarchyConfig.showElements) {
+        return of([]);
+    }
+    return defer(() => {
+        const ctes = [
+            `CategoriesElementsHierarchy(ECInstanceId, ParentId, ModelId, Path) AS (
+        SELECT
+          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
+          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: "tree-widget/categories-tree/elements-filter-paths-query" });
+    }).pipe(releaseMainThreadOnItemsCount(300), map((row) => parseQueryRow(row, separator, elementClass, categoryClass, modelClass)), mergeMap(async (elementHierarchyPath) => {
+        const pathToCategory = await idsCache.getInstanceKeyPaths({ categoryId: elementHierarchyPath[0].id });
+        pathToCategory.pop(); // category is already included in the element hierarchy path
+        const path = [...pathToCategory, ...elementHierarchyPath];
+        return { path, options: { autoExpand: 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