@itwin/tree-widget-react 4.0.0-alpha.2 → 4.0.0-alpha.20

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

@@ -1,663 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- * 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, } from "rxjs";
-import { assert } 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 { 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
- */
-export function createModelsTreeVisibilityHandler(props) {
-    return new ModelsTreeVisibilityHandlerImpl(props);
-}
-class ModelsTreeVisibilityHandlerImpl {
-    constructor(_props) {
-        this._props = _props;
-        this._elementChangeQueue = new Subject();
-        this._subscriptions = [];
-        this._changeRequest = new Subject();
-        this._eventListener = createVisibilityChangeEventListener(_props.viewport);
-        this._alwaysAndNeverDrawnElements = new AlwaysAndNeverDrawnElementInfo(_props.viewport);
-        this._idsCache = this._props.idsCache;
-        this._filteredTree = _props.filteredPaths ? createFilteredTree(this._props.imodelAccess, _props.filteredPaths) : undefined;
-        this._subscriptions.push(this._elementChangeQueue.pipe(concatAll()).subscribe());
-    }
-    get onVisibilityChange() {
-        return this._eventListener.onVisibilityChange;
-    }
-    async getVisibilityStatus(node) {
-        return firstValueFrom(this.getVisibilityStatusObs(node).pipe(
-        // unsubscribe from the observable if the change request for this node is received
-        takeUntil(this._changeRequest.pipe(filter(({ key, depth }) => depth === node.parentKeys.length && HierarchyNodeKey.equals(node.key, key)))), 
-        // unsubscribe if visibility changes
-        takeUntil(fromEventPattern((handler) => {
-            this._eventListener.onVisibilityChange.addListener(handler);
-        }, (handler) => {
-            this._eventListener.onVisibilityChange.removeListener(handler);
-        }))));
-    }
-    async changeVisibility(node, shouldDisplay) {
-        // notify about new change request
-        this._changeRequest.next({ key: node.key, depth: node.parentKeys.length });
-        const changeObservable = this.changeVisibilityObs(node, shouldDisplay).pipe(
-        // unsubscribe from the observable if the change request for this node is received
-        takeUntil(this._changeRequest.pipe(filter(({ key, depth }) => depth === node.parentKeys.length && HierarchyNodeKey.equals(node.key, key)))), tap({
-            subscribe: () => {
-                this._eventListener.suppressChangeEvents();
-                this._alwaysAndNeverDrawnElements.suppressChangeEvents();
-            },
-            finalize: () => {
-                this._eventListener.resumeChangeEvents();
-                this._alwaysAndNeverDrawnElements.resumeChangeEvents();
-            },
-        }));
-        return toVoidPromise(changeObservable);
-    }
-    dispose() {
-        this._eventListener.dispose();
-        this._alwaysAndNeverDrawnElements.dispose();
-        this._subscriptions.forEach((x) => x.unsubscribe());
-    }
-    getVisibilityStatusObs(node) {
-        if (node.filtering?.filteredChildrenIdentifierPaths?.length && !node.filtering.isFilterTarget) {
-            return this.getFilteredNodeVisibility({ node });
-        }
-        if (HierarchyNode.isClassGroupingNode(node)) {
-            return this.getClassGroupingNodeDisplayStatus(node);
-        }
-        if (!HierarchyNode.isInstancesNode(node)) {
-            return of(createVisibilityStatus("disabled"));
-        }
-        if (ModelsTreeNode.isSubjectNode(node)) {
-            // note: subject nodes may be merged to represent multiple subject instances
-            return this.getSubjectNodeVisibilityStatus({ subjectIds: node.key.instanceKeys.map((key) => key.id) });
-        }
-        if (ModelsTreeNode.isModelNode(node)) {
-            return this.getModelVisibilityStatus({ modelId: node.key.instanceKeys[0].id });
-        }
-        const modelId = ModelsTreeNode.getModelId(node);
-        if (!modelId) {
-            return of(createVisibilityStatus("disabled"));
-        }
-        if (ModelsTreeNode.isCategoryNode(node)) {
-            return this.getCategoryDisplayStatus({
-                categoryId: node.key.instanceKeys[0].id,
-                modelId,
-            });
-        }
-        const categoryId = ModelsTreeNode.getCategoryId(node);
-        if (!categoryId) {
-            return of(createVisibilityStatus("disabled"));
-        }
-        return this.getElementDisplayStatus({
-            elementId: node.key.instanceKeys[0].id,
-            modelId,
-            categoryId,
-        });
-    }
-    getFilteredNodeVisibility(props) {
-        return from(this.getVisibilityChangeTargets(props)).pipe(mergeMap(({ subjects, models, categories, elements }) => {
-            const observables = new Array();
-            if (subjects?.size) {
-                observables.push(this.getSubjectNodeVisibilityStatus({ subjectIds: [...subjects], ignoreTooltip: true }));
-            }
-            if (models?.size) {
-                observables.push(from(models).pipe(mergeMap((modelId) => this.getModelVisibilityStatus({ modelId, ignoreTooltip: true }))));
-            }
-            if (categories?.size) {
-                observables.push(from(categories).pipe(mergeMap((key) => {
-                    const { modelId, categoryId } = parseCategoryKey(key);
-                    return this.getCategoryDisplayStatus({ modelId, categoryId, ignoreTooltip: true });
-                })));
-            }
-            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 merge(...observables);
-        }), map((x) => x.state), getVisibilityFromTreeNodeChildren, map((x) => {
-            assert(x !== "empty");
-            return createVisibilityStatus(x);
-        }));
-    }
-    getSubjectNodeVisibilityStatus({ subjectIds, ignoreTooltip }) {
-        const result = defer(() => {
-            if (!this._props.viewport.view.isSpatialView()) {
-                return of(createVisibilityStatus("disabled", getTooltipOptions("modelsTree.subject.nonSpatialView", ignoreTooltip)));
-            }
-            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 createVisibilityHandlerResult(this, { ids: subjectIds }, result, this._props.overrides?.getSubjectNodeVisibility);
-    }
-    getModelVisibilityStatus({ modelId, ignoreTooltip }) {
-        const result = defer(() => {
-            const viewport = this._props.viewport;
-            if (!viewport.view.isSpatialView()) {
-                return of(createVisibilityStatus("disabled", getTooltipOptions("modelsTree.model.nonSpatialView", ignoreTooltip)));
-            }
-            if (!viewport.view.viewsModel(modelId)) {
-                return of(createVisibilityStatus("hidden", getTooltipOptions("modelsTree.model.hiddenThroughModelSelector", ignoreTooltip)));
-            }
-            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 createVisibilityHandlerResult(this, { id: modelId }, result, this._props.overrides?.getModelDisplayStatus);
-    }
-    getDefaultCategoryVisibilityStatus({ modelId, categoryId, ignoreTooltip, }) {
-        const viewport = this._props.viewport;
-        if (!viewport.view.viewsModel(modelId)) {
-            return createVisibilityStatus("hidden", getTooltipOptions("modelsTree.category.hiddenThroughModel", ignoreTooltip));
-        }
-        switch (this._props.viewport.perModelCategoryVisibility.getOverride(modelId, categoryId)) {
-            case PerModelCategoryVisibility.Override.Show:
-                return createVisibilityStatus("visible", getTooltipOptions("modelsTree.category.displayedThroughPerModelOverride", ignoreTooltip));
-            case PerModelCategoryVisibility.Override.Hide:
-                return createVisibilityStatus("hidden", getTooltipOptions("modelsTree.category.hiddenThroughPerModelOverride", ignoreTooltip));
-        }
-        const isVisible = viewport.view.viewsCategory(categoryId);
-        return isVisible
-            ? createVisibilityStatus("visible", getTooltipOptions("modelsTree.category.displayedThroughCategorySelector", ignoreTooltip))
-            : createVisibilityStatus("hidden", getTooltipOptions("modelsTree.category.hiddenThroughCategorySelector", ignoreTooltip));
-    }
-    getCategoryDisplayStatus({ ignoreTooltip, ...props }) {
-        const result = defer(() => {
-            if (!this._props.viewport.view.viewsModel(props.modelId)) {
-                return of(createVisibilityStatus("hidden", getTooltipOptions("modelsTree.category.hiddenThroughModel", ignoreTooltip)));
-            }
-            return this.getVisibilityFromAlwaysAndNeverDrawnElements({
-                queryProps: props,
-                tooltips: {
-                    allElementsInAlwaysDrawnList: "modelsTree.category.allElementsVisible",
-                    allElementsInNeverDrawnList: "modelsTree.category.allElementsHidden",
-                    elementsInBothAlwaysAndNeverDrawn: "modelsTree.category.someElementsAreHidden",
-                    noElementsInExclusiveAlwaysDrawnList: "modelsTree.category.allElementsHidden",
-                },
-                defaultStatus: () => this.getDefaultCategoryVisibilityStatus(props),
-                ignoreTooltip,
-            });
-        });
-        return createVisibilityHandlerResult(this, props, result, this._props.overrides?.getCategoryDisplayStatus);
-    }
-    getClassGroupingNodeDisplayStatus(node) {
-        const result = defer(() => {
-            const info = this.getGroupingNodeInfo(node);
-            const { modelId, categoryId, elementIds } = info;
-            if (!this._props.viewport.view.viewsModel(modelId)) {
-                return of(createVisibilityStatus("hidden"));
-            }
-            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",
-                },
-            });
-        });
-        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;
-    }
-    getElementDisplayStatus({ ignoreTooltip, ...props }) {
-        const result = defer(() => {
-            const viewport = this._props.viewport;
-            const { elementId, modelId, categoryId } = props;
-            if (!viewport.view.viewsModel(modelId)) {
-                return of(createVisibilityStatus("hidden", getTooltipOptions("modelsTree.element.hiddenThroughModel", ignoreTooltip)));
-            }
-            let status = this.getElementOverriddenVisibility(elementId, ignoreTooltip);
-            if (status) {
-                return of(status);
-            }
-            status = this.getDefaultCategoryVisibilityStatus({ categoryId, modelId, ignoreTooltip: true });
-            return of(createVisibilityStatus(status.state, getTooltipOptions(status.state === "visible" ? undefined : "modelsTree.element.hiddenThroughCategory", ignoreTooltip)));
-        });
-        return createVisibilityHandlerResult(this, props, result, this._props.overrides?.getElementDisplayStatus);
-    }
-    /** Changes visibility of the items represented by the tree node. */
-    changeVisibilityObs(node, on) {
-        if (node.filtering?.filteredChildrenIdentifierPaths?.length && !node.filtering.isFilterTarget) {
-            return this.changeFilteredNodeVisibility({ node, on });
-        }
-        if (HierarchyNode.isClassGroupingNode(node)) {
-            return this.changeElementGroupingNodeState(node, on);
-        }
-        if (!HierarchyNode.isInstancesNode(node)) {
-            return EMPTY;
-        }
-        if (ModelsTreeNode.isSubjectNode(node)) {
-            return this.changeSubjectNodeState(node.key.instanceKeys.map((key) => key.id), on);
-        }
-        if (ModelsTreeNode.isModelNode(node)) {
-            return this.changeModelState({ ids: node.key.instanceKeys[0].id, on });
-        }
-        const modelId = ModelsTreeNode.getModelId(node);
-        if (!modelId) {
-            return EMPTY;
-        }
-        if (ModelsTreeNode.isCategoryNode(node)) {
-            return this.changeCategoryState({
-                categoryId: node.key.instanceKeys[0].id,
-                modelId,
-                on,
-            });
-        }
-        const categoryId = ModelsTreeNode.getCategoryId(node);
-        if (!categoryId) {
-            return EMPTY;
-        }
-        return this.changeElementsState({
-            elementIds: new Set([...node.key.instanceKeys.map(({ id }) => id)]),
-            modelId,
-            categoryId,
-            on,
-        });
-    }
-    async getVisibilityChangeTargets({ node }) {
-        const filteredTree = await this._filteredTree;
-        return filteredTree ? filteredTree.getVisibilityChangeTargets(node) : {};
-    }
-    changeFilteredNodeVisibility({ on, ...props }) {
-        return from(this.getVisibilityChangeTargets(props)).pipe(mergeMap(({ subjects, models, categories, elements }) => {
-            const observables = new Array();
-            if (subjects?.size) {
-                observables.push(this.changeSubjectNodeState([...subjects], on));
-            }
-            if (models?.size) {
-                observables.push(this.changeModelState({ ids: models, on }));
-            }
-            if (categories?.size) {
-                observables.push(from(categories).pipe(mergeMap((key) => {
-                    const { modelId, categoryId } = parseCategoryKey(key);
-                    return this.changeCategoryState({ modelId, categoryId, on });
-                })));
-            }
-            if (elements?.size) {
-                observables.push(from(elements).pipe(mergeMap(([categoryKey, elementIds]) => {
-                    const { modelId, categoryId } = parseCategoryKey(categoryKey);
-                    return this.changeElementsState({ modelId, categoryId, elementIds, on });
-                })));
-            }
-            return merge(...observables);
-        }));
-    }
-    changeSubjectNodeState(ids, 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 createVisibilityHandlerResult(this, { ids, on }, result, this._props.overrides?.changeSubjectNodeState);
-    }
-    changeModelState(props) {
-        const result = defer(() => {
-            const viewport = this._props.viewport;
-            if (!viewport.view.isSpatialView()) {
-                return EMPTY;
-            }
-            const { ids, on } = props;
-            if (!on) {
-                viewport.changeModelDisplay(ids, false);
-                return EMPTY;
-            }
-            return concat(defer(() => {
-                viewport.perModelCategoryVisibility.clearOverrides(ids);
-                return from(viewport.addViewedModels(ids));
-            }), (typeof ids === "string" ? of(ids) : from(ids)).pipe(mergeMap((modelId) => {
-                return from(this._idsCache.getModelCategories(modelId)).pipe(concatAll(), mergeMap((categoryId) => this.changeCategoryState({ categoryId, modelId, on: true })));
-            })));
-        });
-        return createVisibilityHandlerResult(this, props, result, this._props.overrides?.changeModelState);
-    }
-    showModelWithoutAnyCategoriesOrElements(modelId) {
-        const viewport = this._props.viewport;
-        return forkJoin({
-            categories: this._idsCache.getModelCategories(modelId),
-            alwaysDrawnElements: this.getAlwaysDrawnElements({ modelId }),
-        }).pipe(mergeMap(async ({ categories, alwaysDrawnElements }) => {
-            const alwaysDrawn = this._props.viewport.alwaysDrawn;
-            if (alwaysDrawn && alwaysDrawnElements) {
-                viewport.setAlwaysDrawn(setDifference(alwaysDrawn, alwaysDrawnElements));
-            }
-            categories.forEach((categoryId) => {
-                this.changeCategoryStateInViewportAccordingToModelVisibility(modelId, categoryId, false);
-            });
-            await viewport.addViewedModels(modelId);
-        }));
-    }
-    changeCategoryStateInViewportAccordingToModelVisibility(modelId, categoryId, on) {
-        const viewport = this._props.viewport;
-        const isDisplayedInSelector = viewport.view.viewsCategory(categoryId);
-        const override = on === isDisplayedInSelector
-            ? PerModelCategoryVisibility.Override.None
-            : on
-                ? PerModelCategoryVisibility.Override.Show
-                : PerModelCategoryVisibility.Override.Hide;
-        viewport.perModelCategoryVisibility.setOverride(modelId, categoryId, override);
-        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, true);
-        }
-    }
-    changeCategoryState(props) {
-        const result = defer(() => {
-            const viewport = this._props.viewport;
-            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 createVisibilityHandlerResult(this, props, result, this._props.overrides?.changeCategoryState);
-    }
-    /**
-     * Updates visibility of all grouping node's elements.
-     * @see `changeElementState`
-     */
-    changeElementGroupingNodeState(node, on) {
-        const result = defer(() => {
-            const info = this.getGroupingNodeInfo(node);
-            const { modelId, categoryId, elementIds } = info;
-            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 isDisplayedByDefault = categoryVisibility.state === "visible";
-                return this.queueElementsVisibilityChange(elementIds, on, isDisplayedByDefault);
-            }));
-        });
-        return createVisibilityHandlerResult(this, { node, on }, result, this._props.overrides?.changeElementGroupingNodeState);
-    }
-    /**
-     * Updates visibility of an element and all its child elements by adding them to the always/never drawn list.
-     * @note If element is to be enabled and model is hidden, it will be enabled.
-     */
-    changeElementsState(props) {
-        const result = defer(() => {
-            const { elementIds, on, modelId, categoryId } = props;
-            const viewport = this._props.viewport;
-            return concat(props.on && !viewport.view.viewsModel(modelId) ? this.showModelWithoutAnyCategoriesOrElements(modelId) : EMPTY, defer(() => {
-                const categoryVisibility = this.getDefaultCategoryVisibilityStatus({ categoryId, modelId, ignoreTooltip: true });
-                const isDisplayedByDefault = categoryVisibility.state === "visible";
-                return this.queueElementsVisibilityChange(elementIds, on, isDisplayedByDefault);
-            }));
-        });
-        return createVisibilityHandlerResult(this, props, result, this._props.overrides?.changeElementsState);
-    }
-    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(
-        // check if visibility change is not finished (cancelled) due to change overall change request being cancelled
-        takeUntil(changeFinished), this.changeElementStateNoChildrenOperator({ on, isDisplayedByDefault: visibleByDefault }), tap({
-            next: () => {
-                // notify that visibility change is finished
-                finishedSubject.next(true);
-            },
-        }));
-        // queue visibility change. `changeObservable` will be subscribed to when other queue changes are finished
-        this._elementChangeQueue.next(changeObservable);
-        // return observable that will emit when visibility change is finished
-        return changeFinished.pipe(take(1), tap({
-            unsubscribe: () => {
-                // if this observable is unsubscribed before visibility change is finished, we have to notify that it queued change request is cancelled
-                finishedSubject.next(true);
-            },
-        }), 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 }) {
-        const viewport = this._props.viewport;
-        if (viewport.isAlwaysDrawnExclusive) {
-            if (!viewport?.alwaysDrawn?.size) {
-                return of(createVisibilityStatus("hidden", getTooltipOptions(props.tooltips.noElementsInExclusiveAlwaysDrawnList, ignoreTooltip)));
-            }
-        }
-        else if (!viewport?.neverDrawn?.size && !viewport?.alwaysDrawn?.size) {
-            return of(props.defaultStatus());
-        }
-        if ("elements" in props) {
-            return of(this.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,
-            }));
-        }
-        const { modelId, categoryId } = props.queryProps;
-        const totalCount = categoryId ? this._idsCache.getCategoryElementsCount(modelId, categoryId) : this._idsCache.getModelElementCount(modelId);
-        return forkJoin({
-            totalCount,
-            alwaysDrawn: this.getAlwaysDrawnElements(props.queryProps),
-            neverDrawn: this.getNeverDrawnElements(props.queryProps),
-        }).pipe(map((state) => {
-            return this.getVisibilityFromAlwaysAndNeverDrawnElementsImpl({
-                ...props,
-                ...state,
-                ignoreTooltip,
-            });
-        }));
-    }
-    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);
-        assert(!!modelId && !!categoryId);
-        const elementIds = new Set(node.groupedInstanceKeys.map((key) => key.id));
-        return { modelId, categoryId, elementIds };
-    }
-}
-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