@itwin/tree-widget-react 3.16.0 → 3.17.0

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

@@ -6,6 +6,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CategoriesTreeIdsCache = void 0;
 exports.getClassesByView = getClassesByView;
+const rxjs_1 = require("rxjs");
 const core_bentley_1 = require("@itwin/core-bentley");
 const ClassNameDefinitions_js_1 = require("./ClassNameDefinitions.js");
 /** @internal */
@@ -31,311 +32,355 @@ 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 (0, rxjs_1.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((0, rxjs_1.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 ${ClassNameDefinitions_js_1.DEFINITION_CONTAINER_CLASS} dc),
-              true,
-              false
-            )`
-            : "false"} parentDefinitionContainerExists
-      FROM
-        ${this.#categoryClass} this
-        JOIN ${ClassNameDefinitions_js_1.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((0, rxjs_1.mergeMap)((isDefinitionContainerSupported) => (0, rxjs_1.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 ${ClassNameDefinitions_js_1.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 ${ClassNameDefinitions_js_1.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((0, rxjs_1.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 (0, rxjs_1.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((0, rxjs_1.toArray)(), (0, rxjs_1.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 (0, rxjs_1.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
-            ${ClassNameDefinitions_js_1.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 ${ClassNameDefinitions_js_1.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 ${ClassNameDefinitions_js_1.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 ${ClassNameDefinitions_js_1.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((0, rxjs_1.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
-        ${ClassNameDefinitions_js_1.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 (0, rxjs_1.defer)(() => {
+            const definitionsQuery = `
+        SELECT
+          sc.ECInstanceId id,
+          sc.Parent.Id categoryId
+        FROM
+          ${ClassNameDefinitions_js_1.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((0, rxjs_1.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((0, rxjs_1.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((0, rxjs_1.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((0, rxjs_1.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((0, rxjs_1.shareReplay)());
         return this.#elementModelsCategories;
     }
-    async getSubCategoriesInfo() {
-        this.#subCategoriesInfo ??= (async () => {
+    getSubCategoriesInfo() {
+        this.#subCategoriesInfo ??= this.getModelsCategoriesInfo()
+            .pipe((0, rxjs_1.mergeMap)((modelsCategoriesInfo) => (0, rxjs_1.from)(modelsCategoriesInfo.values())), (0, rxjs_1.reduce)((acc, modelCategoriesInfo) => {
+            acc.push(...modelCategoriesInfo.childCategories.filter((categoryInfo) => categoryInfo.childCount > 1).map((categoryInfo) => categoryInfo.id));
+            return acc;
+        }, new Array()), (0, rxjs_1.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;
+                return (0, rxjs_1.of)(allSubCategories);
             }
-            for await (const queriedSubCategory of this.queryVisibleSubCategories(categoriesWithMoreThanOneSubCategory)) {
-                allSubCategories.set(queriedSubCategory.id, { categoryId: queriedSubCategory.parentId });
-            }
-            return allSubCategories;
-        })();
+            return this.queryVisibleSubCategories(categoriesWithMoreThanOneSubCategory).pipe((0, rxjs_1.reduce)((acc, queriedSubCategory) => {
+                acc.set(queriedSubCategory.id, { categoryId: queriedSubCategory.parentId });
+                return acc;
+            }, allSubCategories));
+        }))
+            .pipe((0, rxjs_1.shareReplay)());
         return this.#subCategoriesInfo;
     }
-    async getDefinitionContainersInfo() {
-        this.#definitionContainersInfo ??= (async () => {
+    getDefinitionContainersInfo() {
+        this.#definitionContainersInfo ??= (0, rxjs_1.forkJoin)({
+            isDefinitionContainerSupported: this.getIsDefinitionContainerSupported(),
+            modelsCategoriesInfo: this.getModelsCategoriesInfo(),
+        })
+            .pipe((0, rxjs_1.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 (0, rxjs_1.of)(definitionContainersInfo);
             }
-            for await (const queriedDefinitionContainer of this.queryDefinitionContainers()) {
+            return this.queryDefinitionContainers().pipe((0, rxjs_1.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), (0, rxjs_1.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((0, rxjs_1.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((0, rxjs_1.mergeMap)((definitionContainersInfo) => (0, rxjs_1.from)(parentDefinitionContainerIds).pipe((0, rxjs_1.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) {
+    getCategoriesElementModels(categoryIds) {
+        return this.getElementModelsCategories().pipe((0, rxjs_1.mergeMap)((elementModelsCategories) => (0, rxjs_1.from)(categoryIds).pipe((0, rxjs_1.reduce)((acc, categoryId) => {
             for (const [modelId, categories] of elementModelsCategories) {
                 if (categories.has(categoryId)) {
-                    let categoryModels = result.get(categoryId);
+                    let categoryModels = acc.get(categoryId);
                     if (!categoryModels) {
                         categoryModels = new Array();
-                        result.set(categoryId, categoryModels);
+                        acc.set(categoryId, categoryModels);
                     }
                     categoryModels.push(modelId);
                 }
             }
-        }
-        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((0, rxjs_1.mergeMap)((definitionContainersInfo) => (0, rxjs_1.from)(definitionContainerIds).pipe((0, rxjs_1.mergeMap)((definitionContainerId) => {
             const definitionContainerInfo = definitionContainersInfo.get(definitionContainerId);
             if (definitionContainerInfo === undefined) {
-                return [];
+                return (0, rxjs_1.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,
+                })
+                : (0, rxjs_1.of)(new Set())).pipe((0, rxjs_1.map)((indirectCategories) => {
+                return {
+                    directCategories: applyElementsFilter(definitionContainerInfo.childCategories, includeEmptyCategories).map((category) => category.id),
+                    indirectCategories,
+                };
+            }));
+        }), (0, rxjs_1.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: ClassNameDefinitions_js_1.SUB_CATEGORY_CLASS }];
+            return this.getSubCategoriesInfo().pipe((0, rxjs_1.mergeMap)((subCategoriesInfo) => {
+                const subCategoryInfo = subCategoriesInfo.get(props.subCategoryId);
+                if (subCategoryInfo === undefined) {
+                    return (0, rxjs_1.of)([]);
+                }
+                return this.getInstanceKeyPaths({ categoryId: subCategoryInfo.categoryId }).pipe((0, rxjs_1.map)((pathToCategory) => [...pathToCategory, { id: props.subCategoryId, className: ClassNameDefinitions_js_1.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((0, rxjs_1.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 (0, rxjs_1.of)([instanceKey]);
+                        }
+                        return this.getInstanceKeyPaths({ definitionContainerId: modelId }).pipe((0, rxjs_1.map)((pathToDefinitionContainer) => [...pathToDefinitionContainer, instanceKey]));
                     }
-                    return [...(await this.getInstanceKeyPaths({ definitionContainerId: modelId })), { id: props.categoryId, className: this.#categoryClass }];
                 }
-            }
-            return [];
+                return (0, rxjs_1.of)([]);
+            }));
         }
-        const definitionContainersInfo = await this.getDefinitionContainersInfo();
-        const definitionContainerInfo = definitionContainersInfo.get(props.definitionContainerId);
-        if (definitionContainerInfo === undefined) {
-            return [];
-        }
-        if (!definitionContainerInfo.parentDefinitionContainerExists) {
-            return [{ id: props.definitionContainerId, className: ClassNameDefinitions_js_1.DEFINITION_CONTAINER_CLASS }];
-        }
-        return [
-            ...(await this.getInstanceKeyPaths({ definitionContainerId: definitionContainerInfo.modelId })),
-            { id: props.definitionContainerId, className: ClassNameDefinitions_js_1.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((0, rxjs_1.mergeMap)((definitionContainersInfo) => {
+            const definitionContainerInfo = definitionContainersInfo.get(props.definitionContainerId);
+            if (definitionContainerInfo === undefined) {
+                return (0, rxjs_1.of)([]);
             }
-        }
-        for (const [definitionContainerId, definitionContainerInfo] of definitionContainersInfo) {
+            const instanceKey = { id: props.definitionContainerId, className: ClassNameDefinitions_js_1.DEFINITION_CONTAINER_CLASS };
             if (!definitionContainerInfo.parentDefinitionContainerExists) {
-                result.definitionContainers.push(definitionContainerId);
+                return (0, rxjs_1.of)([instanceKey]);
             }
-        }
-        return result;
+            return this.getInstanceKeyPaths({ definitionContainerId: definitionContainerInfo.modelId }).pipe((0, rxjs_1.map)((pathToParentDefinitionContainer) => [...pathToParentDefinitionContainer, instanceKey]));
+        }));
+    }
+    getAllDefinitionContainersAndCategories(props) {
+        return (0, rxjs_1.forkJoin)({
+            categories: this.getModelsCategoriesInfo().pipe((0, rxjs_1.mergeMap)((modelsCategoriesInfo) => modelsCategoriesInfo.values()), (0, rxjs_1.reduce)((acc, modelCategoriesInfo) => {
+                applyElementsFilter(modelCategoriesInfo.childCategories, props?.includeEmpty).forEach((categoryInfo) => acc.push(categoryInfo.id));
+                return acc;
+            }, new Array())),
+            definitionContainers: this.getDefinitionContainersInfo().pipe((0, rxjs_1.mergeMap)((definitionContainersInfo) => definitionContainersInfo.entries()), (0, rxjs_1.reduce)((acc, [definitionContainerId, definitionContainerInfo]) => {
+                if (definitionContainerInfo.hasElements || !!props?.includeEmpty) {
+                    acc.push(definitionContainerId);
+                }
+                return acc;
+            }, new Array())),
+        });
+    }
+    getRootDefinitionContainersAndCategories(props) {
+        return (0, rxjs_1.forkJoin)({
+            categories: this.getModelsCategoriesInfo().pipe((0, rxjs_1.mergeMap)((modelsCategoriesInfo) => modelsCategoriesInfo.values()), (0, rxjs_1.reduce)((acc, modelCategoriesInfo) => {
+                if (!modelCategoriesInfo.parentDefinitionContainerExists) {
+                    applyElementsFilter(modelCategoriesInfo.childCategories, props?.includeEmpty).forEach((categoryInfo) => acc.push(categoryInfo));
+                }
+                return acc;
+            }, new Array())),
+            definitionContainers: this.getDefinitionContainersInfo().pipe((0, rxjs_1.mergeMap)((definitionContainersInfo) => definitionContainersInfo.entries()), (0, rxjs_1.reduce)((acc, [definitionContainerId, definitionContainerInfo]) => {
+                if (!definitionContainerInfo.parentDefinitionContainerExists && (definitionContainerInfo.hasElements || !!props?.includeEmpty)) {
+                    acc.push(definitionContainerId);
+                }
+                return acc;
+            }, new Array())),
+        });
     }
-    async getSubCategories(categoryId) {
-        const subCategoriesInfo = await this.getSubCategoriesInfo();
-        const result = new Array();
-        for (const [subCategoryId, subCategoryInfo] of subCategoriesInfo) {
+    getSubCategories(categoryId) {
+        return this.getSubCategoriesInfo().pipe((0, rxjs_1.mergeMap)((subCategoriesInfo) => subCategoriesInfo.entries()), (0, rxjs_1.reduce)((acc, [subCategoryId, subCategoryInfo]) => {
             if (subCategoryInfo.categoryId === categoryId) {
-                result.push(subCategoryId);
+                acc.push(subCategoryId);
             }
-        }
-        return result;
+            return acc;
+        }, new Array()));
     }
-    async getIsDefinitionContainerSupported() {
-        this.#isDefinitionContainerSupported ??= this.queryIsDefinitionContainersSupported();
+    getIsDefinitionContainerSupported() {
+        this.#isDefinitionContainerSupported ??= this.queryIsDefinitionContainersSupported().pipe((0, rxjs_1.shareReplay)());
         return this.#isDefinitionContainerSupported;
     }
 }
@@ -346,4 +391,7 @@ 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