@itwin/tree-widget-react 4.0.0-alpha.6 → 4.0.0-alpha.8

package/lib/esm/tree-widget-react/components/trees/models-tree/internal/ModelsTreeVisibilityHandler.js

@@ -2,19 +2,20 @@
  * 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, defer, distinct, EMPTY, filter, firstValueFrom, forkJoin, from, fromEventPattern, map, merge, mergeMap, of, reduce, shareReplay, startWith, Subject, take, takeUntil, tap, toArray, } from "rxjs";
+import { concat, concatAll, defaultIfEmpty, defer, distinct, EMPTY, filter, firstValueFrom, forkJoin, from, fromEventPattern, map, merge, mergeMap, of, 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 { toggleAllCategories } from "../../common/CategoriesVisibilityUtils.js";
-import { reduceWhile, toVoidPromise } from "../../common/Rxjs.js";
-import { createVisibilityStatus } from "../../common/Tooltip.js";
+import { AlwaysAndNeverDrawnElementInfo } from "../../common/internal/AlwaysAndNeverDrawnElementInfo.js";
+import { GEOMETRIC_ELEMENT_3D_CLASS_NAME } from "../../common/internal/ClassNameDefinitions.js";
+import { toVoidPromise } from "../../common/internal/Rxjs.js";
+import { createVisibilityStatus } from "../../common/internal/Tooltip.js";
+import { releaseMainThreadOnItemsCount, setDifference, setIntersection } from "../../common/internal/Utils.js";
+import { createVisibilityChangeEventListener } from "../../common/internal/VisibilityChangeEventListener.js";
+import { changeElementStateNoChildrenOperator, filterSubModeledElementIds, getElementOverriddenVisibility, getElementVisibility, getSubModeledElementsVisibilityStatus, getVisibilityFromAlwaysAndNeverDrawnElementsImpl, mergeVisibilityStatuses, } from "../../common/internal/VisibilityUtils.js";
 import { createVisibilityHandlerResult } from "../../common/UseHierarchyVisibility.js";
-import { releaseMainThreadOnItemsCount } from "../Utils.js";
-import { AlwaysAndNeverDrawnElementInfo } from "./AlwaysAndNeverDrawnElementInfo.js";
 import { createFilteredTree, parseCategoryKey } from "./FilteredTree.js";
 import { ModelsTreeNode } from "./ModelsTreeNode.js";
-import { createVisibilityChangeEventListener } from "./VisibilityChangeEventListener.js";
 /**
  * Creates an instance if `ModelsTreeVisibilityHandler`.
  * @internal
@@ -28,8 +29,15 @@ class ModelsTreeVisibilityHandlerImpl {
         this._elementChangeQueue = new Subject();
         this._subscriptions = [];
         this._changeRequest = new Subject();
-        this._eventListener = createVisibilityChangeEventListener(_props.viewport);
-        this._alwaysAndNeverDrawnElements = new AlwaysAndNeverDrawnElementInfo(_props.viewport);
+        this._eventListener = createVisibilityChangeEventListener({
+            viewport: _props.viewport,
+            listeners: {
+                models: true,
+                categories: true,
+                elements: true,
+            },
+        });
+        this._alwaysAndNeverDrawnElements = new AlwaysAndNeverDrawnElementInfo(_props.viewport, GEOMETRIC_ELEMENT_3D_CLASS_NAME);
         this._idsCache = this._props.idsCache;
         this._filteredTree = _props.filteredPaths ? createFilteredTree(this._props.imodelAccess, _props.filteredPaths) : undefined;
         this._subscriptions.push(this._elementChangeQueue.pipe(concatAll()).subscribe());
@@ -46,7 +54,7 @@ class ModelsTreeVisibilityHandlerImpl {
             this._eventListener.onVisibilityChange.addListener(handler);
         }, (handler) => {
             this._eventListener.onVisibilityChange.removeListener(handler);
-        }))));
+        })), defaultIfEmpty(createVisibilityStatus("hidden"))));
     }
     async changeVisibility(node, shouldDisplay) {
         // notify about new change request
@@ -69,8 +77,8 @@ class ModelsTreeVisibilityHandlerImpl {
         this[Symbol.dispose]();
     }
     [Symbol.dispose]() {
-        this._eventListener.dispose();
-        this._alwaysAndNeverDrawnElements.dispose();
+        this._eventListener[Symbol.dispose]();
+        this._alwaysAndNeverDrawnElements[Symbol.dispose]();
         this._subscriptions.forEach((x) => x.unsubscribe());
     }
     getVisibilityStatusObs(node) {
@@ -111,116 +119,85 @@ class ModelsTreeVisibilityHandlerImpl {
         });
     }
     getFilteredNodeVisibility(props) {
-        return from(this.getVisibilityChangeTargets(props)).pipe(mergeMap(({ subjects, models, categories, elements }) => {
+        return from(this.getVisibilityChangeTargets(props)).pipe(mergeMap(({ subjectIds: subjects, modelIds: models, categories, elements }) => {
             const observables = new Array();
             if (subjects?.size) {
-                observables.push(this.getSubjectNodeVisibilityStatus({ subjectIds: [...subjects], ignoreTooltip: true }));
+                observables.push(this.getSubjectNodeVisibilityStatus({ subjectIds: [...subjects] }));
             }
             if (models?.size) {
-                observables.push(from(models).pipe(mergeMap((modelId) => this.getModelVisibilityStatus({ modelId, ignoreTooltip: true }))));
+                observables.push(from(models).pipe(mergeMap((modelId) => this.getModelVisibilityStatus({ modelId }))));
             }
             if (categories?.size) {
                 observables.push(from(categories).pipe(mergeMap((key) => {
                     const { modelId, categoryId } = parseCategoryKey(key);
-                    return this.getCategoryDisplayStatus({ modelId, categoryId, ignoreTooltip: true });
+                    return this.getCategoryDisplayStatus({ modelId, categoryId });
                 })));
             }
             if (elements?.size) {
                 observables.push(from(elements).pipe(releaseMainThreadOnItemsCount(50), mergeMap(([categoryKey, elementIds]) => {
                     const { modelId, categoryId } = parseCategoryKey(categoryKey);
-                    return from(elementIds).pipe(releaseMainThreadOnItemsCount(1000), mergeMap((elementId) => this.getElementDisplayStatus({ modelId, categoryId, elementId, ignoreTooltip: true })));
+                    return from(elementIds).pipe(releaseMainThreadOnItemsCount(1000), mergeMap((elementId) => this.getElementDisplayStatus({ modelId, categoryId, elementId })));
                 })));
             }
             return merge(...observables);
-        }), map((x) => x.state), getVisibilityFromTreeNodeChildren, map((x) => {
-            assert(x !== "empty");
-            return createVisibilityStatus(x);
-        }));
+        }), mergeVisibilityStatuses);
     }
-    getSubjectNodeVisibilityStatus({ subjectIds, ignoreTooltip }) {
+    getSubjectNodeVisibilityStatus({ subjectIds }) {
         const result = defer(() => {
             if (!this._props.viewport.view.isSpatialView()) {
-                return of(createVisibilityStatus("disabled", getTooltipOptions("modelsTree.subject.nonSpatialView", ignoreTooltip)));
+                return of(createVisibilityStatus("disabled"));
             }
-            return from(this._idsCache.getSubjectModelIds(subjectIds)).pipe(concatAll(), distinct(), mergeMap((modelId) => this.getModelVisibilityStatus({ modelId, ignoreTooltip: true })), map((x) => x.state), getVisibilityStatusFromTreeNodeChildren({
-                visible: "modelsTree.subject.allModelsVisible",
-                hidden: "modelsTree.subject.allModelsHidden",
-                partial: "modelsTree.subject.someModelsHidden",
-            }, ignoreTooltip));
+            return from(this._idsCache.getSubjectModelIds(subjectIds)).pipe(concatAll(), distinct(), mergeMap((modelId) => this.getModelVisibilityStatus({ modelId })), mergeVisibilityStatuses);
         });
         return createVisibilityHandlerResult(this, { ids: subjectIds }, result, this._props.overrides?.getSubjectNodeVisibility);
     }
-    getModelVisibilityStatus({ modelId, ignoreTooltip }) {
+    getModelVisibilityStatus({ modelId }) {
         const result = defer(() => {
             const viewport = this._props.viewport;
             if (!viewport.view.isSpatialView()) {
-                return of(createVisibilityStatus("disabled", getTooltipOptions("modelsTree.model.nonSpatialView", ignoreTooltip)));
+                return of(createVisibilityStatus("disabled"));
             }
             if (!viewport.view.viewsModel(modelId)) {
-                return from(this._idsCache.getModelCategories(modelId)).pipe(mergeMap((categoryIds) => from(this._idsCache.getCategoriesModeledElements(modelId, categoryIds))), this.getSubModeledElementsVisibilityStatus({
-                    ignoreTooltips: ignoreTooltip,
-                    haveSubModel: "yes",
-                    tooltips: { visible: undefined, hidden: "modelsTree.model.hiddenThroughModelSelector", partial: "modelsTree.model.someSubModelsVisible" },
+                return from(this._idsCache.getModelCategoryIds(modelId)).pipe(mergeMap((categoryIds) => from(this._idsCache.getCategoriesModeledElements(modelId, categoryIds))), getSubModeledElementsVisibilityStatus({
                     parentNodeVisibilityStatus: createVisibilityStatus("hidden"),
+                    getModelVisibilityStatus: (modelProps) => this.getModelVisibilityStatus(modelProps),
                 }));
             }
-            return from(this._idsCache.getModelCategories(modelId)).pipe(concatAll(), mergeMap((categoryId) => this.getCategoryDisplayStatus({ modelId, categoryId, ignoreTooltip: true })), map((x) => x.state), getVisibilityFromTreeNodeChildren, map((visibilityByCategories) => {
-                const state = visibilityByCategories === "empty" ? "visible" : visibilityByCategories;
-                return createVisibilityStatus(state, getTooltipOptions(state === "partial" ? "modelsTree.model.someCategoriesHidden" : `modelsTree.model.allCategories${state ? "Visible" : "Hidden"}`, ignoreTooltip));
-            }));
+            return from(this._idsCache.getModelCategoryIds(modelId)).pipe(concatAll(), mergeMap((categoryId) => this.getCategoryDisplayStatus({ modelId, categoryId })), mergeVisibilityStatuses);
         });
         return createVisibilityHandlerResult(this, { id: modelId }, result, this._props.overrides?.getModelDisplayStatus);
     }
-    getDefaultCategoryVisibilityStatus({ modelId, categoryId, ignoreTooltip, }) {
+    getDefaultCategoryVisibilityStatus({ modelId, categoryId }) {
         const viewport = this._props.viewport;
         if (!viewport.view.viewsModel(modelId)) {
-            return createVisibilityStatus("hidden", getTooltipOptions("modelsTree.category.hiddenThroughModel", ignoreTooltip));
+            return createVisibilityStatus("hidden");
         }
         switch (this._props.viewport.perModelCategoryVisibility.getOverride(modelId, categoryId)) {
             case PerModelCategoryVisibility.Override.Show:
-                return createVisibilityStatus("visible", getTooltipOptions("modelsTree.category.displayedThroughPerModelOverride", ignoreTooltip));
+                return createVisibilityStatus("visible");
             case PerModelCategoryVisibility.Override.Hide:
-                return createVisibilityStatus("hidden", getTooltipOptions("modelsTree.category.hiddenThroughPerModelOverride", ignoreTooltip));
+                return createVisibilityStatus("hidden");
         }
-        const isVisible = viewport.view.viewsCategory(categoryId);
-        return isVisible
-            ? createVisibilityStatus("visible", getTooltipOptions("modelsTree.category.displayedThroughCategorySelector", ignoreTooltip))
-            : createVisibilityStatus("hidden", getTooltipOptions("modelsTree.category.hiddenThroughCategorySelector", ignoreTooltip));
+        return createVisibilityStatus(viewport.view.viewsCategory(categoryId) ? "visible" : "hidden");
     }
-    getCategoryDisplayStatus({ ignoreTooltip, ...props }) {
+    getCategoryDisplayStatus(props) {
         const result = defer(() => {
             if (!this._props.viewport.view.viewsModel(props.modelId)) {
-                return from(this._idsCache.getCategoriesModeledElements(props.modelId, [props.categoryId])).pipe(this.getSubModeledElementsVisibilityStatus({
-                    ignoreTooltips: ignoreTooltip,
+                return from(this._idsCache.getCategoriesModeledElements(props.modelId, [props.categoryId])).pipe(getSubModeledElementsVisibilityStatus({
                     parentNodeVisibilityStatus: createVisibilityStatus("hidden"),
-                    tooltips: {
-                        visible: undefined,
-                        hidden: "modelsTree.category.hiddenThroughModel",
-                        partial: "modelsTree.category.someElementsOrSubModelsHidden",
-                    },
-                    haveSubModel: "yes",
+                    getModelVisibilityStatus: (modelProps) => this.getModelVisibilityStatus(modelProps),
                 }));
             }
             return this.getVisibilityFromAlwaysAndNeverDrawnElements({
-                queryProps: props,
-                tooltips: {
-                    allElementsInAlwaysDrawnList: "modelsTree.category.allElementsVisible",
-                    allElementsInNeverDrawnList: "modelsTree.category.allElementsHidden",
-                    elementsInBothAlwaysAndNeverDrawn: "modelsTree.category.someElementsAreHidden",
-                    noElementsInExclusiveAlwaysDrawnList: "modelsTree.category.allElementsHidden",
+                queryProps: {
+                    categoryIds: [props.categoryId],
+                    modelId: props.modelId,
                 },
                 defaultStatus: () => this.getDefaultCategoryVisibilityStatus(props),
-                ignoreTooltip,
             }).pipe(mergeMap((visibilityStatusAlwaysAndNeverDraw) => {
-                return from(this._idsCache.getCategoriesModeledElements(props.modelId, [props.categoryId])).pipe(this.getSubModeledElementsVisibilityStatus({
-                    tooltips: {
-                        visible: undefined,
-                        hidden: "modelsTree.category.allElementsAndSubModelsHidden",
-                        partial: "modelsTree.category.someElementsOrSubModelsHidden",
-                    },
-                    haveSubModel: "yes",
+                return from(this._idsCache.getCategoriesModeledElements(props.modelId, [props.categoryId])).pipe(getSubModeledElementsVisibilityStatus({
                     parentNodeVisibilityStatus: visibilityStatusAlwaysAndNeverDraw,
-                    ignoreTooltips: ignoreTooltip,
+                    getModelVisibilityStatus: (modelProps) => this.getModelVisibilityStatus(modelProps),
                 }));
             }));
         });
@@ -231,97 +208,33 @@ class ModelsTreeVisibilityHandlerImpl {
             const info = this.getGroupingNodeInfo(node);
             const { modelId, categoryId, elementIds } = info;
             if (!this._props.viewport.view.viewsModel(modelId)) {
-                return of([...elementIds]).pipe(this.getSubModeledElementsVisibilityStatus({
-                    tooltips: {
-                        visible: undefined,
-                        hidden: undefined,
-                        partial: "modelsTree.groupingNode.someElementsOrSubModelsHidden",
-                    },
+                return of([...elementIds]).pipe(filterSubModeledElementIds({ doesSubModelExist: async (id) => this._idsCache.hasSubModel(id) }), getSubModeledElementsVisibilityStatus({
                     parentNodeVisibilityStatus: createVisibilityStatus("hidden"),
-                    haveSubModel: "unknown",
+                    getModelVisibilityStatus: (modelProps) => this.getModelVisibilityStatus(modelProps),
                 }));
             }
             return this.getVisibilityFromAlwaysAndNeverDrawnElements({
                 elements: elementIds,
-                defaultStatus: () => {
-                    const status = this.getDefaultCategoryVisibilityStatus({ categoryId, modelId, ignoreTooltip: true });
-                    return createVisibilityStatus(status.state, getTooltipOptions(`modelsTree.groupingNode.${status.state}ThroughCategory`));
-                },
-                tooltips: {
-                    allElementsInAlwaysDrawnList: "modelsTree.groupingNode.allElementsVisible",
-                    allElementsInNeverDrawnList: "modelsTree.groupingNode.allElementsHidden",
-                    elementsInBothAlwaysAndNeverDrawn: "modelsTree.groupingNode.someElementsAreHidden",
-                    noElementsInExclusiveAlwaysDrawnList: "modelsTree.groupingNode.allElementsHidden",
-                },
+                defaultStatus: () => this.getDefaultCategoryVisibilityStatus({ categoryId, modelId }),
             }).pipe(mergeMap((visibilityStatusAlwaysAndNeverDraw) => {
-                return of([...elementIds]).pipe(this.getSubModeledElementsVisibilityStatus({
-                    tooltips: {
-                        visible: undefined,
-                        hidden: "modelsTree.groupingNode.allElementsAndSubModelsHidden",
-                        partial: "modelsTree.groupingNode.someElementsOrSubModelsHidden",
-                    },
+                return of([...elementIds]).pipe(filterSubModeledElementIds({ doesSubModelExist: async (id) => this._idsCache.hasSubModel(id) }), getSubModeledElementsVisibilityStatus({
                     parentNodeVisibilityStatus: visibilityStatusAlwaysAndNeverDraw,
-                    haveSubModel: "unknown",
+                    getModelVisibilityStatus: (modelProps) => this.getModelVisibilityStatus(modelProps),
                 }));
             }));
         });
         return createVisibilityHandlerResult(this, { node }, result, this._props.overrides?.getElementGroupingNodeDisplayStatus);
     }
-    getElementOverriddenVisibility(elementId, ignoreTooltip) {
-        const viewport = this._props.viewport;
-        if (viewport.neverDrawn?.has(elementId)) {
-            return createVisibilityStatus("hidden", getTooltipOptions("modelsTree.element.hiddenThroughNeverDrawnList", ignoreTooltip));
-        }
-        if (viewport.alwaysDrawn?.size) {
-            if (viewport.alwaysDrawn.has(elementId)) {
-                return createVisibilityStatus("visible", getTooltipOptions("modelsTree.element.displayedThroughAlwaysDrawnList", ignoreTooltip));
-            }
-            if (viewport.isAlwaysDrawnExclusive) {
-                return createVisibilityStatus("hidden", getTooltipOptions("modelsTree.element.hiddenDueToOtherElementsExclusivelyAlwaysDrawn", ignoreTooltip));
-            }
-        }
-        return undefined;
-    }
-    getElementVisibility(ignoreTooltip, viewsModel, overridenVisibility, categoryVisibility, subModelVisibilityStatus) {
-        if (subModelVisibilityStatus === undefined) {
-            if (!viewsModel) {
-                return createVisibilityStatus("hidden", getTooltipOptions("modelsTree.element.hiddenThroughModel", ignoreTooltip));
-            }
-            if (overridenVisibility) {
-                return overridenVisibility;
-            }
-            return createVisibilityStatus(categoryVisibility.state, getTooltipOptions(categoryVisibility.state === "visible" ? undefined : "modelsTree.element.hiddenThroughCategory", ignoreTooltip));
-        }
-        if (subModelVisibilityStatus.state === "partial") {
-            return createVisibilityStatus("partial", getTooltipOptions("modelsTree.element.someElementsAreHidden", ignoreTooltip));
-        }
-        if (subModelVisibilityStatus.state === "visible") {
-            if (!viewsModel || overridenVisibility?.state === "hidden" || (categoryVisibility.state === "hidden" && !overridenVisibility)) {
-                return createVisibilityStatus("partial", getTooltipOptions("modelsTree.element.partialThroughSubModel", ignoreTooltip));
-            }
-            return createVisibilityStatus("visible", getTooltipOptions(undefined, ignoreTooltip));
-        }
-        if (!viewsModel) {
-            return createVisibilityStatus("hidden", getTooltipOptions("modelsTree.element.hiddenThroughModel", ignoreTooltip));
-        }
-        if (overridenVisibility) {
-            if (overridenVisibility.state === "hidden") {
-                return overridenVisibility;
-            }
-            return createVisibilityStatus("partial", getTooltipOptions("modelsTree.element.partialThroughElement", ignoreTooltip));
-        }
-        if (categoryVisibility.state === "visible") {
-            return createVisibilityStatus("partial", getTooltipOptions("modelsTree.element.partialThroughCategory", ignoreTooltip));
-        }
-        return createVisibilityStatus("hidden", getTooltipOptions("modelsTree.element.hiddenThroughCategory", ignoreTooltip));
-    }
-    getElementDisplayStatus({ ignoreTooltip, ...props }) {
+    getElementDisplayStatus(props) {
         const result = defer(() => {
             const viewport = this._props.viewport;
             const { elementId, modelId, categoryId } = props;
             const viewsModel = viewport.view.viewsModel(modelId);
-            const elementStatus = this.getElementOverriddenVisibility(elementId, ignoreTooltip);
-            return from(this._idsCache.hasSubModel(elementId)).pipe(mergeMap((hasSubModel) => (hasSubModel ? this.getModelVisibilityStatus({ modelId: elementId }) : of(undefined))), map((subModelVisibilityStatus) => this.getElementVisibility(ignoreTooltip, viewsModel, elementStatus, this.getDefaultCategoryVisibilityStatus({ categoryId, modelId, ignoreTooltip: true }), subModelVisibilityStatus)));
+            const elementStatus = getElementOverriddenVisibility({
+                elementId,
+                viewport,
+            });
+            return from(this._idsCache.hasSubModel(elementId)).pipe(mergeMap((hasSubModel) => (hasSubModel ? this.getModelVisibilityStatus({ modelId: elementId }) : of(undefined))), map((subModelVisibilityStatus) => getElementVisibility(viewsModel, elementStatus, this.getDefaultCategoryVisibilityStatus({ categoryId, modelId }), subModelVisibilityStatus)));
         });
         return createVisibilityHandlerResult(this, props, result, this._props.overrides?.getElementDisplayStatus);
     }
@@ -369,7 +282,7 @@ class ModelsTreeVisibilityHandlerImpl {
         return filteredTree ? filteredTree.getVisibilityChangeTargets(node) : {};
     }
     changeFilteredNodeVisibility({ on, ...props }) {
-        return from(this.getVisibilityChangeTargets(props)).pipe(mergeMap(({ subjects, models, categories, elements }) => {
+        return from(this.getVisibilityChangeTargets(props)).pipe(mergeMap(({ subjectIds: subjects, modelIds: models, categories, elements }) => {
             const observables = new Array();
             if (subjects?.size) {
                 observables.push(this.changeSubjectNodeState([...subjects], on));
@@ -392,14 +305,14 @@ class ModelsTreeVisibilityHandlerImpl {
             return merge(...observables);
         }));
     }
-    changeSubjectNodeState(ids, on) {
+    changeSubjectNodeState(subjectIds, on) {
         const result = defer(() => {
             if (!this._props.viewport.view.isSpatialView()) {
                 return EMPTY;
             }
-            return from(this._idsCache.getSubjectModelIds(ids)).pipe(mergeMap((modelIds) => this.changeModelState({ ids: modelIds, on })));
+            return from(this._idsCache.getSubjectModelIds(subjectIds)).pipe(mergeMap((modelIds) => this.changeModelState({ ids: modelIds, on })));
         });
-        return createVisibilityHandlerResult(this, { ids, on }, result, this._props.overrides?.changeSubjectNodeState);
+        return createVisibilityHandlerResult(this, { ids: subjectIds, on }, result, this._props.overrides?.changeSubjectNodeState);
     }
     changeModelState(props) {
         const { ids, on } = props;
@@ -414,13 +327,13 @@ class ModelsTreeVisibilityHandlerImpl {
             const idsObs = from(Id64.iterable(ids));
             if (!on) {
                 viewport.changeModelDisplay(ids, false);
-                return idsObs.pipe(mergeMap(async (modelId) => ({ modelId, categoryIds: await this._idsCache.getModelCategories(modelId) })), mergeMap(({ modelId, categoryIds }) => from(this._idsCache.getCategoriesModeledElements(modelId, categoryIds))), mergeMap((modeledElementIds) => this.changeModelState({ ids: modeledElementIds, on })));
+                return idsObs.pipe(mergeMap(async (modelId) => ({ modelId, categoryIds: await this._idsCache.getModelCategoryIds(modelId) })), mergeMap(({ modelId, categoryIds }) => from(this._idsCache.getCategoriesModeledElements(modelId, categoryIds))), mergeMap((modeledElementIds) => this.changeModelState({ ids: modeledElementIds, on })));
             }
             return concat(defer(() => {
                 viewport.perModelCategoryVisibility.clearOverrides(ids);
                 return from(viewport.addViewedModels(ids));
             }), idsObs.pipe(mergeMap((modelId) => {
-                return from(this._idsCache.getModelCategories(modelId)).pipe(concatAll(), mergeMap((categoryId) => this.changeCategoryState({ categoryId, modelId, on: true })));
+                return from(this._idsCache.getModelCategoryIds(modelId)).pipe(concatAll(), mergeMap((categoryId) => this.changeCategoryState({ categoryId, modelId, on: true })));
             })));
         });
         return createVisibilityHandlerResult(this, props, result, this._props.overrides?.changeModelState);
@@ -428,8 +341,8 @@ class ModelsTreeVisibilityHandlerImpl {
     showModelWithoutAnyCategoriesOrElements(modelId) {
         const viewport = this._props.viewport;
         return forkJoin({
-            categories: this._idsCache.getModelCategories(modelId),
-            alwaysDrawnElements: this.getAlwaysDrawnElements({ modelId }),
+            categories: this._idsCache.getModelCategoryIds(modelId),
+            alwaysDrawnElements: this._alwaysAndNeverDrawnElements.getAlwaysDrawnElements({ modelId }),
         }).pipe(mergeMap(async ({ categories, alwaysDrawnElements }) => {
             const alwaysDrawn = this._props.viewport.alwaysDrawn;
             if (alwaysDrawn && alwaysDrawnElements) {
@@ -462,7 +375,7 @@ class ModelsTreeVisibilityHandlerImpl {
             const { modelId, categoryId, on } = props;
             return concat(props.on && !viewport.view.viewsModel(modelId) ? this.showModelWithoutAnyCategoriesOrElements(modelId) : EMPTY, defer(() => {
                 this.changeCategoryStateInViewportAccordingToModelVisibility(modelId, categoryId, on);
-                return this.clearAlwaysAndNeverDrawnElements(props);
+                return this._alwaysAndNeverDrawnElements.clearAlwaysAndNeverDrawnElements({ categoryIds: [props.categoryId], modelId: props.modelId });
             }), from(this._idsCache.getCategoriesModeledElements(modelId, [categoryId])).pipe(mergeMap((modeledElementIds) => this.changeModelState({ ids: modeledElementIds, on }))));
         });
         return createVisibilityHandlerResult(this, props, result, this._props.overrides?.changeCategoryState);
@@ -472,7 +385,7 @@ class ModelsTreeVisibilityHandlerImpl {
             const { modelId, categoryId, elementIds, on } = props;
             const viewport = this._props.viewport;
             return concat(on && !viewport.view.viewsModel(modelId) ? this.showModelWithoutAnyCategoriesOrElements(modelId) : EMPTY, defer(() => {
-                const categoryVisibility = this.getDefaultCategoryVisibilityStatus({ categoryId, modelId, ignoreTooltip: true });
+                const categoryVisibility = this.getDefaultCategoryVisibilityStatus({ 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.changeModelState({ ids: subModelIds, on }))));
@@ -500,7 +413,7 @@ class ModelsTreeVisibilityHandlerImpl {
         const changeFinished = finishedSubject.pipe(startWith(false), shareReplay(1), filter((finished) => finished));
         const changeObservable = from(elementIds).pipe(
         // check if visibility change is not finished (cancelled) due to change overall change request being cancelled
-        takeUntil(changeFinished), this.changeElementStateNoChildrenOperator({ on, isDisplayedByDefault: visibleByDefault }), tap({
+        takeUntil(changeFinished), changeElementStateNoChildrenOperator({ on, isDisplayedByDefault: visibleByDefault, viewport: this._props.viewport }), tap({
             next: () => {
                 // notify that visibility change is finished
                 finishedSubject.next(true);
@@ -516,118 +429,40 @@ class ModelsTreeVisibilityHandlerImpl {
             },
         }), map(() => undefined));
     }
-    changeElementStateNoChildrenOperator(props) {
-        return (elementIds) => {
-            const { on, isDisplayedByDefault } = props;
-            const isAlwaysDrawnExclusive = this._props.viewport.isAlwaysDrawnExclusive;
-            return elementIds.pipe(releaseMainThreadOnItemsCount(500), reduce((acc, elementId) => {
-                if (acc.alwaysDrawn === undefined || acc.neverDrawn === undefined) {
-                    acc.alwaysDrawn = new Set(this._props.viewport.alwaysDrawn || []);
-                    acc.neverDrawn = new Set(this._props.viewport.neverDrawn || []);
-                }
-                if (on) {
-                    const wasRemoved = acc.neverDrawn.delete(elementId);
-                    acc.changedNeverDrawn ||= wasRemoved;
-                    // If exclusive mode is enabled, we must add the element to the always drawn list.
-                    if ((!isDisplayedByDefault || isAlwaysDrawnExclusive) && !acc.alwaysDrawn.has(elementId)) {
-                        acc.alwaysDrawn.add(elementId);
-                        acc.changedAlwaysDrawn = true;
-                    }
-                }
-                else {
-                    const wasRemoved = acc.alwaysDrawn.delete(elementId);
-                    acc.changedAlwaysDrawn ||= wasRemoved;
-                    // If exclusive mode is not enabled, we have to add the element to the never drawn list.
-                    if (isDisplayedByDefault && !isAlwaysDrawnExclusive && !acc.neverDrawn.has(elementId)) {
-                        acc.neverDrawn.add(elementId);
-                        acc.changedNeverDrawn = true;
-                    }
-                }
-                return acc;
-            }, {
-                changedNeverDrawn: false,
-                changedAlwaysDrawn: false,
-                neverDrawn: undefined,
-                alwaysDrawn: undefined,
-            }), map((state) => {
-                state.changedNeverDrawn && state.neverDrawn && this._props.viewport.setNeverDrawn(state.neverDrawn);
-                state.changedAlwaysDrawn && state.alwaysDrawn && this._props.viewport.setAlwaysDrawn(state.alwaysDrawn, this._props.viewport.isAlwaysDrawnExclusive);
-            }));
-        };
-    }
-    getVisibilityFromAlwaysAndNeverDrawnElementsImpl(props) {
-        const { alwaysDrawn, neverDrawn, totalCount, ignoreTooltip } = props;
-        if (neverDrawn?.size === totalCount) {
-            return createVisibilityStatus("hidden", getTooltipOptions(props.tooltips.allElementsInNeverDrawnList, ignoreTooltip));
-        }
-        if (alwaysDrawn?.size === totalCount) {
-            return createVisibilityStatus("visible", getTooltipOptions(props.tooltips.allElementsInAlwaysDrawnList, ignoreTooltip));
-        }
-        const viewport = this._props.viewport;
-        if (viewport.isAlwaysDrawnExclusive && viewport.alwaysDrawn?.size) {
-            return alwaysDrawn?.size
-                ? createVisibilityStatus("partial", getTooltipOptions(props.tooltips.elementsInBothAlwaysAndNeverDrawn, ignoreTooltip))
-                : createVisibilityStatus("hidden", getTooltipOptions(props.tooltips.noElementsInExclusiveAlwaysDrawnList, ignoreTooltip));
-        }
-        const status = props.defaultStatus();
-        if ((status.state === "visible" && neverDrawn?.size) || (status.state === "hidden" && alwaysDrawn?.size)) {
-            return createVisibilityStatus("partial", getTooltipOptions(undefined, ignoreTooltip));
-        }
-        return status;
-    }
-    getVisibilityFromAlwaysAndNeverDrawnElements({ ignoreTooltip, ...props }) {
+    getVisibilityFromAlwaysAndNeverDrawnElements(props) {
         const viewport = this._props.viewport;
         if (viewport.isAlwaysDrawnExclusive) {
             if (!viewport?.alwaysDrawn?.size) {
-                return of(createVisibilityStatus("hidden", getTooltipOptions(props.tooltips.noElementsInExclusiveAlwaysDrawnList, ignoreTooltip)));
+                return of(createVisibilityStatus("hidden"));
             }
         }
         else if (!viewport?.neverDrawn?.size && !viewport?.alwaysDrawn?.size) {
             return of(props.defaultStatus());
         }
         if ("elements" in props) {
-            return of(this.getVisibilityFromAlwaysAndNeverDrawnElementsImpl({
+            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,
-                ignoreTooltip,
+                viewport,
             }));
         }
-        const { modelId, categoryId } = props.queryProps;
-        const totalCount = categoryId ? this._idsCache.getCategoryElementsCount(modelId, categoryId) : this._idsCache.getModelElementCount(modelId);
+        const { modelId, categoryIds } = props.queryProps;
+        assert(modelId !== undefined);
+        const totalCount = this._idsCache.getCategoryElementsCount(modelId, categoryIds[0]);
         return forkJoin({
             totalCount,
-            alwaysDrawn: this.getAlwaysDrawnElements(props.queryProps),
-            neverDrawn: this.getNeverDrawnElements(props.queryProps),
+            alwaysDrawn: this._alwaysAndNeverDrawnElements.getAlwaysDrawnElements(props.queryProps),
+            neverDrawn: this._alwaysAndNeverDrawnElements.getNeverDrawnElements(props.queryProps),
         }).pipe(map((state) => {
-            return this.getVisibilityFromAlwaysAndNeverDrawnElementsImpl({
+            return getVisibilityFromAlwaysAndNeverDrawnElementsImpl({
                 ...props,
                 ...state,
-                ignoreTooltip,
+                viewport,
             });
         }));
     }
-    getAlwaysDrawnElements(props) {
-        return this._alwaysAndNeverDrawnElements.getElements({ ...props, setType: "always" });
-    }
-    getNeverDrawnElements(props) {
-        return this._alwaysAndNeverDrawnElements.getElements({ ...props, setType: "never" });
-    }
-    clearAlwaysAndNeverDrawnElements(props) {
-        return forkJoin({
-            alwaysDrawn: this.getAlwaysDrawnElements(props),
-            neverDrawn: this.getNeverDrawnElements(props),
-        }).pipe(map(({ alwaysDrawn, neverDrawn }) => {
-            const viewport = this._props.viewport;
-            if (viewport.alwaysDrawn?.size && alwaysDrawn.size) {
-                viewport.setAlwaysDrawn(setDifference(viewport.alwaysDrawn, alwaysDrawn));
-            }
-            if (viewport.neverDrawn?.size && neverDrawn.size) {
-                viewport.setNeverDrawn(setDifference(viewport.neverDrawn, neverDrawn));
-            }
-        }));
-    }
     getGroupingNodeInfo(node) {
         const modelId = ModelsTreeNode.getModelId(node);
         const categoryId = ModelsTreeNode.getCategoryId(node);
@@ -635,119 +470,5 @@ class ModelsTreeVisibilityHandlerImpl {
         const elementIds = new Set(node.groupedInstanceKeys.map((key) => key.id));
         return { modelId, categoryId, elementIds };
     }
-    getSubModeledElementsVisibilityStatus({ parentNodeVisibilityStatus, haveSubModel, tooltips, ignoreTooltips, }) {
-        return (obs) => {
-            return obs.pipe(
-            // ensure we're only looking at elements that have a sub-model
-            mergeMap((modeledElementIds) => {
-                if (haveSubModel === "yes") {
-                    return of(modeledElementIds);
-                }
-                return from(modeledElementIds).pipe(mergeMap(async (elementId) => ({ elementId, hasSubModel: await this._idsCache.hasSubModel(elementId) })), filter(({ hasSubModel }) => hasSubModel), map(({ elementId }) => elementId), toArray());
-            }), 
-            // combine visibility status of sub-models with visibility status of parent node
-            mergeMap((modeledElementIds) => {
-                if (modeledElementIds.length === 0) {
-                    return of(parentNodeVisibilityStatus);
-                }
-                return from(modeledElementIds).pipe(mergeMap((modeledElementId) => this.getModelVisibilityStatus({ modelId: modeledElementId })), startWith(parentNodeVisibilityStatus), map((visibilityStatus) => visibilityStatus.state), getVisibilityStatusFromTreeNodeChildren(tooltips, ignoreTooltips));
-            }));
-        };
-    }
-}
-function getVisibilityFromTreeNodeChildren(obs) {
-    return obs.pipe(reduceWhile((x) => x.allVisible || x.allHidden, (acc, val) => {
-        acc.allVisible &&= val === "visible";
-        acc.allHidden &&= val === "hidden";
-        return acc;
-    }, { allVisible: true, allHidden: true }), map((x) => {
-        if (!x) {
-            return "empty";
-        }
-        return x.allVisible ? "visible" : x.allHidden ? "hidden" : "partial";
-    }));
-}
-function getVisibilityStatusFromTreeNodeChildren(tooltipMap, ignoreTooltip) {
-    return (obs) => {
-        return getVisibilityFromTreeNodeChildren(obs).pipe(map((visibility) => {
-            if (visibility === "empty") {
-                visibility = "visible";
-            }
-            return createVisibilityStatus(visibility, getTooltipOptions(tooltipMap[visibility], ignoreTooltip));
-        }));
-    };
-}
-function setDifference(lhs, rhs) {
-    const result = new Set();
-    lhs.forEach((x) => !rhs.has(x) && result.add(x));
-    return result;
-}
-function setIntersection(lhs, rhs) {
-    const result = new Set();
-    lhs.forEach((x) => rhs.has(x) && result.add(x));
-    return result;
-}
-/**
- * Enables display of all given models. Also enables display of all categories and clears always and
- * never drawn lists in the viewport.
- * @public
- */
-export async function showAllModels(models, viewport) {
-    await viewport.addViewedModels(models);
-    viewport.clearNeverDrawn();
-    viewport.clearAlwaysDrawn();
-    await toggleAllCategories(viewport, true);
-}
-/**
- * Disables display of all given models.
- * @public
- */
-export async function hideAllModels(models, viewport) {
-    viewport.changeModelDisplay(models, false);
-}
-/**
- * Inverts display of all given models.
- * @public
- */
-export async function invertAllModels(models, viewport) {
-    const notViewedModels = [];
-    const viewedModels = [];
-    models.forEach((modelId) => {
-        if (viewport.viewsModel(modelId)) {
-            viewedModels.push(modelId);
-        }
-        else {
-            notViewedModels.push(modelId);
-        }
-    });
-    await viewport.addViewedModels(notViewedModels);
-    viewport.changeModelDisplay(viewedModels, false);
-}
-/**
- * Based on the value of `enable` argument, either enables or disables display of given models.
- * @public
- */
-export async function toggleModels(models, enable, viewport) {
-    if (!models) {
-        return;
-    }
-    if (enable) {
-        viewport.changeModelDisplay(models, false);
-    }
-    else {
-        await viewport.addViewedModels(models);
-    }
-}
-/**
- * Checks if all given models are displayed in given viewport.
- * @public
- */
-export function areAllModelsVisible(models, viewport) {
-    return models.length !== 0 ? models.every((id) => viewport.viewsModel(id)) : false;
-}
-function getTooltipOptions(key, ignoreTooltip) {
-    return {
-        useTooltip: ignoreTooltip ? false : key,
-    };
 }
 //# sourceMappingURL=ModelsTreeVisibilityHandler.js.map