@itwin/tree-widget-react 4.0.0-alpha.13 → 4.0.0-alpha.15

package/lib/esm/tree-widget-react/components/trees/classifications-tree/internal/ClassificationsTreeVisibilityHandler.js

@@ -2,18 +2,19 @@
  * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
  * See LICENSE.md in the project root for license terms and full copyright notice.
  *--------------------------------------------------------------------------------------------*/
-import { concat, concatAll, defaultIfEmpty, defer, distinct, EMPTY, filter, firstValueFrom, forkJoin, from, fromEventPattern, map, merge, mergeAll, mergeMap, of, reduce, shareReplay, startWith, Subject, take, takeUntil, tap, toArray, } from "rxjs";
+import { concat, concatAll, defaultIfEmpty, defer, EMPTY, filter, firstValueFrom, forkJoin, from, fromEventPattern, map, merge, mergeMap, of, reduce, shareReplay, startWith, Subject, take, takeUntil, tap, toArray, } from "rxjs";
 import { assert, Id64 } from "@itwin/core-bentley";
 import { PerModelCategoryVisibility } from "@itwin/core-frontend";
 import { HierarchyNode, HierarchyNodeKey } from "@itwin/presentation-hierarchies";
 import { AlwaysAndNeverDrawnElementInfo } from "../../common/internal/AlwaysAndNeverDrawnElementInfo.js";
 import { toVoidPromise } from "../../common/internal/Rxjs.js";
 import { createVisibilityStatus } from "../../common/internal/Tooltip.js";
-import { setDifference, setIntersection } from "../../common/internal/Utils.js";
+import { getSetFromId64Arg, releaseMainThreadOnItemsCount, setDifference, setIntersection } from "../../common/internal/Utils.js";
 import { createVisibilityChangeEventListener } from "../../common/internal/VisibilityChangeEventListener.js";
-import { changeElementStateNoChildrenOperator, enableCategoryDisplay, getElementOverriddenVisibility, getElementVisibility, getSubModeledElementsVisibilityStatus, getVisibilityFromAlwaysAndNeverDrawnElementsImpl, mergeVisibilityStatuses, } from "../../common/internal/VisibilityUtils.js";
+import { changeElementStateNoChildrenOperator, enableCategoryDisplay, getVisibilityFromAlwaysAndNeverDrawnElementsImpl, mergeVisibilityStatuses, } from "../../common/internal/VisibilityUtils.js";
 import { createVisibilityHandlerResult } from "../../common/UseHierarchyVisibility.js";
 import { ClassificationsTreeNode } from "./ClassificationsTreeNode.js";
+import { createFilteredTree } from "./FilteredTree.js";
 /**
  * Creates an instance if `ClassificationsTreeVisibilityHandler`.
  * @internal
@@ -26,6 +27,7 @@ class ClassificationsTreeVisibilityHandlerImpl {
     _eventListener;
     _alwaysAndNeverDrawnElements;
     _idsCache;
+    _filteredTree;
     _elementChangeQueue = new Subject();
     _subscriptions = [];
     _changeRequest = new Subject();
@@ -41,6 +43,13 @@ class ClassificationsTreeVisibilityHandlerImpl {
         });
         this._alwaysAndNeverDrawnElements = new AlwaysAndNeverDrawnElementInfo(_props.viewport);
         this._idsCache = this._props.idsCache;
+        if (_props.filteredPaths) {
+            this._filteredTree = createFilteredTree({
+                idsCache: this._idsCache,
+                filteringPaths: _props.filteredPaths,
+                imodelAccess: this._props.imodelAccess,
+            });
+        }
         this._subscriptions.push(this._elementChangeQueue.pipe(concatAll()).subscribe());
     }
     [Symbol.dispose]() {
@@ -80,306 +89,341 @@ class ClassificationsTreeVisibilityHandlerImpl {
         return toVoidPromise(changeObservable);
     }
     getVisibilityStatusObs(node) {
+        if (node.filtering?.filteredChildrenIdentifierPaths?.length && !node.filtering.isFilterTarget) {
+            return this.getFilteredNodeVisibility({ node });
+        }
         if (!HierarchyNode.isInstancesNode(node)) {
             return EMPTY;
         }
         if (ClassificationsTreeNode.isClassificationTableNode(node)) {
-            return this.getClassificationTableDisplayStatus({
+            return this.getClassificationTablesVisibilityStatus({
                 classificationTableIds: node.key.instanceKeys.map((instanceKey) => instanceKey.id),
             });
         }
         if (ClassificationsTreeNode.isClassificationNode(node)) {
-            return this.getClassificationDisplayStatus({
+            return this.getClassificationsVisibilityStatus({
                 classificationIds: node.key.instanceKeys.map((instanceKey) => instanceKey.id),
             });
         }
-        return this.getGeometricElementDisplayStatus({
-            elementId: (() => {
-                assert(node.key.instanceKeys.length === 1);
-                return node.key.instanceKeys[0].id;
-            })(),
+        return this.getElementsVisibilityStatus({
+            elementIds: node.key.instanceKeys.map((instanceKey) => instanceKey.id),
             modelId: ClassificationsTreeNode.getModelId(node),
             categoryId: ClassificationsTreeNode.getCategoryId(node),
-            elementType: node.extendedData?.type,
+            type: node.extendedData?.type,
         });
     }
-    getClassificationTableDisplayStatus(props) {
+    getFilteredNodeVisibility(props) {
+        return from(this.getVisibilityChangeTargets(props)).pipe(mergeMap(({ classificationIds, classificationTableIds, elements2d, elements3d }) => {
+            const observables = new Array();
+            if (classificationTableIds?.size) {
+                observables.push(this.getClassificationTablesVisibilityStatus({ classificationTableIds }));
+            }
+            if (classificationIds?.size) {
+                observables.push(this.getClassificationsVisibilityStatus({ classificationIds }));
+            }
+            if (elements2d?.length) {
+                observables.push(from(elements2d).pipe(releaseMainThreadOnItemsCount(50), mergeMap(({ modelId, categoryId, elementIds }) => {
+                    return from(elementIds).pipe(releaseMainThreadOnItemsCount(1000), mergeMap((elementId) => this.getElementsVisibilityStatus({ modelId, categoryId, elementIds: elementId, type: "GeometricElement2d" })));
+                })));
+            }
+            if (elements3d?.length) {
+                observables.push(from(elements3d).pipe(releaseMainThreadOnItemsCount(50), mergeMap(({ modelId, categoryId, elementIds }) => {
+                    return from(elementIds).pipe(releaseMainThreadOnItemsCount(1000), mergeMap((elementId) => this.getElementsVisibilityStatus({ modelId, categoryId, elementIds: elementId, type: "GeometricElement3d" })));
+                })));
+            }
+            return merge(...observables);
+        }), mergeVisibilityStatuses);
+    }
+    async getVisibilityChangeTargets({ node }) {
+        const filteredTree = await this._filteredTree;
+        return filteredTree ? filteredTree.getVisibilityChangeTargets(node) : {};
+    }
+    getClassificationTablesVisibilityStatus(props) {
         const result = defer(() => {
-            return from(this._idsCache.getAllContainedCategories(props.classificationTableIds)).pipe(mergeMap(({ drawing, spatial }) => merge(of(drawing).pipe(mergeMap((categoryIds) => this.getCategoryDisplayStatus({ categoryIds, type: "DrawingCategory" }))), of(spatial).pipe(mergeMap((categoryIds) => this.getCategoryDisplayStatus({ categoryIds, type: "SpatialCategory" }))))), mergeVisibilityStatuses);
+            return from(this._idsCache.getAllContainedCategories(props.classificationTableIds)).pipe(mergeMap(({ drawing, spatial }) => merge(of(drawing).pipe(mergeMap((categoryIds) => this.getCategoriesVisibilityStatus({ modelId: undefined, categoryIds, type: "DrawingCategory" }))), of(spatial).pipe(mergeMap((categoryIds) => this.getCategoriesVisibilityStatus({ modelId: undefined, categoryIds, type: "SpatialCategory" }))))), mergeVisibilityStatuses);
         });
         return createVisibilityHandlerResult(this, props, result, undefined);
     }
-    getClassificationDisplayStatus(props) {
+    getClassificationsVisibilityStatus(props) {
         const result = defer(() => {
-            return from(this._idsCache.getAllContainedCategories(props.classificationIds)).pipe(mergeMap(({ drawing, spatial }) => merge(of(drawing).pipe(mergeMap((categoryIds) => this.getCategoryDisplayStatus({ categoryIds, type: "DrawingCategory" }))), of(spatial).pipe(mergeMap((categoryIds) => this.getCategoryDisplayStatus({ categoryIds, type: "SpatialCategory" }))))), mergeVisibilityStatuses);
+            return from(this._idsCache.getAllContainedCategories(props.classificationIds)).pipe(mergeMap(({ drawing, spatial }) => merge(of(drawing).pipe(mergeMap((categoryIds) => this.getCategoriesVisibilityStatus({ modelId: undefined, categoryIds, type: "DrawingCategory" }))), of(spatial).pipe(mergeMap((categoryIds) => this.getCategoriesVisibilityStatus({ modelId: undefined, categoryIds, type: "SpatialCategory" }))))), mergeVisibilityStatuses);
         });
         return createVisibilityHandlerResult(this, props, result, undefined);
     }
-    getModelVisibilityStatus({ modelIds }) {
+    getModelsVisibilityStatus({ modelIds }) {
         const result = defer(() => {
-            const viewport = this._props.viewport;
-            return from(modelIds).pipe(distinct(), mergeMap((modelId) => {
-                if (!viewport.view.viewsModel(modelId)) {
-                    return from(this._idsCache.getModelCategoryIds(modelId)).pipe(mergeMap(({ drawing, spatial }) => merge(drawing, spatial)), toArray(), mergeMap((categoryIds) => from(this._idsCache.getCategoriesModeledElements(modelId, categoryIds))), getSubModeledElementsVisibilityStatus({
-                        parentNodeVisibilityStatus: createVisibilityStatus("hidden"),
-                        getModelVisibilityStatus: (modelProps) => this.getModelVisibilityStatus(modelProps),
+            return from(Id64.iterable(modelIds)).pipe(mergeMap((modelId) => {
+                // For hidden models we only need to check subModels
+                if (!this._props.viewport.view.viewsModel(modelId)) {
+                    return this.getSubModels({ modelIds: modelId }).pipe(mergeMap(({ subModels }) => {
+                        if (subModels && Id64.sizeOf(subModels) > 0) {
+                            return this.getModelsVisibilityStatus({ modelIds: subModels }).pipe(map((subModelsVisibilityStatus) => subModelsVisibilityStatus.state !== "hidden" ? createVisibilityStatus("partial") : createVisibilityStatus("hidden")));
+                        }
+                        return of(createVisibilityStatus("hidden"));
                     }));
                 }
-                return from(this._idsCache.getModelCategoryIds(modelId)).pipe(mergeMap(({ drawing, spatial }) => merge(of(drawing).pipe(mergeMap((categoryIds) => this.getCategoryDisplayStatus({ modelId, categoryIds, type: "DrawingCategory" }))), of(spatial).pipe(mergeMap((categoryIds) => this.getCategoryDisplayStatus({ modelId, categoryIds, type: "SpatialCategory" }))))), mergeVisibilityStatuses);
+                // For visible models we need to check all categories
+                return this.getCategories({ modelIds: modelId }).pipe(mergeMap(({ drawingCategories, spatialCategories }) => merge(drawingCategories
+                    ? of(drawingCategories).pipe(mergeMap((categoryIds) => this.getCategoriesVisibilityStatus({ modelId, categoryIds, type: "DrawingCategory" })))
+                    : EMPTY, spatialCategories
+                    ? of(spatialCategories).pipe(mergeMap((categoryIds) => this.getCategoriesVisibilityStatus({ modelId, categoryIds, type: "SpatialCategory" })))
+                    : EMPTY)), defaultIfEmpty(createVisibilityStatus("visible")));
             }), mergeVisibilityStatuses);
         });
-        return createVisibilityHandlerResult(this, { ids: modelIds }, result, undefined);
+        return createVisibilityHandlerResult(this, { modelIds }, result, undefined);
     }
-    getDefaultModelsCategoryVisibilityStatus({ modelId, categoryIds }) {
-        const viewport = this._props.viewport;
-        if (!viewport.view.viewsModel(modelId)) {
-            return createVisibilityStatus("hidden");
-        }
-        let visibleCount = 0;
-        let hiddenCount = 0;
-        let visibleThroughCategorySelectorCount = 0;
-        for (const categoryId of categoryIds) {
-            if (viewport.view.viewsCategory(categoryId)) {
-                ++visibleThroughCategorySelectorCount;
-            }
-            const override = this._props.viewport.perModelCategoryVisibility.getOverride(modelId, categoryId);
-            if (override === PerModelCategoryVisibility.Override.Show) {
-                ++visibleCount;
-                continue;
+    getVisibleModelCategoriesVisibilityStatus({ modelId, categoryIds }) {
+        return merge(this.getVisibilityFromAlwaysAndNeverDrawnElements({
+            queryProps: { modelId, categoryIds },
+            defaultStatus: () => this.getVisibleModelDefaultCategoriesVisibilityStatus({ modelId, categoryIds }),
+        }), this.getSubModels({ modelId, categoryIds }).pipe(mergeMap(({ subModels }) => {
+            if (subModels && Id64.sizeOf(subModels) > 0) {
+                return this.getModelsVisibilityStatus({ modelIds: subModels });
             }
-            if (override === PerModelCategoryVisibility.Override.Hide) {
-                ++hiddenCount;
-                continue;
+            return EMPTY;
+        }))).pipe(mergeVisibilityStatuses);
+    }
+    getVisibileCategorySubCategoriesVisibilityStatus(props) {
+        const { subCategoryIds } = props;
+        let subCategoryVisiblity = "unknown";
+        for (const subCategoryId of Id64.iterable(subCategoryIds)) {
+            const isSubCategoryVisible = this._props.viewport.isSubCategoryVisible(subCategoryId);
+            if (isSubCategoryVisible && subCategoryVisiblity === "hidden") {
+                return createVisibilityStatus("partial");
             }
-            if (visibleCount > 0 && hiddenCount > 0) {
+            if (!isSubCategoryVisible && subCategoryVisiblity === "visible") {
                 return createVisibilityStatus("partial");
             }
+            subCategoryVisiblity = isSubCategoryVisible ? "visible" : "hidden";
         }
-        if (hiddenCount + visibleCount > 0) {
-            return createVisibilityStatus(hiddenCount > 0 ? "hidden" : "visible");
-        }
-        return createVisibilityStatus(visibleThroughCategorySelectorCount > 0 ? "visible" : "hidden");
-    }
-    getDefaultCategoryVisibilityStatus({ categoryIds }) {
-        const result = from(categoryIds).pipe(mergeMap(async (categoryId) => {
-            let visibility = "unknown";
-            const categoryModels = [...(await this._idsCache.getCategoriesElementModels([categoryId], true)).values()].flat();
-            let nonDefaultModelDisplayStatesCount = 0;
-            for (const modelId of categoryModels) {
-                if (!this._props.viewport.view.viewsModel(modelId)) {
-                    if (visibility === "visible") {
-                        return createVisibilityStatus("partial");
+        // If visibility is unknown, no subCategories were provided,
+        // Since category is visible we return visible
+        return createVisibilityStatus(subCategoryVisiblity === "unknown" ? "visible" : subCategoryVisiblity);
+    }
+    getSubCategoriesVisibilityStatus(props) {
+        const result = defer(() => {
+            return (props.modelId ? of({ id: props.categoryId, models: props.modelId }) : from(this.getModels({ categoryIds: props.categoryId }))).pipe(map(({ models }) => {
+                let visibility = "unknown";
+                let nonDefaultModelDisplayStatesCount = 0;
+                for (const modelId of Id64.iterable(models ?? [])) {
+                    if (!this._props.viewport.view.viewsModel(modelId)) {
+                        if (visibility === "visible") {
+                            return createVisibilityStatus("partial");
+                        }
+                        visibility = "hidden";
+                        ++nonDefaultModelDisplayStatesCount;
+                        continue;
                     }
-                    visibility = "hidden";
-                    ++nonDefaultModelDisplayStatesCount;
-                    continue;
-                }
-                const override = this._props.viewport.perModelCategoryVisibility.getOverride(modelId, categoryId);
-                if (override === PerModelCategoryVisibility.Override.Show) {
-                    if (visibility === "hidden") {
-                        return createVisibilityStatus("partial");
+                    const override = this._props.viewport.perModelCategoryVisibility.getOverride(modelId, props.categoryId);
+                    if (override === PerModelCategoryVisibility.Override.Show) {
+                        if (visibility === "hidden") {
+                            return createVisibilityStatus("partial");
+                        }
+                        visibility = "visible";
+                        ++nonDefaultModelDisplayStatesCount;
+                        continue;
+                    }
+                    if (override === PerModelCategoryVisibility.Override.Hide) {
+                        if (visibility === "visible") {
+                            return createVisibilityStatus("partial");
+                        }
+                        visibility = "hidden";
+                        ++nonDefaultModelDisplayStatesCount;
+                        continue;
                     }
-                    visibility = "visible";
-                    ++nonDefaultModelDisplayStatesCount;
-                    continue;
                 }
-                if (override === PerModelCategoryVisibility.Override.Hide) {
-                    if (visibility === "visible") {
+                if (models && Id64.sizeOf(models) > 0 && nonDefaultModelDisplayStatesCount === Id64.sizeOf(models)) {
+                    assert(visibility === "visible" || visibility === "hidden");
+                    return createVisibilityStatus(visibility);
+                }
+                if (!this._props.viewport.view.viewsCategory(props.categoryId)) {
+                    return createVisibilityStatus(visibility === "visible" ? "partial" : "hidden");
+                }
+                if (Id64.sizeOf(props.subCategoryIds) === 0) {
+                    if (visibility === "hidden") {
                         return createVisibilityStatus("partial");
                     }
-                    visibility = "hidden";
-                    ++nonDefaultModelDisplayStatesCount;
-                    continue;
+                    return createVisibilityStatus("visible");
                 }
+                const subCategoriesVisibility = this.getVisibileCategorySubCategoriesVisibilityStatus({ subCategoryIds: props.subCategoryIds });
+                return subCategoriesVisibility.state === visibility || visibility === "unknown" ? subCategoriesVisibility : createVisibilityStatus("partial");
+            }), mergeVisibilityStatuses);
+        });
+        return createVisibilityHandlerResult(this, props, result, undefined);
+    }
+    getVisibleModelDefaultCategoriesVisibilityStatus({ modelId, categoryIds }) {
+        const viewport = this._props.viewport;
+        let visibleCount = 0;
+        for (const categoryId of Id64.iterable(categoryIds)) {
+            const override = this._props.viewport.perModelCategoryVisibility.getOverride(modelId, categoryId);
+            if (override === PerModelCategoryVisibility.Override.Show ||
+                (override === PerModelCategoryVisibility.Override.None && viewport.view.viewsCategory(categoryId))) {
+                ++visibleCount;
+                continue;
             }
-            if (categoryModels.length > 0 && nonDefaultModelDisplayStatesCount === categoryModels.length) {
-                assert(visibility === "visible" || visibility === "hidden");
-                return createVisibilityStatus(visibility);
-            }
-            if (!this._props.viewport.view.viewsCategory(categoryId)) {
-                return createVisibilityStatus(visibility === "visible" ? "partial" : "hidden");
-            }
-            if (visibility === "hidden") {
+            if (visibleCount > 0) {
                 return createVisibilityStatus("partial");
             }
-            return createVisibilityStatus("visible");
-        }), mergeVisibilityStatuses);
-        return result;
+        }
+        return visibleCount > 0 ? createVisibilityStatus("visible") : createVisibilityStatus("hidden");
     }
-    getCategoryDisplayStatus(props) {
+    getCategoriesVisibilityStatus(props) {
         const result = defer(() => {
-            if (props.categoryIds.length === 0) {
+            const { categoryIds, modelId: modelIdFromProps, type } = props;
+            if (Id64.sizeOf(categoryIds) === 0) {
                 return EMPTY;
             }
-            const isSupportedInView = (this._props.viewport.view.is3d() && props.type === "SpatialCategory") || (this._props.viewport.view.is2d() && props.type === "DrawingCategory");
+            const isSupportedInView = (this._props.viewport.view.is3d() && type === "SpatialCategory") || (this._props.viewport.view.is2d() && type === "DrawingCategory");
             if (!isSupportedInView) {
                 return of(createVisibilityStatus("disabled"));
             }
-            const modelsObservable = props.modelId
-                ? of(new Map(props.categoryIds.map((id) => [id, [props.modelId]])))
-                : from(this._idsCache.getCategoriesElementModels(props.categoryIds));
-            return merge(
-            // get visibility status from always and never drawn elements
-            modelsObservable.pipe(mergeMap((categoryModelsMap) => {
-                if (categoryModelsMap.size === 0) {
-                    return props.modelId
-                        ? of(this.getDefaultModelsCategoryVisibilityStatus({ modelId: props.modelId, categoryIds: props.categoryIds }))
-                        : from(this.getDefaultCategoryVisibilityStatus({ categoryIds: props.categoryIds }));
+            return (modelIdFromProps
+                ? from(Id64.iterable(categoryIds)).pipe(map((categoryId) => ({ id: categoryId, models: modelIdFromProps })))
+                : this.getModels({ categoryIds })).pipe(map(({ id, models }) => {
+                const acc = { categoryId: id, visibleModels: new Array(), hiddenModels: new Array() };
+                if (!models) {
+                    return acc;
                 }
-                return from(categoryModelsMap).pipe(mergeMap(([category, models]) => from(models).pipe(mergeMap((model) => {
-                    if (this._props.viewport.view.viewsModel(model)) {
-                        return this.getVisibilityFromAlwaysAndNeverDrawnElements({
-                            queryProps: props,
-                            defaultStatus: () => this.getDefaultModelsCategoryVisibilityStatus({ modelId: model, categoryIds: [category] }),
-                        }).pipe(mergeMap((visibilityStatusAlwaysAndNeverDraw) => {
-                            return from(this._idsCache.getCategoriesModeledElements(model, [category])).pipe(getSubModeledElementsVisibilityStatus({
-                                parentNodeVisibilityStatus: visibilityStatusAlwaysAndNeverDraw,
-                                getModelVisibilityStatus: (modelProps) => this.getModelVisibilityStatus(modelProps),
-                            }));
-                        }));
+                for (const modelId of Id64.iterable(models)) {
+                    if (this._props.viewport.view.viewsModel(modelId)) {
+                        acc.visibleModels.push(modelId);
                     }
-                    return from(this._idsCache.getCategoriesModeledElements(model, [category])).pipe(getSubModeledElementsVisibilityStatus({
-                        parentNodeVisibilityStatus: createVisibilityStatus("hidden"),
-                        getModelVisibilityStatus: (modelProps) => this.getModelVisibilityStatus(modelProps),
-                    }));
-                }))), mergeVisibilityStatuses);
-            }), map((visibilityStatus) => {
-                return { visibilityStatus, type: 0 };
-            })), 
-            // get category status
-            (props.modelId
-                ? of(this.getDefaultModelsCategoryVisibilityStatus({ modelId: props.modelId, categoryIds: props.categoryIds }))
-                : from(this.getDefaultCategoryVisibilityStatus({ categoryIds: props.categoryIds }))).pipe(map((visibilityStatus) => {
-                return { visibilityStatus, type: 1 };
-            }))).pipe(toArray(), mergeMap(async (visibilityStatusesInfo) => {
-                let defaultStatus;
-                let alwaysNeverDrawStatus;
-                visibilityStatusesInfo.forEach((visibilityStatusInfo) => {
-                    switch (visibilityStatusInfo.type) {
-                        case 0:
-                            alwaysNeverDrawStatus = visibilityStatusInfo.visibilityStatus;
-                            break;
-                        case 1:
-                            defaultStatus = visibilityStatusInfo.visibilityStatus;
-                            break;
+                    else {
+                        acc.hiddenModels.push(modelId);
                     }
-                });
-                assert(defaultStatus !== undefined);
-                if (defaultStatus.state === "partial") {
-                    return defaultStatus;
-                }
-                // This can happen if:
-                // a) showElements is set to false
-                // b) root category does not have any elements (that dont have Parent)
-                // In both cases we don't need to look at modeled elements visibility
-                if (alwaysNeverDrawStatus === undefined) {
-                    return defaultStatus;
-                }
-                // In cases where Category has model (it means that category is under hidden subModel)
-                // We don't need to look at default category status, it is already accounted for in always/never drawn visibility
-                if (props.modelId) {
-                    return alwaysNeverDrawStatus;
                 }
-                if (alwaysNeverDrawStatus.state === "partial" || alwaysNeverDrawStatus.state !== defaultStatus.state) {
-                    return createVisibilityStatus("partial");
-                }
-                return alwaysNeverDrawStatus;
-            }));
+                return acc;
+            }), mergeMap(({ categoryId, visibleModels, hiddenModels }) => {
+                return merge(
+                // For hidden models we only need to check subModels
+                hiddenModels.length > 0
+                    ? this.getSubModels({ modelIds: hiddenModels }).pipe(mergeMap(({ subModels }) => {
+                        if (subModels && Id64.sizeOf(subModels) > 0) {
+                            return this.getModelsVisibilityStatus({
+                                modelIds: subModels,
+                            }).pipe(map((subModelsVisibilityStatus) => subModelsVisibilityStatus.state !== "hidden" ? createVisibilityStatus("partial") : createVisibilityStatus("hidden")));
+                        }
+                        return of(createVisibilityStatus("hidden"));
+                    }))
+                    : EMPTY, 
+                // For visible models we need to check all categories
+                visibleModels.length > 0
+                    ? from(visibleModels).pipe(mergeMap((modelId) => this.getVisibleModelCategoriesVisibilityStatus({
+                        modelId,
+                        categoryIds: categoryId,
+                    })))
+                    : EMPTY, 
+                // We need to check subCategories as well
+                this.getSubCategories({ categoryIds: categoryId }).pipe(mergeMap(({ subCategories }) => {
+                    if (subCategories && Id64.sizeOf(subCategories) > 0) {
+                        return this.getSubCategoriesVisibilityStatus({ categoryId, modelId: modelIdFromProps, subCategoryIds: subCategories });
+                    }
+                    return EMPTY;
+                }))).pipe(defaultIfEmpty(createVisibilityStatus(this._props.viewport.view.viewsCategory(categoryId) ? "visible" : "hidden")));
+            }), mergeVisibilityStatuses);
         });
         return createVisibilityHandlerResult(this, props, result, undefined);
     }
-    getVisibilityFromAlwaysAndNeverDrawnElements(props) {
-        const viewport = this._props.viewport;
-        if (viewport.isAlwaysDrawnExclusive) {
-            if (!viewport?.alwaysDrawn?.size) {
-                return of(createVisibilityStatus("hidden"));
-            }
-        }
-        else if (!viewport?.neverDrawn?.size && !viewport?.alwaysDrawn?.size) {
-            return of(props.defaultStatus());
-        }
-        if ("elements" in props) {
-            return of(getVisibilityFromAlwaysAndNeverDrawnElementsImpl({
-                ...props,
-                alwaysDrawn: viewport.alwaysDrawn?.size ? setIntersection(props.elements, viewport.alwaysDrawn) : undefined,
-                neverDrawn: viewport.neverDrawn?.size ? setIntersection(props.elements, viewport.neverDrawn) : undefined,
-                totalCount: props.elements.size,
-                viewport,
-            }));
-        }
-        const { modelId, categoryIds } = props.queryProps;
-        const totalCount = (modelId ? of(new Map(categoryIds.map((categoryId) => [categoryId, [modelId]]))) : from(this._idsCache.getCategoriesElementModels(categoryIds))).pipe(mergeMap((categoriesMap) => from(categoriesMap)), mergeMap(([categoryId, modelIds]) => {
-            return from(modelIds).pipe(mergeMap((modelOfCategory) => from(this._idsCache.getCategoryElementsCount(modelOfCategory, categoryId))), reduce((acc, specificModelCategoryCount) => acc + specificModelCategoryCount, 0));
-        }));
-        return forkJoin({
-            totalCount,
-            alwaysDrawn: this._alwaysAndNeverDrawnElements.getAlwaysDrawnElements(props.queryProps),
-            neverDrawn: this._alwaysAndNeverDrawnElements.getNeverDrawnElements(props.queryProps),
-        }).pipe(map((state) => {
-            return getVisibilityFromAlwaysAndNeverDrawnElementsImpl({
-                ...props,
-                ...state,
-                viewport,
-            });
-        }));
-    }
-    getGeometricElementDisplayStatus(props) {
+    getElementsVisibilityStatus(props) {
         const result = defer(() => {
-            const viewport = this._props.viewport;
-            const { elementId, modelId, categoryId, elementType } = props;
-            const isSupportedInView = (viewport.view.is3d() && elementType === "GeometricElement3d") || (viewport.view.is2d() && elementType === "GeometricElement2d");
+            const { elementIds, modelId, categoryId, type } = props;
+            const isSupportedInView = (this._props.viewport.view.is3d() && type === "GeometricElement3d") || (this._props.viewport.view.is2d() && type === "GeometricElement2d");
             if (!isSupportedInView) {
                 return of(createVisibilityStatus("disabled"));
             }
-            const viewsModel = viewport.view.viewsModel(modelId);
-            const elementStatus = getElementOverriddenVisibility({
-                elementId,
-                viewport,
-            });
-            return from(this._idsCache.hasSubModel(elementId)).pipe(mergeMap((hasSubModel) => (hasSubModel ? this.getModelVisibilityStatus({ modelIds: [elementId] }) : of(undefined))), map((subModelVisibilityStatus) => getElementVisibility(viewsModel, elementStatus, this.getDefaultModelsCategoryVisibilityStatus({ categoryIds: [categoryId], modelId }), subModelVisibilityStatus)));
+            // TODO: check child elements that are subModels
+            if (!this._props.viewport.view.viewsModel(modelId)) {
+                return from(elementIds).pipe(mergeMap((elementId) => from(this._idsCache.hasSubModel(elementId)).pipe(mergeMap((isSubModel) => {
+                    if (isSubModel) {
+                        return this.getModelsVisibilityStatus({
+                            modelIds: elementId,
+                        }).pipe(map((subModelVisibilityStatus) => subModelVisibilityStatus.state !== "hidden" ? createVisibilityStatus("partial") : createVisibilityStatus("hidden")));
+                    }
+                    return of(createVisibilityStatus("hidden"));
+                }))), mergeVisibilityStatuses);
+            }
+            // TODO: check child elements
+            // TODO: check child element categories
+            // TODO: check child elements that are subModels
+            return this.getVisibilityFromAlwaysAndNeverDrawnElements({
+                elements: elementIds,
+                defaultStatus: () => this.getVisibleModelDefaultCategoriesVisibilityStatus({ categoryIds: categoryId, modelId }),
+            }).pipe(mergeMap((visibilityStatusAlwaysAndNeverDraw) => {
+                return from(Id64.iterable(elementIds)).pipe(mergeMap((elementId) => from(this._idsCache.hasSubModel(elementId)).pipe(mergeMap((isSubModel) => {
+                    if (isSubModel) {
+                        return this.getModelsVisibilityStatus({
+                            modelIds: elementId,
+                        }).pipe(map((subModelVisibilityStatus) => subModelVisibilityStatus.state !== visibilityStatusAlwaysAndNeverDraw.state
+                            ? createVisibilityStatus("partial")
+                            : visibilityStatusAlwaysAndNeverDraw));
+                    }
+                    return of(visibilityStatusAlwaysAndNeverDraw);
+                }))), mergeVisibilityStatuses);
+            }));
         });
         return createVisibilityHandlerResult(this, props, result, undefined);
     }
     changeVisibilityObs(node, on) {
+        if (node.filtering?.filteredChildrenIdentifierPaths?.length && !node.filtering.isFilterTarget) {
+            return this.changeFilteredNodeVisibility({ node, on });
+        }
         if (!HierarchyNode.isInstancesNode(node)) {
             return EMPTY;
         }
         if (ClassificationsTreeNode.isClassificationTableNode(node)) {
-            return this.changeClassificationTableDisplayState({
+            return this.changeClassificationTablesVisibilityStatus({
                 classificationTableIds: node.key.instanceKeys.map((instanceKey) => instanceKey.id),
                 on,
             });
         }
         if (ClassificationsTreeNode.isClassificationNode(node)) {
-            return this.changeClassificationDisplayState({
+            return this.changeClassificationsVisibilityStatus({
                 classificationIds: node.key.instanceKeys.map((instanceKey) => instanceKey.id),
                 on,
             });
         }
-        return this.changeGeometricElementsDisplayState({
-            elementIds: new Set([...node.key.instanceKeys.map(({ id }) => id)]),
+        return this.changeElementsVisibilityStatus({
+            elementIds: node.key.instanceKeys.map(({ id }) => id),
             modelId: ClassificationsTreeNode.getModelId(node),
             categoryId: ClassificationsTreeNode.getCategoryId(node),
             on,
         });
     }
-    changeClassificationTableDisplayState(props) {
+    changeFilteredNodeVisibility({ on, ...props }) {
+        return from(this.getVisibilityChangeTargets(props)).pipe(mergeMap(({ classificationTableIds, classificationIds, elements2d, elements3d }) => {
+            const observables = new Array();
+            if (classificationTableIds?.size) {
+                observables.push(this.changeClassificationTablesVisibilityStatus({ classificationTableIds, on }));
+            }
+            if (classificationIds?.size) {
+                observables.push(this.changeClassificationsVisibilityStatus({ classificationIds, on }));
+            }
+            if (elements2d?.length) {
+                observables.push(from(elements2d).pipe(mergeMap(({ modelId, categoryId, elementIds }) => {
+                    return this.changeElementsVisibilityStatus({ modelId, categoryId, elementIds, on });
+                })));
+            }
+            if (elements3d?.length) {
+                observables.push(from(elements3d).pipe(mergeMap(({ modelId, categoryId, elementIds }) => {
+                    return this.changeElementsVisibilityStatus({ modelId, categoryId, elementIds, on });
+                })));
+            }
+            return merge(...observables);
+        }));
+    }
+    changeClassificationTablesVisibilityStatus(props) {
         const result = defer(() => {
-            return from(this._idsCache.getAllContainedCategories(props.classificationTableIds)).pipe(mergeMap(({ drawing, spatial }) => merge(drawing, spatial)), toArray(), mergeMap((categoryIds) => {
-                return this.changeCategoryDisplayState({ categoryIds, on: props.on });
-            }));
+            return from(this._idsCache.getAllContainedCategories(props.classificationTableIds)).pipe(mergeMap(({ drawing, spatial }) => merge(drawing, spatial)), toArray(), mergeMap((categoryIds) => this.changeCategoriesVisibilityStatus({ modelId: undefined, categoryIds, on: props.on })));
         });
         return createVisibilityHandlerResult(this, props, result, undefined);
     }
-    changeClassificationDisplayState(props) {
+    changeClassificationsVisibilityStatus(props) {
         const result = defer(() => {
-            return from(this._idsCache.getAllContainedCategories(props.classificationIds)).pipe(mergeMap(({ drawing, spatial }) => merge(drawing, spatial)), toArray(), mergeMap((categoryIds) => {
-                return this.changeCategoryDisplayState({ categoryIds, on: props.on });
-            }));
+            return from(this._idsCache.getAllContainedCategories(props.classificationIds)).pipe(mergeMap(({ drawing, spatial }) => merge(drawing, spatial)), toArray(), mergeMap((categoryIds) => this.changeCategoriesVisibilityStatus({ modelId: undefined, categoryIds, on: props.on })));
         });
         return createVisibilityHandlerResult(this, props, result, undefined);
     }
-    changeModelDisplayState(props) {
+    changeModelsVisibilityStatus(props) {
         const { modelIds, on } = props;
         if (Id64.sizeOf(modelIds) === 0) {
             return EMPTY;
@@ -387,37 +431,44 @@ class ClassificationsTreeVisibilityHandlerImpl {
         const result = defer(() => {
             const viewport = this._props.viewport;
             viewport.perModelCategoryVisibility.clearOverrides(modelIds);
-            const idsObs = from(Id64.iterable(modelIds));
             if (!on) {
                 viewport.changeModelDisplay(modelIds, false);
-                return idsObs.pipe(mergeMap(async (modelId) => ({ modelId, categoryIds: await this._idsCache.getModelCategoryIds(modelId) })), mergeMap(({ modelId, categoryIds }) => from(this._idsCache.getCategoriesModeledElements(modelId, [...categoryIds.drawing, ...categoryIds.spatial]))), mergeMap((modeledElementIds) => this.changeModelDisplayState({ modelIds: modeledElementIds, on })));
+                return this.getSubModels({ modelIds }).pipe(mergeMap(({ subModels }) => (subModels ? this.changeModelsVisibilityStatus({ modelIds: subModels, on }) : EMPTY)));
             }
-            return concat(from(viewport.addViewedModels(modelIds)), idsObs.pipe(mergeMap((modelId) => {
-                return from(this._idsCache.getModelCategoryIds(modelId)).pipe(mergeMap(({ drawing, spatial }) => merge(drawing, spatial)), mergeMap((categoryId) => this.changeCategoryDisplayState({ categoryIds: [categoryId], modelId, on })));
+            return concat(from(viewport.addViewedModels(modelIds)), this.getCategories({ modelIds }).pipe(mergeMap(({ id, drawingCategories, spatialCategories }) => {
+                return merge(drawingCategories ? this.changeCategoriesVisibilityStatus({ categoryIds: drawingCategories, modelId: id, on }) : EMPTY, spatialCategories ? this.changeCategoriesVisibilityStatus({ categoryIds: spatialCategories, modelId: id, on }) : EMPTY);
             })));
         });
         return createVisibilityHandlerResult(this, props, result, undefined);
     }
-    showModelWithoutAnyCategoriesOrElements(modelId) {
+    showModelWithoutAnyCategoriesOrElements(modelId, categoriesToNotOverride) {
         const viewport = this._props.viewport;
         return forkJoin({
-            categories: this._idsCache.getModelCategoryIds(modelId),
-            alwaysDrawnElements: this._alwaysAndNeverDrawnElements.getAlwaysDrawnElements({ modelId }),
-        }).pipe(mergeMap(async ({ categories, alwaysDrawnElements }) => {
+            allModelCategories: this.getCategories({ modelIds: modelId }).pipe(reduce((acc, { drawingCategories, spatialCategories }) => {
+                for (const category of Id64.iterable(drawingCategories ?? [])) {
+                    acc.add(category);
+                }
+                for (const category of Id64.iterable(spatialCategories ?? [])) {
+                    acc.add(category);
+                }
+                return acc;
+            }, new Set())),
+            modelAlwaysDrawnElements: this._alwaysAndNeverDrawnElements.getAlwaysDrawnElements({ modelId }),
+        }).pipe(mergeMap(async ({ allModelCategories, modelAlwaysDrawnElements }) => {
             const alwaysDrawn = this._props.viewport.alwaysDrawn;
-            if (alwaysDrawn && alwaysDrawnElements) {
-                viewport.setAlwaysDrawn(setDifference(alwaysDrawn, alwaysDrawnElements));
+            if (alwaysDrawn && modelAlwaysDrawnElements) {
+                viewport.setAlwaysDrawn(setDifference(alwaysDrawn, modelAlwaysDrawnElements));
             }
-            categories.drawing.forEach((categoryId) => {
-                this.changeCategoryStateInViewportAccordingToModelVisibility(modelId, categoryId, false);
-            });
-            categories.spatial.forEach((categoryId) => {
-                this.changeCategoryStateInViewportAccordingToModelVisibility(modelId, categoryId, false);
+            const categoriesToOverride = categoriesToNotOverride
+                ? setDifference(allModelCategories, getSetFromId64Arg(categoriesToNotOverride))
+                : allModelCategories;
+            categoriesToOverride.forEach((categoryId) => {
+                this.changeCategoryStateInViewportAccordingToModelVisibility(modelId, categoryId, false, false);
             });
             await viewport.addViewedModels(modelId);
         }));
     }
-    changeCategoryStateInViewportAccordingToModelVisibility(modelId, categoryId, on) {
+    changeCategoryStateInViewportAccordingToModelVisibility(modelId, categoryId, on, changeSubCategories) {
         const viewport = this._props.viewport;
         const isDisplayedInSelector = viewport.view.viewsCategory(categoryId);
         const override = on === isDisplayedInSelector
@@ -429,44 +480,88 @@ class ClassificationsTreeVisibilityHandlerImpl {
         if (override === PerModelCategoryVisibility.Override.None && on) {
             // we took off the override which means the category is displayed in selector, but
             // doesn't mean all its subcategories are displayed - this call ensures that
-            viewport.changeCategoryDisplay(categoryId, true);
+            viewport.changeCategoryDisplay(categoryId, true, changeSubCategories);
         }
     }
-    changeCategoryDisplayState(props) {
+    changeCategoriesVisibilityStatus(props) {
         const result = defer(() => {
-            const { modelId, categoryIds, on } = props;
+            const { modelId: modelIdFromProps, categoryIds, on } = props;
             const viewport = this._props.viewport;
-            const modelIdsObservable = modelId
-                ? of(new Map(categoryIds.map((id) => [id, [modelId]])))
-                : from(this._idsCache.getCategoriesElementModels(categoryIds, true));
-            return concat(modelId ? EMPTY : from(enableCategoryDisplay(viewport, categoryIds, on)), on
-                ? modelIdsObservable.pipe(mergeMap((categoriesMap) => from(categoriesMap.values())), mergeAll(), filter((modelIdToCheck) => !viewport.view.viewsModel(modelIdToCheck)), mergeMap((modelIdToCheck) => this.showModelWithoutAnyCategoriesOrElements(modelIdToCheck)))
-                : EMPTY, modelIdsObservable.pipe(mergeMap((categoriesMap) => from(categoriesMap.entries())), mergeMap(([categoryId, modelIds]) => {
-                return from(modelIds).pipe(mergeMap((modelOfCategory) => {
-                    this.changeCategoryStateInViewportAccordingToModelVisibility(modelOfCategory, categoryId, on);
-                    return this._alwaysAndNeverDrawnElements.clearAlwaysAndNeverDrawnElements({ modelId: modelOfCategory, categoryIds: [categoryId] });
-                }));
-            })), modelIdsObservable.pipe(mergeMap((categoriesMap) => from(categoriesMap.entries())), mergeMap(([categoryId, modelIds]) => {
-                return from(modelIds).pipe(mergeMap((modelOfCategory) => from(this._idsCache.getCategoriesModeledElements(modelOfCategory, [categoryId])).pipe(mergeMap((modeledElementIds) => this.changeModelDisplayState({ modelIds: modeledElementIds, on })))));
-            })));
+            const modelIdsObservable = (modelIdFromProps
+                ? of(new Map([[modelIdFromProps, getSetFromId64Arg(categoryIds)]]))
+                : this.getModels({ categoryIds }).pipe(reduce((acc, { id, models }) => {
+                    if (!models) {
+                        return acc;
+                    }
+                    for (const modelId of Id64.iterable(models)) {
+                        let entry = acc.get(modelId);
+                        if (!entry) {
+                            entry = new Set();
+                            acc.set(modelId, entry);
+                        }
+                        entry.add(id);
+                    }
+                    return acc;
+                }, new Map()))).pipe(mergeMap((modelCategoriesMap) => modelCategoriesMap.entries()), shareReplay());
+            return concat(
+            // If modelId was provided: add override
+            // If modelId was not provided: change categoryDisplay and remove categories per model overrides
+            modelIdFromProps
+                ? of(viewport.perModelCategoryVisibility.setOverride(modelIdFromProps, categoryIds, on ? PerModelCategoryVisibility.Override.Show : PerModelCategoryVisibility.Override.Hide))
+                : concat(from(enableCategoryDisplay(viewport, categoryIds, on, on)), modelIdsObservable.pipe(map(([modelId, modelCategories]) => {
+                    viewport.perModelCategoryVisibility.setOverride(modelId, modelCategories, PerModelCategoryVisibility.Override.None);
+                }))), 
+            // If categories visibility needs to be turned on, we need to turn on models without turning on unrelated elements or categories for that model
+            on
+                ? modelIdsObservable.pipe(mergeMap(([modelId, categories]) => {
+                    if (!viewport.view.viewsModel(modelId)) {
+                        return this.showModelWithoutAnyCategoriesOrElements(modelId, categories);
+                    }
+                    return EMPTY;
+                }))
+                : EMPTY, this._alwaysAndNeverDrawnElements.clearAlwaysAndNeverDrawnElements({ categoryIds, modelId: modelIdFromProps }), this.getSubModels({ categoryIds, modelId: modelIdFromProps }).pipe(mergeMap(({ subModels }) => (subModels ? this.changeModelsVisibilityStatus({ modelIds: subModels, on }) : EMPTY))));
         });
         return createVisibilityHandlerResult(this, props, result, undefined);
     }
-    changeGeometricElementsDisplayState(props) {
-        const { modelId, categoryId, elementIds, on } = props;
-        const viewport = this._props.viewport;
-        const result = concat(on && !viewport.view.viewsModel(modelId) ? this.showModelWithoutAnyCategoriesOrElements(modelId) : EMPTY, defer(() => {
-            const categoryVisibility = this.getDefaultModelsCategoryVisibilityStatus({ categoryIds: [categoryId], modelId });
-            const isDisplayedByDefault = categoryVisibility.state === "visible";
-            return this.queueElementsVisibilityChange(elementIds, on, isDisplayedByDefault);
-        }), from(elementIds).pipe(mergeMap(async (elementId) => ({ elementId, isSubModel: await this._idsCache.hasSubModel(elementId) })), filter(({ isSubModel }) => isSubModel), map(({ elementId }) => elementId), toArray(), mergeMap((subModelIds) => this.changeModelDisplayState({ modelIds: subModelIds, on }))));
+    changeElementsVisibilityStatus(props) {
+        const result = defer(() => {
+            const { modelId, categoryId, elementIds, on } = props;
+            const viewport = this._props.viewport;
+            // TODO: change child elements
+            // TODO: change child element categories
+            // TODO: change child subModels
+            return concat(
+            // Change elements state
+            defer(() => {
+                if (!viewport.view.viewsModel(modelId)) {
+                    if (!on) {
+                        return this.queueElementsVisibilityChange(elementIds, on, false);
+                    }
+                    return this.showModelWithoutAnyCategoriesOrElements(modelId).pipe(mergeMap(() => {
+                        const defaultVisibility = this.getVisibleModelDefaultCategoriesVisibilityStatus({ categoryIds: categoryId, modelId });
+                        const displayedByDefault = defaultVisibility.state === "visible";
+                        return this.queueElementsVisibilityChange(elementIds, on, displayedByDefault);
+                    }));
+                }
+                const categoryVisibility = this.getVisibleModelDefaultCategoriesVisibilityStatus({ categoryIds: categoryId, modelId });
+                const isDisplayedByDefault = categoryVisibility.state === "visible";
+                return this.queueElementsVisibilityChange(elementIds, on, isDisplayedByDefault);
+            }), 
+            // Change visibility of elements that are models
+            from(Id64.iterable(elementIds)).pipe(mergeMap((elementId) => from(this._idsCache.hasSubModel(elementId)).pipe(mergeMap((isSubModel) => {
+                if (isSubModel) {
+                    return this.changeModelsVisibilityStatus({ modelIds: elementId, on });
+                }
+                return EMPTY;
+            })))));
+        });
         return createVisibilityHandlerResult(this, props, result, undefined);
     }
     queueElementsVisibilityChange(elementIds, on, visibleByDefault) {
         const finishedSubject = new Subject();
         // observable to track if visibility change is finished/cancelled
         const changeFinished = finishedSubject.pipe(startWith(false), shareReplay(1), filter((finished) => finished));
-        const changeObservable = from(elementIds).pipe(
+        const changeObservable = from(Id64.iterable(elementIds)).pipe(
         // check if visibility change is not finished (cancelled) due to change overall change request being cancelled
         takeUntil(changeFinished), changeElementStateNoChildrenOperator({ on, isDisplayedByDefault: visibleByDefault, viewport: this._props.viewport }), tap({
             next: () => {
@@ -484,5 +579,67 @@ class ClassificationsTreeVisibilityHandlerImpl {
             },
         }), map(() => undefined));
     }
+    getVisibilityFromAlwaysAndNeverDrawnElements(props) {
+        const viewport = this._props.viewport;
+        if (viewport.isAlwaysDrawnExclusive) {
+            if (!viewport?.alwaysDrawn?.size) {
+                return of(createVisibilityStatus("hidden"));
+            }
+        }
+        else if (!viewport?.neverDrawn?.size && !viewport?.alwaysDrawn?.size) {
+            return of(props.defaultStatus());
+        }
+        if ("elements" in props) {
+            return of(getVisibilityFromAlwaysAndNeverDrawnElementsImpl({
+                ...props,
+                alwaysDrawn: viewport.alwaysDrawn?.size ? setIntersection(Id64.iterable(props.elements), viewport.alwaysDrawn) : undefined,
+                neverDrawn: viewport.neverDrawn?.size ? setIntersection(Id64.iterable(props.elements), viewport.neverDrawn) : undefined,
+                totalCount: Id64.sizeOf(props.elements),
+                viewport,
+            }));
+        }
+        const { modelId, categoryIds } = props.queryProps;
+        const totalCount = from(Id64.iterable(categoryIds)).pipe(mergeMap((categoryId) => this.getElementsCount({ modelId, categoryId })), reduce((acc, specificModelCategoryCount) => {
+            return acc + specificModelCategoryCount;
+        }, 0));
+        return forkJoin({
+            totalCount,
+            alwaysDrawn: this._alwaysAndNeverDrawnElements.getAlwaysDrawnElements(props.queryProps),
+            neverDrawn: this._alwaysAndNeverDrawnElements.getNeverDrawnElements(props.queryProps),
+        }).pipe(map((state) => {
+            return getVisibilityFromAlwaysAndNeverDrawnElementsImpl({
+                ...props,
+                ...state,
+                viewport,
+            });
+        }));
+    }
+    getCategories(props) {
+        return from(Id64.iterable(props.modelIds)).pipe(mergeMap((modelId) => from(this._props.idsCache.getModelCategoryIds(modelId)).pipe(map(({ spatial, drawing }) => ({ id: modelId, drawingCategories: drawing, spatialCategories: spatial })))));
+    }
+    getElementsCount(props) {
+        return from(this._props.idsCache.getCategoryElementsCount(props.modelId, props.categoryId));
+    }
+    getModels(props) {
+        return from(Id64.iterable(props.categoryIds)).pipe(mergeMap((categoryId) => from(this._props.idsCache.getCategoriesElementModels(categoryId, true)).pipe(mergeMap((categoryModelsMap) => (categoryModelsMap.size > 0 ? categoryModelsMap.values() : of(new Array()))), map((categoryModels) => ({ id: categoryId, models: categoryModels })))));
+    }
+    getSubCategories(props) {
+        return from(Id64.iterable(props.categoryIds)).pipe(map((categoryId) => ({ id: categoryId, subCategories: undefined })));
+    }
+    getSubModels(props) {
+        if ("modelIds" in props) {
+            return from(Id64.iterable(props.modelIds)).pipe(mergeMap((modelId) => from(this._props.idsCache.getModelCategoryIds(modelId)).pipe(mergeMap(({ drawing, spatial }) => merge(drawing, spatial)), toArray(), mergeMap((categoryIds) => from(this._props.idsCache.getCategoriesModeledElements(modelId, categoryIds))), map((subModels) => ({ id: modelId, subModels })))));
+        }
+        if (props.modelId) {
+            return from(Id64.iterable(props.categoryIds)).pipe(mergeMap((categoryId) => from(this._props.idsCache.getCategoriesModeledElements(props.modelId, categoryId)).pipe(map((subModels) => ({ id: categoryId, subModels })))));
+        }
+        return from(Id64.iterable(props.categoryIds)).pipe(mergeMap((categoryId) => from(this._props.idsCache.getCategoriesElementModels(categoryId)).pipe(mergeMap((categoryModelsMap) => {
+            const models = categoryModelsMap.get(categoryId);
+            if (!models) {
+                return of({ id: categoryId, subModels: undefined });
+            }
+            return from(models).pipe(mergeMap((modelId) => from(this._props.idsCache.getCategoriesModeledElements(modelId, categoryId))), map((subModels) => ({ id: categoryId, subModels })));
+        }))));
+    }
 }
 //# sourceMappingURL=ClassificationsTreeVisibilityHandler.js.map