@itwin/tree-widget-react 3.0.0-dev.0 → 3.0.0-dev.1

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

@@ -0,0 +1,748 @@
+/*---------------------------------------------------------------------------------------------
+ * 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, firstValueFrom, forkJoin, from, map, merge, mergeMap, of, reduce } from "rxjs";
+import { assert } from "@itwin/core-bentley";
+import { IModelApp, PerModelCategoryVisibility } from "@itwin/core-frontend";
+import { HierarchyNode, HierarchyNodeIdentifier, HierarchyNodeKey } from "@itwin/presentation-hierarchies";
+import { toggleAllCategories } from "../../common/CategoriesVisibilityUtils";
+import { reduceWhile, toVoidPromise } from "../../common/Rxjs";
+import { AlwaysAndNeverDrawnElementInfo } from "./AlwaysAndNeverDrawnElementInfo";
+import { ModelsTreeNode } from "./ModelsTreeNode";
+import { createVisibilityStatus } from "./Tooltip";
+import { createVisibilityChangeEventListener } from "./VisibilityChangeEventListener";
+export const SUBJECT_CLASS_NAME = "BisCore.Subject";
+export const MODEL_CLASS_NAME = "BisCore.GeometricModel3d";
+export const CATEGORY_CLASS_NAME = "BisCore.SpatialCategory";
+export const ELEMENT_CLASS_NAME = "BisCore.GeometricElement3d";
+function createCategoryKey(modelId, categoryId) {
+    return `${modelId}-${categoryId}`;
+}
+function parseCategoryKey(key) {
+    const [modelId, categoryId] = key.split("-");
+    return { modelId, categoryId };
+}
+function createElementKey(modelId, categoryId, elementId) {
+    return `${modelId}-${categoryId}-${elementId}`;
+}
+function parseElementKey(key) {
+    const [modelId, categoryId, elementId] = key.split("-");
+    return { modelId, categoryId, elementId };
+}
+/**
+ * Creates an instance if `ModelsTreeVisibilityHandler`.
+ * @internal
+ */
+export function createModelsTreeVisibilityHandler(props) {
+    return new ModelsTreeVisibilityHandlerImpl(props);
+}
+class ModelsTreeVisibilityHandlerImpl {
+    constructor(_props) {
+        this._props = _props;
+        this._eventListener = createVisibilityChangeEventListener(_props.viewport);
+        this._alwaysAndNeverDrawnElements = new AlwaysAndNeverDrawnElementInfo(_props.viewport);
+        this._idsCache = this._props.idsCache;
+    }
+    // istanbul ignore next
+    get onVisibilityChange() {
+        return this._eventListener.onVisibilityChange;
+    }
+    async getVisibilityStatus(node) {
+        return firstValueFrom(this.getVisibilityStatusObs(node));
+    }
+    async changeVisibility(node, shouldDisplay) {
+        return toVoidPromise(this.changeVisibilityObs(node, shouldDisplay));
+    }
+    dispose() {
+        this._eventListener.dispose();
+        this._alwaysAndNeverDrawnElements.dispose();
+    }
+    getVisibilityStatusObs(node) {
+        if (node.filtering?.filteredChildrenIdentifierPaths?.length && !node.filtering.isFilterTarget) {
+            return this.getFilteredNodeVisibility({
+                parentKeys: [...node.parentKeys, node.key],
+                filterPaths: node.filtering.filteredChildrenIdentifierPaths,
+            });
+        }
+        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(node.key.instanceKeys.map((key) => key.id));
+        }
+        if (ModelsTreeNode.isModelNode(node)) {
+            return this.getModelVisibilityStatus(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({ parentKeys, filterPaths }) {
+        return from(this.getFilterTargets({ parentKeys, filterPaths })).pipe(mergeMap(({ subjects, models, categories, elements }) => {
+            const observables = new Array();
+            if (subjects?.size) {
+                observables.push(this.getSubjectNodeVisibilityStatus([...subjects]));
+            }
+            if (models?.size) {
+                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 });
+                })));
+            }
+            if (elements?.size) {
+                observables.push(from(elements).pipe(mergeMap((key) => {
+                    const { modelId, categoryId, elementId } = parseElementKey(key);
+                    return this.getElementDisplayStatus({ modelId, categoryId, elementId });
+                })));
+            }
+            return merge(...observables);
+        }), map((x) => x.state), getVisibilityFromTreeNodeChildren, map((x) => {
+            assert(x !== "empty");
+            return createVisibilityStatus(x);
+        }));
+    }
+    getSubjectNodeVisibilityStatus(subjectIds) {
+        const result = defer(() => {
+            if (!this._props.viewport.view.isSpatialView()) {
+                return of(createVisibilityStatus("disabled", "subject.nonSpatialView"));
+            }
+            return from(this._idsCache.getSubjectModelIds(subjectIds)).pipe(concatAll(), distinct(), mergeMap((modelId) => this.getModelVisibilityStatus(modelId)), map((x) => x.state), getVisibilityStatusFromTreeNodeChildren({
+                visible: "subject.allModelsVisible",
+                hidden: "subject.allModelsHidden",
+                partial: "subject.someModelsHidden",
+            }));
+        });
+        const ovr = this._props.overrides?.getSubjectNodeVisibility;
+        return ovr ? from(ovr(this.createOverrideProps({ ids: subjectIds }, result))) : result;
+    }
+    getModelVisibilityStatus(modelId) {
+        const result = defer(() => {
+            const viewport = this._props.viewport;
+            if (!viewport.view.isSpatialView()) {
+                return of(createVisibilityStatus("disabled", "model.nonSpatialView"));
+            }
+            if (!viewport.view.viewsModel(modelId)) {
+                return of(createVisibilityStatus("hidden", "model.hiddenThroughModelSelector"));
+            }
+            return from(this._idsCache.getModelCategories(modelId)).pipe(concatAll(), mergeMap((categoryId) => this.getCategoryDisplayStatus({ modelId, categoryId })), map((x) => x.state), getVisibilityFromTreeNodeChildren, map((visibilityByCategories) => {
+                const state = visibilityByCategories === "empty" ? "visible" : visibilityByCategories;
+                return createVisibilityStatus(state, state === "partial" ? "model.someCategoriesHidden" : `model.allCategories${state ? "Visible" : "Hidden"}`);
+            }));
+        });
+        const ovr = this._props.overrides?.getModelDisplayStatus;
+        return ovr ? from(ovr(this.createOverrideProps({ id: modelId }, result))) : result;
+    }
+    getDefaultCategoryVisibilityStatus({ modelId, categoryId }) {
+        const viewport = this._props.viewport;
+        if (!viewport.view.viewsModel(modelId)) {
+            return createVisibilityStatus("hidden", "category.hiddenThroughModel");
+        }
+        switch (this._props.viewport.perModelCategoryVisibility.getOverride(modelId, categoryId)) {
+            case PerModelCategoryVisibility.Override.Show:
+                return createVisibilityStatus("visible", "category.displayedThroughPerModelOverride");
+            case PerModelCategoryVisibility.Override.Hide:
+                return createVisibilityStatus("hidden", "category.hiddenThroughPerModelOverride");
+        }
+        const isVisible = viewport.view.viewsCategory(categoryId);
+        return isVisible
+            ? createVisibilityStatus("visible", "category.displayedThroughCategorySelector")
+            : createVisibilityStatus("hidden", "category.hiddenThroughCategorySelector");
+    }
+    getCategoryDisplayStatus(props) {
+        const result = defer(() => {
+            if (!this._props.viewport.view.viewsModel(props.modelId)) {
+                return of(createVisibilityStatus("hidden", "category.hiddenThroughModel"));
+            }
+            return this.getVisibilityFromAlwaysAndNeverDrawnElements({
+                queryProps: props,
+                tooltips: {
+                    allElementsInAlwaysDrawnList: "category.allElementsVisible",
+                    allElementsInNeverDrawnList: "category.allElementsHidden",
+                    elementsInBothAlwaysAndNeverDrawn: "category.someElementsAreHidden",
+                    noElementsInExclusiveAlwaysDrawnList: "category.allElementsHidden",
+                },
+                defaultStatus: () => this.getDefaultCategoryVisibilityStatus(props),
+            });
+        });
+        const ovr = this._props.overrides?.getCategoryDisplayStatus;
+        return ovr ? from(ovr(this.createOverrideProps(props, result))) : result;
+    }
+    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 });
+                    return createVisibilityStatus(status.state, `groupingNode.${status.state}ThroughCategory`);
+                },
+                tooltips: {
+                    allElementsInAlwaysDrawnList: "groupingNode.allElementsVisible",
+                    allElementsInNeverDrawnList: "groupingNode.allElementsHidden",
+                    elementsInBothAlwaysAndNeverDrawn: "groupingNode.someElementsAreHidden",
+                    noElementsInExclusiveAlwaysDrawnList: "groupingNode.allElementsHidden",
+                },
+            });
+        });
+        const ovr = this._props.overrides?.getElementGroupingNodeDisplayStatus;
+        return ovr ? from(ovr(this.createOverrideProps({ node }, result))) : result;
+    }
+    getElementOverriddenVisibility(elementId) {
+        const viewport = this._props.viewport;
+        if (viewport.neverDrawn?.has(elementId)) {
+            return createVisibilityStatus("hidden", "element.hiddenThroughNeverDrawnList");
+        }
+        if (viewport.alwaysDrawn?.size) {
+            if (viewport.alwaysDrawn.has(elementId)) {
+                return createVisibilityStatus("visible", "element.displayedThroughAlwaysDrawnList");
+            }
+            if (viewport.isAlwaysDrawnExclusive) {
+                return createVisibilityStatus("hidden", "element.hiddenDueToOtherElementsExclusivelyAlwaysDrawn");
+            }
+        }
+        return undefined;
+    }
+    getElementDisplayStatus(props) {
+        const result = defer(() => {
+            const viewport = this._props.viewport;
+            const { elementId, modelId, categoryId } = props;
+            if (!viewport.view.viewsModel(modelId)) {
+                return of(createVisibilityStatus("hidden", "element.hiddenThroughModel"));
+            }
+            let status = this.getElementOverriddenVisibility(elementId);
+            if (status) {
+                return of(status);
+            }
+            status = this.getDefaultCategoryVisibilityStatus({ categoryId, modelId });
+            return of(createVisibilityStatus(status.state, status.state === "visible" ? undefined : "element.hiddenThroughCategory"));
+        });
+        const ovr = this._props.overrides?.getElementDisplayStatus;
+        return ovr ? from(ovr(this.createOverrideProps(props, result))) : result;
+    }
+    /** Changes visibility of the items represented by the tree node. */
+    changeVisibilityObs(node, on) {
+        if (node.filtering?.filteredChildrenIdentifierPaths?.length && !node.filtering.isFilterTarget) {
+            return this.changeFilteredNodeVisibility({
+                parentKeys: [...node.parentKeys, node.key],
+                filterPaths: node.filtering.filteredChildrenIdentifierPaths,
+                on,
+            });
+        }
+        if (HierarchyNode.isClassGroupingNode(node)) {
+            return this.changeElementGroupingNodeState(node, on);
+        }
+        // istanbul ignore if
+        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);
+        // istanbul ignore if
+        if (!modelId) {
+            return EMPTY;
+        }
+        if (ModelsTreeNode.isCategoryNode(node)) {
+            return this.changeCategoryState({
+                categoryId: node.key.instanceKeys[0].id,
+                modelId,
+                on,
+            });
+        }
+        const categoryId = ModelsTreeNode.getCategoryId(node);
+        // istanbul ignore if
+        if (!categoryId) {
+            // istanbul ignore next
+            return EMPTY;
+        }
+        return this.changeElementState({
+            elementId: node.key.instanceKeys[0].id,
+            modelId,
+            categoryId,
+            on,
+        });
+    }
+    async getFilterTargets({ parentKeys, filterPaths }) {
+        const filterTargets = {};
+        function addFilterTarget(targetType, value) {
+            (filterTargets[targetType] ??= new Set()).add(value);
+        }
+        const imodelAccess = this._props.imodelAccess;
+        // Remove all paths such that there are paths to any of the ancestors of the filter target.
+        filterPaths = reduceFilterPaths(filterPaths);
+        await Promise.all(filterPaths.map(async (path) => {
+            const target = path[path.length - 1];
+            if (!HierarchyNodeIdentifier.isInstanceNodeIdentifier(target)) {
+                return;
+            }
+            const previousPath = path.slice(0, path.length - 1);
+            if (await imodelAccess.classDerivesFrom(target.className, SUBJECT_CLASS_NAME)) {
+                addFilterTarget("subjects", target.id);
+                return;
+            }
+            if (await imodelAccess.classDerivesFrom(target.className, MODEL_CLASS_NAME)) {
+                addFilterTarget("models", target.id);
+                return;
+            }
+            if (await imodelAccess.classDerivesFrom(target.className, CATEGORY_CLASS_NAME)) {
+                // eslint-disable-next-line @typescript-eslint/no-shadow
+                const modelId = await this.findClassIdInFilterPath(previousPath, parentKeys, MODEL_CLASS_NAME);
+                addFilterTarget("categories", createCategoryKey(modelId, target.id));
+                return;
+            }
+            const [modelId, categoryId] = await Promise.all([
+                this.findClassIdInFilterPath(previousPath, parentKeys, MODEL_CLASS_NAME),
+                this.findClassIdInFilterPath(previousPath, parentKeys, CATEGORY_CLASS_NAME),
+            ]);
+            addFilterTarget("elements", createElementKey(modelId, categoryId, target.id));
+            // Add parent elements to the filter targets as well
+            for (let idx = path.length - 1; idx >= 0; --idx) {
+                const pathIdentifier = path[idx];
+                if (!HierarchyNodeIdentifier.isInstanceNodeIdentifier(pathIdentifier)) {
+                    continue;
+                }
+                if (!(await imodelAccess.classDerivesFrom(pathIdentifier.className, ELEMENT_CLASS_NAME))) {
+                    break;
+                }
+                addFilterTarget("elements", createElementKey(modelId, categoryId, pathIdentifier.id));
+            }
+        }));
+        return filterTargets;
+    }
+    changeFilteredNodeVisibility({ on, ...props }) {
+        return from(this.getFilterTargets(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((key) => {
+                    const { modelId, categoryId, elementId } = parseElementKey(key);
+                    return this.changeElementState({ modelId, categoryId, elementId, on });
+                })));
+            }
+            return merge(...observables);
+        }));
+    }
+    changeSubjectNodeState(ids, on) {
+        const result = defer(() => {
+            // istanbul ignore if
+            if (!this._props.viewport.view.isSpatialView()) {
+                return EMPTY;
+            }
+            return from(this._idsCache.getSubjectModelIds(ids)).pipe(mergeMap((modelIds) => this.changeModelState({ ids: modelIds, on })));
+        });
+        const ovr = this._props.overrides?.changeSubjectNodeState;
+        return ovr ? from(ovr(this.createVoidOverrideProps({ ids, on }, result))) : result;
+    }
+    changeModelState(props) {
+        const result = defer(() => {
+            const viewport = this._props.viewport;
+            // istanbul ignore if
+            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 })));
+            })));
+        });
+        const ovr = this._props.overrides?.changeModelState;
+        return ovr ? from(ovr(this.createVoidOverrideProps(props, result))) : result;
+    }
+    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);
+            }));
+        });
+        const ovr = this._props.overrides?.changeCategoryState;
+        return ovr ? from(ovr(this.createVoidOverrideProps(props, result))) : result;
+    }
+    /**
+     * 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 });
+                const isDisplayedByDefault = categoryVisibility.state === "visible";
+                return from(elementIds).pipe(this.changeElementStateNoChildrenOperator({ on, isDisplayedByDefault }));
+            }));
+        });
+        const ovr = this._props.overrides?.changeElementGroupingNodeState;
+        return ovr ? from(ovr(this.createVoidOverrideProps({ node, on }, result))) : result;
+    }
+    /**
+     * 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.
+     */
+    changeElementState(props) {
+        const result = defer(() => {
+            const { elementId, 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 });
+                const isDisplayedByDefault = categoryVisibility.state === "visible";
+                return of(elementId).pipe(this.changeElementStateNoChildrenOperator({ on, isDisplayedByDefault }));
+            }));
+        });
+        const ovr = this._props.overrides?.changeElementState;
+        return ovr ? from(ovr(this.createVoidOverrideProps(props, result))) : result;
+    }
+    changeElementStateNoChildrenOperator(props) {
+        return (elementIds) => {
+            const { on, isDisplayedByDefault } = props;
+            const isAlwaysDrawnExclusive = this._props.viewport.isAlwaysDrawnExclusive;
+            return elementIds.pipe(reduce((acc, elementId) => {
+                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: new Set(this._props.viewport.neverDrawn || []),
+                alwaysDrawn: new Set(this._props.viewport.alwaysDrawn || []),
+            }), map((state) => {
+                state.changedNeverDrawn && this._props.viewport.setNeverDrawn(state.neverDrawn);
+                state.changedAlwaysDrawn && this._props.viewport.setAlwaysDrawn(state.alwaysDrawn, this._props.viewport.isAlwaysDrawnExclusive);
+            }));
+        };
+    }
+    getVisibilityFromAlwaysAndNeverDrawnElementsImpl(props) {
+        const { alwaysDrawn, neverDrawn, totalCount } = props;
+        if (neverDrawn?.size === totalCount) {
+            return createVisibilityStatus("hidden", props.tooltips.allElementsInNeverDrawnList);
+        }
+        if (alwaysDrawn?.size === totalCount) {
+            return createVisibilityStatus("visible", props.tooltips.allElementsInAlwaysDrawnList);
+        }
+        const viewport = this._props.viewport;
+        if (viewport.isAlwaysDrawnExclusive && viewport.alwaysDrawn?.size) {
+            return alwaysDrawn?.size
+                ? createVisibilityStatus("partial", props.tooltips.elementsInBothAlwaysAndNeverDrawn)
+                : createVisibilityStatus("hidden", props.tooltips.noElementsInExclusiveAlwaysDrawnList);
+        }
+        const status = props.defaultStatus();
+        if ((status.state === "visible" && neverDrawn?.size) || (status.state === "hidden" && alwaysDrawn?.size)) {
+            return createVisibilityStatus("partial");
+        }
+        return status;
+    }
+    getVisibilityFromAlwaysAndNeverDrawnElements(props) {
+        const viewport = this._props.viewport;
+        if (viewport.isAlwaysDrawnExclusive) {
+            if (!viewport?.alwaysDrawn?.size) {
+                return of(createVisibilityStatus("hidden", props.tooltips.noElementsInExclusiveAlwaysDrawnList));
+            }
+        }
+        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,
+            }));
+        }
+        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,
+            });
+        }));
+    }
+    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));
+            }
+        }));
+    }
+    createVoidOverrideProps(props, obs) {
+        return {
+            ...props,
+            originalImplementation: async () => toVoidPromise(obs),
+            handler: this,
+        };
+    }
+    createOverrideProps(props, obs) {
+        return {
+            ...props,
+            originalImplementation: async () => firstValueFrom(obs),
+            handler: this,
+        };
+    }
+    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 };
+    }
+    async findClassIdInFilterPath(path, parentKeys, className) {
+        function* keysToCheck() {
+            for (let i = path.length - 1; i >= 0; --i) {
+                const id = path[i];
+                if (HierarchyNodeIdentifier.isInstanceNodeIdentifier(id)) {
+                    yield id;
+                }
+            }
+            for (let i = parentKeys.length - 1; i >= 0; --i) {
+                const key = parentKeys[i];
+                if (HierarchyNodeKey.isInstances(key)) {
+                    yield* key.instanceKeys;
+                }
+            }
+        }
+        for (const parentKey of keysToCheck()) {
+            if (await this._props.imodelAccess.classDerivesFrom(parentKey.className, className)) {
+                return parentKey.id;
+            }
+        }
+        assert(false, () => `Cannot find an instance of ${className} in instance keys: ${JSON.stringify([...keysToCheck()], undefined, 2)}`);
+    }
+}
+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) {
+    return (obs) => {
+        return getVisibilityFromTreeNodeChildren(obs).pipe(map((visibility) => {
+            if (visibility === "empty") {
+                visibility = "visible";
+            }
+            return createVisibilityStatus(visibility, tooltipMap[visibility]);
+        }));
+    };
+}
+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;
+}
+function reduceFilterPaths(paths) {
+    const sorted = [...paths].sort((a, b) => a.length - b.length);
+    paths = [];
+    for (const path of sorted) {
+        if (!arraySortedByLengthContainsPrefix(paths, path)) {
+            paths.push(path);
+        }
+    }
+    return paths;
+}
+function arraySortedByLengthContainsPrefix(targetArray, source) {
+    for (const targetVal of targetArray) {
+        if (targetVal.length >= source.length) {
+            break;
+        }
+        let isPrefix = true;
+        for (let i = 0; i < targetVal.length; ++i) {
+            if (!HierarchyNodeIdentifier.equal(targetVal[i], source[i])) {
+                isPrefix = false;
+                break;
+            }
+        }
+        if (isPrefix) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * 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(IModelApp.viewManager, viewport.iModel, true, viewport, false);
+}
+/**
+ * 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) {
+    // istanbul ignore if
+    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;
+}
+//# sourceMappingURL=ModelsTreeVisibilityHandler.js.map