@itwin/tree-widget-react 3.16.1 → 3.17.1

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

@@ -2,7 +2,9 @@
  * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
  * See LICENSE.md in the project root for license terms and full copyright notice.
  *--------------------------------------------------------------------------------------------*/
-import { Guid } from "@itwin/core-bentley";
+import { defer, forkJoin, from, map, mergeMap, of, reduce, shareReplay, toArray } from "rxjs";
+import { Guid, Id64 } from "@itwin/core-bentley";
+import { setIntersection } from "../../common/internal/Utils.js";
 import { DEFINITION_CONTAINER_CLASS, SUB_CATEGORY_CLASS } from "./ClassNameDefinitions.js";
 /** @internal */
 export class CategoriesTreeIdsCache {
@@ -27,311 +29,355 @@ export class CategoriesTreeIdsCache {
         this.#componentName = "CategoriesTreeIdsCache";
     }
     [Symbol.dispose]() { }
-    async *queryElementModelCategories() {
-        const query = `
-      SELECT this.Model.Id modelId, this.Category.Id categoryId
-      FROM ${this.#categoryModelClass} m
-      JOIN ${this.#categoryElementClass} this ON m.ECInstanceId = this.Model.Id
-      WHERE m.IsPrivate = false
-      GROUP BY modelId, categoryId
-    `;
-        for await (const row of this.#queryExecutor.createQueryReader({ ecsql: query }, {
-            rowFormat: "ECSqlPropertyNames",
-            limit: "unbounded",
-            restartToken: `${this.#componentName}/${this.#componentId}/element-models-and-categories`,
-        })) {
-            yield { modelId: row.modelId, categoryId: row.categoryId };
-        }
+    queryElementModelCategories() {
+        return defer(() => {
+            const query = `
+        SELECT this.Model.Id modelId, this.Category.Id categoryId
+        FROM ${this.#categoryModelClass} m
+        JOIN ${this.#categoryElementClass} this ON m.ECInstanceId = this.Model.Id
+        WHERE m.IsPrivate = false
+        GROUP BY modelId, categoryId
+      `;
+            return this.#queryExecutor.createQueryReader({ ecsql: query }, {
+                rowFormat: "ECSqlPropertyNames",
+                limit: "unbounded",
+                restartToken: `${this.#componentName}/${this.#componentId}/element-models-and-categories`,
+            });
+        }).pipe(map((row) => {
+            return { modelId: row.modelId, categoryId: row.categoryId };
+        }));
     }
-    async *queryCategories() {
-        const isDefinitionContainerSupported = await this.getIsDefinitionContainerSupported();
-        const categoriesQuery = `
-      SELECT
-        this.ECInstanceId id,
-        COUNT(sc.ECInstanceId) childCount,
-        this.Model.Id modelId,
-        ${isDefinitionContainerSupported
-            ? `
-            IIF(this.Model.Id IN (SELECT dc.ECInstanceId FROM ${DEFINITION_CONTAINER_CLASS} dc),
-              true,
-              false
-            )`
-            : "false"} parentDefinitionContainerExists
-      FROM
-        ${this.#categoryClass} this
-        JOIN ${SUB_CATEGORY_CLASS} sc ON sc.Parent.Id = this.ECInstanceId
-        JOIN BisCore.Model m ON m.ECInstanceId = this.Model.Id
-      WHERE
-        NOT this.IsPrivate
-        AND (NOT m.IsPrivate OR m.ECClassId IS (BisCore.DictionaryModel))
-        AND EXISTS (SELECT 1 FROM ${this.#categoryElementClass} e WHERE e.Category.Id = this.ECInstanceId)
-      GROUP BY this.ECInstanceId
-    `;
-        for await (const row of this.#queryExecutor.createQueryReader({ ecsql: categoriesQuery }, { rowFormat: "ECSqlPropertyNames", limit: "unbounded", restartToken: `${this.#componentName}/${this.#componentId}/categories` })) {
-            yield { id: row.id, modelId: row.modelId, parentDefinitionContainerExists: row.parentDefinitionContainerExists, childCount: row.childCount };
-        }
+    queryCategories() {
+        return this.getIsDefinitionContainerSupported().pipe(mergeMap((isDefinitionContainerSupported) => defer(() => {
+            const categoriesQuery = `
+            SELECT
+              this.ECInstanceId id,
+              COUNT(sc.ECInstanceId) childCount,
+              this.Model.Id modelId,
+              ${isDefinitionContainerSupported
+                ? `
+                  IIF(this.Model.Id IN (SELECT dc.ECInstanceId FROM ${DEFINITION_CONTAINER_CLASS} dc),
+                    true,
+                    false
+                  )`
+                : "false"} parentDefinitionContainerExists,
+              IFNULL(
+                (SELECT 1 FROM ${this.#categoryElementClass} e WHERE e.Category.Id = this.ECInstanceId LIMIT 1),
+                0
+              ) hasElements
+            FROM
+              ${this.#categoryClass} this
+              JOIN ${SUB_CATEGORY_CLASS} sc ON sc.Parent.Id = this.ECInstanceId
+              JOIN BisCore.Model m ON m.ECInstanceId = this.Model.Id
+            WHERE
+              NOT this.IsPrivate
+              AND (NOT m.IsPrivate OR m.ECClassId IS (BisCore.DictionaryModel))
+            GROUP BY this.ECInstanceId
+          `;
+            return this.#queryExecutor.createQueryReader({ ecsql: categoriesQuery }, { rowFormat: "ECSqlPropertyNames", limit: "unbounded", restartToken: `${this.#componentName}/${this.#componentId}/categories` });
+        }).pipe(map((row) => {
+            return {
+                id: row.id,
+                modelId: row.modelId,
+                parentDefinitionContainerExists: row.parentDefinitionContainerExists,
+                childCount: row.childCount,
+                hasElements: !!row.hasElements,
+            };
+        }))));
     }
-    async queryIsDefinitionContainersSupported() {
-        const query = `
-      SELECT
-        1
-      FROM
-        ECDbMeta.ECSchemaDef s
-        JOIN ECDbMeta.ECClassDef c ON c.Schema.Id = s.ECInstanceId
-      WHERE
-        s.Name = 'BisCore'
-        AND c.Name = 'DefinitionContainer'
-    `;
-        for await (const _row of this.#queryExecutor.createQueryReader({ ecsql: query }, { restartToken: `${this.#componentName}/${this.#componentId}/is-definition-container-supported` })) {
-            return true;
-        }
-        return false;
+    queryIsDefinitionContainersSupported() {
+        return defer(() => {
+            const query = `
+        SELECT
+          1
+        FROM
+          ECDbMeta.ECSchemaDef s
+          JOIN ECDbMeta.ECClassDef c ON c.Schema.Id = s.ECInstanceId
+        WHERE
+          s.Name = 'BisCore'
+          AND c.Name = 'DefinitionContainer'
+        LIMIT 1
+      `;
+            return this.#queryExecutor.createQueryReader({ ecsql: query }, { restartToken: `${this.#componentName}/${this.#componentId}/is-definition-container-supported` });
+        }).pipe(toArray(), map((rows) => rows.length > 0));
     }
-    async *queryDefinitionContainers() {
-        // DefinitionModel ECInstanceId will always be the same as modeled DefinitionContainer ECInstanceId, if this wasn't the case, we would need to do something like:
-        //  JOIN BisCore.DefinitionModel dm ON dm.ECInstanceId = ${modelIdAccessor}
-        //  JOIN BisCore.DefinitionModelBreaksDownDefinitionContainer dr ON dr.SourceECInstanceId = dm.ECInstanceId
-        //  JOIN BisCore.DefinitionContainer dc ON dc.ECInstanceId = dr.TargetECInstanceId
-        const DEFINITION_CONTAINERS_CTE = "DefinitionContainers";
-        const ctes = [
-            `
-        ${DEFINITION_CONTAINERS_CTE}(ECInstanceId, ModelId) AS (
+    queryDefinitionContainers() {
+        return defer(() => {
+            // DefinitionModel ECInstanceId will always be the same as modeled DefinitionContainer ECInstanceId, if this wasn't the case, we would need to do something like:
+            //  JOIN BisCore.DefinitionModel dm ON dm.ECInstanceId = ${modelIdAccessor}
+            //  JOIN BisCore.DefinitionModelBreaksDownDefinitionContainer dr ON dr.SourceECInstanceId = dm.ECInstanceId
+            //  JOIN BisCore.DefinitionContainer dc ON dc.ECInstanceId = dr.TargetECInstanceId
+            const DEFINITION_CONTAINERS_CTE = "DefinitionContainers";
+            const CATEGORIES_MODELS_CTE = "CategoriesModels";
+            const ctes = [
+                `${CATEGORIES_MODELS_CTE}(ModelId, HasElements) AS (
           SELECT
-            dc.ECInstanceId,
-            dc.Model.Id
+            c.Model.Id,
+            IFNULL((
+              SELECT 1
+              FROM ${this.#categoryElementClass} e
+              WHERE e.Category.Id = c.ECInstanceId
+              LIMIT 1
+            ), 0)
           FROM
-            ${DEFINITION_CONTAINER_CLASS} dc
+            ${this.#categoryClass} c
           WHERE
-            dc.ECInstanceId IN (SELECT c.Model.Id FROM ${this.#categoryClass} c WHERE NOT c.IsPrivate AND EXISTS (SELECT 1 FROM ${this.#categoryElementClass} e WHERE e.Category.Id = c.ECInstanceId))
-            AND NOT dc.IsPrivate
+            NOT c.IsPrivate
+        )`,
+                `
+          ${DEFINITION_CONTAINERS_CTE}(ECInstanceId, ModelId, HasElements) AS (
+            SELECT
+              dc.ECInstanceId,
+              dc.Model.Id,
+              c.HasElements
+            FROM ${DEFINITION_CONTAINER_CLASS} dc
+            JOIN ${CATEGORIES_MODELS_CTE} c ON dc.ECInstanceId = c.ModelId
+            WHERE NOT dc.IsPrivate
 
-          UNION ALL
+            UNION ALL
 
-          SELECT
-            pdc.ECInstanceId,
-            pdc.Model.Id
-          FROM
-            ${DEFINITION_CONTAINERS_CTE} cdc
-            JOIN ${DEFINITION_CONTAINER_CLASS} pdc ON pdc.ECInstanceId = cdc.ModelId
-          WHERE
-            NOT pdc.IsPrivate
-        )
-      `,
-        ];
-        const definitionsQuery = `
-      SELECT dc.ECInstanceId id, dc.ModelId modelId FROM ${DEFINITION_CONTAINERS_CTE} dc GROUP BY dc.ECInstanceId
-    `;
-        for await (const row of this.#queryExecutor.createQueryReader({ ctes, ecsql: definitionsQuery }, { rowFormat: "ECSqlPropertyNames", limit: "unbounded", restartToken: `${this.#componentName}/${this.#componentId}/definition-containers` })) {
-            yield { id: row.id, modelId: row.modelId };
-        }
+            SELECT
+              pdc.ECInstanceId,
+              pdc.Model.Id,
+              cdc.HasElements
+            FROM
+              ${DEFINITION_CONTAINERS_CTE} cdc
+              JOIN ${DEFINITION_CONTAINER_CLASS} pdc ON pdc.ECInstanceId = cdc.ModelId
+            WHERE NOT pdc.IsPrivate
+          )
+        `,
+            ];
+            const definitionsQuery = `
+        SELECT dc.ECInstanceId id, dc.ModelId modelId, MAX(dc.HasElements) hasElements FROM ${DEFINITION_CONTAINERS_CTE} dc GROUP BY dc.ECInstanceId
+      `;
+            return this.#queryExecutor.createQueryReader({ ctes, ecsql: definitionsQuery }, { rowFormat: "ECSqlPropertyNames", limit: "unbounded", restartToken: `${this.#componentName}/${this.#componentId}/definition-containers` });
+        }).pipe(map((row) => {
+            return { id: row.id, modelId: row.modelId, hasElements: !!row.hasElements };
+        }));
     }
-    async *queryVisibleSubCategories(categoriesInfo) {
-        const definitionsQuery = `
-      SELECT
-        sc.ECInstanceId id,
-        sc.Parent.Id categoryId
-      FROM
-        ${SUB_CATEGORY_CLASS} sc
-      WHERE
-        NOT sc.IsPrivate
-        AND sc.Parent.Id IN (${categoriesInfo.join(",")})
-    `;
-        for await (const row of this.#queryExecutor.createQueryReader({ ecsql: definitionsQuery }, { rowFormat: "ECSqlPropertyNames", limit: "unbounded", restartToken: `${this.#componentName}/${this.#componentId}/visible-sub-categories` })) {
-            yield { id: row.id, parentId: row.categoryId };
-        }
+    queryVisibleSubCategories(categoriesInfo) {
+        return defer(() => {
+            const definitionsQuery = `
+        SELECT
+          sc.ECInstanceId id,
+          sc.Parent.Id categoryId
+        FROM
+          ${SUB_CATEGORY_CLASS} sc
+        WHERE
+          NOT sc.IsPrivate
+          AND sc.Parent.Id IN (${categoriesInfo.join(",")})
+      `;
+            return this.#queryExecutor.createQueryReader({ ecsql: definitionsQuery }, { rowFormat: "ECSqlPropertyNames", limit: "unbounded", restartToken: `${this.#componentName}/${this.#componentId}/visible-sub-categories` });
+        }).pipe(map((row) => {
+            return { id: row.id, parentId: row.categoryId };
+        }));
     }
-    async getModelsCategoriesInfo() {
-        this.#modelsCategoriesInfo ??= (async () => {
-            const allModelsCategories = new Map();
-            for await (const queriedCategory of this.queryCategories()) {
-                let modelCategories = allModelsCategories.get(queriedCategory.modelId);
-                if (modelCategories === undefined) {
-                    modelCategories = { parentDefinitionContainerExists: queriedCategory.parentDefinitionContainerExists, childCategories: [] };
-                    allModelsCategories.set(queriedCategory.modelId, modelCategories);
-                }
-                modelCategories.childCategories.push({ id: queriedCategory.id, childCount: queriedCategory.childCount });
+    getModelsCategoriesInfo() {
+        this.#modelsCategoriesInfo ??= this.queryCategories()
+            .pipe(reduce((acc, queriedCategory) => {
+            let modelCategories = acc.get(queriedCategory.modelId);
+            if (modelCategories === undefined) {
+                modelCategories = { parentDefinitionContainerExists: queriedCategory.parentDefinitionContainerExists, childCategories: [] };
+                acc.set(queriedCategory.modelId, modelCategories);
             }
-            return allModelsCategories;
-        })();
+            modelCategories.childCategories.push({ id: queriedCategory.id, childCount: queriedCategory.childCount, hasElements: queriedCategory.hasElements });
+            return acc;
+        }, new Map()))
+            .pipe(shareReplay());
         return this.#modelsCategoriesInfo;
     }
-    async getElementModelsCategories() {
-        this.#elementModelsCategories ??= (async () => {
-            const elementModelsCategories = new Map();
-            for await (const queriedCategory of this.queryElementModelCategories()) {
-                let modelEntry = elementModelsCategories.get(queriedCategory.modelId);
-                if (modelEntry === undefined) {
-                    modelEntry = new Set();
-                    elementModelsCategories.set(queriedCategory.modelId, modelEntry);
-                }
-                modelEntry.add(queriedCategory.categoryId);
+    getElementModelsCategories() {
+        this.#elementModelsCategories ??= this.queryElementModelCategories()
+            .pipe(reduce((acc, queriedCategory) => {
+            let modelEntry = acc.get(queriedCategory.modelId);
+            if (modelEntry === undefined) {
+                modelEntry = new Set();
+                acc.set(queriedCategory.modelId, modelEntry);
             }
-            return elementModelsCategories;
-        })();
+            modelEntry.add(queriedCategory.categoryId);
+            return acc;
+        }, new Map()))
+            .pipe(shareReplay());
         return this.#elementModelsCategories;
     }
-    async getSubCategoriesInfo() {
-        this.#subCategoriesInfo ??= (async () => {
+    getSubCategoriesInfo() {
+        this.#subCategoriesInfo ??= this.getModelsCategoriesInfo()
+            .pipe(mergeMap((modelsCategoriesInfo) => from(modelsCategoriesInfo.values())), reduce((acc, modelCategoriesInfo) => {
+            acc.push(...modelCategoriesInfo.childCategories.filter((categoryInfo) => categoryInfo.childCount > 1).map((categoryInfo) => categoryInfo.id));
+            return acc;
+        }, new Array()), mergeMap((categoriesWithMoreThanOneSubCategory) => {
             const allSubCategories = new Map();
-            const modelsCategoriesInfo = await this.getModelsCategoriesInfo();
-            const categoriesWithMoreThanOneSubCategory = new Array();
-            for (const modelCategoriesInfo of modelsCategoriesInfo.values()) {
-                categoriesWithMoreThanOneSubCategory.push(...modelCategoriesInfo.childCategories.filter((categoryInfo) => categoryInfo.childCount > 1).map((categoryInfo) => categoryInfo.id));
-            }
             if (categoriesWithMoreThanOneSubCategory.length === 0) {
-                return allSubCategories;
-            }
-            for await (const queriedSubCategory of this.queryVisibleSubCategories(categoriesWithMoreThanOneSubCategory)) {
-                allSubCategories.set(queriedSubCategory.id, { categoryId: queriedSubCategory.parentId });
+                return of(allSubCategories);
             }
-            return allSubCategories;
-        })();
+            return this.queryVisibleSubCategories(categoriesWithMoreThanOneSubCategory).pipe(reduce((acc, queriedSubCategory) => {
+                const entry = acc.get(queriedSubCategory.parentId);
+                if (!entry) {
+                    acc.set(queriedSubCategory.parentId, new Set([queriedSubCategory.id]));
+                    return acc;
+                }
+                entry.add(queriedSubCategory.id);
+                return acc;
+            }, allSubCategories));
+        }))
+            .pipe(shareReplay());
         return this.#subCategoriesInfo;
     }
-    async getDefinitionContainersInfo() {
-        this.#definitionContainersInfo ??= (async () => {
+    getDefinitionContainersInfo() {
+        this.#definitionContainersInfo ??= forkJoin({
+            isDefinitionContainerSupported: this.getIsDefinitionContainerSupported(),
+            modelsCategoriesInfo: this.getModelsCategoriesInfo(),
+        })
+            .pipe(mergeMap(({ isDefinitionContainerSupported, modelsCategoriesInfo }) => {
             const definitionContainersInfo = new Map();
-            const [isDefinitionContainerSupported, modelsCategoriesInfo] = await Promise.all([
-                this.getIsDefinitionContainerSupported(),
-                this.getModelsCategoriesInfo(),
-            ]);
             if (!isDefinitionContainerSupported || modelsCategoriesInfo.size === 0) {
-                return definitionContainersInfo;
+                return of(definitionContainersInfo);
             }
-            for await (const queriedDefinitionContainer of this.queryDefinitionContainers()) {
+            return this.queryDefinitionContainers().pipe(reduce((acc, queriedDefinitionContainer) => {
                 const modelCategoriesInfo = modelsCategoriesInfo.get(queriedDefinitionContainer.id);
-                definitionContainersInfo.set(queriedDefinitionContainer.id, {
+                acc.set(queriedDefinitionContainer.id, {
                     childCategories: modelCategoriesInfo?.childCategories ?? [],
                     modelId: queriedDefinitionContainer.modelId,
                     childDefinitionContainers: [],
                     parentDefinitionContainerExists: false,
+                    hasElements: queriedDefinitionContainer.hasElements,
                 });
-            }
-            for (const [definitionContainerId, definitionContainerInfo] of definitionContainersInfo) {
-                const parentDefinitionContainer = definitionContainersInfo.get(definitionContainerInfo.modelId);
-                if (parentDefinitionContainer !== undefined) {
-                    parentDefinitionContainer.childDefinitionContainers.push(definitionContainerId);
-                    definitionContainerInfo.parentDefinitionContainerExists = true;
+                return acc;
+            }, definitionContainersInfo), map((result) => {
+                for (const [definitionContainerId, definitionContainerInfo] of result) {
+                    const parentDefinitionContainer = result.get(definitionContainerInfo.modelId);
+                    if (parentDefinitionContainer !== undefined) {
+                        parentDefinitionContainer.childDefinitionContainers.push({ id: definitionContainerId, hasElements: definitionContainerInfo.hasElements });
+                        definitionContainerInfo.parentDefinitionContainerExists = true;
+                        parentDefinitionContainer.hasElements = parentDefinitionContainer.hasElements || definitionContainerInfo.hasElements;
+                    }
                 }
-            }
-            return definitionContainersInfo;
-        })();
+                return result;
+            }));
+        }))
+            .pipe(shareReplay());
         return this.#definitionContainersInfo;
     }
-    async getDirectChildDefinitionContainersAndCategories(parentDefinitionContainerIds) {
-        const definitionContainersInfo = await this.getDefinitionContainersInfo();
-        const result = { definitionContainers: new Array(), categories: new Array() };
-        parentDefinitionContainerIds.forEach((parentDefinitionContainerId) => {
+    getDirectChildDefinitionContainersAndCategories({ parentDefinitionContainerIds, includeEmpty, }) {
+        return this.getDefinitionContainersInfo().pipe(mergeMap((definitionContainersInfo) => from(parentDefinitionContainerIds).pipe(reduce((acc, parentDefinitionContainerId) => {
             const parentDefinitionContainerInfo = definitionContainersInfo.get(parentDefinitionContainerId);
             if (parentDefinitionContainerInfo !== undefined) {
-                result.definitionContainers.push(...parentDefinitionContainerInfo.childDefinitionContainers);
-                result.categories.push(...parentDefinitionContainerInfo.childCategories);
+                acc.definitionContainers.push(...applyElementsFilter(parentDefinitionContainerInfo.childDefinitionContainers, includeEmpty).map((dc) => dc.id));
+                acc.categories.push(...applyElementsFilter(parentDefinitionContainerInfo.childCategories, includeEmpty));
             }
-        });
-        return result;
+            return acc;
+        }, { definitionContainers: new Array(), categories: new Array() }))));
     }
-    async getCategoriesElementModels(categoryIds) {
-        const elementModelsCategories = await this.getElementModelsCategories();
-        const result = new Map();
-        for (const categoryId of categoryIds) {
-            for (const [modelId, categories] of elementModelsCategories) {
-                if (categories.has(categoryId)) {
-                    let categoryModels = result.get(categoryId);
-                    if (!categoryModels) {
-                        categoryModels = new Array();
-                        result.set(categoryId, categoryModels);
-                    }
-                    categoryModels.push(modelId);
-                }
+    getCategoriesElementModels(categoryIds) {
+        return this.getElementModelsCategories().pipe(mergeMap((elementModelsCategories) => elementModelsCategories.entries()), reduce((acc, [modelId, modelCategoryIds]) => {
+            const sharedCategories = setIntersection(Id64.iterable(categoryIds), modelCategoryIds);
+            if (sharedCategories.size > 0) {
+                acc.set(modelId, sharedCategories);
             }
-        }
-        return result;
+            return acc;
+        }, new Map()));
     }
-    async getAllContainedCategories(definitionContainerIds) {
-        const result = new Array();
-        const definitionContainersInfo = await this.getDefinitionContainersInfo();
-        const indirectCategories = await Promise.all(definitionContainerIds.map(async (definitionContainerId) => {
+    getAllContainedCategories({ definitionContainerIds, includeEmptyCategories, }) {
+        return this.getDefinitionContainersInfo().pipe(mergeMap((definitionContainersInfo) => from(definitionContainerIds).pipe(mergeMap((definitionContainerId) => {
             const definitionContainerInfo = definitionContainersInfo.get(definitionContainerId);
             if (definitionContainerInfo === undefined) {
-                return [];
+                return of({ directCategories: undefined, indirectCategories: undefined });
             }
-            result.push(...definitionContainerInfo.childCategories.map((category) => category.id));
-            return this.getAllContainedCategories(definitionContainerInfo.childDefinitionContainers);
-        }));
-        for (const categories of indirectCategories) {
-            result.push(...categories);
-        }
-        return result;
+            const childDefinitionContainerIds = definitionContainerInfo.childDefinitionContainers.map(({ id }) => id);
+            return (childDefinitionContainerIds.length > 0
+                ? this.getAllContainedCategories({
+                    definitionContainerIds: childDefinitionContainerIds,
+                    includeEmptyCategories,
+                })
+                : of(new Set())).pipe(map((indirectCategories) => {
+                return {
+                    directCategories: applyElementsFilter(definitionContainerInfo.childCategories, includeEmptyCategories).map((category) => category.id),
+                    indirectCategories,
+                };
+            }));
+        }), reduce((acc, { directCategories, indirectCategories }) => {
+            directCategories?.forEach((categoryId) => acc.add(categoryId));
+            indirectCategories?.forEach((categoryId) => acc.add(categoryId));
+            return acc;
+        }, new Set()))));
     }
-    async getInstanceKeyPaths(props) {
+    getInstanceKeyPaths(props) {
         if ("subCategoryId" in props) {
-            const subCategoriesInfo = await this.getSubCategoriesInfo();
-            const subCategoryInfo = subCategoriesInfo.get(props.subCategoryId);
-            if (subCategoryInfo === undefined) {
-                return [];
-            }
-            return [...(await this.getInstanceKeyPaths({ categoryId: subCategoryInfo.categoryId })), { id: props.subCategoryId, className: SUB_CATEGORY_CLASS }];
+            return this.getSubCategoriesInfo().pipe(mergeMap((subCategoriesInfo) => {
+                let categoryOfSubCategory;
+                for (const [categoryId, subCategories] of subCategoriesInfo.entries()) {
+                    if (subCategories.has(props.subCategoryId)) {
+                        categoryOfSubCategory = categoryId;
+                        break;
+                    }
+                }
+                if (categoryOfSubCategory === undefined) {
+                    return of([]);
+                }
+                return this.getInstanceKeyPaths({ categoryId: categoryOfSubCategory }).pipe(map((pathToCategory) => [...pathToCategory, { id: props.subCategoryId, className: SUB_CATEGORY_CLASS }]));
+            }));
         }
         if ("categoryId" in props) {
-            const modelsCategoriesInfo = await this.getModelsCategoriesInfo();
-            for (const [modelId, modelCategoriesInfo] of modelsCategoriesInfo) {
-                if (modelCategoriesInfo.childCategories.find((childCategory) => childCategory.id === props.categoryId)) {
-                    if (!modelCategoriesInfo.parentDefinitionContainerExists) {
-                        return [{ id: props.categoryId, className: this.#categoryClass }];
+            return this.getModelsCategoriesInfo().pipe(mergeMap((modelsCategoriesInfo) => {
+                for (const [modelId, modelCategoriesInfo] of modelsCategoriesInfo) {
+                    if (modelCategoriesInfo.childCategories.find((childCategory) => childCategory.id === props.categoryId)) {
+                        const instanceKey = { id: props.categoryId, className: this.#categoryClass };
+                        if (!modelCategoriesInfo.parentDefinitionContainerExists) {
+                            return of([instanceKey]);
+                        }
+                        return this.getInstanceKeyPaths({ definitionContainerId: modelId }).pipe(map((pathToDefinitionContainer) => [...pathToDefinitionContainer, instanceKey]));
                     }
-                    return [...(await this.getInstanceKeyPaths({ definitionContainerId: modelId })), { id: props.categoryId, className: this.#categoryClass }];
                 }
-            }
-            return [];
-        }
-        const definitionContainersInfo = await this.getDefinitionContainersInfo();
-        const definitionContainerInfo = definitionContainersInfo.get(props.definitionContainerId);
-        if (definitionContainerInfo === undefined) {
-            return [];
+                return of([]);
+            }));
         }
-        if (!definitionContainerInfo.parentDefinitionContainerExists) {
-            return [{ id: props.definitionContainerId, className: DEFINITION_CONTAINER_CLASS }];
-        }
-        return [
-            ...(await this.getInstanceKeyPaths({ definitionContainerId: definitionContainerInfo.modelId })),
-            { id: props.definitionContainerId, className: DEFINITION_CONTAINER_CLASS },
-        ];
-    }
-    async getAllDefinitionContainersAndCategories() {
-        const [modelsCategoriesInfo, definitionContainersInfo] = await Promise.all([this.getModelsCategoriesInfo(), this.getDefinitionContainersInfo()]);
-        const result = { definitionContainers: [...definitionContainersInfo.keys()], categories: new Array() };
-        for (const modelCategoriesInfo of modelsCategoriesInfo.values()) {
-            result.categories.push(...modelCategoriesInfo.childCategories.map((childCategory) => childCategory.id));
-        }
-        return result;
-    }
-    async getRootDefinitionContainersAndCategories() {
-        const [modelsCategoriesInfo, definitionContainersInfo] = await Promise.all([this.getModelsCategoriesInfo(), this.getDefinitionContainersInfo()]);
-        const result = { definitionContainers: new Array(), categories: new Array() };
-        for (const modelCategoriesInfo of modelsCategoriesInfo.values()) {
-            if (!modelCategoriesInfo.parentDefinitionContainerExists) {
-                result.categories.push(...modelCategoriesInfo.childCategories);
+        return this.getDefinitionContainersInfo().pipe(mergeMap((definitionContainersInfo) => {
+            const definitionContainerInfo = definitionContainersInfo.get(props.definitionContainerId);
+            if (definitionContainerInfo === undefined) {
+                return of([]);
             }
-        }
-        for (const [definitionContainerId, definitionContainerInfo] of definitionContainersInfo) {
+            const instanceKey = { id: props.definitionContainerId, className: DEFINITION_CONTAINER_CLASS };
             if (!definitionContainerInfo.parentDefinitionContainerExists) {
-                result.definitionContainers.push(definitionContainerId);
+                return of([instanceKey]);
             }
-        }
-        return result;
+            return this.getInstanceKeyPaths({ definitionContainerId: definitionContainerInfo.modelId }).pipe(map((pathToParentDefinitionContainer) => [...pathToParentDefinitionContainer, instanceKey]));
+        }));
     }
-    async getSubCategories(categoryId) {
-        const subCategoriesInfo = await this.getSubCategoriesInfo();
-        const result = new Array();
-        for (const [subCategoryId, subCategoryInfo] of subCategoriesInfo) {
-            if (subCategoryInfo.categoryId === categoryId) {
-                result.push(subCategoryId);
-            }
-        }
-        return result;
+    getAllDefinitionContainersAndCategories(props) {
+        return forkJoin({
+            categories: this.getModelsCategoriesInfo().pipe(mergeMap((modelsCategoriesInfo) => modelsCategoriesInfo.values()), reduce((acc, modelCategoriesInfo) => {
+                applyElementsFilter(modelCategoriesInfo.childCategories, props?.includeEmpty).forEach((categoryInfo) => acc.push(categoryInfo.id));
+                return acc;
+            }, new Array())),
+            definitionContainers: this.getDefinitionContainersInfo().pipe(mergeMap((definitionContainersInfo) => definitionContainersInfo.entries()), reduce((acc, [definitionContainerId, definitionContainerInfo]) => {
+                if (definitionContainerInfo.hasElements || !!props?.includeEmpty) {
+                    acc.push(definitionContainerId);
+                }
+                return acc;
+            }, new Array())),
+        });
     }
-    async getIsDefinitionContainerSupported() {
-        this.#isDefinitionContainerSupported ??= this.queryIsDefinitionContainersSupported();
+    getRootDefinitionContainersAndCategories(props) {
+        return forkJoin({
+            categories: this.getModelsCategoriesInfo().pipe(mergeMap((modelsCategoriesInfo) => modelsCategoriesInfo.values()), reduce((acc, modelCategoriesInfo) => {
+                if (!modelCategoriesInfo.parentDefinitionContainerExists) {
+                    applyElementsFilter(modelCategoriesInfo.childCategories, props?.includeEmpty).forEach((categoryInfo) => acc.push(categoryInfo));
+                }
+                return acc;
+            }, new Array())),
+            definitionContainers: this.getDefinitionContainersInfo().pipe(mergeMap((definitionContainersInfo) => definitionContainersInfo.entries()), reduce((acc, [definitionContainerId, definitionContainerInfo]) => {
+                if (!definitionContainerInfo.parentDefinitionContainerExists && (definitionContainerInfo.hasElements || !!props?.includeEmpty)) {
+                    acc.push(definitionContainerId);
+                }
+                return acc;
+            }, new Array())),
+        });
+    }
+    getSubCategories(categoryId) {
+        return this.getSubCategoriesInfo().pipe(map((subCategoriesInfo) => subCategoriesInfo.get(categoryId) ?? new Set()));
+    }
+    getIsDefinitionContainerSupported() {
+        this.#isDefinitionContainerSupported ??= this.queryIsDefinitionContainersSupported().pipe(shareReplay());
         return this.#isDefinitionContainerSupported;
     }
 }
@@ -341,4 +387,7 @@ export function getClassesByView(viewType) {
         ? { categoryClass: "BisCore.DrawingCategory", categoryElementClass: "BisCore.GeometricElement2d", categoryModelClass: "BisCore.GeometricModel2d" }
         : { categoryClass: "BisCore.SpatialCategory", categoryElementClass: "BisCore.GeometricElement3d", categoryModelClass: "BisCore.GeometricModel3d" };
 }
+function applyElementsFilter(list, includeEmpty) {
+    return includeEmpty ? list : list.filter(({ hasElements }) => !!hasElements);
+}
 //# sourceMappingURL=CategoriesTreeIdsCache.js.map